1 //===-- AsmPrinterDwarf.cpp - AsmPrinter Dwarf Support --------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the Dwarf emissions parts of AsmPrinter. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "ByteStreamer.h" 15 #include "DwarfDebug.h" 16 #include "DwarfExpression.h" 17 #include "llvm/ADT/Twine.h" 18 #include "llvm/CodeGen/AsmPrinter.h" 19 #include "llvm/CodeGen/DIE.h" 20 #include "llvm/CodeGen/MachineFunction.h" 21 #include "llvm/CodeGen/MachineModuleInfo.h" 22 #include "llvm/IR/DataLayout.h" 23 #include "llvm/MC/MCAsmInfo.h" 24 #include "llvm/MC/MCRegisterInfo.h" 25 #include "llvm/MC/MCSection.h" 26 #include "llvm/MC/MCStreamer.h" 27 #include "llvm/MC/MCSymbol.h" 28 #include "llvm/MC/MachineLocation.h" 29 #include "llvm/Support/Dwarf.h" 30 #include "llvm/Support/ErrorHandling.h" 31 #include "llvm/Target/TargetLoweringObjectFile.h" 32 #include "llvm/Target/TargetMachine.h" 33 #include "llvm/Target/TargetSubtargetInfo.h" 34 using namespace llvm; 35 36 #define DEBUG_TYPE "asm-printer" 37 38 //===----------------------------------------------------------------------===// 39 // Dwarf Emission Helper Routines 40 //===----------------------------------------------------------------------===// 41 42 /// EmitSLEB128 - emit the specified signed leb128 value. 43 void AsmPrinter::EmitSLEB128(int64_t Value, const char *Desc) const { 44 if (isVerbose() && Desc) 45 OutStreamer.AddComment(Desc); 46 47 OutStreamer.EmitSLEB128IntValue(Value); 48 } 49 50 /// EmitULEB128 - emit the specified signed leb128 value. 51 void AsmPrinter::EmitULEB128(uint64_t Value, const char *Desc, 52 unsigned PadTo) const { 53 if (isVerbose() && Desc) 54 OutStreamer.AddComment(Desc); 55 56 OutStreamer.EmitULEB128IntValue(Value, PadTo); 57 } 58 59 /// EmitCFAByte - Emit a .byte 42 directive for a DW_CFA_xxx value. 60 void AsmPrinter::EmitCFAByte(unsigned Val) const { 61 if (isVerbose()) { 62 if (Val >= dwarf::DW_CFA_offset && Val < dwarf::DW_CFA_offset + 64) 63 OutStreamer.AddComment("DW_CFA_offset + Reg (" + 64 Twine(Val - dwarf::DW_CFA_offset) + ")"); 65 else 66 OutStreamer.AddComment(dwarf::CallFrameString(Val)); 67 } 68 OutStreamer.EmitIntValue(Val, 1); 69 } 70 71 static const char *DecodeDWARFEncoding(unsigned Encoding) { 72 switch (Encoding) { 73 case dwarf::DW_EH_PE_absptr: 74 return "absptr"; 75 case dwarf::DW_EH_PE_omit: 76 return "omit"; 77 case dwarf::DW_EH_PE_pcrel: 78 return "pcrel"; 79 case dwarf::DW_EH_PE_udata4: 80 return "udata4"; 81 case dwarf::DW_EH_PE_udata8: 82 return "udata8"; 83 case dwarf::DW_EH_PE_sdata4: 84 return "sdata4"; 85 case dwarf::DW_EH_PE_sdata8: 86 return "sdata8"; 87 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata4: 88 return "pcrel udata4"; 89 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4: 90 return "pcrel sdata4"; 91 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8: 92 return "pcrel udata8"; 93 case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8: 94 return "pcrel sdata8"; 95 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata4 96 : 97 return "indirect pcrel udata4"; 98 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4 99 : 100 return "indirect pcrel sdata4"; 101 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8 102 : 103 return "indirect pcrel udata8"; 104 case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8 105 : 106 return "indirect pcrel 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 TM.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, 148 unsigned Encoding) const { 149 if (GV) { 150 const TargetLoweringObjectFile &TLOF = getObjFileLowering(); 151 152 const MCExpr *Exp = 153 TLOF.getTTypeGlobalReference(GV, Encoding, *Mang, TM, MMI, OutStreamer); 154 OutStreamer.EmitValue(Exp, GetSizeOfEncodedValue(Encoding)); 155 } else 156 OutStreamer.EmitIntValue(0, GetSizeOfEncodedValue(Encoding)); 157 } 158 159 /// EmitSectionOffset - Emit the 4-byte offset of Label from the start of its 160 /// section. This can be done with a special directive if the target supports 161 /// it (e.g. cygwin) or by emitting it as an offset from a label at the start 162 /// of the section. 163 /// 164 /// SectionLabel is a temporary label emitted at the start of the section that 165 /// Label lives in. 166 void AsmPrinter::emitSectionOffset(const MCSymbol *Label) const { 167 // On COFF targets, we have to emit the special .secrel32 directive. 168 if (MAI->needsDwarfSectionOffsetDirective()) { 169 OutStreamer.EmitCOFFSecRel32(Label); 170 return; 171 } 172 173 // If the format uses relocations with dwarf, refer to the symbol directly. 174 if (MAI->doesDwarfUseRelocationsAcrossSections()) { 175 OutStreamer.EmitSymbolValue(Label, 4); 176 return; 177 } 178 179 // Otherwise, emit it as a label difference from the start of the section. 180 EmitLabelDifference(Label, Label->getSection().getBeginSymbol(), 4); 181 } 182 183 /// EmitDwarfRegOp - Emit dwarf register operation. 184 void AsmPrinter::EmitDwarfRegOp(ByteStreamer &Streamer, 185 const MachineLocation &MLoc) const { 186 DebugLocDwarfExpression Expr(*MF->getSubtarget().getRegisterInfo(), 187 getDwarfDebug()->getDwarfVersion(), Streamer); 188 const MCRegisterInfo *MRI = MMI->getContext().getRegisterInfo(); 189 int Reg = MRI->getDwarfRegNum(MLoc.getReg(), false); 190 if (Reg < 0) { 191 // We assume that pointers are always in an addressable register. 192 if (MLoc.isIndirect()) 193 // FIXME: We have no reasonable way of handling errors in here. The 194 // caller might be in the middle of a dwarf expression. We should 195 // probably assert that Reg >= 0 once debug info generation is more 196 // mature. 197 return Expr.EmitOp(dwarf::DW_OP_nop, 198 "nop (could not find a dwarf register number)"); 199 200 // Attempt to find a valid super- or sub-register. 201 if (!Expr.AddMachineRegPiece(MLoc.getReg())) 202 Expr.EmitOp(dwarf::DW_OP_nop, 203 "nop (could not find a dwarf register number)"); 204 return; 205 } 206 207 if (MLoc.isIndirect()) 208 Expr.AddRegIndirect(Reg, MLoc.getOffset()); 209 else 210 Expr.AddReg(Reg); 211 } 212 213 //===----------------------------------------------------------------------===// 214 // Dwarf Lowering Routines 215 //===----------------------------------------------------------------------===// 216 217 void AsmPrinter::emitCFIInstruction(const MCCFIInstruction &Inst) const { 218 switch (Inst.getOperation()) { 219 default: 220 llvm_unreachable("Unexpected instruction"); 221 case MCCFIInstruction::OpDefCfaOffset: 222 OutStreamer.EmitCFIDefCfaOffset(Inst.getOffset()); 223 break; 224 case MCCFIInstruction::OpDefCfa: 225 OutStreamer.EmitCFIDefCfa(Inst.getRegister(), Inst.getOffset()); 226 break; 227 case MCCFIInstruction::OpDefCfaRegister: 228 OutStreamer.EmitCFIDefCfaRegister(Inst.getRegister()); 229 break; 230 case MCCFIInstruction::OpOffset: 231 OutStreamer.EmitCFIOffset(Inst.getRegister(), Inst.getOffset()); 232 break; 233 case MCCFIInstruction::OpRegister: 234 OutStreamer.EmitCFIRegister(Inst.getRegister(), Inst.getRegister2()); 235 break; 236 case MCCFIInstruction::OpWindowSave: 237 OutStreamer.EmitCFIWindowSave(); 238 break; 239 case MCCFIInstruction::OpSameValue: 240 OutStreamer.EmitCFISameValue(Inst.getRegister()); 241 break; 242 } 243 } 244 245 void AsmPrinter::emitDwarfDIE(const DIE &Die) const { 246 // Get the abbreviation for this DIE. 247 const DIEAbbrev &Abbrev = Die.getAbbrev(); 248 249 // Emit the code (index) for the abbreviation. 250 if (isVerbose()) 251 OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) + 252 "] 0x" + Twine::utohexstr(Die.getOffset()) + 253 ":0x" + Twine::utohexstr(Die.getSize()) + " " + 254 dwarf::TagString(Abbrev.getTag())); 255 EmitULEB128(Abbrev.getNumber()); 256 257 const SmallVectorImpl<DIEValue *> &Values = Die.getValues(); 258 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData(); 259 260 // Emit the DIE attribute values. 261 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 262 dwarf::Attribute Attr = AbbrevData[i].getAttribute(); 263 dwarf::Form Form = AbbrevData[i].getForm(); 264 assert(Form && "Too many attributes for DIE (check abbreviation)"); 265 266 if (isVerbose()) { 267 OutStreamer.AddComment(dwarf::AttributeString(Attr)); 268 if (Attr == dwarf::DW_AT_accessibility) 269 OutStreamer.AddComment(dwarf::AccessibilityString( 270 cast<DIEInteger>(Values[i])->getValue())); 271 } 272 273 // Emit an attribute using the defined form. 274 Values[i]->EmitValue(this, Form); 275 } 276 277 // Emit the DIE children if any. 278 if (Abbrev.hasChildren()) { 279 for (auto &Child : Die.getChildren()) 280 emitDwarfDIE(*Child); 281 282 OutStreamer.AddComment("End Of Children Mark"); 283 EmitInt8(0); 284 } 285 } 286 287 void 288 AsmPrinter::emitDwarfAbbrevs(const std::vector<DIEAbbrev *>& Abbrevs) const { 289 // For each abbrevation. 290 for (const DIEAbbrev *Abbrev : Abbrevs) { 291 // Emit the abbrevations code (base 1 index.) 292 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 293 294 // Emit the abbreviations data. 295 Abbrev->Emit(this); 296 } 297 298 // Mark end of abbreviations. 299 EmitULEB128(0, "EOM(3)"); 300 } 301