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 // EmittingAsmStreamer Implementation
36 //===----------------------------------------------------------------------===//
37 unsigned EmittingAsmStreamer::emitULEB128(uint64_t Value, const char *Desc,
38                                           unsigned PadTo) {
39   AP->EmitULEB128(Value, Desc, PadTo);
40   return 0;
41 }
42 
43 unsigned EmittingAsmStreamer::emitInt8(unsigned char Value) {
44   AP->EmitInt8(Value);
45   return 0;
46 }
47 
48 unsigned EmittingAsmStreamer::emitBytes(StringRef Data) {
49   AP->OutStreamer->EmitBytes(Data);
50   return 0;
51 }
52 
53 //===----------------------------------------------------------------------===//
54 // SizeReporterAsmStreamer Implementation
55 //===----------------------------------------------------------------------===//
56 unsigned SizeReporterAsmStreamer::emitULEB128(uint64_t Value, const char *Desc,
57                                               unsigned PadTo) {
58   return getULEB128Size(Value);
59 }
60 
61 unsigned SizeReporterAsmStreamer::emitInt8(unsigned char Value) { return 1; }
62 
63 unsigned 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 ///
73 void 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 ///
86 void 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 ///
97 void 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 
122 LLVM_DUMP_METHOD
123 void 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 
141 LLVM_DUMP_METHOD
142 void DIEAbbrev::dump() { print(dbgs()); }
143 
144 DIEAbbrev 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.
153 const 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.
161 const 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 
172 DIEValue 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 
181 LLVM_DUMP_METHOD
182 static 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 
197 LLVM_DUMP_METHOD
198 void 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 
222 LLVM_DUMP_METHOD
223 void DIE::dump() {
224   print(dbgs());
225 }
226 
227 void 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 
239 unsigned 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 
251 LLVM_DUMP_METHOD
252 void 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 
264 LLVM_DUMP_METHOD
265 void DIEValue::dump() const {
266   print(dbgs());
267 }
268 
269 //===----------------------------------------------------------------------===//
270 // DIEInteger Implementation
271 //===----------------------------------------------------------------------===//
272 
273 /// EmitValue - Emit integer of appropriate size.
274 ///
275 void 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 ///
312 unsigned 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 
341 LLVM_DUMP_METHOD
342 void 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 ///
353 void 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 ///
359 unsigned 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 
366 LLVM_DUMP_METHOD
367 void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
368 
369 //===----------------------------------------------------------------------===//
370 // DIELabel Implementation
371 //===----------------------------------------------------------------------===//
372 
373 /// EmitValue - Emit label value.
374 ///
375 void 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 ///
384 unsigned 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 
391 LLVM_DUMP_METHOD
392 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
393 
394 //===----------------------------------------------------------------------===//
395 // DIEDelta Implementation
396 //===----------------------------------------------------------------------===//
397 
398 /// EmitValue - Emit delta value.
399 ///
400 void 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 ///
406 unsigned 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 
413 LLVM_DUMP_METHOD
414 void 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 ///
424 void 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 ///
448 unsigned 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 
465 LLVM_DUMP_METHOD
466 void 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 ///
476 void 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 
497 unsigned 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 
509 LLVM_DUMP_METHOD
510 void DIEEntry::print(raw_ostream &O) const {
511   O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
512 }
513 
514 //===----------------------------------------------------------------------===//
515 // DIETypeSignature Implementation
516 //===----------------------------------------------------------------------===//
517 void 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 
523 LLVM_DUMP_METHOD
524 void 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 ///
534 unsigned 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 ///
545 void 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 ///
562 unsigned 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 
574 LLVM_DUMP_METHOD
575 void 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 ///
585 unsigned 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 ///
596 void 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 ///
611 unsigned 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 
621 LLVM_DUMP_METHOD
622 void DIEBlock::print(raw_ostream &O) const {
623   printValues(O, *this, "Blk", Size, 5);
624 }
625 
626 //===----------------------------------------------------------------------===//
627 // DIELocList Implementation
628 //===----------------------------------------------------------------------===//
629 
630 unsigned 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 ///
640 void 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 
646 LLVM_DUMP_METHOD
647 void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }
648