From: Chris Lattner Date: Fri, 29 Mar 2002 03:39:36 +0000 (+0000) Subject: s/Method/Function/g X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=0d461f7f09731b34b21b99dab749dae89db241c3;p=oota-llvm.git s/Method/Function/g git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2029 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index a3dc9d88abd..955e9e672a7 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -42,9 +42,9 @@ namespace { // bool doInitialization(Module *M); - // doPerMethodWork - This method simplifies the specified method hopefully. + // runOnFunction - This method simplifies the specified function hopefully. // - bool runOnMethod(Method *M); + bool runOnMethod(Function *F); // doPassFinalization - Strip out type names that are unused by the program bool doFinalization(Module *M); @@ -63,11 +63,11 @@ namespace { // ConvertCallTo - Convert a call to a varargs function with no arg types -// specified to a concrete nonvarargs method. +// specified to a concrete nonvarargs function. // -static void ConvertCallTo(CallInst *CI, Method *Dest) { - const MethodType::ParamTypes &ParamTys = - Dest->getMethodType()->getParamTypes(); +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 @@ -77,7 +77,7 @@ static void ConvertCallTo(CallInst *CI, Method *Dest) { assert(BBI != BB->end() && "CallInst not in parent block?"); assert(CI->getNumOperands()-1 == ParamTys.size()&& - "Method calls resolved funny somehow, incompatible number of args"); + "Function calls resolved funny somehow, incompatible number of args"); vector Params; @@ -96,100 +96,99 @@ static void ConvertCallTo(CallInst *CI, Method *Dest) { } // Replace the old call instruction with a new call instruction that calls - // the real method. + // the real function. // ReplaceInstWithInst(BB->getInstList(), BBI, new CallInst(Dest, Params)); } -// PatchUpMethodReferences - Go over the methods that are in the module and -// look for methods that have the same name. More often than not, there will +// PatchUpFunctionReferences - 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. // -static bool PatchUpMethodReferences(Module *M) { +static bool PatchUpFunctionReferences(Module *M) { SymbolTable *ST = M->getSymbolTable(); if (!ST) return false; - std::map > Methods; + std::map > Functions; - // Loop over the entries in the symbol table. If an entry is a method pointer, - // then add it to the Methods map. We do a two pass algorithm here to avoid + // 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())) { + 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; - Method *M = cast(PI->second); - Methods[Name].push_back(M); + Functions[Name].push_back(cast(PI->second)); } } bool Changed = false; - // Now we have a list of all methods with a particular name. If there is more - // than one entry in a list, merge the methods together. + // 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 = Methods.begin(), - E = Methods.end(); I != E; ++I) { - vector &Methods = I->second; - Method *Implementation = 0; // Find the implementation - Method *Concrete = 0; - for (unsigned i = 0; i < Methods.size(); ) { - if (!Methods[i]->isExternal()) { // Found an implementation + 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" - " method. Case not handled yet!"); - Implementation = Methods[i]; + " function. Case not handled yet!"); + Implementation = Functions[i]; } else { - // Ignore methods that are never used so they don't cause spurious + // 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 (Methods[i]->use_size() == 0) { - M->getFunctionList().remove(Methods[i]); - delete Methods[i]; - Methods.erase(Methods.begin()+i); + if (Functions[i]->use_size() == 0) { + M->getFunctionList().remove(Functions[i]); + delete Functions[i]; + Functions.erase(Functions.begin()+i); Changed = true; continue; } } - if (Methods[i] && (!Methods[i]->getMethodType()->isVarArg())) { - if (Concrete) { // Found two different methods types. Can't choose + if (Functions[i] && (!Functions[i]->getFunctionType()->isVarArg())) { + if (Concrete) { // Found two different functions types. Can't choose Concrete = 0; break; } - Concrete = Methods[i]; + Concrete = Functions[i]; } ++i; } - if (Methods.size() > 1) { // Found a multiply defined method. - // We should find exactly one non-vararg method definition, which is - // probably the implementation. Change all of the method definitions + 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 methods types that are not compatible:\n"; - for (unsigned i = 0; i < Methods.size(); ++i) { - cerr << "\t" << Methods[i]->getType()->getDescription() << " %" - << Methods[i]->getName() << "\n"; + 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 methods named '" << Methods[0]->getName() + cerr << " No linkage of functions named '" << Functions[0]->getName() << "' performed!\n"; } else { - for (unsigned i = 0; i < Methods.size(); ++i) - if (Methods[i] != Concrete) { - Method *Old = Methods[i]; - const MethodType *OldMT = Old->getMethodType(); - const MethodType *ConcreteMT = Concrete->getMethodType(); + 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() && @@ -210,13 +209,13 @@ static bool PatchUpMethodReferences(Module *M) { if (Broken) break; // Can't process this one! - // Attempt to convert all of the uses of the old method to the - // concrete form of the method. If there is a use of the method + // 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 method has no varargs methods + // 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(); ) { @@ -237,7 +236,7 @@ static bool PatchUpMethodReferences(Module *M) { ++i; } } else { - cerr << "Cannot convert use of method: " << U << "\n"; + cerr << "Cannot convert use of function: " << U << "\n"; ++i; } } @@ -281,12 +280,12 @@ bool CleanupGCCOutput::doInitialization(Module *M) { if (M->hasSymbolTable()) { SymbolTable *ST = M->getSymbolTable(); - // Go over the methods that are in the module and look for methods that have - // the same name. More often than not, there will be things like: + // Go over the functions that are in the module and look for methods that + // have the same name. More often than not, there will be things like: // void "foo"(...) and void "foo"(int, int) because of the way things are // declared in C. If this is the case, patch things up. // - Changed |= PatchUpMethodReferences(M); + Changed |= PatchUpFunctionReferences(M); // Check the symbol table for superfluous type entries... // @@ -397,15 +396,15 @@ static inline bool FixCastsAndPHIs(BasicBlock *BB) { } // RefactorPredecessor - When we find out that a basic block is a repeated -// predecessor in a PHI node, we have to refactor the method until there is at +// predecessor in a PHI node, we have to refactor the function until there is at // most a single instance of a basic block in any predecessor list. // static inline void RefactorPredecessor(BasicBlock *BB, BasicBlock *Pred) { - Method *M = BB->getParent(); + Function *M = BB->getParent(); assert(find(pred_begin(BB), pred_end(BB), Pred) != pred_end(BB) && "Pred is not a predecessor of BB!"); - // Create a new basic block, adding it to the end of the method. + // Create a new basic block, adding it to the end of the function. BasicBlock *NewBB = new BasicBlock("", M); // Add an unconditional branch to BB to the new block. @@ -435,9 +434,9 @@ static inline void RefactorPredecessor(BasicBlock *BB, BasicBlock *Pred) { } -// fixLocalProblems - Loop through the method and fix problems with the PHI -// nodes in the current method. The problem is that PHI nodes might exist with -// multiple entries for the same predecessor. GCC sometimes generates code +// fixLocalProblems - Loop through the function and fix problems with the PHI +// nodes in the current function. The problem is that PHI nodes might exist +// with multiple entries for the same predecessor. GCC sometimes generates code // that looks like this: // // bb7: br bool %cond1004, label %bb8, label %bb8 @@ -451,7 +450,7 @@ static inline void RefactorPredecessor(BasicBlock *BB, BasicBlock *Pred) { // bb8: %reg119 = phi uint [ 0, %bbX ], [ 1, %bb7 ] // // -static bool fixLocalProblems(Method *M) { +static bool fixLocalProblems(Function *M) { bool Changed = false; // Don't use iterators because invalidation gets messy... for (unsigned MI = 0; MI < M->size(); ++MI) { @@ -484,10 +483,10 @@ static bool fixLocalProblems(Method *M) { -// doPerMethodWork - This method simplifies the specified method hopefully. +// runOnFunction - This method simplifies the specified function hopefully. // -bool CleanupGCCOutput::runOnMethod(Method *M) { - return fixLocalProblems(M); +bool CleanupGCCOutput::runOnMethod(Function *F) { + return fixLocalProblems(F); } bool CleanupGCCOutput::doFinalization(Module *M) {