From d50330cd02b00c8e3de40e8544c45701b9891d87 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Wed, 22 Apr 2009 15:57:18 +0000 Subject: [PATCH] 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 --- tools/bugpoint/BugDriver.h | 5 ++++- tools/bugpoint/ExtractFunction.cpp | 32 +++++++++++++++------------ tools/bugpoint/Miscompilation.cpp | 35 ++++++++++++++++++++---------- 3 files changed, 45 insertions(+), 27 deletions(-) diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h index 6a2105392f1..96e9fb98017 100644 --- 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 #include 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 &F); +Module *SplitFunctionsOutOfModule(Module *M, const std::vector &F, + DenseMap &ValueMap); } // End llvm namespace diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp index 811169d86f8..e4affbb0ddc 100644 --- a/tools/bugpoint/ExtractFunction.cpp +++ b/tools/bugpoint/ExtractFunction.cpp @@ -197,7 +197,8 @@ static Constant *GetTorInit(std::vector > &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 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(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 &F) { +Module * +llvm::SplitFunctionsOutOfModule(Module *M, + const std::vector &F, + DenseMap &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 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 > TestFunctions; + std::set 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(ValueMap[F[i]]); + DEBUG(std::cerr << "Removing function "); + DEBUG(WriteAsOperand(std::cerr, TNOF, false)); + DEBUG(std::cerr << "\n"); + TestFunctions.insert(cast(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 6a0911bfb54..7e8ff78a9cf 100644 --- a/tools/bugpoint/Miscompilation.cpp +++ b/tools/bugpoint/Miscompilation.cpp @@ -220,8 +220,10 @@ bool ReduceMiscompilingFunctions::TestFuncs(const std::vector&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 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 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 &BBs) { std::cout << '\n'; // Split the module into the two halves of the program we want. - Module *ToNotOptimize = CloneModule(BD.getProgram()); + DenseMap 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 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 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 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 ValueMap; + Module *ToNotCodeGen = CloneModule(getProgram(), ValueMap); + Module *ToCodeGen = SplitFunctionsOutOfModule(ToNotCodeGen, Funcs, ValueMap); // Condition the modules CleanupAndPrepareModules(*this, ToCodeGen, ToNotCodeGen);