[Flang] Revert "[Flang] Add support for -ffast-real-mod (llvm#4164)" (llvm#4284)

Author: ronlieb

clang/include/clang/Driver/Options.td

@@ -2759,7 +2759,6 @@ def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">
   Group<f_Group>;
 def fassociative_math : Flag<["-"], "fassociative-math">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
 def fno_associative_math : Flag<["-"], "fno-associative-math">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
-def ffast_real_mod : Flag<["-"], "ffast-real-mod">, Visibility<[FlangOption, FC1Option]>, Group<f_Group>;
 defm reciprocal_math : BoolFOption<"reciprocal-math",
   LangOpts<"AllowRecip">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption, CC1Option, FC1Option, FlangOption],
@@ -7576,6 +7575,7 @@ def emit_mlir : Flag<["-"], "emit-mlir">, Alias<emit_fir>;
 
 def emit_hlfir : Flag<["-"], "emit-hlfir">, Group<Action_Group>,
   HelpText<"Build the parse tree, then lower it to HLFIR">;
+
 } // let Visibility = [FC1Option]
 
 //===----------------------------------------------------------------------===//

clang/lib/Driver/ToolChains/Flang.cpp

@@ -857,9 +857,6 @@ static void addFloatingPointOptions(const Driver &D, const ArgList &Args,
 
   if (ReciprocalMath)
     CmdArgs.push_back("-freciprocal-math");
-
-  if (Args.hasArg(options::OPT_ffast_real_mod))
-    CmdArgs.push_back("-ffast-real-mod");
 }
 
 static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs,

flang/include/flang/Support/LangOptions.def

@@ -60,8 +60,7 @@ LANGOPT(OpenMPNoThreadState, 1, 0)
 LANGOPT(OpenMPNoNestedParallelism, 1, 0)
 /// Use SIMD only OpenMP support.
 LANGOPT(OpenMPSimd, 1, false)
-/// Enable fast MOD operations for REAL
-LANGOPT(FastRealMod, 1, false)
+
 LANGOPT(VScaleMin, 32, 0)  ///< Minimum vscale range value
 LANGOPT(VScaleMax, 32, 0)  ///< Maximum vscale range value
 

flang/lib/Frontend/CompilerInvocation.cpp

@@ -1444,10 +1444,6 @@ static bool parseFloatingPointArgs(CompilerInvocation &invoc,
     opts.setFPContractMode(Fortran::common::LangOptions::FPM_Fast);
   }
 
-  if (args.hasArg(clang::driver::options::OPT_ffast_real_mod)) {
-    opts.FastRealMod = true;
-  }
-
   return true;
 }
 

flang/lib/Frontend/FrontendActions.cpp

@@ -277,14 +277,6 @@ bool CodeGenAction::beginSourceFileAction() {
                               ci.getInvocation().getLangOpts().OpenMPVersion);
   }
 
-  if (ci.getInvocation().getLangOpts().FastRealMod) {
-    auto mod = lb.getModule();
-    mod.getOperation()->setAttr(
-        mlir::StringAttr::get(mod.getContext(),
-                              llvm::Twine{"fir.fast_real_mod"}),
-        mlir::BoolAttr::get(mod.getContext(), true));
-  }
-
   // Create a parse tree and lower it to FIR
   parseAndLowerTree(ci, lb);
 

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

@@ -46,7 +46,6 @@
 #include "flang/Optimizer/Support/Utils.h"
 #include "flang/Runtime/entry-names.h"
 #include "flang/Runtime/iostat-consts.h"
-#include "flang/Support/LangOptions.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
@@ -6990,30 +6989,8 @@ mlir::Value IntrinsicLibrary::genMergeBits(mlir::Type resultType,
 }
 
 // MOD
-static mlir::Value genFastMod(fir::FirOpBuilder &builder, mlir::Location loc,
-                              mlir::Value a, mlir::Value p) {
-  auto fastmathFlags = mlir::arith::FastMathFlags::contract;
-  auto fastmathAttr =
-      mlir::arith::FastMathFlagsAttr::get(builder.getContext(), fastmathFlags);
-  mlir::Value divResult = mlir::arith::DivFOp::create(builder, loc, a, p, fastmathAttr);
-  mlir::Type intType = builder.getIntegerType(
-      a.getType().getIntOrFloatBitWidth(), /*signed=*/true);
-  mlir::Value intResult = builder.createConvert(loc, intType, divResult);
-  mlir::Value cnvResult = builder.createConvert(loc, a.getType(), intResult);
-  mlir::Value mulResult =
-      mlir::arith::MulFOp::create(builder, loc, cnvResult, p, fastmathAttr);
-  mlir::Value subResult =
-      mlir::arith::SubFOp::create(builder, loc, a, mulResult, fastmathAttr);
-  return subResult;
-}
-
 mlir::Value IntrinsicLibrary::genMod(mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) {
-  auto mod = builder.getModule();
-  bool useFastRealMod = false;
-  if (auto attr = mod->getAttrOfType<mlir::BoolAttr>("fir.fast_real_mod"))
-    useFastRealMod = attr.getValue();
-
   assert(args.size() == 2);
   if (resultType.isUnsignedInteger()) {
     mlir::Type signlessType = mlir::IntegerType::get(
@@ -7025,18 +7002,9 @@ mlir::Value IntrinsicLibrary::genMod(mlir::Type resultType,
   if (mlir::isa<mlir::IntegerType>(resultType))
     return mlir::arith::RemSIOp::create(builder, loc, args[0], args[1]);
 
-  if (useFastRealMod) {
-    // If fast MOD for REAL has been requested, generate less precise,
-    // but faster code directly.
-    assert(resultType.isFloat() &&
-           "non floating-point type hit for fast real MOD");
-    return builder.createConvert(loc, resultType,
-                                 genFastMod(builder, loc, args[0], args[1]));
-  } else {
-    // Use runtime.
-    return builder.createConvert(
-        loc, resultType, fir::runtime::genMod(builder, loc, args[0], args[1]));
-  }
+  // Use runtime.
+  return builder.createConvert(
+      loc, resultType, fir::runtime::genMod(builder, loc, args[0], args[1]));
 }
 
 // MODULO