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