RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity

[FPEnv][SelectionDAG] Relax chain requirements

Browse Source 
This patch implements the following changes:

1) SelectionDAGBuilder::visitConstrainedFPIntrinsic currently treats
each constrained intrinsic like a global barrier (e.g. a function call)
and fully serializes all pending chains. This is actually not required;
it is allowed for constrained intrinsics to be reordered w.r.t one
another or (nonvolatile) memory accesses. The MI-level scheduler already
allows for that flexibility, so it makes sense to allow it at the DAG
level as well.

This patch therefore changes the way chains for constrained intrisincs
are created, and handles them basically like load operations are handled.
This has the effect that constrained intrinsics are no longer serialized
against one another or (nonvolatile) loads. They are still serialized
against stores, but that seems hard to change with the current DAG chain
setup, and it also doesn't seem to be a big problem preventing DAG

2) The OPC_CheckFoldableChainNode check requires that each of the
intermediate nodes in a multi-node pattern match only has a single use.
This check tends to fail if those intermediate nodes are strict operations
as those have a chain output that typically indeed has another use.
However, we don't really need to consider chains here at all, since they
will all be rewritten anyway by UpdateChains later. Other parts of the
matcher therefore already ignore chains, but this hasOneUse check doesn't.

This patch replaces hasOneUse by a custom test that verifies there is no
more than one use of any non-chain output value.

In theory, this change could affect code unrelated to strict FP nodes,
but at least on SystemZ I could not find any single instance of that
happening

3) The SystemZ back-end currently does not allow matching multiply-and-
extend operations (32x32 -> 64bit or 64x64 -> 128bit FP multiply) for
strict FP operations.  This was not possible in the past due to the
problems described under 1) and 2) above.

With those issues fixed, it is now possible to fully support those
instructions in strict mode as well, and this patch does so.

Differential Revision: https://reviews.llvm.org/D70913
This commit is contained in:
Ulrich Weigand 2019-12-06 11:02:11 +01:00
parent 2cf462d7ef
commit 1a3ef94576
10 changed files with 774 additions and 598 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -6888,7 +6888,10 @@ void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
ComputeValueVTs(TLI, DAG.getDataLayout(), FPI.getType(), ValueVTs);
ValueVTs.push_back(MVT::Other); // Out chain
SDValue Chain = getRoot();
// We do not need to serialize constrained FP intrinsics against
// each other or against (nonvolatile) loads, so they can be
// chained like loads.
SDValue Chain = DAG.getRoot();
SmallVector<SDValue, 4> Opers;
Opers.push_back(Chain);
if (FPI.isUnaryOp()) {
@ -6926,8 +6929,9 @@ void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
}
assert(Result.getNode()->getNumValues() == 2);
// See above -- chain is handled like for loads here.
SDValue OutChain = Result.getValue(1);
DAG.setRoot(OutChain);
PendingLoads.push_back(OutChain);
SDValue FPResult = Result.getValue(0);
setValue(&FPI, FPResult);
}

18
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -3171,13 +3171,19 @@ void SelectionDAGISel::SelectCodeCommon(SDNode *NodeToMatch,
case OPC_CheckFoldableChainNode: {
assert(NodeStack.size() != 1 && "No parent node");
// Verify that all intermediate nodes between the root and this one have
// a single use.
// a single use (ignoring chains, which are handled in UpdateChains).
bool HasMultipleUses = false;
for (unsigned i = 1, e = NodeStack.size()-1; i != e; ++i)
if (!NodeStack[i].getNode()->hasOneUse()) {
HasMultipleUses = true;
break;
}
for (unsigned i = 1, e = NodeStack.size()-1; i != e; ++i) {
unsigned NNonChainUses = 0;
SDNode *NS = NodeStack[i].getNode();
for (auto UI = NS->use_begin(), UE = NS->use_end(); UI != UE; ++UI)
if (UI.getUse().getValueType() != MVT::Other)
if (++NNonChainUses > 1) {
HasMultipleUses = true;
break;
}
if (HasMultipleUses) break;
}
if (HasMultipleUses) break;
// Check to see that the target thinks this is profitable to fold and that

16
lib/Target/SystemZ/SystemZInstrFP.td
View File

@ -467,16 +467,16 @@ let Uses = [FPC], mayRaiseFPException = 1 in {
// f64 multiplication of two FP32 registers.
let Uses = [FPC], mayRaiseFPException = 1 in
def MDEBR : BinaryRRE<"mdebr", 0xB30C, null_frag, FP64, FP32>;
def : Pat<(any_fmul (f64 (fpextend FP32:$src1)),
(f64 (fpextend FP32:$src2))),
def : Pat<(any_fmul (f64 (any_fpextend FP32:$src1)),
(f64 (any_fpextend FP32:$src2))),
(MDEBR (INSERT_SUBREG (f64 (IMPLICIT_DEF)),
FP32:$src1, subreg_h32), FP32:$src2)>;
// f64 multiplication of an FP32 register and an f32 memory.
let Uses = [FPC], mayRaiseFPException = 1 in
def MDEB : BinaryRXE<"mdeb", 0xED0C, null_frag, FP64, load, 4>;
def : Pat<(any_fmul (f64 (fpextend FP32:$src1)),
(f64 (extloadf32 bdxaddr12only:$addr))),
def : Pat<(any_fmul (f64 (any_fpextend FP32:$src1)),
(f64 (any_extloadf32 bdxaddr12only:$addr))),
(MDEB (INSERT_SUBREG (f64 (IMPLICIT_DEF)), FP32:$src1, subreg_h32),
bdxaddr12only:$addr)>;
@ -484,8 +484,8 @@ def : Pat<(any_fmul (f64 (fpextend FP32:$src1)),
let Uses = [FPC], mayRaiseFPException = 1 in
def MXDBR : BinaryRRE<"mxdbr", 0xB307, null_frag, FP128, FP64>;
let Predicates = [FeatureNoVectorEnhancements1] in
def : Pat<(any_fmul (f128 (fpextend FP64:$src1)),
(f128 (fpextend FP64:$src2))),
def : Pat<(any_fmul (f128 (any_fpextend FP64:$src1)),
(f128 (any_fpextend FP64:$src2))),
(MXDBR (INSERT_SUBREG (f128 (IMPLICIT_DEF)),
FP64:$src1, subreg_h64), FP64:$src2)>;
@ -493,8 +493,8 @@ let Predicates = [FeatureNoVectorEnhancements1] in
let Uses = [FPC], mayRaiseFPException = 1 in
def MXDB : BinaryRXE<"mxdb", 0xED07, null_frag, FP128, load, 8>;
let Predicates = [FeatureNoVectorEnhancements1] in
def : Pat<(any_fmul (f128 (fpextend FP64:$src1)),
(f128 (extloadf64 bdxaddr12only:$addr))),
def : Pat<(any_fmul (f128 (any_fpextend FP64:$src1)),
(f128 (any_extloadf64 bdxaddr12only:$addr))),
(MXDB (INSERT_SUBREG (f128 (IMPLICIT_DEF)), FP64:$src1, subreg_h64),
bdxaddr12only:$addr)>;

131
test/CodeGen/SystemZ/fp-strict-mul-02.ll
View File

@ -1,6 +1,4 @@
; Test strict multiplication of two f32s, producing an f64 result.
; FIXME: We should use llvm.experimental.constrained.fpext, but we currently
; cannot match a combination of two strict operations in ISel.
;
; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
@ -8,14 +6,19 @@ declare float @foo()
declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
declare float @llvm.experimental.constrained.fadd.f32(float, float, metadata, metadata)
declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)
declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)
; Check register multiplication.
define double @f1(float %f1, float %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: mdebr %f0, %f2
; CHECK: br %r14
%f1x = fpext float %f1 to double
%f2x = fpext float %f2 to double
%f1x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f1,
metadata !"fpexcept.strict") #0
%f2x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f2,
metadata !"fpexcept.strict") #0
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
@ -29,8 +32,12 @@ define double @f2(float %f1, float *%ptr) #0 {
; CHECK: mdeb %f0, 0(%r2)
; CHECK: br %r14
%f2 = load float, float *%ptr
%f1x = fpext float %f1 to double
%f2x = fpext float %f2 to double
%f1x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f1,
metadata !"fpexcept.strict") #0
%f2x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f2,
metadata !"fpexcept.strict") #0
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
@ -45,8 +52,12 @@ define double @f3(float %f1, float *%base) #0 {
; CHECK: br %r14
%ptr = getelementptr float, float *%base, i64 1023
%f2 = load float, float *%ptr
%f1x = fpext float %f1 to double
%f2x = fpext float %f2 to double
%f1x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f1,
metadata !"fpexcept.strict") #0
%f2x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f2,
metadata !"fpexcept.strict") #0
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
@ -63,8 +74,12 @@ define double @f4(float %f1, float *%base) #0 {
; CHECK: br %r14
%ptr = getelementptr float, float *%base, i64 1024
%f2 = load float, float *%ptr
%f1x = fpext float %f1 to double
%f2x = fpext float %f2 to double
%f1x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f1,
metadata !"fpexcept.strict") #0
%f2x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f2,
metadata !"fpexcept.strict") #0
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
@ -80,8 +95,12 @@ define double @f5(float %f1, float *%base) #0 {
; CHECK: br %r14
%ptr = getelementptr float, float *%base, i64 -1
%f2 = load float, float *%ptr
%f1x = fpext float %f1 to double
%f2x = fpext float %f2 to double
%f1x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f1,
metadata !"fpexcept.strict") #0
%f2x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f2,
metadata !"fpexcept.strict") #0
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
@ -98,8 +117,12 @@ define double @f6(float %f1, float *%base, i64 %index) #0 {
%ptr1 = getelementptr float, float *%base, i64 %index
%ptr2 = getelementptr float, float *%ptr1, i64 100
%f2 = load float, float *%ptr2
%f1x = fpext float %f1 to double
%f2x = fpext float %f2 to double
%f1x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f1,
metadata !"fpexcept.strict") #0
%f2x = call double @llvm.experimental.constrained.fpext.f64.f32(
float %f2,
metadata !"fpexcept.strict") #0
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
@ -195,8 +218,12 @@ define float @f7(float *%ptr0) #0 {
%ret = call float @foo() #0
%accext0 = fpext float %ret to double
%ext0 = fpext float %frob0 to double
%accext0 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %ret,
metadata !"fpexcept.strict") #0
%ext0 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob0,
metadata !"fpexcept.strict") #0
%mul0 = call double @llvm.experimental.constrained.fmul.f64(
double %accext0, double %ext0,
metadata !"round.dynamic",
@ -210,8 +237,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext1 = fpext float %trunc0 to double
%ext1 = fpext float %frob1 to double
%accext1 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc0,
metadata !"fpexcept.strict") #0
%ext1 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob1,
metadata !"fpexcept.strict") #0
%mul1 = call double @llvm.experimental.constrained.fmul.f64(
double %accext1, double %ext1,
metadata !"round.dynamic",
@ -225,8 +256,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext2 = fpext float %trunc1 to double
%ext2 = fpext float %frob2 to double
%accext2 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc1,
metadata !"fpexcept.strict") #0
%ext2 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob2,
metadata !"fpexcept.strict") #0
%mul2 = call double @llvm.experimental.constrained.fmul.f64(
double %accext2, double %ext2,
metadata !"round.dynamic",
@ -240,8 +275,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext3 = fpext float %trunc2 to double
%ext3 = fpext float %frob3 to double
%accext3 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc2,
metadata !"fpexcept.strict") #0
%ext3 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob3,
metadata !"fpexcept.strict") #0
%mul3 = call double @llvm.experimental.constrained.fmul.f64(
double %accext3, double %ext3,
metadata !"round.dynamic",
@ -255,8 +294,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext4 = fpext float %trunc3 to double
%ext4 = fpext float %frob4 to double
%accext4 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc3,
metadata !"fpexcept.strict") #0
%ext4 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob4,
metadata !"fpexcept.strict") #0
%mul4 = call double @llvm.experimental.constrained.fmul.f64(
double %accext4, double %ext4,
metadata !"round.dynamic",
@ -270,8 +313,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext5 = fpext float %trunc4 to double
%ext5 = fpext float %frob5 to double
%accext5 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc4,
metadata !"fpexcept.strict") #0
%ext5 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob5,
metadata !"fpexcept.strict") #0
%mul5 = call double @llvm.experimental.constrained.fmul.f64(
double %accext5, double %ext5,
metadata !"round.dynamic",
@ -285,8 +332,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext6 = fpext float %trunc5 to double
%ext6 = fpext float %frob6 to double
%accext6 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc5,
metadata !"fpexcept.strict") #0
%ext6 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob6,
metadata !"fpexcept.strict") #0
%mul6 = call double @llvm.experimental.constrained.fmul.f64(
double %accext6, double %ext6,
metadata !"round.dynamic",
@ -300,8 +351,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext7 = fpext float %trunc6 to double
%ext7 = fpext float %frob7 to double
%accext7 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc6,
metadata !"fpexcept.strict") #0
%ext7 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob7,
metadata !"fpexcept.strict") #0
%mul7 = call double @llvm.experimental.constrained.fmul.f64(
double %accext7, double %ext7,
metadata !"round.dynamic",
@ -315,8 +370,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext8 = fpext float %trunc7 to double
%ext8 = fpext float %frob8 to double
%accext8 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc7,
metadata !"fpexcept.strict") #0
%ext8 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob8,
metadata !"fpexcept.strict") #0
%mul8 = call double @llvm.experimental.constrained.fmul.f64(
double %accext8, double %ext8,
metadata !"round.dynamic",
@ -330,8 +389,12 @@ define float @f7(float *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext9 = fpext float %trunc8 to double
%ext9 = fpext float %frob9 to double
%accext9 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %trunc8,
metadata !"fpexcept.strict") #0
%ext9 = call double @llvm.experimental.constrained.fpext.f64.f32(
float %frob9,
metadata !"fpexcept.strict") #0
%mul9 = call double @llvm.experimental.constrained.fmul.f64(
double %accext9, double %ext9,
metadata !"round.dynamic",

131
test/CodeGen/SystemZ/fp-strict-mul-04.ll
View File

@ -1,12 +1,11 @@
; Test strict multiplication of two f64s, producing an f128 result.
; FIXME: We should use llvm.experimental.constrained.fpext, but we currently
; cannot match a combination of two strict operations in ISel.
;
; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, metadata)
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.fptrunc.f64.f128(fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.fpext.f128.f64(double, metadata)
declare double @foo()
@ -19,8 +18,12 @@ define void @f1(double %f1, double %dummy, double %f2, fp128 *%dst) #0 {
; CHECK: std %f0, 0(%r2)
; CHECK: std %f2, 8(%r2)
; CHECK: br %r14
%f1x = fpext double %f1 to fp128
%f2x = fpext double %f2 to fp128
%f1x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f1,
metadata !"fpexcept.strict") #0
%f2x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f2,
metadata !"fpexcept.strict") #0
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
@ -37,8 +40,12 @@ define void @f2(double %f1, double *%ptr, fp128 *%dst) #0 {
; CHECK: std %f2, 8(%r3)
; CHECK: br %r14
%f2 = load double, double *%ptr
%f1x = fpext double %f1 to fp128
%f2x = fpext double %f2 to fp128
%f1x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f1,
metadata !"fpexcept.strict") #0
%f2x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f2,
metadata !"fpexcept.strict") #0
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
@ -56,8 +63,12 @@ define void @f3(double %f1, double *%base, fp128 *%dst) #0 {
; CHECK: br %r14
%ptr = getelementptr double, double *%base, i64 511
%f2 = load double, double *%ptr
%f1x = fpext double %f1 to fp128
%f2x = fpext double %f2 to fp128
%f1x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f1,
metadata !"fpexcept.strict") #0
%f2x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f2,
metadata !"fpexcept.strict") #0
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
@ -77,8 +88,12 @@ define void @f4(double %f1, double *%base, fp128 *%dst) #0 {
; CHECK: br %r14
%ptr = getelementptr double, double *%base, i64 512
%f2 = load double, double *%ptr
%f1x = fpext double %f1 to fp128
%f2x = fpext double %f2 to fp128
%f1x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f1,
metadata !"fpexcept.strict") #0
%f2x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f2,
metadata !"fpexcept.strict") #0
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
@ -97,8 +112,12 @@ define void @f5(double %f1, double *%base, fp128 *%dst) #0 {
; CHECK: br %r14
%ptr = getelementptr double, double *%base, i64 -1
%f2 = load double, double *%ptr
%f1x = fpext double %f1 to fp128
%f2x = fpext double %f2 to fp128
%f1x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f1,
metadata !"fpexcept.strict") #0
%f2x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f2,
metadata !"fpexcept.strict") #0
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
@ -118,8 +137,12 @@ define void @f6(double %f1, double *%base, i64 %index, fp128 *%dst) #0 {
%ptr1 = getelementptr double, double *%base, i64 %index
%ptr2 = getelementptr double, double *%ptr1, i64 100
%f2 = load double, double *%ptr2
%f1x = fpext double %f1 to fp128
%f2x = fpext double %f2 to fp128
%f1x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f1,
metadata !"fpexcept.strict") #0
%f2x = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %f2,
metadata !"fpexcept.strict") #0
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
@ -216,8 +239,12 @@ define double @f7(double *%ptr0) #0 {
%ret = call double @foo() #0
%accext0 = fpext double %ret to fp128
%ext0 = fpext double %frob0 to fp128
%accext0 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %ret,
metadata !"fpexcept.strict") #0
%ext0 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob0,
metadata !"fpexcept.strict") #0
%mul0 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext0, fp128 %ext0,
metadata !"round.dynamic",
@ -231,8 +258,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext1 = fpext double %trunc0 to fp128
%ext1 = fpext double %frob1 to fp128
%accext1 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc0,
metadata !"fpexcept.strict") #0
%ext1 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob1,
metadata !"fpexcept.strict") #0
%mul1 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext1, fp128 %ext1,
metadata !"round.dynamic",
@ -246,8 +277,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext2 = fpext double %trunc1 to fp128
%ext2 = fpext double %frob2 to fp128
%accext2 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc1,
metadata !"fpexcept.strict") #0
%ext2 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob2,
metadata !"fpexcept.strict") #0
%mul2 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext2, fp128 %ext2,
metadata !"round.dynamic",
@ -261,8 +296,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext3 = fpext double %trunc2 to fp128
%ext3 = fpext double %frob3 to fp128
%accext3 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc2,
metadata !"fpexcept.strict") #0
%ext3 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob3,
metadata !"fpexcept.strict") #0
%mul3 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext3, fp128 %ext3,
metadata !"round.dynamic",
@ -276,8 +315,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext4 = fpext double %trunc3 to fp128
%ext4 = fpext double %frob4 to fp128
%accext4 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc3,
metadata !"fpexcept.strict") #0
%ext4 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob4,
metadata !"fpexcept.strict") #0
%mul4 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext4, fp128 %ext4,
metadata !"round.dynamic",
@ -291,8 +334,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext5 = fpext double %trunc4 to fp128
%ext5 = fpext double %frob5 to fp128
%accext5 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc4,
metadata !"fpexcept.strict") #0
%ext5 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob5,
metadata !"fpexcept.strict") #0
%mul5 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext5, fp128 %ext5,
metadata !"round.dynamic",
@ -306,8 +353,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext6 = fpext double %trunc5 to fp128
%ext6 = fpext double %frob6 to fp128
%accext6 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc5,
metadata !"fpexcept.strict") #0
%ext6 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob6,
metadata !"fpexcept.strict") #0
%mul6 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext6, fp128 %ext6,
metadata !"round.dynamic",
@ -321,8 +372,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext7 = fpext double %trunc6 to fp128
%ext7 = fpext double %frob7 to fp128
%accext7 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc6,
metadata !"fpexcept.strict") #0
%ext7 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob7,
metadata !"fpexcept.strict") #0
%mul7 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext7, fp128 %ext7,
metadata !"round.dynamic",
@ -336,8 +391,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext8 = fpext double %trunc7 to fp128
%ext8 = fpext double %frob8 to fp128
%accext8 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc7,
metadata !"fpexcept.strict") #0
%ext8 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob8,
metadata !"fpexcept.strict") #0
%mul8 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext8, fp128 %ext8,
metadata !"round.dynamic",
@ -351,8 +410,12 @@ define double @f7(double *%ptr0) #0 {
metadata !"round.dynamic",
metadata !"fpexcept.strict") #0
%accext9 = fpext double %trunc8 to fp128
%ext9 = fpext double %frob9 to fp128
%accext9 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %trunc8,
metadata !"fpexcept.strict") #0
%ext9 = call fp128 @llvm.experimental.constrained.fpext.f128.f64(
double %frob9,
metadata !"fpexcept.strict") #0
%mul9 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext9, fp128 %ext9,
metadata !"round.dynamic",

816
test/CodeGen/SystemZ/vector-constrained-fp-intrinsics.ll
View File

File diff suppressed because it is too large Load Diff

24
test/CodeGen/X86/fp-intrinsics.ll
View File

@ -1104,10 +1104,10 @@ define i128 @f20s128(double %x) nounwind strictfp {
; X87-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X87-NEXT: movl {{[0-9]+}}(%esp), %edx
; X87-NEXT: movl {{[0-9]+}}(%esp), %edi
; X87-NEXT: movl %edi, 8(%esi)
; X87-NEXT: movl %edx, 12(%esi)
; X87-NEXT: movl %eax, (%esi)
; X87-NEXT: movl %edi, 12(%esi)
; X87-NEXT: movl %edx, 8(%esi)
; X87-NEXT: movl %ecx, 4(%esi)
; X87-NEXT: movl %eax, (%esi)
; X87-NEXT: movl %esi, %eax
; X87-NEXT: addl $36, %esp
; X87-NEXT: popl %esi
@ -1130,10 +1130,10 @@ define i128 @f20s128(double %x) nounwind strictfp {
; X86-SSE-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-SSE-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-SSE-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-SSE-NEXT: movl %edi, 8(%esi)
; X86-SSE-NEXT: movl %edx, 12(%esi)
; X86-SSE-NEXT: movl %eax, (%esi)
; X86-SSE-NEXT: movl %edi, 12(%esi)
; X86-SSE-NEXT: movl %edx, 8(%esi)
; X86-SSE-NEXT: movl %ecx, 4(%esi)
; X86-SSE-NEXT: movl %eax, (%esi)
; X86-SSE-NEXT: movl %esi, %eax
; X86-SSE-NEXT: addl $36, %esp
; X86-SSE-NEXT: popl %esi
@ -1444,10 +1444,10 @@ define i128 @f20u128(double %x) nounwind strictfp {
; X87-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X87-NEXT: movl {{[0-9]+}}(%esp), %edx
; X87-NEXT: movl {{[0-9]+}}(%esp), %edi
; X87-NEXT: movl %edi, 8(%esi)
; X87-NEXT: movl %edx, 12(%esi)
; X87-NEXT: movl %eax, (%esi)
; X87-NEXT: movl %edi, 12(%esi)
; X87-NEXT: movl %edx, 8(%esi)
; X87-NEXT: movl %ecx, 4(%esi)
; X87-NEXT: movl %eax, (%esi)
; X87-NEXT: movl %esi, %eax
; X87-NEXT: addl $36, %esp
; X87-NEXT: popl %esi
@ -1470,10 +1470,10 @@ define i128 @f20u128(double %x) nounwind strictfp {
; X86-SSE-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-SSE-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-SSE-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-SSE-NEXT: movl %edi, 8(%esi)
; X86-SSE-NEXT: movl %edx, 12(%esi)
; X86-SSE-NEXT: movl %eax, (%esi)
; X86-SSE-NEXT: movl %edi, 12(%esi)
; X86-SSE-NEXT: movl %edx, 8(%esi)
; X86-SSE-NEXT: movl %ecx, 4(%esi)
; X86-SSE-NEXT: movl %eax, (%esi)
; X86-SSE-NEXT: movl %esi, %eax
; X86-SSE-NEXT: addl $36, %esp
; X86-SSE-NEXT: popl %esi

12
test/CodeGen/X86/fp128-cast-strict.ll
View File

@ -396,10 +396,10 @@ define i128 @fptosi_i128(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -535,10 +535,10 @@ define i128 @fptoui_i128(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi

144
test/CodeGen/X86/fp128-libcalls-strict.ll
View File

@ -42,10 +42,10 @@ define fp128 @add(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -87,10 +87,10 @@ define fp128 @sub(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -132,10 +132,10 @@ define fp128 @mul(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -177,10 +177,10 @@ define fp128 @div(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -226,10 +226,10 @@ define fp128 @fma(fp128 %x, fp128 %y, fp128 %z) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -271,10 +271,10 @@ define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -312,10 +312,10 @@ define fp128 @ceil(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -353,10 +353,10 @@ define fp128 @cos(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -394,10 +394,10 @@ define fp128 @exp(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -435,10 +435,10 @@ define fp128 @exp2(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -476,10 +476,10 @@ define fp128 @floor(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -517,10 +517,10 @@ define fp128 @log(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -558,10 +558,10 @@ define fp128 @log10(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -599,10 +599,10 @@ define fp128 @log2(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -644,10 +644,10 @@ define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -689,10 +689,10 @@ define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -730,10 +730,10 @@ define fp128 @nearbyint(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -775,10 +775,10 @@ define fp128 @pow(fp128 %x, fp128 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -817,10 +817,10 @@ define fp128 @powi(fp128 %x, i32 %y) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -858,10 +858,10 @@ define fp128 @rint(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -899,10 +899,10 @@ define fp128 @round(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -940,10 +940,10 @@ define fp128 @sin(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -981,10 +981,10 @@ define fp128 @sqrt(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi
@ -1022,10 +1022,10 @@ define fp128 @trunc(fp128 %x) nounwind strictfp {
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
; X86-NEXT: movl %edi, 8(%esi)
; X86-NEXT: movl %edx, 12(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %edi, 12(%esi)
; X86-NEXT: movl %edx, 8(%esi)
; X86-NEXT: movl %ecx, 4(%esi)
; X86-NEXT: movl %eax, (%esi)
; X86-NEXT: movl %esi, %eax
; X86-NEXT: addl $20, %esp
; X86-NEXT: popl %esi

72
test/CodeGen/X86/vector-constrained-fp-intrinsics.ll
View File

@ -292,9 +292,9 @@ define <3 x double> @constrained_vector_frem_v3f64() #0 {
; CHECK-NEXT: callq fmod
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -1077,9 +1077,9 @@ define <3 x double> @constrained_vector_pow_v3f64() #0 {
; CHECK-NEXT: callq pow
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -1333,9 +1333,9 @@ define <3 x double> @constrained_vector_powi_v3f64() #0 {
; CHECK-NEXT: callq __powidf2
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -1570,9 +1570,9 @@ define <3 x double> @constrained_vector_sin_v3f64() #0 {
; CHECK-NEXT: callq sin
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -1794,9 +1794,9 @@ define <3 x double> @constrained_vector_cos_v3f64() #0 {
; CHECK-NEXT: callq cos
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -2018,9 +2018,9 @@ define <3 x double> @constrained_vector_exp_v3f64() #0 {
; CHECK-NEXT: callq exp
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -2242,9 +2242,9 @@ define <3 x double> @constrained_vector_exp2_v3f64() #0 {
; CHECK-NEXT: callq exp2
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -2466,9 +2466,9 @@ define <3 x double> @constrained_vector_log_v3f64() #0 {
; CHECK-NEXT: callq log
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -2690,9 +2690,9 @@ define <3 x double> @constrained_vector_log10_v3f64() #0 {
; CHECK-NEXT: callq log10
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -2914,9 +2914,9 @@ define <3 x double> @constrained_vector_log2_v3f64() #0 {
; CHECK-NEXT: callq log2
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -3116,9 +3116,9 @@ define <3 x double> @constrained_vector_rint_v3f64() #0 {
; CHECK-NEXT: callq rint
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -3286,9 +3286,9 @@ define <3 x double> @constrained_vector_nearby_v3f64() #0 {
; CHECK-NEXT: callq nearbyint
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -3495,9 +3495,9 @@ define <3 x double> @constrained_vector_max_v3f64() #0 {
; CHECK-NEXT: callq fmax
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -3750,9 +3750,9 @@ define <3 x double> @constrained_vector_min_v3f64() #0 {
; CHECK-NEXT: callq fmin
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -5237,9 +5237,9 @@ define <3 x double> @constrained_vector_ceil_v3f64() #0 {
; CHECK-NEXT: callq ceil
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -5369,9 +5369,9 @@ define <3 x double> @constrained_vector_floor_v3f64() #0 {
; CHECK-NEXT: callq floor
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -5523,9 +5523,9 @@ define <3 x double> @constrained_vector_round_v3f64() #0 {
; CHECK-NEXT: callq round
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
@ -5667,9 +5667,9 @@ define <3 x double> @constrained_vector_trunc_v3f64() #0 {
; CHECK-NEXT: callq trunc
; CHECK-NEXT: movsd %xmm0, {{[0-9]+}}(%rsp)
; CHECK-NEXT: fldl {{[0-9]+}}(%rsp)
; CHECK-NEXT: movsd (%rsp), %xmm0 # 8-byte Reload
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 8-byte Reload
; CHECK-NEXT: # xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 8-byte Reload
; CHECK-NEXT: movsd (%rsp), %xmm1 # 8-byte Reload
; CHECK-NEXT: # xmm1 = mem[0],zero
; CHECK-NEXT: addq $24, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8