lib/IR/DebugInfo.cpp

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