lib/CodeGen/AsmPrinter/DIE.cpp

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