[flang] Configure FirOpBuilder based on math driver options.

[vzakhari]

Summary

Added MathOptionsBase to share fastmath config between different
components. Frontend driver translates LangOptions into MathOptionsBase.
FirConverter configures FirOpBuilder using MathOptionsBase
config passed to it via LoweringOptions.

Depends on D137390

[tblah]

Thanks for adding this. The warnings that -ffp-contract and -menable-no-infs are unimplemented also need to be removed (parseFloatingPointArgs in CompilerInvocation.cpp).

flang/lib/Frontend/CompilerInvocation.cpp

924–926

Perhaps the math options should be moved from LangOptions to LoweringOptions so we don't have to maintain two copies? Clang keeps them in LangOptions but I think LoweringOptions makes more sense in this context.

[jeanPerier]

Looks good, how do you plan to thread the option to the FirOpBuilder created in the FIR passes ?

[awarzynski]

flang/lib/Frontend/CompilerInvocation.cpp

924–926

I don't have a strong opinion - quite often these things fit in multiple places. I'm happy with whatever you decide :)

[tschuett]

flang/include/flang/Common/MathOptionsBase.def

20

Allow

[vzakhari]

In D137391#3907739, @tblah wrote:

Thanks for adding this. The warnings that -ffp-contract and -menable-no-infs are unimplemented also need to be removed (parseFloatingPointArgs in CompilerInvocation.cpp).

I would not remove the warnings just yet, because there is still no complete support (e.g. the intrinsics simplification pass ignores fastmath completely). We can probably reword the warnings as "the option is partially supported" or just leave them as-is.

In D137391#3908124, @jeanPerier wrote:

Looks good, how do you plan to thread the option to the FirOpBuilder created in the FIR passes ?

I think most of the passes will not need to take the options explicitly. For example, I suggest that for intrinsics simplification pass the FIR/MLIR generation inherits the flags from the original intrinsic calls (this implies that fir.call supports arith::FastMathAttr).
If there is a pass that needs the math options, we can pass them as the pass options (e.g. as in https://reviews.llvm.org/D137114#change-wdpbNxC4VXer, but using MathOptionsBase vs the string). So CodeGenAction::generateLLVMIR will pass the math options to createDefaultFIRCodeGenPassPipeline and they will propagate further to the passes.

flang/include/flang/Common/MathOptionsBase.def

20

Thanks! Will fix.

flang/lib/Frontend/CompilerInvocation.cpp

924–926

I am not sure about this. LoweringOptions are targeting the lowering in particular. The driver math options may need to be propagated not only to lowering, so it makes sense to have them in some unrelated collection. I guess LangOptions is a suitable name and it may contain more than math options. I do not have strong opinion here either. I think it should not be a big deal to copy MathOptionsBase from one structure to another.

[tblah]

I would not remove the warnings just yet, because there is still no complete support (e.g. the intrinsics simplification pass ignores fastmath completely). We can probably reword the warnings as "the option is partially supported" or just leave them as-is.

Thanks for explaining. Either option is fine with me.

[jeanPerier]

Thanks, sounds good to me

[vzakhari]

Thank you all for the review!

flang/include/flang/Common/MathOptionsBase.h

+//===- MathOptionsBase.h - Math options config ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Options controlling mathematical computations generated in FIR.
+/// This is intended to be header-only implementation without extra
+/// dependencies so that multiple components can use it to exchange
+/// math configuration.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_COMMON_MATHOPTIONSBASE_H
+#define FORTRAN_COMMON_MATHOPTIONSBASE_H
+
+namespace Fortran::common {
+
+class MathOptionsBase {
+public:
+#define ENUM_MATHOPT(Name, Type, Bits, Default) \
+  Type get##Name() const { return static_cast<Type>(Name); } \
+  MathOptionsBase &set##Name(Type Value) { \
+    Name = static_cast<unsigned>(Value); \
+    return *this; \
+  }
+#include "flang/Common/MathOptionsBase.def"
+
+  MathOptionsBase() {
+#define ENUM_MATHOPT(Name, Type, Bits, Default) set##Name(Default);
+#include "flang/Common/MathOptionsBase.def"
+  }
+
+private:
+#define ENUM_MATHOPT(Name, Type, Bits, Default) unsigned Name : Bits;
+#include "flang/Common/MathOptionsBase.def"
+};
+
+} // namespace Fortran::common
+
+#endif // FORTRAN_COMMON_MATHOPTIONSBASE_H

flang/include/flang/Common/MathOptionsBase.def

+//===--- MathOptionsBase.def - Math options config ---------------- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines math options. Users of this file must define
+/// ENUM_MATHOPT macro to make use of this information.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef ENUM_MATHOPT
+#  error Define the ENUM_MATHOPT macro to handle lowering options
+#endif
+
+/// Alow fusing FP operations (e.g. create FMAs from mul/add).
+ENUM_MATHOPT(FPContractEnabled, unsigned, 1, 0)
+
+/// Permit floating point optimizations without regard to infinities.
+ENUM_MATHOPT(NoHonorInfs, unsigned, 1, 0)
+
+#undef ENUM_MATHOPT

flang/include/flang/Lower/LoweringOptions.h

 /// Options controlling lowering of front-end fragments to the FIR dialect
 /// of MLIR
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef FLANG_LOWER_LOWERINGOPTIONS_H
 #define FLANG_LOWER_LOWERINGOPTIONS_H
 
+#include "flang/Common/MathOptionsBase.h"
+
 namespace Fortran::lower {
 
 class LoweringOptionsBase {
 public:
 #define LOWERINGOPT(Name, Bits, Default) unsigned Name : Bits;
 #define ENUM_LOWERINGOPT(Name, Type, Bits, Default)
 #include "flang/Lower/LoweringOptions.def"
 
#define ENUM_LOWERINGOPT(Name, Type, Bits, Default)                            \
   Type get##Name() const { return static_cast<Type>(Name); }                   \
   LoweringOptions &set##Name(Type Value) {                                     \
     Name = static_cast<unsigned>(Value);                                       \
     return *this;                                                              \
   }
 #include "flang/Lower/LoweringOptions.def"
 
   LoweringOptions();
+
+  const Fortran::common::MathOptionsBase &getMathOptions() const {
+    return MathOptions;
+  }
+
+  Fortran::common::MathOptionsBase &getMathOptions() { return MathOptions; }
+
+private:
+  /// Options for handling/optimizing mathematical computations.
+  Fortran::common::MathOptionsBase MathOptions;
 };
 
 } // namespace Fortran::lower
 
 #endif // FLANG_LOWER_LOWERINGOPTIONS_H

flang/include/flang/Optimizer/Builder/FIRBuilder.h

 // style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
 // module.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
 #define FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
 
+#include "flang/Common/MathOptionsBase.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 
public:
 
   /// Set default FastMathFlags value for all operations
   /// supporting mlir::arith::FastMathAttr that will be created
   /// by this builder.
   void setFastMathFlags(mlir::arith::FastMathFlags flags) {
     fastMathFlags = flags;
   }
 
+  /// Set default FastMathFlags value from the passed MathOptionsBase
+  /// config.
+  void setFastMathFlags(Fortran::common::MathOptionsBase options);
+
   /// Set attributes (e.g. FastMathAttr) to \p op operation
   /// based on the current attributes setting.
   void setCommonAttributes(mlir::Operation *op) const;
 
   /// FirOpBuilder hook for creating new operation.
   virtual void notifyOperationInserted(mlir::Operation *op) override {
     setCommonAttributes(op);
   }

flang/lib/Frontend/CompilerInvocation.cpp

if (targetTriple.getArch() != llvm::Triple::ArchType::x86_64) {
     semanticsContext->targetCharacteristics().DisableType(
         Fortran::common::TypeCategory::Real, /*kind=*/10);
   }
 }
 
 /// Set \p loweringOptions controlling lowering behavior based
 /// on the \p optimizationLevel.
 void CompilerInvocation::setLoweringOptions() {
-  const auto &codegenOpts = getCodeGenOpts();
+  const CodeGenOptions &codegenOpts = getCodeGenOpts();
 
   // Lower TRANSPOSE as a runtime call under -O0.
   loweringOpts.setOptimizeTranspose(codegenOpts.OptimizationLevel > 0);
+
+  const LangOptions &langOptions = getLangOpts();
+  Fortran::common::MathOptionsBase &mathOpts = loweringOpts.getMathOptions();
+  // TODO: when LangOptions are finalized, we can represent
+  //       the math related options using Fortran::commmon::MathOptionsBase,
+  //       so that we can just copy it into LoweringOptions.
+  mathOpts
+      .setFPContractEnabled(langOptions.getFPContractMode() ==
+                            LangOptions::FPM_Fast)
+      .setNoHonorInfs(langOptions.NoHonorInfs);
 }

flang/lib/Lower/Bridge.cpp

#endif
 
   /// Prepare to translate a new function
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     assert(!builder && "expected nullptr");
     Fortran::lower::CalleeInterface callee(funit, *this);
     mlir::func::FuncOp func = callee.addEntryBlockAndMapArguments();
     builder = new fir::FirOpBuilder(func, bridge.getKindMap());
     assert(builder && "FirOpBuilder did not instantiate");
+    builder->setFastMathFlags(bridge.getLoweringOptions().getMathOptions());
     builder->setInsertionPointToStart(&func.front());
     func.setVisibility(mlir::SymbolTable::Visibility::Public);
 
     mapDummiesAndResults(funit, callee);
 
     // Note: not storing Variable references because getOrderedSymbolTable
     // below returns a temporary.
     llvm::SmallVector<Fortran::lower::pft::Variable> deferredFuncResultList;
void createGlobalOutsideOfFunctionLowering(
     // globals directly into the module.
     mlir::MLIRContext *context = &getMLIRContext();
     mlir::func::FuncOp func = fir::FirOpBuilder::createFunction(
         mlir::UnknownLoc::get(context), getModuleOp(),
         fir::NameUniquer::doGenerated("Sham"),
         mlir::FunctionType::get(context, llvm::None, llvm::None));
     func.addEntryBlock();
     builder = new fir::FirOpBuilder(func, bridge.getKindMap());
+    assert(builder && "FirOpBuilder did not instantiate");
+    builder->setFastMathFlags(bridge.getLoweringOptions().getMathOptions());
     createGlobals();
     if (mlir::Region *region = func.getCallableRegion())
       region->dropAllReferences();
     func.erase();
     delete builder;
     builder = nullptr;
     localSymbols.clear();
   }

flang/lib/Lower/LoweringOptions.cpp

 //===--- LoweringOptions.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/LoweringOptions.h"
 
 namespace Fortran::lower {
 
-LoweringOptions::LoweringOptions() {
+LoweringOptions::LoweringOptions() : MathOptions{} {
 #define LOWERINGOPT(Name, Bits, Default) Name = Default;
 #define ENUM_LOWERINGOPT(Name, Type, Bits, Default) set##Name(Default);
 #include "flang/Lower/LoweringOptions.def"
 }
 
 } // namespace Fortran::lower

flang/lib/Optimizer/Builder/FIRBuilder.cpp

void fir::FirOpBuilder::setCommonAttributes(mlir::Operation *op) const {
   // TODO: use fmi.setFastMathFlagsAttr() after D137114 is merged.
   //       For now set the attribute by the name.
   llvm::StringRef arithFMFAttrName = fmi.getFastMathAttrName();
   if (fastMathFlags != mlir::arith::FastMathFlags::none)
     op->setAttr(arithFMFAttrName, mlir::arith::FastMathFlagsAttr::get(
                                       op->getContext(), fastMathFlags));
 }
 
+void fir::FirOpBuilder::setFastMathFlags(
+    Fortran::common::MathOptionsBase options) {
+  mlir::arith::FastMathFlags arithFMF{};
+  if (options.getFPContractEnabled()) {
+    arithFMF = arithFMF | mlir::arith::FastMathFlags::contract;
+  }
+  if (options.getNoHonorInfs()) {
+    arithFMF = arithFMF | mlir::arith::FastMathFlags::ninf;
+  }
+  setFastMathFlags(arithFMF);
+}
+
 //===--------------------------------------------------------------------===//
 // ExtendedValue inquiry helper implementation
 //===--------------------------------------------------------------------===//
 
 mlir::Value fir::factory::readCharLen(fir::FirOpBuilder &builder,
                                       mlir::Location loc,
                                       const fir::ExtendedValue &box) {
   return box.match(

flang/test/Lower/fast-math-arithmetic.f90

+! RUN: %flang_fc1 -emit-fir -ffp-contract=fast %s -o - 2>&1 | FileCheck --check-prefixes=CONTRACT,ALL %s
+! RUN: %flang_fc1 -emit-fir -menable-no-infs %s -o - 2>&1 | FileCheck --check-prefixes=NINF,ALL %s
+
+! ALL-LABEL: func.func @_QPtest
+subroutine test(x)
+  real x
+! CONTRACT: arith.mulf{{.*}}, {{.*}} fastmath<[[ATTRS:contract]]> : f32
+! NINF: arith.mulf{{.*}}, {{.*}} fastmath<[[ATTRS:ninf]]> : f32
+! ALL: arith.divf{{.*}}, {{.*}} fastmath<[[ATTRS]]> : f32
+! ALL: arith.addf{{.*}}, {{.*}} fastmath<[[ATTRS]]> : f32
+! ALL: arith.subf{{.*}}, {{.*}} fastmath<[[ATTRS]]> : f32
+  x = x * x + x / x - x
+end subroutine test