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