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