mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-20 11:29:24 +00:00
This allows pointers to aggregate objects, whose elements are only read, to be promoted and passed in by element instead of by reference. This can enable a LOT of subsequent optimizations in the caller function. It's worth pointing out that this stuff happens a LOT of C++ programs, because objects in templates are generally passed around by reference. When these templates are instantiated on small aggregate or scalar types, however, it is more efficient to pass them in by value than by reference. This transformation triggers most on C++ codes (e.g. 334 times on eon), but does happen on C codes as well. For example, on mesa it triggers 72 times, and on gcc it triggers 35 times. this is amazingly good considering that we are using 'basicaa' so far. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12202 91177308-0d34-0410-b5e6-96231b3b80d8
462 lines
18 KiB
C++
462 lines
18 KiB
C++
//===-- 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.
|
|
//
|
|
// This pass also handles aggregate arguments that are passed into a function,
|
|
// scalarizing them if the elements of the aggregate are only loaded. Note that
|
|
// we refuse to scalarize aggregates which would require passing in more than
|
|
// three operands to the function, because we don't want to pass thousands of
|
|
// operands for a large array or something!
|
|
//
|
|
// 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. This case would be best handled when and if we start supporting
|
|
// multiple return values from functions.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#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 "Support/StringExtras.h"
|
|
#include <set>
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
Statistic<> NumArgumentsPromoted("argpromotion",
|
|
"Number of pointer arguments promoted");
|
|
Statistic<> NumAggregatesPromoted("argpromotion",
|
|
"Number of aggregate 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<Function*> WorkList;
|
|
public:
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.addRequired<AliasAnalysis>();
|
|
AU.addRequired<TargetData>();
|
|
}
|
|
|
|
virtual bool run(Module &M);
|
|
private:
|
|
bool PromoteArguments(Function *F);
|
|
bool isSafeToPromoteArgument(Argument *Arg) const;
|
|
void DoPromotion(Function *F, std::vector<Argument*> &ArgsToPromote);
|
|
};
|
|
|
|
RegisterOpt<ArgPromotion> 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<ConstantPointerRef>(*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<Constant>(TheUser) && !isa<GlobalVariable>(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<Argument*> PointerArgs;
|
|
for (Function::aiterator I = F->abegin(), E = F->aend(); I != E; ++I)
|
|
if (isa<PointerType>(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) {
|
|
CallSite CS = CallSite::get(*UI);
|
|
if (Instruction *I = CS.getInstruction()) {
|
|
// Ensure that this call site is CALLING the function, not passing it as
|
|
// an argument.
|
|
for (CallSite::arg_iterator AI = CS.arg_begin(), E = CS.arg_end();
|
|
AI != E; ++AI)
|
|
if (*AI == F) return false; // Passing the function address in!
|
|
} else {
|
|
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, or are GEP
|
|
// instructions (with constant indices) that are subsequently loaded.
|
|
std::vector<LoadInst*> Loads;
|
|
std::vector<std::vector<Constant*> > GEPIndices;
|
|
for (Value::use_iterator UI = Arg->use_begin(), E = Arg->use_end();
|
|
UI != E; ++UI)
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(*UI)) {
|
|
if (LI->isVolatile()) return false; // Don't hack volatile loads
|
|
Loads.push_back(LI);
|
|
} else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(*UI)) {
|
|
if (GEP->use_empty()) {
|
|
// Dead GEP's cause trouble later. Just remove them if we run into
|
|
// them.
|
|
GEP->getParent()->getInstList().erase(GEP);
|
|
return isSafeToPromoteArgument(Arg);
|
|
}
|
|
// Ensure that all of the indices are constants.
|
|
std::vector<Constant*> Operands;
|
|
for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i)
|
|
if (Constant *C = dyn_cast<Constant>(GEP->getOperand(i)))
|
|
Operands.push_back(C);
|
|
else
|
|
return false; // Not a constant operand GEP!
|
|
|
|
// Ensure that the only users of the GEP are load instructions.
|
|
for (Value::use_iterator UI = GEP->use_begin(), E = GEP->use_end();
|
|
UI != E; ++UI)
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(*UI)) {
|
|
if (LI->isVolatile()) return false; // Don't hack volatile loads
|
|
Loads.push_back(LI);
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
// See if there is already a GEP with these indices. If so, check to make
|
|
// sure that we aren't promoting too many elements. If not, nothing to
|
|
// do.
|
|
if (std::find(GEPIndices.begin(), GEPIndices.end(), Operands) ==
|
|
GEPIndices.end()) {
|
|
if (GEPIndices.size() == 3) {
|
|
// We limit aggregate promotion to only promoting up to three elements
|
|
// of the aggregate.
|
|
return false;
|
|
}
|
|
GEPIndices.push_back(Operands);
|
|
}
|
|
} else {
|
|
return false; // Not a load or a GEP.
|
|
}
|
|
|
|
if (Loads.empty()) return true; // No users, dead argument.
|
|
|
|
// 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<BasicBlock*> TranspBlocks;
|
|
|
|
AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
|
|
TargetData &TD = getAnalysis<TargetData>();
|
|
|
|
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();
|
|
|
|
const PointerType *LoadTy =
|
|
cast<PointerType>(Load->getOperand(0)->getType());
|
|
unsigned LoadSize = TD.getTypeSize(LoadTy->getElementType());
|
|
|
|
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<BasicBlock*> 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<Argument*> &Args2Prom) {
|
|
std::set<Argument*> 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<const Type*> Params;
|
|
|
|
// ScalarizedElements - If we are promoting a pointer that has elements
|
|
// accessed out of it, keep track of which elements are accessed so that we
|
|
// can add one argument for each.
|
|
//
|
|
// Arguments that are directly loaded will have a zero element value here, to
|
|
// handle cases where there are both a direct load and GEP accesses.
|
|
//
|
|
std::map<Argument*, std::set<std::vector<Value*> > > ScalarizedElements;
|
|
|
|
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()) {
|
|
// Okay, this is being promoted. Check to see if there are any GEP uses
|
|
// of the argument.
|
|
std::set<std::vector<Value*> > &ArgIndices = ScalarizedElements[I];
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E;
|
|
++UI) {
|
|
Instruction *User = cast<Instruction>(*UI);
|
|
assert(isa<LoadInst>(User) || isa<GetElementPtrInst>(User));
|
|
ArgIndices.insert(std::vector<Value*>(User->op_begin()+1,
|
|
User->op_end()));
|
|
}
|
|
|
|
// Add a parameter to the function for each element passed in.
|
|
for (std::set<std::vector<Value*> >::iterator SI = ArgIndices.begin(),
|
|
E = ArgIndices.end(); SI != E; ++SI)
|
|
Params.push_back(GetElementPtrInst::getIndexedType(I->getType(), *SI));
|
|
|
|
if (ArgIndices.size() == 1 && ArgIndices.begin()->empty())
|
|
++NumArgumentsPromoted;
|
|
else
|
|
++NumAggregatesPromoted;
|
|
} 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<Value*> 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 argument.
|
|
std::set<std::vector<Value*> > &ArgIndices = ScalarizedElements[I];
|
|
for (std::set<std::vector<Value*> >::iterator SI = ArgIndices.begin(),
|
|
E = ArgIndices.end(); SI != E; ++SI) {
|
|
Value *V = *AI;
|
|
if (!SI->empty())
|
|
V = new GetElementPtrInst(V, *SI, V->getName()+".idx", Call);
|
|
|
|
Args.push_back(new LoadInst(V, V->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<InvokeInst>(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.
|
|
std::set<std::vector<Value*> > &ArgIndices = ScalarizedElements[I];
|
|
|
|
while (!I->use_empty()) {
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(I->use_back())) {
|
|
assert(ArgIndices.begin()->empty() &&
|
|
"Load element should sort to front!");
|
|
I2->setName(I->getName()+".val");
|
|
LI->replaceAllUsesWith(I2);
|
|
LI->getParent()->getInstList().erase(LI);
|
|
DEBUG(std::cerr << "*** Promoted argument '" << I->getName()
|
|
<< "' of function '" << F->getName() << "'\n");
|
|
} else {
|
|
GetElementPtrInst *GEP = cast<GetElementPtrInst>(I->use_back());
|
|
std::vector<Value*> Operands(GEP->op_begin()+1, GEP->op_end());
|
|
|
|
unsigned ArgNo = 0;
|
|
Function::aiterator TheArg = I2;
|
|
for (std::set<std::vector<Value*> >::iterator It = ArgIndices.begin();
|
|
*It != Operands; ++It, ++TheArg) {
|
|
assert(It != ArgIndices.end() && "GEP not handled??");
|
|
}
|
|
|
|
std::string NewName = I->getName();
|
|
for (unsigned i = 0, e = Operands.size(); i != e; ++i)
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(Operands[i]))
|
|
NewName += "."+itostr((int64_t)CI->getRawValue());
|
|
else
|
|
NewName += ".x";
|
|
TheArg->setName(NewName+".val");
|
|
|
|
DEBUG(std::cerr << "*** Promoted agg argument '" << TheArg->getName()
|
|
<< "' of function '" << F->getName() << "'\n");
|
|
|
|
// All of the uses must be load instructions. Replace them all with
|
|
// the argument specified by ArgNo.
|
|
while (!GEP->use_empty()) {
|
|
LoadInst *L = cast<LoadInst>(GEP->use_back());
|
|
L->replaceAllUsesWith(TheArg);
|
|
L->getParent()->getInstList().erase(L);
|
|
}
|
|
GEP->getParent()->getInstList().erase(GEP);
|
|
}
|
|
}
|
|
|
|
// If we inserted a new pointer type, it's possible that IT could be
|
|
// promoted too. Also, increment I2 past all of the arguments for this
|
|
// pointer.
|
|
for (unsigned i = 0, e = ArgIndices.size(); i != e; ++i, ++I2)
|
|
if (isa<PointerType>(I2->getType()))
|
|
WorkList.insert(NF);
|
|
}
|
|
|
|
// Now that the old function is dead, delete it.
|
|
F->getParent()->getFunctionList().erase(F);
|
|
}
|