DebugInfo.cpp revision d4afa8bbabd83e2b68afcc61e44fadb9e7964b07
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 return true; 250 default: 251 break; 252 } 253 return false; 254} 255 256/// isTemplateTypeParameter - Return true if the specified tag is 257/// DW_TAG_template_type_parameter. 258bool DIDescriptor::isTemplateTypeParameter() const { 259 return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter; 260} 261 262/// isTemplateValueParameter - Return true if the specified tag is 263/// DW_TAG_template_value_parameter. 264bool DIDescriptor::isTemplateValueParameter() const { 265 return DbgNode && (getTag() == dwarf::DW_TAG_template_value_parameter || 266 getTag() == dwarf::DW_TAG_GNU_template_template_param || 267 getTag() == dwarf::DW_TAG_GNU_template_parameter_pack); 268} 269 270/// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit. 271bool DIDescriptor::isCompileUnit() const { 272 return DbgNode && getTag() == dwarf::DW_TAG_compile_unit; 273} 274 275/// isFile - Return true if the specified tag is DW_TAG_file_type. 276bool DIDescriptor::isFile() const { 277 return DbgNode && getTag() == dwarf::DW_TAG_file_type; 278} 279 280/// isNameSpace - Return true if the specified tag is DW_TAG_namespace. 281bool DIDescriptor::isNameSpace() const { 282 return DbgNode && getTag() == dwarf::DW_TAG_namespace; 283} 284 285/// isLexicalBlockFile - Return true if the specified descriptor is a 286/// lexical block with an extra file. 287bool DIDescriptor::isLexicalBlockFile() const { 288 return DbgNode && getTag() == dwarf::DW_TAG_lexical_block && 289 (DbgNode->getNumOperands() == 3); 290} 291 292/// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block. 293bool DIDescriptor::isLexicalBlock() const { 294 return DbgNode && getTag() == dwarf::DW_TAG_lexical_block && 295 (DbgNode->getNumOperands() > 3); 296} 297 298/// isSubrange - Return true if the specified tag is DW_TAG_subrange_type. 299bool DIDescriptor::isSubrange() const { 300 return DbgNode && getTag() == dwarf::DW_TAG_subrange_type; 301} 302 303/// isEnumerator - Return true if the specified tag is DW_TAG_enumerator. 304bool DIDescriptor::isEnumerator() const { 305 return DbgNode && getTag() == dwarf::DW_TAG_enumerator; 306} 307 308/// isObjCProperty - Return true if the specified tag is DW_TAG_APPLE_property. 309bool DIDescriptor::isObjCProperty() const { 310 return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property; 311} 312 313/// \brief Return true if the specified tag is DW_TAG_imported_module or 314/// DW_TAG_imported_declaration. 315bool DIDescriptor::isImportedEntity() const { 316 return DbgNode && (getTag() == dwarf::DW_TAG_imported_module || 317 getTag() == dwarf::DW_TAG_imported_declaration); 318} 319 320//===----------------------------------------------------------------------===// 321// Simple Descriptor Constructors and other Methods 322//===----------------------------------------------------------------------===// 323 324unsigned DIArray::getNumElements() const { 325 if (!DbgNode) 326 return 0; 327 return DbgNode->getNumOperands(); 328} 329 330/// replaceAllUsesWith - Replace all uses of the MDNode used by this 331/// type with the one in the passed descriptor. 332void DIType::replaceAllUsesWith(DIDescriptor &D) { 333 334 assert(DbgNode && "Trying to replace an unverified type!"); 335 336 // Since we use a TrackingVH for the node, its easy for clients to manufacture 337 // legitimate situations where they want to replaceAllUsesWith() on something 338 // which, due to uniquing, has merged with the source. We shield clients from 339 // this detail by allowing a value to be replaced with replaceAllUsesWith() 340 // itself. 341 if (DbgNode != D) { 342 MDNode *Node = const_cast<MDNode*>(DbgNode); 343 const MDNode *DN = D; 344 const Value *V = cast_or_null<Value>(DN); 345 Node->replaceAllUsesWith(const_cast<Value*>(V)); 346 MDNode::deleteTemporary(Node); 347 } 348} 349 350/// replaceAllUsesWith - Replace all uses of the MDNode used by this 351/// type with the one in D. 352void DIType::replaceAllUsesWith(MDNode *D) { 353 354 assert(DbgNode && "Trying to replace an unverified type!"); 355 356 // Since we use a TrackingVH for the node, its easy for clients to manufacture 357 // legitimate situations where they want to replaceAllUsesWith() on something 358 // which, due to uniquing, has merged with the source. We shield clients from 359 // this detail by allowing a value to be replaced with replaceAllUsesWith() 360 // itself. 361 if (DbgNode != D) { 362 MDNode *Node = const_cast<MDNode*>(DbgNode); 363 const MDNode *DN = D; 364 const Value *V = cast_or_null<Value>(DN); 365 Node->replaceAllUsesWith(const_cast<Value*>(V)); 366 MDNode::deleteTemporary(Node); 367 } 368} 369 370/// isUnsignedDIType - Return true if type encoding is unsigned. 371bool DIType::isUnsignedDIType() { 372 DIDerivedType DTy(DbgNode); 373 if (DTy.Verify()) 374 return DTy.getTypeDerivedFrom().isUnsignedDIType(); 375 376 DIBasicType BTy(DbgNode); 377 if (BTy.Verify()) { 378 unsigned Encoding = BTy.getEncoding(); 379 if (Encoding == dwarf::DW_ATE_unsigned || 380 Encoding == dwarf::DW_ATE_unsigned_char || 381 Encoding == dwarf::DW_ATE_boolean) 382 return true; 383 } 384 return false; 385} 386 387/// Verify - Verify that a compile unit is well formed. 388bool DICompileUnit::Verify() const { 389 if (!isCompileUnit()) 390 return false; 391 392 // Don't bother verifying the compilation directory or producer string 393 // as those could be empty. 394 if (getFilename().empty()) 395 return false; 396 397 return DbgNode->getNumOperands() == 13; 398} 399 400/// Verify - Verify that an ObjC property is well formed. 401bool DIObjCProperty::Verify() const { 402 if (!isObjCProperty()) 403 return false; 404 405 // Don't worry about the rest of the strings for now. 406 return DbgNode->getNumOperands() == 8; 407} 408 409/// Check if a field at position Elt of a MDNode is a MDNode. 410/// We currently allow an empty string and an integer. 411/// But we don't allow a non-empty string in a MDNode field. 412static bool fieldIsMDNode(const MDNode *DbgNode, unsigned Elt) { 413 // FIXME: This function should return true, if the field is null or the field 414 // is indeed a MDNode: return !Fld || isa<MDNode>(Fld). 415 Value *Fld = getField(DbgNode, Elt); 416 if (Fld && isa<MDString>(Fld) && 417 !cast<MDString>(Fld)->getString().empty()) 418 return false; 419 return true; 420} 421 422/// Verify - Verify that a type descriptor is well formed. 423bool DIType::Verify() const { 424 if (!isType()) 425 return false; 426 // Make sure Context @ field 2 is MDNode. 427 if (!fieldIsMDNode(DbgNode, 2)) 428 return false; 429 430 // FIXME: Sink this into the various subclass verifies. 431 unsigned Tag = getTag(); 432 if (!isBasicType() && Tag != dwarf::DW_TAG_const_type && 433 Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type && 434 Tag != dwarf::DW_TAG_ptr_to_member_type && 435 Tag != dwarf::DW_TAG_reference_type && 436 Tag != dwarf::DW_TAG_rvalue_reference_type && 437 Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_array_type && 438 Tag != dwarf::DW_TAG_enumeration_type && 439 Tag != dwarf::DW_TAG_subroutine_type && 440 Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend && 441 getFilename().empty()) 442 return false; 443 // DIType is abstract, it should be a BasicType, a DerivedType or 444 // a CompositeType. 445 if (isBasicType()) 446 DIBasicType(DbgNode).Verify(); 447 else if (isCompositeType()) 448 DICompositeType(DbgNode).Verify(); 449 else if (isDerivedType()) 450 DIDerivedType(DbgNode).Verify(); 451 else 452 return false; 453 return true; 454} 455 456/// Verify - Verify that a basic type descriptor is well formed. 457bool DIBasicType::Verify() const { 458 return isBasicType() && DbgNode->getNumOperands() == 10; 459} 460 461/// Verify - Verify that a derived type descriptor is well formed. 462bool DIDerivedType::Verify() const { 463 // Make sure DerivedFrom @ field 9 is MDNode. 464 if (!fieldIsMDNode(DbgNode, 9)) 465 return false; 466 if (getTag() == dwarf::DW_TAG_ptr_to_member_type) 467 // Make sure ClassType @ field 10 is MDNode. 468 if (!fieldIsMDNode(DbgNode, 10)) 469 return false; 470 471 return isDerivedType() && DbgNode->getNumOperands() >= 10 && 472 DbgNode->getNumOperands() <= 14; 473} 474 475/// Verify - Verify that a composite type descriptor is well formed. 476bool DICompositeType::Verify() const { 477 if (!isCompositeType()) 478 return false; 479 480 // Make sure DerivedFrom @ field 9 and ContainingType @ field 12 are MDNodes. 481 if (!fieldIsMDNode(DbgNode, 9)) 482 return false; 483 if (!fieldIsMDNode(DbgNode, 12)) 484 return false; 485 486 return DbgNode->getNumOperands() >= 10 && DbgNode->getNumOperands() <= 14; 487} 488 489/// Verify - Verify that a subprogram descriptor is well formed. 490bool DISubprogram::Verify() const { 491 if (!isSubprogram()) 492 return false; 493 494 // Make sure context @ field 2 and type @ field 7 are MDNodes. 495 if (!fieldIsMDNode(DbgNode, 2)) 496 return false; 497 if (!fieldIsMDNode(DbgNode, 7)) 498 return false; 499 // Containing type @ field 12. 500 if (!fieldIsMDNode(DbgNode, 12)) 501 return false; 502 return DbgNode->getNumOperands() == 20; 503} 504 505/// Verify - Verify that a global variable descriptor is well formed. 506bool DIGlobalVariable::Verify() const { 507 if (!isGlobalVariable()) 508 return false; 509 510 if (getDisplayName().empty()) 511 return false; 512 // Make sure context @ field 2 and type @ field 8 are MDNodes. 513 if (!fieldIsMDNode(DbgNode, 2)) 514 return false; 515 if (!fieldIsMDNode(DbgNode, 8)) 516 return false; 517 // Make sure StaticDataMemberDeclaration @ field 12 is MDNode. 518 if (!fieldIsMDNode(DbgNode, 12)) 519 return false; 520 521 return DbgNode->getNumOperands() == 13; 522} 523 524/// Verify - Verify that a variable descriptor is well formed. 525bool DIVariable::Verify() const { 526 if (!isVariable()) 527 return false; 528 529 // Make sure context @ field 1 and type @ field 5 are MDNodes. 530 if (!fieldIsMDNode(DbgNode, 1)) 531 return false; 532 if (!fieldIsMDNode(DbgNode, 5)) 533 return false; 534 return DbgNode->getNumOperands() >= 8; 535} 536 537/// Verify - Verify that a location descriptor is well formed. 538bool DILocation::Verify() const { 539 if (!DbgNode) 540 return false; 541 542 return DbgNode->getNumOperands() == 4; 543} 544 545/// Verify - Verify that a namespace descriptor is well formed. 546bool DINameSpace::Verify() const { 547 if (!isNameSpace()) 548 return false; 549 return DbgNode->getNumOperands() == 5; 550} 551 552/// \brief Retrieve the MDNode for the directory/file pair. 553MDNode *DIFile::getFileNode() const { 554 return getNodeField(DbgNode, 1); 555} 556 557/// \brief Verify that the file descriptor is well formed. 558bool DIFile::Verify() const { 559 return isFile() && DbgNode->getNumOperands() == 2; 560} 561 562/// \brief Verify that the enumerator descriptor is well formed. 563bool DIEnumerator::Verify() const { 564 return isEnumerator() && DbgNode->getNumOperands() == 3; 565} 566 567/// \brief Verify that the subrange descriptor is well formed. 568bool DISubrange::Verify() const { 569 return isSubrange() && DbgNode->getNumOperands() == 3; 570} 571 572/// \brief Verify that the lexical block descriptor is well formed. 573bool DILexicalBlock::Verify() const { 574 return isLexicalBlock() && DbgNode->getNumOperands() == 6; 575} 576 577/// \brief Verify that the file-scoped lexical block descriptor is well formed. 578bool DILexicalBlockFile::Verify() const { 579 return isLexicalBlockFile() && DbgNode->getNumOperands() == 3; 580} 581 582/// \brief Verify that the template type parameter descriptor is well formed. 583bool DITemplateTypeParameter::Verify() const { 584 return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7; 585} 586 587/// \brief Verify that the template value parameter descriptor is well formed. 588bool DITemplateValueParameter::Verify() const { 589 return isTemplateValueParameter() && DbgNode->getNumOperands() == 8; 590} 591 592/// \brief Verify that the imported module descriptor is well formed. 593bool DIImportedEntity::Verify() const { 594 return isImportedEntity() && 595 (DbgNode->getNumOperands() == 4 || DbgNode->getNumOperands() == 5); 596} 597 598/// getOriginalTypeSize - If this type is derived from a base type then 599/// return base type size. 600uint64_t DIDerivedType::getOriginalTypeSize() const { 601 unsigned Tag = getTag(); 602 603 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && 604 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && 605 Tag != dwarf::DW_TAG_restrict_type) 606 return getSizeInBits(); 607 608 DIType BaseType = getTypeDerivedFrom(); 609 610 // If this type is not derived from any type then take conservative approach. 611 if (!BaseType.isValid()) 612 return getSizeInBits(); 613 614 // If this is a derived type, go ahead and get the base type, unless it's a 615 // reference then it's just the size of the field. Pointer types have no need 616 // of this since they're a different type of qualification on the type. 617 if (BaseType.getTag() == dwarf::DW_TAG_reference_type || 618 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type) 619 return getSizeInBits(); 620 621 if (BaseType.isDerivedType()) 622 return DIDerivedType(BaseType).getOriginalTypeSize(); 623 624 return BaseType.getSizeInBits(); 625} 626 627/// getObjCProperty - Return property node, if this ivar is associated with one. 628MDNode *DIDerivedType::getObjCProperty() const { 629 return getNodeField(DbgNode, 10); 630} 631 632/// \brief Set the array of member DITypes. 633void DICompositeType::setTypeArray(DIArray Elements, DIArray TParams) { 634 assert((!TParams || DbgNode->getNumOperands() == 14) && 635 "If you're setting the template parameters this should include a slot " 636 "for that!"); 637 TrackingVH<MDNode> N(*this); 638 N->replaceOperandWith(10, Elements); 639 if (TParams) 640 N->replaceOperandWith(13, TParams); 641 DbgNode = N; 642} 643 644/// \brief Set the containing type. 645void DICompositeType::setContainingType(DICompositeType ContainingType) { 646 TrackingVH<MDNode> N(*this); 647 N->replaceOperandWith(12, ContainingType); 648 DbgNode = N; 649} 650 651/// isInlinedFnArgument - Return true if this variable provides debugging 652/// information for an inlined function arguments. 653bool DIVariable::isInlinedFnArgument(const Function *CurFn) { 654 assert(CurFn && "Invalid function"); 655 if (!getContext().isSubprogram()) 656 return false; 657 // This variable is not inlined function argument if its scope 658 // does not describe current function. 659 return !DISubprogram(getContext()).describes(CurFn); 660} 661 662/// describes - Return true if this subprogram provides debugging 663/// information for the function F. 664bool DISubprogram::describes(const Function *F) { 665 assert(F && "Invalid function"); 666 if (F == getFunction()) 667 return true; 668 StringRef Name = getLinkageName(); 669 if (Name.empty()) 670 Name = getName(); 671 if (F->getName() == Name) 672 return true; 673 return false; 674} 675 676unsigned DISubprogram::isOptimized() const { 677 assert (DbgNode && "Invalid subprogram descriptor!"); 678 if (DbgNode->getNumOperands() == 15) 679 return getUnsignedField(14); 680 return 0; 681} 682 683MDNode *DISubprogram::getVariablesNodes() const { 684 return getNodeField(DbgNode, 18); 685} 686 687DIArray DISubprogram::getVariables() const { 688 return DIArray(getNodeField(DbgNode, 18)); 689} 690 691Value *DITemplateValueParameter::getValue() const { 692 return getField(DbgNode, 4); 693} 694 695// If the current node has a parent scope then return that, 696// else return an empty scope. 697DIScope DIScope::getContext() const { 698 699 if (isType()) 700 return DIType(DbgNode).getContext(); 701 702 if (isSubprogram()) 703 return DISubprogram(DbgNode).getContext(); 704 705 if (isLexicalBlock()) 706 return DILexicalBlock(DbgNode).getContext(); 707 708 if (isLexicalBlockFile()) 709 return DILexicalBlockFile(DbgNode).getContext(); 710 711 if (isNameSpace()) 712 return DINameSpace(DbgNode).getContext(); 713 714 assert(isFile() || isCompileUnit() && "Unhandled type of scope."); 715 return DIScope(); 716} 717 718StringRef DIScope::getFilename() const { 719 if (!DbgNode) 720 return StringRef(); 721 return ::getStringField(getNodeField(DbgNode, 1), 0); 722} 723 724StringRef DIScope::getDirectory() const { 725 if (!DbgNode) 726 return StringRef(); 727 return ::getStringField(getNodeField(DbgNode, 1), 1); 728} 729 730DIArray DICompileUnit::getEnumTypes() const { 731 if (!DbgNode || DbgNode->getNumOperands() < 13) 732 return DIArray(); 733 734 return DIArray(getNodeField(DbgNode, 7)); 735} 736 737DIArray DICompileUnit::getRetainedTypes() const { 738 if (!DbgNode || DbgNode->getNumOperands() < 13) 739 return DIArray(); 740 741 return DIArray(getNodeField(DbgNode, 8)); 742} 743 744DIArray DICompileUnit::getSubprograms() const { 745 if (!DbgNode || DbgNode->getNumOperands() < 13) 746 return DIArray(); 747 748 return DIArray(getNodeField(DbgNode, 9)); 749} 750 751 752DIArray DICompileUnit::getGlobalVariables() const { 753 if (!DbgNode || DbgNode->getNumOperands() < 13) 754 return DIArray(); 755 756 return DIArray(getNodeField(DbgNode, 10)); 757} 758 759DIArray DICompileUnit::getImportedEntities() const { 760 if (!DbgNode || DbgNode->getNumOperands() < 13) 761 return DIArray(); 762 763 return DIArray(getNodeField(DbgNode, 11)); 764} 765 766/// fixupSubprogramName - Replace contains special characters used 767/// in a typical Objective-C names with '.' in a given string. 768static void fixupSubprogramName(DISubprogram Fn, SmallVectorImpl<char> &Out) { 769 StringRef FName = 770 Fn.getFunction() ? Fn.getFunction()->getName() : Fn.getName(); 771 FName = Function::getRealLinkageName(FName); 772 773 StringRef Prefix("llvm.dbg.lv."); 774 Out.reserve(FName.size() + Prefix.size()); 775 Out.append(Prefix.begin(), Prefix.end()); 776 777 bool isObjCLike = false; 778 for (size_t i = 0, e = FName.size(); i < e; ++i) { 779 char C = FName[i]; 780 if (C == '[') 781 isObjCLike = true; 782 783 if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' || 784 C == '+' || C == '(' || C == ')')) 785 Out.push_back('.'); 786 else 787 Out.push_back(C); 788 } 789} 790 791/// getFnSpecificMDNode - Return a NameMDNode, if available, that is 792/// suitable to hold function specific information. 793NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) { 794 SmallString<32> Name; 795 fixupSubprogramName(Fn, Name); 796 return M.getNamedMetadata(Name.str()); 797} 798 799/// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable 800/// to hold function specific information. 801NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) { 802 SmallString<32> Name; 803 fixupSubprogramName(Fn, Name); 804 return M.getOrInsertNamedMetadata(Name.str()); 805} 806 807/// createInlinedVariable - Create a new inlined variable based on current 808/// variable. 809/// @param DV Current Variable. 810/// @param InlinedScope Location at current variable is inlined. 811DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope, 812 LLVMContext &VMContext) { 813 SmallVector<Value *, 16> Elts; 814 // Insert inlined scope as 7th element. 815 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) 816 i == 7 ? Elts.push_back(InlinedScope) : 817 Elts.push_back(DV->getOperand(i)); 818 return DIVariable(MDNode::get(VMContext, Elts)); 819} 820 821/// cleanseInlinedVariable - Remove inlined scope from the variable. 822DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) { 823 SmallVector<Value *, 16> Elts; 824 // Insert inlined scope as 7th element. 825 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) 826 i == 7 ? 827 Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext))): 828 Elts.push_back(DV->getOperand(i)); 829 return DIVariable(MDNode::get(VMContext, Elts)); 830} 831 832/// getDISubprogram - Find subprogram that is enclosing this scope. 833DISubprogram llvm::getDISubprogram(const MDNode *Scope) { 834 DIDescriptor D(Scope); 835 if (D.isSubprogram()) 836 return DISubprogram(Scope); 837 838 if (D.isLexicalBlockFile()) 839 return getDISubprogram(DILexicalBlockFile(Scope).getContext()); 840 841 if (D.isLexicalBlock()) 842 return getDISubprogram(DILexicalBlock(Scope).getContext()); 843 844 return DISubprogram(); 845} 846 847/// getDICompositeType - Find underlying composite type. 848DICompositeType llvm::getDICompositeType(DIType T) { 849 if (T.isCompositeType()) 850 return DICompositeType(T); 851 852 if (T.isDerivedType()) 853 return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom()); 854 855 return DICompositeType(); 856} 857 858/// isSubprogramContext - Return true if Context is either a subprogram 859/// or another context nested inside a subprogram. 860bool llvm::isSubprogramContext(const MDNode *Context) { 861 if (!Context) 862 return false; 863 DIDescriptor D(Context); 864 if (D.isSubprogram()) 865 return true; 866 if (D.isType()) 867 return isSubprogramContext(DIType(Context).getContext()); 868 return false; 869} 870 871//===----------------------------------------------------------------------===// 872// DebugInfoFinder implementations. 873//===----------------------------------------------------------------------===// 874 875void DebugInfoFinder::reset() { 876 CUs.clear(); 877 SPs.clear(); 878 GVs.clear(); 879 TYs.clear(); 880 Scopes.clear(); 881 NodesSeen.clear(); 882} 883 884/// processModule - Process entire module and collect debug info. 885void DebugInfoFinder::processModule(const Module &M) { 886 if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) { 887 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 888 DICompileUnit CU(CU_Nodes->getOperand(i)); 889 addCompileUnit(CU); 890 DIArray GVs = CU.getGlobalVariables(); 891 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) { 892 DIGlobalVariable DIG(GVs.getElement(i)); 893 if (addGlobalVariable(DIG)) { 894 processScope(DIG.getContext()); 895 processType(DIG.getType()); 896 } 897 } 898 DIArray SPs = CU.getSubprograms(); 899 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) 900 processSubprogram(DISubprogram(SPs.getElement(i))); 901 DIArray EnumTypes = CU.getEnumTypes(); 902 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) 903 processType(DIType(EnumTypes.getElement(i))); 904 DIArray RetainedTypes = CU.getRetainedTypes(); 905 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) 906 processType(DIType(RetainedTypes.getElement(i))); 907 // FIXME: We really shouldn't be bailing out after visiting just one CU 908 return; 909 } 910 } 911} 912 913/// processLocation - Process DILocation. 914void DebugInfoFinder::processLocation(DILocation Loc) { 915 if (!Loc.Verify()) return; 916 DIDescriptor S(Loc.getScope()); 917 if (S.isCompileUnit()) 918 addCompileUnit(DICompileUnit(S)); 919 else if (S.isSubprogram()) 920 processSubprogram(DISubprogram(S)); 921 else if (S.isLexicalBlock()) 922 processLexicalBlock(DILexicalBlock(S)); 923 else if (S.isLexicalBlockFile()) { 924 DILexicalBlockFile DBF = DILexicalBlockFile(S); 925 processLexicalBlock(DILexicalBlock(DBF.getScope())); 926 } 927 processLocation(Loc.getOrigLocation()); 928} 929 930/// processType - Process DIType. 931void DebugInfoFinder::processType(DIType DT) { 932 if (!addType(DT)) 933 return; 934 processScope(DT.getContext()); 935 if (DT.isCompositeType()) { 936 DICompositeType DCT(DT); 937 processType(DCT.getTypeDerivedFrom()); 938 DIArray DA = DCT.getTypeArray(); 939 for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) { 940 DIDescriptor D = DA.getElement(i); 941 if (D.isType()) 942 processType(DIType(D)); 943 else if (D.isSubprogram()) 944 processSubprogram(DISubprogram(D)); 945 } 946 } else if (DT.isDerivedType()) { 947 DIDerivedType DDT(DT); 948 processType(DDT.getTypeDerivedFrom()); 949 } 950} 951 952void DebugInfoFinder::processScope(DIScope Scope) { 953 if (Scope.isType()) { 954 DIType Ty(Scope); 955 processType(Ty); 956 return; 957 } 958 if (Scope.isCompileUnit()) { 959 addCompileUnit(DICompileUnit(Scope)); 960 return; 961 } 962 if (Scope.isSubprogram()) { 963 processSubprogram(DISubprogram(Scope)); 964 return; 965 } 966 if (!addScope(Scope)) 967 return; 968 if (Scope.isLexicalBlock()) { 969 DILexicalBlock LB(Scope); 970 processScope(LB.getContext()); 971 } else if (Scope.isLexicalBlockFile()) { 972 DILexicalBlockFile LBF = DILexicalBlockFile(Scope); 973 processScope(LBF.getScope()); 974 } else if (Scope.isNameSpace()) { 975 DINameSpace NS(Scope); 976 processScope(NS.getContext()); 977 } 978} 979 980/// processLexicalBlock 981void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) { 982 DIScope Context = LB.getContext(); 983 if (Context.isLexicalBlock()) 984 return processLexicalBlock(DILexicalBlock(Context)); 985 else if (Context.isLexicalBlockFile()) { 986 DILexicalBlockFile DBF = DILexicalBlockFile(Context); 987 return processLexicalBlock(DILexicalBlock(DBF.getScope())); 988 } 989 else 990 return processSubprogram(DISubprogram(Context)); 991} 992 993/// processSubprogram - Process DISubprogram. 994void DebugInfoFinder::processSubprogram(DISubprogram SP) { 995 if (!addSubprogram(SP)) 996 return; 997 processScope(SP.getContext()); 998 processType(SP.getType()); 999} 1000 1001/// processDeclare - Process DbgDeclareInst. 1002void DebugInfoFinder::processDeclare(const DbgDeclareInst *DDI) { 1003 MDNode *N = dyn_cast<MDNode>(DDI->getVariable()); 1004 if (!N) return; 1005 1006 DIDescriptor DV(N); 1007 if (!DV.isVariable()) 1008 return; 1009 1010 if (!NodesSeen.insert(DV)) 1011 return; 1012 processScope(DIVariable(N).getContext()); 1013 processType(DIVariable(N).getType()); 1014} 1015 1016void DebugInfoFinder::processValue(const DbgValueInst *DVI) { 1017 MDNode *N = dyn_cast<MDNode>(DVI->getVariable()); 1018 if (!N) return; 1019 1020 DIDescriptor DV(N); 1021 if (!DV.isVariable()) 1022 return; 1023 1024 if (!NodesSeen.insert(DV)) 1025 return; 1026 processScope(DIVariable(N).getContext()); 1027 processType(DIVariable(N).getType()); 1028} 1029 1030/// addType - Add type into Tys. 1031bool DebugInfoFinder::addType(DIType DT) { 1032 if (!DT.isValid()) 1033 return false; 1034 1035 if (!NodesSeen.insert(DT)) 1036 return false; 1037 1038 TYs.push_back(DT); 1039 return true; 1040} 1041 1042/// addCompileUnit - Add compile unit into CUs. 1043bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) { 1044 if (!CU.Verify()) 1045 return false; 1046 1047 if (!NodesSeen.insert(CU)) 1048 return false; 1049 1050 CUs.push_back(CU); 1051 return true; 1052} 1053 1054/// addGlobalVariable - Add global variable into GVs. 1055bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) { 1056 if (!DIDescriptor(DIG).isGlobalVariable()) 1057 return false; 1058 1059 if (!NodesSeen.insert(DIG)) 1060 return false; 1061 1062 GVs.push_back(DIG); 1063 return true; 1064} 1065 1066// addSubprogram - Add subprgoram into SPs. 1067bool DebugInfoFinder::addSubprogram(DISubprogram SP) { 1068 if (!DIDescriptor(SP).isSubprogram()) 1069 return false; 1070 1071 if (!NodesSeen.insert(SP)) 1072 return false; 1073 1074 SPs.push_back(SP); 1075 return true; 1076} 1077 1078bool DebugInfoFinder::addScope(DIScope Scope) { 1079 if (!Scope) 1080 return false; 1081 if (!NodesSeen.insert(Scope)) 1082 return false; 1083 Scopes.push_back(Scope); 1084 return true; 1085} 1086 1087//===----------------------------------------------------------------------===// 1088// DIDescriptor: dump routines for all descriptors. 1089//===----------------------------------------------------------------------===// 1090 1091/// dump - Print descriptor to dbgs() with a newline. 1092void DIDescriptor::dump() const { 1093 print(dbgs()); dbgs() << '\n'; 1094} 1095 1096/// print - Print descriptor. 1097void DIDescriptor::print(raw_ostream &OS) const { 1098 if (!DbgNode) return; 1099 1100 if (const char *Tag = dwarf::TagString(getTag())) 1101 OS << "[ " << Tag << " ]"; 1102 1103 if (this->isSubrange()) { 1104 DISubrange(DbgNode).printInternal(OS); 1105 } else if (this->isCompileUnit()) { 1106 DICompileUnit(DbgNode).printInternal(OS); 1107 } else if (this->isFile()) { 1108 DIFile(DbgNode).printInternal(OS); 1109 } else if (this->isEnumerator()) { 1110 DIEnumerator(DbgNode).printInternal(OS); 1111 } else if (this->isBasicType()) { 1112 DIType(DbgNode).printInternal(OS); 1113 } else if (this->isDerivedType()) { 1114 DIDerivedType(DbgNode).printInternal(OS); 1115 } else if (this->isCompositeType()) { 1116 DICompositeType(DbgNode).printInternal(OS); 1117 } else if (this->isSubprogram()) { 1118 DISubprogram(DbgNode).printInternal(OS); 1119 } else if (this->isGlobalVariable()) { 1120 DIGlobalVariable(DbgNode).printInternal(OS); 1121 } else if (this->isVariable()) { 1122 DIVariable(DbgNode).printInternal(OS); 1123 } else if (this->isObjCProperty()) { 1124 DIObjCProperty(DbgNode).printInternal(OS); 1125 } else if (this->isNameSpace()) { 1126 DINameSpace(DbgNode).printInternal(OS); 1127 } else if (this->isScope()) { 1128 DIScope(DbgNode).printInternal(OS); 1129 } 1130} 1131 1132void DISubrange::printInternal(raw_ostream &OS) const { 1133 int64_t Count = getCount(); 1134 if (Count != -1) 1135 OS << " [" << getLo() << ", " << Count - 1 << ']'; 1136 else 1137 OS << " [unbounded]"; 1138} 1139 1140void DIScope::printInternal(raw_ostream &OS) const { 1141 OS << " [" << getDirectory() << "/" << getFilename() << ']'; 1142} 1143 1144void DICompileUnit::printInternal(raw_ostream &OS) const { 1145 DIScope::printInternal(OS); 1146 OS << " ["; 1147 unsigned Lang = getLanguage(); 1148 if (const char *LangStr = dwarf::LanguageString(Lang)) 1149 OS << LangStr; 1150 else 1151 (OS << "lang 0x").write_hex(Lang); 1152 OS << ']'; 1153} 1154 1155void DIEnumerator::printInternal(raw_ostream &OS) const { 1156 OS << " [" << getName() << " :: " << getEnumValue() << ']'; 1157} 1158 1159void DIType::printInternal(raw_ostream &OS) const { 1160 if (!DbgNode) return; 1161 1162 StringRef Res = getName(); 1163 if (!Res.empty()) 1164 OS << " [" << Res << "]"; 1165 1166 // TODO: Print context? 1167 1168 OS << " [line " << getLineNumber() 1169 << ", size " << getSizeInBits() 1170 << ", align " << getAlignInBits() 1171 << ", offset " << getOffsetInBits(); 1172 if (isBasicType()) 1173 if (const char *Enc = 1174 dwarf::AttributeEncodingString(DIBasicType(DbgNode).getEncoding())) 1175 OS << ", enc " << Enc; 1176 OS << "]"; 1177 1178 if (isPrivate()) 1179 OS << " [private]"; 1180 else if (isProtected()) 1181 OS << " [protected]"; 1182 1183 if (isArtificial()) 1184 OS << " [artificial]"; 1185 1186 if (isForwardDecl()) 1187 OS << " [decl]"; 1188 else if (getTag() == dwarf::DW_TAG_structure_type || 1189 getTag() == dwarf::DW_TAG_union_type || 1190 getTag() == dwarf::DW_TAG_enumeration_type || 1191 getTag() == dwarf::DW_TAG_class_type) 1192 OS << " [def]"; 1193 if (isVector()) 1194 OS << " [vector]"; 1195 if (isStaticMember()) 1196 OS << " [static]"; 1197} 1198 1199void DIDerivedType::printInternal(raw_ostream &OS) const { 1200 DIType::printInternal(OS); 1201 OS << " [from " << getTypeDerivedFrom().getName() << ']'; 1202} 1203 1204void DICompositeType::printInternal(raw_ostream &OS) const { 1205 DIType::printInternal(OS); 1206 DIArray A = getTypeArray(); 1207 OS << " [" << A.getNumElements() << " elements]"; 1208} 1209 1210void DINameSpace::printInternal(raw_ostream &OS) const { 1211 StringRef Name = getName(); 1212 if (!Name.empty()) 1213 OS << " [" << Name << ']'; 1214 1215 OS << " [line " << getLineNumber() << ']'; 1216} 1217 1218void DISubprogram::printInternal(raw_ostream &OS) const { 1219 // TODO : Print context 1220 OS << " [line " << getLineNumber() << ']'; 1221 1222 if (isLocalToUnit()) 1223 OS << " [local]"; 1224 1225 if (isDefinition()) 1226 OS << " [def]"; 1227 1228 if (getScopeLineNumber() != getLineNumber()) 1229 OS << " [scope " << getScopeLineNumber() << "]"; 1230 1231 if (isPrivate()) 1232 OS << " [private]"; 1233 else if (isProtected()) 1234 OS << " [protected]"; 1235 1236 StringRef Res = getName(); 1237 if (!Res.empty()) 1238 OS << " [" << Res << ']'; 1239} 1240 1241void DIGlobalVariable::printInternal(raw_ostream &OS) const { 1242 StringRef Res = getName(); 1243 if (!Res.empty()) 1244 OS << " [" << Res << ']'; 1245 1246 OS << " [line " << getLineNumber() << ']'; 1247 1248 // TODO : Print context 1249 1250 if (isLocalToUnit()) 1251 OS << " [local]"; 1252 1253 if (isDefinition()) 1254 OS << " [def]"; 1255} 1256 1257void DIVariable::printInternal(raw_ostream &OS) const { 1258 StringRef Res = getName(); 1259 if (!Res.empty()) 1260 OS << " [" << Res << ']'; 1261 1262 OS << " [line " << getLineNumber() << ']'; 1263} 1264 1265void DIObjCProperty::printInternal(raw_ostream &OS) const { 1266 StringRef Name = getObjCPropertyName(); 1267 if (!Name.empty()) 1268 OS << " [" << Name << ']'; 1269 1270 OS << " [line " << getLineNumber() 1271 << ", properties " << getUnsignedField(6) << ']'; 1272} 1273 1274static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS, 1275 const LLVMContext &Ctx) { 1276 if (!DL.isUnknown()) { // Print source line info. 1277 DIScope Scope(DL.getScope(Ctx)); 1278 assert(Scope.isScope() && 1279 "Scope of a DebugLoc should be a DIScope."); 1280 // Omit the directory, because it's likely to be long and uninteresting. 1281 CommentOS << Scope.getFilename(); 1282 CommentOS << ':' << DL.getLine(); 1283 if (DL.getCol() != 0) 1284 CommentOS << ':' << DL.getCol(); 1285 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx)); 1286 if (!InlinedAtDL.isUnknown()) { 1287 CommentOS << " @[ "; 1288 printDebugLoc(InlinedAtDL, CommentOS, Ctx); 1289 CommentOS << " ]"; 1290 } 1291 } 1292} 1293 1294void DIVariable::printExtendedName(raw_ostream &OS) const { 1295 const LLVMContext &Ctx = DbgNode->getContext(); 1296 StringRef Res = getName(); 1297 if (!Res.empty()) 1298 OS << Res << "," << getLineNumber(); 1299 if (MDNode *InlinedAt = getInlinedAt()) { 1300 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt); 1301 if (!InlinedAtDL.isUnknown()) { 1302 OS << " @["; 1303 printDebugLoc(InlinedAtDL, OS, Ctx); 1304 OS << "]"; 1305 } 1306 } 1307} 1308