lib/CodeGen/MachineDebugInfo.cpp

   1 //===-- llvm/CodeGen/MachineDebugInfo.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/MachineDebugInfo.h"
  11
  12 #include "llvm/Constants.h"
  13 #include "llvm/CodeGen/MachineLocation.h"
  14 #include "llvm/DerivedTypes.h"
  15 #include "llvm/GlobalVariable.h"
  16 #include "llvm/Intrinsics.h"
  17 #include "llvm/Instructions.h"
  18 #include "llvm/Module.h"
  19 #include "llvm/Support/Dwarf.h"
  20
  21 #include <iostream>
  22
  23 using namespace llvm;
  24 using namespace llvm::dwarf;
  25
  26 // Handle the Pass registration stuff necessary to use TargetData's.
  27 namespace {
  28   RegisterPass<MachineDebugInfo> X("machinedebuginfo", "Debug Information");
  29 }
  30
  31 //===----------------------------------------------------------------------===//
  32
  33 /// getGlobalVariablesUsing - Return all of the GlobalVariables which have the
  34 /// specified value in their initializer somewhere.
  35 static void
  36 getGlobalVariablesUsing(Value *V, std::vector<GlobalVariable*> &Result) {
  37   // Scan though value users.
  38   for (Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) {
  39     if (GlobalVariable *GV = dyn_cast<GlobalVariable>(*I)) {
  40       // If the user is a GlobalVariable then add to result.
  41       Result.push_back(GV);
  42     } else if (Constant *C = dyn_cast<Constant>(*I)) {
  43       // If the user is a constant variable then scan its users
  44       getGlobalVariablesUsing(C, Result);
  45     }
  46   }
  47 }
  48
  49 /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the
  50 /// named GlobalVariable.
  51 static std::vector<GlobalVariable*>
  52 getGlobalVariablesUsing(Module &M, const std::string &RootName) {
  53   std::vector<GlobalVariable*> Result;  // GlobalVariables matching criteria.
  54
  55   std::vector<const Type*> FieldTypes;
  56   FieldTypes.push_back(Type::UIntTy);
  57   FieldTypes.push_back(Type::UIntTy);
  58
  59   // Get the GlobalVariable root.
  60   GlobalVariable *UseRoot = M.getGlobalVariable(RootName,
  61                                                 StructType::get(FieldTypes));
  62
  63   // If present and linkonce then scan for users.
  64   if (UseRoot && UseRoot->hasLinkOnceLinkage()) {
  65     getGlobalVariablesUsing(UseRoot, Result);
  66   }
  67
  68   return Result;
  69 }
  70
  71 /// isStringValue - Return true if the given value can be coerced to a string.
  72 ///
  73 static bool isStringValue(Value *V) {
  74   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
  75     if (GV->hasInitializer() && isa<ConstantArray>(GV->getInitializer())) {
  76       ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
  77       return Init->isString();
  78     }
  79   } else if (Constant *C = dyn_cast<Constant>(V)) {
  80     if (GlobalValue *GV = dyn_cast<GlobalValue>(C))
  81       return isStringValue(GV);
  82     else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
  83       if (CE->getOpcode() == Instruction::GetElementPtr) {
  84         if (CE->getNumOperands() == 3 &&
  85             cast<Constant>(CE->getOperand(1))->isNullValue() &&
  86             isa<ConstantInt>(CE->getOperand(2))) {
  87           return isStringValue(CE->getOperand(0));
  88         }
  89       }
  90     }
  91   }
  92   return false;
  93 }
  94
  95 /// getGlobalVariable - Return either a direct or cast Global value.
  96 ///
  97 static GlobalVariable *getGlobalVariable(Value *V) {
  98   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
  99     return GV;
 100   } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
 101     if (CE->getOpcode() == Instruction::Cast) {
 102       return dyn_cast<GlobalVariable>(CE->getOperand(0));
 103     }
 104   }
 105   return NULL;
 106 }
 107
 108 /// isGlobalVariable - Return true if the given value can be coerced to a
 109 /// GlobalVariable.
 110 static bool isGlobalVariable(Value *V) {
 111   if (isa<GlobalVariable>(V) || isa<ConstantPointerNull>(V)) {
 112     return true;
 113   } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
 114     if (CE->getOpcode() == Instruction::Cast) {
 115       return isa<GlobalVariable>(CE->getOperand(0));
 116     }
 117   }
 118   return false;
 119 }
 120
 121 /// getUIntOperand - Return ith operand if it is an unsigned integer.
 122 ///
 123 static ConstantUInt *getUIntOperand(GlobalVariable *GV, unsigned i) {
 124   // Make sure the GlobalVariable has an initializer.
 125   if (!GV->hasInitializer()) return NULL;
 126
 127   // Get the initializer constant.
 128   ConstantStruct *CI = dyn_cast<ConstantStruct>(GV->getInitializer());
 129   if (!CI) return NULL;
 130
 131   // Check if there is at least i + 1 operands.
 132   unsigned N = CI->getNumOperands();
 133   if (i >= N) return NULL;
 134
 135   // Check constant.
 136   return dyn_cast<ConstantUInt>(CI->getOperand(i));
 137 }
 138 //===----------------------------------------------------------------------===//
 139
 140 /// ApplyToFields - Target the visitor to each field of the debug information
 141 /// descriptor.
 142 void DIVisitor::ApplyToFields(DebugInfoDesc *DD) {
 143   DD->ApplyToFields(this);
 144 }
 145
 146 //===----------------------------------------------------------------------===//
 147 /// DICountVisitor - This DIVisitor counts all the fields in the supplied debug
 148 /// the supplied DebugInfoDesc.
 149 class DICountVisitor : public DIVisitor {
 150 private:
 151   unsigned Count;                       // Running count of fields.
 152
 153 public:
 154   DICountVisitor() : DIVisitor(), Count(0) {}
 155
 156   // Accessors.
 157   unsigned getCount() const { return Count; }
 158
 159   /// Apply - Count each of the fields.
 160   ///
 161   virtual void Apply(int &Field)             { ++Count; }
 162   virtual void Apply(unsigned &Field)        { ++Count; }
 163   virtual void Apply(int64_t &Field)         { ++Count; }
 164   virtual void Apply(uint64_t &Field)        { ++Count; }
 165   virtual void Apply(bool &Field)            { ++Count; }
 166   virtual void Apply(std::string &Field)     { ++Count; }
 167   virtual void Apply(DebugInfoDesc *&Field)  { ++Count; }
 168   virtual void Apply(GlobalVariable *&Field) { ++Count; }
 169   virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
 170     ++Count;
 171   }
 172 };
 173
 174 //===----------------------------------------------------------------------===//
 175 /// DIDeserializeVisitor - This DIVisitor deserializes all the fields in the
 176 /// supplied DebugInfoDesc.
 177 class DIDeserializeVisitor : public DIVisitor {
 178 private:
 179   DIDeserializer &DR;                   // Active deserializer.
 180   unsigned I;                           // Current operand index.
 181   ConstantStruct *CI;                   // GlobalVariable constant initializer.
 182
 183 public:
 184   DIDeserializeVisitor(DIDeserializer &D, GlobalVariable *GV)
 185   : DIVisitor()
 186   , DR(D)
 187   , I(0)
 188   , CI(cast<ConstantStruct>(GV->getInitializer()))
 189   {}
 190
 191   /// Apply - Set the value of each of the fields.
 192   ///
 193   virtual void Apply(int &Field) {
 194     Constant *C = CI->getOperand(I++);
 195     Field = cast<ConstantSInt>(C)->getValue();
 196   }
 197   virtual void Apply(unsigned &Field) {
 198     Constant *C = CI->getOperand(I++);
 199     Field = cast<ConstantUInt>(C)->getValue();
 200   }
 201   virtual void Apply(int64_t &Field) {
 202     Constant *C = CI->getOperand(I++);
 203     Field = cast<ConstantSInt>(C)->getValue();
 204   }
 205   virtual void Apply(uint64_t &Field) {
 206     Constant *C = CI->getOperand(I++);
 207     Field = cast<ConstantUInt>(C)->getValue();
 208   }
 209   virtual void Apply(bool &Field) {
 210     Constant *C = CI->getOperand(I++);
 211     Field = cast<ConstantBool>(C)->getValue();
 212   }
 213   virtual void Apply(std::string &Field) {
 214     Constant *C = CI->getOperand(I++);
 215     Field = C->getStringValue();
 216   }
 217   virtual void Apply(DebugInfoDesc *&Field) {
 218     Constant *C = CI->getOperand(I++);
 219     Field = DR.Deserialize(C);
 220   }
 221   virtual void Apply(GlobalVariable *&Field) {
 222     Constant *C = CI->getOperand(I++);
 223     Field = getGlobalVariable(C);
 224   }
 225   virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
 226     Constant *C = CI->getOperand(I++);
 227     GlobalVariable *GV = getGlobalVariable(C);
 228     Field.resize(0);
 229     // Have to be able to deal with the empty array case (zero initializer)
 230     if (!GV->hasInitializer()) return;
 231     if (ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer())) {
 232       for (unsigned i = 0, N = CA->getNumOperands(); i < N; ++i) {
 233         GlobalVariable *GVE = getGlobalVariable(CA->getOperand(i));
 234         DebugInfoDesc *DE = DR.Deserialize(GVE);
 235         Field.push_back(DE);
 236       }
 237     }
 238   }
 239 };
 240
 241 //===----------------------------------------------------------------------===//
 242 /// DISerializeVisitor - This DIVisitor serializes all the fields in
 243 /// the supplied DebugInfoDesc.
 244 class DISerializeVisitor : public DIVisitor {
 245 private:
 246   DISerializer &SR;                     // Active serializer.
 247   std::vector<Constant*> &Elements;     // Element accumulator.
 248
 249 public:
 250   DISerializeVisitor(DISerializer &S, std::vector<Constant*> &E)
 251   : DIVisitor()
 252   , SR(S)
 253   , Elements(E)
 254   {}
 255
 256   /// Apply - Set the value of each of the fields.
 257   ///
 258   virtual void Apply(int &Field) {
 259     Elements.push_back(ConstantSInt::get(Type::IntTy, Field));
 260   }
 261   virtual void Apply(unsigned &Field) {
 262     Elements.push_back(ConstantUInt::get(Type::UIntTy, Field));
 263   }
 264   virtual void Apply(int64_t &Field) {
 265     Elements.push_back(ConstantSInt::get(Type::LongTy, Field));
 266   }
 267   virtual void Apply(uint64_t &Field) {
 268     Elements.push_back(ConstantUInt::get(Type::ULongTy, Field));
 269   }
 270   virtual void Apply(bool &Field) {
 271     Elements.push_back(ConstantBool::get(Field));
 272   }
 273   virtual void Apply(std::string &Field) {
 274       Elements.push_back(SR.getString(Field));
 275   }
 276   virtual void Apply(DebugInfoDesc *&Field) {
 277     GlobalVariable *GV = NULL;
 278
 279     // If non-NULL then convert to global.
 280     if (Field) GV = SR.Serialize(Field);
 281
 282     // FIXME - At some point should use specific type.
 283     const PointerType *EmptyTy = SR.getEmptyStructPtrType();
 284
 285     if (GV) {
 286       // Set to pointer to global.
 287       Elements.push_back(ConstantExpr::getCast(GV, EmptyTy));
 288     } else {
 289       // Use NULL.
 290       Elements.push_back(ConstantPointerNull::get(EmptyTy));
 291     }
 292   }
 293   virtual void Apply(GlobalVariable *&Field) {
 294     const PointerType *EmptyTy = SR.getEmptyStructPtrType();
 295     if (Field) {
 296       Elements.push_back(ConstantExpr::getCast(Field, EmptyTy));
 297     } else {
 298       Elements.push_back(ConstantPointerNull::get(EmptyTy));
 299     }
 300   }
 301   virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
 302     const PointerType *EmptyTy = SR.getEmptyStructPtrType();
 303     unsigned N = Field.size();
 304     ArrayType *AT = ArrayType::get(EmptyTy, N);
 305     std::vector<Constant *> ArrayElements;
 306
 307     for (unsigned i = 0, N = Field.size(); i < N; ++i) {
 308       GlobalVariable *GVE = SR.Serialize(Field[i]);
 309       Constant *CE = ConstantExpr::getCast(GVE, EmptyTy);
 310       ArrayElements.push_back(cast<Constant>(CE));
 311     }
 312
 313     Constant *CA = ConstantArray::get(AT, ArrayElements);
 314     GlobalVariable *CAGV = new GlobalVariable(AT, true,
 315                                               GlobalValue::InternalLinkage,
 316                                               CA, "llvm.dbg.array",
 317                                               SR.getModule());
 318     CAGV->setSection("llvm.metadata");
 319     Constant *CAE = ConstantExpr::getCast(CAGV, EmptyTy);
 320     Elements.push_back(CAE);
 321   }
 322 };
 323
 324 //===----------------------------------------------------------------------===//
 325 /// DIGetTypesVisitor - This DIVisitor gathers all the field types in
 326 /// the supplied DebugInfoDesc.
 327 class DIGetTypesVisitor : public DIVisitor {
 328 private:
 329   DISerializer &SR;                     // Active serializer.
 330   std::vector<const Type*> &Fields;     // Type accumulator.
 331
 332 public:
 333   DIGetTypesVisitor(DISerializer &S, std::vector<const Type*> &F)
 334   : DIVisitor()
 335   , SR(S)
 336   , Fields(F)
 337   {}
 338
 339   /// Apply - Set the value of each of the fields.
 340   ///
 341   virtual void Apply(int &Field) {
 342     Fields.push_back(Type::IntTy);
 343   }
 344   virtual void Apply(unsigned &Field) {
 345     Fields.push_back(Type::UIntTy);
 346   }
 347   virtual void Apply(int64_t &Field) {
 348     Fields.push_back(Type::LongTy);
 349   }
 350   virtual void Apply(uint64_t &Field) {
 351     Fields.push_back(Type::ULongTy);
 352   }
 353   virtual void Apply(bool &Field) {
 354     Fields.push_back(Type::BoolTy);
 355   }
 356   virtual void Apply(std::string &Field) {
 357     Fields.push_back(SR.getStrPtrType());
 358   }
 359   virtual void Apply(DebugInfoDesc *&Field) {
 360     // FIXME - At some point should use specific type.
 361     const PointerType *EmptyTy = SR.getEmptyStructPtrType();
 362     Fields.push_back(EmptyTy);
 363   }
 364   virtual void Apply(GlobalVariable *&Field) {
 365     const PointerType *EmptyTy = SR.getEmptyStructPtrType();
 366     Fields.push_back(EmptyTy);
 367   }
 368   virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
 369     const PointerType *EmptyTy = SR.getEmptyStructPtrType();
 370     Fields.push_back(EmptyTy);
 371   }
 372 };
 373
 374 //===----------------------------------------------------------------------===//
 375 /// DIVerifyVisitor - This DIVisitor verifies all the field types against
 376 /// a constant initializer.
 377 class DIVerifyVisitor : public DIVisitor {
 378 private:
 379   DIVerifier &VR;                       // Active verifier.
 380   bool IsValid;                         // Validity status.
 381   unsigned I;                           // Current operand index.
 382   ConstantStruct *CI;                   // GlobalVariable constant initializer.
 383
 384 public:
 385   DIVerifyVisitor(DIVerifier &V, GlobalVariable *GV)
 386   : DIVisitor()
 387   , VR(V)
 388   , IsValid(true)
 389   , I(0)
 390   , CI(cast<ConstantStruct>(GV->getInitializer()))
 391   {
 392   }
 393
 394   // Accessors.
 395   bool isValid() const { return IsValid; }
 396
 397   /// Apply - Set the value of each of the fields.
 398   ///
 399   virtual void Apply(int &Field) {
 400     Constant *C = CI->getOperand(I++);
 401     IsValid = IsValid && isa<ConstantInt>(C);
 402   }
 403   virtual void Apply(unsigned &Field) {
 404     Constant *C = CI->getOperand(I++);
 405     IsValid = IsValid && isa<ConstantInt>(C);
 406   }
 407   virtual void Apply(int64_t &Field) {
 408     Constant *C = CI->getOperand(I++);
 409     IsValid = IsValid && isa<ConstantInt>(C);
 410   }
 411   virtual void Apply(uint64_t &Field) {
 412     Constant *C = CI->getOperand(I++);
 413     IsValid = IsValid && isa<ConstantInt>(C);
 414   }
 415   virtual void Apply(bool &Field) {
 416     Constant *C = CI->getOperand(I++);
 417     IsValid = IsValid && isa<ConstantBool>(C);
 418   }
 419   virtual void Apply(std::string &Field) {
 420     Constant *C = CI->getOperand(I++);
 421     IsValid = IsValid && (!C || isStringValue(C));
 422   }
 423   virtual void Apply(DebugInfoDesc *&Field) {
 424     // FIXME - Prepare the correct descriptor.
 425     Constant *C = CI->getOperand(I++);
 426     IsValid = IsValid && isGlobalVariable(C);
 427   }
 428   virtual void Apply(GlobalVariable *&Field) {
 429     Constant *C = CI->getOperand(I++);
 430     IsValid = IsValid && isGlobalVariable(C);
 431   }
 432   virtual void Apply(std::vector<DebugInfoDesc *> &Field) {
 433     Constant *C = CI->getOperand(I++);
 434     IsValid = IsValid && isGlobalVariable(C);
 435     if (!IsValid) return;
 436
 437     GlobalVariable *GV = getGlobalVariable(C);
 438     IsValid = IsValid && GV && GV->hasInitializer();
 439     if (!IsValid) return;
 440
 441     ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer());
 442     IsValid = IsValid && CA;
 443     if (!IsValid) return;
 444
 445     for (unsigned i = 0, N = CA->getNumOperands(); IsValid && i < N; ++i) {
 446       IsValid = IsValid && isGlobalVariable(CA->getOperand(i));
 447       if (!IsValid) return;
 448
 449       GlobalVariable *GVE = getGlobalVariable(CA->getOperand(i));
 450       VR.Verify(GVE);
 451     }
 452   }
 453 };
 454
 455
 456 //===----------------------------------------------------------------------===//
 457
 458 /// TagFromGlobal - Returns the tag number from a debug info descriptor
 459 /// GlobalVariable.   Return DIIValid if operand is not an unsigned int.
 460 unsigned DebugInfoDesc::TagFromGlobal(GlobalVariable *GV) {
 461   ConstantUInt *C = getUIntOperand(GV, 0);
 462   return C ? ((unsigned)C->getValue() & tag_mask) : (unsigned)DW_TAG_invalid;
 463 }
 464
 465 /// VersionFromGlobal - Returns the version number from a debug info
 466 /// descriptor GlobalVariable.  Return DIIValid if operand is not an unsigned
 467 /// int.
 468 unsigned  DebugInfoDesc::VersionFromGlobal(GlobalVariable *GV) {
 469   ConstantUInt *C = getUIntOperand(GV, 0);
 470   return C ? ((unsigned)C->getValue() >> version_shift) :
 471              (unsigned)DW_TAG_invalid;
 472 }
 473
 474 /// DescFactory - Create an instance of debug info descriptor based on Tag.
 475 /// Return NULL if not a recognized Tag.
 476 DebugInfoDesc *DebugInfoDesc::DescFactory(unsigned Tag) {
 477   switch (Tag) {
 478   case DW_TAG_anchor:           return new AnchorDesc();
 479   case DW_TAG_compile_unit:     return new CompileUnitDesc();
 480   case DW_TAG_variable:         return new GlobalVariableDesc();
 481   case DW_TAG_subprogram:       return new SubprogramDesc();
 482   case DW_TAG_lexical_block:    return new BlockDesc();
 483   case DW_TAG_base_type:        return new BasicTypeDesc();
 484   case DW_TAG_typedef:
 485   case DW_TAG_pointer_type:
 486   case DW_TAG_reference_type:
 487   case DW_TAG_const_type:
 488   case DW_TAG_volatile_type:
 489   case DW_TAG_restrict_type:
 490   case DW_TAG_member:           return new DerivedTypeDesc(Tag);
 491   case DW_TAG_array_type:
 492   case DW_TAG_structure_type:
 493   case DW_TAG_union_type:
 494   case DW_TAG_enumeration_type: return new CompositeTypeDesc(Tag);
 495   case DW_TAG_subrange_type:    return new SubrangeDesc();
 496   case DW_TAG_enumerator:       return new EnumeratorDesc();
 497   case DW_TAG_return_variable:
 498   case DW_TAG_arg_variable:
 499   case DW_TAG_auto_variable:    return new VariableDesc(Tag);
 500   default: break;
 501   }
 502   return NULL;
 503 }
 504
 505 /// getLinkage - get linkage appropriate for this type of descriptor.
 506 ///
 507 GlobalValue::LinkageTypes DebugInfoDesc::getLinkage() const {
 508   return GlobalValue::InternalLinkage;
 509 }
 510
 511 /// ApplyToFields - Target the vistor to the fields of the descriptor.
 512 ///
 513 void DebugInfoDesc::ApplyToFields(DIVisitor *Visitor) {
 514   Visitor->Apply(Tag);
 515 }
 516
 517 //===----------------------------------------------------------------------===//
 518
 519 AnchorDesc::AnchorDesc()
 520 : DebugInfoDesc(DW_TAG_anchor)
 521 , AnchorTag(0)
 522 {}
 523 AnchorDesc::AnchorDesc(AnchoredDesc *D)
 524 : DebugInfoDesc(DW_TAG_anchor)
 525 , AnchorTag(D->getTag())
 526 {}
 527
 528 // Implement isa/cast/dyncast.
 529 bool AnchorDesc::classof(const DebugInfoDesc *D) {
 530   return D->getTag() == DW_TAG_anchor;
 531 }
 532
 533 /// getLinkage - get linkage appropriate for this type of descriptor.
 534 ///
 535 GlobalValue::LinkageTypes AnchorDesc::getLinkage() const {
 536   return GlobalValue::LinkOnceLinkage;
 537 }
 538
 539 /// ApplyToFields - Target the visitor to the fields of the TransUnitDesc.
 540 ///
 541 void AnchorDesc::ApplyToFields(DIVisitor *Visitor) {
 542   DebugInfoDesc::ApplyToFields(Visitor);
 543
 544   Visitor->Apply(AnchorTag);
 545 }
 546
 547 /// getDescString - Return a string used to compose global names and labels. A
 548 /// A global variable name needs to be defined for each debug descriptor that is
 549 /// anchored. NOTE: that each global variable named here also needs to be added
 550 /// to the list of names left external in the internalizer.
 551 ///   ExternalNames.insert("llvm.dbg.compile_units");
 552 ///   ExternalNames.insert("llvm.dbg.global_variables");
 553 ///   ExternalNames.insert("llvm.dbg.subprograms");
 554 const char *AnchorDesc::getDescString() const {
 555   switch (AnchorTag) {
 556   case DW_TAG_compile_unit: return CompileUnitDesc::AnchorString;
 557   case DW_TAG_variable:     return GlobalVariableDesc::AnchorString;
 558   case DW_TAG_subprogram:   return SubprogramDesc::AnchorString;
 559   default: break;
 560   }
 561
 562   assert(0 && "Tag does not have a case for anchor string");
 563   return "";
 564 }
 565
 566 /// getTypeString - Return a string used to label this descriptors type.
 567 ///
 568 const char *AnchorDesc::getTypeString() const {
 569   return "llvm.dbg.anchor.type";
 570 }
 571
 572 #ifndef NDEBUG
 573 void AnchorDesc::dump() {
 574   std::cerr << getDescString() << " "
 575             << "Version(" << getVersion() << "), "
 576             << "Tag(" << getTag() << "), "
 577             << "AnchorTag(" << AnchorTag << ")\n";
 578 }
 579 #endif
 580
 581 //===----------------------------------------------------------------------===//
 582
 583 AnchoredDesc::AnchoredDesc(unsigned T)
 584 : DebugInfoDesc(T)
 585 , Anchor(NULL)
 586 {}
 587
 588 /// ApplyToFields - Target the visitor to the fields of the AnchoredDesc.
 589 ///
 590 void AnchoredDesc::ApplyToFields(DIVisitor *Visitor) {
 591   DebugInfoDesc::ApplyToFields(Visitor);
 592
 593   DebugInfoDesc *Tmp = Anchor;
 594   Visitor->Apply(Tmp);
 595   Anchor = (AnchorDesc*)Tmp;
 596 }
 597
 598 //===----------------------------------------------------------------------===//
 599
 600 CompileUnitDesc::CompileUnitDesc()
 601 : AnchoredDesc(DW_TAG_compile_unit)
 602 , Language(0)
 603 , FileName("")
 604 , Directory("")
 605 , Producer("")
 606 {}
 607
 608 // Implement isa/cast/dyncast.
 609 bool CompileUnitDesc::classof(const DebugInfoDesc *D) {
 610   return D->getTag() == DW_TAG_compile_unit;
 611 }
 612
 613 /// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc.
 614 ///
 615 void CompileUnitDesc::ApplyToFields(DIVisitor *Visitor) {
 616   AnchoredDesc::ApplyToFields(Visitor);
 617
 618   Visitor->Apply(Language);
 619   Visitor->Apply(FileName);
 620   Visitor->Apply(Directory);
 621   Visitor->Apply(Producer);
 622 }
 623
 624 /// getDescString - Return a string used to compose global names and labels.
 625 ///
 626 const char *CompileUnitDesc::getDescString() const {
 627   return "llvm.dbg.compile_unit";
 628 }
 629
 630 /// getTypeString - Return a string used to label this descriptors type.
 631 ///
 632 const char *CompileUnitDesc::getTypeString() const {
 633   return "llvm.dbg.compile_unit.type";
 634 }
 635
 636 /// getAnchorString - Return a string used to label this descriptor's anchor.
 637 ///
 638 const char *CompileUnitDesc::AnchorString = "llvm.dbg.compile_units";
 639 const char *CompileUnitDesc::getAnchorString() const {
 640   return AnchorString;
 641 }
 642
 643 #ifndef NDEBUG
 644 void CompileUnitDesc::dump() {
 645   std::cerr << getDescString() << " "
 646             << "Version(" << getVersion() << "), "
 647             << "Tag(" << getTag() << "), "
 648             << "Anchor(" << getAnchor() << "), "
 649             << "Language(" << Language << "), "
 650             << "FileName(\"" << FileName << "\"), "
 651             << "Directory(\"" << Directory << "\"), "
 652             << "Producer(\"" << Producer << "\")\n";
 653 }
 654 #endif
 655
 656 //===----------------------------------------------------------------------===//
 657
 658 TypeDesc::TypeDesc(unsigned T)
 659 : DebugInfoDesc(T)
 660 , Context(NULL)
 661 , Name("")
 662 , File(NULL)
 663 , Line(0)
 664 , Size(0)
 665 , Align(0)
 666 , Offset(0)
 667 {}
 668
 669 /// ApplyToFields - Target the visitor to the fields of the TypeDesc.
 670 ///
 671 void TypeDesc::ApplyToFields(DIVisitor *Visitor) {
 672   DebugInfoDesc::ApplyToFields(Visitor);
 673
 674   Visitor->Apply(Context);
 675   Visitor->Apply(Name);
 676   DebugInfoDesc* Tmp = File;
 677   Visitor->Apply(Tmp);
 678   File = (CompileUnitDesc*)Tmp;
 679   Visitor->Apply(Line);
 680   Visitor->Apply(Size);
 681   Visitor->Apply(Align);
 682   Visitor->Apply(Offset);
 683 }
 684
 685 /// getDescString - Return a string used to compose global names and labels.
 686 ///
 687 const char *TypeDesc::getDescString() const {
 688   return "llvm.dbg.type";
 689 }
 690
 691 /// getTypeString - Return a string used to label this descriptor's type.
 692 ///
 693 const char *TypeDesc::getTypeString() const {
 694   return "llvm.dbg.type.type";
 695 }
 696
 697 #ifndef NDEBUG
 698 void TypeDesc::dump() {
 699   std::cerr << getDescString() << " "
 700             << "Version(" << getVersion() << "), "
 701             << "Tag(" << getTag() << "), "
 702             << "Context(" << Context << "), "
 703             << "Name(\"" << Name << "\"), "
 704             << "File(" << File << "), "
 705             << "Line(" << Line << "), "
 706             << "Size(" << Size << "), "
 707             << "Align(" << Align << "), "
 708             << "Offset(" << Offset << ")\n";
 709 }
 710 #endif
 711
 712 //===----------------------------------------------------------------------===//
 713
 714 BasicTypeDesc::BasicTypeDesc()
 715 : TypeDesc(DW_TAG_base_type)
 716 , Encoding(0)
 717 {}
 718
 719 // Implement isa/cast/dyncast.
 720 bool BasicTypeDesc::classof(const DebugInfoDesc *D) {
 721   return D->getTag() == DW_TAG_base_type;
 722 }
 723
 724 /// ApplyToFields - Target the visitor to the fields of the BasicTypeDesc.
 725 ///
 726 void BasicTypeDesc::ApplyToFields(DIVisitor *Visitor) {
 727   TypeDesc::ApplyToFields(Visitor);
 728
 729   Visitor->Apply(Encoding);
 730 }
 731
 732 /// getDescString - Return a string used to compose global names and labels.
 733 ///
 734 const char *BasicTypeDesc::getDescString() const {
 735   return "llvm.dbg.basictype";
 736 }
 737
 738 /// getTypeString - Return a string used to label this descriptor's type.
 739 ///
 740 const char *BasicTypeDesc::getTypeString() const {
 741   return "llvm.dbg.basictype.type";
 742 }
 743
 744 #ifndef NDEBUG
 745 void BasicTypeDesc::dump() {
 746   std::cerr << getDescString() << " "
 747             << "Version(" << getVersion() << "), "
 748             << "Tag(" << getTag() << "), "
 749             << "Context(" << getContext() << "), "
 750             << "Name(\"" << getName() << "\"), "
 751             << "Size(" << getSize() << "), "
 752             << "Encoding(" << Encoding << ")\n";
 753 }
 754 #endif
 755
 756 //===----------------------------------------------------------------------===//
 757
 758 DerivedTypeDesc::DerivedTypeDesc(unsigned T)
 759 : TypeDesc(T)
 760 , FromType(NULL)
 761 {}
 762
 763 // Implement isa/cast/dyncast.
 764 bool DerivedTypeDesc::classof(const DebugInfoDesc *D) {
 765   unsigned T =  D->getTag();
 766   switch (T) {
 767   case DW_TAG_typedef:
 768   case DW_TAG_pointer_type:
 769   case DW_TAG_reference_type:
 770   case DW_TAG_const_type:
 771   case DW_TAG_volatile_type:
 772   case DW_TAG_restrict_type:
 773   case DW_TAG_member:
 774     return true;
 775   default: break;
 776   }
 777   return false;
 778 }
 779
 780 /// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc.
 781 ///
 782 void DerivedTypeDesc::ApplyToFields(DIVisitor *Visitor) {
 783   TypeDesc::ApplyToFields(Visitor);
 784
 785   DebugInfoDesc* Tmp = FromType;
 786   Visitor->Apply(Tmp);
 787   FromType = (TypeDesc*)Tmp;
 788 }
 789
 790 /// getDescString - Return a string used to compose global names and labels.
 791 ///
 792 const char *DerivedTypeDesc::getDescString() const {
 793   return "llvm.dbg.derivedtype";
 794 }
 795
 796 /// getTypeString - Return a string used to label this descriptor's type.
 797 ///
 798 const char *DerivedTypeDesc::getTypeString() const {
 799   return "llvm.dbg.derivedtype.type";
 800 }
 801
 802 #ifndef NDEBUG
 803 void DerivedTypeDesc::dump() {
 804   std::cerr << getDescString() << " "
 805             << "Version(" << getVersion() << "), "
 806             << "Tag(" << getTag() << "), "
 807             << "Context(" << getContext() << "), "
 808             << "Name(\"" << getName() << "\"), "
 809             << "Size(" << getSize() << "), "
 810             << "File(" << getFile() << "), "
 811             << "Line(" << getLine() << "), "
 812             << "FromType(" << FromType << ")\n";
 813 }
 814 #endif
 815
 816 //===----------------------------------------------------------------------===//
 817
 818 CompositeTypeDesc::CompositeTypeDesc(unsigned T)
 819 : DerivedTypeDesc(T)
 820 , IsVector(false)
 821 , Elements()
 822 {}
 823
 824 // Implement isa/cast/dyncast.
 825 bool CompositeTypeDesc::classof(const DebugInfoDesc *D) {
 826   unsigned T =  D->getTag();
 827   switch (T) {
 828   case DW_TAG_array_type:
 829   case DW_TAG_structure_type:
 830   case DW_TAG_union_type:
 831   case DW_TAG_enumeration_type:
 832     return true;
 833   default: break;
 834   }
 835   return false;
 836 }
 837
 838 /// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc.
 839 ///
 840 void CompositeTypeDesc::ApplyToFields(DIVisitor *Visitor) {
 841   DerivedTypeDesc::ApplyToFields(Visitor);
 842
 843   Visitor->Apply(IsVector);
 844   Visitor->Apply(Elements);
 845 }
 846
 847 /// getDescString - Return a string used to compose global names and labels.
 848 ///
 849 const char *CompositeTypeDesc::getDescString() const {
 850   return "llvm.dbg.compositetype";
 851 }
 852
 853 /// getTypeString - Return a string used to label this descriptor's type.
 854 ///
 855 const char *CompositeTypeDesc::getTypeString() const {
 856   return "llvm.dbg.compositetype.type";
 857 }
 858
 859 #ifndef NDEBUG
 860 void CompositeTypeDesc::dump() {
 861   std::cerr << getDescString() << " "
 862             << "Version(" << getVersion() << "), "
 863             << "Tag(" << getTag() << "), "
 864             << "Context(" << getContext() << "), "
 865             << "Name(\"" << getName() << "\"), "
 866             << "Size(" << getSize() << "), "
 867             << "File(" << getFile() << "), "
 868             << "Line(" << getLine() << "), "
 869             << "FromType(" << getFromType() << "), "
 870             << "Elements.size(" << Elements.size() << ")\n";
 871 }
 872 #endif
 873
 874 //===----------------------------------------------------------------------===//
 875
 876 SubrangeDesc::SubrangeDesc()
 877 : DebugInfoDesc(DW_TAG_subrange_type)
 878 , Lo(0)
 879 , Hi(0)
 880 {}
 881
 882 // Implement isa/cast/dyncast.
 883 bool SubrangeDesc::classof(const DebugInfoDesc *D) {
 884   return D->getTag() == DW_TAG_subrange_type;
 885 }
 886
 887 /// ApplyToFields - Target the visitor to the fields of the SubrangeDesc.
 888 ///
 889 void SubrangeDesc::ApplyToFields(DIVisitor *Visitor) {
 890   DebugInfoDesc::ApplyToFields(Visitor);
 891
 892   Visitor->Apply(Lo);
 893   Visitor->Apply(Hi);
 894 }
 895
 896 /// getDescString - Return a string used to compose global names and labels.
 897 ///
 898 const char *SubrangeDesc::getDescString() const {
 899   return "llvm.dbg.subrange";
 900 }
 901
 902 /// getTypeString - Return a string used to label this descriptor's type.
 903 ///
 904 const char *SubrangeDesc::getTypeString() const {
 905   return "llvm.dbg.subrange.type";
 906 }
 907
 908 #ifndef NDEBUG
 909 void SubrangeDesc::dump() {
 910   std::cerr << getDescString() << " "
 911             << "Version(" << getVersion() << "), "
 912             << "Tag(" << getTag() << "), "
 913             << "Lo(" << Lo << "), "
 914             << "Hi(" << Hi << ")\n";
 915 }
 916 #endif
 917
 918 //===----------------------------------------------------------------------===//
 919
 920 EnumeratorDesc::EnumeratorDesc()
 921 : DebugInfoDesc(DW_TAG_enumerator)
 922 , Name("")
 923 , Value(0)
 924 {}
 925
 926 // Implement isa/cast/dyncast.
 927 bool EnumeratorDesc::classof(const DebugInfoDesc *D) {
 928   return D->getTag() == DW_TAG_enumerator;
 929 }
 930
 931 /// ApplyToFields - Target the visitor to the fields of the EnumeratorDesc.
 932 ///
 933 void EnumeratorDesc::ApplyToFields(DIVisitor *Visitor) {
 934   DebugInfoDesc::ApplyToFields(Visitor);
 935
 936   Visitor->Apply(Name);
 937   Visitor->Apply(Value);
 938 }
 939
 940 /// getDescString - Return a string used to compose global names and labels.
 941 ///
 942 const char *EnumeratorDesc::getDescString() const {
 943   return "llvm.dbg.enumerator";
 944 }
 945
 946 /// getTypeString - Return a string used to label this descriptor's type.
 947 ///
 948 const char *EnumeratorDesc::getTypeString() const {
 949   return "llvm.dbg.enumerator.type";
 950 }
 951
 952 #ifndef NDEBUG
 953 void EnumeratorDesc::dump() {
 954   std::cerr << getDescString() << " "
 955             << "Version(" << getVersion() << "), "
 956             << "Tag(" << getTag() << "), "
 957             << "Name(" << Name << "), "
 958             << "Value(" << Value << ")\n";
 959 }
 960 #endif
 961
 962 //===----------------------------------------------------------------------===//
 963
 964 VariableDesc::VariableDesc(unsigned T)
 965 : DebugInfoDesc(T)
 966 , Context(NULL)
 967 , Name("")
 968 , File(NULL)
 969 , Line(0)
 970 , TyDesc(0)
 971 {}
 972
 973 // Implement isa/cast/dyncast.
 974 bool VariableDesc::classof(const DebugInfoDesc *D) {
 975   unsigned T =  D->getTag();
 976   switch (T) {
 977   case DW_TAG_auto_variable:
 978   case DW_TAG_arg_variable:
 979   case DW_TAG_return_variable:
 980     return true;
 981   default: break;
 982   }
 983   return false;
 984 }
 985
 986 /// ApplyToFields - Target the visitor to the fields of the VariableDesc.
 987 ///
 988 void VariableDesc::ApplyToFields(DIVisitor *Visitor) {
 989   DebugInfoDesc::ApplyToFields(Visitor);
 990
 991   Visitor->Apply(Context);
 992   Visitor->Apply(Name);
 993   DebugInfoDesc* Tmp1 = File;
 994   Visitor->Apply(Tmp1);
 995   File = (CompileUnitDesc*)Tmp1;
 996   Visitor->Apply(Line);
 997   DebugInfoDesc* Tmp2 = TyDesc;
 998   Visitor->Apply(Tmp2);
 999   TyDesc = (TypeDesc*)Tmp2;
1000 }
1001
1002 /// getDescString - Return a string used to compose global names and labels.
1003 ///
1004 const char *VariableDesc::getDescString() const {
1005   return "llvm.dbg.variable";
1006 }
1007
1008 /// getTypeString - Return a string used to label this descriptor's type.
1009 ///
1010 const char *VariableDesc::getTypeString() const {
1011   return "llvm.dbg.variable.type";
1012 }
1013
1014 #ifndef NDEBUG
1015 void VariableDesc::dump() {
1016   std::cerr << getDescString() << " "
1017             << "Version(" << getVersion() << "), "
1018             << "Tag(" << getTag() << "), "
1019             << "Context(" << Context << "), "
1020             << "Name(\"" << Name << "\"), "
1021             << "File(" << File << "), "
1022             << "Line(" << Line << "), "
1023             << "TyDesc(" << TyDesc << ")\n";
1024 }
1025 #endif
1026
1027 //===----------------------------------------------------------------------===//
1028
1029 GlobalDesc::GlobalDesc(unsigned T)
1030 : AnchoredDesc(T)
1031 , Context(0)
1032 , Name("")
1033 , File(NULL)
1034 , Line(0)
1035 , TyDesc(NULL)
1036 , IsStatic(false)
1037 , IsDefinition(false)
1038 {}
1039
1040 /// ApplyToFields - Target the visitor to the fields of the global.
1041 ///
1042 void GlobalDesc::ApplyToFields(DIVisitor *Visitor) {
1043   AnchoredDesc::ApplyToFields(Visitor);
1044
1045   Visitor->Apply(Context);
1046   Visitor->Apply(Name);
1047   DebugInfoDesc* Tmp1 = File;
1048   Visitor->Apply(Tmp1);
1049   File = (CompileUnitDesc*)Tmp1;
1050   Visitor->Apply(Line);
1051   DebugInfoDesc* Tmp2 = TyDesc;
1052   Visitor->Apply(Tmp2);
1053   TyDesc = (TypeDesc*)Tmp2;
1054   Visitor->Apply(IsStatic);
1055   Visitor->Apply(IsDefinition);
1056 }
1057
1058 //===----------------------------------------------------------------------===//
1059
1060 GlobalVariableDesc::GlobalVariableDesc()
1061 : GlobalDesc(DW_TAG_variable)
1062 , Global(NULL)
1063 {}
1064
1065 // Implement isa/cast/dyncast.
1066 bool GlobalVariableDesc::classof(const DebugInfoDesc *D) {
1067   return D->getTag() == DW_TAG_variable;
1068 }
1069
1070 /// ApplyToFields - Target the visitor to the fields of the GlobalVariableDesc.
1071 ///
1072 void GlobalVariableDesc::ApplyToFields(DIVisitor *Visitor) {
1073   GlobalDesc::ApplyToFields(Visitor);
1074
1075   Visitor->Apply(Global);
1076 }
1077
1078 /// getDescString - Return a string used to compose global names and labels.
1079 ///
1080 const char *GlobalVariableDesc::getDescString() const {
1081   return "llvm.dbg.global_variable";
1082 }
1083
1084 /// getTypeString - Return a string used to label this descriptors type.
1085 ///
1086 const char *GlobalVariableDesc::getTypeString() const {
1087   return "llvm.dbg.global_variable.type";
1088 }
1089
1090 /// getAnchorString - Return a string used to label this descriptor's anchor.
1091 ///
1092 const char *GlobalVariableDesc::AnchorString = "llvm.dbg.global_variables";
1093 const char *GlobalVariableDesc::getAnchorString() const {
1094   return AnchorString;
1095 }
1096
1097 #ifndef NDEBUG
1098 void GlobalVariableDesc::dump() {
1099   std::cerr << getDescString() << " "
1100             << "Version(" << getVersion() << "), "
1101             << "Tag(" << getTag() << "), "
1102             << "Anchor(" << getAnchor() << "), "
1103             << "Name(\"" << getName() << "\"), "
1104             << "File(" << getFile() << "),"
1105             << "Line(" << getLine() << "),"
1106             << "Type(\"" << getType() << "\"), "
1107             << "IsStatic(" << (isStatic() ? "true" : "false") << "), "
1108             << "IsDefinition(" << (isDefinition() ? "true" : "false") << "), "
1109             << "Global(" << Global << ")\n";
1110 }
1111 #endif
1112
1113 //===----------------------------------------------------------------------===//
1114
1115 SubprogramDesc::SubprogramDesc()
1116 : GlobalDesc(DW_TAG_subprogram)
1117 {}
1118
1119 // Implement isa/cast/dyncast.
1120 bool SubprogramDesc::classof(const DebugInfoDesc *D) {
1121   return D->getTag() == DW_TAG_subprogram;
1122 }
1123
1124 /// ApplyToFields - Target the visitor to the fields of the
1125 /// SubprogramDesc.
1126 void SubprogramDesc::ApplyToFields(DIVisitor *Visitor) {
1127   GlobalDesc::ApplyToFields(Visitor);
1128 }
1129
1130 /// getDescString - Return a string used to compose global names and labels.
1131 ///
1132 const char *SubprogramDesc::getDescString() const {
1133   return "llvm.dbg.subprogram";
1134 }
1135
1136 /// getTypeString - Return a string used to label this descriptors type.
1137 ///
1138 const char *SubprogramDesc::getTypeString() const {
1139   return "llvm.dbg.subprogram.type";
1140 }
1141
1142 /// getAnchorString - Return a string used to label this descriptor's anchor.
1143 ///
1144 const char *SubprogramDesc::AnchorString = "llvm.dbg.subprograms";
1145 const char *SubprogramDesc::getAnchorString() const {
1146   return AnchorString;
1147 }
1148
1149 #ifndef NDEBUG
1150 void SubprogramDesc::dump() {
1151   std::cerr << getDescString() << " "
1152             << "Version(" << getVersion() << "), "
1153             << "Tag(" << getTag() << "), "
1154             << "Anchor(" << getAnchor() << "), "
1155             << "Name(\"" << getName() << "\"), "
1156             << "File(" << getFile() << "),"
1157             << "Line(" << getLine() << "),"
1158             << "Type(\"" << getType() << "\"), "
1159             << "IsStatic(" << (isStatic() ? "true" : "false") << "), "
1160             << "IsDefinition(" << (isDefinition() ? "true" : "false") << ")\n";
1161 }
1162 #endif
1163
1164 //===----------------------------------------------------------------------===//
1165
1166 BlockDesc::BlockDesc()
1167 : DebugInfoDesc(DW_TAG_lexical_block)
1168 , Context(NULL)
1169 {}
1170
1171 // Implement isa/cast/dyncast.
1172 bool BlockDesc::classof(const DebugInfoDesc *D) {
1173   return D->getTag() == DW_TAG_lexical_block;
1174 }
1175
1176 /// ApplyToFields - Target the visitor to the fields of the BlockDesc.
1177 ///
1178 void BlockDesc::ApplyToFields(DIVisitor *Visitor) {
1179   DebugInfoDesc::ApplyToFields(Visitor);
1180
1181   Visitor->Apply(Context);
1182 }
1183
1184 /// getDescString - Return a string used to compose global names and labels.
1185 ///
1186 const char *BlockDesc::getDescString() const {
1187   return "llvm.dbg.block";
1188 }
1189
1190 /// getTypeString - Return a string used to label this descriptors type.
1191 ///
1192 const char *BlockDesc::getTypeString() const {
1193   return "llvm.dbg.block.type";
1194 }
1195
1196 #ifndef NDEBUG
1197 void BlockDesc::dump() {
1198   std::cerr << getDescString() << " "
1199             << "Version(" << getVersion() << "), "
1200             << "Tag(" << getTag() << "),"
1201             << "Context(" << Context << ")\n";
1202 }
1203 #endif
1204
1205 //===----------------------------------------------------------------------===//
1206
1207 DebugInfoDesc *DIDeserializer::Deserialize(Value *V) {
1208   return Deserialize(getGlobalVariable(V));
1209 }
1210 DebugInfoDesc *DIDeserializer::Deserialize(GlobalVariable *GV) {
1211   // Handle NULL.
1212   if (!GV) return NULL;
1213
1214   // Check to see if it has been already deserialized.
1215   DebugInfoDesc *&Slot = GlobalDescs[GV];
1216   if (Slot) return Slot;
1217
1218   // Get the Tag from the global.
1219   unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
1220
1221   // Create an empty instance of the correct sort.
1222   Slot = DebugInfoDesc::DescFactory(Tag);
1223
1224   // If not a user defined descriptor.
1225   if (Slot) {
1226     // Deserialize the fields.
1227     DIDeserializeVisitor DRAM(*this, GV);
1228     DRAM.ApplyToFields(Slot);
1229   }
1230
1231   return Slot;
1232 }
1233
1234 //===----------------------------------------------------------------------===//
1235
1236 /// getStrPtrType - Return a "sbyte *" type.
1237 ///
1238 const PointerType *DISerializer::getStrPtrType() {
1239   // If not already defined.
1240   if (!StrPtrTy) {
1241     // Construct the pointer to signed bytes.
1242     StrPtrTy = PointerType::get(Type::SByteTy);
1243   }
1244
1245   return StrPtrTy;
1246 }
1247
1248 /// getEmptyStructPtrType - Return a "{ }*" type.
1249 ///
1250 const PointerType *DISerializer::getEmptyStructPtrType() {
1251   // If not already defined.
1252   if (!EmptyStructPtrTy) {
1253     // Construct the empty structure type.
1254     const StructType *EmptyStructTy =
1255                                     StructType::get(std::vector<const Type*>());
1256     // Construct the pointer to empty structure type.
1257     EmptyStructPtrTy = PointerType::get(EmptyStructTy);
1258   }
1259
1260   return EmptyStructPtrTy;
1261 }
1262
1263 /// getTagType - Return the type describing the specified descriptor (via tag.)
1264 ///
1265 const StructType *DISerializer::getTagType(DebugInfoDesc *DD) {
1266   // Attempt to get the previously defined type.
1267   StructType *&Ty = TagTypes[DD->getTag()];
1268
1269   // If not already defined.
1270   if (!Ty) {
1271     // Set up fields vector.
1272     std::vector<const Type*> Fields;
1273     // Get types of fields.
1274     DIGetTypesVisitor GTAM(*this, Fields);
1275     GTAM.ApplyToFields(DD);
1276
1277     // Construct structured type.
1278     Ty = StructType::get(Fields);
1279
1280     // Register type name with module.
1281     M->addTypeName(DD->getTypeString(), Ty);
1282   }
1283
1284   return Ty;
1285 }
1286
1287 /// getString - Construct the string as constant string global.
1288 ///
1289 Constant *DISerializer::getString(const std::string &String) {
1290   // Check string cache for previous edition.
1291   Constant *&Slot = StringCache[String];
1292   // Return Constant if previously defined.
1293   if (Slot) return Slot;
1294   // If empty string then use a sbyte* null instead.
1295   if (String.empty()) {
1296     Slot = ConstantPointerNull::get(getStrPtrType());
1297   } else {
1298     // Construct string as an llvm constant.
1299     Constant *ConstStr = ConstantArray::get(String);
1300     // Otherwise create and return a new string global.
1301     GlobalVariable *StrGV = new GlobalVariable(ConstStr->getType(), true,
1302                                                GlobalVariable::InternalLinkage,
1303                                                ConstStr, "str", M);
1304     StrGV->setSection("llvm.metadata");
1305     // Convert to generic string pointer.
1306     Slot = ConstantExpr::getCast(StrGV, getStrPtrType());
1307   }
1308   return Slot;
1309
1310 }
1311
1312 /// Serialize - Recursively cast the specified descriptor into a GlobalVariable
1313 /// so that it can be serialized to a .bc or .ll file.
1314 GlobalVariable *DISerializer::Serialize(DebugInfoDesc *DD) {
1315   // Check if the DebugInfoDesc is already in the map.
1316   GlobalVariable *&Slot = DescGlobals[DD];
1317
1318   // See if DebugInfoDesc exists, if so return prior GlobalVariable.
1319   if (Slot) return Slot;
1320
1321   // Get the type associated with the Tag.
1322   const StructType *Ty = getTagType(DD);
1323
1324   // Create the GlobalVariable early to prevent infinite recursion.
1325   GlobalVariable *GV = new GlobalVariable(Ty, true, DD->getLinkage(),
1326                                           NULL, DD->getDescString(), M);
1327   GV->setSection("llvm.metadata");
1328
1329   // Insert new GlobalVariable in DescGlobals map.
1330   Slot = GV;
1331
1332   // Set up elements vector
1333   std::vector<Constant*> Elements;
1334   // Add fields.
1335   DISerializeVisitor SRAM(*this, Elements);
1336   SRAM.ApplyToFields(DD);
1337
1338   // Set the globals initializer.
1339   GV->setInitializer(ConstantStruct::get(Ty, Elements));
1340
1341   return GV;
1342 }
1343
1344 //===----------------------------------------------------------------------===//
1345
1346 /// Verify - Return true if the GlobalVariable appears to be a valid
1347 /// serialization of a DebugInfoDesc.
1348 bool DIVerifier::Verify(Value *V) {
1349   return !V || Verify(getGlobalVariable(V));
1350 }
1351 bool DIVerifier::Verify(GlobalVariable *GV) {
1352   // NULLs are valid.
1353   if (!GV) return true;
1354
1355   // Check prior validity.
1356   unsigned &ValiditySlot = Validity[GV];
1357
1358   // If visited before then use old state.
1359   if (ValiditySlot) return ValiditySlot == Valid;
1360
1361   // Assume validity for the time being (recursion.)
1362   ValiditySlot = Valid;
1363
1364   // Make sure the global is internal or link once (anchor.)
1365   if (GV->getLinkage() != GlobalValue::InternalLinkage &&
1366       GV->getLinkage() != GlobalValue::LinkOnceLinkage) {
1367     ValiditySlot = Invalid;
1368     return false;
1369   }
1370
1371   // Get the Tag
1372   unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
1373
1374   // Check for user defined descriptors.
1375   if (Tag == DW_TAG_invalid) return true;
1376
1377   // Construct an empty DebugInfoDesc.
1378   DebugInfoDesc *DD = DebugInfoDesc::DescFactory(Tag);
1379
1380   // Allow for user defined descriptors.
1381   if (!DD) return true;
1382
1383   // Get the initializer constant.
1384   ConstantStruct *CI = cast<ConstantStruct>(GV->getInitializer());
1385
1386   // Get the operand count.
1387   unsigned N = CI->getNumOperands();
1388
1389   // Get the field count.
1390   unsigned &CountSlot = Counts[Tag];
1391   if (!CountSlot) {
1392     // Check the operand count to the field count
1393     DICountVisitor CTAM;
1394     CTAM.ApplyToFields(DD);
1395     CountSlot = CTAM.getCount();
1396   }
1397
1398   // Field count must be at most equal operand count.
1399   if (CountSlot >  N) {
1400     delete DD;
1401     ValiditySlot = Invalid;
1402     return false;
1403   }
1404
1405   // Check each field for valid type.
1406   DIVerifyVisitor VRAM(*this, GV);
1407   VRAM.ApplyToFields(DD);
1408
1409   // Release empty DebugInfoDesc.
1410   delete DD;
1411
1412   // If fields are not valid.
1413   if (!VRAM.isValid()) {
1414     ValiditySlot = Invalid;
1415     return false;
1416   }
1417
1418   return true;
1419 }
1420
1421 //===----------------------------------------------------------------------===//
1422
1423 DebugScope::~DebugScope() {
1424   for (unsigned i = 0, N = Scopes.size(); i < N; ++i) delete Scopes[i];
1425   for (unsigned j = 0, M = Variables.size(); j < M; ++j) delete Variables[j];
1426 }
1427
1428 //===----------------------------------------------------------------------===//
1429
1430 MachineDebugInfo::MachineDebugInfo()
1431 : DR()
1432 , VR()
1433 , CompileUnits()
1434 , Directories()
1435 , SourceFiles()
1436 , Lines()
1437 , LabelID(0)
1438 , ScopeMap()
1439 , RootScope(NULL)
1440 , FrameMoves()
1441 {}
1442 MachineDebugInfo::~MachineDebugInfo() {
1443
1444 }
1445
1446 /// doInitialization - Initialize the debug state for a new module.
1447 ///
1448 bool MachineDebugInfo::doInitialization() {
1449   return false;
1450 }
1451
1452 /// doFinalization - Tear down the debug state after completion of a module.
1453 ///
1454 bool MachineDebugInfo::doFinalization() {
1455   return false;
1456 }
1457
1458 /// BeginFunction - Begin gathering function debug information.
1459 ///
1460 void MachineDebugInfo::BeginFunction(MachineFunction *MF) {
1461   // Coming soon.
1462 }
1463
1464 /// MachineDebugInfo::EndFunction - Discard function debug information.
1465 ///
1466 void MachineDebugInfo::EndFunction() {
1467   // Clean up scope information.
1468   if (RootScope) {
1469     delete RootScope;
1470     ScopeMap.clear();
1471     RootScope = NULL;
1472   }
1473
1474   // Clean up frame info.
1475   for (unsigned i = 0, N = FrameMoves.size(); i < N; ++i) delete FrameMoves[i];
1476   FrameMoves.clear();
1477 }
1478
1479 /// getDescFor - Convert a Value to a debug information descriptor.
1480 ///
1481 // FIXME - use new Value type when available.
1482 DebugInfoDesc *MachineDebugInfo::getDescFor(Value *V) {
1483   return DR.Deserialize(V);
1484 }
1485
1486 /// Verify - Verify that a Value is debug information descriptor.
1487 ///
1488 bool MachineDebugInfo::Verify(Value *V) {
1489   return VR.Verify(V);
1490 }
1491
1492 /// AnalyzeModule - Scan the module for global debug information.
1493 ///
1494 void MachineDebugInfo::AnalyzeModule(Module &M) {
1495   SetupCompileUnits(M);
1496 }
1497
1498 /// SetupCompileUnits - Set up the unique vector of compile units.
1499 ///
1500 void MachineDebugInfo::SetupCompileUnits(Module &M) {
1501   std::vector<CompileUnitDesc *>CU = getAnchoredDescriptors<CompileUnitDesc>(M);
1502
1503   for (unsigned i = 0, N = CU.size(); i < N; i++) {
1504     CompileUnits.insert(CU[i]);
1505   }
1506 }
1507
1508 /// getCompileUnits - Return a vector of debug compile units.
1509 ///
1510 const UniqueVector<CompileUnitDesc *> MachineDebugInfo::getCompileUnits()const{
1511   return CompileUnits;
1512 }
1513
1514 /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the
1515 /// named GlobalVariable.
1516 std::vector<GlobalVariable*>
1517 MachineDebugInfo::getGlobalVariablesUsing(Module &M,
1518                                           const std::string &RootName) {
1519   return ::getGlobalVariablesUsing(M, RootName);
1520 }
1521
1522 /// RecordLabel - Records location information and associates it with a
1523 /// debug label.  Returns a unique label ID used to generate a label and
1524 /// provide correspondence to the source line list.
1525 unsigned MachineDebugInfo::RecordLabel(unsigned Line, unsigned Column,
1526                                        unsigned Source) {
1527   unsigned ID = NextLabelID();
1528   Lines.push_back(new SourceLineInfo(Line, Column, Source, ID));
1529   return ID;
1530 }
1531
1532 /// RecordSource - Register a source file with debug info. Returns an source
1533 /// ID.
1534 unsigned MachineDebugInfo::RecordSource(const std::string &Directory,
1535                                         const std::string &Source) {
1536   unsigned DirectoryID = Directories.insert(Directory);
1537   return SourceFiles.insert(SourceFileInfo(DirectoryID, Source));
1538 }
1539 unsigned MachineDebugInfo::RecordSource(const CompileUnitDesc *CompileUnit) {
1540   return RecordSource(CompileUnit->getDirectory(),
1541                       CompileUnit->getFileName());
1542 }
1543
1544 /// RecordRegionStart - Indicate the start of a region.
1545 ///
1546 unsigned MachineDebugInfo::RecordRegionStart(Value *V) {
1547   // FIXME - need to be able to handle split scopes because of bb cloning.
1548   DebugInfoDesc *ScopeDesc = DR.Deserialize(V);
1549   DebugScope *Scope = getOrCreateScope(ScopeDesc);
1550   unsigned ID = NextLabelID();
1551   if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID);
1552   return ID;
1553 }
1554
1555 /// RecordRegionEnd - Indicate the end of a region.
1556 ///
1557 unsigned MachineDebugInfo::RecordRegionEnd(Value *V) {
1558   // FIXME - need to be able to handle split scopes because of bb cloning.
1559   DebugInfoDesc *ScopeDesc = DR.Deserialize(V);
1560   DebugScope *Scope = getOrCreateScope(ScopeDesc);
1561   unsigned ID = NextLabelID();
1562   Scope->setEndLabelID(ID);
1563   return ID;
1564 }
1565
1566 /// RecordVariable - Indicate the declaration of  a local variable.
1567 ///
1568 void MachineDebugInfo::RecordVariable(Value *V, unsigned FrameIndex) {
1569   VariableDesc *VD = cast<VariableDesc>(DR.Deserialize(V));
1570   DebugScope *Scope = getOrCreateScope(VD->getContext());
1571   DebugVariable *DV = new DebugVariable(VD, FrameIndex);
1572   Scope->AddVariable(DV);
1573 }
1574
1575 /// getOrCreateScope - Returns the scope associated with the given descriptor.
1576 ///
1577 DebugScope *MachineDebugInfo::getOrCreateScope(DebugInfoDesc *ScopeDesc) {
1578   DebugScope *&Slot = ScopeMap[ScopeDesc];
1579   if (!Slot) {
1580     // FIXME - breaks down when the context is an inlined function.
1581     DebugInfoDesc *ParentDesc = NULL;
1582     if (BlockDesc *Block = dyn_cast<BlockDesc>(ScopeDesc)) {
1583       ParentDesc = Block->getContext();
1584     }
1585     DebugScope *Parent = ParentDesc ? getOrCreateScope(ParentDesc) : NULL;
1586     Slot = new DebugScope(Parent, ScopeDesc);
1587     if (Parent) {
1588       Parent->AddScope(Slot);
1589     } else if (RootScope) {
1590       // FIXME - Add inlined function scopes to the root so we can delete
1591       // them later.  Long term, handle inlined functions properly.
1592       RootScope->AddScope(Slot);
1593     } else {
1594       // First function is top level function.
1595       RootScope = Slot;
1596     }
1597   }
1598   return Slot;
1599 }
1600
1601