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