1//===-- AsmPrinterDwarf.cpp - AsmPrinter Dwarf Support --------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Dwarf emissions parts of AsmPrinter.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ADT/Twine.h"
14#include "llvm/BinaryFormat/Dwarf.h"
15#include "llvm/CodeGen/AsmPrinter.h"
16#include "llvm/CodeGen/DIE.h"
17#include "llvm/CodeGen/MachineFunction.h"
18#include "llvm/MC/MCAsmInfo.h"
19#include "llvm/MC/MCDwarf.h"
20#include "llvm/MC/MCSection.h"
21#include "llvm/MC/MCStreamer.h"
22#include "llvm/MC/MCSymbol.h"
23#include "llvm/Support/ErrorHandling.h"
24#include "llvm/Target/TargetLoweringObjectFile.h"
25#include <cstdint>
26using namespace llvm;
27
28#define DEBUG_TYPE "asm-printer"
29
30//===----------------------------------------------------------------------===//
31// Dwarf Emission Helper Routines
32//===----------------------------------------------------------------------===//
33
34static const char *DecodeDWARFEncoding(unsigned Encoding) {
35 switch (Encoding) {
36 case dwarf::DW_EH_PE_absptr:
37 return "absptr";
38 case dwarf::DW_EH_PE_omit:
39 return "omit";
40 case dwarf::DW_EH_PE_pcrel:
41 return "pcrel";
42 case dwarf::DW_EH_PE_uleb128:
43 return "uleb128";
44 case dwarf::DW_EH_PE_sleb128:
45 return "sleb128";
46 case dwarf::DW_EH_PE_udata4:
47 return "udata4";
48 case dwarf::DW_EH_PE_udata8:
49 return "udata8";
50 case dwarf::DW_EH_PE_sdata4:
51 return "sdata4";
52 case dwarf::DW_EH_PE_sdata8:
53 return "sdata8";
54 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata4:
55 return "pcrel udata4";
56 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4:
57 return "pcrel sdata4";
58 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8:
59 return "pcrel udata8";
60 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8:
61 return "pcrel sdata8";
62 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata4
63 :
64 return "indirect pcrel udata4";
65 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4
66 :
67 return "indirect pcrel sdata4";
68 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8
69 :
70 return "indirect pcrel udata8";
71 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8
72 :
73 return "indirect pcrel sdata8";
74 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
75 dwarf::DW_EH_PE_sdata4:
76 return "indirect datarel sdata4";
77 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
78 dwarf::DW_EH_PE_sdata8:
79 return "indirect datarel sdata8";
80 }
81
82 return "<unknown encoding>";
83}
84
85/// EmitEncodingByte - Emit a .byte 42 directive that corresponds to an
86/// encoding. If verbose assembly output is enabled, we output comments
87/// describing the encoding. Desc is an optional string saying what the
88/// encoding is specifying (e.g. "LSDA").
89void AsmPrinter::emitEncodingByte(unsigned Val, const char *Desc) const {
90 if (isVerbose()) {
91 if (Desc)
92 OutStreamer->AddComment(T: Twine(Desc) + " Encoding = " +
93 Twine(DecodeDWARFEncoding(Encoding: Val)));
94 else
95 OutStreamer->AddComment(T: Twine("Encoding = ") + DecodeDWARFEncoding(Encoding: Val));
96 }
97
98 OutStreamer->emitIntValue(Value: Val, Size: 1);
99}
100
101/// GetSizeOfEncodedValue - Return the size of the encoding in bytes.
102unsigned AsmPrinter::GetSizeOfEncodedValue(unsigned Encoding) const {
103 if (Encoding == dwarf::DW_EH_PE_omit)
104 return 0;
105
106 switch (Encoding & 0x07) {
107 default:
108 llvm_unreachable("Invalid encoded value.");
109 case dwarf::DW_EH_PE_absptr:
110 return MAI.getCodePointerSize();
111 case dwarf::DW_EH_PE_udata2:
112 return 2;
113 case dwarf::DW_EH_PE_udata4:
114 return 4;
115 case dwarf::DW_EH_PE_udata8:
116 return 8;
117 }
118}
119
120void AsmPrinter::emitTTypeReference(const GlobalValue *GV, unsigned Encoding) {
121 if (GV) {
122 const TargetLoweringObjectFile &TLOF = getObjFileLowering();
123
124 const MCExpr *Exp =
125 TLOF.getTTypeGlobalReference(GV, Encoding, TM, MMI, Streamer&: *OutStreamer);
126 OutStreamer->emitValue(Value: Exp, Size: GetSizeOfEncodedValue(Encoding));
127 } else
128 OutStreamer->emitIntValue(Value: 0, Size: GetSizeOfEncodedValue(Encoding));
129}
130
131void AsmPrinter::emitDwarfSymbolReference(const MCSymbol *Label,
132 bool ForceOffset) const {
133 if (!ForceOffset) {
134 // On COFF targets, we have to emit the special .secrel32 directive.
135 if (MAI.needsDwarfSectionOffsetDirective()) {
136 assert(!isDwarf64() &&
137 "emitting DWARF64 is not implemented for COFF targets");
138 OutStreamer->emitDwarfSectionOffset(Sym: Label, /*Offset=*/0,
139 Size: getDwarfOffsetByteSize());
140 return;
141 }
142
143 // If the format uses relocations with dwarf, refer to the symbol directly.
144 if (doesDwarfUseRelocationsAcrossSections()) {
145 OutStreamer->emitDwarfSectionOffset(Sym: Label, /*Offset=*/0,
146 Size: getDwarfOffsetByteSize());
147 return;
148 }
149 }
150
151 // Otherwise, emit it as a label difference from the start of the section.
152 emitLabelDifference(Hi: Label, Lo: Label->getSection().getBeginSymbol(),
153 Size: getDwarfOffsetByteSize());
154}
155
156void AsmPrinter::emitDwarfStringOffset(DwarfStringPoolEntry S) const {
157 if (doesDwarfUseRelocationsAcrossSections()) {
158 assert(S.Symbol && "No symbol available");
159 emitDwarfSymbolReference(Label: S.Symbol);
160 return;
161 }
162
163 // Just emit the offset directly; no need for symbol math.
164 OutStreamer->emitIntValue(Value: S.Offset, Size: getDwarfOffsetByteSize());
165}
166
167void AsmPrinter::emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const {
168 emitLabelPlusOffset(Label, Offset, Size: getDwarfOffsetByteSize());
169}
170
171void AsmPrinter::emitDwarfLengthOrOffset(uint64_t Value) const {
172 assert(isDwarf64() || Value <= UINT32_MAX);
173 OutStreamer->emitIntValue(Value, Size: getDwarfOffsetByteSize());
174}
175
176void AsmPrinter::emitDwarfUnitLength(uint64_t Length,
177 const Twine &Comment) const {
178 OutStreamer->emitDwarfUnitLength(Length, Comment);
179}
180
181MCSymbol *AsmPrinter::emitDwarfUnitLength(const Twine &Prefix,
182 const Twine &Comment) const {
183 return OutStreamer->emitDwarfUnitLength(Prefix, Comment);
184}
185
186void AsmPrinter::emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
187 unsigned Encoding) const {
188 // The least significant 3 bits specify the width of the encoding
189 if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128)
190 emitLabelDifferenceAsULEB128(Hi, Lo);
191 else
192 emitLabelDifference(Hi, Lo, Size: GetSizeOfEncodedValue(Encoding));
193}
194
195void AsmPrinter::emitCallSiteValue(uint64_t Value, unsigned Encoding) const {
196 // The least significant 3 bits specify the width of the encoding
197 if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128)
198 emitULEB128(Value);
199 else
200 OutStreamer->emitIntValue(Value, Size: GetSizeOfEncodedValue(Encoding));
201}
202
203//===----------------------------------------------------------------------===//
204// Dwarf Lowering Routines
205//===----------------------------------------------------------------------===//
206
207void AsmPrinter::emitCFIInstruction(const MCCFIInstruction &Inst) const {
208 SMLoc Loc = Inst.getLoc();
209 switch (Inst.getOperation()) {
210 default:
211 llvm_unreachable("Unexpected instruction");
212 case MCCFIInstruction::OpDefCfaOffset:
213 OutStreamer->emitCFIDefCfaOffset(Offset: Inst.getOffset(), Loc);
214 break;
215 case MCCFIInstruction::OpAdjustCfaOffset:
216 OutStreamer->emitCFIAdjustCfaOffset(Adjustment: Inst.getOffset(), Loc);
217 break;
218 case MCCFIInstruction::OpDefCfa:
219 OutStreamer->emitCFIDefCfa(Register: Inst.getRegister(), Offset: Inst.getOffset(), Loc);
220 break;
221 case MCCFIInstruction::OpDefCfaRegister:
222 OutStreamer->emitCFIDefCfaRegister(Register: Inst.getRegister(), Loc);
223 break;
224 case MCCFIInstruction::OpLLVMDefAspaceCfa:
225 OutStreamer->emitCFILLVMDefAspaceCfa(Register: Inst.getRegister(), Offset: Inst.getOffset(),
226 AddressSpace: Inst.getAddressSpace(), Loc);
227 break;
228 case MCCFIInstruction::OpOffset:
229 OutStreamer->emitCFIOffset(Register: Inst.getRegister(), Offset: Inst.getOffset(), Loc);
230 break;
231 case MCCFIInstruction::OpRegister:
232 OutStreamer->emitCFIRegister(Register1: Inst.getRegister(), Register2: Inst.getRegister2(), Loc);
233 break;
234 case MCCFIInstruction::OpWindowSave:
235 OutStreamer->emitCFIWindowSave(Loc);
236 break;
237 case MCCFIInstruction::OpNegateRAState:
238 OutStreamer->emitCFINegateRAState(Loc);
239 break;
240 case MCCFIInstruction::OpNegateRAStateWithPC:
241 OutStreamer->emitCFINegateRAStateWithPC(Loc);
242 break;
243 case MCCFIInstruction::OpLLVMSetRAState: {
244 if (MCSymbol *Symbol = Inst.getRASignSymbol())
245 OutStreamer->emitCFILLVMSetRAState(State: Inst.getRASignState(), PACSym: Symbol, Loc);
246 else
247 OutStreamer->emitCFILLVMSetRAState(State: Inst.getRASignState(),
248 Offset: Inst.getRASignOffset(), Loc);
249 break;
250 }
251 case MCCFIInstruction::OpSameValue:
252 OutStreamer->emitCFISameValue(Register: Inst.getRegister(), Loc);
253 break;
254 case MCCFIInstruction::OpGnuArgsSize:
255 OutStreamer->emitCFIGnuArgsSize(Size: Inst.getOffset(), Loc);
256 break;
257 case MCCFIInstruction::OpEscape:
258 OutStreamer->AddComment(T: Inst.getComment());
259 OutStreamer->emitCFIEscape(Values: Inst.getValues(), Loc);
260 break;
261 case MCCFIInstruction::OpRestore:
262 OutStreamer->emitCFIRestore(Register: Inst.getRegister(), Loc);
263 break;
264 case MCCFIInstruction::OpUndefined:
265 OutStreamer->emitCFIUndefined(Register: Inst.getRegister(), Loc);
266 break;
267 case MCCFIInstruction::OpRememberState:
268 OutStreamer->emitCFIRememberState(Loc);
269 break;
270 case MCCFIInstruction::OpRestoreState:
271 OutStreamer->emitCFIRestoreState(Loc);
272 break;
273 case MCCFIInstruction::OpLLVMRegisterPair: {
274 const auto &Fields =
275 Inst.getExtraFields<MCCFIInstruction::RegisterPairFields>();
276 OutStreamer->emitCFILLVMRegisterPair(Register: Fields.Register, R1: Fields.Reg1,
277 R1SizeInBits: Fields.Reg1SizeInBits, R2: Fields.Reg2,
278 R2SizeInBits: Fields.Reg2SizeInBits, Loc);
279 break;
280 }
281 case MCCFIInstruction::OpLLVMVectorRegisters: {
282 const auto &Fields =
283 Inst.getExtraFields<MCCFIInstruction::VectorRegistersFields>();
284 OutStreamer->emitCFILLVMVectorRegisters(Register: Fields.Register,
285 VRs: Fields.VectorRegisters, Loc);
286 break;
287 }
288 case MCCFIInstruction::OpLLVMVectorOffset: {
289 const auto &Fields =
290 Inst.getExtraFields<MCCFIInstruction::VectorOffsetFields>();
291 OutStreamer->emitCFILLVMVectorOffset(
292 Register: Fields.Register, RegisterSizeInBits: Fields.RegisterSizeInBits, MaskRegister: Fields.MaskRegister,
293 MaskRegisterSizeInBits: Fields.MaskRegisterSizeInBits, Offset: Fields.Offset, Loc);
294 break;
295 }
296 case MCCFIInstruction::OpLLVMVectorRegisterMask: {
297 const auto &Fields =
298 Inst.getExtraFields<MCCFIInstruction::VectorRegisterMaskFields>();
299 OutStreamer->emitCFILLVMVectorRegisterMask(
300 Register: Fields.Register, SpillRegister: Fields.SpillRegister,
301 SpillRegisterLaneSizeInBits: Fields.SpillRegisterLaneSizeInBits, MaskRegister: Fields.MaskRegister,
302 MaskRegisterSizeInBits: Fields.MaskRegisterSizeInBits);
303 break;
304 }
305
306 case MCCFIInstruction::OpValOffset:
307 OutStreamer->emitCFIValOffset(Register: Inst.getRegister(), Offset: Inst.getOffset(), Loc);
308 break;
309 }
310}
311
312void AsmPrinter::emitDwarfDIE(const DIE &Die) const {
313 assert(!Die.isPlaceholder() && "Cannot emit a placeholder DIE");
314
315 // Emit the code (index) for the abbreviation.
316 if (isVerbose())
317 OutStreamer->AddComment(T: "Abbrev [" + Twine(Die.getAbbrevNumber()) + "] 0x" +
318 Twine::utohexstr(Val: Die.getOffset()) + ":0x" +
319 Twine::utohexstr(Val: Die.getSize()) + " " +
320 dwarf::TagString(Tag: Die.getTag()));
321 emitULEB128(Value: Die.getAbbrevNumber());
322
323 // Emit the DIE attribute values.
324 for (const auto &V : Die.values()) {
325 dwarf::Attribute Attr = V.getAttribute();
326 assert(V.getForm() && "Too many attributes for DIE (check abbreviation)");
327
328 if (isVerbose()) {
329 OutStreamer->AddComment(T: dwarf::AttributeString(Attribute: Attr));
330 if (Attr == dwarf::DW_AT_accessibility)
331 OutStreamer->AddComment(
332 T: dwarf::AccessibilityString(Access: V.getDIEInteger().getValue()));
333 }
334
335 // Emit an attribute using the defined form.
336 V.emitValue(AP: this);
337 }
338
339 // Emit the DIE children if any.
340 if (Die.hasChildren()) {
341 for (const auto &Child : Die.children())
342 emitDwarfDIE(Die: Child);
343
344 OutStreamer->AddComment(T: "End Of Children Mark");
345 emitInt8(Value: 0);
346 }
347}
348
349void AsmPrinter::emitDwarfAbbrev(const DIEAbbrev &Abbrev) const {
350 // Emit the abbreviations code (base 1 index.)
351 emitULEB128(Value: Abbrev.getNumber(), Desc: "Abbreviation Code");
352
353 // Emit the abbreviations data.
354 Abbrev.Emit(AP: this);
355}
356