DIE.cpp revision 198090
1193323Sed//===--- lib/CodeGen/DIE.cpp - DWARF Info Entries -------------------------===// 2193323Sed// 3193323Sed// The LLVM Compiler Infrastructure 4193323Sed// 5193323Sed// This file is distributed under the University of Illinois Open Source 6193323Sed// License. See LICENSE.TXT for details. 7193323Sed// 8193323Sed//===----------------------------------------------------------------------===// 9193323Sed// 10193323Sed// Data structures for DWARF info entries. 11193323Sed// 12193323Sed//===----------------------------------------------------------------------===// 13193323Sed 14193323Sed#include "DIE.h" 15193323Sed#include "DwarfPrinter.h" 16193323Sed#include "llvm/CodeGen/AsmPrinter.h" 17198090Srdivacky#include "llvm/MC/MCAsmInfo.h" 18193323Sed#include "llvm/Target/TargetData.h" 19198090Srdivacky#include "llvm/Support/ErrorHandling.h" 20198090Srdivacky#include "llvm/Support/Format.h" 21193323Sedusing namespace llvm; 22193323Sed 23193323Sed//===----------------------------------------------------------------------===// 24193323Sed// DIEAbbrevData Implementation 25193323Sed//===----------------------------------------------------------------------===// 26193323Sed 27193323Sed/// Profile - Used to gather unique data for the abbreviation folding set. 28193323Sed/// 29193323Sedvoid DIEAbbrevData::Profile(FoldingSetNodeID &ID) const { 30193323Sed ID.AddInteger(Attribute); 31193323Sed ID.AddInteger(Form); 32193323Sed} 33193323Sed 34193323Sed//===----------------------------------------------------------------------===// 35193323Sed// DIEAbbrev Implementation 36193323Sed//===----------------------------------------------------------------------===// 37193323Sed 38193323Sed/// Profile - Used to gather unique data for the abbreviation folding set. 39193323Sed/// 40193323Sedvoid DIEAbbrev::Profile(FoldingSetNodeID &ID) const { 41193323Sed ID.AddInteger(Tag); 42193323Sed ID.AddInteger(ChildrenFlag); 43193323Sed 44193323Sed // For each attribute description. 45193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) 46193323Sed Data[i].Profile(ID); 47193323Sed} 48193323Sed 49193323Sed/// Emit - Print the abbreviation using the specified asm printer. 50193323Sed/// 51193323Sedvoid DIEAbbrev::Emit(const AsmPrinter *Asm) const { 52193323Sed // Emit its Dwarf tag type. 53193323Sed Asm->EmitULEB128Bytes(Tag); 54193323Sed Asm->EOL(dwarf::TagString(Tag)); 55193323Sed 56193323Sed // Emit whether it has children DIEs. 57193323Sed Asm->EmitULEB128Bytes(ChildrenFlag); 58193323Sed Asm->EOL(dwarf::ChildrenString(ChildrenFlag)); 59193323Sed 60193323Sed // For each attribute description. 61193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) { 62193323Sed const DIEAbbrevData &AttrData = Data[i]; 63193323Sed 64193323Sed // Emit attribute type. 65193323Sed Asm->EmitULEB128Bytes(AttrData.getAttribute()); 66193323Sed Asm->EOL(dwarf::AttributeString(AttrData.getAttribute())); 67193323Sed 68193323Sed // Emit form type. 69193323Sed Asm->EmitULEB128Bytes(AttrData.getForm()); 70193323Sed Asm->EOL(dwarf::FormEncodingString(AttrData.getForm())); 71193323Sed } 72193323Sed 73193323Sed // Mark end of abbreviation. 74193323Sed Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(1)"); 75193323Sed Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(2)"); 76193323Sed} 77193323Sed 78193323Sed#ifndef NDEBUG 79198090Srdivackyvoid DIEAbbrev::print(raw_ostream &O) { 80193323Sed O << "Abbreviation @" 81198090Srdivacky << format("0x%lx", (long)(intptr_t)this) 82193323Sed << " " 83193323Sed << dwarf::TagString(Tag) 84193323Sed << " " 85193323Sed << dwarf::ChildrenString(ChildrenFlag) 86198090Srdivacky << '\n'; 87193323Sed 88193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) { 89193323Sed O << " " 90193323Sed << dwarf::AttributeString(Data[i].getAttribute()) 91193323Sed << " " 92193323Sed << dwarf::FormEncodingString(Data[i].getForm()) 93198090Srdivacky << '\n'; 94193323Sed } 95193323Sed} 96198090Srdivackyvoid DIEAbbrev::dump() { print(errs()); } 97193323Sed#endif 98193323Sed 99193323Sed//===----------------------------------------------------------------------===// 100193323Sed// DIE Implementation 101193323Sed//===----------------------------------------------------------------------===// 102193323Sed 103193323SedDIE::~DIE() { 104193323Sed for (unsigned i = 0, N = Children.size(); i < N; ++i) 105193323Sed delete Children[i]; 106193323Sed} 107193323Sed 108193323Sed/// AddSiblingOffset - Add a sibling offset field to the front of the DIE. 109193323Sed/// 110193323Sedvoid DIE::AddSiblingOffset() { 111193323Sed DIEInteger *DI = new DIEInteger(0); 112193323Sed Values.insert(Values.begin(), DI); 113193323Sed Abbrev.AddFirstAttribute(dwarf::DW_AT_sibling, dwarf::DW_FORM_ref4); 114193323Sed} 115193323Sed 116193323Sed/// Profile - Used to gather unique data for the value folding set. 117193323Sed/// 118193323Sedvoid DIE::Profile(FoldingSetNodeID &ID) { 119193323Sed Abbrev.Profile(ID); 120193323Sed 121193323Sed for (unsigned i = 0, N = Children.size(); i < N; ++i) 122193323Sed ID.AddPointer(Children[i]); 123193323Sed 124193323Sed for (unsigned j = 0, M = Values.size(); j < M; ++j) 125193323Sed ID.AddPointer(Values[j]); 126193323Sed} 127193323Sed 128193323Sed#ifndef NDEBUG 129198090Srdivackyvoid DIE::print(raw_ostream &O, unsigned IncIndent) { 130193323Sed IndentCount += IncIndent; 131193323Sed const std::string Indent(IndentCount, ' '); 132193323Sed bool isBlock = Abbrev.getTag() == 0; 133193323Sed 134193323Sed if (!isBlock) { 135193323Sed O << Indent 136193323Sed << "Die: " 137198090Srdivacky << format("0x%lx", (long)(intptr_t)this) 138193323Sed << ", Offset: " << Offset 139193323Sed << ", Size: " << Size 140193323Sed << "\n"; 141193323Sed 142193323Sed O << Indent 143193323Sed << dwarf::TagString(Abbrev.getTag()) 144193323Sed << " " 145193323Sed << dwarf::ChildrenString(Abbrev.getChildrenFlag()); 146193323Sed } else { 147193323Sed O << "Size: " << Size; 148193323Sed } 149193323Sed O << "\n"; 150193323Sed 151193323Sed const SmallVector<DIEAbbrevData, 8> &Data = Abbrev.getData(); 152193323Sed 153193323Sed IndentCount += 2; 154193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) { 155193323Sed O << Indent; 156193323Sed 157193323Sed if (!isBlock) 158193323Sed O << dwarf::AttributeString(Data[i].getAttribute()); 159193323Sed else 160193323Sed O << "Blk[" << i << "]"; 161193323Sed 162193323Sed O << " " 163193323Sed << dwarf::FormEncodingString(Data[i].getForm()) 164193323Sed << " "; 165193323Sed Values[i]->print(O); 166193323Sed O << "\n"; 167193323Sed } 168193323Sed IndentCount -= 2; 169193323Sed 170193323Sed for (unsigned j = 0, M = Children.size(); j < M; ++j) { 171193323Sed Children[j]->print(O, 4); 172193323Sed } 173193323Sed 174193323Sed if (!isBlock) O << "\n"; 175193323Sed IndentCount -= IncIndent; 176193323Sed} 177193323Sed 178193323Sedvoid DIE::dump() { 179198090Srdivacky print(errs()); 180193323Sed} 181193323Sed#endif 182193323Sed 183193323Sed 184193323Sed#ifndef NDEBUG 185193323Sedvoid DIEValue::dump() { 186198090Srdivacky print(errs()); 187193323Sed} 188193323Sed#endif 189193323Sed 190193323Sed//===----------------------------------------------------------------------===// 191193323Sed// DIEInteger Implementation 192193323Sed//===----------------------------------------------------------------------===// 193193323Sed 194193323Sed/// EmitValue - Emit integer of appropriate size. 195193323Sed/// 196193323Sedvoid DIEInteger::EmitValue(Dwarf *D, unsigned Form) const { 197193323Sed const AsmPrinter *Asm = D->getAsm(); 198193323Sed switch (Form) { 199193323Sed case dwarf::DW_FORM_flag: // Fall thru 200193323Sed case dwarf::DW_FORM_ref1: // Fall thru 201193323Sed case dwarf::DW_FORM_data1: Asm->EmitInt8(Integer); break; 202193323Sed case dwarf::DW_FORM_ref2: // Fall thru 203193323Sed case dwarf::DW_FORM_data2: Asm->EmitInt16(Integer); break; 204193323Sed case dwarf::DW_FORM_ref4: // Fall thru 205193323Sed case dwarf::DW_FORM_data4: Asm->EmitInt32(Integer); break; 206193323Sed case dwarf::DW_FORM_ref8: // Fall thru 207193323Sed case dwarf::DW_FORM_data8: Asm->EmitInt64(Integer); break; 208193323Sed case dwarf::DW_FORM_udata: Asm->EmitULEB128Bytes(Integer); break; 209193323Sed case dwarf::DW_FORM_sdata: Asm->EmitSLEB128Bytes(Integer); break; 210198090Srdivacky default: llvm_unreachable("DIE Value form not supported yet"); 211193323Sed } 212193323Sed} 213193323Sed 214193323Sed/// SizeOf - Determine size of integer value in bytes. 215193323Sed/// 216193323Sedunsigned DIEInteger::SizeOf(const TargetData *TD, unsigned Form) const { 217193323Sed switch (Form) { 218193323Sed case dwarf::DW_FORM_flag: // Fall thru 219193323Sed case dwarf::DW_FORM_ref1: // Fall thru 220193323Sed case dwarf::DW_FORM_data1: return sizeof(int8_t); 221193323Sed case dwarf::DW_FORM_ref2: // Fall thru 222193323Sed case dwarf::DW_FORM_data2: return sizeof(int16_t); 223193323Sed case dwarf::DW_FORM_ref4: // Fall thru 224193323Sed case dwarf::DW_FORM_data4: return sizeof(int32_t); 225193323Sed case dwarf::DW_FORM_ref8: // Fall thru 226193323Sed case dwarf::DW_FORM_data8: return sizeof(int64_t); 227198090Srdivacky case dwarf::DW_FORM_udata: return MCAsmInfo::getULEB128Size(Integer); 228198090Srdivacky case dwarf::DW_FORM_sdata: return MCAsmInfo::getSLEB128Size(Integer); 229198090Srdivacky default: llvm_unreachable("DIE Value form not supported yet"); break; 230193323Sed } 231193323Sed return 0; 232193323Sed} 233193323Sed 234193323Sed/// Profile - Used to gather unique data for the value folding set. 235193323Sed/// 236193323Sedvoid DIEInteger::Profile(FoldingSetNodeID &ID, unsigned Int) { 237193323Sed ID.AddInteger(isInteger); 238193323Sed ID.AddInteger(Int); 239193323Sed} 240193323Sedvoid DIEInteger::Profile(FoldingSetNodeID &ID) { 241193323Sed Profile(ID, Integer); 242193323Sed} 243193323Sed 244193323Sed#ifndef NDEBUG 245198090Srdivackyvoid DIEInteger::print(raw_ostream &O) { 246193323Sed O << "Int: " << (int64_t)Integer 247198090Srdivacky << format(" 0x%llx", (unsigned long long)Integer); 248193323Sed} 249193323Sed#endif 250193323Sed 251193323Sed//===----------------------------------------------------------------------===// 252193323Sed// DIEString Implementation 253193323Sed//===----------------------------------------------------------------------===// 254193323Sed 255193323Sed/// EmitValue - Emit string value. 256193323Sed/// 257193323Sedvoid DIEString::EmitValue(Dwarf *D, unsigned Form) const { 258193323Sed D->getAsm()->EmitString(Str); 259193323Sed} 260193323Sed 261193323Sed/// Profile - Used to gather unique data for the value folding set. 262193323Sed/// 263193323Sedvoid DIEString::Profile(FoldingSetNodeID &ID, const std::string &Str) { 264193323Sed ID.AddInteger(isString); 265193323Sed ID.AddString(Str); 266193323Sed} 267193323Sedvoid DIEString::Profile(FoldingSetNodeID &ID) { 268193323Sed Profile(ID, Str); 269193323Sed} 270193323Sed 271193323Sed#ifndef NDEBUG 272198090Srdivackyvoid DIEString::print(raw_ostream &O) { 273193323Sed O << "Str: \"" << Str << "\""; 274193323Sed} 275193323Sed#endif 276193323Sed 277193323Sed//===----------------------------------------------------------------------===// 278193323Sed// DIEDwarfLabel Implementation 279193323Sed//===----------------------------------------------------------------------===// 280193323Sed 281193323Sed/// EmitValue - Emit label value. 282193323Sed/// 283193323Sedvoid DIEDwarfLabel::EmitValue(Dwarf *D, unsigned Form) const { 284193323Sed bool IsSmall = Form == dwarf::DW_FORM_data4; 285193323Sed D->EmitReference(Label, false, IsSmall); 286193323Sed} 287193323Sed 288193323Sed/// SizeOf - Determine size of label value in bytes. 289193323Sed/// 290193323Sedunsigned DIEDwarfLabel::SizeOf(const TargetData *TD, unsigned Form) const { 291193323Sed if (Form == dwarf::DW_FORM_data4) return 4; 292193323Sed return TD->getPointerSize(); 293193323Sed} 294193323Sed 295193323Sed/// Profile - Used to gather unique data for the value folding set. 296193323Sed/// 297193323Sedvoid DIEDwarfLabel::Profile(FoldingSetNodeID &ID, const DWLabel &Label) { 298193323Sed ID.AddInteger(isLabel); 299193323Sed Label.Profile(ID); 300193323Sed} 301193323Sedvoid DIEDwarfLabel::Profile(FoldingSetNodeID &ID) { 302193323Sed Profile(ID, Label); 303193323Sed} 304193323Sed 305193323Sed#ifndef NDEBUG 306198090Srdivackyvoid DIEDwarfLabel::print(raw_ostream &O) { 307193323Sed O << "Lbl: "; 308193323Sed Label.print(O); 309193323Sed} 310193323Sed#endif 311193323Sed 312193323Sed//===----------------------------------------------------------------------===// 313193323Sed// DIEObjectLabel Implementation 314193323Sed//===----------------------------------------------------------------------===// 315193323Sed 316193323Sed/// EmitValue - Emit label value. 317193323Sed/// 318193323Sedvoid DIEObjectLabel::EmitValue(Dwarf *D, unsigned Form) const { 319193323Sed bool IsSmall = Form == dwarf::DW_FORM_data4; 320193323Sed D->EmitReference(Label, false, IsSmall); 321193323Sed} 322193323Sed 323193323Sed/// SizeOf - Determine size of label value in bytes. 324193323Sed/// 325193323Sedunsigned DIEObjectLabel::SizeOf(const TargetData *TD, unsigned Form) const { 326193323Sed if (Form == dwarf::DW_FORM_data4) return 4; 327193323Sed return TD->getPointerSize(); 328193323Sed} 329193323Sed 330193323Sed/// Profile - Used to gather unique data for the value folding set. 331193323Sed/// 332193323Sedvoid DIEObjectLabel::Profile(FoldingSetNodeID &ID, const std::string &Label) { 333193323Sed ID.AddInteger(isAsIsLabel); 334193323Sed ID.AddString(Label); 335193323Sed} 336193323Sedvoid DIEObjectLabel::Profile(FoldingSetNodeID &ID) { 337193323Sed Profile(ID, Label.c_str()); 338193323Sed} 339193323Sed 340193323Sed#ifndef NDEBUG 341198090Srdivackyvoid DIEObjectLabel::print(raw_ostream &O) { 342193323Sed O << "Obj: " << Label; 343193323Sed} 344193323Sed#endif 345193323Sed 346193323Sed//===----------------------------------------------------------------------===// 347193323Sed// DIESectionOffset Implementation 348193323Sed//===----------------------------------------------------------------------===// 349193323Sed 350193323Sed/// EmitValue - Emit delta value. 351193323Sed/// 352193323Sedvoid DIESectionOffset::EmitValue(Dwarf *D, unsigned Form) const { 353193323Sed bool IsSmall = Form == dwarf::DW_FORM_data4; 354193323Sed D->EmitSectionOffset(Label.getTag(), Section.getTag(), 355193323Sed Label.getNumber(), Section.getNumber(), 356193323Sed IsSmall, IsEH, UseSet); 357193323Sed} 358193323Sed 359193323Sed/// SizeOf - Determine size of delta value in bytes. 360193323Sed/// 361193323Sedunsigned DIESectionOffset::SizeOf(const TargetData *TD, unsigned Form) const { 362193323Sed if (Form == dwarf::DW_FORM_data4) return 4; 363193323Sed return TD->getPointerSize(); 364193323Sed} 365193323Sed 366193323Sed/// Profile - Used to gather unique data for the value folding set. 367193323Sed/// 368193323Sedvoid DIESectionOffset::Profile(FoldingSetNodeID &ID, const DWLabel &Label, 369193323Sed const DWLabel &Section) { 370193323Sed ID.AddInteger(isSectionOffset); 371193323Sed Label.Profile(ID); 372193323Sed Section.Profile(ID); 373193323Sed // IsEH and UseSet are specific to the Label/Section that we will emit the 374193323Sed // offset for; so Label/Section are enough for uniqueness. 375193323Sed} 376193323Sedvoid DIESectionOffset::Profile(FoldingSetNodeID &ID) { 377193323Sed Profile(ID, Label, Section); 378193323Sed} 379193323Sed 380193323Sed#ifndef NDEBUG 381198090Srdivackyvoid DIESectionOffset::print(raw_ostream &O) { 382193323Sed O << "Off: "; 383193323Sed Label.print(O); 384193323Sed O << "-"; 385193323Sed Section.print(O); 386193323Sed O << "-" << IsEH << "-" << UseSet; 387193323Sed} 388193323Sed#endif 389193323Sed 390193323Sed//===----------------------------------------------------------------------===// 391193323Sed// DIEDelta Implementation 392193323Sed//===----------------------------------------------------------------------===// 393193323Sed 394193323Sed/// EmitValue - Emit delta value. 395193323Sed/// 396193323Sedvoid DIEDelta::EmitValue(Dwarf *D, unsigned Form) const { 397193323Sed bool IsSmall = Form == dwarf::DW_FORM_data4; 398193323Sed D->EmitDifference(LabelHi, LabelLo, IsSmall); 399193323Sed} 400193323Sed 401193323Sed/// SizeOf - Determine size of delta value in bytes. 402193323Sed/// 403193323Sedunsigned DIEDelta::SizeOf(const TargetData *TD, unsigned Form) const { 404193323Sed if (Form == dwarf::DW_FORM_data4) return 4; 405193323Sed return TD->getPointerSize(); 406193323Sed} 407193323Sed 408193323Sed/// Profile - Used to gather unique data for the value folding set. 409193323Sed/// 410193323Sedvoid DIEDelta::Profile(FoldingSetNodeID &ID, const DWLabel &LabelHi, 411193323Sed const DWLabel &LabelLo) { 412193323Sed ID.AddInteger(isDelta); 413193323Sed LabelHi.Profile(ID); 414193323Sed LabelLo.Profile(ID); 415193323Sed} 416193323Sedvoid DIEDelta::Profile(FoldingSetNodeID &ID) { 417193323Sed Profile(ID, LabelHi, LabelLo); 418193323Sed} 419193323Sed 420193323Sed#ifndef NDEBUG 421198090Srdivackyvoid DIEDelta::print(raw_ostream &O) { 422193323Sed O << "Del: "; 423193323Sed LabelHi.print(O); 424193323Sed O << "-"; 425193323Sed LabelLo.print(O); 426193323Sed} 427193323Sed#endif 428193323Sed 429193323Sed//===----------------------------------------------------------------------===// 430193323Sed// DIEEntry Implementation 431193323Sed//===----------------------------------------------------------------------===// 432193323Sed 433193323Sed/// EmitValue - Emit debug information entry offset. 434193323Sed/// 435193323Sedvoid DIEEntry::EmitValue(Dwarf *D, unsigned Form) const { 436193323Sed D->getAsm()->EmitInt32(Entry->getOffset()); 437193323Sed} 438193323Sed 439193323Sed/// Profile - Used to gather unique data for the value folding set. 440193323Sed/// 441193323Sedvoid DIEEntry::Profile(FoldingSetNodeID &ID, DIE *Entry) { 442193323Sed ID.AddInteger(isEntry); 443193323Sed ID.AddPointer(Entry); 444193323Sed} 445193323Sedvoid DIEEntry::Profile(FoldingSetNodeID &ID) { 446193323Sed ID.AddInteger(isEntry); 447193323Sed 448193323Sed if (Entry) 449193323Sed ID.AddPointer(Entry); 450193323Sed else 451193323Sed ID.AddPointer(this); 452193323Sed} 453193323Sed 454193323Sed#ifndef NDEBUG 455198090Srdivackyvoid DIEEntry::print(raw_ostream &O) { 456198090Srdivacky O << format("Die: 0x%lx", (long)(intptr_t)Entry); 457193323Sed} 458193323Sed#endif 459193323Sed 460193323Sed//===----------------------------------------------------------------------===// 461193323Sed// DIEBlock Implementation 462193323Sed//===----------------------------------------------------------------------===// 463193323Sed 464193323Sed/// ComputeSize - calculate the size of the block. 465193323Sed/// 466193323Sedunsigned DIEBlock::ComputeSize(const TargetData *TD) { 467193323Sed if (!Size) { 468193323Sed const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData(); 469193323Sed for (unsigned i = 0, N = Values.size(); i < N; ++i) 470193323Sed Size += Values[i]->SizeOf(TD, AbbrevData[i].getForm()); 471193323Sed } 472193323Sed 473193323Sed return Size; 474193323Sed} 475193323Sed 476193323Sed/// EmitValue - Emit block data. 477193323Sed/// 478193323Sedvoid DIEBlock::EmitValue(Dwarf *D, unsigned Form) const { 479193323Sed const AsmPrinter *Asm = D->getAsm(); 480193323Sed switch (Form) { 481193323Sed case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break; 482193323Sed case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break; 483193323Sed case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break; 484193323Sed case dwarf::DW_FORM_block: Asm->EmitULEB128Bytes(Size); break; 485198090Srdivacky default: llvm_unreachable("Improper form for block"); break; 486193323Sed } 487193323Sed 488193323Sed const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData(); 489193323Sed for (unsigned i = 0, N = Values.size(); i < N; ++i) { 490193323Sed Asm->EOL(); 491193323Sed Values[i]->EmitValue(D, AbbrevData[i].getForm()); 492193323Sed } 493193323Sed} 494193323Sed 495193323Sed/// SizeOf - Determine size of block data in bytes. 496193323Sed/// 497193323Sedunsigned DIEBlock::SizeOf(const TargetData *TD, unsigned Form) const { 498193323Sed switch (Form) { 499193323Sed case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); 500193323Sed case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); 501193323Sed case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); 502198090Srdivacky case dwarf::DW_FORM_block: return Size + MCAsmInfo::getULEB128Size(Size); 503198090Srdivacky default: llvm_unreachable("Improper form for block"); break; 504193323Sed } 505193323Sed return 0; 506193323Sed} 507193323Sed 508193323Sedvoid DIEBlock::Profile(FoldingSetNodeID &ID) { 509193323Sed ID.AddInteger(isBlock); 510193323Sed DIE::Profile(ID); 511193323Sed} 512193323Sed 513193323Sed#ifndef NDEBUG 514198090Srdivackyvoid DIEBlock::print(raw_ostream &O) { 515193323Sed O << "Blk: "; 516193323Sed DIE::print(O, 5); 517193323Sed} 518193323Sed#endif 519