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::emitDwarfUnitLength(uint64_t Length, 202 const Twine &Comment) const { 203 OutStreamer->emitDwarfUnitLength(Length, Comment); 204 } 205 206 MCSymbol *AsmPrinter::emitDwarfUnitLength(const Twine &Prefix, 207 const Twine &Comment) const { 208 return OutStreamer->emitDwarfUnitLength(Prefix, Comment); 209 } 210 211 void AsmPrinter::emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo, 212 unsigned Encoding) const { 213 // The least significant 3 bits specify the width of the encoding 214 if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128) 215 emitLabelDifferenceAsULEB128(Hi, Lo); 216 else 217 emitLabelDifference(Hi, Lo, GetSizeOfEncodedValue(Encoding)); 218 } 219 220 void AsmPrinter::emitCallSiteValue(uint64_t Value, unsigned Encoding) const { 221 // The least significant 3 bits specify the width of the encoding 222 if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128) 223 emitULEB128(Value); 224 else 225 OutStreamer->emitIntValue(Value, GetSizeOfEncodedValue(Encoding)); 226 } 227 228 //===----------------------------------------------------------------------===// 229 // Dwarf Lowering Routines 230 //===----------------------------------------------------------------------===// 231 232 void AsmPrinter::emitCFIInstruction(const MCCFIInstruction &Inst) const { 233 switch (Inst.getOperation()) { 234 default: 235 llvm_unreachable("Unexpected instruction"); 236 case MCCFIInstruction::OpDefCfaOffset: 237 OutStreamer->emitCFIDefCfaOffset(Inst.getOffset()); 238 break; 239 case MCCFIInstruction::OpAdjustCfaOffset: 240 OutStreamer->emitCFIAdjustCfaOffset(Inst.getOffset()); 241 break; 242 case MCCFIInstruction::OpDefCfa: 243 OutStreamer->emitCFIDefCfa(Inst.getRegister(), Inst.getOffset()); 244 break; 245 case MCCFIInstruction::OpDefCfaRegister: 246 OutStreamer->emitCFIDefCfaRegister(Inst.getRegister()); 247 break; 248 case MCCFIInstruction::OpLLVMDefAspaceCfa: 249 OutStreamer->emitCFILLVMDefAspaceCfa(Inst.getRegister(), Inst.getOffset(), 250 Inst.getAddressSpace()); 251 break; 252 case MCCFIInstruction::OpOffset: 253 OutStreamer->emitCFIOffset(Inst.getRegister(), Inst.getOffset()); 254 break; 255 case MCCFIInstruction::OpRegister: 256 OutStreamer->emitCFIRegister(Inst.getRegister(), Inst.getRegister2()); 257 break; 258 case MCCFIInstruction::OpWindowSave: 259 OutStreamer->emitCFIWindowSave(); 260 break; 261 case MCCFIInstruction::OpNegateRAState: 262 OutStreamer->emitCFINegateRAState(); 263 break; 264 case MCCFIInstruction::OpSameValue: 265 OutStreamer->emitCFISameValue(Inst.getRegister()); 266 break; 267 case MCCFIInstruction::OpGnuArgsSize: 268 OutStreamer->emitCFIGnuArgsSize(Inst.getOffset()); 269 break; 270 case MCCFIInstruction::OpEscape: 271 OutStreamer->AddComment(Inst.getComment()); 272 OutStreamer->emitCFIEscape(Inst.getValues()); 273 break; 274 case MCCFIInstruction::OpRestore: 275 OutStreamer->emitCFIRestore(Inst.getRegister()); 276 break; 277 case MCCFIInstruction::OpUndefined: 278 OutStreamer->emitCFIUndefined(Inst.getRegister()); 279 break; 280 } 281 } 282 283 void AsmPrinter::emitDwarfDIE(const DIE &Die) const { 284 // Emit the code (index) for the abbreviation. 285 if (isVerbose()) 286 OutStreamer->AddComment("Abbrev [" + Twine(Die.getAbbrevNumber()) + "] 0x" + 287 Twine::utohexstr(Die.getOffset()) + ":0x" + 288 Twine::utohexstr(Die.getSize()) + " " + 289 dwarf::TagString(Die.getTag())); 290 emitULEB128(Die.getAbbrevNumber()); 291 292 // Emit the DIE attribute values. 293 for (const auto &V : Die.values()) { 294 dwarf::Attribute Attr = V.getAttribute(); 295 assert(V.getForm() && "Too many attributes for DIE (check abbreviation)"); 296 297 if (isVerbose()) { 298 OutStreamer->AddComment(dwarf::AttributeString(Attr)); 299 if (Attr == dwarf::DW_AT_accessibility) 300 OutStreamer->AddComment( 301 dwarf::AccessibilityString(V.getDIEInteger().getValue())); 302 } 303 304 // Emit an attribute using the defined form. 305 V.emitValue(this); 306 } 307 308 // Emit the DIE children if any. 309 if (Die.hasChildren()) { 310 for (auto &Child : Die.children()) 311 emitDwarfDIE(Child); 312 313 OutStreamer->AddComment("End Of Children Mark"); 314 emitInt8(0); 315 } 316 } 317 318 void AsmPrinter::emitDwarfAbbrev(const DIEAbbrev &Abbrev) const { 319 // Emit the abbreviations code (base 1 index.) 320 emitULEB128(Abbrev.getNumber(), "Abbreviation Code"); 321 322 // Emit the abbreviations data. 323 Abbrev.Emit(this); 324 } 325