| //===- 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/BasicBlock.h" |
| #include "llvm/SymbolTable.h" |
| #include "llvm/DerivedTypes.h" |
| #include "llvm/Pass.h" |
| #include "llvm/iOther.h" |
| #include "llvm/Constant.h" |
| #include "Support/StatisticReporter.h" |
| #include <iostream> |
| #include <algorithm> |
| |
| 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<Value*> 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); |
| } |
| |
| Instruction *NewCall = new CallInst(Dest, Params); |
| |
| // Replace the old call instruction with a new call instruction that calls |
| // the real function. |
| // |
| BBI = BB->getInstList().insert(BBI, NewCall)+1; |
| |
| // Remove the old call instruction from the program... |
| BB->getInstList().remove(BBI); |
| |
| // Replace uses of the old instruction with the appropriate values... |
| // |
| if (NewCall->getType() == CI->getType()) { |
| CI->replaceAllUsesWith(NewCall); |
| NewCall->setName(CI->getName()); |
| |
| } else if (NewCall->getType() == Type::VoidTy) { |
| // Resolved function does not return a value but the prototype does. This |
| // often occurs because undefined functions default to returning integers. |
| // Just replace uses of the call (which are broken anyway) with dummy |
| // values. |
| CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); |
| } else if (CI->getType() == Type::VoidTy) { |
| // If we are gaining a new return value, we don't have to do anything |
| // special. |
| } else { |
| assert(0 && "This should have been checked before!"); |
| abort(); |
| } |
| |
| // The old instruction is no longer needed, destroy it! |
| delete CI; |
| } |
| |
| |
| bool FunctionResolvingPass::run(Module *M) { |
| SymbolTable *ST = M->getSymbolTable(); |
| if (!ST) return false; |
| |
| std::map<string, vector<Function*> > 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<PointerType>(I->first)) |
| if (isa<FunctionType>(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<Function>(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<string, vector<Function*> >::iterator I = Functions.begin(), |
| E = Functions.end(); I != E; ++I) { |
| vector<Function*> &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() || |
| Concrete->getReturnType() == Type::VoidTy || |
| Old->getReturnType() == Type::VoidTy) && |
| "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 <retty> (...) |
| // |
| for (unsigned i = 0; i < Old->use_size(); ) { |
| User *U = *(Old->use_begin()+i); |
| if (CastInst *CI = dyn_cast<CastInst>(U)) { |
| // Convert casts directly |
| assert(CI->getOperand(0) == Old); |
| CI->setOperand(0, Concrete); |
| Changed = true; |
| ++NumResolved; |
| } else if (CallInst *CI = dyn_cast<CallInst>(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; |
| } |