From 22ee3eb802cf4dfb5d5142dfa84618cb03e991a8 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Fri, 24 May 2002 20:42:13 +0000 Subject: [PATCH] Split the FunctionResolution pass out of CleanGCCOutput.cpp. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2742 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/IPO/DeadTypeElimination.cpp | 221 +------------------- lib/Transforms/IPO/FunctionResolution.cpp | 223 +++++++++++++++++++++ 2 files changed, 226 insertions(+), 218 deletions(-) create mode 100644 lib/Transforms/IPO/FunctionResolution.cpp diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index 97cb30cc6d0..123549f1ee2 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -7,7 +7,6 @@ // * Eliminate names for GCC types that we know can't be needed by the user. // * Eliminate names for types that are unused in the entire translation unit // * Fix various problems that we might have in PHI nodes and casts -// * Link uses of 'void %foo(...)' to 'void %foo(sometypes)' // // Note: This code produces dead declarations, it is a good idea to run DCE // after this pass. @@ -25,20 +24,15 @@ #include "llvm/iOther.h" #include "llvm/Support/CFG.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" +#include "Support/StatisticReporter.h" #include #include -#include "Support/StatisticReporter.h" -static Statistic<> NumResolved("funcresolve\t- Number of varargs functions resolved"); static Statistic<> NumTypeSymtabEntriesKilled("cleangcc\t- Number of unused typenames removed from symtab"); static Statistic<> NumCastsMoved("cleangcc\t- Number of casts removed from head of basic block"); static Statistic<> NumRefactoredPreds("cleangcc\t- Number of predecessor blocks refactored"); using std::vector; -using std::string; -using std::cerr; - -static const Type *PtrSByte = 0; // 'sbyte*' type namespace { struct CleanupGCCOutput : public FunctionPass { @@ -76,7 +70,7 @@ Pass *createCleanupGCCOutputPass() { // ShouldNukSymtabEntry - Return true if this module level symbol table entry // should be eliminated. // -static inline bool ShouldNukeSymtabEntry(const std::pair &E) { +static inline bool ShouldNukeSymtabEntry(const std::pair&E){ // Nuke all names for primitive types! if (cast(E.second)->isPrimitiveType()) return true; @@ -86,7 +80,7 @@ static inline bool ShouldNukeSymtabEntry(const std::pair &E) { // The only types that could contain .'s in the program are things generated // by GCC itself, including "complex.float" and friends. Nuke them too. - if (E.first.find('.') != string::npos) return true; + if (E.first.find('.') != std::string::npos) return true; return false; } @@ -98,9 +92,6 @@ static inline bool ShouldNukeSymtabEntry(const std::pair &E) { bool CleanupGCCOutput::doInitialization(Module *M) { bool Changed = false; - if (PtrSByte == 0) - PtrSByte = PointerType::get(Type::SByteTy); - if (M->hasSymbolTable()) { SymbolTable *ST = M->getSymbolTable(); @@ -335,209 +326,3 @@ bool CleanupGCCOutput::doFinalization(Module *M) { } return Changed; } - - -//===----------------------------------------------------------------------===// -// -// FunctionResolvingPass - Go over the functions that are in the module and -// look for functions that have the same name. More often than not, there will -// be things like: -// void "foo"(...) -// void "foo"(int, int) -// because of the way things are declared in C. If this is the case, patch -// things up. -// -//===----------------------------------------------------------------------===// - -namespace { - struct FunctionResolvingPass : public Pass { - const char *getPassName() const { return "Resolve Functions"; } - - bool run(Module *M); - }; -} - -// ConvertCallTo - Convert a call to a varargs function with no arg types -// specified to a concrete nonvarargs function. -// -static void ConvertCallTo(CallInst *CI, Function *Dest) { - const FunctionType::ParamTypes &ParamTys = - Dest->getFunctionType()->getParamTypes(); - BasicBlock *BB = CI->getParent(); - - // Get an iterator to where we want to insert cast instructions if the - // argument types don't agree. - // - BasicBlock::iterator BBI = find(BB->begin(), BB->end(), CI); - assert(BBI != BB->end() && "CallInst not in parent block?"); - - assert(CI->getNumOperands()-1 == ParamTys.size()&& - "Function calls resolved funny somehow, incompatible number of args"); - - vector Params; - - // Convert all of the call arguments over... inserting cast instructions if - // the types are not compatible. - for (unsigned i = 1; i < CI->getNumOperands(); ++i) { - Value *V = CI->getOperand(i); - - if (V->getType() != ParamTys[i-1]) { // Must insert a cast... - Instruction *Cast = new CastInst(V, ParamTys[i-1]); - BBI = BB->getInstList().insert(BBI, Cast)+1; - V = Cast; - } - - Params.push_back(V); - } - - // Replace the old call instruction with a new call instruction that calls - // the real function. - // - ReplaceInstWithInst(BB->getInstList(), BBI, new CallInst(Dest, Params)); -} - - -bool FunctionResolvingPass::run(Module *M) { - SymbolTable *ST = M->getSymbolTable(); - if (!ST) return false; - - std::map > Functions; - - // Loop over the entries in the symbol table. If an entry is a func pointer, - // then add it to the Functions map. We do a two pass algorithm here to avoid - // problems with iterators getting invalidated if we did a one pass scheme. - // - for (SymbolTable::iterator I = ST->begin(), E = ST->end(); I != E; ++I) - if (const PointerType *PT = dyn_cast(I->first)) - if (isa(PT->getElementType())) { - SymbolTable::VarMap &Plane = I->second; - for (SymbolTable::type_iterator PI = Plane.begin(), PE = Plane.end(); - PI != PE; ++PI) { - const string &Name = PI->first; - Functions[Name].push_back(cast(PI->second)); - } - } - - bool Changed = false; - - // Now we have a list of all functions with a particular name. If there is - // more than one entry in a list, merge the functions together. - // - for (std::map >::iterator I = Functions.begin(), - E = Functions.end(); I != E; ++I) { - vector &Functions = I->second; - Function *Implementation = 0; // Find the implementation - Function *Concrete = 0; - for (unsigned i = 0; i < Functions.size(); ) { - if (!Functions[i]->isExternal()) { // Found an implementation - assert(Implementation == 0 && "Multiple definitions of the same" - " function. Case not handled yet!"); - Implementation = Functions[i]; - } else { - // Ignore functions that are never used so they don't cause spurious - // warnings... here we will actually DCE the function so that it isn't - // used later. - // - if (Functions[i]->use_size() == 0) { - M->getFunctionList().remove(Functions[i]); - delete Functions[i]; - Functions.erase(Functions.begin()+i); - Changed = true; - ++NumResolved; - continue; - } - } - - if (Functions[i] && (!Functions[i]->getFunctionType()->isVarArg())) { - if (Concrete) { // Found two different functions types. Can't choose - Concrete = 0; - break; - } - Concrete = Functions[i]; - } - ++i; - } - - if (Functions.size() > 1) { // Found a multiply defined function... - // We should find exactly one non-vararg function definition, which is - // probably the implementation. Change all of the function definitions - // and uses to use it instead. - // - if (!Concrete) { - cerr << "Warning: Found functions types that are not compatible:\n"; - for (unsigned i = 0; i < Functions.size(); ++i) { - cerr << "\t" << Functions[i]->getType()->getDescription() << " %" - << Functions[i]->getName() << "\n"; - } - cerr << " No linkage of functions named '" << Functions[0]->getName() - << "' performed!\n"; - } else { - for (unsigned i = 0; i < Functions.size(); ++i) - if (Functions[i] != Concrete) { - Function *Old = Functions[i]; - const FunctionType *OldMT = Old->getFunctionType(); - const FunctionType *ConcreteMT = Concrete->getFunctionType(); - bool Broken = false; - - assert(Old->getReturnType() == Concrete->getReturnType() && - "Differing return types not handled yet!"); - assert(OldMT->getParamTypes().size() <= - ConcreteMT->getParamTypes().size() && - "Concrete type must have more specified parameters!"); - - // Check to make sure that if there are specified types, that they - // match... - // - for (unsigned i = 0; i < OldMT->getParamTypes().size(); ++i) - if (OldMT->getParamTypes()[i] != ConcreteMT->getParamTypes()[i]) { - cerr << "Parameter types conflict for" << OldMT - << " and " << ConcreteMT; - Broken = true; - } - if (Broken) break; // Can't process this one! - - - // Attempt to convert all of the uses of the old function to the - // concrete form of the function. If there is a use of the fn - // that we don't understand here we punt to avoid making a bad - // transformation. - // - // At this point, we know that the return values are the same for - // our two functions and that the Old function has no varargs fns - // specified. In otherwords it's just (...) - // - for (unsigned i = 0; i < Old->use_size(); ) { - User *U = *(Old->use_begin()+i); - if (CastInst *CI = dyn_cast(U)) { - // Convert casts directly - assert(CI->getOperand(0) == Old); - CI->setOperand(0, Concrete); - Changed = true; - ++NumResolved; - } else if (CallInst *CI = dyn_cast(U)) { - // Can only fix up calls TO the argument, not args passed in. - if (CI->getCalledValue() == Old) { - ConvertCallTo(CI, Concrete); - Changed = true; - ++NumResolved; - } else { - cerr << "Couldn't cleanup this function call, must be an" - << " argument or something!" << CI; - ++i; - } - } else { - cerr << "Cannot convert use of function: " << U << "\n"; - ++i; - } - } - } - } - } - } - - return Changed; -} - -Pass *createFunctionResolvingPass() { - return new FunctionResolvingPass(); -} diff --git a/lib/Transforms/IPO/FunctionResolution.cpp b/lib/Transforms/IPO/FunctionResolution.cpp new file mode 100644 index 00000000000..63ea3b1cd36 --- /dev/null +++ b/lib/Transforms/IPO/FunctionResolution.cpp @@ -0,0 +1,223 @@ +//===- FunctionResolution.cpp - Resolve declarations to implementations ---===// +// +// Loop over the functions that are in the module and look for functions that +// have the same name. More often than not, there will be things like: +// +// declare void %foo(...) +// void %foo(int, int) { ... } +// +// because of the way things are declared in C. If this is the case, patch +// things up. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Transforms/CleanupGCCOutput.h" +#include "llvm/Module.h" +#include "llvm/Function.h" +#include "llvm/Transforms/Utils/BasicBlockUtils.h" +#include "llvm/SymbolTable.h" +#include "llvm/DerivedTypes.h" +#include "llvm/Pass.h" +#include "llvm/iOther.h" +#include "Support/StatisticReporter.h" +#include +#include + +using std::vector; +using std::string; +using std::cerr; + +namespace { + Statistic<>NumResolved("funcresolve\t- Number of varargs functions resolved"); + + struct FunctionResolvingPass : public Pass { + const char *getPassName() const { return "Resolve Functions"; } + + bool run(Module *M); + }; +} + +Pass *createFunctionResolvingPass() { + return new FunctionResolvingPass(); +} + +// ConvertCallTo - Convert a call to a varargs function with no arg types +// specified to a concrete nonvarargs function. +// +static void ConvertCallTo(CallInst *CI, Function *Dest) { + const FunctionType::ParamTypes &ParamTys = + Dest->getFunctionType()->getParamTypes(); + BasicBlock *BB = CI->getParent(); + + // Get an iterator to where we want to insert cast instructions if the + // argument types don't agree. + // + BasicBlock::iterator BBI = find(BB->begin(), BB->end(), CI); + assert(BBI != BB->end() && "CallInst not in parent block?"); + + assert(CI->getNumOperands()-1 == ParamTys.size()&& + "Function calls resolved funny somehow, incompatible number of args"); + + vector Params; + + // Convert all of the call arguments over... inserting cast instructions if + // the types are not compatible. + for (unsigned i = 1; i < CI->getNumOperands(); ++i) { + Value *V = CI->getOperand(i); + + if (V->getType() != ParamTys[i-1]) { // Must insert a cast... + Instruction *Cast = new CastInst(V, ParamTys[i-1]); + BBI = BB->getInstList().insert(BBI, Cast)+1; + V = Cast; + } + + Params.push_back(V); + } + + // Replace the old call instruction with a new call instruction that calls + // the real function. + // + ReplaceInstWithInst(BB->getInstList(), BBI, new CallInst(Dest, Params)); +} + + +bool FunctionResolvingPass::run(Module *M) { + SymbolTable *ST = M->getSymbolTable(); + if (!ST) return false; + + std::map > Functions; + + // Loop over the entries in the symbol table. If an entry is a func pointer, + // then add it to the Functions map. We do a two pass algorithm here to avoid + // problems with iterators getting invalidated if we did a one pass scheme. + // + for (SymbolTable::iterator I = ST->begin(), E = ST->end(); I != E; ++I) + if (const PointerType *PT = dyn_cast(I->first)) + if (isa(PT->getElementType())) { + SymbolTable::VarMap &Plane = I->second; + for (SymbolTable::type_iterator PI = Plane.begin(), PE = Plane.end(); + PI != PE; ++PI) { + const string &Name = PI->first; + Functions[Name].push_back(cast(PI->second)); + } + } + + bool Changed = false; + + // Now we have a list of all functions with a particular name. If there is + // more than one entry in a list, merge the functions together. + // + for (std::map >::iterator I = Functions.begin(), + E = Functions.end(); I != E; ++I) { + vector &Functions = I->second; + Function *Implementation = 0; // Find the implementation + Function *Concrete = 0; + for (unsigned i = 0; i < Functions.size(); ) { + if (!Functions[i]->isExternal()) { // Found an implementation + assert(Implementation == 0 && "Multiple definitions of the same" + " function. Case not handled yet!"); + Implementation = Functions[i]; + } else { + // Ignore functions that are never used so they don't cause spurious + // warnings... here we will actually DCE the function so that it isn't + // used later. + // + if (Functions[i]->use_size() == 0) { + M->getFunctionList().remove(Functions[i]); + delete Functions[i]; + Functions.erase(Functions.begin()+i); + Changed = true; + ++NumResolved; + continue; + } + } + + if (Functions[i] && (!Functions[i]->getFunctionType()->isVarArg())) { + if (Concrete) { // Found two different functions types. Can't choose + Concrete = 0; + break; + } + Concrete = Functions[i]; + } + ++i; + } + + if (Functions.size() > 1) { // Found a multiply defined function... + // We should find exactly one non-vararg function definition, which is + // probably the implementation. Change all of the function definitions + // and uses to use it instead. + // + if (!Concrete) { + cerr << "Warning: Found functions types that are not compatible:\n"; + for (unsigned i = 0; i < Functions.size(); ++i) { + cerr << "\t" << Functions[i]->getType()->getDescription() << " %" + << Functions[i]->getName() << "\n"; + } + cerr << " No linkage of functions named '" << Functions[0]->getName() + << "' performed!\n"; + } else { + for (unsigned i = 0; i < Functions.size(); ++i) + if (Functions[i] != Concrete) { + Function *Old = Functions[i]; + const FunctionType *OldMT = Old->getFunctionType(); + const FunctionType *ConcreteMT = Concrete->getFunctionType(); + bool Broken = false; + + assert(Old->getReturnType() == Concrete->getReturnType() && + "Differing return types not handled yet!"); + assert(OldMT->getParamTypes().size() <= + ConcreteMT->getParamTypes().size() && + "Concrete type must have more specified parameters!"); + + // Check to make sure that if there are specified types, that they + // match... + // + for (unsigned i = 0; i < OldMT->getParamTypes().size(); ++i) + if (OldMT->getParamTypes()[i] != ConcreteMT->getParamTypes()[i]) { + cerr << "Parameter types conflict for" << OldMT + << " and " << ConcreteMT; + Broken = true; + } + if (Broken) break; // Can't process this one! + + + // Attempt to convert all of the uses of the old function to the + // concrete form of the function. If there is a use of the fn + // that we don't understand here we punt to avoid making a bad + // transformation. + // + // At this point, we know that the return values are the same for + // our two functions and that the Old function has no varargs fns + // specified. In otherwords it's just (...) + // + for (unsigned i = 0; i < Old->use_size(); ) { + User *U = *(Old->use_begin()+i); + if (CastInst *CI = dyn_cast(U)) { + // Convert casts directly + assert(CI->getOperand(0) == Old); + CI->setOperand(0, Concrete); + Changed = true; + ++NumResolved; + } else if (CallInst *CI = dyn_cast(U)) { + // Can only fix up calls TO the argument, not args passed in. + if (CI->getCalledValue() == Old) { + ConvertCallTo(CI, Concrete); + Changed = true; + ++NumResolved; + } else { + cerr << "Couldn't cleanup this function call, must be an" + << " argument or something!" << CI; + ++i; + } + } else { + cerr << "Cannot convert use of function: " << U << "\n"; + ++i; + } + } + } + } + } + } + + return Changed; +}