DIE.cpp revision 276479
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. 11249423Sdim// 12193323Sed//===----------------------------------------------------------------------===// 13193323Sed 14193323Sed#include "DIE.h" 15261991Sdim#include "DwarfDebug.h" 16276479Sdim#include "DwarfUnit.h" 17202878Srdivacky#include "llvm/ADT/Twine.h" 18193323Sed#include "llvm/CodeGen/AsmPrinter.h" 19249423Sdim#include "llvm/IR/DataLayout.h" 20198090Srdivacky#include "llvm/MC/MCAsmInfo.h" 21202878Srdivacky#include "llvm/MC/MCStreamer.h" 22202878Srdivacky#include "llvm/MC/MCSymbol.h" 23201360Srdivacky#include "llvm/Support/Debug.h" 24198090Srdivacky#include "llvm/Support/ErrorHandling.h" 25198090Srdivacky#include "llvm/Support/Format.h" 26202878Srdivacky#include "llvm/Support/FormattedStream.h" 27276479Sdim#include "llvm/Support/LEB128.h" 28261991Sdim#include "llvm/Support/MD5.h" 29193323Sedusing namespace llvm; 30193323Sed 31193323Sed//===----------------------------------------------------------------------===// 32193323Sed// DIEAbbrevData Implementation 33193323Sed//===----------------------------------------------------------------------===// 34193323Sed 35193323Sed/// Profile - Used to gather unique data for the abbreviation folding set. 36193323Sed/// 37193323Sedvoid DIEAbbrevData::Profile(FoldingSetNodeID &ID) const { 38261991Sdim // Explicitly cast to an integer type for which FoldingSetNodeID has 39261991Sdim // overloads. Otherwise MSVC 2010 thinks this call is ambiguous. 40261991Sdim ID.AddInteger(unsigned(Attribute)); 41261991Sdim ID.AddInteger(unsigned(Form)); 42193323Sed} 43193323Sed 44193323Sed//===----------------------------------------------------------------------===// 45193323Sed// DIEAbbrev Implementation 46193323Sed//===----------------------------------------------------------------------===// 47193323Sed 48193323Sed/// Profile - Used to gather unique data for the abbreviation folding set. 49193323Sed/// 50193323Sedvoid DIEAbbrev::Profile(FoldingSetNodeID &ID) const { 51261991Sdim ID.AddInteger(unsigned(Tag)); 52276479Sdim ID.AddInteger(unsigned(Children)); 53193323Sed 54193323Sed // For each attribute description. 55193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) 56193323Sed Data[i].Profile(ID); 57193323Sed} 58193323Sed 59193323Sed/// Emit - Print the abbreviation using the specified asm printer. 60193323Sed/// 61206274Srdivackyvoid DIEAbbrev::Emit(AsmPrinter *AP) const { 62193323Sed // Emit its Dwarf tag type. 63206274Srdivacky AP->EmitULEB128(Tag, dwarf::TagString(Tag)); 64193323Sed 65193323Sed // Emit whether it has children DIEs. 66276479Sdim AP->EmitULEB128((unsigned)Children, dwarf::ChildrenString(Children)); 67193323Sed 68193323Sed // For each attribute description. 69193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) { 70193323Sed const DIEAbbrevData &AttrData = Data[i]; 71193323Sed 72193323Sed // Emit attribute type. 73206274Srdivacky AP->EmitULEB128(AttrData.getAttribute(), 74226633Sdim dwarf::AttributeString(AttrData.getAttribute())); 75193323Sed 76193323Sed // Emit form type. 77206274Srdivacky AP->EmitULEB128(AttrData.getForm(), 78202878Srdivacky dwarf::FormEncodingString(AttrData.getForm())); 79193323Sed } 80193323Sed 81193323Sed // Mark end of abbreviation. 82206274Srdivacky AP->EmitULEB128(0, "EOM(1)"); 83206274Srdivacky AP->EmitULEB128(0, "EOM(2)"); 84193323Sed} 85193323Sed 86193323Sed#ifndef NDEBUG 87198090Srdivackyvoid DIEAbbrev::print(raw_ostream &O) { 88193323Sed O << "Abbreviation @" 89198090Srdivacky << format("0x%lx", (long)(intptr_t)this) 90193323Sed << " " 91193323Sed << dwarf::TagString(Tag) 92193323Sed << " " 93276479Sdim << dwarf::ChildrenString(Children) 94198090Srdivacky << '\n'; 95193323Sed 96193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) { 97193323Sed O << " " 98193323Sed << dwarf::AttributeString(Data[i].getAttribute()) 99193323Sed << " " 100193323Sed << dwarf::FormEncodingString(Data[i].getForm()) 101198090Srdivacky << '\n'; 102193323Sed } 103193323Sed} 104201360Srdivackyvoid DIEAbbrev::dump() { print(dbgs()); } 105193323Sed#endif 106193323Sed 107276479Sdim/// Climb up the parent chain to get the unit DIE to which this DIE 108251662Sdim/// belongs. 109276479Sdimconst DIE *DIE::getUnit() const { 110276479Sdim const DIE *Cu = getUnitOrNull(); 111261991Sdim assert(Cu && "We should not have orphaned DIEs."); 112261991Sdim return Cu; 113261991Sdim} 114261991Sdim 115276479Sdim/// Climb up the parent chain to get the unit DIE this DIE belongs 116261991Sdim/// to. Return NULL if DIE is not added to an owner yet. 117276479Sdimconst DIE *DIE::getUnitOrNull() const { 118261991Sdim const DIE *p = this; 119249423Sdim while (p) { 120276479Sdim if (p->getTag() == dwarf::DW_TAG_compile_unit || 121276479Sdim p->getTag() == dwarf::DW_TAG_type_unit) 122249423Sdim return p; 123249423Sdim p = p->getParent(); 124249423Sdim } 125276479Sdim return nullptr; 126249423Sdim} 127249423Sdim 128276479SdimDIEValue *DIE::findAttribute(dwarf::Attribute Attribute) const { 129261991Sdim const SmallVectorImpl<DIEValue *> &Values = getValues(); 130261991Sdim const DIEAbbrev &Abbrevs = getAbbrev(); 131261991Sdim 132261991Sdim // Iterate through all the attributes until we find the one we're 133261991Sdim // looking for, if we can't find it return NULL. 134261991Sdim for (size_t i = 0; i < Values.size(); ++i) 135261991Sdim if (Abbrevs.getData()[i].getAttribute() == Attribute) 136261991Sdim return Values[i]; 137276479Sdim return nullptr; 138261991Sdim} 139261991Sdim 140193323Sed#ifndef NDEBUG 141251662Sdimvoid DIE::print(raw_ostream &O, unsigned IndentCount) const { 142193323Sed const std::string Indent(IndentCount, ' '); 143193323Sed bool isBlock = Abbrev.getTag() == 0; 144193323Sed 145193323Sed if (!isBlock) { 146193323Sed O << Indent 147193323Sed << "Die: " 148198090Srdivacky << format("0x%lx", (long)(intptr_t)this) 149193323Sed << ", Offset: " << Offset 150204961Srdivacky << ", Size: " << Size << "\n"; 151193323Sed 152193323Sed O << Indent 153193323Sed << dwarf::TagString(Abbrev.getTag()) 154193323Sed << " " 155276479Sdim << dwarf::ChildrenString(Abbrev.hasChildren()) << "\n"; 156193323Sed } else { 157204961Srdivacky O << "Size: " << Size << "\n"; 158193323Sed } 159193323Sed 160249423Sdim const SmallVectorImpl<DIEAbbrevData> &Data = Abbrev.getData(); 161193323Sed 162193323Sed IndentCount += 2; 163193323Sed for (unsigned i = 0, N = Data.size(); i < N; ++i) { 164193323Sed O << Indent; 165193323Sed 166193323Sed if (!isBlock) 167193323Sed O << dwarf::AttributeString(Data[i].getAttribute()); 168193323Sed else 169193323Sed O << "Blk[" << i << "]"; 170193323Sed 171193323Sed O << " " 172193323Sed << dwarf::FormEncodingString(Data[i].getForm()) 173193323Sed << " "; 174193323Sed Values[i]->print(O); 175193323Sed O << "\n"; 176193323Sed } 177193323Sed IndentCount -= 2; 178193323Sed 179193323Sed for (unsigned j = 0, M = Children.size(); j < M; ++j) { 180251662Sdim Children[j]->print(O, IndentCount+4); 181193323Sed } 182193323Sed 183193323Sed if (!isBlock) O << "\n"; 184193323Sed} 185193323Sed 186193323Sedvoid DIE::dump() { 187201360Srdivacky print(dbgs()); 188193323Sed} 189193323Sed#endif 190193323Sed 191234353Sdimvoid DIEValue::anchor() { } 192193323Sed 193193323Sed#ifndef NDEBUG 194261991Sdimvoid DIEValue::dump() const { 195201360Srdivacky print(dbgs()); 196193323Sed} 197193323Sed#endif 198193323Sed 199193323Sed//===----------------------------------------------------------------------===// 200193323Sed// DIEInteger Implementation 201193323Sed//===----------------------------------------------------------------------===// 202193323Sed 203193323Sed/// EmitValue - Emit integer of appropriate size. 204193323Sed/// 205261991Sdimvoid DIEInteger::EmitValue(AsmPrinter *Asm, dwarf::Form Form) const { 206202878Srdivacky unsigned Size = ~0U; 207193323Sed switch (Form) { 208243830Sdim case dwarf::DW_FORM_flag_present: 209243830Sdim // Emit something to keep the lines and comments in sync. 210243830Sdim // FIXME: Is there a better way to do this? 211276479Sdim Asm->OutStreamer.AddBlankLine(); 212243830Sdim return; 213193323Sed case dwarf::DW_FORM_flag: // Fall thru 214193323Sed case dwarf::DW_FORM_ref1: // Fall thru 215202878Srdivacky case dwarf::DW_FORM_data1: Size = 1; break; 216193323Sed case dwarf::DW_FORM_ref2: // Fall thru 217202878Srdivacky case dwarf::DW_FORM_data2: Size = 2; break; 218249423Sdim case dwarf::DW_FORM_sec_offset: // Fall thru 219193323Sed case dwarf::DW_FORM_ref4: // Fall thru 220202878Srdivacky case dwarf::DW_FORM_data4: Size = 4; break; 221193323Sed case dwarf::DW_FORM_ref8: // Fall thru 222276479Sdim case dwarf::DW_FORM_ref_sig8: // Fall thru 223202878Srdivacky case dwarf::DW_FORM_data8: Size = 8; break; 224249423Sdim case dwarf::DW_FORM_GNU_str_index: Asm->EmitULEB128(Integer); return; 225249423Sdim case dwarf::DW_FORM_GNU_addr_index: Asm->EmitULEB128(Integer); return; 226206274Srdivacky case dwarf::DW_FORM_udata: Asm->EmitULEB128(Integer); return; 227206274Srdivacky case dwarf::DW_FORM_sdata: Asm->EmitSLEB128(Integer); return; 228243830Sdim case dwarf::DW_FORM_addr: 229243830Sdim Size = Asm->getDataLayout().getPointerSize(); break; 230198090Srdivacky default: llvm_unreachable("DIE Value form not supported yet"); 231193323Sed } 232249423Sdim Asm->OutStreamer.EmitIntValue(Integer, Size); 233193323Sed} 234193323Sed 235193323Sed/// SizeOf - Determine size of integer value in bytes. 236193323Sed/// 237261991Sdimunsigned DIEInteger::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 238193323Sed switch (Form) { 239243830Sdim case dwarf::DW_FORM_flag_present: return 0; 240193323Sed case dwarf::DW_FORM_flag: // Fall thru 241193323Sed case dwarf::DW_FORM_ref1: // Fall thru 242193323Sed case dwarf::DW_FORM_data1: return sizeof(int8_t); 243193323Sed case dwarf::DW_FORM_ref2: // Fall thru 244193323Sed case dwarf::DW_FORM_data2: return sizeof(int16_t); 245249423Sdim case dwarf::DW_FORM_sec_offset: // Fall thru 246193323Sed case dwarf::DW_FORM_ref4: // Fall thru 247193323Sed case dwarf::DW_FORM_data4: return sizeof(int32_t); 248193323Sed case dwarf::DW_FORM_ref8: // Fall thru 249276479Sdim case dwarf::DW_FORM_ref_sig8: // Fall thru 250193323Sed case dwarf::DW_FORM_data8: return sizeof(int64_t); 251276479Sdim case dwarf::DW_FORM_GNU_str_index: return getULEB128Size(Integer); 252276479Sdim case dwarf::DW_FORM_GNU_addr_index: return getULEB128Size(Integer); 253276479Sdim case dwarf::DW_FORM_udata: return getULEB128Size(Integer); 254276479Sdim case dwarf::DW_FORM_sdata: return getSLEB128Size(Integer); 255243830Sdim case dwarf::DW_FORM_addr: return AP->getDataLayout().getPointerSize(); 256234353Sdim default: llvm_unreachable("DIE Value form not supported yet"); 257193323Sed } 258193323Sed} 259193323Sed 260193323Sed#ifndef NDEBUG 261261991Sdimvoid DIEInteger::print(raw_ostream &O) const { 262234353Sdim O << "Int: " << (int64_t)Integer << " 0x"; 263234353Sdim O.write_hex(Integer); 264193323Sed} 265193323Sed#endif 266193323Sed 267193323Sed//===----------------------------------------------------------------------===// 268261991Sdim// DIEExpr Implementation 269261991Sdim//===----------------------------------------------------------------------===// 270261991Sdim 271261991Sdim/// EmitValue - Emit expression value. 272261991Sdim/// 273261991Sdimvoid DIEExpr::EmitValue(AsmPrinter *AP, dwarf::Form Form) const { 274261991Sdim AP->OutStreamer.EmitValue(Expr, SizeOf(AP, Form)); 275261991Sdim} 276261991Sdim 277261991Sdim/// SizeOf - Determine size of expression value in bytes. 278261991Sdim/// 279261991Sdimunsigned DIEExpr::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 280261991Sdim if (Form == dwarf::DW_FORM_data4) return 4; 281261991Sdim if (Form == dwarf::DW_FORM_sec_offset) return 4; 282261991Sdim if (Form == dwarf::DW_FORM_strp) return 4; 283261991Sdim return AP->getDataLayout().getPointerSize(); 284261991Sdim} 285261991Sdim 286261991Sdim#ifndef NDEBUG 287261991Sdimvoid DIEExpr::print(raw_ostream &O) const { 288261991Sdim O << "Expr: "; 289261991Sdim Expr->print(O); 290261991Sdim} 291261991Sdim#endif 292261991Sdim 293261991Sdim//===----------------------------------------------------------------------===// 294204961Srdivacky// DIELabel Implementation 295193323Sed//===----------------------------------------------------------------------===// 296193323Sed 297193323Sed/// EmitValue - Emit label value. 298193323Sed/// 299261991Sdimvoid DIELabel::EmitValue(AsmPrinter *AP, dwarf::Form Form) const { 300261991Sdim AP->EmitLabelReference(Label, SizeOf(AP, Form), 301261991Sdim Form == dwarf::DW_FORM_strp || 302261991Sdim Form == dwarf::DW_FORM_sec_offset || 303261991Sdim Form == dwarf::DW_FORM_ref_addr); 304193323Sed} 305193323Sed 306193323Sed/// SizeOf - Determine size of label value in bytes. 307193323Sed/// 308261991Sdimunsigned DIELabel::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 309193323Sed if (Form == dwarf::DW_FORM_data4) return 4; 310249423Sdim if (Form == dwarf::DW_FORM_sec_offset) return 4; 311234353Sdim if (Form == dwarf::DW_FORM_strp) return 4; 312243830Sdim return AP->getDataLayout().getPointerSize(); 313193323Sed} 314193323Sed 315193323Sed#ifndef NDEBUG 316261991Sdimvoid DIELabel::print(raw_ostream &O) const { 317204961Srdivacky O << "Lbl: " << Label->getName(); 318193323Sed} 319193323Sed#endif 320193323Sed 321193323Sed//===----------------------------------------------------------------------===// 322193323Sed// DIEDelta Implementation 323193323Sed//===----------------------------------------------------------------------===// 324193323Sed 325193323Sed/// EmitValue - Emit delta value. 326193323Sed/// 327261991Sdimvoid DIEDelta::EmitValue(AsmPrinter *AP, dwarf::Form Form) const { 328206274Srdivacky AP->EmitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form)); 329193323Sed} 330193323Sed 331193323Sed/// SizeOf - Determine size of delta value in bytes. 332193323Sed/// 333261991Sdimunsigned DIEDelta::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 334193323Sed if (Form == dwarf::DW_FORM_data4) return 4; 335261991Sdim if (Form == dwarf::DW_FORM_sec_offset) return 4; 336234353Sdim if (Form == dwarf::DW_FORM_strp) return 4; 337243830Sdim return AP->getDataLayout().getPointerSize(); 338193323Sed} 339193323Sed 340193323Sed#ifndef NDEBUG 341261991Sdimvoid DIEDelta::print(raw_ostream &O) const { 342204961Srdivacky O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName(); 343193323Sed} 344193323Sed#endif 345193323Sed 346193323Sed//===----------------------------------------------------------------------===// 347261991Sdim// DIEString Implementation 348261991Sdim//===----------------------------------------------------------------------===// 349261991Sdim 350261991Sdim/// EmitValue - Emit string value. 351261991Sdim/// 352261991Sdimvoid DIEString::EmitValue(AsmPrinter *AP, dwarf::Form Form) const { 353261991Sdim Access->EmitValue(AP, Form); 354261991Sdim} 355261991Sdim 356261991Sdim/// SizeOf - Determine size of delta value in bytes. 357261991Sdim/// 358261991Sdimunsigned DIEString::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 359261991Sdim return Access->SizeOf(AP, Form); 360261991Sdim} 361261991Sdim 362261991Sdim#ifndef NDEBUG 363261991Sdimvoid DIEString::print(raw_ostream &O) const { 364261991Sdim O << "String: " << Str << "\tSymbol: "; 365261991Sdim Access->print(O); 366261991Sdim} 367261991Sdim#endif 368261991Sdim 369261991Sdim//===----------------------------------------------------------------------===// 370193323Sed// DIEEntry Implementation 371193323Sed//===----------------------------------------------------------------------===// 372193323Sed 373193323Sed/// EmitValue - Emit debug information entry offset. 374193323Sed/// 375261991Sdimvoid DIEEntry::EmitValue(AsmPrinter *AP, dwarf::Form Form) const { 376276479Sdim 377276479Sdim if (Form == dwarf::DW_FORM_ref_addr) { 378276479Sdim const DwarfDebug *DD = AP->getDwarfDebug(); 379276479Sdim unsigned Addr = Entry.getOffset(); 380276479Sdim assert(!DD->useSplitDwarf() && "TODO: dwo files can't have relocations."); 381276479Sdim // For DW_FORM_ref_addr, output the offset from beginning of debug info 382276479Sdim // section. Entry->getOffset() returns the offset from start of the 383276479Sdim // compile unit. 384276479Sdim DwarfCompileUnit *CU = DD->lookupUnit(Entry.getUnit()); 385276479Sdim assert(CU && "CUDie should belong to a CU."); 386276479Sdim Addr += CU->getDebugInfoOffset(); 387276479Sdim if (AP->MAI->doesDwarfUseRelocationsAcrossSections()) 388276479Sdim AP->EmitLabelPlusOffset(CU->getSectionSym(), Addr, 389276479Sdim DIEEntry::getRefAddrSize(AP)); 390276479Sdim else 391276479Sdim AP->EmitLabelOffsetDifference(CU->getSectionSym(), Addr, 392276479Sdim CU->getSectionSym(), 393276479Sdim DIEEntry::getRefAddrSize(AP)); 394276479Sdim } else 395276479Sdim AP->EmitInt32(Entry.getOffset()); 396193323Sed} 397193323Sed 398261991Sdimunsigned DIEEntry::getRefAddrSize(AsmPrinter *AP) { 399261991Sdim // DWARF4: References that use the attribute form DW_FORM_ref_addr are 400261991Sdim // specified to be four bytes in the DWARF 32-bit format and eight bytes 401261991Sdim // in the DWARF 64-bit format, while DWARF Version 2 specifies that such 402261991Sdim // references have the same size as an address on the target system. 403276479Sdim const DwarfDebug *DD = AP->getDwarfDebug(); 404276479Sdim assert(DD && "Expected Dwarf Debug info to be available"); 405276479Sdim if (DD->getDwarfVersion() == 2) 406261991Sdim return AP->getDataLayout().getPointerSize(); 407261991Sdim return sizeof(int32_t); 408261991Sdim} 409261991Sdim 410193323Sed#ifndef NDEBUG 411261991Sdimvoid DIEEntry::print(raw_ostream &O) const { 412276479Sdim O << format("Die: 0x%lx", (long)(intptr_t)&Entry); 413193323Sed} 414193323Sed#endif 415193323Sed 416193323Sed//===----------------------------------------------------------------------===// 417276479Sdim// DIETypeSignature Implementation 418276479Sdim//===----------------------------------------------------------------------===// 419276479Sdimvoid DIETypeSignature::EmitValue(AsmPrinter *Asm, dwarf::Form Form) const { 420276479Sdim assert(Form == dwarf::DW_FORM_ref_sig8); 421276479Sdim Asm->OutStreamer.EmitIntValue(Unit.getTypeSignature(), 8); 422276479Sdim} 423276479Sdim 424276479Sdim#ifndef NDEBUG 425276479Sdimvoid DIETypeSignature::print(raw_ostream &O) const { 426276479Sdim O << format("Type Unit: 0x%lx", Unit.getTypeSignature()); 427276479Sdim} 428276479Sdim 429276479Sdimvoid DIETypeSignature::dump() const { print(dbgs()); } 430276479Sdim#endif 431276479Sdim 432276479Sdim//===----------------------------------------------------------------------===// 433276479Sdim// DIELoc Implementation 434276479Sdim//===----------------------------------------------------------------------===// 435276479Sdim 436276479Sdim/// ComputeSize - calculate the size of the location expression. 437276479Sdim/// 438276479Sdimunsigned DIELoc::ComputeSize(AsmPrinter *AP) const { 439276479Sdim if (!Size) { 440276479Sdim const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData(); 441276479Sdim for (unsigned i = 0, N = Values.size(); i < N; ++i) 442276479Sdim Size += Values[i]->SizeOf(AP, AbbrevData[i].getForm()); 443276479Sdim } 444276479Sdim 445276479Sdim return Size; 446276479Sdim} 447276479Sdim 448276479Sdim/// EmitValue - Emit location data. 449276479Sdim/// 450276479Sdimvoid DIELoc::EmitValue(AsmPrinter *Asm, dwarf::Form Form) const { 451276479Sdim switch (Form) { 452276479Sdim default: llvm_unreachable("Improper form for block"); 453276479Sdim case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break; 454276479Sdim case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break; 455276479Sdim case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break; 456276479Sdim case dwarf::DW_FORM_block: 457276479Sdim case dwarf::DW_FORM_exprloc: 458276479Sdim Asm->EmitULEB128(Size); break; 459276479Sdim } 460276479Sdim 461276479Sdim const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData(); 462276479Sdim for (unsigned i = 0, N = Values.size(); i < N; ++i) 463276479Sdim Values[i]->EmitValue(Asm, AbbrevData[i].getForm()); 464276479Sdim} 465276479Sdim 466276479Sdim/// SizeOf - Determine size of location data in bytes. 467276479Sdim/// 468276479Sdimunsigned DIELoc::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 469276479Sdim switch (Form) { 470276479Sdim case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); 471276479Sdim case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); 472276479Sdim case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); 473276479Sdim case dwarf::DW_FORM_block: 474276479Sdim case dwarf::DW_FORM_exprloc: 475276479Sdim return Size + getULEB128Size(Size); 476276479Sdim default: llvm_unreachable("Improper form for block"); 477276479Sdim } 478276479Sdim} 479276479Sdim 480276479Sdim#ifndef NDEBUG 481276479Sdimvoid DIELoc::print(raw_ostream &O) const { 482276479Sdim O << "ExprLoc: "; 483276479Sdim DIE::print(O, 5); 484276479Sdim} 485276479Sdim#endif 486276479Sdim 487276479Sdim//===----------------------------------------------------------------------===// 488193323Sed// DIEBlock Implementation 489193323Sed//===----------------------------------------------------------------------===// 490193323Sed 491193323Sed/// ComputeSize - calculate the size of the block. 492193323Sed/// 493276479Sdimunsigned DIEBlock::ComputeSize(AsmPrinter *AP) const { 494193323Sed if (!Size) { 495249423Sdim const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData(); 496193323Sed for (unsigned i = 0, N = Values.size(); i < N; ++i) 497206274Srdivacky Size += Values[i]->SizeOf(AP, AbbrevData[i].getForm()); 498193323Sed } 499193323Sed 500193323Sed return Size; 501193323Sed} 502193323Sed 503193323Sed/// EmitValue - Emit block data. 504193323Sed/// 505261991Sdimvoid DIEBlock::EmitValue(AsmPrinter *Asm, dwarf::Form Form) const { 506193323Sed switch (Form) { 507234353Sdim default: llvm_unreachable("Improper form for block"); 508206274Srdivacky case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break; 509206274Srdivacky case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break; 510206274Srdivacky case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break; 511206274Srdivacky case dwarf::DW_FORM_block: Asm->EmitULEB128(Size); break; 512193323Sed } 513193323Sed 514249423Sdim const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData(); 515204961Srdivacky for (unsigned i = 0, N = Values.size(); i < N; ++i) 516206274Srdivacky Values[i]->EmitValue(Asm, AbbrevData[i].getForm()); 517193323Sed} 518193323Sed 519193323Sed/// SizeOf - Determine size of block data in bytes. 520193323Sed/// 521261991Sdimunsigned DIEBlock::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 522193323Sed switch (Form) { 523193323Sed case dwarf::DW_FORM_block1: return Size + sizeof(int8_t); 524193323Sed case dwarf::DW_FORM_block2: return Size + sizeof(int16_t); 525193323Sed case dwarf::DW_FORM_block4: return Size + sizeof(int32_t); 526276479Sdim case dwarf::DW_FORM_block: return Size + getULEB128Size(Size); 527234353Sdim default: llvm_unreachable("Improper form for block"); 528193323Sed } 529193323Sed} 530193323Sed 531193323Sed#ifndef NDEBUG 532261991Sdimvoid DIEBlock::print(raw_ostream &O) const { 533193323Sed O << "Blk: "; 534193323Sed DIE::print(O, 5); 535193323Sed} 536193323Sed#endif 537276479Sdim 538276479Sdim//===----------------------------------------------------------------------===// 539276479Sdim// DIELocList Implementation 540276479Sdim//===----------------------------------------------------------------------===// 541276479Sdim 542276479Sdimunsigned DIELocList::SizeOf(AsmPrinter *AP, dwarf::Form Form) const { 543276479Sdim if (Form == dwarf::DW_FORM_data4) 544276479Sdim return 4; 545276479Sdim if (Form == dwarf::DW_FORM_sec_offset) 546276479Sdim return 4; 547276479Sdim return AP->getDataLayout().getPointerSize(); 548276479Sdim} 549276479Sdim 550276479Sdim/// EmitValue - Emit label value. 551276479Sdim/// 552276479Sdimvoid DIELocList::EmitValue(AsmPrinter *AP, dwarf::Form Form) const { 553276479Sdim DwarfDebug *DD = AP->getDwarfDebug(); 554276479Sdim MCSymbol *Label = DD->getDebugLocEntries()[Index].Label; 555276479Sdim 556276479Sdim if (AP->MAI->doesDwarfUseRelocationsAcrossSections() && !DD->useSplitDwarf()) 557276479Sdim AP->EmitSectionOffset(Label, DD->getDebugLocSym()); 558276479Sdim else 559276479Sdim AP->EmitLabelDifference(Label, DD->getDebugLocSym(), 4); 560276479Sdim} 561276479Sdim 562276479Sdim#ifndef NDEBUG 563276479Sdimvoid DIELocList::print(raw_ostream &O) const { 564276479Sdim O << "LocList: " << Index; 565276479Sdim 566276479Sdim} 567276479Sdim#endif 568