lib/VMCore/Module.cpp

   1 //===-- Module.cpp - Implement the Module class ---------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the Module class for the VMCore library.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Module.h"
  15 #include "llvm/InstrTypes.h"
  16 #include "llvm/Constants.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/LLVMContext.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/Support/LeakDetector.h"
  22 #include "SymbolTableListTraitsImpl.h"
  23 #include "llvm/TypeSymbolTable.h"
  24 #include <algorithm>
  25 #include <cstdarg>
  26 #include <cstdlib>
  27 using namespace llvm;
  28
  29 //===----------------------------------------------------------------------===//
  30 // Methods to implement the globals and functions lists.
  31 //
  32
  33 GlobalVariable *ilist_traits<GlobalVariable>::createSentinel() {
  34   GlobalVariable *Ret = new GlobalVariable(getGlobalContext(), Type::Int32Ty,
  35                                            false, GlobalValue::ExternalLinkage);
  36   // This should not be garbage monitored.
  37   LeakDetector::removeGarbageObject(Ret);
  38   return Ret;
  39 }
  40 GlobalAlias *ilist_traits<GlobalAlias>::createSentinel() {
  41   GlobalAlias *Ret = new GlobalAlias(Type::Int32Ty,
  42                                      GlobalValue::ExternalLinkage);
  43   // This should not be garbage monitored.
  44   LeakDetector::removeGarbageObject(Ret);
  45   return Ret;
  46 }
  47
  48 // Explicit instantiations of SymbolTableListTraits since some of the methods
  49 // are not in the public header file.
  50 template class SymbolTableListTraits<GlobalVariable, Module>;
  51 template class SymbolTableListTraits<Function, Module>;
  52 template class SymbolTableListTraits<GlobalAlias, Module>;
  53
  54 //===----------------------------------------------------------------------===//
  55 // Primitive Module methods.
  56 //
  57
  58 Module::Module(const StringRef &MID, LLVMContext& C)
  59   : Context(C), ModuleID(MID), DataLayout("")  {
  60   ValSymTab = new ValueSymbolTable();
  61   TypeSymTab = new TypeSymbolTable();
  62 }
  63
  64 Module::~Module() {
  65   dropAllReferences();
  66   GlobalList.clear();
  67   FunctionList.clear();
  68   AliasList.clear();
  69   LibraryList.clear();
  70   delete ValSymTab;
  71   delete TypeSymTab;
  72 }
  73
  74 /// Target endian information...
  75 Module::Endianness Module::getEndianness() const {
  76   std::string temp = DataLayout;
  77   Module::Endianness ret = AnyEndianness;
  78
  79   while (!temp.empty()) {
  80     std::string token = getToken(temp, "-");
  81
  82     if (token[0] == 'e') {
  83       ret = LittleEndian;
  84     } else if (token[0] == 'E') {
  85       ret = BigEndian;
  86     }
  87   }
  88
  89   return ret;
  90 }
  91
  92 /// Target Pointer Size information...
  93 Module::PointerSize Module::getPointerSize() const {
  94   std::string temp = DataLayout;
  95   Module::PointerSize ret = AnyPointerSize;
  96
  97   while (!temp.empty()) {
  98     std::string token = getToken(temp, "-");
  99     char signal = getToken(token, ":")[0];
 100
 101     if (signal == 'p') {
 102       int size = atoi(getToken(token, ":").c_str());
 103       if (size == 32)
 104         ret = Pointer32;
 105       else if (size == 64)
 106         ret = Pointer64;
 107     }
 108   }
 109
 110   return ret;
 111 }
 112
 113 /// getNamedValue - Return the first global value in the module with
 114 /// the specified name, of arbitrary type.  This method returns null
 115 /// if a global with the specified name is not found.
 116 GlobalValue *Module::getNamedValue(const StringRef &Name) const {
 117   return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
 118 }
 119
 120 //===----------------------------------------------------------------------===//
 121 // Methods for easy access to the functions in the module.
 122 //
 123
 124 // getOrInsertFunction - Look up the specified function in the module symbol
 125 // table.  If it does not exist, add a prototype for the function and return
 126 // it.  This is nice because it allows most passes to get away with not handling
 127 // the symbol table directly for this common task.
 128 //
 129 Constant *Module::getOrInsertFunction(const StringRef &Name,
 130                                       const FunctionType *Ty,
 131                                       AttrListPtr AttributeList) {
 132   // See if we have a definition for the specified function already.
 133   GlobalValue *F = getNamedValue(Name);
 134   if (F == 0) {
 135     // Nope, add it
 136     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
 137     if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
 138       New->setAttributes(AttributeList);
 139     FunctionList.push_back(New);
 140     return New;                    // Return the new prototype.
 141   }
 142
 143   // Okay, the function exists.  Does it have externally visible linkage?
 144   if (F->hasLocalLinkage()) {
 145     // Clear the function's name.
 146     F->setName("");
 147     // Retry, now there won't be a conflict.
 148     Constant *NewF = getOrInsertFunction(Name, Ty);
 149     F->setName(Name);
 150     return NewF;
 151   }
 152
 153   // If the function exists but has the wrong type, return a bitcast to the
 154   // right type.
 155   if (F->getType() != Context.getPointerTypeUnqual(Ty))
 156     return Context.getConstantExprBitCast(F, Context.getPointerTypeUnqual(Ty));
 157
 158   // Otherwise, we just found the existing function or a prototype.
 159   return F;
 160 }
 161
 162 Constant *Module::getOrInsertTargetIntrinsic(const StringRef &Name,
 163                                              const FunctionType *Ty,
 164                                              AttrListPtr AttributeList) {
 165   // See if we have a definition for the specified function already.
 166   GlobalValue *F = getNamedValue(Name);
 167   if (F == 0) {
 168     // Nope, add it
 169     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
 170     New->setAttributes(AttributeList);
 171     FunctionList.push_back(New);
 172     return New; // Return the new prototype.
 173   }
 174
 175   // Otherwise, we just found the existing function or a prototype.
 176   return F;
 177 }
 178
 179 Constant *Module::getOrInsertFunction(const StringRef &Name,
 180                                       const FunctionType *Ty) {
 181   AttrListPtr AttributeList = AttrListPtr::get((AttributeWithIndex *)0, 0);
 182   return getOrInsertFunction(Name, Ty, AttributeList);
 183 }
 184
 185 // getOrInsertFunction - Look up the specified function in the module symbol
 186 // table.  If it does not exist, add a prototype for the function and return it.
 187 // This version of the method takes a null terminated list of function
 188 // arguments, which makes it easier for clients to use.
 189 //
 190 Constant *Module::getOrInsertFunction(const StringRef &Name,
 191                                       AttrListPtr AttributeList,
 192                                       const Type *RetTy, ...) {
 193   va_list Args;
 194   va_start(Args, RetTy);
 195
 196   // Build the list of argument types...
 197   std::vector<const Type*> ArgTys;
 198   while (const Type *ArgTy = va_arg(Args, const Type*))
 199     ArgTys.push_back(ArgTy);
 200
 201   va_end(Args);
 202
 203   // Build the function type and chain to the other getOrInsertFunction...
 204   return getOrInsertFunction(Name,
 205                              Context.getFunctionType(RetTy, ArgTys, false),
 206                              AttributeList);
 207 }
 208
 209 Constant *Module::getOrInsertFunction(const StringRef &Name,
 210                                       const Type *RetTy, ...) {
 211   va_list Args;
 212   va_start(Args, RetTy);
 213
 214   // Build the list of argument types...
 215   std::vector<const Type*> ArgTys;
 216   while (const Type *ArgTy = va_arg(Args, const Type*))
 217     ArgTys.push_back(ArgTy);
 218
 219   va_end(Args);
 220
 221   // Build the function type and chain to the other getOrInsertFunction...
 222   return getOrInsertFunction(Name,
 223                              Context.getFunctionType(RetTy, ArgTys, false),
 224                              AttrListPtr::get((AttributeWithIndex *)0, 0));
 225 }
 226
 227 // getFunction - Look up the specified function in the module symbol table.
 228 // If it does not exist, return null.
 229 //
 230 Function *Module::getFunction(const StringRef &Name) const {
 231   return dyn_cast_or_null<Function>(getNamedValue(Name));
 232 }
 233
 234 //===----------------------------------------------------------------------===//
 235 // Methods for easy access to the global variables in the module.
 236 //
 237
 238 /// getGlobalVariable - Look up the specified global variable in the module
 239 /// symbol table.  If it does not exist, return null.  The type argument
 240 /// should be the underlying type of the global, i.e., it should not have
 241 /// the top-level PointerType, which represents the address of the global.
 242 /// If AllowLocal is set to true, this function will return types that
 243 /// have an local. By default, these types are not returned.
 244 ///
 245 GlobalVariable *Module::getGlobalVariable(const StringRef &Name,
 246                                           bool AllowLocal) const {
 247   if (GlobalVariable *Result =
 248       dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
 249     if (AllowLocal || !Result->hasLocalLinkage())
 250       return Result;
 251   return 0;
 252 }
 253
 254 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
 255 ///   1. If it does not exist, add a declaration of the global and return it.
 256 ///   2. Else, the global exists but has the wrong type: return the function
 257 ///      with a constantexpr cast to the right type.
 258 ///   3. Finally, if the existing global is the correct delclaration, return the
 259 ///      existing global.
 260 Constant *Module::getOrInsertGlobal(const StringRef &Name, const Type *Ty) {
 261   // See if we have a definition for the specified global already.
 262   GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
 263   if (GV == 0) {
 264     // Nope, add it
 265     GlobalVariable *New =
 266       new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
 267                          0, Name);
 268      return New;                    // Return the new declaration.
 269   }
 270
 271   // If the variable exists but has the wrong type, return a bitcast to the
 272   // right type.
 273   if (GV->getType() != Context.getPointerTypeUnqual(Ty))
 274     return Context.getConstantExprBitCast(GV, Context.getPointerTypeUnqual(Ty));
 275
 276   // Otherwise, we just found the existing function or a prototype.
 277   return GV;
 278 }
 279
 280 //===----------------------------------------------------------------------===//
 281 // Methods for easy access to the global variables in the module.
 282 //
 283
 284 // getNamedAlias - Look up the specified global in the module symbol table.
 285 // If it does not exist, return null.
 286 //
 287 GlobalAlias *Module::getNamedAlias(const StringRef &Name) const {
 288   return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
 289 }
 290
 291 //===----------------------------------------------------------------------===//
 292 // Methods for easy access to the types in the module.
 293 //
 294
 295
 296 // addTypeName - Insert an entry in the symbol table mapping Str to Type.  If
 297 // there is already an entry for this name, true is returned and the symbol
 298 // table is not modified.
 299 //
 300 bool Module::addTypeName(const StringRef &Name, const Type *Ty) {
 301   TypeSymbolTable &ST = getTypeSymbolTable();
 302
 303   if (ST.lookup(Name)) return true;  // Already in symtab...
 304
 305   // Not in symbol table?  Set the name with the Symtab as an argument so the
 306   // type knows what to update...
 307   ST.insert(Name, Ty);
 308
 309   return false;
 310 }
 311
 312 /// getTypeByName - Return the type with the specified name in this module, or
 313 /// null if there is none by that name.
 314 const Type *Module::getTypeByName(const StringRef &Name) const {
 315   const TypeSymbolTable &ST = getTypeSymbolTable();
 316   return cast_or_null<Type>(ST.lookup(Name));
 317 }
 318
 319 // getTypeName - If there is at least one entry in the symbol table for the
 320 // specified type, return it.
 321 //
 322 std::string Module::getTypeName(const Type *Ty) const {
 323   const TypeSymbolTable &ST = getTypeSymbolTable();
 324
 325   TypeSymbolTable::const_iterator TI = ST.begin();
 326   TypeSymbolTable::const_iterator TE = ST.end();
 327   if ( TI == TE ) return ""; // No names for types
 328
 329   while (TI != TE && TI->second != Ty)
 330     ++TI;
 331
 332   if (TI != TE)  // Must have found an entry!
 333     return TI->first;
 334   return "";     // Must not have found anything...
 335 }
 336
 337 //===----------------------------------------------------------------------===//
 338 // Other module related stuff.
 339 //
 340
 341
 342 // dropAllReferences() - This function causes all the subelementss to "let go"
 343 // of all references that they are maintaining.  This allows one to 'delete' a
 344 // whole module at a time, even though there may be circular references... first
 345 // all references are dropped, and all use counts go to zero.  Then everything
 346 // is deleted for real.  Note that no operations are valid on an object that
 347 // has "dropped all references", except operator delete.
 348 //
 349 void Module::dropAllReferences() {
 350   for(Module::iterator I = begin(), E = end(); I != E; ++I)
 351     I->dropAllReferences();
 352
 353   for(Module::global_iterator I = global_begin(), E = global_end(); I != E; ++I)
 354     I->dropAllReferences();
 355
 356   for(Module::alias_iterator I = alias_begin(), E = alias_end(); I != E; ++I)
 357     I->dropAllReferences();
 358 }
 359
 360 void Module::addLibrary(const StringRef& Lib) {
 361   for (Module::lib_iterator I = lib_begin(), E = lib_end(); I != E; ++I)
 362     if (*I == Lib)
 363       return;
 364   LibraryList.push_back(Lib);
 365 }
 366
 367 void Module::removeLibrary(const StringRef& Lib) {
 368   LibraryListType::iterator I = LibraryList.begin();
 369   LibraryListType::iterator E = LibraryList.end();
 370   for (;I != E; ++I)
 371     if (*I == Lib) {
 372       LibraryList.erase(I);
 373       return;
 374     }
 375 }