[llvm] f21f1ee - [FPEnv] EarlyCSE support for constrained intrinsics, default FP environment edition
Kevin P. Neal via llvm-commits
llvm-commits at lists.llvm.org
Thu May 20 11:40:58 PDT 2021
Author: Kevin P. Neal
Date: 2021-05-20T14:40:51-04:00
New Revision: f21f1eea05d65dbd6992fdb6b2bf1d5b4f657166
URL: https://github.com/llvm/llvm-project/commit/f21f1eea05d65dbd6992fdb6b2bf1d5b4f657166
DIFF: https://github.com/llvm/llvm-project/commit/f21f1eea05d65dbd6992fdb6b2bf1d5b4f657166.diff
LOG: [FPEnv] EarlyCSE support for constrained intrinsics, default FP environment edition
EarlyCSE cannot distinguish between floating point instructions and
constrained floating point intrinsics that are marked as running in the
default FP environment. Said intrinsics are supposed to behave exactly the
same as the regular FP instructions. Teach EarlyCSE to handle them in that
case.
Differential Revision: https://reviews.llvm.org/D99962
Added:
llvm/test/Transforms/EarlyCSE/defaultfp-strictfp.ll
Modified:
llvm/include/llvm/IR/IntrinsicInst.h
llvm/lib/IR/IntrinsicInst.cpp
llvm/lib/Transforms/Scalar/EarlyCSE.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/IR/IntrinsicInst.h b/llvm/include/llvm/IR/IntrinsicInst.h
index 66540d20fdf51..1b38653006f37 100644
--- a/llvm/include/llvm/IR/IntrinsicInst.h
+++ b/llvm/include/llvm/IR/IntrinsicInst.h
@@ -432,6 +432,7 @@ class ConstrainedFPIntrinsic : public IntrinsicInst {
bool isTernaryOp() const;
Optional<RoundingMode> getRoundingMode() const;
Optional<fp::ExceptionBehavior> getExceptionBehavior() const;
+ bool isDefaultFPEnvironment() const;
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const IntrinsicInst *I);
diff --git a/llvm/lib/IR/IntrinsicInst.cpp b/llvm/lib/IR/IntrinsicInst.cpp
index a78b05109f88f..017836a1f9cbd 100644
--- a/llvm/lib/IR/IntrinsicInst.cpp
+++ b/llvm/lib/IR/IntrinsicInst.cpp
@@ -172,8 +172,10 @@ Value *InstrProfIncrementInst::getStep() const {
Optional<RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const {
unsigned NumOperands = getNumArgOperands();
- Metadata *MD =
- cast<MetadataAsValue>(getArgOperand(NumOperands - 2))->getMetadata();
+ Metadata *MD = nullptr;
+ auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2));
+ if (MAV)
+ MD = MAV->getMetadata();
if (!MD || !isa<MDString>(MD))
return None;
return StrToRoundingMode(cast<MDString>(MD)->getString());
@@ -182,13 +184,31 @@ Optional<RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const {
Optional<fp::ExceptionBehavior>
ConstrainedFPIntrinsic::getExceptionBehavior() const {
unsigned NumOperands = getNumArgOperands();
- Metadata *MD =
- cast<MetadataAsValue>(getArgOperand(NumOperands - 1))->getMetadata();
+ Metadata *MD = nullptr;
+ auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1));
+ if (MAV)
+ MD = MAV->getMetadata();
if (!MD || !isa<MDString>(MD))
return None;
return StrToExceptionBehavior(cast<MDString>(MD)->getString());
}
+bool ConstrainedFPIntrinsic::isDefaultFPEnvironment() const {
+ Optional<fp::ExceptionBehavior> Except = getExceptionBehavior();
+ if (Except) {
+ if (Except.getValue() != fp::ebIgnore)
+ return false;
+ }
+
+ Optional<RoundingMode> Rounding = getRoundingMode();
+ if (Rounding) {
+ if (Rounding.getValue() != RoundingMode::NearestTiesToEven)
+ return false;
+ }
+
+ return true;
+}
+
FCmpInst::Predicate ConstrainedFPCmpIntrinsic::getPredicate() const {
Metadata *MD = cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
if (!MD || !isa<MDString>(MD))
diff --git a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp
index 3905ceb754d6d..978c6a77b8dc3 100644
--- a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp
+++ b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp
@@ -108,8 +108,29 @@ struct SimpleValue {
static bool canHandle(Instruction *Inst) {
// This can only handle non-void readnone functions.
- if (CallInst *CI = dyn_cast<CallInst>(Inst))
+ // Also handled are constrained intrinsic that look like the types
+ // of instruction handled below (UnaryOperator, etc.).
+ if (CallInst *CI = dyn_cast<CallInst>(Inst)) {
+ if (Function *F = CI->getCalledFunction()) {
+ switch ((Intrinsic::ID)F->getIntrinsicID()) {
+ case Intrinsic::experimental_constrained_fadd:
+ case Intrinsic::experimental_constrained_fsub:
+ case Intrinsic::experimental_constrained_fmul:
+ case Intrinsic::experimental_constrained_fdiv:
+ case Intrinsic::experimental_constrained_frem:
+ case Intrinsic::experimental_constrained_fptosi:
+ case Intrinsic::experimental_constrained_sitofp:
+ case Intrinsic::experimental_constrained_fptoui:
+ case Intrinsic::experimental_constrained_uitofp:
+ case Intrinsic::experimental_constrained_fcmp:
+ case Intrinsic::experimental_constrained_fcmps: {
+ auto *CFP = cast<ConstrainedFPIntrinsic>(CI);
+ return CFP->isDefaultFPEnvironment();
+ }
+ }
+ }
return CI->doesNotAccessMemory() && !CI->getType()->isVoidTy();
+ }
return isa<CastInst>(Inst) || isa<UnaryOperator>(Inst) ||
isa<BinaryOperator>(Inst) || isa<GetElementPtrInst>(Inst) ||
isa<CmpInst>(Inst) || isa<SelectInst>(Inst) ||
diff --git a/llvm/test/Transforms/EarlyCSE/defaultfp-strictfp.ll b/llvm/test/Transforms/EarlyCSE/defaultfp-strictfp.ll
new file mode 100644
index 0000000000000..978f18f013272
--- /dev/null
+++ b/llvm/test/Transforms/EarlyCSE/defaultfp-strictfp.ll
@@ -0,0 +1,322 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -S -early-cse -earlycse-debug-hash | FileCheck %s
+; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s
+
+; Test use of constrained floating point intrinsics in the default
+; floating point environment.
+
+define double @multiple_fadd(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fadd(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fadd.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0:[0-9]+]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fadd.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %2 = call double @llvm.experimental.constrained.fadd.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_fadd_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fadd_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fadd.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fadd.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call double @llvm.experimental.constrained.fadd.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_fsub(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fsub(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fsub.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fsub.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %2 = call double @llvm.experimental.constrained.fsub.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_fsub_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fsub_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fsub.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fsub.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call double @llvm.experimental.constrained.fsub.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_fmul(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fmul(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fmul.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fmul.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %2 = call double @llvm.experimental.constrained.fmul.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_fmul_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fmul_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fmul.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fmul.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call double @llvm.experimental.constrained.fmul.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_fdiv(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fdiv(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fdiv.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fdiv.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %2 = call double @llvm.experimental.constrained.fdiv.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_fdiv_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fdiv_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.fdiv.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.fdiv.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call double @llvm.experimental.constrained.fdiv.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_frem(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_frem(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.frem.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.frem.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %2 = call double @llvm.experimental.constrained.frem.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define double @multiple_frem_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_frem_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.frem.f64(double [[A:%.*]], double [[B:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.frem.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call double @llvm.experimental.constrained.frem.f64(double %a, double %b, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %2) #0
+ ret double %2
+}
+
+define i32 @multiple_fptoui(double %a) #0 {
+; CHECK-LABEL: @multiple_fptoui(
+; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double [[A:%.*]], metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call i32 @bar.i32(i32 [[TMP1]], i32 [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret i32 [[TMP1]]
+;
+ %1 = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ %2 = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ %3 = call i32 @bar.i32(i32 %1, i32 %1) #0
+ ret i32 %2
+}
+
+define i32 @multiple_fptoui_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fptoui_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double [[A:%.*]], metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call i32 @bar.i32(i32 [[TMP1]], i32 [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret i32 [[TMP1]]
+;
+ %1 = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ %3 = call i32 @bar.i32(i32 %1, i32 %1) #0
+ ret i32 %2
+}
+
+define double @multiple_uitofp(i32 %a) #0 {
+; CHECK-LABEL: @multiple_uitofp(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %2 = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %1) #0
+ ret double %2
+}
+
+define double @multiple_uitofp_split(i32 %a) #0 {
+; CHECK-LABEL: @multiple_uitofp_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %1) #0
+ ret double %2
+}
+
+define i32 @multiple_fptosi(double %a) #0 {
+; CHECK-LABEL: @multiple_fptosi(
+; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double [[A:%.*]], metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call i32 @bar.i32(i32 [[TMP1]], i32 [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret i32 [[TMP1]]
+;
+ %1 = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ %2 = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ %3 = call i32 @bar.i32(i32 %1, i32 %1) #0
+ ret i32 %2
+}
+
+define i32 @multiple_fptosi_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fptosi_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double [[A:%.*]], metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call i32 @bar.i32(i32 [[TMP1]], i32 [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret i32 [[TMP1]]
+;
+ %1 = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double %a, metadata !"fpexcept.ignore") #0
+ %3 = call i32 @bar.i32(i32 %1, i32 %1) #0
+ ret i32 %2
+}
+
+define double @multiple_sitofp(i32 %a) #0 {
+; CHECK-LABEL: @multiple_sitofp(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %2 = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %1) #0
+ ret double %2
+}
+
+define double @multiple_sitofp_split(i32 %a) #0 {
+; CHECK-LABEL: @multiple_sitofp_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = call double @foo.f64(double [[TMP1]], double [[TMP1]]) #[[ATTR0]]
+; CHECK-NEXT: ret double [[TMP1]]
+;
+ %1 = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+ %3 = call double @foo.f64(double %1, double %1) #0
+ ret double %2
+}
+
+define i1 @multiple_fcmp(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fcmp(
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[A:%.*]], double [[B:%.*]], metadata !"oeq", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = zext i1 [[TMP1]] to i32
+; CHECK-NEXT: [[TMP3:%.*]] = call i32 @bar.i32(i32 [[TMP2]], i32 [[TMP2]]) #[[ATTR0]]
+; CHECK-NEXT: ret i1 [[TMP1]]
+;
+ %1 = call i1 @llvm.experimental.constrained.fcmp.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ %2 = call i1 @llvm.experimental.constrained.fcmp.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ %3 = zext i1 %1 to i32
+ %4 = zext i1 %2 to i32
+ %5 = call i32 @bar.i32(i32 %3, i32 %4) #0
+ ret i1 %2
+}
+
+define i1 @multiple_fcmp_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fcmp_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[A:%.*]], double [[B:%.*]], metadata !"oeq", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = zext i1 [[TMP1]] to i32
+; CHECK-NEXT: [[TMP3:%.*]] = call i32 @bar.i32(i32 [[TMP2]], i32 [[TMP2]]) #[[ATTR0]]
+; CHECK-NEXT: ret i1 [[TMP1]]
+;
+ %1 = call i1 @llvm.experimental.constrained.fcmp.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call i1 @llvm.experimental.constrained.fcmp.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ %3 = zext i1 %1 to i32
+ %4 = zext i1 %2 to i32
+ %5 = call i32 @bar.i32(i32 %3, i32 %4) #0
+ ret i1 %2
+}
+
+define i1 @multiple_fcmps(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fcmps(
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f64(double [[A:%.*]], double [[B:%.*]], metadata !"oeq", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = zext i1 [[TMP1]] to i32
+; CHECK-NEXT: [[TMP3:%.*]] = call i32 @bar.i32(i32 [[TMP2]], i32 [[TMP2]]) #[[ATTR0]]
+; CHECK-NEXT: ret i1 [[TMP1]]
+;
+ %1 = call i1 @llvm.experimental.constrained.fcmps.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ %2 = call i1 @llvm.experimental.constrained.fcmps.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ %3 = zext i1 %1 to i32
+ %4 = zext i1 %2 to i32
+ %5 = call i32 @bar.i32(i32 %3, i32 %4) #0
+ ret i1 %2
+}
+
+define i1 @multiple_fcmps_split(double %a, double %b) #0 {
+; CHECK-LABEL: @multiple_fcmps_split(
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f64(double [[A:%.*]], double [[B:%.*]], metadata !"oeq", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT: call void @arbitraryfunc() #[[ATTR0]]
+; CHECK-NEXT: [[TMP2:%.*]] = zext i1 [[TMP1]] to i32
+; CHECK-NEXT: [[TMP3:%.*]] = call i32 @bar.i32(i32 [[TMP2]], i32 [[TMP2]]) #[[ATTR0]]
+; CHECK-NEXT: ret i1 [[TMP1]]
+;
+ %1 = call i1 @llvm.experimental.constrained.fcmps.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ call void @arbitraryfunc() #0
+ %2 = call i1 @llvm.experimental.constrained.fcmps.i1.f64(double %a, double %b, metadata !"oeq", metadata !"fpexcept.ignore") #0
+ %3 = zext i1 %1 to i32
+ %4 = zext i1 %2 to i32
+ %5 = call i32 @bar.i32(i32 %3, i32 %4) #0
+ ret i1 %2
+}
+
+attributes #0 = { strictfp }
+
+declare void @arbitraryfunc() #0
+declare double @foo.f64(double, double) #0
+declare i32 @bar.i32(i32, i32) #0
+
+declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
+declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata)
+declare i32 @llvm.experimental.constrained.fptoui.i32.f64(double, metadata)
+declare double @llvm.experimental.constrained.uitofp.f64.i32(i32, metadata, metadata)
+declare i32 @llvm.experimental.constrained.fptosi.i32.f64(double, metadata)
+declare double @llvm.experimental.constrained.sitofp.f64.i32(i32, metadata, metadata)
+declare i1 @llvm.experimental.constrained.fcmp.i1.f64(double, double, metadata, metadata)
+declare i1 @llvm.experimental.constrained.fcmps.i1.f64(double, double, metadata, metadata)
More information about the llvm-commits
mailing list