DebugInfo.cpp revision 00c5c5d46731834caa0ca3280e0dcc43202dd3c8 
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() == 12;
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 Retrieve the MDNode for the directory/file pair.
543MDNode *DIFile::getFileNode() const {
544  return const_cast<MDNode*>(getNodeField(DbgNode, 1));
545}
546
547/// \brief Verify that the file descriptor is well formed.
548bool DIFile::Verify() const {
549  return isFile() && DbgNode->getNumOperands() == 2;
550}
551
552/// \brief Verify that the enumerator descriptor is well formed.
553bool DIEnumerator::Verify() const {
554  return isEnumerator() && DbgNode->getNumOperands() == 3;
555}
556
557/// \brief Verify that the subrange descriptor is well formed.
558bool DISubrange::Verify() const {
559  return isSubrange() && DbgNode->getNumOperands() == 3;
560}
561
562/// \brief Verify that the lexical block descriptor is well formed.
563bool DILexicalBlock::Verify() const {
564  return isLexicalBlock() && DbgNode->getNumOperands() == 6;
565}
566
567/// \brief Verify that the file-scoped lexical block descriptor is well formed.
568bool DILexicalBlockFile::Verify() const {
569  return isLexicalBlockFile() && DbgNode->getNumOperands() == 3;
570}
571
572/// \brief Verify that the template type parameter descriptor is well formed.
573bool DITemplateTypeParameter::Verify() const {
574  return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7;
575}
576
577/// \brief Verify that the template value parameter descriptor is well formed.
578bool DITemplateValueParameter::Verify() const {
579  return isTemplateValueParameter() && DbgNode->getNumOperands() == 8;
580}
581
582/// getOriginalTypeSize - If this type is derived from a base type then
583/// return base type size.
584uint64_t DIDerivedType::getOriginalTypeSize() const {
585  unsigned Tag = getTag();
586
587  if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
588      Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
589      Tag != dwarf::DW_TAG_restrict_type)
590    return getSizeInBits();
591
592  DIType BaseType = getTypeDerivedFrom();
593
594  // If this type is not derived from any type then take conservative approach.
595  if (!BaseType.isValid())
596    return getSizeInBits();
597
598  // If this is a derived type, go ahead and get the base type, unless it's a
599  // reference then it's just the size of the field. Pointer types have no need
600  // of this since they're a different type of qualification on the type.
601  if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
602      BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
603    return getSizeInBits();
604
605  if (BaseType.isDerivedType())
606    return DIDerivedType(BaseType).getOriginalTypeSize();
607
608  return BaseType.getSizeInBits();
609}
610
611/// getObjCProperty - Return property node, if this ivar is associated with one.
612MDNode *DIDerivedType::getObjCProperty() const {
613  if (DbgNode->getNumOperands() <= 10)
614    return NULL;
615  return dyn_cast_or_null<MDNode>(DbgNode->getOperand(10));
616}
617
618/// isInlinedFnArgument - Return true if this variable provides debugging
619/// information for an inlined function arguments.
620bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
621  assert(CurFn && "Invalid function");
622  if (!getContext().isSubprogram())
623    return false;
624  // This variable is not inlined function argument if its scope
625  // does not describe current function.
626  return !DISubprogram(getContext()).describes(CurFn);
627}
628
629/// describes - Return true if this subprogram provides debugging
630/// information for the function F.
631bool DISubprogram::describes(const Function *F) {
632  assert(F && "Invalid function");
633  if (F == getFunction())
634    return true;
635  StringRef Name = getLinkageName();
636  if (Name.empty())
637    Name = getName();
638  if (F->getName() == Name)
639    return true;
640  return false;
641}
642
643unsigned DISubprogram::isOptimized() const {
644  assert (DbgNode && "Invalid subprogram descriptor!");
645  if (DbgNode->getNumOperands() == 16)
646    return getUnsignedField(15);
647  return 0;
648}
649
650MDNode *DISubprogram::getVariablesNodes() const {
651  if (!DbgNode || DbgNode->getNumOperands() <= 19)
652    return NULL;
653  return dyn_cast_or_null<MDNode>(DbgNode->getOperand(19));
654}
655
656DIArray DISubprogram::getVariables() const {
657  if (!DbgNode || DbgNode->getNumOperands() <= 19)
658    return DIArray();
659  if (MDNode *T = dyn_cast_or_null<MDNode>(DbgNode->getOperand(19)))
660    return DIArray(T);
661  return DIArray();
662}
663
664StringRef DIScope::getFilename() const {
665  if (!DbgNode)
666    return StringRef();
667  if (isLexicalBlockFile())
668    return DILexicalBlockFile(DbgNode).getFilename();
669  if (isLexicalBlock())
670    return DILexicalBlock(DbgNode).getFilename();
671  if (isSubprogram())
672    return DISubprogram(DbgNode).getFilename();
673  return ::getStringField(getNodeField(DbgNode, 1), 0);
674}
675
676StringRef DIScope::getDirectory() const {
677  if (!DbgNode)
678    return StringRef();
679  if (isLexicalBlockFile())
680    return DILexicalBlockFile(DbgNode).getDirectory();
681  if (isLexicalBlock())
682    return DILexicalBlock(DbgNode).getDirectory();
683  if (isSubprogram())
684    return DISubprogram(DbgNode).getDirectory();
685  return ::getStringField(getNodeField(DbgNode, 1), 1);
686}
687
688DIArray DICompileUnit::getEnumTypes() const {
689  if (!DbgNode || DbgNode->getNumOperands() < 12)
690    return DIArray();
691
692  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(7)))
693    return DIArray(N);
694  return DIArray();
695}
696
697DIArray DICompileUnit::getRetainedTypes() const {
698  if (!DbgNode || DbgNode->getNumOperands() < 12)
699    return DIArray();
700
701  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(8)))
702    return DIArray(N);
703  return DIArray();
704}
705
706DIArray DICompileUnit::getSubprograms() const {
707  if (!DbgNode || DbgNode->getNumOperands() < 12)
708    return DIArray();
709
710  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(9)))
711    return DIArray(N);
712  return DIArray();
713}
714
715
716DIArray DICompileUnit::getGlobalVariables() const {
717  if (!DbgNode || DbgNode->getNumOperands() < 12)
718    return DIArray();
719
720  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(10)))
721    return DIArray(N);
722  return DIArray();
723}
724
725/// fixupObjcLikeName - Replace contains special characters used
726/// in a typical Objective-C names with '.' in a given string.
727static void fixupObjcLikeName(StringRef Str, SmallVectorImpl<char> &Out) {
728  bool isObjCLike = false;
729  for (size_t i = 0, e = Str.size(); i < e; ++i) {
730    char C = Str[i];
731    if (C == '[')
732      isObjCLike = true;
733
734    if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' ||
735                       C == '+' || C == '(' || C == ')'))
736      Out.push_back('.');
737    else
738      Out.push_back(C);
739  }
740}
741
742/// getFnSpecificMDNode - Return a NameMDNode, if available, that is
743/// suitable to hold function specific information.
744NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) {
745  SmallString<32> Name = StringRef("llvm.dbg.lv.");
746  StringRef FName = "fn";
747  if (Fn.getFunction())
748    FName = Fn.getFunction()->getName();
749  else
750    FName = Fn.getName();
751  char One = '\1';
752  if (FName.startswith(StringRef(&One, 1)))
753    FName = FName.substr(1);
754  fixupObjcLikeName(FName, Name);
755  return M.getNamedMetadata(Name.str());
756}
757
758/// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable
759/// to hold function specific information.
760NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) {
761  SmallString<32> Name = StringRef("llvm.dbg.lv.");
762  StringRef FName = "fn";
763  if (Fn.getFunction())
764    FName = Fn.getFunction()->getName();
765  else
766    FName = Fn.getName();
767  char One = '\1';
768  if (FName.startswith(StringRef(&One, 1)))
769    FName = FName.substr(1);
770  fixupObjcLikeName(FName, Name);
771
772  return M.getOrInsertNamedMetadata(Name.str());
773}
774
775/// createInlinedVariable - Create a new inlined variable based on current
776/// variable.
777/// @param DV            Current Variable.
778/// @param InlinedScope  Location at current variable is inlined.
779DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
780                                       LLVMContext &VMContext) {
781  SmallVector<Value *, 16> Elts;
782  // Insert inlined scope as 7th element.
783  for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
784    i == 7 ? Elts.push_back(InlinedScope) :
785             Elts.push_back(DV->getOperand(i));
786  return DIVariable(MDNode::get(VMContext, Elts));
787}
788
789/// cleanseInlinedVariable - Remove inlined scope from the variable.
790DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) {
791  SmallVector<Value *, 16> Elts;
792  // Insert inlined scope as 7th element.
793  for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
794    i == 7 ?
795      Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext))):
796      Elts.push_back(DV->getOperand(i));
797  return DIVariable(MDNode::get(VMContext, Elts));
798}
799
800/// getDISubprogram - Find subprogram that is enclosing this scope.
801DISubprogram llvm::getDISubprogram(const MDNode *Scope) {
802  DIDescriptor D(Scope);
803  if (D.isSubprogram())
804    return DISubprogram(Scope);
805
806  if (D.isLexicalBlockFile())
807    return getDISubprogram(DILexicalBlockFile(Scope).getContext());
808
809  if (D.isLexicalBlock())
810    return getDISubprogram(DILexicalBlock(Scope).getContext());
811
812  return DISubprogram();
813}
814
815/// getDICompositeType - Find underlying composite type.
816DICompositeType llvm::getDICompositeType(DIType T) {
817  if (T.isCompositeType())
818    return DICompositeType(T);
819
820  if (T.isDerivedType())
821    return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom());
822
823  return DICompositeType();
824}
825
826/// isSubprogramContext - Return true if Context is either a subprogram
827/// or another context nested inside a subprogram.
828bool llvm::isSubprogramContext(const MDNode *Context) {
829  if (!Context)
830    return false;
831  DIDescriptor D(Context);
832  if (D.isSubprogram())
833    return true;
834  if (D.isType())
835    return isSubprogramContext(DIType(Context).getContext());
836  return false;
837}
838
839//===----------------------------------------------------------------------===//
840// DebugInfoFinder implementations.
841//===----------------------------------------------------------------------===//
842
843/// processModule - Process entire module and collect debug info.
844void DebugInfoFinder::processModule(const Module &M) {
845  if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) {
846    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
847      DICompileUnit CU(CU_Nodes->getOperand(i));
848      addCompileUnit(CU);
849      DIArray GVs = CU.getGlobalVariables();
850      for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) {
851        DIGlobalVariable DIG(GVs.getElement(i));
852        if (addGlobalVariable(DIG))
853          processType(DIG.getType());
854      }
855      DIArray SPs = CU.getSubprograms();
856      for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
857        processSubprogram(DISubprogram(SPs.getElement(i)));
858      DIArray EnumTypes = CU.getEnumTypes();
859      for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
860        processType(DIType(EnumTypes.getElement(i)));
861      DIArray RetainedTypes = CU.getRetainedTypes();
862      for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
863        processType(DIType(RetainedTypes.getElement(i)));
864      // FIXME: We really shouldn't be bailing out after visiting just one CU
865      return;
866    }
867  }
868}
869
870/// processLocation - Process DILocation.
871void DebugInfoFinder::processLocation(DILocation Loc) {
872  if (!Loc.Verify()) return;
873  DIDescriptor S(Loc.getScope());
874  if (S.isCompileUnit())
875    addCompileUnit(DICompileUnit(S));
876  else if (S.isSubprogram())
877    processSubprogram(DISubprogram(S));
878  else if (S.isLexicalBlock())
879    processLexicalBlock(DILexicalBlock(S));
880  else if (S.isLexicalBlockFile()) {
881    DILexicalBlockFile DBF = DILexicalBlockFile(S);
882    processLexicalBlock(DILexicalBlock(DBF.getScope()));
883  }
884  processLocation(Loc.getOrigLocation());
885}
886
887/// processType - Process DIType.
888void DebugInfoFinder::processType(DIType DT) {
889  if (!addType(DT))
890    return;
891  if (DT.isCompositeType()) {
892    DICompositeType DCT(DT);
893    processType(DCT.getTypeDerivedFrom());
894    DIArray DA = DCT.getTypeArray();
895    for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
896      DIDescriptor D = DA.getElement(i);
897      if (D.isType())
898        processType(DIType(D));
899      else if (D.isSubprogram())
900        processSubprogram(DISubprogram(D));
901    }
902  } else if (DT.isDerivedType()) {
903    DIDerivedType DDT(DT);
904    processType(DDT.getTypeDerivedFrom());
905  }
906}
907
908/// processLexicalBlock
909void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) {
910  DIScope Context = LB.getContext();
911  if (Context.isLexicalBlock())
912    return processLexicalBlock(DILexicalBlock(Context));
913  else if (Context.isLexicalBlockFile()) {
914    DILexicalBlockFile DBF = DILexicalBlockFile(Context);
915    return processLexicalBlock(DILexicalBlock(DBF.getScope()));
916  }
917  else
918    return processSubprogram(DISubprogram(Context));
919}
920
921/// processSubprogram - Process DISubprogram.
922void DebugInfoFinder::processSubprogram(DISubprogram SP) {
923  if (!addSubprogram(SP))
924    return;
925  processType(SP.getType());
926}
927
928/// processDeclare - Process DbgDeclareInst.
929void DebugInfoFinder::processDeclare(const DbgDeclareInst *DDI) {
930  MDNode *N = dyn_cast<MDNode>(DDI->getVariable());
931  if (!N) return;
932
933  DIDescriptor DV(N);
934  if (!DV.isVariable())
935    return;
936
937  if (!NodesSeen.insert(DV))
938    return;
939  processType(DIVariable(N).getType());
940}
941
942/// addType - Add type into Tys.
943bool DebugInfoFinder::addType(DIType DT) {
944  if (!DT.isValid())
945    return false;
946
947  if (!NodesSeen.insert(DT))
948    return false;
949
950  TYs.push_back(DT);
951  return true;
952}
953
954/// addCompileUnit - Add compile unit into CUs.
955bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) {
956  if (!CU.Verify())
957    return false;
958
959  if (!NodesSeen.insert(CU))
960    return false;
961
962  CUs.push_back(CU);
963  return true;
964}
965
966/// addGlobalVariable - Add global variable into GVs.
967bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) {
968  if (!DIDescriptor(DIG).isGlobalVariable())
969    return false;
970
971  if (!NodesSeen.insert(DIG))
972    return false;
973
974  GVs.push_back(DIG);
975  return true;
976}
977
978// addSubprogram - Add subprgoram into SPs.
979bool DebugInfoFinder::addSubprogram(DISubprogram SP) {
980  if (!DIDescriptor(SP).isSubprogram())
981    return false;
982
983  if (!NodesSeen.insert(SP))
984    return false;
985
986  SPs.push_back(SP);
987  return true;
988}
989
990//===----------------------------------------------------------------------===//
991// DIDescriptor: dump routines for all descriptors.
992//===----------------------------------------------------------------------===//
993
994/// dump - Print descriptor to dbgs() with a newline.
995void DIDescriptor::dump() const {
996  print(dbgs()); dbgs() << '\n';
997}
998
999/// print - Print descriptor.
1000void DIDescriptor::print(raw_ostream &OS) const {
1001  if (!DbgNode) return;
1002
1003  if (const char *Tag = dwarf::TagString(getTag()))
1004    OS << "[ " << Tag << " ]";
1005
1006  if (this->isSubrange()) {
1007    DISubrange(DbgNode).printInternal(OS);
1008  } else if (this->isCompileUnit()) {
1009    DICompileUnit(DbgNode).printInternal(OS);
1010  } else if (this->isFile()) {
1011    DIFile(DbgNode).printInternal(OS);
1012  } else if (this->isEnumerator()) {
1013    DIEnumerator(DbgNode).printInternal(OS);
1014  } else if (this->isBasicType()) {
1015    DIType(DbgNode).printInternal(OS);
1016  } else if (this->isDerivedType()) {
1017    DIDerivedType(DbgNode).printInternal(OS);
1018  } else if (this->isCompositeType()) {
1019    DICompositeType(DbgNode).printInternal(OS);
1020  } else if (this->isSubprogram()) {
1021    DISubprogram(DbgNode).printInternal(OS);
1022  } else if (this->isGlobalVariable()) {
1023    DIGlobalVariable(DbgNode).printInternal(OS);
1024  } else if (this->isVariable()) {
1025    DIVariable(DbgNode).printInternal(OS);
1026  } else if (this->isObjCProperty()) {
1027    DIObjCProperty(DbgNode).printInternal(OS);
1028  } else if (this->isNameSpace()) {
1029    DINameSpace(DbgNode).printInternal(OS);
1030  } else if (this->isScope()) {
1031    DIScope(DbgNode).printInternal(OS);
1032  }
1033}
1034
1035void DISubrange::printInternal(raw_ostream &OS) const {
1036  int64_t Count = getCount();
1037  if (Count != -1)
1038    OS << " [" << getLo() << ", " << Count - 1 << ']';
1039  else
1040    OS << " [unbounded]";
1041}
1042
1043void DIScope::printInternal(raw_ostream &OS) const {
1044  OS << " [" << getDirectory() << "/" << getFilename() << ']';
1045}
1046
1047void DICompileUnit::printInternal(raw_ostream &OS) const {
1048  DIScope::printInternal(OS);
1049  if (const char *Lang = dwarf::LanguageString(getLanguage()))
1050    OS << " [" << Lang << ']';
1051}
1052
1053void DIEnumerator::printInternal(raw_ostream &OS) const {
1054  OS << " [" << getName() << " :: " << getEnumValue() << ']';
1055}
1056
1057void DIType::printInternal(raw_ostream &OS) const {
1058  if (!DbgNode) return;
1059
1060  StringRef Res = getName();
1061  if (!Res.empty())
1062    OS << " [" << Res << "]";
1063
1064  // TODO: Print context?
1065
1066  OS << " [line " << getLineNumber()
1067     << ", size " << getSizeInBits()
1068     << ", align " << getAlignInBits()
1069     << ", offset " << getOffsetInBits();
1070  if (isBasicType())
1071    if (const char *Enc =
1072        dwarf::AttributeEncodingString(DIBasicType(DbgNode).getEncoding()))
1073      OS << ", enc " << Enc;
1074  OS << "]";
1075
1076  if (isPrivate())
1077    OS << " [private]";
1078  else if (isProtected())
1079    OS << " [protected]";
1080
1081  if (isArtificial())
1082    OS << " [artificial]";
1083
1084  if (isForwardDecl())
1085    OS << " [fwd]";
1086  if (isVector())
1087    OS << " [vector]";
1088  if (isStaticMember())
1089    OS << " [static]";
1090}
1091
1092void DIDerivedType::printInternal(raw_ostream &OS) const {
1093  DIType::printInternal(OS);
1094  OS << " [from " << getTypeDerivedFrom().getName() << ']';
1095}
1096
1097void DICompositeType::printInternal(raw_ostream &OS) const {
1098  DIType::printInternal(OS);
1099  DIArray A = getTypeArray();
1100  OS << " [" << A.getNumElements() << " elements]";
1101}
1102
1103void DINameSpace::printInternal(raw_ostream &OS) const {
1104  StringRef Name = getName();
1105  if (!Name.empty())
1106    OS << " [" << Name << ']';
1107
1108  OS << " [line " << getLineNumber() << ']';
1109}
1110
1111void DISubprogram::printInternal(raw_ostream &OS) const {
1112  // TODO : Print context
1113  OS << " [line " << getLineNumber() << ']';
1114
1115  if (isLocalToUnit())
1116    OS << " [local]";
1117
1118  if (isDefinition())
1119    OS << " [def]";
1120
1121  if (getScopeLineNumber() != getLineNumber())
1122    OS << " [scope " << getScopeLineNumber() << "]";
1123
1124  if (isPrivate())
1125    OS << " [private]";
1126  else if (isProtected())
1127    OS << " [protected]";
1128
1129  StringRef Res = getName();
1130  if (!Res.empty())
1131    OS << " [" << Res << ']';
1132}
1133
1134void DIGlobalVariable::printInternal(raw_ostream &OS) const {
1135  StringRef Res = getName();
1136  if (!Res.empty())
1137    OS << " [" << Res << ']';
1138
1139  OS << " [line " << getLineNumber() << ']';
1140
1141  // TODO : Print context
1142
1143  if (isLocalToUnit())
1144    OS << " [local]";
1145
1146  if (isDefinition())
1147    OS << " [def]";
1148}
1149
1150void DIVariable::printInternal(raw_ostream &OS) const {
1151  StringRef Res = getName();
1152  if (!Res.empty())
1153    OS << " [" << Res << ']';
1154
1155  OS << " [line " << getLineNumber() << ']';
1156}
1157
1158void DIObjCProperty::printInternal(raw_ostream &OS) const {
1159  StringRef Name = getObjCPropertyName();
1160  if (!Name.empty())
1161    OS << " [" << Name << ']';
1162
1163  OS << " [line " << getLineNumber()
1164     << ", properties " << getUnsignedField(6) << ']';
1165}
1166
1167static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS,
1168                          const LLVMContext &Ctx) {
1169  if (!DL.isUnknown()) {          // Print source line info.
1170    DIScope Scope(DL.getScope(Ctx));
1171    // Omit the directory, because it's likely to be long and uninteresting.
1172    if (Scope.Verify())
1173      CommentOS << Scope.getFilename();
1174    else
1175      CommentOS << "<unknown>";
1176    CommentOS << ':' << DL.getLine();
1177    if (DL.getCol() != 0)
1178      CommentOS << ':' << DL.getCol();
1179    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx));
1180    if (!InlinedAtDL.isUnknown()) {
1181      CommentOS << " @[ ";
1182      printDebugLoc(InlinedAtDL, CommentOS, Ctx);
1183      CommentOS << " ]";
1184    }
1185  }
1186}
1187
1188void DIVariable::printExtendedName(raw_ostream &OS) const {
1189  const LLVMContext &Ctx = DbgNode->getContext();
1190  StringRef Res = getName();
1191  if (!Res.empty())
1192    OS << Res << "," << getLineNumber();
1193  if (MDNode *InlinedAt = getInlinedAt()) {
1194    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt);
1195    if (!InlinedAtDL.isUnknown()) {
1196      OS << " @[";
1197      printDebugLoc(InlinedAtDL, OS, Ctx);
1198      OS << "]";
1199    }
1200  }
1201}
1202