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