2005-01-07 07:46:32 +00:00
|
|
|
//===-- SelectionDAG.cpp - Implement the SelectionDAG data structures -----===//
|
2005-04-21 22:36:52 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
2005-04-21 22:36:52 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-08-11 14:57:33 +00:00
|
|
|
//
|
2005-01-07 07:46:32 +00:00
|
|
|
// This implements the SelectionDAG class.
|
2003-08-11 14:57:33 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/CodeGen/SelectionDAG.h"
|
2005-01-07 07:46:32 +00:00
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/GlobalValue.h"
|
|
|
|
#include "llvm/Assembly/Writer.h"
|
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
2005-08-02 19:26:06 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2005-08-19 21:34:13 +00:00
|
|
|
#include "llvm/Target/MRegisterInfo.h"
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
#include "llvm/Target/TargetLowering.h"
|
2005-08-16 18:33:07 +00:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2004-07-04 12:19:56 +00:00
|
|
|
#include <iostream>
|
2005-01-07 21:09:16 +00:00
|
|
|
#include <set>
|
2005-01-07 07:46:32 +00:00
|
|
|
#include <cmath>
|
2005-01-09 20:41:56 +00:00
|
|
|
#include <algorithm>
|
2004-06-02 04:28:06 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2005-09-07 05:37:01 +00:00
|
|
|
// Temporary boolean for testing the dag combiner
|
|
|
|
namespace llvm {
|
|
|
|
extern bool CombinerEnabled;
|
|
|
|
}
|
|
|
|
|
Add some folds for == and != comparisons. This allows us to
codegen this loop in stepanov:
no_exit.i: ; preds = %entry, %no_exit.i, %then.i, %_Z5checkd.exit
%i.0.0 = phi int [ 0, %entry ], [ %i.0.0, %no_exit.i ], [ %inc.0, %_Z5checkd.exit ], [ %inc.012, %then.i ] ; <int> [#uses=3]
%indvar = phi uint [ %indvar.next, %no_exit.i ], [ 0, %entry ], [ 0, %then.i ], [ 0, %_Z5checkd.exit ] ; <uint> [#uses=3]
%result_addr.i.0 = phi double [ %tmp.4.i.i, %no_exit.i ], [ 0.000000e+00, %entry ], [ 0.000000e+00, %then.i ], [ 0.000000e+00, %_Z5checkd.exit ] ; <double> [#uses=1]
%first_addr.0.i.2.rec = cast uint %indvar to int ; <int> [#uses=1]
%first_addr.0.i.2 = getelementptr [2000 x double]* %data, int 0, uint %indvar ; <double*> [#uses=1]
%inc.i.rec = add int %first_addr.0.i.2.rec, 1 ; <int> [#uses=1]
%inc.i = getelementptr [2000 x double]* %data, int 0, int %inc.i.rec ; <double*> [#uses=1]
%tmp.3.i.i = load double* %first_addr.0.i.2 ; <double> [#uses=1]
%tmp.4.i.i = add double %result_addr.i.0, %tmp.3.i.i ; <double> [#uses=2]
%tmp.2.i = seteq double* %inc.i, getelementptr ([2000 x double]* %data, int 0, int 2000) ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1 ; <uint> [#uses=1]
br bool %tmp.2.i, label %_Z10accumulateIPddET0_T_S2_S1_.exit, label %no_exit.i
To this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
movl %eax, %ecx
shll $3, %ecx
cmpl $16000, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
instead of this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
leal data(,%eax,8), %ecx
leal data+16000, %edx
cmpl %edx, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19425 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:52:51 +00:00
|
|
|
static bool isCommutativeBinOp(unsigned Opcode) {
|
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::ADD:
|
|
|
|
case ISD::MUL:
|
|
|
|
case ISD::AND:
|
|
|
|
case ISD::OR:
|
|
|
|
case ISD::XOR: return true;
|
|
|
|
default: return false; // FIXME: Need commutative info for user ops!
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool isAssociativeBinOp(unsigned Opcode) {
|
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::ADD:
|
|
|
|
case ISD::MUL:
|
|
|
|
case ISD::AND:
|
|
|
|
case ISD::OR:
|
|
|
|
case ISD::XOR: return true;
|
|
|
|
default: return false; // FIXME: Need associative info for user ops!
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// isInvertibleForFree - Return true if there is no cost to emitting the logical
|
|
|
|
// inverse of this node.
|
|
|
|
static bool isInvertibleForFree(SDOperand N) {
|
|
|
|
if (isa<ConstantSDNode>(N.Val)) return true;
|
2005-08-09 20:20:18 +00:00
|
|
|
if (N.Val->getOpcode() == ISD::SETCC && N.Val->hasOneUse())
|
Add some folds for == and != comparisons. This allows us to
codegen this loop in stepanov:
no_exit.i: ; preds = %entry, %no_exit.i, %then.i, %_Z5checkd.exit
%i.0.0 = phi int [ 0, %entry ], [ %i.0.0, %no_exit.i ], [ %inc.0, %_Z5checkd.exit ], [ %inc.012, %then.i ] ; <int> [#uses=3]
%indvar = phi uint [ %indvar.next, %no_exit.i ], [ 0, %entry ], [ 0, %then.i ], [ 0, %_Z5checkd.exit ] ; <uint> [#uses=3]
%result_addr.i.0 = phi double [ %tmp.4.i.i, %no_exit.i ], [ 0.000000e+00, %entry ], [ 0.000000e+00, %then.i ], [ 0.000000e+00, %_Z5checkd.exit ] ; <double> [#uses=1]
%first_addr.0.i.2.rec = cast uint %indvar to int ; <int> [#uses=1]
%first_addr.0.i.2 = getelementptr [2000 x double]* %data, int 0, uint %indvar ; <double*> [#uses=1]
%inc.i.rec = add int %first_addr.0.i.2.rec, 1 ; <int> [#uses=1]
%inc.i = getelementptr [2000 x double]* %data, int 0, int %inc.i.rec ; <double*> [#uses=1]
%tmp.3.i.i = load double* %first_addr.0.i.2 ; <double> [#uses=1]
%tmp.4.i.i = add double %result_addr.i.0, %tmp.3.i.i ; <double> [#uses=2]
%tmp.2.i = seteq double* %inc.i, getelementptr ([2000 x double]* %data, int 0, int 2000) ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1 ; <uint> [#uses=1]
br bool %tmp.2.i, label %_Z10accumulateIPddET0_T_S2_S1_.exit, label %no_exit.i
To this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
movl %eax, %ecx
shll $3, %ecx
cmpl $16000, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
instead of this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
leal data(,%eax,8), %ecx
leal data+16000, %edx
cmpl %edx, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19425 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:52:51 +00:00
|
|
|
return true;
|
2005-04-21 22:36:52 +00:00
|
|
|
return false;
|
Add some folds for == and != comparisons. This allows us to
codegen this loop in stepanov:
no_exit.i: ; preds = %entry, %no_exit.i, %then.i, %_Z5checkd.exit
%i.0.0 = phi int [ 0, %entry ], [ %i.0.0, %no_exit.i ], [ %inc.0, %_Z5checkd.exit ], [ %inc.012, %then.i ] ; <int> [#uses=3]
%indvar = phi uint [ %indvar.next, %no_exit.i ], [ 0, %entry ], [ 0, %then.i ], [ 0, %_Z5checkd.exit ] ; <uint> [#uses=3]
%result_addr.i.0 = phi double [ %tmp.4.i.i, %no_exit.i ], [ 0.000000e+00, %entry ], [ 0.000000e+00, %then.i ], [ 0.000000e+00, %_Z5checkd.exit ] ; <double> [#uses=1]
%first_addr.0.i.2.rec = cast uint %indvar to int ; <int> [#uses=1]
%first_addr.0.i.2 = getelementptr [2000 x double]* %data, int 0, uint %indvar ; <double*> [#uses=1]
%inc.i.rec = add int %first_addr.0.i.2.rec, 1 ; <int> [#uses=1]
%inc.i = getelementptr [2000 x double]* %data, int 0, int %inc.i.rec ; <double*> [#uses=1]
%tmp.3.i.i = load double* %first_addr.0.i.2 ; <double> [#uses=1]
%tmp.4.i.i = add double %result_addr.i.0, %tmp.3.i.i ; <double> [#uses=2]
%tmp.2.i = seteq double* %inc.i, getelementptr ([2000 x double]* %data, int 0, int 2000) ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1 ; <uint> [#uses=1]
br bool %tmp.2.i, label %_Z10accumulateIPddET0_T_S2_S1_.exit, label %no_exit.i
To this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
movl %eax, %ecx
shll $3, %ecx
cmpl $16000, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
instead of this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
leal data(,%eax,8), %ecx
leal data+16000, %edx
cmpl %edx, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19425 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:52:51 +00:00
|
|
|
}
|
|
|
|
|
2005-08-17 20:08:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ConstantFPSDNode Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// isExactlyValue - We don't rely on operator== working on double values, as
|
|
|
|
/// it returns true for things that are clearly not equal, like -0.0 and 0.0.
|
|
|
|
/// As such, this method can be used to do an exact bit-for-bit comparison of
|
|
|
|
/// two floating point values.
|
|
|
|
bool ConstantFPSDNode::isExactlyValue(double V) const {
|
|
|
|
return DoubleToBits(V) == DoubleToBits(Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ISD Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
Add some folds for == and != comparisons. This allows us to
codegen this loop in stepanov:
no_exit.i: ; preds = %entry, %no_exit.i, %then.i, %_Z5checkd.exit
%i.0.0 = phi int [ 0, %entry ], [ %i.0.0, %no_exit.i ], [ %inc.0, %_Z5checkd.exit ], [ %inc.012, %then.i ] ; <int> [#uses=3]
%indvar = phi uint [ %indvar.next, %no_exit.i ], [ 0, %entry ], [ 0, %then.i ], [ 0, %_Z5checkd.exit ] ; <uint> [#uses=3]
%result_addr.i.0 = phi double [ %tmp.4.i.i, %no_exit.i ], [ 0.000000e+00, %entry ], [ 0.000000e+00, %then.i ], [ 0.000000e+00, %_Z5checkd.exit ] ; <double> [#uses=1]
%first_addr.0.i.2.rec = cast uint %indvar to int ; <int> [#uses=1]
%first_addr.0.i.2 = getelementptr [2000 x double]* %data, int 0, uint %indvar ; <double*> [#uses=1]
%inc.i.rec = add int %first_addr.0.i.2.rec, 1 ; <int> [#uses=1]
%inc.i = getelementptr [2000 x double]* %data, int 0, int %inc.i.rec ; <double*> [#uses=1]
%tmp.3.i.i = load double* %first_addr.0.i.2 ; <double> [#uses=1]
%tmp.4.i.i = add double %result_addr.i.0, %tmp.3.i.i ; <double> [#uses=2]
%tmp.2.i = seteq double* %inc.i, getelementptr ([2000 x double]* %data, int 0, int 2000) ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1 ; <uint> [#uses=1]
br bool %tmp.2.i, label %_Z10accumulateIPddET0_T_S2_S1_.exit, label %no_exit.i
To this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
movl %eax, %ecx
shll $3, %ecx
cmpl $16000, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
instead of this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
leal data(,%eax,8), %ecx
leal data+16000, %edx
cmpl %edx, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19425 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:52:51 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
/// getSetCCSwappedOperands - Return the operation corresponding to (Y op X)
|
|
|
|
/// when given the operation for (X op Y).
|
|
|
|
ISD::CondCode ISD::getSetCCSwappedOperands(ISD::CondCode Operation) {
|
|
|
|
// To perform this operation, we just need to swap the L and G bits of the
|
|
|
|
// operation.
|
|
|
|
unsigned OldL = (Operation >> 2) & 1;
|
|
|
|
unsigned OldG = (Operation >> 1) & 1;
|
|
|
|
return ISD::CondCode((Operation & ~6) | // Keep the N, U, E bits
|
|
|
|
(OldL << 1) | // New G bit
|
|
|
|
(OldG << 2)); // New L bit.
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getSetCCInverse - Return the operation corresponding to !(X op Y), where
|
|
|
|
/// 'op' is a valid SetCC operation.
|
|
|
|
ISD::CondCode ISD::getSetCCInverse(ISD::CondCode Op, bool isInteger) {
|
|
|
|
unsigned Operation = Op;
|
|
|
|
if (isInteger)
|
|
|
|
Operation ^= 7; // Flip L, G, E bits, but not U.
|
|
|
|
else
|
|
|
|
Operation ^= 15; // Flip all of the condition bits.
|
|
|
|
if (Operation > ISD::SETTRUE2)
|
|
|
|
Operation &= ~8; // Don't let N and U bits get set.
|
|
|
|
return ISD::CondCode(Operation);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// isSignedOp - For an integer comparison, return 1 if the comparison is a
|
|
|
|
/// signed operation and 2 if the result is an unsigned comparison. Return zero
|
|
|
|
/// if the operation does not depend on the sign of the input (setne and seteq).
|
|
|
|
static int isSignedOp(ISD::CondCode Opcode) {
|
|
|
|
switch (Opcode) {
|
|
|
|
default: assert(0 && "Illegal integer setcc operation!");
|
|
|
|
case ISD::SETEQ:
|
|
|
|
case ISD::SETNE: return 0;
|
|
|
|
case ISD::SETLT:
|
|
|
|
case ISD::SETLE:
|
|
|
|
case ISD::SETGT:
|
|
|
|
case ISD::SETGE: return 1;
|
|
|
|
case ISD::SETULT:
|
|
|
|
case ISD::SETULE:
|
|
|
|
case ISD::SETUGT:
|
|
|
|
case ISD::SETUGE: return 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getSetCCOrOperation - Return the result of a logical OR between different
|
|
|
|
/// comparisons of identical values: ((X op1 Y) | (X op2 Y)). This function
|
|
|
|
/// returns SETCC_INVALID if it is not possible to represent the resultant
|
|
|
|
/// comparison.
|
|
|
|
ISD::CondCode ISD::getSetCCOrOperation(ISD::CondCode Op1, ISD::CondCode Op2,
|
|
|
|
bool isInteger) {
|
|
|
|
if (isInteger && (isSignedOp(Op1) | isSignedOp(Op2)) == 3)
|
|
|
|
// Cannot fold a signed integer setcc with an unsigned integer setcc.
|
|
|
|
return ISD::SETCC_INVALID;
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
unsigned Op = Op1 | Op2; // Combine all of the condition bits.
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
// If the N and U bits get set then the resultant comparison DOES suddenly
|
|
|
|
// care about orderedness, and is true when ordered.
|
|
|
|
if (Op > ISD::SETTRUE2)
|
|
|
|
Op &= ~16; // Clear the N bit.
|
|
|
|
return ISD::CondCode(Op);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getSetCCAndOperation - Return the result of a logical AND between different
|
|
|
|
/// comparisons of identical values: ((X op1 Y) & (X op2 Y)). This
|
|
|
|
/// function returns zero if it is not possible to represent the resultant
|
|
|
|
/// comparison.
|
|
|
|
ISD::CondCode ISD::getSetCCAndOperation(ISD::CondCode Op1, ISD::CondCode Op2,
|
|
|
|
bool isInteger) {
|
|
|
|
if (isInteger && (isSignedOp(Op1) | isSignedOp(Op2)) == 3)
|
|
|
|
// Cannot fold a signed setcc with an unsigned setcc.
|
2005-04-21 22:36:52 +00:00
|
|
|
return ISD::SETCC_INVALID;
|
2005-01-07 07:46:32 +00:00
|
|
|
|
|
|
|
// Combine all of the condition bits.
|
|
|
|
return ISD::CondCode(Op1 & Op2);
|
|
|
|
}
|
|
|
|
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
const TargetMachine &SelectionDAG::getTarget() const {
|
|
|
|
return TLI.getTargetMachine();
|
|
|
|
}
|
|
|
|
|
2005-08-17 20:08:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SelectionDAG Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
|
2005-01-07 21:09:16 +00:00
|
|
|
/// RemoveDeadNodes - This method deletes all unreachable nodes in the
|
|
|
|
/// SelectionDAG, including nodes (like loads) that have uses of their token
|
|
|
|
/// chain but no other uses and no side effect. If a node is passed in as an
|
|
|
|
/// argument, it is used as the seed for node deletion.
|
|
|
|
void SelectionDAG::RemoveDeadNodes(SDNode *N) {
|
|
|
|
std::set<SDNode*> AllNodeSet(AllNodes.begin(), AllNodes.end());
|
|
|
|
|
|
|
|
// Create a dummy node (which is not added to allnodes), that adds a reference
|
|
|
|
// to the root node, preventing it from being deleted.
|
|
|
|
SDNode *DummyNode = new SDNode(ISD::EntryToken, getRoot());
|
|
|
|
|
2005-08-17 19:00:20 +00:00
|
|
|
// If we have a hint to start from, use it.
|
|
|
|
if (N) DeleteNodeIfDead(N, &AllNodeSet);
|
2005-01-07 21:09:16 +00:00
|
|
|
|
|
|
|
Restart:
|
|
|
|
unsigned NumNodes = AllNodeSet.size();
|
|
|
|
for (std::set<SDNode*>::iterator I = AllNodeSet.begin(), E = AllNodeSet.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
// Try to delete this node.
|
|
|
|
DeleteNodeIfDead(*I, &AllNodeSet);
|
|
|
|
|
|
|
|
// If we actually deleted any nodes, do not use invalid iterators in
|
|
|
|
// AllNodeSet.
|
|
|
|
if (AllNodeSet.size() != NumNodes)
|
|
|
|
goto Restart;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Restore AllNodes.
|
|
|
|
if (AllNodes.size() != NumNodes)
|
|
|
|
AllNodes.assign(AllNodeSet.begin(), AllNodeSet.end());
|
|
|
|
|
|
|
|
// If the root changed (e.g. it was a dead load, update the root).
|
|
|
|
setRoot(DummyNode->getOperand(0));
|
|
|
|
|
|
|
|
// Now that we are done with the dummy node, delete it.
|
|
|
|
DummyNode->getOperand(0).Val->removeUser(DummyNode);
|
|
|
|
delete DummyNode;
|
|
|
|
}
|
|
|
|
|
2005-08-16 18:17:10 +00:00
|
|
|
|
2005-01-07 21:09:16 +00:00
|
|
|
void SelectionDAG::DeleteNodeIfDead(SDNode *N, void *NodeSet) {
|
|
|
|
if (!N->use_empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Okay, we really are going to delete this node. First take this out of the
|
|
|
|
// appropriate CSE map.
|
2005-08-16 18:17:10 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
|
|
|
|
// Next, brutally remove the operand list. This is safe to do, as there are
|
|
|
|
// no cycles in the graph.
|
|
|
|
while (!N->Operands.empty()) {
|
|
|
|
SDNode *O = N->Operands.back().Val;
|
|
|
|
N->Operands.pop_back();
|
|
|
|
O->removeUser(N);
|
|
|
|
|
|
|
|
// Now that we removed this operand, see if there are no uses of it left.
|
|
|
|
DeleteNodeIfDead(O, NodeSet);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the node from the nodes set and delete it.
|
|
|
|
std::set<SDNode*> &AllNodeSet = *(std::set<SDNode*>*)NodeSet;
|
|
|
|
AllNodeSet.erase(N);
|
|
|
|
|
|
|
|
// Now that the node is gone, check to see if any of the operands of this node
|
|
|
|
// are dead now.
|
|
|
|
delete N;
|
|
|
|
}
|
|
|
|
|
2005-08-29 21:59:31 +00:00
|
|
|
void SelectionDAG::DeleteNode(SDNode *N) {
|
|
|
|
assert(N->use_empty() && "Cannot delete a node that is not dead!");
|
|
|
|
|
|
|
|
// First take this out of the appropriate CSE map.
|
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
|
2005-09-07 05:37:01 +00:00
|
|
|
// Finally, remove uses due to operands of this node, remove from the
|
|
|
|
// AllNodes list, and delete the node.
|
|
|
|
DeleteNodeNotInCSEMaps(N);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAG::DeleteNodeNotInCSEMaps(SDNode *N) {
|
|
|
|
|
2005-08-29 21:59:31 +00:00
|
|
|
// Remove it from the AllNodes list.
|
|
|
|
for (std::vector<SDNode*>::iterator I = AllNodes.begin(); ; ++I) {
|
|
|
|
assert(I != AllNodes.end() && "Node not in AllNodes list??");
|
|
|
|
if (*I == N) {
|
|
|
|
// Erase from the vector, which is not ordered.
|
|
|
|
std::swap(*I, AllNodes.back());
|
|
|
|
AllNodes.pop_back();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Drop all of the operands and decrement used nodes use counts.
|
|
|
|
while (!N->Operands.empty()) {
|
|
|
|
SDNode *O = N->Operands.back().Val;
|
|
|
|
N->Operands.pop_back();
|
|
|
|
O->removeUser(N);
|
|
|
|
}
|
|
|
|
|
|
|
|
delete N;
|
|
|
|
}
|
|
|
|
|
2005-08-16 18:17:10 +00:00
|
|
|
/// RemoveNodeFromCSEMaps - Take the specified node out of the CSE map that
|
|
|
|
/// correspond to it. This is useful when we're about to delete or repurpose
|
|
|
|
/// the node. We don't want future request for structurally identical nodes
|
|
|
|
/// to return N anymore.
|
|
|
|
void SelectionDAG::RemoveNodeFromCSEMaps(SDNode *N) {
|
2005-09-02 19:15:44 +00:00
|
|
|
bool Erased = false;
|
2005-01-07 21:09:16 +00:00
|
|
|
switch (N->getOpcode()) {
|
|
|
|
case ISD::Constant:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = Constants.erase(std::make_pair(cast<ConstantSDNode>(N)->getValue(),
|
|
|
|
N->getValueType(0)));
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
2005-08-17 00:34:06 +00:00
|
|
|
case ISD::TargetConstant:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = TargetConstants.erase(std::make_pair(
|
|
|
|
cast<ConstantSDNode>(N)->getValue(),
|
|
|
|
N->getValueType(0)));
|
2005-08-17 00:34:06 +00:00
|
|
|
break;
|
2005-02-17 20:17:32 +00:00
|
|
|
case ISD::ConstantFP: {
|
2005-08-17 19:34:49 +00:00
|
|
|
uint64_t V = DoubleToBits(cast<ConstantFPSDNode>(N)->getValue());
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = ConstantFPs.erase(std::make_pair(V, N->getValueType(0)));
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
2005-02-17 20:17:32 +00:00
|
|
|
}
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::CONDCODE:
|
|
|
|
assert(CondCodeNodes[cast<CondCodeSDNode>(N)->get()] &&
|
|
|
|
"Cond code doesn't exist!");
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = CondCodeNodes[cast<CondCodeSDNode>(N)->get()] != 0;
|
2005-08-09 20:20:18 +00:00
|
|
|
CondCodeNodes[cast<CondCodeSDNode>(N)->get()] = 0;
|
|
|
|
break;
|
2005-01-07 21:09:16 +00:00
|
|
|
case ISD::GlobalAddress:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = GlobalValues.erase(cast<GlobalAddressSDNode>(N)->getGlobal());
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
2005-08-19 22:31:04 +00:00
|
|
|
case ISD::TargetGlobalAddress:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased =TargetGlobalValues.erase(cast<GlobalAddressSDNode>(N)->getGlobal());
|
2005-08-19 22:31:04 +00:00
|
|
|
break;
|
2005-01-07 21:09:16 +00:00
|
|
|
case ISD::FrameIndex:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = FrameIndices.erase(cast<FrameIndexSDNode>(N)->getIndex());
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
2005-08-25 00:43:01 +00:00
|
|
|
case ISD::TargetFrameIndex:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = TargetFrameIndices.erase(cast<FrameIndexSDNode>(N)->getIndex());
|
2005-08-25 00:43:01 +00:00
|
|
|
break;
|
2005-01-07 21:09:16 +00:00
|
|
|
case ISD::ConstantPool:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = ConstantPoolIndices.erase(cast<ConstantPoolSDNode>(N)->get());
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
2005-08-25 05:03:06 +00:00
|
|
|
case ISD::TargetConstantPool:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased =TargetConstantPoolIndices.erase(cast<ConstantPoolSDNode>(N)->get());
|
2005-08-25 05:03:06 +00:00
|
|
|
break;
|
2005-01-07 21:09:16 +00:00
|
|
|
case ISD::BasicBlock:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = BBNodes.erase(cast<BasicBlockSDNode>(N)->getBasicBlock());
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
|
|
|
case ISD::ExternalSymbol:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = ExternalSymbols.erase(cast<ExternalSymbolSDNode>(N)->getSymbol());
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
2005-07-10 00:07:11 +00:00
|
|
|
case ISD::VALUETYPE:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = ValueTypeNodes[cast<VTSDNode>(N)->getVT()] != 0;
|
2005-07-10 00:07:11 +00:00
|
|
|
ValueTypeNodes[cast<VTSDNode>(N)->getVT()] = 0;
|
|
|
|
break;
|
2005-08-16 21:55:35 +00:00
|
|
|
case ISD::Register:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = RegNodes.erase(std::make_pair(cast<RegisterSDNode>(N)->getReg(),
|
|
|
|
N->getValueType(0)));
|
2005-08-16 21:55:35 +00:00
|
|
|
break;
|
2005-08-05 16:55:31 +00:00
|
|
|
case ISD::SRCVALUE: {
|
|
|
|
SrcValueSDNode *SVN = cast<SrcValueSDNode>(N);
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased =ValueNodes.erase(std::make_pair(SVN->getValue(), SVN->getOffset()));
|
2005-08-05 16:55:31 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-01-07 21:09:16 +00:00
|
|
|
case ISD::LOAD:
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased = Loads.erase(std::make_pair(N->getOperand(1),
|
|
|
|
std::make_pair(N->getOperand(0),
|
|
|
|
N->getValueType(0))));
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
|
|
|
default:
|
2005-09-02 19:15:44 +00:00
|
|
|
if (N->getNumValues() == 1) {
|
2005-09-02 19:36:17 +00:00
|
|
|
if (N->getNumOperands() == 0) {
|
|
|
|
Erased = NullaryOps.erase(std::make_pair(N->getOpcode(),
|
|
|
|
N->getValueType(0)));
|
|
|
|
} else if (N->getNumOperands() == 1) {
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased =
|
|
|
|
UnaryOps.erase(std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(N->getOperand(0),
|
|
|
|
N->getValueType(0))));
|
|
|
|
} else if (N->getNumOperands() == 2) {
|
|
|
|
Erased =
|
|
|
|
BinaryOps.erase(std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(N->getOperand(0),
|
|
|
|
N->getOperand(1))));
|
|
|
|
} else {
|
|
|
|
std::vector<SDOperand> Ops(N->op_begin(), N->op_end());
|
|
|
|
Erased =
|
|
|
|
OneResultNodes.erase(std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(N->getValueType(0),
|
|
|
|
Ops)));
|
|
|
|
}
|
2005-05-14 07:42:29 +00:00
|
|
|
} else {
|
2005-05-14 06:20:26 +00:00
|
|
|
// Remove the node from the ArbitraryNodes map.
|
|
|
|
std::vector<MVT::ValueType> RV(N->value_begin(), N->value_end());
|
|
|
|
std::vector<SDOperand> Ops(N->op_begin(), N->op_end());
|
2005-09-02 19:15:44 +00:00
|
|
|
Erased =
|
|
|
|
ArbitraryNodes.erase(std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(RV, Ops)));
|
2005-05-14 06:20:26 +00:00
|
|
|
}
|
2005-01-07 21:09:16 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-09-02 19:15:44 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
// Verify that the node was actually in one of the CSE maps, unless it has a
|
|
|
|
// flag result (which cannot be CSE'd) or is one of the special cases that are
|
|
|
|
// not subject to CSE.
|
|
|
|
if (!Erased && N->getValueType(N->getNumValues()-1) != MVT::Flag &&
|
|
|
|
N->getOpcode() != ISD::CALL && N->getOpcode() != ISD::CALLSEQ_START &&
|
2005-09-03 01:04:40 +00:00
|
|
|
N->getOpcode() != ISD::CALLSEQ_END && !N->isTargetOpcode()) {
|
2005-09-02 19:15:44 +00:00
|
|
|
|
|
|
|
N->dump();
|
|
|
|
assert(0 && "Node is not in map!");
|
|
|
|
}
|
|
|
|
#endif
|
2005-01-07 21:09:16 +00:00
|
|
|
}
|
|
|
|
|
2005-08-17 19:00:20 +00:00
|
|
|
/// AddNonLeafNodeToCSEMaps - Add the specified node back to the CSE maps. It
|
|
|
|
/// has been taken out and modified in some way. If the specified node already
|
|
|
|
/// exists in the CSE maps, do not modify the maps, but return the existing node
|
|
|
|
/// instead. If it doesn't exist, add it and return null.
|
|
|
|
///
|
|
|
|
SDNode *SelectionDAG::AddNonLeafNodeToCSEMaps(SDNode *N) {
|
|
|
|
assert(N->getNumOperands() && "This is a leaf node!");
|
|
|
|
if (N->getOpcode() == ISD::LOAD) {
|
|
|
|
SDNode *&L = Loads[std::make_pair(N->getOperand(1),
|
|
|
|
std::make_pair(N->getOperand(0),
|
|
|
|
N->getValueType(0)))];
|
|
|
|
if (L) return L;
|
|
|
|
L = N;
|
|
|
|
} else if (N->getNumOperands() == 1) {
|
|
|
|
SDNode *&U = UnaryOps[std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(N->getOperand(0),
|
|
|
|
N->getValueType(0)))];
|
|
|
|
if (U) return U;
|
|
|
|
U = N;
|
|
|
|
} else if (N->getNumOperands() == 2) {
|
|
|
|
SDNode *&B = BinaryOps[std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(N->getOperand(0),
|
|
|
|
N->getOperand(1)))];
|
|
|
|
if (B) return B;
|
|
|
|
B = N;
|
|
|
|
} else if (N->getNumValues() == 1) {
|
|
|
|
std::vector<SDOperand> Ops(N->op_begin(), N->op_end());
|
|
|
|
SDNode *&ORN = OneResultNodes[std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(N->getValueType(0), Ops))];
|
|
|
|
if (ORN) return ORN;
|
|
|
|
ORN = N;
|
|
|
|
} else {
|
|
|
|
// Remove the node from the ArbitraryNodes map.
|
|
|
|
std::vector<MVT::ValueType> RV(N->value_begin(), N->value_end());
|
|
|
|
std::vector<SDOperand> Ops(N->op_begin(), N->op_end());
|
|
|
|
SDNode *&AN = ArbitraryNodes[std::make_pair(N->getOpcode(),
|
|
|
|
std::make_pair(RV, Ops))];
|
|
|
|
if (AN) return AN;
|
|
|
|
AN = N;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-07 21:09:16 +00:00
|
|
|
|
2003-08-11 14:57:33 +00:00
|
|
|
SelectionDAG::~SelectionDAG() {
|
|
|
|
for (unsigned i = 0, e = AllNodes.size(); i != e; ++i)
|
|
|
|
delete AllNodes[i];
|
|
|
|
}
|
|
|
|
|
2005-04-13 02:38:18 +00:00
|
|
|
SDOperand SelectionDAG::getZeroExtendInReg(SDOperand Op, MVT::ValueType VT) {
|
2005-04-13 19:41:05 +00:00
|
|
|
if (Op.getValueType() == VT) return Op;
|
2005-05-10 02:22:38 +00:00
|
|
|
int64_t Imm = ~0ULL >> (64-MVT::getSizeInBits(VT));
|
2005-04-13 02:38:18 +00:00
|
|
|
return getNode(ISD::AND, Op.getValueType(), Op,
|
|
|
|
getConstant(Imm, Op.getValueType()));
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getConstant(uint64_t Val, MVT::ValueType VT) {
|
|
|
|
assert(MVT::isInteger(VT) && "Cannot create FP integer constant!");
|
|
|
|
// Mask out any bits that are not valid for this constant.
|
2005-01-08 06:24:30 +00:00
|
|
|
if (VT != MVT::i64)
|
|
|
|
Val &= ((uint64_t)1 << MVT::getSizeInBits(VT)) - 1;
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDNode *&N = Constants[std::make_pair(Val, VT)];
|
|
|
|
if (N) return SDOperand(N, 0);
|
2005-08-17 00:34:06 +00:00
|
|
|
N = new ConstantSDNode(false, Val, VT);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getTargetConstant(uint64_t Val, MVT::ValueType VT) {
|
|
|
|
assert(MVT::isInteger(VT) && "Cannot create FP integer constant!");
|
|
|
|
// Mask out any bits that are not valid for this constant.
|
|
|
|
if (VT != MVT::i64)
|
|
|
|
Val &= ((uint64_t)1 << MVT::getSizeInBits(VT)) - 1;
|
|
|
|
|
|
|
|
SDNode *&N = TargetConstants[std::make_pair(Val, VT)];
|
|
|
|
if (N) return SDOperand(N, 0);
|
|
|
|
N = new ConstantSDNode(true, Val, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
2003-08-11 14:57:33 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getConstantFP(double Val, MVT::ValueType VT) {
|
|
|
|
assert(MVT::isFloatingPoint(VT) && "Cannot create integer FP constant!");
|
|
|
|
if (VT == MVT::f32)
|
|
|
|
Val = (float)Val; // Mask out extra precision.
|
|
|
|
|
2005-02-17 20:17:32 +00:00
|
|
|
// Do the map lookup using the actual bit pattern for the floating point
|
|
|
|
// value, so that we don't have problems with 0.0 comparing equal to -0.0, and
|
|
|
|
// we don't have issues with SNANs.
|
2005-08-17 19:34:49 +00:00
|
|
|
SDNode *&N = ConstantFPs[std::make_pair(DoubleToBits(Val), VT)];
|
2005-01-07 07:46:32 +00:00
|
|
|
if (N) return SDOperand(N, 0);
|
|
|
|
N = new ConstantFPSDNode(Val, VT);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getGlobalAddress(const GlobalValue *GV,
|
|
|
|
MVT::ValueType VT) {
|
|
|
|
SDNode *&N = GlobalValues[GV];
|
|
|
|
if (N) return SDOperand(N, 0);
|
2005-08-19 22:31:04 +00:00
|
|
|
N = new GlobalAddressSDNode(false, GV, VT);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getTargetGlobalAddress(const GlobalValue *GV,
|
|
|
|
MVT::ValueType VT) {
|
|
|
|
SDNode *&N = TargetGlobalValues[GV];
|
|
|
|
if (N) return SDOperand(N, 0);
|
|
|
|
N = new GlobalAddressSDNode(true, GV, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getFrameIndex(int FI, MVT::ValueType VT) {
|
|
|
|
SDNode *&N = FrameIndices[FI];
|
|
|
|
if (N) return SDOperand(N, 0);
|
2005-08-25 00:43:01 +00:00
|
|
|
N = new FrameIndexSDNode(FI, VT, false);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getTargetFrameIndex(int FI, MVT::ValueType VT) {
|
|
|
|
SDNode *&N = TargetFrameIndices[FI];
|
|
|
|
if (N) return SDOperand(N, 0);
|
|
|
|
N = new FrameIndexSDNode(FI, VT, true);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-08-26 17:15:30 +00:00
|
|
|
SDOperand SelectionDAG::getConstantPool(Constant *C, MVT::ValueType VT) {
|
|
|
|
SDNode *&N = ConstantPoolIndices[C];
|
2005-01-07 07:46:32 +00:00
|
|
|
if (N) return SDOperand(N, 0);
|
2005-08-26 17:15:30 +00:00
|
|
|
N = new ConstantPoolSDNode(C, VT, false);
|
2005-08-25 05:03:06 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-08-26 17:15:30 +00:00
|
|
|
SDOperand SelectionDAG::getTargetConstantPool(Constant *C, MVT::ValueType VT) {
|
|
|
|
SDNode *&N = TargetConstantPoolIndices[C];
|
2005-08-25 05:03:06 +00:00
|
|
|
if (N) return SDOperand(N, 0);
|
2005-08-26 17:15:30 +00:00
|
|
|
N = new ConstantPoolSDNode(C, VT, true);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getBasicBlock(MachineBasicBlock *MBB) {
|
|
|
|
SDNode *&N = BBNodes[MBB];
|
|
|
|
if (N) return SDOperand(N, 0);
|
|
|
|
N = new BasicBlockSDNode(MBB);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-07-10 00:07:11 +00:00
|
|
|
SDOperand SelectionDAG::getValueType(MVT::ValueType VT) {
|
|
|
|
if ((unsigned)VT >= ValueTypeNodes.size())
|
|
|
|
ValueTypeNodes.resize(VT+1);
|
|
|
|
if (ValueTypeNodes[VT] == 0) {
|
|
|
|
ValueTypeNodes[VT] = new VTSDNode(VT);
|
|
|
|
AllNodes.push_back(ValueTypeNodes[VT]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return SDOperand(ValueTypeNodes[VT], 0);
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getExternalSymbol(const char *Sym, MVT::ValueType VT) {
|
|
|
|
SDNode *&N = ExternalSymbols[Sym];
|
|
|
|
if (N) return SDOperand(N, 0);
|
|
|
|
N = new ExternalSymbolSDNode(Sym, VT);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
SDOperand SelectionDAG::getCondCode(ISD::CondCode Cond) {
|
|
|
|
if ((unsigned)Cond >= CondCodeNodes.size())
|
|
|
|
CondCodeNodes.resize(Cond+1);
|
|
|
|
|
2005-08-09 20:40:02 +00:00
|
|
|
if (CondCodeNodes[Cond] == 0) {
|
2005-08-09 20:20:18 +00:00
|
|
|
CondCodeNodes[Cond] = new CondCodeSDNode(Cond);
|
2005-08-09 20:40:02 +00:00
|
|
|
AllNodes.push_back(CondCodeNodes[Cond]);
|
|
|
|
}
|
2005-08-09 20:20:18 +00:00
|
|
|
return SDOperand(CondCodeNodes[Cond], 0);
|
|
|
|
}
|
|
|
|
|
2005-08-30 22:38:38 +00:00
|
|
|
SDOperand SelectionDAG::getRegister(unsigned RegNo, MVT::ValueType VT) {
|
|
|
|
RegisterSDNode *&Reg = RegNodes[std::make_pair(RegNo, VT)];
|
|
|
|
if (!Reg) {
|
|
|
|
Reg = new RegisterSDNode(RegNo, VT);
|
|
|
|
AllNodes.push_back(Reg);
|
2005-08-16 21:55:35 +00:00
|
|
|
}
|
2005-08-30 22:38:38 +00:00
|
|
|
return SDOperand(Reg, 0);
|
2005-08-16 21:55:35 +00:00
|
|
|
}
|
|
|
|
|
2005-08-09 23:09:05 +00:00
|
|
|
SDOperand SelectionDAG::SimplifySetCC(MVT::ValueType VT, SDOperand N1,
|
|
|
|
SDOperand N2, ISD::CondCode Cond) {
|
2005-01-07 07:46:32 +00:00
|
|
|
// These setcc operations always fold.
|
|
|
|
switch (Cond) {
|
|
|
|
default: break;
|
|
|
|
case ISD::SETFALSE:
|
2005-01-18 02:52:03 +00:00
|
|
|
case ISD::SETFALSE2: return getConstant(0, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::SETTRUE:
|
2005-01-18 02:52:03 +00:00
|
|
|
case ISD::SETTRUE2: return getConstant(1, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.Val)) {
|
|
|
|
uint64_t C2 = N2C->getValue();
|
|
|
|
if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.Val)) {
|
|
|
|
uint64_t C1 = N1C->getValue();
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
// Sign extend the operands if required
|
|
|
|
if (ISD::isSignedIntSetCC(Cond)) {
|
|
|
|
C1 = N1C->getSignExtended();
|
|
|
|
C2 = N2C->getSignExtended();
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (Cond) {
|
|
|
|
default: assert(0 && "Unknown integer setcc!");
|
2005-01-18 02:52:03 +00:00
|
|
|
case ISD::SETEQ: return getConstant(C1 == C2, VT);
|
|
|
|
case ISD::SETNE: return getConstant(C1 != C2, VT);
|
|
|
|
case ISD::SETULT: return getConstant(C1 < C2, VT);
|
|
|
|
case ISD::SETUGT: return getConstant(C1 > C2, VT);
|
|
|
|
case ISD::SETULE: return getConstant(C1 <= C2, VT);
|
|
|
|
case ISD::SETUGE: return getConstant(C1 >= C2, VT);
|
|
|
|
case ISD::SETLT: return getConstant((int64_t)C1 < (int64_t)C2, VT);
|
|
|
|
case ISD::SETGT: return getConstant((int64_t)C1 > (int64_t)C2, VT);
|
|
|
|
case ISD::SETLE: return getConstant((int64_t)C1 <= (int64_t)C2, VT);
|
|
|
|
case ISD::SETGE: return getConstant((int64_t)C1 >= (int64_t)C2, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2005-04-07 18:58:54 +00:00
|
|
|
} else {
|
2005-08-24 22:44:39 +00:00
|
|
|
// If the LHS is a ZERO_EXTEND, perform the comparison on the input.
|
2005-04-18 04:30:45 +00:00
|
|
|
if (N1.getOpcode() == ISD::ZERO_EXTEND) {
|
|
|
|
unsigned InSize = MVT::getSizeInBits(N1.getOperand(0).getValueType());
|
|
|
|
|
|
|
|
// If the comparison constant has bits in the upper part, the
|
|
|
|
// zero-extended value could never match.
|
|
|
|
if (C2 & (~0ULL << InSize)) {
|
|
|
|
unsigned VSize = MVT::getSizeInBits(N1.getValueType());
|
|
|
|
switch (Cond) {
|
|
|
|
case ISD::SETUGT:
|
|
|
|
case ISD::SETUGE:
|
|
|
|
case ISD::SETEQ: return getConstant(0, VT);
|
|
|
|
case ISD::SETULT:
|
|
|
|
case ISD::SETULE:
|
|
|
|
case ISD::SETNE: return getConstant(1, VT);
|
|
|
|
case ISD::SETGT:
|
|
|
|
case ISD::SETGE:
|
|
|
|
// True if the sign bit of C2 is set.
|
|
|
|
return getConstant((C2 & (1ULL << VSize)) != 0, VT);
|
|
|
|
case ISD::SETLT:
|
|
|
|
case ISD::SETLE:
|
|
|
|
// True if the sign bit of C2 isn't set.
|
|
|
|
return getConstant((C2 & (1ULL << VSize)) == 0, VT);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we can perform the comparison with the low bits.
|
|
|
|
switch (Cond) {
|
|
|
|
case ISD::SETEQ:
|
|
|
|
case ISD::SETNE:
|
|
|
|
case ISD::SETUGT:
|
|
|
|
case ISD::SETUGE:
|
|
|
|
case ISD::SETULT:
|
|
|
|
case ISD::SETULE:
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(0),
|
|
|
|
getConstant(C2, N1.getOperand(0).getValueType()),
|
|
|
|
Cond);
|
2005-04-18 04:30:45 +00:00
|
|
|
default:
|
|
|
|
break; // todo, be more careful with signed comparisons
|
|
|
|
}
|
2005-08-24 22:44:39 +00:00
|
|
|
} else if (N1.getOpcode() == ISD::SIGN_EXTEND_INREG &&
|
|
|
|
(Cond == ISD::SETEQ || Cond == ISD::SETNE)) {
|
|
|
|
MVT::ValueType ExtSrcTy = cast<VTSDNode>(N1.getOperand(1))->getVT();
|
|
|
|
unsigned ExtSrcTyBits = MVT::getSizeInBits(ExtSrcTy);
|
|
|
|
MVT::ValueType ExtDstTy = N1.getValueType();
|
|
|
|
unsigned ExtDstTyBits = MVT::getSizeInBits(ExtDstTy);
|
Add support for AssertSext and AssertZext, folding other extensions with
them. This allows for elminination of redundant extends in the entry
blocks of functions on PowerPC.
Add support for i32 x i32 -> i64 multiplies, by recognizing when the inputs
to ISD::MUL in ExpandOp are actually just extended i32 values and not real
i64 values. this allows us to codegen
int mulhs(int a, int b) { return ((long long)a * b) >> 32; }
as:
_mulhs:
mulhw r3, r4, r3
blr
instead of:
_mulhs:
mulhwu r2, r4, r3
srawi r5, r3, 31
mullw r5, r4, r5
add r2, r2, r5
srawi r4, r4, 31
mullw r3, r4, r3
add r3, r2, r3
blr
with a similar improvement on x86.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23147 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-30 02:44:00 +00:00
|
|
|
|
2005-08-24 22:44:39 +00:00
|
|
|
// If the extended part has any inconsistent bits, it cannot ever
|
|
|
|
// compare equal. In other words, they have to be all ones or all
|
|
|
|
// zeros.
|
|
|
|
uint64_t ExtBits =
|
2005-08-31 02:47:06 +00:00
|
|
|
(~0ULL >> (64-ExtSrcTyBits)) & (~0ULL << (ExtDstTyBits-1));
|
2005-08-24 22:44:39 +00:00
|
|
|
if ((C2 & ExtBits) != 0 && (C2 & ExtBits) != ExtBits)
|
|
|
|
return getConstant(Cond == ISD::SETNE, VT);
|
|
|
|
|
|
|
|
// Otherwise, make this a use of a zext.
|
|
|
|
return getSetCC(VT, getZeroExtendInReg(N1.getOperand(0), ExtSrcTy),
|
2005-08-31 02:47:06 +00:00
|
|
|
getConstant(C2 & (~0ULL>>(64-ExtSrcTyBits)), ExtDstTy),
|
2005-08-24 22:44:39 +00:00
|
|
|
Cond);
|
2005-04-18 04:30:45 +00:00
|
|
|
}
|
|
|
|
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
uint64_t MinVal, MaxVal;
|
|
|
|
unsigned OperandBitSize = MVT::getSizeInBits(N2C->getValueType(0));
|
|
|
|
if (ISD::isSignedIntSetCC(Cond)) {
|
|
|
|
MinVal = 1ULL << (OperandBitSize-1);
|
|
|
|
if (OperandBitSize != 1) // Avoid X >> 64, which is undefined.
|
|
|
|
MaxVal = ~0ULL >> (65-OperandBitSize);
|
|
|
|
else
|
|
|
|
MaxVal = 0;
|
|
|
|
} else {
|
|
|
|
MinVal = 0;
|
|
|
|
MaxVal = ~0ULL >> (64-OperandBitSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Canonicalize GE/LE comparisons to use GT/LT comparisons.
|
|
|
|
if (Cond == ISD::SETGE || Cond == ISD::SETUGE) {
|
|
|
|
if (C2 == MinVal) return getConstant(1, VT); // X >= MIN --> true
|
|
|
|
--C2; // X >= C1 --> X > (C1-1)
|
2005-08-09 23:09:05 +00:00
|
|
|
return getSetCC(VT, N1, getConstant(C2, N2.getValueType()),
|
|
|
|
(Cond == ISD::SETGE) ? ISD::SETGT : ISD::SETUGT);
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Cond == ISD::SETLE || Cond == ISD::SETULE) {
|
|
|
|
if (C2 == MaxVal) return getConstant(1, VT); // X <= MAX --> true
|
|
|
|
++C2; // X <= C1 --> X < (C1+1)
|
2005-08-09 23:09:05 +00:00
|
|
|
return getSetCC(VT, N1, getConstant(C2, N2.getValueType()),
|
|
|
|
(Cond == ISD::SETLE) ? ISD::SETLT : ISD::SETULT);
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-04-14 08:56:52 +00:00
|
|
|
if ((Cond == ISD::SETLT || Cond == ISD::SETULT) && C2 == MinVal)
|
|
|
|
return getConstant(0, VT); // X < MIN --> false
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-04-14 08:56:52 +00:00
|
|
|
// Canonicalize setgt X, Min --> setne X, Min
|
|
|
|
if ((Cond == ISD::SETGT || Cond == ISD::SETUGT) && C2 == MinVal)
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1, N2, ISD::SETNE);
|
2005-04-21 22:36:52 +00:00
|
|
|
|
canonicalize x <u 1 -> x == 0. On this testcase:
unsigned long long g;
unsigned long foo (unsigned long a) {
return (a >= g) ? 1 : 0;
}
It changes the ppc code from:
_foo:
.LBB_foo_0: ; entry
mflr r11
stw r11, 8(r1)
bl "L00000$pb"
"L00000$pb":
mflr r2
addis r2, r2, ha16(L_g$non_lazy_ptr-"L00000$pb")
lwz r2, lo16(L_g$non_lazy_ptr-"L00000$pb")(r2)
lwz r4, 0(r2)
lwz r2, 4(r2)
cmplw cr0, r3, r2
li r2, 1
li r3, 0
bge .LBB_foo_2 ; entry
.LBB_foo_1: ; entry
or r2, r3, r3
.LBB_foo_2: ; entry
cmplwi cr0, r4, 1
li r3, 1
li r5, 0
blt .LBB_foo_4 ; entry
.LBB_foo_3: ; entry
or r3, r5, r5
.LBB_foo_4: ; entry
cmpwi cr0, r4, 0
beq .LBB_foo_6 ; entry
.LBB_foo_5: ; entry
or r2, r3, r3
.LBB_foo_6: ; entry
rlwinm r3, r2, 0, 31, 31
lwz r11, 8(r1)
mtlr r11
blr
to:
_foo:
.LBB_foo_0: ; entry
mflr r11
stw r11, 8(r1)
bl "L00000$pb"
"L00000$pb":
mflr r2
addis r2, r2, ha16(L_g$non_lazy_ptr-"L00000$pb")
lwz r2, lo16(L_g$non_lazy_ptr-"L00000$pb")(r2)
lwz r4, 0(r2)
lwz r2, 4(r2)
cmplw cr0, r3, r2
li r2, 1
li r3, 0
bge .LBB_foo_2 ; entry
.LBB_foo_1: ; entry
or r2, r3, r3
.LBB_foo_2: ; entry
cntlzw r3, r4
srwi r3, r3, 5
cmpwi cr0, r4, 0
beq .LBB_foo_4 ; entry
.LBB_foo_3: ; entry
or r2, r3, r3
.LBB_foo_4: ; entry
rlwinm r3, r2, 0, 31, 31
lwz r11, 8(r1)
mtlr r11
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21241 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-12 00:28:49 +00:00
|
|
|
// If we have setult X, 1, turn it into seteq X, 0
|
|
|
|
if ((Cond == ISD::SETLT || Cond == ISD::SETULT) && C2 == MinVal+1)
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1, getConstant(MinVal, N1.getValueType()),
|
|
|
|
ISD::SETEQ);
|
2005-04-14 08:56:52 +00:00
|
|
|
// If we have setugt X, Max-1, turn it into seteq X, Max
|
canonicalize x <u 1 -> x == 0. On this testcase:
unsigned long long g;
unsigned long foo (unsigned long a) {
return (a >= g) ? 1 : 0;
}
It changes the ppc code from:
_foo:
.LBB_foo_0: ; entry
mflr r11
stw r11, 8(r1)
bl "L00000$pb"
"L00000$pb":
mflr r2
addis r2, r2, ha16(L_g$non_lazy_ptr-"L00000$pb")
lwz r2, lo16(L_g$non_lazy_ptr-"L00000$pb")(r2)
lwz r4, 0(r2)
lwz r2, 4(r2)
cmplw cr0, r3, r2
li r2, 1
li r3, 0
bge .LBB_foo_2 ; entry
.LBB_foo_1: ; entry
or r2, r3, r3
.LBB_foo_2: ; entry
cmplwi cr0, r4, 1
li r3, 1
li r5, 0
blt .LBB_foo_4 ; entry
.LBB_foo_3: ; entry
or r3, r5, r5
.LBB_foo_4: ; entry
cmpwi cr0, r4, 0
beq .LBB_foo_6 ; entry
.LBB_foo_5: ; entry
or r2, r3, r3
.LBB_foo_6: ; entry
rlwinm r3, r2, 0, 31, 31
lwz r11, 8(r1)
mtlr r11
blr
to:
_foo:
.LBB_foo_0: ; entry
mflr r11
stw r11, 8(r1)
bl "L00000$pb"
"L00000$pb":
mflr r2
addis r2, r2, ha16(L_g$non_lazy_ptr-"L00000$pb")
lwz r2, lo16(L_g$non_lazy_ptr-"L00000$pb")(r2)
lwz r4, 0(r2)
lwz r2, 4(r2)
cmplw cr0, r3, r2
li r2, 1
li r3, 0
bge .LBB_foo_2 ; entry
.LBB_foo_1: ; entry
or r2, r3, r3
.LBB_foo_2: ; entry
cntlzw r3, r4
srwi r3, r3, 5
cmpwi cr0, r4, 0
beq .LBB_foo_4 ; entry
.LBB_foo_3: ; entry
or r2, r3, r3
.LBB_foo_4: ; entry
rlwinm r3, r2, 0, 31, 31
lwz r11, 8(r1)
mtlr r11
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21241 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-12 00:28:49 +00:00
|
|
|
else if ((Cond == ISD::SETGT || Cond == ISD::SETUGT) && C2 == MaxVal-1)
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1, getConstant(MaxVal, N1.getValueType()),
|
|
|
|
ISD::SETEQ);
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
|
|
|
|
// If we have "setcc X, C1", check to see if we can shrink the immediate
|
|
|
|
// by changing cc.
|
|
|
|
|
|
|
|
// SETUGT X, SINTMAX -> SETLT X, 0
|
|
|
|
if (Cond == ISD::SETUGT && OperandBitSize != 1 &&
|
|
|
|
C2 == (~0ULL >> (65-OperandBitSize)))
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1, getConstant(0, N2.getValueType()), ISD::SETLT);
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
|
|
|
|
// FIXME: Implement the rest of these.
|
|
|
|
|
Fold (x & 8) != 0 and (x & 8) == 8 into (x & 8) >> 3.
This turns this PPC code:
rlwinm r2, r3, 0, 28, 28
cmpwi cr7, r2, 8
mfcr r2
rlwinm r3, r2, 31, 31, 31
into this:
rlwinm r2, r3, 0, 28, 28
srwi r2, r2, 3
rlwinm r3, r2, 0, 31, 31
Next up, nuking the extra and.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21390 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-21 06:12:41 +00:00
|
|
|
|
|
|
|
// Fold bit comparisons when we can.
|
|
|
|
if ((Cond == ISD::SETEQ || Cond == ISD::SETNE) &&
|
|
|
|
VT == N1.getValueType() && N1.getOpcode() == ISD::AND)
|
|
|
|
if (ConstantSDNode *AndRHS =
|
|
|
|
dyn_cast<ConstantSDNode>(N1.getOperand(1))) {
|
|
|
|
if (Cond == ISD::SETNE && C2 == 0) {// (X & 8) != 0 --> (X & 8) >> 3
|
|
|
|
// Perform the xform if the AND RHS is a single bit.
|
|
|
|
if ((AndRHS->getValue() & (AndRHS->getValue()-1)) == 0) {
|
|
|
|
return getNode(ISD::SRL, VT, N1,
|
2005-08-02 19:26:06 +00:00
|
|
|
getConstant(Log2_64(AndRHS->getValue()),
|
Fold (x & 8) != 0 and (x & 8) == 8 into (x & 8) >> 3.
This turns this PPC code:
rlwinm r2, r3, 0, 28, 28
cmpwi cr7, r2, 8
mfcr r2
rlwinm r3, r2, 31, 31, 31
into this:
rlwinm r2, r3, 0, 28, 28
srwi r2, r2, 3
rlwinm r3, r2, 0, 31, 31
Next up, nuking the extra and.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21390 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-21 06:12:41 +00:00
|
|
|
TLI.getShiftAmountTy()));
|
|
|
|
}
|
|
|
|
} else if (Cond == ISD::SETEQ && C2 == AndRHS->getValue()) {
|
|
|
|
// (X & 8) == 8 --> (X & 8) >> 3
|
|
|
|
// Perform the xform if C2 is a single bit.
|
|
|
|
if ((C2 & (C2-1)) == 0) {
|
|
|
|
return getNode(ISD::SRL, VT, N1,
|
2005-08-02 19:26:06 +00:00
|
|
|
getConstant(Log2_64(C2),TLI.getShiftAmountTy()));
|
Fold (x & 8) != 0 and (x & 8) == 8 into (x & 8) >> 3.
This turns this PPC code:
rlwinm r2, r3, 0, 28, 28
cmpwi cr7, r2, 8
mfcr r2
rlwinm r3, r2, 31, 31, 31
into this:
rlwinm r2, r3, 0, 28, 28
srwi r2, r2, 3
rlwinm r3, r2, 0, 31, 31
Next up, nuking the extra and.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21390 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-21 06:12:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
} else if (isa<ConstantSDNode>(N1.Val)) {
|
|
|
|
// Ensure that the constant occurs on the RHS.
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N2, N1, ISD::getSetCCSwappedOperands(Cond));
|
This patch does two things. First, it canonicalizes 'X >= C' -> 'X > C-1'
(likewise for <= >=u >=u).
Second, it implements a special case hack to turn 'X gtu SINTMAX' -> 'X lt 0'
On powerpc, for example, this changes this:
lis r2, 32767
ori r2, r2, 65535
cmplw cr0, r3, r2
bgt .LBB_test_2
into:
cmpwi cr0, r3, 0
blt .LBB_test_2
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21142 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 18:14:58 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
|
|
|
|
if (ConstantFPSDNode *N1C = dyn_cast<ConstantFPSDNode>(N1.Val))
|
|
|
|
if (ConstantFPSDNode *N2C = dyn_cast<ConstantFPSDNode>(N2.Val)) {
|
|
|
|
double C1 = N1C->getValue(), C2 = N2C->getValue();
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
switch (Cond) {
|
|
|
|
default: break; // FIXME: Implement the rest of these!
|
2005-01-18 02:52:03 +00:00
|
|
|
case ISD::SETEQ: return getConstant(C1 == C2, VT);
|
|
|
|
case ISD::SETNE: return getConstant(C1 != C2, VT);
|
|
|
|
case ISD::SETLT: return getConstant(C1 < C2, VT);
|
|
|
|
case ISD::SETGT: return getConstant(C1 > C2, VT);
|
|
|
|
case ISD::SETLE: return getConstant(C1 <= C2, VT);
|
|
|
|
case ISD::SETGE: return getConstant(C1 >= C2, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Ensure that the constant occurs on the RHS.
|
2005-08-09 23:09:05 +00:00
|
|
|
return getSetCC(VT, N2, N1, ISD::getSetCCSwappedOperands(Cond));
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (N1 == N2) {
|
|
|
|
// We can always fold X == Y for integer setcc's.
|
|
|
|
if (MVT::isInteger(N1.getValueType()))
|
2005-01-18 02:52:03 +00:00
|
|
|
return getConstant(ISD::isTrueWhenEqual(Cond), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
unsigned UOF = ISD::getUnorderedFlavor(Cond);
|
|
|
|
if (UOF == 2) // FP operators that are undefined on NaNs.
|
2005-01-18 02:52:03 +00:00
|
|
|
return getConstant(ISD::isTrueWhenEqual(Cond), VT);
|
2005-05-10 02:22:38 +00:00
|
|
|
if (UOF == unsigned(ISD::isTrueWhenEqual(Cond)))
|
2005-01-18 02:52:03 +00:00
|
|
|
return getConstant(UOF, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
// Otherwise, we can't fold it. However, we can simplify it to SETUO/SETO
|
|
|
|
// if it is not already.
|
2005-08-09 23:09:05 +00:00
|
|
|
ISD::CondCode NewCond = UOF == 0 ? ISD::SETUO : ISD::SETO;
|
|
|
|
if (NewCond != Cond)
|
|
|
|
return getSetCC(VT, N1, N2, NewCond);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
Add some folds for == and != comparisons. This allows us to
codegen this loop in stepanov:
no_exit.i: ; preds = %entry, %no_exit.i, %then.i, %_Z5checkd.exit
%i.0.0 = phi int [ 0, %entry ], [ %i.0.0, %no_exit.i ], [ %inc.0, %_Z5checkd.exit ], [ %inc.012, %then.i ] ; <int> [#uses=3]
%indvar = phi uint [ %indvar.next, %no_exit.i ], [ 0, %entry ], [ 0, %then.i ], [ 0, %_Z5checkd.exit ] ; <uint> [#uses=3]
%result_addr.i.0 = phi double [ %tmp.4.i.i, %no_exit.i ], [ 0.000000e+00, %entry ], [ 0.000000e+00, %then.i ], [ 0.000000e+00, %_Z5checkd.exit ] ; <double> [#uses=1]
%first_addr.0.i.2.rec = cast uint %indvar to int ; <int> [#uses=1]
%first_addr.0.i.2 = getelementptr [2000 x double]* %data, int 0, uint %indvar ; <double*> [#uses=1]
%inc.i.rec = add int %first_addr.0.i.2.rec, 1 ; <int> [#uses=1]
%inc.i = getelementptr [2000 x double]* %data, int 0, int %inc.i.rec ; <double*> [#uses=1]
%tmp.3.i.i = load double* %first_addr.0.i.2 ; <double> [#uses=1]
%tmp.4.i.i = add double %result_addr.i.0, %tmp.3.i.i ; <double> [#uses=2]
%tmp.2.i = seteq double* %inc.i, getelementptr ([2000 x double]* %data, int 0, int 2000) ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1 ; <uint> [#uses=1]
br bool %tmp.2.i, label %_Z10accumulateIPddET0_T_S2_S1_.exit, label %no_exit.i
To this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
movl %eax, %ecx
shll $3, %ecx
cmpl $16000, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
instead of this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
leal data(,%eax,8), %ecx
leal data+16000, %edx
cmpl %edx, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19425 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:52:51 +00:00
|
|
|
if ((Cond == ISD::SETEQ || Cond == ISD::SETNE) &&
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
MVT::isInteger(N1.getValueType())) {
|
|
|
|
if (N1.getOpcode() == ISD::ADD || N1.getOpcode() == ISD::SUB ||
|
|
|
|
N1.getOpcode() == ISD::XOR) {
|
|
|
|
// Simplify (X+Y) == (X+Z) --> Y == Z
|
|
|
|
if (N1.getOpcode() == N2.getOpcode()) {
|
|
|
|
if (N1.getOperand(0) == N2.getOperand(0))
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(1), N2.getOperand(1), Cond);
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
if (N1.getOperand(1) == N2.getOperand(1))
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(0), N2.getOperand(0), Cond);
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
if (isCommutativeBinOp(N1.getOpcode())) {
|
|
|
|
// If X op Y == Y op X, try other combinations.
|
|
|
|
if (N1.getOperand(0) == N2.getOperand(1))
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(1), N2.getOperand(0), Cond);
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
if (N1.getOperand(1) == N2.getOperand(0))
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(1), N2.getOperand(1), Cond);
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
}
|
|
|
|
}
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
|
|
|
|
// FIXME: move this stuff to the DAG Combiner when it exists!
|
2005-04-21 22:36:52 +00:00
|
|
|
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
// Simplify (X+Z) == X --> Z == 0
|
|
|
|
if (N1.getOperand(0) == N2)
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(1),
|
|
|
|
getConstant(0, N1.getValueType()), Cond);
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
if (N1.getOperand(1) == N2) {
|
|
|
|
if (isCommutativeBinOp(N1.getOpcode()))
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(0),
|
|
|
|
getConstant(0, N1.getValueType()), Cond);
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
else {
|
|
|
|
assert(N1.getOpcode() == ISD::SUB && "Unexpected operation!");
|
|
|
|
// (Z-X) == X --> Z == X<<1
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N1.getOperand(0),
|
2005-04-21 22:36:52 +00:00
|
|
|
getNode(ISD::SHL, N2.getValueType(),
|
2005-08-09 20:20:18 +00:00
|
|
|
N2, getConstant(1, TLI.getShiftAmountTy())),
|
|
|
|
Cond);
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
}
|
Add some folds for == and != comparisons. This allows us to
codegen this loop in stepanov:
no_exit.i: ; preds = %entry, %no_exit.i, %then.i, %_Z5checkd.exit
%i.0.0 = phi int [ 0, %entry ], [ %i.0.0, %no_exit.i ], [ %inc.0, %_Z5checkd.exit ], [ %inc.012, %then.i ] ; <int> [#uses=3]
%indvar = phi uint [ %indvar.next, %no_exit.i ], [ 0, %entry ], [ 0, %then.i ], [ 0, %_Z5checkd.exit ] ; <uint> [#uses=3]
%result_addr.i.0 = phi double [ %tmp.4.i.i, %no_exit.i ], [ 0.000000e+00, %entry ], [ 0.000000e+00, %then.i ], [ 0.000000e+00, %_Z5checkd.exit ] ; <double> [#uses=1]
%first_addr.0.i.2.rec = cast uint %indvar to int ; <int> [#uses=1]
%first_addr.0.i.2 = getelementptr [2000 x double]* %data, int 0, uint %indvar ; <double*> [#uses=1]
%inc.i.rec = add int %first_addr.0.i.2.rec, 1 ; <int> [#uses=1]
%inc.i = getelementptr [2000 x double]* %data, int 0, int %inc.i.rec ; <double*> [#uses=1]
%tmp.3.i.i = load double* %first_addr.0.i.2 ; <double> [#uses=1]
%tmp.4.i.i = add double %result_addr.i.0, %tmp.3.i.i ; <double> [#uses=2]
%tmp.2.i = seteq double* %inc.i, getelementptr ([2000 x double]* %data, int 0, int 2000) ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1 ; <uint> [#uses=1]
br bool %tmp.2.i, label %_Z10accumulateIPddET0_T_S2_S1_.exit, label %no_exit.i
To this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
movl %eax, %ecx
shll $3, %ecx
cmpl $16000, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
instead of this:
.LBB_Z4testIPddEvT_S1_T0__1: # no_exit.i
fldl data(,%eax,8)
fldl 16(%esp)
faddp %st(1)
fstpl 16(%esp)
incl %eax
leal data(,%eax,8), %ecx
leal data+16000, %edx
cmpl %edx, %ecx
#FP_REG_KILL
jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19425 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:52:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
if (N2.getOpcode() == ISD::ADD || N2.getOpcode() == ISD::SUB ||
|
|
|
|
N2.getOpcode() == ISD::XOR) {
|
|
|
|
// Simplify X == (X+Z) --> Z == 0
|
2005-08-10 17:37:53 +00:00
|
|
|
if (N2.getOperand(0) == N1) {
|
2005-08-09 20:20:18 +00:00
|
|
|
return getSetCC(VT, N2.getOperand(1),
|
|
|
|
getConstant(0, N2.getValueType()), Cond);
|
2005-08-10 17:37:53 +00:00
|
|
|
} else if (N2.getOperand(1) == N1) {
|
|
|
|
if (isCommutativeBinOp(N2.getOpcode())) {
|
|
|
|
return getSetCC(VT, N2.getOperand(0),
|
|
|
|
getConstant(0, N2.getValueType()), Cond);
|
|
|
|
} else {
|
|
|
|
assert(N2.getOpcode() == ISD::SUB && "Unexpected operation!");
|
|
|
|
// X == (Z-X) --> X<<1 == Z
|
|
|
|
return getSetCC(VT, getNode(ISD::SHL, N2.getValueType(), N1,
|
|
|
|
getConstant(1, TLI.getShiftAmountTy())),
|
|
|
|
N2.getOperand(0), Cond);
|
|
|
|
}
|
|
|
|
}
|
Implement a couple of more simplifications. This lets us codegen:
int test2(int * P, int* Q, int A, int B) {
return P+A == P;
}
into:
test2:
movl 4(%esp), %eax
movl 12(%esp), %eax
shll $2, %eax
cmpl $0, %eax
sete %al
movzbl %al, %eax
ret
instead of:
test2:
movl 4(%esp), %eax
movl 12(%esp), %ecx
leal (%eax,%ecx,4), %ecx
cmpl %eax, %ecx
sete %al
movzbl %al, %eax
ret
ICC is producing worse code:
test2:
movl 4(%esp), %eax #8.5
movl 12(%esp), %edx #8.5
lea (%edx,%edx), %ecx #9.9
addl %ecx, %ecx #9.9
addl %eax, %ecx #9.9
cmpl %eax, %ecx #9.16
movl $0, %eax #9.16
sete %al #9.16
ret #9.16
as is GCC (looks like our old code):
test2:
movl 4(%esp), %edx
movl 12(%esp), %eax
leal (%edx,%eax,4), %ecx
cmpl %edx, %ecx
sete %al
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19430 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-10 02:03:02 +00:00
|
|
|
}
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
|
2005-04-18 04:48:12 +00:00
|
|
|
// Fold away ALL boolean setcc's.
|
|
|
|
if (N1.getValueType() == MVT::i1) {
|
|
|
|
switch (Cond) {
|
|
|
|
default: assert(0 && "Unknown integer setcc!");
|
|
|
|
case ISD::SETEQ: // X == Y -> (X^Y)^1
|
|
|
|
N1 = getNode(ISD::XOR, MVT::i1,
|
|
|
|
getNode(ISD::XOR, MVT::i1, N1, N2),
|
|
|
|
getConstant(1, MVT::i1));
|
|
|
|
break;
|
|
|
|
case ISD::SETNE: // X != Y --> (X^Y)
|
|
|
|
N1 = getNode(ISD::XOR, MVT::i1, N1, N2);
|
|
|
|
break;
|
|
|
|
case ISD::SETGT: // X >s Y --> X == 0 & Y == 1 --> X^1 & Y
|
|
|
|
case ISD::SETULT: // X <u Y --> X == 0 & Y == 1 --> X^1 & Y
|
|
|
|
N1 = getNode(ISD::AND, MVT::i1, N2,
|
|
|
|
getNode(ISD::XOR, MVT::i1, N1, getConstant(1, MVT::i1)));
|
|
|
|
break;
|
|
|
|
case ISD::SETLT: // X <s Y --> X == 1 & Y == 0 --> Y^1 & X
|
|
|
|
case ISD::SETUGT: // X >u Y --> X == 1 & Y == 0 --> Y^1 & X
|
|
|
|
N1 = getNode(ISD::AND, MVT::i1, N1,
|
|
|
|
getNode(ISD::XOR, MVT::i1, N2, getConstant(1, MVT::i1)));
|
|
|
|
break;
|
|
|
|
case ISD::SETULE: // X <=u Y --> X == 0 | Y == 1 --> X^1 | Y
|
|
|
|
case ISD::SETGE: // X >=s Y --> X == 0 | Y == 1 --> X^1 | Y
|
|
|
|
N1 = getNode(ISD::OR, MVT::i1, N2,
|
|
|
|
getNode(ISD::XOR, MVT::i1, N1, getConstant(1, MVT::i1)));
|
|
|
|
break;
|
|
|
|
case ISD::SETUGE: // X >=u Y --> X == 1 | Y == 0 --> Y^1 | X
|
|
|
|
case ISD::SETLE: // X <=s Y --> X == 1 | Y == 0 --> Y^1 | X
|
|
|
|
N1 = getNode(ISD::OR, MVT::i1, N1,
|
|
|
|
getNode(ISD::XOR, MVT::i1, N2, getConstant(1, MVT::i1)));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (VT != MVT::i1)
|
|
|
|
N1 = getNode(ISD::ZERO_EXTEND, VT, N1);
|
|
|
|
return N1;
|
|
|
|
}
|
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
// Could not fold it.
|
|
|
|
return SDOperand();
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2005-08-13 06:14:17 +00:00
|
|
|
SDOperand SelectionDAG::SimplifySelectCC(SDOperand N1, SDOperand N2,
|
|
|
|
SDOperand N3, SDOperand N4,
|
|
|
|
ISD::CondCode CC) {
|
|
|
|
MVT::ValueType VT = N3.getValueType();
|
2005-08-25 20:04:38 +00:00
|
|
|
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.Val);
|
2005-08-13 06:00:21 +00:00
|
|
|
ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.Val);
|
|
|
|
ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N3.Val);
|
|
|
|
ConstantSDNode *N4C = dyn_cast<ConstantSDNode>(N4.Val);
|
|
|
|
|
|
|
|
// Check to see if we can simplify the select into an fabs node
|
|
|
|
if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(N2)) {
|
|
|
|
// Allow either -0.0 or 0.0
|
|
|
|
if (CFP->getValue() == 0.0) {
|
|
|
|
// select (setg[te] X, +/-0.0), X, fneg(X) -> fabs
|
|
|
|
if ((CC == ISD::SETGE || CC == ISD::SETGT) &&
|
|
|
|
N1 == N3 && N4.getOpcode() == ISD::FNEG &&
|
|
|
|
N1 == N4.getOperand(0))
|
|
|
|
return getNode(ISD::FABS, VT, N1);
|
|
|
|
|
|
|
|
// select (setl[te] X, +/-0.0), fneg(X), X -> fabs
|
|
|
|
if ((CC == ISD::SETLT || CC == ISD::SETLE) &&
|
|
|
|
N1 == N4 && N3.getOpcode() == ISD::FNEG &&
|
|
|
|
N3.getOperand(0) == N4)
|
|
|
|
return getNode(ISD::FABS, VT, N4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-25 20:04:38 +00:00
|
|
|
// check to see if we're select_cc'ing a select_cc.
|
|
|
|
// this allows us to turn:
|
|
|
|
// select_cc set[eq,ne] (select_cc cc, lhs, rhs, 1, 0), 0, true, false ->
|
|
|
|
// select_cc cc, lhs, rhs, true, false
|
|
|
|
if ((N1C && N1C->isNullValue() && N2.getOpcode() == ISD::SELECT_CC) ||
|
|
|
|
(N2C && N2C->isNullValue() && N1.getOpcode() == ISD::SELECT_CC) &&
|
|
|
|
(CC == ISD::SETEQ || CC == ISD::SETNE)) {
|
|
|
|
SDOperand SCC = N1C ? N2 : N1;
|
|
|
|
ConstantSDNode *SCCT = dyn_cast<ConstantSDNode>(SCC.getOperand(2));
|
|
|
|
ConstantSDNode *SCCF = dyn_cast<ConstantSDNode>(SCC.getOperand(3));
|
|
|
|
if (SCCT && SCCF && SCCF->isNullValue() && SCCT->getValue() == 1ULL) {
|
|
|
|
if (CC == ISD::SETEQ) std::swap(N3, N4);
|
|
|
|
return getNode(ISD::SELECT_CC, N3.getValueType(), SCC.getOperand(0),
|
|
|
|
SCC.getOperand(1), N3, N4, SCC.getOperand(4));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-13 06:00:21 +00:00
|
|
|
// Check to see if we can perform the "gzip trick", transforming
|
|
|
|
// select_cc setlt X, 0, A, 0 -> and (sra X, size(X)-1), A
|
|
|
|
if (N2C && N2C->isNullValue() && N4C && N4C->isNullValue() &&
|
|
|
|
MVT::isInteger(N1.getValueType()) &&
|
|
|
|
MVT::isInteger(N3.getValueType()) && CC == ISD::SETLT) {
|
|
|
|
MVT::ValueType XType = N1.getValueType();
|
|
|
|
MVT::ValueType AType = N3.getValueType();
|
|
|
|
if (XType >= AType) {
|
|
|
|
// and (sra X, size(X)-1, A) -> "and (srl X, C2), A" iff A is a
|
|
|
|
// single-bit constant. FIXME: remove once the dag combiner
|
|
|
|
// exists.
|
|
|
|
if (N3C && ((N3C->getValue() & (N3C->getValue()-1)) == 0)) {
|
|
|
|
unsigned ShCtV = Log2_64(N3C->getValue());
|
|
|
|
ShCtV = MVT::getSizeInBits(XType)-ShCtV-1;
|
|
|
|
SDOperand ShCt = getConstant(ShCtV, TLI.getShiftAmountTy());
|
|
|
|
SDOperand Shift = getNode(ISD::SRL, XType, N1, ShCt);
|
|
|
|
if (XType > AType)
|
|
|
|
Shift = getNode(ISD::TRUNCATE, AType, Shift);
|
|
|
|
return getNode(ISD::AND, AType, Shift, N3);
|
|
|
|
}
|
|
|
|
SDOperand Shift = getNode(ISD::SRA, XType, N1,
|
|
|
|
getConstant(MVT::getSizeInBits(XType)-1,
|
|
|
|
TLI.getShiftAmountTy()));
|
|
|
|
if (XType > AType)
|
|
|
|
Shift = getNode(ISD::TRUNCATE, AType, Shift);
|
|
|
|
return getNode(ISD::AND, AType, Shift, N3);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-25 20:04:38 +00:00
|
|
|
// Check to see if this is the equivalent of setcc
|
2005-08-24 04:57:57 +00:00
|
|
|
if (N4C && N4C->isNullValue() && N3C && (N3C->getValue() == 1ULL)) {
|
2005-08-23 05:41:12 +00:00
|
|
|
MVT::ValueType XType = N1.getValueType();
|
2005-09-09 23:00:07 +00:00
|
|
|
if (TLI.isOperationLegal(ISD::SETCC, TLI.getSetCCResultTy())) {
|
|
|
|
SDOperand Res = getSetCC(TLI.getSetCCResultTy(), N1, N2, CC);
|
|
|
|
if (Res.getValueType() != VT)
|
|
|
|
Res = getNode(ISD::ZERO_EXTEND, VT, Res);
|
|
|
|
return Res;
|
|
|
|
}
|
2005-08-25 17:54:58 +00:00
|
|
|
|
2005-08-24 04:57:57 +00:00
|
|
|
// seteq X, 0 -> srl (ctlz X, log2(size(X)))
|
|
|
|
if (N2C && N2C->isNullValue() && CC == ISD::SETEQ &&
|
2005-08-25 17:54:58 +00:00
|
|
|
TLI.isOperationLegal(ISD::CTLZ, XType)) {
|
2005-08-23 05:41:12 +00:00
|
|
|
SDOperand Ctlz = getNode(ISD::CTLZ, XType, N1);
|
|
|
|
return getNode(ISD::SRL, XType, Ctlz,
|
2005-08-24 00:21:28 +00:00
|
|
|
getConstant(Log2_32(MVT::getSizeInBits(XType)),
|
2005-08-23 05:41:12 +00:00
|
|
|
TLI.getShiftAmountTy()));
|
|
|
|
}
|
2005-08-24 04:57:57 +00:00
|
|
|
// setgt X, 0 -> srl (and (-X, ~X), size(X)-1)
|
|
|
|
if (N2C && N2C->isNullValue() && CC == ISD::SETGT) {
|
|
|
|
SDOperand NegN1 = getNode(ISD::SUB, XType, getConstant(0, XType), N1);
|
|
|
|
SDOperand NotN1 = getNode(ISD::XOR, XType, N1, getConstant(~0ULL, XType));
|
|
|
|
return getNode(ISD::SRL, XType, getNode(ISD::AND, XType, NegN1, NotN1),
|
|
|
|
getConstant(MVT::getSizeInBits(XType)-1,
|
|
|
|
TLI.getShiftAmountTy()));
|
|
|
|
}
|
|
|
|
// setgt X, -1 -> xor (srl (X, size(X)-1), 1)
|
|
|
|
if (N2C && N2C->isAllOnesValue() && CC == ISD::SETGT) {
|
|
|
|
SDOperand Sign = getNode(ISD::SRL, XType, N1,
|
|
|
|
getConstant(MVT::getSizeInBits(XType)-1,
|
|
|
|
TLI.getShiftAmountTy()));
|
|
|
|
return getNode(ISD::XOR, XType, Sign, getConstant(1, XType));
|
|
|
|
}
|
2005-08-23 05:41:12 +00:00
|
|
|
}
|
|
|
|
|
2005-08-13 06:00:21 +00:00
|
|
|
// Check to see if this is an integer abs. select_cc setl[te] X, 0, -X, X ->
|
|
|
|
// Y = sra (X, size(X)-1); xor (add (X, Y), Y)
|
|
|
|
if (N2C && N2C->isNullValue() && (CC == ISD::SETLT || CC == ISD::SETLE) &&
|
|
|
|
N1 == N4 && N3.getOpcode() == ISD::SUB && N1 == N3.getOperand(1)) {
|
|
|
|
if (ConstantSDNode *SubC = dyn_cast<ConstantSDNode>(N3.getOperand(0))) {
|
|
|
|
MVT::ValueType XType = N1.getValueType();
|
|
|
|
if (SubC->isNullValue() && MVT::isInteger(XType)) {
|
|
|
|
SDOperand Shift = getNode(ISD::SRA, XType, N1,
|
|
|
|
getConstant(MVT::getSizeInBits(XType)-1,
|
|
|
|
TLI.getShiftAmountTy()));
|
|
|
|
return getNode(ISD::XOR, XType, getNode(ISD::ADD, XType, N1, Shift),
|
|
|
|
Shift);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Could not fold it.
|
|
|
|
return SDOperand();
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
/// getNode - Gets or creates the specified node.
|
2003-08-11 14:57:33 +00:00
|
|
|
///
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT) {
|
2005-09-02 19:36:17 +00:00
|
|
|
SDNode *&N = NullaryOps[std::make_pair(Opcode, VT)];
|
|
|
|
if (!N) {
|
|
|
|
N = new SDNode(Opcode, VT);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
|
|
|
|
SDOperand Operand) {
|
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Operand.Val)) {
|
|
|
|
uint64_t Val = C->getValue();
|
|
|
|
switch (Opcode) {
|
|
|
|
default: break;
|
|
|
|
case ISD::SIGN_EXTEND: return getConstant(C->getSignExtended(), VT);
|
2005-09-02 00:17:32 +00:00
|
|
|
case ISD::ANY_EXTEND:
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::ZERO_EXTEND: return getConstant(Val, VT);
|
|
|
|
case ISD::TRUNCATE: return getConstant(Val, VT);
|
2005-01-08 08:08:56 +00:00
|
|
|
case ISD::SINT_TO_FP: return getConstantFP(C->getSignExtended(), VT);
|
|
|
|
case ISD::UINT_TO_FP: return getConstantFP(C->getValue(), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Operand.Val))
|
|
|
|
switch (Opcode) {
|
2005-04-09 03:02:46 +00:00
|
|
|
case ISD::FNEG:
|
|
|
|
return getConstantFP(-C->getValue(), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::FP_ROUND:
|
|
|
|
case ISD::FP_EXTEND:
|
|
|
|
return getConstantFP(C->getValue(), VT);
|
2005-01-08 08:08:56 +00:00
|
|
|
case ISD::FP_TO_SINT:
|
|
|
|
return getConstant((int64_t)C->getValue(), VT);
|
|
|
|
case ISD::FP_TO_UINT:
|
|
|
|
return getConstant((uint64_t)C->getValue(), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned OpOpcode = Operand.Val->getOpcode();
|
|
|
|
switch (Opcode) {
|
2005-01-21 18:01:22 +00:00
|
|
|
case ISD::TokenFactor:
|
|
|
|
return Operand; // Factor of one node? No factor.
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::SIGN_EXTEND:
|
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop extension
|
|
|
|
if (OpOpcode == ISD::SIGN_EXTEND || OpOpcode == ISD::ZERO_EXTEND)
|
|
|
|
return getNode(OpOpcode, VT, Operand.Val->getOperand(0));
|
|
|
|
break;
|
|
|
|
case ISD::ZERO_EXTEND:
|
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop extension
|
If a target zero or sign extends the result of its setcc, allow folding of
this into sign/zero extension instructions later.
On PPC, for example, this testcase:
%G = external global sbyte
implementation
void %test(int %X, int %Y) {
%C = setlt int %X, %Y
%D = cast bool %C to sbyte
store sbyte %D, sbyte* %G
ret void
}
Now codegens to:
cmpw cr0, r3, r4
li r3, 1
li r4, 0
blt .LBB_test_2 ;
.LBB_test_1: ;
or r3, r4, r4
.LBB_test_2: ;
addis r2, r2, ha16(L_G$non_lazy_ptr-"L00000$pb")
lwz r2, lo16(L_G$non_lazy_ptr-"L00000$pb")(r2)
stb r3, 0(r2)
instead of:
cmpw cr0, r3, r4
li r3, 1
li r4, 0
blt .LBB_test_2 ;
.LBB_test_1: ;
or r3, r4, r4
.LBB_test_2: ;
*** rlwinm r3, r3, 0, 31, 31
addis r2, r2, ha16(L_G$non_lazy_ptr-"L00000$pb")
lwz r2, lo16(L_G$non_lazy_ptr-"L00000$pb")(r2)
stb r3, 0(r2)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21148 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-07 19:43:53 +00:00
|
|
|
if (OpOpcode == ISD::ZERO_EXTEND) // (zext (zext x)) -> (zext x)
|
2005-01-12 18:51:15 +00:00
|
|
|
return getNode(ISD::ZERO_EXTEND, VT, Operand.Val->getOperand(0));
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
2005-09-02 00:17:32 +00:00
|
|
|
case ISD::ANY_EXTEND:
|
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop extension
|
|
|
|
if (OpOpcode == ISD::ZERO_EXTEND || OpOpcode == ISD::SIGN_EXTEND)
|
|
|
|
// (ext (zext x)) -> (zext x) and (ext (sext x)) -> (sext x)
|
|
|
|
return getNode(OpOpcode, VT, Operand.Val->getOperand(0));
|
|
|
|
break;
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::TRUNCATE:
|
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop truncate
|
|
|
|
if (OpOpcode == ISD::TRUNCATE)
|
|
|
|
return getNode(ISD::TRUNCATE, VT, Operand.Val->getOperand(0));
|
2005-09-02 00:17:32 +00:00
|
|
|
else if (OpOpcode == ISD::ZERO_EXTEND || OpOpcode == ISD::SIGN_EXTEND ||
|
|
|
|
OpOpcode == ISD::ANY_EXTEND) {
|
2005-01-07 21:56:24 +00:00
|
|
|
// If the source is smaller than the dest, we still need an extend.
|
|
|
|
if (Operand.Val->getOperand(0).getValueType() < VT)
|
|
|
|
return getNode(OpOpcode, VT, Operand.Val->getOperand(0));
|
|
|
|
else if (Operand.Val->getOperand(0).getValueType() > VT)
|
|
|
|
return getNode(ISD::TRUNCATE, VT, Operand.Val->getOperand(0));
|
|
|
|
else
|
|
|
|
return Operand.Val->getOperand(0);
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
2005-04-09 03:02:46 +00:00
|
|
|
case ISD::FNEG:
|
|
|
|
if (OpOpcode == ISD::SUB) // -(X-Y) -> (Y-X)
|
|
|
|
return getNode(ISD::SUB, VT, Operand.Val->getOperand(1),
|
|
|
|
Operand.Val->getOperand(0));
|
|
|
|
if (OpOpcode == ISD::FNEG) // --X -> X
|
|
|
|
return Operand.Val->getOperand(0);
|
|
|
|
break;
|
|
|
|
case ISD::FABS:
|
|
|
|
if (OpOpcode == ISD::FNEG) // abs(-X) -> abs(X)
|
|
|
|
return getNode(ISD::FABS, VT, Operand.Val->getOperand(0));
|
|
|
|
break;
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 19:12:10 +00:00
|
|
|
SDNode *N;
|
|
|
|
if (VT != MVT::Flag) { // Don't CSE flag producing nodes
|
|
|
|
SDNode *&E = UnaryOps[std::make_pair(Opcode, std::make_pair(Operand, VT))];
|
2005-08-26 00:13:12 +00:00
|
|
|
if (E) return SDOperand(E, 0);
|
2005-08-25 19:12:10 +00:00
|
|
|
E = N = new SDNode(Opcode, Operand);
|
|
|
|
} else {
|
|
|
|
N = new SDNode(Opcode, Operand);
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
N->setValueTypes(VT);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
/// MaskedValueIsZero - Return true if 'V & Mask' is known to be zero. We use
|
|
|
|
/// this predicate to simplify operations downstream. V and Mask are known to
|
|
|
|
/// be the same type.
|
|
|
|
static bool MaskedValueIsZero(const SDOperand &Op, uint64_t Mask,
|
|
|
|
const TargetLowering &TLI) {
|
|
|
|
unsigned SrcBits;
|
|
|
|
if (Mask == 0) return true;
|
2005-04-21 22:36:52 +00:00
|
|
|
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
// If we know the result of a setcc has the top bits zero, use this info.
|
|
|
|
switch (Op.getOpcode()) {
|
|
|
|
case ISD::Constant:
|
|
|
|
return (cast<ConstantSDNode>(Op)->getValue() & Mask) == 0;
|
|
|
|
|
|
|
|
case ISD::SETCC:
|
2005-04-21 22:36:52 +00:00
|
|
|
return ((Mask & 1) == 0) &&
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
TLI.getSetCCResultContents() == TargetLowering::ZeroOrOneSetCCResult;
|
|
|
|
|
|
|
|
case ISD::ZEXTLOAD:
|
2005-07-10 01:55:33 +00:00
|
|
|
SrcBits = MVT::getSizeInBits(cast<VTSDNode>(Op.getOperand(3))->getVT());
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
return (Mask & ((1ULL << SrcBits)-1)) == 0; // Returning only the zext bits.
|
|
|
|
case ISD::ZERO_EXTEND:
|
|
|
|
SrcBits = MVT::getSizeInBits(Op.getOperand(0).getValueType());
|
|
|
|
return MaskedValueIsZero(Op.getOperand(0),Mask & ((1ULL << SrcBits)-1),TLI);
|
2005-08-31 00:43:08 +00:00
|
|
|
case ISD::AssertZext:
|
|
|
|
SrcBits = MVT::getSizeInBits(cast<VTSDNode>(Op.getOperand(1))->getVT());
|
2005-08-31 00:43:49 +00:00
|
|
|
return (Mask & ((1ULL << SrcBits)-1)) == 0; // Returning only the zext bits.
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
case ISD::AND:
|
|
|
|
// (X & C1) & C2 == 0 iff C1 & C2 == 0.
|
Improve and elimination. On PPC, for:
bool %test(int %X) {
%Y = and int %X, 8
%Z = setne int %Y, 0
ret bool %Z
}
we now generate this:
rlwinm r2, r3, 0, 28, 28
srwi r3, r2, 3
instead of this:
rlwinm r2, r3, 0, 28, 28
srwi r2, r2, 3
rlwinm r3, r2, 0, 31, 31
I'll leave it to Nate to get it down to one instruction. :)
---------------------------------------------------------------------
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21391 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-21 06:28:15 +00:00
|
|
|
if (ConstantSDNode *AndRHS = dyn_cast<ConstantSDNode>(Op.getOperand(1)))
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
return MaskedValueIsZero(Op.getOperand(0),AndRHS->getValue() & Mask, TLI);
|
|
|
|
|
|
|
|
// FALL THROUGH
|
|
|
|
case ISD::OR:
|
|
|
|
case ISD::XOR:
|
|
|
|
return MaskedValueIsZero(Op.getOperand(0), Mask, TLI) &&
|
|
|
|
MaskedValueIsZero(Op.getOperand(1), Mask, TLI);
|
|
|
|
case ISD::SELECT:
|
|
|
|
return MaskedValueIsZero(Op.getOperand(1), Mask, TLI) &&
|
|
|
|
MaskedValueIsZero(Op.getOperand(2), Mask, TLI);
|
teach selection dag mask tracking about the fact that select_cc operates like
select. Also teach it that the bit count instructions can only set the low bits
of the result, depending on the size of the input.
This allows us to compile this:
int %eq0(int %a) {
%tmp.1 = seteq int %a, 0 ; <bool> [#uses=1]
%tmp.2 = cast bool %tmp.1 to int ; <int> [#uses=1]
ret int %tmp.2
}
To this:
_eq0:
cntlzw r2, r3
srwi r3, r2, 5
blr
instead of this:
_eq0:
cntlzw r2, r3
rlwinm r3, r2, 27, 31, 31
blr
when setcc is marked illegal on ppc (which restores parity to non-illegal
setcc). Thanks to Nate for pointing this out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23013 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-24 16:46:55 +00:00
|
|
|
case ISD::SELECT_CC:
|
|
|
|
return MaskedValueIsZero(Op.getOperand(2), Mask, TLI) &&
|
|
|
|
MaskedValueIsZero(Op.getOperand(3), Mask, TLI);
|
Improve and elimination. On PPC, for:
bool %test(int %X) {
%Y = and int %X, 8
%Z = setne int %Y, 0
ret bool %Z
}
we now generate this:
rlwinm r2, r3, 0, 28, 28
srwi r3, r2, 3
instead of this:
rlwinm r2, r3, 0, 28, 28
srwi r2, r2, 3
rlwinm r3, r2, 0, 31, 31
I'll leave it to Nate to get it down to one instruction. :)
---------------------------------------------------------------------
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21391 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-21 06:28:15 +00:00
|
|
|
case ISD::SRL:
|
|
|
|
// (ushr X, C1) & C2 == 0 iff X & (C2 << C1) == 0
|
|
|
|
if (ConstantSDNode *ShAmt = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
|
|
|
uint64_t NewVal = Mask << ShAmt->getValue();
|
|
|
|
SrcBits = MVT::getSizeInBits(Op.getValueType());
|
|
|
|
if (SrcBits != 64) NewVal &= (1ULL << SrcBits)-1;
|
|
|
|
return MaskedValueIsZero(Op.getOperand(0), NewVal, TLI);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
case ISD::SHL:
|
|
|
|
// (ushl X, C1) & C2 == 0 iff X & (C2 >> C1) == 0
|
|
|
|
if (ConstantSDNode *ShAmt = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
|
|
|
uint64_t NewVal = Mask >> ShAmt->getValue();
|
|
|
|
return MaskedValueIsZero(Op.getOperand(0), NewVal, TLI);
|
|
|
|
}
|
|
|
|
return false;
|
teach selection dag mask tracking about the fact that select_cc operates like
select. Also teach it that the bit count instructions can only set the low bits
of the result, depending on the size of the input.
This allows us to compile this:
int %eq0(int %a) {
%tmp.1 = seteq int %a, 0 ; <bool> [#uses=1]
%tmp.2 = cast bool %tmp.1 to int ; <int> [#uses=1]
ret int %tmp.2
}
To this:
_eq0:
cntlzw r2, r3
srwi r3, r2, 5
blr
instead of this:
_eq0:
cntlzw r2, r3
rlwinm r3, r2, 27, 31, 31
blr
when setcc is marked illegal on ppc (which restores parity to non-illegal
setcc). Thanks to Nate for pointing this out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23013 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-24 16:46:55 +00:00
|
|
|
case ISD::CTTZ:
|
|
|
|
case ISD::CTLZ:
|
|
|
|
case ISD::CTPOP:
|
|
|
|
// Bit counting instructions can not set the high bits of the result
|
|
|
|
// register. The max number of bits sets depends on the input.
|
|
|
|
return (Mask & (MVT::getSizeInBits(Op.getValueType())*2-1)) == 0;
|
|
|
|
|
Codegen x < 0 | y < 0 as (x|y) < 0. This allows us to compile this to:
_foo:
or r2, r4, r3
srwi r3, r2, 31
blr
instead of:
_foo:
srwi r2, r4, 31
srwi r3, r3, 31
or r3, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21544 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-25 21:03:25 +00:00
|
|
|
// TODO we could handle some SRA cases here.
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
|
|
|
|
SDOperand N1, SDOperand N2) {
|
2005-01-16 02:23:22 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
switch (Opcode) {
|
2005-01-19 18:01:40 +00:00
|
|
|
case ISD::TokenFactor:
|
|
|
|
assert(VT == MVT::Other && N1.getValueType() == MVT::Other &&
|
|
|
|
N2.getValueType() == MVT::Other && "Invalid token factor!");
|
|
|
|
break;
|
2005-01-16 02:23:22 +00:00
|
|
|
case ISD::AND:
|
|
|
|
case ISD::OR:
|
|
|
|
case ISD::XOR:
|
|
|
|
case ISD::UDIV:
|
|
|
|
case ISD::UREM:
|
Add some simplifications for MULH[SU]. This allows us to compile this:
long %bar(long %X) {
%Y = mul long %X, 4294967297
ret long %Y
}
to this:
l1_bar:
mov %EAX, DWORD PTR [%ESP + 4]
mov %EDX, %EAX
add %EDX, DWORD PTR [%ESP + 8]
ret
instead of:
l1_bar:
mov %ECX, DWORD PTR [%ESP + 4]
mov %EDX, 1
mov %EAX, %ECX
mul %EDX
add %EDX, %ECX
add %EDX, DWORD PTR [%ESP + 8]
mov %EAX, %ECX
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@22044 91177308-0d34-0410-b5e6-96231b3b80d8
2005-05-15 05:39:08 +00:00
|
|
|
case ISD::MULHU:
|
|
|
|
case ISD::MULHS:
|
2005-01-16 02:23:22 +00:00
|
|
|
assert(MVT::isInteger(VT) && "This operator does not apply to FP types!");
|
|
|
|
// fall through
|
|
|
|
case ISD::ADD:
|
|
|
|
case ISD::SUB:
|
|
|
|
case ISD::MUL:
|
|
|
|
case ISD::SDIV:
|
|
|
|
case ISD::SREM:
|
|
|
|
assert(N1.getValueType() == N2.getValueType() &&
|
|
|
|
N1.getValueType() == VT && "Binary operator types must match!");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ISD::SHL:
|
|
|
|
case ISD::SRA:
|
|
|
|
case ISD::SRL:
|
|
|
|
assert(VT == N1.getValueType() &&
|
|
|
|
"Shift operators return type must be the same as their first arg");
|
|
|
|
assert(MVT::isInteger(VT) && MVT::isInteger(N2.getValueType()) &&
|
2005-01-17 17:15:02 +00:00
|
|
|
VT != MVT::i1 && "Shifts only work on integers");
|
2005-01-16 02:23:22 +00:00
|
|
|
break;
|
2005-07-10 00:07:11 +00:00
|
|
|
case ISD::FP_ROUND_INREG: {
|
|
|
|
MVT::ValueType EVT = cast<VTSDNode>(N2)->getVT();
|
|
|
|
assert(VT == N1.getValueType() && "Not an inreg round!");
|
|
|
|
assert(MVT::isFloatingPoint(VT) && MVT::isFloatingPoint(EVT) &&
|
|
|
|
"Cannot FP_ROUND_INREG integer types");
|
|
|
|
assert(EVT <= VT && "Not rounding down!");
|
|
|
|
break;
|
|
|
|
}
|
Add support for AssertSext and AssertZext, folding other extensions with
them. This allows for elminination of redundant extends in the entry
blocks of functions on PowerPC.
Add support for i32 x i32 -> i64 multiplies, by recognizing when the inputs
to ISD::MUL in ExpandOp are actually just extended i32 values and not real
i64 values. this allows us to codegen
int mulhs(int a, int b) { return ((long long)a * b) >> 32; }
as:
_mulhs:
mulhw r3, r4, r3
blr
instead of:
_mulhs:
mulhwu r2, r4, r3
srawi r5, r3, 31
mullw r5, r4, r5
add r2, r2, r5
srawi r4, r4, 31
mullw r3, r4, r3
add r3, r2, r3
blr
with a similar improvement on x86.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23147 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-30 02:44:00 +00:00
|
|
|
case ISD::AssertSext:
|
|
|
|
case ISD::AssertZext:
|
2005-07-10 00:07:11 +00:00
|
|
|
case ISD::SIGN_EXTEND_INREG: {
|
|
|
|
MVT::ValueType EVT = cast<VTSDNode>(N2)->getVT();
|
|
|
|
assert(VT == N1.getValueType() && "Not an inreg extend!");
|
|
|
|
assert(MVT::isInteger(VT) && MVT::isInteger(EVT) &&
|
|
|
|
"Cannot *_EXTEND_INREG FP types");
|
|
|
|
assert(EVT <= VT && "Not extending!");
|
|
|
|
}
|
|
|
|
|
2005-01-16 02:23:22 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.Val);
|
|
|
|
ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.Val);
|
|
|
|
if (N1C) {
|
|
|
|
if (N2C) {
|
|
|
|
uint64_t C1 = N1C->getValue(), C2 = N2C->getValue();
|
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::ADD: return getConstant(C1 + C2, VT);
|
|
|
|
case ISD::SUB: return getConstant(C1 - C2, VT);
|
|
|
|
case ISD::MUL: return getConstant(C1 * C2, VT);
|
|
|
|
case ISD::UDIV:
|
|
|
|
if (C2) return getConstant(C1 / C2, VT);
|
|
|
|
break;
|
|
|
|
case ISD::UREM :
|
|
|
|
if (C2) return getConstant(C1 % C2, VT);
|
|
|
|
break;
|
|
|
|
case ISD::SDIV :
|
|
|
|
if (C2) return getConstant(N1C->getSignExtended() /
|
|
|
|
N2C->getSignExtended(), VT);
|
|
|
|
break;
|
|
|
|
case ISD::SREM :
|
|
|
|
if (C2) return getConstant(N1C->getSignExtended() %
|
|
|
|
N2C->getSignExtended(), VT);
|
|
|
|
break;
|
|
|
|
case ISD::AND : return getConstant(C1 & C2, VT);
|
|
|
|
case ISD::OR : return getConstant(C1 | C2, VT);
|
|
|
|
case ISD::XOR : return getConstant(C1 ^ C2, VT);
|
2005-08-31 00:27:53 +00:00
|
|
|
case ISD::SHL : return getConstant(C1 << C2, VT);
|
|
|
|
case ISD::SRL : return getConstant(C1 >> C2, VT);
|
2005-01-10 00:07:15 +00:00
|
|
|
case ISD::SRA : return getConstant(N1C->getSignExtended() >>(int)C2, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
} else { // Cannonicalize constant to RHS if commutative
|
|
|
|
if (isCommutativeBinOp(Opcode)) {
|
|
|
|
std::swap(N1C, N2C);
|
|
|
|
std::swap(N1, N2);
|
|
|
|
}
|
|
|
|
}
|
2005-01-19 17:29:49 +00:00
|
|
|
|
2005-09-07 05:37:01 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-01-19 17:29:49 +00:00
|
|
|
switch (Opcode) {
|
|
|
|
default: break;
|
|
|
|
case ISD::SHL: // shl 0, X -> 0
|
|
|
|
if (N1C->isNullValue()) return N1;
|
|
|
|
break;
|
|
|
|
case ISD::SRL: // srl 0, X -> 0
|
|
|
|
if (N1C->isNullValue()) return N1;
|
|
|
|
break;
|
|
|
|
case ISD::SRA: // sra -1, X -> -1
|
|
|
|
if (N1C->isAllOnesValue()) return N1;
|
|
|
|
break;
|
2005-07-10 00:07:11 +00:00
|
|
|
case ISD::SIGN_EXTEND_INREG: // SIGN_EXTEND_INREG N1C, EVT
|
|
|
|
// Extending a constant? Just return the extended constant.
|
|
|
|
SDOperand Tmp = getNode(ISD::TRUNCATE, cast<VTSDNode>(N2)->getVT(), N1);
|
|
|
|
return getNode(ISD::SIGN_EXTEND, VT, Tmp);
|
2005-01-19 17:29:49 +00:00
|
|
|
}
|
2005-09-07 05:37:01 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2005-09-09 19:49:52 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-01-07 07:46:32 +00:00
|
|
|
if (N2C) {
|
|
|
|
uint64_t C2 = N2C->getValue();
|
|
|
|
|
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::ADD:
|
|
|
|
if (!C2) return N1; // add X, 0 -> X
|
|
|
|
break;
|
|
|
|
case ISD::SUB:
|
|
|
|
if (!C2) return N1; // sub X, 0 -> X
|
2005-05-12 00:17:04 +00:00
|
|
|
return getNode(ISD::ADD, VT, N1, getConstant(-C2, VT));
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::MUL:
|
|
|
|
if (!C2) return N2; // mul X, 0 -> 0
|
|
|
|
if (N2C->isAllOnesValue()) // mul X, -1 -> 0-X
|
|
|
|
return getNode(ISD::SUB, VT, getConstant(0, VT), N1);
|
|
|
|
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
// FIXME: Move this to the DAG combiner when it exists.
|
2005-01-07 07:46:32 +00:00
|
|
|
if ((C2 & C2-1) == 0) {
|
2005-08-02 19:26:06 +00:00
|
|
|
SDOperand ShAmt = getConstant(Log2_64(C2), TLI.getShiftAmountTy());
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
return getNode(ISD::SHL, VT, N1, ShAmt);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
Add some simplifications for MULH[SU]. This allows us to compile this:
long %bar(long %X) {
%Y = mul long %X, 4294967297
ret long %Y
}
to this:
l1_bar:
mov %EAX, DWORD PTR [%ESP + 4]
mov %EDX, %EAX
add %EDX, DWORD PTR [%ESP + 8]
ret
instead of:
l1_bar:
mov %ECX, DWORD PTR [%ESP + 4]
mov %EDX, 1
mov %EAX, %ECX
mul %EDX
add %EDX, %ECX
add %EDX, DWORD PTR [%ESP + 8]
mov %EAX, %ECX
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@22044 91177308-0d34-0410-b5e6-96231b3b80d8
2005-05-15 05:39:08 +00:00
|
|
|
case ISD::MULHU:
|
|
|
|
case ISD::MULHS:
|
|
|
|
if (!C2) return N2; // mul X, 0 -> 0
|
|
|
|
|
|
|
|
if (C2 == 1) // 0X*01 -> 0X hi(0X) == 0
|
|
|
|
return getConstant(0, VT);
|
|
|
|
|
|
|
|
// Many others could be handled here, including -1, powers of 2, etc.
|
|
|
|
break;
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::UDIV:
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
// FIXME: Move this to the DAG combiner when it exists.
|
2005-01-07 07:46:32 +00:00
|
|
|
if ((C2 & C2-1) == 0 && C2) {
|
2005-08-02 19:26:06 +00:00
|
|
|
SDOperand ShAmt = getConstant(Log2_64(C2), TLI.getShiftAmountTy());
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
return getNode(ISD::SRL, VT, N1, ShAmt);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2005-01-11 04:25:13 +00:00
|
|
|
case ISD::SHL:
|
|
|
|
case ISD::SRL:
|
2005-04-12 23:12:17 +00:00
|
|
|
case ISD::SRA:
|
|
|
|
// If the shift amount is bigger than the size of the data, then all the
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
// bits are shifted out. Simplify to undef.
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
if (C2 >= MVT::getSizeInBits(N1.getValueType())) {
|
2005-04-12 23:12:17 +00:00
|
|
|
return getNode(ISD::UNDEF, N1.getValueType());
|
Remove the 3 HACK HACK HACKs I put in before, fixing them properly with
the new TLI that is available.
Implement support for handling out of range shifts. This allows us to
compile this code (a 64-bit rotate):
unsigned long long f3(unsigned long long x) {
return (x << 32) | (x >> (64-32));
}
into this:
f3:
mov %EDX, DWORD PTR [%ESP + 4]
mov %EAX, DWORD PTR [%ESP + 8]
ret
GCC produces this:
$ gcc t.c -masm=intel -O3 -S -o - -fomit-frame-pointer
..
f3:
push %ebx
mov %ebx, DWORD PTR [%esp+12]
mov %ecx, DWORD PTR [%esp+8]
mov %eax, %ebx
mov %edx, %ecx
pop %ebx
ret
The Simple ISEL produces (eww gross):
f3:
sub %ESP, 4
mov DWORD PTR [%ESP], %ESI
mov %EDX, DWORD PTR [%ESP + 8]
mov %ECX, DWORD PTR [%ESP + 12]
mov %EAX, 0
mov %ESI, 0
or %EAX, %ECX
or %EDX, %ESI
mov %ESI, DWORD PTR [%ESP]
add %ESP, 4
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19780 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-23 04:39:44 +00:00
|
|
|
}
|
2005-01-11 04:25:13 +00:00
|
|
|
if (C2 == 0) return N1;
|
2005-08-12 23:54:58 +00:00
|
|
|
|
|
|
|
if (Opcode == ISD::SRA) {
|
|
|
|
// If the sign bit is known to be zero, switch this to a SRL.
|
|
|
|
if (MaskedValueIsZero(N1,
|
2005-08-19 04:39:48 +00:00
|
|
|
1ULL << (MVT::getSizeInBits(N1.getValueType())-1),
|
2005-08-12 23:54:58 +00:00
|
|
|
TLI))
|
|
|
|
return getNode(ISD::SRL, N1.getValueType(), N1, N2);
|
|
|
|
} else {
|
|
|
|
// If the part left over is known to be zero, the whole thing is zero.
|
|
|
|
uint64_t TypeMask = ~0ULL >> (64-MVT::getSizeInBits(N1.getValueType()));
|
|
|
|
if (Opcode == ISD::SRL) {
|
|
|
|
if (MaskedValueIsZero(N1, TypeMask << C2, TLI))
|
|
|
|
return getConstant(0, N1.getValueType());
|
|
|
|
} else if (Opcode == ISD::SHL) {
|
|
|
|
if (MaskedValueIsZero(N1, TypeMask >> C2, TLI))
|
|
|
|
return getConstant(0, N1.getValueType());
|
|
|
|
}
|
|
|
|
}
|
2005-05-09 17:06:45 +00:00
|
|
|
|
|
|
|
if (Opcode == ISD::SHL && N1.getNumOperands() == 2)
|
|
|
|
if (ConstantSDNode *OpSA = dyn_cast<ConstantSDNode>(N1.getOperand(1))) {
|
|
|
|
unsigned OpSAC = OpSA->getValue();
|
|
|
|
if (N1.getOpcode() == ISD::SHL) {
|
|
|
|
if (C2+OpSAC >= MVT::getSizeInBits(N1.getValueType()))
|
|
|
|
return getConstant(0, N1.getValueType());
|
|
|
|
return getNode(ISD::SHL, N1.getValueType(), N1.getOperand(0),
|
|
|
|
getConstant(C2+OpSAC, N2.getValueType()));
|
|
|
|
} else if (N1.getOpcode() == ISD::SRL) {
|
|
|
|
// (X >> C1) << C2: if C2 > C1, ((X & ~0<<C1) << C2-C1)
|
|
|
|
SDOperand Mask = getNode(ISD::AND, VT, N1.getOperand(0),
|
|
|
|
getConstant(~0ULL << OpSAC, VT));
|
|
|
|
if (C2 > OpSAC) {
|
|
|
|
return getNode(ISD::SHL, VT, Mask,
|
|
|
|
getConstant(C2-OpSAC, N2.getValueType()));
|
|
|
|
} else {
|
|
|
|
// (X >> C1) << C2: if C2 <= C1, ((X & ~0<<C1) >> C1-C2)
|
|
|
|
return getNode(ISD::SRL, VT, Mask,
|
|
|
|
getConstant(OpSAC-C2, N2.getValueType()));
|
|
|
|
}
|
|
|
|
} else if (N1.getOpcode() == ISD::SRA) {
|
|
|
|
// if C1 == C2, just mask out low bits.
|
|
|
|
if (C2 == OpSAC)
|
|
|
|
return getNode(ISD::AND, VT, N1.getOperand(0),
|
|
|
|
getConstant(~0ULL << C2, VT));
|
|
|
|
}
|
|
|
|
}
|
2005-01-11 04:25:13 +00:00
|
|
|
break;
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::AND:
|
|
|
|
if (!C2) return N2; // X and 0 -> 0
|
|
|
|
if (N2C->isAllOnesValue())
|
2005-04-13 21:23:31 +00:00
|
|
|
return N1; // X and -1 -> X
|
2005-04-09 21:43:54 +00:00
|
|
|
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
if (MaskedValueIsZero(N1, C2, TLI)) // X and 0 -> 0
|
|
|
|
return getConstant(0, VT);
|
|
|
|
|
Improve and elimination. On PPC, for:
bool %test(int %X) {
%Y = and int %X, 8
%Z = setne int %Y, 0
ret bool %Z
}
we now generate this:
rlwinm r2, r3, 0, 28, 28
srwi r3, r2, 3
instead of this:
rlwinm r2, r3, 0, 28, 28
srwi r2, r2, 3
rlwinm r3, r2, 0, 31, 31
I'll leave it to Nate to get it down to one instruction. :)
---------------------------------------------------------------------
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21391 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-21 06:28:15 +00:00
|
|
|
{
|
|
|
|
uint64_t NotC2 = ~C2;
|
|
|
|
if (VT != MVT::i64)
|
|
|
|
NotC2 &= (1ULL << MVT::getSizeInBits(VT))-1;
|
|
|
|
|
|
|
|
if (MaskedValueIsZero(N1, NotC2, TLI))
|
|
|
|
return N1; // if (X & ~C2) -> 0, the and is redundant
|
|
|
|
}
|
Make the AND elimination operation recursive and significantly more powerful,
eliminating an and for Nate's testcase:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
generating:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r2, r2, r3
rlwinm r3, r2, 0, 31, 31
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21315 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:48:41 +00:00
|
|
|
|
2005-04-10 01:13:15 +00:00
|
|
|
// FIXME: Should add a corresponding version of this for
|
|
|
|
// ZERO_EXTEND/SIGN_EXTEND by converting them to an ANY_EXTEND node which
|
|
|
|
// we don't have yet.
|
2005-09-02 00:17:32 +00:00
|
|
|
// FIXME: NOW WE DO, add this.
|
2005-04-10 01:13:15 +00:00
|
|
|
|
2005-04-13 02:38:18 +00:00
|
|
|
// and (sign_extend_inreg x:16:32), 1 -> and x, 1
|
|
|
|
if (N1.getOpcode() == ISD::SIGN_EXTEND_INREG) {
|
2005-04-09 21:43:54 +00:00
|
|
|
// If we are masking out the part of our input that was extended, just
|
|
|
|
// mask the input to the extension directly.
|
|
|
|
unsigned ExtendBits =
|
2005-07-10 00:07:11 +00:00
|
|
|
MVT::getSizeInBits(cast<VTSDNode>(N1.getOperand(1))->getVT());
|
2005-04-09 21:43:54 +00:00
|
|
|
if ((C2 & (~0ULL << ExtendBits)) == 0)
|
|
|
|
return getNode(ISD::AND, VT, N1.getOperand(0), N2);
|
2005-08-07 05:00:44 +00:00
|
|
|
} else if (N1.getOpcode() == ISD::OR) {
|
|
|
|
if (ConstantSDNode *ORI = dyn_cast<ConstantSDNode>(N1.getOperand(1)))
|
|
|
|
if ((ORI->getValue() & C2) == C2) {
|
|
|
|
// If the 'or' is setting all of the bits that we are masking for,
|
|
|
|
// we know the result of the AND will be the AND mask itself.
|
|
|
|
return N2;
|
|
|
|
}
|
2005-04-09 21:43:54 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
|
|
|
case ISD::OR:
|
|
|
|
if (!C2)return N1; // X or 0 -> X
|
|
|
|
if (N2C->isAllOnesValue())
|
2005-04-22 04:01:18 +00:00
|
|
|
return N2; // X or -1 -> -1
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
|
|
|
case ISD::XOR:
|
|
|
|
if (!C2) return N1; // X xor 0 -> X
|
2005-09-01 23:25:49 +00:00
|
|
|
if (N2C->getValue() == 1 && N1.Val->getOpcode() == ISD::SETCC) {
|
2005-08-09 20:20:18 +00:00
|
|
|
SDNode *SetCC = N1.Val;
|
2005-01-07 07:46:32 +00:00
|
|
|
// !(X op Y) -> (X !op Y)
|
|
|
|
bool isInteger = MVT::isInteger(SetCC->getOperand(0).getValueType());
|
2005-08-09 20:20:18 +00:00
|
|
|
ISD::CondCode CC = cast<CondCodeSDNode>(SetCC->getOperand(2))->get();
|
|
|
|
return getSetCC(SetCC->getValueType(0),
|
|
|
|
SetCC->getOperand(0), SetCC->getOperand(1),
|
|
|
|
ISD::getSetCCInverse(CC, isInteger));
|
2005-09-01 23:25:49 +00:00
|
|
|
} else if (N2C->isAllOnesValue()) {
|
|
|
|
if (N1.getOpcode() == ISD::AND || N1.getOpcode() == ISD::OR) {
|
2005-01-07 07:46:32 +00:00
|
|
|
SDNode *Op = N1.Val;
|
|
|
|
// !(X or Y) -> (!X and !Y) iff X or Y are freely invertible
|
|
|
|
// !(X and Y) -> (!X or !Y) iff X or Y are freely invertible
|
|
|
|
SDOperand LHS = Op->getOperand(0), RHS = Op->getOperand(1);
|
|
|
|
if (isInvertibleForFree(RHS) || isInvertibleForFree(LHS)) {
|
|
|
|
LHS = getNode(ISD::XOR, VT, LHS, N2); // RHS = ~LHS
|
|
|
|
RHS = getNode(ISD::XOR, VT, RHS, N2); // RHS = ~RHS
|
|
|
|
if (Op->getOpcode() == ISD::AND)
|
|
|
|
return getNode(ISD::OR, VT, LHS, RHS);
|
|
|
|
return getNode(ISD::AND, VT, LHS, RHS);
|
|
|
|
}
|
|
|
|
}
|
2005-04-22 04:01:18 +00:00
|
|
|
// X xor -1 -> not(x) ?
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reassociate ((X op C1) op C2) if possible.
|
|
|
|
if (N1.getOpcode() == Opcode && isAssociativeBinOp(Opcode))
|
|
|
|
if (ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N1.Val->getOperand(1)))
|
2005-01-07 22:44:09 +00:00
|
|
|
return getNode(Opcode, VT, N1.Val->getOperand(0),
|
2005-01-07 07:46:32 +00:00
|
|
|
getNode(Opcode, VT, N2, N1.Val->getOperand(1)));
|
2005-09-09 19:49:52 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1.Val);
|
|
|
|
ConstantFPSDNode *N2CFP = dyn_cast<ConstantFPSDNode>(N2.Val);
|
2005-07-10 00:07:11 +00:00
|
|
|
if (N1CFP) {
|
2005-01-07 07:46:32 +00:00
|
|
|
if (N2CFP) {
|
|
|
|
double C1 = N1CFP->getValue(), C2 = N2CFP->getValue();
|
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::ADD: return getConstantFP(C1 + C2, VT);
|
|
|
|
case ISD::SUB: return getConstantFP(C1 - C2, VT);
|
|
|
|
case ISD::MUL: return getConstantFP(C1 * C2, VT);
|
|
|
|
case ISD::SDIV:
|
|
|
|
if (C2) return getConstantFP(C1 / C2, VT);
|
|
|
|
break;
|
|
|
|
case ISD::SREM :
|
|
|
|
if (C2) return getConstantFP(fmod(C1, C2), VT);
|
|
|
|
break;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
} else { // Cannonicalize constant to RHS if commutative
|
|
|
|
if (isCommutativeBinOp(Opcode)) {
|
|
|
|
std::swap(N1CFP, N2CFP);
|
|
|
|
std::swap(N1, N2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-07 23:25:52 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-07-10 00:07:11 +00:00
|
|
|
if (Opcode == ISD::FP_ROUND_INREG)
|
|
|
|
return getNode(ISD::FP_EXTEND, VT,
|
|
|
|
getNode(ISD::FP_ROUND, cast<VTSDNode>(N2)->getVT(), N1));
|
2005-09-07 23:25:52 +00:00
|
|
|
}
|
2005-07-10 00:07:11 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
// Finally, fold operations that do not require constants.
|
|
|
|
switch (Opcode) {
|
2005-01-19 18:01:40 +00:00
|
|
|
case ISD::TokenFactor:
|
2005-09-07 05:37:01 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-01-19 18:01:40 +00:00
|
|
|
if (N1.getOpcode() == ISD::EntryToken)
|
|
|
|
return N2;
|
|
|
|
if (N2.getOpcode() == ISD::EntryToken)
|
|
|
|
return N1;
|
2005-09-07 05:37:01 +00:00
|
|
|
}
|
2005-01-19 18:01:40 +00:00
|
|
|
break;
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::AND:
|
|
|
|
case ISD::OR:
|
2005-09-09 19:49:52 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-08-09 20:20:18 +00:00
|
|
|
if (N1.Val->getOpcode() == ISD::SETCC && N2.Val->getOpcode() == ISD::SETCC){
|
|
|
|
SDNode *LHS = N1.Val, *RHS = N2.Val;
|
|
|
|
SDOperand LL = LHS->getOperand(0), RL = RHS->getOperand(0);
|
|
|
|
SDOperand LR = LHS->getOperand(1), RR = RHS->getOperand(1);
|
|
|
|
ISD::CondCode Op1 = cast<CondCodeSDNode>(LHS->getOperand(2))->get();
|
|
|
|
ISD::CondCode Op2 = cast<CondCodeSDNode>(RHS->getOperand(2))->get();
|
|
|
|
|
|
|
|
if (LR == RR && isa<ConstantSDNode>(LR) &&
|
|
|
|
Op2 == Op1 && MVT::isInteger(LL.getValueType())) {
|
|
|
|
// (X != 0) | (Y != 0) -> (X|Y != 0)
|
|
|
|
// (X == 0) & (Y == 0) -> (X|Y == 0)
|
|
|
|
// (X < 0) | (Y < 0) -> (X|Y < 0)
|
|
|
|
if (cast<ConstantSDNode>(LR)->getValue() == 0 &&
|
|
|
|
((Op2 == ISD::SETEQ && Opcode == ISD::AND) ||
|
|
|
|
(Op2 == ISD::SETNE && Opcode == ISD::OR) ||
|
|
|
|
(Op2 == ISD::SETLT && Opcode == ISD::OR)))
|
|
|
|
return getSetCC(VT, getNode(ISD::OR, LR.getValueType(), LL, RL), LR,
|
|
|
|
Op2);
|
|
|
|
|
|
|
|
if (cast<ConstantSDNode>(LR)->isAllOnesValue()) {
|
|
|
|
// (X == -1) & (Y == -1) -> (X&Y == -1)
|
|
|
|
// (X != -1) | (Y != -1) -> (X&Y != -1)
|
|
|
|
// (X > -1) | (Y > -1) -> (X&Y > -1)
|
|
|
|
if ((Opcode == ISD::AND && Op2 == ISD::SETEQ) ||
|
|
|
|
(Opcode == ISD::OR && Op2 == ISD::SETNE) ||
|
|
|
|
(Opcode == ISD::OR && Op2 == ISD::SETGT))
|
|
|
|
return getSetCC(VT, getNode(ISD::AND, LR.getValueType(), LL, RL),
|
|
|
|
LR, Op2);
|
|
|
|
// (X > -1) & (Y > -1) -> (X|Y > -1)
|
|
|
|
if (Opcode == ISD::AND && Op2 == ISD::SETGT)
|
|
|
|
return getSetCC(VT, getNode(ISD::OR, LR.getValueType(), LL, RL),
|
|
|
|
LR, Op2);
|
Fold:
// (X != 0) | (Y != 0) -> (X|Y != 0)
// (X == 0) & (Y == 0) -> (X|Y == 0)
Compiling this:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
to this:
_bar:
or r2, r3, r4
addic r3, r2, -1
subfe r3, r3, r2
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21316 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:59:53 +00:00
|
|
|
}
|
2005-08-09 20:20:18 +00:00
|
|
|
}
|
Fold:
// (X != 0) | (Y != 0) -> (X|Y != 0)
// (X == 0) & (Y == 0) -> (X|Y == 0)
Compiling this:
int %bar(int %a, int %b) {
entry:
%tmp.1 = setne int %a, 0
%tmp.2 = setne int %b, 0
%tmp.3 = or bool %tmp.1, %tmp.2
%retval = cast bool %tmp.3 to int
ret int %retval
}
to this:
_bar:
or r2, r3, r4
addic r3, r2, -1
subfe r3, r3, r2
blr
instead of:
_bar:
addic r2, r3, -1
subfe r2, r2, r3
addic r3, r4, -1
subfe r3, r3, r4
or r3, r2, r3
blr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21316 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-18 03:59:53 +00:00
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
// (X op1 Y) | (Y op2 X) -> (X op1 Y) | (X swapop2 Y)
|
|
|
|
if (LL == RR && LR == RL) {
|
|
|
|
Op2 = ISD::getSetCCSwappedOperands(Op2);
|
|
|
|
goto MatchedBackwards;
|
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
if (LL == RL && LR == RR) {
|
|
|
|
MatchedBackwards:
|
|
|
|
ISD::CondCode Result;
|
|
|
|
bool isInteger = MVT::isInteger(LL.getValueType());
|
|
|
|
if (Opcode == ISD::OR)
|
|
|
|
Result = ISD::getSetCCOrOperation(Op1, Op2, isInteger);
|
|
|
|
else
|
|
|
|
Result = ISD::getSetCCAndOperation(Op1, Op2, isInteger);
|
|
|
|
|
|
|
|
if (Result != ISD::SETCC_INVALID)
|
|
|
|
return getSetCC(LHS->getValueType(0), LL, LR, Result);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2005-08-09 20:20:18 +00:00
|
|
|
}
|
2005-04-18 04:11:19 +00:00
|
|
|
|
|
|
|
// and/or zext(a), zext(b) -> zext(and/or a, b)
|
|
|
|
if (N1.getOpcode() == ISD::ZERO_EXTEND &&
|
|
|
|
N2.getOpcode() == ISD::ZERO_EXTEND &&
|
|
|
|
N1.getOperand(0).getValueType() == N2.getOperand(0).getValueType())
|
|
|
|
return getNode(ISD::ZERO_EXTEND, VT,
|
|
|
|
getNode(Opcode, N1.getOperand(0).getValueType(),
|
|
|
|
N1.getOperand(0), N2.getOperand(0)));
|
2005-09-09 19:49:52 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
|
|
|
case ISD::XOR:
|
2005-09-08 20:18:10 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-01-07 07:46:32 +00:00
|
|
|
if (N1 == N2) return getConstant(0, VT); // xor X, Y -> 0
|
2005-09-08 20:18:10 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
2005-04-09 03:02:46 +00:00
|
|
|
case ISD::ADD:
|
2005-09-08 20:18:10 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-04-09 03:02:46 +00:00
|
|
|
if (N2.getOpcode() == ISD::FNEG) // (A+ (-B) -> A-B
|
|
|
|
return getNode(ISD::SUB, VT, N1, N2.getOperand(0));
|
|
|
|
if (N1.getOpcode() == ISD::FNEG) // ((-A)+B) -> B-A
|
|
|
|
return getNode(ISD::SUB, VT, N2, N1.getOperand(0));
|
2005-04-10 04:04:49 +00:00
|
|
|
if (N1.getOpcode() == ISD::SUB && isa<ConstantSDNode>(N1.getOperand(0)) &&
|
|
|
|
cast<ConstantSDNode>(N1.getOperand(0))->getValue() == 0)
|
|
|
|
return getNode(ISD::SUB, VT, N2, N1.getOperand(1)); // (0-A)+B -> B-A
|
|
|
|
if (N2.getOpcode() == ISD::SUB && isa<ConstantSDNode>(N2.getOperand(0)) &&
|
|
|
|
cast<ConstantSDNode>(N2.getOperand(0))->getValue() == 0)
|
|
|
|
return getNode(ISD::SUB, VT, N1, N2.getOperand(1)); // A+(0-B) -> A-B
|
2005-06-16 07:06:03 +00:00
|
|
|
if (N2.getOpcode() == ISD::SUB && N1 == N2.Val->getOperand(1) &&
|
|
|
|
!MVT::isFloatingPoint(N2.getValueType()))
|
|
|
|
return N2.Val->getOperand(0); // A+(B-A) -> B
|
2005-09-08 20:18:10 +00:00
|
|
|
}
|
2005-04-09 03:02:46 +00:00
|
|
|
break;
|
Add a simple transformation. This allows us to compile one of the inner
loops in stepanov to this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
cmpl $2000, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
instead of this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
movl $data, %ecx
movl %ecx, %edx
addl $16000, %edx
subl %ecx, %edx
movl %edx, %ecx
sarl $2, %ecx
shrl $29, %ecx
addl %ecx, %edx
sarl $3, %edx
cmpl %edx, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
The old instruction selector produced:
.LBB_Z5test0PdS__2: # no_exit.1
fldl 24(%esp)
faddl data(,%eax,8)
fstl 24(%esp)
movl %eax, %ecx
incl %ecx
incl %eax
leal data+16000, %edx
movl $data, %edi
subl %edi, %edx
movl %edx, %edi
sarl $2, %edi
shrl $29, %edi
addl %edi, %edx
sarl $3, %edx
cmpl %edx, %ecx
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2 # no_exit.1
Which is even worse!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19419 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:09:57 +00:00
|
|
|
case ISD::SUB:
|
2005-09-08 20:18:10 +00:00
|
|
|
if (!CombinerEnabled) {
|
Add a simple transformation. This allows us to compile one of the inner
loops in stepanov to this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
cmpl $2000, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
instead of this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
movl $data, %ecx
movl %ecx, %edx
addl $16000, %edx
subl %ecx, %edx
movl %edx, %ecx
sarl $2, %ecx
shrl $29, %ecx
addl %ecx, %edx
sarl $3, %edx
cmpl %edx, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
The old instruction selector produced:
.LBB_Z5test0PdS__2: # no_exit.1
fldl 24(%esp)
faddl data(,%eax,8)
fstl 24(%esp)
movl %eax, %ecx
incl %ecx
incl %eax
leal data+16000, %edx
movl $data, %edi
subl %edi, %edx
movl %edx, %edi
sarl $2, %edi
shrl $29, %edi
addl %edi, %edx
sarl $3, %edx
cmpl %edx, %ecx
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2 # no_exit.1
Which is even worse!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19419 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:09:57 +00:00
|
|
|
if (N1.getOpcode() == ISD::ADD) {
|
2005-07-27 06:12:32 +00:00
|
|
|
if (N1.Val->getOperand(0) == N2 &&
|
2005-06-16 07:06:03 +00:00
|
|
|
!MVT::isFloatingPoint(N2.getValueType()))
|
Add a simple transformation. This allows us to compile one of the inner
loops in stepanov to this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
cmpl $2000, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
instead of this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
movl $data, %ecx
movl %ecx, %edx
addl $16000, %edx
subl %ecx, %edx
movl %edx, %ecx
sarl $2, %ecx
shrl $29, %ecx
addl %ecx, %edx
sarl $3, %edx
cmpl %edx, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
The old instruction selector produced:
.LBB_Z5test0PdS__2: # no_exit.1
fldl 24(%esp)
faddl data(,%eax,8)
fstl 24(%esp)
movl %eax, %ecx
incl %ecx
incl %eax
leal data+16000, %edx
movl $data, %edi
subl %edi, %edx
movl %edx, %edi
sarl $2, %edi
shrl $29, %edi
addl %edi, %edx
sarl $3, %edx
cmpl %edx, %ecx
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2 # no_exit.1
Which is even worse!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19419 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:09:57 +00:00
|
|
|
return N1.Val->getOperand(1); // (A+B)-A == B
|
2005-06-16 07:06:03 +00:00
|
|
|
if (N1.Val->getOperand(1) == N2 &&
|
|
|
|
!MVT::isFloatingPoint(N2.getValueType()))
|
Add a simple transformation. This allows us to compile one of the inner
loops in stepanov to this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
cmpl $2000, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
instead of this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
movl $data, %ecx
movl %ecx, %edx
addl $16000, %edx
subl %ecx, %edx
movl %edx, %ecx
sarl $2, %ecx
shrl $29, %ecx
addl %ecx, %edx
sarl $3, %edx
cmpl %edx, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
The old instruction selector produced:
.LBB_Z5test0PdS__2: # no_exit.1
fldl 24(%esp)
faddl data(,%eax,8)
fstl 24(%esp)
movl %eax, %ecx
incl %ecx
incl %eax
leal data+16000, %edx
movl $data, %edi
subl %edi, %edx
movl %edx, %edi
sarl $2, %edi
shrl $29, %edi
addl %edi, %edx
sarl $3, %edx
cmpl %edx, %ecx
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2 # no_exit.1
Which is even worse!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19419 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:09:57 +00:00
|
|
|
return N1.Val->getOperand(0); // (A+B)-B == A
|
|
|
|
}
|
2005-04-09 03:02:46 +00:00
|
|
|
if (N2.getOpcode() == ISD::FNEG) // (A- (-B) -> A+B
|
|
|
|
return getNode(ISD::ADD, VT, N1, N2.getOperand(0));
|
2005-09-08 20:18:10 +00:00
|
|
|
}
|
Add a simple transformation. This allows us to compile one of the inner
loops in stepanov to this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
cmpl $2000, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
instead of this:
.LBB_Z5test0PdS__2: # no_exit.1
fldl data(,%eax,8)
fldl 24(%esp)
faddp %st(1)
fstl 24(%esp)
incl %eax
movl $data, %ecx
movl %ecx, %edx
addl $16000, %edx
subl %ecx, %edx
movl %edx, %ecx
sarl $2, %ecx
shrl $29, %ecx
addl %ecx, %edx
sarl $3, %edx
cmpl %edx, %eax
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2
The old instruction selector produced:
.LBB_Z5test0PdS__2: # no_exit.1
fldl 24(%esp)
faddl data(,%eax,8)
fstl 24(%esp)
movl %eax, %ecx
incl %ecx
incl %eax
leal data+16000, %edx
movl $data, %edi
subl %edi, %edx
movl %edx, %edi
sarl $2, %edi
shrl $29, %edi
addl %edi, %edx
sarl $3, %edx
cmpl %edx, %ecx
fstpl 16(%esp)
#FP_REG_KILL
jl .LBB_Z5test0PdS__2 # no_exit.1
Which is even worse!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19419 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-09 20:09:57 +00:00
|
|
|
break;
|
2005-07-10 00:07:11 +00:00
|
|
|
case ISD::FP_ROUND_INREG:
|
|
|
|
if (cast<VTSDNode>(N2)->getVT() == VT) return N1; // Not actually rounding.
|
|
|
|
break;
|
|
|
|
case ISD::SIGN_EXTEND_INREG: {
|
|
|
|
MVT::ValueType EVT = cast<VTSDNode>(N2)->getVT();
|
|
|
|
if (EVT == VT) return N1; // Not actually extending
|
2005-09-08 20:18:10 +00:00
|
|
|
if (!CombinerEnabled) {
|
2005-07-10 00:07:11 +00:00
|
|
|
// If we are sign extending an extension, use the original source.
|
Add support for AssertSext and AssertZext, folding other extensions with
them. This allows for elminination of redundant extends in the entry
blocks of functions on PowerPC.
Add support for i32 x i32 -> i64 multiplies, by recognizing when the inputs
to ISD::MUL in ExpandOp are actually just extended i32 values and not real
i64 values. this allows us to codegen
int mulhs(int a, int b) { return ((long long)a * b) >> 32; }
as:
_mulhs:
mulhw r3, r4, r3
blr
instead of:
_mulhs:
mulhwu r2, r4, r3
srawi r5, r3, 31
mullw r5, r4, r5
add r2, r2, r5
srawi r4, r4, 31
mullw r3, r4, r3
add r3, r2, r3
blr
with a similar improvement on x86.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23147 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-30 02:44:00 +00:00
|
|
|
if (N1.getOpcode() == ISD::SIGN_EXTEND_INREG ||
|
|
|
|
N1.getOpcode() == ISD::AssertSext)
|
2005-07-10 00:07:11 +00:00
|
|
|
if (cast<VTSDNode>(N1.getOperand(1))->getVT() <= EVT)
|
|
|
|
return N1;
|
2005-07-27 06:12:32 +00:00
|
|
|
|
2005-07-10 00:07:11 +00:00
|
|
|
// If we are sign extending a sextload, return just the load.
|
|
|
|
if (N1.getOpcode() == ISD::SEXTLOAD)
|
2005-07-10 01:55:33 +00:00
|
|
|
if (cast<VTSDNode>(N1.getOperand(3))->getVT() <= EVT)
|
Add support for AssertSext and AssertZext, folding other extensions with
them. This allows for elminination of redundant extends in the entry
blocks of functions on PowerPC.
Add support for i32 x i32 -> i64 multiplies, by recognizing when the inputs
to ISD::MUL in ExpandOp are actually just extended i32 values and not real
i64 values. this allows us to codegen
int mulhs(int a, int b) { return ((long long)a * b) >> 32; }
as:
_mulhs:
mulhw r3, r4, r3
blr
instead of:
_mulhs:
mulhwu r2, r4, r3
srawi r5, r3, 31
mullw r5, r4, r5
add r2, r2, r5
srawi r4, r4, 31
mullw r3, r4, r3
add r3, r2, r3
blr
with a similar improvement on x86.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23147 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-30 02:44:00 +00:00
|
|
|
return N1;
|
2005-07-10 00:07:11 +00:00
|
|
|
|
|
|
|
// If we are extending the result of a setcc, and we already know the
|
|
|
|
// contents of the top bits, eliminate the extension.
|
|
|
|
if (N1.getOpcode() == ISD::SETCC &&
|
|
|
|
TLI.getSetCCResultContents() ==
|
|
|
|
TargetLowering::ZeroOrNegativeOneSetCCResult)
|
|
|
|
return N1;
|
Add support for AssertSext and AssertZext, folding other extensions with
them. This allows for elminination of redundant extends in the entry
blocks of functions on PowerPC.
Add support for i32 x i32 -> i64 multiplies, by recognizing when the inputs
to ISD::MUL in ExpandOp are actually just extended i32 values and not real
i64 values. this allows us to codegen
int mulhs(int a, int b) { return ((long long)a * b) >> 32; }
as:
_mulhs:
mulhw r3, r4, r3
blr
instead of:
_mulhs:
mulhwu r2, r4, r3
srawi r5, r3, 31
mullw r5, r4, r5
add r2, r2, r5
srawi r4, r4, 31
mullw r3, r4, r3
add r3, r2, r3
blr
with a similar improvement on x86.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23147 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-30 02:44:00 +00:00
|
|
|
|
2005-07-10 00:07:11 +00:00
|
|
|
// If we are sign extending the result of an (and X, C) operation, and we
|
|
|
|
// know the extended bits are zeros already, don't do the extend.
|
|
|
|
if (N1.getOpcode() == ISD::AND)
|
|
|
|
if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getOperand(1))) {
|
|
|
|
uint64_t Mask = N1C->getValue();
|
|
|
|
unsigned NumBits = MVT::getSizeInBits(EVT);
|
|
|
|
if ((Mask & (~0ULL << (NumBits-1))) == 0)
|
|
|
|
return N1;
|
|
|
|
}
|
2005-09-08 20:18:10 +00:00
|
|
|
}
|
2005-07-10 00:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-04-13 21:23:31 +00:00
|
|
|
// FIXME: figure out how to safely handle things like
|
|
|
|
// int foo(int x) { return 1 << (x & 255); }
|
|
|
|
// int bar() { return foo(256); }
|
|
|
|
#if 0
|
2005-04-12 23:32:28 +00:00
|
|
|
case ISD::SHL:
|
|
|
|
case ISD::SRL:
|
|
|
|
case ISD::SRA:
|
2005-04-13 02:58:13 +00:00
|
|
|
if (N2.getOpcode() == ISD::SIGN_EXTEND_INREG &&
|
2005-07-10 00:07:11 +00:00
|
|
|
cast<VTSDNode>(N2.getOperand(1))->getVT() != MVT::i1)
|
2005-04-12 23:32:28 +00:00
|
|
|
return getNode(Opcode, VT, N1, N2.getOperand(0));
|
2005-04-13 02:58:13 +00:00
|
|
|
else if (N2.getOpcode() == ISD::AND)
|
|
|
|
if (ConstantSDNode *AndRHS = dyn_cast<ConstantSDNode>(N2.getOperand(1))) {
|
|
|
|
// If the and is only masking out bits that cannot effect the shift,
|
|
|
|
// eliminate the and.
|
|
|
|
unsigned NumBits = MVT::getSizeInBits(VT);
|
|
|
|
if ((AndRHS->getValue() & (NumBits-1)) == NumBits-1)
|
|
|
|
return getNode(Opcode, VT, N1, N2.getOperand(0));
|
|
|
|
}
|
2005-04-12 23:32:28 +00:00
|
|
|
break;
|
2005-04-13 21:23:31 +00:00
|
|
|
#endif
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2005-05-11 18:57:39 +00:00
|
|
|
// Memoize this node if possible.
|
|
|
|
SDNode *N;
|
2005-08-25 19:12:10 +00:00
|
|
|
if (Opcode != ISD::CALLSEQ_START && Opcode != ISD::CALLSEQ_END &&
|
|
|
|
VT != MVT::Flag) {
|
2005-05-11 18:57:39 +00:00
|
|
|
SDNode *&BON = BinaryOps[std::make_pair(Opcode, std::make_pair(N1, N2))];
|
|
|
|
if (BON) return SDOperand(BON, 0);
|
|
|
|
|
|
|
|
BON = N = new SDNode(Opcode, N1, N2);
|
|
|
|
} else {
|
2005-05-12 00:17:04 +00:00
|
|
|
N = new SDNode(Opcode, N1, N2);
|
2005-05-11 18:57:39 +00:00
|
|
|
}
|
|
|
|
|
2005-05-14 07:45:46 +00:00
|
|
|
N->setValueTypes(VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-05-12 00:17:04 +00:00
|
|
|
// setAdjCallChain - This method changes the token chain of an
|
2005-05-12 23:24:06 +00:00
|
|
|
// CALLSEQ_START/END node to be the specified operand.
|
2005-05-11 18:57:39 +00:00
|
|
|
void SDNode::setAdjCallChain(SDOperand N) {
|
|
|
|
assert(N.getValueType() == MVT::Other);
|
2005-05-12 23:24:06 +00:00
|
|
|
assert((getOpcode() == ISD::CALLSEQ_START ||
|
|
|
|
getOpcode() == ISD::CALLSEQ_END) && "Cannot adjust this node!");
|
2005-05-11 18:57:39 +00:00
|
|
|
|
|
|
|
Operands[0].Val->removeUser(this);
|
|
|
|
Operands[0] = N;
|
|
|
|
N.Val->Uses.push_back(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getLoad(MVT::ValueType VT,
|
2005-07-27 06:12:32 +00:00
|
|
|
SDOperand Chain, SDOperand Ptr,
|
2005-04-27 20:10:01 +00:00
|
|
|
SDOperand SV) {
|
2005-01-07 07:46:32 +00:00
|
|
|
SDNode *&N = Loads[std::make_pair(Ptr, std::make_pair(Chain, VT))];
|
|
|
|
if (N) return SDOperand(N, 0);
|
2005-04-27 20:10:01 +00:00
|
|
|
N = new SDNode(ISD::LOAD, Chain, Ptr, SV);
|
2005-01-07 07:46:32 +00:00
|
|
|
|
|
|
|
// Loads have a token chain.
|
|
|
|
N->setValueTypes(VT, MVT::Other);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-07-10 01:55:33 +00:00
|
|
|
|
|
|
|
SDOperand SelectionDAG::getExtLoad(unsigned Opcode, MVT::ValueType VT,
|
|
|
|
SDOperand Chain, SDOperand Ptr, SDOperand SV,
|
|
|
|
MVT::ValueType EVT) {
|
|
|
|
std::vector<SDOperand> Ops;
|
|
|
|
Ops.reserve(4);
|
|
|
|
Ops.push_back(Chain);
|
|
|
|
Ops.push_back(Ptr);
|
|
|
|
Ops.push_back(SV);
|
|
|
|
Ops.push_back(getValueType(EVT));
|
|
|
|
std::vector<MVT::ValueType> VTs;
|
|
|
|
VTs.reserve(2);
|
|
|
|
VTs.push_back(VT); VTs.push_back(MVT::Other); // Add token chain.
|
|
|
|
return getNode(Opcode, VTs, Ops);
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
|
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3) {
|
|
|
|
// Perform various simplifications.
|
|
|
|
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.Val);
|
|
|
|
ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.Val);
|
|
|
|
ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N3.Val);
|
|
|
|
switch (Opcode) {
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::SETCC: {
|
|
|
|
// Use SimplifySetCC to simplify SETCC's.
|
2005-08-09 23:09:05 +00:00
|
|
|
SDOperand Simp = SimplifySetCC(VT, N1, N2, cast<CondCodeSDNode>(N3)->get());
|
2005-08-09 20:20:18 +00:00
|
|
|
if (Simp.Val) return Simp;
|
|
|
|
break;
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
case ISD::SELECT:
|
|
|
|
if (N1C)
|
|
|
|
if (N1C->getValue())
|
|
|
|
return N2; // select true, X, Y -> X
|
2005-04-21 22:36:52 +00:00
|
|
|
else
|
2005-01-07 07:46:32 +00:00
|
|
|
return N3; // select false, X, Y -> Y
|
|
|
|
|
|
|
|
if (N2 == N3) return N2; // select C, X, X -> X
|
|
|
|
|
|
|
|
if (VT == MVT::i1) { // Boolean SELECT
|
|
|
|
if (N2C) {
|
|
|
|
if (N2C->getValue()) // select C, 1, X -> C | X
|
|
|
|
return getNode(ISD::OR, VT, N1, N3);
|
|
|
|
else // select C, 0, X -> ~C & X
|
|
|
|
return getNode(ISD::AND, VT,
|
|
|
|
getNode(ISD::XOR, N1.getValueType(), N1,
|
|
|
|
getConstant(1, N1.getValueType())), N3);
|
|
|
|
} else if (N3C) {
|
|
|
|
if (N3C->getValue()) // select C, X, 1 -> ~C | X
|
|
|
|
return getNode(ISD::OR, VT,
|
|
|
|
getNode(ISD::XOR, N1.getValueType(), N1,
|
|
|
|
getConstant(1, N1.getValueType())), N2);
|
|
|
|
else // select C, X, 0 -> C & X
|
|
|
|
return getNode(ISD::AND, VT, N1, N2);
|
|
|
|
}
|
Remove some redundant checks, add a couple of new ones. This allows us to
compile this:
int foo (unsigned long a, unsigned long long g) {
return a >= g;
}
To:
foo:
movl 8(%esp), %eax
cmpl %eax, 4(%esp)
setae %al
cmpl $0, 12(%esp)
sete %cl
andb %al, %cl
movzbl %cl, %eax
ret
instead of:
foo:
movl 8(%esp), %eax
cmpl %eax, 4(%esp)
setae %al
movzbw %al, %cx
movl 12(%esp), %edx
cmpl $0, %edx
sete %al
movzbw %al, %ax
cmpl $0, %edx
cmove %cx, %ax
movzbl %al, %eax
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21244 91177308-0d34-0410-b5e6-96231b3b80d8
2005-04-12 02:54:39 +00:00
|
|
|
|
|
|
|
if (N1 == N2) // X ? X : Y --> X ? 1 : Y --> X | Y
|
|
|
|
return getNode(ISD::OR, VT, N1, N3);
|
|
|
|
if (N1 == N3) // X ? Y : X --> X ? Y : 0 --> X & Y
|
|
|
|
return getNode(ISD::AND, VT, N1, N2);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2005-08-13 06:00:21 +00:00
|
|
|
if (N1.getOpcode() == ISD::SETCC) {
|
2005-08-13 06:14:17 +00:00
|
|
|
SDOperand Simp = SimplifySelectCC(N1.getOperand(0), N1.getOperand(1), N2,
|
|
|
|
N3, cast<CondCodeSDNode>(N1.getOperand(2))->get());
|
2005-08-13 06:00:21 +00:00
|
|
|
if (Simp.Val) return Simp;
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
2005-01-07 22:49:57 +00:00
|
|
|
case ISD::BRCOND:
|
|
|
|
if (N2C)
|
|
|
|
if (N2C->getValue()) // Unconditional branch
|
|
|
|
return getNode(ISD::BR, MVT::Other, N1, N3);
|
|
|
|
else
|
|
|
|
return N1; // Never-taken branch
|
2005-01-07 23:32:00 +00:00
|
|
|
break;
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2005-05-14 07:42:29 +00:00
|
|
|
std::vector<SDOperand> Ops;
|
|
|
|
Ops.reserve(3);
|
|
|
|
Ops.push_back(N1);
|
|
|
|
Ops.push_back(N2);
|
|
|
|
Ops.push_back(N3);
|
|
|
|
|
2005-08-25 19:12:10 +00:00
|
|
|
// Memoize node if it doesn't produce a flag.
|
|
|
|
SDNode *N;
|
|
|
|
if (VT != MVT::Flag) {
|
|
|
|
SDNode *&E = OneResultNodes[std::make_pair(Opcode,std::make_pair(VT, Ops))];
|
|
|
|
if (E) return SDOperand(E, 0);
|
|
|
|
E = N = new SDNode(Opcode, N1, N2, N3);
|
|
|
|
} else {
|
|
|
|
N = new SDNode(Opcode, N1, N2, N3);
|
|
|
|
}
|
2005-05-14 07:29:57 +00:00
|
|
|
N->setValueTypes(VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-04-27 20:10:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
|
2005-07-27 06:12:32 +00:00
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3,
|
2005-04-27 20:10:01 +00:00
|
|
|
SDOperand N4) {
|
2005-05-14 07:32:14 +00:00
|
|
|
std::vector<SDOperand> Ops;
|
|
|
|
Ops.reserve(4);
|
|
|
|
Ops.push_back(N1);
|
|
|
|
Ops.push_back(N2);
|
|
|
|
Ops.push_back(N3);
|
|
|
|
Ops.push_back(N4);
|
|
|
|
return getNode(Opcode, VT, Ops);
|
2005-04-27 20:10:01 +00:00
|
|
|
}
|
|
|
|
|
2005-07-10 00:29:18 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
|
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3,
|
|
|
|
SDOperand N4, SDOperand N5) {
|
|
|
|
std::vector<SDOperand> Ops;
|
|
|
|
Ops.reserve(5);
|
|
|
|
Ops.push_back(N1);
|
|
|
|
Ops.push_back(N2);
|
|
|
|
Ops.push_back(N3);
|
|
|
|
Ops.push_back(N4);
|
|
|
|
Ops.push_back(N5);
|
|
|
|
return getNode(Opcode, VT, Ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-05-09 04:14:13 +00:00
|
|
|
SDOperand SelectionDAG::getSrcValue(const Value *V, int Offset) {
|
2005-06-29 18:54:02 +00:00
|
|
|
assert((!V || isa<PointerType>(V->getType())) &&
|
|
|
|
"SrcValue is not a pointer?");
|
2005-05-09 04:14:13 +00:00
|
|
|
SDNode *&N = ValueNodes[std::make_pair(V, Offset)];
|
|
|
|
if (N) return SDOperand(N, 0);
|
|
|
|
|
|
|
|
N = new SrcValueSDNode(V, Offset);
|
2005-04-27 20:10:01 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
|
2005-05-14 06:20:26 +00:00
|
|
|
std::vector<SDOperand> &Ops) {
|
|
|
|
switch (Ops.size()) {
|
2005-01-07 07:46:32 +00:00
|
|
|
case 0: return getNode(Opcode, VT);
|
2005-05-14 06:20:26 +00:00
|
|
|
case 1: return getNode(Opcode, VT, Ops[0]);
|
|
|
|
case 2: return getNode(Opcode, VT, Ops[0], Ops[1]);
|
|
|
|
case 3: return getNode(Opcode, VT, Ops[0], Ops[1], Ops[2]);
|
2005-04-09 03:27:28 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
2005-05-14 06:20:26 +00:00
|
|
|
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Ops[1].Val);
|
2005-04-09 03:27:28 +00:00
|
|
|
switch (Opcode) {
|
|
|
|
default: break;
|
|
|
|
case ISD::BRCONDTWOWAY:
|
|
|
|
if (N1C)
|
|
|
|
if (N1C->getValue()) // Unconditional branch to true dest.
|
2005-05-14 06:20:26 +00:00
|
|
|
return getNode(ISD::BR, MVT::Other, Ops[0], Ops[2]);
|
2005-04-09 03:27:28 +00:00
|
|
|
else // Unconditional branch to false dest.
|
2005-05-14 06:20:26 +00:00
|
|
|
return getNode(ISD::BR, MVT::Other, Ops[0], Ops[3]);
|
2005-04-09 03:27:28 +00:00
|
|
|
break;
|
2005-08-16 19:49:35 +00:00
|
|
|
case ISD::BRTWOWAY_CC:
|
|
|
|
assert(Ops.size() == 6 && "BRTWOWAY_CC takes 6 operands!");
|
|
|
|
assert(Ops[2].getValueType() == Ops[3].getValueType() &&
|
|
|
|
"LHS and RHS of comparison must have same type!");
|
|
|
|
break;
|
2005-07-10 00:29:18 +00:00
|
|
|
case ISD::TRUNCSTORE: {
|
|
|
|
assert(Ops.size() == 5 && "TRUNCSTORE takes 5 operands!");
|
|
|
|
MVT::ValueType EVT = cast<VTSDNode>(Ops[4])->getVT();
|
|
|
|
#if 0 // FIXME: If the target supports EVT natively, convert to a truncate/store
|
|
|
|
// If this is a truncating store of a constant, convert to the desired type
|
|
|
|
// and store it instead.
|
|
|
|
if (isa<Constant>(Ops[0])) {
|
|
|
|
SDOperand Op = getNode(ISD::TRUNCATE, EVT, N1);
|
|
|
|
if (isa<Constant>(Op))
|
|
|
|
N1 = Op;
|
|
|
|
}
|
|
|
|
// Also for ConstantFP?
|
|
|
|
#endif
|
|
|
|
if (Ops[0].getValueType() == EVT) // Normal store?
|
|
|
|
return getNode(ISD::STORE, VT, Ops[0], Ops[1], Ops[2], Ops[3]);
|
|
|
|
assert(Ops[1].getValueType() > EVT && "Not a truncation?");
|
|
|
|
assert(MVT::isInteger(Ops[1].getValueType()) == MVT::isInteger(EVT) &&
|
|
|
|
"Can't do FP-INT conversion!");
|
|
|
|
break;
|
|
|
|
}
|
2005-08-24 22:44:39 +00:00
|
|
|
case ISD::SELECT_CC: {
|
|
|
|
assert(Ops.size() == 5 && "TRUNCSTORE takes 5 operands!");
|
|
|
|
assert(Ops[0].getValueType() == Ops[1].getValueType() &&
|
|
|
|
"LHS and RHS of condition must have same type!");
|
|
|
|
assert(Ops[2].getValueType() == Ops[3].getValueType() &&
|
|
|
|
"True and False arms of SelectCC must have same type!");
|
|
|
|
assert(Ops[2].getValueType() == VT &&
|
|
|
|
"select_cc node must be of same type as true and false value!");
|
|
|
|
SDOperand Simp = SimplifySelectCC(Ops[0], Ops[1], Ops[2], Ops[3],
|
|
|
|
cast<CondCodeSDNode>(Ops[4])->get());
|
|
|
|
if (Simp.Val) return Simp;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::BR_CC: {
|
|
|
|
assert(Ops.size() == 5 && "TRUNCSTORE takes 5 operands!");
|
|
|
|
assert(Ops[2].getValueType() == Ops[3].getValueType() &&
|
|
|
|
"LHS/RHS of comparison should match types!");
|
|
|
|
// Use SimplifySetCC to simplify SETCC's.
|
|
|
|
SDOperand Simp = SimplifySetCC(MVT::i1, Ops[2], Ops[3],
|
|
|
|
cast<CondCodeSDNode>(Ops[1])->get());
|
|
|
|
if (Simp.Val) {
|
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Simp)) {
|
|
|
|
if (C->getValue() & 1) // Unconditional branch
|
|
|
|
return getNode(ISD::BR, MVT::Other, Ops[0], Ops[4]);
|
|
|
|
else
|
|
|
|
return Ops[0]; // Unconditional Fall through
|
|
|
|
} else if (Simp.Val->getOpcode() == ISD::SETCC) {
|
|
|
|
Ops[2] = Simp.getOperand(0);
|
|
|
|
Ops[3] = Simp.getOperand(1);
|
|
|
|
Ops[1] = Simp.getOperand(2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2005-04-09 03:27:28 +00:00
|
|
|
}
|
|
|
|
|
2005-05-14 07:42:29 +00:00
|
|
|
// Memoize nodes.
|
2005-08-25 19:12:10 +00:00
|
|
|
SDNode *N;
|
|
|
|
if (VT != MVT::Flag) {
|
|
|
|
SDNode *&E =
|
|
|
|
OneResultNodes[std::make_pair(Opcode, std::make_pair(VT, Ops))];
|
|
|
|
if (E) return SDOperand(E, 0);
|
|
|
|
E = N = new SDNode(Opcode, Ops);
|
|
|
|
} else {
|
|
|
|
N = new SDNode(Opcode, Ops);
|
|
|
|
}
|
2005-05-14 07:25:05 +00:00
|
|
|
N->setValueTypes(VT);
|
2005-04-09 03:27:28 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2005-05-14 06:20:26 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode,
|
|
|
|
std::vector<MVT::ValueType> &ResultTys,
|
|
|
|
std::vector<SDOperand> &Ops) {
|
|
|
|
if (ResultTys.size() == 1)
|
|
|
|
return getNode(Opcode, ResultTys[0], Ops);
|
|
|
|
|
2005-07-10 01:55:33 +00:00
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::EXTLOAD:
|
|
|
|
case ISD::SEXTLOAD:
|
|
|
|
case ISD::ZEXTLOAD: {
|
|
|
|
MVT::ValueType EVT = cast<VTSDNode>(Ops[3])->getVT();
|
|
|
|
assert(Ops.size() == 4 && ResultTys.size() == 2 && "Bad *EXTLOAD!");
|
|
|
|
// If they are asking for an extending load from/to the same thing, return a
|
|
|
|
// normal load.
|
|
|
|
if (ResultTys[0] == EVT)
|
|
|
|
return getLoad(ResultTys[0], Ops[0], Ops[1], Ops[2]);
|
|
|
|
assert(EVT < ResultTys[0] &&
|
|
|
|
"Should only be an extending load, not truncating!");
|
|
|
|
assert((Opcode == ISD::EXTLOAD || MVT::isInteger(ResultTys[0])) &&
|
|
|
|
"Cannot sign/zero extend a FP load!");
|
|
|
|
assert(MVT::isInteger(ResultTys[0]) == MVT::isInteger(EVT) &&
|
|
|
|
"Cannot convert from FP to Int or Int -> FP!");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-05-14 07:25:05 +00:00
|
|
|
// FIXME: figure out how to safely handle things like
|
|
|
|
// int foo(int x) { return 1 << (x & 255); }
|
|
|
|
// int bar() { return foo(256); }
|
|
|
|
#if 0
|
|
|
|
case ISD::SRA_PARTS:
|
|
|
|
case ISD::SRL_PARTS:
|
|
|
|
case ISD::SHL_PARTS:
|
|
|
|
if (N3.getOpcode() == ISD::SIGN_EXTEND_INREG &&
|
2005-07-10 00:07:11 +00:00
|
|
|
cast<VTSDNode>(N3.getOperand(1))->getVT() != MVT::i1)
|
2005-05-14 07:25:05 +00:00
|
|
|
return getNode(Opcode, VT, N1, N2, N3.getOperand(0));
|
|
|
|
else if (N3.getOpcode() == ISD::AND)
|
|
|
|
if (ConstantSDNode *AndRHS = dyn_cast<ConstantSDNode>(N3.getOperand(1))) {
|
|
|
|
// If the and is only masking out bits that cannot effect the shift,
|
|
|
|
// eliminate the and.
|
|
|
|
unsigned NumBits = MVT::getSizeInBits(VT)*2;
|
|
|
|
if ((AndRHS->getValue() & (NumBits-1)) == NumBits-1)
|
|
|
|
return getNode(Opcode, VT, N1, N2, N3.getOperand(0));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
2005-07-10 01:55:33 +00:00
|
|
|
}
|
2005-05-14 06:20:26 +00:00
|
|
|
|
2005-08-25 19:12:10 +00:00
|
|
|
// Memoize the node unless it returns a flag.
|
|
|
|
SDNode *N;
|
|
|
|
if (ResultTys.back() != MVT::Flag) {
|
|
|
|
SDNode *&E =
|
|
|
|
ArbitraryNodes[std::make_pair(Opcode, std::make_pair(ResultTys, Ops))];
|
|
|
|
if (E) return SDOperand(E, 0);
|
|
|
|
E = N = new SDNode(Opcode, Ops);
|
|
|
|
} else {
|
|
|
|
N = new SDNode(Opcode, Ops);
|
|
|
|
}
|
2005-05-14 06:20:26 +00:00
|
|
|
N->setValueTypes(ResultTys);
|
2005-05-14 06:42:57 +00:00
|
|
|
AllNodes.push_back(N);
|
2005-05-14 06:20:26 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-08-16 18:17:10 +00:00
|
|
|
|
|
|
|
/// SelectNodeTo - These are used for target selectors to *mutate* the
|
|
|
|
/// specified node to have the specified return type, Target opcode, and
|
|
|
|
/// operands. Note that target opcodes are stored as
|
|
|
|
/// ISD::BUILTIN_OP_END+TargetOpcode in the node opcode field.
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
|
|
|
MVT::ValueType VT) {
|
2005-08-24 23:00:29 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT);
|
|
|
|
}
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
|
|
|
MVT::ValueType VT, SDOperand Op1) {
|
2005-08-16 18:17:10 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT);
|
|
|
|
N->setOperands(Op1);
|
|
|
|
}
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
|
|
|
MVT::ValueType VT, SDOperand Op1,
|
2005-08-16 18:17:10 +00:00
|
|
|
SDOperand Op2) {
|
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT);
|
|
|
|
N->setOperands(Op1, Op2);
|
|
|
|
}
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
2005-08-21 19:48:59 +00:00
|
|
|
MVT::ValueType VT1, MVT::ValueType VT2,
|
2005-08-26 16:36:26 +00:00
|
|
|
SDOperand Op1, SDOperand Op2) {
|
2005-08-21 19:48:59 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT1, VT2);
|
|
|
|
N->setOperands(Op1, Op2);
|
|
|
|
}
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
|
|
|
MVT::ValueType VT, SDOperand Op1,
|
2005-08-16 18:17:10 +00:00
|
|
|
SDOperand Op2, SDOperand Op3) {
|
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT);
|
|
|
|
N->setOperands(Op1, Op2, Op3);
|
|
|
|
}
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
|
|
|
MVT::ValueType VT1, MVT::ValueType VT2,
|
|
|
|
SDOperand Op1, SDOperand Op2, SDOperand Op3) {
|
2005-08-21 22:30:30 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT1, VT2);
|
|
|
|
N->setOperands(Op1, Op2, Op3);
|
|
|
|
}
|
|
|
|
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
|
|
|
MVT::ValueType VT, SDOperand Op1,
|
2005-08-18 07:30:15 +00:00
|
|
|
SDOperand Op2, SDOperand Op3, SDOperand Op4) {
|
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT);
|
|
|
|
N->setOperands(Op1, Op2, Op3, Op4);
|
|
|
|
}
|
2005-08-26 16:36:26 +00:00
|
|
|
void SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
|
|
|
|
MVT::ValueType VT, SDOperand Op1,
|
2005-08-21 18:49:33 +00:00
|
|
|
SDOperand Op2, SDOperand Op3, SDOperand Op4,
|
|
|
|
SDOperand Op5) {
|
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
|
|
|
|
N->setValueTypes(VT);
|
|
|
|
N->setOperands(Op1, Op2, Op3, Op4, Op5);
|
|
|
|
}
|
2005-08-16 18:17:10 +00:00
|
|
|
|
2005-08-17 19:00:20 +00:00
|
|
|
/// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
|
|
|
|
/// This can cause recursive merging of nodes in the DAG.
|
|
|
|
///
|
2005-08-26 18:36:28 +00:00
|
|
|
/// This version assumes From/To have a single result value.
|
|
|
|
///
|
2005-09-07 05:37:01 +00:00
|
|
|
void SelectionDAG::ReplaceAllUsesWith(SDOperand FromN, SDOperand ToN,
|
|
|
|
std::vector<SDNode*> *Deleted) {
|
2005-08-26 18:36:28 +00:00
|
|
|
SDNode *From = FromN.Val, *To = ToN.Val;
|
|
|
|
assert(From->getNumValues() == 1 && To->getNumValues() == 1 &&
|
|
|
|
"Cannot replace with this method!");
|
|
|
|
assert(From != To && "Cannot replace uses of with self");
|
|
|
|
|
|
|
|
while (!From->use_empty()) {
|
|
|
|
// Process users until they are all gone.
|
|
|
|
SDNode *U = *From->use_begin();
|
|
|
|
|
|
|
|
// This node is about to morph, remove its old self from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(U);
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = U->getNumOperands(); i != e; ++i)
|
|
|
|
if (U->getOperand(i).Val == From) {
|
|
|
|
From->removeUser(U);
|
|
|
|
U->Operands[i].Val = To;
|
|
|
|
To->addUser(U);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we have modified U, add it back to the CSE maps. If it already
|
|
|
|
// exists there, recursively merge the results together.
|
2005-09-07 05:37:01 +00:00
|
|
|
if (SDNode *Existing = AddNonLeafNodeToCSEMaps(U)) {
|
|
|
|
ReplaceAllUsesWith(U, Existing, Deleted);
|
2005-08-26 18:36:28 +00:00
|
|
|
// U is now dead.
|
2005-09-07 05:37:01 +00:00
|
|
|
if (Deleted) Deleted->push_back(U);
|
|
|
|
DeleteNodeNotInCSEMaps(U);
|
|
|
|
}
|
2005-08-26 18:36:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
|
|
|
|
/// This can cause recursive merging of nodes in the DAG.
|
|
|
|
///
|
|
|
|
/// This version assumes From/To have matching types and numbers of result
|
|
|
|
/// values.
|
|
|
|
///
|
2005-09-07 05:37:01 +00:00
|
|
|
void SelectionDAG::ReplaceAllUsesWith(SDNode *From, SDNode *To,
|
|
|
|
std::vector<SDNode*> *Deleted) {
|
2005-08-17 19:00:20 +00:00
|
|
|
assert(From != To && "Cannot replace uses of with self");
|
2005-08-26 18:36:28 +00:00
|
|
|
assert(From->getNumValues() == To->getNumValues() &&
|
|
|
|
"Cannot use this version of ReplaceAllUsesWith!");
|
|
|
|
if (From->getNumValues() == 1) { // If possible, use the faster version.
|
2005-09-07 05:37:01 +00:00
|
|
|
ReplaceAllUsesWith(SDOperand(From, 0), SDOperand(To, 0), Deleted);
|
2005-08-26 18:36:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-08-17 19:00:20 +00:00
|
|
|
while (!From->use_empty()) {
|
|
|
|
// Process users until they are all gone.
|
|
|
|
SDNode *U = *From->use_begin();
|
|
|
|
|
|
|
|
// This node is about to morph, remove its old self from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(U);
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = U->getNumOperands(); i != e; ++i)
|
|
|
|
if (U->getOperand(i).Val == From) {
|
|
|
|
From->removeUser(U);
|
|
|
|
U->Operands[i].Val = To;
|
|
|
|
To->addUser(U);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we have modified U, add it back to the CSE maps. If it already
|
|
|
|
// exists there, recursively merge the results together.
|
2005-09-07 05:37:01 +00:00
|
|
|
if (SDNode *Existing = AddNonLeafNodeToCSEMaps(U)) {
|
|
|
|
ReplaceAllUsesWith(U, Existing, Deleted);
|
|
|
|
// U is now dead.
|
|
|
|
if (Deleted) Deleted->push_back(U);
|
|
|
|
DeleteNodeNotInCSEMaps(U);
|
|
|
|
}
|
2005-08-17 19:00:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-26 18:36:28 +00:00
|
|
|
/// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
|
|
|
|
/// This can cause recursive merging of nodes in the DAG.
|
|
|
|
///
|
|
|
|
/// This version can replace From with any result values. To must match the
|
|
|
|
/// number and types of values returned by From.
|
2005-08-24 22:44:39 +00:00
|
|
|
void SelectionDAG::ReplaceAllUsesWith(SDNode *From,
|
2005-09-07 05:37:01 +00:00
|
|
|
const std::vector<SDOperand> &To,
|
|
|
|
std::vector<SDNode*> *Deleted) {
|
2005-08-24 22:44:39 +00:00
|
|
|
assert(From->getNumValues() == To.size() &&
|
|
|
|
"Incorrect number of values to replace with!");
|
2005-08-28 23:59:36 +00:00
|
|
|
if (To.size() == 1 && To[0].Val->getNumValues() == 1) {
|
2005-08-24 22:44:39 +00:00
|
|
|
// Degenerate case handled above.
|
2005-09-07 05:37:01 +00:00
|
|
|
ReplaceAllUsesWith(SDOperand(From, 0), To[0], Deleted);
|
2005-08-24 22:44:39 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!From->use_empty()) {
|
|
|
|
// Process users until they are all gone.
|
|
|
|
SDNode *U = *From->use_begin();
|
|
|
|
|
|
|
|
// This node is about to morph, remove its old self from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(U);
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = U->getNumOperands(); i != e; ++i)
|
|
|
|
if (U->getOperand(i).Val == From) {
|
|
|
|
const SDOperand &ToOp = To[U->getOperand(i).ResNo];
|
|
|
|
From->removeUser(U);
|
|
|
|
U->Operands[i] = ToOp;
|
|
|
|
ToOp.Val->addUser(U);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we have modified U, add it back to the CSE maps. If it already
|
|
|
|
// exists there, recursively merge the results together.
|
2005-09-07 05:37:01 +00:00
|
|
|
if (SDNode *Existing = AddNonLeafNodeToCSEMaps(U)) {
|
|
|
|
ReplaceAllUsesWith(U, Existing, Deleted);
|
|
|
|
// U is now dead.
|
|
|
|
if (Deleted) Deleted->push_back(U);
|
|
|
|
DeleteNodeNotInCSEMaps(U);
|
|
|
|
}
|
2005-08-24 22:44:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-08-17 20:08:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SDNode Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
2005-08-16 18:17:10 +00:00
|
|
|
|
2005-01-12 18:37:47 +00:00
|
|
|
/// hasNUsesOfValue - Return true if there are exactly NUSES uses of the
|
|
|
|
/// indicated value. This method ignores uses of other values defined by this
|
|
|
|
/// operation.
|
|
|
|
bool SDNode::hasNUsesOfValue(unsigned NUses, unsigned Value) {
|
|
|
|
assert(Value < getNumValues() && "Bad value!");
|
|
|
|
|
|
|
|
// If there is only one value, this is easy.
|
|
|
|
if (getNumValues() == 1)
|
|
|
|
return use_size() == NUses;
|
|
|
|
if (Uses.size() < NUses) return false;
|
|
|
|
|
|
|
|
SDOperand TheValue(this, Value);
|
|
|
|
|
|
|
|
std::set<SDNode*> UsersHandled;
|
|
|
|
|
|
|
|
for (std::vector<SDNode*>::iterator UI = Uses.begin(), E = Uses.end();
|
|
|
|
UI != E; ++UI) {
|
|
|
|
SDNode *User = *UI;
|
|
|
|
if (User->getNumOperands() == 1 ||
|
|
|
|
UsersHandled.insert(User).second) // First time we've seen this?
|
|
|
|
for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i)
|
|
|
|
if (User->getOperand(i) == TheValue) {
|
|
|
|
if (NUses == 0)
|
|
|
|
return false; // too many uses
|
|
|
|
--NUses;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Found exactly the right number of uses?
|
|
|
|
return NUses == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-08-16 18:33:07 +00:00
|
|
|
const char *SDNode::getOperationName(const SelectionDAG *G) const {
|
2005-01-10 23:25:25 +00:00
|
|
|
switch (getOpcode()) {
|
2005-08-16 18:33:07 +00:00
|
|
|
default:
|
|
|
|
if (getOpcode() < ISD::BUILTIN_OP_END)
|
|
|
|
return "<<Unknown DAG Node>>";
|
|
|
|
else {
|
|
|
|
if (G)
|
|
|
|
if (const TargetInstrInfo *TII = G->getTarget().getInstrInfo())
|
2005-09-09 22:35:03 +00:00
|
|
|
if (getOpcode()-ISD::BUILTIN_OP_END < TII->getNumOpcodes())
|
|
|
|
return TII->getName(getOpcode()-ISD::BUILTIN_OP_END);
|
2005-08-16 18:33:07 +00:00
|
|
|
return "<<Unknown Target Node>>";
|
|
|
|
}
|
|
|
|
|
2005-03-31 21:24:06 +00:00
|
|
|
case ISD::PCMARKER: return "PCMarker";
|
2005-05-09 04:08:27 +00:00
|
|
|
case ISD::SRCVALUE: return "SrcValue";
|
2005-08-18 03:31:02 +00:00
|
|
|
case ISD::VALUETYPE: return "ValueType";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::EntryToken: return "EntryToken";
|
2005-01-13 17:59:10 +00:00
|
|
|
case ISD::TokenFactor: return "TokenFactor";
|
Add support for AssertSext and AssertZext, folding other extensions with
them. This allows for elminination of redundant extends in the entry
blocks of functions on PowerPC.
Add support for i32 x i32 -> i64 multiplies, by recognizing when the inputs
to ISD::MUL in ExpandOp are actually just extended i32 values and not real
i64 values. this allows us to codegen
int mulhs(int a, int b) { return ((long long)a * b) >> 32; }
as:
_mulhs:
mulhw r3, r4, r3
blr
instead of:
_mulhs:
mulhwu r2, r4, r3
srawi r5, r3, 31
mullw r5, r4, r5
add r2, r2, r5
srawi r4, r4, 31
mullw r3, r4, r3
add r3, r2, r3
blr
with a similar improvement on x86.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23147 91177308-0d34-0410-b5e6-96231b3b80d8
2005-08-30 02:44:00 +00:00
|
|
|
case ISD::AssertSext: return "AssertSext";
|
|
|
|
case ISD::AssertZext: return "AssertZext";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::Constant: return "Constant";
|
2005-08-17 00:34:06 +00:00
|
|
|
case ISD::TargetConstant: return "TargetConstant";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::ConstantFP: return "ConstantFP";
|
|
|
|
case ISD::GlobalAddress: return "GlobalAddress";
|
2005-08-19 22:31:04 +00:00
|
|
|
case ISD::TargetGlobalAddress: return "TargetGlobalAddress";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::FrameIndex: return "FrameIndex";
|
2005-08-25 00:43:01 +00:00
|
|
|
case ISD::TargetFrameIndex: return "TargetFrameIndex";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::BasicBlock: return "BasicBlock";
|
2005-08-16 21:55:35 +00:00
|
|
|
case ISD::Register: return "Register";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::ExternalSymbol: return "ExternalSymbol";
|
2005-08-26 17:15:30 +00:00
|
|
|
case ISD::ConstantPool: return "ConstantPool";
|
|
|
|
case ISD::TargetConstantPool: return "TargetConstantPool";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::CopyToReg: return "CopyToReg";
|
|
|
|
case ISD::CopyFromReg: return "CopyFromReg";
|
2005-01-13 20:50:02 +00:00
|
|
|
case ISD::ImplicitDef: return "ImplicitDef";
|
2005-04-01 22:34:39 +00:00
|
|
|
case ISD::UNDEF: return "undef";
|
2005-01-10 23:25:25 +00:00
|
|
|
|
2005-04-02 04:58:41 +00:00
|
|
|
// Unary operators
|
|
|
|
case ISD::FABS: return "fabs";
|
|
|
|
case ISD::FNEG: return "fneg";
|
2005-04-28 21:44:03 +00:00
|
|
|
case ISD::FSQRT: return "fsqrt";
|
|
|
|
case ISD::FSIN: return "fsin";
|
|
|
|
case ISD::FCOS: return "fcos";
|
2005-04-02 04:58:41 +00:00
|
|
|
|
|
|
|
// Binary operators
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::ADD: return "add";
|
|
|
|
case ISD::SUB: return "sub";
|
|
|
|
case ISD::MUL: return "mul";
|
2005-04-05 22:36:56 +00:00
|
|
|
case ISD::MULHU: return "mulhu";
|
|
|
|
case ISD::MULHS: return "mulhs";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::SDIV: return "sdiv";
|
|
|
|
case ISD::UDIV: return "udiv";
|
|
|
|
case ISD::SREM: return "srem";
|
|
|
|
case ISD::UREM: return "urem";
|
|
|
|
case ISD::AND: return "and";
|
|
|
|
case ISD::OR: return "or";
|
|
|
|
case ISD::XOR: return "xor";
|
|
|
|
case ISD::SHL: return "shl";
|
|
|
|
case ISD::SRA: return "sra";
|
|
|
|
case ISD::SRL: return "srl";
|
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::SETCC: return "setcc";
|
|
|
|
case ISD::SELECT: return "select";
|
2005-08-10 20:51:12 +00:00
|
|
|
case ISD::SELECT_CC: return "select_cc";
|
2005-01-20 18:50:55 +00:00
|
|
|
case ISD::ADD_PARTS: return "add_parts";
|
|
|
|
case ISD::SUB_PARTS: return "sub_parts";
|
2005-04-02 03:30:42 +00:00
|
|
|
case ISD::SHL_PARTS: return "shl_parts";
|
|
|
|
case ISD::SRA_PARTS: return "sra_parts";
|
|
|
|
case ISD::SRL_PARTS: return "srl_parts";
|
2005-01-10 23:25:25 +00:00
|
|
|
|
2005-04-28 21:44:03 +00:00
|
|
|
// Conversion operators.
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::SIGN_EXTEND: return "sign_extend";
|
|
|
|
case ISD::ZERO_EXTEND: return "zero_extend";
|
2005-09-02 00:17:32 +00:00
|
|
|
case ISD::ANY_EXTEND: return "any_extend";
|
2005-01-15 06:17:04 +00:00
|
|
|
case ISD::SIGN_EXTEND_INREG: return "sign_extend_inreg";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::TRUNCATE: return "truncate";
|
|
|
|
case ISD::FP_ROUND: return "fp_round";
|
2005-01-15 06:17:04 +00:00
|
|
|
case ISD::FP_ROUND_INREG: return "fp_round_inreg";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::FP_EXTEND: return "fp_extend";
|
|
|
|
|
|
|
|
case ISD::SINT_TO_FP: return "sint_to_fp";
|
|
|
|
case ISD::UINT_TO_FP: return "uint_to_fp";
|
|
|
|
case ISD::FP_TO_SINT: return "fp_to_sint";
|
|
|
|
case ISD::FP_TO_UINT: return "fp_to_uint";
|
|
|
|
|
|
|
|
// Control flow instructions
|
|
|
|
case ISD::BR: return "br";
|
|
|
|
case ISD::BRCOND: return "brcond";
|
2005-04-09 03:27:28 +00:00
|
|
|
case ISD::BRCONDTWOWAY: return "brcondtwoway";
|
2005-08-16 19:49:35 +00:00
|
|
|
case ISD::BR_CC: return "br_cc";
|
|
|
|
case ISD::BRTWOWAY_CC: return "brtwoway_cc";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::RET: return "ret";
|
|
|
|
case ISD::CALL: return "call";
|
2005-05-13 18:43:43 +00:00
|
|
|
case ISD::TAILCALL:return "tailcall";
|
2005-05-12 23:51:40 +00:00
|
|
|
case ISD::CALLSEQ_START: return "callseq_start";
|
|
|
|
case ISD::CALLSEQ_END: return "callseq_end";
|
2005-01-10 23:25:25 +00:00
|
|
|
|
|
|
|
// Other operators
|
|
|
|
case ISD::LOAD: return "load";
|
|
|
|
case ISD::STORE: return "store";
|
2005-01-14 22:08:15 +00:00
|
|
|
case ISD::EXTLOAD: return "extload";
|
|
|
|
case ISD::SEXTLOAD: return "sextload";
|
|
|
|
case ISD::ZEXTLOAD: return "zextload";
|
|
|
|
case ISD::TRUNCSTORE: return "truncstore";
|
|
|
|
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";
|
|
|
|
case ISD::EXTRACT_ELEMENT: return "extract_element";
|
|
|
|
case ISD::BUILD_PAIR: return "build_pair";
|
2005-01-11 05:57:01 +00:00
|
|
|
case ISD::MEMSET: return "memset";
|
|
|
|
case ISD::MEMCPY: return "memcpy";
|
|
|
|
case ISD::MEMMOVE: return "memmove";
|
2005-01-07 07:46:32 +00:00
|
|
|
|
2005-05-11 04:50:30 +00:00
|
|
|
// Bit counting
|
|
|
|
case ISD::CTPOP: return "ctpop";
|
|
|
|
case ISD::CTTZ: return "cttz";
|
|
|
|
case ISD::CTLZ: return "ctlz";
|
|
|
|
|
|
|
|
// IO Intrinsics
|
2005-05-09 20:22:17 +00:00
|
|
|
case ISD::READPORT: return "readport";
|
|
|
|
case ISD::WRITEPORT: return "writeport";
|
|
|
|
case ISD::READIO: return "readio";
|
|
|
|
case ISD::WRITEIO: return "writeio";
|
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::CONDCODE:
|
|
|
|
switch (cast<CondCodeSDNode>(this)->get()) {
|
2005-01-10 23:25:25 +00:00
|
|
|
default: assert(0 && "Unknown setcc condition!");
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::SETOEQ: return "setoeq";
|
|
|
|
case ISD::SETOGT: return "setogt";
|
|
|
|
case ISD::SETOGE: return "setoge";
|
|
|
|
case ISD::SETOLT: return "setolt";
|
|
|
|
case ISD::SETOLE: return "setole";
|
|
|
|
case ISD::SETONE: return "setone";
|
|
|
|
|
|
|
|
case ISD::SETO: return "seto";
|
|
|
|
case ISD::SETUO: return "setuo";
|
|
|
|
case ISD::SETUEQ: return "setue";
|
|
|
|
case ISD::SETUGT: return "setugt";
|
|
|
|
case ISD::SETUGE: return "setuge";
|
|
|
|
case ISD::SETULT: return "setult";
|
|
|
|
case ISD::SETULE: return "setule";
|
|
|
|
case ISD::SETUNE: return "setune";
|
|
|
|
|
|
|
|
case ISD::SETEQ: return "seteq";
|
|
|
|
case ISD::SETGT: return "setgt";
|
|
|
|
case ISD::SETGE: return "setge";
|
|
|
|
case ISD::SETLT: return "setlt";
|
|
|
|
case ISD::SETLE: return "setle";
|
|
|
|
case ISD::SETNE: return "setne";
|
2005-01-10 23:25:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
|
2005-08-16 18:33:07 +00:00
|
|
|
void SDNode::dump() const { dump(0); }
|
|
|
|
void SDNode::dump(const SelectionDAG *G) const {
|
2005-01-07 07:46:32 +00:00
|
|
|
std::cerr << (void*)this << ": ";
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
|
|
|
|
if (i) std::cerr << ",";
|
2005-01-15 07:14:32 +00:00
|
|
|
if (getValueType(i) == MVT::Other)
|
|
|
|
std::cerr << "ch";
|
|
|
|
else
|
|
|
|
std::cerr << MVT::getValueTypeString(getValueType(i));
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2005-08-16 18:33:07 +00:00
|
|
|
std::cerr << " = " << getOperationName(G);
|
2005-01-07 07:46:32 +00:00
|
|
|
|
|
|
|
std::cerr << " ";
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
|
|
|
|
if (i) std::cerr << ", ";
|
|
|
|
std::cerr << (void*)getOperand(i).Val;
|
|
|
|
if (unsigned RN = getOperand(i).ResNo)
|
|
|
|
std::cerr << ":" << RN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
|
|
|
|
std::cerr << "<" << CSDN->getValue() << ">";
|
|
|
|
} else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
|
|
|
|
std::cerr << "<" << CSDN->getValue() << ">";
|
2005-04-21 22:36:52 +00:00
|
|
|
} else if (const GlobalAddressSDNode *GADN =
|
2005-01-07 07:46:32 +00:00
|
|
|
dyn_cast<GlobalAddressSDNode>(this)) {
|
|
|
|
std::cerr << "<";
|
|
|
|
WriteAsOperand(std::cerr, GADN->getGlobal()) << ">";
|
2005-04-22 04:01:18 +00:00
|
|
|
} else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
|
2005-01-07 07:46:32 +00:00
|
|
|
std::cerr << "<" << FIDN->getIndex() << ">";
|
|
|
|
} else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
|
2005-08-26 17:15:30 +00:00
|
|
|
std::cerr << "<" << *CP->get() << ">";
|
2005-04-22 04:01:18 +00:00
|
|
|
} else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
|
2005-01-07 07:46:32 +00:00
|
|
|
std::cerr << "<";
|
|
|
|
const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
|
|
|
|
if (LBB)
|
|
|
|
std::cerr << LBB->getName() << " ";
|
|
|
|
std::cerr << (const void*)BBDN->getBasicBlock() << ">";
|
2005-08-19 21:34:13 +00:00
|
|
|
} else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
|
2005-08-19 21:21:16 +00:00
|
|
|
if (G && MRegisterInfo::isPhysicalRegister(R->getReg())) {
|
|
|
|
std::cerr << " " <<G->getTarget().getRegisterInfo()->getName(R->getReg());
|
|
|
|
} else {
|
|
|
|
std::cerr << " #" << R->getReg();
|
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
} else if (const ExternalSymbolSDNode *ES =
|
|
|
|
dyn_cast<ExternalSymbolSDNode>(this)) {
|
|
|
|
std::cerr << "'" << ES->getSymbol() << "'";
|
2005-05-09 04:08:27 +00:00
|
|
|
} else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
|
|
|
|
if (M->getValue())
|
|
|
|
std::cerr << "<" << M->getValue() << ":" << M->getOffset() << ">";
|
|
|
|
else
|
|
|
|
std::cerr << "<null:" << M->getOffset() << ">";
|
2005-08-18 03:31:02 +00:00
|
|
|
} else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
|
|
|
|
std::cerr << ":" << getValueTypeString(N->getVT());
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-16 18:33:07 +00:00
|
|
|
static void DumpNodes(SDNode *N, unsigned indent, const SelectionDAG *G) {
|
2005-01-09 20:38:33 +00:00
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
|
|
|
|
if (N->getOperand(i).Val->hasOneUse())
|
2005-08-16 18:33:07 +00:00
|
|
|
DumpNodes(N->getOperand(i).Val, indent+2, G);
|
2005-01-09 20:38:33 +00:00
|
|
|
else
|
|
|
|
std::cerr << "\n" << std::string(indent+2, ' ')
|
|
|
|
<< (void*)N->getOperand(i).Val << ": <multiple use>";
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-09 20:38:33 +00:00
|
|
|
|
|
|
|
std::cerr << "\n" << std::string(indent, ' ');
|
2005-08-16 18:33:07 +00:00
|
|
|
N->dump(G);
|
2005-01-09 20:38:33 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
void SelectionDAG::dump() const {
|
|
|
|
std::cerr << "SelectionDAG has " << AllNodes.size() << " nodes:";
|
2005-01-09 20:26:36 +00:00
|
|
|
std::vector<SDNode*> Nodes(AllNodes);
|
|
|
|
std::sort(Nodes.begin(), Nodes.end());
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
|
2005-01-09 20:38:33 +00:00
|
|
|
if (!Nodes[i]->hasOneUse() && Nodes[i] != getRoot().Val)
|
2005-08-16 18:33:07 +00:00
|
|
|
DumpNodes(Nodes[i], 2, this);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2005-01-09 20:38:33 +00:00
|
|
|
|
2005-08-16 18:33:07 +00:00
|
|
|
DumpNodes(getRoot().Val, 2, this);
|
2005-01-09 20:38:33 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
std::cerr << "\n\n";
|
|
|
|
}
|
|
|
|
|