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// DIEAbbrevData Implementation
36//===----------------------------------------------------------------------===//
37
38/// Profile - Used to gather unique data for the abbreviation folding set.
39///
40void 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///
53void 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///
64void 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
89LLVM_DUMP_METHOD
90void 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
108LLVM_DUMP_METHOD
109void DIEAbbrev::dump() { print(dbgs()); }
110
111DIEAbbrev 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.
120const 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.
128const 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
139DIEValue 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
148LLVM_DUMP_METHOD
149static 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
164LLVM_DUMP_METHOD
165void 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
189LLVM_DUMP_METHOD
190void DIE::dump() {
191  print(dbgs());
192}
193
194void 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
206unsigned 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
218LLVM_DUMP_METHOD
219void 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
231LLVM_DUMP_METHOD
232void DIEValue::dump() const {
233  print(dbgs());
234}
235
236//===----------------------------------------------------------------------===//
237// DIEInteger Implementation
238//===----------------------------------------------------------------------===//
239
240/// EmitValue - Emit integer of appropriate size.
241///
242void 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///
279unsigned 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
308LLVM_DUMP_METHOD
309void 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///
320void 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///
326unsigned 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
333LLVM_DUMP_METHOD
334void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
335
336//===----------------------------------------------------------------------===//
337// DIELabel Implementation
338//===----------------------------------------------------------------------===//
339
340/// EmitValue - Emit label value.
341///
342void 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///
351unsigned 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
358LLVM_DUMP_METHOD
359void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
360
361//===----------------------------------------------------------------------===//
362// DIEDelta Implementation
363//===----------------------------------------------------------------------===//
364
365/// EmitValue - Emit delta value.
366///
367void 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///
373unsigned 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
380LLVM_DUMP_METHOD
381void 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///
391void 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///
415unsigned 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
432LLVM_DUMP_METHOD
433void 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///
443void 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
464unsigned 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
476LLVM_DUMP_METHOD
477void DIEEntry::print(raw_ostream &O) const {
478  O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
479}
480
481//===----------------------------------------------------------------------===//
482// DIETypeSignature Implementation
483//===----------------------------------------------------------------------===//
484void DIETypeSignature::EmitValue(const AsmPrinter *Asm,
485                                 dwarf::Form Form) const {
486  assert(Form == dwarf::DW_FORM_ref_sig8);
487  Asm->OutStreamer->EmitIntValue(Unit->getTypeSignature(), 8);
488}
489
490LLVM_DUMP_METHOD
491void DIETypeSignature::print(raw_ostream &O) const {
492  O << format("Type Unit: 0x%lx", Unit->getTypeSignature());
493}
494
495//===----------------------------------------------------------------------===//
496// DIELoc Implementation
497//===----------------------------------------------------------------------===//
498
499/// ComputeSize - calculate the size of the location expression.
500///
501unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const {
502  if (!Size) {
503    for (const auto &V : values())
504      Size += V.SizeOf(AP);
505  }
506
507  return Size;
508}
509
510/// EmitValue - Emit location data.
511///
512void DIELoc::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
513  switch (Form) {
514  default: llvm_unreachable("Improper form for block");
515  case dwarf::DW_FORM_block1: Asm->EmitInt8(Size);    break;
516  case dwarf::DW_FORM_block2: Asm->EmitInt16(Size);   break;
517  case dwarf::DW_FORM_block4: Asm->EmitInt32(Size);   break;
518  case dwarf::DW_FORM_block:
519  case dwarf::DW_FORM_exprloc:
520    Asm->EmitULEB128(Size); break;
521  }
522
523  for (const auto &V : values())
524    V.EmitValue(Asm);
525}
526
527/// SizeOf - Determine size of location data in bytes.
528///
529unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
530  switch (Form) {
531  case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
532  case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
533  case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
534  case dwarf::DW_FORM_block:
535  case dwarf::DW_FORM_exprloc:
536    return Size + getULEB128Size(Size);
537  default: llvm_unreachable("Improper form for block");
538  }
539}
540
541LLVM_DUMP_METHOD
542void DIELoc::print(raw_ostream &O) const {
543  printValues(O, *this, "ExprLoc", Size, 5);
544}
545
546//===----------------------------------------------------------------------===//
547// DIEBlock Implementation
548//===----------------------------------------------------------------------===//
549
550/// ComputeSize - calculate the size of the block.
551///
552unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const {
553  if (!Size) {
554    for (const auto &V : values())
555      Size += V.SizeOf(AP);
556  }
557
558  return Size;
559}
560
561/// EmitValue - Emit block data.
562///
563void DIEBlock::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
564  switch (Form) {
565  default: llvm_unreachable("Improper form for block");
566  case dwarf::DW_FORM_block1: Asm->EmitInt8(Size);    break;
567  case dwarf::DW_FORM_block2: Asm->EmitInt16(Size);   break;
568  case dwarf::DW_FORM_block4: Asm->EmitInt32(Size);   break;
569  case dwarf::DW_FORM_block:  Asm->EmitULEB128(Size); break;
570  }
571
572  for (const auto &V : values())
573    V.EmitValue(Asm);
574}
575
576/// SizeOf - Determine size of block data in bytes.
577///
578unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
579  switch (Form) {
580  case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
581  case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
582  case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
583  case dwarf::DW_FORM_block:  return Size + getULEB128Size(Size);
584  default: llvm_unreachable("Improper form for block");
585  }
586}
587
588LLVM_DUMP_METHOD
589void DIEBlock::print(raw_ostream &O) const {
590  printValues(O, *this, "Blk", Size, 5);
591}
592
593//===----------------------------------------------------------------------===//
594// DIELocList Implementation
595//===----------------------------------------------------------------------===//
596
597unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
598  if (Form == dwarf::DW_FORM_data4)
599    return 4;
600  if (Form == dwarf::DW_FORM_sec_offset)
601    return 4;
602  return AP->getPointerSize();
603}
604
605/// EmitValue - Emit label value.
606///
607void DIELocList::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
608  DwarfDebug *DD = AP->getDwarfDebug();
609  MCSymbol *Label = DD->getDebugLocs().getList(Index).Label;
610  AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf());
611}
612
613LLVM_DUMP_METHOD
614void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }
615