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 LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H 15#define LLVM_LIB_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(const 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 // This can't be a vector<DIE> because pointer validity is requirent for the 128 // Parent pointer and DIEEntry. 129 // It can't be a list<DIE> because some clients need pointer validity before 130 // the object has been added to any child list 131 // (eg: DwarfUnit::constructVariableDIE). These aren't insurmountable, but may 132 // be more convoluted than beneficial. 133 std::vector<std::unique_ptr<DIE>> Children; 134 135 DIE *Parent; 136 137 /// Attribute values. 138 /// 139 SmallVector<DIEValue *, 12> Values; 140 141protected: 142 DIE() 143 : Offset(0), Size(0), Abbrev((dwarf::Tag)0, dwarf::DW_CHILDREN_no), 144 Parent(nullptr) {} 145 146public: 147 explicit DIE(dwarf::Tag Tag) 148 : Offset(0), Size(0), Abbrev((dwarf::Tag)Tag, dwarf::DW_CHILDREN_no), 149 Parent(nullptr) {} 150 151 // Accessors. 152 DIEAbbrev &getAbbrev() { return Abbrev; } 153 const DIEAbbrev &getAbbrev() const { return Abbrev; } 154 unsigned getAbbrevNumber() const { return Abbrev.getNumber(); } 155 dwarf::Tag getTag() const { return Abbrev.getTag(); } 156 unsigned getOffset() const { return Offset; } 157 unsigned getSize() const { return Size; } 158 const std::vector<std::unique_ptr<DIE>> &getChildren() const { 159 return Children; 160 } 161 const SmallVectorImpl<DIEValue *> &getValues() const { return Values; } 162 DIE *getParent() const { return Parent; } 163 /// Climb up the parent chain to get the compile or type unit DIE this DIE 164 /// belongs to. 165 const DIE *getUnit() const; 166 /// Similar to getUnit, returns null when DIE is not added to an 167 /// owner yet. 168 const DIE *getUnitOrNull() const; 169 void setOffset(unsigned O) { Offset = O; } 170 void setSize(unsigned S) { Size = S; } 171 172 /// addValue - Add a value and attributes to a DIE. 173 /// 174 void addValue(dwarf::Attribute Attribute, dwarf::Form Form, DIEValue *Value) { 175 Abbrev.AddAttribute(Attribute, Form); 176 Values.push_back(Value); 177 } 178 179 /// addChild - Add a child to the DIE. 180 /// 181 void addChild(std::unique_ptr<DIE> Child) { 182 assert(!Child->getParent()); 183 Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes); 184 Child->Parent = this; 185 Children.push_back(std::move(Child)); 186 } 187 188 /// findAttribute - Find a value in the DIE with the attribute given, 189 /// returns NULL if no such attribute exists. 190 DIEValue *findAttribute(dwarf::Attribute Attribute) const; 191 192#ifndef NDEBUG 193 void print(raw_ostream &O, unsigned IndentCount = 0) const; 194 void dump(); 195#endif 196}; 197 198//===--------------------------------------------------------------------===// 199/// DIEValue - A debug information entry value. Some of these roughly correlate 200/// to DWARF attribute classes. 201/// 202class DIEValue { 203 virtual void anchor(); 204 205public: 206 enum Type { 207 isInteger, 208 isString, 209 isExpr, 210 isLabel, 211 isDelta, 212 isEntry, 213 isTypeSignature, 214 isBlock, 215 isLoc, 216 isLocList, 217 }; 218 219protected: 220 /// Ty - Type of data stored in the value. 221 /// 222 Type Ty; 223 224 explicit DIEValue(Type T) : Ty(T) {} 225 virtual ~DIEValue() {} 226 227public: 228 // Accessors 229 Type getType() const { return Ty; } 230 231 /// EmitValue - Emit value via the Dwarf writer. 232 /// 233 virtual void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const = 0; 234 235 /// SizeOf - Return the size of a value in bytes. 236 /// 237 virtual unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const = 0; 238 239#ifndef NDEBUG 240 virtual void print(raw_ostream &O) const = 0; 241 void dump() const; 242#endif 243}; 244 245//===--------------------------------------------------------------------===// 246/// DIEInteger - An integer value DIE. 247/// 248class DIEInteger : public DIEValue { 249 uint64_t Integer; 250 251public: 252 explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {} 253 254 /// BestForm - Choose the best form for integer. 255 /// 256 static dwarf::Form BestForm(bool IsSigned, uint64_t Int) { 257 if (IsSigned) { 258 const int64_t SignedInt = Int; 259 if ((char)Int == SignedInt) 260 return dwarf::DW_FORM_data1; 261 if ((short)Int == SignedInt) 262 return dwarf::DW_FORM_data2; 263 if ((int)Int == SignedInt) 264 return dwarf::DW_FORM_data4; 265 } else { 266 if ((unsigned char)Int == Int) 267 return dwarf::DW_FORM_data1; 268 if ((unsigned short)Int == Int) 269 return dwarf::DW_FORM_data2; 270 if ((unsigned int)Int == Int) 271 return dwarf::DW_FORM_data4; 272 } 273 return dwarf::DW_FORM_data8; 274 } 275 276 /// EmitValue - Emit integer of appropriate size. 277 /// 278 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 279 280 uint64_t getValue() const { return Integer; } 281 void setValue(uint64_t Val) { Integer = Val; } 282 283 /// SizeOf - Determine size of integer value in bytes. 284 /// 285 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 286 287 // Implement isa/cast/dyncast. 288 static bool classof(const DIEValue *I) { return I->getType() == isInteger; } 289 290#ifndef NDEBUG 291 void print(raw_ostream &O) const override; 292#endif 293}; 294 295//===--------------------------------------------------------------------===// 296/// DIEExpr - An expression DIE. 297// 298class DIEExpr : public DIEValue { 299 const MCExpr *Expr; 300 301public: 302 explicit DIEExpr(const MCExpr *E) : DIEValue(isExpr), Expr(E) {} 303 304 /// EmitValue - Emit expression value. 305 /// 306 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 307 308 /// getValue - Get MCExpr. 309 /// 310 const MCExpr *getValue() const { return Expr; } 311 312 /// SizeOf - Determine size of expression value in bytes. 313 /// 314 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 315 316 // Implement isa/cast/dyncast. 317 static bool classof(const DIEValue *E) { return E->getType() == isExpr; } 318 319#ifndef NDEBUG 320 void print(raw_ostream &O) const override; 321#endif 322}; 323 324//===--------------------------------------------------------------------===// 325/// DIELabel - A label DIE. 326// 327class DIELabel : public DIEValue { 328 const MCSymbol *Label; 329 330public: 331 explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {} 332 333 /// EmitValue - Emit label value. 334 /// 335 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 336 337 /// getValue - Get MCSymbol. 338 /// 339 const MCSymbol *getValue() const { return Label; } 340 341 /// SizeOf - Determine size of label value in bytes. 342 /// 343 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 344 345 // Implement isa/cast/dyncast. 346 static bool classof(const DIEValue *L) { return L->getType() == isLabel; } 347 348#ifndef NDEBUG 349 void print(raw_ostream &O) const override; 350#endif 351}; 352 353//===--------------------------------------------------------------------===// 354/// DIEDelta - A simple label difference DIE. 355/// 356class DIEDelta : public DIEValue { 357 const MCSymbol *LabelHi; 358 const MCSymbol *LabelLo; 359 360public: 361 DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) 362 : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {} 363 364 /// EmitValue - Emit delta value. 365 /// 366 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 367 368 /// SizeOf - Determine size of delta value in bytes. 369 /// 370 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 371 372 // Implement isa/cast/dyncast. 373 static bool classof(const DIEValue *D) { return D->getType() == isDelta; } 374 375#ifndef NDEBUG 376 void print(raw_ostream &O) const override; 377#endif 378}; 379 380//===--------------------------------------------------------------------===// 381/// DIEString - A container for string values. 382/// 383class DIEString : public DIEValue { 384 const DIEValue *Access; 385 StringRef Str; 386 387public: 388 DIEString(const DIEValue *Acc, StringRef S) 389 : DIEValue(isString), Access(Acc), Str(S) {} 390 391 /// getString - Grab the string out of the object. 392 StringRef getString() const { return Str; } 393 394 /// EmitValue - Emit delta value. 395 /// 396 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 397 398 /// SizeOf - Determine size of delta value in bytes. 399 /// 400 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 401 402 // Implement isa/cast/dyncast. 403 static bool classof(const DIEValue *D) { return D->getType() == isString; } 404 405#ifndef NDEBUG 406 void print(raw_ostream &O) const override; 407#endif 408}; 409 410//===--------------------------------------------------------------------===// 411/// DIEEntry - A pointer to another debug information entry. An instance of 412/// this class can also be used as a proxy for a debug information entry not 413/// yet defined (ie. types.) 414class DIEEntry : public DIEValue { 415 DIE &Entry; 416 417public: 418 explicit DIEEntry(DIE &E) : DIEValue(isEntry), Entry(E) { 419 } 420 421 DIE &getEntry() const { return Entry; } 422 423 /// EmitValue - Emit debug information entry offset. 424 /// 425 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 426 427 /// SizeOf - Determine size of debug information entry in bytes. 428 /// 429 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override { 430 return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP) 431 : sizeof(int32_t); 432 } 433 434 /// Returns size of a ref_addr entry. 435 static unsigned getRefAddrSize(const AsmPrinter *AP); 436 437 // Implement isa/cast/dyncast. 438 static bool classof(const DIEValue *E) { return E->getType() == isEntry; } 439 440#ifndef NDEBUG 441 void print(raw_ostream &O) const override; 442#endif 443}; 444 445//===--------------------------------------------------------------------===// 446/// \brief A signature reference to a type unit. 447class DIETypeSignature : public DIEValue { 448 const DwarfTypeUnit &Unit; 449 450public: 451 explicit DIETypeSignature(const DwarfTypeUnit &Unit) 452 : DIEValue(isTypeSignature), Unit(Unit) {} 453 454 /// \brief Emit type unit signature. 455 void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const override; 456 457 /// Returns size of a ref_sig8 entry. 458 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override { 459 assert(Form == dwarf::DW_FORM_ref_sig8); 460 return 8; 461 } 462 463 // \brief Implement isa/cast/dyncast. 464 static bool classof(const DIEValue *E) { 465 return E->getType() == isTypeSignature; 466 } 467#ifndef NDEBUG 468 void print(raw_ostream &O) const override; 469 void dump() const; 470#endif 471}; 472 473//===--------------------------------------------------------------------===// 474/// DIELoc - Represents an expression location. 475// 476class DIELoc : public DIEValue, public DIE { 477 mutable unsigned Size; // Size in bytes excluding size header. 478public: 479 DIELoc() : DIEValue(isLoc), Size(0) {} 480 481 /// ComputeSize - Calculate the size of the location expression. 482 /// 483 unsigned ComputeSize(const AsmPrinter *AP) const; 484 485 /// BestForm - Choose the best form for data. 486 /// 487 dwarf::Form BestForm(unsigned DwarfVersion) const { 488 if (DwarfVersion > 3) 489 return dwarf::DW_FORM_exprloc; 490 // Pre-DWARF4 location expressions were blocks and not exprloc. 491 if ((unsigned char)Size == Size) 492 return dwarf::DW_FORM_block1; 493 if ((unsigned short)Size == Size) 494 return dwarf::DW_FORM_block2; 495 if ((unsigned int)Size == Size) 496 return dwarf::DW_FORM_block4; 497 return dwarf::DW_FORM_block; 498 } 499 500 /// EmitValue - Emit location data. 501 /// 502 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 503 504 /// SizeOf - Determine size of location data in bytes. 505 /// 506 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 507 508 // Implement isa/cast/dyncast. 509 static bool classof(const DIEValue *E) { return E->getType() == isLoc; } 510 511#ifndef NDEBUG 512 void print(raw_ostream &O) const override; 513#endif 514}; 515 516//===--------------------------------------------------------------------===// 517/// DIEBlock - Represents a block of values. 518// 519class DIEBlock : public DIEValue, public DIE { 520 mutable unsigned Size; // Size in bytes excluding size header. 521public: 522 DIEBlock() : DIEValue(isBlock), Size(0) {} 523 524 /// ComputeSize - Calculate the size of the location expression. 525 /// 526 unsigned ComputeSize(const AsmPrinter *AP) const; 527 528 /// BestForm - Choose the best form for data. 529 /// 530 dwarf::Form BestForm() const { 531 if ((unsigned char)Size == Size) 532 return dwarf::DW_FORM_block1; 533 if ((unsigned short)Size == Size) 534 return dwarf::DW_FORM_block2; 535 if ((unsigned int)Size == Size) 536 return dwarf::DW_FORM_block4; 537 return dwarf::DW_FORM_block; 538 } 539 540 /// EmitValue - Emit location data. 541 /// 542 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 543 544 /// SizeOf - Determine size of location data in bytes. 545 /// 546 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 547 548 // Implement isa/cast/dyncast. 549 static bool classof(const DIEValue *E) { return E->getType() == isBlock; } 550 551#ifndef NDEBUG 552 void print(raw_ostream &O) const override; 553#endif 554}; 555 556//===--------------------------------------------------------------------===// 557/// DIELocList - Represents a pointer to a location list in the debug_loc 558/// section. 559// 560class DIELocList : public DIEValue { 561 // Index into the .debug_loc vector. 562 size_t Index; 563 564public: 565 DIELocList(size_t I) : DIEValue(isLocList), Index(I) {} 566 567 /// getValue - Grab the current index out. 568 size_t getValue() const { return Index; } 569 570 /// EmitValue - Emit location data. 571 /// 572 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override; 573 574 /// SizeOf - Determine size of location data in bytes. 575 /// 576 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override; 577 578 // Implement isa/cast/dyncast. 579 static bool classof(const DIEValue *E) { return E->getType() == isLocList; } 580 581#ifndef NDEBUG 582 void print(raw_ostream &O) const override; 583#endif 584}; 585 586} // end llvm namespace 587 588#endif 589