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