DIE.h revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
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/Dwarf.h" 20#include <vector> 21 22namespace llvm { 23class AsmPrinter; 24class MCExpr; 25class MCSymbol; 26class raw_ostream; 27class DwarfTypeUnit; 28 29//===--------------------------------------------------------------------===// 30/// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a 31/// Dwarf abbreviation. 32class DIEAbbrevData { 33 /// Attribute - Dwarf attribute code. 34 /// 35 dwarf::Attribute Attribute; 36 37 /// Form - Dwarf form code. 38 /// 39 dwarf::Form Form; 40 41public: 42 DIEAbbrevData(dwarf::Attribute A, dwarf::Form F) : Attribute(A), Form(F) {} 43 44 // Accessors. 45 dwarf::Attribute getAttribute() const { return Attribute; } 46 dwarf::Form getForm() const { return Form; } 47 48 /// Profile - Used to gather unique data for the abbreviation folding set. 49 /// 50 void Profile(FoldingSetNodeID &ID) const; 51}; 52 53//===--------------------------------------------------------------------===// 54/// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug 55/// information object. 56class DIEAbbrev : public FoldingSetNode { 57 /// Unique number for node. 58 /// 59 unsigned Number; 60 61 /// Tag - Dwarf tag code. 62 /// 63 dwarf::Tag Tag; 64 65 /// Children - Whether or not this node has children. 66 /// 67 // This cheats a bit in all of the uses since the values in the standard 68 // are 0 and 1 for no children and children respectively. 69 bool Children; 70 71 /// Data - Raw data bytes for abbreviation. 72 /// 73 SmallVector<DIEAbbrevData, 12> Data; 74 75public: 76 DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C), Data() {} 77 78 // Accessors. 79 dwarf::Tag getTag() const { return Tag; } 80 unsigned getNumber() const { return Number; } 81 bool hasChildren() const { return Children; } 82 const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; } 83 void setChildrenFlag(bool hasChild) { Children = hasChild; } 84 void setNumber(unsigned N) { Number = N; } 85 86 /// AddAttribute - Adds another set of attribute information to the 87 /// abbreviation. 88 void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) { 89 Data.push_back(DIEAbbrevData(Attribute, Form)); 90 } 91 92 /// Profile - Used to gather unique data for the abbreviation folding set. 93 /// 94 void Profile(FoldingSetNodeID &ID) const; 95 96 /// Emit - Print the abbreviation using the specified asm printer. 97 /// 98 void Emit(AsmPrinter *AP) const; 99 100#ifndef NDEBUG 101 void print(raw_ostream &O); 102 void dump(); 103#endif 104}; 105 106//===--------------------------------------------------------------------===// 107/// DIE - A structured debug information entry. Has an abbreviation which 108/// describes its organization. 109class DIEValue; 110 111class DIE { 112protected: 113 /// Offset - Offset in debug info section. 114 /// 115 unsigned Offset; 116 117 /// Size - Size of instance + children. 118 /// 119 unsigned Size; 120 121 /// Abbrev - Buffer for constructing abbreviation. 122 /// 123 DIEAbbrev Abbrev; 124 125 /// Children DIEs. 126 /// 127 std::vector<DIE *> Children; 128 129 DIE *Parent; 130 131 /// Attribute values. 132 /// 133 SmallVector<DIEValue *, 12> Values; 134 135public: 136 explicit DIE(unsigned Tag) 137 : Offset(0), Size(0), Abbrev((dwarf::Tag)Tag, dwarf::DW_CHILDREN_no), 138 Parent(0) {} 139 ~DIE(); 140 141 // Accessors. 142 DIEAbbrev &getAbbrev() { return Abbrev; } 143 const DIEAbbrev &getAbbrev() const { return Abbrev; } 144 unsigned getAbbrevNumber() const { return Abbrev.getNumber(); } 145 dwarf::Tag getTag() const { return Abbrev.getTag(); } 146 unsigned getOffset() const { return Offset; } 147 unsigned getSize() const { return Size; } 148 const std::vector<DIE *> &getChildren() const { return Children; } 149 const SmallVectorImpl<DIEValue *> &getValues() const { return Values; } 150 DIE *getParent() const { return Parent; } 151 /// Climb up the parent chain to get the compile or type unit DIE this DIE 152 /// belongs to. 153 const DIE *getUnit() const; 154 /// Similar to getUnit, returns null when DIE is not added to an 155 /// owner yet. 156 const DIE *getUnitOrNull() const; 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(dwarf::Attribute Attribute, dwarf::Form Form, DIEValue *Value) { 163 Abbrev.AddAttribute(Attribute, Form); 164 Values.push_back(Value); 165 } 166 167 /// addChild - Add a child to the DIE. 168 /// 169 void addChild(DIE *Child) { 170 assert(!Child->getParent()); 171 Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes); 172 Children.push_back(Child); 173 Child->Parent = this; 174 } 175 176 /// findAttribute - Find a value in the DIE with the attribute given, 177 /// returns NULL if no such attribute exists. 178 DIEValue *findAttribute(dwarf::Attribute Attribute) const; 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. Some of these roughly correlate 188/// to DWARF attribute classes. 189/// 190class DIEValue { 191 virtual void anchor(); 192 193public: 194 enum Type { 195 isInteger, 196 isString, 197 isExpr, 198 isLabel, 199 isDelta, 200 isEntry, 201 isTypeSignature, 202 isBlock, 203 isLoc, 204 isLocList, 205 }; 206 207protected: 208 /// Ty - Type of data stored in the value. 209 /// 210 Type Ty; 211 212 explicit DIEValue(Type T) : Ty(T) {} 213 virtual ~DIEValue() {} 214 215public: 216 // Accessors 217 Type getType() const { return Ty; } 218 219 /// EmitValue - Emit value via the Dwarf writer. 220 /// 221 virtual void EmitValue(AsmPrinter *AP, dwarf::Form Form) const = 0; 222 223 /// SizeOf - Return the size of a value in bytes. 224 /// 225 virtual unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const = 0; 226 227#ifndef NDEBUG 228 virtual void print(raw_ostream &O) const = 0; 229 void dump() const; 230#endif 231}; 232 233//===--------------------------------------------------------------------===// 234/// DIEInteger - An integer value DIE. 235/// 236class DIEInteger : public DIEValue { 237 uint64_t Integer; 238 239public: 240 explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {} 241 242 /// BestForm - Choose the best form for integer. 243 /// 244 static dwarf::Form BestForm(bool IsSigned, uint64_t Int) { 245 if (IsSigned) { 246 const int64_t SignedInt = Int; 247 if ((char)Int == SignedInt) 248 return dwarf::DW_FORM_data1; 249 if ((short)Int == SignedInt) 250 return dwarf::DW_FORM_data2; 251 if ((int)Int == SignedInt) 252 return dwarf::DW_FORM_data4; 253 } else { 254 if ((unsigned char)Int == Int) 255 return dwarf::DW_FORM_data1; 256 if ((unsigned short)Int == Int) 257 return dwarf::DW_FORM_data2; 258 if ((unsigned int)Int == Int) 259 return dwarf::DW_FORM_data4; 260 } 261 return dwarf::DW_FORM_data8; 262 } 263 264 /// EmitValue - Emit integer of appropriate size. 265 /// 266 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 267 268 uint64_t getValue() const { return Integer; } 269 270 /// SizeOf - Determine size of integer value in bytes. 271 /// 272 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 273 274 // Implement isa/cast/dyncast. 275 static bool classof(const DIEValue *I) { return I->getType() == isInteger; } 276 277#ifndef NDEBUG 278 void print(raw_ostream &O) const override; 279#endif 280}; 281 282//===--------------------------------------------------------------------===// 283/// DIEExpr - An expression DIE. 284// 285class DIEExpr : public DIEValue { 286 const MCExpr *Expr; 287 288public: 289 explicit DIEExpr(const MCExpr *E) : DIEValue(isExpr), Expr(E) {} 290 291 /// EmitValue - Emit expression value. 292 /// 293 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 294 295 /// getValue - Get MCExpr. 296 /// 297 const MCExpr *getValue() const { return Expr; } 298 299 /// SizeOf - Determine size of expression value in bytes. 300 /// 301 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 302 303 // Implement isa/cast/dyncast. 304 static bool classof(const DIEValue *E) { return E->getType() == isExpr; } 305 306#ifndef NDEBUG 307 void print(raw_ostream &O) const override; 308#endif 309}; 310 311//===--------------------------------------------------------------------===// 312/// DIELabel - A label DIE. 313// 314class DIELabel : public DIEValue { 315 const MCSymbol *Label; 316 317public: 318 explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {} 319 320 /// EmitValue - Emit label value. 321 /// 322 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 323 324 /// getValue - Get MCSymbol. 325 /// 326 const MCSymbol *getValue() const { return Label; } 327 328 /// SizeOf - Determine size of label value in bytes. 329 /// 330 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 331 332 // Implement isa/cast/dyncast. 333 static bool classof(const DIEValue *L) { return L->getType() == isLabel; } 334 335#ifndef NDEBUG 336 void print(raw_ostream &O) const override; 337#endif 338}; 339 340//===--------------------------------------------------------------------===// 341/// DIEDelta - A simple label difference DIE. 342/// 343class DIEDelta : public DIEValue { 344 const MCSymbol *LabelHi; 345 const MCSymbol *LabelLo; 346 347public: 348 DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) 349 : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {} 350 351 /// EmitValue - Emit delta value. 352 /// 353 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 354 355 /// SizeOf - Determine size of delta value in bytes. 356 /// 357 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 358 359 // Implement isa/cast/dyncast. 360 static bool classof(const DIEValue *D) { return D->getType() == isDelta; } 361 362#ifndef NDEBUG 363 void print(raw_ostream &O) const override; 364#endif 365}; 366 367//===--------------------------------------------------------------------===// 368/// DIEString - A container for string values. 369/// 370class DIEString : public DIEValue { 371 const DIEValue *Access; 372 const StringRef Str; 373 374public: 375 DIEString(const DIEValue *Acc, const StringRef S) 376 : DIEValue(isString), Access(Acc), Str(S) {} 377 378 /// getString - Grab the string out of the object. 379 StringRef getString() const { return Str; } 380 381 /// EmitValue - Emit delta value. 382 /// 383 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 384 385 /// SizeOf - Determine size of delta value in bytes. 386 /// 387 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 388 389 // Implement isa/cast/dyncast. 390 static bool classof(const DIEValue *D) { return D->getType() == isString; } 391 392#ifndef NDEBUG 393 void print(raw_ostream &O) const override; 394#endif 395}; 396 397//===--------------------------------------------------------------------===// 398/// DIEEntry - A pointer to another debug information entry. An instance of 399/// this class can also be used as a proxy for a debug information entry not 400/// yet defined (ie. types.) 401class DIEEntry : public DIEValue { 402 DIE *const Entry; 403 404public: 405 explicit DIEEntry(DIE *E) : DIEValue(isEntry), Entry(E) { 406 assert(E && "Cannot construct a DIEEntry with a null DIE"); 407 } 408 409 DIE *getEntry() const { return Entry; } 410 411 /// EmitValue - Emit debug information entry offset. 412 /// 413 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 414 415 /// SizeOf - Determine size of debug information entry in bytes. 416 /// 417 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override { 418 return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP) 419 : sizeof(int32_t); 420 } 421 422 /// Returns size of a ref_addr entry. 423 static unsigned getRefAddrSize(AsmPrinter *AP); 424 425 // Implement isa/cast/dyncast. 426 static bool classof(const DIEValue *E) { return E->getType() == isEntry; } 427 428#ifndef NDEBUG 429 void print(raw_ostream &O) const override; 430#endif 431}; 432 433//===--------------------------------------------------------------------===// 434/// \brief A signature reference to a type unit. 435class DIETypeSignature : public DIEValue { 436 const DwarfTypeUnit &Unit; 437 438public: 439 explicit DIETypeSignature(const DwarfTypeUnit &Unit) 440 : DIEValue(isTypeSignature), Unit(Unit) {} 441 442 /// \brief Emit type unit signature. 443 void EmitValue(AsmPrinter *Asm, dwarf::Form Form) const override; 444 445 /// Returns size of a ref_sig8 entry. 446 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override { 447 assert(Form == dwarf::DW_FORM_ref_sig8); 448 return 8; 449 } 450 451 // \brief Implement isa/cast/dyncast. 452 static bool classof(const DIEValue *E) { 453 return E->getType() == isTypeSignature; 454 } 455#ifndef NDEBUG 456 void print(raw_ostream &O) const override; 457 void dump() const; 458#endif 459}; 460 461//===--------------------------------------------------------------------===// 462/// DIELoc - Represents an expression location. 463// 464class DIELoc : public DIEValue, public DIE { 465 mutable unsigned Size; // Size in bytes excluding size header. 466public: 467 DIELoc() : DIEValue(isLoc), DIE(0), Size(0) {} 468 469 /// ComputeSize - Calculate the size of the location expression. 470 /// 471 unsigned ComputeSize(AsmPrinter *AP) const; 472 473 /// BestForm - Choose the best form for data. 474 /// 475 dwarf::Form BestForm(unsigned DwarfVersion) const { 476 if (DwarfVersion > 3) 477 return dwarf::DW_FORM_exprloc; 478 // Pre-DWARF4 location expressions were blocks and not exprloc. 479 if ((unsigned char)Size == Size) 480 return dwarf::DW_FORM_block1; 481 if ((unsigned short)Size == Size) 482 return dwarf::DW_FORM_block2; 483 if ((unsigned int)Size == Size) 484 return dwarf::DW_FORM_block4; 485 return dwarf::DW_FORM_block; 486 } 487 488 /// EmitValue - Emit location data. 489 /// 490 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 491 492 /// SizeOf - Determine size of location data in bytes. 493 /// 494 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 495 496 // Implement isa/cast/dyncast. 497 static bool classof(const DIEValue *E) { return E->getType() == isLoc; } 498 499#ifndef NDEBUG 500 void print(raw_ostream &O) const override; 501#endif 502}; 503 504//===--------------------------------------------------------------------===// 505/// DIEBlock - Represents a block of values. 506// 507class DIEBlock : public DIEValue, public DIE { 508 mutable unsigned Size; // Size in bytes excluding size header. 509public: 510 DIEBlock() : DIEValue(isBlock), DIE(0), Size(0) {} 511 512 /// ComputeSize - Calculate the size of the location expression. 513 /// 514 unsigned ComputeSize(AsmPrinter *AP) const; 515 516 /// BestForm - Choose the best form for data. 517 /// 518 dwarf::Form BestForm() const { 519 if ((unsigned char)Size == Size) 520 return dwarf::DW_FORM_block1; 521 if ((unsigned short)Size == Size) 522 return dwarf::DW_FORM_block2; 523 if ((unsigned int)Size == Size) 524 return dwarf::DW_FORM_block4; 525 return dwarf::DW_FORM_block; 526 } 527 528 /// EmitValue - Emit location data. 529 /// 530 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 531 532 /// SizeOf - Determine size of location data in bytes. 533 /// 534 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 535 536 // Implement isa/cast/dyncast. 537 static bool classof(const DIEValue *E) { return E->getType() == isBlock; } 538 539#ifndef NDEBUG 540 void print(raw_ostream &O) const override; 541#endif 542}; 543 544//===--------------------------------------------------------------------===// 545/// DIELocList - Represents a pointer to a location list in the debug_loc 546/// section. 547// 548class DIELocList : public DIEValue { 549 // Index into the .debug_loc vector. 550 size_t Index; 551 552public: 553 DIELocList(size_t I) : DIEValue(isLocList), Index(I) {} 554 555 /// getValue - Grab the current index out. 556 size_t getValue() const { return Index; } 557 558 /// EmitValue - Emit location data. 559 /// 560 void EmitValue(AsmPrinter *AP, dwarf::Form Form) const override; 561 562 /// SizeOf - Determine size of location data in bytes. 563 /// 564 unsigned SizeOf(AsmPrinter *AP, dwarf::Form Form) const override; 565 566 // Implement isa/cast/dyncast. 567 static bool classof(const DIEValue *E) { return E->getType() == isLocList; } 568 569#ifndef NDEBUG 570 void print(raw_ostream &O) const override; 571#endif 572}; 573 574} // end llvm namespace 575 576#endif 577