DebugInfo.cpp revision 02d296759cd53f2d6081fd307c4d81cc41f2c9ed
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/// Verify - Verify that a type descriptor is well formed. 450bool DIType::Verify() const { 451 if (!isType()) 452 return false; 453 // Make sure Context @ field 2 is MDNode. 454 if (!fieldIsMDNode(DbgNode, 2)) 455 return false; 456 457 // FIXME: Sink this into the various subclass verifies. 458 uint16_t Tag = getTag(); 459 if (!isBasicType() && Tag != dwarf::DW_TAG_const_type && 460 Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type && 461 Tag != dwarf::DW_TAG_ptr_to_member_type && 462 Tag != dwarf::DW_TAG_reference_type && 463 Tag != dwarf::DW_TAG_rvalue_reference_type && 464 Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_array_type && 465 Tag != dwarf::DW_TAG_enumeration_type && 466 Tag != dwarf::DW_TAG_subroutine_type && 467 Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend && 468 getFilename().empty()) 469 return false; 470 // DIType is abstract, it should be a BasicType, a DerivedType or 471 // a CompositeType. 472 if (isBasicType()) 473 DIBasicType(DbgNode).Verify(); 474 else if (isCompositeType()) 475 DICompositeType(DbgNode).Verify(); 476 else if (isDerivedType()) 477 DIDerivedType(DbgNode).Verify(); 478 else 479 return false; 480 return true; 481} 482 483/// Verify - Verify that a basic type descriptor is well formed. 484bool DIBasicType::Verify() const { 485 return isBasicType() && DbgNode->getNumOperands() == 10; 486} 487 488/// Verify - Verify that a derived type descriptor is well formed. 489bool DIDerivedType::Verify() const { 490 // Make sure DerivedFrom @ field 9 is MDNode. 491 if (!fieldIsMDNode(DbgNode, 9)) 492 return false; 493 if (getTag() == dwarf::DW_TAG_ptr_to_member_type) 494 // Make sure ClassType @ field 10 is a TypeRef. 495 if (!fieldIsTypeRef(DbgNode, 10)) 496 return false; 497 498 return isDerivedType() && DbgNode->getNumOperands() >= 10 && 499 DbgNode->getNumOperands() <= 14; 500} 501 502/// Verify - Verify that a composite type descriptor is well formed. 503bool DICompositeType::Verify() const { 504 if (!isCompositeType()) 505 return false; 506 507 // Make sure DerivedFrom @ field 9 and ContainingType @ field 12 are MDNodes. 508 if (!fieldIsMDNode(DbgNode, 9)) 509 return false; 510 if (!fieldIsTypeRef(DbgNode, 12)) 511 return false; 512 513 // Make sure the type identifier at field 14 is MDString, it can be null. 514 if (!fieldIsMDString(DbgNode, 14)) 515 return false; 516 517 // If this is an array type verify that we have a DIType in the derived type 518 // field as that's the type of our element. 519 if (getTag() == dwarf::DW_TAG_array_type) 520 if (!DIType(getTypeDerivedFrom())) 521 return false; 522 523 return DbgNode->getNumOperands() == 15; 524} 525 526/// Verify - Verify that a subprogram descriptor is well formed. 527bool DISubprogram::Verify() const { 528 if (!isSubprogram()) 529 return false; 530 531 // Make sure context @ field 2 and type @ field 7 are MDNodes. 532 if (!fieldIsMDNode(DbgNode, 2)) 533 return false; 534 if (!fieldIsMDNode(DbgNode, 7)) 535 return false; 536 // Containing type @ field 12. 537 if (!fieldIsTypeRef(DbgNode, 12)) 538 return false; 539 return DbgNode->getNumOperands() == 20; 540} 541 542/// Verify - Verify that a global variable descriptor is well formed. 543bool DIGlobalVariable::Verify() const { 544 if (!isGlobalVariable()) 545 return false; 546 547 if (getDisplayName().empty()) 548 return false; 549 // Make sure context @ field 2 and type @ field 8 are MDNodes. 550 if (!fieldIsMDNode(DbgNode, 2)) 551 return false; 552 if (!fieldIsMDNode(DbgNode, 8)) 553 return false; 554 // Make sure StaticDataMemberDeclaration @ field 12 is MDNode. 555 if (!fieldIsMDNode(DbgNode, 12)) 556 return false; 557 558 return DbgNode->getNumOperands() == 13; 559} 560 561/// Verify - Verify that a variable descriptor is well formed. 562bool DIVariable::Verify() const { 563 if (!isVariable()) 564 return false; 565 566 // Make sure context @ field 1 and type @ field 5 are MDNodes. 567 if (!fieldIsMDNode(DbgNode, 1)) 568 return false; 569 if (!fieldIsMDNode(DbgNode, 5)) 570 return false; 571 return DbgNode->getNumOperands() >= 8; 572} 573 574/// Verify - Verify that a location descriptor is well formed. 575bool DILocation::Verify() const { 576 if (!DbgNode) 577 return false; 578 579 return DbgNode->getNumOperands() == 4; 580} 581 582/// Verify - Verify that a namespace descriptor is well formed. 583bool DINameSpace::Verify() const { 584 if (!isNameSpace()) 585 return false; 586 return DbgNode->getNumOperands() == 5; 587} 588 589/// \brief Retrieve the MDNode for the directory/file pair. 590MDNode *DIFile::getFileNode() const { 591 return getNodeField(DbgNode, 1); 592} 593 594/// \brief Verify that the file descriptor is well formed. 595bool DIFile::Verify() const { 596 return isFile() && DbgNode->getNumOperands() == 2; 597} 598 599/// \brief Verify that the enumerator descriptor is well formed. 600bool DIEnumerator::Verify() const { 601 return isEnumerator() && DbgNode->getNumOperands() == 3; 602} 603 604/// \brief Verify that the subrange descriptor is well formed. 605bool DISubrange::Verify() const { 606 return isSubrange() && DbgNode->getNumOperands() == 3; 607} 608 609/// \brief Verify that the lexical block descriptor is well formed. 610bool DILexicalBlock::Verify() const { 611 return isLexicalBlock() && DbgNode->getNumOperands() == 6; 612} 613 614/// \brief Verify that the file-scoped lexical block descriptor is well formed. 615bool DILexicalBlockFile::Verify() const { 616 return isLexicalBlockFile() && DbgNode->getNumOperands() == 3; 617} 618 619/// \brief Verify that the template type parameter descriptor is well formed. 620bool DITemplateTypeParameter::Verify() const { 621 return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7; 622} 623 624/// \brief Verify that the template value parameter descriptor is well formed. 625bool DITemplateValueParameter::Verify() const { 626 return isTemplateValueParameter() && DbgNode->getNumOperands() == 8; 627} 628 629/// \brief Verify that the imported module descriptor is well formed. 630bool DIImportedEntity::Verify() const { 631 return isImportedEntity() && 632 (DbgNode->getNumOperands() == 4 || DbgNode->getNumOperands() == 5); 633} 634 635/// getOriginalTypeSize - If this type is derived from a base type then 636/// return base type size. 637uint64_t DIDerivedType::getOriginalTypeSize() const { 638 uint16_t Tag = getTag(); 639 640 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && 641 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && 642 Tag != dwarf::DW_TAG_restrict_type) 643 return getSizeInBits(); 644 645 DIType BaseType = getTypeDerivedFrom(); 646 647 // If this type is not derived from any type then take conservative approach. 648 if (!BaseType.isValid()) 649 return getSizeInBits(); 650 651 // If this is a derived type, go ahead and get the base type, unless it's a 652 // reference then it's just the size of the field. Pointer types have no need 653 // of this since they're a different type of qualification on the type. 654 if (BaseType.getTag() == dwarf::DW_TAG_reference_type || 655 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type) 656 return getSizeInBits(); 657 658 if (BaseType.isDerivedType()) 659 return DIDerivedType(BaseType).getOriginalTypeSize(); 660 661 return BaseType.getSizeInBits(); 662} 663 664/// getObjCProperty - Return property node, if this ivar is associated with one. 665MDNode *DIDerivedType::getObjCProperty() const { 666 return getNodeField(DbgNode, 10); 667} 668 669MDString *DICompositeType::getIdentifier() const { 670 return cast_or_null<MDString>(getField(DbgNode, 14)); 671} 672 673#ifndef NDEBUG 674static void VerifySubsetOf(const MDNode *LHS, const MDNode *RHS) { 675 for (unsigned i = 0; i != LHS->getNumOperands(); ++i) { 676 // Skip the 'empty' list (that's a single i32 0, rather than truly empty). 677 if (i == 0 && isa<ConstantInt>(LHS->getOperand(i))) 678 continue; 679 const MDNode *E = cast<MDNode>(LHS->getOperand(i)); 680 bool found = false; 681 for (unsigned j = 0; !found && j != RHS->getNumOperands(); ++j) 682 found = E == RHS->getOperand(j); 683 assert(found && "Losing a member during member list replacement"); 684 } 685} 686#endif 687 688/// \brief Set the array of member DITypes. 689void DICompositeType::setTypeArray(DIArray Elements, DIArray TParams) { 690 assert((!TParams || DbgNode->getNumOperands() == 15) && 691 "If you're setting the template parameters this should include a slot " 692 "for that!"); 693 TrackingVH<MDNode> N(*this); 694 if (Elements) { 695#ifndef NDEBUG 696 // Check that the new list of members contains all the old members as well. 697 if (const MDNode *El = cast_or_null<MDNode>(N->getOperand(10))) 698 VerifySubsetOf(El, Elements); 699#endif 700 N->replaceOperandWith(10, Elements); 701 } 702 if (TParams) 703 N->replaceOperandWith(13, TParams); 704 DbgNode = N; 705} 706 707void DICompositeType::addMember(DIDescriptor D) { 708 SmallVector<llvm::Value *, 16> M; 709 DIArray OrigM = getTypeArray(); 710 unsigned Elements = OrigM.getNumElements(); 711 if (Elements == 1 && !OrigM.getElement(0)) 712 Elements = 0; 713 M.reserve(Elements + 1); 714 for (unsigned i = 0; i != Elements; ++i) 715 M.push_back(OrigM.getElement(i)); 716 M.push_back(D); 717 setTypeArray(DIArray(MDNode::get(DbgNode->getContext(), M))); 718} 719 720/// Generate a reference to this DIType. Uses the type identifier instead 721/// of the actual MDNode if possible, to help type uniquing. 722Value *DIScope::generateRef() { 723 if (!isCompositeType()) 724 return *this; 725 DICompositeType DTy(DbgNode); 726 if (!DTy.getIdentifier()) 727 return *this; 728 return DTy.getIdentifier(); 729} 730 731/// \brief Set the containing type. 732void DICompositeType::setContainingType(DICompositeType ContainingType) { 733 TrackingVH<MDNode> N(*this); 734 N->replaceOperandWith(12, ContainingType.generateRef()); 735 DbgNode = N; 736} 737 738/// isInlinedFnArgument - Return true if this variable provides debugging 739/// information for an inlined function arguments. 740bool DIVariable::isInlinedFnArgument(const Function *CurFn) { 741 assert(CurFn && "Invalid function"); 742 if (!getContext().isSubprogram()) 743 return false; 744 // This variable is not inlined function argument if its scope 745 // does not describe current function. 746 return !DISubprogram(getContext()).describes(CurFn); 747} 748 749/// describes - Return true if this subprogram provides debugging 750/// information for the function F. 751bool DISubprogram::describes(const Function *F) { 752 assert(F && "Invalid function"); 753 if (F == getFunction()) 754 return true; 755 StringRef Name = getLinkageName(); 756 if (Name.empty()) 757 Name = getName(); 758 if (F->getName() == Name) 759 return true; 760 return false; 761} 762 763unsigned DISubprogram::isOptimized() const { 764 assert (DbgNode && "Invalid subprogram descriptor!"); 765 if (DbgNode->getNumOperands() == 15) 766 return getUnsignedField(14); 767 return 0; 768} 769 770MDNode *DISubprogram::getVariablesNodes() const { 771 return getNodeField(DbgNode, 18); 772} 773 774DIArray DISubprogram::getVariables() const { 775 return DIArray(getNodeField(DbgNode, 18)); 776} 777 778Value *DITemplateValueParameter::getValue() const { 779 return getField(DbgNode, 4); 780} 781 782// If the current node has a parent scope then return that, 783// else return an empty scope. 784DIScope DIScope::getContext() const { 785 786 if (isType()) 787 return DIType(DbgNode).getContext(); 788 789 if (isSubprogram()) 790 return DISubprogram(DbgNode).getContext(); 791 792 if (isLexicalBlock()) 793 return DILexicalBlock(DbgNode).getContext(); 794 795 if (isLexicalBlockFile()) 796 return DILexicalBlockFile(DbgNode).getContext(); 797 798 if (isNameSpace()) 799 return DINameSpace(DbgNode).getContext(); 800 801 assert((isFile() || isCompileUnit()) && "Unhandled type of scope."); 802 return DIScope(); 803} 804 805StringRef DIScope::getFilename() const { 806 if (!DbgNode) 807 return StringRef(); 808 return ::getStringField(getNodeField(DbgNode, 1), 0); 809} 810 811StringRef DIScope::getDirectory() const { 812 if (!DbgNode) 813 return StringRef(); 814 return ::getStringField(getNodeField(DbgNode, 1), 1); 815} 816 817DIArray DICompileUnit::getEnumTypes() const { 818 if (!DbgNode || DbgNode->getNumOperands() < 13) 819 return DIArray(); 820 821 return DIArray(getNodeField(DbgNode, 7)); 822} 823 824DIArray DICompileUnit::getRetainedTypes() const { 825 if (!DbgNode || DbgNode->getNumOperands() < 13) 826 return DIArray(); 827 828 return DIArray(getNodeField(DbgNode, 8)); 829} 830 831DIArray DICompileUnit::getSubprograms() const { 832 if (!DbgNode || DbgNode->getNumOperands() < 13) 833 return DIArray(); 834 835 return DIArray(getNodeField(DbgNode, 9)); 836} 837 838 839DIArray DICompileUnit::getGlobalVariables() const { 840 if (!DbgNode || DbgNode->getNumOperands() < 13) 841 return DIArray(); 842 843 return DIArray(getNodeField(DbgNode, 10)); 844} 845 846DIArray DICompileUnit::getImportedEntities() const { 847 if (!DbgNode || DbgNode->getNumOperands() < 13) 848 return DIArray(); 849 850 return DIArray(getNodeField(DbgNode, 11)); 851} 852 853/// fixupSubprogramName - Replace contains special characters used 854/// in a typical Objective-C names with '.' in a given string. 855static void fixupSubprogramName(DISubprogram Fn, SmallVectorImpl<char> &Out) { 856 StringRef FName = 857 Fn.getFunction() ? Fn.getFunction()->getName() : Fn.getName(); 858 FName = Function::getRealLinkageName(FName); 859 860 StringRef Prefix("llvm.dbg.lv."); 861 Out.reserve(FName.size() + Prefix.size()); 862 Out.append(Prefix.begin(), Prefix.end()); 863 864 bool isObjCLike = false; 865 for (size_t i = 0, e = FName.size(); i < e; ++i) { 866 char C = FName[i]; 867 if (C == '[') 868 isObjCLike = true; 869 870 if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' || 871 C == '+' || C == '(' || C == ')')) 872 Out.push_back('.'); 873 else 874 Out.push_back(C); 875 } 876} 877 878/// getFnSpecificMDNode - Return a NameMDNode, if available, that is 879/// suitable to hold function specific information. 880NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) { 881 SmallString<32> Name; 882 fixupSubprogramName(Fn, Name); 883 return M.getNamedMetadata(Name.str()); 884} 885 886/// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable 887/// to hold function specific information. 888NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) { 889 SmallString<32> Name; 890 fixupSubprogramName(Fn, Name); 891 return M.getOrInsertNamedMetadata(Name.str()); 892} 893 894/// createInlinedVariable - Create a new inlined variable based on current 895/// variable. 896/// @param DV Current Variable. 897/// @param InlinedScope Location at current variable is inlined. 898DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope, 899 LLVMContext &VMContext) { 900 SmallVector<Value *, 16> Elts; 901 // Insert inlined scope as 7th element. 902 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) 903 i == 7 ? Elts.push_back(InlinedScope) : 904 Elts.push_back(DV->getOperand(i)); 905 return DIVariable(MDNode::get(VMContext, Elts)); 906} 907 908/// cleanseInlinedVariable - Remove inlined scope from the variable. 909DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) { 910 SmallVector<Value *, 16> Elts; 911 // Insert inlined scope as 7th element. 912 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) 913 i == 7 ? 914 Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext))): 915 Elts.push_back(DV->getOperand(i)); 916 return DIVariable(MDNode::get(VMContext, Elts)); 917} 918 919/// getDISubprogram - Find subprogram that is enclosing this scope. 920DISubprogram llvm::getDISubprogram(const MDNode *Scope) { 921 DIDescriptor D(Scope); 922 if (D.isSubprogram()) 923 return DISubprogram(Scope); 924 925 if (D.isLexicalBlockFile()) 926 return getDISubprogram(DILexicalBlockFile(Scope).getContext()); 927 928 if (D.isLexicalBlock()) 929 return getDISubprogram(DILexicalBlock(Scope).getContext()); 930 931 return DISubprogram(); 932} 933 934/// getDICompositeType - Find underlying composite type. 935DICompositeType llvm::getDICompositeType(DIType T) { 936 if (T.isCompositeType()) 937 return DICompositeType(T); 938 939 if (T.isDerivedType()) 940 return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom()); 941 942 return DICompositeType(); 943} 944 945/// Update DITypeIdentifierMap by going through retained types of each CU. 946DITypeIdentifierMap llvm::generateDITypeIdentifierMap( 947 const NamedMDNode *CU_Nodes) { 948 DITypeIdentifierMap Map; 949 for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) { 950 DICompileUnit CU(CU_Nodes->getOperand(CUi)); 951 DIArray Retain = CU.getRetainedTypes(); 952 for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) { 953 if (!Retain.getElement(Ti).isCompositeType()) 954 continue; 955 DICompositeType Ty(Retain.getElement(Ti)); 956 if (MDString *TypeId = Ty.getIdentifier()) { 957 // Definition has priority over declaration. 958 // Try to insert (TypeId, Ty) to Map. 959 std::pair<DITypeIdentifierMap::iterator, bool> P = 960 Map.insert(std::make_pair(TypeId, Ty)); 961 // If TypeId already exists in Map and this is a definition, replace 962 // whatever we had (declaration or definition) with the definition. 963 if (!P.second && !Ty.isForwardDecl()) 964 P.first->second = Ty; 965 } 966 } 967 } 968 return Map; 969} 970 971//===----------------------------------------------------------------------===// 972// DebugInfoFinder implementations. 973//===----------------------------------------------------------------------===// 974 975void DebugInfoFinder::reset() { 976 CUs.clear(); 977 SPs.clear(); 978 GVs.clear(); 979 TYs.clear(); 980 Scopes.clear(); 981 NodesSeen.clear(); 982} 983 984/// processModule - Process entire module and collect debug info. 985void DebugInfoFinder::processModule(const Module &M) { 986 if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) { 987 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 988 DICompileUnit CU(CU_Nodes->getOperand(i)); 989 addCompileUnit(CU); 990 DIArray GVs = CU.getGlobalVariables(); 991 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) { 992 DIGlobalVariable DIG(GVs.getElement(i)); 993 if (addGlobalVariable(DIG)) { 994 processScope(DIG.getContext()); 995 processType(DIG.getType()); 996 } 997 } 998 DIArray SPs = CU.getSubprograms(); 999 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) 1000 processSubprogram(DISubprogram(SPs.getElement(i))); 1001 DIArray EnumTypes = CU.getEnumTypes(); 1002 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) 1003 processType(DIType(EnumTypes.getElement(i))); 1004 DIArray RetainedTypes = CU.getRetainedTypes(); 1005 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) 1006 processType(DIType(RetainedTypes.getElement(i))); 1007 DIArray Imports = CU.getImportedEntities(); 1008 for (unsigned i = 0, e = Imports.getNumElements(); i != e; ++i) { 1009 DIImportedEntity Import = DIImportedEntity( 1010 Imports.getElement(i)); 1011 DIDescriptor Entity = Import.getEntity(); 1012 if (Entity.isType()) 1013 processType(DIType(Entity)); 1014 else if (Entity.isSubprogram()) 1015 processSubprogram(DISubprogram(Entity)); 1016 else if (Entity.isNameSpace()) 1017 processScope(DINameSpace(Entity).getContext()); 1018 } 1019 // FIXME: We really shouldn't be bailing out after visiting just one CU 1020 return; 1021 } 1022 } 1023} 1024 1025/// processLocation - Process DILocation. 1026void DebugInfoFinder::processLocation(DILocation Loc) { 1027 if (!Loc) return; 1028 processScope(Loc.getScope()); 1029 processLocation(Loc.getOrigLocation()); 1030} 1031 1032/// processType - Process DIType. 1033void DebugInfoFinder::processType(DIType DT) { 1034 if (!addType(DT)) 1035 return; 1036 processScope(DT.getContext()); 1037 if (DT.isCompositeType()) { 1038 DICompositeType DCT(DT); 1039 processType(DCT.getTypeDerivedFrom()); 1040 DIArray DA = DCT.getTypeArray(); 1041 for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) { 1042 DIDescriptor D = DA.getElement(i); 1043 if (D.isType()) 1044 processType(DIType(D)); 1045 else if (D.isSubprogram()) 1046 processSubprogram(DISubprogram(D)); 1047 } 1048 } else if (DT.isDerivedType()) { 1049 DIDerivedType DDT(DT); 1050 processType(DDT.getTypeDerivedFrom()); 1051 } 1052} 1053 1054void DebugInfoFinder::processScope(DIScope Scope) { 1055 if (Scope.isType()) { 1056 DIType Ty(Scope); 1057 processType(Ty); 1058 return; 1059 } 1060 if (Scope.isCompileUnit()) { 1061 addCompileUnit(DICompileUnit(Scope)); 1062 return; 1063 } 1064 if (Scope.isSubprogram()) { 1065 processSubprogram(DISubprogram(Scope)); 1066 return; 1067 } 1068 if (!addScope(Scope)) 1069 return; 1070 if (Scope.isLexicalBlock()) { 1071 DILexicalBlock LB(Scope); 1072 processScope(LB.getContext()); 1073 } else if (Scope.isLexicalBlockFile()) { 1074 DILexicalBlockFile LBF = DILexicalBlockFile(Scope); 1075 processScope(LBF.getScope()); 1076 } else if (Scope.isNameSpace()) { 1077 DINameSpace NS(Scope); 1078 processScope(NS.getContext()); 1079 } 1080} 1081 1082/// processLexicalBlock 1083void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) { 1084 DIScope Context = LB.getContext(); 1085 if (Context.isLexicalBlock()) 1086 return processLexicalBlock(DILexicalBlock(Context)); 1087 else if (Context.isLexicalBlockFile()) { 1088 DILexicalBlockFile DBF = DILexicalBlockFile(Context); 1089 return processLexicalBlock(DILexicalBlock(DBF.getScope())); 1090 } 1091 else 1092 return processSubprogram(DISubprogram(Context)); 1093} 1094 1095/// processSubprogram - Process DISubprogram. 1096void DebugInfoFinder::processSubprogram(DISubprogram SP) { 1097 if (!addSubprogram(SP)) 1098 return; 1099 processScope(SP.getContext()); 1100 processType(SP.getType()); 1101 DIArray TParams = SP.getTemplateParams(); 1102 for (unsigned I = 0, E = TParams.getNumElements(); I != E; ++I) { 1103 DIDescriptor Element = TParams.getElement(I); 1104 if (Element.isTemplateTypeParameter()) { 1105 DITemplateTypeParameter TType(Element); 1106 processScope(TType.getContext()); 1107 processType(TType.getType()); 1108 } else if (Element.isTemplateValueParameter()) { 1109 DITemplateValueParameter TVal(Element); 1110 processScope(TVal.getContext()); 1111 processType(TVal.getType()); 1112 } 1113 } 1114} 1115 1116/// processDeclare - Process DbgDeclareInst. 1117void DebugInfoFinder::processDeclare(const DbgDeclareInst *DDI) { 1118 MDNode *N = dyn_cast<MDNode>(DDI->getVariable()); 1119 if (!N) return; 1120 1121 DIDescriptor DV(N); 1122 if (!DV.isVariable()) 1123 return; 1124 1125 if (!NodesSeen.insert(DV)) 1126 return; 1127 processScope(DIVariable(N).getContext()); 1128 processType(DIVariable(N).getType()); 1129} 1130 1131void DebugInfoFinder::processValue(const DbgValueInst *DVI) { 1132 MDNode *N = dyn_cast<MDNode>(DVI->getVariable()); 1133 if (!N) return; 1134 1135 DIDescriptor DV(N); 1136 if (!DV.isVariable()) 1137 return; 1138 1139 if (!NodesSeen.insert(DV)) 1140 return; 1141 processScope(DIVariable(N).getContext()); 1142 processType(DIVariable(N).getType()); 1143} 1144 1145/// addType - Add type into Tys. 1146bool DebugInfoFinder::addType(DIType DT) { 1147 if (!DT) 1148 return false; 1149 1150 if (!NodesSeen.insert(DT)) 1151 return false; 1152 1153 TYs.push_back(DT); 1154 return true; 1155} 1156 1157/// addCompileUnit - Add compile unit into CUs. 1158bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) { 1159 if (!CU) 1160 return false; 1161 if (!NodesSeen.insert(CU)) 1162 return false; 1163 1164 CUs.push_back(CU); 1165 return true; 1166} 1167 1168/// addGlobalVariable - Add global variable into GVs. 1169bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) { 1170 if (!DIG) 1171 return false; 1172 1173 if (!NodesSeen.insert(DIG)) 1174 return false; 1175 1176 GVs.push_back(DIG); 1177 return true; 1178} 1179 1180// addSubprogram - Add subprgoram into SPs. 1181bool DebugInfoFinder::addSubprogram(DISubprogram SP) { 1182 if (!SP) 1183 return false; 1184 1185 if (!NodesSeen.insert(SP)) 1186 return false; 1187 1188 SPs.push_back(SP); 1189 return true; 1190} 1191 1192bool DebugInfoFinder::addScope(DIScope Scope) { 1193 if (!Scope) 1194 return false; 1195 // FIXME: Ocaml binding generates a scope with no content, we treat it 1196 // as null for now. 1197 if (Scope->getNumOperands() == 0) 1198 return false; 1199 if (!NodesSeen.insert(Scope)) 1200 return false; 1201 Scopes.push_back(Scope); 1202 return true; 1203} 1204 1205//===----------------------------------------------------------------------===// 1206// DIDescriptor: dump routines for all descriptors. 1207//===----------------------------------------------------------------------===// 1208 1209/// dump - Print descriptor to dbgs() with a newline. 1210void DIDescriptor::dump() const { 1211 print(dbgs()); dbgs() << '\n'; 1212} 1213 1214/// print - Print descriptor. 1215void DIDescriptor::print(raw_ostream &OS) const { 1216 if (!DbgNode) return; 1217 1218 if (const char *Tag = dwarf::TagString(getTag())) 1219 OS << "[ " << Tag << " ]"; 1220 1221 if (this->isSubrange()) { 1222 DISubrange(DbgNode).printInternal(OS); 1223 } else if (this->isCompileUnit()) { 1224 DICompileUnit(DbgNode).printInternal(OS); 1225 } else if (this->isFile()) { 1226 DIFile(DbgNode).printInternal(OS); 1227 } else if (this->isEnumerator()) { 1228 DIEnumerator(DbgNode).printInternal(OS); 1229 } else if (this->isBasicType()) { 1230 DIType(DbgNode).printInternal(OS); 1231 } else if (this->isDerivedType()) { 1232 DIDerivedType(DbgNode).printInternal(OS); 1233 } else if (this->isCompositeType()) { 1234 DICompositeType(DbgNode).printInternal(OS); 1235 } else if (this->isSubprogram()) { 1236 DISubprogram(DbgNode).printInternal(OS); 1237 } else if (this->isGlobalVariable()) { 1238 DIGlobalVariable(DbgNode).printInternal(OS); 1239 } else if (this->isVariable()) { 1240 DIVariable(DbgNode).printInternal(OS); 1241 } else if (this->isObjCProperty()) { 1242 DIObjCProperty(DbgNode).printInternal(OS); 1243 } else if (this->isNameSpace()) { 1244 DINameSpace(DbgNode).printInternal(OS); 1245 } else if (this->isScope()) { 1246 DIScope(DbgNode).printInternal(OS); 1247 } 1248} 1249 1250void DISubrange::printInternal(raw_ostream &OS) const { 1251 int64_t Count = getCount(); 1252 if (Count != -1) 1253 OS << " [" << getLo() << ", " << Count - 1 << ']'; 1254 else 1255 OS << " [unbounded]"; 1256} 1257 1258void DIScope::printInternal(raw_ostream &OS) const { 1259 OS << " [" << getDirectory() << "/" << getFilename() << ']'; 1260} 1261 1262void DICompileUnit::printInternal(raw_ostream &OS) const { 1263 DIScope::printInternal(OS); 1264 OS << " ["; 1265 unsigned Lang = getLanguage(); 1266 if (const char *LangStr = dwarf::LanguageString(Lang)) 1267 OS << LangStr; 1268 else 1269 (OS << "lang 0x").write_hex(Lang); 1270 OS << ']'; 1271} 1272 1273void DIEnumerator::printInternal(raw_ostream &OS) const { 1274 OS << " [" << getName() << " :: " << getEnumValue() << ']'; 1275} 1276 1277void DIType::printInternal(raw_ostream &OS) const { 1278 if (!DbgNode) return; 1279 1280 StringRef Res = getName(); 1281 if (!Res.empty()) 1282 OS << " [" << Res << "]"; 1283 1284 // TODO: Print context? 1285 1286 OS << " [line " << getLineNumber() 1287 << ", size " << getSizeInBits() 1288 << ", align " << getAlignInBits() 1289 << ", offset " << getOffsetInBits(); 1290 if (isBasicType()) 1291 if (const char *Enc = 1292 dwarf::AttributeEncodingString(DIBasicType(DbgNode).getEncoding())) 1293 OS << ", enc " << Enc; 1294 OS << "]"; 1295 1296 if (isPrivate()) 1297 OS << " [private]"; 1298 else if (isProtected()) 1299 OS << " [protected]"; 1300 1301 if (isArtificial()) 1302 OS << " [artificial]"; 1303 1304 if (isForwardDecl()) 1305 OS << " [decl]"; 1306 else if (getTag() == dwarf::DW_TAG_structure_type || 1307 getTag() == dwarf::DW_TAG_union_type || 1308 getTag() == dwarf::DW_TAG_enumeration_type || 1309 getTag() == dwarf::DW_TAG_class_type) 1310 OS << " [def]"; 1311 if (isVector()) 1312 OS << " [vector]"; 1313 if (isStaticMember()) 1314 OS << " [static]"; 1315} 1316 1317void DIDerivedType::printInternal(raw_ostream &OS) const { 1318 DIType::printInternal(OS); 1319 OS << " [from " << getTypeDerivedFrom().getName() << ']'; 1320} 1321 1322void DICompositeType::printInternal(raw_ostream &OS) const { 1323 DIType::printInternal(OS); 1324 DIArray A = getTypeArray(); 1325 OS << " [" << A.getNumElements() << " elements]"; 1326} 1327 1328void DINameSpace::printInternal(raw_ostream &OS) const { 1329 StringRef Name = getName(); 1330 if (!Name.empty()) 1331 OS << " [" << Name << ']'; 1332 1333 OS << " [line " << getLineNumber() << ']'; 1334} 1335 1336void DISubprogram::printInternal(raw_ostream &OS) const { 1337 // TODO : Print context 1338 OS << " [line " << getLineNumber() << ']'; 1339 1340 if (isLocalToUnit()) 1341 OS << " [local]"; 1342 1343 if (isDefinition()) 1344 OS << " [def]"; 1345 1346 if (getScopeLineNumber() != getLineNumber()) 1347 OS << " [scope " << getScopeLineNumber() << "]"; 1348 1349 if (isPrivate()) 1350 OS << " [private]"; 1351 else if (isProtected()) 1352 OS << " [protected]"; 1353 1354 StringRef Res = getName(); 1355 if (!Res.empty()) 1356 OS << " [" << Res << ']'; 1357} 1358 1359void DIGlobalVariable::printInternal(raw_ostream &OS) const { 1360 StringRef Res = getName(); 1361 if (!Res.empty()) 1362 OS << " [" << Res << ']'; 1363 1364 OS << " [line " << getLineNumber() << ']'; 1365 1366 // TODO : Print context 1367 1368 if (isLocalToUnit()) 1369 OS << " [local]"; 1370 1371 if (isDefinition()) 1372 OS << " [def]"; 1373} 1374 1375void DIVariable::printInternal(raw_ostream &OS) const { 1376 StringRef Res = getName(); 1377 if (!Res.empty()) 1378 OS << " [" << Res << ']'; 1379 1380 OS << " [line " << getLineNumber() << ']'; 1381} 1382 1383void DIObjCProperty::printInternal(raw_ostream &OS) const { 1384 StringRef Name = getObjCPropertyName(); 1385 if (!Name.empty()) 1386 OS << " [" << Name << ']'; 1387 1388 OS << " [line " << getLineNumber() 1389 << ", properties " << getUnsignedField(6) << ']'; 1390} 1391 1392static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS, 1393 const LLVMContext &Ctx) { 1394 if (!DL.isUnknown()) { // Print source line info. 1395 DIScope Scope(DL.getScope(Ctx)); 1396 assert(Scope.isScope() && 1397 "Scope of a DebugLoc should be a DIScope."); 1398 // Omit the directory, because it's likely to be long and uninteresting. 1399 CommentOS << Scope.getFilename(); 1400 CommentOS << ':' << DL.getLine(); 1401 if (DL.getCol() != 0) 1402 CommentOS << ':' << DL.getCol(); 1403 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx)); 1404 if (!InlinedAtDL.isUnknown()) { 1405 CommentOS << " @[ "; 1406 printDebugLoc(InlinedAtDL, CommentOS, Ctx); 1407 CommentOS << " ]"; 1408 } 1409 } 1410} 1411 1412void DIVariable::printExtendedName(raw_ostream &OS) const { 1413 const LLVMContext &Ctx = DbgNode->getContext(); 1414 StringRef Res = getName(); 1415 if (!Res.empty()) 1416 OS << Res << "," << getLineNumber(); 1417 if (MDNode *InlinedAt = getInlinedAt()) { 1418 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt); 1419 if (!InlinedAtDL.isUnknown()) { 1420 OS << " @["; 1421 printDebugLoc(InlinedAtDL, OS, Ctx); 1422 OS << "]"; 1423 } 1424 } 1425} 1426 1427DIScopeRef::DIScopeRef(const Value *V) : Val(V) { 1428 assert(isScopeRef(V) && "DIScopeRef should be a MDString or MDNode"); 1429} 1430 1431/// Given a DITypeIdentifierMap, tries to find the corresponding 1432/// DIScope for a DIScopeRef. 1433DIScope DIScopeRef::resolve(const DITypeIdentifierMap &Map) const { 1434 if (!Val) 1435 return DIScope(); 1436 1437 if (const MDNode *MD = dyn_cast<MDNode>(Val)) 1438 return DIScope(MD); 1439 1440 const MDString *MS = cast<MDString>(Val); 1441 // Find the corresponding MDNode. 1442 DITypeIdentifierMap::const_iterator Iter = Map.find(MS); 1443 assert(Iter != Map.end() && "Identifier not in the type map?"); 1444 assert(DIType(Iter->second).isType() && 1445 "MDNode in DITypeIdentifierMap should be a DIType."); 1446 return DIScope(Iter->second); 1447} 1448 1449/// Specialize getFieldAs to handle fields that are references to DIScopes. 1450template <> 1451DIScopeRef DIDescriptor::getFieldAs<DIScopeRef>(unsigned Elt) const { 1452 return DIScopeRef(getField(DbgNode, Elt)); 1453} 1454