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