2012-03-16 05:51:52 +00:00
|
|
|
//===- CodeMetrics.cpp - Code cost measurements ---------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements code cost measurement utilities.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Analysis/CodeMetrics.h"
|
|
|
|
#include "llvm/Function.h"
|
|
|
|
#include "llvm/Support/CallSite.h"
|
|
|
|
#include "llvm/IntrinsicInst.h"
|
2012-10-08 16:38:25 +00:00
|
|
|
#include "llvm/DataLayout.h"
|
2012-03-16 05:51:52 +00:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
/// callIsSmall - If a call is likely to lower to a single target instruction,
|
|
|
|
/// or is otherwise deemed small return true.
|
|
|
|
/// TODO: Perhaps calls like memcpy, strcpy, etc?
|
2012-05-04 00:58:03 +00:00
|
|
|
bool llvm::callIsSmall(ImmutableCallSite CS) {
|
|
|
|
if (isa<IntrinsicInst>(CS.getInstruction()))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
const Function *F = CS.getCalledFunction();
|
2012-03-16 05:51:52 +00:00
|
|
|
if (!F) return false;
|
|
|
|
|
|
|
|
if (F->hasLocalLinkage()) return false;
|
|
|
|
|
|
|
|
if (!F->hasName()) return false;
|
|
|
|
|
|
|
|
StringRef Name = F->getName();
|
|
|
|
|
|
|
|
// These will all likely lower to a single selection DAG node.
|
|
|
|
if (Name == "copysign" || Name == "copysignf" || Name == "copysignl" ||
|
|
|
|
Name == "fabs" || Name == "fabsf" || Name == "fabsl" ||
|
|
|
|
Name == "sin" || Name == "sinf" || Name == "sinl" ||
|
|
|
|
Name == "cos" || Name == "cosf" || Name == "cosl" ||
|
|
|
|
Name == "sqrt" || Name == "sqrtf" || Name == "sqrtl" )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// These are all likely to be optimized into something smaller.
|
|
|
|
if (Name == "pow" || Name == "powf" || Name == "powl" ||
|
|
|
|
Name == "exp2" || Name == "exp2l" || Name == "exp2f" ||
|
|
|
|
Name == "floor" || Name == "floorf" || Name == "ceil" ||
|
|
|
|
Name == "round" || Name == "ffs" || Name == "ffsl" ||
|
|
|
|
Name == "abs" || Name == "labs" || Name == "llabs")
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-10-08 16:38:25 +00:00
|
|
|
bool llvm::isInstructionFree(const Instruction *I, const DataLayout *TD) {
|
Initial commit for the rewrite of the inline cost analysis to operate
on a per-callsite walk of the called function's instructions, in
breadth-first order over the potentially reachable set of basic blocks.
This is a major shift in how inline cost analysis works to improve the
accuracy and rationality of inlining decisions. A brief outline of the
algorithm this moves to:
- Build a simplification mapping based on the callsite arguments to the
function arguments.
- Push the entry block onto a worklist of potentially-live basic blocks.
- Pop the first block off of the *front* of the worklist (for
breadth-first ordering) and walk its instructions using a custom
InstVisitor.
- For each instruction's operands, re-map them based on the
simplification mappings available for the given callsite.
- Compute any simplification possible of the instruction after
re-mapping, and store that back int othe simplification mapping.
- Compute any bonuses, costs, or other impacts of the instruction on the
cost metric.
- When the terminator is reached, replace any conditional value in the
terminator with any simplifications from the mapping we have, and add
any successors which are not proven to be dead from these
simplifications to the worklist.
- Pop the next block off of the front of the worklist, and repeat.
- As soon as the cost of inlining exceeds the threshold for the
callsite, stop analyzing the function in order to bound cost.
The primary goal of this algorithm is to perfectly handle dead code
paths. We do not want any code in trivially dead code paths to impact
inlining decisions. The previous metric was *extremely* flawed here, and
would always subtract the average cost of two successors of
a conditional branch when it was proven to become an unconditional
branch at the callsite. There was no handling of wildly different costs
between the two successors, which would cause inlining when the path
actually taken was too large, and no inlining when the path actually
taken was trivially simple. There was also no handling of the code
*path*, only the immediate successors. These problems vanish completely
now. See the added regression tests for the shiny new features -- we
skip recursive function calls, SROA-killing instructions, and high cost
complex CFG structures when dead at the callsite being analyzed.
Switching to this algorithm required refactoring the inline cost
interface to accept the actual threshold rather than simply returning
a single cost. The resulting interface is pretty bad, and I'm planning
to do lots of interface cleanup after this patch.
Several other refactorings fell out of this, but I've tried to minimize
them for this patch. =/ There is still more cleanup that can be done
here. Please point out anything that you see in review.
I've worked really hard to try to mirror at least the spirit of all of
the previous heuristics in the new model. It's not clear that they are
all correct any more, but I wanted to minimize the change in this single
patch, it's already a bit ridiculous. One heuristic that is *not* yet
mirrored is to allow inlining of functions with a dynamic alloca *if*
the caller has a dynamic alloca. I will add this back, but I think the
most reasonable way requires changes to the inliner itself rather than
just the cost metric, and so I've deferred this for a subsequent patch.
The test case is XFAIL-ed until then.
As mentioned in the review mail, this seems to make Clang run about 1%
to 2% faster in -O0, but makes its binary size grow by just under 4%.
I've looked into the 4% growth, and it can be fixed, but requires
changes to other parts of the inliner.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@153812 91177308-0d34-0410-b5e6-96231b3b80d8
2012-03-31 12:42:41 +00:00
|
|
|
if (isa<PHINode>(I))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// If a GEP has all constant indices, it will probably be folded with
|
|
|
|
// a load/store.
|
|
|
|
if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I))
|
|
|
|
return GEP->hasAllConstantIndices();
|
|
|
|
|
|
|
|
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
|
|
|
|
switch (II->getIntrinsicID()) {
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
case Intrinsic::dbg_declare:
|
|
|
|
case Intrinsic::dbg_value:
|
|
|
|
case Intrinsic::invariant_start:
|
|
|
|
case Intrinsic::invariant_end:
|
|
|
|
case Intrinsic::lifetime_start:
|
|
|
|
case Intrinsic::lifetime_end:
|
|
|
|
case Intrinsic::objectsize:
|
|
|
|
case Intrinsic::ptr_annotation:
|
|
|
|
case Intrinsic::var_annotation:
|
|
|
|
// These intrinsics don't count as size.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const CastInst *CI = dyn_cast<CastInst>(I)) {
|
|
|
|
// Noop casts, including ptr <-> int, don't count.
|
2012-05-04 00:58:03 +00:00
|
|
|
if (CI->isLosslessCast())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Value *Op = CI->getOperand(0);
|
|
|
|
// An inttoptr cast is free so long as the input is a legal integer type
|
|
|
|
// which doesn't contain values outside the range of a pointer.
|
|
|
|
if (isa<IntToPtrInst>(CI) && TD &&
|
|
|
|
TD->isLegalInteger(Op->getType()->getScalarSizeInBits()) &&
|
|
|
|
Op->getType()->getScalarSizeInBits() <= TD->getPointerSizeInBits())
|
Initial commit for the rewrite of the inline cost analysis to operate
on a per-callsite walk of the called function's instructions, in
breadth-first order over the potentially reachable set of basic blocks.
This is a major shift in how inline cost analysis works to improve the
accuracy and rationality of inlining decisions. A brief outline of the
algorithm this moves to:
- Build a simplification mapping based on the callsite arguments to the
function arguments.
- Push the entry block onto a worklist of potentially-live basic blocks.
- Pop the first block off of the *front* of the worklist (for
breadth-first ordering) and walk its instructions using a custom
InstVisitor.
- For each instruction's operands, re-map them based on the
simplification mappings available for the given callsite.
- Compute any simplification possible of the instruction after
re-mapping, and store that back int othe simplification mapping.
- Compute any bonuses, costs, or other impacts of the instruction on the
cost metric.
- When the terminator is reached, replace any conditional value in the
terminator with any simplifications from the mapping we have, and add
any successors which are not proven to be dead from these
simplifications to the worklist.
- Pop the next block off of the front of the worklist, and repeat.
- As soon as the cost of inlining exceeds the threshold for the
callsite, stop analyzing the function in order to bound cost.
The primary goal of this algorithm is to perfectly handle dead code
paths. We do not want any code in trivially dead code paths to impact
inlining decisions. The previous metric was *extremely* flawed here, and
would always subtract the average cost of two successors of
a conditional branch when it was proven to become an unconditional
branch at the callsite. There was no handling of wildly different costs
between the two successors, which would cause inlining when the path
actually taken was too large, and no inlining when the path actually
taken was trivially simple. There was also no handling of the code
*path*, only the immediate successors. These problems vanish completely
now. See the added regression tests for the shiny new features -- we
skip recursive function calls, SROA-killing instructions, and high cost
complex CFG structures when dead at the callsite being analyzed.
Switching to this algorithm required refactoring the inline cost
interface to accept the actual threshold rather than simply returning
a single cost. The resulting interface is pretty bad, and I'm planning
to do lots of interface cleanup after this patch.
Several other refactorings fell out of this, but I've tried to minimize
them for this patch. =/ There is still more cleanup that can be done
here. Please point out anything that you see in review.
I've worked really hard to try to mirror at least the spirit of all of
the previous heuristics in the new model. It's not clear that they are
all correct any more, but I wanted to minimize the change in this single
patch, it's already a bit ridiculous. One heuristic that is *not* yet
mirrored is to allow inlining of functions with a dynamic alloca *if*
the caller has a dynamic alloca. I will add this back, but I think the
most reasonable way requires changes to the inliner itself rather than
just the cost metric, and so I've deferred this for a subsequent patch.
The test case is XFAIL-ed until then.
As mentioned in the review mail, this seems to make Clang run about 1%
to 2% faster in -O0, but makes its binary size grow by just under 4%.
I've looked into the 4% growth, and it can be fixed, but requires
changes to other parts of the inliner.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@153812 91177308-0d34-0410-b5e6-96231b3b80d8
2012-03-31 12:42:41 +00:00
|
|
|
return true;
|
2012-05-04 00:58:03 +00:00
|
|
|
|
|
|
|
// A ptrtoint cast is free so long as the result is large enough to store
|
|
|
|
// the pointer, and a legal integer type.
|
|
|
|
if (isa<PtrToIntInst>(CI) && TD &&
|
|
|
|
TD->isLegalInteger(Op->getType()->getScalarSizeInBits()) &&
|
|
|
|
Op->getType()->getScalarSizeInBits() >= TD->getPointerSizeInBits())
|
|
|
|
return true;
|
|
|
|
|
Initial commit for the rewrite of the inline cost analysis to operate
on a per-callsite walk of the called function's instructions, in
breadth-first order over the potentially reachable set of basic blocks.
This is a major shift in how inline cost analysis works to improve the
accuracy and rationality of inlining decisions. A brief outline of the
algorithm this moves to:
- Build a simplification mapping based on the callsite arguments to the
function arguments.
- Push the entry block onto a worklist of potentially-live basic blocks.
- Pop the first block off of the *front* of the worklist (for
breadth-first ordering) and walk its instructions using a custom
InstVisitor.
- For each instruction's operands, re-map them based on the
simplification mappings available for the given callsite.
- Compute any simplification possible of the instruction after
re-mapping, and store that back int othe simplification mapping.
- Compute any bonuses, costs, or other impacts of the instruction on the
cost metric.
- When the terminator is reached, replace any conditional value in the
terminator with any simplifications from the mapping we have, and add
any successors which are not proven to be dead from these
simplifications to the worklist.
- Pop the next block off of the front of the worklist, and repeat.
- As soon as the cost of inlining exceeds the threshold for the
callsite, stop analyzing the function in order to bound cost.
The primary goal of this algorithm is to perfectly handle dead code
paths. We do not want any code in trivially dead code paths to impact
inlining decisions. The previous metric was *extremely* flawed here, and
would always subtract the average cost of two successors of
a conditional branch when it was proven to become an unconditional
branch at the callsite. There was no handling of wildly different costs
between the two successors, which would cause inlining when the path
actually taken was too large, and no inlining when the path actually
taken was trivially simple. There was also no handling of the code
*path*, only the immediate successors. These problems vanish completely
now. See the added regression tests for the shiny new features -- we
skip recursive function calls, SROA-killing instructions, and high cost
complex CFG structures when dead at the callsite being analyzed.
Switching to this algorithm required refactoring the inline cost
interface to accept the actual threshold rather than simply returning
a single cost. The resulting interface is pretty bad, and I'm planning
to do lots of interface cleanup after this patch.
Several other refactorings fell out of this, but I've tried to minimize
them for this patch. =/ There is still more cleanup that can be done
here. Please point out anything that you see in review.
I've worked really hard to try to mirror at least the spirit of all of
the previous heuristics in the new model. It's not clear that they are
all correct any more, but I wanted to minimize the change in this single
patch, it's already a bit ridiculous. One heuristic that is *not* yet
mirrored is to allow inlining of functions with a dynamic alloca *if*
the caller has a dynamic alloca. I will add this back, but I think the
most reasonable way requires changes to the inliner itself rather than
just the cost metric, and so I've deferred this for a subsequent patch.
The test case is XFAIL-ed until then.
As mentioned in the review mail, this seems to make Clang run about 1%
to 2% faster in -O0, but makes its binary size grow by just under 4%.
I've looked into the 4% growth, and it can be fixed, but requires
changes to other parts of the inliner.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@153812 91177308-0d34-0410-b5e6-96231b3b80d8
2012-03-31 12:42:41 +00:00
|
|
|
// trunc to a native type is free (assuming the target has compare and
|
|
|
|
// shift-right of the same width).
|
|
|
|
if (TD && isa<TruncInst>(CI) &&
|
|
|
|
TD->isLegalInteger(TD->getTypeSizeInBits(CI->getType())))
|
|
|
|
return true;
|
|
|
|
// Result of a cmp instruction is often extended (to be used by other
|
|
|
|
// cmp instructions, logical or return instructions). These are usually
|
|
|
|
// nop on most sane targets.
|
|
|
|
if (isa<CmpInst>(CI->getOperand(0)))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-03-16 05:51:52 +00:00
|
|
|
/// analyzeBasicBlock - Fill in the current structure with information gleaned
|
|
|
|
/// from the specified block.
|
|
|
|
void CodeMetrics::analyzeBasicBlock(const BasicBlock *BB,
|
2012-10-08 16:38:25 +00:00
|
|
|
const DataLayout *TD) {
|
2012-03-16 05:51:52 +00:00
|
|
|
++NumBlocks;
|
|
|
|
unsigned NumInstsBeforeThisBB = NumInsts;
|
|
|
|
for (BasicBlock::const_iterator II = BB->begin(), E = BB->end();
|
|
|
|
II != E; ++II) {
|
Initial commit for the rewrite of the inline cost analysis to operate
on a per-callsite walk of the called function's instructions, in
breadth-first order over the potentially reachable set of basic blocks.
This is a major shift in how inline cost analysis works to improve the
accuracy and rationality of inlining decisions. A brief outline of the
algorithm this moves to:
- Build a simplification mapping based on the callsite arguments to the
function arguments.
- Push the entry block onto a worklist of potentially-live basic blocks.
- Pop the first block off of the *front* of the worklist (for
breadth-first ordering) and walk its instructions using a custom
InstVisitor.
- For each instruction's operands, re-map them based on the
simplification mappings available for the given callsite.
- Compute any simplification possible of the instruction after
re-mapping, and store that back int othe simplification mapping.
- Compute any bonuses, costs, or other impacts of the instruction on the
cost metric.
- When the terminator is reached, replace any conditional value in the
terminator with any simplifications from the mapping we have, and add
any successors which are not proven to be dead from these
simplifications to the worklist.
- Pop the next block off of the front of the worklist, and repeat.
- As soon as the cost of inlining exceeds the threshold for the
callsite, stop analyzing the function in order to bound cost.
The primary goal of this algorithm is to perfectly handle dead code
paths. We do not want any code in trivially dead code paths to impact
inlining decisions. The previous metric was *extremely* flawed here, and
would always subtract the average cost of two successors of
a conditional branch when it was proven to become an unconditional
branch at the callsite. There was no handling of wildly different costs
between the two successors, which would cause inlining when the path
actually taken was too large, and no inlining when the path actually
taken was trivially simple. There was also no handling of the code
*path*, only the immediate successors. These problems vanish completely
now. See the added regression tests for the shiny new features -- we
skip recursive function calls, SROA-killing instructions, and high cost
complex CFG structures when dead at the callsite being analyzed.
Switching to this algorithm required refactoring the inline cost
interface to accept the actual threshold rather than simply returning
a single cost. The resulting interface is pretty bad, and I'm planning
to do lots of interface cleanup after this patch.
Several other refactorings fell out of this, but I've tried to minimize
them for this patch. =/ There is still more cleanup that can be done
here. Please point out anything that you see in review.
I've worked really hard to try to mirror at least the spirit of all of
the previous heuristics in the new model. It's not clear that they are
all correct any more, but I wanted to minimize the change in this single
patch, it's already a bit ridiculous. One heuristic that is *not* yet
mirrored is to allow inlining of functions with a dynamic alloca *if*
the caller has a dynamic alloca. I will add this back, but I think the
most reasonable way requires changes to the inliner itself rather than
just the cost metric, and so I've deferred this for a subsequent patch.
The test case is XFAIL-ed until then.
As mentioned in the review mail, this seems to make Clang run about 1%
to 2% faster in -O0, but makes its binary size grow by just under 4%.
I've looked into the 4% growth, and it can be fixed, but requires
changes to other parts of the inliner.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@153812 91177308-0d34-0410-b5e6-96231b3b80d8
2012-03-31 12:42:41 +00:00
|
|
|
if (isInstructionFree(II, TD))
|
|
|
|
continue;
|
2012-03-16 05:51:52 +00:00
|
|
|
|
|
|
|
// Special handling for calls.
|
|
|
|
if (isa<CallInst>(II) || isa<InvokeInst>(II)) {
|
|
|
|
ImmutableCallSite CS(cast<Instruction>(II));
|
|
|
|
|
|
|
|
if (const Function *F = CS.getCalledFunction()) {
|
|
|
|
// If a function is both internal and has a single use, then it is
|
|
|
|
// extremely likely to get inlined in the future (it was probably
|
|
|
|
// exposed by an interleaved devirtualization pass).
|
|
|
|
if (!CS.isNoInline() && F->hasInternalLinkage() && F->hasOneUse())
|
|
|
|
++NumInlineCandidates;
|
|
|
|
|
|
|
|
// If this call is to function itself, then the function is recursive.
|
|
|
|
// Inlining it into other functions is a bad idea, because this is
|
|
|
|
// basically just a form of loop peeling, and our metrics aren't useful
|
|
|
|
// for that case.
|
|
|
|
if (F == BB->getParent())
|
|
|
|
isRecursive = true;
|
|
|
|
}
|
|
|
|
|
2012-05-04 00:58:03 +00:00
|
|
|
if (!callIsSmall(CS)) {
|
2012-03-16 05:51:52 +00:00
|
|
|
// Each argument to a call takes on average one instruction to set up.
|
|
|
|
NumInsts += CS.arg_size();
|
|
|
|
|
|
|
|
// We don't want inline asm to count as a call - that would prevent loop
|
|
|
|
// unrolling. The argument setup cost is still real, though.
|
|
|
|
if (!isa<InlineAsm>(CS.getCalledValue()))
|
|
|
|
++NumCalls;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
|
|
|
|
if (!AI->isStaticAlloca())
|
|
|
|
this->usesDynamicAlloca = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isa<ExtractElementInst>(II) || II->getType()->isVectorTy())
|
|
|
|
++NumVectorInsts;
|
|
|
|
|
|
|
|
++NumInsts;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isa<ReturnInst>(BB->getTerminator()))
|
|
|
|
++NumRets;
|
|
|
|
|
|
|
|
// We never want to inline functions that contain an indirectbr. This is
|
|
|
|
// incorrect because all the blockaddress's (in static global initializers
|
|
|
|
// for example) would be referring to the original function, and this indirect
|
|
|
|
// jump would jump from the inlined copy of the function into the original
|
|
|
|
// function which is extremely undefined behavior.
|
|
|
|
// FIXME: This logic isn't really right; we can safely inline functions
|
|
|
|
// with indirectbr's as long as no other function or global references the
|
|
|
|
// blockaddress of a block within the current function. And as a QOI issue,
|
|
|
|
// if someone is using a blockaddress without an indirectbr, and that
|
|
|
|
// reference somehow ends up in another function or global, we probably
|
|
|
|
// don't want to inline this function.
|
|
|
|
if (isa<IndirectBrInst>(BB->getTerminator()))
|
|
|
|
containsIndirectBr = true;
|
|
|
|
|
|
|
|
// Remember NumInsts for this BB.
|
|
|
|
NumBBInsts[BB] = NumInsts - NumInstsBeforeThisBB;
|
|
|
|
}
|
|
|
|
|
2012-10-08 16:38:25 +00:00
|
|
|
void CodeMetrics::analyzeFunction(Function *F, const DataLayout *TD) {
|
2012-03-16 05:51:52 +00:00
|
|
|
// If this function contains a call that "returns twice" (e.g., setjmp or
|
|
|
|
// _setjmp) and it isn't marked with "returns twice" itself, never inline it.
|
|
|
|
// This is a hack because we depend on the user marking their local variables
|
|
|
|
// as volatile if they are live across a setjmp call, and they probably
|
|
|
|
// won't do this in callers.
|
|
|
|
exposesReturnsTwice = F->callsFunctionThatReturnsTwice() &&
|
2012-10-09 07:45:08 +00:00
|
|
|
!F->getFnAttributes().hasAttribute(Attributes::ReturnsTwice);
|
2012-03-16 05:51:52 +00:00
|
|
|
|
|
|
|
// Look at the size of the callee.
|
|
|
|
for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
|
|
|
|
analyzeBasicBlock(&*BB, TD);
|
|
|
|
}
|