For PR411:

This patch replaces the SymbolTable class with ValueSymbolTable which does
not support types planes. This means that all symbol names in LLVM must now
be unique. The patch addresses the necessary changes to deal with this and
removes code no longer needed as a result. This completes the bulk of the
changes for this PR. Some cleanup patches will follow.

llvm-svn: 33918

4 files changed, 58 insertions, 40 deletions

diff --git a/llvm/lib/Transforms/IPO/LoopExtractor.cpp b/llvm/lib/Transforms/IPO/LoopExtractor.cpp
index 5a6e7671d1b..7169b503b21 100644
--- a/llvm/lib/Transforms/IPO/LoopExtractor.cpp
+++ b/llvm/lib/Transforms/IPO/LoopExtractor.cpp
@@ -167,7 +167,8 @@ bool BlockExtractorPass::runOnModule(Module &M) {
     Function *F = BB->getParent();
 
     // Map the corresponding function in this module.
-    Function *MF = M.getFunction(F->getName(), F->getFunctionType());
+    Function *MF = M.getFunction(F->getName());
+    assert(MF->getFunctionType() == F->getFunctionType() && "Wrong function?");
 
     // Figure out which index the basic block is in its function.
     Function::iterator BBI = MF->begin();
diff --git a/llvm/lib/Transforms/IPO/RaiseAllocations.cpp b/llvm/lib/Transforms/IPO/RaiseAllocations.cpp
index 6082780e354..c5a9cbf4478 100644
--- a/llvm/lib/Transforms/IPO/RaiseAllocations.cpp
+++ b/llvm/lib/Transforms/IPO/RaiseAllocations.cpp
@@ -65,47 +65,65 @@ ModulePass *llvm::createRaiseAllocationsPass() {
 // function into the appropriate instruction.
 //
 void RaiseAllocations::doInitialization(Module &M) {
-  const FunctionType *MallocType =   // Get the type for malloc
-    FunctionType::get(PointerType::get(Type::Int8Ty),
-                    std::vector<const Type*>(1, Type::Int64Ty), false);
-
-  const FunctionType *FreeType =     // Get the type for free
-    FunctionType::get(Type::VoidTy,
-                   std::vector<const Type*>(1, PointerType::get(Type::Int8Ty)),
-                      false);
 
   // Get Malloc and free prototypes if they exist!
-  MallocFunc = M.getFunction("malloc", MallocType);
-  FreeFunc   = M.getFunction("free"  , FreeType);
-
-  // Check to see if the prototype is wrong, giving us sbyte*(uint) * malloc
-  // This handles the common declaration of: 'void *malloc(unsigned);'
-  if (MallocFunc == 0) {
-    MallocType = FunctionType::get(PointerType::get(Type::Int8Ty),
-                            std::vector<const Type*>(1, Type::Int32Ty), false);
-    MallocFunc = M.getFunction("malloc", MallocType);
-  }
-
-  // Check to see if the prototype is missing, giving us sbyte*(...) * malloc
-  // This handles the common declaration of: 'void *malloc();'
-  if (MallocFunc == 0) {
-    MallocType = FunctionType::get(PointerType::get(Type::Int8Ty),
-                                   std::vector<const Type*>(), true);
-    MallocFunc = M.getFunction("malloc", MallocType);
-  }
-
-  // Check to see if the prototype was forgotten, giving us void (...) * free
-  // This handles the common forward declaration of: 'void free();'
-  if (FreeFunc == 0) {
-    FreeType = FunctionType::get(Type::VoidTy, std::vector<const Type*>(),true);
-    FreeFunc = M.getFunction("free", FreeType);
+  MallocFunc = M.getFunction("malloc");
+  if (MallocFunc) {
+    const FunctionType* TyWeHave = MallocFunc->getFunctionType();
+
+    // Get the expected prototype for malloc
+    const FunctionType *Malloc1Type = 
+      FunctionType::get(PointerType::get(Type::Int8Ty),
+                      std::vector<const Type*>(1, Type::Int64Ty), false);
+
+    // Chck to see if we got the expected malloc
+    if (TyWeHave != Malloc1Type) {
+      // Check to see if the prototype is wrong, giving us sbyte*(uint) * malloc
+      // This handles the common declaration of: 'void *malloc(unsigned);'
+      const FunctionType *Malloc2Type = 
+        FunctionType::get(PointerType::get(Type::Int8Ty),
+                          std::vector<const Type*>(1, Type::Int32Ty), false);
+      if (TyWeHave != Malloc2Type) {
+        // Check to see if the prototype is missing, giving us 
+        // sbyte*(...) * malloc
+        // This handles the common declaration of: 'void *malloc();'
+        const FunctionType *Malloc3Type = 
+          FunctionType::get(PointerType::get(Type::Int8Ty),
+                            std::vector<const Type*>(), true);
+        if (TyWeHave != Malloc3Type)
+          // Give up
+          MallocFunc = 0;
+      }
+    }
   }
 
-  // One last try, check to see if we can find free as 'int (...)* free'.  This
-  // handles the case where NOTHING was declared.
-  if (FreeFunc == 0) {
-    FreeType = FunctionType::get(Type::Int32Ty, std::vector<const Type*>(),true);
-    FreeFunc = M.getFunction("free", FreeType);
+  FreeFunc = M.getFunction("free");
+  if (FreeFunc) {
+    const FunctionType* TyWeHave = FreeFunc->getFunctionType();
+    
+    // Get the expected prototype for void free(i8*)
+    const FunctionType *Free1Type = FunctionType::get(Type::VoidTy,
+        std::vector<const Type*>(1, PointerType::get(Type::Int8Ty)), false);
+
+    if (TyWeHave != Free1Type) {
+      // Check to see if the prototype was forgotten, giving us 
+      // void (...) * free
+      // This handles the common forward declaration of: 'void free();'
+      const FunctionType* Free2Type = FunctionType::get(Type::VoidTy, 
+        std::vector<const Type*>(),true);
+
+      if (TyWeHave != Free2Type) {
+        // One last try, check to see if we can find free as 
+        // int (...)* free.  This handles the case where NOTHING was declared.
+        const FunctionType* Free3Type = FunctionType::get(Type::Int32Ty, 
+          std::vector<const Type*>(),true);
+        
+        if (TyWeHave != Free3Type) {
+          // Give up.
+          FreeFunc = 0;
+        }
+      }
+    }
   }
 
   // Don't mess with locally defined versions of these functions...
diff --git a/llvm/lib/Transforms/IPO/StripSymbols.cpp b/llvm/lib/Transforms/IPO/StripSymbols.cpp
index 12cd7fe8938..db4387fa54e 100644
--- a/llvm/lib/Transforms/IPO/StripSymbols.cpp
+++ b/llvm/lib/Transforms/IPO/StripSymbols.cpp
@@ -28,7 +28,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/Pass.h"
-#include "llvm/SymbolTable.h"
+#include "llvm/ValueSymbolTable.h"
 #include "llvm/TypeSymbolTable.h"
 using namespace llvm;
 
diff --git a/llvm/lib/Transforms/Utils/CloneModule.cpp b/llvm/lib/Transforms/Utils/CloneModule.cpp
index d481aea0e53..669b4b2d051 100644
--- a/llvm/lib/Transforms/Utils/CloneModule.cpp
+++ b/llvm/lib/Transforms/Utils/CloneModule.cpp
@@ -15,7 +15,6 @@
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Module.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/SymbolTable.h"
 #include "llvm/TypeSymbolTable.h"
 #include "llvm/Constant.h"
 #include "ValueMapper.h"