MachineModuleInfo.cpp revision a844bdeab31ef04221e7ef59a8467893584cc14d 
1//===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- C++ -*-===//
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#include "llvm/CodeGen/MachineModuleInfo.h"
11
12#include "llvm/Constants.h"
13#include "llvm/CodeGen/MachineFunctionPass.h"
14#include "llvm/CodeGen/MachineFunction.h"
15#include "llvm/CodeGen/MachineLocation.h"
16#include "llvm/Target/TargetInstrInfo.h"
17#include "llvm/Target/TargetMachine.h"
18#include "llvm/Target/TargetOptions.h"
19#include "llvm/DerivedTypes.h"
20#include "llvm/GlobalVariable.h"
21#include "llvm/Intrinsics.h"
22#include "llvm/Instructions.h"
23#include "llvm/Module.h"
24#include "llvm/Support/Dwarf.h"
25#include "llvm/Support/Streams.h"
26using namespace llvm;
27using namespace llvm::dwarf;
28
29// Handle the Pass registration stuff necessary to use TargetData's.
30namespace {
31  RegisterPass<MachineModuleInfo> X("machinemoduleinfo", "Module Information");
32}
33char MachineModuleInfo::ID = 0;
34
35//===----------------------------------------------------------------------===//
36
37/// getGlobalVariablesUsing - Return all of the GlobalVariables which have the
38/// specified value in their initializer somewhere.
39static void
40getGlobalVariablesUsing(Value *V, std::vector<GlobalVariable*> &Result) {
41  // Scan though value users.
42  for (Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) {
43    if (GlobalVariable *GV = dyn_cast<GlobalVariable>(*I)) {
44      // If the user is a GlobalVariable then add to result.
45      Result.push_back(GV);
46    } else if (Constant *C = dyn_cast<Constant>(*I)) {
47      // If the user is a constant variable then scan its users
48      getGlobalVariablesUsing(C, Result);
49    }
50  }
51}
52
53/// getGlobalVariablesUsing - Return all of the GlobalVariables that use the
54/// named GlobalVariable.
55static std::vector<GlobalVariable*>
56getGlobalVariablesUsing(Module &M, const std::string &RootName) {
57  std::vector<GlobalVariable*> Result;  // GlobalVariables matching criteria.
58
59  std::vector<const Type*> FieldTypes;
60  FieldTypes.push_back(Type::Int32Ty);
61  FieldTypes.push_back(Type::Int32Ty);
62
63  // Get the GlobalVariable root.
64  GlobalVariable *UseRoot = M.getGlobalVariable(RootName,
65                                                StructType::get(FieldTypes));
66
67  // If present and linkonce then scan for users.
68  if (UseRoot && UseRoot->hasLinkOnceLinkage()) {
69    getGlobalVariablesUsing(UseRoot, Result);
70  }
71
72  return Result;
73}
74
75/// isStringValue - Return true if the given value can be coerced to a string.
76///
77static bool isStringValue(Value *V) {
78  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
79    if (GV->hasInitializer() && isa<ConstantArray>(GV->getInitializer())) {
80      ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
81      return Init->isString();
82    }
83  } else if (Constant *C = dyn_cast<Constant>(V)) {
84    if (GlobalValue *GV = dyn_cast<GlobalValue>(C))
85      return isStringValue(GV);
86    else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
87      if (CE->getOpcode() == Instruction::GetElementPtr) {
88        if (CE->getNumOperands() == 3 &&
89            cast<Constant>(CE->getOperand(1))->isNullValue() &&
90            isa<ConstantInt>(CE->getOperand(2))) {
91          return isStringValue(CE->getOperand(0));
92        }
93      }
94    }
95  }
96  return false;
97}
98
99/// getGlobalVariable - Return either a direct or cast Global value.
100///
101static GlobalVariable *getGlobalVariable(Value *V) {
102  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
103    return GV;
104  } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
105    if (CE->getOpcode() == Instruction::BitCast) {
106      return dyn_cast<GlobalVariable>(CE->getOperand(0));
107    } else if (CE->getOpcode() == Instruction::GetElementPtr) {
108      for (unsigned int i=1; i<CE->getNumOperands(); i++) {
109        if (!CE->getOperand(i)->isNullValue())
110          return NULL;
111      }
112      return dyn_cast<GlobalVariable>(CE->getOperand(0));
113    }
114  }
115  return NULL;
116}
117
118/// isGlobalVariable - Return true if the given value can be coerced to a
119/// GlobalVariable.
120static bool isGlobalVariable(Value *V) {
121  if (isa<GlobalVariable>(V) || isa<ConstantPointerNull>(V)) {
122    return true;
123  } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
124    if (CE->getOpcode() == Instruction::BitCast) {
125      return isa<GlobalVariable>(CE->getOperand(0));
126    } else if (CE->getOpcode() == Instruction::GetElementPtr) {
127      for (unsigned int i=1; i<CE->getNumOperands(); i++) {
128        if (!CE->getOperand(i)->isNullValue())
129          return false;
130      }
131      return isa<GlobalVariable>(CE->getOperand(0));
132    }
133  }
134  return false;
135}
136
137/// getUIntOperand - Return ith operand if it is an unsigned integer.
138///
139static ConstantInt *getUIntOperand(GlobalVariable *GV, unsigned i) {
140  // Make sure the GlobalVariable has an initializer.
141  if (!GV->hasInitializer()) return NULL;
142
143  // Get the initializer constant.
144  ConstantStruct *CI = dyn_cast<ConstantStruct>(GV->getInitializer());
145  if (!CI) return NULL;
146
147  // Check if there is at least i + 1 operands.
148  unsigned N = CI->getNumOperands();
149  if (i >= N) return NULL;
150
151  // Check constant.
152  return dyn_cast<ConstantInt>(CI->getOperand(i));
153}
154
155//===----------------------------------------------------------------------===//
156
157/// ApplyToFields - Target the visitor to each field of the debug information
158/// descriptor.
159void DIVisitor::ApplyToFields(DebugInfoDesc *DD) {
160  DD->ApplyToFields(this);
161}
162
163//===----------------------------------------------------------------------===//
164/// DICountVisitor - This DIVisitor counts all the fields in the supplied debug
165/// the supplied DebugInfoDesc.
166class DICountVisitor : public DIVisitor {
167private:
168  unsigned Count;                       // Running count of fields.
169
170public:
171  DICountVisitor() : DIVisitor(), Count(0) {}
172
173  // Accessors.
174  unsigned getCount() const { return Count; }
175
176  /// Apply - Count each of the fields.
177  ///
178  virtual void Apply(int &Field)             { ++Count; }
179  virtual void Apply(unsigned &Field)        { ++Count; }
180  virtual void Apply(int64_t &Field)         { ++Count; }
181  virtual void Apply(uint64_t &Field)        { ++Count; }
182  virtual void Apply(bool &Field)            { ++Count; }
183  virtual void Apply(std::string &Field)     { ++Count; }
184  virtual void Apply(DebugInfoDesc *&Field)  { ++Count; }
185  virtual void Apply(GlobalVariable *&Field) { ++Count; }
186  virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
187    ++Count;
188  }
189};
190
191//===----------------------------------------------------------------------===//
192/// DIDeserializeVisitor - This DIVisitor deserializes all the fields in the
193/// supplied DebugInfoDesc.
194class DIDeserializeVisitor : public DIVisitor {
195private:
196  DIDeserializer &DR;                   // Active deserializer.
197  unsigned I;                           // Current operand index.
198  ConstantStruct *CI;                   // GlobalVariable constant initializer.
199
200public:
201  DIDeserializeVisitor(DIDeserializer &D, GlobalVariable *GV)
202  : DIVisitor()
203  , DR(D)
204  , I(0)
205  , CI(cast<ConstantStruct>(GV->getInitializer()))
206  {}
207
208  /// Apply - Set the value of each of the fields.
209  ///
210  virtual void Apply(int &Field) {
211    Constant *C = CI->getOperand(I++);
212    Field = cast<ConstantInt>(C)->getSExtValue();
213  }
214  virtual void Apply(unsigned &Field) {
215    Constant *C = CI->getOperand(I++);
216    Field = cast<ConstantInt>(C)->getZExtValue();
217  }
218  virtual void Apply(int64_t &Field) {
219    Constant *C = CI->getOperand(I++);
220    Field = cast<ConstantInt>(C)->getSExtValue();
221  }
222  virtual void Apply(uint64_t &Field) {
223    Constant *C = CI->getOperand(I++);
224    Field = cast<ConstantInt>(C)->getZExtValue();
225  }
226  virtual void Apply(bool &Field) {
227    Constant *C = CI->getOperand(I++);
228    Field = cast<ConstantInt>(C)->getZExtValue();
229  }
230  virtual void Apply(std::string &Field) {
231    Constant *C = CI->getOperand(I++);
232    Field = C->getStringValue();
233  }
234  virtual void Apply(DebugInfoDesc *&Field) {
235    Constant *C = CI->getOperand(I++);
236    Field = DR.Deserialize(C);
237  }
238  virtual void Apply(GlobalVariable *&Field) {
239    Constant *C = CI->getOperand(I++);
240    Field = getGlobalVariable(C);
241  }
242  virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
243    Field.resize(0);
244    Constant *C = CI->getOperand(I++);
245    GlobalVariable *GV = getGlobalVariable(C);
246    if (GV->hasInitializer()) {
247      if (ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer())) {
248        for (unsigned i = 0, N = CA->getNumOperands(); i < N; ++i) {
249          GlobalVariable *GVE = getGlobalVariable(CA->getOperand(i));
250          DebugInfoDesc *DE = DR.Deserialize(GVE);
251          Field.push_back(DE);
252        }
253      } else if (GV->getInitializer()->isNullValue()) {
254        if (const ArrayType *T =
255            dyn_cast<ArrayType>(GV->getType()->getElementType())) {
256          Field.resize(T->getNumElements());
257        }
258      }
259    }
260  }
261};
262
263//===----------------------------------------------------------------------===//
264/// DISerializeVisitor - This DIVisitor serializes all the fields in
265/// the supplied DebugInfoDesc.
266class DISerializeVisitor : public DIVisitor {
267private:
268  DISerializer &SR;                     // Active serializer.
269  std::vector<Constant*> &Elements;     // Element accumulator.
270
271public:
272  DISerializeVisitor(DISerializer &S, std::vector<Constant*> &E)
273  : DIVisitor()
274  , SR(S)
275  , Elements(E)
276  {}
277
278  /// Apply - Set the value of each of the fields.
279  ///
280  virtual void Apply(int &Field) {
281    Elements.push_back(ConstantInt::get(Type::Int32Ty, int32_t(Field)));
282  }
283  virtual void Apply(unsigned &Field) {
284    Elements.push_back(ConstantInt::get(Type::Int32Ty, uint32_t(Field)));
285  }
286  virtual void Apply(int64_t &Field) {
287    Elements.push_back(ConstantInt::get(Type::Int64Ty, int64_t(Field)));
288  }
289  virtual void Apply(uint64_t &Field) {
290    Elements.push_back(ConstantInt::get(Type::Int64Ty, uint64_t(Field)));
291  }
292  virtual void Apply(bool &Field) {
293    Elements.push_back(ConstantInt::get(Type::Int1Ty, Field));
294  }
295  virtual void Apply(std::string &Field) {
296      Elements.push_back(SR.getString(Field));
297  }
298  virtual void Apply(DebugInfoDesc *&Field) {
299    GlobalVariable *GV = NULL;
300
301    // If non-NULL then convert to global.
302    if (Field) GV = SR.Serialize(Field);
303
304    // FIXME - At some point should use specific type.
305    const PointerType *EmptyTy = SR.getEmptyStructPtrType();
306
307    if (GV) {
308      // Set to pointer to global.
309      Elements.push_back(ConstantExpr::getBitCast(GV, EmptyTy));
310    } else {
311      // Use NULL.
312      Elements.push_back(ConstantPointerNull::get(EmptyTy));
313    }
314  }
315  virtual void Apply(GlobalVariable *&Field) {
316    const PointerType *EmptyTy = SR.getEmptyStructPtrType();
317    if (Field) {
318      Elements.push_back(ConstantExpr::getBitCast(Field, EmptyTy));
319    } else {
320      Elements.push_back(ConstantPointerNull::get(EmptyTy));
321    }
322  }
323  virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
324    const PointerType *EmptyTy = SR.getEmptyStructPtrType();
325    unsigned N = Field.size();
326    ArrayType *AT = ArrayType::get(EmptyTy, N);
327    std::vector<Constant *> ArrayElements;
328
329    for (unsigned i = 0, N = Field.size(); i < N; ++i) {
330      if (DebugInfoDesc *Element = Field[i]) {
331        GlobalVariable *GVE = SR.Serialize(Element);
332        Constant *CE = ConstantExpr::getBitCast(GVE, EmptyTy);
333        ArrayElements.push_back(cast<Constant>(CE));
334      } else {
335        ArrayElements.push_back(ConstantPointerNull::get(EmptyTy));
336      }
337    }
338
339    Constant *CA = ConstantArray::get(AT, ArrayElements);
340    GlobalVariable *CAGV = new GlobalVariable(AT, true,
341                                              GlobalValue::InternalLinkage,
342                                              CA, "llvm.dbg.array",
343                                              SR.getModule());
344    CAGV->setSection("llvm.metadata");
345    Constant *CAE = ConstantExpr::getBitCast(CAGV, EmptyTy);
346    Elements.push_back(CAE);
347  }
348};
349
350//===----------------------------------------------------------------------===//
351/// DIGetTypesVisitor - This DIVisitor gathers all the field types in
352/// the supplied DebugInfoDesc.
353class DIGetTypesVisitor : public DIVisitor {
354private:
355  DISerializer &SR;                     // Active serializer.
356  std::vector<const Type*> &Fields;     // Type accumulator.
357
358public:
359  DIGetTypesVisitor(DISerializer &S, std::vector<const Type*> &F)
360  : DIVisitor()
361  , SR(S)
362  , Fields(F)
363  {}
364
365  /// Apply - Set the value of each of the fields.
366  ///
367  virtual void Apply(int &Field) {
368    Fields.push_back(Type::Int32Ty);
369  }
370  virtual void Apply(unsigned &Field) {
371    Fields.push_back(Type::Int32Ty);
372  }
373  virtual void Apply(int64_t &Field) {
374    Fields.push_back(Type::Int64Ty);
375  }
376  virtual void Apply(uint64_t &Field) {
377    Fields.push_back(Type::Int64Ty);
378  }
379  virtual void Apply(bool &Field) {
380    Fields.push_back(Type::Int1Ty);
381  }
382  virtual void Apply(std::string &Field) {
383    Fields.push_back(SR.getStrPtrType());
384  }
385  virtual void Apply(DebugInfoDesc *&Field) {
386    // FIXME - At some point should use specific type.
387    const PointerType *EmptyTy = SR.getEmptyStructPtrType();
388    Fields.push_back(EmptyTy);
389  }
390  virtual void Apply(GlobalVariable *&Field) {
391    const PointerType *EmptyTy = SR.getEmptyStructPtrType();
392    Fields.push_back(EmptyTy);
393  }
394  virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
395    const PointerType *EmptyTy = SR.getEmptyStructPtrType();
396    Fields.push_back(EmptyTy);
397  }
398};
399
400//===----------------------------------------------------------------------===//
401/// DIVerifyVisitor - This DIVisitor verifies all the field types against
402/// a constant initializer.
403class DIVerifyVisitor : public DIVisitor {
404private:
405  DIVerifier &VR;                       // Active verifier.
406  bool IsValid;                         // Validity status.
407  unsigned I;                           // Current operand index.
408  ConstantStruct *CI;                   // GlobalVariable constant initializer.
409
410public:
411  DIVerifyVisitor(DIVerifier &V, GlobalVariable *GV)
412  : DIVisitor()
413  , VR(V)
414  , IsValid(true)
415  , I(0)
416  , CI(cast<ConstantStruct>(GV->getInitializer()))
417  {
418  }
419
420  // Accessors.
421  bool isValid() const { return IsValid; }
422
423  /// Apply - Set the value of each of the fields.
424  ///
425  virtual void Apply(int &Field) {
426    Constant *C = CI->getOperand(I++);
427    IsValid = IsValid && isa<ConstantInt>(C);
428  }
429  virtual void Apply(unsigned &Field) {
430    Constant *C = CI->getOperand(I++);
431    IsValid = IsValid && isa<ConstantInt>(C);
432  }
433  virtual void Apply(int64_t &Field) {
434    Constant *C = CI->getOperand(I++);
435    IsValid = IsValid && isa<ConstantInt>(C);
436  }
437  virtual void Apply(uint64_t &Field) {
438    Constant *C = CI->getOperand(I++);
439    IsValid = IsValid && isa<ConstantInt>(C);
440  }
441  virtual void Apply(bool &Field) {
442    Constant *C = CI->getOperand(I++);
443    IsValid = IsValid && isa<ConstantInt>(C) && C->getType() == Type::Int1Ty;
444  }
445  virtual void Apply(std::string &Field) {
446    Constant *C = CI->getOperand(I++);
447    IsValid = IsValid &&
448              (!C || isStringValue(C) || C->isNullValue());
449  }
450  virtual void Apply(DebugInfoDesc *&Field) {
451    // FIXME - Prepare the correct descriptor.
452    Constant *C = CI->getOperand(I++);
453    IsValid = IsValid && isGlobalVariable(C);
454  }
455  virtual void Apply(GlobalVariable *&Field) {
456    Constant *C = CI->getOperand(I++);
457    IsValid = IsValid && isGlobalVariable(C);
458  }
459  virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
460    Constant *C = CI->getOperand(I++);
461    IsValid = IsValid && isGlobalVariable(C);
462    if (!IsValid) return;
463
464    GlobalVariable *GV = getGlobalVariable(C);
465    IsValid = IsValid && GV && GV->hasInitializer();
466    if (!IsValid) return;
467
468    ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer());
469    IsValid = IsValid && CA;
470    if (!IsValid) return;
471
472    for (unsigned i = 0, N = CA->getNumOperands(); IsValid && i < N; ++i) {
473      IsValid = IsValid && isGlobalVariable(CA->getOperand(i));
474      if (!IsValid) return;
475
476      GlobalVariable *GVE = getGlobalVariable(CA->getOperand(i));
477      VR.Verify(GVE);
478    }
479  }
480};
481
482
483//===----------------------------------------------------------------------===//
484
485/// TagFromGlobal - Returns the tag number from a debug info descriptor
486/// GlobalVariable.   Return DIIValid if operand is not an unsigned int.
487unsigned DebugInfoDesc::TagFromGlobal(GlobalVariable *GV) {
488  ConstantInt *C = getUIntOperand(GV, 0);
489  return C ? ((unsigned)C->getZExtValue() & ~LLVMDebugVersionMask) :
490             (unsigned)DW_TAG_invalid;
491}
492
493/// VersionFromGlobal - Returns the version number from a debug info
494/// descriptor GlobalVariable.  Return DIIValid if operand is not an unsigned
495/// int.
496unsigned  DebugInfoDesc::VersionFromGlobal(GlobalVariable *GV) {
497  ConstantInt *C = getUIntOperand(GV, 0);
498  return C ? ((unsigned)C->getZExtValue() & LLVMDebugVersionMask) :
499             (unsigned)DW_TAG_invalid;
500}
501
502/// DescFactory - Create an instance of debug info descriptor based on Tag.
503/// Return NULL if not a recognized Tag.
504DebugInfoDesc *DebugInfoDesc::DescFactory(unsigned Tag) {
505  switch (Tag) {
506  case DW_TAG_anchor:           return new AnchorDesc();
507  case DW_TAG_compile_unit:     return new CompileUnitDesc();
508  case DW_TAG_variable:         return new GlobalVariableDesc();
509  case DW_TAG_subprogram:       return new SubprogramDesc();
510  case DW_TAG_lexical_block:    return new BlockDesc();
511  case DW_TAG_base_type:        return new BasicTypeDesc();
512  case DW_TAG_typedef:
513  case DW_TAG_pointer_type:
514  case DW_TAG_reference_type:
515  case DW_TAG_const_type:
516  case DW_TAG_volatile_type:
517  case DW_TAG_restrict_type:
518  case DW_TAG_member:
519  case DW_TAG_inheritance:      return new DerivedTypeDesc(Tag);
520  case DW_TAG_array_type:
521  case DW_TAG_structure_type:
522  case DW_TAG_union_type:
523  case DW_TAG_enumeration_type:
524  case DW_TAG_vector_type:
525  case DW_TAG_subroutine_type:  return new CompositeTypeDesc(Tag);
526  case DW_TAG_subrange_type:    return new SubrangeDesc();
527  case DW_TAG_enumerator:       return new EnumeratorDesc();
528  case DW_TAG_return_variable:
529  case DW_TAG_arg_variable:
530  case DW_TAG_auto_variable:    return new VariableDesc(Tag);
531  default: break;
532  }
533  return NULL;
534}
535
536/// getLinkage - get linkage appropriate for this type of descriptor.
537///
538GlobalValue::LinkageTypes DebugInfoDesc::getLinkage() const {
539  return GlobalValue::InternalLinkage;
540}
541
542/// ApplyToFields - Target the vistor to the fields of the descriptor.
543///
544void DebugInfoDesc::ApplyToFields(DIVisitor *Visitor) {
545  Visitor->Apply(Tag);
546}
547
548//===----------------------------------------------------------------------===//
549
550AnchorDesc::AnchorDesc()
551: DebugInfoDesc(DW_TAG_anchor)
552, AnchorTag(0)
553{}
554AnchorDesc::AnchorDesc(AnchoredDesc *D)
555: DebugInfoDesc(DW_TAG_anchor)
556, AnchorTag(D->getTag())
557{}
558
559// Implement isa/cast/dyncast.
560bool AnchorDesc::classof(const DebugInfoDesc *D) {
561  return D->getTag() == DW_TAG_anchor;
562}
563
564/// getLinkage - get linkage appropriate for this type of descriptor.
565///
566GlobalValue::LinkageTypes AnchorDesc::getLinkage() const {
567  return GlobalValue::LinkOnceLinkage;
568}
569
570/// ApplyToFields - Target the visitor to the fields of the TransUnitDesc.
571///
572void AnchorDesc::ApplyToFields(DIVisitor *Visitor) {
573  DebugInfoDesc::ApplyToFields(Visitor);
574
575  Visitor->Apply(AnchorTag);
576}
577
578/// getDescString - Return a string used to compose global names and labels. A
579/// A global variable name needs to be defined for each debug descriptor that is
580/// anchored. NOTE: that each global variable named here also needs to be added
581/// to the list of names left external in the internalizer.
582///   ExternalNames.insert("llvm.dbg.compile_units");
583///   ExternalNames.insert("llvm.dbg.global_variables");
584///   ExternalNames.insert("llvm.dbg.subprograms");
585const char *AnchorDesc::getDescString() const {
586  switch (AnchorTag) {
587  case DW_TAG_compile_unit: return CompileUnitDesc::AnchorString;
588  case DW_TAG_variable:     return GlobalVariableDesc::AnchorString;
589  case DW_TAG_subprogram:   return SubprogramDesc::AnchorString;
590  default: break;
591  }
592
593  assert(0 && "Tag does not have a case for anchor string");
594  return "";
595}
596
597/// getTypeString - Return a string used to label this descriptors type.
598///
599const char *AnchorDesc::getTypeString() const {
600  return "llvm.dbg.anchor.type";
601}
602
603#ifndef NDEBUG
604void AnchorDesc::dump() {
605  cerr << getDescString() << " "
606       << "Version(" << getVersion() << "), "
607       << "Tag(" << getTag() << "), "
608       << "AnchorTag(" << AnchorTag << ")\n";
609}
610#endif
611
612//===----------------------------------------------------------------------===//
613
614AnchoredDesc::AnchoredDesc(unsigned T)
615: DebugInfoDesc(T)
616, Anchor(NULL)
617{}
618
619/// ApplyToFields - Target the visitor to the fields of the AnchoredDesc.
620///
621void AnchoredDesc::ApplyToFields(DIVisitor *Visitor) {
622  DebugInfoDesc::ApplyToFields(Visitor);
623
624  Visitor->Apply(Anchor);
625}
626
627//===----------------------------------------------------------------------===//
628
629CompileUnitDesc::CompileUnitDesc()
630: AnchoredDesc(DW_TAG_compile_unit)
631, Language(0)
632, FileName("")
633, Directory("")
634, Producer("")
635{}
636
637// Implement isa/cast/dyncast.
638bool CompileUnitDesc::classof(const DebugInfoDesc *D) {
639  return D->getTag() == DW_TAG_compile_unit;
640}
641
642/// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc.
643///
644void CompileUnitDesc::ApplyToFields(DIVisitor *Visitor) {
645  AnchoredDesc::ApplyToFields(Visitor);
646
647  // Handle cases out of sync with compiler.
648  if (getVersion() == 0) {
649    unsigned DebugVersion;
650    Visitor->Apply(DebugVersion);
651  }
652
653  Visitor->Apply(Language);
654  Visitor->Apply(FileName);
655  Visitor->Apply(Directory);
656  Visitor->Apply(Producer);
657}
658
659/// getDescString - Return a string used to compose global names and labels.
660///
661const char *CompileUnitDesc::getDescString() const {
662  return "llvm.dbg.compile_unit";
663}
664
665/// getTypeString - Return a string used to label this descriptors type.
666///
667const char *CompileUnitDesc::getTypeString() const {
668  return "llvm.dbg.compile_unit.type";
669}
670
671/// getAnchorString - Return a string used to label this descriptor's anchor.
672///
673const char *CompileUnitDesc::AnchorString = "llvm.dbg.compile_units";
674const char *CompileUnitDesc::getAnchorString() const {
675  return AnchorString;
676}
677
678#ifndef NDEBUG
679void CompileUnitDesc::dump() {
680  cerr << getDescString() << " "
681       << "Version(" << getVersion() << "), "
682       << "Tag(" << getTag() << "), "
683       << "Anchor(" << getAnchor() << "), "
684       << "Language(" << Language << "), "
685       << "FileName(\"" << FileName << "\"), "
686       << "Directory(\"" << Directory << "\"), "
687       << "Producer(\"" << Producer << "\")\n";
688}
689#endif
690
691//===----------------------------------------------------------------------===//
692
693TypeDesc::TypeDesc(unsigned T)
694: DebugInfoDesc(T)
695, Context(NULL)
696, Name("")
697, File(NULL)
698, Line(0)
699, Size(0)
700, Align(0)
701, Offset(0)
702, Flags(0)
703{}
704
705/// ApplyToFields - Target the visitor to the fields of the TypeDesc.
706///
707void TypeDesc::ApplyToFields(DIVisitor *Visitor) {
708  DebugInfoDesc::ApplyToFields(Visitor);
709
710  Visitor->Apply(Context);
711  Visitor->Apply(Name);
712  Visitor->Apply(File);
713  Visitor->Apply(Line);
714  Visitor->Apply(Size);
715  Visitor->Apply(Align);
716  Visitor->Apply(Offset);
717  if (getVersion() > LLVMDebugVersion4) Visitor->Apply(Flags);
718}
719
720/// getDescString - Return a string used to compose global names and labels.
721///
722const char *TypeDesc::getDescString() const {
723  return "llvm.dbg.type";
724}
725
726/// getTypeString - Return a string used to label this descriptor's type.
727///
728const char *TypeDesc::getTypeString() const {
729  return "llvm.dbg.type.type";
730}
731
732#ifndef NDEBUG
733void TypeDesc::dump() {
734  cerr << getDescString() << " "
735       << "Version(" << getVersion() << "), "
736       << "Tag(" << getTag() << "), "
737       << "Context(" << Context << "), "
738       << "Name(\"" << Name << "\"), "
739       << "File(" << File << "), "
740       << "Line(" << Line << "), "
741       << "Size(" << Size << "), "
742       << "Align(" << Align << "), "
743       << "Offset(" << Offset << "), "
744       << "Flags(" << Flags << ")\n";
745}
746#endif
747
748//===----------------------------------------------------------------------===//
749
750BasicTypeDesc::BasicTypeDesc()
751: TypeDesc(DW_TAG_base_type)
752, Encoding(0)
753{}
754
755// Implement isa/cast/dyncast.
756bool BasicTypeDesc::classof(const DebugInfoDesc *D) {
757  return D->getTag() == DW_TAG_base_type;
758}
759
760/// ApplyToFields - Target the visitor to the fields of the BasicTypeDesc.
761///
762void BasicTypeDesc::ApplyToFields(DIVisitor *Visitor) {
763  TypeDesc::ApplyToFields(Visitor);
764
765  Visitor->Apply(Encoding);
766}
767
768/// getDescString - Return a string used to compose global names and labels.
769///
770const char *BasicTypeDesc::getDescString() const {
771  return "llvm.dbg.basictype";
772}
773
774/// getTypeString - Return a string used to label this descriptor's type.
775///
776const char *BasicTypeDesc::getTypeString() const {
777  return "llvm.dbg.basictype.type";
778}
779
780#ifndef NDEBUG
781void BasicTypeDesc::dump() {
782  cerr << getDescString() << " "
783       << "Version(" << getVersion() << "), "
784       << "Tag(" << getTag() << "), "
785       << "Context(" << getContext() << "), "
786       << "Name(\"" << getName() << "\"), "
787       << "Size(" << getSize() << "), "
788       << "Encoding(" << Encoding << ")\n";
789}
790#endif
791
792//===----------------------------------------------------------------------===//
793
794DerivedTypeDesc::DerivedTypeDesc(unsigned T)
795: TypeDesc(T)
796, FromType(NULL)
797{}
798
799// Implement isa/cast/dyncast.
800bool DerivedTypeDesc::classof(const DebugInfoDesc *D) {
801  unsigned T =  D->getTag();
802  switch (T) {
803  case DW_TAG_typedef:
804  case DW_TAG_pointer_type:
805  case DW_TAG_reference_type:
806  case DW_TAG_const_type:
807  case DW_TAG_volatile_type:
808  case DW_TAG_restrict_type:
809  case DW_TAG_member:
810  case DW_TAG_inheritance:
811    return true;
812  default: break;
813  }
814  return false;
815}
816
817/// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc.
818///
819void DerivedTypeDesc::ApplyToFields(DIVisitor *Visitor) {
820  TypeDesc::ApplyToFields(Visitor);
821
822  Visitor->Apply(FromType);
823}
824
825/// getDescString - Return a string used to compose global names and labels.
826///
827const char *DerivedTypeDesc::getDescString() const {
828  return "llvm.dbg.derivedtype";
829}
830
831/// getTypeString - Return a string used to label this descriptor's type.
832///
833const char *DerivedTypeDesc::getTypeString() const {
834  return "llvm.dbg.derivedtype.type";
835}
836
837#ifndef NDEBUG
838void DerivedTypeDesc::dump() {
839  cerr << getDescString() << " "
840       << "Version(" << getVersion() << "), "
841       << "Tag(" << getTag() << "), "
842       << "Context(" << getContext() << "), "
843       << "Name(\"" << getName() << "\"), "
844       << "Size(" << getSize() << "), "
845       << "File(" << getFile() << "), "
846       << "Line(" << getLine() << "), "
847       << "FromType(" << FromType << ")\n";
848}
849#endif
850
851//===----------------------------------------------------------------------===//
852
853CompositeTypeDesc::CompositeTypeDesc(unsigned T)
854: DerivedTypeDesc(T)
855, Elements()
856{}
857
858// Implement isa/cast/dyncast.
859bool CompositeTypeDesc::classof(const DebugInfoDesc *D) {
860  unsigned T =  D->getTag();
861  switch (T) {
862  case DW_TAG_array_type:
863  case DW_TAG_structure_type:
864  case DW_TAG_union_type:
865  case DW_TAG_enumeration_type:
866  case DW_TAG_vector_type:
867  case DW_TAG_subroutine_type:
868    return true;
869  default: break;
870  }
871  return false;
872}
873
874/// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc.
875///
876void CompositeTypeDesc::ApplyToFields(DIVisitor *Visitor) {
877  DerivedTypeDesc::ApplyToFields(Visitor);
878
879  Visitor->Apply(Elements);
880}
881
882/// getDescString - Return a string used to compose global names and labels.
883///
884const char *CompositeTypeDesc::getDescString() const {
885  return "llvm.dbg.compositetype";
886}
887
888/// getTypeString - Return a string used to label this descriptor's type.
889///
890const char *CompositeTypeDesc::getTypeString() const {
891  return "llvm.dbg.compositetype.type";
892}
893
894#ifndef NDEBUG
895void CompositeTypeDesc::dump() {
896  cerr << getDescString() << " "
897       << "Version(" << getVersion() << "), "
898       << "Tag(" << getTag() << "), "
899       << "Context(" << getContext() << "), "
900       << "Name(\"" << getName() << "\"), "
901       << "Size(" << getSize() << "), "
902       << "File(" << getFile() << "), "
903       << "Line(" << getLine() << "), "
904       << "FromType(" << getFromType() << "), "
905       << "Elements.size(" << Elements.size() << ")\n";
906}
907#endif
908
909//===----------------------------------------------------------------------===//
910
911SubrangeDesc::SubrangeDesc()
912: DebugInfoDesc(DW_TAG_subrange_type)
913, Lo(0)
914, Hi(0)
915{}
916
917// Implement isa/cast/dyncast.
918bool SubrangeDesc::classof(const DebugInfoDesc *D) {
919  return D->getTag() == DW_TAG_subrange_type;
920}
921
922/// ApplyToFields - Target the visitor to the fields of the SubrangeDesc.
923///
924void SubrangeDesc::ApplyToFields(DIVisitor *Visitor) {
925  DebugInfoDesc::ApplyToFields(Visitor);
926
927  Visitor->Apply(Lo);
928  Visitor->Apply(Hi);
929}
930
931/// getDescString - Return a string used to compose global names and labels.
932///
933const char *SubrangeDesc::getDescString() const {
934  return "llvm.dbg.subrange";
935}
936
937/// getTypeString - Return a string used to label this descriptor's type.
938///
939const char *SubrangeDesc::getTypeString() const {
940  return "llvm.dbg.subrange.type";
941}
942
943#ifndef NDEBUG
944void SubrangeDesc::dump() {
945  cerr << getDescString() << " "
946       << "Version(" << getVersion() << "), "
947       << "Tag(" << getTag() << "), "
948       << "Lo(" << Lo << "), "
949       << "Hi(" << Hi << ")\n";
950}
951#endif
952
953//===----------------------------------------------------------------------===//
954
955EnumeratorDesc::EnumeratorDesc()
956: DebugInfoDesc(DW_TAG_enumerator)
957, Name("")
958, Value(0)
959{}
960
961// Implement isa/cast/dyncast.
962bool EnumeratorDesc::classof(const DebugInfoDesc *D) {
963  return D->getTag() == DW_TAG_enumerator;
964}
965
966/// ApplyToFields - Target the visitor to the fields of the EnumeratorDesc.
967///
968void EnumeratorDesc::ApplyToFields(DIVisitor *Visitor) {
969  DebugInfoDesc::ApplyToFields(Visitor);
970
971  Visitor->Apply(Name);
972  Visitor->Apply(Value);
973}
974
975/// getDescString - Return a string used to compose global names and labels.
976///
977const char *EnumeratorDesc::getDescString() const {
978  return "llvm.dbg.enumerator";
979}
980
981/// getTypeString - Return a string used to label this descriptor's type.
982///
983const char *EnumeratorDesc::getTypeString() const {
984  return "llvm.dbg.enumerator.type";
985}
986
987#ifndef NDEBUG
988void EnumeratorDesc::dump() {
989  cerr << getDescString() << " "
990       << "Version(" << getVersion() << "), "
991       << "Tag(" << getTag() << "), "
992       << "Name(" << Name << "), "
993       << "Value(" << Value << ")\n";
994}
995#endif
996
997//===----------------------------------------------------------------------===//
998
999VariableDesc::VariableDesc(unsigned T)
1000: DebugInfoDesc(T)
1001, Context(NULL)
1002, Name("")
1003, File(NULL)
1004, Line(0)
1005, TyDesc(0)
1006{}
1007
1008// Implement isa/cast/dyncast.
1009bool VariableDesc::classof(const DebugInfoDesc *D) {
1010  unsigned T =  D->getTag();
1011  switch (T) {
1012  case DW_TAG_auto_variable:
1013  case DW_TAG_arg_variable:
1014  case DW_TAG_return_variable:
1015    return true;
1016  default: break;
1017  }
1018  return false;
1019}
1020
1021/// ApplyToFields - Target the visitor to the fields of the VariableDesc.
1022///
1023void VariableDesc::ApplyToFields(DIVisitor *Visitor) {
1024  DebugInfoDesc::ApplyToFields(Visitor);
1025
1026  Visitor->Apply(Context);
1027  Visitor->Apply(Name);
1028  Visitor->Apply(File);
1029  Visitor->Apply(Line);
1030  Visitor->Apply(TyDesc);
1031}
1032
1033/// getDescString - Return a string used to compose global names and labels.
1034///
1035const char *VariableDesc::getDescString() const {
1036  return "llvm.dbg.variable";
1037}
1038
1039/// getTypeString - Return a string used to label this descriptor's type.
1040///
1041const char *VariableDesc::getTypeString() const {
1042  return "llvm.dbg.variable.type";
1043}
1044
1045#ifndef NDEBUG
1046void VariableDesc::dump() {
1047  cerr << getDescString() << " "
1048       << "Version(" << getVersion() << "), "
1049       << "Tag(" << getTag() << "), "
1050       << "Context(" << Context << "), "
1051       << "Name(\"" << Name << "\"), "
1052       << "File(" << File << "), "
1053       << "Line(" << Line << "), "
1054       << "TyDesc(" << TyDesc << ")\n";
1055}
1056#endif
1057
1058//===----------------------------------------------------------------------===//
1059
1060GlobalDesc::GlobalDesc(unsigned T)
1061: AnchoredDesc(T)
1062, Context(0)
1063, Name("")
1064, FullName("")
1065, LinkageName("")
1066, File(NULL)
1067, Line(0)
1068, TyDesc(NULL)
1069, IsStatic(false)
1070, IsDefinition(false)
1071{}
1072
1073/// ApplyToFields - Target the visitor to the fields of the global.
1074///
1075void GlobalDesc::ApplyToFields(DIVisitor *Visitor) {
1076  AnchoredDesc::ApplyToFields(Visitor);
1077
1078  Visitor->Apply(Context);
1079  Visitor->Apply(Name);
1080  Visitor->Apply(FullName);
1081  Visitor->Apply(LinkageName);
1082  Visitor->Apply(File);
1083  Visitor->Apply(Line);
1084  Visitor->Apply(TyDesc);
1085  Visitor->Apply(IsStatic);
1086  Visitor->Apply(IsDefinition);
1087}
1088
1089//===----------------------------------------------------------------------===//
1090
1091GlobalVariableDesc::GlobalVariableDesc()
1092: GlobalDesc(DW_TAG_variable)
1093, Global(NULL)
1094{}
1095
1096// Implement isa/cast/dyncast.
1097bool GlobalVariableDesc::classof(const DebugInfoDesc *D) {
1098  return D->getTag() == DW_TAG_variable;
1099}
1100
1101/// ApplyToFields - Target the visitor to the fields of the GlobalVariableDesc.
1102///
1103void GlobalVariableDesc::ApplyToFields(DIVisitor *Visitor) {
1104  GlobalDesc::ApplyToFields(Visitor);
1105
1106  Visitor->Apply(Global);
1107}
1108
1109/// getDescString - Return a string used to compose global names and labels.
1110///
1111const char *GlobalVariableDesc::getDescString() const {
1112  return "llvm.dbg.global_variable";
1113}
1114
1115/// getTypeString - Return a string used to label this descriptors type.
1116///
1117const char *GlobalVariableDesc::getTypeString() const {
1118  return "llvm.dbg.global_variable.type";
1119}
1120
1121/// getAnchorString - Return a string used to label this descriptor's anchor.
1122///
1123const char *GlobalVariableDesc::AnchorString = "llvm.dbg.global_variables";
1124const char *GlobalVariableDesc::getAnchorString() const {
1125  return AnchorString;
1126}
1127
1128#ifndef NDEBUG
1129void GlobalVariableDesc::dump() {
1130  cerr << getDescString() << " "
1131       << "Version(" << getVersion() << "), "
1132       << "Tag(" << getTag() << "), "
1133       << "Anchor(" << getAnchor() << "), "
1134       << "Name(\"" << getName() << "\"), "
1135       << "FullName(\"" << getFullName() << "\"), "
1136       << "LinkageName(\"" << getLinkageName() << "\"), "
1137       << "File(" << getFile() << "),"
1138       << "Line(" << getLine() << "),"
1139       << "Type(" << getType() << "), "
1140       << "IsStatic(" << (isStatic() ? "true" : "false") << "), "
1141       << "IsDefinition(" << (isDefinition() ? "true" : "false") << "), "
1142       << "Global(" << Global << ")\n";
1143}
1144#endif
1145
1146//===----------------------------------------------------------------------===//
1147
1148SubprogramDesc::SubprogramDesc()
1149: GlobalDesc(DW_TAG_subprogram)
1150{}
1151
1152// Implement isa/cast/dyncast.
1153bool SubprogramDesc::classof(const DebugInfoDesc *D) {
1154  return D->getTag() == DW_TAG_subprogram;
1155}
1156
1157/// ApplyToFields - Target the visitor to the fields of the
1158/// SubprogramDesc.
1159void SubprogramDesc::ApplyToFields(DIVisitor *Visitor) {
1160  GlobalDesc::ApplyToFields(Visitor);
1161}
1162
1163/// getDescString - Return a string used to compose global names and labels.
1164///
1165const char *SubprogramDesc::getDescString() const {
1166  return "llvm.dbg.subprogram";
1167}
1168
1169/// getTypeString - Return a string used to label this descriptors type.
1170///
1171const char *SubprogramDesc::getTypeString() const {
1172  return "llvm.dbg.subprogram.type";
1173}
1174
1175/// getAnchorString - Return a string used to label this descriptor's anchor.
1176///
1177const char *SubprogramDesc::AnchorString = "llvm.dbg.subprograms";
1178const char *SubprogramDesc::getAnchorString() const {
1179  return AnchorString;
1180}
1181
1182#ifndef NDEBUG
1183void SubprogramDesc::dump() {
1184  cerr << getDescString() << " "
1185       << "Version(" << getVersion() << "), "
1186       << "Tag(" << getTag() << "), "
1187       << "Anchor(" << getAnchor() << "), "
1188       << "Name(\"" << getName() << "\"), "
1189       << "FullName(\"" << getFullName() << "\"), "
1190       << "LinkageName(\"" << getLinkageName() << "\"), "
1191       << "File(" << getFile() << "),"
1192       << "Line(" << getLine() << "),"
1193       << "Type(" << getType() << "), "
1194       << "IsStatic(" << (isStatic() ? "true" : "false") << "), "
1195       << "IsDefinition(" << (isDefinition() ? "true" : "false") << ")\n";
1196}
1197#endif
1198
1199//===----------------------------------------------------------------------===//
1200
1201BlockDesc::BlockDesc()
1202: DebugInfoDesc(DW_TAG_lexical_block)
1203, Context(NULL)
1204{}
1205
1206// Implement isa/cast/dyncast.
1207bool BlockDesc::classof(const DebugInfoDesc *D) {
1208  return D->getTag() == DW_TAG_lexical_block;
1209}
1210
1211/// ApplyToFields - Target the visitor to the fields of the BlockDesc.
1212///
1213void BlockDesc::ApplyToFields(DIVisitor *Visitor) {
1214  DebugInfoDesc::ApplyToFields(Visitor);
1215
1216  Visitor->Apply(Context);
1217}
1218
1219/// getDescString - Return a string used to compose global names and labels.
1220///
1221const char *BlockDesc::getDescString() const {
1222  return "llvm.dbg.block";
1223}
1224
1225/// getTypeString - Return a string used to label this descriptors type.
1226///
1227const char *BlockDesc::getTypeString() const {
1228  return "llvm.dbg.block.type";
1229}
1230
1231#ifndef NDEBUG
1232void BlockDesc::dump() {
1233  cerr << getDescString() << " "
1234       << "Version(" << getVersion() << "), "
1235       << "Tag(" << getTag() << "),"
1236       << "Context(" << Context << ")\n";
1237}
1238#endif
1239
1240//===----------------------------------------------------------------------===//
1241
1242DebugInfoDesc *DIDeserializer::Deserialize(Value *V) {
1243  return Deserialize(getGlobalVariable(V));
1244}
1245DebugInfoDesc *DIDeserializer::Deserialize(GlobalVariable *GV) {
1246  // Handle NULL.
1247  if (!GV) return NULL;
1248
1249  // Check to see if it has been already deserialized.
1250  DebugInfoDesc *&Slot = GlobalDescs[GV];
1251  if (Slot) return Slot;
1252
1253  // Get the Tag from the global.
1254  unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
1255
1256  // Create an empty instance of the correct sort.
1257  Slot = DebugInfoDesc::DescFactory(Tag);
1258
1259  // If not a user defined descriptor.
1260  if (Slot) {
1261    // Deserialize the fields.
1262    DIDeserializeVisitor DRAM(*this, GV);
1263    DRAM.ApplyToFields(Slot);
1264  }
1265
1266  return Slot;
1267}
1268
1269//===----------------------------------------------------------------------===//
1270
1271/// getStrPtrType - Return a "sbyte *" type.
1272///
1273const PointerType *DISerializer::getStrPtrType() {
1274  // If not already defined.
1275  if (!StrPtrTy) {
1276    // Construct the pointer to signed bytes.
1277    StrPtrTy = PointerType::getUnqual(Type::Int8Ty);
1278  }
1279
1280  return StrPtrTy;
1281}
1282
1283/// getEmptyStructPtrType - Return a "{ }*" type.
1284///
1285const PointerType *DISerializer::getEmptyStructPtrType() {
1286  // If not already defined.
1287  if (!EmptyStructPtrTy) {
1288    // Construct the empty structure type.
1289    const StructType *EmptyStructTy =
1290                                    StructType::get(std::vector<const Type*>());
1291    // Construct the pointer to empty structure type.
1292    EmptyStructPtrTy = PointerType::getUnqual(EmptyStructTy);
1293  }
1294
1295  return EmptyStructPtrTy;
1296}
1297
1298/// getTagType - Return the type describing the specified descriptor (via tag.)
1299///
1300const StructType *DISerializer::getTagType(DebugInfoDesc *DD) {
1301  // Attempt to get the previously defined type.
1302  StructType *&Ty = TagTypes[DD->getTag()];
1303
1304  // If not already defined.
1305  if (!Ty) {
1306    // Set up fields vector.
1307    std::vector<const Type*> Fields;
1308    // Get types of fields.
1309    DIGetTypesVisitor GTAM(*this, Fields);
1310    GTAM.ApplyToFields(DD);
1311
1312    // Construct structured type.
1313    Ty = StructType::get(Fields);
1314
1315    // Register type name with module.
1316    M->addTypeName(DD->getTypeString(), Ty);
1317  }
1318
1319  return Ty;
1320}
1321
1322/// getString - Construct the string as constant string global.
1323///
1324Constant *DISerializer::getString(const std::string &String) {
1325  // Check string cache for previous edition.
1326  Constant *&Slot = StringCache[String];
1327  // Return Constant if previously defined.
1328  if (Slot) return Slot;
1329  // If empty string then use a sbyte* null instead.
1330  if (String.empty()) {
1331    Slot = ConstantPointerNull::get(getStrPtrType());
1332  } else {
1333    // Construct string as an llvm constant.
1334    Constant *ConstStr = ConstantArray::get(String);
1335    // Otherwise create and return a new string global.
1336    GlobalVariable *StrGV = new GlobalVariable(ConstStr->getType(), true,
1337                                               GlobalVariable::InternalLinkage,
1338                                               ConstStr, ".str", M);
1339    StrGV->setSection("llvm.metadata");
1340    // Convert to generic string pointer.
1341    Slot = ConstantExpr::getBitCast(StrGV, getStrPtrType());
1342  }
1343  return Slot;
1344
1345}
1346
1347/// Serialize - Recursively cast the specified descriptor into a GlobalVariable
1348/// so that it can be serialized to a .bc or .ll file.
1349GlobalVariable *DISerializer::Serialize(DebugInfoDesc *DD) {
1350  // Check if the DebugInfoDesc is already in the map.
1351  GlobalVariable *&Slot = DescGlobals[DD];
1352
1353  // See if DebugInfoDesc exists, if so return prior GlobalVariable.
1354  if (Slot) return Slot;
1355
1356  // Get the type associated with the Tag.
1357  const StructType *Ty = getTagType(DD);
1358
1359  // Create the GlobalVariable early to prevent infinite recursion.
1360  GlobalVariable *GV = new GlobalVariable(Ty, true, DD->getLinkage(),
1361                                          NULL, DD->getDescString(), M);
1362  GV->setSection("llvm.metadata");
1363
1364  // Insert new GlobalVariable in DescGlobals map.
1365  Slot = GV;
1366
1367  // Set up elements vector
1368  std::vector<Constant*> Elements;
1369  // Add fields.
1370  DISerializeVisitor SRAM(*this, Elements);
1371  SRAM.ApplyToFields(DD);
1372
1373  // Set the globals initializer.
1374  GV->setInitializer(ConstantStruct::get(Ty, Elements));
1375
1376  return GV;
1377}
1378
1379/// addDescriptor - Directly connect DD with existing GV.
1380void DISerializer::addDescriptor(DebugInfoDesc *DD,
1381                                 GlobalVariable *GV) {
1382  DescGlobals[DD] = GV;
1383}
1384
1385//===----------------------------------------------------------------------===//
1386
1387/// Verify - Return true if the GlobalVariable appears to be a valid
1388/// serialization of a DebugInfoDesc.
1389bool DIVerifier::Verify(Value *V) {
1390  return !V || Verify(getGlobalVariable(V));
1391}
1392bool DIVerifier::Verify(GlobalVariable *GV) {
1393  // NULLs are valid.
1394  if (!GV) return true;
1395
1396  // Check prior validity.
1397  unsigned &ValiditySlot = Validity[GV];
1398
1399  // If visited before then use old state.
1400  if (ValiditySlot) return ValiditySlot == Valid;
1401
1402  // Assume validity for the time being (recursion.)
1403  ValiditySlot = Valid;
1404
1405  // Make sure the global is internal or link once (anchor.)
1406  if (GV->getLinkage() != GlobalValue::InternalLinkage &&
1407      GV->getLinkage() != GlobalValue::LinkOnceLinkage) {
1408    ValiditySlot = Invalid;
1409    return false;
1410  }
1411
1412  // Get the Tag.
1413  unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
1414
1415  // Check for user defined descriptors.
1416  if (Tag == DW_TAG_invalid) {
1417    ValiditySlot = Valid;
1418    return true;
1419  }
1420
1421  // Get the Version.
1422  unsigned Version = DebugInfoDesc::VersionFromGlobal(GV);
1423
1424  // Check for version mismatch.
1425  if (Version != LLVMDebugVersion) {
1426    ValiditySlot = Invalid;
1427    return false;
1428  }
1429
1430  // Construct an empty DebugInfoDesc.
1431  DebugInfoDesc *DD = DebugInfoDesc::DescFactory(Tag);
1432
1433  // Allow for user defined descriptors.
1434  if (!DD) return true;
1435
1436  // Get the initializer constant.
1437  ConstantStruct *CI = cast<ConstantStruct>(GV->getInitializer());
1438
1439  // Get the operand count.
1440  unsigned N = CI->getNumOperands();
1441
1442  // Get the field count.
1443  unsigned &CountSlot = Counts[Tag];
1444  if (!CountSlot) {
1445    // Check the operand count to the field count
1446    DICountVisitor CTAM;
1447    CTAM.ApplyToFields(DD);
1448    CountSlot = CTAM.getCount();
1449  }
1450
1451  // Field count must be at most equal operand count.
1452  if (CountSlot >  N) {
1453    delete DD;
1454    ValiditySlot = Invalid;
1455    return false;
1456  }
1457
1458  // Check each field for valid type.
1459  DIVerifyVisitor VRAM(*this, GV);
1460  VRAM.ApplyToFields(DD);
1461
1462  // Release empty DebugInfoDesc.
1463  delete DD;
1464
1465  // If fields are not valid.
1466  if (!VRAM.isValid()) {
1467    ValiditySlot = Invalid;
1468    return false;
1469  }
1470
1471  return true;
1472}
1473
1474/// isVerified - Return true if the specified GV has already been
1475/// verified as a debug information descriptor.
1476bool DIVerifier::isVerified(GlobalVariable *GV) {
1477  unsigned &ValiditySlot = Validity[GV];
1478  if (ValiditySlot) return ValiditySlot == Valid;
1479  return false;
1480}
1481
1482//===----------------------------------------------------------------------===//
1483
1484DebugScope::~DebugScope() {
1485  for (unsigned i = 0, N = Scopes.size(); i < N; ++i) delete Scopes[i];
1486  for (unsigned j = 0, M = Variables.size(); j < M; ++j) delete Variables[j];
1487}
1488
1489//===----------------------------------------------------------------------===//
1490
1491MachineModuleInfo::MachineModuleInfo()
1492: ImmutablePass((intptr_t)&ID)
1493, DR()
1494, VR()
1495, CompileUnits()
1496, Directories()
1497, SourceFiles()
1498, Lines()
1499, LabelIDList()
1500, ScopeMap()
1501, RootScope(NULL)
1502, FrameMoves()
1503, LandingPads()
1504, Personalities()
1505, CallsEHReturn(0)
1506, CallsUnwindInit(0)
1507{
1508  // Always emit "no personality" info
1509  Personalities.push_back(NULL);
1510}
1511MachineModuleInfo::~MachineModuleInfo() {
1512
1513}
1514
1515/// doInitialization - Initialize the state for a new module.
1516///
1517bool MachineModuleInfo::doInitialization() {
1518  return false;
1519}
1520
1521/// doFinalization - Tear down the state after completion of a module.
1522///
1523bool MachineModuleInfo::doFinalization() {
1524  return false;
1525}
1526
1527/// BeginFunction - Begin gathering function meta information.
1528///
1529void MachineModuleInfo::BeginFunction(MachineFunction *MF) {
1530  // Coming soon.
1531}
1532
1533/// EndFunction - Discard function meta information.
1534///
1535void MachineModuleInfo::EndFunction() {
1536  // Clean up scope information.
1537  if (RootScope) {
1538    delete RootScope;
1539    ScopeMap.clear();
1540    RootScope = NULL;
1541  }
1542
1543  // Clean up line info.
1544  Lines.clear();
1545
1546  // Clean up frame info.
1547  FrameMoves.clear();
1548
1549  // Clean up exception info.
1550  LandingPads.clear();
1551  TypeInfos.clear();
1552  FilterIds.clear();
1553  FilterEnds.clear();
1554  CallsEHReturn = 0;
1555  CallsUnwindInit = 0;
1556}
1557
1558/// getDescFor - Convert a Value to a debug information descriptor.
1559///
1560// FIXME - use new Value type when available.
1561DebugInfoDesc *MachineModuleInfo::getDescFor(Value *V) {
1562  return DR.Deserialize(V);
1563}
1564
1565/// AnalyzeModule - Scan the module for global debug information.
1566///
1567void MachineModuleInfo::AnalyzeModule(Module &M) {
1568  SetupCompileUnits(M);
1569
1570  // Insert functions in the llvm.used array into UsedFunctions.
1571  GlobalVariable *GV = M.getGlobalVariable("llvm.used");
1572  if (!GV || !GV->hasInitializer()) return;
1573
1574  // Should be an array of 'i8*'.
1575  ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
1576  if (InitList == 0) return;
1577
1578  for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
1579    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(InitList->getOperand(i)))
1580      if (CE->getOpcode() == Instruction::BitCast)
1581        if (Function *F = dyn_cast<Function>(CE->getOperand(0)))
1582          UsedFunctions.insert(F);
1583  }
1584}
1585
1586/// needsFrameInfo - Returns true if we need to gather callee-saved register
1587/// move info for the frame.
1588bool MachineModuleInfo::needsFrameInfo() const {
1589  return hasDebugInfo() || ExceptionHandling;
1590}
1591
1592/// SetupCompileUnits - Set up the unique vector of compile units.
1593///
1594void MachineModuleInfo::SetupCompileUnits(Module &M) {
1595  std::vector<CompileUnitDesc *>CU = getAnchoredDescriptors<CompileUnitDesc>(M);
1596
1597  for (unsigned i = 0, N = CU.size(); i < N; i++) {
1598    CompileUnits.insert(CU[i]);
1599  }
1600}
1601
1602/// getCompileUnits - Return a vector of debug compile units.
1603///
1604const UniqueVector<CompileUnitDesc *> MachineModuleInfo::getCompileUnits()const{
1605  return CompileUnits;
1606}
1607
1608/// getGlobalVariablesUsing - Return all of the GlobalVariables that use the
1609/// named GlobalVariable.
1610std::vector<GlobalVariable*>
1611MachineModuleInfo::getGlobalVariablesUsing(Module &M,
1612                                           const std::string &RootName) {
1613  return ::getGlobalVariablesUsing(M, RootName);
1614}
1615
1616/// RecordSourceLine - Records location information and associates it with a
1617/// debug label.  Returns a unique label ID used to generate a label and
1618/// provide correspondence to the source line list.
1619unsigned MachineModuleInfo::RecordSourceLine(unsigned Line, unsigned Column,
1620                                             unsigned Source) {
1621  unsigned ID = NextLabelID();
1622  Lines.push_back(SourceLineInfo(Line, Column, Source, ID));
1623  return ID;
1624}
1625
1626/// RecordSource - Register a source file with debug info. Returns an source
1627/// ID.
1628unsigned MachineModuleInfo::RecordSource(const std::string &Directory,
1629                                         const std::string &Source) {
1630  unsigned DirectoryID = Directories.insert(Directory);
1631  return SourceFiles.insert(SourceFileInfo(DirectoryID, Source));
1632}
1633unsigned MachineModuleInfo::RecordSource(const CompileUnitDesc *CompileUnit) {
1634  return RecordSource(CompileUnit->getDirectory(),
1635                      CompileUnit->getFileName());
1636}
1637
1638/// RecordRegionStart - Indicate the start of a region.
1639///
1640unsigned MachineModuleInfo::RecordRegionStart(Value *V) {
1641  // FIXME - need to be able to handle split scopes because of bb cloning.
1642  DebugInfoDesc *ScopeDesc = DR.Deserialize(V);
1643  DebugScope *Scope = getOrCreateScope(ScopeDesc);
1644  unsigned ID = NextLabelID();
1645  if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID);
1646  return ID;
1647}
1648
1649/// RecordRegionEnd - Indicate the end of a region.
1650///
1651unsigned MachineModuleInfo::RecordRegionEnd(Value *V) {
1652  // FIXME - need to be able to handle split scopes because of bb cloning.
1653  DebugInfoDesc *ScopeDesc = DR.Deserialize(V);
1654  DebugScope *Scope = getOrCreateScope(ScopeDesc);
1655  unsigned ID = NextLabelID();
1656  Scope->setEndLabelID(ID);
1657  return ID;
1658}
1659
1660/// RecordVariable - Indicate the declaration of  a local variable.
1661///
1662void MachineModuleInfo::RecordVariable(GlobalValue *GV, unsigned FrameIndex) {
1663  VariableDesc *VD = cast<VariableDesc>(DR.Deserialize(GV));
1664  DebugScope *Scope = getOrCreateScope(VD->getContext());
1665  DebugVariable *DV = new DebugVariable(VD, FrameIndex);
1666  Scope->AddVariable(DV);
1667}
1668
1669/// getOrCreateScope - Returns the scope associated with the given descriptor.
1670///
1671DebugScope *MachineModuleInfo::getOrCreateScope(DebugInfoDesc *ScopeDesc) {
1672  DebugScope *&Slot = ScopeMap[ScopeDesc];
1673  if (!Slot) {
1674    // FIXME - breaks down when the context is an inlined function.
1675    DebugInfoDesc *ParentDesc = NULL;
1676    if (BlockDesc *Block = dyn_cast<BlockDesc>(ScopeDesc)) {
1677      ParentDesc = Block->getContext();
1678    }
1679    DebugScope *Parent = ParentDesc ? getOrCreateScope(ParentDesc) : NULL;
1680    Slot = new DebugScope(Parent, ScopeDesc);
1681    if (Parent) {
1682      Parent->AddScope(Slot);
1683    } else if (RootScope) {
1684      // FIXME - Add inlined function scopes to the root so we can delete
1685      // them later.  Long term, handle inlined functions properly.
1686      RootScope->AddScope(Slot);
1687    } else {
1688      // First function is top level function.
1689      RootScope = Slot;
1690    }
1691  }
1692  return Slot;
1693}
1694
1695//===-EH-------------------------------------------------------------------===//
1696
1697/// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the
1698/// specified MachineBasicBlock.
1699LandingPadInfo &MachineModuleInfo::getOrCreateLandingPadInfo
1700    (MachineBasicBlock *LandingPad) {
1701  unsigned N = LandingPads.size();
1702  for (unsigned i = 0; i < N; ++i) {
1703    LandingPadInfo &LP = LandingPads[i];
1704    if (LP.LandingPadBlock == LandingPad)
1705      return LP;
1706  }
1707
1708  LandingPads.push_back(LandingPadInfo(LandingPad));
1709  return LandingPads[N];
1710}
1711
1712/// addInvoke - Provide the begin and end labels of an invoke style call and
1713/// associate it with a try landing pad block.
1714void MachineModuleInfo::addInvoke(MachineBasicBlock *LandingPad,
1715                                  unsigned BeginLabel, unsigned EndLabel) {
1716  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1717  LP.BeginLabels.push_back(BeginLabel);
1718  LP.EndLabels.push_back(EndLabel);
1719}
1720
1721/// addLandingPad - Provide the label of a try LandingPad block.
1722///
1723unsigned MachineModuleInfo::addLandingPad(MachineBasicBlock *LandingPad) {
1724  unsigned LandingPadLabel = NextLabelID();
1725  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1726  LP.LandingPadLabel = LandingPadLabel;
1727  return LandingPadLabel;
1728}
1729
1730/// addPersonality - Provide the personality function for the exception
1731/// information.
1732void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad,
1733                                       Function *Personality) {
1734  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1735  LP.Personality = Personality;
1736
1737  for (unsigned i = 0; i < Personalities.size(); ++i)
1738    if (Personalities[i] == Personality)
1739      return;
1740
1741  Personalities.push_back(Personality);
1742}
1743
1744/// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
1745///
1746void MachineModuleInfo::addCatchTypeInfo(MachineBasicBlock *LandingPad,
1747                                        std::vector<GlobalVariable *> &TyInfo) {
1748  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1749  for (unsigned N = TyInfo.size(); N; --N)
1750    LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
1751}
1752
1753/// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
1754///
1755void MachineModuleInfo::addFilterTypeInfo(MachineBasicBlock *LandingPad,
1756                                        std::vector<GlobalVariable *> &TyInfo) {
1757  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1758  std::vector<unsigned> IdsInFilter (TyInfo.size());
1759  for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
1760    IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
1761  LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
1762}
1763
1764/// addCleanup - Add a cleanup action for a landing pad.
1765///
1766void MachineModuleInfo::addCleanup(MachineBasicBlock *LandingPad) {
1767  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1768  LP.TypeIds.push_back(0);
1769}
1770
1771/// TidyLandingPads - Remap landing pad labels and remove any deleted landing
1772/// pads.
1773void MachineModuleInfo::TidyLandingPads() {
1774  for (unsigned i = 0; i != LandingPads.size(); ) {
1775    LandingPadInfo &LandingPad = LandingPads[i];
1776    LandingPad.LandingPadLabel = MappedLabel(LandingPad.LandingPadLabel);
1777
1778    // Special case: we *should* emit LPs with null LP MBB. This indicates
1779    // "nounwind" case.
1780    if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
1781      LandingPads.erase(LandingPads.begin() + i);
1782      continue;
1783    }
1784
1785    for (unsigned j=0; j != LandingPads[i].BeginLabels.size(); ) {
1786      unsigned BeginLabel = MappedLabel(LandingPad.BeginLabels[j]);
1787      unsigned EndLabel = MappedLabel(LandingPad.EndLabels[j]);
1788
1789      if (!BeginLabel || !EndLabel) {
1790        LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
1791        LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
1792        continue;
1793      }
1794
1795      LandingPad.BeginLabels[j] = BeginLabel;
1796      LandingPad.EndLabels[j] = EndLabel;
1797      ++j;
1798    }
1799
1800    // Remove landing pads with no try-ranges.
1801    if (LandingPads[i].BeginLabels.empty()) {
1802      LandingPads.erase(LandingPads.begin() + i);
1803      continue;
1804    }
1805
1806    // If there is no landing pad, ensure that the list of typeids is empty.
1807    // If the only typeid is a cleanup, this is the same as having no typeids.
1808    if (!LandingPad.LandingPadBlock ||
1809        (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
1810      LandingPad.TypeIds.clear();
1811
1812    ++i;
1813  }
1814}
1815
1816/// getTypeIDFor - Return the type id for the specified typeinfo.  This is
1817/// function wide.
1818unsigned MachineModuleInfo::getTypeIDFor(GlobalVariable *TI) {
1819  for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
1820    if (TypeInfos[i] == TI) return i + 1;
1821
1822  TypeInfos.push_back(TI);
1823  return TypeInfos.size();
1824}
1825
1826/// getFilterIDFor - Return the filter id for the specified typeinfos.  This is
1827/// function wide.
1828int MachineModuleInfo::getFilterIDFor(std::vector<unsigned> &TyIds) {
1829  // If the new filter coincides with the tail of an existing filter, then
1830  // re-use the existing filter.  Folding filters more than this requires
1831  // re-ordering filters and/or their elements - probably not worth it.
1832  for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
1833       E = FilterEnds.end(); I != E; ++I) {
1834    unsigned i = *I, j = TyIds.size();
1835
1836    while (i && j)
1837      if (FilterIds[--i] != TyIds[--j])
1838        goto try_next;
1839
1840    if (!j)
1841      // The new filter coincides with range [i, end) of the existing filter.
1842      return -(1 + i);
1843
1844try_next:;
1845  }
1846
1847  // Add the new filter.
1848  int FilterID = -(1 + FilterIds.size());
1849  FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
1850  for (unsigned I = 0, N = TyIds.size(); I != N; ++I)
1851    FilterIds.push_back(TyIds[I]);
1852  FilterEnds.push_back(FilterIds.size());
1853  FilterIds.push_back(0); // terminator
1854  return FilterID;
1855}
1856
1857/// getPersonality - Return the personality function for the current function.
1858Function *MachineModuleInfo::getPersonality() const {
1859  // FIXME: Until PR1414 will be fixed, we're using 1 personality function per
1860  // function
1861  return !LandingPads.empty() ? LandingPads[0].Personality : NULL;
1862}
1863
1864/// getPersonalityIndex - Return unique index for current personality
1865/// function. NULL personality function should always get zero index.
1866unsigned MachineModuleInfo::getPersonalityIndex() const {
1867  const Function* Personality = NULL;
1868
1869  // Scan landing pads. If there is at least one non-NULL personality - use it.
1870  for (unsigned i = 0; i != LandingPads.size(); ++i)
1871    if (LandingPads[i].Personality) {
1872      Personality = LandingPads[i].Personality;
1873      break;
1874    }
1875
1876  for (unsigned i = 0; i < Personalities.size(); ++i) {
1877    if (Personalities[i] == Personality)
1878      return i;
1879  }
1880
1881  // This should never happen
1882  assert(0 && "Personality function should be set!");
1883  return 0;
1884}
1885
1886//===----------------------------------------------------------------------===//
1887/// DebugLabelFolding pass - This pass prunes out redundant labels.  This allows
1888/// a info consumer to determine if the range of two labels is empty, by seeing
1889/// if the labels map to the same reduced label.
1890
1891namespace llvm {
1892
1893struct DebugLabelFolder : public MachineFunctionPass {
1894  static char ID;
1895  DebugLabelFolder() : MachineFunctionPass((intptr_t)&ID) {}
1896
1897  virtual bool runOnMachineFunction(MachineFunction &MF);
1898  virtual const char *getPassName() const { return "Label Folder"; }
1899};
1900
1901char DebugLabelFolder::ID = 0;
1902
1903bool DebugLabelFolder::runOnMachineFunction(MachineFunction &MF) {
1904  // Get machine module info.
1905  MachineModuleInfo *MMI = getAnalysisToUpdate<MachineModuleInfo>();
1906  if (!MMI) return false;
1907
1908  // Track if change is made.
1909  bool MadeChange = false;
1910  // No prior label to begin.
1911  unsigned PriorLabel = 0;
1912
1913  // Iterate through basic blocks.
1914  for (MachineFunction::iterator BB = MF.begin(), E = MF.end();
1915       BB != E; ++BB) {
1916    // Iterate through instructions.
1917    for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
1918      // Is it a label.
1919      if (I->isDebugLabel()) {
1920        // The label ID # is always operand #0, an immediate.
1921        unsigned NextLabel = I->getOperand(0).getImm();
1922
1923        // If there was an immediate prior label.
1924        if (PriorLabel) {
1925          // Remap the current label to prior label.
1926          MMI->RemapLabel(NextLabel, PriorLabel);
1927          // Delete the current label.
1928          I = BB->erase(I);
1929          // Indicate a change has been made.
1930          MadeChange = true;
1931          continue;
1932        } else {
1933          // Start a new round.
1934          PriorLabel = NextLabel;
1935        }
1936       } else {
1937        // No consecutive labels.
1938        PriorLabel = 0;
1939      }
1940
1941      ++I;
1942    }
1943  }
1944
1945  return MadeChange;
1946}
1947
1948FunctionPass *createDebugLabelFoldingPass() { return new DebugLabelFolder(); }
1949
1950}
1951
1952