From: Chris Lattner Date: Sun, 7 Mar 2004 21:29:54 +0000 (+0000) Subject: New LLVM pass: argument promotion. This version only handles simple scalar X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=ed570a7dca45e001a6223e2a25d034b838934f88;p=oota-llvm.git New LLVM pass: argument promotion. This version only handles simple scalar variables. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12193 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp new file mode 100644 index 00000000000..2745af893be --- /dev/null +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -0,0 +1,328 @@ +//===-- ArgumentPromotion.cpp - Promote 'by reference' arguments ----------===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This pass promotes "by reference" arguments to be "by value" arguments. In +// practice, this means looking for internal functions that have pointer +// arguments. If we can prove, through the use of alias analysis, that that an +// argument is *only* loaded, then we can pass the value into the function +// instead of the address of the value. This can cause recursive simplification +// of code, and lead to the elimination of allocas, especially in C++ template +// code like the STL. +// +// Note that this transformation could also be done for arguments that are only +// stored to (returning the value instead), but we do not currently handle that +// case. +// +// Note that we should be able to promote pointers to structures that are only +// loaded from as well. The danger is creating way to many arguments, so this +// transformation should be limited to 3 element structs or something. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Transforms/IPO.h" +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" +#include "llvm/Module.h" +#include "llvm/Pass.h" +#include "llvm/Instructions.h" +#include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Target/TargetData.h" +#include "llvm/Support/CallSite.h" +#include "llvm/Support/CFG.h" +#include "Support/Debug.h" +#include "Support/DepthFirstIterator.h" +#include "Support/Statistic.h" +#include +using namespace llvm; + +namespace { + Statistic<> NumArgumentsPromoted("argpromotion", + "Number of pointer arguments promoted"); + Statistic<> NumArgumentsDead("argpromotion", + "Number of dead pointer args eliminated"); + + /// ArgPromotion - The 'by reference' to 'by value' argument promotion pass. + /// + class ArgPromotion : public Pass { + // WorkList - The set of internal functions that we have yet to process. As + // we eliminate arguments from a function, we push all callers into this set + // so that the by reference argument can be bubbled out as far as possible. + // This set contains only internal functions. + std::set WorkList; + public: + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequired(); + AU.addRequired(); + } + + virtual bool run(Module &M); + private: + bool PromoteArguments(Function *F); + bool isSafeToPromoteArgument(Argument *Arg) const; + void DoPromotion(Function *F, std::vector &ArgsToPromote); + }; + + RegisterOpt X("argpromotion", + "Promote 'by reference' arguments to scalars"); +} + +Pass *llvm::createArgumentPromotionPass() { + return new ArgPromotion(); +} + +bool ArgPromotion::run(Module &M) { + bool Changed = false; + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + if (I->hasInternalLinkage()) { + WorkList.insert(I); + + // If there are any constant pointer refs pointing to this function, + // eliminate them now if possible. + ConstantPointerRef *CPR = 0; + for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; + ++UI) + if ((CPR = dyn_cast(*UI))) + break; // Found one! + if (CPR) { + // See if we can transform all users to use the function directly. + while (!CPR->use_empty()) { + User *TheUser = CPR->use_back(); + if (!isa(TheUser)) { + Changed = true; + TheUser->replaceUsesOfWith(CPR, I); + } else { + // We won't be able to eliminate all users. :( + WorkList.erase(I); // Minor efficiency win. + break; + } + } + + // If we nuked all users of the CPR, kill the CPR now! + if (CPR->use_empty()) { + CPR->destroyConstant(); + Changed = true; + } + } + } + + while (!WorkList.empty()) { + Function *F = *WorkList.begin(); + WorkList.erase(WorkList.begin()); + + if (PromoteArguments(F)) // Attempt to promote an argument. + Changed = true; // Remember that we changed something. + } + + return Changed; +} + + +bool ArgPromotion::PromoteArguments(Function *F) { + assert(F->hasInternalLinkage() && "We can only process internal functions!"); + + // First check: see if there are any pointer arguments! If not, quick exit. + std::vector PointerArgs; + for (Function::aiterator I = F->abegin(), E = F->aend(); I != E; ++I) + if (isa(I->getType())) + PointerArgs.push_back(I); + if (PointerArgs.empty()) return false; + + // Second check: make sure that all callers are direct callers. We can't + // transform functions that have indirect callers. + for (Value::use_iterator UI = F->use_begin(), E = F->use_end(); + UI != E; ++UI) + // What about CPRs? + if (!CallSite::get(*UI).getInstruction()) + return false; // Cannot promote an indirect call! + + // Check to see which arguments are promotable. If an argument is not + // promotable, remove it from the PointerArgs vector. + for (unsigned i = 0; i != PointerArgs.size(); ++i) + if (!isSafeToPromoteArgument(PointerArgs[i])) { + std::swap(PointerArgs[i--], PointerArgs.back()); + PointerArgs.pop_back(); + } + + // No promotable pointer arguments. + if (PointerArgs.empty()) return false; + + // Okay, promote all of the arguments are rewrite the callees! + DoPromotion(F, PointerArgs); + return true; +} + +bool ArgPromotion::isSafeToPromoteArgument(Argument *Arg) const { + // We can only promote this argument if all of the uses are loads... + std::vector Loads; + for (Value::use_iterator UI = Arg->use_begin(), E = Arg->use_end(); + UI != E; ++UI) + if (LoadInst *LI = dyn_cast(*UI)) { + if (LI->isVolatile()) return false; // Don't hack volatile loads + Loads.push_back(LI); + } else + return false; + + if (Loads.empty()) return true; // No users, dead argument. + + const Type *LoadTy = cast(Arg->getType())->getElementType(); + unsigned LoadSize = getAnalysis().getTypeSize(LoadTy); + + // Okay, now we know that the argument is only used by load instructions. + // Check to see if the pointer is guaranteed to not be modified from entry of + // the function to each of the load instructions. + Function &F = *Arg->getParent(); + + // Because there could be several/many load instructions, remember which + // blocks we know to be transparent to the load. + std::set TranspBlocks; + + AliasAnalysis &AA = getAnalysis(); + + for (unsigned i = 0, e = Loads.size(); i != e; ++i) { + // Check to see if the load is invalidated from the start of the block to + // the load itself. + LoadInst *Load = Loads[i]; + BasicBlock *BB = Load->getParent(); + if (AA.canInstructionRangeModify(BB->front(), *Load, Arg, LoadSize)) + return false; // Pointer is invalidated! + + // Now check every path from the entry block to the load for transparency. + // To do this, we perform a depth first search on the inverse CFG from the + // loading block. + for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) + for (idf_ext_iterator I = idf_ext_begin(*PI, TranspBlocks), + E = idf_ext_end(*PI, TranspBlocks); I != E; ++I) + if (AA.canBasicBlockModify(**I, Arg, LoadSize)) + return false; + } + + // If the path from the entry of the function to each load is free of + // instructions that potentially invalidate the load, we can make the + // transformation! + return true; +} + + +void ArgPromotion::DoPromotion(Function *F, std::vector &Args2Prom) { + std::set ArgsToPromote(Args2Prom.begin(), Args2Prom.end()); + + // Start by computing a new prototype for the function, which is the same as + // the old function, but has modified arguments. + const FunctionType *FTy = F->getFunctionType(); + std::vector Params; + + for (Function::aiterator I = F->abegin(), E = F->aend(); I != E; ++I) + if (!ArgsToPromote.count(I)) { + Params.push_back(I->getType()); + } else if (!I->use_empty()) { + Params.push_back(cast(I->getType())->getElementType()); + ++NumArgumentsPromoted; + } else { + ++NumArgumentsDead; + } + + const Type *RetTy = FTy->getReturnType(); + + // Work around LLVM bug PR56: the CWriter cannot emit varargs functions which + // have zero fixed arguments. + bool ExtraArgHack = false; + if (Params.empty() && FTy->isVarArg()) { + ExtraArgHack = true; + Params.push_back(Type::IntTy); + } + FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg()); + + // Create the new function body and insert it into the module... + Function *NF = new Function(NFTy, F->getLinkage(), F->getName()); + F->getParent()->getFunctionList().insert(F, NF); + + // Loop over all of the callers of the function, transforming the call sites + // to pass in the loaded pointers. + // + std::vector Args; + while (!F->use_empty()) { + CallSite CS = CallSite::get(F->use_back()); + Instruction *Call = CS.getInstruction(); + + // Make sure the caller of this function is revisited. + if (Call->getParent()->getParent()->hasInternalLinkage()) + WorkList.insert(Call->getParent()->getParent()); + + // Loop over the operands, deleting dead ones... + CallSite::arg_iterator AI = CS.arg_begin(); + for (Function::aiterator I = F->abegin(), E = F->aend(); I != E; ++I, ++AI) + if (!ArgsToPromote.count(I)) + Args.push_back(*AI); // Unmodified argument + else if (!I->use_empty()) { + // Non-dead instruction + Args.push_back(new LoadInst(*AI, (*AI)->getName()+".val", Call)); + } + + if (ExtraArgHack) + Args.push_back(Constant::getNullValue(Type::IntTy)); + + // Push any varargs arguments on the list + for (; AI != CS.arg_end(); ++AI) + Args.push_back(*AI); + + Instruction *New; + if (InvokeInst *II = dyn_cast(Call)) { + New = new InvokeInst(NF, II->getNormalDest(), II->getUnwindDest(), + Args, "", Call); + } else { + New = new CallInst(NF, Args, "", Call); + } + Args.clear(); + + if (!Call->use_empty()) { + Call->replaceAllUsesWith(New); + std::string Name = Call->getName(); + Call->setName(""); + New->setName(Name); + } + + // Finally, remove the old call from the program, reducing the use-count of + // F. + Call->getParent()->getInstList().erase(Call); + } + + // Since we have now created the new function, splice the body of the old + // function right into the new function, leaving the old rotting hulk of the + // function empty. + NF->getBasicBlockList().splice(NF->begin(), F->getBasicBlockList()); + + // Loop over the argument list, transfering uses of the old arguments over to + // the new arguments, also transfering over the names as well. + // + for (Function::aiterator I = F->abegin(), E = F->aend(), I2 = NF->abegin(); + I != E; ++I) + if (!ArgsToPromote.count(I)) { + // If this is an unmodified argument, move the name and users over to the + // new version. + I->replaceAllUsesWith(I2); + I2->setName(I->getName()); + ++I2; + } else if (!I->use_empty()) { + // Otherwise, if we promoted this argument, then all users are load + // instructions, and all loads should be using the new argument that we + // added. + /*DEBUG*/(std::cerr << "*** Promoted argument '" << I->getName() + << "' of function '" << F->getName() << "'\n"); + I2->setName(I->getName()+".val"); + while (!I->use_empty()) { + LoadInst *LI = cast(I->use_back()); + LI->replaceAllUsesWith(I2); + LI->getParent()->getInstList().erase(LI); + } + ++I2; + } + + // Now that the old function is dead, delete it. + F->getParent()->getFunctionList().erase(F); +}