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