Revert "Add FMF support for fptrunc/fpext (AliveToolkit#1131)"

This reverts commit 9ffc75d.

Author: jmciver

ir/instr.cpp

@@ -1713,9 +1713,9 @@ unique_ptr<Instr> ConversionOp::dup(Function &f, const string &suffix) const {
 
 FpConversionOp::FpConversionOp(Type &type, std::string &&name, Value &val,
                                Op op, FpRoundingMode rm, FpExceptionMode ex,
-                               unsigned flags, FastMathFlags fmath)
+                               unsigned flags)
     : Instr(type, std::move(name)), val(&val), op(op), rm(rm), ex(ex),
-      flags(flags), fmath(fmath) {
+      flags(flags) {
   switch (op) {
   case UIntToFP:
     assert((flags & NNEG) == flags);
@@ -1724,14 +1724,6 @@ FpConversionOp::FpConversionOp(Type &type, std::string &&name, Value &val,
     assert(flags == 0);
     break;
   }
-  switch (op) {
-  case FPTrunc:
-  case FPExt:
-    break;
-  default:
-    assert(fmath.isNone());
-    break;
-  }
 }
 
 vector<Value*> FpConversionOp::operands() const {
@@ -1768,8 +1760,6 @@ void FpConversionOp::print(ostream &os) const {
   os << getName() << " = " << str;
   if (flags & NNEG)
     os << "nneg ";
-  if (!fmath.isNone())
-    os << fmath;
   os << *val << print_type(getType(), " to ", "");
   if (!rm.isDefault())
     os << ", rounding=" << rm;
@@ -1779,8 +1769,7 @@ void FpConversionOp::print(ostream &os) const {
 
 StateValue FpConversionOp::toSMT(State &s) const {
   auto &v = s[*val];
-  function<StateValue(const expr &, const Type &, const expr &)> fn;
-  function<StateValue(const StateValue &, const Type &, const Type &)> scalar;
+  function<StateValue(const expr &, const Type &, const expr&)> fn;
 
   switch (op) {
   case SIntToFP:
@@ -1864,43 +1853,37 @@ StateValue FpConversionOp::toSMT(State &s) const {
     break;
   case FPExt:
   case FPTrunc:
-    scalar = [&](const StateValue &sv, const Type &from_type,
-                 const Type &to_type) -> StateValue {
-      auto fn = [&](auto &v, auto &rm) {
-        return v.float2Float(to_type.getAsFloatType()->getDummyFloat(), rm);
-      };
-      return fm_poison(s, sv.value, sv.non_poison, fn, from_type, fmath, rm,
-                       false, false, &to_type);
+    fn = [](auto &val, auto &to_type, auto &rm) -> StateValue {
+      return { val.float2Float(to_type.getAsFloatType()->getDummyFloat(), rm),
+               true };
     };
     break;
   }
 
-  if (!scalar)
-    scalar = [&](const StateValue &sv, const Type &from_type,
-                 const Type &to_type) -> StateValue {
-      auto val = sv.value;
+  auto scalar = [&](const StateValue &sv, const Type &from_type,
+                    const Type &to_type) -> StateValue {
+    auto val = sv.value;
 
-      if (from_type.isFloatType()) {
-        auto ty = from_type.getAsFloatType();
-        val = ty->getFloat(val);
-      }
+    if (from_type.isFloatType()) {
+      auto ty = from_type.getAsFloatType();
+      val     = ty->getFloat(val);
+    }
 
-      function<StateValue(const expr &)> fn_rm = [&](auto &rm) {
-        return fn(val, to_type, rm);
-      };
-      AndExpr np;
-      np.add(sv.non_poison);
-
-      StateValue ret = to_type.isFloatType() ? round_value(s, rm, np, fn_rm)
-                                             : fn(val, to_type, rm.toSMT());
-      np.add(std::move(ret.non_poison));
-
-      return {to_type.isFloatType() ? to_type.getAsFloatType()->fromFloat(
-                                          s, ret.value, from_type,
-                                          from_type.isFloatType(), sv.value)
-                                    : std::move(ret.value),
-              np()};
-    };
+    function<StateValue(const expr&)> fn_rm
+      = [&](auto &rm) { return fn(val, to_type, rm); };
+    AndExpr np;
+    np.add(sv.non_poison);
+
+    StateValue ret = to_type.isFloatType() ? round_value(s, rm, np, fn_rm)
+                                           : fn(val, to_type, rm.toSMT());
+    np.add(std::move(ret.non_poison));
+
+    return { to_type.isFloatType()
+               ? to_type.getAsFloatType()
+                   ->fromFloat(s, ret.value, from_type, from_type.isFloatType(),
+                               sv.value)
+               : std::move(ret.value), np()};
+  };
 
   if (getType().isVectorType()) {
     vector<StateValue> vals;
@@ -1948,8 +1931,8 @@ expr FpConversionOp::getTypeConstraints(const Function &f) const {
 }
 
 unique_ptr<Instr> FpConversionOp::dup(Function &f, const string &suffix) const {
-  return make_unique<FpConversionOp>(getType(), getName() + suffix, *val, op,
-                                     rm, ex, flags, fmath);
+  return
+    make_unique<FpConversionOp>(getType(), getName() + suffix, *val, op, rm);
 }
 
 

ir/instr.h

@@ -323,20 +323,16 @@ class FpConversionOp final : public Instr {
   FpRoundingMode rm;
   FpExceptionMode ex;
   unsigned flags;
-  FastMathFlags fmath;
 
 public:
   FpConversionOp(Type &type, std::string &&name, Value &val, Op op,
                  FpRoundingMode rm = {}, FpExceptionMode ex = {},
-                 unsigned flags = None, FastMathFlags fmath = {});
+                 unsigned flags = None);
 
   Op getOp() const { return op; }
   FpRoundingMode getRoundingMode() const { return rm; }
   FpExceptionMode getExceptionMode() const { return ex; }
   unsigned getFlags() const { return flags; }
-  FastMathFlags getFastMathFlags() const {
-    return fmath;
-  }
 
   std::vector<Value*> operands() const override;
   bool propagatesPoison() const override;

llvm_util/llvm2alive.cpp

@@ -318,7 +318,7 @@ class llvm2alive_ : public llvm::InstVisitor<llvm2alive_, unique_ptr<Instr>> {
     }
     return make_unique<FpConversionOp>(*ty, value_name(i), *val, op,
                                        FpRoundingMode{}, FpExceptionMode{},
-                                       flags, parse_fmath(i));
+                                       flags);
   }
 
   RetTy visitFreezeInst(llvm::FreezeInst &i) {

tests/alive-tv/fp/fpext-trunc.srctgt.ll

@@ -7,27 +7,3 @@ define half @src(half %0) {
 define half @tgt(half %0) {
   ret half %0
 }
-
-define half @src1(float noundef %a) {
-  %b = fneg nnan float %a
-  %c = fptrunc nnan float %b to half
-  ret half %c
-}
-
-define half @tgt1(float noundef %a) {
-  %b = fptrunc nnan float %a to half
-  %c = fneg nnan half %b
-  ret half %c
-}
-
-define half @src2(half noundef %a) {
-  %av = fpext nnan half %a to float
-  %c = fadd nnan float %av, %av
-  %d = fptrunc nnan float %c to half
-  ret half %d
-}
-
-define half @tgt2(half noundef %a) {
-  %b = fadd nnan half %a, %a
-  ret half %b
-}