Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
//===-- MachineSink.cpp - Sinking for machine instructions ----------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2010-06-03 07:04:26 +08:00
|
|
|
// This pass moves instructions into successor blocks when possible, so that
|
2009-08-05 09:19:01 +08:00
|
|
|
// they aren't executed on paths where their results aren't needed.
|
|
|
|
//
|
|
|
|
// This pass is not intended to be a replacement or a complete alternative
|
|
|
|
// for an LLVM-IR-level sinking pass. It is only designed to sink simple
|
|
|
|
// constructs that are not exposed before lowering and instruction selection.
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/CodeGen/Passes.h"
|
2010-09-18 06:28:18 +08:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
|
|
|
#include "llvm/CodeGen/MachineLoopInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
2010-08-20 01:33:11 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-08-23 04:26:23 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:02:50 +08:00
|
|
|
#define DEBUG_TYPE "machine-sink"
|
|
|
|
|
2012-02-09 05:22:43 +08:00
|
|
|
static cl::opt<bool>
|
2010-08-20 01:33:11 +08:00
|
|
|
SplitEdges("machine-sink-split",
|
|
|
|
cl::desc("Split critical edges during machine sinking"),
|
Enable machine sinking critical edge splitting. e.g.
define double @foo(double %x, double %y, i1 %c) nounwind {
%a = fdiv double %x, 3.2
%z = select i1 %c, double %a, double %y
ret double %z
}
Was:
_foo:
divsd LCPI0_0(%rip), %xmm0
testb $1, %dil
jne LBB0_2
movaps %xmm1, %xmm0
LBB0_2:
ret
Now:
_foo:
testb $1, %dil
je LBB0_2
divsd LCPI0_0(%rip), %xmm0
ret
LBB0_2:
movaps %xmm1, %xmm0
ret
This avoids the divsd when early exit is taken.
rdar://8454886
llvm-svn: 114372
2010-09-21 06:52:00 +08:00
|
|
|
cl::init(true), cl::Hidden);
|
2010-08-20 01:33:11 +08:00
|
|
|
|
2010-09-18 06:28:18 +08:00
|
|
|
STATISTIC(NumSunk, "Number of machine instructions sunk");
|
|
|
|
STATISTIC(NumSplit, "Number of critical edges split");
|
|
|
|
STATISTIC(NumCoalesces, "Number of copies coalesced");
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
|
|
|
|
namespace {
|
2009-10-25 14:33:48 +08:00
|
|
|
class MachineSinking : public MachineFunctionPass {
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
const TargetInstrInfo *TII;
|
2009-09-26 06:53:29 +08:00
|
|
|
const TargetRegisterInfo *TRI;
|
2010-09-18 06:28:18 +08:00
|
|
|
MachineRegisterInfo *MRI; // Machine register information
|
2009-08-05 09:19:01 +08:00
|
|
|
MachineDominatorTree *DT; // Machine dominator tree
|
2010-04-16 07:41:02 +08:00
|
|
|
MachineLoopInfo *LI;
|
2009-10-10 07:27:56 +08:00
|
|
|
AliasAnalysis *AA;
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
|
2010-09-18 06:28:18 +08:00
|
|
|
// Remember which edges have been considered for breaking.
|
|
|
|
SmallSet<std::pair<MachineBasicBlock*,MachineBasicBlock*>, 8>
|
|
|
|
CEBCandidates;
|
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
public:
|
|
|
|
static char ID; // Pass identification
|
2010-10-20 01:21:58 +08:00
|
|
|
MachineSinking() : MachineFunctionPass(ID) {
|
|
|
|
initializeMachineSinkingPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2014-03-07 17:26:03 +08:00
|
|
|
bool runOnMachineFunction(MachineFunction &MF) override;
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2014-03-07 17:26:03 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2009-08-01 07:37:33 +08:00
|
|
|
AU.setPreservesCFG();
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
2009-10-10 07:27:56 +08:00
|
|
|
AU.addRequired<AliasAnalysis>();
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
AU.addRequired<MachineDominatorTree>();
|
2010-04-16 07:41:02 +08:00
|
|
|
AU.addRequired<MachineLoopInfo>();
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
AU.addPreserved<MachineDominatorTree>();
|
2010-04-16 07:41:02 +08:00
|
|
|
AU.addPreserved<MachineLoopInfo>();
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
}
|
2010-09-18 06:28:18 +08:00
|
|
|
|
2014-03-07 17:26:03 +08:00
|
|
|
void releaseMemory() override {
|
2010-09-18 06:28:18 +08:00
|
|
|
CEBCandidates.clear();
|
|
|
|
}
|
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
private:
|
|
|
|
bool ProcessBlock(MachineBasicBlock &MBB);
|
2010-09-18 06:28:18 +08:00
|
|
|
bool isWorthBreakingCriticalEdge(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *From,
|
|
|
|
MachineBasicBlock *To);
|
|
|
|
MachineBasicBlock *SplitCriticalEdge(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *From,
|
|
|
|
MachineBasicBlock *To,
|
2010-09-21 03:12:55 +08:00
|
|
|
bool BreakPHIEdge);
|
2008-01-12 08:17:41 +08:00
|
|
|
bool SinkInstruction(MachineInstr *MI, bool &SawStore);
|
2010-08-19 07:09:25 +08:00
|
|
|
bool AllUsesDominatedByBlock(unsigned Reg, MachineBasicBlock *MBB,
|
2010-09-18 06:28:18 +08:00
|
|
|
MachineBasicBlock *DefMBB,
|
2010-09-21 03:12:55 +08:00
|
|
|
bool &BreakPHIEdge, bool &LocalUse) const;
|
2011-12-15 07:20:38 +08:00
|
|
|
MachineBasicBlock *FindSuccToSinkTo(MachineInstr *MI, MachineBasicBlock *MBB,
|
|
|
|
bool &BreakPHIEdge);
|
2012-02-09 05:22:43 +08:00
|
|
|
bool isProfitableToSinkTo(unsigned Reg, MachineInstr *MI,
|
2011-12-15 07:20:38 +08:00
|
|
|
MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock *SuccToSinkTo);
|
2011-12-09 05:48:01 +08:00
|
|
|
|
2010-09-18 06:28:18 +08:00
|
|
|
bool PerformTrivialForwardCoalescing(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *MBB);
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
char MachineSinking::ID = 0;
|
2012-02-09 05:23:13 +08:00
|
|
|
char &llvm::MachineSinkingID = MachineSinking::ID;
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(MachineSinking, "machine-sink",
|
|
|
|
"Machine code sinking", false, false)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
|
|
|
|
INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
|
|
|
|
INITIALIZE_PASS_END(MachineSinking, "machine-sink",
|
2010-10-08 06:25:06 +08:00
|
|
|
"Machine code sinking", false, false)
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
|
2010-09-18 06:28:18 +08:00
|
|
|
bool MachineSinking::PerformTrivialForwardCoalescing(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *MBB) {
|
|
|
|
if (!MI->isCopy())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned SrcReg = MI->getOperand(1).getReg();
|
|
|
|
unsigned DstReg = MI->getOperand(0).getReg();
|
|
|
|
if (!TargetRegisterInfo::isVirtualRegister(SrcReg) ||
|
|
|
|
!TargetRegisterInfo::isVirtualRegister(DstReg) ||
|
|
|
|
!MRI->hasOneNonDBGUse(SrcReg))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const TargetRegisterClass *SRC = MRI->getRegClass(SrcReg);
|
|
|
|
const TargetRegisterClass *DRC = MRI->getRegClass(DstReg);
|
|
|
|
if (SRC != DRC)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
MachineInstr *DefMI = MRI->getVRegDef(SrcReg);
|
|
|
|
if (DefMI->isCopyLike())
|
|
|
|
return false;
|
|
|
|
DEBUG(dbgs() << "Coalescing: " << *DefMI);
|
|
|
|
DEBUG(dbgs() << "*** to: " << *MI);
|
|
|
|
MRI->replaceRegWith(DstReg, SrcReg);
|
|
|
|
MI->eraseFromParent();
|
|
|
|
++NumCoalesces;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
/// AllUsesDominatedByBlock - Return true if all uses of the specified register
|
2010-08-19 07:09:25 +08:00
|
|
|
/// occur in blocks dominated by the specified block. If any use is in the
|
|
|
|
/// definition block, then return false since it is never legal to move def
|
|
|
|
/// after uses.
|
2010-09-18 06:28:18 +08:00
|
|
|
bool
|
|
|
|
MachineSinking::AllUsesDominatedByBlock(unsigned Reg,
|
|
|
|
MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock *DefMBB,
|
2010-09-21 03:12:55 +08:00
|
|
|
bool &BreakPHIEdge,
|
|
|
|
bool &LocalUse) const {
|
2008-02-11 02:45:23 +08:00
|
|
|
assert(TargetRegisterInfo::isVirtualRegister(Reg) &&
|
|
|
|
"Only makes sense for vregs");
|
2010-09-18 14:42:17 +08:00
|
|
|
|
2011-12-09 09:25:04 +08:00
|
|
|
// Ignore debug uses because debug info doesn't affect the code.
|
2010-09-18 14:42:17 +08:00
|
|
|
if (MRI->use_nodbg_empty(Reg))
|
|
|
|
return true;
|
|
|
|
|
2010-09-21 03:12:55 +08:00
|
|
|
// BreakPHIEdge is true if all the uses are in the successor MBB being sunken
|
|
|
|
// into and they are all PHI nodes. In this case, machine-sink must break
|
|
|
|
// the critical edge first. e.g.
|
|
|
|
//
|
2010-09-18 14:42:17 +08:00
|
|
|
// BB#1: derived from LLVM BB %bb4.preheader
|
|
|
|
// Predecessors according to CFG: BB#0
|
|
|
|
// ...
|
|
|
|
// %reg16385<def> = DEC64_32r %reg16437, %EFLAGS<imp-def,dead>
|
|
|
|
// ...
|
|
|
|
// JE_4 <BB#37>, %EFLAGS<imp-use>
|
|
|
|
// Successors according to CFG: BB#37 BB#2
|
|
|
|
//
|
|
|
|
// BB#2: derived from LLVM BB %bb.nph
|
|
|
|
// Predecessors according to CFG: BB#0 BB#1
|
|
|
|
// %reg16386<def> = PHI %reg16434, <BB#0>, %reg16385, <BB#1>
|
2010-09-21 03:12:55 +08:00
|
|
|
BreakPHIEdge = true;
|
2014-03-18 03:36:09 +08:00
|
|
|
for (MachineOperand &MO : MRI->use_nodbg_operands(Reg)) {
|
|
|
|
MachineInstr *UseInst = MO.getParent();
|
|
|
|
unsigned OpNo = &MO - &UseInst->getOperand(0);
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
MachineBasicBlock *UseBlock = UseInst->getParent();
|
2010-09-18 14:42:17 +08:00
|
|
|
if (!(UseBlock == MBB && UseInst->isPHI() &&
|
2014-03-18 03:36:09 +08:00
|
|
|
UseInst->getOperand(OpNo+1).getMBB() == DefMBB)) {
|
2010-09-21 03:12:55 +08:00
|
|
|
BreakPHIEdge = false;
|
2010-09-18 14:42:17 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-09-21 03:12:55 +08:00
|
|
|
if (BreakPHIEdge)
|
2010-09-18 14:42:17 +08:00
|
|
|
return true;
|
2010-06-03 07:04:26 +08:00
|
|
|
|
2014-03-18 03:36:09 +08:00
|
|
|
for (MachineOperand &MO : MRI->use_nodbg_operands(Reg)) {
|
2010-09-18 14:42:17 +08:00
|
|
|
// Determine the block of the use.
|
2014-03-18 03:36:09 +08:00
|
|
|
MachineInstr *UseInst = MO.getParent();
|
|
|
|
unsigned OpNo = &MO - &UseInst->getOperand(0);
|
2010-09-18 14:42:17 +08:00
|
|
|
MachineBasicBlock *UseBlock = UseInst->getParent();
|
|
|
|
if (UseInst->isPHI()) {
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// PHI nodes use the operand in the predecessor block, not the block with
|
|
|
|
// the PHI.
|
2014-03-18 03:36:09 +08:00
|
|
|
UseBlock = UseInst->getOperand(OpNo+1).getMBB();
|
2010-08-20 02:33:29 +08:00
|
|
|
} else if (UseBlock == DefMBB) {
|
|
|
|
LocalUse = true;
|
|
|
|
return false;
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
}
|
2010-06-03 07:04:26 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// Check that it dominates.
|
|
|
|
if (!DT->dominates(MBB, UseBlock))
|
|
|
|
return false;
|
|
|
|
}
|
2010-06-03 07:04:26 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MachineSinking::runOnMachineFunction(MachineFunction &MF) {
|
2014-04-01 01:43:35 +08:00
|
|
|
if (skipOptnoneFunction(*MF.getFunction()))
|
|
|
|
return false;
|
|
|
|
|
2010-01-05 09:26:00 +08:00
|
|
|
DEBUG(dbgs() << "******** Machine Sinking ********\n");
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2009-10-19 22:52:05 +08:00
|
|
|
const TargetMachine &TM = MF.getTarget();
|
|
|
|
TII = TM.getInstrInfo();
|
|
|
|
TRI = TM.getRegisterInfo();
|
2010-09-18 06:28:18 +08:00
|
|
|
MRI = &MF.getRegInfo();
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
DT = &getAnalysis<MachineDominatorTree>();
|
2010-04-16 07:41:02 +08:00
|
|
|
LI = &getAnalysis<MachineLoopInfo>();
|
2009-10-10 07:27:56 +08:00
|
|
|
AA = &getAnalysis<AliasAnalysis>();
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
|
|
|
|
bool EverMadeChange = false;
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
while (1) {
|
|
|
|
bool MadeChange = false;
|
|
|
|
|
|
|
|
// Process all basic blocks.
|
2010-09-18 06:28:18 +08:00
|
|
|
CEBCandidates.clear();
|
2010-06-04 07:49:57 +08:00
|
|
|
for (MachineFunction::iterator I = MF.begin(), E = MF.end();
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
I != E; ++I)
|
|
|
|
MadeChange |= ProcessBlock(*I);
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// If this iteration over the code changed anything, keep iterating.
|
|
|
|
if (!MadeChange) break;
|
|
|
|
EverMadeChange = true;
|
2010-06-04 07:49:57 +08:00
|
|
|
}
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
return EverMadeChange;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MachineSinking::ProcessBlock(MachineBasicBlock &MBB) {
|
|
|
|
// Can't sink anything out of a block that has less than two successors.
|
2009-04-11 00:38:36 +08:00
|
|
|
if (MBB.succ_size() <= 1 || MBB.empty()) return false;
|
|
|
|
|
2010-04-06 03:17:22 +08:00
|
|
|
// Don't bother sinking code out of unreachable blocks. In addition to being
|
2010-06-04 07:49:57 +08:00
|
|
|
// unprofitable, it can also lead to infinite looping, because in an
|
|
|
|
// unreachable loop there may be nowhere to stop.
|
2010-04-06 03:17:22 +08:00
|
|
|
if (!DT->isReachableFromEntry(&MBB)) return false;
|
|
|
|
|
2009-04-11 00:38:36 +08:00
|
|
|
bool MadeChange = false;
|
|
|
|
|
2008-01-12 08:17:41 +08:00
|
|
|
// Walk the basic block bottom-up. Remember if we saw a store.
|
2009-04-11 00:38:36 +08:00
|
|
|
MachineBasicBlock::iterator I = MBB.end();
|
|
|
|
--I;
|
|
|
|
bool ProcessedBegin, SawStore = false;
|
|
|
|
do {
|
|
|
|
MachineInstr *MI = I; // The instruction to sink.
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2009-04-11 00:38:36 +08:00
|
|
|
// Predecrement I (if it's not begin) so that it isn't invalidated by
|
|
|
|
// sinking.
|
|
|
|
ProcessedBegin = I == MBB.begin();
|
|
|
|
if (!ProcessedBegin)
|
|
|
|
--I;
|
2010-03-05 08:02:59 +08:00
|
|
|
|
|
|
|
if (MI->isDebugValue())
|
|
|
|
continue;
|
|
|
|
|
2011-04-12 02:47:20 +08:00
|
|
|
bool Joined = PerformTrivialForwardCoalescing(MI, &MBB);
|
|
|
|
if (Joined) {
|
|
|
|
MadeChange = true;
|
2010-09-18 06:28:18 +08:00
|
|
|
continue;
|
2011-04-12 02:47:20 +08:00
|
|
|
}
|
2010-09-18 06:28:18 +08:00
|
|
|
|
2009-04-11 00:38:36 +08:00
|
|
|
if (SinkInstruction(MI, SawStore))
|
|
|
|
++NumSunk, MadeChange = true;
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2009-04-11 00:38:36 +08:00
|
|
|
// If we just processed the first instruction in the block, we're done.
|
|
|
|
} while (!ProcessedBegin);
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
return MadeChange;
|
|
|
|
}
|
|
|
|
|
2010-09-18 06:28:18 +08:00
|
|
|
bool MachineSinking::isWorthBreakingCriticalEdge(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *From,
|
|
|
|
MachineBasicBlock *To) {
|
|
|
|
// FIXME: Need much better heuristics.
|
|
|
|
|
|
|
|
// If the pass has already considered breaking this edge (during this pass
|
|
|
|
// through the function), then let's go ahead and break it. This means
|
|
|
|
// sinking multiple "cheap" instructions into the same block.
|
|
|
|
if (!CEBCandidates.insert(std::make_pair(From, To)))
|
|
|
|
return true;
|
|
|
|
|
2011-12-07 15:15:52 +08:00
|
|
|
if (!MI->isCopy() && !MI->isAsCheapAsAMove())
|
2010-09-18 06:28:18 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// MI is cheap, we probably don't want to break the critical edge for it.
|
|
|
|
// However, if this would allow some definitions of its source operands
|
|
|
|
// to be sunk then it's probably worth it.
|
|
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
|
|
const MachineOperand &MO = MI->getOperand(i);
|
MachineSink: Fix and tweak critical-edge breaking heuristic.
Per original comment, the intention of this loop
is to go ahead and break the critical edge
(in order to sink this instruction) if there's
reason to believe doing so might "unblock" the
sinking of additional instructions that define
registers used by this one. The idea is that if
we have a few instructions to sink "together"
breaking the edge might be worthwhile.
This commit makes a few small changes
to help better realize this goal:
First, modify the loop to ignore registers
defined by this instruction. We don't
sink definitions of physical registers,
and sinking an SSA definition isn't
going to unblock an upstream instruction.
Second, ignore uses of physical registers.
Instructions that define physical registers are
rejected for sinking, and so moving this one
won't enable moving any defining instructions.
As an added bonus, while virtual register
use-def chains are generally small due
to SSA goodness, iteration over the uses
and definitions (used by hasOneNonDBGUse)
for physical registers like EFLAGS
can be rather expensive in practice.
(This is the original reason for looking at this)
Finally, to keep things simple continue
to only consider this trick for registers that
have a single use (via hasOneNonDBGUse),
but to avoid spuriously breaking critical edges
only do so if the definition resides
in the same MBB and therefore this one directly
blocks it from being sunk as well.
If sinking them together is meant to be,
let the iterative nature of this pass
sink the definition into this block first.
Update tests to accomodate this change,
add new testcase where sinking avoids pipeline stalls.
llvm-svn: 192608
2013-10-15 00:57:17 +08:00
|
|
|
if (!MO.isReg() || !MO.isUse())
|
|
|
|
continue;
|
2010-09-18 06:28:18 +08:00
|
|
|
unsigned Reg = MO.getReg();
|
MachineSink: Fix and tweak critical-edge breaking heuristic.
Per original comment, the intention of this loop
is to go ahead and break the critical edge
(in order to sink this instruction) if there's
reason to believe doing so might "unblock" the
sinking of additional instructions that define
registers used by this one. The idea is that if
we have a few instructions to sink "together"
breaking the edge might be worthwhile.
This commit makes a few small changes
to help better realize this goal:
First, modify the loop to ignore registers
defined by this instruction. We don't
sink definitions of physical registers,
and sinking an SSA definition isn't
going to unblock an upstream instruction.
Second, ignore uses of physical registers.
Instructions that define physical registers are
rejected for sinking, and so moving this one
won't enable moving any defining instructions.
As an added bonus, while virtual register
use-def chains are generally small due
to SSA goodness, iteration over the uses
and definitions (used by hasOneNonDBGUse)
for physical registers like EFLAGS
can be rather expensive in practice.
(This is the original reason for looking at this)
Finally, to keep things simple continue
to only consider this trick for registers that
have a single use (via hasOneNonDBGUse),
but to avoid spuriously breaking critical edges
only do so if the definition resides
in the same MBB and therefore this one directly
blocks it from being sunk as well.
If sinking them together is meant to be,
let the iterative nature of this pass
sink the definition into this block first.
Update tests to accomodate this change,
add new testcase where sinking avoids pipeline stalls.
llvm-svn: 192608
2013-10-15 00:57:17 +08:00
|
|
|
if (Reg == 0)
|
2010-09-18 06:28:18 +08:00
|
|
|
continue;
|
MachineSink: Fix and tweak critical-edge breaking heuristic.
Per original comment, the intention of this loop
is to go ahead and break the critical edge
(in order to sink this instruction) if there's
reason to believe doing so might "unblock" the
sinking of additional instructions that define
registers used by this one. The idea is that if
we have a few instructions to sink "together"
breaking the edge might be worthwhile.
This commit makes a few small changes
to help better realize this goal:
First, modify the loop to ignore registers
defined by this instruction. We don't
sink definitions of physical registers,
and sinking an SSA definition isn't
going to unblock an upstream instruction.
Second, ignore uses of physical registers.
Instructions that define physical registers are
rejected for sinking, and so moving this one
won't enable moving any defining instructions.
As an added bonus, while virtual register
use-def chains are generally small due
to SSA goodness, iteration over the uses
and definitions (used by hasOneNonDBGUse)
for physical registers like EFLAGS
can be rather expensive in practice.
(This is the original reason for looking at this)
Finally, to keep things simple continue
to only consider this trick for registers that
have a single use (via hasOneNonDBGUse),
but to avoid spuriously breaking critical edges
only do so if the definition resides
in the same MBB and therefore this one directly
blocks it from being sunk as well.
If sinking them together is meant to be,
let the iterative nature of this pass
sink the definition into this block first.
Update tests to accomodate this change,
add new testcase where sinking avoids pipeline stalls.
llvm-svn: 192608
2013-10-15 00:57:17 +08:00
|
|
|
|
|
|
|
// We don't move live definitions of physical registers,
|
|
|
|
// so sinking their uses won't enable any opportunities.
|
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(Reg))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If this instruction is the only user of a virtual register,
|
|
|
|
// check if breaking the edge will enable sinking
|
|
|
|
// both this instruction and the defining instruction.
|
|
|
|
if (MRI->hasOneNonDBGUse(Reg)) {
|
|
|
|
// If the definition resides in same MBB,
|
|
|
|
// claim it's likely we can sink these together.
|
|
|
|
// If definition resides elsewhere, we aren't
|
|
|
|
// blocking it from being sunk so don't break the edge.
|
|
|
|
MachineInstr *DefMI = MRI->getVRegDef(Reg);
|
|
|
|
if (DefMI->getParent() == MI->getParent())
|
|
|
|
return true;
|
|
|
|
}
|
2010-09-18 06:28:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
MachineBasicBlock *MachineSinking::SplitCriticalEdge(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *FromBB,
|
|
|
|
MachineBasicBlock *ToBB,
|
2010-09-21 03:12:55 +08:00
|
|
|
bool BreakPHIEdge) {
|
2010-09-18 06:28:18 +08:00
|
|
|
if (!isWorthBreakingCriticalEdge(MI, FromBB, ToBB))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2010-09-18 06:28:18 +08:00
|
|
|
|
2010-08-20 01:33:11 +08:00
|
|
|
// Avoid breaking back edge. From == To means backedge for single BB loop.
|
Enable machine sinking critical edge splitting. e.g.
define double @foo(double %x, double %y, i1 %c) nounwind {
%a = fdiv double %x, 3.2
%z = select i1 %c, double %a, double %y
ret double %z
}
Was:
_foo:
divsd LCPI0_0(%rip), %xmm0
testb $1, %dil
jne LBB0_2
movaps %xmm1, %xmm0
LBB0_2:
ret
Now:
_foo:
testb $1, %dil
je LBB0_2
divsd LCPI0_0(%rip), %xmm0
ret
LBB0_2:
movaps %xmm1, %xmm0
ret
This avoids the divsd when early exit is taken.
rdar://8454886
llvm-svn: 114372
2010-09-21 06:52:00 +08:00
|
|
|
if (!SplitEdges || FromBB == ToBB)
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2010-08-20 01:33:11 +08:00
|
|
|
|
2010-09-18 06:28:18 +08:00
|
|
|
// Check for backedges of more "complex" loops.
|
|
|
|
if (LI->getLoopFor(FromBB) == LI->getLoopFor(ToBB) &&
|
|
|
|
LI->isLoopHeader(ToBB))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2010-09-18 06:28:18 +08:00
|
|
|
|
|
|
|
// It's not always legal to break critical edges and sink the computation
|
|
|
|
// to the edge.
|
|
|
|
//
|
|
|
|
// BB#1:
|
|
|
|
// v1024
|
|
|
|
// Beq BB#3
|
|
|
|
// <fallthrough>
|
|
|
|
// BB#2:
|
|
|
|
// ... no uses of v1024
|
|
|
|
// <fallthrough>
|
|
|
|
// BB#3:
|
|
|
|
// ...
|
|
|
|
// = v1024
|
|
|
|
//
|
|
|
|
// If BB#1 -> BB#3 edge is broken and computation of v1024 is inserted:
|
|
|
|
//
|
|
|
|
// BB#1:
|
|
|
|
// ...
|
|
|
|
// Bne BB#2
|
|
|
|
// BB#4:
|
|
|
|
// v1024 =
|
|
|
|
// B BB#3
|
|
|
|
// BB#2:
|
|
|
|
// ... no uses of v1024
|
|
|
|
// <fallthrough>
|
|
|
|
// BB#3:
|
|
|
|
// ...
|
|
|
|
// = v1024
|
|
|
|
//
|
|
|
|
// This is incorrect since v1024 is not computed along the BB#1->BB#2->BB#3
|
|
|
|
// flow. We need to ensure the new basic block where the computation is
|
|
|
|
// sunk to dominates all the uses.
|
|
|
|
// It's only legal to break critical edge and sink the computation to the
|
|
|
|
// new block if all the predecessors of "To", except for "From", are
|
|
|
|
// not dominated by "From". Given SSA property, this means these
|
|
|
|
// predecessors are dominated by "To".
|
|
|
|
//
|
|
|
|
// There is no need to do this check if all the uses are PHI nodes. PHI
|
|
|
|
// sources are only defined on the specific predecessor edges.
|
2010-09-21 03:12:55 +08:00
|
|
|
if (!BreakPHIEdge) {
|
2010-08-20 01:33:11 +08:00
|
|
|
for (MachineBasicBlock::pred_iterator PI = ToBB->pred_begin(),
|
|
|
|
E = ToBB->pred_end(); PI != E; ++PI) {
|
|
|
|
if (*PI == FromBB)
|
|
|
|
continue;
|
|
|
|
if (!DT->dominates(ToBB, *PI))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2010-08-20 01:33:11 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-18 06:28:18 +08:00
|
|
|
return FromBB->SplitCriticalEdge(ToBB, this);
|
2010-08-20 01:33:11 +08:00
|
|
|
}
|
|
|
|
|
2010-09-23 14:53:00 +08:00
|
|
|
static bool AvoidsSinking(MachineInstr *MI, MachineRegisterInfo *MRI) {
|
|
|
|
return MI->isInsertSubreg() || MI->isSubregToReg() || MI->isRegSequence();
|
|
|
|
}
|
|
|
|
|
2012-02-09 05:22:43 +08:00
|
|
|
/// collectDebgValues - Scan instructions following MI and collect any
|
2011-09-07 08:07:58 +08:00
|
|
|
/// matching DBG_VALUEs.
|
2012-02-09 05:22:43 +08:00
|
|
|
static void collectDebugValues(MachineInstr *MI,
|
2013-07-14 12:42:23 +08:00
|
|
|
SmallVectorImpl<MachineInstr *> &DbgValues) {
|
2011-09-07 08:07:58 +08:00
|
|
|
DbgValues.clear();
|
|
|
|
if (!MI->getOperand(0).isReg())
|
|
|
|
return;
|
|
|
|
|
|
|
|
MachineBasicBlock::iterator DI = MI; ++DI;
|
|
|
|
for (MachineBasicBlock::iterator DE = MI->getParent()->end();
|
|
|
|
DI != DE; ++DI) {
|
|
|
|
if (!DI->isDebugValue())
|
|
|
|
return;
|
|
|
|
if (DI->getOperand(0).isReg() &&
|
|
|
|
DI->getOperand(0).getReg() == MI->getOperand(0).getReg())
|
|
|
|
DbgValues.push_back(DI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-15 07:20:38 +08:00
|
|
|
/// isPostDominatedBy - Return true if A is post dominated by B.
|
|
|
|
static bool isPostDominatedBy(MachineBasicBlock *A, MachineBasicBlock *B) {
|
|
|
|
|
|
|
|
// FIXME - Use real post dominator.
|
|
|
|
if (A->succ_size() != 2)
|
|
|
|
return false;
|
|
|
|
MachineBasicBlock::succ_iterator I = A->succ_begin();
|
|
|
|
if (B == *I)
|
|
|
|
++I;
|
|
|
|
MachineBasicBlock *OtherSuccBlock = *I;
|
|
|
|
if (OtherSuccBlock->succ_size() != 1 ||
|
|
|
|
*(OtherSuccBlock->succ_begin()) != B)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isProfitableToSinkTo - Return true if it is profitable to sink MI.
|
2012-02-09 05:22:43 +08:00
|
|
|
bool MachineSinking::isProfitableToSinkTo(unsigned Reg, MachineInstr *MI,
|
2011-12-15 07:20:38 +08:00
|
|
|
MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock *SuccToSinkTo) {
|
|
|
|
assert (MI && "Invalid MachineInstr!");
|
|
|
|
assert (SuccToSinkTo && "Invalid SinkTo Candidate BB");
|
|
|
|
|
|
|
|
if (MBB == SuccToSinkTo)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// It is profitable if SuccToSinkTo does not post dominate current block.
|
|
|
|
if (!isPostDominatedBy(MBB, SuccToSinkTo))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Check if only use in post dominated block is PHI instruction.
|
|
|
|
bool NonPHIUse = false;
|
2014-03-18 03:36:09 +08:00
|
|
|
for (MachineInstr &UseInst : MRI->use_nodbg_instructions(Reg)) {
|
|
|
|
MachineBasicBlock *UseBlock = UseInst.getParent();
|
|
|
|
if (UseBlock == SuccToSinkTo && !UseInst.isPHI())
|
2011-12-15 07:20:38 +08:00
|
|
|
NonPHIUse = true;
|
|
|
|
}
|
|
|
|
if (!NonPHIUse)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// If SuccToSinkTo post dominates then also it may be profitable if MI
|
|
|
|
// can further profitably sinked into another block in next round.
|
|
|
|
bool BreakPHIEdge = false;
|
|
|
|
// FIXME - If finding successor is compile time expensive then catch results.
|
|
|
|
if (MachineBasicBlock *MBB2 = FindSuccToSinkTo(MI, SuccToSinkTo, BreakPHIEdge))
|
|
|
|
return isProfitableToSinkTo(Reg, MI, SuccToSinkTo, MBB2);
|
|
|
|
|
|
|
|
// If SuccToSinkTo is final destination and it is a post dominator of current
|
|
|
|
// block then it is not profitable to sink MI into SuccToSinkTo block.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-12-09 05:48:01 +08:00
|
|
|
/// FindSuccToSinkTo - Find a successor to sink this instruction to.
|
|
|
|
MachineBasicBlock *MachineSinking::FindSuccToSinkTo(MachineInstr *MI,
|
2011-12-15 07:20:38 +08:00
|
|
|
MachineBasicBlock *MBB,
|
|
|
|
bool &BreakPHIEdge) {
|
|
|
|
|
|
|
|
assert (MI && "Invalid MachineInstr!");
|
|
|
|
assert (MBB && "Invalid MachineBasicBlock!");
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// Loop over all the operands of the specified instruction. If there is
|
|
|
|
// anything we can't handle, bail out.
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// SuccToSinkTo - This is the successor to sink this instruction to, once we
|
|
|
|
// decide.
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *SuccToSinkTo = nullptr;
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
|
|
const MachineOperand &MO = MI->getOperand(i);
|
2008-10-03 23:45:36 +08:00
|
|
|
if (!MO.isReg()) continue; // Ignore non-register operands.
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0) continue;
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2008-02-11 02:45:23 +08:00
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
|
2009-09-26 06:53:29 +08:00
|
|
|
if (MO.isUse()) {
|
|
|
|
// If the physreg has no defs anywhere, it's just an ambient register
|
2009-09-26 10:34:00 +08:00
|
|
|
// and we can freely move its uses. Alternatively, if it's allocatable,
|
|
|
|
// it could get allocated to something with a def during allocation.
|
2012-01-17 06:34:08 +08:00
|
|
|
if (!MRI->isConstantPhysReg(Reg, *MBB->getParent()))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2010-06-26 04:48:10 +08:00
|
|
|
} else if (!MO.isDead()) {
|
|
|
|
// A def that isn't dead. We can't move it.
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2009-09-26 06:53:29 +08:00
|
|
|
}
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
} else {
|
|
|
|
// Virtual register uses are always safe to sink.
|
|
|
|
if (MO.isUse()) continue;
|
2009-02-07 09:21:47 +08:00
|
|
|
|
|
|
|
// If it's not safe to move defs of the register class, then abort.
|
2010-09-18 06:28:18 +08:00
|
|
|
if (!TII->isSafeToMoveRegClassDefs(MRI->getRegClass(Reg)))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2008-01-05 14:47:58 +08:00
|
|
|
// FIXME: This picks a successor to sink into based on having one
|
|
|
|
// successor that dominates all the uses. However, there are cases where
|
|
|
|
// sinking can happen but where the sink point isn't a successor. For
|
|
|
|
// example:
|
2010-06-04 07:49:57 +08:00
|
|
|
//
|
2008-01-05 14:47:58 +08:00
|
|
|
// x = computation
|
|
|
|
// if () {} else {}
|
|
|
|
// use x
|
2010-06-04 07:49:57 +08:00
|
|
|
//
|
2010-06-03 07:04:26 +08:00
|
|
|
// the instruction could be sunk over the whole diamond for the
|
2008-01-05 14:47:58 +08:00
|
|
|
// if/then/else (or loop, etc), allowing it to be sunk into other blocks
|
|
|
|
// after that.
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// Virtual register defs can only be sunk if all their uses are in blocks
|
|
|
|
// dominated by one of the successors.
|
|
|
|
if (SuccToSinkTo) {
|
|
|
|
// If a previous operand picked a block to sink to, then this operand
|
|
|
|
// must be sinkable to the same block.
|
2010-08-20 02:33:29 +08:00
|
|
|
bool LocalUse = false;
|
2011-12-15 07:20:38 +08:00
|
|
|
if (!AllUsesDominatedByBlock(Reg, SuccToSinkTo, MBB,
|
2010-09-21 03:12:55 +08:00
|
|
|
BreakPHIEdge, LocalUse))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2010-06-03 07:04:26 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
continue;
|
|
|
|
}
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// Otherwise, we should look at all the successors and decide which one
|
|
|
|
// we should sink to.
|
2012-08-01 02:10:39 +08:00
|
|
|
// We give successors with smaller loop depth higher priority.
|
|
|
|
SmallVector<MachineBasicBlock*, 4> Succs(MBB->succ_begin(), MBB->succ_end());
|
2014-03-01 19:47:00 +08:00
|
|
|
// Sort Successors according to their loop depth.
|
|
|
|
std::stable_sort(
|
|
|
|
Succs.begin(), Succs.end(),
|
|
|
|
[this](const MachineBasicBlock *LHS, const MachineBasicBlock *RHS) {
|
|
|
|
return LI->getLoopDepth(LHS) < LI->getLoopDepth(RHS);
|
|
|
|
});
|
2013-07-03 13:11:49 +08:00
|
|
|
for (SmallVectorImpl<MachineBasicBlock *>::iterator SI = Succs.begin(),
|
|
|
|
E = Succs.end(); SI != E; ++SI) {
|
2011-12-15 07:20:38 +08:00
|
|
|
MachineBasicBlock *SuccBlock = *SI;
|
2010-08-20 02:33:29 +08:00
|
|
|
bool LocalUse = false;
|
2011-12-15 07:20:38 +08:00
|
|
|
if (AllUsesDominatedByBlock(Reg, SuccBlock, MBB,
|
2010-09-21 03:12:55 +08:00
|
|
|
BreakPHIEdge, LocalUse)) {
|
2011-12-09 05:33:23 +08:00
|
|
|
SuccToSinkTo = SuccBlock;
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
break;
|
|
|
|
}
|
2010-08-19 07:09:25 +08:00
|
|
|
if (LocalUse)
|
|
|
|
// Def is used locally, it's never safe to move this def.
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
}
|
2010-06-04 07:49:57 +08:00
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// If we couldn't find a block to sink to, ignore this instruction.
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!SuccToSinkTo)
|
|
|
|
return nullptr;
|
|
|
|
if (!isProfitableToSinkTo(Reg, MI, MBB, SuccToSinkTo))
|
|
|
|
return nullptr;
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
}
|
|
|
|
}
|
2011-12-09 07:52:00 +08:00
|
|
|
|
|
|
|
// It is not possible to sink an instruction into its own block. This can
|
|
|
|
// happen with loops.
|
2011-12-15 07:20:38 +08:00
|
|
|
if (MBB == SuccToSinkTo)
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2011-12-09 07:52:00 +08:00
|
|
|
|
|
|
|
// It's not safe to sink instructions to EH landing pad. Control flow into
|
|
|
|
// landing pad is implicitly defined.
|
|
|
|
if (SuccToSinkTo && SuccToSinkTo->isLandingPad())
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2011-12-09 07:52:00 +08:00
|
|
|
|
2011-12-09 05:48:01 +08:00
|
|
|
return SuccToSinkTo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// SinkInstruction - Determine whether it is safe to sink the specified machine
|
|
|
|
/// instruction out of its current block into a successor.
|
|
|
|
bool MachineSinking::SinkInstruction(MachineInstr *MI, bool &SawStore) {
|
|
|
|
// Don't sink insert_subreg, subreg_to_reg, reg_sequence. These are meant to
|
|
|
|
// be close to the source to make it easier to coalesce.
|
|
|
|
if (AvoidsSinking(MI, MRI))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check if it's safe to move the instruction.
|
|
|
|
if (!MI->isSafeToMove(TII, AA, SawStore))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// FIXME: This should include support for sinking instructions within the
|
|
|
|
// block they are currently in to shorten the live ranges. We often get
|
|
|
|
// instructions sunk into the top of a large block, but it would be better to
|
|
|
|
// also sink them down before their first use in the block. This xform has to
|
|
|
|
// be careful not to *increase* register pressure though, e.g. sinking
|
|
|
|
// "x = y + z" down if it kills y and z would increase the live ranges of y
|
|
|
|
// and z and only shrink the live range of x.
|
|
|
|
|
|
|
|
bool BreakPHIEdge = false;
|
2011-12-15 07:20:38 +08:00
|
|
|
MachineBasicBlock *ParentBlock = MI->getParent();
|
|
|
|
MachineBasicBlock *SuccToSinkTo = FindSuccToSinkTo(MI, ParentBlock, BreakPHIEdge);
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2008-01-05 09:39:17 +08:00
|
|
|
// If there are no outputs, it must have side-effects.
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!SuccToSinkTo)
|
2008-01-05 09:39:17 +08:00
|
|
|
return false;
|
2009-02-15 16:36:12 +08:00
|
|
|
|
2010-06-03 15:54:20 +08:00
|
|
|
|
2010-06-23 08:48:25 +08:00
|
|
|
// If the instruction to move defines a dead physical register which is live
|
|
|
|
// when leaving the basic block, don't move it because it could turn into a
|
|
|
|
// "zombie" define of that preg. E.g., EFLAGS. (<rdar://problem/8030636>)
|
2010-06-26 04:48:10 +08:00
|
|
|
for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
|
|
|
|
const MachineOperand &MO = MI->getOperand(I);
|
|
|
|
if (!MO.isReg()) continue;
|
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0 || !TargetRegisterInfo::isPhysicalRegister(Reg)) continue;
|
|
|
|
if (SuccToSinkTo->isLiveIn(Reg))
|
2010-06-03 15:54:20 +08:00
|
|
|
return false;
|
2010-06-26 04:48:10 +08:00
|
|
|
}
|
2010-06-03 15:54:20 +08:00
|
|
|
|
2010-06-03 07:04:26 +08:00
|
|
|
DEBUG(dbgs() << "Sink instr " << *MI << "\tinto block " << *SuccToSinkTo);
|
|
|
|
|
MachineSink: Fix and tweak critical-edge breaking heuristic.
Per original comment, the intention of this loop
is to go ahead and break the critical edge
(in order to sink this instruction) if there's
reason to believe doing so might "unblock" the
sinking of additional instructions that define
registers used by this one. The idea is that if
we have a few instructions to sink "together"
breaking the edge might be worthwhile.
This commit makes a few small changes
to help better realize this goal:
First, modify the loop to ignore registers
defined by this instruction. We don't
sink definitions of physical registers,
and sinking an SSA definition isn't
going to unblock an upstream instruction.
Second, ignore uses of physical registers.
Instructions that define physical registers are
rejected for sinking, and so moving this one
won't enable moving any defining instructions.
As an added bonus, while virtual register
use-def chains are generally small due
to SSA goodness, iteration over the uses
and definitions (used by hasOneNonDBGUse)
for physical registers like EFLAGS
can be rather expensive in practice.
(This is the original reason for looking at this)
Finally, to keep things simple continue
to only consider this trick for registers that
have a single use (via hasOneNonDBGUse),
but to avoid spuriously breaking critical edges
only do so if the definition resides
in the same MBB and therefore this one directly
blocks it from being sunk as well.
If sinking them together is meant to be,
let the iterative nature of this pass
sink the definition into this block first.
Update tests to accomodate this change,
add new testcase where sinking avoids pipeline stalls.
llvm-svn: 192608
2013-10-15 00:57:17 +08:00
|
|
|
// If the block has multiple predecessors, this is a critical edge.
|
|
|
|
// Decide if we can sink along it or need to break the edge.
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
if (SuccToSinkTo->pred_size() > 1) {
|
2010-04-14 03:06:14 +08:00
|
|
|
// We cannot sink a load across a critical edge - there may be stores in
|
|
|
|
// other code paths.
|
2010-08-20 01:33:11 +08:00
|
|
|
bool TryBreak = false;
|
2010-04-14 03:06:14 +08:00
|
|
|
bool store = true;
|
|
|
|
if (!MI->isSafeToMove(TII, AA, store)) {
|
2010-08-20 07:33:02 +08:00
|
|
|
DEBUG(dbgs() << " *** NOTE: Won't sink load along critical edge.\n");
|
2010-08-20 01:33:11 +08:00
|
|
|
TryBreak = true;
|
2010-04-14 03:06:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// We don't want to sink across a critical edge if we don't dominate the
|
|
|
|
// successor. We could be introducing calculations to new code paths.
|
2010-08-20 01:33:11 +08:00
|
|
|
if (!TryBreak && !DT->dominates(ParentBlock, SuccToSinkTo)) {
|
2010-08-20 07:33:02 +08:00
|
|
|
DEBUG(dbgs() << " *** NOTE: Critical edge found\n");
|
2010-08-20 01:33:11 +08:00
|
|
|
TryBreak = true;
|
2010-04-14 03:06:14 +08:00
|
|
|
}
|
|
|
|
|
2010-04-16 07:41:02 +08:00
|
|
|
// Don't sink instructions into a loop.
|
2010-08-20 01:33:11 +08:00
|
|
|
if (!TryBreak && LI->isLoopHeader(SuccToSinkTo)) {
|
2010-08-20 07:33:02 +08:00
|
|
|
DEBUG(dbgs() << " *** NOTE: Loop header found\n");
|
2010-08-20 01:33:11 +08:00
|
|
|
TryBreak = true;
|
2010-04-16 07:41:02 +08:00
|
|
|
}
|
|
|
|
|
2010-04-14 03:06:14 +08:00
|
|
|
// Otherwise we are OK with sinking along a critical edge.
|
2010-08-20 01:33:11 +08:00
|
|
|
if (!TryBreak)
|
|
|
|
DEBUG(dbgs() << "Sinking along critical edge.\n");
|
|
|
|
else {
|
2010-09-18 06:28:18 +08:00
|
|
|
MachineBasicBlock *NewSucc =
|
2010-09-21 03:12:55 +08:00
|
|
|
SplitCriticalEdge(MI, ParentBlock, SuccToSinkTo, BreakPHIEdge);
|
2010-08-20 01:33:11 +08:00
|
|
|
if (!NewSucc) {
|
2010-09-18 06:28:18 +08:00
|
|
|
DEBUG(dbgs() << " *** PUNTING: Not legal or profitable to "
|
|
|
|
"break critical edge\n");
|
2010-08-20 01:33:11 +08:00
|
|
|
return false;
|
|
|
|
} else {
|
2010-08-20 07:33:02 +08:00
|
|
|
DEBUG(dbgs() << " *** Splitting critical edge:"
|
2010-08-20 01:33:11 +08:00
|
|
|
" BB#" << ParentBlock->getNumber()
|
|
|
|
<< " -- BB#" << NewSucc->getNumber()
|
|
|
|
<< " -- BB#" << SuccToSinkTo->getNumber() << '\n');
|
|
|
|
SuccToSinkTo = NewSucc;
|
|
|
|
++NumSplit;
|
2010-09-21 03:12:55 +08:00
|
|
|
BreakPHIEdge = false;
|
2010-08-20 01:33:11 +08:00
|
|
|
}
|
|
|
|
}
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
}
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2010-09-21 03:12:55 +08:00
|
|
|
if (BreakPHIEdge) {
|
|
|
|
// BreakPHIEdge is true if all the uses are in the successor MBB being
|
|
|
|
// sunken into and they are all PHI nodes. In this case, machine-sink must
|
|
|
|
// break the critical edge first.
|
2010-09-18 14:42:17 +08:00
|
|
|
MachineBasicBlock *NewSucc = SplitCriticalEdge(MI, ParentBlock,
|
2010-09-21 03:12:55 +08:00
|
|
|
SuccToSinkTo, BreakPHIEdge);
|
2010-09-18 14:42:17 +08:00
|
|
|
if (!NewSucc) {
|
|
|
|
DEBUG(dbgs() << " *** PUNTING: Not legal or profitable to "
|
|
|
|
"break critical edge\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG(dbgs() << " *** Splitting critical edge:"
|
|
|
|
" BB#" << ParentBlock->getNumber()
|
|
|
|
<< " -- BB#" << NewSucc->getNumber()
|
|
|
|
<< " -- BB#" << SuccToSinkTo->getNumber() << '\n');
|
|
|
|
SuccToSinkTo = NewSucc;
|
|
|
|
++NumSplit;
|
|
|
|
}
|
|
|
|
|
2010-06-03 07:04:26 +08:00
|
|
|
// Determine where to insert into. Skip phi nodes.
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
MachineBasicBlock::iterator InsertPos = SuccToSinkTo->begin();
|
2010-09-18 14:42:17 +08:00
|
|
|
while (InsertPos != SuccToSinkTo->end() && InsertPos->isPHI())
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
++InsertPos;
|
2010-06-04 07:49:57 +08:00
|
|
|
|
2011-09-07 08:07:58 +08:00
|
|
|
// collect matching debug values.
|
|
|
|
SmallVector<MachineInstr *, 2> DbgValuesToSink;
|
|
|
|
collectDebugValues(MI, DbgValuesToSink);
|
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
// Move the instruction.
|
|
|
|
SuccToSinkTo->splice(InsertPos, ParentBlock, MI,
|
|
|
|
++MachineBasicBlock::iterator(MI));
|
2010-05-14 04:34:42 +08:00
|
|
|
|
2011-09-07 08:07:58 +08:00
|
|
|
// Move debug values.
|
2013-07-03 13:11:49 +08:00
|
|
|
for (SmallVectorImpl<MachineInstr *>::iterator DBI = DbgValuesToSink.begin(),
|
2011-09-07 08:07:58 +08:00
|
|
|
DBE = DbgValuesToSink.end(); DBI != DBE; ++DBI) {
|
|
|
|
MachineInstr *DbgMI = *DBI;
|
|
|
|
SuccToSinkTo->splice(InsertPos, ParentBlock, DbgMI,
|
|
|
|
++MachineBasicBlock::iterator(DbgMI));
|
|
|
|
}
|
|
|
|
|
2010-06-03 07:04:26 +08:00
|
|
|
// Conservatively, clear any kill flags, since it's possible that they are no
|
|
|
|
// longer correct.
|
2010-05-14 04:34:42 +08:00
|
|
|
MI->clearKillInfo();
|
|
|
|
|
Add a really quick hack at a machine code sinking pass, enabled with --enable-sinking.
It is missing validity checks, so it is known broken. However, it is powerful enough
to compile this contrived code:
void test1(int C, double A, double B, double *P) {
double Tmp = A*A+B*B;
*P = C ? Tmp : A;
}
into:
_test1:
movsd 8(%esp), %xmm0
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movsd 16(%esp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm0, (%eax)
ret
instead of:
_test1:
movsd 16(%esp), %xmm0
mulsd %xmm0, %xmm0
movsd 8(%esp), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
cmpl $0, 4(%esp)
je LBB1_2 # entry
LBB1_1: # entry
movapd %xmm2, %xmm1
LBB1_2: # entry
movl 24(%esp), %eax
movsd %xmm1, (%eax)
ret
woo.
llvm-svn: 45570
2008-01-04 15:36:53 +08:00
|
|
|
return true;
|
|
|
|
}
|