[flang] Add fastmath flags to localBuilder in IntrinsicCall

[DavidTruby]

Summary

Currently the local builder used in IntrinsicCall doesn't have the
fastmath flags passed to it. This results in the fastmath attribute
not being added to certain runtime calls. This patch simply forwards
the fastmath flags from the parent builder.

[DavidTruby]

The main motivation of this is so that we can access the fastmath flags when generating complex operations, and only use the mlir complex dialect when approx-func is enabled. I have another patch ready for that but wanted to post this separately to make the churn a bit more clear.
I think these operations should have the fastmath attribute anyway though, if I understand correctly? Was there a specific reason that they didn't?

[vzakhari]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1628

This might be okay until we decide to support different FastMathFlags settings for different call sites in the same compilation module (e.g. via some compiler directive).

Would you mind mangling the wrapper name with getFastMathFlagsString(builder) value (e.g. as in SimplifyIntrinsics.cpp)? This should help avoiding any future conflicts between the call sites.

[DavidTruby]

Mangle outlined function names to reflect fastmath flags

[vzakhari]

LGTM in general. Please apply clang-format.

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1697

nit: I would prefer using . here, because it makes the base name (e.g. cos, exp, etc.) separated from the FMF string in a more explicit fashion. In intrinsics simplification this separation is more obvious due to us adding x... rank specification to the name.

Feel free to keep it as-is, since this is just my preference.

[DavidTruby]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1697

I also thought . might look better, but I copied the _ convention from SimplifyIntrinsic.cpp as I wanted to be consistent. Happy to change this to . if _ is used there for a different reason I didn't understand.

[vzakhari]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1697

Functions created in SimplifyIntrinsics are intentionally linkonce-odr external symbols, so I wanted to use C-friendly names for them. The intrinsics wrappers are supposed to be purely internal to the compilation module and we can use whatever names for them. Since . has been used for them, I think we can stick to it.

[DavidTruby]

Change _ to . in name mangling and run clang-format

[vzakhari]

Thank you!

[DavidTruby]

I appear to have not taken PPC into account here: https://lab.llvm.org/buildbot/#/builders/21/builds/74994
Will push a fix asap

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

public:
 
   /// Set default FastMathFlags value from the passed MathOptionsBase
   /// config.
   void setFastMathFlags(Fortran::common::MathOptionsBase options);
 
   /// Get current FastMathFlags value.
   mlir::arith::FastMathFlags getFastMathFlags() const { return fastMathFlags; }
 
+  /// Stringify FastMathFlags set in a way
+  /// that the string may be used for mangling a function name.
+  /// If FastMathFlags are set to 'none', then the result is an empty
+  /// string.
+  std::string getFastMathFlagsString() {
+    mlir::arith::FastMathFlags flags = getFastMathFlags();
+    if (flags == mlir::arith::FastMathFlags::none)
+      return {};
+
+    std::string fmfString{mlir::arith::stringifyFastMathFlags(flags)};
+    std::replace(fmfString.begin(), fmfString.end(), ',', '_');
+    return fmfString;
+  }
+
   /// Dump the current function. (debug)
   LLVM_DUMP_METHOD void dumpFunc();
 
   /// FirOpBuilder hook for creating new operation.
   void notifyOperationInserted(mlir::Operation *op) override {
     setCommonAttributes(op);
   }
 

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 #include "flang/Runtime/iostat.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 #define DEBUG_TYPE "flang-lower-intrinsic"
 
 /// This file implements lowering of Fortran intrinsic procedures and Fortran
 /// intrinsic module procedures.  A call may be inlined with a mix of FIR and
 /// MLIR operations, or as a call to a runtime function or LLVM intrinsic.
 
if (!function) {
     function->setAttr("llvm.linkage", linkage);
     function.addEntryBlock();
 
     // Create local context to emit code into the newly created function
     // This new function is not linked to a source file location, only
     // its calls will be.
     auto localBuilder =
         std::make_unique<fir::FirOpBuilder>(function, builder.getKindMap());
+    localBuilder->setFastMathFlags(builder.getFastMathFlags());
     localBuilder->setInsertionPointToStart(&function.front());
     // Location of code inside wrapper of the wrapper is independent from
     // the location of the intrinsic call.
     mlir::Location localLoc = localBuilder->getUnknownLoc();
     llvm::SmallVector<mlir::Value> localArguments;
     for (mlir::BlockArgument bArg : function.front().getArguments()) {
       auto refType = bArg.getType().dyn_cast<fir::ReferenceType>();
       if (loadRefArguments && refType) {
if (hasAbsentOptional(args)) {
     // them. Needs a better interface here. The issue is that we cannot easily
     // tell that a value is optional or not here if it is presents. And if it is
     // absent, we cannot tell what it type should be.
     TODO(loc, "cannot outline call to intrinsic " + llvm::Twine(name) +
                   " with absent optional argument");
   }
 
   mlir::FunctionType funcType = getFunctionType(resultType, args, builder);
-  mlir::func::FuncOp wrapper = getWrapper(generator, name, funcType);
+  std::string funcName{name};
+  llvm::raw_string_ostream nameOS{funcName};
+  if (std::string fmfString{builder.getFastMathFlagsString()};
+      !fmfString.empty()) {
+    nameOS << '.' << fmfString;
+  }
+  mlir::func::FuncOp wrapper = getWrapper(generator, funcName, funcType);
   return builder.create<fir::CallOp>(loc, wrapper, args).getResult(0);
 }
 
 template <typename GeneratorType>
 fir::ExtendedValue IntrinsicLibrary::outlineInExtendedWrapper(
     GeneratorType generator, llvm::StringRef name,
     std::optional<mlir::Type> resultType,
     llvm::ArrayRef<fir::ExtendedValue> args) {

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

if (!fmi)
     return builder;
 
   // Regardless of what default FastMathFlags are used by FirOpBuilder,
   // override them with FastMathFlags attached to the operation.
   builder.setFastMathFlags(fmi.getFastMathFlagsAttr().getValue());
   return builder;
 }
 
-/// Stringify FastMathFlags set for the given \p builder in a way
-/// that the string may be used for mangling a function name.
-/// If FastMathFlags are set to 'none', then the result is an empty
-/// string.
-static std::string getFastMathFlagsString(const fir::FirOpBuilder &builder) {
-  mlir::arith::FastMathFlags flags = builder.getFastMathFlags();
-  if (flags == mlir::arith::FastMathFlags::none)
-    return {};
-
-  std::string fmfString{mlir::arith::stringifyFastMathFlags(flags)};
-  std::replace(fmfString.begin(), fmfString.end(), ',', '_');
-  return fmfString;
-}
-
 /// Generate function type for the simplified version of RTNAME(Sum) and
 /// similar functions with a fir.box<none> type returning \p elementType.
 static mlir::FunctionType genNoneBoxType(fir::FirOpBuilder &builder,
                                          const mlir::Type &elementType) {
   mlir::Type boxType = fir::BoxType::get(builder.getNoneType());
   return mlir::FunctionType::get(builder.getContext(), {boxType},
                                  {elementType});
 }
void SimplifyIntrinsicsPass::simplifyIntOrFloatReduction(
   if (!argType)
     return;
   assert(*argType == resultType &&
          "Argument/result types mismatch in reduction");
 
   mlir::SymbolRefAttr callee = call.getCalleeAttr();
 
   fir::FirOpBuilder builder{getSimplificationBuilder(call, kindMap)};
-  std::string fmfString{getFastMathFlagsString(builder)};
+  std::string fmfString{builder.getFastMathFlagsString()};
   std::string funcName =
       (mlir::Twine{callee.getLeafReference().getValue(), "x"} +
        mlir::Twine{rank} +
        // We must mangle the generated function name with FastMathFlags
        // value.
        (fmfString.empty() ? mlir::Twine{} : mlir::Twine{"_", fmfString}))
           .str();
 
if (isOperandAbsent(mask)) {
     // Convert fir::LogicalType to mlir::Type
     logicalElemType = logicalFirType;
   }
 
   mlir::Operation *outputDef = args[0].getDefiningOp();
   mlir::Value outputAlloc = outputDef->getOperand(0);
   mlir::Type outType = hlfir::getFortranElementType(outputAlloc.getType());
 
-  std::string fmfString{getFastMathFlagsString(builder)};
+  std::string fmfString{builder.getFastMathFlagsString()};
   std::string funcName =
       (mlir::Twine{callee.getLeafReference().getValue(), "x"} +
        mlir::Twine{rank} +
        (maskRank >= 0
             ? "_Logical" + mlir::Twine{kind} + "x" + mlir::Twine{maskRank}
             : "") +
        "_")
           .str();
if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
                      llvm::dbgs() << "\n");
           mlir::Operation::operand_range args = call.getArgs();
           const mlir::Value &v1 = args[0];
           const mlir::Value &v2 = args[1];
           mlir::Location loc = call.getLoc();
           fir::FirOpBuilder builder{getSimplificationBuilder(op, kindMap)};
           // Stringize the builder's FastMathFlags flags for mangling
           // the generated function name.
-          std::string fmfString{getFastMathFlagsString(builder)};
+          std::string fmfString{builder.getFastMathFlagsString()};
 
           mlir::Type type = call.getResult(0).getType();
           if (!type.isa<mlir::FloatType>() && !type.isa<mlir::IntegerType>())
             return;
 
           // Try to find the element types of the boxed arguments.
           auto arg1Type = getArgElementType(v1);
           auto arg2Type = getArgElementType(v2);

flang/test/Lower/Intrinsics/exp.f90

 ! RUN: bbc -emit-fir -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX,CMPLX-FAST"
 ! RUN: bbc -emit-fir --math-runtime=precise -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 ! RUN: bbc -emit-fir --disable-mlir-complex -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX,CMPLX-FAST"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics -mllvm --math-runtime=precise %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics -mllvm --disable-mlir-complex %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 
 ! CHECK-LABEL: exp_testr
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f32> {{.*}}, %[[BREF:.*]]: !fir.ref<f32> {{.*}})
 subroutine exp_testr(a, b)
   real :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f32>
-! CHECK:  %[[RES:.*]] = fir.call @fir.exp.f32.f32(%[[A]]) {{.*}}: (f32) -> f32
+! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.f32.f32(%[[A]]) {{.*}}: (f32) -> f32
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f32>
   b = exp(a)
 end subroutine
 
 ! CHECK-LABEL: exp_testd
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f64> {{.*}}, %[[BREF:.*]]: !fir.ref<f64> {{.*}})
 subroutine exp_testd(a, b)
   real(kind=8) :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f64>
-! CHECK:  %[[RES:.*]] = fir.call @fir.exp.f64.f64(%[[A]]) {{.*}}: (f64) -> f64
+! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.f64.f64(%[[A]]) {{.*}}: (f64) -> f64
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f64>
   b = exp(a)
 end subroutine
 
 ! CHECK-LABEL: exp_testc
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<!fir.complex<4>> {{.*}}, %[[BREF:.*]]: !fir.ref<!fir.complex<4>> {{.*}})
 subroutine exp_testc(a, b)
   complex :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<!fir.complex<4>>
-! CHECK:  %[[RES:.*]] = fir.call @fir.exp.z4.z4(%[[A]]) {{.*}}: (!fir.complex<4>) -> !fir.complex<4>
+! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.z4.z4(%[[A]]) {{.*}}: (!fir.complex<4>) -> !fir.complex<4>
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<!fir.complex<4>>
   b = exp(a)
 end subroutine
 
 ! CHECK-LABEL: exp_testcd
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<!fir.complex<8>> {{.*}}, %[[BREF:.*]]: !fir.ref<!fir.complex<8>> {{.*}})
 subroutine exp_testcd(a, b)
   complex(kind=8) :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<!fir.complex<8>>
-! CHECK:  %[[RES:.*]] = fir.call @fir.exp.z8.z8(%[[A]]) {{.*}}: (!fir.complex<8>) -> !fir.complex<8>
+! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.z8.z8(%[[A]]) {{.*}}: (!fir.complex<8>) -> !fir.complex<8>
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<!fir.complex<8>>
   b = exp(a)
 end subroutine
 
-! CHECK-LABEL: private @fir.exp.f32.f32
+! CHECK-LABEL: private @fir.exp.contract.f32.f32
 ! CHECK-SAME: (%[[ARG32_OUTLINE:.*]]: f32) -> f32
-! CHECK: %[[RESULT32_OUTLINE:.*]] = math.exp %[[ARG32_OUTLINE]] : f32
+! CHECK: %[[RESULT32_OUTLINE:.*]] = math.exp %[[ARG32_OUTLINE]] fastmath<contract> : f32
 ! CHECK: return %[[RESULT32_OUTLINE]] : f32
 
-! CHECK-LABEL: private @fir.exp.f64.f64
+! CHECK-LABEL: private @fir.exp.contract.f64.f64
 ! CHECK-SAME: (%[[ARG64_OUTLINE:.*]]: f64) -> f64
-! CHECK: %[[RESULT64_OUTLINE:.*]] = math.exp %[[ARG64_OUTLINE]] : f64
+! CHECK: %[[RESULT64_OUTLINE:.*]] = math.exp %[[ARG64_OUTLINE]] fastmath<contract> : f64
 ! CHECK: return %[[RESULT64_OUTLINE]] : f64
 
-! CMPLX-LABEL: private @fir.exp.z4.z4
+! CMPLX-LABEL: private @fir.exp.contract.z4.z4
 ! CMPLX-SAME: (%[[ARG32_OUTLINE:.*]]: !fir.complex<4>) -> !fir.complex<4>
 ! CMPLX-FAST: %[[C:.*]] = fir.convert %[[ARG32_OUTLINE]] : (!fir.complex<4>) -> complex<f32>
 ! CMPLX-FAST: %[[E:.*]] = complex.exp %[[C]] : complex<f32>
 ! CMPLX-FAST: %[[RESULT32_OUTLINE:.*]] = fir.convert %[[E]] : (complex<f32>) -> !fir.complex<4>
-! CMPLX-PRECISE: %[[RESULT32_OUTLINE:.*]] = fir.call @cexpf(%[[ARG32_OUTLINE]]) : (!fir.complex<4>) -> !fir.complex<4>
+! CMPLX-PRECISE: %[[RESULT32_OUTLINE:.*]] = fir.call @cexpf(%[[ARG32_OUTLINE]]) fastmath<contract> : (!fir.complex<4>) -> !fir.complex<4>
 ! CMPLX: return %[[RESULT32_OUTLINE]] : !fir.complex<4>
 
-! CMPLX-LABEL: private @fir.exp.z8.z8
+! CMPLX-LABEL: private @fir.exp.contract.z8.z8
 ! CMPLX-SAME: (%[[ARG64_OUTLINE:.*]]: !fir.complex<8>) -> !fir.complex<8>
 ! CMPLX-FAST: %[[C:.*]] = fir.convert %[[ARG64_OUTLINE]] : (!fir.complex<8>) -> complex<f64>
 ! CMPLX-FAST: %[[E:.*]] = complex.exp %[[C]] : complex<f64>
 ! CMPLX-FAST: %[[RESULT64_OUTLINE:.*]] = fir.convert %[[E]] : (complex<f64>) -> !fir.complex<8>
-! CMPLX-PRECISE: %[[RESULT64_OUTLINE:.*]] = fir.call @cexp(%[[ARG64_OUTLINE]]) : (!fir.complex<8>) -> !fir.complex<8>
+! CMPLX-PRECISE: %[[RESULT64_OUTLINE:.*]] = fir.call @cexp(%[[ARG64_OUTLINE]]) fastmath<contract> : (!fir.complex<8>) -> !fir.complex<8>
 ! CMPLX: return %[[RESULT64_OUTLINE]] : !fir.complex<8>

flang/test/Lower/Intrinsics/log.f90

 ! RUN: bbc -emit-fir -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX,CMPLX-FAST"
 ! RUN: bbc -emit-fir --math-runtime=precise -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 ! RUN: bbc -emit-fir --disable-mlir-complex -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX,CMPLX-FAST"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics -mllvm --math-runtime=precise %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics -mllvm --disable-mlir-complex %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
 
 ! CHECK-LABEL: log_testr
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f32> {{.*}}, %[[BREF:.*]]: !fir.ref<f32> {{.*}})
 subroutine log_testr(a, b)
   real :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f32>
-! CHECK:  %[[RES:.*]] = fir.call @fir.log.f32.f32(%[[A]]) {{.*}}: (f32) -> f32
+! CHECK:  %[[RES:.*]] = fir.call @fir.log.contract.f32.f32(%[[A]]) {{.*}}: (f32) -> f32
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f32>
   b = log(a)
 end subroutine
 
 ! CHECK-LABEL: log_testd
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f64> {{.*}}, %[[BREF:.*]]: !fir.ref<f64> {{.*}})
 subroutine log_testd(a, b)
   real(kind=8) :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f64>
-! CHECK:  %[[RES:.*]] = fir.call @fir.log.f64.f64(%[[A]]) {{.*}}: (f64) -> f64
+! CHECK:  %[[RES:.*]] = fir.call @fir.log.contract.f64.f64(%[[A]]) {{.*}}: (f64) -> f64
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f64>
   b = log(a)
 end subroutine
 
 ! CHECK-LABEL: log_testc
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<!fir.complex<4>> {{.*}}, %[[BREF:.*]]: !fir.ref<!fir.complex<4>> {{.*}})
 subroutine log_testc(a, b)
   complex :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<!fir.complex<4>>
-! CHECK:  %[[RES:.*]] = fir.call @fir.log.z4.z4(%[[A]]) {{.*}}: (!fir.complex<4>) -> !fir.complex<4>
+! CHECK:  %[[RES:.*]] = fir.call @fir.log.contract.z4.z4(%[[A]]) {{.*}}: (!fir.complex<4>) -> !fir.complex<4>
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<!fir.complex<4>>
   b = log(a)
 end subroutine
 
 ! CHECK-LABEL: log_testcd
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<!fir.complex<8>> {{.*}}, %[[BREF:.*]]: !fir.ref<!fir.complex<8>> {{.*}})
 subroutine log_testcd(a, b)
   complex(kind=8) :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<!fir.complex<8>>
-! CHECK:  %[[RES:.*]] = fir.call @fir.log.z8.z8(%[[A]]) {{.*}}: (!fir.complex<8>) -> !fir.complex<8>
+! CHECK:  %[[RES:.*]] = fir.call @fir.log.contract.z8.z8(%[[A]]) {{.*}}: (!fir.complex<8>) -> !fir.complex<8>
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<!fir.complex<8>>
   b = log(a)
 end subroutine
 
 ! CHECK-LABEL: log10_testr
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f32> {{.*}}, %[[BREF:.*]]: !fir.ref<f32> {{.*}})
 subroutine log10_testr(a, b)
   real :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f32>
-! CHECK:  %[[RES:.*]] = fir.call @fir.log10.f32.f32(%[[A]]) {{.*}}: (f32) -> f32
+! CHECK:  %[[RES:.*]] = fir.call @fir.log10.contract.f32.f32(%[[A]]) {{.*}}: (f32) -> f32
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f32>
   b = log10(a)
 end subroutine
 
 ! CHECK-LABEL: log10_testd
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f64> {{.*}}, %[[BREF:.*]]: !fir.ref<f64> {{.*}})
 subroutine log10_testd(a, b)
   real(kind=8) :: a, b
 ! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f64>
-! CHECK:  %[[RES:.*]] = fir.call @fir.log10.f64.f64(%[[A]]) {{.*}}: (f64) -> f64
+! CHECK:  %[[RES:.*]] = fir.call @fir.log10.contract.f64.f64(%[[A]]) {{.*}}: (f64) -> f64
 ! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f64>
   b = log10(a)
 end subroutine
 
-! CHECK-LABEL: private @fir.log.f32.f32
+! CHECK-LABEL: private @fir.log.contract.f32.f32
 ! CHECK-SAME: (%[[ARG32_OUTLINE:.*]]: f32) -> f32
-! CHECK: %[[RESULT32_OUTLINE:.*]] = math.log %[[ARG32_OUTLINE]] : f32
+! CHECK: %[[RESULT32_OUTLINE:.*]] = math.log %[[ARG32_OUTLINE]] fastmath<contract> : f32
 ! CHECK: return %[[RESULT32_OUTLINE]] : f32
 
-! CHECK-LABEL: private @fir.log.f64.f64
+! CHECK-LABEL: private @fir.log.contract.f64.f64
 ! CHECK-SAME: (%[[ARG64_OUTLINE:.*]]: f64) -> f64
-! CHECK: %[[RESULT64_OUTLINE:.*]] = math.log %[[ARG64_OUTLINE]] : f64
+! CHECK: %[[RESULT64_OUTLINE:.*]] = math.log %[[ARG64_OUTLINE]] fastmath<contract> : f64
 ! CHECK: return %[[RESULT64_OUTLINE]] : f64
 
-! CMPLX-LABEL: private @fir.log.z4.z4
+! CMPLX-LABEL: private @fir.log.contract.z4.z4
 ! CMPLX-SAME: (%[[ARG32_OUTLINE:.*]]: !fir.complex<4>) -> !fir.complex<4>
 ! CMPLX-FAST: %[[C:.*]] = fir.convert %[[ARG32_OUTLINE]] : (!fir.complex<4>) -> complex<f32>
 ! CMPLX-FAST: %[[E:.*]] = complex.log %[[C]] : complex<f32>
 ! CMPLX-FAST: %[[RESULT32_OUTLINE:.*]] = fir.convert %[[E]] : (complex<f32>) -> !fir.complex<4>
-! CMPLX-PRECISE: %[[RESULT32_OUTLINE:.*]] = fir.call @clogf(%[[ARG32_OUTLINE]]) : (!fir.complex<4>) -> !fir.complex<4>
+! CMPLX-PRECISE: %[[RESULT32_OUTLINE:.*]] = fir.call @clogf(%[[ARG32_OUTLINE]]) fastmath<contract> : (!fir.complex<4>) -> !fir.complex<4>
 ! CMPLX: return %[[RESULT32_OUTLINE]] : !fir.complex<4>
 
-! CMPLX-LABEL: private @fir.log.z8.z8
+! CMPLX-LABEL: private @fir.log.contract.z8.z8
 ! CMPLX-SAME: (%[[ARG64_OUTLINE:.*]]: !fir.complex<8>) -> !fir.complex<8>
 ! CMPLX-FAST: %[[C:.*]] = fir.convert %[[ARG64_OUTLINE]] : (!fir.complex<8>) -> complex<f64>
 ! CMPLX-FAST: %[[E:.*]] = complex.log %[[C]] : complex<f64>
 ! CMPLX-FAST: %[[RESULT64_OUTLINE:.*]] = fir.convert %[[E]] : (complex<f64>) -> !fir.complex<8>
-! CMPLX-PRECISE: %[[RESULT64_OUTLINE:.*]] = fir.call @clog(%[[ARG64_OUTLINE]]) : (!fir.complex<8>) -> !fir.complex<8>
+! CMPLX-PRECISE: %[[RESULT64_OUTLINE:.*]] = fir.call @clog(%[[ARG64_OUTLINE]]) fastmath<contract> : (!fir.complex<8>) -> !fir.complex<8>
 ! CMPLX: return %[[RESULT64_OUTLINE]] : !fir.complex<8>
 
-! CHECK-LABEL: private @fir.log10.f32.f32
+! CHECK-LABEL: private @fir.log10.contract.f32.f32
 ! CHECK-SAME: (%[[ARG32_OUTLINE:.*]]: f32) -> f32
-! CHECK: %[[RESULT32_OUTLINE:.*]] = math.log10 %[[ARG32_OUTLINE]] : f32
+! CHECK: %[[RESULT32_OUTLINE:.*]] = math.log10 %[[ARG32_OUTLINE]] fastmath<contract> : f32
 ! CHECK: return %[[RESULT32_OUTLINE]] : f32
 
-! CHECK-LABEL: private @fir.log10.f64.f64
+! CHECK-LABEL: private @fir.log10.contract.f64.f64
 ! CHECK-SAME: (%[[ARG64_OUTLINE:.*]]: f64) -> f64
-! CHECK: %[[RESULT64_OUTLINE:.*]] = math.log10 %[[ARG64_OUTLINE]] : f64
+! CHECK: %[[RESULT64_OUTLINE:.*]] = math.log10 %[[ARG64_OUTLINE]] fastmath<contract> : f64
 ! CHECK: return %[[RESULT64_OUTLINE]] : f64

flang/test/Lower/Intrinsics/math-runtime-options.f90

 ! RUN: bbc -emit-fir --math-runtime=fast -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="FIR,FAST"
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=fast -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="FIR,FAST"
 ! RUN: bbc -emit-fir --math-runtime=relaxed -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="FIR,RELAXED"
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=relaxed -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="FIR,RELAXED"
 ! RUN: bbc -emit-fir --math-runtime=precise -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="FIR,PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=precise -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="FIR,PRECISE"
 
 ! CHECK-LABEL: cos_testr
 subroutine cos_testr(a, b)
   real :: a, b
-! FIR: fir.call @fir.cos.f32.f32
+! FIR: fir.call @fir.cos.contract.f32.f32
   b = cos(a)
 end subroutine
 
 ! CHECK-LABEL: cos_testd
 subroutine cos_testd(a, b)
   real(kind=8) :: a, b
-! FIR: fir.call @fir.cos.f64.f64
+! FIR: fir.call @fir.cos.contract.f64.f64
   b = cos(a)
 end subroutine
 
-! FIR: @fir.cos.f32.f32(%arg0: f32) -> f32 attributes
-! FAST: math.cos %arg0 : f32
-! RELAXED: math.cos %arg0 : f32
-! PRECISE: fir.call @cosf(%arg0) : (f32) -> f32
-! FIR: @fir.cos.f64.f64(%arg0: f64) -> f64
-! FAST: math.cos %arg0 : f64
-! RELAXED: math.cos %arg0 : f64
-! PRECISE: fir.call @cos(%arg0) : (f64) -> f64
+! FIR: @fir.cos.contract.f32.f32(%arg0: f32) -> f32 attributes
+! FAST: math.cos %arg0 fastmath<contract> : f32
+! RELAXED: math.cos %arg0 fastmath<contract> : f32
+! PRECISE: fir.call @cosf(%arg0) fastmath<contract> : (f32) -> f32
+! FIR: @fir.cos.contract.f64.f64(%arg0: f64) -> f64
+! FAST: math.cos %arg0 fastmath<contract> : f64
+! RELAXED: math.cos %arg0 fastmath<contract> : f64
+! PRECISE: fir.call @cos(%arg0) fastmath<contract> : (f64) -> f64

flang/test/Lower/array-expression-slice-1.f90

 ! CHECK:         cond_br %[[VAL_38]], ^bb4, ^bb5
 ! CHECK:       ^bb4:
 ! CHECK:         fir.store %[[VAL_36]] to %[[VAL_28]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_40:.*]] = fir.load %[[VAL_31]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_41:.*]] = arith.addi %[[VAL_40]], %[[VAL_23]] : i32
 ! CHECK:         fir.store %[[VAL_41]] to %[[VAL_31]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_42:.*]] = fir.load %[[VAL_31]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (i32) -> f32
-! CHECK:         %[[VAL_44:.*]] = fir.call @fir.cos.f32.f32(%[[VAL_43]]) {{.*}}: (f32) -> f32
+! CHECK:         %[[VAL_44:.*]] = fir.call @fir.cos.contract.f32.f32(%[[VAL_43]]) {{.*}}: (f32) -> f32
 ! CHECK:         %[[VAL_45:.*]] = fir.load %[[VAL_28]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_46:.*]] = fir.convert %[[VAL_45]] : (i32) -> i64
 ! CHECK:         %[[VAL_47:.*]] = arith.subi %[[VAL_46]], %[[VAL_20]] : i64
 ! CHECK:         %[[VAL_48:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_49:.*]] = fir.convert %[[VAL_48]] : (i32) -> i64
 ! CHECK:         %[[VAL_50:.*]] = arith.subi %[[VAL_49]], %[[VAL_20]] : i64
 ! CHECK:         %[[VAL_51:.*]] = fir.coordinate_of %[[VAL_25]], %[[VAL_47]], %[[VAL_50]] : (!fir.ref<!fir.array<10x10xf32>>, i64, i64) -> !fir.ref<f32>
 ! CHECK:         fir.store %[[VAL_44]] to %[[VAL_51]] : !fir.ref<f32>
 ! CHECK:         %[[LOADI:.*]] = fir.load %[[VAL_28]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_52:.*]] = arith.addi %[[LOADI]], %[[STEP]] : i32
 ! CHECK:         %[[VAL_53:.*]] = arith.subi %[[VAL_37]], %[[VAL_5]] : index
 ! CHECK:         br ^bb3(%[[VAL_52]], %[[VAL_53]] : i32, index)
 ! CHECK:       ^bb5:
 ! CHECK:         fir.store %[[VAL_36]] to %[[VAL_28]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_55:.*]] = fir.load %[[VAL_31]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_56:.*]] = fir.convert %[[VAL_55]] : (i32) -> f32
-! CHECK:         %[[VAL_57:.*]] = fir.call @fir.sin.f32.f32(%[[VAL_56]]) {{.*}}: (f32) -> f32
+! CHECK:         %[[VAL_57:.*]] = fir.call @fir.sin.contract.f32.f32(%[[VAL_56]]) {{.*}}: (f32) -> f32
 ! CHECK:         %[[VAL_58:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64
 ! CHECK:         %[[VAL_60:.*]] = arith.subi %[[VAL_59]], %[[VAL_20]] : i64
 ! CHECK:         %[[VAL_61:.*]] = fir.coordinate_of %[[VAL_27]], %[[VAL_60]] : (!fir.ref<!fir.array<10xf32>>, i64) -> !fir.ref<f32>
 ! CHECK:         fir.store %[[VAL_57]] to %[[VAL_61]] : !fir.ref<f32>
 ! CHECK:         %[[LOADJ:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
 ! CHECK:         %[[VAL_62:.*]] = arith.addi %[[LOADJ]], %[[STEP]] : i32
 ! CHECK:         %[[VAL_63:.*]] = arith.subi %[[VAL_33]], %[[VAL_5]] : index

flang/test/Lower/dummy-procedure.f90

 ! SHOULD-CHECK: func @_QPtodo3(%arg0: (!fir.ref<f32>) -> f32)
 subroutine todo3(dummy_proc)
   intrinsic :: acos
   procedure(acos) :: dummy_proc
 end subroutine
 
 ! CHECK-LABEL: func private @fir.acos.f32.ref_f32(%arg0: !fir.ref<f32>) -> f32
   !CHECK: %[[load:.*]] = fir.load %arg0
-  !CHECK: %[[res:.*]] = fir.call @acosf(%[[load]]) : (f32) -> f32
+  !CHECK: %[[res:.*]] = fir.call @acosf(%[[load]]) fastmath<contract> : (f32) -> f32
   !CHECK: return %[[res]] : f32
 
 ! CHECK-LABEL: func private @fir.atan2.f32.ref_f32.ref_f32(
 ! CHECK-SAME: %[[x:.*]]: !fir.ref<f32>, %[[y:.*]]: !fir.ref<f32>) -> f32
   ! CHECK-DAG: %[[xload:.*]] = fir.load %[[x]] : !fir.ref<f32>
   ! CHECK-DAG: %[[yload:.*]] = fir.load %[[y]] : !fir.ref<f32>
-  ! CHECK: %[[atan2:.*]] = math.atan2 %[[xload]], %[[yload]] : f32
+  ! CHECK: %[[atan2:.*]] = math.atan2 %[[xload]], %[[yload]] fastmath<contract> : f32
   ! CHECK: return %[[atan2]] : f32
 
 !CHECK-LABEL: func private @fir.aimag.f32.ref_z4(%arg0: !fir.ref<!fir.complex<4>>)
   !CHECK: %[[load:.*]] = fir.load %arg0
   !CHECK: %[[imag:.*]] = fir.extract_value %[[load]], [1 : index] : (!fir.complex<4>) -> f32
   !CHECK: return %[[imag]] : f32
 
 !CHECK-LABEL: func private @fir.len.i32.bc1(%arg0: !fir.boxchar<1>)
   !CHECK: %[[unboxed:.*]]:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
   !CHECK: %[[len:.*]] = fir.convert %[[unboxed]]#1 : (index) -> i32
   !CHECK: return %[[len]] : i32

flang/test/Lower/intrinsic-procedure-wrappers.f90

 ! RUN: bbc -outline-intrinsics %s -o - | tco --disable-llvm --mlir-print-ir-after=fir-to-llvm-ir 2>&1 | FileCheck %s
 
 ! Test properties of intrinsic function wrappers
 
 ! Test that intrinsic wrappers have internal linkage
 function foo(x)
   foo = acos(x)
 end function
 
-! CHECK: llvm.func internal @fir.acos.f32.f32
+! CHECK: llvm.func internal @fir.acos.contract.f32.f32

flang/test/Lower/sqrt.f90

 ! RUN: bbc -emit-fir -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX-FAST"
 ! RUN: bbc --math-runtime=precise -emit-fir -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
 ! RUN: bbc --disable-mlir-complex -emit-fir -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX-FAST"
 ! RUN: %flang_fc1 -emit-fir -mllvm --math-runtime=precise -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm --disable-mlir-complex -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
 
 ! CHECK-LABEL: sqrt_testr
 subroutine sqrt_testr(a, b)
   real :: a, b
-! CHECK: fir.call @fir.sqrt.f32.f32
+! CHECK: fir.call @fir.sqrt.contract.f32.f32
   b = sqrt(a)
 end subroutine
 
 ! CHECK-LABEL: sqrt_testd
 subroutine sqrt_testd(a, b)
   real(kind=8) :: a, b
-! CHECK: fir.call @fir.sqrt.f64.f64
+! CHECK: fir.call @fir.sqrt.contract.f64.f64
   b = sqrt(a)
 end subroutine
 
 ! CHECK-LABEL: sqrt_testc
 subroutine sqrt_testc(z)
   complex :: z
-! CHECK: fir.call @fir.sqrt.z4.z4
+! CHECK: fir.call @fir.sqrt.contract.z4.z4
   z = sqrt(z)
 end subroutine
 
 ! CHECK-LABEL: sqrt_testcd
 subroutine sqrt_testcd(z)
   complex(kind=8) :: z
-! CHECK: fir.call @fir.sqrt.z8.z8
+! CHECK: fir.call @fir.sqrt.contract.z8.z8
   z = sqrt(z)
 end subroutine
 
-! CHECK-LABEL: @fir.sqrt.f32.f32
+! CHECK-LABEL: @fir.sqrt.contract.f32.f32
 ! CHECK: math.sqrt %{{.*}} : f32
 
-! CHECK-LABEL: @fir.sqrt.f64.f64
+! CHECK-LABEL: @fir.sqrt.contract.f64.f64
 ! CHECK: math.sqrt %{{.*}} : f64
 
-! CHECK-LABEL: func private @fir.sqrt.z4.z4
+! CHECK-LABEL: func private @fir.sqrt.contract.z4.z4
 ! CMPLX-FAST: complex.sqrt %{{.*}} : complex<f32>
 ! CMPLX-PRECISE: fir.call @csqrtf
 
-! CHECK-LABEL: @fir.sqrt.z8.z8
+! CHECK-LABEL: @fir.sqrt.contract.z8.z8
 ! CMPLX-FAST: complex.sqrt %{{.*}} : complex<f64>
 ! CMPLX-PRECISE: fir.call @csqrt

flang/test/Lower/trigonometric-intrinsics.f90

 ! RUN: bbc -emit-fir -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX-FAST"
 ! RUN: bbc --math-runtime=precise -emit-fir -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics %s -o - | FileCheck %s
 
 ! CHECK-LABEL: tan_testr
 subroutine tan_testr(a, b)
   real :: a, b
-! CHECK: fir.call @fir.tan.f32.f32
+! CHECK: fir.call @fir.tan.contract.f32.f32
   b = tan(a)
 end subroutine
 
 ! CHECK-LABEL: tan_testd
 subroutine tan_testd(a, b)
   real(kind=8) :: a, b
-! CHECK: fir.call @fir.tan.f64.f64
+! CHECK: fir.call @fir.tan.contract.f64.f64
   b = tan(a)
 end subroutine
 
 ! CHECK-LABEL: tan_testc
 subroutine tan_testc(z)
   complex :: z
-! CHECK: fir.call @fir.tan.z4.z4
+! CHECK: fir.call @fir.tan.contract.z4.z4
   z = tan(z)
 end subroutine
 
 ! CHECK-LABEL: tan_testcd
 subroutine tan_testcd(z)
   complex(kind=8) :: z
-! CHECK: fir.call @fir.tan.z8.z8
+! CHECK: fir.call @fir.tan.contract.z8.z8
   z = tan(z)
 end subroutine
 
 ! CHECK-LABEL: atan_testr
 subroutine atan_testr(a, b)
   real :: a, b
-! CHECK: fir.call @fir.atan.f32.f32
+! CHECK: fir.call @fir.atan.contract.f32.f32
   b = atan(a)
 end subroutine
 
 ! CHECK-LABEL: atan_testd
 subroutine atan_testd(a, b)
   real(kind=8) :: a, b
-! CHECK: fir.call @fir.atan.f64.f64
+! CHECK: fir.call @fir.atan.contract.f64.f64
   b = atan(a)
 end subroutine
 
 ! CHECK-LABEL: atan_testc
 subroutine atan_testc(z)
   complex :: z
-! CHECK: fir.call @fir.atan.z4.z4
+! CHECK: fir.call @fir.atan.contract.z4.z4
   z = atan(z)
 end subroutine
 
 ! CHECK-LABEL: atan_testcd
 subroutine atan_testcd(z)
   complex(kind=8) :: z
-! CHECK: fir.call @fir.atan.z8.z8
+! CHECK: fir.call @fir.atan.contract.z8.z8
   z = atan(z)
 end subroutine
 
 ! CHECK-LABEL: cos_testr
 subroutine cos_testr(a, b)
   real :: a, b
-! CHECK: fir.call @fir.cos.f32.f32
+! CHECK: fir.call @fir.cos.contract.f32.f32
   b = cos(a)
 end subroutine
 
 ! CHECK-LABEL: cos_testd
 subroutine cos_testd(a, b)
   real(kind=8) :: a, b
-! CHECK: fir.call @fir.cos.f64.f64
+! CHECK: fir.call @fir.cos.contract.f64.f64
   b = cos(a)
 end subroutine
 
 ! CHECK-LABEL: cos_testc
 subroutine cos_testc(z)
   complex :: z
-! CHECK: fir.call @fir.cos.z4.z4
+! CHECK: fir.call @fir.cos.contract.z4.z4
   z = cos(z)
 end subroutine
 
 ! CHECK-LABEL: cos_testcd
 subroutine cos_testcd(z)
   complex(kind=8) :: z
-! CHECK: fir.call @fir.cos.z8.z8
+! CHECK: fir.call @fir.cos.contract.z8.z8
   z = cos(z)
 end subroutine
 
 ! CHECK-LABEL: cosh_testr
 subroutine cosh_testr(a, b)
   real :: a, b
-! CHECK: fir.call @fir.cosh.f32.f32
+! CHECK: fir.call @fir.cosh.contract.f32.f32
   b = cosh(a)
 end subroutine
 
 ! CHECK-LABEL: cosh_testd
 subroutine cosh_testd(a, b)
   real(kind=8) :: a, b
-! CHECK: fir.call @fir.cosh.f64.f64
+! CHECK: fir.call @fir.cosh.contract.f64.f64
   b = cosh(a)
 end subroutine
 
 ! CHECK-LABEL: cosh_testc
 subroutine cosh_testc(z)
   complex :: z
-! CHECK: fir.call @fir.cosh.z4.z4
+! CHECK: fir.call @fir.cosh.contract.z4.z4
   z = cosh(z)
 end subroutine
 
 ! CHECK-LABEL: cosh_testcd
 subroutine cosh_testcd(z)
   complex(kind=8) :: z
-! CHECK: fir.call @fir.cosh.z8.z8
+! CHECK: fir.call @fir.cosh.contract.z8.z8
   z = cosh(z)
 end subroutine
 
 ! CHECK-LABEL: sin_testr
 subroutine sin_testr(a, b)
   real :: a, b
-! CHECK: fir.call @fir.sin.f32.f32
+! CHECK: fir.call @fir.sin.contract.f32.f32
   b = sin(a)
 end subroutine
 
 ! CHECK-LABEL: sin_testd
 subroutine sin_testd(a, b)
   real(kind=8) :: a, b
-! CHECK: fir.call @fir.sin.f64.f64
+! CHECK: fir.call @fir.sin.contract.f64.f64
   b = sin(a)
 end subroutine
 
 ! CHECK-LABEL: sin_testc
 subroutine sin_testc(z)
   complex :: z
-! CHECK: fir.call @fir.sin.z4.z4
+! CHECK: fir.call @fir.sin.contract.z4.z4
   z = sin(z)
 end subroutine
 
 ! CHECK-LABEL: sin_testcd
 subroutine sin_testcd(z)
   complex(kind=8) :: z
-! CHECK: fir.call @fir.sin.z8.z8
+! CHECK: fir.call @fir.sin.contract.z8.z8
   z = sin(z)
 end subroutine
 
 ! CHECK-LABEL: sinh_testr
 subroutine sinh_testr(a, b)
   real :: a, b
-! CHECK: fir.call @fir.sinh.f32.f32
+! CHECK: fir.call @fir.sinh.contract.f32.f32
   b = sinh(a)
 end subroutine
 
 ! CHECK-LABEL: sinh_testd
 subroutine sinh_testd(a, b)
   real(kind=8) :: a, b
-! CHECK: fir.call @fir.sinh.f64.f64
+! CHECK: fir.call @fir.sinh.contract.f64.f64
   b = sinh(a)
 end subroutine
 
 ! CHECK-LABEL: sinh_testc
 subroutine sinh_testc(z)
   complex :: z
-! CHECK: fir.call @fir.sinh.z4.z4
+! CHECK: fir.call @fir.sinh.contract.z4.z4
   z = sinh(z)
 end subroutine
 
 ! CHECK-LABEL: sinh_testcd
 subroutine sinh_testcd(z)
   complex(kind=8) :: z
-! CHECK: fir.call @fir.sinh.z8.z8
+! CHECK: fir.call @fir.sinh.contract.z8.z8
   z = sinh(z)
 end subroutine
 
-! CHECK-LABEL: @fir.tan.f32.f32
+! CHECK-LABEL: @fir.tan.contract.f32.f32
 ! CHECK: math.tan %{{.*}} : f32
 
-! CHECK-LABEL: @fir.tan.f64.f64
+! CHECK-LABEL: @fir.tan.contract.f64.f64
 ! CHECK: math.tan %{{.*}} : f64
 
-! CHECK-LABEL: @fir.tan.z4.z4
+! CHECK-LABEL: @fir.tan.contract.z4.z4
 ! CMPLX-FAST: complex.tan %{{.*}} : complex<f32>
 ! CMPLX-PRECISE: fir.call @ctanf
 
-! CHECK-LABEL: @fir.tan.z8.z8
+! CHECK-LABEL: @fir.tan.contract.z8.z8
 ! CMPLX-FAST: complex.tan %{{.*}} : complex<f64>
 ! CMPLX-PRECISE: fir.call @ctan
 
-! CHECK-LABEL: @fir.atan.f32.f32
+! CHECK-LABEL: @fir.atan.contract.f32.f32
 ! CHECK: math.atan %{{.*}} : f32
 
-! CHECK-LABEL: @fir.atan.f64.f64
+! CHECK-LABEL: @fir.atan.contract.f64.f64
 ! CHECK: math.atan %{{.*}} : f64
 
-! CHECK-LABEL: @fir.atan.z4.z4
+! CHECK-LABEL: @fir.atan.contract.z4.z4
 ! CHECK: fir.call @catanf
 
-! CHECK-LABEL: @fir.atan.z8.z8
+! CHECK-LABEL: @fir.atan.contract.z8.z8
 ! CHECK: fir.call @catan
 
-! CHECK-LABEL: @fir.cos.f32.f32
+! CHECK-LABEL: @fir.cos.contract.f32.f32
 ! CHECK: math.cos %{{.*}} : f32
 
-! CHECK-LABEL: @fir.cos.f64.f64
+! CHECK-LABEL: @fir.cos.contract.f64.f64
 ! CHECK: math.cos %{{.*}} : f64
 
-! CHECK-LABEL: @fir.cos.z4.z4
+! CHECK-LABEL: @fir.cos.contract.z4.z4
 ! CMPLX-FAST: complex.cos %{{.*}} : complex<f32>
 ! CMPLX-PRECISE: fir.call @ccosf
 
-! CHECK-LABEL: @fir.cos.z8.z8
+! CHECK-LABEL: @fir.cos.contract.z8.z8
 ! CMPLX-FAST: complex.cos %{{.*}} : complex<f64>
 ! CMPLX-PRECISE: fir.call @ccos
 
-! CHECK-LABEL: @fir.cosh.f32.f32
+! CHECK-LABEL: @fir.cosh.contract.f32.f32
 ! CHECK: fir.call {{.*}}cosh
 
-! CHECK-LABEL: @fir.cosh.f64.f64
+! CHECK-LABEL: @fir.cosh.contract.f64.f64
 ! CHECK: fir.call {{.*}}cosh
 
-! CHECK-LABEL: @fir.cosh.z4.z4
+! CHECK-LABEL: @fir.cosh.contract.z4.z4
 ! CHECK: fir.call @ccoshf
 
-! CHECK-LABEL: @fir.cosh.z8.z8
+! CHECK-LABEL: @fir.cosh.contract.z8.z8
 ! CHECK: fir.call @ccosh
 
-! CHECK-LABEL: @fir.sin.f32.f32
+! CHECK-LABEL: @fir.sin.contract.f32.f32
 ! CHECK: math.sin %{{.*}} : f32
 
-! CHECK-LABEL: @fir.sin.f64.f64
+! CHECK-LABEL: @fir.sin.contract.f64.f64
 ! CHECK: math.sin %{{.*}} : f64
 
-! CHECK-LABEL: @fir.sin.z4.z4
+! CHECK-LABEL: @fir.sin.contract.z4.z4
 ! CMPLX-FAST: complex.sin %{{.*}} : complex<f32>
 ! CMPLX-PRECISE: fir.call @csinf
 
-! CHECK-LABEL: @fir.sin.z8.z8
+! CHECK-LABEL: @fir.sin.contract.z8.z8
 ! CMPLX-FAST: complex.sin %{{.*}} : complex<f64>
 ! CMPLX-PRECISE: fir.call @csin
 
-! CHECK-LABEL: @fir.sinh.f32.f32
+! CHECK-LABEL: @fir.sinh.contract.f32.f32
 ! CHECK: fir.call {{.*}}sinh
 
-! CHECK-LABEL: @fir.sinh.f64.f64
+! CHECK-LABEL: @fir.sinh.contract.f64.f64
 ! CHECK: fir.call {{.*}}sinh
 
-! CHECK-LABEL: @fir.sinh.z4.z4
+! CHECK-LABEL: @fir.sinh.contract.z4.z4
 ! CHECK: fir.call @csinhf
 
-! CHECK-LABEL: @fir.sinh.z8.z8
+! CHECK-LABEL: @fir.sinh.contract.z8.z8
 ! CHECK: fir.call @csinh