2003-10-24 00:52:27 +08:00
|
|
|
//===-- IPConstantPropagation.cpp - Propagate constants through calls -----===//
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-24 00:52:27 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-24 00:52:27 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This pass implements an _extremely_ simple interprocedural constant
|
|
|
|
// propagation pass. It could certainly be improved in many different ways,
|
|
|
|
// like using a worklist. This pass makes arguments dead, but does not remove
|
|
|
|
// them. The existing dead argument elimination pass should be run after this
|
|
|
|
// to clean up the mess.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/IPO.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2014-03-04 19:01:28 +08:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
2003-10-24 00:52:27 +08:00
|
|
|
#include "llvm/Pass.h"
|
2003-11-22 05:54:22 +08:00
|
|
|
using namespace llvm;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2014-04-22 10:55:47 +08:00
|
|
|
#define DEBUG_TYPE "ipconstprop"
|
|
|
|
|
2006-12-20 06:09:18 +08:00
|
|
|
STATISTIC(NumArgumentsProped, "Number of args turned into constants");
|
|
|
|
STATISTIC(NumReturnValProped, "Number of return values turned into constants");
|
2003-10-24 00:52:27 +08:00
|
|
|
|
2006-12-20 06:09:18 +08:00
|
|
|
namespace {
|
2003-10-24 00:52:27 +08:00
|
|
|
/// IPCP - The interprocedural constant propagation pass
|
|
|
|
///
|
2009-10-25 14:33:48 +08:00
|
|
|
struct IPCP : public ModulePass {
|
2007-05-06 21:37:16 +08:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2010-10-20 01:21:58 +08:00
|
|
|
IPCP() : ModulePass(ID) {
|
|
|
|
initializeIPCPPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-05-02 05:15:47 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
bool runOnModule(Module &M) override;
|
2003-10-24 00:52:27 +08:00
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
2003-10-24 00:52:27 +08:00
|
|
|
|
2004-11-14 14:10:11 +08:00
|
|
|
/// PropagateConstantsIntoArguments - Look at all uses of the specified
|
|
|
|
/// function. If all uses are direct call sites, and all pass a particular
|
|
|
|
/// constant in for an argument, propagate that constant in as the argument.
|
2003-10-24 00:52:27 +08:00
|
|
|
///
|
2016-05-04 04:08:24 +08:00
|
|
|
static bool PropagateConstantsIntoArguments(Function &F) {
|
2006-08-28 06:42:52 +08:00
|
|
|
if (F.arg_empty() || F.use_empty()) return false; // No arguments? Early exit.
|
2003-10-24 00:52:27 +08:00
|
|
|
|
2008-04-23 14:16:27 +08:00
|
|
|
// For each argument, keep track of its constant value and whether it is a
|
|
|
|
// constant or not. The bool is driven to true when found to be non-constant.
|
|
|
|
SmallVector<std::pair<Constant*, bool>, 16> ArgumentConstants;
|
2005-03-15 12:54:21 +08:00
|
|
|
ArgumentConstants.resize(F.arg_size());
|
2003-10-24 00:52:27 +08:00
|
|
|
|
|
|
|
unsigned NumNonconstant = 0;
|
2014-03-09 11:16:01 +08:00
|
|
|
for (Use &U : F.uses()) {
|
|
|
|
User *UR = U.getUser();
|
2009-11-01 14:11:53 +08:00
|
|
|
// Ignore blockaddress uses.
|
2014-03-09 11:16:01 +08:00
|
|
|
if (isa<BlockAddress>(UR)) continue;
|
2009-11-01 14:11:53 +08:00
|
|
|
|
2008-04-23 14:16:27 +08:00
|
|
|
// Used by a non-instruction, or not the callee of a function, do not
|
|
|
|
// transform.
|
2014-03-09 11:16:01 +08:00
|
|
|
if (!isa<CallInst>(UR) && !isa<InvokeInst>(UR))
|
2008-04-23 14:16:27 +08:00
|
|
|
return false;
|
|
|
|
|
2014-03-09 11:16:01 +08:00
|
|
|
CallSite CS(cast<Instruction>(UR));
|
|
|
|
if (!CS.isCallee(&U))
|
2009-01-23 05:35:57 +08:00
|
|
|
return false;
|
2008-04-23 14:16:27 +08:00
|
|
|
|
|
|
|
// Check out all of the potentially constant arguments. Note that we don't
|
|
|
|
// inspect varargs here.
|
|
|
|
CallSite::arg_iterator AI = CS.arg_begin();
|
|
|
|
Function::arg_iterator Arg = F.arg_begin();
|
|
|
|
for (unsigned i = 0, e = ArgumentConstants.size(); i != e;
|
|
|
|
++i, ++AI, ++Arg) {
|
|
|
|
|
|
|
|
// If this argument is known non-constant, ignore it.
|
|
|
|
if (ArgumentConstants[i].second)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Constant *C = dyn_cast<Constant>(*AI);
|
2014-04-25 13:29:35 +08:00
|
|
|
if (C && ArgumentConstants[i].first == nullptr) {
|
2008-04-23 14:16:27 +08:00
|
|
|
ArgumentConstants[i].first = C; // First constant seen.
|
|
|
|
} else if (C && ArgumentConstants[i].first == C) {
|
|
|
|
// Still the constant value we think it is.
|
|
|
|
} else if (*AI == &*Arg) {
|
|
|
|
// Ignore recursive calls passing argument down.
|
|
|
|
} else {
|
|
|
|
// Argument became non-constant. If all arguments are non-constant now,
|
|
|
|
// give up on this function.
|
|
|
|
if (++NumNonconstant == ArgumentConstants.size())
|
|
|
|
return false;
|
|
|
|
ArgumentConstants[i].second = true;
|
2003-10-24 00:52:27 +08:00
|
|
|
}
|
|
|
|
}
|
2008-04-23 14:16:27 +08:00
|
|
|
}
|
2003-10-24 00:52:27 +08:00
|
|
|
|
|
|
|
// If we got to this point, there is a constant argument!
|
|
|
|
assert(NumNonconstant != ArgumentConstants.size());
|
2003-10-28 05:09:00 +08:00
|
|
|
bool MadeChange = false;
|
2008-04-23 14:16:27 +08:00
|
|
|
Function::arg_iterator AI = F.arg_begin();
|
|
|
|
for (unsigned i = 0, e = ArgumentConstants.size(); i != e; ++i, ++AI) {
|
|
|
|
// Do we have a constant argument?
|
2009-09-25 02:33:42 +08:00
|
|
|
if (ArgumentConstants[i].second || AI->use_empty() ||
|
2014-01-28 10:38:36 +08:00
|
|
|
AI->hasInAllocaAttr() || (AI->hasByValAttr() && !F.onlyReadsMemory()))
|
2008-04-23 14:16:27 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
Value *V = ArgumentConstants[i].first;
|
2014-04-25 13:29:35 +08:00
|
|
|
if (!V) V = UndefValue::get(AI->getType());
|
2008-04-23 14:16:27 +08:00
|
|
|
AI->replaceAllUsesWith(V);
|
|
|
|
++NumArgumentsProped;
|
|
|
|
MadeChange = true;
|
|
|
|
}
|
2003-10-28 05:09:00 +08:00
|
|
|
return MadeChange;
|
2003-10-24 00:52:27 +08:00
|
|
|
}
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2004-11-14 14:10:11 +08:00
|
|
|
|
2008-06-18 16:09:27 +08:00
|
|
|
// Check to see if this function returns one or more constants. If so, replace
|
|
|
|
// all callers that use those return values with the constant value. This will
|
|
|
|
// leave in the actual return values and instructions, but deadargelim will
|
|
|
|
// clean that up.
|
2008-06-18 16:30:37 +08:00
|
|
|
//
|
|
|
|
// Additionally if a function always returns one of its arguments directly,
|
|
|
|
// callers will be updated to use the value they pass in directly instead of
|
|
|
|
// using the return value.
|
2016-05-04 04:08:24 +08:00
|
|
|
static bool PropagateConstantReturn(Function &F) {
|
2009-11-23 11:29:18 +08:00
|
|
|
if (F.getReturnType()->isVoidTy())
|
2004-11-14 14:10:11 +08:00
|
|
|
return false; // No return value.
|
|
|
|
|
Don't IPO over functions that can be de-refined
Summary:
Fixes PR26774.
If you're aware of the issue, feel free to skip the "Motivation"
section and jump directly to "This patch".
Motivation:
I define "refinement" as discarding behaviors from a program that the
optimizer has license to discard. So transforming:
```
void f(unsigned x) {
unsigned t = 5 / x;
(void)t;
}
```
to
```
void f(unsigned x) { }
```
is refinement, since the behavior went from "if x == 0 then undefined
else nothing" to "nothing" (the optimizer has license to discard
undefined behavior).
Refinement is a fundamental aspect of many mid-level optimizations done
by LLVM. For instance, transforming `x == (x + 1)` to `false` also
involves refinement since the expression's value went from "if x is
`undef` then { `true` or `false` } else { `false` }" to "`false`" (by
definition, the optimizer has license to fold `undef` to any non-`undef`
value).
Unfortunately, refinement implies that the optimizer cannot assume
that the implementation of a function it can see has all of the
behavior an unoptimized or a differently optimized version of the same
function can have. This is a problem for functions with comdat
linkage, where a function can be replaced by an unoptimized or a
differently optimized version of the same source level function.
For instance, FunctionAttrs cannot assume a comdat function is
actually `readnone` even if it does not have any loads or stores in
it; since there may have been loads and stores in the "original
function" that were refined out in the currently visible variant, and
at the link step the linker may in fact choose an implementation with
a load or a store. As an example, consider a function that does two
atomic loads from the same memory location, and writes to memory only
if the two values are not equal. The optimizer is allowed to refine
this function by first CSE'ing the two loads, and the folding the
comparision to always report that the two values are equal. Such a
refined variant will look like it is `readonly`. However, the
unoptimized version of the function can still write to memory (since
the two loads //can// result in different values), and selecting the
unoptimized version at link time will retroactively invalidate
transforms we may have done under the assumption that the function
does not write to memory.
Note: this is not just a problem with atomics or with linking
differently optimized object files. See PR26774 for more realistic
examples that involved neither.
This patch:
This change introduces a new set of linkage types, predicated as
`GlobalValue::mayBeDerefined` that returns true if the linkage type
allows a function to be replaced by a differently optimized variant at
link time. It then changes a set of IPO passes to bail out if they see
such a function.
Reviewers: chandlerc, hfinkel, dexonsmith, joker.eph, rnk
Subscribers: mcrosier, llvm-commits
Differential Revision: http://reviews.llvm.org/D18634
llvm-svn: 265762
2016-04-08 08:48:30 +08:00
|
|
|
// We can infer and propagate the return value only when we know that the
|
|
|
|
// definition we'll get at link time is *exactly* the definition we see now.
|
|
|
|
// For more details, see GlobalValue::mayBeDerefined.
|
|
|
|
if (!F.isDefinitionExact())
|
2008-06-09 15:58:07 +08:00
|
|
|
return false;
|
2009-07-22 08:24:57 +08:00
|
|
|
|
2004-11-14 14:10:11 +08:00
|
|
|
// Check to see if this function returns a constant.
|
2008-03-12 06:24:29 +08:00
|
|
|
SmallVector<Value *,4> RetVals;
|
2011-07-18 12:54:35 +08:00
|
|
|
StructType *STy = dyn_cast<StructType>(F.getReturnType());
|
2008-03-12 06:24:29 +08:00
|
|
|
if (STy)
|
2008-06-18 16:09:27 +08:00
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i < e; ++i)
|
2009-07-31 07:03:37 +08:00
|
|
|
RetVals.push_back(UndefValue::get(STy->getElementType(i)));
|
2008-03-12 06:24:29 +08:00
|
|
|
else
|
2009-07-31 07:03:37 +08:00
|
|
|
RetVals.push_back(UndefValue::get(F.getReturnType()));
|
2008-03-12 06:24:29 +08:00
|
|
|
|
2008-06-18 16:09:27 +08:00
|
|
|
unsigned NumNonConstant = 0;
|
2004-11-14 14:10:11 +08:00
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
2008-02-20 19:26:25 +08:00
|
|
|
if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {
|
2008-04-23 13:59:23 +08:00
|
|
|
for (unsigned i = 0, e = RetVals.size(); i != e; ++i) {
|
2008-06-18 16:09:27 +08:00
|
|
|
// Already found conflicting return values?
|
2008-04-23 13:59:23 +08:00
|
|
|
Value *RV = RetVals[i];
|
2008-06-18 16:09:27 +08:00
|
|
|
if (!RV)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Find the returned value
|
|
|
|
Value *V;
|
2008-10-04 06:21:24 +08:00
|
|
|
if (!STy)
|
2011-04-04 15:44:02 +08:00
|
|
|
V = RI->getOperand(0);
|
2008-06-18 16:09:27 +08:00
|
|
|
else
|
2009-11-23 11:29:18 +08:00
|
|
|
V = FindInsertedValue(RI->getOperand(0), i);
|
2008-06-18 16:09:27 +08:00
|
|
|
|
|
|
|
if (V) {
|
|
|
|
// Ignore undefs, we can change them into anything
|
|
|
|
if (isa<UndefValue>(V))
|
|
|
|
continue;
|
|
|
|
|
2008-06-18 16:30:37 +08:00
|
|
|
// Try to see if all the rets return the same constant or argument.
|
|
|
|
if (isa<Constant>(V) || isa<Argument>(V)) {
|
2008-06-18 16:09:27 +08:00
|
|
|
if (isa<UndefValue>(RV)) {
|
|
|
|
// No value found yet? Try the current one.
|
|
|
|
RetVals[i] = V;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// Returning the same value? Good.
|
|
|
|
if (RV == V)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Different or no known return value? Don't propagate this return
|
|
|
|
// value.
|
2014-04-25 13:29:35 +08:00
|
|
|
RetVals[i] = nullptr;
|
2013-12-05 13:44:44 +08:00
|
|
|
// All values non-constant? Stop looking.
|
2008-06-18 16:09:27 +08:00
|
|
|
if (++NumNonConstant == RetVals.size())
|
|
|
|
return false;
|
2004-11-14 14:10:11 +08:00
|
|
|
}
|
2008-02-20 19:26:25 +08:00
|
|
|
}
|
2004-11-14 14:10:11 +08:00
|
|
|
|
2008-06-18 16:09:27 +08:00
|
|
|
// If we got here, the function returns at least one constant value. Loop
|
|
|
|
// over all users, replacing any uses of the return value with the returned
|
|
|
|
// constant.
|
2004-11-14 14:10:11 +08:00
|
|
|
bool MadeChange = false;
|
2014-03-09 11:16:01 +08:00
|
|
|
for (Use &U : F.uses()) {
|
|
|
|
CallSite CS(U.getUser());
|
2008-06-19 16:53:24 +08:00
|
|
|
Instruction* Call = CS.getInstruction();
|
|
|
|
|
|
|
|
// Not a call instruction or a call instruction that's not calling F
|
|
|
|
// directly?
|
2014-03-09 11:16:01 +08:00
|
|
|
if (!Call || !CS.isCallee(&U))
|
2008-04-23 13:59:23 +08:00
|
|
|
continue;
|
|
|
|
|
2008-06-19 16:53:24 +08:00
|
|
|
// Call result not used?
|
2008-04-23 13:59:23 +08:00
|
|
|
if (Call->use_empty())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
MadeChange = true;
|
2004-11-14 14:10:11 +08:00
|
|
|
|
2014-04-25 13:29:35 +08:00
|
|
|
if (!STy) {
|
2008-06-18 16:30:37 +08:00
|
|
|
Value* New = RetVals[0];
|
|
|
|
if (Argument *A = dyn_cast<Argument>(New))
|
|
|
|
// Was an argument returned? Then find the corresponding argument in
|
2008-06-19 16:53:24 +08:00
|
|
|
// the call instruction and use that.
|
|
|
|
New = CS.getArgument(A->getArgNo());
|
2008-06-18 16:30:37 +08:00
|
|
|
Call->replaceAllUsesWith(New);
|
2008-04-23 13:59:23 +08:00
|
|
|
continue;
|
|
|
|
}
|
2014-03-09 11:16:01 +08:00
|
|
|
|
|
|
|
for (auto I = Call->user_begin(), E = Call->user_end(); I != E;) {
|
2009-06-07 01:49:35 +08:00
|
|
|
Instruction *Ins = cast<Instruction>(*I);
|
2008-06-18 16:09:27 +08:00
|
|
|
|
|
|
|
// Increment now, so we can remove the use
|
|
|
|
++I;
|
|
|
|
|
|
|
|
// Find the index of the retval to replace with
|
|
|
|
int index = -1;
|
2008-07-23 08:34:11 +08:00
|
|
|
if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Ins))
|
2008-06-18 16:09:27 +08:00
|
|
|
if (EV->hasIndices())
|
|
|
|
index = *EV->idx_begin();
|
|
|
|
|
|
|
|
// If this use uses a specific return value, and we have a replacement,
|
|
|
|
// replace it.
|
|
|
|
if (index != -1) {
|
|
|
|
Value *New = RetVals[index];
|
|
|
|
if (New) {
|
2008-06-18 16:30:37 +08:00
|
|
|
if (Argument *A = dyn_cast<Argument>(New))
|
|
|
|
// Was an argument returned? Then find the corresponding argument in
|
2008-06-19 16:53:24 +08:00
|
|
|
// the call instruction and use that.
|
|
|
|
New = CS.getArgument(A->getArgNo());
|
2008-06-18 16:09:27 +08:00
|
|
|
Ins->replaceAllUsesWith(New);
|
|
|
|
Ins->eraseFromParent();
|
2004-12-12 01:00:14 +08:00
|
|
|
}
|
2008-03-21 02:30:32 +08:00
|
|
|
}
|
2008-03-12 06:24:29 +08:00
|
|
|
}
|
2004-11-14 14:10:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (MadeChange) ++NumReturnValProped;
|
|
|
|
return MadeChange;
|
|
|
|
}
|
2016-05-04 04:08:24 +08:00
|
|
|
|
|
|
|
char IPCP::ID = 0;
|
|
|
|
INITIALIZE_PASS(IPCP, "ipconstprop",
|
|
|
|
"Interprocedural constant propagation", false, false)
|
|
|
|
|
|
|
|
ModulePass *llvm::createIPConstantPropagationPass() { return new IPCP(); }
|
|
|
|
|
|
|
|
bool IPCP::runOnModule(Module &M) {
|
|
|
|
if (skipModule(M))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
bool Changed = false;
|
|
|
|
bool LocalChange = true;
|
|
|
|
|
|
|
|
// FIXME: instead of using smart algorithms, we just iterate until we stop
|
|
|
|
// making changes.
|
|
|
|
while (LocalChange) {
|
|
|
|
LocalChange = false;
|
|
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
|
|
|
|
if (!I->isDeclaration()) {
|
|
|
|
// Delete any klingons.
|
|
|
|
I->removeDeadConstantUsers();
|
|
|
|
if (I->hasLocalLinkage())
|
|
|
|
LocalChange |= PropagateConstantsIntoArguments(*I);
|
|
|
|
Changed |= PropagateConstantReturn(*I);
|
|
|
|
}
|
|
|
|
Changed |= LocalChange;
|
|
|
|
}
|
|
|
|
return Changed;
|
|
|
|
}
|