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