DIE.h revision 200581
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 "DwarfLabel.h" 18#include "llvm/ADT/FoldingSet.h" 19#include "llvm/ADT/SmallVector.h" 20#include "llvm/Support/Compiler.h" 21#include "llvm/Support/Dwarf.h" 22#include <vector> 23 24namespace llvm { 25 class AsmPrinter; 26 class Dwarf; 27 class TargetData; 28 29 //===--------------------------------------------------------------------===// 30 /// DIEAbbrevData - Dwarf abbreviation data, describes the one attribute of a 31 /// Dwarf abbreviation. 32 class DIEAbbrevData { 33 /// Attribute - Dwarf attribute code. 34 /// 35 unsigned Attribute; 36 37 /// Form - Dwarf form code. 38 /// 39 unsigned Form; 40 public: 41 DIEAbbrevData(unsigned A, unsigned F) : Attribute(A), Form(F) {} 42 43 // Accessors. 44 unsigned getAttribute() const { return Attribute; } 45 unsigned getForm() const { return Form; } 46 47 /// Profile - Used to gather unique data for the abbreviation folding set. 48 /// 49 void Profile(FoldingSetNodeID &ID) const; 50 }; 51 52 //===--------------------------------------------------------------------===// 53 /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug 54 /// information object. 55 class DIEAbbrev : public FoldingSetNode { 56 /// Tag - Dwarf tag code. 57 /// 58 unsigned Tag; 59 60 /// Unique number for node. 61 /// 62 unsigned Number; 63 64 /// ChildrenFlag - Dwarf children flag. 65 /// 66 unsigned ChildrenFlag; 67 68 /// Data - Raw data bytes for abbreviation. 69 /// 70 SmallVector<DIEAbbrevData, 8> Data; 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(const AsmPrinter *Asm) 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 CompileUnit; 114 class DIEValue; 115 116 class DIE { 117 protected: 118 /// Abbrev - Buffer for constructing abbreviation. 119 /// 120 DIEAbbrev Abbrev; 121 122 /// Offset - Offset in debug info section. 123 /// 124 unsigned Offset; 125 126 /// Size - Size of instance + children. 127 /// 128 unsigned Size; 129 130 /// Children DIEs. 131 /// 132 std::vector<DIE *> Children; 133 134 /// Attributes values. 135 /// 136 SmallVector<DIEValue*, 32> Values; 137 138 /// Abstract compile unit. 139 CompileUnit *AbstractCU; 140 141 // Private data for print() 142 mutable unsigned IndentCount; 143 public: 144 explicit DIE(unsigned Tag) 145 : Abbrev(Tag, dwarf::DW_CHILDREN_no), Offset(0), 146 Size(0), IndentCount(0) {} 147 virtual ~DIE(); 148 149 // Accessors. 150 DIEAbbrev &getAbbrev() { return Abbrev; } 151 unsigned getAbbrevNumber() const { return Abbrev.getNumber(); } 152 unsigned getTag() const { return Abbrev.getTag(); } 153 unsigned getOffset() const { return Offset; } 154 unsigned getSize() const { return Size; } 155 const std::vector<DIE *> &getChildren() const { return Children; } 156 SmallVector<DIEValue*, 32> &getValues() { return Values; } 157 CompileUnit *getAbstractCompileUnit() const { return AbstractCU; } 158 159 void setTag(unsigned Tag) { Abbrev.setTag(Tag); } 160 void setOffset(unsigned O) { Offset = O; } 161 void setSize(unsigned S) { Size = S; } 162 void setAbstractCompileUnit(CompileUnit *CU) { AbstractCU = CU; } 163 164 /// addValue - Add a value and attributes to a DIE. 165 /// 166 void addValue(unsigned Attribute, unsigned Form, DIEValue *Value) { 167 Abbrev.AddAttribute(Attribute, Form); 168 Values.push_back(Value); 169 } 170 171 /// SiblingOffset - Return the offset of the debug information entry's 172 /// sibling. 173 unsigned getSiblingOffset() const { return Offset + Size; } 174 175 /// addSiblingOffset - Add a sibling offset field to the front of the DIE. 176 /// 177 void addSiblingOffset(); 178 179 /// addChild - Add a child to the DIE. 180 /// 181 void addChild(DIE *Child) { 182 Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes); 183 Children.push_back(Child); 184 } 185 186#ifndef NDEBUG 187 void print(raw_ostream &O, unsigned IncIndent = 0); 188 void dump(); 189#endif 190 }; 191 192 //===--------------------------------------------------------------------===// 193 /// DIEValue - A debug information entry value. 194 /// 195 class DIEValue { 196 public: 197 enum { 198 isInteger, 199 isString, 200 isLabel, 201 isAsIsLabel, 202 isSectionOffset, 203 isDelta, 204 isEntry, 205 isBlock 206 }; 207 protected: 208 /// Type - Type of data stored in the value. 209 /// 210 unsigned Type; 211 public: 212 explicit DIEValue(unsigned T) : Type(T) {} 213 virtual ~DIEValue() {} 214 215 // Accessors 216 unsigned getType() const { return Type; } 217 218 /// EmitValue - Emit value via the Dwarf writer. 219 /// 220 virtual void EmitValue(Dwarf *D, unsigned Form) const = 0; 221 222 /// SizeOf - Return the size of a value in bytes. 223 /// 224 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const = 0; 225 226 // Implement isa/cast/dyncast. 227 static bool classof(const DIEValue *) { return true; } 228 229#ifndef NDEBUG 230 virtual void print(raw_ostream &O) = 0; 231 void dump(); 232#endif 233 }; 234 235 //===--------------------------------------------------------------------===// 236 /// DIEInteger - An integer value DIE. 237 /// 238 class DIEInteger : public DIEValue { 239 uint64_t Integer; 240 public: 241 explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {} 242 243 /// BestForm - Choose the best form for integer. 244 /// 245 static unsigned BestForm(bool IsSigned, uint64_t Int) { 246 if (IsSigned) { 247 if ((char)Int == (signed)Int) return dwarf::DW_FORM_data1; 248 if ((short)Int == (signed)Int) return dwarf::DW_FORM_data2; 249 if ((int)Int == (signed)Int) return dwarf::DW_FORM_data4; 250 } else { 251 if ((unsigned char)Int == Int) return dwarf::DW_FORM_data1; 252 if ((unsigned short)Int == Int) return dwarf::DW_FORM_data2; 253 if ((unsigned int)Int == Int) return dwarf::DW_FORM_data4; 254 } 255 return dwarf::DW_FORM_data8; 256 } 257 258 /// EmitValue - Emit integer of appropriate size. 259 /// 260 virtual void EmitValue(Dwarf *D, unsigned Form) const; 261 262 /// SizeOf - Determine size of integer value in bytes. 263 /// 264 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const; 265 266 267 // Implement isa/cast/dyncast. 268 static bool classof(const DIEInteger *) { return true; } 269 static bool classof(const DIEValue *I) { return I->getType() == isInteger; } 270 271#ifndef NDEBUG 272 virtual void print(raw_ostream &O); 273#endif 274 }; 275 276 //===--------------------------------------------------------------------===// 277 /// DIEString - A string value DIE. This DIE keeps string reference only. 278 /// 279 class DIEString : public DIEValue { 280 const StringRef Str; 281 public: 282 explicit DIEString(const StringRef S) : DIEValue(isString), Str(S) {} 283 284 /// EmitValue - Emit string value. 285 /// 286 virtual void EmitValue(Dwarf *D, unsigned Form) const; 287 288 /// SizeOf - Determine size of string value in bytes. 289 /// 290 virtual unsigned SizeOf(const TargetData *, unsigned /*Form*/) const { 291 return Str.size() + sizeof(char); // sizeof('\0'); 292 } 293 294 // Implement isa/cast/dyncast. 295 static bool classof(const DIEString *) { return true; } 296 static bool classof(const DIEValue *S) { return S->getType() == isString; } 297 298#ifndef NDEBUG 299 virtual void print(raw_ostream &O); 300#endif 301 }; 302 303 //===--------------------------------------------------------------------===// 304 /// DIEDwarfLabel - A Dwarf internal label expression DIE. 305 // 306 class DIEDwarfLabel : public DIEValue { 307 const DWLabel Label; 308 public: 309 explicit DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {} 310 311 /// EmitValue - Emit label value. 312 /// 313 virtual void EmitValue(Dwarf *D, unsigned Form) const; 314 315 /// SizeOf - Determine size of label value in bytes. 316 /// 317 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const; 318 319 // Implement isa/cast/dyncast. 320 static bool classof(const DIEDwarfLabel *) { return true; } 321 static bool classof(const DIEValue *L) { return L->getType() == isLabel; } 322 323#ifndef NDEBUG 324 virtual void print(raw_ostream &O); 325#endif 326 }; 327 328 //===--------------------------------------------------------------------===// 329 /// DIEObjectLabel - A label to an object in code or data. 330 // 331 class DIEObjectLabel : public DIEValue { 332 const std::string Label; 333 public: 334 explicit DIEObjectLabel(const std::string &L) 335 : DIEValue(isAsIsLabel), Label(L) {} 336 337 /// EmitValue - Emit label value. 338 /// 339 virtual void EmitValue(Dwarf *D, unsigned Form) const; 340 341 /// SizeOf - Determine size of label value in bytes. 342 /// 343 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const; 344 345 // Implement isa/cast/dyncast. 346 static bool classof(const DIEObjectLabel *) { return true; } 347 static bool classof(const DIEValue *L) { 348 return L->getType() == isAsIsLabel; 349 } 350 351#ifndef NDEBUG 352 virtual void print(raw_ostream &O); 353#endif 354 }; 355 356 //===--------------------------------------------------------------------===// 357 /// DIESectionOffset - A section offset DIE. 358 /// 359 class DIESectionOffset : public DIEValue { 360 const DWLabel Label; 361 const DWLabel Section; 362 bool IsEH : 1; 363 bool UseSet : 1; 364 public: 365 DIESectionOffset(const DWLabel &Lab, const DWLabel &Sec, 366 bool isEH = false, bool useSet = true) 367 : DIEValue(isSectionOffset), Label(Lab), Section(Sec), 368 IsEH(isEH), UseSet(useSet) {} 369 370 /// EmitValue - Emit section offset. 371 /// 372 virtual void EmitValue(Dwarf *D, unsigned Form) const; 373 374 /// SizeOf - Determine size of section offset value in bytes. 375 /// 376 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const; 377 378 // Implement isa/cast/dyncast. 379 static bool classof(const DIESectionOffset *) { return true; } 380 static bool classof(const DIEValue *D) { 381 return D->getType() == isSectionOffset; 382 } 383 384#ifndef NDEBUG 385 virtual void print(raw_ostream &O); 386#endif 387 }; 388 389 //===--------------------------------------------------------------------===// 390 /// DIEDelta - A simple label difference DIE. 391 /// 392 class DIEDelta : public DIEValue { 393 const DWLabel LabelHi; 394 const DWLabel LabelLo; 395 public: 396 DIEDelta(const DWLabel &Hi, const DWLabel &Lo) 397 : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {} 398 399 /// EmitValue - Emit delta value. 400 /// 401 virtual void EmitValue(Dwarf *D, unsigned Form) const; 402 403 /// SizeOf - Determine size of delta value in bytes. 404 /// 405 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const; 406 407 // Implement isa/cast/dyncast. 408 static bool classof(const DIEDelta *) { return true; } 409 static bool classof(const DIEValue *D) { return D->getType() == isDelta; } 410 411#ifndef NDEBUG 412 virtual void print(raw_ostream &O); 413#endif 414 }; 415 416 //===--------------------------------------------------------------------===// 417 /// DIEntry - A pointer to another debug information entry. An instance of 418 /// this class can also be used as a proxy for a debug information entry not 419 /// yet defined (ie. types.) 420 class DIEEntry : public DIEValue { 421 DIE *Entry; 422 public: 423 explicit DIEEntry(DIE *E) : DIEValue(isEntry), Entry(E) {} 424 425 DIE *getEntry() const { return Entry; } 426 void setEntry(DIE *E) { Entry = E; } 427 428 /// EmitValue - Emit debug information entry offset. 429 /// 430 virtual void EmitValue(Dwarf *D, unsigned Form) const; 431 432 /// SizeOf - Determine size of debug information entry in bytes. 433 /// 434 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const { 435 return sizeof(int32_t); 436 } 437 438 // Implement isa/cast/dyncast. 439 static bool classof(const DIEEntry *) { return true; } 440 static bool classof(const DIEValue *E) { return E->getType() == isEntry; } 441 442#ifndef NDEBUG 443 virtual void print(raw_ostream &O); 444#endif 445 }; 446 447 //===--------------------------------------------------------------------===// 448 /// DIEBlock - A block of values. Primarily used for location expressions. 449 // 450 class DIEBlock : public DIEValue, public DIE { 451 unsigned Size; // Size in bytes excluding size header. 452 public: 453 DIEBlock() 454 : DIEValue(isBlock), DIE(0), Size(0) {} 455 virtual ~DIEBlock() {} 456 457 /// ComputeSize - calculate the size of the block. 458 /// 459 unsigned ComputeSize(const TargetData *TD); 460 461 /// BestForm - Choose the best form for data. 462 /// 463 unsigned BestForm() const { 464 if ((unsigned char)Size == Size) return dwarf::DW_FORM_block1; 465 if ((unsigned short)Size == Size) return dwarf::DW_FORM_block2; 466 if ((unsigned int)Size == Size) return dwarf::DW_FORM_block4; 467 return dwarf::DW_FORM_block; 468 } 469 470 /// EmitValue - Emit block data. 471 /// 472 virtual void EmitValue(Dwarf *D, unsigned Form) const; 473 474 /// SizeOf - Determine size of block data in bytes. 475 /// 476 virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const; 477 478 // Implement isa/cast/dyncast. 479 static bool classof(const DIEBlock *) { return true; } 480 static bool classof(const DIEValue *E) { return E->getType() == isBlock; } 481 482#ifndef NDEBUG 483 virtual void print(raw_ostream &O); 484#endif 485 }; 486 487} // end llvm namespace 488 489#endif 490