lib/VMCore/Module.cpp

   1 //===-- Module.cpp - Implement the Module class ------------------*- C++ -*--=//
   2 //
   3 // This file implements the Module class for the VMCore library.
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   7 #include "llvm/Module.h"
   8 #include "llvm/Function.h"
   9 #include "llvm/GlobalVariable.h"
  10 #include "llvm/InstrTypes.h"
  11 #include "llvm/ValueHolderImpl.h"
  12 #include "llvm/Type.h"
  13 #include "llvm/ConstantVals.h"
  14 #include "llvm/DerivedTypes.h"
  15 #include "Support/STLExtras.h"
  16 #include <map>
  17
  18 // Instantiate Templates - This ugliness is the price we have to pay
  19 // for having a DefHolderImpl.h file seperate from DefHolder.h!  :(
  20 //
  21 template class ValueHolder<GlobalVariable, Module, Module>;
  22 template class ValueHolder<Function, Module, Module>;
  23
  24 // Define the GlobalValueRefMap as a struct that wraps a map so that we don't
  25 // have Module.h depend on <map>
  26 //
  27 struct GlobalValueRefMap : public std::map<GlobalValue*, ConstantPointerRef*>{
  28 };
  29
  30
  31 Module::Module()
  32   : Value(Type::VoidTy, Value::ModuleVal, ""), SymTabValue(this),
  33     GlobalList(this, this), FunctionList(this, this), GVRefMap(0) {
  34 }
  35
  36 Module::~Module() {
  37   dropAllReferences();
  38   GlobalList.delete_all();
  39   GlobalList.setParent(0);
  40   FunctionList.delete_all();
  41   FunctionList.setParent(0);
  42 }
  43
  44 // getOrInsertFunction - Look up the specified function in the module symbol
  45 // table.  If it does not exist, add a prototype for the function and return
  46 // it.  This is nice because it allows most passes to get away with not handling
  47 // the symbol table directly for this common task.
  48 //
  49 Function *Module::getOrInsertFunction(const std::string &Name,
  50                                       const FunctionType *Ty) {
  51   SymbolTable *SymTab = getSymbolTableSure();
  52
  53   // See if we have a definitions for the specified function already...
  54   if (Value *V = SymTab->lookup(PointerType::get(Ty), Name)) {
  55     return cast<Function>(V);      // Yup, got it
  56   } else {                         // Nope, add one
  57     Function *New = new Function(Ty, false, Name);
  58     FunctionList.push_back(New);
  59     return New;                    // Return the new prototype...
  60   }
  61 }
  62
  63 // getFunction - Look up the specified function in the module symbol table.
  64 // If it does not exist, return null.
  65 //
  66 Function *Module::getFunction(const std::string &Name, const FunctionType *Ty) {
  67   SymbolTable *SymTab = getSymbolTable();
  68   if (SymTab == 0) return 0;  // No symtab, no symbols...
  69
  70   return cast_or_null<Function>(SymTab->lookup(PointerType::get(Ty), Name));
  71 }
  72
  73
  74
  75 // dropAllReferences() - This function causes all the subinstructions to "let
  76 // go" of all references that they are maintaining.  This allows one to
  77 // 'delete' a whole class at a time, even though there may be circular
  78 // references... first all references are dropped, and all use counts go to
  79 // zero.  Then everything is delete'd for real.  Note that no operations are
  80 // valid on an object that has "dropped all references", except operator
  81 // delete.
  82 //
  83 void Module::dropAllReferences() {
  84   for_each(FunctionList.begin(), FunctionList.end(),
  85            std::mem_fun(&Function::dropAllReferences));
  86
  87   for_each(GlobalList.begin(), GlobalList.end(),
  88            std::mem_fun(&GlobalVariable::dropAllReferences));
  89
  90   // If there are any GlobalVariable references still out there, nuke them now.
  91   // Since all references are hereby dropped, nothing could possibly reference
  92   // them still.
  93   if (GVRefMap) {
  94     for (GlobalValueRefMap::iterator I = GVRefMap->begin(), E = GVRefMap->end();
  95          I != E; ++I) {
  96       // Delete the ConstantPointerRef node...
  97       I->second->destroyConstant();
  98     }
  99
 100     // Since the table is empty, we can now delete it...
 101     delete GVRefMap;
 102   }
 103 }
 104
 105 // Accessor for the underlying GlobalValRefMap...
 106 ConstantPointerRef *Module::getConstantPointerRef(GlobalValue *V){
 107   // Create ref map lazily on demand...
 108   if (GVRefMap == 0) GVRefMap = new GlobalValueRefMap();
 109
 110   GlobalValueRefMap::iterator I = GVRefMap->find(V);
 111   if (I != GVRefMap->end()) return I->second;
 112
 113   ConstantPointerRef *Ref = new ConstantPointerRef(V);
 114   GVRefMap->insert(std::make_pair(V, Ref));
 115
 116   return Ref;
 117 }
 118
 119 void Module::mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
 120   GlobalValueRefMap::iterator I = GVRefMap->find(OldGV);
 121   assert(I != GVRefMap->end() &&
 122          "mutateConstantPointerRef; OldGV not in table!");
 123   ConstantPointerRef *Ref = I->second;
 124
 125   // Remove the old entry...
 126   GVRefMap->erase(I);
 127
 128   // Insert the new entry...
 129   GVRefMap->insert(std::make_pair(NewGV, Ref));
 130 }