1 //===- lib/MC/MCDwarf.cpp - MCDwarf implementation ------------------------===// 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 #include "llvm/MC/MCDwarf.h" 11 #include "llvm/ADT/Hashing.h" 12 #include "llvm/ADT/STLExtras.h" 13 #include "llvm/ADT/SmallString.h" 14 #include "llvm/ADT/Twine.h" 15 #include "llvm/Config/config.h" 16 #include "llvm/MC/MCAsmInfo.h" 17 #include "llvm/MC/MCContext.h" 18 #include "llvm/MC/MCExpr.h" 19 #include "llvm/MC/MCObjectFileInfo.h" 20 #include "llvm/MC/MCObjectStreamer.h" 21 #include "llvm/MC/MCRegisterInfo.h" 22 #include "llvm/MC/MCSection.h" 23 #include "llvm/MC/MCSymbol.h" 24 #include "llvm/Support/Debug.h" 25 #include "llvm/Support/ErrorHandling.h" 26 #include "llvm/Support/LEB128.h" 27 #include "llvm/Support/Path.h" 28 #include "llvm/Support/SourceMgr.h" 29 #include "llvm/Support/raw_ostream.h" 30 31 using namespace llvm; 32 33 static inline uint64_t ScaleAddrDelta(MCContext &Context, uint64_t AddrDelta) { 34 unsigned MinInsnLength = Context.getAsmInfo()->getMinInstAlignment(); 35 if (MinInsnLength == 1) 36 return AddrDelta; 37 if (AddrDelta % MinInsnLength != 0) { 38 // TODO: report this error, but really only once. 39 ; 40 } 41 return AddrDelta / MinInsnLength; 42 } 43 44 // 45 // This is called when an instruction is assembled into the specified section 46 // and if there is information from the last .loc directive that has yet to have 47 // a line entry made for it is made. 48 // 49 void MCLineEntry::Make(MCObjectStreamer *MCOS, MCSection *Section) { 50 if (!MCOS->getContext().getDwarfLocSeen()) 51 return; 52 53 // Create a symbol at in the current section for use in the line entry. 54 MCSymbol *LineSym = MCOS->getContext().createTempSymbol(); 55 // Set the value of the symbol to use for the MCLineEntry. 56 MCOS->EmitLabel(LineSym); 57 58 // Get the current .loc info saved in the context. 59 const MCDwarfLoc &DwarfLoc = MCOS->getContext().getCurrentDwarfLoc(); 60 61 // Create a (local) line entry with the symbol and the current .loc info. 62 MCLineEntry LineEntry(LineSym, DwarfLoc); 63 64 // clear DwarfLocSeen saying the current .loc info is now used. 65 MCOS->getContext().clearDwarfLocSeen(); 66 67 // Add the line entry to this section's entries. 68 MCOS->getContext() 69 .getMCDwarfLineTable(MCOS->getContext().getDwarfCompileUnitID()) 70 .getMCLineSections() 71 .addLineEntry(LineEntry, Section); 72 } 73 74 // 75 // This helper routine returns an expression of End - Start + IntVal . 76 // 77 static inline const MCExpr *MakeStartMinusEndExpr(const MCStreamer &MCOS, 78 const MCSymbol &Start, 79 const MCSymbol &End, 80 int IntVal) { 81 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None; 82 const MCExpr *Res = 83 MCSymbolRefExpr::create(&End, Variant, MCOS.getContext()); 84 const MCExpr *RHS = 85 MCSymbolRefExpr::create(&Start, Variant, MCOS.getContext()); 86 const MCExpr *Res1 = 87 MCBinaryExpr::create(MCBinaryExpr::Sub, Res, RHS, MCOS.getContext()); 88 const MCExpr *Res2 = 89 MCConstantExpr::create(IntVal, MCOS.getContext()); 90 const MCExpr *Res3 = 91 MCBinaryExpr::create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext()); 92 return Res3; 93 } 94 95 // 96 // This emits the Dwarf line table for the specified section from the entries 97 // in the LineSection. 98 // 99 static inline void 100 EmitDwarfLineTable(MCObjectStreamer *MCOS, MCSection *Section, 101 const MCLineSection::MCLineEntryCollection &LineEntries) { 102 unsigned FileNum = 1; 103 unsigned LastLine = 1; 104 unsigned Column = 0; 105 unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0; 106 unsigned Isa = 0; 107 unsigned Discriminator = 0; 108 MCSymbol *LastLabel = nullptr; 109 110 // Loop through each MCLineEntry and encode the dwarf line number table. 111 for (auto it = LineEntries.begin(), 112 ie = LineEntries.end(); 113 it != ie; ++it) { 114 115 if (FileNum != it->getFileNum()) { 116 FileNum = it->getFileNum(); 117 MCOS->EmitIntValue(dwarf::DW_LNS_set_file, 1); 118 MCOS->EmitULEB128IntValue(FileNum); 119 } 120 if (Column != it->getColumn()) { 121 Column = it->getColumn(); 122 MCOS->EmitIntValue(dwarf::DW_LNS_set_column, 1); 123 MCOS->EmitULEB128IntValue(Column); 124 } 125 if (Discriminator != it->getDiscriminator()) { 126 Discriminator = it->getDiscriminator(); 127 unsigned Size = getULEB128Size(Discriminator); 128 MCOS->EmitIntValue(dwarf::DW_LNS_extended_op, 1); 129 MCOS->EmitULEB128IntValue(Size + 1); 130 MCOS->EmitIntValue(dwarf::DW_LNE_set_discriminator, 1); 131 MCOS->EmitULEB128IntValue(Discriminator); 132 } 133 if (Isa != it->getIsa()) { 134 Isa = it->getIsa(); 135 MCOS->EmitIntValue(dwarf::DW_LNS_set_isa, 1); 136 MCOS->EmitULEB128IntValue(Isa); 137 } 138 if ((it->getFlags() ^ Flags) & DWARF2_FLAG_IS_STMT) { 139 Flags = it->getFlags(); 140 MCOS->EmitIntValue(dwarf::DW_LNS_negate_stmt, 1); 141 } 142 if (it->getFlags() & DWARF2_FLAG_BASIC_BLOCK) 143 MCOS->EmitIntValue(dwarf::DW_LNS_set_basic_block, 1); 144 if (it->getFlags() & DWARF2_FLAG_PROLOGUE_END) 145 MCOS->EmitIntValue(dwarf::DW_LNS_set_prologue_end, 1); 146 if (it->getFlags() & DWARF2_FLAG_EPILOGUE_BEGIN) 147 MCOS->EmitIntValue(dwarf::DW_LNS_set_epilogue_begin, 1); 148 149 int64_t LineDelta = static_cast<int64_t>(it->getLine()) - LastLine; 150 MCSymbol *Label = it->getLabel(); 151 152 // At this point we want to emit/create the sequence to encode the delta in 153 // line numbers and the increment of the address from the previous Label 154 // and the current Label. 155 const MCAsmInfo *asmInfo = MCOS->getContext().getAsmInfo(); 156 MCOS->EmitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label, 157 asmInfo->getPointerSize()); 158 159 LastLine = it->getLine(); 160 LastLabel = Label; 161 } 162 163 // Emit a DW_LNE_end_sequence for the end of the section. 164 // Use the section end label to compute the address delta and use INT64_MAX 165 // as the line delta which is the signal that this is actually a 166 // DW_LNE_end_sequence. 167 MCSymbol *SectionEnd = MCOS->endSection(Section); 168 169 // Switch back the dwarf line section, in case endSection had to switch the 170 // section. 171 MCContext &Ctx = MCOS->getContext(); 172 MCOS->SwitchSection(Ctx.getObjectFileInfo()->getDwarfLineSection()); 173 174 const MCAsmInfo *AsmInfo = Ctx.getAsmInfo(); 175 MCOS->EmitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd, 176 AsmInfo->getPointerSize()); 177 } 178 179 // 180 // This emits the Dwarf file and the line tables. 181 // 182 void MCDwarfLineTable::Emit(MCObjectStreamer *MCOS, 183 MCDwarfLineTableParams Params) { 184 MCContext &context = MCOS->getContext(); 185 186 auto &LineTables = context.getMCDwarfLineTables(); 187 188 // Bail out early so we don't switch to the debug_line section needlessly and 189 // in doing so create an unnecessary (if empty) section. 190 if (LineTables.empty()) 191 return; 192 193 // Switch to the section where the table will be emitted into. 194 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection()); 195 196 // Handle the rest of the Compile Units. 197 for (const auto &CUIDTablePair : LineTables) 198 CUIDTablePair.second.EmitCU(MCOS, Params); 199 } 200 201 void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS, 202 MCDwarfLineTableParams Params) const { 203 MCOS.EmitLabel(Header.Emit(&MCOS, Params, None).second); 204 } 205 206 std::pair<MCSymbol *, MCSymbol *> 207 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, 208 MCDwarfLineTableParams Params) const { 209 static const char StandardOpcodeLengths[] = { 210 0, // length of DW_LNS_copy 211 1, // length of DW_LNS_advance_pc 212 1, // length of DW_LNS_advance_line 213 1, // length of DW_LNS_set_file 214 1, // length of DW_LNS_set_column 215 0, // length of DW_LNS_negate_stmt 216 0, // length of DW_LNS_set_basic_block 217 0, // length of DW_LNS_const_add_pc 218 1, // length of DW_LNS_fixed_advance_pc 219 0, // length of DW_LNS_set_prologue_end 220 0, // length of DW_LNS_set_epilogue_begin 221 1 // DW_LNS_set_isa 222 }; 223 assert(array_lengthof(StandardOpcodeLengths) >= 224 (Params.DWARF2LineOpcodeBase - 1U)); 225 return Emit(MCOS, Params, makeArrayRef(StandardOpcodeLengths, 226 Params.DWARF2LineOpcodeBase - 1)); 227 } 228 229 static const MCExpr *forceExpAbs(MCStreamer &OS, const MCExpr* Expr) { 230 MCContext &Context = OS.getContext(); 231 assert(!isa<MCSymbolRefExpr>(Expr)); 232 if (Context.getAsmInfo()->hasAggressiveSymbolFolding()) 233 return Expr; 234 235 MCSymbol *ABS = Context.createTempSymbol(); 236 OS.EmitAssignment(ABS, Expr); 237 return MCSymbolRefExpr::create(ABS, Context); 238 } 239 240 static void emitAbsValue(MCStreamer &OS, const MCExpr *Value, unsigned Size) { 241 const MCExpr *ABS = forceExpAbs(OS, Value); 242 OS.EmitValue(ABS, Size); 243 } 244 245 std::pair<MCSymbol *, MCSymbol *> 246 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params, 247 ArrayRef<char> StandardOpcodeLengths) const { 248 MCContext &context = MCOS->getContext(); 249 250 // Create a symbol at the beginning of the line table. 251 MCSymbol *LineStartSym = Label; 252 if (!LineStartSym) 253 LineStartSym = context.createTempSymbol(); 254 // Set the value of the symbol, as we are at the start of the line table. 255 MCOS->EmitLabel(LineStartSym); 256 257 // Create a symbol for the end of the section (to be set when we get there). 258 MCSymbol *LineEndSym = context.createTempSymbol(); 259 260 // The first 4 bytes is the total length of the information for this 261 // compilation unit (not including these 4 bytes for the length). 262 emitAbsValue(*MCOS, 263 MakeStartMinusEndExpr(*MCOS, *LineStartSym, *LineEndSym, 4), 4); 264 265 // Next 2 bytes is the Version, which is Dwarf 2. 266 MCOS->EmitIntValue(2, 2); 267 268 // Create a symbol for the end of the prologue (to be set when we get there). 269 MCSymbol *ProEndSym = context.createTempSymbol(); // Lprologue_end 270 271 // Length of the prologue, is the next 4 bytes. Which is the start of the 272 // section to the end of the prologue. Not including the 4 bytes for the 273 // total length, the 2 bytes for the version, and these 4 bytes for the 274 // length of the prologue. 275 emitAbsValue( 276 *MCOS, 277 MakeStartMinusEndExpr(*MCOS, *LineStartSym, *ProEndSym, (4 + 2 + 4)), 4); 278 279 // Parameters of the state machine, are next. 280 MCOS->EmitIntValue(context.getAsmInfo()->getMinInstAlignment(), 1); 281 MCOS->EmitIntValue(DWARF2_LINE_DEFAULT_IS_STMT, 1); 282 MCOS->EmitIntValue(Params.DWARF2LineBase, 1); 283 MCOS->EmitIntValue(Params.DWARF2LineRange, 1); 284 MCOS->EmitIntValue(StandardOpcodeLengths.size() + 1, 1); 285 286 // Standard opcode lengths 287 for (char Length : StandardOpcodeLengths) 288 MCOS->EmitIntValue(Length, 1); 289 290 // Put out the directory and file tables. 291 292 // First the directory table. 293 for (unsigned i = 0; i < MCDwarfDirs.size(); i++) { 294 MCOS->EmitBytes(MCDwarfDirs[i]); // the DirectoryName 295 MCOS->EmitBytes(StringRef("\0", 1)); // the null term. of the string 296 } 297 MCOS->EmitIntValue(0, 1); // Terminate the directory list 298 299 // Second the file table. 300 for (unsigned i = 1; i < MCDwarfFiles.size(); i++) { 301 assert(!MCDwarfFiles[i].Name.empty()); 302 MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName 303 MCOS->EmitBytes(StringRef("\0", 1)); // the null term. of the string 304 // the Directory num 305 MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex); 306 MCOS->EmitIntValue(0, 1); // last modification timestamp (always 0) 307 MCOS->EmitIntValue(0, 1); // filesize (always 0) 308 } 309 MCOS->EmitIntValue(0, 1); // Terminate the file list 310 311 // This is the end of the prologue, so set the value of the symbol at the 312 // end of the prologue (that was used in a previous expression). 313 MCOS->EmitLabel(ProEndSym); 314 315 return std::make_pair(LineStartSym, LineEndSym); 316 } 317 318 void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS, 319 MCDwarfLineTableParams Params) const { 320 MCSymbol *LineEndSym = Header.Emit(MCOS, Params).second; 321 322 // Put out the line tables. 323 for (const auto &LineSec : MCLineSections.getMCLineEntries()) 324 EmitDwarfLineTable(MCOS, LineSec.first, LineSec.second); 325 326 // This is the end of the section, so set the value of the symbol at the end 327 // of this section (that was used in a previous expression). 328 MCOS->EmitLabel(LineEndSym); 329 } 330 331 unsigned MCDwarfLineTable::getFile(StringRef &Directory, StringRef &FileName, 332 unsigned FileNumber) { 333 return Header.getFile(Directory, FileName, FileNumber); 334 } 335 336 unsigned MCDwarfLineTableHeader::getFile(StringRef &Directory, 337 StringRef &FileName, 338 unsigned FileNumber) { 339 if (Directory == CompilationDir) 340 Directory = ""; 341 if (FileName.empty()) { 342 FileName = "<stdin>"; 343 Directory = ""; 344 } 345 assert(!FileName.empty()); 346 if (FileNumber == 0) { 347 FileNumber = SourceIdMap.size() + 1; 348 assert((MCDwarfFiles.empty() || FileNumber == MCDwarfFiles.size()) && 349 "Don't mix autonumbered and explicit numbered line table usage"); 350 SmallString<256> Buffer; 351 auto IterBool = SourceIdMap.insert( 352 std::make_pair((Directory + Twine('\0') + FileName).toStringRef(Buffer), 353 FileNumber)); 354 if (!IterBool.second) 355 return IterBool.first->second; 356 } 357 // Make space for this FileNumber in the MCDwarfFiles vector if needed. 358 MCDwarfFiles.resize(FileNumber + 1); 359 360 // Get the new MCDwarfFile slot for this FileNumber. 361 MCDwarfFile &File = MCDwarfFiles[FileNumber]; 362 363 // It is an error to use see the same number more than once. 364 if (!File.Name.empty()) 365 return 0; 366 367 if (Directory.empty()) { 368 // Separate the directory part from the basename of the FileName. 369 StringRef tFileName = sys::path::filename(FileName); 370 if (!tFileName.empty()) { 371 Directory = sys::path::parent_path(FileName); 372 if (!Directory.empty()) 373 FileName = tFileName; 374 } 375 } 376 377 // Find or make an entry in the MCDwarfDirs vector for this Directory. 378 // Capture directory name. 379 unsigned DirIndex; 380 if (Directory.empty()) { 381 // For FileNames with no directories a DirIndex of 0 is used. 382 DirIndex = 0; 383 } else { 384 DirIndex = 0; 385 for (unsigned End = MCDwarfDirs.size(); DirIndex < End; DirIndex++) { 386 if (Directory == MCDwarfDirs[DirIndex]) 387 break; 388 } 389 if (DirIndex >= MCDwarfDirs.size()) 390 MCDwarfDirs.push_back(Directory); 391 // The DirIndex is one based, as DirIndex of 0 is used for FileNames with 392 // no directories. MCDwarfDirs[] is unlike MCDwarfFiles[] in that the 393 // directory names are stored at MCDwarfDirs[DirIndex-1] where FileNames 394 // are stored at MCDwarfFiles[FileNumber].Name . 395 DirIndex++; 396 } 397 398 File.Name = FileName; 399 File.DirIndex = DirIndex; 400 401 // return the allocated FileNumber. 402 return FileNumber; 403 } 404 405 /// Utility function to emit the encoding to a streamer. 406 void MCDwarfLineAddr::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params, 407 int64_t LineDelta, uint64_t AddrDelta) { 408 MCContext &Context = MCOS->getContext(); 409 SmallString<256> Tmp; 410 raw_svector_ostream OS(Tmp); 411 MCDwarfLineAddr::Encode(Context, Params, LineDelta, AddrDelta, OS); 412 MCOS->EmitBytes(OS.str()); 413 } 414 415 /// Given a special op, return the address skip amount (in units of 416 /// DWARF2_LINE_MIN_INSN_LENGTH). 417 static uint64_t SpecialAddr(MCDwarfLineTableParams Params, uint64_t op) { 418 return (op - Params.DWARF2LineOpcodeBase) / Params.DWARF2LineRange; 419 } 420 421 /// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas. 422 void MCDwarfLineAddr::Encode(MCContext &Context, MCDwarfLineTableParams Params, 423 int64_t LineDelta, uint64_t AddrDelta, 424 raw_ostream &OS) { 425 uint64_t Temp, Opcode; 426 bool NeedCopy = false; 427 428 // The maximum address skip amount that can be encoded with a special op. 429 uint64_t MaxSpecialAddrDelta = SpecialAddr(Params, 255); 430 431 // Scale the address delta by the minimum instruction length. 432 AddrDelta = ScaleAddrDelta(Context, AddrDelta); 433 434 // A LineDelta of INT64_MAX is a signal that this is actually a 435 // DW_LNE_end_sequence. We cannot use special opcodes here, since we want the 436 // end_sequence to emit the matrix entry. 437 if (LineDelta == INT64_MAX) { 438 if (AddrDelta == MaxSpecialAddrDelta) 439 OS << char(dwarf::DW_LNS_const_add_pc); 440 else if (AddrDelta) { 441 OS << char(dwarf::DW_LNS_advance_pc); 442 encodeULEB128(AddrDelta, OS); 443 } 444 OS << char(dwarf::DW_LNS_extended_op); 445 OS << char(1); 446 OS << char(dwarf::DW_LNE_end_sequence); 447 return; 448 } 449 450 // Bias the line delta by the base. 451 Temp = LineDelta - Params.DWARF2LineBase; 452 453 // If the line increment is out of range of a special opcode, we must encode 454 // it with DW_LNS_advance_line. 455 if (Temp >= Params.DWARF2LineRange) { 456 OS << char(dwarf::DW_LNS_advance_line); 457 encodeSLEB128(LineDelta, OS); 458 459 LineDelta = 0; 460 Temp = 0 - Params.DWARF2LineBase; 461 NeedCopy = true; 462 } 463 464 // Use DW_LNS_copy instead of a "line +0, addr +0" special opcode. 465 if (LineDelta == 0 && AddrDelta == 0) { 466 OS << char(dwarf::DW_LNS_copy); 467 return; 468 } 469 470 // Bias the opcode by the special opcode base. 471 Temp += Params.DWARF2LineOpcodeBase; 472 473 // Avoid overflow when addr_delta is large. 474 if (AddrDelta < 256 + MaxSpecialAddrDelta) { 475 // Try using a special opcode. 476 Opcode = Temp + AddrDelta * Params.DWARF2LineRange; 477 if (Opcode <= 255) { 478 OS << char(Opcode); 479 return; 480 } 481 482 // Try using DW_LNS_const_add_pc followed by special op. 483 Opcode = Temp + (AddrDelta - MaxSpecialAddrDelta) * Params.DWARF2LineRange; 484 if (Opcode <= 255) { 485 OS << char(dwarf::DW_LNS_const_add_pc); 486 OS << char(Opcode); 487 return; 488 } 489 } 490 491 // Otherwise use DW_LNS_advance_pc. 492 OS << char(dwarf::DW_LNS_advance_pc); 493 encodeULEB128(AddrDelta, OS); 494 495 if (NeedCopy) 496 OS << char(dwarf::DW_LNS_copy); 497 else 498 OS << char(Temp); 499 } 500 501 // Utility function to write a tuple for .debug_abbrev. 502 static void EmitAbbrev(MCStreamer *MCOS, uint64_t Name, uint64_t Form) { 503 MCOS->EmitULEB128IntValue(Name); 504 MCOS->EmitULEB128IntValue(Form); 505 } 506 507 // When generating dwarf for assembly source files this emits 508 // the data for .debug_abbrev section which contains three DIEs. 509 static void EmitGenDwarfAbbrev(MCStreamer *MCOS) { 510 MCContext &context = MCOS->getContext(); 511 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection()); 512 513 // DW_TAG_compile_unit DIE abbrev (1). 514 MCOS->EmitULEB128IntValue(1); 515 MCOS->EmitULEB128IntValue(dwarf::DW_TAG_compile_unit); 516 MCOS->EmitIntValue(dwarf::DW_CHILDREN_yes, 1); 517 EmitAbbrev(MCOS, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4); 518 if (MCOS->getContext().getGenDwarfSectionSyms().size() > 1 && 519 MCOS->getContext().getDwarfVersion() >= 3) { 520 EmitAbbrev(MCOS, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4); 521 } else { 522 EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr); 523 EmitAbbrev(MCOS, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr); 524 } 525 EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string); 526 if (!context.getCompilationDir().empty()) 527 EmitAbbrev(MCOS, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string); 528 StringRef DwarfDebugFlags = context.getDwarfDebugFlags(); 529 if (!DwarfDebugFlags.empty()) 530 EmitAbbrev(MCOS, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string); 531 EmitAbbrev(MCOS, dwarf::DW_AT_producer, dwarf::DW_FORM_string); 532 EmitAbbrev(MCOS, dwarf::DW_AT_language, dwarf::DW_FORM_data2); 533 EmitAbbrev(MCOS, 0, 0); 534 535 // DW_TAG_label DIE abbrev (2). 536 MCOS->EmitULEB128IntValue(2); 537 MCOS->EmitULEB128IntValue(dwarf::DW_TAG_label); 538 MCOS->EmitIntValue(dwarf::DW_CHILDREN_yes, 1); 539 EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string); 540 EmitAbbrev(MCOS, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data4); 541 EmitAbbrev(MCOS, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data4); 542 EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr); 543 EmitAbbrev(MCOS, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag); 544 EmitAbbrev(MCOS, 0, 0); 545 546 // DW_TAG_unspecified_parameters DIE abbrev (3). 547 MCOS->EmitULEB128IntValue(3); 548 MCOS->EmitULEB128IntValue(dwarf::DW_TAG_unspecified_parameters); 549 MCOS->EmitIntValue(dwarf::DW_CHILDREN_no, 1); 550 EmitAbbrev(MCOS, 0, 0); 551 552 // Terminate the abbreviations for this compilation unit. 553 MCOS->EmitIntValue(0, 1); 554 } 555 556 // When generating dwarf for assembly source files this emits the data for 557 // .debug_aranges section. This section contains a header and a table of pairs 558 // of PointerSize'ed values for the address and size of section(s) with line 559 // table entries. 560 static void EmitGenDwarfAranges(MCStreamer *MCOS, 561 const MCSymbol *InfoSectionSymbol) { 562 MCContext &context = MCOS->getContext(); 563 564 auto &Sections = context.getGenDwarfSectionSyms(); 565 566 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection()); 567 568 // This will be the length of the .debug_aranges section, first account for 569 // the size of each item in the header (see below where we emit these items). 570 int Length = 4 + 2 + 4 + 1 + 1; 571 572 // Figure the padding after the header before the table of address and size 573 // pairs who's values are PointerSize'ed. 574 const MCAsmInfo *asmInfo = context.getAsmInfo(); 575 int AddrSize = asmInfo->getPointerSize(); 576 int Pad = 2 * AddrSize - (Length & (2 * AddrSize - 1)); 577 if (Pad == 2 * AddrSize) 578 Pad = 0; 579 Length += Pad; 580 581 // Add the size of the pair of PointerSize'ed values for the address and size 582 // of each section we have in the table. 583 Length += 2 * AddrSize * Sections.size(); 584 // And the pair of terminating zeros. 585 Length += 2 * AddrSize; 586 587 588 // Emit the header for this section. 589 // The 4 byte length not including the 4 byte value for the length. 590 MCOS->EmitIntValue(Length - 4, 4); 591 // The 2 byte version, which is 2. 592 MCOS->EmitIntValue(2, 2); 593 // The 4 byte offset to the compile unit in the .debug_info from the start 594 // of the .debug_info. 595 if (InfoSectionSymbol) 596 MCOS->EmitSymbolValue(InfoSectionSymbol, 4, 597 asmInfo->needsDwarfSectionOffsetDirective()); 598 else 599 MCOS->EmitIntValue(0, 4); 600 // The 1 byte size of an address. 601 MCOS->EmitIntValue(AddrSize, 1); 602 // The 1 byte size of a segment descriptor, we use a value of zero. 603 MCOS->EmitIntValue(0, 1); 604 // Align the header with the padding if needed, before we put out the table. 605 for(int i = 0; i < Pad; i++) 606 MCOS->EmitIntValue(0, 1); 607 608 // Now emit the table of pairs of PointerSize'ed values for the section 609 // addresses and sizes. 610 for (MCSection *Sec : Sections) { 611 const MCSymbol *StartSymbol = Sec->getBeginSymbol(); 612 MCSymbol *EndSymbol = Sec->getEndSymbol(context); 613 assert(StartSymbol && "StartSymbol must not be NULL"); 614 assert(EndSymbol && "EndSymbol must not be NULL"); 615 616 const MCExpr *Addr = MCSymbolRefExpr::create( 617 StartSymbol, MCSymbolRefExpr::VK_None, context); 618 const MCExpr *Size = MakeStartMinusEndExpr(*MCOS, 619 *StartSymbol, *EndSymbol, 0); 620 MCOS->EmitValue(Addr, AddrSize); 621 emitAbsValue(*MCOS, Size, AddrSize); 622 } 623 624 // And finally the pair of terminating zeros. 625 MCOS->EmitIntValue(0, AddrSize); 626 MCOS->EmitIntValue(0, AddrSize); 627 } 628 629 // When generating dwarf for assembly source files this emits the data for 630 // .debug_info section which contains three parts. The header, the compile_unit 631 // DIE and a list of label DIEs. 632 static void EmitGenDwarfInfo(MCStreamer *MCOS, 633 const MCSymbol *AbbrevSectionSymbol, 634 const MCSymbol *LineSectionSymbol, 635 const MCSymbol *RangesSectionSymbol) { 636 MCContext &context = MCOS->getContext(); 637 638 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection()); 639 640 // Create a symbol at the start and end of this section used in here for the 641 // expression to calculate the length in the header. 642 MCSymbol *InfoStart = context.createTempSymbol(); 643 MCOS->EmitLabel(InfoStart); 644 MCSymbol *InfoEnd = context.createTempSymbol(); 645 646 // First part: the header. 647 648 // The 4 byte total length of the information for this compilation unit, not 649 // including these 4 bytes. 650 const MCExpr *Length = MakeStartMinusEndExpr(*MCOS, *InfoStart, *InfoEnd, 4); 651 emitAbsValue(*MCOS, Length, 4); 652 653 // The 2 byte DWARF version. 654 MCOS->EmitIntValue(context.getDwarfVersion(), 2); 655 656 const MCAsmInfo &AsmInfo = *context.getAsmInfo(); 657 // The 4 byte offset to the debug abbrevs from the start of the .debug_abbrev, 658 // it is at the start of that section so this is zero. 659 if (AbbrevSectionSymbol == nullptr) 660 MCOS->EmitIntValue(0, 4); 661 else 662 MCOS->EmitSymbolValue(AbbrevSectionSymbol, 4, 663 AsmInfo.needsDwarfSectionOffsetDirective()); 664 665 const MCAsmInfo *asmInfo = context.getAsmInfo(); 666 int AddrSize = asmInfo->getPointerSize(); 667 // The 1 byte size of an address. 668 MCOS->EmitIntValue(AddrSize, 1); 669 670 // Second part: the compile_unit DIE. 671 672 // The DW_TAG_compile_unit DIE abbrev (1). 673 MCOS->EmitULEB128IntValue(1); 674 675 // DW_AT_stmt_list, a 4 byte offset from the start of the .debug_line section, 676 // which is at the start of that section so this is zero. 677 if (LineSectionSymbol) 678 MCOS->EmitSymbolValue(LineSectionSymbol, 4, 679 AsmInfo.needsDwarfSectionOffsetDirective()); 680 else 681 MCOS->EmitIntValue(0, 4); 682 683 if (RangesSectionSymbol) { 684 // There are multiple sections containing code, so we must use the 685 // .debug_ranges sections. 686 687 // AT_ranges, the 4 byte offset from the start of the .debug_ranges section 688 // to the address range list for this compilation unit. 689 MCOS->EmitSymbolValue(RangesSectionSymbol, 4); 690 } else { 691 // If we only have one non-empty code section, we can use the simpler 692 // AT_low_pc and AT_high_pc attributes. 693 694 // Find the first (and only) non-empty text section 695 auto &Sections = context.getGenDwarfSectionSyms(); 696 const auto TextSection = Sections.begin(); 697 assert(TextSection != Sections.end() && "No text section found"); 698 699 MCSymbol *StartSymbol = (*TextSection)->getBeginSymbol(); 700 MCSymbol *EndSymbol = (*TextSection)->getEndSymbol(context); 701 assert(StartSymbol && "StartSymbol must not be NULL"); 702 assert(EndSymbol && "EndSymbol must not be NULL"); 703 704 // AT_low_pc, the first address of the default .text section. 705 const MCExpr *Start = MCSymbolRefExpr::create( 706 StartSymbol, MCSymbolRefExpr::VK_None, context); 707 MCOS->EmitValue(Start, AddrSize); 708 709 // AT_high_pc, the last address of the default .text section. 710 const MCExpr *End = MCSymbolRefExpr::create( 711 EndSymbol, MCSymbolRefExpr::VK_None, context); 712 MCOS->EmitValue(End, AddrSize); 713 } 714 715 // AT_name, the name of the source file. Reconstruct from the first directory 716 // and file table entries. 717 const SmallVectorImpl<std::string> &MCDwarfDirs = context.getMCDwarfDirs(); 718 if (MCDwarfDirs.size() > 0) { 719 MCOS->EmitBytes(MCDwarfDirs[0]); 720 MCOS->EmitBytes(sys::path::get_separator()); 721 } 722 const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles = 723 MCOS->getContext().getMCDwarfFiles(); 724 MCOS->EmitBytes(MCDwarfFiles[1].Name); 725 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string. 726 727 // AT_comp_dir, the working directory the assembly was done in. 728 if (!context.getCompilationDir().empty()) { 729 MCOS->EmitBytes(context.getCompilationDir()); 730 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string. 731 } 732 733 // AT_APPLE_flags, the command line arguments of the assembler tool. 734 StringRef DwarfDebugFlags = context.getDwarfDebugFlags(); 735 if (!DwarfDebugFlags.empty()){ 736 MCOS->EmitBytes(DwarfDebugFlags); 737 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string. 738 } 739 740 // AT_producer, the version of the assembler tool. 741 StringRef DwarfDebugProducer = context.getDwarfDebugProducer(); 742 if (!DwarfDebugProducer.empty()) 743 MCOS->EmitBytes(DwarfDebugProducer); 744 else 745 MCOS->EmitBytes(StringRef("llvm-mc (based on LLVM " PACKAGE_VERSION ")")); 746 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string. 747 748 // AT_language, a 4 byte value. We use DW_LANG_Mips_Assembler as the dwarf2 749 // draft has no standard code for assembler. 750 MCOS->EmitIntValue(dwarf::DW_LANG_Mips_Assembler, 2); 751 752 // Third part: the list of label DIEs. 753 754 // Loop on saved info for dwarf labels and create the DIEs for them. 755 const std::vector<MCGenDwarfLabelEntry> &Entries = 756 MCOS->getContext().getMCGenDwarfLabelEntries(); 757 for (const auto &Entry : Entries) { 758 // The DW_TAG_label DIE abbrev (2). 759 MCOS->EmitULEB128IntValue(2); 760 761 // AT_name, of the label without any leading underbar. 762 MCOS->EmitBytes(Entry.getName()); 763 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string. 764 765 // AT_decl_file, index into the file table. 766 MCOS->EmitIntValue(Entry.getFileNumber(), 4); 767 768 // AT_decl_line, source line number. 769 MCOS->EmitIntValue(Entry.getLineNumber(), 4); 770 771 // AT_low_pc, start address of the label. 772 const MCExpr *AT_low_pc = MCSymbolRefExpr::create(Entry.getLabel(), 773 MCSymbolRefExpr::VK_None, context); 774 MCOS->EmitValue(AT_low_pc, AddrSize); 775 776 // DW_AT_prototyped, a one byte flag value of 0 saying we have no prototype. 777 MCOS->EmitIntValue(0, 1); 778 779 // The DW_TAG_unspecified_parameters DIE abbrev (3). 780 MCOS->EmitULEB128IntValue(3); 781 782 // Add the NULL DIE terminating the DW_TAG_unspecified_parameters DIE's. 783 MCOS->EmitIntValue(0, 1); 784 } 785 786 // Add the NULL DIE terminating the Compile Unit DIE's. 787 MCOS->EmitIntValue(0, 1); 788 789 // Now set the value of the symbol at the end of the info section. 790 MCOS->EmitLabel(InfoEnd); 791 } 792 793 // When generating dwarf for assembly source files this emits the data for 794 // .debug_ranges section. We only emit one range list, which spans all of the 795 // executable sections of this file. 796 static void EmitGenDwarfRanges(MCStreamer *MCOS) { 797 MCContext &context = MCOS->getContext(); 798 auto &Sections = context.getGenDwarfSectionSyms(); 799 800 const MCAsmInfo *AsmInfo = context.getAsmInfo(); 801 int AddrSize = AsmInfo->getPointerSize(); 802 803 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection()); 804 805 for (MCSection *Sec : Sections) { 806 const MCSymbol *StartSymbol = Sec->getBeginSymbol(); 807 MCSymbol *EndSymbol = Sec->getEndSymbol(context); 808 assert(StartSymbol && "StartSymbol must not be NULL"); 809 assert(EndSymbol && "EndSymbol must not be NULL"); 810 811 // Emit a base address selection entry for the start of this section 812 const MCExpr *SectionStartAddr = MCSymbolRefExpr::create( 813 StartSymbol, MCSymbolRefExpr::VK_None, context); 814 MCOS->EmitFill(AddrSize, 0xFF); 815 MCOS->EmitValue(SectionStartAddr, AddrSize); 816 817 // Emit a range list entry spanning this section 818 const MCExpr *SectionSize = MakeStartMinusEndExpr(*MCOS, 819 *StartSymbol, *EndSymbol, 0); 820 MCOS->EmitIntValue(0, AddrSize); 821 emitAbsValue(*MCOS, SectionSize, AddrSize); 822 } 823 824 // Emit end of list entry 825 MCOS->EmitIntValue(0, AddrSize); 826 MCOS->EmitIntValue(0, AddrSize); 827 } 828 829 // 830 // When generating dwarf for assembly source files this emits the Dwarf 831 // sections. 832 // 833 void MCGenDwarfInfo::Emit(MCStreamer *MCOS) { 834 MCContext &context = MCOS->getContext(); 835 836 // Create the dwarf sections in this order (.debug_line already created). 837 const MCAsmInfo *AsmInfo = context.getAsmInfo(); 838 bool CreateDwarfSectionSymbols = 839 AsmInfo->doesDwarfUseRelocationsAcrossSections(); 840 MCSymbol *LineSectionSymbol = nullptr; 841 if (CreateDwarfSectionSymbols) 842 LineSectionSymbol = MCOS->getDwarfLineTableSymbol(0); 843 MCSymbol *AbbrevSectionSymbol = nullptr; 844 MCSymbol *InfoSectionSymbol = nullptr; 845 MCSymbol *RangesSectionSymbol = nullptr; 846 847 // Create end symbols for each section, and remove empty sections 848 MCOS->getContext().finalizeDwarfSections(*MCOS); 849 850 // If there are no sections to generate debug info for, we don't need 851 // to do anything 852 if (MCOS->getContext().getGenDwarfSectionSyms().empty()) 853 return; 854 855 // We only use the .debug_ranges section if we have multiple code sections, 856 // and we are emitting a DWARF version which supports it. 857 const bool UseRangesSection = 858 MCOS->getContext().getGenDwarfSectionSyms().size() > 1 && 859 MCOS->getContext().getDwarfVersion() >= 3; 860 CreateDwarfSectionSymbols |= UseRangesSection; 861 862 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection()); 863 if (CreateDwarfSectionSymbols) { 864 InfoSectionSymbol = context.createTempSymbol(); 865 MCOS->EmitLabel(InfoSectionSymbol); 866 } 867 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection()); 868 if (CreateDwarfSectionSymbols) { 869 AbbrevSectionSymbol = context.createTempSymbol(); 870 MCOS->EmitLabel(AbbrevSectionSymbol); 871 } 872 if (UseRangesSection) { 873 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection()); 874 if (CreateDwarfSectionSymbols) { 875 RangesSectionSymbol = context.createTempSymbol(); 876 MCOS->EmitLabel(RangesSectionSymbol); 877 } 878 } 879 880 assert((RangesSectionSymbol != NULL) || !UseRangesSection); 881 882 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection()); 883 884 // Output the data for .debug_aranges section. 885 EmitGenDwarfAranges(MCOS, InfoSectionSymbol); 886 887 if (UseRangesSection) 888 EmitGenDwarfRanges(MCOS); 889 890 // Output the data for .debug_abbrev section. 891 EmitGenDwarfAbbrev(MCOS); 892 893 // Output the data for .debug_info section. 894 EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol, 895 RangesSectionSymbol); 896 } 897 898 // 899 // When generating dwarf for assembly source files this is called when symbol 900 // for a label is created. If this symbol is not a temporary and is in the 901 // section that dwarf is being generated for, save the needed info to create 902 // a dwarf label. 903 // 904 void MCGenDwarfLabelEntry::Make(MCSymbol *Symbol, MCStreamer *MCOS, 905 SourceMgr &SrcMgr, SMLoc &Loc) { 906 // We won't create dwarf labels for temporary symbols. 907 if (Symbol->isTemporary()) 908 return; 909 MCContext &context = MCOS->getContext(); 910 // We won't create dwarf labels for symbols in sections that we are not 911 // generating debug info for. 912 if (!context.getGenDwarfSectionSyms().count(MCOS->getCurrentSection().first)) 913 return; 914 915 // The dwarf label's name does not have the symbol name's leading 916 // underbar if any. 917 StringRef Name = Symbol->getName(); 918 if (Name.startswith("_")) 919 Name = Name.substr(1, Name.size()-1); 920 921 // Get the dwarf file number to be used for the dwarf label. 922 unsigned FileNumber = context.getGenDwarfFileNumber(); 923 924 // Finding the line number is the expensive part which is why we just don't 925 // pass it in as for some symbols we won't create a dwarf label. 926 unsigned CurBuffer = SrcMgr.FindBufferContainingLoc(Loc); 927 unsigned LineNumber = SrcMgr.FindLineNumber(Loc, CurBuffer); 928 929 // We create a temporary symbol for use for the AT_high_pc and AT_low_pc 930 // values so that they don't have things like an ARM thumb bit from the 931 // original symbol. So when used they won't get a low bit set after 932 // relocation. 933 MCSymbol *Label = context.createTempSymbol(); 934 MCOS->EmitLabel(Label); 935 936 // Create and entry for the info and add it to the other entries. 937 MCOS->getContext().addMCGenDwarfLabelEntry( 938 MCGenDwarfLabelEntry(Name, FileNumber, LineNumber, Label)); 939 } 940 941 static int getDataAlignmentFactor(MCStreamer &streamer) { 942 MCContext &context = streamer.getContext(); 943 const MCAsmInfo *asmInfo = context.getAsmInfo(); 944 int size = asmInfo->getCalleeSaveStackSlotSize(); 945 if (asmInfo->isStackGrowthDirectionUp()) 946 return size; 947 else 948 return -size; 949 } 950 951 static unsigned getSizeForEncoding(MCStreamer &streamer, 952 unsigned symbolEncoding) { 953 MCContext &context = streamer.getContext(); 954 unsigned format = symbolEncoding & 0x0f; 955 switch (format) { 956 default: llvm_unreachable("Unknown Encoding"); 957 case dwarf::DW_EH_PE_absptr: 958 case dwarf::DW_EH_PE_signed: 959 return context.getAsmInfo()->getPointerSize(); 960 case dwarf::DW_EH_PE_udata2: 961 case dwarf::DW_EH_PE_sdata2: 962 return 2; 963 case dwarf::DW_EH_PE_udata4: 964 case dwarf::DW_EH_PE_sdata4: 965 return 4; 966 case dwarf::DW_EH_PE_udata8: 967 case dwarf::DW_EH_PE_sdata8: 968 return 8; 969 } 970 } 971 972 static void emitFDESymbol(MCObjectStreamer &streamer, const MCSymbol &symbol, 973 unsigned symbolEncoding, bool isEH) { 974 MCContext &context = streamer.getContext(); 975 const MCAsmInfo *asmInfo = context.getAsmInfo(); 976 const MCExpr *v = asmInfo->getExprForFDESymbol(&symbol, 977 symbolEncoding, 978 streamer); 979 unsigned size = getSizeForEncoding(streamer, symbolEncoding); 980 if (asmInfo->doDwarfFDESymbolsUseAbsDiff() && isEH) 981 emitAbsValue(streamer, v, size); 982 else 983 streamer.EmitValue(v, size); 984 } 985 986 static void EmitPersonality(MCStreamer &streamer, const MCSymbol &symbol, 987 unsigned symbolEncoding) { 988 MCContext &context = streamer.getContext(); 989 const MCAsmInfo *asmInfo = context.getAsmInfo(); 990 const MCExpr *v = asmInfo->getExprForPersonalitySymbol(&symbol, 991 symbolEncoding, 992 streamer); 993 unsigned size = getSizeForEncoding(streamer, symbolEncoding); 994 streamer.EmitValue(v, size); 995 } 996 997 namespace { 998 class FrameEmitterImpl { 999 int CFAOffset = 0; 1000 int InitialCFAOffset = 0; 1001 bool IsEH; 1002 MCObjectStreamer &Streamer; 1003 1004 public: 1005 FrameEmitterImpl(bool IsEH, MCObjectStreamer &Streamer) 1006 : IsEH(IsEH), Streamer(Streamer) {} 1007 1008 /// Emit the unwind information in a compact way. 1009 void EmitCompactUnwind(const MCDwarfFrameInfo &frame); 1010 1011 const MCSymbol &EmitCIE(const MCSymbol *personality, 1012 unsigned personalityEncoding, const MCSymbol *lsda, 1013 bool IsSignalFrame, unsigned lsdaEncoding, 1014 bool IsSimple); 1015 void EmitFDE(const MCSymbol &cieStart, const MCDwarfFrameInfo &frame, 1016 bool LastInSection, const MCSymbol &SectionStart); 1017 void EmitCFIInstructions(ArrayRef<MCCFIInstruction> Instrs, 1018 MCSymbol *BaseLabel); 1019 void EmitCFIInstruction(const MCCFIInstruction &Instr); 1020 }; 1021 1022 } // end anonymous namespace 1023 1024 static void emitEncodingByte(MCObjectStreamer &Streamer, unsigned Encoding) { 1025 Streamer.EmitIntValue(Encoding, 1); 1026 } 1027 1028 void FrameEmitterImpl::EmitCFIInstruction(const MCCFIInstruction &Instr) { 1029 int dataAlignmentFactor = getDataAlignmentFactor(Streamer); 1030 auto *MRI = Streamer.getContext().getRegisterInfo(); 1031 1032 switch (Instr.getOperation()) { 1033 case MCCFIInstruction::OpRegister: { 1034 unsigned Reg1 = Instr.getRegister(); 1035 unsigned Reg2 = Instr.getRegister2(); 1036 if (!IsEH) { 1037 Reg1 = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg1, true), false); 1038 Reg2 = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg2, true), false); 1039 } 1040 Streamer.EmitIntValue(dwarf::DW_CFA_register, 1); 1041 Streamer.EmitULEB128IntValue(Reg1); 1042 Streamer.EmitULEB128IntValue(Reg2); 1043 return; 1044 } 1045 case MCCFIInstruction::OpWindowSave: { 1046 Streamer.EmitIntValue(dwarf::DW_CFA_GNU_window_save, 1); 1047 return; 1048 } 1049 case MCCFIInstruction::OpUndefined: { 1050 unsigned Reg = Instr.getRegister(); 1051 Streamer.EmitIntValue(dwarf::DW_CFA_undefined, 1); 1052 Streamer.EmitULEB128IntValue(Reg); 1053 return; 1054 } 1055 case MCCFIInstruction::OpAdjustCfaOffset: 1056 case MCCFIInstruction::OpDefCfaOffset: { 1057 const bool IsRelative = 1058 Instr.getOperation() == MCCFIInstruction::OpAdjustCfaOffset; 1059 1060 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_offset, 1); 1061 1062 if (IsRelative) 1063 CFAOffset += Instr.getOffset(); 1064 else 1065 CFAOffset = -Instr.getOffset(); 1066 1067 Streamer.EmitULEB128IntValue(CFAOffset); 1068 1069 return; 1070 } 1071 case MCCFIInstruction::OpDefCfa: { 1072 unsigned Reg = Instr.getRegister(); 1073 if (!IsEH) 1074 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false); 1075 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa, 1); 1076 Streamer.EmitULEB128IntValue(Reg); 1077 CFAOffset = -Instr.getOffset(); 1078 Streamer.EmitULEB128IntValue(CFAOffset); 1079 1080 return; 1081 } 1082 1083 case MCCFIInstruction::OpDefCfaRegister: { 1084 unsigned Reg = Instr.getRegister(); 1085 if (!IsEH) 1086 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false); 1087 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_register, 1); 1088 Streamer.EmitULEB128IntValue(Reg); 1089 1090 return; 1091 } 1092 1093 case MCCFIInstruction::OpOffset: 1094 case MCCFIInstruction::OpRelOffset: { 1095 const bool IsRelative = 1096 Instr.getOperation() == MCCFIInstruction::OpRelOffset; 1097 1098 unsigned Reg = Instr.getRegister(); 1099 if (!IsEH) 1100 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false); 1101 1102 int Offset = Instr.getOffset(); 1103 if (IsRelative) 1104 Offset -= CFAOffset; 1105 Offset = Offset / dataAlignmentFactor; 1106 1107 if (Offset < 0) { 1108 Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended_sf, 1); 1109 Streamer.EmitULEB128IntValue(Reg); 1110 Streamer.EmitSLEB128IntValue(Offset); 1111 } else if (Reg < 64) { 1112 Streamer.EmitIntValue(dwarf::DW_CFA_offset + Reg, 1); 1113 Streamer.EmitULEB128IntValue(Offset); 1114 } else { 1115 Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended, 1); 1116 Streamer.EmitULEB128IntValue(Reg); 1117 Streamer.EmitULEB128IntValue(Offset); 1118 } 1119 return; 1120 } 1121 case MCCFIInstruction::OpRememberState: 1122 Streamer.EmitIntValue(dwarf::DW_CFA_remember_state, 1); 1123 return; 1124 case MCCFIInstruction::OpRestoreState: 1125 Streamer.EmitIntValue(dwarf::DW_CFA_restore_state, 1); 1126 return; 1127 case MCCFIInstruction::OpSameValue: { 1128 unsigned Reg = Instr.getRegister(); 1129 Streamer.EmitIntValue(dwarf::DW_CFA_same_value, 1); 1130 Streamer.EmitULEB128IntValue(Reg); 1131 return; 1132 } 1133 case MCCFIInstruction::OpRestore: { 1134 unsigned Reg = Instr.getRegister(); 1135 if (!IsEH) 1136 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false); 1137 Streamer.EmitIntValue(dwarf::DW_CFA_restore | Reg, 1); 1138 return; 1139 } 1140 case MCCFIInstruction::OpGnuArgsSize: { 1141 Streamer.EmitIntValue(dwarf::DW_CFA_GNU_args_size, 1); 1142 Streamer.EmitULEB128IntValue(Instr.getOffset()); 1143 return; 1144 } 1145 case MCCFIInstruction::OpEscape: 1146 Streamer.EmitBytes(Instr.getValues()); 1147 return; 1148 } 1149 llvm_unreachable("Unhandled case in switch"); 1150 } 1151 1152 /// Emit frame instructions to describe the layout of the frame. 1153 void FrameEmitterImpl::EmitCFIInstructions(ArrayRef<MCCFIInstruction> Instrs, 1154 MCSymbol *BaseLabel) { 1155 for (unsigned i = 0, N = Instrs.size(); i < N; ++i) { 1156 const MCCFIInstruction &Instr = Instrs[i]; 1157 MCSymbol *Label = Instr.getLabel(); 1158 // Throw out move if the label is invalid. 1159 if (Label && !Label->isDefined()) continue; // Not emitted, in dead code. 1160 1161 // Advance row if new location. 1162 if (BaseLabel && Label) { 1163 MCSymbol *ThisSym = Label; 1164 if (ThisSym != BaseLabel) { 1165 Streamer.EmitDwarfAdvanceFrameAddr(BaseLabel, ThisSym); 1166 BaseLabel = ThisSym; 1167 } 1168 } 1169 1170 EmitCFIInstruction(Instr); 1171 } 1172 } 1173 1174 /// Emit the unwind information in a compact way. 1175 void FrameEmitterImpl::EmitCompactUnwind(const MCDwarfFrameInfo &Frame) { 1176 MCContext &Context = Streamer.getContext(); 1177 const MCObjectFileInfo *MOFI = Context.getObjectFileInfo(); 1178 1179 // range-start range-length compact-unwind-enc personality-func lsda 1180 // _foo LfooEnd-_foo 0x00000023 0 0 1181 // _bar LbarEnd-_bar 0x00000025 __gxx_personality except_tab1 1182 // 1183 // .section __LD,__compact_unwind,regular,debug 1184 // 1185 // # compact unwind for _foo 1186 // .quad _foo 1187 // .set L1,LfooEnd-_foo 1188 // .long L1 1189 // .long 0x01010001 1190 // .quad 0 1191 // .quad 0 1192 // 1193 // # compact unwind for _bar 1194 // .quad _bar 1195 // .set L2,LbarEnd-_bar 1196 // .long L2 1197 // .long 0x01020011 1198 // .quad __gxx_personality 1199 // .quad except_tab1 1200 1201 uint32_t Encoding = Frame.CompactUnwindEncoding; 1202 if (!Encoding) return; 1203 bool DwarfEHFrameOnly = (Encoding == MOFI->getCompactUnwindDwarfEHFrameOnly()); 1204 1205 // The encoding needs to know we have an LSDA. 1206 if (!DwarfEHFrameOnly && Frame.Lsda) 1207 Encoding |= 0x40000000; 1208 1209 // Range Start 1210 unsigned FDEEncoding = MOFI->getFDEEncoding(); 1211 unsigned Size = getSizeForEncoding(Streamer, FDEEncoding); 1212 Streamer.EmitSymbolValue(Frame.Begin, Size); 1213 1214 // Range Length 1215 const MCExpr *Range = MakeStartMinusEndExpr(Streamer, *Frame.Begin, 1216 *Frame.End, 0); 1217 emitAbsValue(Streamer, Range, 4); 1218 1219 // Compact Encoding 1220 Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_udata4); 1221 Streamer.EmitIntValue(Encoding, Size); 1222 1223 // Personality Function 1224 Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_absptr); 1225 if (!DwarfEHFrameOnly && Frame.Personality) 1226 Streamer.EmitSymbolValue(Frame.Personality, Size); 1227 else 1228 Streamer.EmitIntValue(0, Size); // No personality fn 1229 1230 // LSDA 1231 Size = getSizeForEncoding(Streamer, Frame.LsdaEncoding); 1232 if (!DwarfEHFrameOnly && Frame.Lsda) 1233 Streamer.EmitSymbolValue(Frame.Lsda, Size); 1234 else 1235 Streamer.EmitIntValue(0, Size); // No LSDA 1236 } 1237 1238 static unsigned getCIEVersion(bool IsEH, unsigned DwarfVersion) { 1239 if (IsEH) 1240 return 1; 1241 switch (DwarfVersion) { 1242 case 2: 1243 return 1; 1244 case 3: 1245 return 3; 1246 case 4: 1247 return 4; 1248 } 1249 llvm_unreachable("Unknown version"); 1250 } 1251 1252 const MCSymbol &FrameEmitterImpl::EmitCIE(const MCSymbol *personality, 1253 unsigned personalityEncoding, 1254 const MCSymbol *lsda, 1255 bool IsSignalFrame, 1256 unsigned lsdaEncoding, 1257 bool IsSimple) { 1258 MCContext &context = Streamer.getContext(); 1259 const MCRegisterInfo *MRI = context.getRegisterInfo(); 1260 const MCObjectFileInfo *MOFI = context.getObjectFileInfo(); 1261 1262 MCSymbol *sectionStart = context.createTempSymbol(); 1263 Streamer.EmitLabel(sectionStart); 1264 1265 MCSymbol *sectionEnd = context.createTempSymbol(); 1266 1267 // Length 1268 const MCExpr *Length = 1269 MakeStartMinusEndExpr(Streamer, *sectionStart, *sectionEnd, 4); 1270 emitAbsValue(Streamer, Length, 4); 1271 1272 // CIE ID 1273 unsigned CIE_ID = IsEH ? 0 : -1; 1274 Streamer.EmitIntValue(CIE_ID, 4); 1275 1276 // Version 1277 uint8_t CIEVersion = getCIEVersion(IsEH, context.getDwarfVersion()); 1278 Streamer.EmitIntValue(CIEVersion, 1); 1279 1280 // Augmentation String 1281 SmallString<8> Augmentation; 1282 if (IsEH) { 1283 Augmentation += "z"; 1284 if (personality) 1285 Augmentation += "P"; 1286 if (lsda) 1287 Augmentation += "L"; 1288 Augmentation += "R"; 1289 if (IsSignalFrame) 1290 Augmentation += "S"; 1291 Streamer.EmitBytes(Augmentation); 1292 } 1293 Streamer.EmitIntValue(0, 1); 1294 1295 if (CIEVersion >= 4) { 1296 // Address Size 1297 Streamer.EmitIntValue(context.getAsmInfo()->getPointerSize(), 1); 1298 1299 // Segment Descriptor Size 1300 Streamer.EmitIntValue(0, 1); 1301 } 1302 1303 // Code Alignment Factor 1304 Streamer.EmitULEB128IntValue(context.getAsmInfo()->getMinInstAlignment()); 1305 1306 // Data Alignment Factor 1307 Streamer.EmitSLEB128IntValue(getDataAlignmentFactor(Streamer)); 1308 1309 // Return Address Register 1310 if (CIEVersion == 1) { 1311 assert(MRI->getRARegister() <= 255 && 1312 "DWARF 2 encodes return_address_register in one byte"); 1313 Streamer.EmitIntValue(MRI->getDwarfRegNum(MRI->getRARegister(), IsEH), 1); 1314 } else { 1315 Streamer.EmitULEB128IntValue( 1316 MRI->getDwarfRegNum(MRI->getRARegister(), IsEH)); 1317 } 1318 1319 // Augmentation Data Length (optional) 1320 1321 unsigned augmentationLength = 0; 1322 if (IsEH) { 1323 if (personality) { 1324 // Personality Encoding 1325 augmentationLength += 1; 1326 // Personality 1327 augmentationLength += getSizeForEncoding(Streamer, personalityEncoding); 1328 } 1329 if (lsda) 1330 augmentationLength += 1; 1331 // Encoding of the FDE pointers 1332 augmentationLength += 1; 1333 1334 Streamer.EmitULEB128IntValue(augmentationLength); 1335 1336 // Augmentation Data (optional) 1337 if (personality) { 1338 // Personality Encoding 1339 emitEncodingByte(Streamer, personalityEncoding); 1340 // Personality 1341 EmitPersonality(Streamer, *personality, personalityEncoding); 1342 } 1343 1344 if (lsda) 1345 emitEncodingByte(Streamer, lsdaEncoding); 1346 1347 // Encoding of the FDE pointers 1348 emitEncodingByte(Streamer, MOFI->getFDEEncoding()); 1349 } 1350 1351 // Initial Instructions 1352 1353 const MCAsmInfo *MAI = context.getAsmInfo(); 1354 if (!IsSimple) { 1355 const std::vector<MCCFIInstruction> &Instructions = 1356 MAI->getInitialFrameState(); 1357 EmitCFIInstructions(Instructions, nullptr); 1358 } 1359 1360 InitialCFAOffset = CFAOffset; 1361 1362 // Padding 1363 Streamer.EmitValueToAlignment(IsEH ? 4 : MAI->getPointerSize()); 1364 1365 Streamer.EmitLabel(sectionEnd); 1366 return *sectionStart; 1367 } 1368 1369 void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart, 1370 const MCDwarfFrameInfo &frame, 1371 bool LastInSection, 1372 const MCSymbol &SectionStart) { 1373 MCContext &context = Streamer.getContext(); 1374 MCSymbol *fdeStart = context.createTempSymbol(); 1375 MCSymbol *fdeEnd = context.createTempSymbol(); 1376 const MCObjectFileInfo *MOFI = context.getObjectFileInfo(); 1377 1378 CFAOffset = InitialCFAOffset; 1379 1380 // Length 1381 const MCExpr *Length = MakeStartMinusEndExpr(Streamer, *fdeStart, *fdeEnd, 0); 1382 emitAbsValue(Streamer, Length, 4); 1383 1384 Streamer.EmitLabel(fdeStart); 1385 1386 // CIE Pointer 1387 const MCAsmInfo *asmInfo = context.getAsmInfo(); 1388 if (IsEH) { 1389 const MCExpr *offset = 1390 MakeStartMinusEndExpr(Streamer, cieStart, *fdeStart, 0); 1391 emitAbsValue(Streamer, offset, 4); 1392 } else if (!asmInfo->doesDwarfUseRelocationsAcrossSections()) { 1393 const MCExpr *offset = 1394 MakeStartMinusEndExpr(Streamer, SectionStart, cieStart, 0); 1395 emitAbsValue(Streamer, offset, 4); 1396 } else { 1397 Streamer.EmitSymbolValue(&cieStart, 4); 1398 } 1399 1400 // PC Begin 1401 unsigned PCEncoding = 1402 IsEH ? MOFI->getFDEEncoding() : (unsigned)dwarf::DW_EH_PE_absptr; 1403 unsigned PCSize = getSizeForEncoding(Streamer, PCEncoding); 1404 emitFDESymbol(Streamer, *frame.Begin, PCEncoding, IsEH); 1405 1406 // PC Range 1407 const MCExpr *Range = 1408 MakeStartMinusEndExpr(Streamer, *frame.Begin, *frame.End, 0); 1409 emitAbsValue(Streamer, Range, PCSize); 1410 1411 if (IsEH) { 1412 // Augmentation Data Length 1413 unsigned augmentationLength = 0; 1414 1415 if (frame.Lsda) 1416 augmentationLength += getSizeForEncoding(Streamer, frame.LsdaEncoding); 1417 1418 Streamer.EmitULEB128IntValue(augmentationLength); 1419 1420 // Augmentation Data 1421 if (frame.Lsda) 1422 emitFDESymbol(Streamer, *frame.Lsda, frame.LsdaEncoding, true); 1423 } 1424 1425 // Call Frame Instructions 1426 EmitCFIInstructions(frame.Instructions, frame.Begin); 1427 1428 // Padding 1429 // The size of a .eh_frame section has to be a multiple of the alignment 1430 // since a null CIE is interpreted as the end. Old systems overaligned 1431 // .eh_frame, so we do too and account for it in the last FDE. 1432 unsigned Align = LastInSection ? asmInfo->getPointerSize() : PCSize; 1433 Streamer.EmitValueToAlignment(Align); 1434 1435 Streamer.EmitLabel(fdeEnd); 1436 } 1437 1438 namespace { 1439 struct CIEKey { 1440 static const CIEKey getEmptyKey() { 1441 return CIEKey(nullptr, 0, -1, false, false); 1442 } 1443 static const CIEKey getTombstoneKey() { 1444 return CIEKey(nullptr, -1, 0, false, false); 1445 } 1446 1447 CIEKey(const MCSymbol *Personality, unsigned PersonalityEncoding, 1448 unsigned LsdaEncoding, bool IsSignalFrame, bool IsSimple) 1449 : Personality(Personality), PersonalityEncoding(PersonalityEncoding), 1450 LsdaEncoding(LsdaEncoding), IsSignalFrame(IsSignalFrame), 1451 IsSimple(IsSimple) {} 1452 const MCSymbol *Personality; 1453 unsigned PersonalityEncoding; 1454 unsigned LsdaEncoding; 1455 bool IsSignalFrame; 1456 bool IsSimple; 1457 }; 1458 } // anonymous namespace 1459 1460 namespace llvm { 1461 template <> struct DenseMapInfo<CIEKey> { 1462 static CIEKey getEmptyKey() { return CIEKey::getEmptyKey(); } 1463 static CIEKey getTombstoneKey() { return CIEKey::getTombstoneKey(); } 1464 static unsigned getHashValue(const CIEKey &Key) { 1465 return static_cast<unsigned>( 1466 hash_combine(Key.Personality, Key.PersonalityEncoding, Key.LsdaEncoding, 1467 Key.IsSignalFrame, Key.IsSimple)); 1468 } 1469 static bool isEqual(const CIEKey &LHS, const CIEKey &RHS) { 1470 return LHS.Personality == RHS.Personality && 1471 LHS.PersonalityEncoding == RHS.PersonalityEncoding && 1472 LHS.LsdaEncoding == RHS.LsdaEncoding && 1473 LHS.IsSignalFrame == RHS.IsSignalFrame && 1474 LHS.IsSimple == RHS.IsSimple; 1475 } 1476 }; 1477 } // namespace llvm 1478 1479 void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB, 1480 bool IsEH) { 1481 Streamer.generateCompactUnwindEncodings(MAB); 1482 1483 MCContext &Context = Streamer.getContext(); 1484 const MCObjectFileInfo *MOFI = Context.getObjectFileInfo(); 1485 FrameEmitterImpl Emitter(IsEH, Streamer); 1486 ArrayRef<MCDwarfFrameInfo> FrameArray = Streamer.getDwarfFrameInfos(); 1487 1488 // Emit the compact unwind info if available. 1489 bool NeedsEHFrameSection = !MOFI->getSupportsCompactUnwindWithoutEHFrame(); 1490 if (IsEH && MOFI->getCompactUnwindSection()) { 1491 bool SectionEmitted = false; 1492 for (unsigned i = 0, n = FrameArray.size(); i < n; ++i) { 1493 const MCDwarfFrameInfo &Frame = FrameArray[i]; 1494 if (Frame.CompactUnwindEncoding == 0) continue; 1495 if (!SectionEmitted) { 1496 Streamer.SwitchSection(MOFI->getCompactUnwindSection()); 1497 Streamer.EmitValueToAlignment(Context.getAsmInfo()->getPointerSize()); 1498 SectionEmitted = true; 1499 } 1500 NeedsEHFrameSection |= 1501 Frame.CompactUnwindEncoding == 1502 MOFI->getCompactUnwindDwarfEHFrameOnly(); 1503 Emitter.EmitCompactUnwind(Frame); 1504 } 1505 } 1506 1507 if (!NeedsEHFrameSection) return; 1508 1509 MCSection &Section = 1510 IsEH ? *const_cast<MCObjectFileInfo *>(MOFI)->getEHFrameSection() 1511 : *MOFI->getDwarfFrameSection(); 1512 1513 Streamer.SwitchSection(&Section); 1514 MCSymbol *SectionStart = Context.createTempSymbol(); 1515 Streamer.EmitLabel(SectionStart); 1516 1517 DenseMap<CIEKey, const MCSymbol *> CIEStarts; 1518 1519 const MCSymbol *DummyDebugKey = nullptr; 1520 bool CanOmitDwarf = MOFI->getOmitDwarfIfHaveCompactUnwind(); 1521 for (auto I = FrameArray.begin(), E = FrameArray.end(); I != E;) { 1522 const MCDwarfFrameInfo &Frame = *I; 1523 ++I; 1524 if (CanOmitDwarf && Frame.CompactUnwindEncoding != 1525 MOFI->getCompactUnwindDwarfEHFrameOnly()) 1526 // Don't generate an EH frame if we don't need one. I.e., it's taken care 1527 // of by the compact unwind encoding. 1528 continue; 1529 1530 CIEKey Key(Frame.Personality, Frame.PersonalityEncoding, 1531 Frame.LsdaEncoding, Frame.IsSignalFrame, Frame.IsSimple); 1532 const MCSymbol *&CIEStart = IsEH ? CIEStarts[Key] : DummyDebugKey; 1533 if (!CIEStart) 1534 CIEStart = &Emitter.EmitCIE(Frame.Personality, Frame.PersonalityEncoding, 1535 Frame.Lsda, Frame.IsSignalFrame, 1536 Frame.LsdaEncoding, Frame.IsSimple); 1537 1538 Emitter.EmitFDE(*CIEStart, Frame, I == E, *SectionStart); 1539 } 1540 } 1541 1542 void MCDwarfFrameEmitter::EmitAdvanceLoc(MCObjectStreamer &Streamer, 1543 uint64_t AddrDelta) { 1544 MCContext &Context = Streamer.getContext(); 1545 SmallString<256> Tmp; 1546 raw_svector_ostream OS(Tmp); 1547 MCDwarfFrameEmitter::EncodeAdvanceLoc(Context, AddrDelta, OS); 1548 Streamer.EmitBytes(OS.str()); 1549 } 1550 1551 void MCDwarfFrameEmitter::EncodeAdvanceLoc(MCContext &Context, 1552 uint64_t AddrDelta, 1553 raw_ostream &OS) { 1554 // Scale the address delta by the minimum instruction length. 1555 AddrDelta = ScaleAddrDelta(Context, AddrDelta); 1556 1557 if (AddrDelta == 0) { 1558 } else if (isUIntN(6, AddrDelta)) { 1559 uint8_t Opcode = dwarf::DW_CFA_advance_loc | AddrDelta; 1560 OS << Opcode; 1561 } else if (isUInt<8>(AddrDelta)) { 1562 OS << uint8_t(dwarf::DW_CFA_advance_loc1); 1563 OS << uint8_t(AddrDelta); 1564 } else if (isUInt<16>(AddrDelta)) { 1565 OS << uint8_t(dwarf::DW_CFA_advance_loc2); 1566 if (Context.getAsmInfo()->isLittleEndian()) 1567 support::endian::Writer<support::little>(OS).write<uint16_t>(AddrDelta); 1568 else 1569 support::endian::Writer<support::big>(OS).write<uint16_t>(AddrDelta); 1570 } else { 1571 assert(isUInt<32>(AddrDelta)); 1572 OS << uint8_t(dwarf::DW_CFA_advance_loc4); 1573 if (Context.getAsmInfo()->isLittleEndian()) 1574 support::endian::Writer<support::little>(OS).write<uint32_t>(AddrDelta); 1575 else 1576 support::endian::Writer<support::big>(OS).write<uint32_t>(AddrDelta); 1577 } 1578 } 1579