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