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