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