2007-03-31 04:06:36 +00:00
|
|
|
//===- CodeGenPrepare.cpp - Prepare a function for code generation --------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-03-31 04:06:36 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This pass munges the code in the input function to better prepare it for
|
2008-05-08 17:46:35 +00:00
|
|
|
// SelectionDAG-based code generation. This works around limitations in it's
|
|
|
|
// basic-block-at-a-time approach. It should eventually be removed.
|
2007-03-31 04:06:36 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "codegenprepare"
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/DerivedTypes.h"
|
|
|
|
#include "llvm/Function.h"
|
2012-06-29 12:38:19 +00:00
|
|
|
#include "llvm/IRBuilder.h"
|
2008-02-26 02:42:37 +00:00
|
|
|
#include "llvm/InlineAsm.h"
|
2007-03-31 04:06:36 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2009-03-26 01:15:07 +00:00
|
|
|
#include "llvm/IntrinsicInst.h"
|
2007-03-31 04:06:36 +00:00
|
|
|
#include "llvm/Pass.h"
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2007-03-31 04:06:36 +00:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
2010-09-30 20:51:52 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2012-06-29 12:38:19 +00:00
|
|
|
#include "llvm/Analysis/Dominators.h"
|
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
|
|
|
#include "llvm/Analysis/ProfileInfo.h"
|
2009-02-13 17:45:12 +00:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
2008-02-26 02:42:37 +00:00
|
|
|
#include "llvm/Support/CallSite.h"
|
2010-08-17 01:34:49 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2007-12-05 23:58:20 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
#include "llvm/Support/GetElementPtrTypeIterator.h"
|
2008-11-25 04:42:10 +00:00
|
|
|
#include "llvm/Support/PatternMatch.h"
|
2011-01-15 07:25:29 +00:00
|
|
|
#include "llvm/Support/ValueHandle.h"
|
2012-06-29 12:38:19 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include "llvm/Target/TargetData.h"
|
|
|
|
#include "llvm/Target/TargetLibraryInfo.h"
|
|
|
|
#include "llvm/Target/TargetLowering.h"
|
|
|
|
#include "llvm/Transforms/Utils/AddrModeMatcher.h"
|
|
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
|
|
|
#include "llvm/Transforms/Utils/BuildLibCalls.h"
|
2012-09-04 18:22:17 +00:00
|
|
|
#include "llvm/Transforms/Utils/BypassSlowDivision.h"
|
2012-06-29 12:38:19 +00:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2007-03-31 04:06:36 +00:00
|
|
|
using namespace llvm;
|
2008-11-25 04:42:10 +00:00
|
|
|
using namespace llvm::PatternMatch;
|
2007-03-31 04:06:36 +00:00
|
|
|
|
2011-01-05 17:27:27 +00:00
|
|
|
STATISTIC(NumBlocksElim, "Number of blocks eliminated");
|
2011-03-21 01:19:09 +00:00
|
|
|
STATISTIC(NumPHIsElim, "Number of trivial PHIs eliminated");
|
|
|
|
STATISTIC(NumGEPsElim, "Number of GEPs converted to casts");
|
2011-01-05 17:27:27 +00:00
|
|
|
STATISTIC(NumCmpUses, "Number of uses of Cmp expressions replaced with uses of "
|
|
|
|
"sunken Cmps");
|
|
|
|
STATISTIC(NumCastUses, "Number of uses of Cast expressions replaced with uses "
|
|
|
|
"of sunken Casts");
|
|
|
|
STATISTIC(NumMemoryInsts, "Number of memory instructions whose address "
|
|
|
|
"computations were sunk");
|
2011-03-21 01:19:09 +00:00
|
|
|
STATISTIC(NumExtsMoved, "Number of [s|z]ext instructions combined with loads");
|
|
|
|
STATISTIC(NumExtUses, "Number of uses of [s|z]ext instructions optimized");
|
|
|
|
STATISTIC(NumRetsDup, "Number of return instructions duplicated");
|
2011-08-18 00:50:51 +00:00
|
|
|
STATISTIC(NumDbgValueMoved, "Number of debug value instructions moved");
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
STATISTIC(NumSelectsExpanded, "Number of selects turned into branches");
|
2010-09-30 20:51:52 +00:00
|
|
|
|
2011-03-11 21:52:04 +00:00
|
|
|
static cl::opt<bool> DisableBranchOpts(
|
|
|
|
"disable-cgp-branch-opts", cl::Hidden, cl::init(false),
|
|
|
|
cl::desc("Disable branch optimizations in CodeGenPrepare"));
|
|
|
|
|
2012-05-06 14:25:16 +00:00
|
|
|
static cl::opt<bool> DisableSelectToBranch(
|
|
|
|
"disable-cgp-select2branch", cl::Hidden, cl::init(false),
|
|
|
|
cl::desc("Disable select to branch conversion."));
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
|
2008-09-24 05:32:41 +00:00
|
|
|
namespace {
|
2009-09-02 06:11:42 +00:00
|
|
|
class CodeGenPrepare : public FunctionPass {
|
2007-03-31 04:06:36 +00:00
|
|
|
/// TLI - Keep a pointer of a TargetLowering to consult for determining
|
|
|
|
/// transformation profitability.
|
|
|
|
const TargetLowering *TLI;
|
2011-12-01 03:08:23 +00:00
|
|
|
const TargetLibraryInfo *TLInfo;
|
2011-01-08 17:01:52 +00:00
|
|
|
DominatorTree *DT;
|
2009-12-17 09:39:49 +00:00
|
|
|
ProfileInfo *PFI;
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:14:54 +00:00
|
|
|
/// CurInstIterator - As we scan instructions optimizing them, this is the
|
|
|
|
/// next instruction to optimize. Xforms that can invalidate this should
|
|
|
|
/// update it.
|
|
|
|
BasicBlock::iterator CurInstIterator;
|
2008-12-19 18:03:11 +00:00
|
|
|
|
2011-03-21 01:19:09 +00:00
|
|
|
/// Keeps track of non-local addresses that have been sunk into a block.
|
|
|
|
/// This allows us to avoid inserting duplicate code for blocks with
|
|
|
|
/// multiple load/stores of the same address.
|
2011-01-06 00:42:50 +00:00
|
|
|
DenseMap<Value*, Value*> SunkAddrs;
|
|
|
|
|
2011-03-24 15:35:25 +00:00
|
|
|
/// ModifiedDT - If CFG is modified in anyway, dominator tree may need to
|
2011-03-21 01:19:09 +00:00
|
|
|
/// be updated.
|
2011-03-24 15:35:25 +00:00
|
|
|
bool ModifiedDT;
|
2011-03-21 01:19:09 +00:00
|
|
|
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
/// OptSize - True if optimizing for size.
|
|
|
|
bool OptSize;
|
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
public:
|
2007-05-06 13:37:16 +00:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2007-08-01 15:32:29 +00:00
|
|
|
explicit CodeGenPrepare(const TargetLowering *tli = 0)
|
2010-10-19 17:21:58 +00:00
|
|
|
: FunctionPass(ID), TLI(tli) {
|
|
|
|
initializeCodeGenPreparePass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-03-31 04:06:36 +00:00
|
|
|
bool runOnFunction(Function &F);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2009-09-16 09:26:52 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
2011-01-08 17:01:52 +00:00
|
|
|
AU.addPreserved<DominatorTree>();
|
2009-09-16 09:26:52 +00:00
|
|
|
AU.addPreserved<ProfileInfo>();
|
2011-12-01 03:08:23 +00:00
|
|
|
AU.addRequired<TargetLibraryInfo>();
|
2009-09-16 09:26:52 +00:00
|
|
|
}
|
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
private:
|
2012-08-14 05:19:07 +00:00
|
|
|
bool EliminateFallThrough(Function &F);
|
2007-04-02 01:35:34 +00:00
|
|
|
bool EliminateMostlyEmptyBlocks(Function &F);
|
|
|
|
bool CanMergeBlocks(const BasicBlock *BB, const BasicBlock *DestBB) const;
|
|
|
|
void EliminateMostlyEmptyBlock(BasicBlock *BB);
|
2007-03-31 04:06:36 +00:00
|
|
|
bool OptimizeBlock(BasicBlock &BB);
|
2011-01-06 02:37:26 +00:00
|
|
|
bool OptimizeInst(Instruction *I);
|
2011-07-18 04:54:35 +00:00
|
|
|
bool OptimizeMemoryInst(Instruction *I, Value *Addr, Type *AccessTy);
|
2011-01-15 07:14:54 +00:00
|
|
|
bool OptimizeInlineAsmInst(CallInst *CS);
|
2010-03-11 02:41:03 +00:00
|
|
|
bool OptimizeCallInst(CallInst *CI);
|
2009-10-16 20:59:35 +00:00
|
|
|
bool MoveExtToFormExtLoad(Instruction *I);
|
2007-12-05 23:58:20 +00:00
|
|
|
bool OptimizeExtUses(Instruction *I);
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
bool OptimizeSelectInst(SelectInst *SI);
|
2011-03-21 01:19:09 +00:00
|
|
|
bool DupRetToEnableTailCallOpts(ReturnInst *RI);
|
2011-08-18 00:50:51 +00:00
|
|
|
bool PlaceDbgValues(Function &F);
|
2007-03-31 04:06:36 +00:00
|
|
|
};
|
|
|
|
}
|
2007-05-01 21:15:47 +00:00
|
|
|
|
2007-05-03 01:11:54 +00:00
|
|
|
char CodeGenPrepare::ID = 0;
|
2011-12-01 03:08:23 +00:00
|
|
|
INITIALIZE_PASS_BEGIN(CodeGenPrepare, "codegenprepare",
|
|
|
|
"Optimize for code generation", false, false)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
|
|
|
|
INITIALIZE_PASS_END(CodeGenPrepare, "codegenprepare",
|
2010-10-07 22:25:06 +00:00
|
|
|
"Optimize for code generation", false, false)
|
2007-03-31 04:06:36 +00:00
|
|
|
|
|
|
|
FunctionPass *llvm::createCodeGenPreparePass(const TargetLowering *TLI) {
|
|
|
|
return new CodeGenPrepare(TLI);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CodeGenPrepare::runOnFunction(Function &F) {
|
|
|
|
bool EverMadeChange = false;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2011-03-24 15:35:25 +00:00
|
|
|
ModifiedDT = false;
|
2011-12-01 03:08:23 +00:00
|
|
|
TLInfo = &getAnalysis<TargetLibraryInfo>();
|
2011-01-08 17:01:52 +00:00
|
|
|
DT = getAnalysisIfAvailable<DominatorTree>();
|
2009-12-17 09:39:49 +00:00
|
|
|
PFI = getAnalysisIfAvailable<ProfileInfo>();
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
OptSize = F.hasFnAttr(Attribute::OptimizeForSize);
|
2011-03-21 01:19:09 +00:00
|
|
|
|
2012-09-04 18:22:17 +00:00
|
|
|
/// This optimization identifies DIV instructions that can be
|
|
|
|
/// profitably bypassed and carried out with a shorter, faster divide.
|
|
|
|
if (TLI && TLI->isSlowDivBypassed()) {
|
|
|
|
const DenseMap<Type *, Type *> &BypassTypeMap = TLI->getBypassSlowDivTypes();
|
|
|
|
|
|
|
|
for (Function::iterator I = F.begin(); I != F.end(); I++) {
|
|
|
|
EverMadeChange |= bypassSlowDivision(F,
|
|
|
|
I,
|
|
|
|
BypassTypeMap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Eliminate blocks that contain only PHI nodes and an
|
2007-04-02 01:35:34 +00:00
|
|
|
// unconditional branch.
|
|
|
|
EverMadeChange |= EliminateMostlyEmptyBlocks(F);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2011-08-18 00:50:51 +00:00
|
|
|
// llvm.dbg.value is far away from the value then iSel may not be able
|
2012-07-24 10:51:42 +00:00
|
|
|
// handle it properly. iSel will drop llvm.dbg.value if it can not
|
2011-08-18 00:50:51 +00:00
|
|
|
// find a node corresponding to the value.
|
|
|
|
EverMadeChange |= PlaceDbgValues(F);
|
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
bool MadeChange = true;
|
2007-03-31 04:06:36 +00:00
|
|
|
while (MadeChange) {
|
|
|
|
MadeChange = false;
|
2011-03-21 01:19:09 +00:00
|
|
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ) {
|
|
|
|
BasicBlock *BB = I++;
|
2007-03-31 04:06:36 +00:00
|
|
|
MadeChange |= OptimizeBlock(*BB);
|
2011-03-21 01:19:09 +00:00
|
|
|
}
|
2007-03-31 04:06:36 +00:00
|
|
|
EverMadeChange |= MadeChange;
|
|
|
|
}
|
2011-01-06 00:42:50 +00:00
|
|
|
|
|
|
|
SunkAddrs.clear();
|
|
|
|
|
2011-03-11 21:52:04 +00:00
|
|
|
if (!DisableBranchOpts) {
|
|
|
|
MadeChange = false;
|
2012-03-04 10:46:01 +00:00
|
|
|
SmallPtrSet<BasicBlock*, 8> WorkList;
|
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
|
|
|
SmallVector<BasicBlock*, 2> Successors(succ_begin(BB), succ_end(BB));
|
2011-05-22 16:24:18 +00:00
|
|
|
MadeChange |= ConstantFoldTerminator(BB, true);
|
2012-03-04 10:46:01 +00:00
|
|
|
if (!MadeChange) continue;
|
|
|
|
|
|
|
|
for (SmallVectorImpl<BasicBlock*>::iterator
|
|
|
|
II = Successors.begin(), IE = Successors.end(); II != IE; ++II)
|
|
|
|
if (pred_begin(*II) == pred_end(*II))
|
|
|
|
WorkList.insert(*II);
|
|
|
|
}
|
|
|
|
|
2012-08-15 21:18:10 +00:00
|
|
|
for (SmallPtrSet<BasicBlock*, 8>::iterator
|
|
|
|
I = WorkList.begin(), E = WorkList.end(); I != E; ++I)
|
|
|
|
DeleteDeadBlock(*I);
|
2011-03-11 21:52:04 +00:00
|
|
|
|
2012-08-14 05:19:07 +00:00
|
|
|
// Merge pairs of basic blocks with unconditional branches, connected by
|
|
|
|
// a single edge.
|
|
|
|
if (EverMadeChange || MadeChange)
|
|
|
|
MadeChange |= EliminateFallThrough(F);
|
|
|
|
|
2011-03-21 01:19:09 +00:00
|
|
|
if (MadeChange)
|
2011-03-24 15:35:25 +00:00
|
|
|
ModifiedDT = true;
|
2011-03-11 21:52:04 +00:00
|
|
|
EverMadeChange |= MadeChange;
|
|
|
|
}
|
|
|
|
|
2011-03-24 15:35:25 +00:00
|
|
|
if (ModifiedDT && DT)
|
2011-03-21 01:19:09 +00:00
|
|
|
DT->DT->recalculate(F);
|
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
return EverMadeChange;
|
|
|
|
}
|
|
|
|
|
2012-08-14 05:19:07 +00:00
|
|
|
/// EliminateFallThrough - Merge basic blocks which are connected
|
|
|
|
/// by a single edge, where one of the basic blocks has a single successor
|
|
|
|
/// pointing to the other basic block, which has a single predecessor.
|
|
|
|
bool CodeGenPrepare::EliminateFallThrough(Function &F) {
|
|
|
|
bool Changed = false;
|
|
|
|
// Scan all of the blocks in the function, except for the entry block.
|
|
|
|
for (Function::iterator I = ++F.begin(), E = F.end(); I != E; ) {
|
|
|
|
BasicBlock *BB = I++;
|
|
|
|
// If the destination block has a single pred, then this is a trivial
|
|
|
|
// edge, just collapse it.
|
|
|
|
BasicBlock *SinglePred = BB->getSinglePredecessor();
|
|
|
|
|
|
|
|
if (!SinglePred || SinglePred == BB) continue;
|
|
|
|
|
|
|
|
BranchInst *Term = dyn_cast<BranchInst>(SinglePred->getTerminator());
|
|
|
|
if (Term && !Term->isConditional()) {
|
|
|
|
Changed = true;
|
2012-08-21 05:55:22 +00:00
|
|
|
DEBUG(dbgs() << "To merge:\n"<< *SinglePred << "\n\n\n");
|
2012-08-14 05:19:07 +00:00
|
|
|
// Remember if SinglePred was the entry block of the function.
|
|
|
|
// If so, we will need to move BB back to the entry position.
|
|
|
|
bool isEntry = SinglePred == &SinglePred->getParent()->getEntryBlock();
|
|
|
|
MergeBasicBlockIntoOnlyPred(BB, this);
|
|
|
|
|
|
|
|
if (isEntry && BB != &BB->getParent()->getEntryBlock())
|
|
|
|
BB->moveBefore(&BB->getParent()->getEntryBlock());
|
|
|
|
|
|
|
|
// We have erased a block. Update the iterator.
|
|
|
|
I = BB;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2009-03-27 01:13:37 +00:00
|
|
|
/// EliminateMostlyEmptyBlocks - eliminate blocks that contain only PHI nodes,
|
|
|
|
/// debug info directives, and an unconditional branch. Passes before isel
|
|
|
|
/// (e.g. LSR/loopsimplify) often split edges in ways that are non-optimal for
|
|
|
|
/// isel. Start by eliminating these blocks so we can split them the way we
|
|
|
|
/// want them.
|
2007-04-02 01:35:34 +00:00
|
|
|
bool CodeGenPrepare::EliminateMostlyEmptyBlocks(Function &F) {
|
|
|
|
bool MadeChange = false;
|
|
|
|
// Note that this intentionally skips the entry block.
|
|
|
|
for (Function::iterator I = ++F.begin(), E = F.end(); I != E; ) {
|
|
|
|
BasicBlock *BB = I++;
|
|
|
|
|
|
|
|
// If this block doesn't end with an uncond branch, ignore it.
|
|
|
|
BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
|
|
|
|
if (!BI || !BI->isUnconditional())
|
|
|
|
continue;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2009-03-27 01:13:37 +00:00
|
|
|
// If the instruction before the branch (skipping debug info) isn't a phi
|
|
|
|
// node, then other stuff is happening here.
|
2007-04-02 01:35:34 +00:00
|
|
|
BasicBlock::iterator BBI = BI;
|
|
|
|
if (BBI != BB->begin()) {
|
|
|
|
--BBI;
|
2009-03-27 01:13:37 +00:00
|
|
|
while (isa<DbgInfoIntrinsic>(BBI)) {
|
|
|
|
if (BBI == BB->begin())
|
|
|
|
break;
|
|
|
|
--BBI;
|
|
|
|
}
|
|
|
|
if (!isa<DbgInfoIntrinsic>(BBI) && !isa<PHINode>(BBI))
|
|
|
|
continue;
|
2007-04-02 01:35:34 +00:00
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// Do not break infinite loops.
|
|
|
|
BasicBlock *DestBB = BI->getSuccessor(0);
|
|
|
|
if (DestBB == BB)
|
|
|
|
continue;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
if (!CanMergeBlocks(BB, DestBB))
|
|
|
|
continue;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
EliminateMostlyEmptyBlock(BB);
|
|
|
|
MadeChange = true;
|
|
|
|
}
|
|
|
|
return MadeChange;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// CanMergeBlocks - Return true if we can merge BB into DestBB if there is a
|
|
|
|
/// single uncond branch between them, and BB contains no other non-phi
|
|
|
|
/// instructions.
|
|
|
|
bool CodeGenPrepare::CanMergeBlocks(const BasicBlock *BB,
|
|
|
|
const BasicBlock *DestBB) const {
|
|
|
|
// We only want to eliminate blocks whose phi nodes are used by phi nodes in
|
|
|
|
// the successor. If there are more complex condition (e.g. preheaders),
|
|
|
|
// don't mess around with them.
|
|
|
|
BasicBlock::const_iterator BBI = BB->begin();
|
|
|
|
while (const PHINode *PN = dyn_cast<PHINode>(BBI++)) {
|
2010-03-25 23:06:16 +00:00
|
|
|
for (Value::const_use_iterator UI = PN->use_begin(), E = PN->use_end();
|
2007-04-02 01:35:34 +00:00
|
|
|
UI != E; ++UI) {
|
|
|
|
const Instruction *User = cast<Instruction>(*UI);
|
|
|
|
if (User->getParent() != DestBB || !isa<PHINode>(User))
|
|
|
|
return false;
|
2008-09-24 05:32:41 +00:00
|
|
|
// If User is inside DestBB block and it is a PHINode then check
|
|
|
|
// incoming value. If incoming value is not from BB then this is
|
2007-04-25 00:37:04 +00:00
|
|
|
// a complex condition (e.g. preheaders) we want to avoid here.
|
|
|
|
if (User->getParent() == DestBB) {
|
|
|
|
if (const PHINode *UPN = dyn_cast<PHINode>(User))
|
|
|
|
for (unsigned I = 0, E = UPN->getNumIncomingValues(); I != E; ++I) {
|
|
|
|
Instruction *Insn = dyn_cast<Instruction>(UPN->getIncomingValue(I));
|
|
|
|
if (Insn && Insn->getParent() == BB &&
|
|
|
|
Insn->getParent() != UPN->getIncomingBlock(I))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2007-04-02 01:35:34 +00:00
|
|
|
}
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// If BB and DestBB contain any common predecessors, then the phi nodes in BB
|
|
|
|
// and DestBB may have conflicting incoming values for the block. If so, we
|
|
|
|
// can't merge the block.
|
|
|
|
const PHINode *DestBBPN = dyn_cast<PHINode>(DestBB->begin());
|
|
|
|
if (!DestBBPN) return true; // no conflict.
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// Collect the preds of BB.
|
2007-11-06 22:07:40 +00:00
|
|
|
SmallPtrSet<const BasicBlock*, 16> BBPreds;
|
2007-04-02 01:35:34 +00:00
|
|
|
if (const PHINode *BBPN = dyn_cast<PHINode>(BB->begin())) {
|
|
|
|
// It is faster to get preds from a PHI than with pred_iterator.
|
|
|
|
for (unsigned i = 0, e = BBPN->getNumIncomingValues(); i != e; ++i)
|
|
|
|
BBPreds.insert(BBPN->getIncomingBlock(i));
|
|
|
|
} else {
|
|
|
|
BBPreds.insert(pred_begin(BB), pred_end(BB));
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// Walk the preds of DestBB.
|
|
|
|
for (unsigned i = 0, e = DestBBPN->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
BasicBlock *Pred = DestBBPN->getIncomingBlock(i);
|
|
|
|
if (BBPreds.count(Pred)) { // Common predecessor?
|
|
|
|
BBI = DestBB->begin();
|
|
|
|
while (const PHINode *PN = dyn_cast<PHINode>(BBI++)) {
|
|
|
|
const Value *V1 = PN->getIncomingValueForBlock(Pred);
|
|
|
|
const Value *V2 = PN->getIncomingValueForBlock(BB);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// If V2 is a phi node in BB, look up what the mapped value will be.
|
|
|
|
if (const PHINode *V2PN = dyn_cast<PHINode>(V2))
|
|
|
|
if (V2PN->getParent() == BB)
|
|
|
|
V2 = V2PN->getIncomingValueForBlock(Pred);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// If there is a conflict, bail out.
|
|
|
|
if (V1 != V2) return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// EliminateMostlyEmptyBlock - Eliminate a basic block that have only phi's and
|
|
|
|
/// an unconditional branch in it.
|
|
|
|
void CodeGenPrepare::EliminateMostlyEmptyBlock(BasicBlock *BB) {
|
|
|
|
BranchInst *BI = cast<BranchInst>(BB->getTerminator());
|
|
|
|
BasicBlock *DestBB = BI->getSuccessor(0);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2010-01-05 01:27:11 +00:00
|
|
|
DEBUG(dbgs() << "MERGING MOSTLY EMPTY BLOCKS - BEFORE:\n" << *BB << *DestBB);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// If the destination block has a single pred, then this is a trivial edge,
|
|
|
|
// just collapse it.
|
2008-11-27 19:29:14 +00:00
|
|
|
if (BasicBlock *SinglePred = DestBB->getSinglePredecessor()) {
|
2008-11-28 19:54:49 +00:00
|
|
|
if (SinglePred != DestBB) {
|
|
|
|
// Remember if SinglePred was the entry block of the function. If so, we
|
|
|
|
// will need to move BB back to the entry position.
|
|
|
|
bool isEntry = SinglePred == &SinglePred->getParent()->getEntryBlock();
|
2009-09-16 09:26:52 +00:00
|
|
|
MergeBasicBlockIntoOnlyPred(DestBB, this);
|
2008-11-28 19:54:49 +00:00
|
|
|
|
|
|
|
if (isEntry && BB != &BB->getParent()->getEntryBlock())
|
|
|
|
BB->moveBefore(&BB->getParent()->getEntryBlock());
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-01-05 01:27:11 +00:00
|
|
|
DEBUG(dbgs() << "AFTER:\n" << *DestBB << "\n\n\n");
|
2008-11-28 19:54:49 +00:00
|
|
|
return;
|
|
|
|
}
|
2007-04-02 01:35:34 +00:00
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// Otherwise, we have multiple predecessors of BB. Update the PHIs in DestBB
|
|
|
|
// to handle the new incoming edges it is about to have.
|
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator BBI = DestBB->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(BBI)); ++BBI) {
|
|
|
|
// Remove the incoming value for BB, and remember it.
|
|
|
|
Value *InVal = PN->removeIncomingValue(BB, false);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// Two options: either the InVal is a phi node defined in BB or it is some
|
|
|
|
// value that dominates BB.
|
|
|
|
PHINode *InValPhi = dyn_cast<PHINode>(InVal);
|
|
|
|
if (InValPhi && InValPhi->getParent() == BB) {
|
|
|
|
// Add all of the input values of the input PHI as inputs of this phi.
|
|
|
|
for (unsigned i = 0, e = InValPhi->getNumIncomingValues(); i != e; ++i)
|
|
|
|
PN->addIncoming(InValPhi->getIncomingValue(i),
|
|
|
|
InValPhi->getIncomingBlock(i));
|
|
|
|
} else {
|
|
|
|
// Otherwise, add one instance of the dominating value for each edge that
|
|
|
|
// we will be adding.
|
|
|
|
if (PHINode *BBPN = dyn_cast<PHINode>(BB->begin())) {
|
|
|
|
for (unsigned i = 0, e = BBPN->getNumIncomingValues(); i != e; ++i)
|
|
|
|
PN->addIncoming(InVal, BBPN->getIncomingBlock(i));
|
|
|
|
} else {
|
|
|
|
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
|
|
|
|
PN->addIncoming(InVal, *PI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-04-02 01:35:34 +00:00
|
|
|
// The PHIs are now updated, change everything that refers to BB to use
|
|
|
|
// DestBB and remove BB.
|
|
|
|
BB->replaceAllUsesWith(DestBB);
|
2011-03-24 15:35:25 +00:00
|
|
|
if (DT && !ModifiedDT) {
|
2011-01-08 17:01:52 +00:00
|
|
|
BasicBlock *BBIDom = DT->getNode(BB)->getIDom()->getBlock();
|
|
|
|
BasicBlock *DestBBIDom = DT->getNode(DestBB)->getIDom()->getBlock();
|
|
|
|
BasicBlock *NewIDom = DT->findNearestCommonDominator(BBIDom, DestBBIDom);
|
|
|
|
DT->changeImmediateDominator(DestBB, NewIDom);
|
|
|
|
DT->eraseNode(BB);
|
|
|
|
}
|
2009-12-17 09:39:49 +00:00
|
|
|
if (PFI) {
|
|
|
|
PFI->replaceAllUses(BB, DestBB);
|
|
|
|
PFI->removeEdge(ProfileInfo::getEdge(BB, DestBB));
|
2009-09-16 09:26:52 +00:00
|
|
|
}
|
2007-04-02 01:35:34 +00:00
|
|
|
BB->eraseFromParent();
|
2011-01-05 17:27:27 +00:00
|
|
|
++NumBlocksElim;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2010-01-05 01:27:11 +00:00
|
|
|
DEBUG(dbgs() << "AFTER:\n" << *DestBB << "\n\n\n");
|
2007-04-02 01:35:34 +00:00
|
|
|
}
|
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
/// OptimizeNoopCopyExpression - If the specified cast instruction is a noop
|
2009-06-14 23:30:43 +00:00
|
|
|
/// copy (e.g. it's casting from one pointer type to another, i32->i8 on PPC),
|
|
|
|
/// sink it into user blocks to reduce the number of virtual
|
2007-06-12 16:50:17 +00:00
|
|
|
/// registers that must be created and coalesced.
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
///
|
|
|
|
/// Return true if any changes are made.
|
2008-11-24 22:44:16 +00:00
|
|
|
///
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
static bool OptimizeNoopCopyExpression(CastInst *CI, const TargetLowering &TLI){
|
2008-09-24 05:32:41 +00:00
|
|
|
// If this is a noop copy,
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT SrcVT = TLI.getValueType(CI->getOperand(0)->getType());
|
|
|
|
EVT DstVT = TLI.getValueType(CI->getType());
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// This is an fp<->int conversion?
|
2008-06-06 12:08:01 +00:00
|
|
|
if (SrcVT.isInteger() != DstVT.isInteger())
|
2007-03-31 04:06:36 +00:00
|
|
|
return false;
|
2008-06-08 20:54:56 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// If this is an extension, it will be a zero or sign extension, which
|
|
|
|
// isn't a noop.
|
2008-06-08 20:54:56 +00:00
|
|
|
if (SrcVT.bitsLT(DstVT)) return false;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// If these values will be promoted, find out what they will be promoted
|
|
|
|
// to. This helps us consider truncates on PPC as noop copies when they
|
|
|
|
// are.
|
2011-05-29 08:10:47 +00:00
|
|
|
if (TLI.getTypeAction(CI->getContext(), SrcVT) ==
|
|
|
|
TargetLowering::TypePromoteInteger)
|
2009-08-12 00:36:31 +00:00
|
|
|
SrcVT = TLI.getTypeToTransformTo(CI->getContext(), SrcVT);
|
2011-05-29 08:10:47 +00:00
|
|
|
if (TLI.getTypeAction(CI->getContext(), DstVT) ==
|
|
|
|
TargetLowering::TypePromoteInteger)
|
2009-08-12 00:36:31 +00:00
|
|
|
DstVT = TLI.getTypeToTransformTo(CI->getContext(), DstVT);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// If, after promotion, these are the same types, this is a noop copy.
|
|
|
|
if (SrcVT != DstVT)
|
2007-03-31 04:06:36 +00:00
|
|
|
return false;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
BasicBlock *DefBB = CI->getParent();
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
/// InsertedCasts - Only insert a cast in each block once.
|
2007-06-12 16:50:17 +00:00
|
|
|
DenseMap<BasicBlock*, CastInst*> InsertedCasts;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
bool MadeChange = false;
|
2008-09-24 05:32:41 +00:00
|
|
|
for (Value::use_iterator UI = CI->use_begin(), E = CI->use_end();
|
2007-03-31 04:06:36 +00:00
|
|
|
UI != E; ) {
|
|
|
|
Use &TheUse = UI.getUse();
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
// Figure out which BB this cast is used in. For PHI's this is the
|
|
|
|
// appropriate predecessor block.
|
|
|
|
BasicBlock *UserBB = User->getParent();
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(User)) {
|
2009-01-23 19:40:15 +00:00
|
|
|
UserBB = PN->getIncomingBlock(UI);
|
2007-03-31 04:06:36 +00:00
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
// Preincrement use iterator so we don't invalidate it.
|
|
|
|
++UI;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
// If this user is in the same block as the cast, don't change the cast.
|
|
|
|
if (UserBB == DefBB) continue;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
// If we have already inserted a cast into this block, use it.
|
|
|
|
CastInst *&InsertedCast = InsertedCasts[UserBB];
|
|
|
|
|
|
|
|
if (!InsertedCast) {
|
2011-08-16 20:45:24 +00:00
|
|
|
BasicBlock::iterator InsertPt = UserBB->getFirstInsertionPt();
|
2008-09-24 05:32:41 +00:00
|
|
|
InsertedCast =
|
|
|
|
CastInst::Create(CI->getOpcode(), CI->getOperand(0), CI->getType(), "",
|
2007-03-31 04:06:36 +00:00
|
|
|
InsertPt);
|
|
|
|
MadeChange = true;
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
// Replace a use of the cast with a use of the new cast.
|
2007-03-31 04:06:36 +00:00
|
|
|
TheUse = InsertedCast;
|
2011-01-05 17:27:27 +00:00
|
|
|
++NumCastUses;
|
2007-03-31 04:06:36 +00:00
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
// If we removed all uses, nuke the cast.
|
2008-01-20 16:51:46 +00:00
|
|
|
if (CI->use_empty()) {
|
2007-03-31 04:06:36 +00:00
|
|
|
CI->eraseFromParent();
|
2008-01-20 16:51:46 +00:00
|
|
|
MadeChange = true;
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
return MadeChange;
|
|
|
|
}
|
|
|
|
|
2008-09-24 05:32:41 +00:00
|
|
|
/// OptimizeCmpExpression - sink the given CmpInst into user blocks to reduce
|
2007-06-12 16:50:17 +00:00
|
|
|
/// the number of virtual registers that must be created and coalesced. This is
|
2007-08-02 16:53:43 +00:00
|
|
|
/// a clear win except on targets with multiple condition code registers
|
|
|
|
/// (PowerPC), where it might lose; some adjustment may be wanted there.
|
2007-06-12 16:50:17 +00:00
|
|
|
///
|
|
|
|
/// Return true if any changes are made.
|
2008-11-24 22:44:16 +00:00
|
|
|
static bool OptimizeCmpExpression(CmpInst *CI) {
|
2007-06-12 16:50:17 +00:00
|
|
|
BasicBlock *DefBB = CI->getParent();
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
/// InsertedCmp - Only insert a cmp in each block once.
|
|
|
|
DenseMap<BasicBlock*, CmpInst*> InsertedCmps;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
bool MadeChange = false;
|
2008-09-24 05:32:41 +00:00
|
|
|
for (Value::use_iterator UI = CI->use_begin(), E = CI->use_end();
|
2007-06-12 16:50:17 +00:00
|
|
|
UI != E; ) {
|
|
|
|
Use &TheUse = UI.getUse();
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
// Preincrement use iterator so we don't invalidate it.
|
|
|
|
++UI;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
// Don't bother for PHI nodes.
|
|
|
|
if (isa<PHINode>(User))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Figure out which BB this cmp is used in.
|
|
|
|
BasicBlock *UserBB = User->getParent();
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
// If this user is in the same block as the cmp, don't change the cmp.
|
|
|
|
if (UserBB == DefBB) continue;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
// If we have already inserted a cmp into this block, use it.
|
|
|
|
CmpInst *&InsertedCmp = InsertedCmps[UserBB];
|
|
|
|
|
|
|
|
if (!InsertedCmp) {
|
2011-08-16 20:45:24 +00:00
|
|
|
BasicBlock::iterator InsertPt = UserBB->getFirstInsertionPt();
|
2008-09-24 05:32:41 +00:00
|
|
|
InsertedCmp =
|
2009-08-25 23:17:54 +00:00
|
|
|
CmpInst::Create(CI->getOpcode(),
|
2009-07-09 23:48:35 +00:00
|
|
|
CI->getPredicate(), CI->getOperand(0),
|
2007-06-12 16:50:17 +00:00
|
|
|
CI->getOperand(1), "", InsertPt);
|
|
|
|
MadeChange = true;
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
// Replace a use of the cmp with a use of the new cmp.
|
|
|
|
TheUse = InsertedCmp;
|
2011-01-05 17:27:27 +00:00
|
|
|
++NumCmpUses;
|
2007-06-12 16:50:17 +00:00
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
// If we removed all uses, nuke the cmp.
|
|
|
|
if (CI->use_empty())
|
|
|
|
CI->eraseFromParent();
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-06-12 16:50:17 +00:00
|
|
|
return MadeChange;
|
|
|
|
}
|
|
|
|
|
2010-03-12 09:27:41 +00:00
|
|
|
namespace {
|
|
|
|
class CodeGenPrepareFortifiedLibCalls : public SimplifyFortifiedLibCalls {
|
|
|
|
protected:
|
|
|
|
void replaceCall(Value *With) {
|
|
|
|
CI->replaceAllUsesWith(With);
|
|
|
|
CI->eraseFromParent();
|
|
|
|
}
|
|
|
|
bool isFoldable(unsigned SizeCIOp, unsigned, bool) const {
|
2010-07-16 09:38:02 +00:00
|
|
|
if (ConstantInt *SizeCI =
|
|
|
|
dyn_cast<ConstantInt>(CI->getArgOperand(SizeCIOp)))
|
|
|
|
return SizeCI->isAllOnesValue();
|
2010-03-12 09:27:41 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
2010-03-11 02:41:03 +00:00
|
|
|
bool CodeGenPrepare::OptimizeCallInst(CallInst *CI) {
|
2011-01-15 07:14:54 +00:00
|
|
|
BasicBlock *BB = CI->getParent();
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:14:54 +00:00
|
|
|
// Lower inline assembly if we can.
|
|
|
|
// If we found an inline asm expession, and if the target knows how to
|
|
|
|
// lower it to normal LLVM code, do so now.
|
|
|
|
if (TLI && isa<InlineAsm>(CI->getCalledValue())) {
|
|
|
|
if (TLI->ExpandInlineAsm(CI)) {
|
|
|
|
// Avoid invalidating the iterator.
|
|
|
|
CurInstIterator = BB->begin();
|
|
|
|
// Avoid processing instructions out of order, which could cause
|
|
|
|
// reuse before a value is defined.
|
|
|
|
SunkAddrs.clear();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
// Sink address computing for memory operands into the block.
|
|
|
|
if (OptimizeInlineAsmInst(CI))
|
|
|
|
return true;
|
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-03-11 02:41:03 +00:00
|
|
|
// Lower all uses of llvm.objectsize.*
|
|
|
|
IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
|
|
|
|
if (II && II->getIntrinsicID() == Intrinsic::objectsize) {
|
2010-06-24 00:44:01 +00:00
|
|
|
bool Min = (cast<ConstantInt>(II->getArgOperand(1))->getZExtValue() == 1);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ReturnTy = CI->getType();
|
2012-07-24 10:51:42 +00:00
|
|
|
Constant *RetVal = ConstantInt::get(ReturnTy, Min ? 0 : -1ULL);
|
|
|
|
|
2011-01-15 07:25:29 +00:00
|
|
|
// Substituting this can cause recursive simplifications, which can
|
|
|
|
// invalidate our iterator. Use a WeakVH to hold onto it in case this
|
|
|
|
// happens.
|
|
|
|
WeakVH IterHandle(CurInstIterator);
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2012-03-24 21:11:24 +00:00
|
|
|
replaceAndRecursivelySimplify(CI, RetVal, TLI ? TLI->getTargetData() : 0,
|
|
|
|
TLInfo, ModifiedDT ? 0 : DT);
|
2011-01-15 07:25:29 +00:00
|
|
|
|
|
|
|
// If the iterator instruction was recursively deleted, start over at the
|
|
|
|
// start of the block.
|
2011-01-18 20:53:04 +00:00
|
|
|
if (IterHandle != CurInstIterator) {
|
2011-01-15 07:25:29 +00:00
|
|
|
CurInstIterator = BB->begin();
|
2011-01-18 20:53:04 +00:00
|
|
|
SunkAddrs.clear();
|
|
|
|
}
|
2010-03-11 02:41:03 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-03-13 20:59:56 +00:00
|
|
|
if (II && TLI) {
|
|
|
|
SmallVector<Value*, 2> PtrOps;
|
|
|
|
Type *AccessTy;
|
|
|
|
if (TLI->GetAddrModeArguments(II, PtrOps, AccessTy))
|
|
|
|
while (!PtrOps.empty())
|
|
|
|
if (OptimizeMemoryInst(II, PtrOps.pop_back_val(), AccessTy))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-03-11 02:41:03 +00:00
|
|
|
// From here on out we're working with named functions.
|
|
|
|
if (CI->getCalledFunction() == 0) return false;
|
2011-05-26 21:51:06 +00:00
|
|
|
|
2010-03-11 02:41:03 +00:00
|
|
|
// We'll need TargetData from here on out.
|
|
|
|
const TargetData *TD = TLI ? TLI->getTargetData() : 0;
|
|
|
|
if (!TD) return false;
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-03-12 09:27:41 +00:00
|
|
|
// Lower all default uses of _chk calls. This is very similar
|
|
|
|
// to what InstCombineCalls does, but here we are only lowering calls
|
2010-03-11 02:41:03 +00:00
|
|
|
// that have the default "don't know" as the objectsize. Anything else
|
|
|
|
// should be left alone.
|
2010-03-12 09:27:41 +00:00
|
|
|
CodeGenPrepareFortifiedLibCalls Simplifier;
|
2012-07-25 16:46:31 +00:00
|
|
|
return Simplifier.fold(CI, TD, TLInfo);
|
2010-03-11 02:41:03 +00:00
|
|
|
}
|
2011-01-15 07:25:29 +00:00
|
|
|
|
2011-03-21 01:19:09 +00:00
|
|
|
/// DupRetToEnableTailCallOpts - Look for opportunities to duplicate return
|
|
|
|
/// instructions to the predecessor to enable tail call optimizations. The
|
|
|
|
/// case it is currently looking for is:
|
|
|
|
/// bb0:
|
|
|
|
/// %tmp0 = tail call i32 @f0()
|
|
|
|
/// br label %return
|
|
|
|
/// bb1:
|
|
|
|
/// %tmp1 = tail call i32 @f1()
|
|
|
|
/// br label %return
|
|
|
|
/// bb2:
|
|
|
|
/// %tmp2 = tail call i32 @f2()
|
|
|
|
/// br label %return
|
|
|
|
/// return:
|
|
|
|
/// %retval = phi i32 [ %tmp0, %bb0 ], [ %tmp1, %bb1 ], [ %tmp2, %bb2 ]
|
|
|
|
/// ret i32 %retval
|
|
|
|
///
|
|
|
|
/// =>
|
|
|
|
///
|
|
|
|
/// bb0:
|
|
|
|
/// %tmp0 = tail call i32 @f0()
|
|
|
|
/// ret i32 %tmp0
|
|
|
|
/// bb1:
|
|
|
|
/// %tmp1 = tail call i32 @f1()
|
|
|
|
/// ret i32 %tmp1
|
|
|
|
/// bb2:
|
|
|
|
/// %tmp2 = tail call i32 @f2()
|
|
|
|
/// ret i32 %tmp2
|
|
|
|
///
|
|
|
|
bool CodeGenPrepare::DupRetToEnableTailCallOpts(ReturnInst *RI) {
|
2011-03-24 04:51:51 +00:00
|
|
|
if (!TLI)
|
|
|
|
return false;
|
|
|
|
|
2012-07-27 21:21:26 +00:00
|
|
|
PHINode *PN = 0;
|
|
|
|
BitCastInst *BCI = 0;
|
2011-03-21 01:19:09 +00:00
|
|
|
Value *V = RI->getReturnValue();
|
2012-07-27 21:21:26 +00:00
|
|
|
if (V) {
|
|
|
|
BCI = dyn_cast<BitCastInst>(V);
|
|
|
|
if (BCI)
|
|
|
|
V = BCI->getOperand(0);
|
|
|
|
|
|
|
|
PN = dyn_cast<PHINode>(V);
|
|
|
|
if (!PN)
|
|
|
|
return false;
|
|
|
|
}
|
2011-03-21 01:19:09 +00:00
|
|
|
|
2011-03-24 04:52:07 +00:00
|
|
|
BasicBlock *BB = RI->getParent();
|
2011-03-24 04:52:10 +00:00
|
|
|
if (PN && PN->getParent() != BB)
|
2011-03-24 04:52:07 +00:00
|
|
|
return false;
|
2011-03-21 01:19:09 +00:00
|
|
|
|
2011-03-24 04:52:07 +00:00
|
|
|
// It's not safe to eliminate the sign / zero extension of the return value.
|
|
|
|
// See llvm::isInTailCallPosition().
|
|
|
|
const Function *F = BB->getParent();
|
2012-01-20 17:56:17 +00:00
|
|
|
Attributes CallerRetAttr = F->getAttributes().getRetAttributes();
|
2011-03-24 04:52:07 +00:00
|
|
|
if ((CallerRetAttr & Attribute::ZExt) || (CallerRetAttr & Attribute::SExt))
|
|
|
|
return false;
|
2011-03-21 01:19:09 +00:00
|
|
|
|
2011-03-24 04:52:10 +00:00
|
|
|
// Make sure there are no instructions between the PHI and return, or that the
|
|
|
|
// return is the first instruction in the block.
|
|
|
|
if (PN) {
|
|
|
|
BasicBlock::iterator BI = BB->begin();
|
|
|
|
do { ++BI; } while (isa<DbgInfoIntrinsic>(BI));
|
2012-07-27 21:21:26 +00:00
|
|
|
if (&*BI == BCI)
|
|
|
|
// Also skip over the bitcast.
|
|
|
|
++BI;
|
2011-03-24 04:52:10 +00:00
|
|
|
if (&*BI != RI)
|
|
|
|
return false;
|
|
|
|
} else {
|
2011-03-24 16:34:59 +00:00
|
|
|
BasicBlock::iterator BI = BB->begin();
|
|
|
|
while (isa<DbgInfoIntrinsic>(BI)) ++BI;
|
|
|
|
if (&*BI != RI)
|
2011-03-24 04:52:10 +00:00
|
|
|
return false;
|
|
|
|
}
|
2011-03-21 01:19:09 +00:00
|
|
|
|
2011-03-24 04:52:07 +00:00
|
|
|
/// Only dup the ReturnInst if the CallInst is likely to be emitted as a tail
|
|
|
|
/// call.
|
|
|
|
SmallVector<CallInst*, 4> TailCalls;
|
2011-03-24 04:52:10 +00:00
|
|
|
if (PN) {
|
|
|
|
for (unsigned I = 0, E = PN->getNumIncomingValues(); I != E; ++I) {
|
|
|
|
CallInst *CI = dyn_cast<CallInst>(PN->getIncomingValue(I));
|
|
|
|
// Make sure the phi value is indeed produced by the tail call.
|
|
|
|
if (CI && CI->hasOneUse() && CI->getParent() == PN->getIncomingBlock(I) &&
|
|
|
|
TLI->mayBeEmittedAsTailCall(CI))
|
|
|
|
TailCalls.push_back(CI);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SmallPtrSet<BasicBlock*, 4> VisitedBBs;
|
|
|
|
for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI) {
|
|
|
|
if (!VisitedBBs.insert(*PI))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
BasicBlock::InstListType &InstList = (*PI)->getInstList();
|
|
|
|
BasicBlock::InstListType::reverse_iterator RI = InstList.rbegin();
|
|
|
|
BasicBlock::InstListType::reverse_iterator RE = InstList.rend();
|
2011-03-24 16:34:59 +00:00
|
|
|
do { ++RI; } while (RI != RE && isa<DbgInfoIntrinsic>(&*RI));
|
|
|
|
if (RI == RE)
|
2011-03-24 04:52:10 +00:00
|
|
|
continue;
|
2011-03-24 16:34:59 +00:00
|
|
|
|
2011-03-24 04:52:10 +00:00
|
|
|
CallInst *CI = dyn_cast<CallInst>(&*RI);
|
2011-03-24 15:54:11 +00:00
|
|
|
if (CI && CI->use_empty() && TLI->mayBeEmittedAsTailCall(CI))
|
2011-03-24 04:52:10 +00:00
|
|
|
TailCalls.push_back(CI);
|
|
|
|
}
|
2011-03-24 04:52:07 +00:00
|
|
|
}
|
2011-03-21 01:19:09 +00:00
|
|
|
|
2011-03-24 04:52:07 +00:00
|
|
|
bool Changed = false;
|
|
|
|
for (unsigned i = 0, e = TailCalls.size(); i != e; ++i) {
|
|
|
|
CallInst *CI = TailCalls[i];
|
|
|
|
CallSite CS(CI);
|
|
|
|
|
|
|
|
// Conservatively require the attributes of the call to match those of the
|
|
|
|
// return. Ignore noalias because it doesn't affect the call sequence.
|
2012-01-20 17:56:17 +00:00
|
|
|
Attributes CalleeRetAttr = CS.getAttributes().getRetAttributes();
|
2011-03-24 04:52:07 +00:00
|
|
|
if ((CalleeRetAttr ^ CallerRetAttr) & ~Attribute::NoAlias)
|
|
|
|
continue;
|
2011-03-21 01:19:09 +00:00
|
|
|
|
2011-03-24 04:52:07 +00:00
|
|
|
// Make sure the call instruction is followed by an unconditional branch to
|
|
|
|
// the return block.
|
|
|
|
BasicBlock *CallBB = CI->getParent();
|
|
|
|
BranchInst *BI = dyn_cast<BranchInst>(CallBB->getTerminator());
|
|
|
|
if (!BI || !BI->isUnconditional() || BI->getSuccessor(0) != BB)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Duplicate the return into CallBB.
|
|
|
|
(void)FoldReturnIntoUncondBranch(RI, BB, CallBB);
|
2011-03-24 15:35:25 +00:00
|
|
|
ModifiedDT = Changed = true;
|
2011-03-24 04:52:07 +00:00
|
|
|
++NumRetsDup;
|
2011-03-21 01:19:09 +00:00
|
|
|
}
|
|
|
|
|
2011-03-24 04:52:07 +00:00
|
|
|
// If we eliminated all predecessors of the block, delete the block now.
|
|
|
|
if (Changed && pred_begin(BB) == pred_end(BB))
|
|
|
|
BB->eraseFromParent();
|
|
|
|
|
|
|
|
return Changed;
|
2011-03-21 01:19:09 +00:00
|
|
|
}
|
|
|
|
|
2008-11-25 07:09:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Memory Optimization
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
/// IsNonLocalValue - Return true if the specified values are defined in a
|
|
|
|
/// different basic block than BB.
|
|
|
|
static bool IsNonLocalValue(Value *V, BasicBlock *BB) {
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(V))
|
|
|
|
return I->getParent() != BB;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-12-03 21:47:07 +00:00
|
|
|
/// OptimizeMemoryInst - Load and Store Instructions often have
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
/// addressing modes that can do significant amounts of computation. As such,
|
|
|
|
/// instruction selection will try to get the load or store to do as much
|
|
|
|
/// computation as possible for the program. The problem is that isel can only
|
|
|
|
/// see within a single block. As such, we sink as much legal addressing mode
|
|
|
|
/// stuff into the block as possible.
|
2008-11-25 07:09:13 +00:00
|
|
|
///
|
|
|
|
/// This method is used to optimize both load/store and inline asms with memory
|
|
|
|
/// operands.
|
2008-11-26 03:20:37 +00:00
|
|
|
bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *AccessTy) {
|
2010-11-27 08:15:55 +00:00
|
|
|
Value *Repl = Addr;
|
2012-07-24 10:51:42 +00:00
|
|
|
|
|
|
|
// Try to collapse single-value PHI nodes. This is necessary to undo
|
2010-11-19 22:15:03 +00:00
|
|
|
// unprofitable PRE transformations.
|
2011-01-03 06:33:01 +00:00
|
|
|
SmallVector<Value*, 8> worklist;
|
|
|
|
SmallPtrSet<Value*, 16> Visited;
|
2010-11-27 08:15:55 +00:00
|
|
|
worklist.push_back(Addr);
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-11-27 08:15:55 +00:00
|
|
|
// Use a worklist to iteratively look through PHI nodes, and ensure that
|
|
|
|
// the addressing mode obtained from the non-PHI roots of the graph
|
|
|
|
// are equivalent.
|
|
|
|
Value *Consensus = 0;
|
2011-03-01 21:13:53 +00:00
|
|
|
unsigned NumUsesConsensus = 0;
|
2011-03-05 08:12:26 +00:00
|
|
|
bool IsNumUsesConsensusValid = false;
|
2010-11-27 08:15:55 +00:00
|
|
|
SmallVector<Instruction*, 16> AddrModeInsts;
|
|
|
|
ExtAddrMode AddrMode;
|
|
|
|
while (!worklist.empty()) {
|
|
|
|
Value *V = worklist.back();
|
|
|
|
worklist.pop_back();
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-11-27 08:15:55 +00:00
|
|
|
// Break use-def graph loops.
|
2011-09-29 23:40:12 +00:00
|
|
|
if (!Visited.insert(V)) {
|
2010-11-27 08:15:55 +00:00
|
|
|
Consensus = 0;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-11-27 08:15:55 +00:00
|
|
|
// For a PHI node, push all of its incoming values.
|
|
|
|
if (PHINode *P = dyn_cast<PHINode>(V)) {
|
|
|
|
for (unsigned i = 0, e = P->getNumIncomingValues(); i != e; ++i)
|
|
|
|
worklist.push_back(P->getIncomingValue(i));
|
|
|
|
continue;
|
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-11-27 08:15:55 +00:00
|
|
|
// For non-PHIs, determine the addressing mode being computed.
|
|
|
|
SmallVector<Instruction*, 16> NewAddrModeInsts;
|
|
|
|
ExtAddrMode NewAddrMode =
|
2011-09-29 23:40:12 +00:00
|
|
|
AddressingModeMatcher::Match(V, AccessTy, MemoryInst,
|
2010-11-27 08:15:55 +00:00
|
|
|
NewAddrModeInsts, *TLI);
|
2011-03-05 08:12:26 +00:00
|
|
|
|
|
|
|
// This check is broken into two cases with very similar code to avoid using
|
|
|
|
// getNumUses() as much as possible. Some values have a lot of uses, so
|
|
|
|
// calling getNumUses() unconditionally caused a significant compile-time
|
|
|
|
// regression.
|
|
|
|
if (!Consensus) {
|
|
|
|
Consensus = V;
|
|
|
|
AddrMode = NewAddrMode;
|
|
|
|
AddrModeInsts = NewAddrModeInsts;
|
|
|
|
continue;
|
|
|
|
} else if (NewAddrMode == AddrMode) {
|
|
|
|
if (!IsNumUsesConsensusValid) {
|
|
|
|
NumUsesConsensus = Consensus->getNumUses();
|
|
|
|
IsNumUsesConsensusValid = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure that the obtained addressing mode is equivalent to that obtained
|
|
|
|
// for all other roots of the PHI traversal. Also, when choosing one
|
|
|
|
// such root as representative, select the one with the most uses in order
|
|
|
|
// to keep the cost modeling heuristics in AddressingModeMatcher
|
|
|
|
// applicable.
|
2011-03-01 21:13:53 +00:00
|
|
|
unsigned NumUses = V->getNumUses();
|
|
|
|
if (NumUses > NumUsesConsensus) {
|
2010-11-27 08:15:55 +00:00
|
|
|
Consensus = V;
|
2011-03-01 21:13:53 +00:00
|
|
|
NumUsesConsensus = NumUses;
|
2010-11-27 08:15:55 +00:00
|
|
|
AddrModeInsts = NewAddrModeInsts;
|
2010-11-19 22:15:03 +00:00
|
|
|
}
|
2010-11-27 08:15:55 +00:00
|
|
|
continue;
|
2010-11-19 22:15:03 +00:00
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-11-27 08:15:55 +00:00
|
|
|
Consensus = 0;
|
|
|
|
break;
|
2010-11-19 22:15:03 +00:00
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2010-11-27 08:15:55 +00:00
|
|
|
// If the addressing mode couldn't be determined, or if multiple different
|
|
|
|
// ones were determined, bail out now.
|
|
|
|
if (!Consensus) return false;
|
2012-07-24 10:51:42 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// Check to see if any of the instructions supersumed by this addr mode are
|
|
|
|
// non-local to I's BB.
|
|
|
|
bool AnyNonLocal = false;
|
|
|
|
for (unsigned i = 0, e = AddrModeInsts.size(); i != e; ++i) {
|
2008-11-26 03:20:37 +00:00
|
|
|
if (IsNonLocalValue(AddrModeInsts[i], MemoryInst->getParent())) {
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
AnyNonLocal = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// If all the instructions matched are already in this BB, don't do anything.
|
|
|
|
if (!AnyNonLocal) {
|
2010-01-05 01:27:11 +00:00
|
|
|
DEBUG(dbgs() << "CGP: Found local addrmode: " << AddrMode << "\n");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
return false;
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// Insert this computation right after this user. Since our caller is
|
|
|
|
// scanning from the top of the BB to the bottom, reuse of the expr are
|
|
|
|
// guaranteed to happen later.
|
2011-09-06 18:49:53 +00:00
|
|
|
IRBuilder<> Builder(MemoryInst);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// Now that we determined the addressing expression we want to use and know
|
|
|
|
// that we have to sink it into this block. Check to see if we have already
|
|
|
|
// done this for some other load/store instr in this block. If so, reuse the
|
|
|
|
// computation.
|
|
|
|
Value *&SunkAddr = SunkAddrs[Addr];
|
|
|
|
if (SunkAddr) {
|
2010-01-05 01:27:11 +00:00
|
|
|
DEBUG(dbgs() << "CGP: Reusing nonlocal addrmode: " << AddrMode << " for "
|
2009-07-25 01:13:51 +00:00
|
|
|
<< *MemoryInst);
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
if (SunkAddr->getType() != Addr->getType())
|
2011-09-27 20:39:19 +00:00
|
|
|
SunkAddr = Builder.CreateBitCast(SunkAddr, Addr->getType());
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
} else {
|
2010-01-05 01:27:11 +00:00
|
|
|
DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for "
|
2009-07-25 01:13:51 +00:00
|
|
|
<< *MemoryInst);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *IntPtrTy =
|
2009-08-13 21:58:54 +00:00
|
|
|
TLI->getTargetData()->getIntPtrType(AccessTy->getContext());
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
Value *Result = 0;
|
2010-01-19 22:45:06 +00:00
|
|
|
|
|
|
|
// Start with the base register. Do this first so that subsequent address
|
|
|
|
// matching finds it last, which will prevent it from trying to match it
|
|
|
|
// as the scaled value in case it happens to be a mul. That would be
|
|
|
|
// problematic if we've sunk a different mul for the scale, because then
|
|
|
|
// we'd end up sinking both muls.
|
|
|
|
if (AddrMode.BaseReg) {
|
|
|
|
Value *V = AddrMode.BaseReg;
|
2010-02-16 11:11:14 +00:00
|
|
|
if (V->getType()->isPointerTy())
|
2011-09-06 18:49:53 +00:00
|
|
|
V = Builder.CreatePtrToInt(V, IntPtrTy, "sunkaddr");
|
2010-01-19 22:45:06 +00:00
|
|
|
if (V->getType() != IntPtrTy)
|
2011-09-06 18:49:53 +00:00
|
|
|
V = Builder.CreateIntCast(V, IntPtrTy, /*isSigned=*/true, "sunkaddr");
|
2010-01-19 22:45:06 +00:00
|
|
|
Result = V;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add the scale value.
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
if (AddrMode.Scale) {
|
|
|
|
Value *V = AddrMode.ScaledReg;
|
|
|
|
if (V->getType() == IntPtrTy) {
|
|
|
|
// done.
|
2010-02-16 11:11:14 +00:00
|
|
|
} else if (V->getType()->isPointerTy()) {
|
2011-09-06 18:49:53 +00:00
|
|
|
V = Builder.CreatePtrToInt(V, IntPtrTy, "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
} else if (cast<IntegerType>(IntPtrTy)->getBitWidth() <
|
|
|
|
cast<IntegerType>(V->getType())->getBitWidth()) {
|
2011-09-06 18:49:53 +00:00
|
|
|
V = Builder.CreateTrunc(V, IntPtrTy, "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
} else {
|
2011-09-06 18:49:53 +00:00
|
|
|
V = Builder.CreateSExt(V, IntPtrTy, "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
}
|
|
|
|
if (AddrMode.Scale != 1)
|
2011-09-06 18:49:53 +00:00
|
|
|
V = Builder.CreateMul(V, ConstantInt::get(IntPtrTy, AddrMode.Scale),
|
|
|
|
"sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
if (Result)
|
2011-09-06 18:49:53 +00:00
|
|
|
Result = Builder.CreateAdd(Result, V, "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
else
|
|
|
|
Result = V;
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// Add in the BaseGV if present.
|
|
|
|
if (AddrMode.BaseGV) {
|
2011-09-06 18:49:53 +00:00
|
|
|
Value *V = Builder.CreatePtrToInt(AddrMode.BaseGV, IntPtrTy, "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
if (Result)
|
2011-09-06 18:49:53 +00:00
|
|
|
Result = Builder.CreateAdd(Result, V, "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
else
|
|
|
|
Result = V;
|
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
// Add in the Base Offset if present.
|
|
|
|
if (AddrMode.BaseOffs) {
|
2009-07-24 23:12:02 +00:00
|
|
|
Value *V = ConstantInt::get(IntPtrTy, AddrMode.BaseOffs);
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
if (Result)
|
2011-09-06 18:49:53 +00:00
|
|
|
Result = Builder.CreateAdd(Result, V, "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
else
|
|
|
|
Result = V;
|
|
|
|
}
|
2007-03-31 04:06:36 +00:00
|
|
|
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
if (Result == 0)
|
2009-07-31 20:28:14 +00:00
|
|
|
SunkAddr = Constant::getNullValue(Addr->getType());
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
else
|
2011-09-06 18:49:53 +00:00
|
|
|
SunkAddr = Builder.CreateIntToPtr(Result, Addr->getType(), "sunkaddr");
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
}
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2010-11-19 22:15:03 +00:00
|
|
|
MemoryInst->replaceUsesOfWith(Repl, SunkAddr);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2011-04-09 07:05:44 +00:00
|
|
|
// If we have no uses, recursively delete the value and all dead instructions
|
|
|
|
// using it.
|
2010-11-19 22:15:03 +00:00
|
|
|
if (Repl->use_empty()) {
|
2011-04-09 07:05:44 +00:00
|
|
|
// This can cause recursive deletion, which can invalidate our iterator.
|
|
|
|
// Use a WeakVH to hold onto it in case this happens.
|
|
|
|
WeakVH IterHandle(CurInstIterator);
|
|
|
|
BasicBlock *BB = CurInstIterator->getParent();
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2012-08-29 15:32:21 +00:00
|
|
|
RecursivelyDeleteTriviallyDeadInstructions(Repl, TLInfo);
|
2011-04-09 07:05:44 +00:00
|
|
|
|
|
|
|
if (IterHandle != CurInstIterator) {
|
|
|
|
// If the iterator instruction was recursively deleted, start over at the
|
|
|
|
// start of the block.
|
|
|
|
CurInstIterator = BB->begin();
|
|
|
|
SunkAddrs.clear();
|
|
|
|
} else {
|
|
|
|
// This address is now available for reassignment, so erase the table
|
|
|
|
// entry; we don't want to match some completely different instruction.
|
|
|
|
SunkAddrs[Addr] = 0;
|
2012-07-24 10:51:42 +00:00
|
|
|
}
|
2010-03-31 20:37:15 +00:00
|
|
|
}
|
2011-01-05 17:27:27 +00:00
|
|
|
++NumMemoryInsts;
|
Completely rewrite addressing-mode related sinking of code. In particular,
this fixes problems where codegenprepare would sink expressions into load/stores
that are not valid, and fixes cases where it would miss important valid ones.
This fixes several serious codesize and perf issues, particularly on targets
with complex addressing modes like arm and x86. For example, now we compile
CodeGen/X86/isel-sink.ll to:
_test:
movl 8(%esp), %eax
movl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx,%eax,4)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx,%eax,4), %eax
ret
instead of:
_test:
movl 8(%esp), %eax
leal (,%eax,4), %ecx
addl 4(%esp), %ecx
cmpl $1233, %eax
ja LBB1_2 #F
LBB1_1: #T
movl $4, (%ecx)
movl $141, %eax
ret
LBB1_2: #F
movl (%ecx), %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35970 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-13 20:30:56 +00:00
|
|
|
return true;
|
|
|
|
}
|
2007-03-31 04:06:36 +00:00
|
|
|
|
2008-02-26 02:42:37 +00:00
|
|
|
/// OptimizeInlineAsmInst - If there are any memory operands, use
|
2008-11-25 07:09:13 +00:00
|
|
|
/// OptimizeMemoryInst to sink their address computing into the block when
|
2008-02-26 02:42:37 +00:00
|
|
|
/// possible / profitable.
|
2011-01-15 07:14:54 +00:00
|
|
|
bool CodeGenPrepare::OptimizeInlineAsmInst(CallInst *CS) {
|
2008-02-26 02:42:37 +00:00
|
|
|
bool MadeChange = false;
|
|
|
|
|
2012-07-24 10:51:42 +00:00
|
|
|
TargetLowering::AsmOperandInfoVector
|
2011-01-15 07:14:54 +00:00
|
|
|
TargetConstraints = TLI->ParseConstraints(CS);
|
2010-09-16 18:30:55 +00:00
|
|
|
unsigned ArgNo = 0;
|
2010-09-13 18:15:37 +00:00
|
|
|
for (unsigned i = 0, e = TargetConstraints.size(); i != e; ++i) {
|
|
|
|
TargetLowering::AsmOperandInfo &OpInfo = TargetConstraints[i];
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2008-02-26 02:42:37 +00:00
|
|
|
// Compute the constraint code and ConstraintType to use.
|
2010-06-25 21:55:36 +00:00
|
|
|
TLI->ComputeConstraintToUse(OpInfo, SDValue());
|
2008-02-26 02:42:37 +00:00
|
|
|
|
2008-02-26 18:37:49 +00:00
|
|
|
if (OpInfo.ConstraintType == TargetLowering::C_Memory &&
|
|
|
|
OpInfo.isIndirect) {
|
2011-01-15 07:14:54 +00:00
|
|
|
Value *OpVal = CS->getArgOperand(ArgNo++);
|
2011-01-15 07:29:01 +00:00
|
|
|
MadeChange |= OptimizeMemoryInst(CS, OpVal, OpVal->getType());
|
2010-09-16 18:30:55 +00:00
|
|
|
} else if (OpInfo.Type == InlineAsm::isInput)
|
|
|
|
ArgNo++;
|
2008-02-26 02:42:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return MadeChange;
|
|
|
|
}
|
|
|
|
|
2009-10-16 20:59:35 +00:00
|
|
|
/// MoveExtToFormExtLoad - Move a zext or sext fed by a load into the same
|
|
|
|
/// basic block as the load, unless conditions are unfavorable. This allows
|
|
|
|
/// SelectionDAG to fold the extend into the load.
|
|
|
|
///
|
|
|
|
bool CodeGenPrepare::MoveExtToFormExtLoad(Instruction *I) {
|
|
|
|
// Look for a load being extended.
|
|
|
|
LoadInst *LI = dyn_cast<LoadInst>(I->getOperand(0));
|
|
|
|
if (!LI) return false;
|
|
|
|
|
|
|
|
// If they're already in the same block, there's nothing to do.
|
|
|
|
if (LI->getParent() == I->getParent())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If the load has other users and the truncate is not free, this probably
|
|
|
|
// isn't worthwhile.
|
|
|
|
if (!LI->hasOneUse() &&
|
2010-09-22 18:44:56 +00:00
|
|
|
TLI && (TLI->isTypeLegal(TLI->getValueType(LI->getType())) ||
|
|
|
|
!TLI->isTypeLegal(TLI->getValueType(I->getType()))) &&
|
2010-09-21 21:54:27 +00:00
|
|
|
!TLI->isTruncateFree(I->getType(), LI->getType()))
|
2009-10-16 20:59:35 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check whether the target supports casts folded into loads.
|
|
|
|
unsigned LType;
|
|
|
|
if (isa<ZExtInst>(I))
|
|
|
|
LType = ISD::ZEXTLOAD;
|
|
|
|
else {
|
|
|
|
assert(isa<SExtInst>(I) && "Unexpected ext type!");
|
|
|
|
LType = ISD::SEXTLOAD;
|
|
|
|
}
|
|
|
|
if (TLI && !TLI->isLoadExtLegal(LType, TLI->getValueType(LI->getType())))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Move the extend into the same block as the load, so that SelectionDAG
|
|
|
|
// can fold it.
|
|
|
|
I->removeFromParent();
|
|
|
|
I->insertAfter(LI);
|
2011-01-05 17:27:27 +00:00
|
|
|
++NumExtsMoved;
|
2009-10-16 20:59:35 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-12-05 23:58:20 +00:00
|
|
|
bool CodeGenPrepare::OptimizeExtUses(Instruction *I) {
|
|
|
|
BasicBlock *DefBB = I->getParent();
|
|
|
|
|
2010-09-21 21:44:14 +00:00
|
|
|
// If the result of a {s|z}ext and its source are both live out, rewrite all
|
2007-12-05 23:58:20 +00:00
|
|
|
// other uses of the source with result of extension.
|
|
|
|
Value *Src = I->getOperand(0);
|
|
|
|
if (Src->hasOneUse())
|
|
|
|
return false;
|
|
|
|
|
2007-12-13 07:50:36 +00:00
|
|
|
// Only do this xform if truncating is free.
|
2008-02-26 19:13:21 +00:00
|
|
|
if (TLI && !TLI->isTruncateFree(I->getType(), Src->getType()))
|
2007-12-13 03:32:53 +00:00
|
|
|
return false;
|
|
|
|
|
2007-12-12 00:51:06 +00:00
|
|
|
// Only safe to perform the optimization if the source is also defined in
|
2007-12-12 02:53:41 +00:00
|
|
|
// this block.
|
|
|
|
if (!isa<Instruction>(Src) || DefBB != cast<Instruction>(Src)->getParent())
|
2007-12-12 00:51:06 +00:00
|
|
|
return false;
|
|
|
|
|
2007-12-05 23:58:20 +00:00
|
|
|
bool DefIsLiveOut = false;
|
2008-09-24 05:32:41 +00:00
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
|
2007-12-05 23:58:20 +00:00
|
|
|
UI != E; ++UI) {
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
|
|
|
|
|
|
|
// Figure out which BB this ext is used in.
|
|
|
|
BasicBlock *UserBB = User->getParent();
|
|
|
|
if (UserBB == DefBB) continue;
|
|
|
|
DefIsLiveOut = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!DefIsLiveOut)
|
|
|
|
return false;
|
|
|
|
|
2007-12-12 02:53:41 +00:00
|
|
|
// Make sure non of the uses are PHI nodes.
|
2008-09-24 05:32:41 +00:00
|
|
|
for (Value::use_iterator UI = Src->use_begin(), E = Src->use_end();
|
2007-12-12 02:53:41 +00:00
|
|
|
UI != E; ++UI) {
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
2007-12-13 03:32:53 +00:00
|
|
|
BasicBlock *UserBB = User->getParent();
|
|
|
|
if (UserBB == DefBB) continue;
|
|
|
|
// Be conservative. We don't want this xform to end up introducing
|
|
|
|
// reloads just before load / store instructions.
|
|
|
|
if (isa<PHINode>(User) || isa<LoadInst>(User) || isa<StoreInst>(User))
|
2007-12-12 02:53:41 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2007-12-05 23:58:20 +00:00
|
|
|
// InsertedTruncs - Only insert one trunc in each block once.
|
|
|
|
DenseMap<BasicBlock*, Instruction*> InsertedTruncs;
|
|
|
|
|
|
|
|
bool MadeChange = false;
|
2008-09-24 05:32:41 +00:00
|
|
|
for (Value::use_iterator UI = Src->use_begin(), E = Src->use_end();
|
2007-12-05 23:58:20 +00:00
|
|
|
UI != E; ++UI) {
|
|
|
|
Use &TheUse = UI.getUse();
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
|
|
|
|
|
|
|
// Figure out which BB this ext is used in.
|
|
|
|
BasicBlock *UserBB = User->getParent();
|
|
|
|
if (UserBB == DefBB) continue;
|
|
|
|
|
|
|
|
// Both src and def are live in this block. Rewrite the use.
|
|
|
|
Instruction *&InsertedTrunc = InsertedTruncs[UserBB];
|
|
|
|
|
|
|
|
if (!InsertedTrunc) {
|
2011-08-16 20:45:24 +00:00
|
|
|
BasicBlock::iterator InsertPt = UserBB->getFirstInsertionPt();
|
2007-12-05 23:58:20 +00:00
|
|
|
InsertedTrunc = new TruncInst(I, Src->getType(), "", InsertPt);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Replace a use of the {s|z}ext source with a use of the result.
|
|
|
|
TheUse = InsertedTrunc;
|
2011-01-05 17:27:27 +00:00
|
|
|
++NumExtUses;
|
2007-12-05 23:58:20 +00:00
|
|
|
MadeChange = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return MadeChange;
|
|
|
|
}
|
|
|
|
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
/// isFormingBranchFromSelectProfitable - Returns true if a SelectInst should be
|
|
|
|
/// turned into an explicit branch.
|
|
|
|
static bool isFormingBranchFromSelectProfitable(SelectInst *SI) {
|
|
|
|
// FIXME: This should use the same heuristics as IfConversion to determine
|
|
|
|
// whether a select is better represented as a branch. This requires that
|
|
|
|
// branch probability metadata is preserved for the select, which is not the
|
|
|
|
// case currently.
|
|
|
|
|
|
|
|
CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition());
|
|
|
|
|
|
|
|
// If the branch is predicted right, an out of order CPU can avoid blocking on
|
|
|
|
// the compare. Emit cmovs on compares with a memory operand as branches to
|
|
|
|
// avoid stalls on the load from memory. If the compare has more than one use
|
|
|
|
// there's probably another cmov or setcc around so it's not worth emitting a
|
|
|
|
// branch.
|
|
|
|
if (!Cmp)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Value *CmpOp0 = Cmp->getOperand(0);
|
|
|
|
Value *CmpOp1 = Cmp->getOperand(1);
|
|
|
|
|
|
|
|
// We check that the memory operand has one use to avoid uses of the loaded
|
|
|
|
// value directly after the compare, making branches unprofitable.
|
|
|
|
return Cmp->hasOneUse() &&
|
|
|
|
((isa<LoadInst>(CmpOp0) && CmpOp0->hasOneUse()) ||
|
|
|
|
(isa<LoadInst>(CmpOp1) && CmpOp1->hasOneUse()));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-09-02 12:10:19 +00:00
|
|
|
/// If we have a SelectInst that will likely profit from branch prediction,
|
|
|
|
/// turn it into a branch.
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
bool CodeGenPrepare::OptimizeSelectInst(SelectInst *SI) {
|
2012-09-02 12:10:19 +00:00
|
|
|
bool VectorCond = !SI->getCondition()->getType()->isIntegerTy(1);
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
|
2012-09-02 12:10:19 +00:00
|
|
|
// Can we convert the 'select' to CF ?
|
|
|
|
if (DisableSelectToBranch || OptSize || !TLI || VectorCond)
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
return false;
|
|
|
|
|
2012-09-02 12:10:19 +00:00
|
|
|
TargetLowering::SelectSupportKind SelectKind;
|
|
|
|
if (VectorCond)
|
|
|
|
SelectKind = TargetLowering::VectorMaskSelect;
|
|
|
|
else if (SI->getType()->isVectorTy())
|
|
|
|
SelectKind = TargetLowering::ScalarCondVectorVal;
|
|
|
|
else
|
|
|
|
SelectKind = TargetLowering::ScalarValSelect;
|
|
|
|
|
|
|
|
// Do we have efficient codegen support for this kind of 'selects' ?
|
|
|
|
if (TLI->isSelectSupported(SelectKind)) {
|
|
|
|
// We have efficient codegen support for the select instruction.
|
|
|
|
// Check if it is profitable to keep this 'select'.
|
|
|
|
if (!TLI->isPredictableSelectExpensive() ||
|
|
|
|
!isFormingBranchFromSelectProfitable(SI))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
ModifiedDT = true;
|
|
|
|
|
|
|
|
// First, we split the block containing the select into 2 blocks.
|
|
|
|
BasicBlock *StartBlock = SI->getParent();
|
|
|
|
BasicBlock::iterator SplitPt = ++(BasicBlock::iterator(SI));
|
|
|
|
BasicBlock *NextBlock = StartBlock->splitBasicBlock(SplitPt, "select.end");
|
|
|
|
|
|
|
|
// Create a new block serving as the landing pad for the branch.
|
|
|
|
BasicBlock *SmallBlock = BasicBlock::Create(SI->getContext(), "select.mid",
|
|
|
|
NextBlock->getParent(), NextBlock);
|
|
|
|
|
|
|
|
// Move the unconditional branch from the block with the select in it into our
|
|
|
|
// landing pad block.
|
|
|
|
StartBlock->getTerminator()->eraseFromParent();
|
|
|
|
BranchInst::Create(NextBlock, SmallBlock);
|
|
|
|
|
|
|
|
// Insert the real conditional branch based on the original condition.
|
|
|
|
BranchInst::Create(NextBlock, SmallBlock, SI->getCondition(), SI);
|
|
|
|
|
|
|
|
// The select itself is replaced with a PHI Node.
|
|
|
|
PHINode *PN = PHINode::Create(SI->getType(), 2, "", NextBlock->begin());
|
|
|
|
PN->takeName(SI);
|
|
|
|
PN->addIncoming(SI->getTrueValue(), StartBlock);
|
|
|
|
PN->addIncoming(SI->getFalseValue(), SmallBlock);
|
|
|
|
SI->replaceAllUsesWith(PN);
|
|
|
|
SI->eraseFromParent();
|
|
|
|
|
|
|
|
// Instruct OptimizeBlock to skip to the next block.
|
|
|
|
CurInstIterator = StartBlock->end();
|
|
|
|
++NumSelectsExpanded;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-01-06 02:37:26 +00:00
|
|
|
bool CodeGenPrepare::OptimizeInst(Instruction *I) {
|
|
|
|
if (PHINode *P = dyn_cast<PHINode>(I)) {
|
|
|
|
// It is possible for very late stage optimizations (such as SimplifyCFG)
|
|
|
|
// to introduce PHI nodes too late to be cleaned up. If we detect such a
|
|
|
|
// trivial PHI, go ahead and zap it here.
|
|
|
|
if (Value *V = SimplifyInstruction(P)) {
|
|
|
|
P->replaceAllUsesWith(V);
|
|
|
|
P->eraseFromParent();
|
|
|
|
++NumPHIsElim;
|
2011-01-15 07:29:01 +00:00
|
|
|
return true;
|
2011-01-06 02:37:26 +00:00
|
|
|
}
|
2011-01-15 07:29:01 +00:00
|
|
|
return false;
|
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (CastInst *CI = dyn_cast<CastInst>(I)) {
|
2011-01-06 02:37:26 +00:00
|
|
|
// If the source of the cast is a constant, then this should have
|
|
|
|
// already been constant folded. The only reason NOT to constant fold
|
|
|
|
// it is if something (e.g. LSR) was careful to place the constant
|
|
|
|
// evaluation in a block other than then one that uses it (e.g. to hoist
|
|
|
|
// the address of globals out of a loop). If this is the case, we don't
|
|
|
|
// want to forward-subst the cast.
|
|
|
|
if (isa<Constant>(CI->getOperand(0)))
|
|
|
|
return false;
|
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (TLI && OptimizeNoopCopyExpression(CI, *TLI))
|
|
|
|
return true;
|
2011-01-06 02:37:26 +00:00
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (isa<ZExtInst>(I) || isa<SExtInst>(I)) {
|
|
|
|
bool MadeChange = MoveExtToFormExtLoad(I);
|
|
|
|
return MadeChange | OptimizeExtUses(I);
|
2011-01-06 02:37:26 +00:00
|
|
|
}
|
2011-01-15 07:29:01 +00:00
|
|
|
return false;
|
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (CmpInst *CI = dyn_cast<CmpInst>(I))
|
|
|
|
return OptimizeCmpExpression(CI);
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
|
2011-01-06 02:37:26 +00:00
|
|
|
if (TLI)
|
2011-01-15 07:29:01 +00:00
|
|
|
return OptimizeMemoryInst(I, I->getOperand(0), LI->getType());
|
|
|
|
return false;
|
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
|
2011-01-06 02:37:26 +00:00
|
|
|
if (TLI)
|
2011-01-15 07:29:01 +00:00
|
|
|
return OptimizeMemoryInst(I, SI->getOperand(1),
|
|
|
|
SI->getOperand(0)->getType());
|
|
|
|
return false;
|
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) {
|
2011-01-06 02:44:52 +00:00
|
|
|
if (GEPI->hasAllZeroIndices()) {
|
|
|
|
/// The GEP operand must be a pointer, so must its result -> BitCast
|
|
|
|
Instruction *NC = new BitCastInst(GEPI->getOperand(0), GEPI->getType(),
|
|
|
|
GEPI->getName(), GEPI);
|
|
|
|
GEPI->replaceAllUsesWith(NC);
|
|
|
|
GEPI->eraseFromParent();
|
|
|
|
++NumGEPsElim;
|
|
|
|
OptimizeInst(NC);
|
2011-01-15 07:29:01 +00:00
|
|
|
return true;
|
2011-01-06 02:44:52 +00:00
|
|
|
}
|
2011-01-15 07:29:01 +00:00
|
|
|
return false;
|
2011-01-06 02:37:26 +00:00
|
|
|
}
|
2012-07-24 10:51:42 +00:00
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
if (CallInst *CI = dyn_cast<CallInst>(I))
|
|
|
|
return OptimizeCallInst(CI);
|
2011-01-06 02:37:26 +00:00
|
|
|
|
2011-03-21 01:19:09 +00:00
|
|
|
if (ReturnInst *RI = dyn_cast<ReturnInst>(I))
|
|
|
|
return DupRetToEnableTailCallOpts(RI);
|
|
|
|
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156234 91177308-0d34-0410-b5e6-96231b3b80d8
2012-05-05 12:49:22 +00:00
|
|
|
if (SelectInst *SI = dyn_cast<SelectInst>(I))
|
|
|
|
return OptimizeSelectInst(SI);
|
|
|
|
|
2011-01-15 07:29:01 +00:00
|
|
|
return false;
|
2011-01-06 02:37:26 +00:00
|
|
|
}
|
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
// In this pass we look for GEP and cast instructions that are used
|
|
|
|
// across basic blocks and rewrite them to improve basic-block-at-a-time
|
|
|
|
// selection.
|
|
|
|
bool CodeGenPrepare::OptimizeBlock(BasicBlock &BB) {
|
2011-01-06 00:42:50 +00:00
|
|
|
SunkAddrs.clear();
|
2011-03-02 03:31:46 +00:00
|
|
|
bool MadeChange = false;
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2011-01-15 07:14:54 +00:00
|
|
|
CurInstIterator = BB.begin();
|
2011-01-15 07:25:29 +00:00
|
|
|
for (BasicBlock::iterator E = BB.end(); CurInstIterator != E; )
|
|
|
|
MadeChange |= OptimizeInst(CurInstIterator++);
|
2008-09-24 05:32:41 +00:00
|
|
|
|
2007-03-31 04:06:36 +00:00
|
|
|
return MadeChange;
|
|
|
|
}
|
2011-08-18 00:50:51 +00:00
|
|
|
|
|
|
|
// llvm.dbg.value is far away from the value then iSel may not be able
|
2012-07-24 10:51:42 +00:00
|
|
|
// handle it properly. iSel will drop llvm.dbg.value if it can not
|
2011-08-18 00:50:51 +00:00
|
|
|
// find a node corresponding to the value.
|
|
|
|
bool CodeGenPrepare::PlaceDbgValues(Function &F) {
|
|
|
|
bool MadeChange = false;
|
|
|
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
|
|
|
|
Instruction *PrevNonDbgInst = NULL;
|
|
|
|
for (BasicBlock::iterator BI = I->begin(), BE = I->end(); BI != BE;) {
|
|
|
|
Instruction *Insn = BI; ++BI;
|
|
|
|
DbgValueInst *DVI = dyn_cast<DbgValueInst>(Insn);
|
|
|
|
if (!DVI) {
|
|
|
|
PrevNonDbgInst = Insn;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
Instruction *VI = dyn_cast_or_null<Instruction>(DVI->getValue());
|
|
|
|
if (VI && VI != PrevNonDbgInst && !VI->isTerminator()) {
|
|
|
|
DEBUG(dbgs() << "Moving Debug Value before :\n" << *DVI << ' ' << *VI);
|
|
|
|
DVI->removeFromParent();
|
|
|
|
if (isa<PHINode>(VI))
|
|
|
|
DVI->insertBefore(VI->getParent()->getFirstInsertionPt());
|
|
|
|
else
|
|
|
|
DVI->insertAfter(VI);
|
|
|
|
MadeChange = true;
|
|
|
|
++NumDbgValueMoved;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return MadeChange;
|
|
|
|
}
|