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