Use CloneModule's ValueMap in more places, instead of looking

up functions by name.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@69805 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index 6a2105392f14aae97c8436aa904f8847f524feb4..96e9fb98017556872e12ef56a4b3807c7343e6aa 100644 (file)
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -16,11 +16,13 @@
 #ifndef BUGDRIVER_H
 #define BUGDRIVER_H
 
+#include "llvm/ADT/DenseMap.h"
 #include <vector>
 #include <string>
 
 namespace llvm {
 
+class Value;
 class PassInfo;
 class Module;
 class GlobalVariable;
@@ -312,7 +314,8 @@ void DeleteFunctionBody(Function *F);
 /// SplitFunctionsOutOfModule - Given a module and a list of functions in the
 /// module, split the functions OUT of the specified module, and place them in
 /// the new module.
-Module *SplitFunctionsOutOfModule(Module *M, const std::vector<Function*> &F);
+Module *SplitFunctionsOutOfModule(Module *M, const std::vector<Function*> &F,
+                                  DenseMap<const Value*, Value*> &ValueMap);
 
 } // End llvm namespace
 

diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp
index 811169d86f88acab2d960366ed8b65d43beb3e1b..e4affbb0ddcc331afab8e535476f336fc1d04fb9 100644 (file)
--- a/tools/bugpoint/ExtractFunction.cpp
+++ b/tools/bugpoint/ExtractFunction.cpp
@@ -197,7 +197,8 @@ static Constant *GetTorInit(std::vector<std::pair<Function*, int> > &TorList) {
 /// M1 has all of the global variables.  If M2 contains any functions that are
 /// static ctors/dtors, we need to add an llvm.global_[cd]tors global to M2, and
 /// prune appropriate entries out of M1s list.
-static void SplitStaticCtorDtor(const char *GlobalName, Module *M1, Module *M2){
+static void SplitStaticCtorDtor(const char *GlobalName, Module *M1, Module *M2,
+                                DenseMap<const Value*, Value*> ValueMap) {
   GlobalVariable *GV = M1->getNamedGlobal(GlobalName);
   if (!GV || GV->isDeclaration() || GV->hasLocalLinkage() ||
       !GV->use_empty()) return;
@@ -225,7 +226,7 @@ static void SplitStaticCtorDtor(const char *GlobalName, Module *M1, Module *M2){
           M1Tors.push_back(std::make_pair(F, Priority));
         else {
           // Map to M2's version of the function.
-          F = M2->getFunction(F->getName());
+          F = cast<Function>(ValueMap[F]);
           M2Tors.push_back(std::make_pair(F, Priority));
         }
       }
@@ -255,8 +256,10 @@ static void SplitStaticCtorDtor(const char *GlobalName, Module *M1, Module *M2){
 /// SplitFunctionsOutOfModule - Given a module and a list of functions in the
 /// module, split the functions OUT of the specified module, and place them in
 /// the new module.
-Module *llvm::SplitFunctionsOutOfModule(Module *M,
-                                        const std::vector<Function*> &F) {
+Module *
+llvm::SplitFunctionsOutOfModule(Module *M,
+                                const std::vector<Function*> &F,
+                                DenseMap<const Value*, Value*> &ValueMap) {
   // Make sure functions & globals are all external so that linkage
   // between the two modules will work.
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
@@ -268,7 +271,8 @@ Module *llvm::SplitFunctionsOutOfModule(Module *M,
     I->setLinkage(GlobalValue::ExternalLinkage);
   }
 
-  Module *New = CloneModule(M);
+  DenseMap<const Value*, Value*> NewValueMap;
+  Module *New = CloneModule(M, NewValueMap);
 
   // Make sure global initializers exist only in the safe module (CBE->.so)
   for (Module::global_iterator I = New->global_begin(), E = New->global_end();
@@ -276,27 +280,27 @@ Module *llvm::SplitFunctionsOutOfModule(Module *M,
     I->setInitializer(0);  // Delete the initializer to make it external
 
   // Remove the Test functions from the Safe module
-  std::set<std::pair<std::string, const PointerType*> > TestFunctions;
+  std::set<Function *> TestFunctions;
   for (unsigned i = 0, e = F.size(); i != e; ++i) {
-    TestFunctions.insert(std::make_pair(F[i]->getName(), F[i]->getType()));  
-    Function *TNOF = M->getFunction(F[i]->getName());
-    assert(TNOF && "Function doesn't exist in module!");
-    assert(TNOF->getFunctionType() == F[i]->getFunctionType() && "wrong type?");
-    DEBUG(std::cerr << "Removing function " << F[i]->getName() << "\n");
+    Function *TNOF = cast<Function>(ValueMap[F[i]]);
+    DEBUG(std::cerr << "Removing function ");
+    DEBUG(WriteAsOperand(std::cerr, TNOF, false));
+    DEBUG(std::cerr << "\n");
+    TestFunctions.insert(cast<Function>(NewValueMap[TNOF]));
     DeleteFunctionBody(TNOF);       // Function is now external in this module!
   }
 
   
   // Remove the Safe functions from the Test module
   for (Module::iterator I = New->begin(), E = New->end(); I != E; ++I)
-    if (!TestFunctions.count(std::make_pair(I->getName(), I->getType())))
+    if (!TestFunctions.count(I))
       DeleteFunctionBody(I);
   
 
   // Make sure that there is a global ctor/dtor array in both halves of the
   // module if they both have static ctor/dtor functions.
-  SplitStaticCtorDtor("llvm.global_ctors", M, New);
-  SplitStaticCtorDtor("llvm.global_dtors", M, New);
+  SplitStaticCtorDtor("llvm.global_ctors", M, New, NewValueMap);
+  SplitStaticCtorDtor("llvm.global_dtors", M, New, NewValueMap);
   
   return New;
 }

diff --git a/tools/bugpoint/Miscompilation.cpp b/tools/bugpoint/Miscompilation.cpp
index 6a0911bfb54d48bc7468f4ebc1d363dc5224b590..7e8ff78a9cf2404cb367886436899e23d233e874 100644 (file)
--- a/tools/bugpoint/Miscompilation.cpp
+++ b/tools/bugpoint/Miscompilation.cpp
@@ -220,8 +220,10 @@ bool ReduceMiscompilingFunctions::TestFuncs(const std::vector<Function*>&Funcs){
   std::cout << '\n';
 
   // Split the module into the two halves of the program we want.
-  Module *ToNotOptimize = CloneModule(BD.getProgram());
-  Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize, Funcs);
+  DenseMap<const Value*, Value*> ValueMap;
+  Module *ToNotOptimize = CloneModule(BD.getProgram(), ValueMap);
+  Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize, Funcs,
+                                                 ValueMap);
 
   // Run the predicate, note that the predicate will delete both input modules.
   return TestFn(BD, ToOptimize, ToNotOptimize);
@@ -258,9 +260,11 @@ static bool ExtractLoops(BugDriver &BD,
   while (1) {
     if (BugpointIsInterrupted) return MadeChange;
     
-    Module *ToNotOptimize = CloneModule(BD.getProgram());
+    DenseMap<const Value*, Value*> ValueMap;
+    Module *ToNotOptimize = CloneModule(BD.getProgram(), ValueMap);
     Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize,
-                                                   MiscompiledFunctions);
+                                                   MiscompiledFunctions,
+                                                   ValueMap);
     Module *ToOptimizeLoopExtracted = BD.ExtractLoop(ToOptimize);
     if (!ToOptimizeLoopExtracted) {
       // If the loop extractor crashed or if there were no extractible loops,
@@ -396,9 +400,11 @@ bool ReduceMiscompiledBlocks::TestFuncs(const std::vector<BasicBlock*> &BBs) {
   std::cout << '\n';
 
   // Split the module into the two halves of the program we want.
-  Module *ToNotOptimize = CloneModule(BD.getProgram());
+  DenseMap<const Value*, Value*> ValueMap;
+  Module *ToNotOptimize = CloneModule(BD.getProgram(), ValueMap);
   Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize,
-                                                 FunctionsBeingTested);
+                                                 FunctionsBeingTested,
+                                                 ValueMap);
 
   // Try the extraction.  If it doesn't work, then the block extractor crashed
   // or something, in which case bugpoint can't chase down this possibility.
@@ -443,9 +449,11 @@ static bool ExtractBlocks(BugDriver &BD,
       return false;
   }
 
-  Module *ProgClone = CloneModule(BD.getProgram());
+  DenseMap<const Value*, Value*> ValueMap;
+  Module *ProgClone = CloneModule(BD.getProgram(), ValueMap);
   Module *ToExtract = SplitFunctionsOutOfModule(ProgClone,
-                                                MiscompiledFunctions);
+                                                MiscompiledFunctions,
+                                                ValueMap);
   Module *Extracted = BD.ExtractMappedBlocksFromModule(Blocks, ToExtract);
   if (Extracted == 0) {
     // Weird, extraction should have worked.
@@ -608,9 +616,11 @@ bool BugDriver::debugMiscompilation() {
 
   // Output a bunch of bitcode files for the user...
   std::cout << "Outputting reduced bitcode files which expose the problem:\n";
-  Module *ToNotOptimize = CloneModule(getProgram());
+  DenseMap<const Value*, Value*> ValueMap;
+  Module *ToNotOptimize = CloneModule(getProgram(), ValueMap);
   Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize,
-                                                 MiscompiledFunctions);
+                                                 MiscompiledFunctions,
+                                                 ValueMap);
 
   std::cout << "  Non-optimized portion: ";
   ToNotOptimize = swapProgramIn(ToNotOptimize);
@@ -856,8 +866,9 @@ bool BugDriver::debugCodeGenerator() {
   std::vector<Function*> Funcs = DebugAMiscompilation(*this, TestCodeGenerator);
 
   // Split the module into the two halves of the program we want.
-  Module *ToNotCodeGen = CloneModule(getProgram());
-  Module *ToCodeGen = SplitFunctionsOutOfModule(ToNotCodeGen, Funcs);
+  DenseMap<const Value*, Value*> ValueMap;
+  Module *ToNotCodeGen = CloneModule(getProgram(), ValueMap);
+  Module *ToCodeGen = SplitFunctionsOutOfModule(ToNotCodeGen, Funcs, ValueMap);
 
   // Condition the modules
   CleanupAndPrepareModules(*this, ToCodeGen, ToNotCodeGen);