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