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