DebugInfo.cpp revision b4cf0ab22b5a3ebb720f0b7287fdccfb465b6b7c 
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
54bool 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
69static Value *getField(const MDNode *DbgNode, unsigned Elt) {
70  if (DbgNode == 0 || Elt >= DbgNode->getNumOperands())
71    return 0;
72  return DbgNode->getOperand(Elt);
73}
74
75static 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
81static 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
87StringRef DIDescriptor::getStringField(unsigned Elt) const {
88  return ::getStringField(DbgNode, Elt);
89}
90
91uint64_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
103int64_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
115DIDescriptor 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
125GlobalVariable *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
134Constant *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
143Function *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
152void 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
162unsigned DIVariable::getNumAddrElements() const {
163  return DbgNode->getNumOperands()-8;
164}
165
166/// getInlinedAt - If this variable is inlined then return inline location.
167MDNode *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.
177bool 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.
189bool 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.
212bool 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.
228bool 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.
240bool DIDescriptor::isType() const {
241  return isBasicType() || isCompositeType() || isDerivedType();
242}
243
244/// isSubprogram - Return true if the specified tag is legal for
245/// DISubprogram.
246bool 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.
252bool 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.
258bool DIDescriptor::isGlobal() const {
259  return isGlobalVariable();
260}
261
262/// isUnspecifiedParmeter - Return true if the specified tag is
263/// DW_TAG_unspecified_parameters.
264bool 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.
270bool 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.
286bool 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.
292bool 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.
297bool 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.
302bool 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.
307bool 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.
313bool 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.
319bool 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.
325bool 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.
330bool DIDescriptor::isEnumerator() const {
331  return DbgNode && getTag() == dwarf::DW_TAG_enumerator;
332}
333
334/// isObjCProperty - Return true if the specified tag is DW_TAG
335bool DIDescriptor::isObjCProperty() const {
336  return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property;
337}
338//===----------------------------------------------------------------------===//
339// Simple Descriptor Constructors and other Methods
340//===----------------------------------------------------------------------===//
341
342DIType::DIType(const MDNode *N) : DIScope(N) {
343  if (!N) return;
344  if (!isBasicType() && !isDerivedType() && !isCompositeType()) {
345    DbgNode = 0;
346  }
347}
348
349unsigned 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.
357void 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.
377void 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.
396bool 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.
413bool 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.
424bool 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.
436bool 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.
457bool DIBasicType::Verify() const {
458  return isBasicType() && DbgNode->getNumOperands() == 10;
459}
460
461/// Verify - Verify that a derived type descriptor is well formed.
462bool 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.
468bool 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.
478bool 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.
492bool 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.
513bool 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.
528bool 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.
536bool 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.
543bool DIFile::Verify() const {
544  return isFile() && DbgNode->getNumOperands() == 2;
545}
546
547/// \brief Verify that the enumerator descriptor is well formed.
548bool DIEnumerator::Verify() const {
549  return isEnumerator() && DbgNode->getNumOperands() == 3;
550}
551
552/// \brief Verify that the subrange descriptor is well formed.
553bool DISubrange::Verify() const {
554  return isSubrange() && DbgNode->getNumOperands() == 3;
555}
556
557/// \brief Verify that the lexical block descriptor is well formed.
558bool DILexicalBlock::Verify() const {
559  return isLexicalBlock() && DbgNode->getNumOperands() == 6;
560}
561
562/// \brief Verify that the file-scoped lexical block descriptor is well formed.
563bool DILexicalBlockFile::Verify() const {
564  return isLexicalBlockFile() && DbgNode->getNumOperands() == 3;
565}
566
567/// \brief Verify that the template type parameter descriptor is well formed.
568bool DITemplateTypeParameter::Verify() const {
569  return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7;
570}
571
572/// \brief Verify that the template value parameter descriptor is well formed.
573bool 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.
579uint64_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.
607MDNode *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.
615bool 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.
626bool 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
638unsigned DISubprogram::isOptimized() const {
639  assert (DbgNode && "Invalid subprogram descriptor!");
640  if (DbgNode->getNumOperands() == 16)
641    return getUnsignedField(15);
642  return 0;
643}
644
645MDNode *DISubprogram::getVariablesNodes() const {
646  if (!DbgNode || DbgNode->getNumOperands() <= 19)
647    return NULL;
648  return dyn_cast_or_null<MDNode>(DbgNode->getOperand(19));
649}
650
651DIArray 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
659StringRef 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
677StringRef 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
695DIArray 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
704DIArray 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
713DIArray 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
723DIArray 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.
734static 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.
751NamedMDNode *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.
767NamedMDNode *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.
786DIVariable 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.
797DIVariable 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.
808DISubprogram 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.
823DICompositeType 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.
835bool 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.
851void 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.
878void 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.
895void 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
916void 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.
929void DebugInfoFinder::processSubprogram(DISubprogram SP) {
930  if (!addSubprogram(SP))
931    return;
932  processType(SP.getType());
933}
934
935/// processDeclare - Process DbgDeclareInst.
936void 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.
950bool 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.
962bool 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.
974bool 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.
986bool 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.
1002void DIDescriptor::dump() const {
1003  print(dbgs()); dbgs() << '\n';
1004}
1005
1006/// print - Print descriptor.
1007void 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
1040void 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
1048void DIScope::printInternal(raw_ostream &OS) const {
1049  OS << " [" << getDirectory() << "/" << getFilename() << ']';
1050}
1051
1052void DICompileUnit::printInternal(raw_ostream &OS) const {
1053  DIScope::printInternal(OS);
1054  if (const char *Lang = dwarf::LanguageString(getLanguage()))
1055    OS << " [" << Lang << ']';
1056}
1057
1058void DIEnumerator::printInternal(raw_ostream &OS) const {
1059  OS << " [" << getName() << " :: " << getEnumValue() << ']';
1060}
1061
1062void 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
1097void DIDerivedType::printInternal(raw_ostream &OS) const {
1098  DIType::printInternal(OS);
1099  OS << " [from " << getTypeDerivedFrom().getName() << ']';
1100}
1101
1102void DICompositeType::printInternal(raw_ostream &OS) const {
1103  DIType::printInternal(OS);
1104  DIArray A = getTypeArray();
1105  OS << " [" << A.getNumElements() << " elements]";
1106}
1107
1108void 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
1131void 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
1147void DIVariable::printInternal(raw_ostream &OS) const {
1148  StringRef Res = getName();
1149  if (!Res.empty())
1150    OS << " [" << Res << ']';
1151
1152  OS << " [line " << getLineNumber() << ']';
1153}
1154
1155void 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
1164static 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
1185void 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