lib/CodeGen/AsmPrinter/DIE.cpp

   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 "DIE.h"
  15 #include "DwarfPrinter.h"
  16 #include "llvm/CodeGen/AsmPrinter.h"
  17 #include "llvm/MC/MCAsmInfo.h"
  18 #include "llvm/Target/TargetData.h"
  19 #include "llvm/Support/Debug.h"
  20 #include "llvm/Support/ErrorHandling.h"
  21 #include "llvm/Support/Format.h"
  22 using namespace llvm;
  23
  24 //===----------------------------------------------------------------------===//
  25 // DIEAbbrevData Implementation
  26 //===----------------------------------------------------------------------===//
  27
  28 /// Profile - Used to gather unique data for the abbreviation folding set.
  29 ///
  30 void DIEAbbrevData::Profile(FoldingSetNodeID &ID) const {
  31   ID.AddInteger(Attribute);
  32   ID.AddInteger(Form);
  33 }
  34
  35 //===----------------------------------------------------------------------===//
  36 // DIEAbbrev Implementation
  37 //===----------------------------------------------------------------------===//
  38
  39 /// Profile - Used to gather unique data for the abbreviation folding set.
  40 ///
  41 void DIEAbbrev::Profile(FoldingSetNodeID &ID) const {
  42   ID.AddInteger(Tag);
  43   ID.AddInteger(ChildrenFlag);
  44
  45   // For each attribute description.
  46   for (unsigned i = 0, N = Data.size(); i < N; ++i)
  47     Data[i].Profile(ID);
  48 }
  49
  50 /// Emit - Print the abbreviation using the specified asm printer.
  51 ///
  52 void DIEAbbrev::Emit(const AsmPrinter *Asm) const {
  53   // Emit its Dwarf tag type.
  54   Asm->EmitULEB128Bytes(Tag);
  55   Asm->EOL(dwarf::TagString(Tag));
  56
  57   // Emit whether it has children DIEs.
  58   Asm->EmitULEB128Bytes(ChildrenFlag);
  59   Asm->EOL(dwarf::ChildrenString(ChildrenFlag));
  60
  61   // For each attribute description.
  62   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
  63     const DIEAbbrevData &AttrData = Data[i];
  64
  65     // Emit attribute type.
  66     Asm->EmitULEB128Bytes(AttrData.getAttribute());
  67     Asm->EOL(dwarf::AttributeString(AttrData.getAttribute()));
  68
  69     // Emit form type.
  70     Asm->EmitULEB128Bytes(AttrData.getForm());
  71     Asm->EOL(dwarf::FormEncodingString(AttrData.getForm()));
  72   }
  73
  74   // Mark end of abbreviation.
  75   Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(1)");
  76   Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(2)");
  77 }
  78
  79 #ifndef NDEBUG
  80 void DIEAbbrev::print(raw_ostream &O) {
  81   O << "Abbreviation @"
  82     << format("0x%lx", (long)(intptr_t)this)
  83     << "  "
  84     << dwarf::TagString(Tag)
  85     << " "
  86     << dwarf::ChildrenString(ChildrenFlag)
  87     << '\n';
  88
  89   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
  90     O << "  "
  91       << dwarf::AttributeString(Data[i].getAttribute())
  92       << "  "
  93       << dwarf::FormEncodingString(Data[i].getForm())
  94       << '\n';
  95   }
  96 }
  97 void DIEAbbrev::dump() { print(dbgs()); }
  98 #endif
  99
 100 //===----------------------------------------------------------------------===//
 101 // DIE Implementation
 102 //===----------------------------------------------------------------------===//
 103
 104 DIE::~DIE() {
 105   for (unsigned i = 0, N = Children.size(); i < N; ++i)
 106     delete Children[i];
 107 }
 108
 109 /// addSiblingOffset - Add a sibling offset field to the front of the DIE.
 110 ///
 111 void DIE::addSiblingOffset() {
 112   DIEInteger *DI = new DIEInteger(0);
 113   Values.insert(Values.begin(), DI);
 114   Abbrev.AddFirstAttribute(dwarf::DW_AT_sibling, dwarf::DW_FORM_ref4);
 115 }
 116
 117 #ifndef NDEBUG
 118 void DIE::print(raw_ostream &O, unsigned IncIndent) {
 119   IndentCount += IncIndent;
 120   const std::string Indent(IndentCount, ' ');
 121   bool isBlock = Abbrev.getTag() == 0;
 122
 123   if (!isBlock) {
 124     O << Indent
 125       << "Die: "
 126       << format("0x%lx", (long)(intptr_t)this)
 127       << ", Offset: " << Offset
 128       << ", Size: " << Size
 129       << "\n";
 130
 131     O << Indent
 132       << dwarf::TagString(Abbrev.getTag())
 133       << " "
 134       << dwarf::ChildrenString(Abbrev.getChildrenFlag());
 135   } else {
 136     O << "Size: " << Size;
 137   }
 138   O << "\n";
 139
 140   const SmallVector<DIEAbbrevData, 8> &Data = Abbrev.getData();
 141
 142   IndentCount += 2;
 143   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
 144     O << Indent;
 145
 146     if (!isBlock)
 147       O << dwarf::AttributeString(Data[i].getAttribute());
 148     else
 149       O << "Blk[" << i << "]";
 150
 151     O <<  "  "
 152       << dwarf::FormEncodingString(Data[i].getForm())
 153       << " ";
 154     Values[i]->print(O);
 155     O << "\n";
 156   }
 157   IndentCount -= 2;
 158
 159   for (unsigned j = 0, M = Children.size(); j < M; ++j) {
 160     Children[j]->print(O, 4);
 161   }
 162
 163   if (!isBlock) O << "\n";
 164   IndentCount -= IncIndent;
 165 }
 166
 167 void DIE::dump() {
 168   print(dbgs());
 169 }
 170 #endif
 171
 172
 173 #ifndef NDEBUG
 174 void DIEValue::dump() {
 175   print(dbgs());
 176 }
 177 #endif
 178
 179 //===----------------------------------------------------------------------===//
 180 // DIEInteger Implementation
 181 //===----------------------------------------------------------------------===//
 182
 183 /// EmitValue - Emit integer of appropriate size.
 184 ///
 185 void DIEInteger::EmitValue(Dwarf *D, unsigned Form) const {
 186   const AsmPrinter *Asm = D->getAsm();
 187   switch (Form) {
 188   case dwarf::DW_FORM_flag:  // Fall thru
 189   case dwarf::DW_FORM_ref1:  // Fall thru
 190   case dwarf::DW_FORM_data1: Asm->EmitInt8(Integer);         break;
 191   case dwarf::DW_FORM_ref2:  // Fall thru
 192   case dwarf::DW_FORM_data2: Asm->EmitInt16(Integer);        break;
 193   case dwarf::DW_FORM_ref4:  // Fall thru
 194   case dwarf::DW_FORM_data4: Asm->EmitInt32(Integer);        break;
 195   case dwarf::DW_FORM_ref8:  // Fall thru
 196   case dwarf::DW_FORM_data8: Asm->EmitInt64(Integer);        break;
 197   case dwarf::DW_FORM_udata: Asm->EmitULEB128Bytes(Integer); break;
 198   case dwarf::DW_FORM_sdata: Asm->EmitSLEB128Bytes(Integer); break;
 199   default: llvm_unreachable("DIE Value form not supported yet");
 200   }
 201 }
 202
 203 /// SizeOf - Determine size of integer value in bytes.
 204 ///
 205 unsigned DIEInteger::SizeOf(const TargetData *TD, unsigned Form) const {
 206   switch (Form) {
 207   case dwarf::DW_FORM_flag:  // Fall thru
 208   case dwarf::DW_FORM_ref1:  // Fall thru
 209   case dwarf::DW_FORM_data1: return sizeof(int8_t);
 210   case dwarf::DW_FORM_ref2:  // Fall thru
 211   case dwarf::DW_FORM_data2: return sizeof(int16_t);
 212   case dwarf::DW_FORM_ref4:  // Fall thru
 213   case dwarf::DW_FORM_data4: return sizeof(int32_t);
 214   case dwarf::DW_FORM_ref8:  // Fall thru
 215   case dwarf::DW_FORM_data8: return sizeof(int64_t);
 216   case dwarf::DW_FORM_udata: return MCAsmInfo::getULEB128Size(Integer);
 217   case dwarf::DW_FORM_sdata: return MCAsmInfo::getSLEB128Size(Integer);
 218   default: llvm_unreachable("DIE Value form not supported yet"); break;
 219   }
 220   return 0;
 221 }
 222
 223 #ifndef NDEBUG
 224 void DIEInteger::print(raw_ostream &O) {
 225   O << "Int: " << (int64_t)Integer
 226     << format("  0x%llx", (unsigned long long)Integer);
 227 }
 228 #endif
 229
 230 //===----------------------------------------------------------------------===//
 231 // DIEString Implementation
 232 //===----------------------------------------------------------------------===//
 233
 234 /// EmitValue - Emit string value.
 235 ///
 236 void DIEString::EmitValue(Dwarf *D, unsigned Form) const {
 237   D->getAsm()->EmitString(Str);
 238 }
 239
 240 #ifndef NDEBUG
 241 void DIEString::print(raw_ostream &O) {
 242   O << "Str: \"" << Str << "\"";
 243 }
 244 #endif
 245
 246 //===----------------------------------------------------------------------===//
 247 // DIEDwarfLabel Implementation
 248 //===----------------------------------------------------------------------===//
 249
 250 /// EmitValue - Emit label value.
 251 ///
 252 void DIEDwarfLabel::EmitValue(Dwarf *D, unsigned Form) const {
 253   bool IsSmall = Form == dwarf::DW_FORM_data4;
 254   D->EmitReference(Label, false, IsSmall);
 255 }
 256
 257 /// SizeOf - Determine size of label value in bytes.
 258 ///
 259 unsigned DIEDwarfLabel::SizeOf(const TargetData *TD, unsigned Form) const {
 260   if (Form == dwarf::DW_FORM_data4) return 4;
 261   return TD->getPointerSize();
 262 }
 263
 264 #ifndef NDEBUG
 265 void DIEDwarfLabel::print(raw_ostream &O) {
 266   O << "Lbl: ";
 267   Label.print(O);
 268 }
 269 #endif
 270
 271 //===----------------------------------------------------------------------===//
 272 // DIEObjectLabel Implementation
 273 //===----------------------------------------------------------------------===//
 274
 275 /// EmitValue - Emit label value.
 276 ///
 277 void DIEObjectLabel::EmitValue(Dwarf *D, unsigned Form) const {
 278   bool IsSmall = Form == dwarf::DW_FORM_data4;
 279   D->EmitReference(Label, false, IsSmall);
 280 }
 281
 282 /// SizeOf - Determine size of label value in bytes.
 283 ///
 284 unsigned DIEObjectLabel::SizeOf(const TargetData *TD, unsigned Form) const {
 285   if (Form == dwarf::DW_FORM_data4) return 4;
 286   return TD->getPointerSize();
 287 }
 288
 289 #ifndef NDEBUG
 290 void DIEObjectLabel::print(raw_ostream &O) {
 291   O << "Obj: " << Label;
 292 }
 293 #endif
 294
 295 //===----------------------------------------------------------------------===//
 296 // DIESectionOffset Implementation
 297 //===----------------------------------------------------------------------===//
 298
 299 /// EmitValue - Emit delta value.
 300 ///
 301 void DIESectionOffset::EmitValue(Dwarf *D, unsigned Form) const {
 302   bool IsSmall = Form == dwarf::DW_FORM_data4;
 303   D->EmitSectionOffset(Label.getTag(), Section.getTag(),
 304                        Label.getNumber(), Section.getNumber(),
 305                        IsSmall, IsEH, UseSet);
 306 }
 307
 308 /// SizeOf - Determine size of delta value in bytes.
 309 ///
 310 unsigned DIESectionOffset::SizeOf(const TargetData *TD, unsigned Form) const {
 311   if (Form == dwarf::DW_FORM_data4) return 4;
 312   return TD->getPointerSize();
 313 }
 314
 315 #ifndef NDEBUG
 316 void DIESectionOffset::print(raw_ostream &O) {
 317   O << "Off: ";
 318   Label.print(O);
 319   O << "-";
 320   Section.print(O);
 321   O << "-" << IsEH << "-" << UseSet;
 322 }
 323 #endif
 324
 325 //===----------------------------------------------------------------------===//
 326 // DIEDelta Implementation
 327 //===----------------------------------------------------------------------===//
 328
 329 /// EmitValue - Emit delta value.
 330 ///
 331 void DIEDelta::EmitValue(Dwarf *D, unsigned Form) const {
 332   bool IsSmall = Form == dwarf::DW_FORM_data4;
 333   D->EmitDifference(LabelHi, LabelLo, IsSmall);
 334 }
 335
 336 /// SizeOf - Determine size of delta value in bytes.
 337 ///
 338 unsigned DIEDelta::SizeOf(const TargetData *TD, unsigned Form) const {
 339   if (Form == dwarf::DW_FORM_data4) return 4;
 340   return TD->getPointerSize();
 341 }
 342
 343 #ifndef NDEBUG
 344 void DIEDelta::print(raw_ostream &O) {
 345   O << "Del: ";
 346   LabelHi.print(O);
 347   O << "-";
 348   LabelLo.print(O);
 349 }
 350 #endif
 351
 352 //===----------------------------------------------------------------------===//
 353 // DIEEntry Implementation
 354 //===----------------------------------------------------------------------===//
 355
 356 /// EmitValue - Emit debug information entry offset.
 357 ///
 358 void DIEEntry::EmitValue(Dwarf *D, unsigned Form) const {
 359   D->getAsm()->EmitInt32(Entry->getOffset());
 360 }
 361
 362 #ifndef NDEBUG
 363 void DIEEntry::print(raw_ostream &O) {
 364   O << format("Die: 0x%lx", (long)(intptr_t)Entry);
 365 }
 366 #endif
 367
 368 //===----------------------------------------------------------------------===//
 369 // DIEBlock Implementation
 370 //===----------------------------------------------------------------------===//
 371
 372 /// ComputeSize - calculate the size of the block.
 373 ///
 374 unsigned DIEBlock::ComputeSize(const TargetData *TD) {
 375   if (!Size) {
 376     const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
 377     for (unsigned i = 0, N = Values.size(); i < N; ++i)
 378       Size += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
 379   }
 380
 381   return Size;
 382 }
 383
 384 /// EmitValue - Emit block data.
 385 ///
 386 void DIEBlock::EmitValue(Dwarf *D, unsigned Form) const {
 387   const AsmPrinter *Asm = D->getAsm();
 388   switch (Form) {
 389   case dwarf::DW_FORM_block1: Asm->EmitInt8(Size);         break;
 390   case dwarf::DW_FORM_block2: Asm->EmitInt16(Size);        break;
 391   case dwarf::DW_FORM_block4: Asm->EmitInt32(Size);        break;
 392   case dwarf::DW_FORM_block:  Asm->EmitULEB128Bytes(Size); break;
 393   default: llvm_unreachable("Improper form for block");         break;
 394   }
 395
 396   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
 397   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
 398     Asm->EOL();
 399     Values[i]->EmitValue(D, AbbrevData[i].getForm());
 400   }
 401 }
 402
 403 /// SizeOf - Determine size of block data in bytes.
 404 ///
 405 unsigned DIEBlock::SizeOf(const TargetData *TD, unsigned Form) const {
 406   switch (Form) {
 407   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
 408   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
 409   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
 410   case dwarf::DW_FORM_block: return Size + MCAsmInfo::getULEB128Size(Size);
 411   default: llvm_unreachable("Improper form for block"); break;
 412   }
 413   return 0;
 414 }
 415
 416 #ifndef NDEBUG
 417 void DIEBlock::print(raw_ostream &O) {
 418   O << "Blk: ";
 419   DIE::print(O, 5);
 420 }
 421 #endif