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