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
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
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"
|
2008-06-30 07:31:25 +00:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2008-03-11 22:38:53 +00:00
|
|
|
#include "llvm/GlobalAlias.h"
|
2007-04-20 21:38:10 +00:00
|
|
|
#include "llvm/GlobalVariable.h"
|
2006-03-27 06:45:25 +00:00
|
|
|
#include "llvm/Intrinsics.h"
|
2007-04-22 23:15:30 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2005-01-07 07:46:32 +00:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
#include "llvm/CallingConv.h"
|
2005-01-07 07:46:32 +00:00
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
2006-09-12 21:00:35 +00:00
|
|
|
#include "llvm/CodeGen/MachineConstantPool.h"
|
2007-10-15 17:47:20 +00:00
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
2008-02-02 04:07:54 +00:00
|
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
2008-02-06 22:27:42 +00:00
|
|
|
#include "llvm/CodeGen/PseudoSourceValue.h"
|
2005-08-02 19:26:06 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2008-02-10 18:45:23 +00:00
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
2007-04-22 23:15:30 +00:00
|
|
|
#include "llvm/Target/TargetData.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"
|
2006-02-17 21:58:01 +00:00
|
|
|
#include "llvm/ADT/SetVector.h"
|
2007-02-04 00:24:41 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2007-10-16 09:56:48 +00:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
2006-08-04 17:45:20 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2005-12-19 23:11:49 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2005-01-09 20:41:56 +00:00
|
|
|
#include <algorithm>
|
2006-12-02 02:22:01 +00:00
|
|
|
#include <cmath>
|
2004-06-02 04:28:06 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2006-08-15 19:11:05 +00:00
|
|
|
/// makeVTList - Return an instance of the SDVTList struct initialized with the
|
|
|
|
/// specified members.
|
2008-06-06 12:08:01 +00:00
|
|
|
static SDVTList makeVTList(const MVT *VTs, unsigned NumVTs) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList Res = {VTs, NumVTs};
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
static const fltSemantics *MVTToAPFloatSemantics(MVT VT) {
|
|
|
|
switch (VT.getSimpleVT()) {
|
2008-03-05 06:48:13 +00:00
|
|
|
default: assert(0 && "Unknown FP format");
|
|
|
|
case MVT::f32: return &APFloat::IEEEsingle;
|
|
|
|
case MVT::f64: return &APFloat::IEEEdouble;
|
|
|
|
case MVT::f80: return &APFloat::x87DoubleExtended;
|
|
|
|
case MVT::f128: return &APFloat::IEEEquad;
|
|
|
|
case MVT::ppcf128: return &APFloat::PPCDoubleDouble;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-03 06:49:24 +00:00
|
|
|
SelectionDAG::DAGUpdateListener::~DAGUpdateListener() {}
|
|
|
|
|
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.
|
2007-08-26 01:18:27 +00:00
|
|
|
bool ConstantFPSDNode::isExactlyValue(const APFloat& V) const {
|
2007-08-25 22:10:57 +00:00
|
|
|
return Value.bitwiseIsEqual(V);
|
2005-08-17 20:08:02 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
bool ConstantFPSDNode::isValueValidForType(MVT VT,
|
2007-08-30 00:23:21 +00:00
|
|
|
const APFloat& Val) {
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isFloatingPoint() && "Can only convert between FP types");
|
2008-03-05 06:48:13 +00:00
|
|
|
|
2008-04-20 18:23:46 +00:00
|
|
|
// PPC long double cannot be converted to any other type.
|
|
|
|
if (VT == MVT::ppcf128 ||
|
|
|
|
&Val.getSemantics() == &APFloat::PPCDoubleDouble)
|
2008-03-05 06:48:13 +00:00
|
|
|
return false;
|
|
|
|
|
2007-08-30 00:23:21 +00:00
|
|
|
// convert modifies in place, so make a copy.
|
|
|
|
APFloat Val2 = APFloat(Val);
|
2008-03-05 06:48:13 +00:00
|
|
|
return Val2.convert(*MVTToAPFloatSemantics(VT),
|
|
|
|
APFloat::rmNearestTiesToEven) == APFloat::opOK;
|
2007-08-30 00:23:21 +00:00
|
|
|
}
|
|
|
|
|
2005-08-17 20:08:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-03-25 22:57:01 +00:00
|
|
|
// ISD Namespace
|
2005-08-17 20:08: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
|
|
|
|
2006-03-27 06:58:47 +00:00
|
|
|
/// isBuildVectorAllOnes - Return true if the specified node is a
|
2006-03-25 22:57:01 +00:00
|
|
|
/// BUILD_VECTOR where all of the elements are ~0 or undef.
|
2006-03-27 06:58:47 +00:00
|
|
|
bool ISD::isBuildVectorAllOnes(const SDNode *N) {
|
2006-04-15 23:38:00 +00:00
|
|
|
// Look through a bit convert.
|
|
|
|
if (N->getOpcode() == ISD::BIT_CONVERT)
|
|
|
|
N = N->getOperand(0).Val;
|
|
|
|
|
2006-03-27 06:58:47 +00:00
|
|
|
if (N->getOpcode() != ISD::BUILD_VECTOR) return false;
|
2006-03-25 22:57:01 +00:00
|
|
|
|
|
|
|
unsigned i = 0, e = N->getNumOperands();
|
|
|
|
|
|
|
|
// Skip over all of the undef values.
|
|
|
|
while (i != e && N->getOperand(i).getOpcode() == ISD::UNDEF)
|
|
|
|
++i;
|
|
|
|
|
|
|
|
// Do not accept an all-undef vector.
|
|
|
|
if (i == e) return false;
|
|
|
|
|
|
|
|
// Do not accept build_vectors that aren't all constants or which have non-~0
|
|
|
|
// elements.
|
2006-03-25 22:59:28 +00:00
|
|
|
SDOperand NotZero = N->getOperand(i);
|
2006-03-27 06:58:47 +00:00
|
|
|
if (isa<ConstantSDNode>(NotZero)) {
|
|
|
|
if (!cast<ConstantSDNode>(NotZero)->isAllOnesValue())
|
|
|
|
return false;
|
|
|
|
} else if (isa<ConstantFPSDNode>(NotZero)) {
|
2008-02-29 01:47:35 +00:00
|
|
|
if (!cast<ConstantFPSDNode>(NotZero)->getValueAPF().
|
|
|
|
convertToAPInt().isAllOnesValue())
|
|
|
|
return false;
|
2006-03-27 06:58:47 +00:00
|
|
|
} else
|
2006-03-25 22:57:01 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Okay, we have at least one ~0 value, check to see if the rest match or are
|
|
|
|
// undefs.
|
|
|
|
for (++i; i != e; ++i)
|
|
|
|
if (N->getOperand(i) != NotZero &&
|
|
|
|
N->getOperand(i).getOpcode() != ISD::UNDEF)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-03-26 09:50:58 +00:00
|
|
|
/// isBuildVectorAllZeros - Return true if the specified node is a
|
|
|
|
/// BUILD_VECTOR where all of the elements are 0 or undef.
|
|
|
|
bool ISD::isBuildVectorAllZeros(const SDNode *N) {
|
2006-04-15 23:38:00 +00:00
|
|
|
// Look through a bit convert.
|
|
|
|
if (N->getOpcode() == ISD::BIT_CONVERT)
|
|
|
|
N = N->getOperand(0).Val;
|
|
|
|
|
2006-03-26 09:50:58 +00:00
|
|
|
if (N->getOpcode() != ISD::BUILD_VECTOR) return false;
|
2006-03-27 06:58:47 +00:00
|
|
|
|
|
|
|
unsigned i = 0, e = N->getNumOperands();
|
|
|
|
|
|
|
|
// Skip over all of the undef values.
|
|
|
|
while (i != e && N->getOperand(i).getOpcode() == ISD::UNDEF)
|
|
|
|
++i;
|
|
|
|
|
|
|
|
// Do not accept an all-undef vector.
|
|
|
|
if (i == e) return false;
|
|
|
|
|
|
|
|
// Do not accept build_vectors that aren't all constants or which have non-~0
|
|
|
|
// elements.
|
|
|
|
SDOperand Zero = N->getOperand(i);
|
|
|
|
if (isa<ConstantSDNode>(Zero)) {
|
|
|
|
if (!cast<ConstantSDNode>(Zero)->isNullValue())
|
|
|
|
return false;
|
|
|
|
} else if (isa<ConstantFPSDNode>(Zero)) {
|
2007-08-31 04:03:46 +00:00
|
|
|
if (!cast<ConstantFPSDNode>(Zero)->getValueAPF().isPosZero())
|
2006-03-27 06:58:47 +00:00
|
|
|
return false;
|
|
|
|
} else
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Okay, we have at least one ~0 value, check to see if the rest match or are
|
|
|
|
// undefs.
|
|
|
|
for (++i; i != e; ++i)
|
|
|
|
if (N->getOperand(i) != Zero &&
|
|
|
|
N->getOperand(i).getOpcode() != ISD::UNDEF)
|
|
|
|
return false;
|
|
|
|
return true;
|
2006-03-26 09:50:58 +00:00
|
|
|
}
|
|
|
|
|
- When DAG combiner is folding a bit convert into a BUILD_VECTOR, it should check if it's essentially a SCALAR_TO_VECTOR. Avoid turning (v8i16) <10, u, u, u> to <10, 0, u, u, u, u, u, u>. Instead, simply convert it to a SCALAR_TO_VECTOR of the proper type.
- X86 now normalize SCALAR_TO_VECTOR to (BIT_CONVERT (v4i32 SCALAR_TO_VECTOR)). Get rid of X86ISD::S2VEC.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47290 91177308-0d34-0410-b5e6-96231b3b80d8
2008-02-18 23:04:32 +00:00
|
|
|
/// isScalarToVector - Return true if the specified node is a
|
|
|
|
/// ISD::SCALAR_TO_VECTOR node or a BUILD_VECTOR node where only the low
|
|
|
|
/// element is not an undef.
|
|
|
|
bool ISD::isScalarToVector(const SDNode *N) {
|
|
|
|
if (N->getOpcode() == ISD::SCALAR_TO_VECTOR)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (N->getOpcode() != ISD::BUILD_VECTOR)
|
|
|
|
return false;
|
|
|
|
if (N->getOperand(0).getOpcode() == ISD::UNDEF)
|
|
|
|
return false;
|
|
|
|
unsigned NumElems = N->getNumOperands();
|
|
|
|
for (unsigned i = 1; i < NumElems; ++i) {
|
|
|
|
SDOperand V = N->getOperand(i);
|
|
|
|
if (V.getOpcode() != ISD::UNDEF)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-01-31 09:59:15 +00:00
|
|
|
/// isDebugLabel - Return true if the specified node represents a debug
|
2008-07-01 00:05:16 +00:00
|
|
|
/// label (i.e. ISD::DBG_LABEL or TargetInstrInfo::DBG_LABEL node).
|
2008-01-31 09:59:15 +00:00
|
|
|
bool ISD::isDebugLabel(const SDNode *N) {
|
|
|
|
SDOperand Zero;
|
2008-07-01 00:05:16 +00:00
|
|
|
if (N->getOpcode() == ISD::DBG_LABEL)
|
|
|
|
return true;
|
2008-07-17 19:10:17 +00:00
|
|
|
if (N->isMachineOpcode() &&
|
|
|
|
N->getMachineOpcode() == TargetInstrInfo::DBG_LABEL)
|
2008-07-01 00:05:16 +00:00
|
|
|
return true;
|
|
|
|
return false;
|
2008-01-31 09:59:15 +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)
|
2006-05-12 17:03:46 +00:00
|
|
|
Op &= ~16; // Clear the U bit if the N bit is set.
|
|
|
|
|
|
|
|
// Canonicalize illegal integer setcc's.
|
|
|
|
if (isInteger && Op == ISD::SETUNE) // e.g. SETUGT | SETULT
|
|
|
|
Op = ISD::SETNE;
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
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.
|
2006-04-27 05:01:07 +00:00
|
|
|
ISD::CondCode Result = ISD::CondCode(Op1 & Op2);
|
|
|
|
|
|
|
|
// Canonicalize illegal integer setcc's.
|
|
|
|
if (isInteger) {
|
|
|
|
switch (Result) {
|
|
|
|
default: break;
|
2006-06-28 18:29:47 +00:00
|
|
|
case ISD::SETUO : Result = ISD::SETFALSE; break; // SETUGT & SETULT
|
2008-05-14 18:17:09 +00:00
|
|
|
case ISD::SETOEQ: // SETEQ & SETU[LG]E
|
2006-06-28 18:29:47 +00:00
|
|
|
case ISD::SETUEQ: Result = ISD::SETEQ ; break; // SETUGE & SETULE
|
|
|
|
case ISD::SETOLT: Result = ISD::SETULT ; break; // SETULT & SETNE
|
|
|
|
case ISD::SETOGT: Result = ISD::SETUGT ; break; // SETUGT & SETNE
|
2006-04-27 05:01:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Result;
|
2005-01-07 07:46:32 +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
|
|
|
const TargetMachine &SelectionDAG::getTarget() const {
|
|
|
|
return TLI.getTargetMachine();
|
|
|
|
}
|
|
|
|
|
2006-10-27 23:46:08 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SDNode Profile Support
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-10-27 23:52:51 +00:00
|
|
|
/// AddNodeIDOpcode - Add the node opcode to the NodeID data.
|
|
|
|
///
|
2006-10-27 23:46:08 +00:00
|
|
|
static void AddNodeIDOpcode(FoldingSetNodeID &ID, unsigned OpC) {
|
|
|
|
ID.AddInteger(OpC);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// AddNodeIDValueTypes - Value type lists are intern'd so we can represent them
|
|
|
|
/// solely with their pointer.
|
2008-05-13 00:00:25 +00:00
|
|
|
static void AddNodeIDValueTypes(FoldingSetNodeID &ID, SDVTList VTList) {
|
2006-10-27 23:46:08 +00:00
|
|
|
ID.AddPointer(VTList.VTs);
|
|
|
|
}
|
|
|
|
|
2006-10-27 23:52:51 +00:00
|
|
|
/// AddNodeIDOperands - Various routines for adding operands to the NodeID data.
|
|
|
|
///
|
2006-10-27 23:46:08 +00:00
|
|
|
static void AddNodeIDOperands(FoldingSetNodeID &ID,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2007-02-04 07:28:00 +00:00
|
|
|
for (; NumOps; --NumOps, ++Ops) {
|
|
|
|
ID.AddPointer(Ops->Val);
|
|
|
|
ID.AddInteger(Ops->ResNo);
|
|
|
|
}
|
2006-10-27 23:46:08 +00:00
|
|
|
}
|
|
|
|
|
2008-07-07 18:26:29 +00:00
|
|
|
/// AddNodeIDOperands - Various routines for adding operands to the NodeID data.
|
|
|
|
///
|
|
|
|
static void AddNodeIDOperands(FoldingSetNodeID &ID,
|
|
|
|
const SDUse *Ops, unsigned NumOps) {
|
|
|
|
for (; NumOps; --NumOps, ++Ops) {
|
|
|
|
ID.AddPointer(Ops->getSDOperand().Val);
|
|
|
|
ID.AddInteger(Ops->getSDOperand().ResNo);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-27 23:46:08 +00:00
|
|
|
static void AddNodeIDNode(FoldingSetNodeID &ID,
|
|
|
|
unsigned short OpC, SDVTList VTList,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *OpList, unsigned N) {
|
2006-10-27 23:46:08 +00:00
|
|
|
AddNodeIDOpcode(ID, OpC);
|
|
|
|
AddNodeIDValueTypes(ID, VTList);
|
|
|
|
AddNodeIDOperands(ID, OpList, N);
|
|
|
|
}
|
|
|
|
|
2008-04-16 16:15:27 +00:00
|
|
|
|
2006-10-27 23:52:51 +00:00
|
|
|
/// AddNodeIDNode - Generic routine for adding a nodes info to the NodeID
|
|
|
|
/// data.
|
2006-10-27 23:46:08 +00:00
|
|
|
static void AddNodeIDNode(FoldingSetNodeID &ID, SDNode *N) {
|
|
|
|
AddNodeIDOpcode(ID, N->getOpcode());
|
|
|
|
// Add the return value info.
|
|
|
|
AddNodeIDValueTypes(ID, N->getVTList());
|
|
|
|
// Add the operand info.
|
|
|
|
AddNodeIDOperands(ID, N->op_begin(), N->getNumOperands());
|
|
|
|
|
|
|
|
// Handle SDNode leafs with special info.
|
2007-03-30 21:38:07 +00:00
|
|
|
switch (N->getOpcode()) {
|
|
|
|
default: break; // Normal nodes don't need extra info.
|
2008-03-21 09:14:45 +00:00
|
|
|
case ISD::ARG_FLAGS:
|
|
|
|
ID.AddInteger(cast<ARG_FLAGSSDNode>(N)->getArgFlags().getRawBits());
|
|
|
|
break;
|
2007-03-30 21:38:07 +00:00
|
|
|
case ISD::TargetConstant:
|
|
|
|
case ISD::Constant:
|
2008-02-20 06:28:01 +00:00
|
|
|
ID.Add(cast<ConstantSDNode>(N)->getAPIntValue());
|
2007-03-30 21:38:07 +00:00
|
|
|
break;
|
|
|
|
case ISD::TargetConstantFP:
|
2007-08-31 04:03:46 +00:00
|
|
|
case ISD::ConstantFP: {
|
2008-02-11 17:24:50 +00:00
|
|
|
ID.Add(cast<ConstantFPSDNode>(N)->getValueAPF());
|
2007-03-30 21:38:07 +00:00
|
|
|
break;
|
2007-08-31 04:03:46 +00:00
|
|
|
}
|
2007-03-30 21:38:07 +00:00
|
|
|
case ISD::TargetGlobalAddress:
|
2007-04-20 21:38:10 +00:00
|
|
|
case ISD::GlobalAddress:
|
|
|
|
case ISD::TargetGlobalTLSAddress:
|
|
|
|
case ISD::GlobalTLSAddress: {
|
2007-03-30 21:38:07 +00:00
|
|
|
GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(N);
|
|
|
|
ID.AddPointer(GA->getGlobal());
|
|
|
|
ID.AddInteger(GA->getOffset());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::BasicBlock:
|
|
|
|
ID.AddPointer(cast<BasicBlockSDNode>(N)->getBasicBlock());
|
|
|
|
break;
|
|
|
|
case ISD::Register:
|
|
|
|
ID.AddInteger(cast<RegisterSDNode>(N)->getReg());
|
|
|
|
break;
|
2008-06-30 20:59:49 +00:00
|
|
|
case ISD::DBG_STOPPOINT: {
|
|
|
|
const DbgStopPointSDNode *DSP = cast<DbgStopPointSDNode>(N);
|
|
|
|
ID.AddInteger(DSP->getLine());
|
|
|
|
ID.AddInteger(DSP->getColumn());
|
|
|
|
ID.AddPointer(DSP->getCompileUnit());
|
|
|
|
break;
|
|
|
|
}
|
2008-02-06 22:27:42 +00:00
|
|
|
case ISD::SRCVALUE:
|
|
|
|
ID.AddPointer(cast<SrcValueSDNode>(N)->getValue());
|
|
|
|
break;
|
|
|
|
case ISD::MEMOPERAND: {
|
2008-04-07 19:35:22 +00:00
|
|
|
const MachineMemOperand &MO = cast<MemOperandSDNode>(N)->MO;
|
2008-02-06 22:27:42 +00:00
|
|
|
ID.AddPointer(MO.getValue());
|
|
|
|
ID.AddInteger(MO.getFlags());
|
|
|
|
ID.AddInteger(MO.getOffset());
|
|
|
|
ID.AddInteger(MO.getSize());
|
|
|
|
ID.AddInteger(MO.getAlignment());
|
2007-03-30 21:38:07 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::FrameIndex:
|
|
|
|
case ISD::TargetFrameIndex:
|
|
|
|
ID.AddInteger(cast<FrameIndexSDNode>(N)->getIndex());
|
|
|
|
break;
|
|
|
|
case ISD::JumpTable:
|
|
|
|
case ISD::TargetJumpTable:
|
|
|
|
ID.AddInteger(cast<JumpTableSDNode>(N)->getIndex());
|
|
|
|
break;
|
|
|
|
case ISD::ConstantPool:
|
|
|
|
case ISD::TargetConstantPool: {
|
|
|
|
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(N);
|
|
|
|
ID.AddInteger(CP->getAlignment());
|
|
|
|
ID.AddInteger(CP->getOffset());
|
|
|
|
if (CP->isMachineConstantPoolEntry())
|
|
|
|
CP->getMachineCPVal()->AddSelectionDAGCSEId(ID);
|
|
|
|
else
|
|
|
|
ID.AddPointer(CP->getConstVal());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::LOAD: {
|
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(N);
|
|
|
|
ID.AddInteger(LD->getAddressingMode());
|
|
|
|
ID.AddInteger(LD->getExtensionType());
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(LD->getMemoryVT().getRawBits());
|
2007-03-30 21:38:07 +00:00
|
|
|
ID.AddInteger(LD->getAlignment());
|
|
|
|
ID.AddInteger(LD->isVolatile());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::STORE: {
|
|
|
|
StoreSDNode *ST = cast<StoreSDNode>(N);
|
|
|
|
ID.AddInteger(ST->getAddressingMode());
|
|
|
|
ID.AddInteger(ST->isTruncatingStore());
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(ST->getMemoryVT().getRawBits());
|
2007-03-30 21:38:07 +00:00
|
|
|
ID.AddInteger(ST->getAlignment());
|
|
|
|
ID.AddInteger(ST->isVolatile());
|
|
|
|
break;
|
|
|
|
}
|
2008-06-25 08:15:39 +00:00
|
|
|
case ISD::ATOMIC_CMP_SWAP:
|
|
|
|
case ISD::ATOMIC_LOAD_ADD:
|
|
|
|
case ISD::ATOMIC_SWAP:
|
|
|
|
case ISD::ATOMIC_LOAD_SUB:
|
|
|
|
case ISD::ATOMIC_LOAD_AND:
|
|
|
|
case ISD::ATOMIC_LOAD_OR:
|
|
|
|
case ISD::ATOMIC_LOAD_XOR:
|
|
|
|
case ISD::ATOMIC_LOAD_NAND:
|
|
|
|
case ISD::ATOMIC_LOAD_MIN:
|
|
|
|
case ISD::ATOMIC_LOAD_MAX:
|
|
|
|
case ISD::ATOMIC_LOAD_UMIN:
|
|
|
|
case ISD::ATOMIC_LOAD_UMAX: {
|
|
|
|
AtomicSDNode *AT = cast<AtomicSDNode>(N);
|
|
|
|
ID.AddInteger(AT->getAlignment());
|
|
|
|
ID.AddInteger(AT->isVolatile());
|
|
|
|
break;
|
2006-10-27 23:46:08 +00:00
|
|
|
}
|
2008-06-25 08:15:39 +00:00
|
|
|
} // end switch (N->getOpcode())
|
2006-10-27 23:46:08 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2008-07-07 23:02:41 +00:00
|
|
|
inline alist_traits<SDNode, LargestSDNode>::AllocatorType &
|
|
|
|
SelectionDAG::getAllocator() {
|
|
|
|
return AllNodes.getTraits().Allocator;
|
|
|
|
}
|
|
|
|
|
2005-01-07 21:09:16 +00:00
|
|
|
/// RemoveDeadNodes - This method deletes all unreachable nodes in the
|
2006-08-04 17:45:20 +00:00
|
|
|
/// SelectionDAG.
|
|
|
|
void SelectionDAG::RemoveDeadNodes() {
|
2005-01-07 21:09:16 +00:00
|
|
|
// Create a dummy node (which is not added to allnodes), that adds a reference
|
|
|
|
// to the root node, preventing it from being deleted.
|
2005-10-05 06:35:28 +00:00
|
|
|
HandleSDNode Dummy(getRoot());
|
2005-01-07 21:09:16 +00:00
|
|
|
|
2006-08-04 17:45:20 +00:00
|
|
|
SmallVector<SDNode*, 128> DeadNodes;
|
2005-11-08 18:52:27 +00:00
|
|
|
|
2006-08-04 17:45:20 +00:00
|
|
|
// Add all obviously-dead nodes to the DeadNodes worklist.
|
2005-11-09 23:47:37 +00:00
|
|
|
for (allnodes_iterator I = allnodes_begin(), E = allnodes_end(); I != E; ++I)
|
2006-08-04 17:45:20 +00:00
|
|
|
if (I->use_empty())
|
|
|
|
DeadNodes.push_back(I);
|
|
|
|
|
2008-07-07 20:57:48 +00:00
|
|
|
RemoveDeadNodes(DeadNodes);
|
2005-11-08 18:52:27 +00:00
|
|
|
|
2005-01-07 21:09:16 +00:00
|
|
|
// If the root changed (e.g. it was a dead load, update the root).
|
2005-10-05 06:35:28 +00:00
|
|
|
setRoot(Dummy.getValue());
|
2005-01-07 21:09:16 +00:00
|
|
|
}
|
|
|
|
|
2008-07-07 20:57:48 +00:00
|
|
|
/// RemoveDeadNodes - This method deletes the unreachable nodes in the
|
|
|
|
/// given list, and any nodes that become unreachable as a result.
|
|
|
|
void SelectionDAG::RemoveDeadNodes(SmallVectorImpl<SDNode *> &DeadNodes,
|
|
|
|
DAGUpdateListener *UpdateListener) {
|
2006-10-12 20:34:05 +00:00
|
|
|
|
|
|
|
// Process the worklist, deleting the nodes and adding their uses to the
|
|
|
|
// worklist.
|
|
|
|
while (!DeadNodes.empty()) {
|
|
|
|
SDNode *N = DeadNodes.back();
|
|
|
|
DeadNodes.pop_back();
|
|
|
|
|
2008-02-03 06:49:24 +00:00
|
|
|
if (UpdateListener)
|
2008-06-11 11:42:12 +00:00
|
|
|
UpdateListener->NodeDeleted(N, 0);
|
2008-02-03 06:49:24 +00:00
|
|
|
|
2006-10-12 20:34:05 +00:00
|
|
|
// Take the node out of the appropriate CSE map.
|
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
|
|
|
|
// Next, brutally remove the operand list. This is safe to do, as there are
|
|
|
|
// no cycles in the graph.
|
|
|
|
for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I) {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDNode *Operand = I->getVal();
|
2008-07-07 20:57:48 +00:00
|
|
|
Operand->removeUser(std::distance(N->op_begin(), I), N);
|
2006-10-12 20:34:05 +00:00
|
|
|
|
|
|
|
// Now that we removed this operand, see if there are no uses of it left.
|
|
|
|
if (Operand->use_empty())
|
|
|
|
DeadNodes.push_back(Operand);
|
|
|
|
}
|
2008-04-07 10:06:32 +00:00
|
|
|
if (N->OperandsNeedDelete) {
|
2007-02-04 07:28:00 +00:00
|
|
|
delete[] N->OperandList;
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
2006-10-12 20:34:05 +00:00
|
|
|
N->OperandList = 0;
|
|
|
|
N->NumOperands = 0;
|
|
|
|
|
|
|
|
// Finally, remove N itself.
|
|
|
|
AllNodes.erase(N);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-07 20:57:48 +00:00
|
|
|
void SelectionDAG::RemoveDeadNode(SDNode *N, DAGUpdateListener *UpdateListener){
|
2008-07-17 19:10:17 +00:00
|
|
|
SmallVector<SDNode*, 16> DeadNodes(1, N);
|
2008-07-07 20:57:48 +00:00
|
|
|
RemoveDeadNodes(DeadNodes, UpdateListener);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
// Drop all of the operands and decrement used nodes use counts.
|
2005-11-08 22:07:03 +00:00
|
|
|
for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I)
|
2008-04-16 16:15:27 +00:00
|
|
|
I->getVal()->removeUser(std::distance(N->op_begin(), I), N);
|
2008-04-07 10:06:32 +00:00
|
|
|
if (N->OperandsNeedDelete) {
|
2007-02-04 07:28:00 +00:00
|
|
|
delete[] N->OperandList;
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
2005-11-08 22:07:03 +00:00
|
|
|
N->OperandList = 0;
|
|
|
|
N->NumOperands = 0;
|
2005-08-29 21:59:31 +00:00
|
|
|
|
2008-07-07 23:02:41 +00:00
|
|
|
AllNodes.erase(N);
|
2005-08-29 21:59:31 +00:00
|
|
|
}
|
|
|
|
|
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()) {
|
2005-10-05 06:35:28 +00:00
|
|
|
case ISD::HANDLENODE: return; // noop.
|
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::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-10-23 03:40:17 +00:00
|
|
|
case ISD::TargetExternalSymbol:
|
2006-01-28 10:09:25 +00:00
|
|
|
Erased =
|
|
|
|
TargetExternalSymbols.erase(cast<ExternalSymbolSDNode>(N)->getSymbol());
|
2005-10-23 03:40:17 +00:00
|
|
|
break;
|
2007-10-17 13:49:58 +00:00
|
|
|
case ISD::VALUETYPE: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = cast<VTSDNode>(N)->getVT();
|
|
|
|
if (VT.isExtended()) {
|
2007-10-17 13:49:58 +00:00
|
|
|
Erased = ExtendedValueTypeNodes.erase(VT);
|
|
|
|
} else {
|
2008-06-06 12:08:01 +00:00
|
|
|
Erased = ValueTypeNodes[VT.getSimpleVT()] != 0;
|
|
|
|
ValueTypeNodes[VT.getSimpleVT()] = 0;
|
2007-10-17 13:49:58 +00:00
|
|
|
}
|
2005-07-10 00:07:11 +00:00
|
|
|
break;
|
2007-10-17 13:49:58 +00:00
|
|
|
}
|
2005-01-07 21:09:16 +00:00
|
|
|
default:
|
2006-08-11 18:38:11 +00:00
|
|
|
// Remove it from the CSE Map.
|
|
|
|
Erased = CSEMap.RemoveNode(N);
|
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 &&
|
2008-07-08 20:06:39 +00:00
|
|
|
!N->isTargetOpcode() &&
|
|
|
|
N->getOpcode() != ISD::DBG_LABEL &&
|
|
|
|
N->getOpcode() != ISD::DBG_STOPPOINT &&
|
|
|
|
N->getOpcode() != ISD::EH_LABEL &&
|
|
|
|
N->getOpcode() != ISD::DECLARE) {
|
2007-06-19 14:13:56 +00:00
|
|
|
N->dump(this);
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "\n";
|
2005-09-02 19:15:44 +00:00
|
|
|
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!");
|
2008-07-08 20:06:39 +00:00
|
|
|
|
|
|
|
if (N->getValueType(0) == MVT::Flag)
|
|
|
|
return 0; // Never CSE anything that produces a flag.
|
|
|
|
|
|
|
|
switch (N->getOpcode()) {
|
|
|
|
default: break;
|
|
|
|
case ISD::HANDLENODE:
|
|
|
|
case ISD::DBG_LABEL:
|
|
|
|
case ISD::DBG_STOPPOINT:
|
|
|
|
case ISD::EH_LABEL:
|
|
|
|
case ISD::DECLARE:
|
2005-12-01 23:14:50 +00:00
|
|
|
return 0; // Never add these nodes.
|
2008-07-08 20:06:39 +00:00
|
|
|
}
|
2005-11-30 18:20:52 +00:00
|
|
|
|
2005-12-19 22:21:21 +00:00
|
|
|
// Check that remaining values produced are not flags.
|
|
|
|
for (unsigned i = 1, e = N->getNumValues(); i != e; ++i)
|
|
|
|
if (N->getValueType(i) == MVT::Flag)
|
|
|
|
return 0; // Never CSE anything that produces a flag.
|
|
|
|
|
2006-08-07 23:03:03 +00:00
|
|
|
SDNode *New = CSEMap.GetOrInsertNode(N);
|
|
|
|
if (New != N) return New; // Node already existed.
|
2005-08-17 19:00:20 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-28 09:32:45 +00:00
|
|
|
/// FindModifiedNodeSlot - Find a slot for the specified node if its operands
|
|
|
|
/// were replaced with those specified. If this node is never memoized,
|
|
|
|
/// return null, otherwise return a pointer to the slot it would take. If a
|
|
|
|
/// node already exists with these operands, the slot will be non-null.
|
2006-08-07 23:03:03 +00:00
|
|
|
SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N, SDOperand Op,
|
|
|
|
void *&InsertPos) {
|
2008-07-08 20:06:39 +00:00
|
|
|
if (N->getValueType(0) == MVT::Flag)
|
|
|
|
return 0; // Never CSE anything that produces a flag.
|
|
|
|
|
|
|
|
switch (N->getOpcode()) {
|
|
|
|
default: break;
|
|
|
|
case ISD::HANDLENODE:
|
|
|
|
case ISD::DBG_LABEL:
|
|
|
|
case ISD::DBG_STOPPOINT:
|
|
|
|
case ISD::EH_LABEL:
|
2006-01-28 09:32:45 +00:00
|
|
|
return 0; // Never add these nodes.
|
2008-07-08 20:06:39 +00:00
|
|
|
}
|
2006-01-28 09:32:45 +00:00
|
|
|
|
|
|
|
// Check that remaining values produced are not flags.
|
|
|
|
for (unsigned i = 1, e = N->getNumValues(); i != e; ++i)
|
|
|
|
if (N->getValueType(i) == MVT::Flag)
|
|
|
|
return 0; // Never CSE anything that produces a flag.
|
|
|
|
|
2007-02-04 07:28:00 +00:00
|
|
|
SDOperand Ops[] = { Op };
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2007-02-04 07:28:00 +00:00
|
|
|
AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, 1);
|
2006-08-07 23:03:03 +00:00
|
|
|
return CSEMap.FindNodeOrInsertPos(ID, InsertPos);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// FindModifiedNodeSlot - Find a slot for the specified node if its operands
|
|
|
|
/// were replaced with those specified. If this node is never memoized,
|
|
|
|
/// return null, otherwise return a pointer to the slot it would take. If a
|
|
|
|
/// node already exists with these operands, the slot will be non-null.
|
2006-08-07 23:03:03 +00:00
|
|
|
SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N,
|
|
|
|
SDOperand Op1, SDOperand Op2,
|
|
|
|
void *&InsertPos) {
|
2006-01-29 07:58:15 +00:00
|
|
|
if (N->getOpcode() == ISD::HANDLENODE || N->getValueType(0) == MVT::Flag)
|
2006-01-28 09:32:45 +00:00
|
|
|
|
|
|
|
// Check that remaining values produced are not flags.
|
|
|
|
for (unsigned i = 1, e = N->getNumValues(); i != e; ++i)
|
|
|
|
if (N->getValueType(i) == MVT::Flag)
|
|
|
|
return 0; // Never CSE anything that produces a flag.
|
2006-08-07 23:03:03 +00:00
|
|
|
|
2007-02-04 07:28:00 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2 };
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2007-02-04 07:28:00 +00:00
|
|
|
AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, 2);
|
2006-08-07 23:03:03 +00:00
|
|
|
return CSEMap.FindNodeOrInsertPos(ID, InsertPos);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// FindModifiedNodeSlot - Find a slot for the specified node if its operands
|
|
|
|
/// were replaced with those specified. If this node is never memoized,
|
|
|
|
/// return null, otherwise return a pointer to the slot it would take. If a
|
|
|
|
/// node already exists with these operands, the slot will be non-null.
|
2006-08-07 23:03:03 +00:00
|
|
|
SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops,unsigned NumOps,
|
2006-08-07 23:03:03 +00:00
|
|
|
void *&InsertPos) {
|
2008-07-08 20:06:39 +00:00
|
|
|
if (N->getValueType(0) == MVT::Flag)
|
|
|
|
return 0; // Never CSE anything that produces a flag.
|
|
|
|
|
|
|
|
switch (N->getOpcode()) {
|
|
|
|
default: break;
|
|
|
|
case ISD::HANDLENODE:
|
|
|
|
case ISD::DBG_LABEL:
|
|
|
|
case ISD::DBG_STOPPOINT:
|
|
|
|
case ISD::EH_LABEL:
|
|
|
|
case ISD::DECLARE:
|
2006-01-28 09:32:45 +00:00
|
|
|
return 0; // Never add these nodes.
|
2008-07-08 20:06:39 +00:00
|
|
|
}
|
2006-01-28 09:32:45 +00:00
|
|
|
|
|
|
|
// Check that remaining values produced are not flags.
|
|
|
|
for (unsigned i = 1, e = N->getNumValues(); i != e; ++i)
|
|
|
|
if (N->getValueType(i) == MVT::Flag)
|
|
|
|
return 0; // Never CSE anything that produces a flag.
|
|
|
|
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2007-06-04 15:49:41 +00:00
|
|
|
AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, NumOps);
|
2006-10-27 23:46:08 +00:00
|
|
|
|
2006-10-11 01:47:58 +00:00
|
|
|
if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
|
|
|
|
ID.AddInteger(LD->getAddressingMode());
|
|
|
|
ID.AddInteger(LD->getExtensionType());
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(LD->getMemoryVT().getRawBits());
|
2006-10-11 01:47:58 +00:00
|
|
|
ID.AddInteger(LD->getAlignment());
|
|
|
|
ID.AddInteger(LD->isVolatile());
|
2006-10-13 21:14:26 +00:00
|
|
|
} else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
|
|
|
|
ID.AddInteger(ST->getAddressingMode());
|
|
|
|
ID.AddInteger(ST->isTruncatingStore());
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(ST->getMemoryVT().getRawBits());
|
2006-10-13 21:14:26 +00:00
|
|
|
ID.AddInteger(ST->getAlignment());
|
|
|
|
ID.AddInteger(ST->isVolatile());
|
2006-10-11 01:47:58 +00:00
|
|
|
}
|
2006-10-27 23:46:08 +00:00
|
|
|
|
2006-08-07 23:03:03 +00:00
|
|
|
return CSEMap.FindNodeOrInsertPos(ID, InsertPos);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
2005-08-17 19:00:20 +00:00
|
|
|
|
2008-07-21 10:20:31 +00:00
|
|
|
/// VerifyNode - Sanity check the given node. Aborts if it is invalid.
|
|
|
|
void SelectionDAG::VerifyNode(SDNode *N) {
|
|
|
|
switch (N->getOpcode()) {
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case ISD::BUILD_VECTOR: {
|
|
|
|
assert(N->getNumValues() == 1 && "Too many results for BUILD_VECTOR!");
|
|
|
|
assert(N->getValueType(0).isVector() && "Wrong BUILD_VECTOR return type!");
|
|
|
|
assert(N->getNumOperands() == N->getValueType(0).getVectorNumElements() &&
|
|
|
|
"Wrong number of BUILD_VECTOR operands!");
|
|
|
|
MVT EltVT = N->getValueType(0).getVectorElementType();
|
|
|
|
for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I)
|
|
|
|
assert(I->getSDOperand().getValueType() == EltVT &&
|
|
|
|
"Wrong BUILD_VECTOR operand type!");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-08 23:46:32 +00:00
|
|
|
/// getMVTAlignment - Compute the default alignment value for the
|
|
|
|
/// given type.
|
|
|
|
///
|
|
|
|
unsigned SelectionDAG::getMVTAlignment(MVT VT) const {
|
|
|
|
const Type *Ty = VT == MVT::iPTR ?
|
|
|
|
PointerType::get(Type::Int8Ty, 0) :
|
|
|
|
VT.getTypeForMVT();
|
|
|
|
|
|
|
|
return TLI.getTargetData()->getABITypeAlignment(Ty);
|
|
|
|
}
|
2005-01-07 21:09:16 +00:00
|
|
|
|
2003-08-11 14:57:33 +00:00
|
|
|
SelectionDAG::~SelectionDAG() {
|
2005-11-09 23:47:37 +00:00
|
|
|
while (!AllNodes.empty()) {
|
|
|
|
SDNode *N = AllNodes.begin();
|
2006-08-14 22:19:25 +00:00
|
|
|
N->SetNextInBucket(0);
|
2008-04-07 10:06:32 +00:00
|
|
|
if (N->OperandsNeedDelete) {
|
2007-02-04 07:28:00 +00:00
|
|
|
delete [] N->OperandList;
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
2005-11-08 22:07:03 +00:00
|
|
|
N->OperandList = 0;
|
|
|
|
N->NumOperands = 0;
|
2005-11-09 23:47:37 +00:00
|
|
|
AllNodes.pop_front();
|
2005-11-08 22:07:03 +00:00
|
|
|
}
|
2003-08-11 14:57:33 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getZeroExtendInReg(SDOperand Op, MVT VT) {
|
2005-04-13 19:41:05 +00:00
|
|
|
if (Op.getValueType() == VT) return Op;
|
2008-02-29 01:47:35 +00:00
|
|
|
APInt Imm = APInt::getLowBitsSet(Op.getValueSizeInBits(),
|
2008-06-06 12:08:01 +00:00
|
|
|
VT.getSizeInBits());
|
2005-04-13 02:38:18 +00:00
|
|
|
return getNode(ISD::AND, Op.getValueType(), Op,
|
|
|
|
getConstant(Imm, Op.getValueType()));
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getConstant(uint64_t Val, MVT VT, bool isT) {
|
2008-06-30 07:31:25 +00:00
|
|
|
MVT EltVT = VT.isVector() ? VT.getVectorElementType() : VT;
|
2008-06-06 12:08:01 +00:00
|
|
|
return getConstant(APInt(EltVT.getSizeInBits(), Val), VT, isT);
|
2008-02-08 22:59:30 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getConstant(const APInt &Val, MVT VT, bool isT) {
|
|
|
|
assert(VT.isInteger() && "Cannot create FP integer constant!");
|
2007-12-12 22:21:26 +00:00
|
|
|
|
2008-06-30 07:31:25 +00:00
|
|
|
MVT EltVT = VT.isVector() ? VT.getVectorElementType() : VT;
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(Val.getBitWidth() == EltVT.getSizeInBits() &&
|
2008-02-08 22:59:30 +00:00
|
|
|
"APInt size does not match type size!");
|
2006-08-11 21:01:22 +00:00
|
|
|
|
|
|
|
unsigned Opc = isT ? ISD::TargetConstant : ISD::Constant;
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opc, getVTList(EltVT), 0, 0);
|
2008-02-11 17:24:50 +00:00
|
|
|
ID.Add(Val);
|
2006-08-11 21:01:22 +00:00
|
|
|
void *IP = 0;
|
2007-12-12 22:21:26 +00:00
|
|
|
SDNode *N = NULL;
|
|
|
|
if ((N = CSEMap.FindNodeOrInsertPos(ID, IP)))
|
2008-06-06 12:08:01 +00:00
|
|
|
if (!VT.isVector())
|
2007-12-12 22:21:26 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
if (!N) {
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<ConstantSDNode>();
|
|
|
|
new (N) ConstantSDNode(isT, Val, EltVT);
|
2007-12-12 22:21:26 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand Result(N, 0);
|
2008-06-06 12:08:01 +00:00
|
|
|
if (VT.isVector()) {
|
2007-12-12 22:21:26 +00:00
|
|
|
SmallVector<SDOperand, 8> Ops;
|
2008-06-06 12:08:01 +00:00
|
|
|
Ops.assign(VT.getVectorNumElements(), Result);
|
2007-12-12 22:21:26 +00:00
|
|
|
Result = getNode(ISD::BUILD_VECTOR, VT, &Ops[0], Ops.size());
|
|
|
|
}
|
|
|
|
return Result;
|
2003-08-11 14:57:33 +00:00
|
|
|
}
|
|
|
|
|
2008-01-17 07:00:52 +00:00
|
|
|
SDOperand SelectionDAG::getIntPtrConstant(uint64_t Val, bool isTarget) {
|
|
|
|
return getConstant(Val, TLI.getPointerTy(), isTarget);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getConstantFP(const APFloat& V, MVT VT, bool isTarget) {
|
|
|
|
assert(VT.isFloatingPoint() && "Cannot create integer FP constant!");
|
2007-08-30 00:23:21 +00:00
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT EltVT =
|
|
|
|
VT.isVector() ? VT.getVectorElementType() : VT;
|
2005-01-07 07:46:32 +00:00
|
|
|
|
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.
|
2006-08-11 21:55:30 +00:00
|
|
|
unsigned Opc = isTarget ? ISD::TargetConstantFP : ISD::ConstantFP;
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opc, getVTList(EltVT), 0, 0);
|
2008-02-11 17:24:50 +00:00
|
|
|
ID.Add(V);
|
2006-08-11 21:55:30 +00:00
|
|
|
void *IP = 0;
|
2007-06-29 21:36:04 +00:00
|
|
|
SDNode *N = NULL;
|
|
|
|
if ((N = CSEMap.FindNodeOrInsertPos(ID, IP)))
|
2008-06-06 12:08:01 +00:00
|
|
|
if (!VT.isVector())
|
2007-06-29 21:36:04 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
if (!N) {
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<ConstantFPSDNode>();
|
|
|
|
new (N) ConstantFPSDNode(isTarget, V, EltVT);
|
2007-06-29 21:36:04 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
}
|
|
|
|
|
2007-06-25 16:23:39 +00:00
|
|
|
SDOperand Result(N, 0);
|
2008-06-06 12:08:01 +00:00
|
|
|
if (VT.isVector()) {
|
2007-06-25 16:23:39 +00:00
|
|
|
SmallVector<SDOperand, 8> Ops;
|
2008-06-06 12:08:01 +00:00
|
|
|
Ops.assign(VT.getVectorNumElements(), Result);
|
2007-06-25 16:23:39 +00:00
|
|
|
Result = getNode(ISD::BUILD_VECTOR, VT, &Ops[0], Ops.size());
|
|
|
|
}
|
|
|
|
return Result;
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getConstantFP(double Val, MVT VT, bool isTarget) {
|
|
|
|
MVT EltVT =
|
|
|
|
VT.isVector() ? VT.getVectorElementType() : VT;
|
2007-08-30 00:23:21 +00:00
|
|
|
if (EltVT==MVT::f32)
|
|
|
|
return getConstantFP(APFloat((float)Val), VT, isTarget);
|
|
|
|
else
|
|
|
|
return getConstantFP(APFloat(Val), VT, isTarget);
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getGlobalAddress(const GlobalValue *GV,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT, int Offset,
|
2006-08-11 21:01:22 +00:00
|
|
|
bool isTargetGA) {
|
2007-04-20 21:38:10 +00:00
|
|
|
unsigned Opc;
|
2008-03-11 22:38:53 +00:00
|
|
|
|
|
|
|
const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
|
|
|
|
if (!GVar) {
|
2008-03-22 07:53:40 +00:00
|
|
|
// If GV is an alias then use the aliasee for determining thread-localness.
|
2008-03-11 22:38:53 +00:00
|
|
|
if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
|
|
|
|
GVar = dyn_cast_or_null<GlobalVariable>(GA->resolveAliasedGlobal());
|
|
|
|
}
|
|
|
|
|
2007-04-20 21:38:10 +00:00
|
|
|
if (GVar && GVar->isThreadLocal())
|
|
|
|
Opc = isTargetGA ? ISD::TargetGlobalTLSAddress : ISD::GlobalTLSAddress;
|
|
|
|
else
|
|
|
|
Opc = isTargetGA ? ISD::TargetGlobalAddress : ISD::GlobalAddress;
|
2008-03-11 22:38:53 +00:00
|
|
|
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
|
2006-08-11 21:01:22 +00:00
|
|
|
ID.AddPointer(GV);
|
|
|
|
ID.AddInteger(Offset);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<GlobalAddressSDNode>();
|
|
|
|
new (N) GlobalAddressSDNode(isTargetGA, GV, VT, Offset);
|
2006-08-11 21:01:22 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getFrameIndex(int FI, MVT VT, bool isTarget) {
|
2006-08-11 21:55:30 +00:00
|
|
|
unsigned Opc = isTarget ? ISD::TargetFrameIndex : ISD::FrameIndex;
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
|
2006-08-11 21:55:30 +00:00
|
|
|
ID.AddInteger(FI);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<FrameIndexSDNode>();
|
|
|
|
new (N) FrameIndexSDNode(FI, VT, isTarget);
|
2006-08-11 21:55:30 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2006-04-22 18:53:45 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getJumpTable(int JTI, MVT VT, bool isTarget){
|
2006-08-11 21:55:30 +00:00
|
|
|
unsigned Opc = isTarget ? ISD::TargetJumpTable : ISD::JumpTable;
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
|
2006-08-11 21:55:30 +00:00
|
|
|
ID.AddInteger(JTI);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<JumpTableSDNode>();
|
|
|
|
new (N) JumpTableSDNode(JTI, VT, isTarget);
|
2006-08-11 21:55:30 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2006-04-22 18:53:45 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getConstantPool(Constant *C, MVT VT,
|
2006-08-11 21:55:30 +00:00
|
|
|
unsigned Alignment, int Offset,
|
|
|
|
bool isTarget) {
|
|
|
|
unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
|
2006-08-11 21:55:30 +00:00
|
|
|
ID.AddInteger(Alignment);
|
|
|
|
ID.AddInteger(Offset);
|
2006-08-14 20:12:44 +00:00
|
|
|
ID.AddPointer(C);
|
2006-08-11 21:55:30 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<ConstantPoolSDNode>();
|
|
|
|
new (N) ConstantPoolSDNode(isTarget, C, VT, Offset, Alignment);
|
2006-08-11 21:55:30 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-08-25 05:03:06 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getConstantPool(MachineConstantPoolValue *C, MVT VT,
|
2006-09-12 21:00:35 +00:00
|
|
|
unsigned Alignment, int Offset,
|
|
|
|
bool isTarget) {
|
|
|
|
unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
|
2006-09-12 21:00:35 +00:00
|
|
|
ID.AddInteger(Alignment);
|
|
|
|
ID.AddInteger(Offset);
|
2006-10-27 23:46:08 +00:00
|
|
|
C->AddSelectionDAGCSEId(ID);
|
2006-09-12 21:00:35 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<ConstantPoolSDNode>();
|
|
|
|
new (N) ConstantPoolSDNode(isTarget, C, VT, Offset, Alignment);
|
2006-09-12 21:00:35 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand SelectionDAG::getBasicBlock(MachineBasicBlock *MBB) {
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, ISD::BasicBlock, getVTList(MVT::Other), 0, 0);
|
2006-08-11 21:01:22 +00:00
|
|
|
ID.AddPointer(MBB);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<BasicBlockSDNode>();
|
|
|
|
new (N) BasicBlockSDNode(MBB);
|
2006-08-11 21:01:22 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-03-21 09:14:45 +00:00
|
|
|
SDOperand SelectionDAG::getArgFlags(ISD::ArgFlagsTy Flags) {
|
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, ISD::ARG_FLAGS, getVTList(MVT::Other), 0, 0);
|
2008-03-21 09:14:45 +00:00
|
|
|
ID.AddInteger(Flags.getRawBits());
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<ARG_FLAGSSDNode>();
|
|
|
|
new (N) ARG_FLAGSSDNode(Flags);
|
2008-03-21 09:14:45 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getValueType(MVT VT) {
|
|
|
|
if (VT.isSimple() && (unsigned)VT.getSimpleVT() >= ValueTypeNodes.size())
|
|
|
|
ValueTypeNodes.resize(VT.getSimpleVT()+1);
|
2005-07-10 00:07:11 +00:00
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *&N = VT.isExtended() ?
|
|
|
|
ExtendedValueTypeNodes[VT] : ValueTypeNodes[VT.getSimpleVT()];
|
2007-10-17 13:49:58 +00:00
|
|
|
|
|
|
|
if (N) return SDOperand(N, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<VTSDNode>();
|
|
|
|
new (N) VTSDNode(VT);
|
2007-10-17 13:49:58 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
2005-07-10 00:07:11 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getExternalSymbol(const char *Sym, MVT VT) {
|
2005-01-07 07:46:32 +00:00
|
|
|
SDNode *&N = ExternalSymbols[Sym];
|
|
|
|
if (N) return SDOperand(N, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<ExternalSymbolSDNode>();
|
|
|
|
new (N) ExternalSymbolSDNode(false, Sym, VT);
|
2005-10-23 03:40:17 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getTargetExternalSymbol(const char *Sym, MVT VT) {
|
2005-10-23 03:40:17 +00:00
|
|
|
SDNode *&N = TargetExternalSymbols[Sym];
|
|
|
|
if (N) return SDOperand(N, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<ExternalSymbolSDNode>();
|
|
|
|
new (N) ExternalSymbolSDNode(true, Sym, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
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);
|
2008-06-06 12:08:01 +00:00
|
|
|
|
2005-08-09 20:40:02 +00:00
|
|
|
if (CondCodeNodes[Cond] == 0) {
|
2008-07-07 23:02:41 +00:00
|
|
|
CondCodeSDNode *N = getAllocator().Allocate<CondCodeSDNode>();
|
|
|
|
new (N) CondCodeSDNode(Cond);
|
|
|
|
CondCodeNodes[Cond] = N;
|
|
|
|
AllNodes.push_back(N);
|
2005-08-09 20:40:02 +00:00
|
|
|
}
|
2005-08-09 20:20:18 +00:00
|
|
|
return SDOperand(CondCodeNodes[Cond], 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getRegister(unsigned RegNo, MVT VT) {
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, ISD::Register, getVTList(VT), 0, 0);
|
2006-08-11 21:01:22 +00:00
|
|
|
ID.AddInteger(RegNo);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<RegisterSDNode>();
|
|
|
|
new (N) RegisterSDNode(RegNo, VT);
|
2006-08-11 21:01:22 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-30 20:59:49 +00:00
|
|
|
SDOperand SelectionDAG::getDbgStopPoint(SDOperand Root,
|
|
|
|
unsigned Line, unsigned Col,
|
|
|
|
const CompileUnitDesc *CU) {
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<DbgStopPointSDNode>();
|
|
|
|
new (N) DbgStopPointSDNode(Root, Line, Col, CU);
|
2008-06-30 20:59:49 +00:00
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-07-01 00:05:16 +00:00
|
|
|
SDOperand SelectionDAG::getLabel(unsigned Opcode,
|
|
|
|
SDOperand Root,
|
|
|
|
unsigned LabelID) {
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
SDOperand Ops[] = { Root };
|
|
|
|
AddNodeIDNode(ID, Opcode, getVTList(MVT::Other), &Ops[0], 1);
|
|
|
|
ID.AddInteger(LabelID);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<LabelSDNode>();
|
|
|
|
new (N) LabelSDNode(Opcode, Root, LabelID);
|
2008-07-01 00:05:16 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-02-06 22:27:42 +00:00
|
|
|
SDOperand SelectionDAG::getSrcValue(const Value *V) {
|
2006-08-11 21:01:22 +00:00
|
|
|
assert((!V || isa<PointerType>(V->getType())) &&
|
|
|
|
"SrcValue is not a pointer?");
|
|
|
|
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, ISD::SRCVALUE, getVTList(MVT::Other), 0, 0);
|
2006-08-11 21:01:22 +00:00
|
|
|
ID.AddPointer(V);
|
2008-02-06 22:27:42 +00:00
|
|
|
|
2008-01-31 00:25:39 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-02-06 22:27:42 +00:00
|
|
|
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<SrcValueSDNode>();
|
|
|
|
new (N) SrcValueSDNode(V);
|
2008-02-06 22:27:42 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-04-07 19:35:22 +00:00
|
|
|
SDOperand SelectionDAG::getMemOperand(const MachineMemOperand &MO) {
|
2008-02-06 22:27:42 +00:00
|
|
|
const Value *v = MO.getValue();
|
|
|
|
assert((!v || isa<PointerType>(v->getType())) &&
|
|
|
|
"SrcValue is not a pointer?");
|
|
|
|
|
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, ISD::MEMOPERAND, getVTList(MVT::Other), 0, 0);
|
2008-02-06 22:27:42 +00:00
|
|
|
ID.AddPointer(v);
|
|
|
|
ID.AddInteger(MO.getFlags());
|
|
|
|
ID.AddInteger(MO.getOffset());
|
|
|
|
ID.AddInteger(MO.getSize());
|
|
|
|
ID.AddInteger(MO.getAlignment());
|
|
|
|
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
|
|
|
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<MemOperandSDNode>();
|
|
|
|
new (N) MemOperandSDNode(MO);
|
2006-08-11 21:01:22 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
2005-08-16 21:55:35 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 17:47:20 +00:00
|
|
|
/// CreateStackTemporary - Create a stack temporary, suitable for holding the
|
|
|
|
/// specified value type.
|
2008-07-05 20:40:31 +00:00
|
|
|
SDOperand SelectionDAG::CreateStackTemporary(MVT VT, unsigned minAlign) {
|
2007-10-15 17:47:20 +00:00
|
|
|
MachineFrameInfo *FrameInfo = getMachineFunction().getFrameInfo();
|
2008-06-06 12:08:01 +00:00
|
|
|
unsigned ByteSize = VT.getSizeInBits()/8;
|
|
|
|
const Type *Ty = VT.getTypeForMVT();
|
2008-07-05 20:40:31 +00:00
|
|
|
unsigned StackAlign =
|
|
|
|
std::max((unsigned)TLI.getTargetData()->getPrefTypeAlignment(Ty), minAlign);
|
|
|
|
|
2007-10-15 17:47:20 +00:00
|
|
|
int FrameIdx = FrameInfo->CreateStackObject(ByteSize, StackAlign);
|
|
|
|
return getFrameIndex(FrameIdx, TLI.getPointerTy());
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::FoldSetCC(MVT VT, SDOperand N1,
|
2006-10-14 00:41:01 +00:00
|
|
|
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);
|
2006-04-27 05:01:07 +00:00
|
|
|
|
|
|
|
case ISD::SETOEQ:
|
|
|
|
case ISD::SETOGT:
|
|
|
|
case ISD::SETOGE:
|
|
|
|
case ISD::SETOLT:
|
|
|
|
case ISD::SETOLE:
|
|
|
|
case ISD::SETONE:
|
|
|
|
case ISD::SETO:
|
|
|
|
case ISD::SETUO:
|
|
|
|
case ISD::SETUEQ:
|
|
|
|
case ISD::SETUNE:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(!N1.getValueType().isInteger() && "Illegal setcc for integer!");
|
2006-04-27 05:01:07 +00:00
|
|
|
break;
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2006-10-14 00:41:01 +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)) {
|
2008-02-29 01:47:35 +00:00
|
|
|
const APInt &C2 = N2C->getAPIntValue();
|
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 *N1C = dyn_cast<ConstantSDNode>(N1.Val)) {
|
2008-02-29 01:47:35 +00:00
|
|
|
const APInt &C1 = N1C->getAPIntValue();
|
2006-10-14 00:41:01 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
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);
|
2008-02-29 01:47:35 +00:00
|
|
|
case ISD::SETULT: return getConstant(C1.ult(C2), VT);
|
|
|
|
case ISD::SETUGT: return getConstant(C1.ugt(C2), VT);
|
|
|
|
case ISD::SETULE: return getConstant(C1.ule(C2), VT);
|
|
|
|
case ISD::SETUGE: return getConstant(C1.uge(C2), VT);
|
|
|
|
case ISD::SETLT: return getConstant(C1.slt(C2), VT);
|
|
|
|
case ISD::SETGT: return getConstant(C1.sgt(C2), VT);
|
|
|
|
case ISD::SETLE: return getConstant(C1.sle(C2), VT);
|
|
|
|
case ISD::SETGE: return getConstant(C1.sge(C2), 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
|
|
|
}
|
2008-02-20 11:10:28 +00:00
|
|
|
if (ConstantFPSDNode *N1C = dyn_cast<ConstantFPSDNode>(N1.Val)) {
|
2005-01-07 07:46:32 +00:00
|
|
|
if (ConstantFPSDNode *N2C = dyn_cast<ConstantFPSDNode>(N2.Val)) {
|
2007-10-14 01:56:47 +00:00
|
|
|
// No compile time operations on this type yet.
|
|
|
|
if (N1C->getValueType(0) == MVT::ppcf128)
|
|
|
|
return SDOperand();
|
2007-08-31 04:03:46 +00:00
|
|
|
|
|
|
|
APFloat::cmpResult R = N1C->getValueAPF().compare(N2C->getValueAPF());
|
2005-01-07 07:46:32 +00:00
|
|
|
switch (Cond) {
|
2007-08-31 04:03:46 +00:00
|
|
|
default: break;
|
2007-08-31 17:03:33 +00:00
|
|
|
case ISD::SETEQ: if (R==APFloat::cmpUnordered)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
// fall through
|
|
|
|
case ISD::SETOEQ: return getConstant(R==APFloat::cmpEqual, VT);
|
|
|
|
case ISD::SETNE: if (R==APFloat::cmpUnordered)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
// fall through
|
|
|
|
case ISD::SETONE: return getConstant(R==APFloat::cmpGreaterThan ||
|
2007-08-31 04:03:46 +00:00
|
|
|
R==APFloat::cmpLessThan, VT);
|
2007-08-31 17:03:33 +00:00
|
|
|
case ISD::SETLT: if (R==APFloat::cmpUnordered)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
// fall through
|
|
|
|
case ISD::SETOLT: return getConstant(R==APFloat::cmpLessThan, VT);
|
|
|
|
case ISD::SETGT: if (R==APFloat::cmpUnordered)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
// fall through
|
|
|
|
case ISD::SETOGT: return getConstant(R==APFloat::cmpGreaterThan, VT);
|
|
|
|
case ISD::SETLE: if (R==APFloat::cmpUnordered)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
// fall through
|
|
|
|
case ISD::SETOLE: return getConstant(R==APFloat::cmpLessThan ||
|
2007-08-31 04:03:46 +00:00
|
|
|
R==APFloat::cmpEqual, VT);
|
2007-08-31 17:03:33 +00:00
|
|
|
case ISD::SETGE: if (R==APFloat::cmpUnordered)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
// fall through
|
|
|
|
case ISD::SETOGE: return getConstant(R==APFloat::cmpGreaterThan ||
|
2007-08-31 04:03:46 +00:00
|
|
|
R==APFloat::cmpEqual, VT);
|
|
|
|
case ISD::SETO: return getConstant(R!=APFloat::cmpUnordered, VT);
|
|
|
|
case ISD::SETUO: return getConstant(R==APFloat::cmpUnordered, VT);
|
|
|
|
case ISD::SETUEQ: return getConstant(R==APFloat::cmpUnordered ||
|
|
|
|
R==APFloat::cmpEqual, VT);
|
|
|
|
case ISD::SETUNE: return getConstant(R!=APFloat::cmpEqual, VT);
|
|
|
|
case ISD::SETULT: return getConstant(R==APFloat::cmpUnordered ||
|
|
|
|
R==APFloat::cmpLessThan, VT);
|
|
|
|
case ISD::SETUGT: return getConstant(R==APFloat::cmpGreaterThan ||
|
|
|
|
R==APFloat::cmpUnordered, VT);
|
|
|
|
case ISD::SETULE: return getConstant(R!=APFloat::cmpGreaterThan, VT);
|
|
|
|
case ISD::SETUGE: return getConstant(R!=APFloat::cmpLessThan, 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
|
|
|
}
|
2008-02-20 11:10:28 +00:00
|
|
|
}
|
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
// Could not fold it.
|
|
|
|
return SDOperand();
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2008-02-25 21:11:39 +00:00
|
|
|
/// SignBitIsZero - Return true if the sign bit of Op is known to be zero. We
|
|
|
|
/// use this predicate to simplify operations downstream.
|
|
|
|
bool SelectionDAG::SignBitIsZero(SDOperand Op, unsigned Depth) const {
|
|
|
|
unsigned BitWidth = Op.getValueSizeInBits();
|
|
|
|
return MaskedValueIsZero(Op, APInt::getSignBit(BitWidth), Depth);
|
|
|
|
}
|
|
|
|
|
2007-06-22 14:59:07 +00:00
|
|
|
/// MaskedValueIsZero - Return true if 'V & Mask' is known to be zero. We use
|
|
|
|
/// this predicate to simplify operations downstream. Mask is known to be zero
|
|
|
|
/// for bits that V cannot have.
|
2008-02-25 21:11:39 +00:00
|
|
|
bool SelectionDAG::MaskedValueIsZero(SDOperand Op, const APInt &Mask,
|
2007-06-22 14:59:07 +00:00
|
|
|
unsigned Depth) const {
|
2008-02-25 21:11:39 +00:00
|
|
|
APInt KnownZero, KnownOne;
|
2007-06-22 14:59:07 +00:00
|
|
|
ComputeMaskedBits(Op, Mask, KnownZero, KnownOne, Depth);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
return (KnownZero & Mask) == Mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ComputeMaskedBits - Determine which of the bits specified in Mask are
|
|
|
|
/// known to be either zero or one and return them in the KnownZero/KnownOne
|
|
|
|
/// bitsets. This code only analyzes bits in Mask, in order to short-circuit
|
|
|
|
/// processing.
|
2008-02-13 22:28:48 +00:00
|
|
|
void SelectionDAG::ComputeMaskedBits(SDOperand Op, const APInt &Mask,
|
2008-02-13 00:35:47 +00:00
|
|
|
APInt &KnownZero, APInt &KnownOne,
|
2007-06-22 14:59:07 +00:00
|
|
|
unsigned Depth) const {
|
2008-02-13 00:35:47 +00:00
|
|
|
unsigned BitWidth = Mask.getBitWidth();
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(BitWidth == Op.getValueType().getSizeInBits() &&
|
2008-02-13 23:13:32 +00:00
|
|
|
"Mask size mismatches value type size!");
|
|
|
|
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero = KnownOne = APInt(BitWidth, 0); // Don't know anything.
|
2007-06-22 14:59:07 +00:00
|
|
|
if (Depth == 6 || Mask == 0)
|
|
|
|
return; // Limit search depth.
|
|
|
|
|
2008-02-13 00:35:47 +00:00
|
|
|
APInt KnownZero2, KnownOne2;
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
switch (Op.getOpcode()) {
|
|
|
|
case ISD::Constant:
|
|
|
|
// We know all of the bits for a constant!
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownOne = cast<ConstantSDNode>(Op)->getAPIntValue() & Mask;
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownZero = ~KnownOne & Mask;
|
|
|
|
return;
|
|
|
|
case ISD::AND:
|
|
|
|
// If either the LHS or the RHS are Zero, the result is zero.
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), Mask, KnownZero, KnownOne, Depth+1);
|
2008-02-13 22:28:48 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask & ~KnownZero,
|
|
|
|
KnownZero2, KnownOne2, Depth+1);
|
2007-06-22 14:59:07 +00:00
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
|
|
|
|
// Output known-1 bits are only known if set in both the LHS & RHS.
|
|
|
|
KnownOne &= KnownOne2;
|
|
|
|
// Output known-0 are known to be clear if zero in either the LHS | RHS.
|
|
|
|
KnownZero |= KnownZero2;
|
|
|
|
return;
|
|
|
|
case ISD::OR:
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), Mask, KnownZero, KnownOne, Depth+1);
|
2008-02-13 22:28:48 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask & ~KnownOne,
|
|
|
|
KnownZero2, KnownOne2, Depth+1);
|
2007-06-22 14:59:07 +00:00
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
|
|
|
|
// Output known-0 bits are only known if clear in both the LHS & RHS.
|
|
|
|
KnownZero &= KnownZero2;
|
|
|
|
// Output known-1 are known to be set if set in either the LHS | RHS.
|
|
|
|
KnownOne |= KnownOne2;
|
|
|
|
return;
|
|
|
|
case ISD::XOR: {
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), Mask, KnownZero, KnownOne, Depth+1);
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask, KnownZero2, KnownOne2, Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
|
|
|
|
// Output known-0 bits are known if clear or set in both the LHS & RHS.
|
2008-02-13 00:35:47 +00:00
|
|
|
APInt KnownZeroOut = (KnownZero & KnownZero2) | (KnownOne & KnownOne2);
|
2007-06-22 14:59:07 +00:00
|
|
|
// Output known-1 are known to be set if set in only one of the LHS, RHS.
|
|
|
|
KnownOne = (KnownZero & KnownOne2) | (KnownOne & KnownZero2);
|
|
|
|
KnownZero = KnownZeroOut;
|
|
|
|
return;
|
|
|
|
}
|
2008-04-28 17:02:21 +00:00
|
|
|
case ISD::MUL: {
|
|
|
|
APInt Mask2 = APInt::getAllOnesValue(BitWidth);
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), Mask2, KnownZero, KnownOne, Depth+1);
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask2, KnownZero2, KnownOne2, Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
|
|
|
|
// If low bits are zero in either operand, output low known-0 bits.
|
|
|
|
// Also compute a conserative estimate for high known-0 bits.
|
|
|
|
// More trickiness is possible, but this is sufficient for the
|
|
|
|
// interesting case of alignment computation.
|
|
|
|
KnownOne.clear();
|
|
|
|
unsigned TrailZ = KnownZero.countTrailingOnes() +
|
|
|
|
KnownZero2.countTrailingOnes();
|
|
|
|
unsigned LeadZ = std::max(KnownZero.countLeadingOnes() +
|
2008-05-07 00:35:55 +00:00
|
|
|
KnownZero2.countLeadingOnes(),
|
|
|
|
BitWidth) - BitWidth;
|
2008-04-28 17:02:21 +00:00
|
|
|
|
|
|
|
TrailZ = std::min(TrailZ, BitWidth);
|
|
|
|
LeadZ = std::min(LeadZ, BitWidth);
|
|
|
|
KnownZero = APInt::getLowBitsSet(BitWidth, TrailZ) |
|
|
|
|
APInt::getHighBitsSet(BitWidth, LeadZ);
|
|
|
|
KnownZero &= Mask;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case ISD::UDIV: {
|
|
|
|
// For the purposes of computing leading zeros we can conservatively
|
|
|
|
// treat a udiv as a logical right shift by the power of 2 known to
|
2008-05-02 21:30:02 +00:00
|
|
|
// be less than the denominator.
|
2008-04-28 17:02:21 +00:00
|
|
|
APInt AllOnes = APInt::getAllOnesValue(BitWidth);
|
|
|
|
ComputeMaskedBits(Op.getOperand(0),
|
|
|
|
AllOnes, KnownZero2, KnownOne2, Depth+1);
|
|
|
|
unsigned LeadZ = KnownZero2.countLeadingOnes();
|
|
|
|
|
|
|
|
KnownOne2.clear();
|
|
|
|
KnownZero2.clear();
|
|
|
|
ComputeMaskedBits(Op.getOperand(1),
|
|
|
|
AllOnes, KnownZero2, KnownOne2, Depth+1);
|
2008-05-02 21:30:02 +00:00
|
|
|
unsigned RHSUnknownLeadingOnes = KnownOne2.countLeadingZeros();
|
|
|
|
if (RHSUnknownLeadingOnes != BitWidth)
|
|
|
|
LeadZ = std::min(BitWidth,
|
|
|
|
LeadZ + BitWidth - RHSUnknownLeadingOnes - 1);
|
2008-04-28 17:02:21 +00:00
|
|
|
|
|
|
|
KnownZero = APInt::getHighBitsSet(BitWidth, LeadZ) & Mask;
|
|
|
|
return;
|
|
|
|
}
|
2007-06-22 14:59:07 +00:00
|
|
|
case ISD::SELECT:
|
|
|
|
ComputeMaskedBits(Op.getOperand(2), Mask, KnownZero, KnownOne, Depth+1);
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), Mask, KnownZero2, KnownOne2, Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
|
|
|
|
// Only known if known in both the LHS and RHS.
|
|
|
|
KnownOne &= KnownOne2;
|
|
|
|
KnownZero &= KnownZero2;
|
|
|
|
return;
|
|
|
|
case ISD::SELECT_CC:
|
|
|
|
ComputeMaskedBits(Op.getOperand(3), Mask, KnownZero, KnownOne, Depth+1);
|
|
|
|
ComputeMaskedBits(Op.getOperand(2), Mask, KnownZero2, KnownOne2, Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
|
|
|
|
// Only known if known in both the LHS and RHS.
|
|
|
|
KnownOne &= KnownOne2;
|
|
|
|
KnownZero &= KnownZero2;
|
|
|
|
return;
|
|
|
|
case ISD::SETCC:
|
|
|
|
// If we know the result of a setcc has the top bits zero, use this info.
|
2008-02-13 00:35:47 +00:00
|
|
|
if (TLI.getSetCCResultContents() == TargetLowering::ZeroOrOneSetCCResult &&
|
|
|
|
BitWidth > 1)
|
|
|
|
KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
|
2007-06-22 14:59:07 +00:00
|
|
|
return;
|
|
|
|
case ISD::SHL:
|
|
|
|
// (shl X, C1) & C2 == 0 iff (X & C2 >>u C1) == 0
|
|
|
|
if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
2008-02-26 18:50:50 +00:00
|
|
|
unsigned ShAmt = SA->getValue();
|
|
|
|
|
|
|
|
// If the shift count is an invalid immediate, don't do anything.
|
|
|
|
if (ShAmt >= BitWidth)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask.lshr(ShAmt),
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownZero, KnownOne, Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
2008-02-26 18:50:50 +00:00
|
|
|
KnownZero <<= ShAmt;
|
|
|
|
KnownOne <<= ShAmt;
|
2008-02-13 00:35:47 +00:00
|
|
|
// low bits known zero.
|
2008-02-26 18:50:50 +00:00
|
|
|
KnownZero |= APInt::getLowBitsSet(BitWidth, ShAmt);
|
2007-06-22 14:59:07 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
case ISD::SRL:
|
|
|
|
// (ushr X, C1) & C2 == 0 iff (-1 >> C1) & C2 == 0
|
|
|
|
if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
|
|
|
unsigned ShAmt = SA->getValue();
|
|
|
|
|
2008-02-26 18:50:50 +00:00
|
|
|
// If the shift count is an invalid immediate, don't do anything.
|
|
|
|
if (ShAmt >= BitWidth)
|
|
|
|
return;
|
|
|
|
|
2008-02-13 00:35:47 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), (Mask << ShAmt),
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownZero, KnownOne, Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero = KnownZero.lshr(ShAmt);
|
|
|
|
KnownOne = KnownOne.lshr(ShAmt);
|
2007-06-22 14:59:07 +00:00
|
|
|
|
2008-02-13 22:43:25 +00:00
|
|
|
APInt HighBits = APInt::getHighBitsSet(BitWidth, ShAmt) & Mask;
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownZero |= HighBits; // High bits known zero.
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
case ISD::SRA:
|
|
|
|
if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
|
|
|
unsigned ShAmt = SA->getValue();
|
|
|
|
|
2008-02-26 18:50:50 +00:00
|
|
|
// If the shift count is an invalid immediate, don't do anything.
|
|
|
|
if (ShAmt >= BitWidth)
|
|
|
|
return;
|
|
|
|
|
2008-02-13 00:35:47 +00:00
|
|
|
APInt InDemandedMask = (Mask << ShAmt);
|
2007-06-22 14:59:07 +00:00
|
|
|
// If any of the demanded bits are produced by the sign extension, we also
|
|
|
|
// demand the input sign bit.
|
2008-02-13 22:43:25 +00:00
|
|
|
APInt HighBits = APInt::getHighBitsSet(BitWidth, ShAmt) & Mask;
|
|
|
|
if (HighBits.getBoolValue())
|
2008-02-13 00:35:47 +00:00
|
|
|
InDemandedMask |= APInt::getSignBit(BitWidth);
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), InDemandedMask, KnownZero, KnownOne,
|
|
|
|
Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero = KnownZero.lshr(ShAmt);
|
|
|
|
KnownOne = KnownOne.lshr(ShAmt);
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
// Handle the sign bits.
|
2008-02-13 00:35:47 +00:00
|
|
|
APInt SignBit = APInt::getSignBit(BitWidth);
|
|
|
|
SignBit = SignBit.lshr(ShAmt); // Adjust to where it is now in the mask.
|
2007-06-22 14:59:07 +00:00
|
|
|
|
2008-02-20 16:30:17 +00:00
|
|
|
if (KnownZero.intersects(SignBit)) {
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownZero |= HighBits; // New bits are known zero.
|
2008-02-20 16:30:17 +00:00
|
|
|
} else if (KnownOne.intersects(SignBit)) {
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownOne |= HighBits; // New bits are known one.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
case ISD::SIGN_EXTEND_INREG: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT EVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
|
|
|
|
unsigned EBits = EVT.getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
// Sign extension. Compute the demanded bits in the result that are not
|
|
|
|
// present in the input.
|
2008-02-13 22:28:48 +00:00
|
|
|
APInt NewBits = APInt::getHighBitsSet(BitWidth, BitWidth - EBits) & Mask;
|
2007-06-22 14:59:07 +00:00
|
|
|
|
2008-02-13 22:28:48 +00:00
|
|
|
APInt InSignBit = APInt::getSignBit(EBits);
|
|
|
|
APInt InputDemandedBits = Mask & APInt::getLowBitsSet(BitWidth, EBits);
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
// If the sign extended bits are demanded, we know that the sign
|
|
|
|
// bit is demanded.
|
2008-02-13 00:35:47 +00:00
|
|
|
InSignBit.zext(BitWidth);
|
2008-02-13 22:28:48 +00:00
|
|
|
if (NewBits.getBoolValue())
|
2007-06-22 14:59:07 +00:00
|
|
|
InputDemandedBits |= InSignBit;
|
|
|
|
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), InputDemandedBits,
|
|
|
|
KnownZero, KnownOne, Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
|
|
|
|
|
|
|
// If the sign bit of the input is known set or clear, then we know the
|
|
|
|
// top bits of the result.
|
2008-02-20 16:30:17 +00:00
|
|
|
if (KnownZero.intersects(InSignBit)) { // Input sign bit known clear
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownZero |= NewBits;
|
|
|
|
KnownOne &= ~NewBits;
|
2008-02-20 16:30:17 +00:00
|
|
|
} else if (KnownOne.intersects(InSignBit)) { // Input sign bit known set
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownOne |= NewBits;
|
|
|
|
KnownZero &= ~NewBits;
|
|
|
|
} else { // Input sign bit unknown
|
|
|
|
KnownZero &= ~NewBits;
|
|
|
|
KnownOne &= ~NewBits;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case ISD::CTTZ:
|
|
|
|
case ISD::CTLZ:
|
|
|
|
case ISD::CTPOP: {
|
2008-02-13 00:35:47 +00:00
|
|
|
unsigned LowBits = Log2_32(BitWidth)+1;
|
|
|
|
KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - LowBits);
|
2008-06-21 22:02:15 +00:00
|
|
|
KnownOne.clear();
|
2007-06-22 14:59:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
case ISD::LOAD: {
|
|
|
|
if (ISD::isZEXTLoad(Op.Val)) {
|
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(Op);
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = LD->getMemoryVT();
|
|
|
|
unsigned MemBits = VT.getSizeInBits();
|
2008-02-13 22:28:48 +00:00
|
|
|
KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - MemBits) & Mask;
|
2007-06-22 14:59:07 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case ISD::ZERO_EXTEND: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT InVT = Op.getOperand(0).getValueType();
|
|
|
|
unsigned InBits = InVT.getSizeInBits();
|
2008-02-13 22:28:48 +00:00
|
|
|
APInt NewBits = APInt::getHighBitsSet(BitWidth, BitWidth - InBits) & Mask;
|
|
|
|
APInt InMask = Mask;
|
|
|
|
InMask.trunc(InBits);
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero.trunc(InBits);
|
|
|
|
KnownOne.trunc(InBits);
|
2008-02-13 22:28:48 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), InMask, KnownZero, KnownOne, Depth+1);
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero.zext(BitWidth);
|
|
|
|
KnownOne.zext(BitWidth);
|
|
|
|
KnownZero |= NewBits;
|
2007-06-22 14:59:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
case ISD::SIGN_EXTEND: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT InVT = Op.getOperand(0).getValueType();
|
|
|
|
unsigned InBits = InVT.getSizeInBits();
|
2008-02-13 00:35:47 +00:00
|
|
|
APInt InSignBit = APInt::getSignBit(InBits);
|
2008-02-13 22:28:48 +00:00
|
|
|
APInt NewBits = APInt::getHighBitsSet(BitWidth, BitWidth - InBits) & Mask;
|
|
|
|
APInt InMask = Mask;
|
|
|
|
InMask.trunc(InBits);
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
// If any of the sign extended bits are demanded, we know that the sign
|
2008-02-13 22:28:48 +00:00
|
|
|
// bit is demanded. Temporarily set this bit in the mask for our callee.
|
|
|
|
if (NewBits.getBoolValue())
|
|
|
|
InMask |= InSignBit;
|
2008-02-13 00:35:47 +00:00
|
|
|
|
|
|
|
KnownZero.trunc(InBits);
|
|
|
|
KnownOne.trunc(InBits);
|
2008-02-13 22:28:48 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), InMask, KnownZero, KnownOne, Depth+1);
|
|
|
|
|
|
|
|
// Note if the sign bit is known to be zero or one.
|
|
|
|
bool SignBitKnownZero = KnownZero.isNegative();
|
|
|
|
bool SignBitKnownOne = KnownOne.isNegative();
|
|
|
|
assert(!(SignBitKnownZero && SignBitKnownOne) &&
|
|
|
|
"Sign bit can't be known to be both zero and one!");
|
|
|
|
|
|
|
|
// If the sign bit wasn't actually demanded by our caller, we don't
|
|
|
|
// want it set in the KnownZero and KnownOne result values. Reset the
|
|
|
|
// mask and reapply it to the result values.
|
|
|
|
InMask = Mask;
|
|
|
|
InMask.trunc(InBits);
|
|
|
|
KnownZero &= InMask;
|
|
|
|
KnownOne &= InMask;
|
|
|
|
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero.zext(BitWidth);
|
|
|
|
KnownOne.zext(BitWidth);
|
|
|
|
|
2008-02-13 22:28:48 +00:00
|
|
|
// If the sign bit is known zero or one, the top bits match.
|
|
|
|
if (SignBitKnownZero)
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownZero |= NewBits;
|
2008-02-13 22:28:48 +00:00
|
|
|
else if (SignBitKnownOne)
|
2007-06-22 14:59:07 +00:00
|
|
|
KnownOne |= NewBits;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case ISD::ANY_EXTEND: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT InVT = Op.getOperand(0).getValueType();
|
|
|
|
unsigned InBits = InVT.getSizeInBits();
|
2008-02-13 22:28:48 +00:00
|
|
|
APInt InMask = Mask;
|
|
|
|
InMask.trunc(InBits);
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero.trunc(InBits);
|
|
|
|
KnownOne.trunc(InBits);
|
2008-02-13 22:28:48 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), InMask, KnownZero, KnownOne, Depth+1);
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero.zext(BitWidth);
|
|
|
|
KnownOne.zext(BitWidth);
|
2007-06-22 14:59:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
case ISD::TRUNCATE: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT InVT = Op.getOperand(0).getValueType();
|
|
|
|
unsigned InBits = InVT.getSizeInBits();
|
2008-02-13 22:28:48 +00:00
|
|
|
APInt InMask = Mask;
|
|
|
|
InMask.zext(InBits);
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero.zext(InBits);
|
|
|
|
KnownOne.zext(InBits);
|
2008-02-13 22:28:48 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), InMask, KnownZero, KnownOne, Depth+1);
|
2007-06-22 14:59:07 +00:00
|
|
|
assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero.trunc(BitWidth);
|
|
|
|
KnownOne.trunc(BitWidth);
|
2007-06-22 14:59:07 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::AssertZext: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = cast<VTSDNode>(Op.getOperand(1))->getVT();
|
|
|
|
APInt InMask = APInt::getLowBitsSet(BitWidth, VT.getSizeInBits());
|
2007-06-22 14:59:07 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask & InMask, KnownZero,
|
|
|
|
KnownOne, Depth+1);
|
|
|
|
KnownZero |= (~InMask) & Mask;
|
|
|
|
return;
|
|
|
|
}
|
2007-12-22 21:26:52 +00:00
|
|
|
case ISD::FGETSIGN:
|
|
|
|
// All bits are zero except the low bit.
|
2008-02-13 00:35:47 +00:00
|
|
|
KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - 1);
|
2007-12-22 21:26:52 +00:00
|
|
|
return;
|
|
|
|
|
2008-04-28 17:02:21 +00:00
|
|
|
case ISD::SUB: {
|
|
|
|
if (ConstantSDNode *CLHS = dyn_cast<ConstantSDNode>(Op.getOperand(0))) {
|
|
|
|
// We know that the top bits of C-X are clear if X contains less bits
|
|
|
|
// than C (i.e. no wrap-around can happen). For example, 20-X is
|
|
|
|
// positive if we can prove that X is >= 0 and < 16.
|
|
|
|
if (CLHS->getAPIntValue().isNonNegative()) {
|
|
|
|
unsigned NLZ = (CLHS->getAPIntValue()+1).countLeadingZeros();
|
|
|
|
// NLZ can't be BitWidth with no sign bit
|
|
|
|
APInt MaskV = APInt::getHighBitsSet(BitWidth, NLZ+1);
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), MaskV, KnownZero2, KnownOne2,
|
|
|
|
Depth+1);
|
|
|
|
|
|
|
|
// If all of the MaskV bits are known to be zero, then we know the
|
|
|
|
// output top bits are zero, because we now know that the output is
|
|
|
|
// from [0-C].
|
|
|
|
if ((KnownZero2 & MaskV) == MaskV) {
|
|
|
|
unsigned NLZ2 = CLHS->getAPIntValue().countLeadingZeros();
|
|
|
|
// Top bits known zero.
|
|
|
|
KnownZero = APInt::getHighBitsSet(BitWidth, NLZ2) & Mask;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// fall through
|
2007-06-22 14:59:07 +00:00
|
|
|
case ISD::ADD: {
|
|
|
|
// Output known-0 bits are known if clear or set in both the low clear bits
|
|
|
|
// common to both LHS & RHS. For example, 8+(X<<3) is known to have the
|
|
|
|
// low 3 bits clear.
|
2008-04-28 17:02:21 +00:00
|
|
|
APInt Mask2 = APInt::getLowBitsSet(BitWidth, Mask.countTrailingOnes());
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask2, KnownZero2, KnownOne2, Depth+1);
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
unsigned KnownZeroOut = KnownZero2.countTrailingOnes();
|
|
|
|
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), Mask2, KnownZero2, KnownOne2, Depth+1);
|
|
|
|
assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
|
|
|
|
KnownZeroOut = std::min(KnownZeroOut,
|
|
|
|
KnownZero2.countTrailingOnes());
|
|
|
|
|
|
|
|
KnownZero |= APInt::getLowBitsSet(BitWidth, KnownZeroOut);
|
2007-06-22 14:59:07 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-04-28 17:02:21 +00:00
|
|
|
case ISD::SREM:
|
|
|
|
if (ConstantSDNode *Rem = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
2008-07-03 00:52:03 +00:00
|
|
|
const APInt &RA = Rem->getAPIntValue();
|
2008-04-28 17:02:21 +00:00
|
|
|
if (RA.isPowerOf2() || (-RA).isPowerOf2()) {
|
2008-05-06 00:51:48 +00:00
|
|
|
APInt LowBits = RA.isStrictlyPositive() ? (RA - 1) : ~RA;
|
2008-04-28 17:02:21 +00:00
|
|
|
APInt Mask2 = LowBits | APInt::getSignBit(BitWidth);
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask2,KnownZero2,KnownOne2,Depth+1);
|
|
|
|
|
|
|
|
// The sign of a remainder is equal to the sign of the first
|
|
|
|
// operand (zero being positive).
|
|
|
|
if (KnownZero2[BitWidth-1] || ((KnownZero2 & LowBits) == LowBits))
|
|
|
|
KnownZero2 |= ~LowBits;
|
|
|
|
else if (KnownOne2[BitWidth-1])
|
|
|
|
KnownOne2 |= ~LowBits;
|
|
|
|
|
|
|
|
KnownZero |= KnownZero2 & Mask;
|
|
|
|
KnownOne |= KnownOne2 & Mask;
|
|
|
|
|
|
|
|
assert((KnownZero & KnownOne) == 0&&"Bits known to be one AND zero?");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
case ISD::UREM: {
|
|
|
|
if (ConstantSDNode *Rem = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
2008-07-03 00:52:03 +00:00
|
|
|
const APInt &RA = Rem->getAPIntValue();
|
2008-05-06 00:51:48 +00:00
|
|
|
if (RA.isPowerOf2()) {
|
|
|
|
APInt LowBits = (RA - 1);
|
2008-04-28 17:02:21 +00:00
|
|
|
APInt Mask2 = LowBits & Mask;
|
|
|
|
KnownZero |= ~LowBits & Mask;
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask2, KnownZero, KnownOne,Depth+1);
|
|
|
|
assert((KnownZero & KnownOne) == 0&&"Bits known to be one AND zero?");
|
|
|
|
break;
|
2007-06-22 14:59:07 +00:00
|
|
|
}
|
|
|
|
}
|
2008-04-28 17:02:21 +00:00
|
|
|
|
|
|
|
// Since the result is less than or equal to either operand, any leading
|
|
|
|
// zero bits in either operand must also exist in the result.
|
|
|
|
APInt AllOnes = APInt::getAllOnesValue(BitWidth);
|
|
|
|
ComputeMaskedBits(Op.getOperand(0), AllOnes, KnownZero, KnownOne,
|
|
|
|
Depth+1);
|
|
|
|
ComputeMaskedBits(Op.getOperand(1), AllOnes, KnownZero2, KnownOne2,
|
|
|
|
Depth+1);
|
|
|
|
|
|
|
|
uint32_t Leaders = std::max(KnownZero.countLeadingOnes(),
|
|
|
|
KnownZero2.countLeadingOnes());
|
|
|
|
KnownOne.clear();
|
|
|
|
KnownZero = APInt::getHighBitsSet(BitWidth, Leaders) & Mask;
|
2007-06-22 14:59:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
// Allow the target to implement this method for its nodes.
|
|
|
|
if (Op.getOpcode() >= ISD::BUILTIN_OP_END) {
|
|
|
|
case ISD::INTRINSIC_WO_CHAIN:
|
|
|
|
case ISD::INTRINSIC_W_CHAIN:
|
|
|
|
case ISD::INTRINSIC_VOID:
|
|
|
|
TLI.computeMaskedBitsForTargetNode(Op, Mask, KnownZero, KnownOne, *this);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ComputeNumSignBits - Return the number of times the sign bit of the
|
|
|
|
/// register is replicated into the other bits. We know that at least 1 bit
|
|
|
|
/// is always equal to the sign bit (itself), but other cases can give us
|
|
|
|
/// information. For example, immediately after an "SRA X, 2", we know that
|
|
|
|
/// the top 3 bits are all equal to each other, so we return 3.
|
|
|
|
unsigned SelectionDAG::ComputeNumSignBits(SDOperand Op, unsigned Depth) const{
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = Op.getValueType();
|
|
|
|
assert(VT.isInteger() && "Invalid VT!");
|
|
|
|
unsigned VTBits = VT.getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
unsigned Tmp, Tmp2;
|
2008-05-23 02:28:01 +00:00
|
|
|
unsigned FirstAnswer = 1;
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
if (Depth == 6)
|
|
|
|
return 1; // Limit search depth.
|
|
|
|
|
|
|
|
switch (Op.getOpcode()) {
|
|
|
|
default: break;
|
|
|
|
case ISD::AssertSext:
|
2008-06-06 12:08:01 +00:00
|
|
|
Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
return VTBits-Tmp+1;
|
|
|
|
case ISD::AssertZext:
|
2008-06-06 12:08:01 +00:00
|
|
|
Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
return VTBits-Tmp;
|
|
|
|
|
|
|
|
case ISD::Constant: {
|
2008-03-03 23:35:36 +00:00
|
|
|
const APInt &Val = cast<ConstantSDNode>(Op)->getAPIntValue();
|
|
|
|
// If negative, return # leading ones.
|
|
|
|
if (Val.isNegative())
|
|
|
|
return Val.countLeadingOnes();
|
2007-06-22 14:59:07 +00:00
|
|
|
|
2008-03-03 23:35:36 +00:00
|
|
|
// Return # leading zeros.
|
|
|
|
return Val.countLeadingZeros();
|
2007-06-22 14:59:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
case ISD::SIGN_EXTEND:
|
2008-06-06 12:08:01 +00:00
|
|
|
Tmp = VTBits-Op.getOperand(0).getValueType().getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
return ComputeNumSignBits(Op.getOperand(0), Depth+1) + Tmp;
|
|
|
|
|
|
|
|
case ISD::SIGN_EXTEND_INREG:
|
|
|
|
// Max of the input and what this extends.
|
2008-06-06 12:08:01 +00:00
|
|
|
Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
Tmp = VTBits-Tmp+1;
|
|
|
|
|
|
|
|
Tmp2 = ComputeNumSignBits(Op.getOperand(0), Depth+1);
|
|
|
|
return std::max(Tmp, Tmp2);
|
|
|
|
|
|
|
|
case ISD::SRA:
|
|
|
|
Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
|
|
|
|
// SRA X, C -> adds C sign bits.
|
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
|
|
|
Tmp += C->getValue();
|
|
|
|
if (Tmp > VTBits) Tmp = VTBits;
|
|
|
|
}
|
|
|
|
return Tmp;
|
|
|
|
case ISD::SHL:
|
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
|
|
|
// shl destroys sign bits.
|
|
|
|
Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
|
|
|
|
if (C->getValue() >= VTBits || // Bad shift.
|
|
|
|
C->getValue() >= Tmp) break; // Shifted all sign bits out.
|
|
|
|
return Tmp - C->getValue();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ISD::AND:
|
|
|
|
case ISD::OR:
|
|
|
|
case ISD::XOR: // NOT is handled here.
|
2008-05-23 02:28:01 +00:00
|
|
|
// Logical binary ops preserve the number of sign bits at the worst.
|
2007-06-22 14:59:07 +00:00
|
|
|
Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
|
2008-05-23 02:28:01 +00:00
|
|
|
if (Tmp != 1) {
|
|
|
|
Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1);
|
|
|
|
FirstAnswer = std::min(Tmp, Tmp2);
|
|
|
|
// We computed what we know about the sign bits as our first
|
|
|
|
// answer. Now proceed to the generic code that uses
|
|
|
|
// ComputeMaskedBits, and pick whichever answer is better.
|
|
|
|
}
|
|
|
|
break;
|
2007-06-22 14:59:07 +00:00
|
|
|
|
|
|
|
case ISD::SELECT:
|
2008-05-20 20:59:51 +00:00
|
|
|
Tmp = ComputeNumSignBits(Op.getOperand(1), Depth+1);
|
2007-06-22 14:59:07 +00:00
|
|
|
if (Tmp == 1) return 1; // Early out.
|
2008-05-20 20:59:51 +00:00
|
|
|
Tmp2 = ComputeNumSignBits(Op.getOperand(2), Depth+1);
|
2007-06-22 14:59:07 +00:00
|
|
|
return std::min(Tmp, Tmp2);
|
|
|
|
|
|
|
|
case ISD::SETCC:
|
|
|
|
// If setcc returns 0/-1, all bits are sign bits.
|
|
|
|
if (TLI.getSetCCResultContents() ==
|
|
|
|
TargetLowering::ZeroOrNegativeOneSetCCResult)
|
|
|
|
return VTBits;
|
|
|
|
break;
|
|
|
|
case ISD::ROTL:
|
|
|
|
case ISD::ROTR:
|
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
|
|
|
|
unsigned RotAmt = C->getValue() & (VTBits-1);
|
|
|
|
|
|
|
|
// Handle rotate right by N like a rotate left by 32-N.
|
|
|
|
if (Op.getOpcode() == ISD::ROTR)
|
|
|
|
RotAmt = (VTBits-RotAmt) & (VTBits-1);
|
|
|
|
|
|
|
|
// If we aren't rotating out all of the known-in sign bits, return the
|
|
|
|
// number that are left. This handles rotl(sext(x), 1) for example.
|
|
|
|
Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
|
|
|
|
if (Tmp > RotAmt+1) return Tmp-RotAmt;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ISD::ADD:
|
|
|
|
// Add can have at most one carry bit. Thus we know that the output
|
|
|
|
// is, at worst, one more bit than the inputs.
|
|
|
|
Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
|
|
|
|
if (Tmp == 1) return 1; // Early out.
|
|
|
|
|
|
|
|
// Special case decrementing a value (ADD X, -1):
|
|
|
|
if (ConstantSDNode *CRHS = dyn_cast<ConstantSDNode>(Op.getOperand(0)))
|
|
|
|
if (CRHS->isAllOnesValue()) {
|
2008-02-27 01:23:58 +00:00
|
|
|
APInt KnownZero, KnownOne;
|
|
|
|
APInt Mask = APInt::getAllOnesValue(VTBits);
|
2007-06-22 14:59:07 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(0), Mask, KnownZero, KnownOne, Depth+1);
|
|
|
|
|
|
|
|
// If the input is known to be 0 or 1, the output is 0/-1, which is all
|
|
|
|
// sign bits set.
|
2008-02-27 01:23:58 +00:00
|
|
|
if ((KnownZero | APInt(VTBits, 1)) == Mask)
|
2007-06-22 14:59:07 +00:00
|
|
|
return VTBits;
|
|
|
|
|
|
|
|
// If we are subtracting one from a positive number, there is no carry
|
|
|
|
// out of the result.
|
2008-02-27 01:23:58 +00:00
|
|
|
if (KnownZero.isNegative())
|
2007-06-22 14:59:07 +00:00
|
|
|
return Tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1);
|
|
|
|
if (Tmp2 == 1) return 1;
|
|
|
|
return std::min(Tmp, Tmp2)-1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ISD::SUB:
|
|
|
|
Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1);
|
|
|
|
if (Tmp2 == 1) return 1;
|
|
|
|
|
|
|
|
// Handle NEG.
|
|
|
|
if (ConstantSDNode *CLHS = dyn_cast<ConstantSDNode>(Op.getOperand(0)))
|
2008-03-13 22:13:53 +00:00
|
|
|
if (CLHS->isNullValue()) {
|
2008-02-27 01:23:58 +00:00
|
|
|
APInt KnownZero, KnownOne;
|
|
|
|
APInt Mask = APInt::getAllOnesValue(VTBits);
|
2007-06-22 14:59:07 +00:00
|
|
|
ComputeMaskedBits(Op.getOperand(1), Mask, KnownZero, KnownOne, Depth+1);
|
|
|
|
// If the input is known to be 0 or 1, the output is 0/-1, which is all
|
|
|
|
// sign bits set.
|
2008-02-27 01:23:58 +00:00
|
|
|
if ((KnownZero | APInt(VTBits, 1)) == Mask)
|
2007-06-22 14:59:07 +00:00
|
|
|
return VTBits;
|
|
|
|
|
|
|
|
// If the input is known to be positive (the sign bit is known clear),
|
|
|
|
// the output of the NEG has the same number of sign bits as the input.
|
2008-02-27 01:23:58 +00:00
|
|
|
if (KnownZero.isNegative())
|
2007-06-22 14:59:07 +00:00
|
|
|
return Tmp2;
|
|
|
|
|
|
|
|
// Otherwise, we treat this like a SUB.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sub can have at most one carry bit. Thus we know that the output
|
|
|
|
// is, at worst, one more bit than the inputs.
|
|
|
|
Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
|
|
|
|
if (Tmp == 1) return 1; // Early out.
|
|
|
|
return std::min(Tmp, Tmp2)-1;
|
|
|
|
break;
|
|
|
|
case ISD::TRUNCATE:
|
|
|
|
// FIXME: it's tricky to do anything useful for this, but it is an important
|
|
|
|
// case for targets like X86.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle LOADX separately here. EXTLOAD case will fallthrough.
|
|
|
|
if (Op.getOpcode() == ISD::LOAD) {
|
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(Op);
|
|
|
|
unsigned ExtType = LD->getExtensionType();
|
|
|
|
switch (ExtType) {
|
|
|
|
default: break;
|
|
|
|
case ISD::SEXTLOAD: // '17' bits known
|
2008-06-06 12:08:01 +00:00
|
|
|
Tmp = LD->getMemoryVT().getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
return VTBits-Tmp+1;
|
|
|
|
case ISD::ZEXTLOAD: // '16' bits known
|
2008-06-06 12:08:01 +00:00
|
|
|
Tmp = LD->getMemoryVT().getSizeInBits();
|
2007-06-22 14:59:07 +00:00
|
|
|
return VTBits-Tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Allow the target to implement this method for its nodes.
|
|
|
|
if (Op.getOpcode() >= ISD::BUILTIN_OP_END ||
|
|
|
|
Op.getOpcode() == ISD::INTRINSIC_WO_CHAIN ||
|
|
|
|
Op.getOpcode() == ISD::INTRINSIC_W_CHAIN ||
|
|
|
|
Op.getOpcode() == ISD::INTRINSIC_VOID) {
|
|
|
|
unsigned NumBits = TLI.ComputeNumSignBitsForTargetNode(Op, Depth);
|
2008-05-23 02:28:01 +00:00
|
|
|
if (NumBits > 1) FirstAnswer = std::max(FirstAnswer, NumBits);
|
2007-06-22 14:59:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, if we can prove that the top bits of the result are 0's or 1's,
|
|
|
|
// use this information.
|
2008-02-27 01:23:58 +00:00
|
|
|
APInt KnownZero, KnownOne;
|
|
|
|
APInt Mask = APInt::getAllOnesValue(VTBits);
|
2007-06-22 14:59:07 +00:00
|
|
|
ComputeMaskedBits(Op, Mask, KnownZero, KnownOne, Depth);
|
|
|
|
|
2008-02-27 01:23:58 +00:00
|
|
|
if (KnownZero.isNegative()) { // sign bit is 0
|
2007-06-22 14:59:07 +00:00
|
|
|
Mask = KnownZero;
|
2008-02-27 01:23:58 +00:00
|
|
|
} else if (KnownOne.isNegative()) { // sign bit is 1;
|
2007-06-22 14:59:07 +00:00
|
|
|
Mask = KnownOne;
|
|
|
|
} else {
|
|
|
|
// Nothing known.
|
2008-05-23 02:28:01 +00:00
|
|
|
return FirstAnswer;
|
2007-06-22 14:59:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, we know that the sign bit in Mask is set. Use CLZ to determine
|
|
|
|
// the number of identical bits in the top of the input value.
|
2008-02-27 01:23:58 +00:00
|
|
|
Mask = ~Mask;
|
|
|
|
Mask <<= Mask.getBitWidth()-VTBits;
|
2007-06-22 14:59:07 +00:00
|
|
|
// Return # leading zeros. We use 'min' here in case Val was zero before
|
|
|
|
// shifting. We don't want to return '64' as for an i32 "0".
|
2008-05-23 02:28:01 +00:00
|
|
|
return std::max(FirstAnswer, std::min(VTBits, Mask.countLeadingZeros()));
|
2007-06-22 14:59:07 +00:00
|
|
|
}
|
|
|
|
|
2006-10-14 00:41:01 +00:00
|
|
|
|
2008-02-02 04:07:54 +00:00
|
|
|
bool SelectionDAG::isVerifiedDebugInfoDesc(SDOperand Op) const {
|
|
|
|
GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op);
|
|
|
|
if (!GA) return false;
|
|
|
|
GlobalVariable *GV = dyn_cast<GlobalVariable>(GA->getGlobal());
|
|
|
|
if (!GV) return false;
|
|
|
|
MachineModuleInfo *MMI = getMachineModuleInfo();
|
|
|
|
return MMI && MMI->hasDebugInfo() && MMI->isVerified(GV);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-13 08:35:03 +00:00
|
|
|
/// getShuffleScalarElt - Returns the scalar element that will make up the ith
|
|
|
|
/// element of the result of the vector shuffle.
|
2008-06-25 20:52:59 +00:00
|
|
|
SDOperand SelectionDAG::getShuffleScalarElt(const SDNode *N, unsigned i) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = N->getValueType(0);
|
2008-05-13 08:35:03 +00:00
|
|
|
SDOperand PermMask = N->getOperand(2);
|
2008-06-25 20:52:59 +00:00
|
|
|
SDOperand Idx = PermMask.getOperand(i);
|
|
|
|
if (Idx.getOpcode() == ISD::UNDEF)
|
|
|
|
return getNode(ISD::UNDEF, VT.getVectorElementType());
|
|
|
|
unsigned Index = cast<ConstantSDNode>(Idx)->getValue();
|
2008-05-13 08:35:03 +00:00
|
|
|
unsigned NumElems = PermMask.getNumOperands();
|
2008-06-25 20:52:59 +00:00
|
|
|
SDOperand V = (Index < NumElems) ? N->getOperand(0) : N->getOperand(1);
|
|
|
|
Index %= NumElems;
|
2008-05-29 08:22:04 +00:00
|
|
|
|
|
|
|
if (V.getOpcode() == ISD::BIT_CONVERT) {
|
|
|
|
V = V.getOperand(0);
|
2008-06-06 12:08:01 +00:00
|
|
|
if (V.getValueType().getVectorNumElements() != NumElems)
|
2008-05-29 08:22:04 +00:00
|
|
|
return SDOperand();
|
2008-05-13 08:35:03 +00:00
|
|
|
}
|
2008-05-29 08:22:04 +00:00
|
|
|
if (V.getOpcode() == ISD::SCALAR_TO_VECTOR)
|
2008-06-25 20:52:59 +00:00
|
|
|
return (Index == 0) ? V.getOperand(0)
|
2008-06-06 12:08:01 +00:00
|
|
|
: getNode(ISD::UNDEF, VT.getVectorElementType());
|
2008-05-29 08:22:04 +00:00
|
|
|
if (V.getOpcode() == ISD::BUILD_VECTOR)
|
2008-06-25 20:52:59 +00:00
|
|
|
return V.getOperand(Index);
|
|
|
|
if (V.getOpcode() == ISD::VECTOR_SHUFFLE)
|
|
|
|
return getShuffleScalarElt(V.Val, Index);
|
2008-05-13 08:35:03 +00:00
|
|
|
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
|
|
|
///
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT VT) {
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-07-07 18:26:29 +00:00
|
|
|
AddNodeIDNode(ID, Opcode, getVTList(VT), 0, 0);
|
2006-08-11 18:38:11 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<SDNode>();
|
|
|
|
new (N) SDNode(Opcode, SDNode::getSDVTList(VT));
|
2006-08-11 18:38:11 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
|
|
|
|
AllNodes.push_back(N);
|
2008-07-21 10:20:31 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
VerifyNode(N);
|
|
|
|
#endif
|
2005-01-07 07:46:32 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT VT, SDOperand Operand) {
|
constant fold bits_convert in getNode and in the dag combiner for fp<->int
conversions. This allows V8 to compiles this:
void %test() {
call float %test2( float 1.000000e+00, float 2.000000e+00, double 3.000000e+00, double* null )
ret void
}
into:
test:
save -96, %o6, %o6
sethi 0, %o3
sethi 1049088, %o2
sethi 1048576, %o1
sethi 1040384, %o0
or %g0, %o3, %o4
call test2
nop
restore %g0, %g0, %g0
retl
nop
instead of:
test:
save -112, %o6, %o6
sethi 0, %o4
sethi 1049088, %l0
st %o4, [%i6+-12]
st %l0, [%i6+-16]
ld [%i6+-12], %o3
ld [%i6+-16], %o2
sethi 1048576, %o1
sethi 1040384, %o0
call test2
nop
restore %g0, %g0, %g0
retl
nop
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24980 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-23 05:30:37 +00:00
|
|
|
// Constant fold unary operations with an integer constant operand.
|
2005-01-07 07:46:32 +00:00
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Operand.Val)) {
|
2008-02-29 01:47:35 +00:00
|
|
|
const APInt &Val = C->getAPIntValue();
|
2008-06-06 12:08:01 +00:00
|
|
|
unsigned BitWidth = VT.getSizeInBits();
|
2005-01-07 07:46:32 +00:00
|
|
|
switch (Opcode) {
|
|
|
|
default: break;
|
2008-03-06 17:42:34 +00:00
|
|
|
case ISD::SIGN_EXTEND:
|
|
|
|
return getConstant(APInt(Val).sextOrTrunc(BitWidth), VT);
|
2005-09-02 00:17:32 +00:00
|
|
|
case ISD::ANY_EXTEND:
|
2008-02-29 01:47:35 +00:00
|
|
|
case ISD::ZERO_EXTEND:
|
2008-03-06 17:42:34 +00:00
|
|
|
case ISD::TRUNCATE:
|
|
|
|
return getConstant(APInt(Val).zextOrTrunc(BitWidth), VT);
|
2007-09-19 23:55:34 +00:00
|
|
|
case ISD::UINT_TO_FP:
|
|
|
|
case ISD::SINT_TO_FP: {
|
|
|
|
const uint64_t zero[] = {0, 0};
|
2007-10-16 23:38:29 +00:00
|
|
|
// No compile time operations on this type.
|
|
|
|
if (VT==MVT::ppcf128)
|
|
|
|
break;
|
2008-02-29 01:47:35 +00:00
|
|
|
APFloat apf = APFloat(APInt(BitWidth, 2, zero));
|
|
|
|
(void)apf.convertFromAPInt(Val,
|
|
|
|
Opcode==ISD::SINT_TO_FP,
|
|
|
|
APFloat::rmNearestTiesToEven);
|
2007-09-19 23:55:34 +00:00
|
|
|
return getConstantFP(apf, VT);
|
|
|
|
}
|
constant fold bits_convert in getNode and in the dag combiner for fp<->int
conversions. This allows V8 to compiles this:
void %test() {
call float %test2( float 1.000000e+00, float 2.000000e+00, double 3.000000e+00, double* null )
ret void
}
into:
test:
save -96, %o6, %o6
sethi 0, %o3
sethi 1049088, %o2
sethi 1048576, %o1
sethi 1040384, %o0
or %g0, %o3, %o4
call test2
nop
restore %g0, %g0, %g0
retl
nop
instead of:
test:
save -112, %o6, %o6
sethi 0, %o4
sethi 1049088, %l0
st %o4, [%i6+-12]
st %l0, [%i6+-16]
ld [%i6+-12], %o3
ld [%i6+-16], %o2
sethi 1048576, %o1
sethi 1040384, %o0
call test2
nop
restore %g0, %g0, %g0
retl
nop
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24980 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-23 05:30:37 +00:00
|
|
|
case ISD::BIT_CONVERT:
|
2006-03-24 02:20:47 +00:00
|
|
|
if (VT == MVT::f32 && C->getValueType(0) == MVT::i32)
|
2008-02-29 01:47:35 +00:00
|
|
|
return getConstantFP(Val.bitsToFloat(), VT);
|
2006-03-24 02:20:47 +00:00
|
|
|
else if (VT == MVT::f64 && C->getValueType(0) == MVT::i64)
|
2008-02-29 01:47:35 +00:00
|
|
|
return getConstantFP(Val.bitsToDouble(), VT);
|
constant fold bits_convert in getNode and in the dag combiner for fp<->int
conversions. This allows V8 to compiles this:
void %test() {
call float %test2( float 1.000000e+00, float 2.000000e+00, double 3.000000e+00, double* null )
ret void
}
into:
test:
save -96, %o6, %o6
sethi 0, %o3
sethi 1049088, %o2
sethi 1048576, %o1
sethi 1040384, %o0
or %g0, %o3, %o4
call test2
nop
restore %g0, %g0, %g0
retl
nop
instead of:
test:
save -112, %o6, %o6
sethi 0, %o4
sethi 1049088, %l0
st %o4, [%i6+-12]
st %l0, [%i6+-16]
ld [%i6+-12], %o3
ld [%i6+-16], %o2
sethi 1048576, %o1
sethi 1040384, %o0
call test2
nop
restore %g0, %g0, %g0
retl
nop
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24980 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-23 05:30:37 +00:00
|
|
|
break;
|
2006-01-16 08:07:10 +00:00
|
|
|
case ISD::BSWAP:
|
2008-02-29 01:47:35 +00:00
|
|
|
return getConstant(Val.byteSwap(), VT);
|
2006-01-16 08:07:10 +00:00
|
|
|
case ISD::CTPOP:
|
2008-02-29 01:47:35 +00:00
|
|
|
return getConstant(Val.countPopulation(), VT);
|
2006-01-16 08:07:10 +00:00
|
|
|
case ISD::CTLZ:
|
2008-02-29 01:47:35 +00:00
|
|
|
return getConstant(Val.countLeadingZeros(), VT);
|
2006-01-16 08:07:10 +00:00
|
|
|
case ISD::CTTZ:
|
2008-02-29 01:47:35 +00:00
|
|
|
return getConstant(Val.countTrailingZeros(), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-31 23:34:27 +00:00
|
|
|
// Constant fold unary operations with a floating point constant operand.
|
|
|
|
if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Operand.Val)) {
|
|
|
|
APFloat V = C->getValueAPF(); // make copy
|
2008-01-17 07:00:52 +00:00
|
|
|
if (VT != MVT::ppcf128 && Operand.getValueType() != MVT::ppcf128) {
|
2007-10-16 23:38:29 +00:00
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::FNEG:
|
|
|
|
V.changeSign();
|
|
|
|
return getConstantFP(V, VT);
|
|
|
|
case ISD::FABS:
|
|
|
|
V.clearSign();
|
|
|
|
return getConstantFP(V, VT);
|
|
|
|
case ISD::FP_ROUND:
|
|
|
|
case ISD::FP_EXTEND:
|
|
|
|
// This can return overflow, underflow, or inexact; we don't care.
|
|
|
|
// FIXME need to be more flexible about rounding mode.
|
2008-03-05 06:48:13 +00:00
|
|
|
(void)V.convert(*MVTToAPFloatSemantics(VT),
|
|
|
|
APFloat::rmNearestTiesToEven);
|
2007-10-16 23:38:29 +00:00
|
|
|
return getConstantFP(V, VT);
|
|
|
|
case ISD::FP_TO_SINT:
|
|
|
|
case ISD::FP_TO_UINT: {
|
|
|
|
integerPart x;
|
|
|
|
assert(integerPartWidth >= 64);
|
|
|
|
// FIXME need to be more flexible about rounding mode.
|
|
|
|
APFloat::opStatus s = V.convertToInteger(&x, 64U,
|
|
|
|
Opcode==ISD::FP_TO_SINT,
|
|
|
|
APFloat::rmTowardZero);
|
|
|
|
if (s==APFloat::opInvalidOp) // inexact is OK, in fact usual
|
|
|
|
break;
|
|
|
|
return getConstant(x, VT);
|
|
|
|
}
|
|
|
|
case ISD::BIT_CONVERT:
|
|
|
|
if (VT == MVT::i32 && C->getValueType(0) == MVT::f32)
|
|
|
|
return getConstant((uint32_t)V.convertToAPInt().getZExtValue(), VT);
|
|
|
|
else if (VT == MVT::i64 && C->getValueType(0) == MVT::f64)
|
|
|
|
return getConstant(V.convertToAPInt().getZExtValue(), VT);
|
2007-08-31 23:34:27 +00:00
|
|
|
break;
|
2007-10-16 23:38:29 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2007-08-31 23:34:27 +00:00
|
|
|
}
|
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:
|
2008-06-30 10:19:09 +00:00
|
|
|
return Operand; // Factor of one node? No need.
|
2008-01-17 07:00:52 +00:00
|
|
|
case ISD::FP_ROUND: assert(0 && "Invalid method to make FP_ROUND node");
|
2007-04-09 05:23:13 +00:00
|
|
|
case ISD::FP_EXTEND:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isFloatingPoint() &&
|
|
|
|
Operand.getValueType().isFloatingPoint() && "Invalid FP cast!");
|
2008-01-16 17:59:31 +00:00
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop conversion.
|
2008-03-11 06:21:08 +00:00
|
|
|
if (Operand.getOpcode() == ISD::UNDEF)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
2007-04-09 05:23:13 +00:00
|
|
|
break;
|
2008-03-11 06:21:08 +00:00
|
|
|
case ISD::SIGN_EXTEND:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && Operand.getValueType().isInteger() &&
|
2007-04-09 05:23:13 +00:00
|
|
|
"Invalid SIGN_EXTEND!");
|
2005-01-07 07:46:32 +00:00
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop extension
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(Operand.getValueType().bitsLT(VT)
|
2007-10-16 09:56:48 +00:00
|
|
|
&& "Invalid sext node, dst < src!");
|
2005-01-07 07:46:32 +00:00
|
|
|
if (OpOpcode == ISD::SIGN_EXTEND || OpOpcode == ISD::ZERO_EXTEND)
|
|
|
|
return getNode(OpOpcode, VT, Operand.Val->getOperand(0));
|
|
|
|
break;
|
|
|
|
case ISD::ZERO_EXTEND:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && Operand.getValueType().isInteger() &&
|
2007-04-09 05:23:13 +00:00
|
|
|
"Invalid ZERO_EXTEND!");
|
2005-01-07 07:46:32 +00:00
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop extension
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(Operand.getValueType().bitsLT(VT)
|
2007-10-16 09:56:48 +00:00
|
|
|
&& "Invalid zext node, dst < src!");
|
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:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && Operand.getValueType().isInteger() &&
|
2007-04-09 05:23:13 +00:00
|
|
|
"Invalid ANY_EXTEND!");
|
2005-09-02 00:17:32 +00:00
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop extension
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(Operand.getValueType().bitsLT(VT)
|
2007-10-16 09:56:48 +00:00
|
|
|
&& "Invalid anyext node, dst < src!");
|
2005-09-02 00:17:32 +00:00
|
|
|
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:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && Operand.getValueType().isInteger() &&
|
2007-04-09 05:23:13 +00:00
|
|
|
"Invalid TRUNCATE!");
|
2005-01-07 07:46:32 +00:00
|
|
|
if (Operand.getValueType() == VT) return Operand; // noop truncate
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(Operand.getValueType().bitsGT(VT)
|
2007-10-16 09:56:48 +00:00
|
|
|
&& "Invalid truncate node, src < dst!");
|
2005-01-07 07:46:32 +00:00
|
|
|
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.
|
2008-06-08 20:54:56 +00:00
|
|
|
if (Operand.Val->getOperand(0).getValueType().bitsLT(VT))
|
2005-01-07 21:56:24 +00:00
|
|
|
return getNode(OpOpcode, VT, Operand.Val->getOperand(0));
|
2008-06-08 20:54:56 +00:00
|
|
|
else if (Operand.Val->getOperand(0).getValueType().bitsGT(VT))
|
2005-01-07 21:56:24 +00:00
|
|
|
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-12-23 00:16:34 +00:00
|
|
|
case ISD::BIT_CONVERT:
|
|
|
|
// Basic sanity checking.
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.getSizeInBits() == Operand.getValueType().getSizeInBits()
|
2006-11-11 20:07:59 +00:00
|
|
|
&& "Cannot BIT_CONVERT between types of different sizes!");
|
2005-12-23 00:16:34 +00:00
|
|
|
if (VT == Operand.getValueType()) return Operand; // noop conversion.
|
Fold bitconv(bitconv(x)) -> x. We now compile this:
void foo(double);
void bar(double X) { foo(X); }
to this:
bar:
save -96, %o6, %o6
or %g0, %i0, %o0
or %g0, %i1, %o1
call foo
nop
restore %g0, %g0, %g0
retl
nop
instead of this:
bar:
save -112, %o6, %o6
st %i1, [%i6+-4]
st %i0, [%i6+-8]
ldd [%i6+-8], %f0
std %f0, [%i6+-16]
ld [%i6+-12], %o1
ld [%i6+-16], %o0
call foo
nop
restore %g0, %g0, %g0
retl
nop
on V8.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24981 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-23 05:37:50 +00:00
|
|
|
if (OpOpcode == ISD::BIT_CONVERT) // bitconv(bitconv(x)) -> bitconv(x)
|
|
|
|
return getNode(ISD::BIT_CONVERT, VT, Operand.getOperand(0));
|
2006-04-04 01:02:22 +00:00
|
|
|
if (OpOpcode == ISD::UNDEF)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
2005-12-23 00:16:34 +00:00
|
|
|
break;
|
2006-03-19 06:31:19 +00:00
|
|
|
case ISD::SCALAR_TO_VECTOR:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isVector() && !Operand.getValueType().isVector() &&
|
|
|
|
VT.getVectorElementType() == Operand.getValueType() &&
|
2006-03-19 06:31:19 +00:00
|
|
|
"Illegal SCALAR_TO_VECTOR node!");
|
2008-03-08 23:43:36 +00:00
|
|
|
if (OpOpcode == ISD::UNDEF)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
// scalar_to_vector(extract_vector_elt V, 0) -> V, top bits are undefined.
|
|
|
|
if (OpOpcode == ISD::EXTRACT_VECTOR_ELT &&
|
|
|
|
isa<ConstantSDNode>(Operand.getOperand(1)) &&
|
|
|
|
Operand.getConstantOperandVal(1) == 0 &&
|
|
|
|
Operand.getOperand(0).getValueType() == VT)
|
|
|
|
return Operand.getOperand(0);
|
2006-03-19 06:31:19 +00:00
|
|
|
break;
|
2005-04-09 03:02:46 +00:00
|
|
|
case ISD::FNEG:
|
2005-09-28 22:28:18 +00:00
|
|
|
if (OpOpcode == ISD::FSUB) // -(X-Y) -> (Y-X)
|
|
|
|
return getNode(ISD::FSUB, VT, Operand.Val->getOperand(1),
|
2005-04-09 03:02:46 +00:00
|
|
|
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;
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2005-08-25 19:12:10 +00:00
|
|
|
if (VT != MVT::Flag) { // Don't CSE flag producing nodes
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2007-02-04 08:35:21 +00:00
|
|
|
SDOperand Ops[1] = { Operand };
|
2007-02-04 07:28:00 +00:00
|
|
|
AddNodeIDNode(ID, Opcode, VTs, Ops, 1);
|
2006-08-07 23:03:03 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<UnarySDNode>();
|
|
|
|
new (N) UnarySDNode(Opcode, VTs, Operand);
|
2006-08-07 23:03:03 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-08-25 19:12:10 +00:00
|
|
|
} else {
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<UnarySDNode>();
|
|
|
|
new (N) UnarySDNode(Opcode, VTs, Operand);
|
2005-08-25 19:12:10 +00:00
|
|
|
}
|
2008-07-21 10:20:31 +00:00
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
2008-07-21 10:20:31 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
VerifyNode(N);
|
|
|
|
#endif
|
2005-01-07 07:46:32 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT VT,
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand N1, SDOperand N2) {
|
2008-01-22 19:09:33 +00:00
|
|
|
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.Val);
|
|
|
|
ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.Val);
|
2005-01-16 02:23:22 +00:00
|
|
|
switch (Opcode) {
|
2008-01-22 19:09:33 +00:00
|
|
|
default: break;
|
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!");
|
2008-01-22 19:09:33 +00:00
|
|
|
// Fold trivial token factors.
|
|
|
|
if (N1.getOpcode() == ISD::EntryToken) return N2;
|
|
|
|
if (N2.getOpcode() == ISD::EntryToken) return N1;
|
2005-01-19 18:01:40 +00:00
|
|
|
break;
|
2005-01-16 02:23:22 +00:00
|
|
|
case ISD::AND:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && N1.getValueType() == N2.getValueType() &&
|
2008-01-22 19:09:33 +00:00
|
|
|
N1.getValueType() == VT && "Binary operator types must match!");
|
|
|
|
// (X & 0) -> 0. This commonly occurs when legalizing i64 values, so it's
|
|
|
|
// worth handling here.
|
2008-03-13 22:13:53 +00:00
|
|
|
if (N2C && N2C->isNullValue())
|
2008-01-22 19:09:33 +00:00
|
|
|
return N2;
|
2008-01-26 01:05:42 +00:00
|
|
|
if (N2C && N2C->isAllOnesValue()) // X & -1 -> X
|
|
|
|
return N1;
|
2008-01-22 19:09:33 +00:00
|
|
|
break;
|
2005-01-16 02:23:22 +00:00
|
|
|
case ISD::OR:
|
|
|
|
case ISD::XOR:
|
2008-06-02 22:27:05 +00:00
|
|
|
case ISD::ADD:
|
|
|
|
case ISD::SUB:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && N1.getValueType() == N2.getValueType() &&
|
2008-01-22 19:09:33 +00:00
|
|
|
N1.getValueType() == VT && "Binary operator types must match!");
|
2008-06-02 22:27:05 +00:00
|
|
|
// (X ^|+- 0) -> X. This commonly occurs when legalizing i64 values, so
|
|
|
|
// it's worth handling here.
|
2008-03-13 22:13:53 +00:00
|
|
|
if (N2C && N2C->isNullValue())
|
2008-01-22 19:09:33 +00:00
|
|
|
return N1;
|
|
|
|
break;
|
2005-01-16 02:23:22 +00:00
|
|
|
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:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && "This operator does not apply to FP types!");
|
2005-01-16 02:23:22 +00:00
|
|
|
// fall through
|
|
|
|
case ISD::MUL:
|
|
|
|
case ISD::SDIV:
|
|
|
|
case ISD::SREM:
|
2005-09-28 22:28:18 +00:00
|
|
|
case ISD::FADD:
|
|
|
|
case ISD::FSUB:
|
|
|
|
case ISD::FMUL:
|
|
|
|
case ISD::FDIV:
|
|
|
|
case ISD::FREM:
|
2005-01-16 02:23:22 +00:00
|
|
|
assert(N1.getValueType() == N2.getValueType() &&
|
|
|
|
N1.getValueType() == VT && "Binary operator types must match!");
|
|
|
|
break;
|
2006-03-05 05:09:38 +00:00
|
|
|
case ISD::FCOPYSIGN: // N1 and result must match. N1/N2 need not match.
|
|
|
|
assert(N1.getValueType() == VT &&
|
2008-06-06 12:08:01 +00:00
|
|
|
N1.getValueType().isFloatingPoint() &&
|
|
|
|
N2.getValueType().isFloatingPoint() &&
|
2006-03-05 05:09:38 +00:00
|
|
|
"Invalid FCOPYSIGN!");
|
|
|
|
break;
|
2005-01-16 02:23:22 +00:00
|
|
|
case ISD::SHL:
|
|
|
|
case ISD::SRA:
|
|
|
|
case ISD::SRL:
|
2006-01-11 21:21:00 +00:00
|
|
|
case ISD::ROTL:
|
|
|
|
case ISD::ROTR:
|
2005-01-16 02:23:22 +00:00
|
|
|
assert(VT == N1.getValueType() &&
|
|
|
|
"Shift operators return type must be the same as their first arg");
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && N2.getValueType().isInteger() &&
|
2008-07-02 17:01:57 +00:00
|
|
|
"Shifts only work on integers");
|
|
|
|
|
|
|
|
// Always fold shifts of i1 values so the code generator doesn't need to
|
|
|
|
// handle them. Since we know the size of the shift has to be less than the
|
|
|
|
// size of the value, the shift/rotate count is guaranteed to be zero.
|
|
|
|
if (VT == MVT::i1)
|
|
|
|
return N1;
|
2005-01-16 02:23:22 +00:00
|
|
|
break;
|
2005-07-10 00:07:11 +00:00
|
|
|
case ISD::FP_ROUND_INREG: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT EVT = cast<VTSDNode>(N2)->getVT();
|
2005-07-10 00:07:11 +00:00
|
|
|
assert(VT == N1.getValueType() && "Not an inreg round!");
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isFloatingPoint() && EVT.isFloatingPoint() &&
|
2005-07-10 00:07:11 +00:00
|
|
|
"Cannot FP_ROUND_INREG integer types");
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(EVT.bitsLE(VT) && "Not rounding down!");
|
2008-01-22 19:09:33 +00:00
|
|
|
if (cast<VTSDNode>(N2)->getVT() == VT) return N1; // Not actually rounding.
|
2005-07-10 00:07:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-01-17 07:00:52 +00:00
|
|
|
case ISD::FP_ROUND:
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isFloatingPoint() &&
|
|
|
|
N1.getValueType().isFloatingPoint() &&
|
2008-06-08 20:54:56 +00:00
|
|
|
VT.bitsLE(N1.getValueType()) &&
|
2008-01-17 07:00:52 +00:00
|
|
|
isa<ConstantSDNode>(N2) && "Invalid FP_ROUND!");
|
2008-01-22 19:09:33 +00:00
|
|
|
if (N1.getValueType() == VT) return N1; // noop conversion.
|
2008-01-17 07:00:52 +00:00
|
|
|
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:
|
2008-01-22 19:09:33 +00:00
|
|
|
case ISD::AssertZext: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT EVT = cast<VTSDNode>(N2)->getVT();
|
2005-07-10 00:07:11 +00:00
|
|
|
assert(VT == N1.getValueType() && "Not an inreg extend!");
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && EVT.isInteger() &&
|
2005-07-10 00:07:11 +00:00
|
|
|
"Cannot *_EXTEND_INREG FP types");
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(EVT.bitsLE(VT) && "Not extending!");
|
2008-02-10 10:08:52 +00:00
|
|
|
if (VT == EVT) return N1; // noop assertion.
|
2008-01-22 19:09:33 +00:00
|
|
|
break;
|
2005-07-10 00:07:11 +00:00
|
|
|
}
|
2008-01-22 19:09:33 +00:00
|
|
|
case ISD::SIGN_EXTEND_INREG: {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT EVT = cast<VTSDNode>(N2)->getVT();
|
2008-01-22 19:09:33 +00:00
|
|
|
assert(VT == N1.getValueType() && "Not an inreg extend!");
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() && EVT.isInteger() &&
|
2008-01-22 19:09:33 +00:00
|
|
|
"Cannot *_EXTEND_INREG FP types");
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(EVT.bitsLE(VT) && "Not extending!");
|
2008-01-22 19:09:33 +00:00
|
|
|
if (EVT == VT) return N1; // Not actually extending
|
2005-07-10 00:07:11 +00:00
|
|
|
|
2008-01-22 19:09:33 +00:00
|
|
|
if (N1C) {
|
2008-02-29 01:47:35 +00:00
|
|
|
APInt Val = N1C->getAPIntValue();
|
2008-06-06 12:08:01 +00:00
|
|
|
unsigned FromBits = cast<VTSDNode>(N2)->getVT().getSizeInBits();
|
2008-02-29 01:47:35 +00:00
|
|
|
Val <<= Val.getBitWidth()-FromBits;
|
2008-03-06 08:20:51 +00:00
|
|
|
Val = Val.ashr(Val.getBitWidth()-FromBits);
|
2006-05-06 23:05:41 +00:00
|
|
|
return getConstant(Val, VT);
|
|
|
|
}
|
2008-01-22 19:09:33 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::EXTRACT_VECTOR_ELT:
|
|
|
|
assert(N2C && "Bad EXTRACT_VECTOR_ELT!");
|
|
|
|
|
2008-03-08 23:43:36 +00:00
|
|
|
// EXTRACT_VECTOR_ELT of an UNDEF is an UNDEF.
|
|
|
|
if (N1.getOpcode() == ISD::UNDEF)
|
|
|
|
return getNode(ISD::UNDEF, VT);
|
|
|
|
|
2008-01-22 19:09:33 +00:00
|
|
|
// EXTRACT_VECTOR_ELT of CONCAT_VECTORS is often formed while lowering is
|
|
|
|
// expanding copies of large vectors from registers.
|
|
|
|
if (N1.getOpcode() == ISD::CONCAT_VECTORS &&
|
|
|
|
N1.getNumOperands() > 0) {
|
|
|
|
unsigned Factor =
|
2008-06-06 12:08:01 +00:00
|
|
|
N1.getOperand(0).getValueType().getVectorNumElements();
|
2008-01-22 19:09:33 +00:00
|
|
|
return getNode(ISD::EXTRACT_VECTOR_ELT, VT,
|
|
|
|
N1.getOperand(N2C->getValue() / Factor),
|
|
|
|
getConstant(N2C->getValue() % Factor, N2.getValueType()));
|
|
|
|
}
|
|
|
|
|
|
|
|
// EXTRACT_VECTOR_ELT of BUILD_VECTOR is often formed while lowering is
|
|
|
|
// expanding large vector constants.
|
|
|
|
if (N1.getOpcode() == ISD::BUILD_VECTOR)
|
|
|
|
return N1.getOperand(N2C->getValue());
|
2008-03-08 23:43:36 +00:00
|
|
|
|
2008-01-22 19:09:33 +00:00
|
|
|
// EXTRACT_VECTOR_ELT of INSERT_VECTOR_ELT is often formed when vector
|
|
|
|
// operations are lowered to scalars.
|
|
|
|
if (N1.getOpcode() == ISD::INSERT_VECTOR_ELT)
|
|
|
|
if (ConstantSDNode *IEC = dyn_cast<ConstantSDNode>(N1.getOperand(2))) {
|
|
|
|
if (IEC == N2C)
|
|
|
|
return N1.getOperand(1);
|
|
|
|
else
|
|
|
|
return getNode(ISD::EXTRACT_VECTOR_ELT, VT, N1.getOperand(0), N2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ISD::EXTRACT_ELEMENT:
|
|
|
|
assert(N2C && (unsigned)N2C->getValue() < 2 && "Bad EXTRACT_ELEMENT!");
|
2008-06-25 20:24:48 +00:00
|
|
|
assert(!N1.getValueType().isVector() && !VT.isVector() &&
|
|
|
|
(N1.getValueType().isInteger() == VT.isInteger()) &&
|
|
|
|
"Wrong types for EXTRACT_ELEMENT!");
|
2008-03-12 20:30:08 +00:00
|
|
|
|
2008-01-22 19:09:33 +00:00
|
|
|
// EXTRACT_ELEMENT of BUILD_PAIR is often formed while legalize is expanding
|
|
|
|
// 64-bit integers into 32-bit parts. Instead of building the extract of
|
|
|
|
// the BUILD_PAIR, only to have legalize rip it apart, just do it now.
|
|
|
|
if (N1.getOpcode() == ISD::BUILD_PAIR)
|
|
|
|
return N1.getOperand(N2C->getValue());
|
2008-03-12 20:30:08 +00:00
|
|
|
|
2008-01-22 19:09:33 +00:00
|
|
|
// EXTRACT_ELEMENT of a constant int is also very common.
|
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N1)) {
|
2008-06-06 12:08:01 +00:00
|
|
|
unsigned ElementSize = VT.getSizeInBits();
|
2008-03-24 16:38:05 +00:00
|
|
|
unsigned Shift = ElementSize * N2C->getValue();
|
|
|
|
APInt ShiftedVal = C->getAPIntValue().lshr(Shift);
|
|
|
|
return getConstant(ShiftedVal.trunc(ElementSize), VT);
|
2008-01-22 19:09:33 +00:00
|
|
|
}
|
|
|
|
break;
|
2008-02-20 17:38:09 +00:00
|
|
|
case ISD::EXTRACT_SUBVECTOR:
|
|
|
|
if (N1.getValueType() == VT) // Trivial extraction.
|
|
|
|
return N1;
|
|
|
|
break;
|
2008-01-22 19:09:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (N1C) {
|
2005-01-07 07:46:32 +00:00
|
|
|
if (N2C) {
|
2008-07-03 00:52:03 +00:00
|
|
|
const APInt &C1 = N1C->getAPIntValue(), &C2 = N2C->getAPIntValue();
|
2005-01-07 07:46:32 +00:00
|
|
|
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:
|
2008-02-29 01:47:35 +00:00
|
|
|
if (C2.getBoolValue()) return getConstant(C1.udiv(C2), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
|
|
|
case ISD::UREM :
|
2008-02-29 01:47:35 +00:00
|
|
|
if (C2.getBoolValue()) return getConstant(C1.urem(C2), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
|
|
|
case ISD::SDIV :
|
2008-02-29 01:47:35 +00:00
|
|
|
if (C2.getBoolValue()) return getConstant(C1.sdiv(C2), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
|
|
|
case ISD::SREM :
|
2008-02-29 01:47:35 +00:00
|
|
|
if (C2.getBoolValue()) return getConstant(C1.srem(C2), VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
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);
|
2008-02-29 01:47:35 +00:00
|
|
|
case ISD::SRL : return getConstant(C1.lshr(C2), VT);
|
|
|
|
case ISD::SRA : return getConstant(C1.ashr(C2), VT);
|
|
|
|
case ISD::ROTL : return getConstant(C1.rotl(C2), VT);
|
|
|
|
case ISD::ROTR : return getConstant(C1.rotr(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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-22 19:09:33 +00:00
|
|
|
// Constant fold FP operations.
|
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) {
|
2008-01-22 19:09:33 +00:00
|
|
|
if (!N2CFP && isCommutativeBinOp(Opcode)) {
|
|
|
|
// Cannonicalize constant to RHS if commutative
|
|
|
|
std::swap(N1CFP, N2CFP);
|
|
|
|
std::swap(N1, N2);
|
|
|
|
} else if (N2CFP && VT != MVT::ppcf128) {
|
2007-08-31 23:34:27 +00:00
|
|
|
APFloat V1 = N1CFP->getValueAPF(), V2 = N2CFP->getValueAPF();
|
|
|
|
APFloat::opStatus s;
|
2005-01-07 07:46:32 +00:00
|
|
|
switch (Opcode) {
|
2007-08-31 23:34:27 +00:00
|
|
|
case ISD::FADD:
|
|
|
|
s = V1.add(V2, APFloat::rmNearestTiesToEven);
|
2008-01-22 19:09:33 +00:00
|
|
|
if (s != APFloat::opInvalidOp)
|
2007-08-31 23:34:27 +00:00
|
|
|
return getConstantFP(V1, VT);
|
|
|
|
break;
|
|
|
|
case ISD::FSUB:
|
|
|
|
s = V1.subtract(V2, APFloat::rmNearestTiesToEven);
|
|
|
|
if (s!=APFloat::opInvalidOp)
|
|
|
|
return getConstantFP(V1, VT);
|
|
|
|
break;
|
|
|
|
case ISD::FMUL:
|
|
|
|
s = V1.multiply(V2, APFloat::rmNearestTiesToEven);
|
|
|
|
if (s!=APFloat::opInvalidOp)
|
|
|
|
return getConstantFP(V1, VT);
|
|
|
|
break;
|
2005-09-28 22:28:18 +00:00
|
|
|
case ISD::FDIV:
|
2007-08-31 23:34:27 +00:00
|
|
|
s = V1.divide(V2, APFloat::rmNearestTiesToEven);
|
|
|
|
if (s!=APFloat::opInvalidOp && s!=APFloat::opDivByZero)
|
|
|
|
return getConstantFP(V1, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
2005-09-28 22:28:18 +00:00
|
|
|
case ISD::FREM :
|
2007-08-31 23:34:27 +00:00
|
|
|
s = V1.mod(V2, APFloat::rmNearestTiesToEven);
|
|
|
|
if (s!=APFloat::opInvalidOp && s!=APFloat::opDivByZero)
|
|
|
|
return getConstantFP(V1, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
break;
|
2007-08-31 23:34:27 +00:00
|
|
|
case ISD::FCOPYSIGN:
|
|
|
|
V1.copySign(V2);
|
|
|
|
return getConstantFP(V1, VT);
|
2005-01-07 07:46:32 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
}
|
2005-07-10 00:07:11 +00:00
|
|
|
}
|
2006-04-20 05:39:12 +00:00
|
|
|
|
|
|
|
// Canonicalize an UNDEF to the RHS, even over a constant.
|
|
|
|
if (N1.getOpcode() == ISD::UNDEF) {
|
|
|
|
if (isCommutativeBinOp(Opcode)) {
|
|
|
|
std::swap(N1, N2);
|
|
|
|
} else {
|
|
|
|
switch (Opcode) {
|
|
|
|
case ISD::FP_ROUND_INREG:
|
|
|
|
case ISD::SIGN_EXTEND_INREG:
|
|
|
|
case ISD::SUB:
|
|
|
|
case ISD::FSUB:
|
|
|
|
case ISD::FDIV:
|
|
|
|
case ISD::FREM:
|
2006-05-08 17:29:49 +00:00
|
|
|
case ISD::SRA:
|
2006-04-20 05:39:12 +00:00
|
|
|
return N1; // fold op(undef, arg2) -> undef
|
|
|
|
case ISD::UDIV:
|
|
|
|
case ISD::SDIV:
|
|
|
|
case ISD::UREM:
|
|
|
|
case ISD::SREM:
|
2006-05-08 17:29:49 +00:00
|
|
|
case ISD::SRL:
|
|
|
|
case ISD::SHL:
|
2008-06-06 12:08:01 +00:00
|
|
|
if (!VT.isVector())
|
2007-04-25 00:00:45 +00:00
|
|
|
return getConstant(0, VT); // fold op(undef, arg2) -> 0
|
|
|
|
// For vectors, we can't easily build an all zero vector, just return
|
|
|
|
// the LHS.
|
|
|
|
return N2;
|
2006-04-20 05:39:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-06 23:05:41 +00:00
|
|
|
// Fold a bunch of operators when the RHS is undef.
|
2006-04-20 05:39:12 +00:00
|
|
|
if (N2.getOpcode() == ISD::UNDEF) {
|
|
|
|
switch (Opcode) {
|
2008-03-25 20:08:07 +00:00
|
|
|
case ISD::XOR:
|
|
|
|
if (N1.getOpcode() == ISD::UNDEF)
|
|
|
|
// Handle undef ^ undef -> 0 special case. This is a common
|
|
|
|
// idiom (misuse).
|
|
|
|
return getConstant(0, VT);
|
|
|
|
// fallthrough
|
2006-04-20 05:39:12 +00:00
|
|
|
case ISD::ADD:
|
2007-03-04 20:01:46 +00:00
|
|
|
case ISD::ADDC:
|
|
|
|
case ISD::ADDE:
|
2006-04-20 05:39:12 +00:00
|
|
|
case ISD::SUB:
|
|
|
|
case ISD::FADD:
|
|
|
|
case ISD::FSUB:
|
|
|
|
case ISD::FMUL:
|
|
|
|
case ISD::FDIV:
|
|
|
|
case ISD::FREM:
|
|
|
|
case ISD::UDIV:
|
|
|
|
case ISD::SDIV:
|
|
|
|
case ISD::UREM:
|
|
|
|
case ISD::SREM:
|
|
|
|
return N2; // fold op(arg1, undef) -> undef
|
|
|
|
case ISD::MUL:
|
|
|
|
case ISD::AND:
|
2006-05-08 17:29:49 +00:00
|
|
|
case ISD::SRL:
|
|
|
|
case ISD::SHL:
|
2008-06-06 12:08:01 +00:00
|
|
|
if (!VT.isVector())
|
2007-04-25 00:00:45 +00:00
|
|
|
return getConstant(0, VT); // fold op(arg1, undef) -> 0
|
|
|
|
// For vectors, we can't easily build an all zero vector, just return
|
|
|
|
// the LHS.
|
|
|
|
return N1;
|
2006-04-20 05:39:12 +00:00
|
|
|
case ISD::OR:
|
2008-06-06 12:08:01 +00:00
|
|
|
if (!VT.isVector())
|
|
|
|
return getConstant(VT.getIntegerVTBitMask(), VT);
|
2007-04-25 00:00:45 +00:00
|
|
|
// For vectors, we can't easily build an all one vector, just return
|
|
|
|
// the LHS.
|
|
|
|
return N1;
|
2006-05-08 17:29:49 +00:00
|
|
|
case ISD::SRA:
|
|
|
|
return N1;
|
2006-04-20 05:39:12 +00:00
|
|
|
}
|
|
|
|
}
|
2005-07-10 00:07:11 +00:00
|
|
|
|
2005-05-11 18:57:39 +00:00
|
|
|
// Memoize this node if possible.
|
|
|
|
SDNode *N;
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2006-01-29 07:58:15 +00:00
|
|
|
if (VT != MVT::Flag) {
|
2007-02-04 08:35:21 +00:00
|
|
|
SDOperand Ops[] = { N1, N2 };
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2007-02-04 07:28:00 +00:00
|
|
|
AddNodeIDNode(ID, Opcode, VTs, Ops, 2);
|
2006-08-07 23:03:03 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<BinarySDNode>();
|
|
|
|
new (N) BinarySDNode(Opcode, VTs, N1, N2);
|
2006-08-07 23:03:03 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-05-11 18:57:39 +00:00
|
|
|
} else {
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<BinarySDNode>();
|
|
|
|
new (N) BinarySDNode(Opcode, VTs, N1, N2);
|
2005-05-11 18:57:39 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
2008-07-21 10:20:31 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
VerifyNode(N);
|
|
|
|
#endif
|
2005-01-07 07:46:32 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT VT,
|
2005-01-07 07:46:32 +00:00
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3) {
|
|
|
|
// Perform various simplifications.
|
|
|
|
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.Val);
|
|
|
|
ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.Val);
|
|
|
|
switch (Opcode) {
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::SETCC: {
|
2006-10-14 00:41:01 +00:00
|
|
|
// Use FoldSetCC to simplify SETCC's.
|
|
|
|
SDOperand Simp = FoldSetCC(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:
|
2008-02-20 11:10:28 +00:00
|
|
|
if (N1C) {
|
|
|
|
if (N1C->getValue())
|
2005-01-07 07:46:32 +00:00
|
|
|
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
|
2008-02-20 11:10:28 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
|
|
|
|
if (N2 == N3) return N2; // select C, X, X -> X
|
|
|
|
break;
|
2005-01-07 22:49:57 +00:00
|
|
|
case ISD::BRCOND:
|
2008-02-20 11:10:28 +00:00
|
|
|
if (N2C) {
|
2005-01-07 22:49:57 +00:00
|
|
|
if (N2C->getValue()) // Unconditional branch
|
|
|
|
return getNode(ISD::BR, MVT::Other, N1, N3);
|
|
|
|
else
|
|
|
|
return N1; // Never-taken branch
|
2008-02-20 11:10:28 +00:00
|
|
|
}
|
2005-01-07 23:32:00 +00:00
|
|
|
break;
|
2006-03-19 23:56:04 +00:00
|
|
|
case ISD::VECTOR_SHUFFLE:
|
|
|
|
assert(VT == N1.getValueType() && VT == N2.getValueType() &&
|
2008-06-06 12:08:01 +00:00
|
|
|
VT.isVector() && N3.getValueType().isVector() &&
|
2006-03-19 23:56:04 +00:00
|
|
|
N3.getOpcode() == ISD::BUILD_VECTOR &&
|
2008-06-06 12:08:01 +00:00
|
|
|
VT.getVectorNumElements() == N3.getNumOperands() &&
|
2006-03-19 23:56:04 +00:00
|
|
|
"Illegal VECTOR_SHUFFLE node!");
|
|
|
|
break;
|
2007-06-25 16:23:39 +00:00
|
|
|
case ISD::BIT_CONVERT:
|
|
|
|
// Fold bit_convert nodes from a type to themselves.
|
|
|
|
if (N1.getValueType() == VT)
|
|
|
|
return N1;
|
2007-04-12 05:58:43 +00:00
|
|
|
break;
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2005-08-25 19:12:10 +00:00
|
|
|
// Memoize node if it doesn't produce a flag.
|
|
|
|
SDNode *N;
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2005-08-25 19:12:10 +00:00
|
|
|
if (VT != MVT::Flag) {
|
2007-02-04 08:35:21 +00:00
|
|
|
SDOperand Ops[] = { N1, N2, N3 };
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2007-02-04 07:28:00 +00:00
|
|
|
AddNodeIDNode(ID, Opcode, VTs, Ops, 3);
|
2006-08-07 23:03:03 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<TernarySDNode>();
|
|
|
|
new (N) TernarySDNode(Opcode, VTs, N1, N2, N3);
|
2006-08-07 23:03:03 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-08-25 19:12:10 +00:00
|
|
|
} else {
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<TernarySDNode>();
|
|
|
|
new (N) TernarySDNode(Opcode, VTs, N1, N2, N3);
|
2005-08-25 19:12:10 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
AllNodes.push_back(N);
|
2008-07-21 10:20:31 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
VerifyNode(N);
|
|
|
|
#endif
|
2005-01-07 07:46:32 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT 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) {
|
2006-08-08 01:09:31 +00:00
|
|
|
SDOperand Ops[] = { N1, N2, N3, N4 };
|
|
|
|
return getNode(Opcode, VT, Ops, 4);
|
2005-04-27 20:10:01 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT VT,
|
2005-07-10 00:29:18 +00:00
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3,
|
|
|
|
SDOperand N4, SDOperand N5) {
|
2006-08-08 01:09:31 +00:00
|
|
|
SDOperand Ops[] = { N1, N2, N3, N4, N5 };
|
|
|
|
return getNode(Opcode, VT, Ops, 5);
|
2005-07-10 00:29:18 +00:00
|
|
|
}
|
|
|
|
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
/// getMemsetValue - Vectorized representation of the memset value
|
|
|
|
/// operand.
|
2008-06-06 12:08:01 +00:00
|
|
|
static SDOperand getMemsetValue(SDOperand Value, MVT VT, SelectionDAG &DAG) {
|
|
|
|
unsigned NumBits = VT.isVector() ?
|
|
|
|
VT.getVectorElementType().getSizeInBits() : VT.getSizeInBits();
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) {
|
2008-05-15 08:39:06 +00:00
|
|
|
APInt Val = APInt(NumBits, C->getValue() & 255);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
unsigned Shift = 8;
|
2008-05-15 08:39:06 +00:00
|
|
|
for (unsigned i = NumBits; i > 8; i >>= 1) {
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
Val = (Val << Shift) | Val;
|
|
|
|
Shift <<= 1;
|
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
if (VT.isInteger())
|
2008-05-15 08:39:06 +00:00
|
|
|
return DAG.getConstant(Val, VT);
|
|
|
|
return DAG.getConstantFP(APFloat(Val), VT);
|
|
|
|
}
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
2008-05-15 08:39:06 +00:00
|
|
|
Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value);
|
|
|
|
unsigned Shift = 8;
|
|
|
|
for (unsigned i = NumBits; i > 8; i >>= 1) {
|
|
|
|
Value = DAG.getNode(ISD::OR, VT,
|
|
|
|
DAG.getNode(ISD::SHL, VT, Value,
|
|
|
|
DAG.getConstant(Shift, MVT::i8)), Value);
|
|
|
|
Shift <<= 1;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
}
|
2008-05-15 08:39:06 +00:00
|
|
|
|
|
|
|
return Value;
|
2007-10-19 10:41:11 +00:00
|
|
|
}
|
|
|
|
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
/// getMemsetStringVal - Similar to getMemsetValue. Except this is only
|
|
|
|
/// used when a memcpy is turned into a memset when the source is a constant
|
|
|
|
/// string ptr.
|
2008-06-06 12:08:01 +00:00
|
|
|
static SDOperand getMemsetStringVal(MVT VT, SelectionDAG &DAG,
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
const TargetLowering &TLI,
|
|
|
|
std::string &Str, unsigned Offset) {
|
2008-06-30 07:31:25 +00:00
|
|
|
// Handle vector with all elements zero.
|
|
|
|
if (Str.empty()) {
|
|
|
|
if (VT.isInteger())
|
|
|
|
return DAG.getConstant(0, VT);
|
|
|
|
unsigned NumElts = VT.getVectorNumElements();
|
|
|
|
MVT EltVT = (VT.getVectorElementType() == MVT::f32) ? MVT::i32 : MVT::i64;
|
|
|
|
return DAG.getNode(ISD::BIT_CONVERT, VT,
|
|
|
|
DAG.getConstant(0, MVT::getVectorVT(EltVT, NumElts)));
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(!VT.isVector() && "Can't handle vector type here!");
|
|
|
|
unsigned NumBits = VT.getSizeInBits();
|
2008-05-15 08:39:06 +00:00
|
|
|
unsigned MSB = NumBits / 8;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
uint64_t Val = 0;
|
|
|
|
if (TLI.isLittleEndian())
|
|
|
|
Offset = Offset + MSB - 1;
|
|
|
|
for (unsigned i = 0; i != MSB; ++i) {
|
|
|
|
Val = (Val << 8) | (unsigned char)Str[Offset];
|
|
|
|
Offset += TLI.isLittleEndian() ? -1 : 1;
|
|
|
|
}
|
|
|
|
return DAG.getConstant(Val, VT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getMemBasePlusOffset - Returns base and offset node for the
|
2008-05-15 08:39:06 +00:00
|
|
|
///
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
static SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset,
|
|
|
|
SelectionDAG &DAG) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = Base.getValueType();
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT));
|
2007-10-19 10:41:11 +00:00
|
|
|
}
|
|
|
|
|
2008-05-15 08:39:06 +00:00
|
|
|
/// isMemSrcFromString - Returns true if memcpy source is a string constant.
|
|
|
|
///
|
2008-06-30 07:31:25 +00:00
|
|
|
static bool isMemSrcFromString(SDOperand Src, std::string &Str) {
|
2008-05-15 08:39:06 +00:00
|
|
|
unsigned SrcDelta = 0;
|
|
|
|
GlobalAddressSDNode *G = NULL;
|
|
|
|
if (Src.getOpcode() == ISD::GlobalAddress)
|
|
|
|
G = cast<GlobalAddressSDNode>(Src);
|
|
|
|
else if (Src.getOpcode() == ISD::ADD &&
|
|
|
|
Src.getOperand(0).getOpcode() == ISD::GlobalAddress &&
|
|
|
|
Src.getOperand(1).getOpcode() == ISD::Constant) {
|
|
|
|
G = cast<GlobalAddressSDNode>(Src.getOperand(0));
|
|
|
|
SrcDelta = cast<ConstantSDNode>(Src.getOperand(1))->getValue();
|
|
|
|
}
|
|
|
|
if (!G)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal());
|
2008-06-30 07:31:25 +00:00
|
|
|
if (GV && GetConstantStringInfo(GV, Str, SrcDelta, false))
|
|
|
|
return true;
|
2008-05-15 08:39:06 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
/// MeetsMaxMemopRequirement - Determines if the number of memory ops required
|
|
|
|
/// to replace the memset / memcpy is below the threshold. It also returns the
|
|
|
|
/// types of the sequence of memory ops to perform memset / memcpy.
|
2008-05-15 08:39:06 +00:00
|
|
|
static
|
2008-06-06 12:08:01 +00:00
|
|
|
bool MeetsMaxMemopRequirement(std::vector<MVT> &MemOps,
|
2008-05-15 08:39:06 +00:00
|
|
|
SDOperand Dst, SDOperand Src,
|
|
|
|
unsigned Limit, uint64_t Size, unsigned &Align,
|
2008-06-30 07:31:25 +00:00
|
|
|
std::string &Str, bool &isSrcStr,
|
2008-05-15 08:39:06 +00:00
|
|
|
SelectionDAG &DAG,
|
|
|
|
const TargetLowering &TLI) {
|
2008-06-30 07:31:25 +00:00
|
|
|
isSrcStr = isMemSrcFromString(Src, Str);
|
2008-05-15 08:39:06 +00:00
|
|
|
bool isSrcConst = isa<ConstantSDNode>(Src);
|
2008-06-30 07:31:25 +00:00
|
|
|
bool AllowUnalign = TLI.allowsUnalignedMemoryAccesses();
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT= TLI.getOptimalMemOpType(Size, Align, isSrcConst, isSrcStr);
|
2008-05-15 08:39:06 +00:00
|
|
|
if (VT != MVT::iAny) {
|
|
|
|
unsigned NewAlign = (unsigned)
|
2008-06-06 12:08:01 +00:00
|
|
|
TLI.getTargetData()->getABITypeAlignment(VT.getTypeForMVT());
|
2008-05-15 08:39:06 +00:00
|
|
|
// If source is a string constant, this will require an unaligned load.
|
|
|
|
if (NewAlign > Align && (isSrcConst || AllowUnalign)) {
|
|
|
|
if (Dst.getOpcode() != ISD::FrameIndex) {
|
|
|
|
// Can't change destination alignment. It requires a unaligned store.
|
|
|
|
if (AllowUnalign)
|
|
|
|
VT = MVT::iAny;
|
|
|
|
} else {
|
|
|
|
int FI = cast<FrameIndexSDNode>(Dst)->getIndex();
|
|
|
|
MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
|
|
|
|
if (MFI->isFixedObjectIndex(FI)) {
|
|
|
|
// Can't change destination alignment. It requires a unaligned store.
|
|
|
|
if (AllowUnalign)
|
|
|
|
VT = MVT::iAny;
|
|
|
|
} else {
|
2008-06-04 23:37:54 +00:00
|
|
|
// Give the stack frame object a larger alignment if needed.
|
|
|
|
if (MFI->getObjectAlignment(FI) < NewAlign)
|
|
|
|
MFI->setObjectAlignment(FI, NewAlign);
|
2008-05-15 08:39:06 +00:00
|
|
|
Align = NewAlign;
|
|
|
|
}
|
|
|
|
}
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-15 08:39:06 +00:00
|
|
|
if (VT == MVT::iAny) {
|
|
|
|
if (AllowUnalign) {
|
|
|
|
VT = MVT::i64;
|
|
|
|
} else {
|
|
|
|
switch (Align & 7) {
|
|
|
|
case 0: VT = MVT::i64; break;
|
|
|
|
case 4: VT = MVT::i32; break;
|
|
|
|
case 2: VT = MVT::i16; break;
|
|
|
|
default: VT = MVT::i8; break;
|
|
|
|
}
|
|
|
|
}
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT LVT = MVT::i64;
|
2008-05-15 08:39:06 +00:00
|
|
|
while (!TLI.isTypeLegal(LVT))
|
2008-06-06 12:08:01 +00:00
|
|
|
LVT = (MVT::SimpleValueType)(LVT.getSimpleVT() - 1);
|
|
|
|
assert(LVT.isInteger());
|
2008-05-15 08:39:06 +00:00
|
|
|
|
2008-06-08 20:54:56 +00:00
|
|
|
if (VT.bitsGT(LVT))
|
2008-05-15 08:39:06 +00:00
|
|
|
VT = LVT;
|
|
|
|
}
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
|
|
|
unsigned NumMemOps = 0;
|
|
|
|
while (Size != 0) {
|
2008-06-06 12:08:01 +00:00
|
|
|
unsigned VTSize = VT.getSizeInBits() / 8;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
while (VTSize > Size) {
|
2008-05-15 08:39:06 +00:00
|
|
|
// For now, only use non-vector load / store's for the left-over pieces.
|
2008-06-06 12:08:01 +00:00
|
|
|
if (VT.isVector()) {
|
2008-05-15 08:39:06 +00:00
|
|
|
VT = MVT::i64;
|
|
|
|
while (!TLI.isTypeLegal(VT))
|
2008-06-06 12:08:01 +00:00
|
|
|
VT = (MVT::SimpleValueType)(VT.getSimpleVT() - 1);
|
|
|
|
VTSize = VT.getSizeInBits() / 8;
|
2008-05-15 08:39:06 +00:00
|
|
|
} else {
|
2008-06-06 12:08:01 +00:00
|
|
|
VT = (MVT::SimpleValueType)(VT.getSimpleVT() - 1);
|
2008-05-15 08:39:06 +00:00
|
|
|
VTSize >>= 1;
|
|
|
|
}
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (++NumMemOps > Limit)
|
|
|
|
return false;
|
|
|
|
MemOps.push_back(VT);
|
|
|
|
Size -= VTSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDOperand getMemcpyLoadsAndStores(SelectionDAG &DAG,
|
|
|
|
SDOperand Chain, SDOperand Dst,
|
|
|
|
SDOperand Src, uint64_t Size,
|
2008-05-15 08:39:06 +00:00
|
|
|
unsigned Align, bool AlwaysInline,
|
2008-04-28 17:15:20 +00:00
|
|
|
const Value *DstSV, uint64_t DstSVOff,
|
|
|
|
const Value *SrcSV, uint64_t SrcSVOff){
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
|
|
|
|
|
2008-05-29 19:42:22 +00:00
|
|
|
// Expand memcpy to a series of load and store ops if the size operand falls
|
|
|
|
// below a certain threshold.
|
2008-06-06 12:08:01 +00:00
|
|
|
std::vector<MVT> MemOps;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
uint64_t Limit = -1;
|
|
|
|
if (!AlwaysInline)
|
|
|
|
Limit = TLI.getMaxStoresPerMemcpy();
|
2008-05-15 08:39:06 +00:00
|
|
|
unsigned DstAlign = Align; // Destination alignment can change.
|
2008-06-30 07:31:25 +00:00
|
|
|
std::string Str;
|
|
|
|
bool CopyFromStr;
|
2008-05-15 08:39:06 +00:00
|
|
|
if (!MeetsMaxMemopRequirement(MemOps, Dst, Src, Limit, Size, DstAlign,
|
2008-06-30 07:31:25 +00:00
|
|
|
Str, CopyFromStr, DAG, TLI))
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
return SDOperand();
|
|
|
|
|
|
|
|
|
2008-06-30 07:31:25 +00:00
|
|
|
bool isZeroStr = CopyFromStr && Str.empty();
|
2008-05-15 08:39:06 +00:00
|
|
|
SmallVector<SDOperand, 8> OutChains;
|
|
|
|
unsigned NumMemOps = MemOps.size();
|
2008-06-30 07:31:25 +00:00
|
|
|
uint64_t SrcOff = 0, DstOff = 0;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
for (unsigned i = 0; i < NumMemOps; i++) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = MemOps[i];
|
|
|
|
unsigned VTSize = VT.getSizeInBits() / 8;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
SDOperand Value, Store;
|
|
|
|
|
2008-06-30 07:31:25 +00:00
|
|
|
if (CopyFromStr && (isZeroStr || !VT.isVector())) {
|
2008-05-15 08:39:06 +00:00
|
|
|
// It's unlikely a store of a vector immediate can be done in a single
|
|
|
|
// instruction. It would require a load from a constantpool first.
|
2008-06-30 07:31:25 +00:00
|
|
|
// We also handle store a vector with all zero's.
|
|
|
|
// FIXME: Handle other cases where store of vector immediate is done in
|
|
|
|
// a single instruction.
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff);
|
2008-05-15 08:39:06 +00:00
|
|
|
Store = DAG.getStore(Chain, Value,
|
|
|
|
getMemBasePlusOffset(Dst, DstOff, DAG),
|
2008-07-09 06:38:06 +00:00
|
|
|
DstSV, DstSVOff + DstOff, false, DstAlign);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
} else {
|
|
|
|
Value = DAG.getLoad(VT, Chain,
|
|
|
|
getMemBasePlusOffset(Src, SrcOff, DAG),
|
2008-04-28 17:15:20 +00:00
|
|
|
SrcSV, SrcSVOff + SrcOff, false, Align);
|
2008-05-15 08:39:06 +00:00
|
|
|
Store = DAG.getStore(Chain, Value,
|
|
|
|
getMemBasePlusOffset(Dst, DstOff, DAG),
|
|
|
|
DstSV, DstSVOff + DstOff, false, DstAlign);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
}
|
|
|
|
OutChains.push_back(Store);
|
|
|
|
SrcOff += VTSize;
|
|
|
|
DstOff += VTSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
return DAG.getNode(ISD::TokenFactor, MVT::Other,
|
|
|
|
&OutChains[0], OutChains.size());
|
|
|
|
}
|
|
|
|
|
2008-05-29 19:42:22 +00:00
|
|
|
static SDOperand getMemmoveLoadsAndStores(SelectionDAG &DAG,
|
|
|
|
SDOperand Chain, SDOperand Dst,
|
|
|
|
SDOperand Src, uint64_t Size,
|
|
|
|
unsigned Align, bool AlwaysInline,
|
|
|
|
const Value *DstSV, uint64_t DstSVOff,
|
|
|
|
const Value *SrcSV, uint64_t SrcSVOff){
|
|
|
|
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
|
|
|
|
|
|
|
|
// Expand memmove to a series of load and store ops if the size operand falls
|
|
|
|
// below a certain threshold.
|
2008-06-06 12:08:01 +00:00
|
|
|
std::vector<MVT> MemOps;
|
2008-05-29 19:42:22 +00:00
|
|
|
uint64_t Limit = -1;
|
|
|
|
if (!AlwaysInline)
|
|
|
|
Limit = TLI.getMaxStoresPerMemmove();
|
|
|
|
unsigned DstAlign = Align; // Destination alignment can change.
|
2008-06-30 07:31:25 +00:00
|
|
|
std::string Str;
|
|
|
|
bool CopyFromStr;
|
2008-05-29 19:42:22 +00:00
|
|
|
if (!MeetsMaxMemopRequirement(MemOps, Dst, Src, Limit, Size, DstAlign,
|
2008-06-30 07:31:25 +00:00
|
|
|
Str, CopyFromStr, DAG, TLI))
|
2008-05-29 19:42:22 +00:00
|
|
|
return SDOperand();
|
|
|
|
|
|
|
|
uint64_t SrcOff = 0, DstOff = 0;
|
|
|
|
|
|
|
|
SmallVector<SDOperand, 8> LoadValues;
|
|
|
|
SmallVector<SDOperand, 8> LoadChains;
|
|
|
|
SmallVector<SDOperand, 8> OutChains;
|
|
|
|
unsigned NumMemOps = MemOps.size();
|
|
|
|
for (unsigned i = 0; i < NumMemOps; i++) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = MemOps[i];
|
|
|
|
unsigned VTSize = VT.getSizeInBits() / 8;
|
2008-05-29 19:42:22 +00:00
|
|
|
SDOperand Value, Store;
|
|
|
|
|
|
|
|
Value = DAG.getLoad(VT, Chain,
|
|
|
|
getMemBasePlusOffset(Src, SrcOff, DAG),
|
|
|
|
SrcSV, SrcSVOff + SrcOff, false, Align);
|
|
|
|
LoadValues.push_back(Value);
|
|
|
|
LoadChains.push_back(Value.getValue(1));
|
|
|
|
SrcOff += VTSize;
|
|
|
|
}
|
|
|
|
Chain = DAG.getNode(ISD::TokenFactor, MVT::Other,
|
|
|
|
&LoadChains[0], LoadChains.size());
|
|
|
|
OutChains.clear();
|
|
|
|
for (unsigned i = 0; i < NumMemOps; i++) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = MemOps[i];
|
|
|
|
unsigned VTSize = VT.getSizeInBits() / 8;
|
2008-05-29 19:42:22 +00:00
|
|
|
SDOperand Value, Store;
|
|
|
|
|
|
|
|
Store = DAG.getStore(Chain, LoadValues[i],
|
|
|
|
getMemBasePlusOffset(Dst, DstOff, DAG),
|
|
|
|
DstSV, DstSVOff + DstOff, false, DstAlign);
|
|
|
|
OutChains.push_back(Store);
|
|
|
|
DstOff += VTSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
return DAG.getNode(ISD::TokenFactor, MVT::Other,
|
|
|
|
&OutChains[0], OutChains.size());
|
|
|
|
}
|
|
|
|
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
static SDOperand getMemsetStores(SelectionDAG &DAG,
|
|
|
|
SDOperand Chain, SDOperand Dst,
|
|
|
|
SDOperand Src, uint64_t Size,
|
|
|
|
unsigned Align,
|
2008-04-28 17:15:20 +00:00
|
|
|
const Value *DstSV, uint64_t DstSVOff) {
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
|
|
|
|
|
|
|
|
// Expand memset to a series of load/store ops if the size operand
|
|
|
|
// falls below a certain threshold.
|
2008-06-06 12:08:01 +00:00
|
|
|
std::vector<MVT> MemOps;
|
2008-06-30 07:31:25 +00:00
|
|
|
std::string Str;
|
|
|
|
bool CopyFromStr;
|
2008-05-15 08:39:06 +00:00
|
|
|
if (!MeetsMaxMemopRequirement(MemOps, Dst, Src, TLI.getMaxStoresPerMemset(),
|
2008-06-30 07:31:25 +00:00
|
|
|
Size, Align, Str, CopyFromStr, DAG, TLI))
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
return SDOperand();
|
|
|
|
|
|
|
|
SmallVector<SDOperand, 8> OutChains;
|
2008-04-28 17:15:20 +00:00
|
|
|
uint64_t DstOff = 0;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
|
|
|
unsigned NumMemOps = MemOps.size();
|
|
|
|
for (unsigned i = 0; i < NumMemOps; i++) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = MemOps[i];
|
|
|
|
unsigned VTSize = VT.getSizeInBits() / 8;
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
SDOperand Value = getMemsetValue(Src, VT, DAG);
|
|
|
|
SDOperand Store = DAG.getStore(Chain, Value,
|
|
|
|
getMemBasePlusOffset(Dst, DstOff, DAG),
|
2008-04-28 17:15:20 +00:00
|
|
|
DstSV, DstSVOff + DstOff);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
OutChains.push_back(Store);
|
|
|
|
DstOff += VTSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
return DAG.getNode(ISD::TokenFactor, MVT::Other,
|
|
|
|
&OutChains[0], OutChains.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getMemcpy(SDOperand Chain, SDOperand Dst,
|
|
|
|
SDOperand Src, SDOperand Size,
|
|
|
|
unsigned Align, bool AlwaysInline,
|
2008-04-28 17:15:20 +00:00
|
|
|
const Value *DstSV, uint64_t DstSVOff,
|
|
|
|
const Value *SrcSV, uint64_t SrcSVOff) {
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
|
|
|
// Check to see if we should lower the memcpy to loads and stores first.
|
|
|
|
// For cases within the target-specified limits, this is the best choice.
|
|
|
|
ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
|
|
|
|
if (ConstantSize) {
|
|
|
|
// Memcpy with size zero? Just return the original chain.
|
|
|
|
if (ConstantSize->isNullValue())
|
|
|
|
return Chain;
|
|
|
|
|
|
|
|
SDOperand Result =
|
|
|
|
getMemcpyLoadsAndStores(*this, Chain, Dst, Src, ConstantSize->getValue(),
|
2008-04-28 17:15:20 +00:00
|
|
|
Align, false, DstSV, DstSVOff, SrcSV, SrcSVOff);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
if (Result.Val)
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Then check to see if we should lower the memcpy with target-specific
|
|
|
|
// code. If the target chooses to do this, this is the next best.
|
|
|
|
SDOperand Result =
|
|
|
|
TLI.EmitTargetCodeForMemcpy(*this, Chain, Dst, Src, Size, Align,
|
|
|
|
AlwaysInline,
|
2008-04-28 17:15:20 +00:00
|
|
|
DstSV, DstSVOff, SrcSV, SrcSVOff);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
if (Result.Val)
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
// If we really need inline code and the target declined to provide it,
|
|
|
|
// use a (potentially long) sequence of loads and stores.
|
|
|
|
if (AlwaysInline) {
|
|
|
|
assert(ConstantSize && "AlwaysInline requires a constant size!");
|
|
|
|
return getMemcpyLoadsAndStores(*this, Chain, Dst, Src,
|
|
|
|
ConstantSize->getValue(), Align, true,
|
2008-04-28 17:15:20 +00:00
|
|
|
DstSV, DstSVOff, SrcSV, SrcSVOff);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Emit a library call.
|
|
|
|
TargetLowering::ArgListTy Args;
|
|
|
|
TargetLowering::ArgListEntry Entry;
|
|
|
|
Entry.Ty = TLI.getTargetData()->getIntPtrType();
|
|
|
|
Entry.Node = Dst; Args.push_back(Entry);
|
|
|
|
Entry.Node = Src; Args.push_back(Entry);
|
|
|
|
Entry.Node = Size; Args.push_back(Entry);
|
|
|
|
std::pair<SDOperand,SDOperand> CallResult =
|
|
|
|
TLI.LowerCallTo(Chain, Type::VoidTy,
|
|
|
|
false, false, false, CallingConv::C, false,
|
|
|
|
getExternalSymbol("memcpy", TLI.getPointerTy()),
|
|
|
|
Args, *this);
|
|
|
|
return CallResult.second;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getMemmove(SDOperand Chain, SDOperand Dst,
|
|
|
|
SDOperand Src, SDOperand Size,
|
|
|
|
unsigned Align,
|
2008-04-28 17:15:20 +00:00
|
|
|
const Value *DstSV, uint64_t DstSVOff,
|
|
|
|
const Value *SrcSV, uint64_t SrcSVOff) {
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
2008-05-29 19:42:22 +00:00
|
|
|
// Check to see if we should lower the memmove to loads and stores first.
|
|
|
|
// For cases within the target-specified limits, this is the best choice.
|
|
|
|
ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
|
|
|
|
if (ConstantSize) {
|
|
|
|
// Memmove with size zero? Just return the original chain.
|
|
|
|
if (ConstantSize->isNullValue())
|
|
|
|
return Chain;
|
|
|
|
|
|
|
|
SDOperand Result =
|
|
|
|
getMemmoveLoadsAndStores(*this, Chain, Dst, Src, ConstantSize->getValue(),
|
|
|
|
Align, false, DstSV, DstSVOff, SrcSV, SrcSVOff);
|
|
|
|
if (Result.Val)
|
|
|
|
return Result;
|
|
|
|
}
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
|
|
|
// Then check to see if we should lower the memmove with target-specific
|
|
|
|
// code. If the target chooses to do this, this is the next best.
|
|
|
|
SDOperand Result =
|
|
|
|
TLI.EmitTargetCodeForMemmove(*this, Chain, Dst, Src, Size, Align,
|
2008-04-28 17:15:20 +00:00
|
|
|
DstSV, DstSVOff, SrcSV, SrcSVOff);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
if (Result.Val)
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
// Emit a library call.
|
|
|
|
TargetLowering::ArgListTy Args;
|
|
|
|
TargetLowering::ArgListEntry Entry;
|
|
|
|
Entry.Ty = TLI.getTargetData()->getIntPtrType();
|
|
|
|
Entry.Node = Dst; Args.push_back(Entry);
|
|
|
|
Entry.Node = Src; Args.push_back(Entry);
|
|
|
|
Entry.Node = Size; Args.push_back(Entry);
|
|
|
|
std::pair<SDOperand,SDOperand> CallResult =
|
|
|
|
TLI.LowerCallTo(Chain, Type::VoidTy,
|
|
|
|
false, false, false, CallingConv::C, false,
|
|
|
|
getExternalSymbol("memmove", TLI.getPointerTy()),
|
|
|
|
Args, *this);
|
|
|
|
return CallResult.second;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getMemset(SDOperand Chain, SDOperand Dst,
|
2007-10-19 10:41:11 +00:00
|
|
|
SDOperand Src, SDOperand Size,
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
unsigned Align,
|
2008-04-28 17:15:20 +00:00
|
|
|
const Value *DstSV, uint64_t DstSVOff) {
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
|
|
|
|
// Check to see if we should lower the memset to stores first.
|
|
|
|
// For cases within the target-specified limits, this is the best choice.
|
|
|
|
ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
|
|
|
|
if (ConstantSize) {
|
|
|
|
// Memset with size zero? Just return the original chain.
|
|
|
|
if (ConstantSize->isNullValue())
|
|
|
|
return Chain;
|
|
|
|
|
|
|
|
SDOperand Result =
|
|
|
|
getMemsetStores(*this, Chain, Dst, Src, ConstantSize->getValue(), Align,
|
2008-04-28 17:15:20 +00:00
|
|
|
DstSV, DstSVOff);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
if (Result.Val)
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Then check to see if we should lower the memset with target-specific
|
|
|
|
// code. If the target chooses to do this, this is the next best.
|
|
|
|
SDOperand Result =
|
|
|
|
TLI.EmitTargetCodeForMemset(*this, Chain, Dst, Src, Size, Align,
|
2008-04-28 17:15:20 +00:00
|
|
|
DstSV, DstSVOff);
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
if (Result.Val)
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
// Emit a library call.
|
|
|
|
const Type *IntPtrTy = TLI.getTargetData()->getIntPtrType();
|
|
|
|
TargetLowering::ArgListTy Args;
|
|
|
|
TargetLowering::ArgListEntry Entry;
|
|
|
|
Entry.Node = Dst; Entry.Ty = IntPtrTy;
|
|
|
|
Args.push_back(Entry);
|
|
|
|
// Extend or truncate the argument to be an i32 value for the call.
|
2008-06-08 20:54:56 +00:00
|
|
|
if (Src.getValueType().bitsGT(MVT::i32))
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
Src = getNode(ISD::TRUNCATE, MVT::i32, Src);
|
|
|
|
else
|
|
|
|
Src = getNode(ISD::ZERO_EXTEND, MVT::i32, Src);
|
|
|
|
Entry.Node = Src; Entry.Ty = Type::Int32Ty; Entry.isSExt = true;
|
|
|
|
Args.push_back(Entry);
|
|
|
|
Entry.Node = Size; Entry.Ty = IntPtrTy; Entry.isSExt = false;
|
|
|
|
Args.push_back(Entry);
|
|
|
|
std::pair<SDOperand,SDOperand> CallResult =
|
|
|
|
TLI.LowerCallTo(Chain, Type::VoidTy,
|
|
|
|
false, false, false, CallingConv::C, false,
|
|
|
|
getExternalSymbol("memset", TLI.getPointerTy()),
|
|
|
|
Args, *this);
|
|
|
|
return CallResult.second;
|
2007-10-19 10:41:11 +00:00
|
|
|
}
|
|
|
|
|
2008-02-21 06:45:13 +00:00
|
|
|
SDOperand SelectionDAG::getAtomic(unsigned Opcode, SDOperand Chain,
|
2008-02-21 16:11:38 +00:00
|
|
|
SDOperand Ptr, SDOperand Cmp,
|
2008-06-25 16:07:49 +00:00
|
|
|
SDOperand Swp, const Value* PtrVal,
|
2008-06-25 08:15:39 +00:00
|
|
|
unsigned Alignment) {
|
|
|
|
assert(Opcode == ISD::ATOMIC_CMP_SWAP && "Invalid Atomic Op");
|
2008-02-21 16:11:38 +00:00
|
|
|
assert(Cmp.getValueType() == Swp.getValueType() && "Invalid Atomic Op Types");
|
2008-07-08 23:46:32 +00:00
|
|
|
|
|
|
|
MVT VT = Cmp.getValueType();
|
|
|
|
|
|
|
|
if (Alignment == 0) // Ensure that codegen never sees alignment 0
|
|
|
|
Alignment = getMVTAlignment(VT);
|
|
|
|
|
|
|
|
SDVTList VTs = getVTList(VT, MVT::Other);
|
2008-02-21 06:45:13 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-02-21 16:11:38 +00:00
|
|
|
SDOperand Ops[] = {Chain, Ptr, Cmp, Swp};
|
2008-02-21 06:45:13 +00:00
|
|
|
AddNodeIDNode(ID, Opcode, VTs, Ops, 4);
|
|
|
|
void* IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode* N = getAllocator().Allocate<AtomicSDNode>();
|
|
|
|
new (N) AtomicSDNode(Opcode, VTs, Chain, Ptr, Cmp, Swp, PtrVal, Alignment);
|
2008-02-21 06:45:13 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getAtomic(unsigned Opcode, SDOperand Chain,
|
2008-02-21 16:11:38 +00:00
|
|
|
SDOperand Ptr, SDOperand Val,
|
2008-06-25 16:07:49 +00:00
|
|
|
const Value* PtrVal,
|
2008-06-25 08:15:39 +00:00
|
|
|
unsigned Alignment) {
|
|
|
|
assert(( Opcode == ISD::ATOMIC_LOAD_ADD || Opcode == ISD::ATOMIC_LOAD_SUB
|
2008-05-05 19:05:59 +00:00
|
|
|
|| Opcode == ISD::ATOMIC_SWAP || Opcode == ISD::ATOMIC_LOAD_AND
|
|
|
|
|| Opcode == ISD::ATOMIC_LOAD_OR || Opcode == ISD::ATOMIC_LOAD_XOR
|
2008-06-14 05:48:15 +00:00
|
|
|
|| Opcode == ISD::ATOMIC_LOAD_NAND
|
2008-05-05 19:05:59 +00:00
|
|
|
|| Opcode == ISD::ATOMIC_LOAD_MIN || Opcode == ISD::ATOMIC_LOAD_MAX
|
|
|
|
|| Opcode == ISD::ATOMIC_LOAD_UMIN || Opcode == ISD::ATOMIC_LOAD_UMAX)
|
2008-02-21 06:45:13 +00:00
|
|
|
&& "Invalid Atomic Op");
|
2008-07-08 23:46:32 +00:00
|
|
|
|
|
|
|
MVT VT = Val.getValueType();
|
|
|
|
|
|
|
|
if (Alignment == 0) // Ensure that codegen never sees alignment 0
|
|
|
|
Alignment = getMVTAlignment(VT);
|
|
|
|
|
|
|
|
SDVTList VTs = getVTList(VT, MVT::Other);
|
2008-02-21 06:45:13 +00:00
|
|
|
FoldingSetNodeID ID;
|
2008-02-21 16:11:38 +00:00
|
|
|
SDOperand Ops[] = {Chain, Ptr, Val};
|
2008-02-21 06:45:13 +00:00
|
|
|
AddNodeIDNode(ID, Opcode, VTs, Ops, 3);
|
|
|
|
void* IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode* N = getAllocator().Allocate<AtomicSDNode>();
|
|
|
|
new (N) AtomicSDNode(Opcode, VTs, Chain, Ptr, Val, PtrVal, Alignment);
|
2008-02-21 06:45:13 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-07-02 17:40:58 +00:00
|
|
|
/// getMergeValues - Create a MERGE_VALUES node from the given operands.
|
|
|
|
/// Allowed to return something different (and simpler) if Simplify is true.
|
2008-07-07 18:26:29 +00:00
|
|
|
SDOperand SelectionDAG::getMergeValues(const SDOperand *Ops, unsigned NumOps,
|
2008-07-02 17:40:58 +00:00
|
|
|
bool Simplify) {
|
|
|
|
if (Simplify && NumOps == 1)
|
|
|
|
return Ops[0];
|
|
|
|
|
|
|
|
SmallVector<MVT, 4> VTs;
|
|
|
|
VTs.reserve(NumOps);
|
|
|
|
for (unsigned i = 0; i < NumOps; ++i)
|
|
|
|
VTs.push_back(Ops[i].getValueType());
|
|
|
|
return getNode(ISD::MERGE_VALUES, getVTList(&VTs[0], NumOps), Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
2008-03-27 20:23:40 +00:00
|
|
|
SDOperand
|
2008-03-28 09:45:24 +00:00
|
|
|
SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT, SDOperand Chain,
|
2008-03-28 09:45:24 +00:00
|
|
|
SDOperand Ptr, SDOperand Offset,
|
2008-06-06 12:08:01 +00:00
|
|
|
const Value *SV, int SVOffset, MVT EVT,
|
2008-03-28 09:45:24 +00:00
|
|
|
bool isVolatile, unsigned Alignment) {
|
2008-07-08 23:46:32 +00:00
|
|
|
if (Alignment == 0) // Ensure that codegen never sees alignment 0
|
|
|
|
Alignment = getMVTAlignment(VT);
|
2008-03-27 20:23:40 +00:00
|
|
|
|
|
|
|
if (VT == EVT) {
|
|
|
|
ExtType = ISD::NON_EXTLOAD;
|
|
|
|
} else if (ExtType == ISD::NON_EXTLOAD) {
|
|
|
|
assert(VT == EVT && "Non-extending load from different memory type!");
|
|
|
|
} else {
|
|
|
|
// Extending load.
|
2008-06-06 12:08:01 +00:00
|
|
|
if (VT.isVector())
|
|
|
|
assert(EVT == VT.getVectorElementType() && "Invalid vector extload!");
|
2008-03-27 20:23:40 +00:00
|
|
|
else
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(EVT.bitsLT(VT) &&
|
2008-03-27 20:23:40 +00:00
|
|
|
"Should only be an extending load, not truncating!");
|
2008-06-06 12:08:01 +00:00
|
|
|
assert((ExtType == ISD::EXTLOAD || VT.isInteger()) &&
|
2008-03-27 20:23:40 +00:00
|
|
|
"Cannot sign/zero extend a FP/Vector load!");
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() == EVT.isInteger() &&
|
2008-03-27 20:23:40 +00:00
|
|
|
"Cannot convert from FP to Int or Int -> FP!");
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Indexed = AM != ISD::UNINDEXED;
|
2008-05-27 11:50:51 +00:00
|
|
|
assert((Indexed || Offset.getOpcode() == ISD::UNDEF) &&
|
2008-03-27 20:23:40 +00:00
|
|
|
"Unindexed load with an offset!");
|
|
|
|
|
|
|
|
SDVTList VTs = Indexed ?
|
|
|
|
getVTList(VT, Ptr.getValueType(), MVT::Other) : getVTList(VT, MVT::Other);
|
|
|
|
SDOperand Ops[] = { Chain, Ptr, Offset };
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
2007-02-04 07:28:00 +00:00
|
|
|
AddNodeIDNode(ID, ISD::LOAD, VTs, Ops, 3);
|
2008-03-27 20:23:40 +00:00
|
|
|
ID.AddInteger(AM);
|
|
|
|
ID.AddInteger(ExtType);
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(EVT.getRawBits());
|
2006-10-09 20:57:25 +00:00
|
|
|
ID.AddInteger(Alignment);
|
|
|
|
ID.AddInteger(isVolatile);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<LoadSDNode>();
|
|
|
|
new (N) LoadSDNode(Ops, VTs, AM, ExtType, EVT, SV, SVOffset,
|
|
|
|
Alignment, isVolatile);
|
2006-10-09 20:57:25 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getLoad(MVT VT,
|
2008-03-27 20:23:40 +00:00
|
|
|
SDOperand Chain, SDOperand Ptr,
|
|
|
|
const Value *SV, int SVOffset,
|
|
|
|
bool isVolatile, unsigned Alignment) {
|
|
|
|
SDOperand Undef = getNode(ISD::UNDEF, Ptr.getValueType());
|
2008-03-28 09:45:24 +00:00
|
|
|
return getLoad(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, Chain, Ptr, Undef,
|
|
|
|
SV, SVOffset, VT, isVolatile, Alignment);
|
2008-03-27 20:23:40 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, MVT VT,
|
2007-02-01 04:55:59 +00:00
|
|
|
SDOperand Chain, SDOperand Ptr,
|
|
|
|
const Value *SV,
|
2008-06-06 12:08:01 +00:00
|
|
|
int SVOffset, MVT EVT,
|
2007-04-22 23:15:30 +00:00
|
|
|
bool isVolatile, unsigned Alignment) {
|
2006-10-13 21:14:26 +00:00
|
|
|
SDOperand Undef = getNode(ISD::UNDEF, Ptr.getValueType());
|
2008-03-28 09:45:24 +00:00
|
|
|
return getLoad(ISD::UNINDEXED, ExtType, VT, Chain, Ptr, Undef,
|
|
|
|
SV, SVOffset, EVT, isVolatile, Alignment);
|
2005-12-10 00:37:58 +00:00
|
|
|
}
|
|
|
|
|
2006-11-09 17:55:04 +00:00
|
|
|
SDOperand
|
|
|
|
SelectionDAG::getIndexedLoad(SDOperand OrigLoad, SDOperand Base,
|
|
|
|
SDOperand Offset, ISD::MemIndexedMode AM) {
|
2006-10-17 21:14:32 +00:00
|
|
|
LoadSDNode *LD = cast<LoadSDNode>(OrigLoad);
|
2006-10-26 21:53:40 +00:00
|
|
|
assert(LD->getOffset().getOpcode() == ISD::UNDEF &&
|
|
|
|
"Load is already a indexed load!");
|
2008-03-28 09:45:24 +00:00
|
|
|
return getLoad(AM, LD->getExtensionType(), OrigLoad.getValueType(),
|
|
|
|
LD->getChain(), Base, Offset, LD->getSrcValue(),
|
|
|
|
LD->getSrcValueOffset(), LD->getMemoryVT(),
|
|
|
|
LD->isVolatile(), LD->getAlignment());
|
2006-10-17 21:14:32 +00:00
|
|
|
}
|
|
|
|
|
2006-11-05 19:31:28 +00:00
|
|
|
SDOperand SelectionDAG::getStore(SDOperand Chain, SDOperand Val,
|
2006-10-13 21:14:26 +00:00
|
|
|
SDOperand Ptr, const Value *SV, int SVOffset,
|
2007-04-22 23:15:30 +00:00
|
|
|
bool isVolatile, unsigned Alignment) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = Val.getValueType();
|
2006-10-13 21:14:26 +00:00
|
|
|
|
2008-07-08 23:46:32 +00:00
|
|
|
if (Alignment == 0) // Ensure that codegen never sees alignment 0
|
|
|
|
Alignment = getMVTAlignment(VT);
|
|
|
|
|
2006-10-05 22:57:11 +00:00
|
|
|
SDVTList VTs = getVTList(MVT::Other);
|
2006-10-13 21:14:26 +00:00
|
|
|
SDOperand Undef = getNode(ISD::UNDEF, Ptr.getValueType());
|
2006-11-05 19:31:28 +00:00
|
|
|
SDOperand Ops[] = { Chain, Val, Ptr, Undef };
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
|
2006-10-13 21:14:26 +00:00
|
|
|
ID.AddInteger(ISD::UNINDEXED);
|
|
|
|
ID.AddInteger(false);
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(VT.getRawBits());
|
2006-10-13 21:14:26 +00:00
|
|
|
ID.AddInteger(Alignment);
|
|
|
|
ID.AddInteger(isVolatile);
|
2006-10-05 22:57:11 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<StoreSDNode>();
|
|
|
|
new (N) StoreSDNode(Ops, VTs, ISD::UNINDEXED, false,
|
|
|
|
VT, SV, SVOffset, Alignment, isVolatile);
|
2006-10-13 21:14:26 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2006-11-05 19:31:28 +00:00
|
|
|
SDOperand SelectionDAG::getTruncStore(SDOperand Chain, SDOperand Val,
|
2006-10-13 21:14:26 +00:00
|
|
|
SDOperand Ptr, const Value *SV,
|
2008-06-06 12:08:01 +00:00
|
|
|
int SVOffset, MVT SVT,
|
2007-04-22 23:15:30 +00:00
|
|
|
bool isVolatile, unsigned Alignment) {
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT = Val.getValueType();
|
2007-10-30 12:40:58 +00:00
|
|
|
|
|
|
|
if (VT == SVT)
|
|
|
|
return getStore(Chain, Val, Ptr, SV, SVOffset, isVolatile, Alignment);
|
2006-10-13 21:14:26 +00:00
|
|
|
|
2008-06-08 20:54:56 +00:00
|
|
|
assert(VT.bitsGT(SVT) && "Not a truncation?");
|
2008-06-06 12:08:01 +00:00
|
|
|
assert(VT.isInteger() == SVT.isInteger() &&
|
2006-10-13 21:14:26 +00:00
|
|
|
"Can't do FP-INT conversion!");
|
|
|
|
|
2008-07-08 23:46:32 +00:00
|
|
|
if (Alignment == 0) // Ensure that codegen never sees alignment 0
|
|
|
|
Alignment = getMVTAlignment(VT);
|
|
|
|
|
2006-10-13 21:14:26 +00:00
|
|
|
SDVTList VTs = getVTList(MVT::Other);
|
|
|
|
SDOperand Undef = getNode(ISD::UNDEF, Ptr.getValueType());
|
2006-11-05 19:31:28 +00:00
|
|
|
SDOperand Ops[] = { Chain, Val, Ptr, Undef };
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
|
2006-10-13 21:14:26 +00:00
|
|
|
ID.AddInteger(ISD::UNINDEXED);
|
2007-10-30 12:40:58 +00:00
|
|
|
ID.AddInteger(1);
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(SVT.getRawBits());
|
2006-10-13 21:14:26 +00:00
|
|
|
ID.AddInteger(Alignment);
|
|
|
|
ID.AddInteger(isVolatile);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<StoreSDNode>();
|
|
|
|
new (N) StoreSDNode(Ops, VTs, ISD::UNINDEXED, true,
|
|
|
|
SVT, SV, SVOffset, Alignment, isVolatile);
|
2006-10-05 22:57:11 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2006-11-09 17:55:04 +00:00
|
|
|
SDOperand
|
|
|
|
SelectionDAG::getIndexedStore(SDOperand OrigStore, SDOperand Base,
|
|
|
|
SDOperand Offset, ISD::MemIndexedMode AM) {
|
2006-11-05 09:30:09 +00:00
|
|
|
StoreSDNode *ST = cast<StoreSDNode>(OrigStore);
|
|
|
|
assert(ST->getOffset().getOpcode() == ISD::UNDEF &&
|
|
|
|
"Store is already a indexed store!");
|
|
|
|
SDVTList VTs = getVTList(Base.getValueType(), MVT::Other);
|
|
|
|
SDOperand Ops[] = { ST->getChain(), ST->getValue(), Base, Offset };
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
|
|
|
|
ID.AddInteger(AM);
|
|
|
|
ID.AddInteger(ST->isTruncatingStore());
|
2008-06-06 12:49:32 +00:00
|
|
|
ID.AddInteger(ST->getMemoryVT().getRawBits());
|
2006-11-05 09:30:09 +00:00
|
|
|
ID.AddInteger(ST->getAlignment());
|
|
|
|
ID.AddInteger(ST->isVolatile());
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
SDNode *N = getAllocator().Allocate<StoreSDNode>();
|
|
|
|
new (N) StoreSDNode(Ops, VTs, AM,
|
|
|
|
ST->isTruncatingStore(), ST->getMemoryVT(),
|
|
|
|
ST->getSrcValue(), ST->getSrcValueOffset(),
|
|
|
|
ST->getAlignment(), ST->isVolatile());
|
2006-11-05 09:30:09 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
|
|
|
AllNodes.push_back(N);
|
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getVAArg(MVT VT,
|
2006-01-25 18:21:52 +00:00
|
|
|
SDOperand Chain, SDOperand Ptr,
|
|
|
|
SDOperand SV) {
|
2006-08-08 02:23:42 +00:00
|
|
|
SDOperand Ops[] = { Chain, Ptr, SV };
|
2006-08-16 22:57:46 +00:00
|
|
|
return getNode(ISD::VAARG, getVTList(VT, MVT::Other), Ops, 3);
|
2006-01-25 18:21:52 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT VT,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDUse *Ops, unsigned NumOps) {
|
|
|
|
switch (NumOps) {
|
|
|
|
case 0: return getNode(Opcode, VT);
|
|
|
|
case 1: return getNode(Opcode, VT, Ops[0].getSDOperand());
|
|
|
|
case 2: return getNode(Opcode, VT, Ops[0].getSDOperand(),
|
|
|
|
Ops[1].getSDOperand());
|
|
|
|
case 3: return getNode(Opcode, VT, Ops[0].getSDOperand(),
|
|
|
|
Ops[1].getSDOperand(), Ops[2].getSDOperand());
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Copy from an SDUse array into an SDOperand array for use with
|
|
|
|
// the regular getNode logic.
|
|
|
|
SmallVector<SDOperand, 8> NewOps;
|
|
|
|
NewOps.reserve(NumOps);
|
|
|
|
for (unsigned i = 0; i != NumOps; ++i)
|
|
|
|
NewOps.push_back(Ops[i].getSDOperand());
|
|
|
|
return getNode(Opcode, VT, Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT VT,
|
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2006-08-08 01:09:31 +00:00
|
|
|
switch (NumOps) {
|
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-11-09 23:47:37 +00:00
|
|
|
|
2005-04-09 03:27:28 +00:00
|
|
|
switch (Opcode) {
|
|
|
|
default: break;
|
2005-08-24 22:44:39 +00:00
|
|
|
case ISD::SELECT_CC: {
|
2006-08-08 01:09:31 +00:00
|
|
|
assert(NumOps == 5 && "SELECT_CC takes 5 operands!");
|
2005-08-24 22:44:39 +00:00
|
|
|
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!");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ISD::BR_CC: {
|
2006-08-08 01:09:31 +00:00
|
|
|
assert(NumOps == 5 && "BR_CC takes 5 operands!");
|
2005-08-24 22:44:39 +00:00
|
|
|
assert(Ops[2].getValueType() == Ops[3].getValueType() &&
|
|
|
|
"LHS/RHS of comparison should match types!");
|
|
|
|
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;
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2005-08-25 19:12:10 +00:00
|
|
|
if (VT != MVT::Flag) {
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
AddNodeIDNode(ID, Opcode, VTs, Ops, NumOps);
|
2006-08-07 23:03:03 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<SDNode>();
|
|
|
|
new (N) SDNode(Opcode, VTs, Ops, NumOps);
|
2006-08-07 23:03:03 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-08-25 19:12:10 +00:00
|
|
|
} else {
|
2008-07-07 23:02:41 +00:00
|
|
|
N = getAllocator().Allocate<SDNode>();
|
|
|
|
new (N) SDNode(Opcode, VTs, Ops, NumOps);
|
2005-08-25 19:12:10 +00:00
|
|
|
}
|
2005-04-09 03:27:28 +00:00
|
|
|
AllNodes.push_back(N);
|
2008-07-21 10:20:31 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
VerifyNode(N);
|
|
|
|
#endif
|
2005-04-09 03:27:28 +00:00
|
|
|
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,
|
2008-07-09 00:00:42 +00:00
|
|
|
const std::vector<MVT> &ResultTys,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2006-08-14 23:31:51 +00:00
|
|
|
return getNode(Opcode, getNodeValueTypes(ResultTys), ResultTys.size(),
|
|
|
|
Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode,
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs, unsigned NumVTs,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2006-08-14 23:31:51 +00:00
|
|
|
if (NumVTs == 1)
|
|
|
|
return getNode(Opcode, VTs[0], Ops, NumOps);
|
2006-08-16 22:57:46 +00:00
|
|
|
return getNode(Opcode, makeVTList(VTs, NumVTs), Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2006-08-16 22:57:46 +00:00
|
|
|
if (VTList.NumVTs == 1)
|
|
|
|
return getNode(Opcode, VTList.VTs[0], Ops, NumOps);
|
2005-05-14 06:20:26 +00:00
|
|
|
|
2005-07-10 01:55:33 +00:00
|
|
|
switch (Opcode) {
|
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.
|
2008-06-06 12:08:01 +00:00
|
|
|
unsigned NumBits = VT.getSizeInBits()*2;
|
2005-05-14 07:25:05 +00:00
|
|
|
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;
|
2006-08-16 22:57:46 +00:00
|
|
|
if (VTList.VTs[VTList.NumVTs-1] != MVT::Flag) {
|
2006-10-27 23:46:08 +00:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
|
2006-08-07 23:03:03 +00:00
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return SDOperand(E, 0);
|
2008-07-07 23:02:41 +00:00
|
|
|
if (NumOps == 1) {
|
|
|
|
N = getAllocator().Allocate<UnarySDNode>();
|
|
|
|
new (N) UnarySDNode(Opcode, VTList, Ops[0]);
|
|
|
|
} else if (NumOps == 2) {
|
|
|
|
N = getAllocator().Allocate<BinarySDNode>();
|
|
|
|
new (N) BinarySDNode(Opcode, VTList, Ops[0], Ops[1]);
|
|
|
|
} else if (NumOps == 3) {
|
|
|
|
N = getAllocator().Allocate<TernarySDNode>();
|
|
|
|
new (N) TernarySDNode(Opcode, VTList, Ops[0], Ops[1], Ops[2]);
|
|
|
|
} else {
|
|
|
|
N = getAllocator().Allocate<SDNode>();
|
|
|
|
new (N) SDNode(Opcode, VTList, Ops, NumOps);
|
|
|
|
}
|
2006-08-07 23:03:03 +00:00
|
|
|
CSEMap.InsertNode(N, IP);
|
2005-08-25 19:12:10 +00:00
|
|
|
} else {
|
2008-07-07 23:02:41 +00:00
|
|
|
if (NumOps == 1) {
|
|
|
|
N = getAllocator().Allocate<UnarySDNode>();
|
|
|
|
new (N) UnarySDNode(Opcode, VTList, Ops[0]);
|
|
|
|
} else if (NumOps == 2) {
|
|
|
|
N = getAllocator().Allocate<BinarySDNode>();
|
|
|
|
new (N) BinarySDNode(Opcode, VTList, Ops[0], Ops[1]);
|
|
|
|
} else if (NumOps == 3) {
|
|
|
|
N = getAllocator().Allocate<TernarySDNode>();
|
|
|
|
new (N) TernarySDNode(Opcode, VTList, Ops[0], Ops[1], Ops[2]);
|
|
|
|
} else {
|
|
|
|
N = getAllocator().Allocate<SDNode>();
|
|
|
|
new (N) SDNode(Opcode, VTList, Ops, NumOps);
|
|
|
|
}
|
2005-08-25 19:12:10 +00:00
|
|
|
}
|
2005-05-14 06:42:57 +00:00
|
|
|
AllNodes.push_back(N);
|
2008-07-21 10:20:31 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
VerifyNode(N);
|
|
|
|
#endif
|
2005-05-14 06:20:26 +00:00
|
|
|
return SDOperand(N, 0);
|
|
|
|
}
|
|
|
|
|
2007-10-08 15:49:58 +00:00
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList) {
|
2008-07-07 18:26:29 +00:00
|
|
|
return getNode(Opcode, VTList, 0, 0);
|
2007-10-08 15:49:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
|
|
|
|
SDOperand N1) {
|
|
|
|
SDOperand Ops[] = { N1 };
|
|
|
|
return getNode(Opcode, VTList, Ops, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
|
|
|
|
SDOperand N1, SDOperand N2) {
|
|
|
|
SDOperand Ops[] = { N1, N2 };
|
|
|
|
return getNode(Opcode, VTList, Ops, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
|
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3) {
|
|
|
|
SDOperand Ops[] = { N1, N2, N3 };
|
|
|
|
return getNode(Opcode, VTList, Ops, 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
|
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3,
|
|
|
|
SDOperand N4) {
|
|
|
|
SDOperand Ops[] = { N1, N2, N3, N4 };
|
|
|
|
return getNode(Opcode, VTList, Ops, 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
|
|
|
|
SDOperand N1, SDOperand N2, SDOperand N3,
|
|
|
|
SDOperand N4, SDOperand N5) {
|
|
|
|
SDOperand Ops[] = { N1, N2, N3, N4, N5 };
|
|
|
|
return getNode(Opcode, VTList, Ops, 5);
|
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDVTList SelectionDAG::getVTList(MVT VT) {
|
2007-10-16 09:56:48 +00:00
|
|
|
return makeVTList(SDNode::getValueTypeList(VT), 1);
|
2005-11-08 23:30:28 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDVTList SelectionDAG::getVTList(MVT VT1, MVT VT2) {
|
2008-07-17 19:10:17 +00:00
|
|
|
for (std::vector<SDVTList>::reverse_iterator I = VTList.rbegin(),
|
|
|
|
E = VTList.rend(); I != E; ++I)
|
|
|
|
if (I->NumVTs == 2 && I->VTs[0] == VT1 && I->VTs[1] == VT2)
|
|
|
|
return *I;
|
|
|
|
|
|
|
|
MVT *Array = Allocator.Allocate<MVT>(2);
|
|
|
|
Array[0] = VT1;
|
|
|
|
Array[1] = VT2;
|
|
|
|
SDVTList Result = makeVTList(Array, 2);
|
|
|
|
VTList.push_back(Result);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDVTList SelectionDAG::getVTList(MVT VT1, MVT VT2, MVT VT3) {
|
|
|
|
for (std::vector<SDVTList>::reverse_iterator I = VTList.rbegin(),
|
|
|
|
E = VTList.rend(); I != E; ++I)
|
|
|
|
if (I->NumVTs == 3 && I->VTs[0] == VT1 && I->VTs[1] == VT2 &&
|
|
|
|
I->VTs[2] == VT3)
|
|
|
|
return *I;
|
|
|
|
|
|
|
|
MVT *Array = Allocator.Allocate<MVT>(3);
|
|
|
|
Array[0] = VT1;
|
|
|
|
Array[1] = VT2;
|
|
|
|
Array[2] = VT3;
|
|
|
|
SDVTList Result = makeVTList(Array, 3);
|
|
|
|
VTList.push_back(Result);
|
|
|
|
return Result;
|
2006-08-15 17:46:01 +00:00
|
|
|
}
|
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
SDVTList SelectionDAG::getVTList(const MVT *VTs, unsigned NumVTs) {
|
2006-08-15 17:46:01 +00:00
|
|
|
switch (NumVTs) {
|
|
|
|
case 0: assert(0 && "Cannot have nodes without results!");
|
2007-06-25 16:23:39 +00:00
|
|
|
case 1: return getVTList(VTs[0]);
|
2006-08-15 17:46:01 +00:00
|
|
|
case 2: return getVTList(VTs[0], VTs[1]);
|
|
|
|
case 3: return getVTList(VTs[0], VTs[1], VTs[2]);
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
for (std::vector<SDVTList>::reverse_iterator I = VTList.rbegin(),
|
|
|
|
E = VTList.rend(); I != E; ++I) {
|
|
|
|
if (I->NumVTs != NumVTs || VTs[0] != I->VTs[0] || VTs[1] != I->VTs[1])
|
|
|
|
continue;
|
2006-08-15 17:46:01 +00:00
|
|
|
|
|
|
|
bool NoMatch = false;
|
|
|
|
for (unsigned i = 2; i != NumVTs; ++i)
|
2008-07-17 19:10:17 +00:00
|
|
|
if (VTs[i] != I->VTs[i]) {
|
2006-08-15 17:46:01 +00:00
|
|
|
NoMatch = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!NoMatch)
|
2008-07-17 19:10:17 +00:00
|
|
|
return *I;
|
2006-08-15 17:46:01 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
MVT *Array = Allocator.Allocate<MVT>(NumVTs);
|
|
|
|
std::copy(VTs, VTs+NumVTs, Array);
|
|
|
|
SDVTList Result = makeVTList(Array, NumVTs);
|
|
|
|
VTList.push_back(Result);
|
|
|
|
return Result;
|
2006-08-14 23:31:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-01-28 09:32:45 +00:00
|
|
|
/// UpdateNodeOperands - *Mutate* the specified node in-place to have the
|
|
|
|
/// specified operands. If the resultant node already exists in the DAG,
|
|
|
|
/// this does not modify the specified node, instead it returns the node that
|
|
|
|
/// already exists. If the resultant node does not exist in the DAG, the
|
|
|
|
/// input node is returned. As a degenerate case, if you specify the same
|
|
|
|
/// input operands as the node already has, the input node is returned.
|
|
|
|
SDOperand SelectionDAG::
|
|
|
|
UpdateNodeOperands(SDOperand InN, SDOperand Op) {
|
|
|
|
SDNode *N = InN.Val;
|
|
|
|
assert(N->getNumOperands() == 1 && "Update with wrong number of operands");
|
|
|
|
|
|
|
|
// Check to see if there is no change.
|
|
|
|
if (Op == N->getOperand(0)) return InN;
|
|
|
|
|
|
|
|
// See if the modified node already exists.
|
2006-08-07 23:03:03 +00:00
|
|
|
void *InsertPos = 0;
|
|
|
|
if (SDNode *Existing = FindModifiedNodeSlot(N, Op, InsertPos))
|
|
|
|
return SDOperand(Existing, InN.ResNo);
|
2006-01-28 09:32:45 +00:00
|
|
|
|
2008-07-21 22:38:59 +00:00
|
|
|
// Nope it doesn't. Remove the node from its current place in the maps.
|
2006-08-07 23:03:03 +00:00
|
|
|
if (InsertPos)
|
2006-01-28 09:32:45 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
|
|
|
|
// Now we update the operands.
|
2008-04-16 16:15:27 +00:00
|
|
|
N->OperandList[0].getVal()->removeUser(0, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
N->OperandList[0] = Op;
|
2008-04-07 10:06:32 +00:00
|
|
|
N->OperandList[0].setUser(N);
|
|
|
|
Op.Val->addUser(0, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
|
|
|
|
// If this gets put into a CSE map, add it.
|
2006-08-07 23:03:03 +00:00
|
|
|
if (InsertPos) CSEMap.InsertNode(N, InsertPos);
|
2006-01-28 09:32:45 +00:00
|
|
|
return InN;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::
|
|
|
|
UpdateNodeOperands(SDOperand InN, SDOperand Op1, SDOperand Op2) {
|
|
|
|
SDNode *N = InN.Val;
|
|
|
|
assert(N->getNumOperands() == 2 && "Update with wrong number of operands");
|
|
|
|
|
|
|
|
// Check to see if there is no change.
|
|
|
|
if (Op1 == N->getOperand(0) && Op2 == N->getOperand(1))
|
|
|
|
return InN; // No operands changed, just return the input node.
|
|
|
|
|
|
|
|
// See if the modified node already exists.
|
2006-08-07 23:03:03 +00:00
|
|
|
void *InsertPos = 0;
|
|
|
|
if (SDNode *Existing = FindModifiedNodeSlot(N, Op1, Op2, InsertPos))
|
|
|
|
return SDOperand(Existing, InN.ResNo);
|
2006-01-28 09:32:45 +00:00
|
|
|
|
2008-07-21 22:38:59 +00:00
|
|
|
// Nope it doesn't. Remove the node from its current place in the maps.
|
2006-08-07 23:03:03 +00:00
|
|
|
if (InsertPos)
|
2006-01-28 09:32:45 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
|
|
|
|
// Now we update the operands.
|
|
|
|
if (N->OperandList[0] != Op1) {
|
2008-04-16 16:15:27 +00:00
|
|
|
N->OperandList[0].getVal()->removeUser(0, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
N->OperandList[0] = Op1;
|
2008-04-07 10:06:32 +00:00
|
|
|
N->OperandList[0].setUser(N);
|
|
|
|
Op1.Val->addUser(0, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
|
|
|
if (N->OperandList[1] != Op2) {
|
2008-04-16 16:15:27 +00:00
|
|
|
N->OperandList[1].getVal()->removeUser(1, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
N->OperandList[1] = Op2;
|
2008-04-07 10:06:32 +00:00
|
|
|
N->OperandList[1].setUser(N);
|
|
|
|
Op2.Val->addUser(1, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// If this gets put into a CSE map, add it.
|
2006-08-07 23:03:03 +00:00
|
|
|
if (InsertPos) CSEMap.InsertNode(N, InsertPos);
|
2006-01-28 09:32:45 +00:00
|
|
|
return InN;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::
|
|
|
|
UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2, SDOperand Op3) {
|
2006-08-08 01:09:31 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3 };
|
|
|
|
return UpdateNodeOperands(N, Ops, 3);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand SelectionDAG::
|
|
|
|
UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2,
|
|
|
|
SDOperand Op3, SDOperand Op4) {
|
2006-08-08 01:09:31 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3, Op4 };
|
|
|
|
return UpdateNodeOperands(N, Ops, 4);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
|
|
|
|
2006-01-28 10:09:25 +00:00
|
|
|
SDOperand SelectionDAG::
|
|
|
|
UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2,
|
|
|
|
SDOperand Op3, SDOperand Op4, SDOperand Op5) {
|
2006-08-08 01:09:31 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5 };
|
|
|
|
return UpdateNodeOperands(N, Ops, 5);
|
2006-01-28 10:09:25 +00:00
|
|
|
}
|
|
|
|
|
2006-01-28 09:32:45 +00:00
|
|
|
SDOperand SelectionDAG::
|
2008-07-07 18:26:29 +00:00
|
|
|
UpdateNodeOperands(SDOperand InN, const SDOperand *Ops, unsigned NumOps) {
|
2006-01-28 09:32:45 +00:00
|
|
|
SDNode *N = InN.Val;
|
2006-08-08 01:09:31 +00:00
|
|
|
assert(N->getNumOperands() == NumOps &&
|
2006-01-28 09:32:45 +00:00
|
|
|
"Update with wrong number of operands");
|
|
|
|
|
|
|
|
// Check to see if there is no change.
|
|
|
|
bool AnyChange = false;
|
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
|
|
|
if (Ops[i] != N->getOperand(i)) {
|
|
|
|
AnyChange = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// No operands changed, just return the input node.
|
|
|
|
if (!AnyChange) return InN;
|
|
|
|
|
|
|
|
// See if the modified node already exists.
|
2006-08-07 23:03:03 +00:00
|
|
|
void *InsertPos = 0;
|
2006-08-08 01:09:31 +00:00
|
|
|
if (SDNode *Existing = FindModifiedNodeSlot(N, Ops, NumOps, InsertPos))
|
2006-08-07 23:03:03 +00:00
|
|
|
return SDOperand(Existing, InN.ResNo);
|
2006-01-28 09:32:45 +00:00
|
|
|
|
2008-05-02 00:05:03 +00:00
|
|
|
// Nope it doesn't. Remove the node from its current place in the maps.
|
2006-08-07 23:03:03 +00:00
|
|
|
if (InsertPos)
|
2006-01-28 09:32:45 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
|
|
|
|
|
|
|
// Now we update the operands.
|
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
|
|
|
if (N->OperandList[i] != Ops[i]) {
|
2008-04-16 16:15:27 +00:00
|
|
|
N->OperandList[i].getVal()->removeUser(i, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
N->OperandList[i] = Ops[i];
|
2008-04-07 10:06:32 +00:00
|
|
|
N->OperandList[i].setUser(N);
|
|
|
|
Ops[i].Val->addUser(i, N);
|
2006-01-28 09:32:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this gets put into a CSE map, add it.
|
2006-08-07 23:03:03 +00:00
|
|
|
if (InsertPos) CSEMap.InsertNode(N, InsertPos);
|
2006-01-28 09:32:45 +00:00
|
|
|
return InN;
|
|
|
|
}
|
|
|
|
|
2008-07-07 20:57:48 +00:00
|
|
|
/// DropOperands - Release the operands and set this node to have
|
2008-07-17 19:10:17 +00:00
|
|
|
/// zero operands.
|
2008-07-07 20:57:48 +00:00
|
|
|
void SDNode::DropOperands() {
|
|
|
|
// Unlike the code in MorphNodeTo that does this, we don't need to
|
|
|
|
// watch for dead nodes here.
|
|
|
|
for (op_iterator I = op_begin(), E = op_end(); I != E; ++I)
|
|
|
|
I->getVal()->removeUser(std::distance(op_begin(), I), this);
|
|
|
|
|
|
|
|
NumOperands = 0;
|
2007-02-04 02:49:29 +00:00
|
|
|
}
|
2005-08-16 18:17:10 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
/// SelectNodeTo - These are wrappers around MorphNodeTo that accept a
|
|
|
|
/// machine opcode.
|
2005-12-01 18:00:57 +00:00
|
|
|
///
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, 0, 0);
|
2005-08-24 23:00:29 +00:00
|
|
|
}
|
2005-11-19 01:44:53 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT, SDOperand Op1) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2007-02-04 07:28:00 +00:00
|
|
|
SDOperand Ops[] = { Op1 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, 1);
|
2005-08-16 18:17:10 +00:00
|
|
|
}
|
2005-11-19 01:44:53 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT, SDOperand Op1,
|
2006-08-26 08:00:10 +00:00
|
|
|
SDOperand Op2) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2007-02-04 07:28:00 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, 2);
|
2005-08-16 18:17:10 +00:00
|
|
|
}
|
2005-11-19 01:44:53 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT, SDOperand Op1,
|
2006-08-26 08:00:10 +00:00
|
|
|
SDOperand Op2, SDOperand Op3) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2007-02-04 07:28:00 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, 3);
|
2005-08-21 19:48:59 +00:00
|
|
|
}
|
2005-11-19 01:44:53 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-07-07 18:26:29 +00:00
|
|
|
MVT VT, const SDOperand *Ops,
|
2006-08-27 08:08:54 +00:00
|
|
|
unsigned NumOps) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT);
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, NumOps);
|
2008-07-02 23:23:19 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-07-07 18:26:29 +00:00
|
|
|
MVT VT1, MVT VT2, const SDOperand *Ops,
|
2008-07-02 23:23:19 +00:00
|
|
|
unsigned NumOps) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, NumOps);
|
2008-07-02 23:23:19 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-07-02 23:23:19 +00:00
|
|
|
MVT VT1, MVT VT2) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, (SDOperand *)0, 0);
|
2008-07-02 23:23:19 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-07-07 18:26:29 +00:00
|
|
|
MVT VT1, MVT VT2, MVT VT3,
|
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2008-07-02 23:23:19 +00:00
|
|
|
SDVTList VTs = getVTList(VT1, VT2, VT3);
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, NumOps);
|
2008-07-02 23:23:19 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-07-02 23:23:19 +00:00
|
|
|
MVT VT1, MVT VT2,
|
|
|
|
SDOperand Op1) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
|
|
|
SDOperand Ops[] = { Op1 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, 1);
|
2006-01-23 21:51:14 +00:00
|
|
|
}
|
2006-01-23 20:59:12 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT1, MVT VT2,
|
2006-08-26 08:00:10 +00:00
|
|
|
SDOperand Op1, SDOperand Op2) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
2007-02-04 07:28:00 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, 2);
|
2005-11-19 01:44:53 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT1, MVT VT2,
|
2006-08-26 08:00:10 +00:00
|
|
|
SDOperand Op1, SDOperand Op2,
|
|
|
|
SDOperand Op3) {
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
2007-02-04 07:28:00 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return SelectNodeTo(N, MachineOpc, VTs, Ops, 3);
|
2008-07-02 23:23:19 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
|
2008-07-07 18:26:29 +00:00
|
|
|
SDVTList VTs, const SDOperand *Ops,
|
2008-07-02 23:23:19 +00:00
|
|
|
unsigned NumOps) {
|
2008-07-17 19:10:17 +00:00
|
|
|
return MorphNodeTo(N, ~MachineOpc, VTs, Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT) {
|
|
|
|
SDVTList VTs = getVTList(VT);
|
|
|
|
return MorphNodeTo(N, Opc, VTs, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT, SDOperand Op1) {
|
|
|
|
SDVTList VTs = getVTList(VT);
|
|
|
|
SDOperand Ops[] = { Op1 };
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT, SDOperand Op1,
|
|
|
|
SDOperand Op2) {
|
|
|
|
SDVTList VTs = getVTList(VT);
|
|
|
|
SDOperand Ops[] = { Op1, Op2 };
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT, SDOperand Op1,
|
|
|
|
SDOperand Op2, SDOperand Op3) {
|
|
|
|
SDVTList VTs = getVTList(VT);
|
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3 };
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT, const SDOperand *Ops,
|
|
|
|
unsigned NumOps) {
|
|
|
|
SDVTList VTs = getVTList(VT);
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT1, MVT VT2, const SDOperand *Ops,
|
|
|
|
unsigned NumOps) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT1, MVT VT2) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
|
|
|
return MorphNodeTo(N, Opc, VTs, (SDOperand *)0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT1, MVT VT2, MVT VT3,
|
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2, VT3);
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, NumOps);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT1, MVT VT2,
|
|
|
|
SDOperand Op1) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
|
|
|
SDOperand Ops[] = { Op1 };
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT1, MVT VT2,
|
|
|
|
SDOperand Op1, SDOperand Op2) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
|
|
|
SDOperand Ops[] = { Op1, Op2 };
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
MVT VT1, MVT VT2,
|
|
|
|
SDOperand Op1, SDOperand Op2,
|
|
|
|
SDOperand Op3) {
|
|
|
|
SDVTList VTs = getVTList(VT1, VT2);
|
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3 };
|
|
|
|
return MorphNodeTo(N, Opc, VTs, Ops, 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// MorphNodeTo - These *mutate* the specified node to have the specified
|
|
|
|
/// return type, opcode, and operands.
|
|
|
|
///
|
|
|
|
/// Note that MorphNodeTo returns the resultant node. If there is already a
|
|
|
|
/// node of the specified opcode and operands, it returns that node instead of
|
|
|
|
/// the current one.
|
|
|
|
///
|
|
|
|
/// Using MorphNodeTo is faster than creating a new node and swapping it in
|
|
|
|
/// with ReplaceAllUsesWith both because it often avoids allocating a new
|
|
|
|
/// node, and because it doesn't require CSE recalulation for any of
|
|
|
|
/// the node's users.
|
|
|
|
///
|
|
|
|
SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
|
|
|
SDVTList VTs, const SDOperand *Ops,
|
|
|
|
unsigned NumOps) {
|
2008-07-02 23:23:19 +00:00
|
|
|
// If an identical node already exists, use it.
|
2006-08-07 23:03:03 +00:00
|
|
|
void *IP = 0;
|
2008-07-17 19:10:17 +00:00
|
|
|
if (VTs.VTs[VTs.NumVTs-1] != MVT::Flag) {
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
AddNodeIDNode(ID, Opc, VTs, Ops, NumOps);
|
|
|
|
if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return ON;
|
|
|
|
}
|
2005-12-01 18:00:57 +00:00
|
|
|
|
2005-08-21 22:30:30 +00:00
|
|
|
RemoveNodeFromCSEMaps(N);
|
2007-02-04 02:32:44 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
// Start the morphing.
|
|
|
|
N->NodeType = Opc;
|
|
|
|
N->ValueList = VTs.VTs;
|
|
|
|
N->NumValues = VTs.NumVTs;
|
|
|
|
|
|
|
|
// Clear the operands list, updating used nodes to remove this from their
|
|
|
|
// use list. Keep track of any operands that become dead as a result.
|
|
|
|
SmallPtrSet<SDNode*, 16> DeadNodeSet;
|
|
|
|
for (SDNode::op_iterator B = N->op_begin(), I = B, E = N->op_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
SDNode *Used = I->getVal();
|
|
|
|
Used->removeUser(std::distance(B, I), N);
|
|
|
|
if (Used->use_empty())
|
|
|
|
DeadNodeSet.insert(Used);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If NumOps is larger than the # of operands we currently have, reallocate
|
|
|
|
// the operand list.
|
|
|
|
if (NumOps > N->NumOperands) {
|
|
|
|
if (N->OperandsNeedDelete)
|
|
|
|
delete[] N->OperandList;
|
|
|
|
if (N->isMachineOpcode()) {
|
|
|
|
// We're creating a final node that will live unmorphed for the
|
|
|
|
// remainder of this SelectionDAG's duration, so we can allocate the
|
|
|
|
// operands directly out of the pool with no recycling metadata.
|
|
|
|
N->OperandList = Allocator.Allocate<SDUse>(NumOps);
|
|
|
|
N->OperandsNeedDelete = false;
|
|
|
|
} else {
|
|
|
|
N->OperandList = new SDUse[NumOps];
|
|
|
|
N->OperandsNeedDelete = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Assign the new operands.
|
|
|
|
N->NumOperands = NumOps;
|
|
|
|
for (unsigned i = 0, e = NumOps; i != e; ++i) {
|
|
|
|
N->OperandList[i] = Ops[i];
|
|
|
|
N->OperandList[i].setUser(N);
|
|
|
|
SDNode *ToUse = N->OperandList[i].getVal();
|
|
|
|
ToUse->addUser(i, N);
|
|
|
|
DeadNodeSet.erase(ToUse);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete any nodes that are still dead after adding the uses for the
|
|
|
|
// new operands.
|
2008-07-07 20:57:48 +00:00
|
|
|
SmallVector<SDNode *, 16> DeadNodes;
|
2008-07-17 19:10:17 +00:00
|
|
|
for (SmallPtrSet<SDNode *, 16>::iterator I = DeadNodeSet.begin(),
|
|
|
|
E = DeadNodeSet.end(); I != E; ++I)
|
|
|
|
if ((*I)->use_empty())
|
|
|
|
DeadNodes.push_back(*I);
|
2008-07-07 20:57:48 +00:00
|
|
|
RemoveDeadNodes(DeadNodes);
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
if (IP)
|
|
|
|
CSEMap.InsertNode(N, IP); // Memoize the new node.
|
2006-08-26 08:00:10 +00:00
|
|
|
return N;
|
2005-08-21 22:30:30 +00:00
|
|
|
}
|
|
|
|
|
2005-08-16 18:17:10 +00:00
|
|
|
|
2006-02-09 07:15:23 +00:00
|
|
|
/// getTargetNode - These are used for target selectors to create a new node
|
|
|
|
/// with specified return type(s), target opcode, and operands.
|
|
|
|
///
|
|
|
|
/// Note that getTargetNode returns the resultant node. If there is already a
|
|
|
|
/// node of the specified opcode and operands, it returns that node instead of
|
|
|
|
/// the current one.
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT) {
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VT).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT, SDOperand Op1) {
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VT, Op1).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT,
|
2006-02-09 07:15:23 +00:00
|
|
|
SDOperand Op1, SDOperand Op2) {
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VT, Op1, Op2).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT,
|
2007-02-01 04:55:59 +00:00
|
|
|
SDOperand Op1, SDOperand Op2,
|
|
|
|
SDOperand Op3) {
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VT, Op1, Op2, Op3).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VT, Ops, NumOps).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT VT2) {
|
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2);
|
2007-10-10 01:01:31 +00:00
|
|
|
SDOperand Op;
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 2, &Op, 0).Val;
|
2007-10-10 01:01:31 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
|
|
|
|
MVT VT2, SDOperand Op1) {
|
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2);
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 2, &Op1, 1).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
|
|
|
|
MVT VT2, SDOperand Op1,
|
2006-08-07 23:03:03 +00:00
|
|
|
SDOperand Op2) {
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2);
|
2006-08-08 02:23:42 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 2, Ops, 2).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
|
|
|
|
MVT VT2, SDOperand Op1,
|
2006-08-07 23:03:03 +00:00
|
|
|
SDOperand Op2, SDOperand Op3) {
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2);
|
2006-08-08 02:23:42 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 2, Ops, 3).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT VT2,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2);
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 2, Ops, NumOps).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3,
|
2006-02-09 07:15:23 +00:00
|
|
|
SDOperand Op1, SDOperand Op2) {
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
|
2006-08-08 02:23:42 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 3, Ops, 2).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3,
|
2007-04-20 21:38:10 +00:00
|
|
|
SDOperand Op1, SDOperand Op2,
|
|
|
|
SDOperand Op3) {
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
|
2007-04-20 21:38:10 +00:00
|
|
|
SDOperand Ops[] = { Op1, Op2, Op3 };
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 3, Ops, 3).Val;
|
2007-04-20 21:38:10 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 3, Ops, NumOps).Val;
|
2006-02-09 07:15:23 +00:00
|
|
|
}
|
2008-06-06 12:08:01 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
|
|
|
|
MVT VT2, MVT VT3, MVT VT4,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2008-06-06 12:08:01 +00:00
|
|
|
std::vector<MVT> VTList;
|
2007-09-12 23:39:49 +00:00
|
|
|
VTList.push_back(VT1);
|
|
|
|
VTList.push_back(VT2);
|
|
|
|
VTList.push_back(VT3);
|
|
|
|
VTList.push_back(VT4);
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(VTList);
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, 4, Ops, NumOps).Val;
|
2007-09-12 23:39:49 +00:00
|
|
|
}
|
2007-10-05 01:10:49 +00:00
|
|
|
SDNode *SelectionDAG::getTargetNode(unsigned Opcode,
|
2008-07-09 00:00:42 +00:00
|
|
|
const std::vector<MVT> &ResultTys,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *VTs = getNodeValueTypes(ResultTys);
|
2008-07-17 19:10:17 +00:00
|
|
|
return getNode(~Opcode, VTs, ResultTys.size(),
|
2007-10-05 01:10:49 +00:00
|
|
|
Ops, NumOps).Val;
|
|
|
|
}
|
2006-02-09 07:15:23 +00:00
|
|
|
|
2008-03-22 01:55:50 +00:00
|
|
|
/// getNodeIfExists - Get the specified node if it's already available, or
|
|
|
|
/// else return NULL.
|
|
|
|
SDNode *SelectionDAG::getNodeIfExists(unsigned Opcode, SDVTList VTList,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *Ops, unsigned NumOps) {
|
2008-03-22 01:55:50 +00:00
|
|
|
if (VTList.VTs[VTList.NumVTs-1] != MVT::Flag) {
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
|
|
|
|
void *IP = 0;
|
|
|
|
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
|
|
|
return E;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-03 06:49:24 +00:00
|
|
|
|
2006-08-07 22:13:29 +00:00
|
|
|
/// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
|
2005-08-17 19:00:20 +00:00
|
|
|
/// This can cause recursive merging of nodes in the DAG.
|
|
|
|
///
|
2008-02-03 03:35:22 +00:00
|
|
|
/// This version assumes From has a single result value.
|
2005-08-26 18:36:28 +00:00
|
|
|
///
|
2008-02-03 03:35:22 +00:00
|
|
|
void SelectionDAG::ReplaceAllUsesWith(SDOperand FromN, SDOperand To,
|
2008-02-03 06:49:24 +00:00
|
|
|
DAGUpdateListener *UpdateListener) {
|
2008-02-03 03:35:22 +00:00
|
|
|
SDNode *From = FromN.Val;
|
|
|
|
assert(From->getNumValues() == 1 && FromN.ResNo == 0 &&
|
2005-08-26 18:36:28 +00:00
|
|
|
"Cannot replace with this method!");
|
2008-02-03 03:35:22 +00:00
|
|
|
assert(From != To.Val && "Cannot replace uses of with self");
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2005-08-26 18:36:28 +00:00
|
|
|
while (!From->use_empty()) {
|
2008-04-07 10:06:32 +00:00
|
|
|
SDNode::use_iterator UI = From->use_begin();
|
|
|
|
SDNode *U = UI->getUser();
|
|
|
|
|
2005-08-26 18:36:28 +00:00
|
|
|
// This node is about to morph, remove its old self from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(U);
|
2008-04-07 10:06:32 +00:00
|
|
|
int operandNum = 0;
|
|
|
|
for (SDNode::op_iterator I = U->op_begin(), E = U->op_end();
|
|
|
|
I != E; ++I, ++operandNum)
|
2008-04-16 16:15:27 +00:00
|
|
|
if (I->getVal() == From) {
|
2008-04-07 10:06:32 +00:00
|
|
|
From->removeUser(operandNum, U);
|
2008-02-03 03:35:22 +00:00
|
|
|
*I = To;
|
2008-04-07 10:06:32 +00:00
|
|
|
I->setUser(U);
|
|
|
|
To.Val->addUser(operandNum, U);
|
|
|
|
}
|
2005-08-26 18:36:28 +00:00
|
|
|
|
|
|
|
// 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)) {
|
2008-02-03 06:49:24 +00:00
|
|
|
ReplaceAllUsesWith(U, Existing, UpdateListener);
|
|
|
|
// U is now dead. Inform the listener if it exists and delete it.
|
|
|
|
if (UpdateListener)
|
2008-06-11 11:42:12 +00:00
|
|
|
UpdateListener->NodeDeleted(U, Existing);
|
2005-09-07 05:37:01 +00:00
|
|
|
DeleteNodeNotInCSEMaps(U);
|
2008-02-03 06:49:24 +00:00
|
|
|
} else {
|
|
|
|
// If the node doesn't already exist, we updated it. Inform a listener if
|
|
|
|
// it exists.
|
|
|
|
if (UpdateListener)
|
|
|
|
UpdateListener->NodeUpdated(U);
|
2005-09-07 05:37:01 +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 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,
|
2008-02-03 06:49:24 +00:00
|
|
|
DAGUpdateListener *UpdateListener) {
|
2008-07-17 19:10:17 +00:00
|
|
|
assert(From->getVTList().VTs == To->getVTList().VTs &&
|
|
|
|
From->getNumValues() == To->getNumValues() &&
|
2005-08-26 18:36:28 +00:00
|
|
|
"Cannot use this version of ReplaceAllUsesWith!");
|
2008-07-17 19:10:17 +00:00
|
|
|
|
|
|
|
// Handle the trivial case.
|
|
|
|
if (From == To)
|
|
|
|
return;
|
|
|
|
|
2005-08-17 19:00:20 +00:00
|
|
|
while (!From->use_empty()) {
|
2008-04-07 10:06:32 +00:00
|
|
|
SDNode::use_iterator UI = From->use_begin();
|
|
|
|
SDNode *U = UI->getUser();
|
|
|
|
|
2005-08-17 19:00:20 +00:00
|
|
|
// This node is about to morph, remove its old self from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(U);
|
2008-04-07 10:06:32 +00:00
|
|
|
int operandNum = 0;
|
|
|
|
for (SDNode::op_iterator I = U->op_begin(), E = U->op_end();
|
|
|
|
I != E; ++I, ++operandNum)
|
2008-04-16 16:15:27 +00:00
|
|
|
if (I->getVal() == From) {
|
2008-04-07 10:06:32 +00:00
|
|
|
From->removeUser(operandNum, U);
|
2008-04-16 16:15:27 +00:00
|
|
|
I->getVal() = To;
|
2008-04-07 10:06:32 +00:00
|
|
|
To->addUser(operandNum, U);
|
2005-08-17 19:00:20 +00:00
|
|
|
}
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2005-08-17 19:00:20 +00:00
|
|
|
// 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)) {
|
2008-02-03 06:49:24 +00:00
|
|
|
ReplaceAllUsesWith(U, Existing, UpdateListener);
|
|
|
|
// U is now dead. Inform the listener if it exists and delete it.
|
|
|
|
if (UpdateListener)
|
2008-06-11 11:42:12 +00:00
|
|
|
UpdateListener->NodeDeleted(U, Existing);
|
2005-09-07 05:37:01 +00:00
|
|
|
DeleteNodeNotInCSEMaps(U);
|
2008-02-03 06:49:24 +00:00
|
|
|
} else {
|
|
|
|
// If the node doesn't already exist, we updated it. Inform a listener if
|
|
|
|
// it exists.
|
|
|
|
if (UpdateListener)
|
|
|
|
UpdateListener->NodeUpdated(U);
|
2005-09-07 05:37:01 +00:00
|
|
|
}
|
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,
|
2008-07-07 18:26:29 +00:00
|
|
|
const SDOperand *To,
|
2008-02-03 06:49:24 +00:00
|
|
|
DAGUpdateListener *UpdateListener) {
|
2008-02-03 03:35:22 +00:00
|
|
|
if (From->getNumValues() == 1) // Handle the simple case efficiently.
|
2008-02-03 06:49:24 +00:00
|
|
|
return ReplaceAllUsesWith(SDOperand(From, 0), To[0], UpdateListener);
|
2005-08-24 22:44:39 +00:00
|
|
|
|
|
|
|
while (!From->use_empty()) {
|
2008-04-07 10:06:32 +00:00
|
|
|
SDNode::use_iterator UI = From->use_begin();
|
|
|
|
SDNode *U = UI->getUser();
|
|
|
|
|
2005-08-24 22:44:39 +00:00
|
|
|
// This node is about to morph, remove its old self from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(U);
|
2008-04-07 10:06:32 +00:00
|
|
|
int operandNum = 0;
|
|
|
|
for (SDNode::op_iterator I = U->op_begin(), E = U->op_end();
|
|
|
|
I != E; ++I, ++operandNum)
|
2008-04-16 16:15:27 +00:00
|
|
|
if (I->getVal() == From) {
|
|
|
|
const SDOperand &ToOp = To[I->getSDOperand().ResNo];
|
2008-04-07 10:06:32 +00:00
|
|
|
From->removeUser(operandNum, U);
|
2005-11-08 22:07:03 +00:00
|
|
|
*I = ToOp;
|
2008-04-07 10:06:32 +00:00
|
|
|
I->setUser(U);
|
|
|
|
ToOp.Val->addUser(operandNum, U);
|
2005-08-24 22:44:39 +00:00
|
|
|
}
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2005-08-24 22:44:39 +00:00
|
|
|
// 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)) {
|
2008-02-03 06:49:24 +00:00
|
|
|
ReplaceAllUsesWith(U, Existing, UpdateListener);
|
|
|
|
// U is now dead. Inform the listener if it exists and delete it.
|
|
|
|
if (UpdateListener)
|
2008-06-11 11:42:12 +00:00
|
|
|
UpdateListener->NodeDeleted(U, Existing);
|
2005-09-07 05:37:01 +00:00
|
|
|
DeleteNodeNotInCSEMaps(U);
|
2008-02-03 06:49:24 +00:00
|
|
|
} else {
|
|
|
|
// If the node doesn't already exist, we updated it. Inform a listener if
|
|
|
|
// it exists.
|
|
|
|
if (UpdateListener)
|
|
|
|
UpdateListener->NodeUpdated(U);
|
2005-09-07 05:37:01 +00:00
|
|
|
}
|
2005-08-24 22:44:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-17 21:58:01 +00:00
|
|
|
/// ReplaceAllUsesOfValueWith - Replace any uses of From with To, leaving
|
|
|
|
/// uses of other values produced by From.Val alone. The Deleted vector is
|
2008-02-03 06:49:24 +00:00
|
|
|
/// handled the same way as for ReplaceAllUsesWith.
|
2006-02-17 21:58:01 +00:00
|
|
|
void SelectionDAG::ReplaceAllUsesOfValueWith(SDOperand From, SDOperand To,
|
2008-02-03 06:49:24 +00:00
|
|
|
DAGUpdateListener *UpdateListener){
|
2008-07-17 19:10:17 +00:00
|
|
|
// Handle the really simple, really trivial case efficiently.
|
|
|
|
if (From == To) return;
|
|
|
|
|
2006-02-17 21:58:01 +00:00
|
|
|
// Handle the simple, trivial, case efficiently.
|
2008-02-03 03:35:22 +00:00
|
|
|
if (From.Val->getNumValues() == 1) {
|
2008-02-03 06:49:24 +00:00
|
|
|
ReplaceAllUsesWith(From, To, UpdateListener);
|
2006-02-17 21:58:01 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-02-03 06:49:24 +00:00
|
|
|
|
|
|
|
if (From.use_empty()) return;
|
|
|
|
|
2007-02-04 00:14:31 +00:00
|
|
|
// Get all of the users of From.Val. We want these in a nice,
|
|
|
|
// deterministically ordered and uniqued set, so we use a SmallSetVector.
|
2008-04-07 10:06:32 +00:00
|
|
|
SmallSetVector<SDNode*, 16> Users;
|
|
|
|
for (SDNode::use_iterator UI = From.Val->use_begin(),
|
|
|
|
E = From.Val->use_end(); UI != E; ++UI) {
|
|
|
|
SDNode *User = UI->getUser();
|
2008-07-02 23:23:19 +00:00
|
|
|
Users.insert(User);
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
2006-02-17 21:58:01 +00:00
|
|
|
|
|
|
|
while (!Users.empty()) {
|
|
|
|
// We know that this user uses some value of From. If it is the right
|
|
|
|
// value, update it.
|
|
|
|
SDNode *User = Users.back();
|
|
|
|
Users.pop_back();
|
|
|
|
|
One mundane change: Change ReplaceAllUsesOfValueWith to *optionally*
take a deleted nodes vector, instead of requiring it.
One more significant change: Implement the start of a legalizer that
just works on types. This legalizer is designed to run before the
operation legalizer and ensure just that the input dag is transformed
into an output dag whose operand and result types are all legal, even
if the operations on those types are not.
This design/impl has the following advantages:
1. When finished, this will *significantly* reduce the amount of code in
LegalizeDAG.cpp. It will remove all the code related to promotion and
expansion as well as splitting and scalarizing vectors.
2. The new code is very simple, idiomatic, and modular: unlike
LegalizeDAG.cpp, it has no 3000 line long functions. :)
3. The implementation is completely iterative instead of recursive, good
for hacking on large dags without blowing out your stack.
4. The implementation updates nodes in place when possible instead of
deallocating and reallocating the entire graph that points to some
mutated node.
5. The code nicely separates out handling of operations with invalid
results from operations with invalid operands, making some cases
simpler and easier to understand.
6. The new -debug-only=legalize-types option is very very handy :),
allowing you to easily understand what legalize types is doing.
This is not yet done. Until the ifdef added to SelectionDAGISel.cpp is
enabled, this does nothing. However, this code is sufficient to legalize
all of the code in 186.crafty, olden and freebench on an x86 machine. The
biggest issues are:
1. Vectors aren't implemented at all yet
2. SoftFP is a mess, I need to talk to Evan about it.
3. No lowering to libcalls is implemented yet.
4. Various operations are missing etc.
5. There are FIXME's for stuff I hax0r'd out, like softfp.
Hey, at least it is a step in the right direction :). If you'd like to help,
just enable the #ifdef in SelectionDAGISel.cpp and compile code with it. If
this explodes it will tell you what needs to be implemented. Help is
certainly appreciated.
Once this goes in, we can do three things:
1. Add a new pass of dag combine between the "type legalizer" and "operation
legalizer" passes. This will let us catch some long-standing isel issues
that we miss because operation legalization often obfuscates the dag with
target-specific nodes.
2. We can rip out all of the type legalization code from LegalizeDAG.cpp,
making it much smaller and simpler. When that happens we can then
reimplement the core functionality left in it in a much more efficient and
non-recursive way.
3. Once the whole legalizer is non-recursive, we can implement whole-function
selectiondags maybe...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42981 91177308-0d34-0410-b5e6-96231b3b80d8
2007-10-15 06:10:22 +00:00
|
|
|
// Scan for an operand that matches From.
|
2008-04-07 10:06:32 +00:00
|
|
|
SDNode::op_iterator Op = User->op_begin(), E = User->op_end();
|
One mundane change: Change ReplaceAllUsesOfValueWith to *optionally*
take a deleted nodes vector, instead of requiring it.
One more significant change: Implement the start of a legalizer that
just works on types. This legalizer is designed to run before the
operation legalizer and ensure just that the input dag is transformed
into an output dag whose operand and result types are all legal, even
if the operations on those types are not.
This design/impl has the following advantages:
1. When finished, this will *significantly* reduce the amount of code in
LegalizeDAG.cpp. It will remove all the code related to promotion and
expansion as well as splitting and scalarizing vectors.
2. The new code is very simple, idiomatic, and modular: unlike
LegalizeDAG.cpp, it has no 3000 line long functions. :)
3. The implementation is completely iterative instead of recursive, good
for hacking on large dags without blowing out your stack.
4. The implementation updates nodes in place when possible instead of
deallocating and reallocating the entire graph that points to some
mutated node.
5. The code nicely separates out handling of operations with invalid
results from operations with invalid operands, making some cases
simpler and easier to understand.
6. The new -debug-only=legalize-types option is very very handy :),
allowing you to easily understand what legalize types is doing.
This is not yet done. Until the ifdef added to SelectionDAGISel.cpp is
enabled, this does nothing. However, this code is sufficient to legalize
all of the code in 186.crafty, olden and freebench on an x86 machine. The
biggest issues are:
1. Vectors aren't implemented at all yet
2. SoftFP is a mess, I need to talk to Evan about it.
3. No lowering to libcalls is implemented yet.
4. Various operations are missing etc.
5. There are FIXME's for stuff I hax0r'd out, like softfp.
Hey, at least it is a step in the right direction :). If you'd like to help,
just enable the #ifdef in SelectionDAGISel.cpp and compile code with it. If
this explodes it will tell you what needs to be implemented. Help is
certainly appreciated.
Once this goes in, we can do three things:
1. Add a new pass of dag combine between the "type legalizer" and "operation
legalizer" passes. This will let us catch some long-standing isel issues
that we miss because operation legalization often obfuscates the dag with
target-specific nodes.
2. We can rip out all of the type legalization code from LegalizeDAG.cpp,
making it much smaller and simpler. When that happens we can then
reimplement the core functionality left in it in a much more efficient and
non-recursive way.
3. Once the whole legalizer is non-recursive, we can implement whole-function
selectiondags maybe...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42981 91177308-0d34-0410-b5e6-96231b3b80d8
2007-10-15 06:10:22 +00:00
|
|
|
for (; Op != E; ++Op)
|
|
|
|
if (*Op == From) break;
|
|
|
|
|
|
|
|
// If there are no matches, the user must use some other result of From.
|
|
|
|
if (Op == E) continue;
|
|
|
|
|
|
|
|
// Okay, we know this user needs to be updated. Remove its old self
|
|
|
|
// from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(User);
|
|
|
|
|
2008-02-03 06:49:24 +00:00
|
|
|
// Update all operands that match "From" in case there are multiple uses.
|
One mundane change: Change ReplaceAllUsesOfValueWith to *optionally*
take a deleted nodes vector, instead of requiring it.
One more significant change: Implement the start of a legalizer that
just works on types. This legalizer is designed to run before the
operation legalizer and ensure just that the input dag is transformed
into an output dag whose operand and result types are all legal, even
if the operations on those types are not.
This design/impl has the following advantages:
1. When finished, this will *significantly* reduce the amount of code in
LegalizeDAG.cpp. It will remove all the code related to promotion and
expansion as well as splitting and scalarizing vectors.
2. The new code is very simple, idiomatic, and modular: unlike
LegalizeDAG.cpp, it has no 3000 line long functions. :)
3. The implementation is completely iterative instead of recursive, good
for hacking on large dags without blowing out your stack.
4. The implementation updates nodes in place when possible instead of
deallocating and reallocating the entire graph that points to some
mutated node.
5. The code nicely separates out handling of operations with invalid
results from operations with invalid operands, making some cases
simpler and easier to understand.
6. The new -debug-only=legalize-types option is very very handy :),
allowing you to easily understand what legalize types is doing.
This is not yet done. Until the ifdef added to SelectionDAGISel.cpp is
enabled, this does nothing. However, this code is sufficient to legalize
all of the code in 186.crafty, olden and freebench on an x86 machine. The
biggest issues are:
1. Vectors aren't implemented at all yet
2. SoftFP is a mess, I need to talk to Evan about it.
3. No lowering to libcalls is implemented yet.
4. Various operations are missing etc.
5. There are FIXME's for stuff I hax0r'd out, like softfp.
Hey, at least it is a step in the right direction :). If you'd like to help,
just enable the #ifdef in SelectionDAGISel.cpp and compile code with it. If
this explodes it will tell you what needs to be implemented. Help is
certainly appreciated.
Once this goes in, we can do three things:
1. Add a new pass of dag combine between the "type legalizer" and "operation
legalizer" passes. This will let us catch some long-standing isel issues
that we miss because operation legalization often obfuscates the dag with
target-specific nodes.
2. We can rip out all of the type legalization code from LegalizeDAG.cpp,
making it much smaller and simpler. When that happens we can then
reimplement the core functionality left in it in a much more efficient and
non-recursive way.
3. Once the whole legalizer is non-recursive, we can implement whole-function
selectiondags maybe...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42981 91177308-0d34-0410-b5e6-96231b3b80d8
2007-10-15 06:10:22 +00:00
|
|
|
for (; Op != E; ++Op) {
|
2006-02-17 21:58:01 +00:00
|
|
|
if (*Op == From) {
|
2008-04-07 10:06:32 +00:00
|
|
|
From.Val->removeUser(Op-User->op_begin(), User);
|
2008-04-11 09:34:57 +00:00
|
|
|
*Op = To;
|
2008-04-07 10:06:32 +00:00
|
|
|
Op->setUser(User);
|
|
|
|
To.Val->addUser(Op-User->op_begin(), User);
|
2006-02-17 21:58:01 +00:00
|
|
|
}
|
|
|
|
}
|
One mundane change: Change ReplaceAllUsesOfValueWith to *optionally*
take a deleted nodes vector, instead of requiring it.
One more significant change: Implement the start of a legalizer that
just works on types. This legalizer is designed to run before the
operation legalizer and ensure just that the input dag is transformed
into an output dag whose operand and result types are all legal, even
if the operations on those types are not.
This design/impl has the following advantages:
1. When finished, this will *significantly* reduce the amount of code in
LegalizeDAG.cpp. It will remove all the code related to promotion and
expansion as well as splitting and scalarizing vectors.
2. The new code is very simple, idiomatic, and modular: unlike
LegalizeDAG.cpp, it has no 3000 line long functions. :)
3. The implementation is completely iterative instead of recursive, good
for hacking on large dags without blowing out your stack.
4. The implementation updates nodes in place when possible instead of
deallocating and reallocating the entire graph that points to some
mutated node.
5. The code nicely separates out handling of operations with invalid
results from operations with invalid operands, making some cases
simpler and easier to understand.
6. The new -debug-only=legalize-types option is very very handy :),
allowing you to easily understand what legalize types is doing.
This is not yet done. Until the ifdef added to SelectionDAGISel.cpp is
enabled, this does nothing. However, this code is sufficient to legalize
all of the code in 186.crafty, olden and freebench on an x86 machine. The
biggest issues are:
1. Vectors aren't implemented at all yet
2. SoftFP is a mess, I need to talk to Evan about it.
3. No lowering to libcalls is implemented yet.
4. Various operations are missing etc.
5. There are FIXME's for stuff I hax0r'd out, like softfp.
Hey, at least it is a step in the right direction :). If you'd like to help,
just enable the #ifdef in SelectionDAGISel.cpp and compile code with it. If
this explodes it will tell you what needs to be implemented. Help is
certainly appreciated.
Once this goes in, we can do three things:
1. Add a new pass of dag combine between the "type legalizer" and "operation
legalizer" passes. This will let us catch some long-standing isel issues
that we miss because operation legalization often obfuscates the dag with
target-specific nodes.
2. We can rip out all of the type legalization code from LegalizeDAG.cpp,
making it much smaller and simpler. When that happens we can then
reimplement the core functionality left in it in a much more efficient and
non-recursive way.
3. Once the whole legalizer is non-recursive, we can implement whole-function
selectiondags maybe...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42981 91177308-0d34-0410-b5e6-96231b3b80d8
2007-10-15 06:10:22 +00:00
|
|
|
|
|
|
|
// Now that we have modified User, add it back to the CSE maps. If it
|
|
|
|
// already exists there, recursively merge the results together.
|
|
|
|
SDNode *Existing = AddNonLeafNodeToCSEMaps(User);
|
2008-02-03 06:49:24 +00:00
|
|
|
if (!Existing) {
|
|
|
|
if (UpdateListener) UpdateListener->NodeUpdated(User);
|
|
|
|
continue; // Continue on to next user.
|
|
|
|
}
|
One mundane change: Change ReplaceAllUsesOfValueWith to *optionally*
take a deleted nodes vector, instead of requiring it.
One more significant change: Implement the start of a legalizer that
just works on types. This legalizer is designed to run before the
operation legalizer and ensure just that the input dag is transformed
into an output dag whose operand and result types are all legal, even
if the operations on those types are not.
This design/impl has the following advantages:
1. When finished, this will *significantly* reduce the amount of code in
LegalizeDAG.cpp. It will remove all the code related to promotion and
expansion as well as splitting and scalarizing vectors.
2. The new code is very simple, idiomatic, and modular: unlike
LegalizeDAG.cpp, it has no 3000 line long functions. :)
3. The implementation is completely iterative instead of recursive, good
for hacking on large dags without blowing out your stack.
4. The implementation updates nodes in place when possible instead of
deallocating and reallocating the entire graph that points to some
mutated node.
5. The code nicely separates out handling of operations with invalid
results from operations with invalid operands, making some cases
simpler and easier to understand.
6. The new -debug-only=legalize-types option is very very handy :),
allowing you to easily understand what legalize types is doing.
This is not yet done. Until the ifdef added to SelectionDAGISel.cpp is
enabled, this does nothing. However, this code is sufficient to legalize
all of the code in 186.crafty, olden and freebench on an x86 machine. The
biggest issues are:
1. Vectors aren't implemented at all yet
2. SoftFP is a mess, I need to talk to Evan about it.
3. No lowering to libcalls is implemented yet.
4. Various operations are missing etc.
5. There are FIXME's for stuff I hax0r'd out, like softfp.
Hey, at least it is a step in the right direction :). If you'd like to help,
just enable the #ifdef in SelectionDAGISel.cpp and compile code with it. If
this explodes it will tell you what needs to be implemented. Help is
certainly appreciated.
Once this goes in, we can do three things:
1. Add a new pass of dag combine between the "type legalizer" and "operation
legalizer" passes. This will let us catch some long-standing isel issues
that we miss because operation legalization often obfuscates the dag with
target-specific nodes.
2. We can rip out all of the type legalization code from LegalizeDAG.cpp,
making it much smaller and simpler. When that happens we can then
reimplement the core functionality left in it in a much more efficient and
non-recursive way.
3. Once the whole legalizer is non-recursive, we can implement whole-function
selectiondags maybe...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42981 91177308-0d34-0410-b5e6-96231b3b80d8
2007-10-15 06:10:22 +00:00
|
|
|
|
|
|
|
// If there was already an existing matching node, use ReplaceAllUsesWith
|
2008-02-03 06:49:24 +00:00
|
|
|
// to replace the dead one with the existing one. This can cause
|
2008-07-17 19:10:17 +00:00
|
|
|
// recursive merging of other unrelated nodes down the line.
|
|
|
|
ReplaceAllUsesWith(User, Existing, UpdateListener);
|
|
|
|
|
|
|
|
// User is now dead. Notify a listener if present.
|
|
|
|
if (UpdateListener) UpdateListener->NodeDeleted(User, Existing);
|
|
|
|
DeleteNodeNotInCSEMaps(User);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ReplaceAllUsesOfValuesWith - Replace any uses of From with To, leaving
|
|
|
|
/// uses of other values produced by From.Val alone. The same value may
|
|
|
|
/// appear in both the From and To list. The Deleted vector is
|
|
|
|
/// handled the same way as for ReplaceAllUsesWith.
|
|
|
|
void SelectionDAG::ReplaceAllUsesOfValuesWith(const SDOperand *From,
|
|
|
|
const SDOperand *To,
|
|
|
|
unsigned Num,
|
|
|
|
DAGUpdateListener *UpdateListener){
|
|
|
|
// Handle the simple, trivial case efficiently.
|
|
|
|
if (Num == 1)
|
|
|
|
return ReplaceAllUsesOfValueWith(*From, *To, UpdateListener);
|
|
|
|
|
|
|
|
SmallVector<std::pair<SDNode *, unsigned>, 16> Users;
|
|
|
|
for (unsigned i = 0; i != Num; ++i)
|
|
|
|
for (SDNode::use_iterator UI = From[i].Val->use_begin(),
|
|
|
|
E = From[i].Val->use_end(); UI != E; ++UI)
|
|
|
|
Users.push_back(std::make_pair(UI->getUser(), i));
|
|
|
|
|
|
|
|
while (!Users.empty()) {
|
|
|
|
// We know that this user uses some value of From. If it is the right
|
|
|
|
// value, update it.
|
|
|
|
SDNode *User = Users.back().first;
|
|
|
|
unsigned i = Users.back().second;
|
|
|
|
Users.pop_back();
|
|
|
|
|
|
|
|
// Scan for an operand that matches From.
|
|
|
|
SDNode::op_iterator Op = User->op_begin(), E = User->op_end();
|
|
|
|
for (; Op != E; ++Op)
|
|
|
|
if (*Op == From[i]) break;
|
|
|
|
|
|
|
|
// If there are no matches, the user must use some other result of From.
|
|
|
|
if (Op == E) continue;
|
|
|
|
|
|
|
|
// Okay, we know this user needs to be updated. Remove its old self
|
|
|
|
// from the CSE maps.
|
|
|
|
RemoveNodeFromCSEMaps(User);
|
|
|
|
|
|
|
|
// Update all operands that match "From" in case there are multiple uses.
|
|
|
|
for (; Op != E; ++Op) {
|
|
|
|
if (*Op == From[i]) {
|
|
|
|
From[i].Val->removeUser(Op-User->op_begin(), User);
|
|
|
|
*Op = To[i];
|
|
|
|
Op->setUser(User);
|
|
|
|
To[i].Val->addUser(Op-User->op_begin(), User);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we have modified User, add it back to the CSE maps. If it
|
|
|
|
// already exists there, recursively merge the results together.
|
|
|
|
SDNode *Existing = AddNonLeafNodeToCSEMaps(User);
|
|
|
|
if (!Existing) {
|
|
|
|
if (UpdateListener) UpdateListener->NodeUpdated(User);
|
|
|
|
continue; // Continue on to next user.
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there was already an existing matching node, use ReplaceAllUsesWith
|
|
|
|
// to replace the dead one with the existing one. This can cause
|
|
|
|
// recursive merging of other unrelated nodes down the line.
|
|
|
|
ReplaceAllUsesWith(User, Existing, UpdateListener);
|
One mundane change: Change ReplaceAllUsesOfValueWith to *optionally*
take a deleted nodes vector, instead of requiring it.
One more significant change: Implement the start of a legalizer that
just works on types. This legalizer is designed to run before the
operation legalizer and ensure just that the input dag is transformed
into an output dag whose operand and result types are all legal, even
if the operations on those types are not.
This design/impl has the following advantages:
1. When finished, this will *significantly* reduce the amount of code in
LegalizeDAG.cpp. It will remove all the code related to promotion and
expansion as well as splitting and scalarizing vectors.
2. The new code is very simple, idiomatic, and modular: unlike
LegalizeDAG.cpp, it has no 3000 line long functions. :)
3. The implementation is completely iterative instead of recursive, good
for hacking on large dags without blowing out your stack.
4. The implementation updates nodes in place when possible instead of
deallocating and reallocating the entire graph that points to some
mutated node.
5. The code nicely separates out handling of operations with invalid
results from operations with invalid operands, making some cases
simpler and easier to understand.
6. The new -debug-only=legalize-types option is very very handy :),
allowing you to easily understand what legalize types is doing.
This is not yet done. Until the ifdef added to SelectionDAGISel.cpp is
enabled, this does nothing. However, this code is sufficient to legalize
all of the code in 186.crafty, olden and freebench on an x86 machine. The
biggest issues are:
1. Vectors aren't implemented at all yet
2. SoftFP is a mess, I need to talk to Evan about it.
3. No lowering to libcalls is implemented yet.
4. Various operations are missing etc.
5. There are FIXME's for stuff I hax0r'd out, like softfp.
Hey, at least it is a step in the right direction :). If you'd like to help,
just enable the #ifdef in SelectionDAGISel.cpp and compile code with it. If
this explodes it will tell you what needs to be implemented. Help is
certainly appreciated.
Once this goes in, we can do three things:
1. Add a new pass of dag combine between the "type legalizer" and "operation
legalizer" passes. This will let us catch some long-standing isel issues
that we miss because operation legalization often obfuscates the dag with
target-specific nodes.
2. We can rip out all of the type legalization code from LegalizeDAG.cpp,
making it much smaller and simpler. When that happens we can then
reimplement the core functionality left in it in a much more efficient and
non-recursive way.
3. Once the whole legalizer is non-recursive, we can implement whole-function
selectiondags maybe...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42981 91177308-0d34-0410-b5e6-96231b3b80d8
2007-10-15 06:10:22 +00:00
|
|
|
|
2008-02-03 06:49:24 +00:00
|
|
|
// User is now dead. Notify a listener if present.
|
2008-06-11 11:42:12 +00:00
|
|
|
if (UpdateListener) UpdateListener->NodeDeleted(User, Existing);
|
One mundane change: Change ReplaceAllUsesOfValueWith to *optionally*
take a deleted nodes vector, instead of requiring it.
One more significant change: Implement the start of a legalizer that
just works on types. This legalizer is designed to run before the
operation legalizer and ensure just that the input dag is transformed
into an output dag whose operand and result types are all legal, even
if the operations on those types are not.
This design/impl has the following advantages:
1. When finished, this will *significantly* reduce the amount of code in
LegalizeDAG.cpp. It will remove all the code related to promotion and
expansion as well as splitting and scalarizing vectors.
2. The new code is very simple, idiomatic, and modular: unlike
LegalizeDAG.cpp, it has no 3000 line long functions. :)
3. The implementation is completely iterative instead of recursive, good
for hacking on large dags without blowing out your stack.
4. The implementation updates nodes in place when possible instead of
deallocating and reallocating the entire graph that points to some
mutated node.
5. The code nicely separates out handling of operations with invalid
results from operations with invalid operands, making some cases
simpler and easier to understand.
6. The new -debug-only=legalize-types option is very very handy :),
allowing you to easily understand what legalize types is doing.
This is not yet done. Until the ifdef added to SelectionDAGISel.cpp is
enabled, this does nothing. However, this code is sufficient to legalize
all of the code in 186.crafty, olden and freebench on an x86 machine. The
biggest issues are:
1. Vectors aren't implemented at all yet
2. SoftFP is a mess, I need to talk to Evan about it.
3. No lowering to libcalls is implemented yet.
4. Various operations are missing etc.
5. There are FIXME's for stuff I hax0r'd out, like softfp.
Hey, at least it is a step in the right direction :). If you'd like to help,
just enable the #ifdef in SelectionDAGISel.cpp and compile code with it. If
this explodes it will tell you what needs to be implemented. Help is
certainly appreciated.
Once this goes in, we can do three things:
1. Add a new pass of dag combine between the "type legalizer" and "operation
legalizer" passes. This will let us catch some long-standing isel issues
that we miss because operation legalization often obfuscates the dag with
target-specific nodes.
2. We can rip out all of the type legalization code from LegalizeDAG.cpp,
making it much smaller and simpler. When that happens we can then
reimplement the core functionality left in it in a much more efficient and
non-recursive way.
3. Once the whole legalizer is non-recursive, we can implement whole-function
selectiondags maybe...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42981 91177308-0d34-0410-b5e6-96231b3b80d8
2007-10-15 06:10:22 +00:00
|
|
|
DeleteNodeNotInCSEMaps(User);
|
2006-02-17 21:58:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-01 08:20:41 +00:00
|
|
|
/// AssignTopologicalOrder - Assign a unique node id for each node in the DAG
|
2006-08-02 22:00:34 +00:00
|
|
|
/// based on their topological order. It returns the maximum id and a vector
|
|
|
|
/// of the SDNodes* in assigned order by reference.
|
|
|
|
unsigned SelectionDAG::AssignTopologicalOrder(std::vector<SDNode*> &TopOrder) {
|
2006-08-01 08:20:41 +00:00
|
|
|
unsigned DAGSize = AllNodes.size();
|
2006-08-02 22:00:34 +00:00
|
|
|
std::vector<unsigned> InDegree(DAGSize);
|
|
|
|
std::vector<SDNode*> Sources;
|
|
|
|
|
|
|
|
// Use a two pass approach to avoid using a std::map which is slow.
|
|
|
|
unsigned Id = 0;
|
2006-08-01 08:20:41 +00:00
|
|
|
for (allnodes_iterator I = allnodes_begin(),E = allnodes_end(); I != E; ++I){
|
|
|
|
SDNode *N = I;
|
2006-08-02 22:00:34 +00:00
|
|
|
N->setNodeId(Id++);
|
2006-08-01 08:20:41 +00:00
|
|
|
unsigned Degree = N->use_size();
|
2006-08-02 22:00:34 +00:00
|
|
|
InDegree[N->getNodeId()] = Degree;
|
2006-08-01 08:20:41 +00:00
|
|
|
if (Degree == 0)
|
2006-08-02 22:00:34 +00:00
|
|
|
Sources.push_back(N);
|
2006-08-01 08:20:41 +00:00
|
|
|
}
|
|
|
|
|
2006-08-07 22:13:29 +00:00
|
|
|
TopOrder.clear();
|
2008-07-07 23:02:41 +00:00
|
|
|
TopOrder.reserve(DAGSize);
|
2006-08-01 08:20:41 +00:00
|
|
|
while (!Sources.empty()) {
|
2006-08-02 22:00:34 +00:00
|
|
|
SDNode *N = Sources.back();
|
|
|
|
Sources.pop_back();
|
2006-08-01 08:20:41 +00:00
|
|
|
TopOrder.push_back(N);
|
|
|
|
for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I) {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDNode *P = I->getVal();
|
2006-08-02 22:00:34 +00:00
|
|
|
unsigned Degree = --InDegree[P->getNodeId()];
|
2006-08-01 08:20:41 +00:00
|
|
|
if (Degree == 0)
|
|
|
|
Sources.push_back(P);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-02 22:00:34 +00:00
|
|
|
// Second pass, assign the actual topological order as node ids.
|
|
|
|
Id = 0;
|
|
|
|
for (std::vector<SDNode*>::iterator TI = TopOrder.begin(),TE = TopOrder.end();
|
|
|
|
TI != TE; ++TI)
|
|
|
|
(*TI)->setNodeId(Id++);
|
|
|
|
|
|
|
|
return Id;
|
2006-08-01 08:20:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-27 06:39:06 +00:00
|
|
|
|
2005-08-17 20:08:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SDNode Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
2005-08-16 18:17:10 +00:00
|
|
|
|
2006-07-19 00:00:37 +00:00
|
|
|
// Out-of-line virtual method to give class a home.
|
2007-02-04 02:23:32 +00:00
|
|
|
void SDNode::ANCHOR() {}
|
2007-02-04 08:35:21 +00:00
|
|
|
void UnarySDNode::ANCHOR() {}
|
|
|
|
void BinarySDNode::ANCHOR() {}
|
|
|
|
void TernarySDNode::ANCHOR() {}
|
2007-02-04 02:23:32 +00:00
|
|
|
void HandleSDNode::ANCHOR() {}
|
|
|
|
void ConstantSDNode::ANCHOR() {}
|
|
|
|
void ConstantFPSDNode::ANCHOR() {}
|
|
|
|
void GlobalAddressSDNode::ANCHOR() {}
|
|
|
|
void FrameIndexSDNode::ANCHOR() {}
|
|
|
|
void JumpTableSDNode::ANCHOR() {}
|
|
|
|
void ConstantPoolSDNode::ANCHOR() {}
|
|
|
|
void BasicBlockSDNode::ANCHOR() {}
|
|
|
|
void SrcValueSDNode::ANCHOR() {}
|
2008-02-06 22:27:42 +00:00
|
|
|
void MemOperandSDNode::ANCHOR() {}
|
2007-02-04 02:23:32 +00:00
|
|
|
void RegisterSDNode::ANCHOR() {}
|
2008-06-30 20:59:49 +00:00
|
|
|
void DbgStopPointSDNode::ANCHOR() {}
|
2008-07-01 00:05:16 +00:00
|
|
|
void LabelSDNode::ANCHOR() {}
|
2007-02-04 02:23:32 +00:00
|
|
|
void ExternalSymbolSDNode::ANCHOR() {}
|
|
|
|
void CondCodeSDNode::ANCHOR() {}
|
2008-03-21 09:14:45 +00:00
|
|
|
void ARG_FLAGSSDNode::ANCHOR() {}
|
2007-02-04 02:23:32 +00:00
|
|
|
void VTSDNode::ANCHOR() {}
|
2008-06-25 08:15:39 +00:00
|
|
|
void MemSDNode::ANCHOR() {}
|
2007-02-04 02:23:32 +00:00
|
|
|
void LoadSDNode::ANCHOR() {}
|
|
|
|
void StoreSDNode::ANCHOR() {}
|
2008-02-21 06:45:13 +00:00
|
|
|
void AtomicSDNode::ANCHOR() {}
|
2006-07-19 00:00:37 +00:00
|
|
|
|
2007-02-04 02:41:42 +00:00
|
|
|
HandleSDNode::~HandleSDNode() {
|
2008-07-07 20:57:48 +00:00
|
|
|
DropOperands();
|
2007-02-04 02:41:42 +00:00
|
|
|
}
|
|
|
|
|
2007-04-21 20:56:26 +00:00
|
|
|
GlobalAddressSDNode::GlobalAddressSDNode(bool isTarget, const GlobalValue *GA,
|
2008-06-06 12:08:01 +00:00
|
|
|
MVT VT, int o)
|
2007-04-21 20:56:26 +00:00
|
|
|
: SDNode(isa<GlobalVariable>(GA) &&
|
2007-07-23 20:24:29 +00:00
|
|
|
cast<GlobalVariable>(GA)->isThreadLocal() ?
|
2007-04-21 20:56:26 +00:00
|
|
|
// Thread Local
|
|
|
|
(isTarget ? ISD::TargetGlobalTLSAddress : ISD::GlobalTLSAddress) :
|
|
|
|
// Non Thread Local
|
|
|
|
(isTarget ? ISD::TargetGlobalAddress : ISD::GlobalAddress),
|
|
|
|
getSDVTList(VT)), Offset(o) {
|
|
|
|
TheGlobal = const_cast<GlobalValue*>(GA);
|
|
|
|
}
|
2007-02-04 02:41:42 +00:00
|
|
|
|
2008-07-09 22:08:04 +00:00
|
|
|
MemSDNode::MemSDNode(unsigned Opc, SDVTList VTs, MVT memvt,
|
2008-07-09 21:23:02 +00:00
|
|
|
const Value *srcValue, int SVO,
|
|
|
|
unsigned alignment, bool vol)
|
2008-07-09 22:08:04 +00:00
|
|
|
: SDNode(Opc, VTs), MemoryVT(memvt), SrcValue(srcValue), SVOffset(SVO),
|
2008-07-09 21:23:02 +00:00
|
|
|
Flags(vol | ((Log2_32(alignment) + 1) << 1)) {
|
|
|
|
|
|
|
|
assert(isPowerOf2_32(alignment) && "Alignment is not a power of 2!");
|
|
|
|
assert(getAlignment() == alignment && "Alignment representation error!");
|
|
|
|
assert(isVolatile() == vol && "Volatile representation error!");
|
|
|
|
}
|
|
|
|
|
2008-06-25 08:15:39 +00:00
|
|
|
/// getMemOperand - Return a MachineMemOperand object describing the memory
|
2008-07-09 22:08:04 +00:00
|
|
|
/// reference performed by this memory reference.
|
|
|
|
MachineMemOperand MemSDNode::getMemOperand() const {
|
|
|
|
int Flags;
|
|
|
|
if (isa<LoadSDNode>(this))
|
|
|
|
Flags = MachineMemOperand::MOLoad;
|
|
|
|
else if (isa<StoreSDNode>(this))
|
|
|
|
Flags = MachineMemOperand::MOStore;
|
|
|
|
else {
|
|
|
|
assert(isa<AtomicSDNode>(this) && "Unknown MemSDNode opcode!");
|
|
|
|
Flags = MachineMemOperand::MOLoad | MachineMemOperand::MOStore;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Size = (getMemoryVT().getSizeInBits() + 7) >> 3;
|
2008-06-25 08:15:39 +00:00
|
|
|
if (isVolatile()) Flags |= MachineMemOperand::MOVolatile;
|
|
|
|
|
2008-07-09 22:08:04 +00:00
|
|
|
// Check if the memory reference references a frame index
|
2008-06-25 08:15:39 +00:00
|
|
|
const FrameIndexSDNode *FI =
|
|
|
|
dyn_cast<const FrameIndexSDNode>(getBasePtr().Val);
|
|
|
|
if (!getSrcValue() && FI)
|
2008-07-11 22:44:52 +00:00
|
|
|
return MachineMemOperand(PseudoSourceValue::getFixedStack(FI->getIndex()),
|
|
|
|
Flags, 0, Size, getAlignment());
|
2008-06-25 08:15:39 +00:00
|
|
|
else
|
|
|
|
return MachineMemOperand(getSrcValue(), Flags, getSrcValueOffset(),
|
|
|
|
Size, getAlignment());
|
|
|
|
}
|
|
|
|
|
2006-10-27 23:46:08 +00:00
|
|
|
/// Profile - Gather unique data for the node.
|
|
|
|
///
|
|
|
|
void SDNode::Profile(FoldingSetNodeID &ID) {
|
|
|
|
AddNodeIDNode(ID, this);
|
|
|
|
}
|
|
|
|
|
2005-11-08 23:30:28 +00:00
|
|
|
/// getValueTypeList - Return a pointer to the specified value type.
|
|
|
|
///
|
2008-06-06 12:08:01 +00:00
|
|
|
const MVT *SDNode::getValueTypeList(MVT VT) {
|
|
|
|
if (VT.isExtended()) {
|
2008-06-08 20:54:56 +00:00
|
|
|
static std::set<MVT, MVT::compareRawBits> EVTs;
|
2008-02-08 03:26:46 +00:00
|
|
|
return &(*EVTs.insert(VT).first);
|
2007-10-16 09:56:48 +00:00
|
|
|
} else {
|
2008-06-06 12:08:01 +00:00
|
|
|
static MVT VTs[MVT::LAST_VALUETYPE];
|
|
|
|
VTs[VT.getSimpleVT()] = VT;
|
|
|
|
return &VTs[VT.getSimpleVT()];
|
2007-10-16 09:56:48 +00:00
|
|
|
}
|
2005-11-08 23:30:28 +00:00
|
|
|
}
|
2007-10-16 09:56:48 +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.
|
2006-02-05 06:29:23 +00:00
|
|
|
bool SDNode::hasNUsesOfValue(unsigned NUses, unsigned Value) const {
|
2005-01-12 18:37:47 +00:00
|
|
|
assert(Value < getNumValues() && "Bad value!");
|
|
|
|
|
2008-04-07 10:06:32 +00:00
|
|
|
// TODO: Only iterate over uses of a given value of the node
|
|
|
|
for (SDNode::use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) {
|
2008-07-09 23:03:14 +00:00
|
|
|
if (UI->getSDOperand().ResNo == Value) {
|
2008-04-07 10:06:32 +00:00
|
|
|
if (NUses == 0)
|
|
|
|
return false;
|
|
|
|
--NUses;
|
|
|
|
}
|
2005-01-12 18:37:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Found exactly the right number of uses?
|
|
|
|
return NUses == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-02 05:29:38 +00:00
|
|
|
/// hasAnyUseOfValue - Return true if there are any use of the indicated
|
|
|
|
/// value. This method ignores uses of other values defined by this operation.
|
|
|
|
bool SDNode::hasAnyUseOfValue(unsigned Value) const {
|
|
|
|
assert(Value < getNumValues() && "Bad value!");
|
|
|
|
|
2008-07-09 22:39:01 +00:00
|
|
|
for (SDNode::use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI)
|
2008-07-09 23:03:14 +00:00
|
|
|
if (UI->getSDOperand().ResNo == Value)
|
2008-07-09 22:39:01 +00:00
|
|
|
return true;
|
2007-08-02 05:29:38 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-04 00:41:45 +00:00
|
|
|
/// isOnlyUseOf - Return true if this node is the only use of N.
|
2006-11-03 07:31:32 +00:00
|
|
|
///
|
2008-03-04 00:41:45 +00:00
|
|
|
bool SDNode::isOnlyUseOf(SDNode *N) const {
|
2006-02-05 06:29:23 +00:00
|
|
|
bool Seen = false;
|
|
|
|
for (SDNode::use_iterator I = N->use_begin(), E = N->use_end(); I != E; ++I) {
|
2008-04-07 10:06:32 +00:00
|
|
|
SDNode *User = I->getUser();
|
2006-02-05 06:29:23 +00:00
|
|
|
if (User == this)
|
|
|
|
Seen = true;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Seen;
|
|
|
|
}
|
|
|
|
|
2006-11-03 07:31:32 +00:00
|
|
|
/// isOperand - Return true if this node is an operand of N.
|
|
|
|
///
|
2008-04-16 16:15:27 +00:00
|
|
|
bool SDOperand::isOperandOf(SDNode *N) const {
|
2006-03-03 06:42:32 +00:00
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
|
|
|
|
if (*this == N->getOperand(i))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-03-04 00:41:45 +00:00
|
|
|
bool SDNode::isOperandOf(SDNode *N) const {
|
2006-03-03 06:24:54 +00:00
|
|
|
for (unsigned i = 0, e = N->NumOperands; i != e; ++i)
|
2008-04-16 16:15:27 +00:00
|
|
|
if (this == N->OperandList[i].getVal())
|
2006-03-03 06:24:54 +00:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2006-02-05 06:29:23 +00:00
|
|
|
|
2008-01-16 05:49:24 +00:00
|
|
|
/// reachesChainWithoutSideEffects - Return true if this operand (which must
|
|
|
|
/// be a chain) reaches the specified operand without crossing any
|
|
|
|
/// side-effecting instructions. In practice, this looks through token
|
|
|
|
/// factors and non-volatile loads. In order to remain efficient, this only
|
|
|
|
/// looks a couple of nodes in, it does not do an exhaustive search.
|
2008-04-16 16:15:27 +00:00
|
|
|
bool SDOperand::reachesChainWithoutSideEffects(SDOperand Dest,
|
2008-01-16 05:49:24 +00:00
|
|
|
unsigned Depth) const {
|
|
|
|
if (*this == Dest) return true;
|
|
|
|
|
|
|
|
// Don't search too deeply, we just want to be able to see through
|
|
|
|
// TokenFactor's etc.
|
|
|
|
if (Depth == 0) return false;
|
|
|
|
|
|
|
|
// If this is a token factor, all inputs to the TF happen in parallel. If any
|
|
|
|
// of the operands of the TF reach dest, then we can do the xform.
|
|
|
|
if (getOpcode() == ISD::TokenFactor) {
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
|
|
|
if (getOperand(i).reachesChainWithoutSideEffects(Dest, Depth-1))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Loads don't have side effects, look through them.
|
|
|
|
if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(*this)) {
|
|
|
|
if (!Ld->isVolatile())
|
|
|
|
return Ld->getChain().reachesChainWithoutSideEffects(Dest, Depth-1);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-03 03:05:24 +00:00
|
|
|
static void findPredecessor(SDNode *N, const SDNode *P, bool &found,
|
2007-02-04 00:24:41 +00:00
|
|
|
SmallPtrSet<SDNode *, 32> &Visited) {
|
|
|
|
if (found || !Visited.insert(N))
|
2006-11-03 03:05:24 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); !found && i != e; ++i) {
|
|
|
|
SDNode *Op = N->getOperand(i).Val;
|
|
|
|
if (Op == P) {
|
|
|
|
found = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
findPredecessor(Op, P, found, Visited);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-04 00:41:45 +00:00
|
|
|
/// isPredecessorOf - Return true if this node is a predecessor of N. This node
|
2006-11-03 07:31:32 +00:00
|
|
|
/// is either an operand of N or it can be reached by recursively traversing
|
|
|
|
/// up the operands.
|
|
|
|
/// NOTE: this is an expensive method. Use it carefully.
|
2008-03-04 00:41:45 +00:00
|
|
|
bool SDNode::isPredecessorOf(SDNode *N) const {
|
2007-02-04 00:24:41 +00:00
|
|
|
SmallPtrSet<SDNode *, 32> Visited;
|
2006-11-03 03:05:24 +00:00
|
|
|
bool found = false;
|
|
|
|
findPredecessor(N, this, found, Visited);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2006-10-04 00:56:09 +00:00
|
|
|
uint64_t SDNode::getConstantOperandVal(unsigned Num) const {
|
|
|
|
assert(Num < NumOperands && "Invalid child # of SDNode!");
|
|
|
|
return cast<ConstantSDNode>(OperandList[Num])->getValue();
|
|
|
|
}
|
|
|
|
|
2007-04-01 07:32:19 +00:00
|
|
|
std::string 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>>";
|
2008-07-17 19:10:17 +00:00
|
|
|
if (isMachineOpcode()) {
|
|
|
|
if (G)
|
2005-08-16 18:33:07 +00:00
|
|
|
if (const TargetInstrInfo *TII = G->getTarget().getInstrInfo())
|
2008-07-17 19:10:17 +00:00
|
|
|
if (getMachineOpcode() < TII->getNumOpcodes())
|
|
|
|
return TII->get(getMachineOpcode()).getName();
|
|
|
|
return "<<Unknown Machine Node>>";
|
|
|
|
}
|
|
|
|
if (G) {
|
|
|
|
TargetLowering &TLI = G->getTargetLoweringInfo();
|
|
|
|
const char *Name = TLI.getTargetNodeName(getOpcode());
|
|
|
|
if (Name) return Name;
|
2005-12-20 06:22:03 +00:00
|
|
|
return "<<Unknown Target Node>>";
|
2005-08-16 18:33:07 +00:00
|
|
|
}
|
2008-07-17 19:10:17 +00:00
|
|
|
return "<<Unknown Node>>";
|
2005-08-16 18:33:07 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
case ISD::DELETED_NODE:
|
|
|
|
return "<<Deleted Node!>>";
|
|
|
|
#endif
|
2008-03-08 00:58:38 +00:00
|
|
|
case ISD::PREFETCH: return "Prefetch";
|
2008-02-16 01:24:58 +00:00
|
|
|
case ISD::MEMBARRIER: return "MemBarrier";
|
2008-06-25 08:15:39 +00:00
|
|
|
case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";
|
|
|
|
case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";
|
|
|
|
case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";
|
2008-05-05 19:05:59 +00:00
|
|
|
case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";
|
|
|
|
case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";
|
|
|
|
case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";
|
2008-06-14 05:48:15 +00:00
|
|
|
case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";
|
2008-05-05 19:05:59 +00:00
|
|
|
case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";
|
|
|
|
case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";
|
|
|
|
case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";
|
|
|
|
case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";
|
|
|
|
case ISD::ATOMIC_SWAP: return "AtomicSWAP";
|
2005-03-31 21:24:06 +00:00
|
|
|
case ISD::PCMARKER: return "PCMarker";
|
2005-11-11 16:47:30 +00:00
|
|
|
case ISD::READCYCLECOUNTER: return "ReadCycleCounter";
|
2005-05-09 04:08:27 +00:00
|
|
|
case ISD::SRCVALUE: return "SrcValue";
|
2008-02-06 22:27:42 +00:00
|
|
|
case ISD::MEMOPERAND: return "MemOperand";
|
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";
|
2006-03-01 00:51:13 +00:00
|
|
|
|
|
|
|
case ISD::BasicBlock: return "BasicBlock";
|
2008-03-21 09:14:45 +00:00
|
|
|
case ISD::ARG_FLAGS: return "ArgFlags";
|
2006-03-01 00:51:13 +00:00
|
|
|
case ISD::VALUETYPE: return "ValueType";
|
|
|
|
case ISD::Register: return "Register";
|
|
|
|
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::Constant: return "Constant";
|
|
|
|
case ISD::ConstantFP: return "ConstantFP";
|
|
|
|
case ISD::GlobalAddress: return "GlobalAddress";
|
2007-04-20 21:38:10 +00:00
|
|
|
case ISD::GlobalTLSAddress: return "GlobalTLSAddress";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::FrameIndex: return "FrameIndex";
|
2006-04-22 18:53:45 +00:00
|
|
|
case ISD::JumpTable: return "JumpTable";
|
2006-10-11 04:29:42 +00:00
|
|
|
case ISD::GLOBAL_OFFSET_TABLE: return "GLOBAL_OFFSET_TABLE";
|
2007-01-29 22:58:52 +00:00
|
|
|
case ISD::RETURNADDR: return "RETURNADDR";
|
|
|
|
case ISD::FRAMEADDR: return "FRAMEADDR";
|
2007-07-14 14:06:15 +00:00
|
|
|
case ISD::FRAME_TO_ARGS_OFFSET: return "FRAME_TO_ARGS_OFFSET";
|
2007-02-21 22:53:45 +00:00
|
|
|
case ISD::EXCEPTIONADDR: return "EXCEPTIONADDR";
|
|
|
|
case ISD::EHSELECTION: return "EHSELECTION";
|
2007-07-14 14:06:15 +00:00
|
|
|
case ISD::EH_RETURN: return "EH_RETURN";
|
2005-08-26 17:15:30 +00:00
|
|
|
case ISD::ConstantPool: return "ConstantPool";
|
2006-03-01 00:51:13 +00:00
|
|
|
case ISD::ExternalSymbol: return "ExternalSymbol";
|
2006-03-28 00:40:33 +00:00
|
|
|
case ISD::INTRINSIC_WO_CHAIN: {
|
|
|
|
unsigned IID = cast<ConstantSDNode>(getOperand(0))->getValue();
|
|
|
|
return Intrinsic::getName((Intrinsic::ID)IID);
|
|
|
|
}
|
|
|
|
case ISD::INTRINSIC_VOID:
|
|
|
|
case ISD::INTRINSIC_W_CHAIN: {
|
|
|
|
unsigned IID = cast<ConstantSDNode>(getOperand(1))->getValue();
|
2006-03-27 06:45:25 +00:00
|
|
|
return Intrinsic::getName((Intrinsic::ID)IID);
|
2006-03-27 16:10:59 +00:00
|
|
|
}
|
2006-03-01 00:51:13 +00:00
|
|
|
|
2006-03-19 00:52:58 +00:00
|
|
|
case ISD::BUILD_VECTOR: return "BUILD_VECTOR";
|
2006-03-01 00:51:13 +00:00
|
|
|
case ISD::TargetConstant: return "TargetConstant";
|
|
|
|
case ISD::TargetConstantFP:return "TargetConstantFP";
|
|
|
|
case ISD::TargetGlobalAddress: return "TargetGlobalAddress";
|
2007-04-20 21:38:10 +00:00
|
|
|
case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress";
|
2006-03-01 00:51:13 +00:00
|
|
|
case ISD::TargetFrameIndex: return "TargetFrameIndex";
|
2006-04-22 18:53:45 +00:00
|
|
|
case ISD::TargetJumpTable: return "TargetJumpTable";
|
2005-08-26 17:15:30 +00:00
|
|
|
case ISD::TargetConstantPool: return "TargetConstantPool";
|
2006-03-01 00:51:13 +00:00
|
|
|
case ISD::TargetExternalSymbol: return "TargetExternalSymbol";
|
|
|
|
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::CopyToReg: return "CopyToReg";
|
|
|
|
case ISD::CopyFromReg: return "CopyFromReg";
|
2005-04-01 22:34:39 +00:00
|
|
|
case ISD::UNDEF: return "undef";
|
2007-07-05 20:15:43 +00:00
|
|
|
case ISD::MERGE_VALUES: return "merge_values";
|
2006-01-26 22:24:51 +00:00
|
|
|
case ISD::INLINEASM: return "inlineasm";
|
2008-07-01 00:05:16 +00:00
|
|
|
case ISD::DBG_LABEL: return "dbg_label";
|
|
|
|
case ISD::EH_LABEL: return "eh_label";
|
2008-02-02 04:07:54 +00:00
|
|
|
case ISD::DECLARE: return "declare";
|
2006-02-03 01:33:01 +00:00
|
|
|
case ISD::HANDLENODE: return "handlenode";
|
2006-04-12 16:20:43 +00:00
|
|
|
case ISD::FORMAL_ARGUMENTS: return "formal_arguments";
|
2006-05-16 22:53:20 +00:00
|
|
|
case ISD::CALL: return "call";
|
2006-01-26 22:24:51 +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";
|
2006-09-09 06:03:30 +00:00
|
|
|
case ISD::FPOWI: return "fpowi";
|
2007-10-11 23:06:37 +00:00
|
|
|
case ISD::FPOW: return "fpow";
|
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";
|
2007-10-05 14:11:04 +00:00
|
|
|
case ISD::SMUL_LOHI: return "smul_lohi";
|
|
|
|
case ISD::UMUL_LOHI: return "umul_lohi";
|
|
|
|
case ISD::SDIVREM: return "sdivrem";
|
|
|
|
case ISD::UDIVREM: return "divrem";
|
2005-01-10 23:25:25 +00:00
|
|
|
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";
|
2006-01-11 21:21:00 +00:00
|
|
|
case ISD::ROTL: return "rotl";
|
|
|
|
case ISD::ROTR: return "rotr";
|
2005-09-28 22:28:18 +00:00
|
|
|
case ISD::FADD: return "fadd";
|
|
|
|
case ISD::FSUB: return "fsub";
|
|
|
|
case ISD::FMUL: return "fmul";
|
|
|
|
case ISD::FDIV: return "fdiv";
|
|
|
|
case ISD::FREM: return "frem";
|
2006-03-05 05:09:38 +00:00
|
|
|
case ISD::FCOPYSIGN: return "fcopysign";
|
2007-12-22 21:26:52 +00:00
|
|
|
case ISD::FGETSIGN: return "fgetsign";
|
2006-03-17 19:53:59 +00:00
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::SETCC: return "setcc";
|
2008-05-12 19:40:03 +00:00
|
|
|
case ISD::VSETCC: return "vsetcc";
|
2005-08-09 20:20:18 +00:00
|
|
|
case ISD::SELECT: return "select";
|
2005-08-10 20:51:12 +00:00
|
|
|
case ISD::SELECT_CC: return "select_cc";
|
2006-04-08 22:22:57 +00:00
|
|
|
case ISD::INSERT_VECTOR_ELT: return "insert_vector_elt";
|
|
|
|
case ISD::EXTRACT_VECTOR_ELT: return "extract_vector_elt";
|
2007-06-25 16:23:39 +00:00
|
|
|
case ISD::CONCAT_VECTORS: return "concat_vectors";
|
|
|
|
case ISD::EXTRACT_SUBVECTOR: return "extract_subvector";
|
2006-04-08 22:22:57 +00:00
|
|
|
case ISD::SCALAR_TO_VECTOR: return "scalar_to_vector";
|
|
|
|
case ISD::VECTOR_SHUFFLE: return "vector_shuffle";
|
2007-03-04 20:40:38 +00:00
|
|
|
case ISD::CARRY_FALSE: return "carry_false";
|
2006-02-17 05:43:56 +00:00
|
|
|
case ISD::ADDC: return "addc";
|
|
|
|
case ISD::ADDE: return "adde";
|
|
|
|
case ISD::SUBC: return "subc";
|
|
|
|
case ISD::SUBE: return "sube";
|
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";
|
2007-07-26 07:34:40 +00:00
|
|
|
|
|
|
|
case ISD::EXTRACT_SUBREG: return "extract_subreg";
|
|
|
|
case ISD::INSERT_SUBREG: return "insert_subreg";
|
|
|
|
|
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";
|
2008-01-31 00:41:03 +00:00
|
|
|
case ISD::FLT_ROUNDS_: return "flt_rounds";
|
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";
|
2005-12-23 00:16:34 +00:00
|
|
|
case ISD::BIT_CONVERT: return "bit_convert";
|
2005-01-10 23:25:25 +00:00
|
|
|
|
|
|
|
// Control flow instructions
|
|
|
|
case ISD::BR: return "br";
|
2006-04-22 18:53:45 +00:00
|
|
|
case ISD::BRIND: return "brind";
|
2006-10-30 07:59:36 +00:00
|
|
|
case ISD::BR_JT: return "br_jt";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::BRCOND: return "brcond";
|
2006-03-17 01:40:33 +00:00
|
|
|
case ISD::BR_CC: return "br_cc";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::RET: return "ret";
|
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
|
2006-01-25 18:21:52 +00:00
|
|
|
case ISD::LOAD: return "load";
|
|
|
|
case ISD::STORE: return "store";
|
|
|
|
case ISD::VAARG: return "vaarg";
|
|
|
|
case ISD::VACOPY: return "vacopy";
|
|
|
|
case ISD::VAEND: return "vaend";
|
|
|
|
case ISD::VASTART: return "vastart";
|
2005-01-10 23:25:25 +00:00
|
|
|
case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";
|
2006-01-13 02:39:42 +00:00
|
|
|
case ISD::EXTRACT_ELEMENT: return "extract_element";
|
|
|
|
case ISD::BUILD_PAIR: return "build_pair";
|
|
|
|
case ISD::STACKSAVE: return "stacksave";
|
|
|
|
case ISD::STACKRESTORE: return "stackrestore";
|
2008-01-15 07:02:33 +00:00
|
|
|
case ISD::TRAP: return "trap";
|
|
|
|
|
2006-01-16 08:07:10 +00:00
|
|
|
// Bit manipulation
|
|
|
|
case ISD::BSWAP: return "bswap";
|
2005-05-11 04:50:30 +00:00
|
|
|
case ISD::CTPOP: return "ctpop";
|
|
|
|
case ISD::CTTZ: return "cttz";
|
|
|
|
case ISD::CTLZ: return "ctlz";
|
|
|
|
|
2005-11-29 06:21:05 +00:00
|
|
|
// Debug info
|
2008-06-30 20:59:49 +00:00
|
|
|
case ISD::DBG_STOPPOINT: return "dbg_stoppoint";
|
2005-12-16 22:45:29 +00:00
|
|
|
case ISD::DEBUG_LOC: return "debug_loc";
|
2005-11-29 06:21:05 +00:00
|
|
|
|
2007-07-27 12:58:54 +00:00
|
|
|
// Trampolines
|
2007-09-11 14:10:23 +00:00
|
|
|
case ISD::TRAMPOLINE: return "trampoline";
|
2007-07-27 12:58:54 +00:00
|
|
|
|
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
|
|
|
|
2006-11-09 17:55:04 +00:00
|
|
|
const char *SDNode::getIndexedModeName(ISD::MemIndexedMode AM) {
|
2006-10-17 21:14:32 +00:00
|
|
|
switch (AM) {
|
|
|
|
default:
|
|
|
|
return "";
|
|
|
|
case ISD::PRE_INC:
|
|
|
|
return "<pre-inc>";
|
|
|
|
case ISD::PRE_DEC:
|
|
|
|
return "<pre-dec>";
|
|
|
|
case ISD::POST_INC:
|
|
|
|
return "<post-inc>";
|
|
|
|
case ISD::POST_DEC:
|
|
|
|
return "<post-dec>";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-21 09:14:45 +00:00
|
|
|
std::string ISD::ArgFlagsTy::getArgFlagsString() {
|
|
|
|
std::string S = "< ";
|
|
|
|
|
|
|
|
if (isZExt())
|
|
|
|
S += "zext ";
|
|
|
|
if (isSExt())
|
|
|
|
S += "sext ";
|
|
|
|
if (isInReg())
|
|
|
|
S += "inreg ";
|
|
|
|
if (isSRet())
|
|
|
|
S += "sret ";
|
|
|
|
if (isByVal())
|
|
|
|
S += "byval ";
|
|
|
|
if (isNest())
|
|
|
|
S += "nest ";
|
|
|
|
if (getByValAlign())
|
|
|
|
S += "byval-align:" + utostr(getByValAlign()) + " ";
|
|
|
|
if (getOrigAlign())
|
|
|
|
S += "orig-align:" + utostr(getOrigAlign()) + " ";
|
|
|
|
if (getByValSize())
|
|
|
|
S += "byval-size:" + utostr(getByValSize()) + " ";
|
|
|
|
return S + ">";
|
|
|
|
}
|
|
|
|
|
2005-08-16 18:33:07 +00:00
|
|
|
void SDNode::dump() const { dump(0); }
|
|
|
|
void SDNode::dump(const SelectionDAG *G) const {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << (void*)this << ": ";
|
2005-01-07 07:46:32 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
|
2006-12-07 20:04:42 +00:00
|
|
|
if (i) cerr << ",";
|
2005-01-15 07:14:32 +00:00
|
|
|
if (getValueType(i) == MVT::Other)
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "ch";
|
2005-01-15 07:14:32 +00:00
|
|
|
else
|
2008-06-06 12:08:01 +00:00
|
|
|
cerr << getValueType(i).getMVTString();
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " = " << getOperationName(G);
|
2005-01-07 07:46:32 +00:00
|
|
|
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " ";
|
2005-01-07 07:46:32 +00:00
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
|
2006-12-07 20:04:42 +00:00
|
|
|
if (i) cerr << ", ";
|
|
|
|
cerr << (void*)getOperand(i).Val;
|
2005-01-07 07:46:32 +00:00
|
|
|
if (unsigned RN = getOperand(i).ResNo)
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << ":" << RN;
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2007-12-11 02:08:35 +00:00
|
|
|
if (!isTargetOpcode() && getOpcode() == ISD::VECTOR_SHUFFLE) {
|
|
|
|
SDNode *Mask = getOperand(2).Val;
|
|
|
|
cerr << "<";
|
|
|
|
for (unsigned i = 0, e = Mask->getNumOperands(); i != e; ++i) {
|
|
|
|
if (i) cerr << ",";
|
|
|
|
if (Mask->getOperand(i).getOpcode() == ISD::UNDEF)
|
|
|
|
cerr << "u";
|
|
|
|
else
|
|
|
|
cerr << cast<ConstantSDNode>(Mask->getOperand(i))->getValue();
|
|
|
|
}
|
|
|
|
cerr << ">";
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:46:32 +00:00
|
|
|
if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
|
2008-07-10 11:23:14 +00:00
|
|
|
cerr << "<" << CSDN->getAPIntValue().toStringUnsigned() << ">";
|
2005-01-07 07:46:32 +00:00
|
|
|
} else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
|
2007-09-14 22:26:36 +00:00
|
|
|
if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEsingle)
|
|
|
|
cerr << "<" << CSDN->getValueAPF().convertToFloat() << ">";
|
|
|
|
else if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEdouble)
|
|
|
|
cerr << "<" << CSDN->getValueAPF().convertToDouble() << ">";
|
|
|
|
else {
|
|
|
|
cerr << "<APFloat(";
|
|
|
|
CSDN->getValueAPF().convertToAPInt().dump();
|
|
|
|
cerr << ")>";
|
|
|
|
}
|
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)) {
|
2005-11-30 02:04:11 +00:00
|
|
|
int offset = GADN->getOffset();
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "<";
|
2006-12-07 20:28:15 +00:00
|
|
|
WriteAsOperand(*cerr.stream(), GADN->getGlobal()) << ">";
|
2005-11-30 02:04:11 +00:00
|
|
|
if (offset > 0)
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " + " << offset;
|
2005-11-30 02:04:11 +00:00
|
|
|
else
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " " << offset;
|
2005-04-22 04:01:18 +00:00
|
|
|
} else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "<" << FIDN->getIndex() << ">";
|
2006-11-01 04:48:30 +00:00
|
|
|
} else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "<" << JTDN->getIndex() << ">";
|
2005-01-07 07:46:32 +00:00
|
|
|
} else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
|
2006-02-26 08:36:57 +00:00
|
|
|
int offset = CP->getOffset();
|
2006-09-12 21:00:35 +00:00
|
|
|
if (CP->isMachineConstantPoolEntry())
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "<" << *CP->getMachineCPVal() << ">";
|
2006-09-12 21:00:35 +00:00
|
|
|
else
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "<" << *CP->getConstVal() << ">";
|
2006-02-26 08:36:57 +00:00
|
|
|
if (offset > 0)
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " + " << offset;
|
2006-02-26 08:36:57 +00:00
|
|
|
else
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " " << offset;
|
2005-04-22 04:01:18 +00:00
|
|
|
} else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "<";
|
2005-01-07 07:46:32 +00:00
|
|
|
const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
|
|
|
|
if (LBB)
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << LBB->getName() << " ";
|
|
|
|
cerr << (const void*)BBDN->getBasicBlock() << ">";
|
2005-08-19 21:34:13 +00:00
|
|
|
} else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
|
2008-02-10 18:45:23 +00:00
|
|
|
if (G && R->getReg() &&
|
|
|
|
TargetRegisterInfo::isPhysicalRegister(R->getReg())) {
|
2008-02-26 21:47:57 +00:00
|
|
|
cerr << " " << G->getTarget().getRegisterInfo()->getName(R->getReg());
|
2005-08-19 21:21:16 +00:00
|
|
|
} else {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " #" << R->getReg();
|
2005-08-19 21:21:16 +00:00
|
|
|
}
|
2005-01-07 07:46:32 +00:00
|
|
|
} else if (const ExternalSymbolSDNode *ES =
|
|
|
|
dyn_cast<ExternalSymbolSDNode>(this)) {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "'" << ES->getSymbol() << "'";
|
2005-05-09 04:08:27 +00:00
|
|
|
} else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
|
|
|
|
if (M->getValue())
|
2008-02-06 22:27:42 +00:00
|
|
|
cerr << "<" << M->getValue() << ">";
|
|
|
|
else
|
|
|
|
cerr << "<null>";
|
|
|
|
} else if (const MemOperandSDNode *M = dyn_cast<MemOperandSDNode>(this)) {
|
|
|
|
if (M->MO.getValue())
|
|
|
|
cerr << "<" << M->MO.getValue() << ":" << M->MO.getOffset() << ">";
|
2005-05-09 04:08:27 +00:00
|
|
|
else
|
2008-02-06 22:27:42 +00:00
|
|
|
cerr << "<null:" << M->MO.getOffset() << ">";
|
2008-03-21 09:14:45 +00:00
|
|
|
} else if (const ARG_FLAGSSDNode *N = dyn_cast<ARG_FLAGSSDNode>(this)) {
|
|
|
|
cerr << N->getArgFlags().getArgFlagsString();
|
2005-08-18 03:31:02 +00:00
|
|
|
} else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
|
2008-06-06 12:08:01 +00:00
|
|
|
cerr << ":" << N->getVT().getMVTString();
|
2008-06-25 08:15:39 +00:00
|
|
|
}
|
|
|
|
else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
|
2007-12-18 19:06:30 +00:00
|
|
|
const Value *SrcValue = LD->getSrcValue();
|
|
|
|
int SrcOffset = LD->getSrcValueOffset();
|
|
|
|
cerr << " <";
|
|
|
|
if (SrcValue)
|
|
|
|
cerr << SrcValue;
|
|
|
|
else
|
|
|
|
cerr << "null";
|
|
|
|
cerr << ":" << SrcOffset << ">";
|
|
|
|
|
2006-10-10 20:05:10 +00:00
|
|
|
bool doExt = true;
|
|
|
|
switch (LD->getExtensionType()) {
|
|
|
|
default: doExt = false; break;
|
|
|
|
case ISD::EXTLOAD:
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " <anyext ";
|
2006-10-10 20:05:10 +00:00
|
|
|
break;
|
|
|
|
case ISD::SEXTLOAD:
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " <sext ";
|
2006-10-10 20:05:10 +00:00
|
|
|
break;
|
|
|
|
case ISD::ZEXTLOAD:
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " <zext ";
|
2006-10-10 20:05:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (doExt)
|
2008-06-06 12:08:01 +00:00
|
|
|
cerr << LD->getMemoryVT().getMVTString() << ">";
|
2006-10-10 20:05:10 +00:00
|
|
|
|
2006-11-09 17:55:04 +00:00
|
|
|
const char *AM = getIndexedModeName(LD->getAddressingMode());
|
2007-07-19 07:31:58 +00:00
|
|
|
if (*AM)
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " " << AM;
|
2007-12-18 19:06:30 +00:00
|
|
|
if (LD->isVolatile())
|
|
|
|
cerr << " <volatile>";
|
|
|
|
cerr << " alignment=" << LD->getAlignment();
|
|
|
|
} else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
|
|
|
|
const Value *SrcValue = ST->getSrcValue();
|
|
|
|
int SrcOffset = ST->getSrcValueOffset();
|
2007-12-18 07:02:08 +00:00
|
|
|
cerr << " <";
|
|
|
|
if (SrcValue)
|
|
|
|
cerr << SrcValue;
|
|
|
|
else
|
|
|
|
cerr << "null";
|
|
|
|
cerr << ":" << SrcOffset << ">";
|
2007-12-18 19:06:30 +00:00
|
|
|
|
2006-10-17 21:14:32 +00:00
|
|
|
if (ST->isTruncatingStore())
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " <trunc "
|
2008-06-06 12:08:01 +00:00
|
|
|
<< ST->getMemoryVT().getMVTString() << ">";
|
2006-10-17 21:14:32 +00:00
|
|
|
|
2006-11-09 17:55:04 +00:00
|
|
|
const char *AM = getIndexedModeName(ST->getAddressingMode());
|
2007-07-19 07:31:58 +00:00
|
|
|
if (*AM)
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << " " << AM;
|
2007-12-18 19:06:30 +00:00
|
|
|
if (ST->isVolatile())
|
|
|
|
cerr << " <volatile>";
|
|
|
|
cerr << " alignment=" << ST->getAlignment();
|
2008-06-25 08:15:39 +00:00
|
|
|
} else if (const AtomicSDNode* AT = dyn_cast<AtomicSDNode>(this)) {
|
|
|
|
const Value *SrcValue = AT->getSrcValue();
|
|
|
|
int SrcOffset = AT->getSrcValueOffset();
|
|
|
|
cerr << " <";
|
|
|
|
if (SrcValue)
|
|
|
|
cerr << SrcValue;
|
|
|
|
else
|
|
|
|
cerr << "null";
|
|
|
|
cerr << ":" << SrcOffset << ">";
|
|
|
|
if (AT->isVolatile())
|
|
|
|
cerr << " <volatile>";
|
|
|
|
cerr << " alignment=" << AT->getAlignment();
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-09 23:47:37 +00:00
|
|
|
static void DumpNodes(const 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
|
2006-12-07 20:04:42 +00:00
|
|
|
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
|
|
|
|
2006-12-07 20:04:42 +00:00
|
|
|
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 {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "SelectionDAG has " << AllNodes.size() << " nodes:";
|
2005-11-09 23:47:37 +00:00
|
|
|
|
2008-07-15 18:18:54 +00:00
|
|
|
for (allnodes_const_iterator I = allnodes_begin(), E = allnodes_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
const SDNode *N = I;
|
|
|
|
if (!N->hasOneUse() && N != getRoot().Val)
|
|
|
|
DumpNodes(N, 2, this);
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
2005-01-09 20:38:33 +00:00
|
|
|
|
2006-10-17 19:33:52 +00:00
|
|
|
if (getRoot().Val) DumpNodes(getRoot().Val, 2, this);
|
2005-01-09 20:38:33 +00:00
|
|
|
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << "\n\n";
|
2005-01-07 07:46:32 +00:00
|
|
|
}
|
|
|
|
|
2006-09-12 21:00:35 +00:00
|
|
|
const Type *ConstantPoolSDNode::getType() const {
|
|
|
|
if (isMachineConstantPoolEntry())
|
|
|
|
return Val.MachineCPVal->getType();
|
|
|
|
return Val.ConstVal->getType();
|
|
|
|
}
|