Commit b29e5cdb authored by Craig Topper's avatar Craig Topper
Browse files

[X86] Add test cases for most of the constrained fp libcalls with fp128. 

Add explicit setOperation actions for some to match their none
strict counterparts. This isn't required, but makes the code
self documenting that we didn't forget about strict fp. I've
used LibCall instead of Expand since that's more explicitly what
we want.

Only lrint/llrint/lround/llround are missing now.
parent fc4020db

llvm/lib/Target/X86/X86ISelLowering.cpp

+8 −4
Original line number Diff line number Diff line
@@ -681,10 +681,14 @@ X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM, 
    setOperationAction(ISD::FNEG, MVT::f128, Custom);

    setOperationAction(ISD::FCOPYSIGN, MVT::f128, Custom);













    setOperationAction(ISD::FSIN,    MVT::f128, Expand);













    setOperationAction(ISD::FCOS,    MVT::f128, Expand);













    setOperationAction(ISD::FSINCOS, MVT::f128, Expand);













    setOperationAction(ISD::FSQRT,   MVT::f128, Expand);













    setOperationAction(ISD::FSIN,         MVT::f128, LibCall);













    setOperationAction(ISD::STRICT_FSIN,  MVT::f128, LibCall);













    setOperationAction(ISD::FCOS,         MVT::f128, LibCall);













    setOperationAction(ISD::STRICT_FCOS,  MVT::f128, LibCall);













    setOperationAction(ISD::FSINCOS,      MVT::f128, LibCall);













    // No STRICT_FSINCOS













    setOperationAction(ISD::FSQRT,        MVT::f128, LibCall);













    setOperationAction(ISD::STRICT_FSQRT, MVT::f128, LibCall);





























    setOperationAction(ISD::FP_EXTEND, MVT::f128, Custom);















    // We need to custom handle any FP_ROUND with an f128 input, but

























llvm/test/CodeGen/X86/fp128-libcalls-strict.ll



+247
−0






























Original line number
Diff line number
Diff line








@@ -66,6 +66,234 @@ entry:













  ret fp128 %fma















}





























define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {













; CHECK-LABEL: frem:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq fmodl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %div = call fp128 @llvm.experimental.constrained.frem.f128(fp128 %x, fp128 %y,  metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %div













}



























define fp128 @ceil(fp128 %x) nounwind strictfp {













; CHECK-LABEL: ceil:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq ceill













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %ceil













}



























define fp128 @cos(fp128 %x) nounwind strictfp {













; CHECK-LABEL: cos:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq cosl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %cos = call fp128 @llvm.experimental.constrained.cos.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %cos













}



























define fp128 @exp(fp128 %x) nounwind strictfp {













; CHECK-LABEL: exp:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq expl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %exp = call fp128 @llvm.experimental.constrained.exp.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %exp













}



























define fp128 @exp2(fp128 %x) nounwind strictfp {













; CHECK-LABEL: exp2:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq exp2l













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %exp2 = call fp128 @llvm.experimental.constrained.exp2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %exp2













}



























define fp128 @floor(fp128 %x) nounwind strictfp {













; CHECK-LABEL: floor:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq floorl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %floor













}



























define fp128 @log(fp128 %x) nounwind strictfp {













; CHECK-LABEL: log:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq logl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %log = call fp128 @llvm.experimental.constrained.log.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %log













}



























define fp128 @log10(fp128 %x) nounwind strictfp {













; CHECK-LABEL: log10:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq log10l













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %log10 = call fp128 @llvm.experimental.constrained.log10.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %log10













}



























define fp128 @log2(fp128 %x) nounwind strictfp {













; CHECK-LABEL: log2:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq log2l













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %log2 = call fp128 @llvm.experimental.constrained.log2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %log2













}



























define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {













; CHECK-LABEL: maxnum:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq fmaxl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %maxnum













}



























define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {













; CHECK-LABEL: minnum:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq fminl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %minnum













}



























define fp128 @nearbyint(fp128 %x) nounwind strictfp {













; CHECK-LABEL: nearbyint:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq nearbyintl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %nearbyint = call fp128 @llvm.experimental.constrained.nearbyint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %nearbyint













}



























define fp128 @pow(fp128 %x, fp128 %y) nounwind strictfp {













; CHECK-LABEL: pow:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq powl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %pow = call fp128 @llvm.experimental.constrained.pow.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %pow













}



























define fp128 @powi(fp128 %x, i32 %y) nounwind strictfp {













; CHECK-LABEL: powi:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq __powitf2













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %powi = call fp128 @llvm.experimental.constrained.powi.f128(fp128 %x, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %powi













}



























define fp128 @rint(fp128 %x) nounwind strictfp {













; CHECK-LABEL: rint:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq rintl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %rint = call fp128 @llvm.experimental.constrained.rint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %rint













}



























define fp128 @round(fp128 %x) nounwind strictfp {













; CHECK-LABEL: round:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq roundl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %round













}



























define fp128 @sin(fp128 %x) nounwind strictfp {













; CHECK-LABEL: sin:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq sinl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %sin = call fp128 @llvm.experimental.constrained.sin.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %sin













}



























define fp128 @sqrt(fp128 %x) nounwind strictfp {













; CHECK-LABEL: sqrt:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq sqrtl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %sqrt = call fp128 @llvm.experimental.constrained.sqrt.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %sqrt













}



























define fp128 @trunc(fp128 %x) nounwind strictfp {













; CHECK-LABEL: trunc:













; CHECK:       # %bb.0: # %entry













; CHECK-NEXT:    pushq %rax













; CHECK-NEXT:    callq truncl













; CHECK-NEXT:    popq %rax













; CHECK-NEXT:    retq













entry:













  %trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0













  ret fp128 %trunc













}





























attributes #0 = { strictfp }































declare fp128 @llvm.experimental.constrained.fadd.f128(fp128, fp128, metadata, metadata)









@@ -73,3 +301,22 @@ declare fp128 @llvm.experimental.constrained.fsub.f128(fp128, fp128, metadata, m













declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, metadata)















declare fp128 @llvm.experimental.constrained.fdiv.f128(fp128, fp128, metadata, metadata)















declare fp128 @llvm.experimental.constrained.fma.f128(fp128, fp128, fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.frem.f128(fp128, fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.cos.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.exp.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.exp2.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.log.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.log10.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.log2.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.pow.f128(fp128, fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.powi.f128(fp128, i32, metadata, metadata)













declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.sin.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)













declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)