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