DebugInfo.cpp revision 3f045005bf96b6521b2769fc824283589bfa133a
1//===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===// 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// This file implements the helper classes used to build and interpret debug 11// information in LLVM IR form. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/DebugInfo.h" 16#include "llvm/ADT/STLExtras.h" 17#include "llvm/ADT/SmallPtrSet.h" 18#include "llvm/ADT/SmallString.h" 19#include "llvm/Analysis/ValueTracking.h" 20#include "llvm/IR/Constants.h" 21#include "llvm/IR/DerivedTypes.h" 22#include "llvm/IR/Instructions.h" 23#include "llvm/IR/IntrinsicInst.h" 24#include "llvm/IR/Intrinsics.h" 25#include "llvm/IR/Module.h" 26#include "llvm/Support/Debug.h" 27#include "llvm/Support/Dwarf.h" 28#include "llvm/Support/ValueHandle.h" 29#include "llvm/Support/raw_ostream.h" 30using namespace llvm; 31using namespace llvm::dwarf; 32 33//===----------------------------------------------------------------------===// 34// DIDescriptor 35//===----------------------------------------------------------------------===// 36 37bool DIDescriptor::Verify() const { 38 return DbgNode && 39 (DIDerivedType(DbgNode).Verify() || 40 DICompositeType(DbgNode).Verify() || DIBasicType(DbgNode).Verify() || 41 DIVariable(DbgNode).Verify() || DISubprogram(DbgNode).Verify() || 42 DIGlobalVariable(DbgNode).Verify() || DIFile(DbgNode).Verify() || 43 DICompileUnit(DbgNode).Verify() || DINameSpace(DbgNode).Verify() || 44 DILexicalBlock(DbgNode).Verify() || 45 DILexicalBlockFile(DbgNode).Verify() || 46 DISubrange(DbgNode).Verify() || DIEnumerator(DbgNode).Verify() || 47 DIObjCProperty(DbgNode).Verify() || 48 DITemplateTypeParameter(DbgNode).Verify() || 49 DITemplateValueParameter(DbgNode).Verify() || 50 DIImportedEntity(DbgNode).Verify()); 51} 52 53static Value *getField(const MDNode *DbgNode, unsigned Elt) { 54 if (DbgNode == 0 || Elt >= DbgNode->getNumOperands()) 55 return 0; 56 return DbgNode->getOperand(Elt); 57} 58 59static MDNode *getNodeField(const MDNode *DbgNode, unsigned Elt) { 60 return dyn_cast_or_null<MDNode>(getField(DbgNode, Elt)); 61} 62 63static StringRef getStringField(const MDNode *DbgNode, unsigned Elt) { 64 if (MDString *MDS = dyn_cast_or_null<MDString>(getField(DbgNode, Elt))) 65 return MDS->getString(); 66 return StringRef(); 67} 68 69StringRef DIDescriptor::getStringField(unsigned Elt) const { 70 return ::getStringField(DbgNode, Elt); 71} 72 73uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const { 74 if (DbgNode == 0) 75 return 0; 76 77 if (Elt < DbgNode->getNumOperands()) 78 if (ConstantInt *CI 79 = dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(Elt))) 80 return CI->getZExtValue(); 81 82 return 0; 83} 84 85int64_t DIDescriptor::getInt64Field(unsigned Elt) const { 86 if (DbgNode == 0) 87 return 0; 88 89 if (Elt < DbgNode->getNumOperands()) 90 if (ConstantInt *CI 91 = dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(Elt))) 92 return CI->getSExtValue(); 93 94 return 0; 95} 96 97DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const { 98 MDNode *Field = getNodeField(DbgNode, Elt); 99 return DIDescriptor(Field); 100} 101 102GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const { 103 if (DbgNode == 0) 104 return 0; 105 106 if (Elt < DbgNode->getNumOperands()) 107 return dyn_cast_or_null<GlobalVariable>(DbgNode->getOperand(Elt)); 108 return 0; 109} 110 111Constant *DIDescriptor::getConstantField(unsigned Elt) const { 112 if (DbgNode == 0) 113 return 0; 114 115 if (Elt < DbgNode->getNumOperands()) 116 return dyn_cast_or_null<Constant>(DbgNode->getOperand(Elt)); 117 return 0; 118} 119 120Function *DIDescriptor::getFunctionField(unsigned Elt) const { 121 if (DbgNode == 0) 122 return 0; 123 124 if (Elt < DbgNode->getNumOperands()) 125 return dyn_cast_or_null<Function>(DbgNode->getOperand(Elt)); 126 return 0; 127} 128 129void DIDescriptor::replaceFunctionField(unsigned Elt, Function *F) { 130 if (DbgNode == 0) 131 return; 132 133 if (Elt < DbgNode->getNumOperands()) { 134 MDNode *Node = const_cast<MDNode*>(DbgNode); 135 Node->replaceOperandWith(Elt, F); 136 } 137} 138 139unsigned DIVariable::getNumAddrElements() const { 140 return DbgNode->getNumOperands()-8; 141} 142 143/// getInlinedAt - If this variable is inlined then return inline location. 144MDNode *DIVariable::getInlinedAt() const { 145 return getNodeField(DbgNode, 7); 146} 147 148//===----------------------------------------------------------------------===// 149// Predicates 150//===----------------------------------------------------------------------===// 151 152/// isBasicType - Return true if the specified tag is legal for 153/// DIBasicType. 154bool DIDescriptor::isBasicType() const { 155 if (!DbgNode) return false; 156 switch (getTag()) { 157 case dwarf::DW_TAG_base_type: 158 case dwarf::DW_TAG_unspecified_type: 159 return true; 160 default: 161 return false; 162 } 163} 164 165/// isDerivedType - Return true if the specified tag is legal for DIDerivedType. 166bool DIDescriptor::isDerivedType() const { 167 if (!DbgNode) return false; 168 switch (getTag()) { 169 case dwarf::DW_TAG_typedef: 170 case dwarf::DW_TAG_pointer_type: 171 case dwarf::DW_TAG_ptr_to_member_type: 172 case dwarf::DW_TAG_reference_type: 173 case dwarf::DW_TAG_rvalue_reference_type: 174 case dwarf::DW_TAG_const_type: 175 case dwarf::DW_TAG_volatile_type: 176 case dwarf::DW_TAG_restrict_type: 177 case dwarf::DW_TAG_member: 178 case dwarf::DW_TAG_inheritance: 179 case dwarf::DW_TAG_friend: 180 return true; 181 default: 182 // CompositeTypes are currently modelled as DerivedTypes. 183 return isCompositeType(); 184 } 185} 186 187/// isCompositeType - Return true if the specified tag is legal for 188/// DICompositeType. 189bool DIDescriptor::isCompositeType() const { 190 if (!DbgNode) return false; 191 switch (getTag()) { 192 case dwarf::DW_TAG_array_type: 193 case dwarf::DW_TAG_structure_type: 194 case dwarf::DW_TAG_union_type: 195 case dwarf::DW_TAG_enumeration_type: 196 case dwarf::DW_TAG_subroutine_type: 197 case dwarf::DW_TAG_class_type: 198 return true; 199 default: 200 return false; 201 } 202} 203 204/// isVariable - Return true if the specified tag is legal for DIVariable. 205bool DIDescriptor::isVariable() const { 206 if (!DbgNode) return false; 207 switch (getTag()) { 208 case dwarf::DW_TAG_auto_variable: 209 case dwarf::DW_TAG_arg_variable: 210 return true; 211 default: 212 return false; 213 } 214} 215 216/// isType - Return true if the specified tag is legal for DIType. 217bool DIDescriptor::isType() const { 218 return isBasicType() || isCompositeType() || isDerivedType(); 219} 220 221/// isSubprogram - Return true if the specified tag is legal for 222/// DISubprogram. 223bool DIDescriptor::isSubprogram() const { 224 return DbgNode && getTag() == dwarf::DW_TAG_subprogram; 225} 226 227/// isGlobalVariable - Return true if the specified tag is legal for 228/// DIGlobalVariable. 229bool DIDescriptor::isGlobalVariable() const { 230 return DbgNode && (getTag() == dwarf::DW_TAG_variable || 231 getTag() == dwarf::DW_TAG_constant); 232} 233 234/// isUnspecifiedParmeter - Return true if the specified tag is 235/// DW_TAG_unspecified_parameters. 236bool DIDescriptor::isUnspecifiedParameter() const { 237 return DbgNode && getTag() == dwarf::DW_TAG_unspecified_parameters; 238} 239 240/// isScope - Return true if the specified tag is one of the scope 241/// related tag. 242bool DIDescriptor::isScope() const { 243 if (!DbgNode) return false; 244 switch (getTag()) { 245 case dwarf::DW_TAG_compile_unit: 246 case dwarf::DW_TAG_lexical_block: 247 case dwarf::DW_TAG_subprogram: 248 case dwarf::DW_TAG_namespace: 249 case dwarf::DW_TAG_file_type: 250 return true; 251 default: 252 break; 253 } 254 return isType(); 255} 256 257/// isTemplateTypeParameter - Return true if the specified tag is 258/// DW_TAG_template_type_parameter. 259bool DIDescriptor::isTemplateTypeParameter() const { 260 return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter; 261} 262 263/// isTemplateValueParameter - Return true if the specified tag is 264/// DW_TAG_template_value_parameter. 265bool DIDescriptor::isTemplateValueParameter() const { 266 return DbgNode && (getTag() == dwarf::DW_TAG_template_value_parameter || 267 getTag() == dwarf::DW_TAG_GNU_template_template_param || 268 getTag() == dwarf::DW_TAG_GNU_template_parameter_pack); 269} 270 271/// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit. 272bool DIDescriptor::isCompileUnit() const { 273 return DbgNode && getTag() == dwarf::DW_TAG_compile_unit; 274} 275 276/// isFile - Return true if the specified tag is DW_TAG_file_type. 277bool DIDescriptor::isFile() const { 278 return DbgNode && getTag() == dwarf::DW_TAG_file_type; 279} 280 281/// isNameSpace - Return true if the specified tag is DW_TAG_namespace. 282bool DIDescriptor::isNameSpace() const { 283 return DbgNode && getTag() == dwarf::DW_TAG_namespace; 284} 285 286/// isLexicalBlockFile - Return true if the specified descriptor is a 287/// lexical block with an extra file. 288bool DIDescriptor::isLexicalBlockFile() const { 289 return DbgNode && getTag() == dwarf::DW_TAG_lexical_block && 290 (DbgNode->getNumOperands() == 3); 291} 292 293/// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block. 294bool DIDescriptor::isLexicalBlock() const { 295 return DbgNode && getTag() == dwarf::DW_TAG_lexical_block && 296 (DbgNode->getNumOperands() > 3); 297} 298 299/// isSubrange - Return true if the specified tag is DW_TAG_subrange_type. 300bool DIDescriptor::isSubrange() const { 301 return DbgNode && getTag() == dwarf::DW_TAG_subrange_type; 302} 303 304/// isEnumerator - Return true if the specified tag is DW_TAG_enumerator. 305bool DIDescriptor::isEnumerator() const { 306 return DbgNode && getTag() == dwarf::DW_TAG_enumerator; 307} 308 309/// isObjCProperty - Return true if the specified tag is DW_TAG_APPLE_property. 310bool DIDescriptor::isObjCProperty() const { 311 return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property; 312} 313 314/// \brief Return true if the specified tag is DW_TAG_imported_module or 315/// DW_TAG_imported_declaration. 316bool DIDescriptor::isImportedEntity() const { 317 return DbgNode && (getTag() == dwarf::DW_TAG_imported_module || 318 getTag() == dwarf::DW_TAG_imported_declaration); 319} 320 321//===----------------------------------------------------------------------===// 322// Simple Descriptor Constructors and other Methods 323//===----------------------------------------------------------------------===// 324 325unsigned DIArray::getNumElements() const { 326 if (!DbgNode) 327 return 0; 328 return DbgNode->getNumOperands(); 329} 330 331/// replaceAllUsesWith - Replace all uses of the MDNode used by this 332/// type with the one in the passed descriptor. 333void DIType::replaceAllUsesWith(DIDescriptor &D) { 334 335 assert(DbgNode && "Trying to replace an unverified type!"); 336 337 // Since we use a TrackingVH for the node, its easy for clients to manufacture 338 // legitimate situations where they want to replaceAllUsesWith() on something 339 // which, due to uniquing, has merged with the source. We shield clients from 340 // this detail by allowing a value to be replaced with replaceAllUsesWith() 341 // itself. 342 if (DbgNode != D) { 343 MDNode *Node = const_cast<MDNode*>(DbgNode); 344 const MDNode *DN = D; 345 const Value *V = cast_or_null<Value>(DN); 346 Node->replaceAllUsesWith(const_cast<Value*>(V)); 347 MDNode::deleteTemporary(Node); 348 } 349} 350 351/// replaceAllUsesWith - Replace all uses of the MDNode used by this 352/// type with the one in D. 353void DIType::replaceAllUsesWith(MDNode *D) { 354 355 assert(DbgNode && "Trying to replace an unverified type!"); 356 357 // Since we use a TrackingVH for the node, its easy for clients to manufacture 358 // legitimate situations where they want to replaceAllUsesWith() on something 359 // which, due to uniquing, has merged with the source. We shield clients from 360 // this detail by allowing a value to be replaced with replaceAllUsesWith() 361 // itself. 362 if (DbgNode != D) { 363 MDNode *Node = const_cast<MDNode*>(DbgNode); 364 const MDNode *DN = D; 365 const Value *V = cast_or_null<Value>(DN); 366 Node->replaceAllUsesWith(const_cast<Value*>(V)); 367 MDNode::deleteTemporary(Node); 368 } 369} 370 371/// isUnsignedDIType - Return true if type encoding is unsigned. 372bool DIType::isUnsignedDIType() { 373 DIDerivedType DTy(DbgNode); 374 if (DTy.Verify()) 375 return DTy.getTypeDerivedFrom().isUnsignedDIType(); 376 377 DIBasicType BTy(DbgNode); 378 if (BTy.Verify()) { 379 unsigned Encoding = BTy.getEncoding(); 380 if (Encoding == dwarf::DW_ATE_unsigned || 381 Encoding == dwarf::DW_ATE_unsigned_char || 382 Encoding == dwarf::DW_ATE_boolean) 383 return true; 384 } 385 return false; 386} 387 388/// Verify - Verify that a compile unit is well formed. 389bool DICompileUnit::Verify() const { 390 if (!isCompileUnit()) 391 return false; 392 393 // Don't bother verifying the compilation directory or producer string 394 // as those could be empty. 395 if (getFilename().empty()) 396 return false; 397 398 return DbgNode->getNumOperands() == 13; 399} 400 401/// Verify - Verify that an ObjC property is well formed. 402bool DIObjCProperty::Verify() const { 403 if (!isObjCProperty()) 404 return false; 405 406 // Don't worry about the rest of the strings for now. 407 return DbgNode->getNumOperands() == 8; 408} 409 410/// Check if a field at position Elt of a MDNode is a MDNode. 411/// We currently allow an empty string and an integer. 412/// But we don't allow a non-empty string in a MDNode field. 413static bool fieldIsMDNode(const MDNode *DbgNode, unsigned Elt) { 414 // FIXME: This function should return true, if the field is null or the field 415 // is indeed a MDNode: return !Fld || isa<MDNode>(Fld). 416 Value *Fld = getField(DbgNode, Elt); 417 if (Fld && isa<MDString>(Fld) && 418 !cast<MDString>(Fld)->getString().empty()) 419 return false; 420 return true; 421} 422 423/// Check if a field at position Elt of a MDNode is a MDString. 424static bool fieldIsMDString(const MDNode *DbgNode, unsigned Elt) { 425 Value *Fld = getField(DbgNode, Elt); 426 return !Fld || isa<MDString>(Fld); 427} 428 429/// Check if a value can be a reference to a type. 430static bool isTypeRef(const Value *Val) { 431 return !Val || 432 (isa<MDString>(Val) && !cast<MDString>(Val)->getString().empty()) || 433 (isa<MDNode>(Val) && DIType(cast<MDNode>(Val)).isType()); 434} 435 436/// Check if a field at position Elt of a MDNode can be a reference to a type. 437static bool fieldIsTypeRef(const MDNode *DbgNode, unsigned Elt) { 438 Value *Fld = getField(DbgNode, Elt); 439 return isTypeRef(Fld); 440} 441 442/// Check if a value can be a ScopeRef. 443static bool isScopeRef(const Value *Val) { 444 return !Val || 445 (isa<MDString>(Val) && !cast<MDString>(Val)->getString().empty()) || 446 (isa<MDNode>(Val) && DIScope(cast<MDNode>(Val)).isScope()); 447} 448 449/// Check if a field at position Elt of a MDNode can be a ScopeRef. 450static bool fieldIsScopeRef(const MDNode *DbgNode, unsigned Elt) { 451 Value *Fld = getField(DbgNode, Elt); 452 return isScopeRef(Fld); 453} 454 455/// Verify - Verify that a type descriptor is well formed. 456bool DIType::Verify() const { 457 if (!isType()) 458 return false; 459 // Make sure Context @ field 2 is MDNode. 460 if (!fieldIsScopeRef(DbgNode, 2)) 461 return false; 462 463 // FIXME: Sink this into the various subclass verifies. 464 uint16_t Tag = getTag(); 465 if (!isBasicType() && Tag != dwarf::DW_TAG_const_type && 466 Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type && 467 Tag != dwarf::DW_TAG_ptr_to_member_type && 468 Tag != dwarf::DW_TAG_reference_type && 469 Tag != dwarf::DW_TAG_rvalue_reference_type && 470 Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_array_type && 471 Tag != dwarf::DW_TAG_enumeration_type && 472 Tag != dwarf::DW_TAG_subroutine_type && 473 Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend && 474 getFilename().empty()) 475 return false; 476 // DIType is abstract, it should be a BasicType, a DerivedType or 477 // a CompositeType. 478 if (isBasicType()) 479 DIBasicType(DbgNode).Verify(); 480 else if (isCompositeType()) 481 DICompositeType(DbgNode).Verify(); 482 else if (isDerivedType()) 483 DIDerivedType(DbgNode).Verify(); 484 else 485 return false; 486 return true; 487} 488 489/// Verify - Verify that a basic type descriptor is well formed. 490bool DIBasicType::Verify() const { 491 return isBasicType() && DbgNode->getNumOperands() == 10; 492} 493 494/// Verify - Verify that a derived type descriptor is well formed. 495bool DIDerivedType::Verify() const { 496 // Make sure DerivedFrom @ field 9 is MDNode. 497 if (!fieldIsMDNode(DbgNode, 9)) 498 return false; 499 if (getTag() == dwarf::DW_TAG_ptr_to_member_type) 500 // Make sure ClassType @ field 10 is a TypeRef. 501 if (!fieldIsTypeRef(DbgNode, 10)) 502 return false; 503 504 return isDerivedType() && DbgNode->getNumOperands() >= 10 && 505 DbgNode->getNumOperands() <= 14; 506} 507 508/// Verify - Verify that a composite type descriptor is well formed. 509bool DICompositeType::Verify() const { 510 if (!isCompositeType()) 511 return false; 512 513 // Make sure DerivedFrom @ field 9 and ContainingType @ field 12 are MDNodes. 514 if (!fieldIsMDNode(DbgNode, 9)) 515 return false; 516 if (!fieldIsTypeRef(DbgNode, 12)) 517 return false; 518 519 // Make sure the type identifier at field 14 is MDString, it can be null. 520 if (!fieldIsMDString(DbgNode, 14)) 521 return false; 522 523 // If this is an array type verify that we have a DIType in the derived type 524 // field as that's the type of our element. 525 if (getTag() == dwarf::DW_TAG_array_type) 526 if (!DIType(getTypeDerivedFrom())) 527 return false; 528 529 return DbgNode->getNumOperands() == 15; 530} 531 532/// Verify - Verify that a subprogram descriptor is well formed. 533bool DISubprogram::Verify() const { 534 if (!isSubprogram()) 535 return false; 536 537 // Make sure context @ field 2 and type @ field 7 are MDNodes. 538 if (!fieldIsMDNode(DbgNode, 2)) 539 return false; 540 if (!fieldIsMDNode(DbgNode, 7)) 541 return false; 542 // Containing type @ field 12. 543 if (!fieldIsTypeRef(DbgNode, 12)) 544 return false; 545 return DbgNode->getNumOperands() == 20; 546} 547 548/// Verify - Verify that a global variable descriptor is well formed. 549bool DIGlobalVariable::Verify() const { 550 if (!isGlobalVariable()) 551 return false; 552 553 if (getDisplayName().empty()) 554 return false; 555 // Make sure context @ field 2 and type @ field 8 are MDNodes. 556 if (!fieldIsMDNode(DbgNode, 2)) 557 return false; 558 if (!fieldIsMDNode(DbgNode, 8)) 559 return false; 560 // Make sure StaticDataMemberDeclaration @ field 12 is MDNode. 561 if (!fieldIsMDNode(DbgNode, 12)) 562 return false; 563 564 return DbgNode->getNumOperands() == 13; 565} 566 567/// Verify - Verify that a variable descriptor is well formed. 568bool DIVariable::Verify() const { 569 if (!isVariable()) 570 return false; 571 572 // Make sure context @ field 1 and type @ field 5 are MDNodes. 573 if (!fieldIsMDNode(DbgNode, 1)) 574 return false; 575 if (!fieldIsMDNode(DbgNode, 5)) 576 return false; 577 return DbgNode->getNumOperands() >= 8; 578} 579 580/// Verify - Verify that a location descriptor is well formed. 581bool DILocation::Verify() const { 582 if (!DbgNode) 583 return false; 584 585 return DbgNode->getNumOperands() == 4; 586} 587 588/// Verify - Verify that a namespace descriptor is well formed. 589bool DINameSpace::Verify() const { 590 if (!isNameSpace()) 591 return false; 592 return DbgNode->getNumOperands() == 5; 593} 594 595/// \brief Retrieve the MDNode for the directory/file pair. 596MDNode *DIFile::getFileNode() const { 597 return getNodeField(DbgNode, 1); 598} 599 600/// \brief Verify that the file descriptor is well formed. 601bool DIFile::Verify() const { 602 return isFile() && DbgNode->getNumOperands() == 2; 603} 604 605/// \brief Verify that the enumerator descriptor is well formed. 606bool DIEnumerator::Verify() const { 607 return isEnumerator() && DbgNode->getNumOperands() == 3; 608} 609 610/// \brief Verify that the subrange descriptor is well formed. 611bool DISubrange::Verify() const { 612 return isSubrange() && DbgNode->getNumOperands() == 3; 613} 614 615/// \brief Verify that the lexical block descriptor is well formed. 616bool DILexicalBlock::Verify() const { 617 return isLexicalBlock() && DbgNode->getNumOperands() == 6; 618} 619 620/// \brief Verify that the file-scoped lexical block descriptor is well formed. 621bool DILexicalBlockFile::Verify() const { 622 return isLexicalBlockFile() && DbgNode->getNumOperands() == 3; 623} 624 625/// \brief Verify that the template type parameter descriptor is well formed. 626bool DITemplateTypeParameter::Verify() const { 627 return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7; 628} 629 630/// \brief Verify that the template value parameter descriptor is well formed. 631bool DITemplateValueParameter::Verify() const { 632 return isTemplateValueParameter() && DbgNode->getNumOperands() == 8; 633} 634 635/// \brief Verify that the imported module descriptor is well formed. 636bool DIImportedEntity::Verify() const { 637 return isImportedEntity() && 638 (DbgNode->getNumOperands() == 4 || DbgNode->getNumOperands() == 5); 639} 640 641/// getOriginalTypeSize - If this type is derived from a base type then 642/// return base type size. 643uint64_t DIDerivedType::getOriginalTypeSize() const { 644 uint16_t Tag = getTag(); 645 646 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && 647 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && 648 Tag != dwarf::DW_TAG_restrict_type) 649 return getSizeInBits(); 650 651 DIType BaseType = getTypeDerivedFrom(); 652 653 // If this type is not derived from any type then take conservative approach. 654 if (!BaseType.isValid()) 655 return getSizeInBits(); 656 657 // If this is a derived type, go ahead and get the base type, unless it's a 658 // reference then it's just the size of the field. Pointer types have no need 659 // of this since they're a different type of qualification on the type. 660 if (BaseType.getTag() == dwarf::DW_TAG_reference_type || 661 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type) 662 return getSizeInBits(); 663 664 if (BaseType.isDerivedType()) 665 return DIDerivedType(BaseType).getOriginalTypeSize(); 666 667 return BaseType.getSizeInBits(); 668} 669 670/// getObjCProperty - Return property node, if this ivar is associated with one. 671MDNode *DIDerivedType::getObjCProperty() const { 672 return getNodeField(DbgNode, 10); 673} 674 675MDString *DICompositeType::getIdentifier() const { 676 return cast_or_null<MDString>(getField(DbgNode, 14)); 677} 678 679#ifndef NDEBUG 680static void VerifySubsetOf(const MDNode *LHS, const MDNode *RHS) { 681 for (unsigned i = 0; i != LHS->getNumOperands(); ++i) { 682 // Skip the 'empty' list (that's a single i32 0, rather than truly empty). 683 if (i == 0 && isa<ConstantInt>(LHS->getOperand(i))) 684 continue; 685 const MDNode *E = cast<MDNode>(LHS->getOperand(i)); 686 bool found = false; 687 for (unsigned j = 0; !found && j != RHS->getNumOperands(); ++j) 688 found = E == RHS->getOperand(j); 689 assert(found && "Losing a member during member list replacement"); 690 } 691} 692#endif 693 694/// \brief Set the array of member DITypes. 695void DICompositeType::setTypeArray(DIArray Elements, DIArray TParams) { 696 assert((!TParams || DbgNode->getNumOperands() == 15) && 697 "If you're setting the template parameters this should include a slot " 698 "for that!"); 699 TrackingVH<MDNode> N(*this); 700 if (Elements) { 701#ifndef NDEBUG 702 // Check that the new list of members contains all the old members as well. 703 if (const MDNode *El = cast_or_null<MDNode>(N->getOperand(10))) 704 VerifySubsetOf(El, Elements); 705#endif 706 N->replaceOperandWith(10, Elements); 707 } 708 if (TParams) 709 N->replaceOperandWith(13, TParams); 710 DbgNode = N; 711} 712 713void DICompositeType::addMember(DIDescriptor D) { 714 SmallVector<llvm::Value *, 16> M; 715 DIArray OrigM = getTypeArray(); 716 unsigned Elements = OrigM.getNumElements(); 717 if (Elements == 1 && !OrigM.getElement(0)) 718 Elements = 0; 719 M.reserve(Elements + 1); 720 for (unsigned i = 0; i != Elements; ++i) 721 M.push_back(OrigM.getElement(i)); 722 M.push_back(D); 723 setTypeArray(DIArray(MDNode::get(DbgNode->getContext(), M))); 724} 725 726/// Generate a reference to this DIType. Uses the type identifier instead 727/// of the actual MDNode if possible, to help type uniquing. 728DIScopeRef DIScope::getRef() const { 729 if (!isCompositeType()) 730 return DIScopeRef(*this); 731 DICompositeType DTy(DbgNode); 732 if (!DTy.getIdentifier()) 733 return DIScopeRef(*this); 734 return DIScopeRef(DTy.getIdentifier()); 735} 736 737/// \brief Set the containing type. 738void DICompositeType::setContainingType(DICompositeType ContainingType) { 739 TrackingVH<MDNode> N(*this); 740 N->replaceOperandWith(12, ContainingType.getRef()); 741 DbgNode = N; 742} 743 744/// isInlinedFnArgument - Return true if this variable provides debugging 745/// information for an inlined function arguments. 746bool DIVariable::isInlinedFnArgument(const Function *CurFn) { 747 assert(CurFn && "Invalid function"); 748 if (!getContext().isSubprogram()) 749 return false; 750 // This variable is not inlined function argument if its scope 751 // does not describe current function. 752 return !DISubprogram(getContext()).describes(CurFn); 753} 754 755/// describes - Return true if this subprogram provides debugging 756/// information for the function F. 757bool DISubprogram::describes(const Function *F) { 758 assert(F && "Invalid function"); 759 if (F == getFunction()) 760 return true; 761 StringRef Name = getLinkageName(); 762 if (Name.empty()) 763 Name = getName(); 764 if (F->getName() == Name) 765 return true; 766 return false; 767} 768 769unsigned DISubprogram::isOptimized() const { 770 assert (DbgNode && "Invalid subprogram descriptor!"); 771 if (DbgNode->getNumOperands() == 15) 772 return getUnsignedField(14); 773 return 0; 774} 775 776MDNode *DISubprogram::getVariablesNodes() const { 777 return getNodeField(DbgNode, 18); 778} 779 780DIArray DISubprogram::getVariables() const { 781 return DIArray(getNodeField(DbgNode, 18)); 782} 783 784Value *DITemplateValueParameter::getValue() const { 785 return getField(DbgNode, 4); 786} 787 788// If the current node has a parent scope then return that, 789// else return an empty scope. 790DIScopeRef DIScope::getContext() const { 791 792 if (isType()) 793 return DIType(DbgNode).getContext(); 794 795 if (isSubprogram()) 796 return DIScopeRef(DISubprogram(DbgNode).getContext()); 797 798 if (isLexicalBlock()) 799 return DIScopeRef(DILexicalBlock(DbgNode).getContext()); 800 801 if (isLexicalBlockFile()) 802 return DIScopeRef(DILexicalBlockFile(DbgNode).getContext()); 803 804 if (isNameSpace()) 805 return DIScopeRef(DINameSpace(DbgNode).getContext()); 806 807 assert((isFile() || isCompileUnit()) && "Unhandled type of scope."); 808 return DIScopeRef(NULL); 809} 810 811StringRef DIScope::getFilename() const { 812 if (!DbgNode) 813 return StringRef(); 814 return ::getStringField(getNodeField(DbgNode, 1), 0); 815} 816 817StringRef DIScope::getDirectory() const { 818 if (!DbgNode) 819 return StringRef(); 820 return ::getStringField(getNodeField(DbgNode, 1), 1); 821} 822 823DIArray DICompileUnit::getEnumTypes() const { 824 if (!DbgNode || DbgNode->getNumOperands() < 13) 825 return DIArray(); 826 827 return DIArray(getNodeField(DbgNode, 7)); 828} 829 830DIArray DICompileUnit::getRetainedTypes() const { 831 if (!DbgNode || DbgNode->getNumOperands() < 13) 832 return DIArray(); 833 834 return DIArray(getNodeField(DbgNode, 8)); 835} 836 837DIArray DICompileUnit::getSubprograms() const { 838 if (!DbgNode || DbgNode->getNumOperands() < 13) 839 return DIArray(); 840 841 return DIArray(getNodeField(DbgNode, 9)); 842} 843 844 845DIArray DICompileUnit::getGlobalVariables() const { 846 if (!DbgNode || DbgNode->getNumOperands() < 13) 847 return DIArray(); 848 849 return DIArray(getNodeField(DbgNode, 10)); 850} 851 852DIArray DICompileUnit::getImportedEntities() const { 853 if (!DbgNode || DbgNode->getNumOperands() < 13) 854 return DIArray(); 855 856 return DIArray(getNodeField(DbgNode, 11)); 857} 858 859/// fixupSubprogramName - Replace contains special characters used 860/// in a typical Objective-C names with '.' in a given string. 861static void fixupSubprogramName(DISubprogram Fn, SmallVectorImpl<char> &Out) { 862 StringRef FName = 863 Fn.getFunction() ? Fn.getFunction()->getName() : Fn.getName(); 864 FName = Function::getRealLinkageName(FName); 865 866 StringRef Prefix("llvm.dbg.lv."); 867 Out.reserve(FName.size() + Prefix.size()); 868 Out.append(Prefix.begin(), Prefix.end()); 869 870 bool isObjCLike = false; 871 for (size_t i = 0, e = FName.size(); i < e; ++i) { 872 char C = FName[i]; 873 if (C == '[') 874 isObjCLike = true; 875 876 if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' || 877 C == '+' || C == '(' || C == ')')) 878 Out.push_back('.'); 879 else 880 Out.push_back(C); 881 } 882} 883 884/// getFnSpecificMDNode - Return a NameMDNode, if available, that is 885/// suitable to hold function specific information. 886NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) { 887 SmallString<32> Name; 888 fixupSubprogramName(Fn, Name); 889 return M.getNamedMetadata(Name.str()); 890} 891 892/// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable 893/// to hold function specific information. 894NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) { 895 SmallString<32> Name; 896 fixupSubprogramName(Fn, Name); 897 return M.getOrInsertNamedMetadata(Name.str()); 898} 899 900/// createInlinedVariable - Create a new inlined variable based on current 901/// variable. 902/// @param DV Current Variable. 903/// @param InlinedScope Location at current variable is inlined. 904DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope, 905 LLVMContext &VMContext) { 906 SmallVector<Value *, 16> Elts; 907 // Insert inlined scope as 7th element. 908 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) 909 i == 7 ? Elts.push_back(InlinedScope) : 910 Elts.push_back(DV->getOperand(i)); 911 return DIVariable(MDNode::get(VMContext, Elts)); 912} 913 914/// cleanseInlinedVariable - Remove inlined scope from the variable. 915DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) { 916 SmallVector<Value *, 16> Elts; 917 // Insert inlined scope as 7th element. 918 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) 919 i == 7 ? 920 Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext))): 921 Elts.push_back(DV->getOperand(i)); 922 return DIVariable(MDNode::get(VMContext, Elts)); 923} 924 925/// getDISubprogram - Find subprogram that is enclosing this scope. 926DISubprogram llvm::getDISubprogram(const MDNode *Scope) { 927 DIDescriptor D(Scope); 928 if (D.isSubprogram()) 929 return DISubprogram(Scope); 930 931 if (D.isLexicalBlockFile()) 932 return getDISubprogram(DILexicalBlockFile(Scope).getContext()); 933 934 if (D.isLexicalBlock()) 935 return getDISubprogram(DILexicalBlock(Scope).getContext()); 936 937 return DISubprogram(); 938} 939 940/// getDICompositeType - Find underlying composite type. 941DICompositeType llvm::getDICompositeType(DIType T) { 942 if (T.isCompositeType()) 943 return DICompositeType(T); 944 945 if (T.isDerivedType()) 946 return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom()); 947 948 return DICompositeType(); 949} 950 951/// Update DITypeIdentifierMap by going through retained types of each CU. 952DITypeIdentifierMap llvm::generateDITypeIdentifierMap( 953 const NamedMDNode *CU_Nodes) { 954 DITypeIdentifierMap Map; 955 for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) { 956 DICompileUnit CU(CU_Nodes->getOperand(CUi)); 957 DIArray Retain = CU.getRetainedTypes(); 958 for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) { 959 if (!Retain.getElement(Ti).isCompositeType()) 960 continue; 961 DICompositeType Ty(Retain.getElement(Ti)); 962 if (MDString *TypeId = Ty.getIdentifier()) { 963 // Definition has priority over declaration. 964 // Try to insert (TypeId, Ty) to Map. 965 std::pair<DITypeIdentifierMap::iterator, bool> P = 966 Map.insert(std::make_pair(TypeId, Ty)); 967 // If TypeId already exists in Map and this is a definition, replace 968 // whatever we had (declaration or definition) with the definition. 969 if (!P.second && !Ty.isForwardDecl()) 970 P.first->second = Ty; 971 } 972 } 973 } 974 return Map; 975} 976 977//===----------------------------------------------------------------------===// 978// DebugInfoFinder implementations. 979//===----------------------------------------------------------------------===// 980 981void DebugInfoFinder::reset() { 982 CUs.clear(); 983 SPs.clear(); 984 GVs.clear(); 985 TYs.clear(); 986 Scopes.clear(); 987 NodesSeen.clear(); 988 TypeIdentifierMap.clear(); 989} 990 991/// processModule - Process entire module and collect debug info. 992void DebugInfoFinder::processModule(const Module &M) { 993 if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) { 994 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes); 995 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 996 DICompileUnit CU(CU_Nodes->getOperand(i)); 997 addCompileUnit(CU); 998 DIArray GVs = CU.getGlobalVariables(); 999 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) { 1000 DIGlobalVariable DIG(GVs.getElement(i)); 1001 if (addGlobalVariable(DIG)) { 1002 processScope(DIG.getContext()); 1003 processType(DIG.getType()); 1004 } 1005 } 1006 DIArray SPs = CU.getSubprograms(); 1007 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) 1008 processSubprogram(DISubprogram(SPs.getElement(i))); 1009 DIArray EnumTypes = CU.getEnumTypes(); 1010 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) 1011 processType(DIType(EnumTypes.getElement(i))); 1012 DIArray RetainedTypes = CU.getRetainedTypes(); 1013 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) 1014 processType(DIType(RetainedTypes.getElement(i))); 1015 DIArray Imports = CU.getImportedEntities(); 1016 for (unsigned i = 0, e = Imports.getNumElements(); i != e; ++i) { 1017 DIImportedEntity Import = DIImportedEntity( 1018 Imports.getElement(i)); 1019 DIDescriptor Entity = Import.getEntity(); 1020 if (Entity.isType()) 1021 processType(DIType(Entity)); 1022 else if (Entity.isSubprogram()) 1023 processSubprogram(DISubprogram(Entity)); 1024 else if (Entity.isNameSpace()) 1025 processScope(DINameSpace(Entity).getContext()); 1026 } 1027 // FIXME: We really shouldn't be bailing out after visiting just one CU 1028 return; 1029 } 1030 } 1031} 1032 1033/// processLocation - Process DILocation. 1034void DebugInfoFinder::processLocation(DILocation Loc) { 1035 if (!Loc) return; 1036 processScope(Loc.getScope()); 1037 processLocation(Loc.getOrigLocation()); 1038} 1039 1040/// processType - Process DIType. 1041void DebugInfoFinder::processType(DIType DT) { 1042 if (!addType(DT)) 1043 return; 1044 processScope(DT.getContext().resolve(TypeIdentifierMap)); 1045 if (DT.isCompositeType()) { 1046 DICompositeType DCT(DT); 1047 processType(DCT.getTypeDerivedFrom()); 1048 DIArray DA = DCT.getTypeArray(); 1049 for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) { 1050 DIDescriptor D = DA.getElement(i); 1051 if (D.isType()) 1052 processType(DIType(D)); 1053 else if (D.isSubprogram()) 1054 processSubprogram(DISubprogram(D)); 1055 } 1056 } else if (DT.isDerivedType()) { 1057 DIDerivedType DDT(DT); 1058 processType(DDT.getTypeDerivedFrom()); 1059 } 1060} 1061 1062void DebugInfoFinder::processScope(DIScope Scope) { 1063 if (Scope.isType()) { 1064 DIType Ty(Scope); 1065 processType(Ty); 1066 return; 1067 } 1068 if (Scope.isCompileUnit()) { 1069 addCompileUnit(DICompileUnit(Scope)); 1070 return; 1071 } 1072 if (Scope.isSubprogram()) { 1073 processSubprogram(DISubprogram(Scope)); 1074 return; 1075 } 1076 if (!addScope(Scope)) 1077 return; 1078 if (Scope.isLexicalBlock()) { 1079 DILexicalBlock LB(Scope); 1080 processScope(LB.getContext()); 1081 } else if (Scope.isLexicalBlockFile()) { 1082 DILexicalBlockFile LBF = DILexicalBlockFile(Scope); 1083 processScope(LBF.getScope()); 1084 } else if (Scope.isNameSpace()) { 1085 DINameSpace NS(Scope); 1086 processScope(NS.getContext()); 1087 } 1088} 1089 1090/// processLexicalBlock 1091void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) { 1092 DIScope Context = LB.getContext(); 1093 if (Context.isLexicalBlock()) 1094 return processLexicalBlock(DILexicalBlock(Context)); 1095 else if (Context.isLexicalBlockFile()) { 1096 DILexicalBlockFile DBF = DILexicalBlockFile(Context); 1097 return processLexicalBlock(DILexicalBlock(DBF.getScope())); 1098 } 1099 else 1100 return processSubprogram(DISubprogram(Context)); 1101} 1102 1103/// processSubprogram - Process DISubprogram. 1104void DebugInfoFinder::processSubprogram(DISubprogram SP) { 1105 if (!addSubprogram(SP)) 1106 return; 1107 processScope(SP.getContext()); 1108 processType(SP.getType()); 1109 DIArray TParams = SP.getTemplateParams(); 1110 for (unsigned I = 0, E = TParams.getNumElements(); I != E; ++I) { 1111 DIDescriptor Element = TParams.getElement(I); 1112 if (Element.isTemplateTypeParameter()) { 1113 DITemplateTypeParameter TType(Element); 1114 processScope(TType.getContext()); 1115 processType(TType.getType()); 1116 } else if (Element.isTemplateValueParameter()) { 1117 DITemplateValueParameter TVal(Element); 1118 processScope(TVal.getContext()); 1119 processType(TVal.getType()); 1120 } 1121 } 1122} 1123 1124/// processDeclare - Process DbgDeclareInst. 1125void DebugInfoFinder::processDeclare(const DbgDeclareInst *DDI) { 1126 MDNode *N = dyn_cast<MDNode>(DDI->getVariable()); 1127 if (!N) return; 1128 1129 DIDescriptor DV(N); 1130 if (!DV.isVariable()) 1131 return; 1132 1133 if (!NodesSeen.insert(DV)) 1134 return; 1135 processScope(DIVariable(N).getContext()); 1136 processType(DIVariable(N).getType()); 1137} 1138 1139void DebugInfoFinder::processValue(const DbgValueInst *DVI) { 1140 MDNode *N = dyn_cast<MDNode>(DVI->getVariable()); 1141 if (!N) return; 1142 1143 DIDescriptor DV(N); 1144 if (!DV.isVariable()) 1145 return; 1146 1147 if (!NodesSeen.insert(DV)) 1148 return; 1149 processScope(DIVariable(N).getContext()); 1150 processType(DIVariable(N).getType()); 1151} 1152 1153/// addType - Add type into Tys. 1154bool DebugInfoFinder::addType(DIType DT) { 1155 if (!DT) 1156 return false; 1157 1158 if (!NodesSeen.insert(DT)) 1159 return false; 1160 1161 TYs.push_back(DT); 1162 return true; 1163} 1164 1165/// addCompileUnit - Add compile unit into CUs. 1166bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) { 1167 if (!CU) 1168 return false; 1169 if (!NodesSeen.insert(CU)) 1170 return false; 1171 1172 CUs.push_back(CU); 1173 return true; 1174} 1175 1176/// addGlobalVariable - Add global variable into GVs. 1177bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) { 1178 if (!DIG) 1179 return false; 1180 1181 if (!NodesSeen.insert(DIG)) 1182 return false; 1183 1184 GVs.push_back(DIG); 1185 return true; 1186} 1187 1188// addSubprogram - Add subprgoram into SPs. 1189bool DebugInfoFinder::addSubprogram(DISubprogram SP) { 1190 if (!SP) 1191 return false; 1192 1193 if (!NodesSeen.insert(SP)) 1194 return false; 1195 1196 SPs.push_back(SP); 1197 return true; 1198} 1199 1200bool DebugInfoFinder::addScope(DIScope Scope) { 1201 if (!Scope) 1202 return false; 1203 // FIXME: Ocaml binding generates a scope with no content, we treat it 1204 // as null for now. 1205 if (Scope->getNumOperands() == 0) 1206 return false; 1207 if (!NodesSeen.insert(Scope)) 1208 return false; 1209 Scopes.push_back(Scope); 1210 return true; 1211} 1212 1213//===----------------------------------------------------------------------===// 1214// DIDescriptor: dump routines for all descriptors. 1215//===----------------------------------------------------------------------===// 1216 1217/// dump - Print descriptor to dbgs() with a newline. 1218void DIDescriptor::dump() const { 1219 print(dbgs()); dbgs() << '\n'; 1220} 1221 1222/// print - Print descriptor. 1223void DIDescriptor::print(raw_ostream &OS) const { 1224 if (!DbgNode) return; 1225 1226 if (const char *Tag = dwarf::TagString(getTag())) 1227 OS << "[ " << Tag << " ]"; 1228 1229 if (this->isSubrange()) { 1230 DISubrange(DbgNode).printInternal(OS); 1231 } else if (this->isCompileUnit()) { 1232 DICompileUnit(DbgNode).printInternal(OS); 1233 } else if (this->isFile()) { 1234 DIFile(DbgNode).printInternal(OS); 1235 } else if (this->isEnumerator()) { 1236 DIEnumerator(DbgNode).printInternal(OS); 1237 } else if (this->isBasicType()) { 1238 DIType(DbgNode).printInternal(OS); 1239 } else if (this->isDerivedType()) { 1240 DIDerivedType(DbgNode).printInternal(OS); 1241 } else if (this->isCompositeType()) { 1242 DICompositeType(DbgNode).printInternal(OS); 1243 } else if (this->isSubprogram()) { 1244 DISubprogram(DbgNode).printInternal(OS); 1245 } else if (this->isGlobalVariable()) { 1246 DIGlobalVariable(DbgNode).printInternal(OS); 1247 } else if (this->isVariable()) { 1248 DIVariable(DbgNode).printInternal(OS); 1249 } else if (this->isObjCProperty()) { 1250 DIObjCProperty(DbgNode).printInternal(OS); 1251 } else if (this->isNameSpace()) { 1252 DINameSpace(DbgNode).printInternal(OS); 1253 } else if (this->isScope()) { 1254 DIScope(DbgNode).printInternal(OS); 1255 } 1256} 1257 1258void DISubrange::printInternal(raw_ostream &OS) const { 1259 int64_t Count = getCount(); 1260 if (Count != -1) 1261 OS << " [" << getLo() << ", " << Count - 1 << ']'; 1262 else 1263 OS << " [unbounded]"; 1264} 1265 1266void DIScope::printInternal(raw_ostream &OS) const { 1267 OS << " [" << getDirectory() << "/" << getFilename() << ']'; 1268} 1269 1270void DICompileUnit::printInternal(raw_ostream &OS) const { 1271 DIScope::printInternal(OS); 1272 OS << " ["; 1273 unsigned Lang = getLanguage(); 1274 if (const char *LangStr = dwarf::LanguageString(Lang)) 1275 OS << LangStr; 1276 else 1277 (OS << "lang 0x").write_hex(Lang); 1278 OS << ']'; 1279} 1280 1281void DIEnumerator::printInternal(raw_ostream &OS) const { 1282 OS << " [" << getName() << " :: " << getEnumValue() << ']'; 1283} 1284 1285void DIType::printInternal(raw_ostream &OS) const { 1286 if (!DbgNode) return; 1287 1288 StringRef Res = getName(); 1289 if (!Res.empty()) 1290 OS << " [" << Res << "]"; 1291 1292 // TODO: Print context? 1293 1294 OS << " [line " << getLineNumber() 1295 << ", size " << getSizeInBits() 1296 << ", align " << getAlignInBits() 1297 << ", offset " << getOffsetInBits(); 1298 if (isBasicType()) 1299 if (const char *Enc = 1300 dwarf::AttributeEncodingString(DIBasicType(DbgNode).getEncoding())) 1301 OS << ", enc " << Enc; 1302 OS << "]"; 1303 1304 if (isPrivate()) 1305 OS << " [private]"; 1306 else if (isProtected()) 1307 OS << " [protected]"; 1308 1309 if (isArtificial()) 1310 OS << " [artificial]"; 1311 1312 if (isForwardDecl()) 1313 OS << " [decl]"; 1314 else if (getTag() == dwarf::DW_TAG_structure_type || 1315 getTag() == dwarf::DW_TAG_union_type || 1316 getTag() == dwarf::DW_TAG_enumeration_type || 1317 getTag() == dwarf::DW_TAG_class_type) 1318 OS << " [def]"; 1319 if (isVector()) 1320 OS << " [vector]"; 1321 if (isStaticMember()) 1322 OS << " [static]"; 1323} 1324 1325void DIDerivedType::printInternal(raw_ostream &OS) const { 1326 DIType::printInternal(OS); 1327 OS << " [from " << getTypeDerivedFrom().getName() << ']'; 1328} 1329 1330void DICompositeType::printInternal(raw_ostream &OS) const { 1331 DIType::printInternal(OS); 1332 DIArray A = getTypeArray(); 1333 OS << " [" << A.getNumElements() << " elements]"; 1334} 1335 1336void DINameSpace::printInternal(raw_ostream &OS) const { 1337 StringRef Name = getName(); 1338 if (!Name.empty()) 1339 OS << " [" << Name << ']'; 1340 1341 OS << " [line " << getLineNumber() << ']'; 1342} 1343 1344void DISubprogram::printInternal(raw_ostream &OS) const { 1345 // TODO : Print context 1346 OS << " [line " << getLineNumber() << ']'; 1347 1348 if (isLocalToUnit()) 1349 OS << " [local]"; 1350 1351 if (isDefinition()) 1352 OS << " [def]"; 1353 1354 if (getScopeLineNumber() != getLineNumber()) 1355 OS << " [scope " << getScopeLineNumber() << "]"; 1356 1357 if (isPrivate()) 1358 OS << " [private]"; 1359 else if (isProtected()) 1360 OS << " [protected]"; 1361 1362 StringRef Res = getName(); 1363 if (!Res.empty()) 1364 OS << " [" << Res << ']'; 1365} 1366 1367void DIGlobalVariable::printInternal(raw_ostream &OS) const { 1368 StringRef Res = getName(); 1369 if (!Res.empty()) 1370 OS << " [" << Res << ']'; 1371 1372 OS << " [line " << getLineNumber() << ']'; 1373 1374 // TODO : Print context 1375 1376 if (isLocalToUnit()) 1377 OS << " [local]"; 1378 1379 if (isDefinition()) 1380 OS << " [def]"; 1381} 1382 1383void DIVariable::printInternal(raw_ostream &OS) const { 1384 StringRef Res = getName(); 1385 if (!Res.empty()) 1386 OS << " [" << Res << ']'; 1387 1388 OS << " [line " << getLineNumber() << ']'; 1389} 1390 1391void DIObjCProperty::printInternal(raw_ostream &OS) const { 1392 StringRef Name = getObjCPropertyName(); 1393 if (!Name.empty()) 1394 OS << " [" << Name << ']'; 1395 1396 OS << " [line " << getLineNumber() 1397 << ", properties " << getUnsignedField(6) << ']'; 1398} 1399 1400static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS, 1401 const LLVMContext &Ctx) { 1402 if (!DL.isUnknown()) { // Print source line info. 1403 DIScope Scope(DL.getScope(Ctx)); 1404 assert(Scope.isScope() && 1405 "Scope of a DebugLoc should be a DIScope."); 1406 // Omit the directory, because it's likely to be long and uninteresting. 1407 CommentOS << Scope.getFilename(); 1408 CommentOS << ':' << DL.getLine(); 1409 if (DL.getCol() != 0) 1410 CommentOS << ':' << DL.getCol(); 1411 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx)); 1412 if (!InlinedAtDL.isUnknown()) { 1413 CommentOS << " @[ "; 1414 printDebugLoc(InlinedAtDL, CommentOS, Ctx); 1415 CommentOS << " ]"; 1416 } 1417 } 1418} 1419 1420void DIVariable::printExtendedName(raw_ostream &OS) const { 1421 const LLVMContext &Ctx = DbgNode->getContext(); 1422 StringRef Res = getName(); 1423 if (!Res.empty()) 1424 OS << Res << "," << getLineNumber(); 1425 if (MDNode *InlinedAt = getInlinedAt()) { 1426 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt); 1427 if (!InlinedAtDL.isUnknown()) { 1428 OS << " @["; 1429 printDebugLoc(InlinedAtDL, OS, Ctx); 1430 OS << "]"; 1431 } 1432 } 1433} 1434 1435/// Specialize constructor to make sure it has the correct type. 1436template <> 1437DIRef<DIScope>::DIRef(const Value *V) : Val(V) { 1438 assert(isScopeRef(V) && "DIScopeRef should be a MDString or MDNode"); 1439} 1440template <> 1441DIRef<DIType>::DIRef(const Value *V) : Val(V) { 1442 assert(isTypeRef(V) && "DITypeRef should be a MDString or MDNode"); 1443} 1444 1445/// Specialize getFieldAs to handle fields that are references to DIScopes. 1446template <> 1447DIScopeRef DIDescriptor::getFieldAs<DIScopeRef>(unsigned Elt) const { 1448 return DIScopeRef(getField(DbgNode, Elt)); 1449} 1450/// Specialize getFieldAs to handle fields that are references to DITypes. 1451template <> 1452DITypeRef DIDescriptor::getFieldAs<DITypeRef>(unsigned Elt) const { 1453 return DITypeRef(getField(DbgNode, Elt)); 1454} 1455