DebugInfo.cpp revision 51fce2c886e4ca33272975cc80bc1cc5abfcdffd 
1//===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the helper classes used to build and interpret debug
11// information in LLVM IR form.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/DebugInfo.h"
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/ADT/SmallPtrSet.h"
18#include "llvm/ADT/SmallString.h"
19#include "llvm/Analysis/ValueTracking.h"
20#include "llvm/IR/Constants.h"
21#include "llvm/IR/DerivedTypes.h"
22#include "llvm/IR/Instructions.h"
23#include "llvm/IR/IntrinsicInst.h"
24#include "llvm/IR/Intrinsics.h"
25#include "llvm/IR/Module.h"
26#include "llvm/Support/Debug.h"
27#include "llvm/Support/Dwarf.h"
28#include "llvm/Support/ValueHandle.h"
29#include "llvm/Support/raw_ostream.h"
30using namespace llvm;
31using namespace llvm::dwarf;
32
33//===----------------------------------------------------------------------===//
34// DIDescriptor
35//===----------------------------------------------------------------------===//
36
37bool DIDescriptor::Verify() const {
38  return DbgNode &&
39         (DIDerivedType(DbgNode).Verify() ||
40          DICompositeType(DbgNode).Verify() || DIBasicType(DbgNode).Verify() ||
41          DIVariable(DbgNode).Verify() || DISubprogram(DbgNode).Verify() ||
42          DIGlobalVariable(DbgNode).Verify() || DIFile(DbgNode).Verify() ||
43          DICompileUnit(DbgNode).Verify() || DINameSpace(DbgNode).Verify() ||
44          DILexicalBlock(DbgNode).Verify() ||
45          DILexicalBlockFile(DbgNode).Verify() ||
46          DISubrange(DbgNode).Verify() || DIEnumerator(DbgNode).Verify() ||
47          DIObjCProperty(DbgNode).Verify() ||
48          DITemplateTypeParameter(DbgNode).Verify() ||
49          DITemplateValueParameter(DbgNode).Verify() ||
50          DIImportedEntity(DbgNode).Verify());
51}
52
53static Value *getField(const MDNode *DbgNode, unsigned Elt) {
54  if (DbgNode == 0 || Elt >= DbgNode->getNumOperands())
55    return 0;
56  return DbgNode->getOperand(Elt);
57}
58
59static MDNode *getNodeField(const MDNode *DbgNode, unsigned Elt) {
60  return dyn_cast_or_null<MDNode>(getField(DbgNode, Elt));
61}
62
63static StringRef getStringField(const MDNode *DbgNode, unsigned Elt) {
64  if (MDString *MDS = dyn_cast_or_null<MDString>(getField(DbgNode, Elt)))
65    return MDS->getString();
66  return StringRef();
67}
68
69StringRef DIDescriptor::getStringField(unsigned Elt) const {
70  return ::getStringField(DbgNode, Elt);
71}
72
73uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
74  if (DbgNode == 0)
75    return 0;
76
77  if (Elt < DbgNode->getNumOperands())
78    if (ConstantInt *CI =
79            dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(Elt)))
80      return CI->getZExtValue();
81
82  return 0;
83}
84
85int64_t DIDescriptor::getInt64Field(unsigned Elt) const {
86  if (DbgNode == 0)
87    return 0;
88
89  if (Elt < DbgNode->getNumOperands())
90    if (ConstantInt *CI =
91            dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(Elt)))
92      return CI->getSExtValue();
93
94  return 0;
95}
96
97DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const {
98  MDNode *Field = getNodeField(DbgNode, Elt);
99  return DIDescriptor(Field);
100}
101
102GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const {
103  if (DbgNode == 0)
104    return 0;
105
106  if (Elt < DbgNode->getNumOperands())
107    return dyn_cast_or_null<GlobalVariable>(DbgNode->getOperand(Elt));
108  return 0;
109}
110
111Constant *DIDescriptor::getConstantField(unsigned Elt) const {
112  if (DbgNode == 0)
113    return 0;
114
115  if (Elt < DbgNode->getNumOperands())
116    return dyn_cast_or_null<Constant>(DbgNode->getOperand(Elt));
117  return 0;
118}
119
120Function *DIDescriptor::getFunctionField(unsigned Elt) const {
121  if (DbgNode == 0)
122    return 0;
123
124  if (Elt < DbgNode->getNumOperands())
125    return dyn_cast_or_null<Function>(DbgNode->getOperand(Elt));
126  return 0;
127}
128
129void DIDescriptor::replaceFunctionField(unsigned Elt, Function *F) {
130  if (DbgNode == 0)
131    return;
132
133  if (Elt < DbgNode->getNumOperands()) {
134    MDNode *Node = const_cast<MDNode *>(DbgNode);
135    Node->replaceOperandWith(Elt, F);
136  }
137}
138
139unsigned DIVariable::getNumAddrElements() const {
140  return DbgNode->getNumOperands() - 8;
141}
142
143/// getInlinedAt - If this variable is inlined then return inline location.
144MDNode *DIVariable::getInlinedAt() const { return getNodeField(DbgNode, 7); }
145
146//===----------------------------------------------------------------------===//
147// Predicates
148//===----------------------------------------------------------------------===//
149
150/// isBasicType - Return true if the specified tag is legal for
151/// DIBasicType.
152bool DIDescriptor::isBasicType() const {
153  if (!DbgNode)
154    return false;
155  switch (getTag()) {
156  case dwarf::DW_TAG_base_type:
157  case dwarf::DW_TAG_unspecified_type:
158    return true;
159  default:
160    return false;
161  }
162}
163
164/// isDerivedType - Return true if the specified tag is legal for DIDerivedType.
165bool DIDescriptor::isDerivedType() const {
166  if (!DbgNode)
167    return false;
168  switch (getTag()) {
169  case dwarf::DW_TAG_typedef:
170  case dwarf::DW_TAG_pointer_type:
171  case dwarf::DW_TAG_ptr_to_member_type:
172  case dwarf::DW_TAG_reference_type:
173  case dwarf::DW_TAG_rvalue_reference_type:
174  case dwarf::DW_TAG_const_type:
175  case dwarf::DW_TAG_volatile_type:
176  case dwarf::DW_TAG_restrict_type:
177  case dwarf::DW_TAG_member:
178  case dwarf::DW_TAG_inheritance:
179  case dwarf::DW_TAG_friend:
180    return true;
181  default:
182    // CompositeTypes are currently modelled as DerivedTypes.
183    return isCompositeType();
184  }
185}
186
187/// isCompositeType - Return true if the specified tag is legal for
188/// DICompositeType.
189bool DIDescriptor::isCompositeType() const {
190  if (!DbgNode)
191    return false;
192  switch (getTag()) {
193  case dwarf::DW_TAG_array_type:
194  case dwarf::DW_TAG_structure_type:
195  case dwarf::DW_TAG_union_type:
196  case dwarf::DW_TAG_enumeration_type:
197  case dwarf::DW_TAG_subroutine_type:
198  case dwarf::DW_TAG_class_type:
199    return true;
200  default:
201    return false;
202  }
203}
204
205/// isVariable - Return true if the specified tag is legal for DIVariable.
206bool DIDescriptor::isVariable() const {
207  if (!DbgNode)
208    return false;
209  switch (getTag()) {
210  case dwarf::DW_TAG_auto_variable:
211  case dwarf::DW_TAG_arg_variable:
212    return true;
213  default:
214    return false;
215  }
216}
217
218/// isType - Return true if the specified tag is legal for DIType.
219bool DIDescriptor::isType() const {
220  return isBasicType() || isCompositeType() || isDerivedType();
221}
222
223/// isSubprogram - Return true if the specified tag is legal for
224/// DISubprogram.
225bool DIDescriptor::isSubprogram() const {
226  return DbgNode && getTag() == dwarf::DW_TAG_subprogram;
227}
228
229/// isGlobalVariable - Return true if the specified tag is legal for
230/// DIGlobalVariable.
231bool DIDescriptor::isGlobalVariable() const {
232  return DbgNode && (getTag() == dwarf::DW_TAG_variable ||
233                     getTag() == dwarf::DW_TAG_constant);
234}
235
236/// isUnspecifiedParmeter - Return true if the specified tag is
237/// DW_TAG_unspecified_parameters.
238bool DIDescriptor::isUnspecifiedParameter() const {
239  return DbgNode && getTag() == dwarf::DW_TAG_unspecified_parameters;
240}
241
242/// isScope - Return true if the specified tag is one of the scope
243/// related tag.
244bool DIDescriptor::isScope() const {
245  if (!DbgNode)
246    return false;
247  switch (getTag()) {
248  case dwarf::DW_TAG_compile_unit:
249  case dwarf::DW_TAG_lexical_block:
250  case dwarf::DW_TAG_subprogram:
251  case dwarf::DW_TAG_namespace:
252  case dwarf::DW_TAG_file_type:
253    return true;
254  default:
255    break;
256  }
257  return isType();
258}
259
260/// isTemplateTypeParameter - Return true if the specified tag is
261/// DW_TAG_template_type_parameter.
262bool DIDescriptor::isTemplateTypeParameter() const {
263  return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter;
264}
265
266/// isTemplateValueParameter - Return true if the specified tag is
267/// DW_TAG_template_value_parameter.
268bool DIDescriptor::isTemplateValueParameter() const {
269  return DbgNode && (getTag() == dwarf::DW_TAG_template_value_parameter ||
270                     getTag() == dwarf::DW_TAG_GNU_template_template_param ||
271                     getTag() == dwarf::DW_TAG_GNU_template_parameter_pack);
272}
273
274/// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit.
275bool DIDescriptor::isCompileUnit() const {
276  return DbgNode && getTag() == dwarf::DW_TAG_compile_unit;
277}
278
279/// isFile - Return true if the specified tag is DW_TAG_file_type.
280bool DIDescriptor::isFile() const {
281  return DbgNode && getTag() == dwarf::DW_TAG_file_type;
282}
283
284/// isNameSpace - Return true if the specified tag is DW_TAG_namespace.
285bool DIDescriptor::isNameSpace() const {
286  return DbgNode && getTag() == dwarf::DW_TAG_namespace;
287}
288
289/// isLexicalBlockFile - Return true if the specified descriptor is a
290/// lexical block with an extra file.
291bool DIDescriptor::isLexicalBlockFile() const {
292  return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
293         (DbgNode->getNumOperands() == 3);
294}
295
296/// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block.
297bool DIDescriptor::isLexicalBlock() const {
298  return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
299         (DbgNode->getNumOperands() > 3);
300}
301
302/// isSubrange - Return true if the specified tag is DW_TAG_subrange_type.
303bool DIDescriptor::isSubrange() const {
304  return DbgNode && getTag() == dwarf::DW_TAG_subrange_type;
305}
306
307/// isEnumerator - Return true if the specified tag is DW_TAG_enumerator.
308bool DIDescriptor::isEnumerator() const {
309  return DbgNode && getTag() == dwarf::DW_TAG_enumerator;
310}
311
312/// isObjCProperty - Return true if the specified tag is DW_TAG_APPLE_property.
313bool DIDescriptor::isObjCProperty() const {
314  return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property;
315}
316
317/// \brief Return true if the specified tag is DW_TAG_imported_module or
318/// DW_TAG_imported_declaration.
319bool DIDescriptor::isImportedEntity() const {
320  return DbgNode && (getTag() == dwarf::DW_TAG_imported_module ||
321                     getTag() == dwarf::DW_TAG_imported_declaration);
322}
323
324//===----------------------------------------------------------------------===//
325// Simple Descriptor Constructors and other Methods
326//===----------------------------------------------------------------------===//
327
328unsigned DIArray::getNumElements() const {
329  if (!DbgNode)
330    return 0;
331  return DbgNode->getNumOperands();
332}
333
334/// replaceAllUsesWith - Replace all uses of the MDNode used by this
335/// type with the one in the passed descriptor.
336void DIType::replaceAllUsesWith(DIDescriptor &D) {
337
338  assert(DbgNode && "Trying to replace an unverified type!");
339
340  // Since we use a TrackingVH for the node, its easy for clients to manufacture
341  // legitimate situations where they want to replaceAllUsesWith() on something
342  // which, due to uniquing, has merged with the source. We shield clients from
343  // this detail by allowing a value to be replaced with replaceAllUsesWith()
344  // itself.
345  if (DbgNode != D) {
346    MDNode *Node = const_cast<MDNode *>(DbgNode);
347    const MDNode *DN = D;
348    const Value *V = cast_or_null<Value>(DN);
349    Node->replaceAllUsesWith(const_cast<Value *>(V));
350    MDNode::deleteTemporary(Node);
351  }
352}
353
354/// replaceAllUsesWith - Replace all uses of the MDNode used by this
355/// type with the one in D.
356void DIType::replaceAllUsesWith(MDNode *D) {
357
358  assert(DbgNode && "Trying to replace an unverified type!");
359
360  // Since we use a TrackingVH for the node, its easy for clients to manufacture
361  // legitimate situations where they want to replaceAllUsesWith() on something
362  // which, due to uniquing, has merged with the source. We shield clients from
363  // this detail by allowing a value to be replaced with replaceAllUsesWith()
364  // itself.
365  if (DbgNode != D) {
366    MDNode *Node = const_cast<MDNode *>(DbgNode);
367    const MDNode *DN = D;
368    const Value *V = cast_or_null<Value>(DN);
369    Node->replaceAllUsesWith(const_cast<Value *>(V));
370    MDNode::deleteTemporary(Node);
371  }
372}
373
374/// Verify - Verify that a compile unit is well formed.
375bool DICompileUnit::Verify() const {
376  if (!isCompileUnit())
377    return false;
378
379  // Don't bother verifying the compilation directory or producer string
380  // as those could be empty.
381  if (getFilename().empty())
382    return false;
383
384  return DbgNode->getNumOperands() == 13;
385}
386
387/// Verify - Verify that an ObjC property is well formed.
388bool DIObjCProperty::Verify() const {
389  if (!isObjCProperty())
390    return false;
391
392  // Don't worry about the rest of the strings for now.
393  return DbgNode->getNumOperands() == 8;
394}
395
396/// Check if a field at position Elt of a MDNode is a MDNode.
397/// We currently allow an empty string and an integer.
398/// But we don't allow a non-empty string in a MDNode field.
399static bool fieldIsMDNode(const MDNode *DbgNode, unsigned Elt) {
400  // FIXME: This function should return true, if the field is null or the field
401  // is indeed a MDNode: return !Fld || isa<MDNode>(Fld).
402  Value *Fld = getField(DbgNode, Elt);
403  if (Fld && isa<MDString>(Fld) && !cast<MDString>(Fld)->getString().empty())
404    return false;
405  return true;
406}
407
408/// Check if a field at position Elt of a MDNode is a MDString.
409static bool fieldIsMDString(const MDNode *DbgNode, unsigned Elt) {
410  Value *Fld = getField(DbgNode, Elt);
411  return !Fld || isa<MDString>(Fld);
412}
413
414/// Check if a value can be a reference to a type.
415static bool isTypeRef(const Value *Val) {
416  return !Val ||
417         (isa<MDString>(Val) && !cast<MDString>(Val)->getString().empty()) ||
418         (isa<MDNode>(Val) && DIType(cast<MDNode>(Val)).isType());
419}
420
421/// Check if a field at position Elt of a MDNode can be a reference to a type.
422static bool fieldIsTypeRef(const MDNode *DbgNode, unsigned Elt) {
423  Value *Fld = getField(DbgNode, Elt);
424  return isTypeRef(Fld);
425}
426
427/// Check if a value can be a ScopeRef.
428static bool isScopeRef(const Value *Val) {
429  return !Val ||
430         (isa<MDString>(Val) && !cast<MDString>(Val)->getString().empty()) ||
431         (isa<MDNode>(Val) && DIScope(cast<MDNode>(Val)).isScope());
432}
433
434/// Check if a field at position Elt of a MDNode can be a ScopeRef.
435static bool fieldIsScopeRef(const MDNode *DbgNode, unsigned Elt) {
436  Value *Fld = getField(DbgNode, Elt);
437  return isScopeRef(Fld);
438}
439
440/// Verify - Verify that a type descriptor is well formed.
441bool DIType::Verify() const {
442  if (!isType())
443    return false;
444  // Make sure Context @ field 2 is MDNode.
445  if (!fieldIsScopeRef(DbgNode, 2))
446    return false;
447
448  // FIXME: Sink this into the various subclass verifies.
449  uint16_t Tag = getTag();
450  if (!isBasicType() && Tag != dwarf::DW_TAG_const_type &&
451      Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type &&
452      Tag != dwarf::DW_TAG_ptr_to_member_type &&
453      Tag != dwarf::DW_TAG_reference_type &&
454      Tag != dwarf::DW_TAG_rvalue_reference_type &&
455      Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_array_type &&
456      Tag != dwarf::DW_TAG_enumeration_type &&
457      Tag != dwarf::DW_TAG_subroutine_type &&
458      Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend &&
459      getFilename().empty())
460    return false;
461  // DIType is abstract, it should be a BasicType, a DerivedType or
462  // a CompositeType.
463  if (isBasicType())
464    DIBasicType(DbgNode).Verify();
465  else if (isCompositeType())
466    DICompositeType(DbgNode).Verify();
467  else if (isDerivedType())
468    DIDerivedType(DbgNode).Verify();
469  else
470    return false;
471  return true;
472}
473
474/// Verify - Verify that a basic type descriptor is well formed.
475bool DIBasicType::Verify() const {
476  return isBasicType() && DbgNode->getNumOperands() == 10;
477}
478
479/// Verify - Verify that a derived type descriptor is well formed.
480bool DIDerivedType::Verify() const {
481  // Make sure DerivedFrom @ field 9 is TypeRef.
482  if (!fieldIsTypeRef(DbgNode, 9))
483    return false;
484  if (getTag() == dwarf::DW_TAG_ptr_to_member_type)
485    // Make sure ClassType @ field 10 is a TypeRef.
486    if (!fieldIsTypeRef(DbgNode, 10))
487      return false;
488
489  return isDerivedType() && DbgNode->getNumOperands() >= 10 &&
490         DbgNode->getNumOperands() <= 14;
491}
492
493/// Verify - Verify that a composite type descriptor is well formed.
494bool DICompositeType::Verify() const {
495  if (!isCompositeType())
496    return false;
497
498  // Make sure DerivedFrom @ field 9 and ContainingType @ field 12 are TypeRef.
499  if (!fieldIsTypeRef(DbgNode, 9))
500    return false;
501  if (!fieldIsTypeRef(DbgNode, 12))
502    return false;
503
504  // Make sure the type identifier at field 14 is MDString, it can be null.
505  if (!fieldIsMDString(DbgNode, 14))
506    return false;
507
508  return DbgNode->getNumOperands() == 15;
509}
510
511/// Verify - Verify that a subprogram descriptor is well formed.
512bool DISubprogram::Verify() const {
513  if (!isSubprogram())
514    return false;
515
516  // Make sure context @ field 2 is a ScopeRef and type @ field 7 is a MDNode.
517  if (!fieldIsScopeRef(DbgNode, 2))
518    return false;
519  if (!fieldIsMDNode(DbgNode, 7))
520    return false;
521  // Containing type @ field 12.
522  if (!fieldIsTypeRef(DbgNode, 12))
523    return false;
524  return DbgNode->getNumOperands() == 20;
525}
526
527/// Verify - Verify that a global variable descriptor is well formed.
528bool DIGlobalVariable::Verify() const {
529  if (!isGlobalVariable())
530    return false;
531
532  if (getDisplayName().empty())
533    return false;
534  // Make sure context @ field 2 and type @ field 8 are MDNodes.
535  if (!fieldIsMDNode(DbgNode, 2))
536    return false;
537  if (!fieldIsMDNode(DbgNode, 8))
538    return false;
539  // Make sure StaticDataMemberDeclaration @ field 12 is MDNode.
540  if (!fieldIsMDNode(DbgNode, 12))
541    return false;
542
543  return DbgNode->getNumOperands() == 13;
544}
545
546/// Verify - Verify that a variable descriptor is well formed.
547bool DIVariable::Verify() const {
548  if (!isVariable())
549    return false;
550
551  // Make sure context @ field 1 and type @ field 5 are MDNodes.
552  if (!fieldIsMDNode(DbgNode, 1))
553    return false;
554  if (!fieldIsMDNode(DbgNode, 5))
555    return false;
556  return DbgNode->getNumOperands() >= 8;
557}
558
559/// Verify - Verify that a location descriptor is well formed.
560bool DILocation::Verify() const {
561  if (!DbgNode)
562    return false;
563
564  return DbgNode->getNumOperands() == 4;
565}
566
567/// Verify - Verify that a namespace descriptor is well formed.
568bool DINameSpace::Verify() const {
569  if (!isNameSpace())
570    return false;
571  return DbgNode->getNumOperands() == 5;
572}
573
574/// \brief Retrieve the MDNode for the directory/file pair.
575MDNode *DIFile::getFileNode() const { return getNodeField(DbgNode, 1); }
576
577/// \brief Verify that the file descriptor is well formed.
578bool DIFile::Verify() const {
579  return isFile() && DbgNode->getNumOperands() == 2;
580}
581
582/// \brief Verify that the enumerator descriptor is well formed.
583bool DIEnumerator::Verify() const {
584  return isEnumerator() && DbgNode->getNumOperands() == 3;
585}
586
587/// \brief Verify that the subrange descriptor is well formed.
588bool DISubrange::Verify() const {
589  return isSubrange() && DbgNode->getNumOperands() == 3;
590}
591
592/// \brief Verify that the lexical block descriptor is well formed.
593bool DILexicalBlock::Verify() const {
594  return isLexicalBlock() && DbgNode->getNumOperands() == 6;
595}
596
597/// \brief Verify that the file-scoped lexical block descriptor is well formed.
598bool DILexicalBlockFile::Verify() const {
599  return isLexicalBlockFile() && DbgNode->getNumOperands() == 3;
600}
601
602/// \brief Verify that the template type parameter descriptor is well formed.
603bool DITemplateTypeParameter::Verify() const {
604  return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7;
605}
606
607/// \brief Verify that the template value parameter descriptor is well formed.
608bool DITemplateValueParameter::Verify() const {
609  return isTemplateValueParameter() && DbgNode->getNumOperands() == 8;
610}
611
612/// \brief Verify that the imported module descriptor is well formed.
613bool DIImportedEntity::Verify() const {
614  return isImportedEntity() &&
615         (DbgNode->getNumOperands() == 4 || DbgNode->getNumOperands() == 5);
616}
617
618/// getObjCProperty - Return property node, if this ivar is associated with one.
619MDNode *DIDerivedType::getObjCProperty() const {
620  return getNodeField(DbgNode, 10);
621}
622
623MDString *DICompositeType::getIdentifier() const {
624  return cast_or_null<MDString>(getField(DbgNode, 14));
625}
626
627#ifndef NDEBUG
628static void VerifySubsetOf(const MDNode *LHS, const MDNode *RHS) {
629  for (unsigned i = 0; i != LHS->getNumOperands(); ++i) {
630    // Skip the 'empty' list (that's a single i32 0, rather than truly empty).
631    if (i == 0 && isa<ConstantInt>(LHS->getOperand(i)))
632      continue;
633    const MDNode *E = cast<MDNode>(LHS->getOperand(i));
634    bool found = false;
635    for (unsigned j = 0; !found && j != RHS->getNumOperands(); ++j)
636      found = E == RHS->getOperand(j);
637    assert(found && "Losing a member during member list replacement");
638  }
639}
640#endif
641
642/// \brief Set the array of member DITypes.
643void DICompositeType::setTypeArray(DIArray Elements, DIArray TParams) {
644  assert((!TParams || DbgNode->getNumOperands() == 15) &&
645         "If you're setting the template parameters this should include a slot "
646         "for that!");
647  TrackingVH<MDNode> N(*this);
648  if (Elements) {
649#ifndef NDEBUG
650    // Check that the new list of members contains all the old members as well.
651    if (const MDNode *El = cast_or_null<MDNode>(N->getOperand(10)))
652      VerifySubsetOf(El, Elements);
653#endif
654    N->replaceOperandWith(10, Elements);
655  }
656  if (TParams)
657    N->replaceOperandWith(13, TParams);
658  DbgNode = N;
659}
660
661void DICompositeType::addMember(DIDescriptor D) {
662  SmallVector<llvm::Value *, 16> M;
663  DIArray OrigM = getTypeArray();
664  unsigned Elements = OrigM.getNumElements();
665  if (Elements == 1 && !OrigM.getElement(0))
666    Elements = 0;
667  M.reserve(Elements + 1);
668  for (unsigned i = 0; i != Elements; ++i)
669    M.push_back(OrigM.getElement(i));
670  M.push_back(D);
671  setTypeArray(DIArray(MDNode::get(DbgNode->getContext(), M)));
672}
673
674/// Generate a reference to this DIType. Uses the type identifier instead
675/// of the actual MDNode if possible, to help type uniquing.
676DIScopeRef DIScope::getRef() const {
677  if (!isCompositeType())
678    return DIScopeRef(*this);
679  DICompositeType DTy(DbgNode);
680  if (!DTy.getIdentifier())
681    return DIScopeRef(*this);
682  return DIScopeRef(DTy.getIdentifier());
683}
684
685/// \brief Set the containing type.
686void DICompositeType::setContainingType(DICompositeType ContainingType) {
687  TrackingVH<MDNode> N(*this);
688  N->replaceOperandWith(12, ContainingType.getRef());
689  DbgNode = N;
690}
691
692/// isInlinedFnArgument - Return true if this variable provides debugging
693/// information for an inlined function arguments.
694bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
695  assert(CurFn && "Invalid function");
696  if (!getContext().isSubprogram())
697    return false;
698  // This variable is not inlined function argument if its scope
699  // does not describe current function.
700  return !DISubprogram(getContext()).describes(CurFn);
701}
702
703/// describes - Return true if this subprogram provides debugging
704/// information for the function F.
705bool DISubprogram::describes(const Function *F) {
706  assert(F && "Invalid function");
707  if (F == getFunction())
708    return true;
709  StringRef Name = getLinkageName();
710  if (Name.empty())
711    Name = getName();
712  if (F->getName() == Name)
713    return true;
714  return false;
715}
716
717unsigned DISubprogram::isOptimized() const {
718  assert(DbgNode && "Invalid subprogram descriptor!");
719  if (DbgNode->getNumOperands() == 15)
720    return getUnsignedField(14);
721  return 0;
722}
723
724MDNode *DISubprogram::getVariablesNodes() const {
725  return getNodeField(DbgNode, 18);
726}
727
728DIArray DISubprogram::getVariables() const {
729  return DIArray(getNodeField(DbgNode, 18));
730}
731
732Value *DITemplateValueParameter::getValue() const {
733  return getField(DbgNode, 4);
734}
735
736// If the current node has a parent scope then return that,
737// else return an empty scope.
738DIScopeRef DIScope::getContext() const {
739
740  if (isType())
741    return DIType(DbgNode).getContext();
742
743  if (isSubprogram())
744    return DIScopeRef(DISubprogram(DbgNode).getContext());
745
746  if (isLexicalBlock())
747    return DIScopeRef(DILexicalBlock(DbgNode).getContext());
748
749  if (isLexicalBlockFile())
750    return DIScopeRef(DILexicalBlockFile(DbgNode).getContext());
751
752  if (isNameSpace())
753    return DIScopeRef(DINameSpace(DbgNode).getContext());
754
755  assert((isFile() || isCompileUnit()) && "Unhandled type of scope.");
756  return DIScopeRef(NULL);
757}
758
759// If the scope node has a name, return that, else return an empty string.
760StringRef DIScope::getName() const {
761  if (isType())
762    return DIType(DbgNode).getName();
763  if (isSubprogram())
764    return DISubprogram(DbgNode).getName();
765  if (isNameSpace())
766    return DINameSpace(DbgNode).getName();
767  assert((isLexicalBlock() || isLexicalBlockFile() || isFile() ||
768          isCompileUnit()) &&
769         "Unhandled type of scope.");
770  return StringRef();
771}
772
773StringRef DIScope::getFilename() const {
774  if (!DbgNode)
775    return StringRef();
776  return ::getStringField(getNodeField(DbgNode, 1), 0);
777}
778
779StringRef DIScope::getDirectory() const {
780  if (!DbgNode)
781    return StringRef();
782  return ::getStringField(getNodeField(DbgNode, 1), 1);
783}
784
785DIArray DICompileUnit::getEnumTypes() const {
786  if (!DbgNode || DbgNode->getNumOperands() < 13)
787    return DIArray();
788
789  return DIArray(getNodeField(DbgNode, 7));
790}
791
792DIArray DICompileUnit::getRetainedTypes() const {
793  if (!DbgNode || DbgNode->getNumOperands() < 13)
794    return DIArray();
795
796  return DIArray(getNodeField(DbgNode, 8));
797}
798
799DIArray DICompileUnit::getSubprograms() const {
800  if (!DbgNode || DbgNode->getNumOperands() < 13)
801    return DIArray();
802
803  return DIArray(getNodeField(DbgNode, 9));
804}
805
806DIArray DICompileUnit::getGlobalVariables() const {
807  if (!DbgNode || DbgNode->getNumOperands() < 13)
808    return DIArray();
809
810  return DIArray(getNodeField(DbgNode, 10));
811}
812
813DIArray DICompileUnit::getImportedEntities() const {
814  if (!DbgNode || DbgNode->getNumOperands() < 13)
815    return DIArray();
816
817  return DIArray(getNodeField(DbgNode, 11));
818}
819
820/// fixupSubprogramName - Replace contains special characters used
821/// in a typical Objective-C names with '.' in a given string.
822static void fixupSubprogramName(DISubprogram Fn, SmallVectorImpl<char> &Out) {
823  StringRef FName =
824      Fn.getFunction() ? Fn.getFunction()->getName() : Fn.getName();
825  FName = Function::getRealLinkageName(FName);
826
827  StringRef Prefix("llvm.dbg.lv.");
828  Out.reserve(FName.size() + Prefix.size());
829  Out.append(Prefix.begin(), Prefix.end());
830
831  bool isObjCLike = false;
832  for (size_t i = 0, e = FName.size(); i < e; ++i) {
833    char C = FName[i];
834    if (C == '[')
835      isObjCLike = true;
836
837    if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' ||
838                       C == '+' || C == '(' || C == ')'))
839      Out.push_back('.');
840    else
841      Out.push_back(C);
842  }
843}
844
845/// getFnSpecificMDNode - Return a NameMDNode, if available, that is
846/// suitable to hold function specific information.
847NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) {
848  SmallString<32> Name;
849  fixupSubprogramName(Fn, Name);
850  return M.getNamedMetadata(Name.str());
851}
852
853/// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable
854/// to hold function specific information.
855NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) {
856  SmallString<32> Name;
857  fixupSubprogramName(Fn, Name);
858  return M.getOrInsertNamedMetadata(Name.str());
859}
860
861/// createInlinedVariable - Create a new inlined variable based on current
862/// variable.
863/// @param DV            Current Variable.
864/// @param InlinedScope  Location at current variable is inlined.
865DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
866                                       LLVMContext &VMContext) {
867  SmallVector<Value *, 16> Elts;
868  // Insert inlined scope as 7th element.
869  for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
870    i == 7 ? Elts.push_back(InlinedScope) : Elts.push_back(DV->getOperand(i));
871  return DIVariable(MDNode::get(VMContext, Elts));
872}
873
874/// cleanseInlinedVariable - Remove inlined scope from the variable.
875DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) {
876  SmallVector<Value *, 16> Elts;
877  // Insert inlined scope as 7th element.
878  for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
879    i == 7 ? Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)))
880           : Elts.push_back(DV->getOperand(i));
881  return DIVariable(MDNode::get(VMContext, Elts));
882}
883
884/// getDISubprogram - Find subprogram that is enclosing this scope.
885DISubprogram llvm::getDISubprogram(const MDNode *Scope) {
886  DIDescriptor D(Scope);
887  if (D.isSubprogram())
888    return DISubprogram(Scope);
889
890  if (D.isLexicalBlockFile())
891    return getDISubprogram(DILexicalBlockFile(Scope).getContext());
892
893  if (D.isLexicalBlock())
894    return getDISubprogram(DILexicalBlock(Scope).getContext());
895
896  return DISubprogram();
897}
898
899/// getDICompositeType - Find underlying composite type.
900DICompositeType llvm::getDICompositeType(DIType T) {
901  if (T.isCompositeType())
902    return DICompositeType(T);
903
904  if (T.isDerivedType()) {
905    // This function is currently used by dragonegg and dragonegg does
906    // not generate identifier for types, so using an empty map to resolve
907    // DerivedFrom should be fine.
908    DITypeIdentifierMap EmptyMap;
909    return getDICompositeType(
910        DIDerivedType(T).getTypeDerivedFrom().resolve(EmptyMap));
911  }
912
913  return DICompositeType();
914}
915
916/// Update DITypeIdentifierMap by going through retained types of each CU.
917DITypeIdentifierMap
918llvm::generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes) {
919  DITypeIdentifierMap Map;
920  for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) {
921    DICompileUnit CU(CU_Nodes->getOperand(CUi));
922    DIArray Retain = CU.getRetainedTypes();
923    for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) {
924      if (!Retain.getElement(Ti).isCompositeType())
925        continue;
926      DICompositeType Ty(Retain.getElement(Ti));
927      if (MDString *TypeId = Ty.getIdentifier()) {
928        // Definition has priority over declaration.
929        // Try to insert (TypeId, Ty) to Map.
930        std::pair<DITypeIdentifierMap::iterator, bool> P =
931            Map.insert(std::make_pair(TypeId, Ty));
932        // If TypeId already exists in Map and this is a definition, replace
933        // whatever we had (declaration or definition) with the definition.
934        if (!P.second && !Ty.isForwardDecl())
935          P.first->second = Ty;
936      }
937    }
938  }
939  return Map;
940}
941
942//===----------------------------------------------------------------------===//
943// DebugInfoFinder implementations.
944//===----------------------------------------------------------------------===//
945
946void DebugInfoFinder::reset() {
947  CUs.clear();
948  SPs.clear();
949  GVs.clear();
950  TYs.clear();
951  Scopes.clear();
952  NodesSeen.clear();
953  TypeIdentifierMap.clear();
954  TypeMapInitialized = false;
955}
956
957void DebugInfoFinder::InitializeTypeMap(const Module &M) {
958  if (!TypeMapInitialized)
959    if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) {
960      TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
961      TypeMapInitialized = true;
962    }
963}
964
965/// processModule - Process entire module and collect debug info.
966void DebugInfoFinder::processModule(const Module &M) {
967  InitializeTypeMap(M);
968  if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) {
969    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
970      DICompileUnit CU(CU_Nodes->getOperand(i));
971      addCompileUnit(CU);
972      DIArray GVs = CU.getGlobalVariables();
973      for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) {
974        DIGlobalVariable DIG(GVs.getElement(i));
975        if (addGlobalVariable(DIG)) {
976          processScope(DIG.getContext());
977          processType(DIG.getType());
978        }
979      }
980      DIArray SPs = CU.getSubprograms();
981      for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
982        processSubprogram(DISubprogram(SPs.getElement(i)));
983      DIArray EnumTypes = CU.getEnumTypes();
984      for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
985        processType(DIType(EnumTypes.getElement(i)));
986      DIArray RetainedTypes = CU.getRetainedTypes();
987      for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
988        processType(DIType(RetainedTypes.getElement(i)));
989      DIArray Imports = CU.getImportedEntities();
990      for (unsigned i = 0, e = Imports.getNumElements(); i != e; ++i) {
991        DIImportedEntity Import = DIImportedEntity(Imports.getElement(i));
992        DIDescriptor Entity = Import.getEntity();
993        if (Entity.isType())
994          processType(DIType(Entity));
995        else if (Entity.isSubprogram())
996          processSubprogram(DISubprogram(Entity));
997        else if (Entity.isNameSpace())
998          processScope(DINameSpace(Entity).getContext());
999      }
1000    }
1001  }
1002}
1003
1004/// processLocation - Process DILocation.
1005void DebugInfoFinder::processLocation(const Module &M, DILocation Loc) {
1006  if (!Loc)
1007    return;
1008  InitializeTypeMap(M);
1009  processScope(Loc.getScope());
1010  processLocation(M, Loc.getOrigLocation());
1011}
1012
1013/// processType - Process DIType.
1014void DebugInfoFinder::processType(DIType DT) {
1015  if (!addType(DT))
1016    return;
1017  processScope(DT.getContext().resolve(TypeIdentifierMap));
1018  if (DT.isCompositeType()) {
1019    DICompositeType DCT(DT);
1020    processType(DCT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
1021    DIArray DA = DCT.getTypeArray();
1022    for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
1023      DIDescriptor D = DA.getElement(i);
1024      if (D.isType())
1025        processType(DIType(D));
1026      else if (D.isSubprogram())
1027        processSubprogram(DISubprogram(D));
1028    }
1029  } else if (DT.isDerivedType()) {
1030    DIDerivedType DDT(DT);
1031    processType(DDT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
1032  }
1033}
1034
1035void DebugInfoFinder::processScope(DIScope Scope) {
1036  if (Scope.isType()) {
1037    DIType Ty(Scope);
1038    processType(Ty);
1039    return;
1040  }
1041  if (Scope.isCompileUnit()) {
1042    addCompileUnit(DICompileUnit(Scope));
1043    return;
1044  }
1045  if (Scope.isSubprogram()) {
1046    processSubprogram(DISubprogram(Scope));
1047    return;
1048  }
1049  if (!addScope(Scope))
1050    return;
1051  if (Scope.isLexicalBlock()) {
1052    DILexicalBlock LB(Scope);
1053    processScope(LB.getContext());
1054  } else if (Scope.isLexicalBlockFile()) {
1055    DILexicalBlockFile LBF = DILexicalBlockFile(Scope);
1056    processScope(LBF.getScope());
1057  } else if (Scope.isNameSpace()) {
1058    DINameSpace NS(Scope);
1059    processScope(NS.getContext());
1060  }
1061}
1062
1063/// processLexicalBlock
1064void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) {
1065  DIScope Context = LB.getContext();
1066  if (Context.isLexicalBlock())
1067    return processLexicalBlock(DILexicalBlock(Context));
1068  else if (Context.isLexicalBlockFile()) {
1069    DILexicalBlockFile DBF = DILexicalBlockFile(Context);
1070    return processLexicalBlock(DILexicalBlock(DBF.getScope()));
1071  } else
1072    return processSubprogram(DISubprogram(Context));
1073}
1074
1075/// processSubprogram - Process DISubprogram.
1076void DebugInfoFinder::processSubprogram(DISubprogram SP) {
1077  if (!addSubprogram(SP))
1078    return;
1079  processScope(SP.getContext().resolve(TypeIdentifierMap));
1080  processType(SP.getType());
1081  DIArray TParams = SP.getTemplateParams();
1082  for (unsigned I = 0, E = TParams.getNumElements(); I != E; ++I) {
1083    DIDescriptor Element = TParams.getElement(I);
1084    if (Element.isTemplateTypeParameter()) {
1085      DITemplateTypeParameter TType(Element);
1086      processScope(TType.getContext().resolve(TypeIdentifierMap));
1087      processType(TType.getType().resolve(TypeIdentifierMap));
1088    } else if (Element.isTemplateValueParameter()) {
1089      DITemplateValueParameter TVal(Element);
1090      processScope(TVal.getContext().resolve(TypeIdentifierMap));
1091      processType(TVal.getType().resolve(TypeIdentifierMap));
1092    }
1093  }
1094}
1095
1096/// processDeclare - Process DbgDeclareInst.
1097void DebugInfoFinder::processDeclare(const Module &M,
1098                                     const DbgDeclareInst *DDI) {
1099  MDNode *N = dyn_cast<MDNode>(DDI->getVariable());
1100  if (!N)
1101    return;
1102  InitializeTypeMap(M);
1103
1104  DIDescriptor DV(N);
1105  if (!DV.isVariable())
1106    return;
1107
1108  if (!NodesSeen.insert(DV))
1109    return;
1110  processScope(DIVariable(N).getContext());
1111  processType(DIVariable(N).getType());
1112}
1113
1114void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
1115  MDNode *N = dyn_cast<MDNode>(DVI->getVariable());
1116  if (!N)
1117    return;
1118  InitializeTypeMap(M);
1119
1120  DIDescriptor DV(N);
1121  if (!DV.isVariable())
1122    return;
1123
1124  if (!NodesSeen.insert(DV))
1125    return;
1126  processScope(DIVariable(N).getContext());
1127  processType(DIVariable(N).getType());
1128}
1129
1130/// addType - Add type into Tys.
1131bool DebugInfoFinder::addType(DIType DT) {
1132  if (!DT)
1133    return false;
1134
1135  if (!NodesSeen.insert(DT))
1136    return false;
1137
1138  TYs.push_back(DT);
1139  return true;
1140}
1141
1142/// addCompileUnit - Add compile unit into CUs.
1143bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) {
1144  if (!CU)
1145    return false;
1146  if (!NodesSeen.insert(CU))
1147    return false;
1148
1149  CUs.push_back(CU);
1150  return true;
1151}
1152
1153/// addGlobalVariable - Add global variable into GVs.
1154bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) {
1155  if (!DIG)
1156    return false;
1157
1158  if (!NodesSeen.insert(DIG))
1159    return false;
1160
1161  GVs.push_back(DIG);
1162  return true;
1163}
1164
1165// addSubprogram - Add subprgoram into SPs.
1166bool DebugInfoFinder::addSubprogram(DISubprogram SP) {
1167  if (!SP)
1168    return false;
1169
1170  if (!NodesSeen.insert(SP))
1171    return false;
1172
1173  SPs.push_back(SP);
1174  return true;
1175}
1176
1177bool DebugInfoFinder::addScope(DIScope Scope) {
1178  if (!Scope)
1179    return false;
1180  // FIXME: Ocaml binding generates a scope with no content, we treat it
1181  // as null for now.
1182  if (Scope->getNumOperands() == 0)
1183    return false;
1184  if (!NodesSeen.insert(Scope))
1185    return false;
1186  Scopes.push_back(Scope);
1187  return true;
1188}
1189
1190//===----------------------------------------------------------------------===//
1191// DIDescriptor: dump routines for all descriptors.
1192//===----------------------------------------------------------------------===//
1193
1194/// dump - Print descriptor to dbgs() with a newline.
1195void DIDescriptor::dump() const {
1196  print(dbgs());
1197  dbgs() << '\n';
1198}
1199
1200/// print - Print descriptor.
1201void DIDescriptor::print(raw_ostream &OS) const {
1202  if (!DbgNode)
1203    return;
1204
1205  if (const char *Tag = dwarf::TagString(getTag()))
1206    OS << "[ " << Tag << " ]";
1207
1208  if (this->isSubrange()) {
1209    DISubrange(DbgNode).printInternal(OS);
1210  } else if (this->isCompileUnit()) {
1211    DICompileUnit(DbgNode).printInternal(OS);
1212  } else if (this->isFile()) {
1213    DIFile(DbgNode).printInternal(OS);
1214  } else if (this->isEnumerator()) {
1215    DIEnumerator(DbgNode).printInternal(OS);
1216  } else if (this->isBasicType()) {
1217    DIType(DbgNode).printInternal(OS);
1218  } else if (this->isDerivedType()) {
1219    DIDerivedType(DbgNode).printInternal(OS);
1220  } else if (this->isCompositeType()) {
1221    DICompositeType(DbgNode).printInternal(OS);
1222  } else if (this->isSubprogram()) {
1223    DISubprogram(DbgNode).printInternal(OS);
1224  } else if (this->isGlobalVariable()) {
1225    DIGlobalVariable(DbgNode).printInternal(OS);
1226  } else if (this->isVariable()) {
1227    DIVariable(DbgNode).printInternal(OS);
1228  } else if (this->isObjCProperty()) {
1229    DIObjCProperty(DbgNode).printInternal(OS);
1230  } else if (this->isNameSpace()) {
1231    DINameSpace(DbgNode).printInternal(OS);
1232  } else if (this->isScope()) {
1233    DIScope(DbgNode).printInternal(OS);
1234  }
1235}
1236
1237void DISubrange::printInternal(raw_ostream &OS) const {
1238  int64_t Count = getCount();
1239  if (Count != -1)
1240    OS << " [" << getLo() << ", " << Count - 1 << ']';
1241  else
1242    OS << " [unbounded]";
1243}
1244
1245void DIScope::printInternal(raw_ostream &OS) const {
1246  OS << " [" << getDirectory() << "/" << getFilename() << ']';
1247}
1248
1249void DICompileUnit::printInternal(raw_ostream &OS) const {
1250  DIScope::printInternal(OS);
1251  OS << " [";
1252  unsigned Lang = getLanguage();
1253  if (const char *LangStr = dwarf::LanguageString(Lang))
1254    OS << LangStr;
1255  else
1256    (OS << "lang 0x").write_hex(Lang);
1257  OS << ']';
1258}
1259
1260void DIEnumerator::printInternal(raw_ostream &OS) const {
1261  OS << " [" << getName() << " :: " << getEnumValue() << ']';
1262}
1263
1264void DIType::printInternal(raw_ostream &OS) const {
1265  if (!DbgNode)
1266    return;
1267
1268  StringRef Res = getName();
1269  if (!Res.empty())
1270    OS << " [" << Res << "]";
1271
1272  // TODO: Print context?
1273
1274  OS << " [line " << getLineNumber() << ", size " << getSizeInBits()
1275     << ", align " << getAlignInBits() << ", offset " << getOffsetInBits();
1276  if (isBasicType())
1277    if (const char *Enc =
1278            dwarf::AttributeEncodingString(DIBasicType(DbgNode).getEncoding()))
1279      OS << ", enc " << Enc;
1280  OS << "]";
1281
1282  if (isPrivate())
1283    OS << " [private]";
1284  else if (isProtected())
1285    OS << " [protected]";
1286
1287  if (isArtificial())
1288    OS << " [artificial]";
1289
1290  if (isForwardDecl())
1291    OS << " [decl]";
1292  else if (getTag() == dwarf::DW_TAG_structure_type ||
1293           getTag() == dwarf::DW_TAG_union_type ||
1294           getTag() == dwarf::DW_TAG_enumeration_type ||
1295           getTag() == dwarf::DW_TAG_class_type)
1296    OS << " [def]";
1297  if (isVector())
1298    OS << " [vector]";
1299  if (isStaticMember())
1300    OS << " [static]";
1301}
1302
1303void DIDerivedType::printInternal(raw_ostream &OS) const {
1304  DIType::printInternal(OS);
1305  OS << " [from " << getTypeDerivedFrom().getName() << ']';
1306}
1307
1308void DICompositeType::printInternal(raw_ostream &OS) const {
1309  DIType::printInternal(OS);
1310  DIArray A = getTypeArray();
1311  OS << " [" << A.getNumElements() << " elements]";
1312}
1313
1314void DINameSpace::printInternal(raw_ostream &OS) const {
1315  StringRef Name = getName();
1316  if (!Name.empty())
1317    OS << " [" << Name << ']';
1318
1319  OS << " [line " << getLineNumber() << ']';
1320}
1321
1322void DISubprogram::printInternal(raw_ostream &OS) const {
1323  // TODO : Print context
1324  OS << " [line " << getLineNumber() << ']';
1325
1326  if (isLocalToUnit())
1327    OS << " [local]";
1328
1329  if (isDefinition())
1330    OS << " [def]";
1331
1332  if (getScopeLineNumber() != getLineNumber())
1333    OS << " [scope " << getScopeLineNumber() << "]";
1334
1335  if (isPrivate())
1336    OS << " [private]";
1337  else if (isProtected())
1338    OS << " [protected]";
1339
1340  StringRef Res = getName();
1341  if (!Res.empty())
1342    OS << " [" << Res << ']';
1343}
1344
1345void DIGlobalVariable::printInternal(raw_ostream &OS) const {
1346  StringRef Res = getName();
1347  if (!Res.empty())
1348    OS << " [" << Res << ']';
1349
1350  OS << " [line " << getLineNumber() << ']';
1351
1352  // TODO : Print context
1353
1354  if (isLocalToUnit())
1355    OS << " [local]";
1356
1357  if (isDefinition())
1358    OS << " [def]";
1359}
1360
1361void DIVariable::printInternal(raw_ostream &OS) const {
1362  StringRef Res = getName();
1363  if (!Res.empty())
1364    OS << " [" << Res << ']';
1365
1366  OS << " [line " << getLineNumber() << ']';
1367}
1368
1369void DIObjCProperty::printInternal(raw_ostream &OS) const {
1370  StringRef Name = getObjCPropertyName();
1371  if (!Name.empty())
1372    OS << " [" << Name << ']';
1373
1374  OS << " [line " << getLineNumber() << ", properties " << getUnsignedField(6)
1375     << ']';
1376}
1377
1378static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS,
1379                          const LLVMContext &Ctx) {
1380  if (!DL.isUnknown()) { // Print source line info.
1381    DIScope Scope(DL.getScope(Ctx));
1382    assert(Scope.isScope() && "Scope of a DebugLoc should be a DIScope.");
1383    // Omit the directory, because it's likely to be long and uninteresting.
1384    CommentOS << Scope.getFilename();
1385    CommentOS << ':' << DL.getLine();
1386    if (DL.getCol() != 0)
1387      CommentOS << ':' << DL.getCol();
1388    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx));
1389    if (!InlinedAtDL.isUnknown()) {
1390      CommentOS << " @[ ";
1391      printDebugLoc(InlinedAtDL, CommentOS, Ctx);
1392      CommentOS << " ]";
1393    }
1394  }
1395}
1396
1397void DIVariable::printExtendedName(raw_ostream &OS) const {
1398  const LLVMContext &Ctx = DbgNode->getContext();
1399  StringRef Res = getName();
1400  if (!Res.empty())
1401    OS << Res << "," << getLineNumber();
1402  if (MDNode *InlinedAt = getInlinedAt()) {
1403    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt);
1404    if (!InlinedAtDL.isUnknown()) {
1405      OS << " @[";
1406      printDebugLoc(InlinedAtDL, OS, Ctx);
1407      OS << "]";
1408    }
1409  }
1410}
1411
1412/// Specialize constructor to make sure it has the correct type.
1413template <> DIRef<DIScope>::DIRef(const Value *V) : Val(V) {
1414  assert(isScopeRef(V) && "DIScopeRef should be a MDString or MDNode");
1415}
1416template <> DIRef<DIType>::DIRef(const Value *V) : Val(V) {
1417  assert(isTypeRef(V) && "DITypeRef should be a MDString or MDNode");
1418}
1419
1420/// Specialize getFieldAs to handle fields that are references to DIScopes.
1421template <>
1422DIScopeRef DIDescriptor::getFieldAs<DIScopeRef>(unsigned Elt) const {
1423  return DIScopeRef(getField(DbgNode, Elt));
1424}
1425/// Specialize getFieldAs to handle fields that are references to DITypes.
1426template <> DITypeRef DIDescriptor::getFieldAs<DITypeRef>(unsigned Elt) const {
1427  return DITypeRef(getField(DbgNode, Elt));
1428}
1429
1430/// Strip debug info in the module if it exists.
1431/// To do this, we remove all calls to the debugger intrinsics and any named
1432/// metadata for debugging. We also remove debug locations for instructions.
1433/// Return true if module is modified.
1434bool llvm::StripDebugInfo(Module &M) {
1435
1436  bool Changed = false;
1437
1438  // Remove all of the calls to the debugger intrinsics, and remove them from
1439  // the module.
1440  if (Function *Declare = M.getFunction("llvm.dbg.declare")) {
1441    while (!Declare->use_empty()) {
1442      CallInst *CI = cast<CallInst>(Declare->use_back());
1443      CI->eraseFromParent();
1444    }
1445    Declare->eraseFromParent();
1446    Changed = true;
1447  }
1448
1449  if (Function *DbgVal = M.getFunction("llvm.dbg.value")) {
1450    while (!DbgVal->use_empty()) {
1451      CallInst *CI = cast<CallInst>(DbgVal->use_back());
1452      CI->eraseFromParent();
1453    }
1454    DbgVal->eraseFromParent();
1455    Changed = true;
1456  }
1457
1458  for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
1459         NME = M.named_metadata_end(); NMI != NME;) {
1460    NamedMDNode *NMD = NMI;
1461    ++NMI;
1462    if (NMD->getName().startswith("llvm.dbg.")) {
1463      NMD->eraseFromParent();
1464      Changed = true;
1465    }
1466  }
1467
1468  for (Module::iterator MI = M.begin(), ME = M.end(); MI != ME; ++MI)
1469    for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE;
1470         ++FI)
1471      for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE;
1472           ++BI) {
1473        if (!BI->getDebugLoc().isUnknown()) {
1474          Changed = true;
1475          BI->setDebugLoc(DebugLoc());
1476        }
1477      }
1478
1479  return Changed;
1480}
1481
1482/// Return Debug Info Metadata Version by checking module flags.
1483unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
1484  Value *Val = M.getModuleFlag("Debug Info Version");
1485  if (!Val)
1486    return 0;
1487  return cast<ConstantInt>(Val)->getZExtValue();
1488}
1489