1//===--- lib/CodeGen/DIE.cpp - DWARF Info Entries -------------------------===// 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// Data structures for DWARF info entries. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/CodeGen/DIE.h" 15#include "DwarfCompileUnit.h" 16#include "DwarfDebug.h" 17#include "DwarfUnit.h" 18#include "llvm/ADT/Twine.h" 19#include "llvm/CodeGen/AsmPrinter.h" 20#include "llvm/IR/DataLayout.h" 21#include "llvm/MC/MCAsmInfo.h" 22#include "llvm/MC/MCContext.h" 23#include "llvm/MC/MCStreamer.h" 24#include "llvm/MC/MCSymbol.h" 25#include "llvm/Support/Debug.h" 26#include "llvm/Support/ErrorHandling.h" 27#include "llvm/Support/Format.h" 28#include "llvm/Support/FormattedStream.h" 29#include "llvm/Support/LEB128.h" 30#include "llvm/Support/MD5.h" 31#include "llvm/Support/raw_ostream.h" 32using namespace llvm; 33 34//===----------------------------------------------------------------------===// 35// EmittingAsmStreamer Implementation 36//===----------------------------------------------------------------------===// 37unsigned EmittingAsmStreamer::emitULEB128(uint64_t Value, const char *Desc, 38 unsigned PadTo) { 39 AP->EmitULEB128(Value, Desc, PadTo); 40 return 0; 41} 42 43unsigned EmittingAsmStreamer::emitInt8(unsigned char Value) { 44 AP->EmitInt8(Value); 45 return 0; 46} 47 48unsigned EmittingAsmStreamer::emitBytes(StringRef Data) { 49 AP->OutStreamer->EmitBytes(Data); 50 return 0; 51} 52 53//===----------------------------------------------------------------------===// 54// SizeReporterAsmStreamer Implementation 55//===----------------------------------------------------------------------===// 56unsigned SizeReporterAsmStreamer::emitULEB128(uint64_t Value, const char *Desc, 57 unsigned PadTo) { 58 return getULEB128Size(Value); 59} 60 61unsigned SizeReporterAsmStreamer::emitInt8(unsigned char Value) { return 1; } 62 63unsigned SizeReporterAsmStreamer::emitBytes(StringRef Data) { 64 return Data.size(); 65} 66 67//===----------------------------------------------------------------------===// 68// DIEAbbrevData Implementation 69//===----------------------------------------------------------------------===// 70 71/// Profile - Used to gather unique data for the abbreviation folding set. 72/// 73void DIEAbbrevData::Profile(FoldingSetNodeID &ID) const { 74 // Explicitly cast to an integer type for which FoldingSetNodeID has 75 // overloads. Otherwise MSVC 2010 thinks this call is ambiguous. 76 ID.AddInteger(unsigned(Attribute)); 77 ID.AddInteger(unsigned(Form)); 78} 79 80//===----------------------------------------------------------------------===// 81// DIEAbbrev Implementation 82//===----------------------------------------------------------------------===// 83 84/// Profile - Used to gather unique data for the abbreviation folding set. 85/// 86void DIEAbbrev::Profile(FoldingSetNodeID &ID) const { 87 ID.AddInteger(unsigned(Tag)); 88 ID.AddInteger(unsigned(Children)); 89 90 // For each attribute description. 91 for (unsigned i = 0, N = Data.size(); i < N; ++i) 92 Data[i].Profile(ID); 93} 94 95/// Emit - Print the abbreviation using the specified asm printer. 96/// 97void DIEAbbrev::Emit(const AsmPrinter *AP) const { 98 // Emit its Dwarf tag type. 99 AP->EmitULEB128(Tag, dwarf::TagString(Tag)); 100 101 // Emit whether it has children DIEs. 102 AP->EmitULEB128((unsigned)Children, dwarf::ChildrenString(Children)); 103 104 // For each attribute description. 105 for (unsigned i = 0, N = Data.size(); i < N; ++i) { 106 const DIEAbbrevData &AttrData = Data[i]; 107 108 // Emit attribute type. 109 AP->EmitULEB128(AttrData.getAttribute(), 110 dwarf::AttributeString(AttrData.getAttribute())); 111 112 // Emit form type. 113 AP->EmitULEB128(AttrData.getForm(), 114 dwarf::FormEncodingString(AttrData.getForm())); 115 } 116 117 // Mark end of abbreviation. 118 AP->EmitULEB128(0, "EOM(1)"); 119 AP->EmitULEB128(0, "EOM(2)"); 120} 121 122LLVM_DUMP_METHOD 123void DIEAbbrev::print(raw_ostream &O) { 124 O << "Abbreviation @" 125 << format("0x%lx", (long)(intptr_t)this) 126 << " " 127 << dwarf::TagString(Tag) 128 << " " 129 << dwarf::ChildrenString(Children) 130 << '\n'; 131 132 for (unsigned i = 0, N = Data.size(); i < N; ++i) { 133 O << " " 134 << dwarf::AttributeString(Data[i].getAttribute()) 135 << " " 136 << dwarf::FormEncodingString(Data[i].getForm()) 137 << '\n'; 138 } 139} 140 141LLVM_DUMP_METHOD 142void DIEAbbrev::dump() { print(dbgs()); } 143 144DIEAbbrev DIE::generateAbbrev() const { 145 DIEAbbrev Abbrev(Tag, hasChildren()); 146 for (const DIEValue &V : values()) 147 Abbrev.AddAttribute(V.getAttribute(), V.getForm()); 148 return Abbrev; 149} 150 151/// Climb up the parent chain to get the unit DIE to which this DIE 152/// belongs. 153const DIE *DIE::getUnit() const { 154 const DIE *Cu = getUnitOrNull(); 155 assert(Cu && "We should not have orphaned DIEs."); 156 return Cu; 157} 158 159/// Climb up the parent chain to get the unit DIE this DIE belongs 160/// to. Return NULL if DIE is not added to an owner yet. 161const DIE *DIE::getUnitOrNull() const { 162 const DIE *p = this; 163 while (p) { 164 if (p->getTag() == dwarf::DW_TAG_compile_unit || 165 p->getTag() == dwarf::DW_TAG_type_unit) 166 return p; 167 p = p->getParent(); 168 } 169 return nullptr; 170} 171 172DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const { 173 // Iterate through all the attributes until we find the one we're 174 // looking for, if we can't find it return NULL. 175 for (const auto &V : values()) 176 if (V.getAttribute() == Attribute) 177 return V; 178 return DIEValue(); 179} 180 181LLVM_DUMP_METHOD 182static void printValues(raw_ostream &O, const DIEValueList &Values, 183 StringRef Type, unsigned Size, unsigned IndentCount) { 184 O << Type << ": Size: " << Size << "\n"; 185 186 unsigned I = 0; 187 const std::string Indent(IndentCount, ' '); 188 for (const auto &V : Values.values()) { 189 O << Indent; 190 O << "Blk[" << I++ << "]"; 191 O << " " << dwarf::FormEncodingString(V.getForm()) << " "; 192 V.print(O); 193 O << "\n"; 194 } 195} 196 197LLVM_DUMP_METHOD 198void DIE::print(raw_ostream &O, unsigned IndentCount) const { 199 const std::string Indent(IndentCount, ' '); 200 O << Indent << "Die: " << format("0x%lx", (long)(intptr_t) this) 201 << ", Offset: " << Offset << ", Size: " << Size << "\n"; 202 203 O << Indent << dwarf::TagString(getTag()) << " " 204 << dwarf::ChildrenString(hasChildren()) << "\n"; 205 206 IndentCount += 2; 207 for (const auto &V : values()) { 208 O << Indent; 209 O << dwarf::AttributeString(V.getAttribute()); 210 O << " " << dwarf::FormEncodingString(V.getForm()) << " "; 211 V.print(O); 212 O << "\n"; 213 } 214 IndentCount -= 2; 215 216 for (const auto &Child : children()) 217 Child.print(O, IndentCount + 4); 218 219 O << "\n"; 220} 221 222LLVM_DUMP_METHOD 223void DIE::dump() { 224 print(dbgs()); 225} 226 227void DIEValue::EmitValue(const AsmPrinter *AP) const { 228 switch (Ty) { 229 case isNone: 230 llvm_unreachable("Expected valid DIEValue"); 231#define HANDLE_DIEVALUE(T) \ 232 case is##T: \ 233 getDIE##T().EmitValue(AP, Form); \ 234 break; 235#include "llvm/CodeGen/DIEValue.def" 236 } 237} 238 239unsigned DIEValue::SizeOf(const AsmPrinter *AP) const { 240 switch (Ty) { 241 case isNone: 242 llvm_unreachable("Expected valid DIEValue"); 243#define HANDLE_DIEVALUE(T) \ 244 case is##T: \ 245 return getDIE##T().SizeOf(AP, Form); 246#include "llvm/CodeGen/DIEValue.def" 247 } 248 llvm_unreachable("Unknown DIE kind"); 249} 250 251LLVM_DUMP_METHOD 252void DIEValue::print(raw_ostream &O) const { 253 switch (Ty) { 254 case isNone: 255 llvm_unreachable("Expected valid DIEValue"); 256#define HANDLE_DIEVALUE(T) \ 257 case is##T: \ 258 getDIE##T().print(O); \ 259 break; 260#include "llvm/CodeGen/DIEValue.def" 261 } 262} 263 264LLVM_DUMP_METHOD 265void DIEValue::dump() const { 266 print(dbgs()); 267} 268 269//===----------------------------------------------------------------------===// 270// DIEInteger Implementation 271//===----------------------------------------------------------------------===// 272 273/// EmitValue - Emit integer of appropriate size. 274/// 275void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const { 276 unsigned Size = ~0U; 277 switch (Form) { 278 case dwarf::DW_FORM_flag_present: 279 // Emit something to keep the lines and comments in sync. 280 // FIXME: Is there a better way to do this? 281 Asm->OutStreamer->AddBlankLine(); 282 return; 283 case dwarf::DW_FORM_flag: // Fall thru 284 case dwarf::DW_FORM_ref1: // Fall thru 285 case dwarf::DW_FORM_data1: Size = 1; break; 286 case dwarf::DW_FORM_ref2: // Fall thru 287 case dwarf::DW_FORM_data2: Size = 2; break; 288 case dwarf::DW_FORM_sec_offset: // Fall thru 289 case dwarf::DW_FORM_strp: // Fall thru 290 case dwarf::DW_FORM_ref4: // Fall thru 291 case dwarf::DW_FORM_data4: Size = 4; break; 292 case dwarf::DW_FORM_ref8: // Fall thru 293 case dwarf::DW_FORM_ref_sig8: // Fall thru 294 case dwarf::DW_FORM_data8: Size = 8; break; 295 case dwarf::DW_FORM_GNU_str_index: Asm->EmitULEB128(Integer); return; 296 case dwarf::DW_FORM_GNU_addr_index: Asm->EmitULEB128(Integer); return; 297 case dwarf::DW_FORM_udata: Asm->EmitULEB128(Integer); return; 298 case dwarf::DW_FORM_sdata: Asm->EmitSLEB128(Integer); return; 299 case dwarf::DW_FORM_addr: 300 Size = Asm->getPointerSize(); 301 break; 302 case dwarf::DW_FORM_ref_addr: 303 Size = SizeOf(Asm, dwarf::DW_FORM_ref_addr); 304 break; 305 default: llvm_unreachable("DIE Value form not supported yet"); 306 } 307 Asm->OutStreamer->EmitIntValue(Integer, Size); 308} 309 310/// SizeOf - Determine size of integer value in bytes. 311/// 312unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 313 switch (Form) { 314 case dwarf::DW_FORM_flag_present: return 0; 315 case dwarf::DW_FORM_flag: // Fall thru 316 case dwarf::DW_FORM_ref1: // Fall thru 317 case dwarf::DW_FORM_data1: return sizeof(int8_t); 318 case dwarf::DW_FORM_ref2: // Fall thru 319 case dwarf::DW_FORM_data2: return sizeof(int16_t); 320 case dwarf::DW_FORM_sec_offset: // Fall thru 321 case dwarf::DW_FORM_strp: // Fall thru 322 case dwarf::DW_FORM_ref4: // Fall thru 323 case dwarf::DW_FORM_data4: return sizeof(int32_t); 324 case dwarf::DW_FORM_ref8: // Fall thru 325 case dwarf::DW_FORM_ref_sig8: // Fall thru 326 case dwarf::DW_FORM_data8: return sizeof(int64_t); 327 case dwarf::DW_FORM_GNU_str_index: return getULEB128Size(Integer); 328 case dwarf::DW_FORM_GNU_addr_index: return getULEB128Size(Integer); 329 case dwarf::DW_FORM_udata: return getULEB128Size(Integer); 330 case dwarf::DW_FORM_sdata: return getSLEB128Size(Integer); 331 case dwarf::DW_FORM_addr: 332 return AP->getPointerSize(); 333 case dwarf::DW_FORM_ref_addr: 334 if (AP->OutStreamer->getContext().getDwarfVersion() == 2) 335 return AP->getPointerSize(); 336 return sizeof(int32_t); 337 default: llvm_unreachable("DIE Value form not supported yet"); 338 } 339} 340 341LLVM_DUMP_METHOD 342void DIEInteger::print(raw_ostream &O) const { 343 O << "Int: " << (int64_t)Integer << " 0x"; 344 O.write_hex(Integer); 345} 346 347//===----------------------------------------------------------------------===// 348// DIEExpr Implementation 349//===----------------------------------------------------------------------===// 350 351/// EmitValue - Emit expression value. 352/// 353void DIEExpr::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { 354 AP->OutStreamer->EmitValue(Expr, SizeOf(AP, Form)); 355} 356 357/// SizeOf - Determine size of expression value in bytes. 358/// 359unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 360 if (Form == dwarf::DW_FORM_data4) return 4; 361 if (Form == dwarf::DW_FORM_sec_offset) return 4; 362 if (Form == dwarf::DW_FORM_strp) return 4; 363 return AP->getPointerSize(); 364} 365 366LLVM_DUMP_METHOD 367void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; } 368 369//===----------------------------------------------------------------------===// 370// DIELabel Implementation 371//===----------------------------------------------------------------------===// 372 373/// EmitValue - Emit label value. 374/// 375void DIELabel::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { 376 AP->EmitLabelReference(Label, SizeOf(AP, Form), 377 Form == dwarf::DW_FORM_strp || 378 Form == dwarf::DW_FORM_sec_offset || 379 Form == dwarf::DW_FORM_ref_addr); 380} 381 382/// SizeOf - Determine size of label value in bytes. 383/// 384unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 385 if (Form == dwarf::DW_FORM_data4) return 4; 386 if (Form == dwarf::DW_FORM_sec_offset) return 4; 387 if (Form == dwarf::DW_FORM_strp) return 4; 388 return AP->getPointerSize(); 389} 390 391LLVM_DUMP_METHOD 392void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); } 393 394//===----------------------------------------------------------------------===// 395// DIEDelta Implementation 396//===----------------------------------------------------------------------===// 397 398/// EmitValue - Emit delta value. 399/// 400void DIEDelta::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { 401 AP->EmitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form)); 402} 403 404/// SizeOf - Determine size of delta value in bytes. 405/// 406unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 407 if (Form == dwarf::DW_FORM_data4) return 4; 408 if (Form == dwarf::DW_FORM_sec_offset) return 4; 409 if (Form == dwarf::DW_FORM_strp) return 4; 410 return AP->getPointerSize(); 411} 412 413LLVM_DUMP_METHOD 414void DIEDelta::print(raw_ostream &O) const { 415 O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName(); 416} 417 418//===----------------------------------------------------------------------===// 419// DIEString Implementation 420//===----------------------------------------------------------------------===// 421 422/// EmitValue - Emit string value. 423/// 424void DIEString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { 425 assert( 426 (Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_GNU_str_index) && 427 "Expected valid string form"); 428 429 // Index of string in symbol table. 430 if (Form == dwarf::DW_FORM_GNU_str_index) { 431 DIEInteger(S.getIndex()).EmitValue(AP, Form); 432 return; 433 } 434 435 // Relocatable symbol. 436 assert(Form == dwarf::DW_FORM_strp); 437 if (AP->MAI->doesDwarfUseRelocationsAcrossSections()) { 438 DIELabel(S.getSymbol()).EmitValue(AP, Form); 439 return; 440 } 441 442 // Offset into symbol table. 443 DIEInteger(S.getOffset()).EmitValue(AP, Form); 444} 445 446/// SizeOf - Determine size of delta value in bytes. 447/// 448unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 449 assert( 450 (Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_GNU_str_index) && 451 "Expected valid string form"); 452 453 // Index of string in symbol table. 454 if (Form == dwarf::DW_FORM_GNU_str_index) 455 return DIEInteger(S.getIndex()).SizeOf(AP, Form); 456 457 // Relocatable symbol. 458 if (AP->MAI->doesDwarfUseRelocationsAcrossSections()) 459 return DIELabel(S.getSymbol()).SizeOf(AP, Form); 460 461 // Offset into symbol table. 462 return DIEInteger(S.getOffset()).SizeOf(AP, Form); 463} 464 465LLVM_DUMP_METHOD 466void DIEString::print(raw_ostream &O) const { 467 O << "String: " << S.getString(); 468} 469 470//===----------------------------------------------------------------------===// 471// DIEEntry Implementation 472//===----------------------------------------------------------------------===// 473 474/// EmitValue - Emit debug information entry offset. 475/// 476void DIEEntry::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { 477 478 if (Form == dwarf::DW_FORM_ref_addr) { 479 const DwarfDebug *DD = AP->getDwarfDebug(); 480 unsigned Addr = Entry->getOffset(); 481 assert(!DD->useSplitDwarf() && "TODO: dwo files can't have relocations."); 482 // For DW_FORM_ref_addr, output the offset from beginning of debug info 483 // section. Entry->getOffset() returns the offset from start of the 484 // compile unit. 485 DwarfCompileUnit *CU = DD->lookupUnit(Entry->getUnit()); 486 assert(CU && "CUDie should belong to a CU."); 487 Addr += CU->getDebugInfoOffset(); 488 if (AP->MAI->doesDwarfUseRelocationsAcrossSections()) 489 AP->EmitLabelPlusOffset(CU->getSectionSym(), Addr, 490 DIEEntry::getRefAddrSize(AP)); 491 else 492 AP->OutStreamer->EmitIntValue(Addr, DIEEntry::getRefAddrSize(AP)); 493 } else 494 AP->EmitInt32(Entry->getOffset()); 495} 496 497unsigned DIEEntry::getRefAddrSize(const AsmPrinter *AP) { 498 // DWARF4: References that use the attribute form DW_FORM_ref_addr are 499 // specified to be four bytes in the DWARF 32-bit format and eight bytes 500 // in the DWARF 64-bit format, while DWARF Version 2 specifies that such 501 // references have the same size as an address on the target system. 502 const DwarfDebug *DD = AP->getDwarfDebug(); 503 assert(DD && "Expected Dwarf Debug info to be available"); 504 if (DD->getDwarfVersion() == 2) 505 return AP->getPointerSize(); 506 return sizeof(int32_t); 507} 508 509LLVM_DUMP_METHOD 510void DIEEntry::print(raw_ostream &O) const { 511 O << format("Die: 0x%lx", (long)(intptr_t)&Entry); 512} 513 514//===----------------------------------------------------------------------===// 515// DIETypeSignature Implementation 516//===----------------------------------------------------------------------===// 517void DIETypeSignature::EmitValue(const AsmPrinter *Asm, 518 dwarf::Form Form) const { 519 assert(Form == dwarf::DW_FORM_ref_sig8); 520 Asm->OutStreamer->EmitIntValue(Unit->getTypeSignature(), 8); 521} 522 523LLVM_DUMP_METHOD 524void DIETypeSignature::print(raw_ostream &O) const { 525 O << format("Type Unit: 0x%lx", Unit->getTypeSignature()); 526} 527 528//===----------------------------------------------------------------------===// 529// DIELoc Implementation 530//===----------------------------------------------------------------------===// 531 532/// ComputeSize - calculate the size of the location expression. 533/// 534unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const { 535 if (!Size) { 536 for (const auto &V : values()) 537 Size += V.SizeOf(AP); 538 } 539 540 return Size; 541} 542 543/// EmitValue - Emit location data. 544/// 545void DIELoc::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const { 546 switch (Form) { 547 default: llvm_unreachable("Improper form for block"); 548 case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break; 549 case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break; 550 case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break; 551 case dwarf::DW_FORM_block: 552 case dwarf::DW_FORM_exprloc: 553 Asm->EmitULEB128(Size); break; 554 } 555 556 for (const auto &V : values()) 557 V.EmitValue(Asm); 558} 559 560/// SizeOf - Determine size of location data in bytes. 561/// 562unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 563 switch (Form) { 564 case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); 565 case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); 566 case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); 567 case dwarf::DW_FORM_block: 568 case dwarf::DW_FORM_exprloc: 569 return Size + getULEB128Size(Size); 570 default: llvm_unreachable("Improper form for block"); 571 } 572} 573 574LLVM_DUMP_METHOD 575void DIELoc::print(raw_ostream &O) const { 576 printValues(O, *this, "ExprLoc", Size, 5); 577} 578 579//===----------------------------------------------------------------------===// 580// DIEBlock Implementation 581//===----------------------------------------------------------------------===// 582 583/// ComputeSize - calculate the size of the block. 584/// 585unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const { 586 if (!Size) { 587 for (const auto &V : values()) 588 Size += V.SizeOf(AP); 589 } 590 591 return Size; 592} 593 594/// EmitValue - Emit block data. 595/// 596void DIEBlock::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const { 597 switch (Form) { 598 default: llvm_unreachable("Improper form for block"); 599 case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break; 600 case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break; 601 case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break; 602 case dwarf::DW_FORM_block: Asm->EmitULEB128(Size); break; 603 } 604 605 for (const auto &V : values()) 606 V.EmitValue(Asm); 607} 608 609/// SizeOf - Determine size of block data in bytes. 610/// 611unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 612 switch (Form) { 613 case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); 614 case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); 615 case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); 616 case dwarf::DW_FORM_block: return Size + getULEB128Size(Size); 617 default: llvm_unreachable("Improper form for block"); 618 } 619} 620 621LLVM_DUMP_METHOD 622void DIEBlock::print(raw_ostream &O) const { 623 printValues(O, *this, "Blk", Size, 5); 624} 625 626//===----------------------------------------------------------------------===// 627// DIELocList Implementation 628//===----------------------------------------------------------------------===// 629 630unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const { 631 if (Form == dwarf::DW_FORM_data4) 632 return 4; 633 if (Form == dwarf::DW_FORM_sec_offset) 634 return 4; 635 return AP->getPointerSize(); 636} 637 638/// EmitValue - Emit label value. 639/// 640void DIELocList::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const { 641 DwarfDebug *DD = AP->getDwarfDebug(); 642 MCSymbol *Label = DD->getDebugLocs().getList(Index).Label; 643 AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf()); 644} 645 646LLVM_DUMP_METHOD 647void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; } 648