DIE.h revision 146c6f7e026d4c91ed4fb030660f5af245ee03c6
1//===--- lib/CodeGen/DIE.h - DWARF Info Entries -----------------*- C++ -*-===// 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#ifndef CODEGEN_ASMPRINTER_DIE_H__ 15#define CODEGEN_ASMPRINTER_DIE_H__ 16 17#include "llvm/ADT/FoldingSet.h" 18#include "llvm/ADT/SmallVector.h" 19#include "llvm/Support/Compiler.h" 20#include "llvm/Support/Dwarf.h" 21#include <vector> 22 23namespace llvm { 24 class AsmPrinter; 25 class MCSymbol; 26 class raw_ostream; 27 28 //===--------------------------------------------------------------------===// 29 /// DIEAbbrevData - Dwarf abbreviation data, describes the one attribute of a 30 /// Dwarf abbreviation. 31 class DIEAbbrevData { 32 /// Attribute - Dwarf attribute code. 33 /// 34 unsigned Attribute; 35 36 /// Form - Dwarf form code. 37 /// 38 unsigned Form; 39 public: 40 DIEAbbrevData(unsigned A, unsigned F) : Attribute(A), Form(F) {} 41 42 // Accessors. 43 unsigned getAttribute() const { return Attribute; } 44 unsigned getForm() const { return Form; } 45 46 /// Profile - Used to gather unique data for the abbreviation folding set. 47 /// 48 void Profile(FoldingSetNodeID &ID) const; 49 }; 50 51 //===--------------------------------------------------------------------===// 52 /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug 53 /// information object. 54 class DIEAbbrev : public FoldingSetNode { 55 /// Tag - Dwarf tag code. 56 /// 57 unsigned Tag; 58 59 /// Unique number for node. 60 /// 61 unsigned Number; 62 63 /// ChildrenFlag - Dwarf children flag. 64 /// 65 unsigned ChildrenFlag; 66 67 /// Data - Raw data bytes for abbreviation. 68 /// 69 SmallVector<DIEAbbrevData, 8> Data; 70 71 public: 72 DIEAbbrev(unsigned T, unsigned C) : Tag(T), ChildrenFlag(C), Data() {} 73 virtual ~DIEAbbrev() {} 74 75 // Accessors. 76 unsigned getTag() const { return Tag; } 77 unsigned getNumber() const { return Number; } 78 unsigned getChildrenFlag() const { return ChildrenFlag; } 79 const SmallVector<DIEAbbrevData, 8> &getData() const { return Data; } 80 void setTag(unsigned T) { Tag = T; } 81 void setChildrenFlag(unsigned CF) { ChildrenFlag = CF; } 82 void setNumber(unsigned N) { Number = N; } 83 84 /// AddAttribute - Adds another set of attribute information to the 85 /// abbreviation. 86 void AddAttribute(unsigned Attribute, unsigned Form) { 87 Data.push_back(DIEAbbrevData(Attribute, Form)); 88 } 89 90 /// AddFirstAttribute - Adds a set of attribute information to the front 91 /// of the abbreviation. 92 void AddFirstAttribute(unsigned Attribute, unsigned Form) { 93 Data.insert(Data.begin(), DIEAbbrevData(Attribute, Form)); 94 } 95 96 /// Profile - Used to gather unique data for the abbreviation folding set. 97 /// 98 void Profile(FoldingSetNodeID &ID) const; 99 100 /// Emit - Print the abbreviation using the specified asm printer. 101 /// 102 void Emit(AsmPrinter *AP) const; 103 104#ifndef NDEBUG 105 void print(raw_ostream &O); 106 void dump(); 107#endif 108 }; 109 110 //===--------------------------------------------------------------------===// 111 /// DIE - A structured debug information entry. Has an abbreviation which 112 /// describes it's organization. 113 class DIEValue; 114 115 class DIE { 116 protected: 117 /// Abbrev - Buffer for constructing abbreviation. 118 /// 119 DIEAbbrev Abbrev; 120 121 /// Offset - Offset in debug info section. 122 /// 123 unsigned Offset; 124 125 /// Size - Size of instance + children. 126 /// 127 unsigned Size; 128 129 /// Children DIEs. 130 /// 131 std::vector<DIE *> Children; 132 133 DIE *Parent; 134 135 /// Attributes values. 136 /// 137 SmallVector<DIEValue*, 32> Values; 138 139 // Private data for print() 140 mutable unsigned IndentCount; 141 public: 142 explicit DIE(unsigned Tag) 143 : Abbrev(Tag, dwarf::DW_CHILDREN_no), Offset(0), 144 Size(0), Parent (0), IndentCount(0) {} 145 virtual ~DIE(); 146 147 // Accessors. 148 DIEAbbrev &getAbbrev() { return Abbrev; } 149 unsigned getAbbrevNumber() const { return Abbrev.getNumber(); } 150 unsigned getTag() const { return Abbrev.getTag(); } 151 unsigned getOffset() const { return Offset; } 152 unsigned getSize() const { return Size; } 153 const std::vector<DIE *> &getChildren() const { return Children; } 154 const SmallVector<DIEValue*, 32> &getValues() const { return Values; } 155 DIE *getParent() const { return Parent; } 156 void setTag(unsigned Tag) { Abbrev.setTag(Tag); } 157 void setOffset(unsigned O) { Offset = O; } 158 void setSize(unsigned S) { Size = S; } 159 160 /// addValue - Add a value and attributes to a DIE. 161 /// 162 void addValue(unsigned Attribute, unsigned Form, DIEValue *Value) { 163 Abbrev.AddAttribute(Attribute, Form); 164 Values.push_back(Value); 165 } 166 167 /// SiblingOffset - Return the offset of the debug information entry's 168 /// sibling. 169 unsigned getSiblingOffset() const { return Offset + Size; } 170 171 /// addSiblingOffset - Add a sibling offset field to the front of the DIE. 172 /// The caller is responsible for deleting the return value at or after the 173 /// same time it destroys this DIE. 174 /// 175 DIEValue *addSiblingOffset(BumpPtrAllocator &A); 176 177 /// addChild - Add a child to the DIE. 178 /// 179 void addChild(DIE *Child) { 180 if (Child->getParent()) { 181 assert (Child->getParent() == this && "Unexpected DIE Parent!"); 182 return; 183 } 184 Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes); 185 Children.push_back(Child); 186 Child->Parent = this; 187 } 188 189#ifndef NDEBUG 190 void print(raw_ostream &O, unsigned IncIndent = 0); 191 void dump(); 192#endif 193 }; 194 195 //===--------------------------------------------------------------------===// 196 /// DIEValue - A debug information entry value. 197 /// 198 class DIEValue { 199 public: 200 enum { 201 isInteger, 202 isString, 203 isLabel, 204 isSectionOffset, 205 isDelta, 206 isEntry, 207 isBlock 208 }; 209 protected: 210 /// Type - Type of data stored in the value. 211 /// 212 unsigned Type; 213 public: 214 explicit DIEValue(unsigned T) : Type(T) {} 215 virtual ~DIEValue() {} 216 217 // Accessors 218 unsigned getType() const { return Type; } 219 220 /// EmitValue - Emit value via the Dwarf writer. 221 /// 222 virtual void EmitValue(AsmPrinter *AP, unsigned Form) const = 0; 223 224 /// SizeOf - Return the size of a value in bytes. 225 /// 226 virtual unsigned SizeOf(AsmPrinter *AP, unsigned Form) const = 0; 227 228 // Implement isa/cast/dyncast. 229 static bool classof(const DIEValue *) { return true; } 230 231#ifndef NDEBUG 232 virtual void print(raw_ostream &O) = 0; 233 void dump(); 234#endif 235 }; 236 237 //===--------------------------------------------------------------------===// 238 /// DIEInteger - An integer value DIE. 239 /// 240 class DIEInteger : public DIEValue { 241 uint64_t Integer; 242 public: 243 explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {} 244 245 /// BestForm - Choose the best form for integer. 246 /// 247 static unsigned BestForm(bool IsSigned, uint64_t Int) { 248 if (IsSigned) { 249 if ((char)Int == (signed)Int) return dwarf::DW_FORM_data1; 250 if ((short)Int == (signed)Int) return dwarf::DW_FORM_data2; 251 if ((int)Int == (signed)Int) return dwarf::DW_FORM_data4; 252 } else { 253 if ((unsigned char)Int == Int) return dwarf::DW_FORM_data1; 254 if ((unsigned short)Int == Int) return dwarf::DW_FORM_data2; 255 if ((unsigned int)Int == Int) return dwarf::DW_FORM_data4; 256 } 257 return dwarf::DW_FORM_data8; 258 } 259 260 /// EmitValue - Emit integer of appropriate size. 261 /// 262 virtual void EmitValue(AsmPrinter *AP, unsigned Form) const; 263 264 uint64_t getValue() const { return Integer; } 265 266 /// SizeOf - Determine size of integer value in bytes. 267 /// 268 virtual unsigned SizeOf(AsmPrinter *AP, unsigned Form) const; 269 270 // Implement isa/cast/dyncast. 271 static bool classof(const DIEInteger *) { return true; } 272 static bool classof(const DIEValue *I) { return I->getType() == isInteger; } 273 274#ifndef NDEBUG 275 virtual void print(raw_ostream &O); 276#endif 277 }; 278 279 //===--------------------------------------------------------------------===// 280 /// DIEString - A string value DIE. This DIE keeps string reference only. 281 /// 282 class DIEString : public DIEValue { 283 const StringRef Str; 284 public: 285 explicit DIEString(const StringRef S) : DIEValue(isString), Str(S) {} 286 287 /// EmitValue - Emit string value. 288 /// 289 virtual void EmitValue(AsmPrinter *AP, unsigned Form) const; 290 291 /// SizeOf - Determine size of string value in bytes. 292 /// 293 virtual unsigned SizeOf(AsmPrinter *AP, unsigned /*Form*/) const { 294 return Str.size() + sizeof(char); // sizeof('\0'); 295 } 296 297 // Implement isa/cast/dyncast. 298 static bool classof(const DIEString *) { return true; } 299 static bool classof(const DIEValue *S) { return S->getType() == isString; } 300 301#ifndef NDEBUG 302 virtual void print(raw_ostream &O); 303#endif 304 }; 305 306 //===--------------------------------------------------------------------===// 307 /// DIELabel - A label expression DIE. 308 // 309 class DIELabel : public DIEValue { 310 const MCSymbol *Label; 311 public: 312 explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {} 313 314 /// EmitValue - Emit label value. 315 /// 316 virtual void EmitValue(AsmPrinter *AP, unsigned Form) const; 317 318 /// SizeOf - Determine size of label value in bytes. 319 /// 320 virtual unsigned SizeOf(AsmPrinter *AP, unsigned Form) const; 321 322 // Implement isa/cast/dyncast. 323 static bool classof(const DIELabel *) { return true; } 324 static bool classof(const DIEValue *L) { return L->getType() == isLabel; } 325 326#ifndef NDEBUG 327 virtual void print(raw_ostream &O); 328#endif 329 }; 330 331 //===--------------------------------------------------------------------===// 332 /// DIEDelta - A simple label difference DIE. 333 /// 334 class DIEDelta : public DIEValue { 335 const MCSymbol *LabelHi; 336 const MCSymbol *LabelLo; 337 public: 338 DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) 339 : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {} 340 341 /// EmitValue - Emit delta value. 342 /// 343 virtual void EmitValue(AsmPrinter *AP, unsigned Form) const; 344 345 /// SizeOf - Determine size of delta value in bytes. 346 /// 347 virtual unsigned SizeOf(AsmPrinter *AP, unsigned Form) const; 348 349 // Implement isa/cast/dyncast. 350 static bool classof(const DIEDelta *) { return true; } 351 static bool classof(const DIEValue *D) { return D->getType() == isDelta; } 352 353#ifndef NDEBUG 354 virtual void print(raw_ostream &O); 355#endif 356 }; 357 358 //===--------------------------------------------------------------------===// 359 /// DIEntry - A pointer to another debug information entry. An instance of 360 /// this class can also be used as a proxy for a debug information entry not 361 /// yet defined (ie. types.) 362 class DIEEntry : public DIEValue { 363 DIE *const Entry; 364 public: 365 explicit DIEEntry(DIE *E) : DIEValue(isEntry), Entry(E) {} 366 367 DIE *getEntry() const { return Entry; } 368 369 /// EmitValue - Emit debug information entry offset. 370 /// 371 virtual void EmitValue(AsmPrinter *AP, unsigned Form) const; 372 373 /// SizeOf - Determine size of debug information entry in bytes. 374 /// 375 virtual unsigned SizeOf(AsmPrinter *AP, unsigned Form) const { 376 return sizeof(int32_t); 377 } 378 379 // Implement isa/cast/dyncast. 380 static bool classof(const DIEEntry *) { return true; } 381 static bool classof(const DIEValue *E) { return E->getType() == isEntry; } 382 383#ifndef NDEBUG 384 virtual void print(raw_ostream &O); 385#endif 386 }; 387 388 //===--------------------------------------------------------------------===// 389 /// DIEBlock - A block of values. Primarily used for location expressions. 390 // 391 class DIEBlock : public DIEValue, public DIE { 392 unsigned Size; // Size in bytes excluding size header. 393 public: 394 DIEBlock() 395 : DIEValue(isBlock), DIE(0), Size(0) {} 396 virtual ~DIEBlock() {} 397 398 /// ComputeSize - calculate the size of the block. 399 /// 400 unsigned ComputeSize(AsmPrinter *AP); 401 402 /// BestForm - Choose the best form for data. 403 /// 404 unsigned BestForm() const { 405 if ((unsigned char)Size == Size) return dwarf::DW_FORM_block1; 406 if ((unsigned short)Size == Size) return dwarf::DW_FORM_block2; 407 if ((unsigned int)Size == Size) return dwarf::DW_FORM_block4; 408 return dwarf::DW_FORM_block; 409 } 410 411 /// EmitValue - Emit block data. 412 /// 413 virtual void EmitValue(AsmPrinter *AP, unsigned Form) const; 414 415 /// SizeOf - Determine size of block data in bytes. 416 /// 417 virtual unsigned SizeOf(AsmPrinter *AP, unsigned Form) const; 418 419 // Implement isa/cast/dyncast. 420 static bool classof(const DIEBlock *) { return true; } 421 static bool classof(const DIEValue *E) { return E->getType() == isBlock; } 422 423#ifndef NDEBUG 424 virtual void print(raw_ostream &O); 425#endif 426 }; 427 428} // end llvm namespace 429 430#endif 431