Make sure only one copy of a filter is placed in the
[oota-llvm.git] / lib / CodeGen / MachineModuleInfo.cpp
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"
26 using namespace llvm;
27 using namespace llvm::dwarf;
28
29 // Handle the Pass registration stuff necessary to use TargetData's.
30 namespace {
31   RegisterPass<MachineModuleInfo> X("machinemoduleinfo", "Module Information");
32 }
33 char MachineModuleInfo::ID = 0;
34
35 //===----------------------------------------------------------------------===//
36
37 /// getGlobalVariablesUsing - Return all of the GlobalVariables which have the
38 /// specified value in their initializer somewhere.
39 static void
40 getGlobalVariablesUsing(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.
55 static std::vector<GlobalVariable*>
56 getGlobalVariablesUsing(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 ///
77 static 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 ///
101 static 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.
114 static 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 ///
127 static 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.
147 void 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.
154 class DICountVisitor : public DIVisitor {
155 private:
156   unsigned Count;                       // Running count of fields.
157   
158 public:
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.
182 class DIDeserializeVisitor : public DIVisitor {
183 private:
184   DIDeserializer &DR;                   // Active deserializer.
185   unsigned I;                           // Current operand index.
186   ConstantStruct *CI;                   // GlobalVariable constant initializer.
187
188 public:
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.
254 class DISerializeVisitor : public DIVisitor {
255 private:
256   DISerializer &SR;                     // Active serializer.
257   std::vector<Constant*> &Elements;     // Element accumulator.
258   
259 public:
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.
341 class DIGetTypesVisitor : public DIVisitor {
342 private:
343   DISerializer &SR;                     // Active serializer.
344   std::vector<const Type*> &Fields;     // Type accumulator.
345   
346 public:
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.
391 class DIVerifyVisitor : public DIVisitor {
392 private:
393   DIVerifier &VR;                       // Active verifier.
394   bool IsValid;                         // Validity status.
395   unsigned I;                           // Current operand index.
396   ConstantStruct *CI;                   // GlobalVariable constant initializer.
397   
398 public:
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. 
475 unsigned 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.
484 unsigned  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.
492 DebugInfoDesc *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 ///
526 GlobalValue::LinkageTypes DebugInfoDesc::getLinkage() const {
527   return GlobalValue::InternalLinkage;
528 }
529
530 /// ApplyToFields - Target the vistor to the fields of the descriptor.
531 ///
532 void DebugInfoDesc::ApplyToFields(DIVisitor *Visitor) {
533   Visitor->Apply(Tag);
534 }
535
536 //===----------------------------------------------------------------------===//
537
538 AnchorDesc::AnchorDesc()
539 : DebugInfoDesc(DW_TAG_anchor)
540 , AnchorTag(0)
541 {}
542 AnchorDesc::AnchorDesc(AnchoredDesc *D)
543 : DebugInfoDesc(DW_TAG_anchor)
544 , AnchorTag(D->getTag())
545 {}
546
547 // Implement isa/cast/dyncast.
548 bool 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 ///
554 GlobalValue::LinkageTypes AnchorDesc::getLinkage() const {
555   return GlobalValue::LinkOnceLinkage;
556 }
557
558 /// ApplyToFields - Target the visitor to the fields of the TransUnitDesc.
559 ///
560 void 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");
573 const 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 ///
587 const char *AnchorDesc::getTypeString() const {
588   return "llvm.dbg.anchor.type";
589 }
590
591 #ifndef NDEBUG
592 void AnchorDesc::dump() {
593   cerr << getDescString() << " "
594        << "Version(" << getVersion() << "), "
595        << "Tag(" << getTag() << "), "
596        << "AnchorTag(" << AnchorTag << ")\n";
597 }
598 #endif
599
600 //===----------------------------------------------------------------------===//
601
602 AnchoredDesc::AnchoredDesc(unsigned T)
603 : DebugInfoDesc(T)
604 , Anchor(NULL)
605 {}
606
607 /// ApplyToFields - Target the visitor to the fields of the AnchoredDesc.
608 ///
609 void AnchoredDesc::ApplyToFields(DIVisitor *Visitor) {
610   DebugInfoDesc::ApplyToFields(Visitor);
611
612   Visitor->Apply(Anchor);
613 }
614
615 //===----------------------------------------------------------------------===//
616
617 CompileUnitDesc::CompileUnitDesc()
618 : AnchoredDesc(DW_TAG_compile_unit)
619 , Language(0)
620 , FileName("")
621 , Directory("")
622 , Producer("")
623 {}
624
625 // Implement isa/cast/dyncast.
626 bool 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 ///
632 void 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 ///
649 const char *CompileUnitDesc::getDescString() const {
650   return "llvm.dbg.compile_unit";
651 }
652
653 /// getTypeString - Return a string used to label this descriptors type.
654 ///
655 const 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 ///
661 const char *CompileUnitDesc::AnchorString = "llvm.dbg.compile_units";
662 const char *CompileUnitDesc::getAnchorString() const {
663   return AnchorString;
664 }
665
666 #ifndef NDEBUG
667 void 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
681 TypeDesc::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 ///
695 void 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 ///
710 const char *TypeDesc::getDescString() const {
711   return "llvm.dbg.type";
712 }
713
714 /// getTypeString - Return a string used to label this descriptor's type.
715 ///
716 const char *TypeDesc::getTypeString() const {
717   return "llvm.dbg.type.type";
718 }
719
720 #ifndef NDEBUG
721 void 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
738 BasicTypeDesc::BasicTypeDesc()
739 : TypeDesc(DW_TAG_base_type)
740 , Encoding(0)
741 {}
742
743 // Implement isa/cast/dyncast.
744 bool 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 ///
750 void 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 ///
758 const char *BasicTypeDesc::getDescString() const {
759   return "llvm.dbg.basictype";
760 }
761
762 /// getTypeString - Return a string used to label this descriptor's type.
763 ///
764 const char *BasicTypeDesc::getTypeString() const {
765   return "llvm.dbg.basictype.type";
766 }
767
768 #ifndef NDEBUG
769 void 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
782 DerivedTypeDesc::DerivedTypeDesc(unsigned T)
783 : TypeDesc(T)
784 , FromType(NULL)
785 {}
786
787 // Implement isa/cast/dyncast.
788 bool 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 ///
807 void 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 ///
815 const char *DerivedTypeDesc::getDescString() const {
816   return "llvm.dbg.derivedtype";
817 }
818
819 /// getTypeString - Return a string used to label this descriptor's type.
820 ///
821 const char *DerivedTypeDesc::getTypeString() const {
822   return "llvm.dbg.derivedtype.type";
823 }
824
825 #ifndef NDEBUG
826 void 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
841 CompositeTypeDesc::CompositeTypeDesc(unsigned T)
842 : DerivedTypeDesc(T)
843 , Elements()
844 {}
845   
846 // Implement isa/cast/dyncast.
847 bool 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 ///
864 void 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 ///
872 const char *CompositeTypeDesc::getDescString() const {
873   return "llvm.dbg.compositetype";
874 }
875
876 /// getTypeString - Return a string used to label this descriptor's type.
877 ///
878 const char *CompositeTypeDesc::getTypeString() const {
879   return "llvm.dbg.compositetype.type";
880 }
881
882 #ifndef NDEBUG
883 void 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
899 SubrangeDesc::SubrangeDesc()
900 : DebugInfoDesc(DW_TAG_subrange_type)
901 , Lo(0)
902 , Hi(0)
903 {}
904
905 // Implement isa/cast/dyncast.
906 bool 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 ///
912 void 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 ///
921 const char *SubrangeDesc::getDescString() const {
922   return "llvm.dbg.subrange";
923 }
924   
925 /// getTypeString - Return a string used to label this descriptor's type.
926 ///
927 const char *SubrangeDesc::getTypeString() const {
928   return "llvm.dbg.subrange.type";
929 }
930
931 #ifndef NDEBUG
932 void SubrangeDesc::dump() {
933   cerr << getDescString() << " "
934        << "Version(" << getVersion() << "), "
935        << "Tag(" << getTag() << "), "
936        << "Lo(" << Lo << "), "
937        << "Hi(" << Hi << ")\n";
938 }
939 #endif
940
941 //===----------------------------------------------------------------------===//
942
943 EnumeratorDesc::EnumeratorDesc()
944 : DebugInfoDesc(DW_TAG_enumerator)
945 , Name("")
946 , Value(0)
947 {}
948
949 // Implement isa/cast/dyncast.
950 bool 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 ///
956 void 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 ///
965 const char *EnumeratorDesc::getDescString() const {
966   return "llvm.dbg.enumerator";
967 }
968   
969 /// getTypeString - Return a string used to label this descriptor's type.
970 ///
971 const char *EnumeratorDesc::getTypeString() const {
972   return "llvm.dbg.enumerator.type";
973 }
974
975 #ifndef NDEBUG
976 void EnumeratorDesc::dump() {
977   cerr << getDescString() << " "
978        << "Version(" << getVersion() << "), "
979        << "Tag(" << getTag() << "), "
980        << "Name(" << Name << "), "
981        << "Value(" << Value << ")\n";
982 }
983 #endif
984
985 //===----------------------------------------------------------------------===//
986
987 VariableDesc::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.
997 bool 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 ///
1011 void 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 ///
1023 const char *VariableDesc::getDescString() const {
1024   return "llvm.dbg.variable";
1025 }
1026
1027 /// getTypeString - Return a string used to label this descriptor's type.
1028 ///
1029 const char *VariableDesc::getTypeString() const {
1030   return "llvm.dbg.variable.type";
1031 }
1032
1033 #ifndef NDEBUG
1034 void 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
1048 GlobalDesc::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 ///
1063 void 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
1079 GlobalVariableDesc::GlobalVariableDesc()
1080 : GlobalDesc(DW_TAG_variable)
1081 , Global(NULL)
1082 {}
1083
1084 // Implement isa/cast/dyncast.
1085 bool 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 ///
1091 void 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 ///
1099 const char *GlobalVariableDesc::getDescString() const {
1100   return "llvm.dbg.global_variable";
1101 }
1102
1103 /// getTypeString - Return a string used to label this descriptors type.
1104 ///
1105 const 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 ///
1111 const char *GlobalVariableDesc::AnchorString = "llvm.dbg.global_variables";
1112 const char *GlobalVariableDesc::getAnchorString() const {
1113   return AnchorString;
1114 }
1115
1116 #ifndef NDEBUG
1117 void 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
1136 SubprogramDesc::SubprogramDesc()
1137 : GlobalDesc(DW_TAG_subprogram)
1138 {}
1139
1140 // Implement isa/cast/dyncast.
1141 bool 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.
1147 void SubprogramDesc::ApplyToFields(DIVisitor *Visitor) {
1148   GlobalDesc::ApplyToFields(Visitor);
1149 }
1150
1151 /// getDescString - Return a string used to compose global names and labels.
1152 ///
1153 const char *SubprogramDesc::getDescString() const {
1154   return "llvm.dbg.subprogram";
1155 }
1156
1157 /// getTypeString - Return a string used to label this descriptors type.
1158 ///
1159 const 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 ///
1165 const char *SubprogramDesc::AnchorString = "llvm.dbg.subprograms";
1166 const char *SubprogramDesc::getAnchorString() const {
1167   return AnchorString;
1168 }
1169
1170 #ifndef NDEBUG
1171 void 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
1189 BlockDesc::BlockDesc()
1190 : DebugInfoDesc(DW_TAG_lexical_block)
1191 , Context(NULL)
1192 {}
1193
1194 // Implement isa/cast/dyncast.
1195 bool 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 ///
1201 void 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 ///
1209 const char *BlockDesc::getDescString() const {
1210   return "llvm.dbg.block";
1211 }
1212
1213 /// getTypeString - Return a string used to label this descriptors type.
1214 ///
1215 const char *BlockDesc::getTypeString() const {
1216   return "llvm.dbg.block.type";
1217 }
1218
1219 #ifndef NDEBUG
1220 void BlockDesc::dump() {
1221   cerr << getDescString() << " "
1222        << "Version(" << getVersion() << "), "
1223        << "Tag(" << getTag() << "),"
1224        << "Context(" << Context << ")\n";
1225 }
1226 #endif
1227
1228 //===----------------------------------------------------------------------===//
1229
1230 DebugInfoDesc *DIDeserializer::Deserialize(Value *V) {
1231   return Deserialize(getGlobalVariable(V));
1232 }
1233 DebugInfoDesc *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 ///
1261 const 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 ///
1273 const 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 ///
1288 const 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 ///
1312 Constant *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.
1337 GlobalVariable *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 //===----------------------------------------------------------------------===//
1368
1369 /// Verify - Return true if the GlobalVariable appears to be a valid
1370 /// serialization of a DebugInfoDesc.
1371 bool DIVerifier::Verify(Value *V) {
1372   return !V || Verify(getGlobalVariable(V));
1373 }
1374 bool DIVerifier::Verify(GlobalVariable *GV) {
1375   // NULLs are valid.
1376   if (!GV) return true;
1377   
1378   // Check prior validity.
1379   unsigned &ValiditySlot = Validity[GV];
1380   
1381   // If visited before then use old state.
1382   if (ValiditySlot) return ValiditySlot == Valid;
1383   
1384   // Assume validity for the time being (recursion.)
1385   ValiditySlot = Valid;
1386   
1387   // Make sure the global is internal or link once (anchor.)
1388   if (GV->getLinkage() != GlobalValue::InternalLinkage &&
1389       GV->getLinkage() != GlobalValue::LinkOnceLinkage) {
1390     ValiditySlot = Invalid;
1391     return false;
1392   }
1393
1394   // Get the Tag.
1395   unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
1396   
1397   // Check for user defined descriptors.
1398   if (Tag == DW_TAG_invalid) {
1399     ValiditySlot = Valid;
1400     return true;
1401   }
1402   
1403   // Get the Version.
1404   unsigned Version = DebugInfoDesc::VersionFromGlobal(GV);
1405   
1406   // Check for version mismatch.
1407   if (Version != LLVMDebugVersion) {
1408     ValiditySlot = Invalid;
1409     return false;
1410   }
1411
1412   // Construct an empty DebugInfoDesc.
1413   DebugInfoDesc *DD = DebugInfoDesc::DescFactory(Tag);
1414   
1415   // Allow for user defined descriptors.
1416   if (!DD) return true;
1417   
1418   // Get the initializer constant.
1419   ConstantStruct *CI = cast<ConstantStruct>(GV->getInitializer());
1420   
1421   // Get the operand count.
1422   unsigned N = CI->getNumOperands();
1423   
1424   // Get the field count.
1425   unsigned &CountSlot = Counts[Tag];
1426   if (!CountSlot) {
1427     // Check the operand count to the field count
1428     DICountVisitor CTAM;
1429     CTAM.ApplyToFields(DD);
1430     CountSlot = CTAM.getCount();
1431   }
1432   
1433   // Field count must be at most equal operand count.
1434   if (CountSlot >  N) {
1435     delete DD;
1436     ValiditySlot = Invalid;
1437     return false;
1438   }
1439   
1440   // Check each field for valid type.
1441   DIVerifyVisitor VRAM(*this, GV);
1442   VRAM.ApplyToFields(DD);
1443   
1444   // Release empty DebugInfoDesc.
1445   delete DD;
1446   
1447   // If fields are not valid.
1448   if (!VRAM.isValid()) {
1449     ValiditySlot = Invalid;
1450     return false;
1451   }
1452   
1453   return true;
1454 }
1455
1456 //===----------------------------------------------------------------------===//
1457
1458 DebugScope::~DebugScope() {
1459   for (unsigned i = 0, N = Scopes.size(); i < N; ++i) delete Scopes[i];
1460   for (unsigned j = 0, M = Variables.size(); j < M; ++j) delete Variables[j];
1461 }
1462
1463 //===----------------------------------------------------------------------===//
1464
1465 MachineModuleInfo::MachineModuleInfo()
1466 : ImmutablePass((intptr_t)&ID)
1467 , DR()
1468 , VR()
1469 , CompileUnits()
1470 , Directories()
1471 , SourceFiles()
1472 , Lines()
1473 , LabelIDList()
1474 , ScopeMap()
1475 , RootScope(NULL)
1476 , FrameMoves()
1477 , LandingPads()
1478 , Personalities()
1479 {
1480   // Always emit "no personality" info
1481   Personalities.push_back(NULL);
1482 }
1483 MachineModuleInfo::~MachineModuleInfo() {
1484
1485 }
1486
1487 /// doInitialization - Initialize the state for a new module.
1488 ///
1489 bool MachineModuleInfo::doInitialization() {
1490   return false;
1491 }
1492
1493 /// doFinalization - Tear down the state after completion of a module.
1494 ///
1495 bool MachineModuleInfo::doFinalization() {
1496   return false;
1497 }
1498
1499 /// BeginFunction - Begin gathering function meta information.
1500 ///
1501 void MachineModuleInfo::BeginFunction(MachineFunction *MF) {
1502   // Coming soon.
1503 }
1504
1505 /// EndFunction - Discard function meta information.
1506 ///
1507 void MachineModuleInfo::EndFunction() {
1508   // Clean up scope information.
1509   if (RootScope) {
1510     delete RootScope;
1511     ScopeMap.clear();
1512     RootScope = NULL;
1513   }
1514   
1515   // Clean up line info.
1516   Lines.clear();
1517
1518   // Clean up frame info.
1519   FrameMoves.clear();
1520   
1521   // Clean up exception info.
1522   LandingPads.clear();
1523   TypeInfos.clear();
1524   FilterIds.clear();
1525   FilterEnds.clear();
1526 }
1527
1528 /// getDescFor - Convert a Value to a debug information descriptor.
1529 ///
1530 // FIXME - use new Value type when available.
1531 DebugInfoDesc *MachineModuleInfo::getDescFor(Value *V) {
1532   return DR.Deserialize(V);
1533 }
1534
1535 /// Verify - Verify that a Value is debug information descriptor.
1536 ///
1537 bool MachineModuleInfo::Verify(Value *V) {
1538   return VR.Verify(V);
1539 }
1540
1541 /// AnalyzeModule - Scan the module for global debug information.
1542 ///
1543 void MachineModuleInfo::AnalyzeModule(Module &M) {
1544   SetupCompileUnits(M);
1545 }
1546
1547 /// needsFrameInfo - Returns true if we need to gather callee-saved register
1548 /// move info for the frame.
1549 bool MachineModuleInfo::needsFrameInfo() const {
1550   return hasDebugInfo() || ExceptionHandling;
1551 }
1552
1553 /// SetupCompileUnits - Set up the unique vector of compile units.
1554 ///
1555 void MachineModuleInfo::SetupCompileUnits(Module &M) {
1556   std::vector<CompileUnitDesc *>CU = getAnchoredDescriptors<CompileUnitDesc>(M);
1557   
1558   for (unsigned i = 0, N = CU.size(); i < N; i++) {
1559     CompileUnits.insert(CU[i]);
1560   }
1561 }
1562
1563 /// getCompileUnits - Return a vector of debug compile units.
1564 ///
1565 const UniqueVector<CompileUnitDesc *> MachineModuleInfo::getCompileUnits()const{
1566   return CompileUnits;
1567 }
1568
1569 /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the
1570 /// named GlobalVariable.
1571 std::vector<GlobalVariable*>
1572 MachineModuleInfo::getGlobalVariablesUsing(Module &M,
1573                                            const std::string &RootName) {
1574   return ::getGlobalVariablesUsing(M, RootName);
1575 }
1576
1577 /// RecordLabel - Records location information and associates it with a
1578 /// debug label.  Returns a unique label ID used to generate a label and 
1579 /// provide correspondence to the source line list.
1580 unsigned MachineModuleInfo::RecordLabel(unsigned Line, unsigned Column,
1581                                        unsigned Source) {
1582   unsigned ID = NextLabelID();
1583   Lines.push_back(SourceLineInfo(Line, Column, Source, ID));
1584   return ID;
1585 }
1586
1587 /// RecordSource - Register a source file with debug info. Returns an source
1588 /// ID.
1589 unsigned MachineModuleInfo::RecordSource(const std::string &Directory,
1590                                          const std::string &Source) {
1591   unsigned DirectoryID = Directories.insert(Directory);
1592   return SourceFiles.insert(SourceFileInfo(DirectoryID, Source));
1593 }
1594 unsigned MachineModuleInfo::RecordSource(const CompileUnitDesc *CompileUnit) {
1595   return RecordSource(CompileUnit->getDirectory(),
1596                       CompileUnit->getFileName());
1597 }
1598
1599 /// RecordRegionStart - Indicate the start of a region.
1600 ///
1601 unsigned MachineModuleInfo::RecordRegionStart(Value *V) {
1602   // FIXME - need to be able to handle split scopes because of bb cloning.
1603   DebugInfoDesc *ScopeDesc = DR.Deserialize(V);
1604   DebugScope *Scope = getOrCreateScope(ScopeDesc);
1605   unsigned ID = NextLabelID();
1606   if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID);
1607   return ID;
1608 }
1609
1610 /// RecordRegionEnd - Indicate the end of a region.
1611 ///
1612 unsigned MachineModuleInfo::RecordRegionEnd(Value *V) {
1613   // FIXME - need to be able to handle split scopes because of bb cloning.
1614   DebugInfoDesc *ScopeDesc = DR.Deserialize(V);
1615   DebugScope *Scope = getOrCreateScope(ScopeDesc);
1616   unsigned ID = NextLabelID();
1617   Scope->setEndLabelID(ID);
1618   return ID;
1619 }
1620
1621 /// RecordVariable - Indicate the declaration of  a local variable.
1622 ///
1623 void MachineModuleInfo::RecordVariable(Value *V, unsigned FrameIndex) {
1624   VariableDesc *VD = cast<VariableDesc>(DR.Deserialize(V));
1625   DebugScope *Scope = getOrCreateScope(VD->getContext());
1626   DebugVariable *DV = new DebugVariable(VD, FrameIndex);
1627   Scope->AddVariable(DV);
1628 }
1629
1630 /// getOrCreateScope - Returns the scope associated with the given descriptor.
1631 ///
1632 DebugScope *MachineModuleInfo::getOrCreateScope(DebugInfoDesc *ScopeDesc) {
1633   DebugScope *&Slot = ScopeMap[ScopeDesc];
1634   if (!Slot) {
1635     // FIXME - breaks down when the context is an inlined function.
1636     DebugInfoDesc *ParentDesc = NULL;
1637     if (BlockDesc *Block = dyn_cast<BlockDesc>(ScopeDesc)) {
1638       ParentDesc = Block->getContext();
1639     }
1640     DebugScope *Parent = ParentDesc ? getOrCreateScope(ParentDesc) : NULL;
1641     Slot = new DebugScope(Parent, ScopeDesc);
1642     if (Parent) {
1643       Parent->AddScope(Slot);
1644     } else if (RootScope) {
1645       // FIXME - Add inlined function scopes to the root so we can delete
1646       // them later.  Long term, handle inlined functions properly.
1647       RootScope->AddScope(Slot);
1648     } else {
1649       // First function is top level function.
1650       RootScope = Slot;
1651     }
1652   }
1653   return Slot;
1654 }
1655
1656 //===-EH-------------------------------------------------------------------===//
1657
1658 /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the
1659 /// specified MachineBasicBlock.
1660 LandingPadInfo &MachineModuleInfo::getOrCreateLandingPadInfo
1661     (MachineBasicBlock *LandingPad) {
1662   unsigned N = LandingPads.size();
1663   for (unsigned i = 0; i < N; ++i) {
1664     LandingPadInfo &LP = LandingPads[i];
1665     if (LP.LandingPadBlock == LandingPad)
1666       return LP;
1667   }
1668   
1669   LandingPads.push_back(LandingPadInfo(LandingPad));
1670   return LandingPads[N];
1671 }
1672
1673 /// addInvoke - Provide the begin and end labels of an invoke style call and
1674 /// associate it with a try landing pad block.
1675 void MachineModuleInfo::addInvoke(MachineBasicBlock *LandingPad,
1676                                   unsigned BeginLabel, unsigned EndLabel) {
1677   LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1678   LP.BeginLabels.push_back(BeginLabel);
1679   LP.EndLabels.push_back(EndLabel);
1680 }
1681
1682 /// addLandingPad - Provide the label of a try LandingPad block.
1683 ///
1684 unsigned MachineModuleInfo::addLandingPad(MachineBasicBlock *LandingPad) {
1685   unsigned LandingPadLabel = NextLabelID();
1686   LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1687   LP.LandingPadLabel = LandingPadLabel;  
1688   return LandingPadLabel;
1689 }
1690
1691 /// addPersonality - Provide the personality function for the exception
1692 /// information.
1693 void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad,
1694                                        Function *Personality) {
1695   LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1696   LP.Personality = Personality;
1697
1698   for (unsigned i = 0; i < Personalities.size(); ++i)
1699     if (Personalities[i] == Personality)
1700       return;
1701   
1702   Personalities.push_back(Personality);
1703 }
1704
1705 /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
1706 ///
1707 void MachineModuleInfo::addCatchTypeInfo(MachineBasicBlock *LandingPad,
1708                                         std::vector<GlobalVariable *> &TyInfo) {
1709   LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1710   for (unsigned N = TyInfo.size(); N; --N)
1711     LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
1712 }
1713
1714 /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
1715 ///
1716 void MachineModuleInfo::addFilterTypeInfo(MachineBasicBlock *LandingPad,
1717                                         std::vector<GlobalVariable *> &TyInfo) {
1718   LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
1719   std::vector<unsigned> IdsInFilter (TyInfo.size());
1720   for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
1721     IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
1722   LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
1723 }
1724
1725 /// TidyLandingPads - Remap landing pad labels and remove any deleted landing
1726 /// pads.
1727 void MachineModuleInfo::TidyLandingPads() {
1728   for (unsigned i = 0; i != LandingPads.size(); ) {
1729     LandingPadInfo &LandingPad = LandingPads[i];
1730     LandingPad.LandingPadLabel = MappedLabel(LandingPad.LandingPadLabel);
1731
1732     if (!LandingPad.LandingPadBlock)
1733       // Must not have cleanups if no landing pad.
1734       LandingPad.TypeIds.clear();
1735
1736     // Special case: we *should* emit LPs with null LP MBB. This indicates
1737     // "rethrow" case.
1738     if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
1739       LandingPads.erase(LandingPads.begin() + i);
1740       continue;
1741     }
1742           
1743     for (unsigned j=0; j != LandingPads[i].BeginLabels.size(); ) {
1744       unsigned BeginLabel = MappedLabel(LandingPad.BeginLabels[j]);
1745       unsigned EndLabel = MappedLabel(LandingPad.EndLabels[j]);
1746             
1747           
1748       if (!BeginLabel || !EndLabel) {
1749         LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
1750         LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
1751         continue;
1752       }
1753
1754       LandingPad.BeginLabels[j] = BeginLabel;
1755       LandingPad.EndLabels[j] = EndLabel;
1756       ++j;
1757     }
1758     
1759     ++i;
1760   }
1761 }
1762
1763 /// getTypeIDFor - Return the type id for the specified typeinfo.  This is 
1764 /// function wide.
1765 unsigned MachineModuleInfo::getTypeIDFor(GlobalVariable *TI) {
1766   for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
1767     if (TypeInfos[i] == TI) return i + 1;
1768
1769   TypeInfos.push_back(TI);
1770   return TypeInfos.size();
1771 }
1772
1773 /// getFilterIDFor - Return the filter id for the specified typeinfos.  This is
1774 /// function wide.
1775 int MachineModuleInfo::getFilterIDFor(std::vector<unsigned> &TyIds) {
1776   // If the new filter coincides with the tail of an existing filter, then
1777   // re-use the existing filter.  Folding filters more than this requires
1778   // re-ordering filters and/or their elements - probably not worth it.
1779   for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
1780        E = FilterEnds.end(); I != E; ++I) {
1781     unsigned i = *I, j = TyIds.size();
1782
1783     while (i && j)
1784       if (FilterIds[--i] != TyIds[--j])
1785         goto try_next;
1786
1787     if (!j)
1788       // The new filter coincides with range [i, end) of the existing filter.
1789       return -(1 + i);
1790
1791 try_next:;
1792   }
1793
1794   // Add the new filter.
1795   int FilterID = -(1 + FilterIds.size());
1796   FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
1797   for (unsigned I = 0, N = TyIds.size(); I != N; ++I)
1798     FilterIds.push_back(TyIds[I]);
1799   FilterEnds.push_back(FilterIds.size());
1800   FilterIds.push_back(0); // terminator
1801   return FilterID;
1802 }
1803
1804 /// getPersonality - Return the personality function for the current function.
1805 Function *MachineModuleInfo::getPersonality() const {
1806   // FIXME: Until PR1414 will be fixed, we're using 1 personality function per
1807   // function
1808   return !LandingPads.empty() ? LandingPads[0].Personality : NULL;
1809 }
1810
1811 /// getPersonalityIndex - Return unique index for current personality
1812 /// function. NULL personality function should always get zero index.
1813 unsigned MachineModuleInfo::getPersonalityIndex() const {
1814   const Function* Personality = NULL;
1815   
1816   // Scan landing pads. If there is at least one non-NULL personality - use it.
1817   for (unsigned i = 0; i != LandingPads.size(); ++i)
1818     if (LandingPads[i].Personality) {
1819       Personality = LandingPads[i].Personality;
1820       break;
1821     }
1822   
1823   for (unsigned i = 0; i < Personalities.size(); ++i) {
1824     if (Personalities[i] == Personality)
1825       return i;
1826   }
1827
1828   // This should never happen
1829   assert(0 && "Personality function should be set!");
1830   return 0;
1831 }
1832
1833 //===----------------------------------------------------------------------===//
1834 /// DebugLabelFolding pass - This pass prunes out redundant labels.  This allows
1835 /// a info consumer to determine if the range of two labels is empty, by seeing
1836 /// if the labels map to the same reduced label.
1837
1838 namespace llvm {
1839
1840 struct DebugLabelFolder : public MachineFunctionPass {
1841   static char ID;
1842   DebugLabelFolder() : MachineFunctionPass((intptr_t)&ID) {}
1843
1844   virtual bool runOnMachineFunction(MachineFunction &MF);
1845   virtual const char *getPassName() const { return "Label Folder"; }
1846 };
1847
1848 char DebugLabelFolder::ID = 0;
1849
1850 bool DebugLabelFolder::runOnMachineFunction(MachineFunction &MF) {
1851   // Get machine module info.
1852   MachineModuleInfo *MMI = getAnalysisToUpdate<MachineModuleInfo>();
1853   if (!MMI) return false;
1854   // Get target instruction info.
1855   const TargetInstrInfo *TII = MF.getTarget().getInstrInfo();
1856   if (!TII) return false;
1857   
1858   // Track if change is made.
1859   bool MadeChange = false;
1860   // No prior label to begin.
1861   unsigned PriorLabel = 0;
1862   
1863   // Iterate through basic blocks.
1864   for (MachineFunction::iterator BB = MF.begin(), E = MF.end();
1865        BB != E; ++BB) {
1866     // Iterate through instructions.
1867     for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
1868       // Is it a label.
1869       if ((unsigned)I->getOpcode() == TargetInstrInfo::LABEL) {
1870         // The label ID # is always operand #0, an immediate.
1871         unsigned NextLabel = I->getOperand(0).getImm();
1872         
1873         // If there was an immediate prior label.
1874         if (PriorLabel) {
1875           // Remap the current label to prior label.
1876           MMI->RemapLabel(NextLabel, PriorLabel);
1877           // Delete the current label.
1878           I = BB->erase(I);
1879           // Indicate a change has been made.
1880           MadeChange = true;
1881           continue;
1882         } else {
1883           // Start a new round.
1884           PriorLabel = NextLabel;
1885         }
1886        } else {
1887         // No consecutive labels.
1888         PriorLabel = 0;
1889       }
1890       
1891       ++I;
1892     }
1893   }
1894   
1895   return MadeChange;
1896 }
1897
1898 FunctionPass *createDebugLabelFoldingPass() { return new DebugLabelFolder(); }
1899
1900 }
1901