[Flang] Replace intrinsic function type generators with single generic function type generator

[pscoro]

Summary

In a future patch we plan on introducing a large set of Power-PC specific intrinsics. During our prototyping we found that the number of function type generators we were defining, plus those already defined, were reaching an unreasonable number. This patch introduces a generic function type generator function that can be used for almost all cases. The generator supports creating function types with up to 4 arguments and with arguments/return type of types: void, integer, real, and comlex. The intention is for a future patch, which introduces a set of PowerPC-specific vector intrinsics, to also introduce support in the generator for: integer vector, unsigned vector, and real vector types.

[pscoro]

Removed outdated comment

[vzakhari]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

503

It is probably worth asserting the supported widths.

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

888

The element size is not 24 bits in this case.

To avoid such weird cases, can we use the kind as the template argument instead of the bit-width? Then you may use FirOpBuilder::getRealType and KindMapping::getIntegerBitsize for mapping the kind to the bitsize in genFuncType.

[tschuett]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

487

Could you turn this also in a fatal error? In release mode, the assert does not help.

[pscoro]

Addressed comments, genFuncType now uses kind instead of bit width

[pscoro]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

888

Done, genFuncType now uses kind instead of bitwidth. I had to override the type declaration for FuncTypeBuilderFunc to include an additional FirOpBuilder argument so that the builder can be used for the kind-to-bitwidth calculations. I made this type declaration inside of MathOperations to limit the scope, any references to FuncTypeBuilderFunc outside of IntrinsicCall still expects a function type that only has an MLIRContext argument

[luporl]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

509–520

I'm not against current approach, but I want to suggest an alternative, if others agree.

If the type enum and kind could be encapsulated in a new type, then it would be possible to use a variadic template here, to support an arbitrary number of arguments. It could be something similar to the edit above.

[pscoro]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

509–520

I am a fan of this approach and appreciate the code your provided. I will try to switch to this approach and update the patch when successful. Thanks!

[pscoro]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

509–520

static_assert(t != ParamTypeId::Integer || k == 4 || k == 8, "Unsupported integer kind");
static_assert(t != ParamTypeId::Real || k == 4 || k == 8, "Unsupported real kind");

This new code now checks supported kinds as an assert in addition to the llvm::report_fatal_errors in getTypeHelper (when trying to convert to mlir::Type). Having both seems like overkill, do we prefer to have the static_asserts or the report_fatal_errors for the supported kind checks

[luporl]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

509–520

As the supported kinds can now be checked at compile time, I think it would be better to remove the llvm::report_fatal_errors.

[pscoro]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

509–520

Do static_asserts get checked in release builds? I know asserts are typically debug only.

I am also hesitating because of @tschuett 's previous comment that requested using fatal_error over asserts

[tschuett]

No worries. static_assert is a compile-time assert.

[pscoro]

Implemented variadic template arg suggestion

[pscoro]

Ping.

Now using variadic arguments and opted for static_assert over report_fatal_error where appropriate since its asserted at compile time. Thanks for the suggestion @luporl

[luporl]

Thanks for replacing all those function type generators with a generic one!

LGTM. I have just a few nitpicks.

You might want to wait a little longer to see if anyone has more comments on this patch.

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

485

Unsupported complex kind

516

typo: bitsize

539–540

Is this if still needed?

[tschuett]

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

538

Nit: ++i

547

The else is kind of redundant. The If will return.

[pscoro]

Addressed nits

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

539–540

Because Void arguments are no longer expect (as a result of the variadic args), and because getTypeHelper will report fatal_error if it recieves void, this if statement was no longer needed. Thanks

[pscoro]

Patch is approved but I will wait a bit before landing in case there are additional nits

But I shouldn't wait for too long as we have other patches dependent on and waiting for this to land first

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

struct MathOperation {
 
   // A callback to generate FIR for the intrinsic defined by 'key'.
   // A callback may generate either dedicated MLIR operation(s) or
   // a function call to a runtime function with name defined by
   // 'runtimeFunc'.
   MathGeneratorTy funcGenerator;
 };
 
+// Enum of most supported intrinsic argument or return types.
+// Used by getTypeHelper to help generate most intrinsic function types.
+enum class Ty {
+  Void,
+  Integer,
+  Real,
+  Complex,
+};
+
+// Helper function that generates most types that are supported for intrinsic
+// arguments and return type. Used by `genFuncType` to generate function
+// types for most of the intrinsics.
+static inline mlir::Type getTypeHelper(mlir::MLIRContext *context, Ty ty,
+                                       int bits) {
+  mlir::Type r;
+  switch (ty) {
+  case Ty::Void:
+    llvm::report_fatal_error("can not get type of void");
+    break;
+  case Ty::Integer:
+    assert((bits == 8 || bits == 16 || bits == 32 || bits == 64) &&
+           "unsupported integer bit width");
+    r = mlir::IntegerType::get(context, bits);
+    break;
+  case Ty::Real:
+    if (bits == 32)
+      r = mlir::FloatType::getF32(context);
+    else if (bits == 64)
+      r = mlir::FloatType::getF64(context);
+    else if (bits == 80)
+      r = mlir::FloatType::getF80(context);
+    else if (bits == 128)
+      r = mlir::FloatType::getF128(context);
+    else
+      llvm::report_fatal_error("unsupported float bit width");
+    break;
+  case Ty::Complex:
+    r = fir::ComplexType::get(context, bits / 8);
+    break;
+  }
+  return r;
+}
+
+// Generic function type generator that supports most of the function types
+// used by intrinsics with upto 4 arguments.
+template <Ty tyR, int eleBitsR, // return type
+          Ty ty1, int eleBits1, // arg1
+          Ty ty2, int eleBits2, // arg2
+          Ty ty3, int eleBits3, // arg3
+          Ty ty4, int eleBits4> // arg4
+static inline mlir::FunctionType genFuncType(mlir::MLIRContext *context) {
+  llvm::SmallVector<Ty> types = {ty1, ty2, ty3, ty4};
+  llvm::SmallVector<int> bits = {eleBits1, eleBits2, eleBits3, eleBits4};
+  llvm::SmallVector<mlir::Type> argTypes;
+
+  for (size_t i = 0; i < types.size(); i++) {
+    // ignore void arguments
+    if (types[i] != Ty::Void)
+      argTypes.push_back(getTypeHelper(context, types[i], bits[i]));
+  }
+
+  if (tyR == Ty::Void) {
+    return mlir::FunctionType::get(context, argTypes, std::nullopt);
+  } else {
+    auto resType = getTypeHelper(context, tyR, eleBitsR);
+    return mlir::FunctionType::get(context, argTypes, {resType});
+  }
+}
+
+template <Ty tyR, int eleBitsR, // return type
+          Ty ty1, int eleBits1, // arg1
+          Ty ty2, int eleBits2, // arg2
+          Ty ty3, int eleBits3> // arg3
+static inline mlir::FunctionType genFuncType(mlir::MLIRContext *context) {
+  return genFuncType<tyR, eleBitsR, ty1, eleBits1, ty2, eleBits2, ty3, eleBits3,
+                     Ty::Void, 0>(context);
+}
+
+template <Ty tyR, int eleBitsR, // return type
+          Ty ty1, int eleBits1, // arg1
+          Ty ty2, int eleBits2> // arg2
+static inline mlir::FunctionType genFuncType(mlir::MLIRContext *context) {
+  return genFuncType<tyR, eleBitsR, ty1, eleBits1, ty2, eleBits2, Ty::Void, 0,
+                     Ty::Void, 0>(context);
+}
+
+template <Ty tyR, int eleBitsR, // return type
+          Ty ty1, int eleBits1> // arg1
+static inline mlir::FunctionType genFuncType(mlir::MLIRContext *context) {
+  return genFuncType<tyR, eleBitsR, ty1, eleBits1, Ty::Void, 0, Ty::Void, 0,
+                     Ty::Void, 0>(context);
+}
+
 /// Return argument lowering rules for an intrinsic.
 /// Returns a nullptr if all the intrinsic arguments should be lowered by value.
 const IntrinsicArgumentLoweringRules *
 getIntrinsicArgumentLowering(llvm::StringRef intrinsicName);
 
 /// Return how argument \p argName should be lowered given the rules for the
 /// intrinsic function. The argument names are the one defined by the standard.
 ArgLoweringRule lowerIntrinsicArgumentAs(const IntrinsicArgumentLoweringRules &,

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

llvm::cl::opt<MathRuntimeVersion> mathRuntimeVersion(
     llvm::cl::init(fastVersion));
 
 static llvm::cl::opt<bool>
     disableMlirComplex("disable-mlir-complex",
                        llvm::cl::desc("Use libm instead of the MLIR complex "
                                       "dialect to lower complex operations"),
                        llvm::cl::init(false));
 
-static mlir::FunctionType genF32F32FuncType(mlir::MLIRContext *context) {
-  mlir::Type t = mlir::FloatType::getF32(context);
-  return mlir::FunctionType::get(context, {t}, {t});
-}
-
-static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *context) {
-  mlir::Type t = mlir::FloatType::getF64(context);
-  return mlir::FunctionType::get(context, {t}, {t});
-}
-
-static mlir::FunctionType genF80F80FuncType(mlir::MLIRContext *context) {
-  mlir::Type t = mlir::FloatType::getF80(context);
-  return mlir::FunctionType::get(context, {t}, {t});
-}
-
-static mlir::FunctionType genF128F128FuncType(mlir::MLIRContext *context) {
-  mlir::Type t = mlir::FloatType::getF128(context);
-  return mlir::FunctionType::get(context, {t}, {t});
-}
-
-static mlir::FunctionType genF32F32F32FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF32(context);
-  return mlir::FunctionType::get(context, {t, t}, {t});
-}
-
-static mlir::FunctionType genF64F64F64FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF64(context);
-  return mlir::FunctionType::get(context, {t, t}, {t});
-}
-
-static mlir::FunctionType genF80F80F80FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF80(context);
-  return mlir::FunctionType::get(context, {t, t}, {t});
-}
-
-static mlir::FunctionType genF128F128F128FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF128(context);
-  return mlir::FunctionType::get(context, {t, t}, {t});
-}
-
-static mlir::FunctionType genF32F32F32F32FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF32(context);
-  return mlir::FunctionType::get(context, {t, t, t}, {t});
-}
-
-static mlir::FunctionType genF64F64F64F64FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF64(context);
-  return mlir::FunctionType::get(context, {t, t, t}, {t});
-}
-
-template <int Bits>
-static mlir::FunctionType genVoidIntF64FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::IntegerType::get(context, Bits);
-  auto u = mlir::FloatType::getF64(context);
-  return mlir::FunctionType::get(context, {t, u}, std::nullopt);
-}
-
-template <int BitsA, int BitsB>
-static mlir::FunctionType genVoidIntIntFuncType(mlir::MLIRContext *context) {
-  auto t = mlir::IntegerType::get(context, BitsA);
-  auto u = mlir::IntegerType::get(context, BitsB);
-  return mlir::FunctionType::get(context, {t, u}, std::nullopt);
-}
-
-template <int Bits>
-static mlir::FunctionType genIntF64FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF64(context);
-  auto r = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {t}, {r});
-}
-
-template <int Bits>
-static mlir::FunctionType genIntF32FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF32(context);
-  auto r = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {t}, {r});
-}
-
-template <int Bits>
-static mlir::FunctionType genF64F64IntFuncType(mlir::MLIRContext *context) {
-  auto ftype = mlir::FloatType::getF64(context);
-  auto itype = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {ftype, itype}, {ftype});
-}
-
-template <int Bits>
-static mlir::FunctionType genF32F32IntFuncType(mlir::MLIRContext *context) {
-  auto ftype = mlir::FloatType::getF32(context);
-  auto itype = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {ftype, itype}, {ftype});
-}
-
-template <int Bits>
-static mlir::FunctionType genF64IntF64FuncType(mlir::MLIRContext *context) {
-  auto ftype = mlir::FloatType::getF64(context);
-  auto itype = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {itype, ftype}, {ftype});
-}
-
-template <int Bits>
-static mlir::FunctionType genF32IntF32FuncType(mlir::MLIRContext *context) {
-  auto ftype = mlir::FloatType::getF32(context);
-  auto itype = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {itype, ftype}, {ftype});
-}
-
-template <int Bits>
-static mlir::FunctionType genIntIntIntFuncType(mlir::MLIRContext *context) {
-  auto itype = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {itype, itype}, {itype});
-}
-
-template <int Kind>
-static mlir::FunctionType
-genComplexComplexFuncType(mlir::MLIRContext *context) {
-  auto ctype = fir::ComplexType::get(context, Kind);
-  return mlir::FunctionType::get(context, {ctype}, {ctype});
-}
-
-template <int Kind>
-static mlir::FunctionType
-genComplexComplexComplexFuncType(mlir::MLIRContext *context) {
-  auto ctype = fir::ComplexType::get(context, Kind);
-  return mlir::FunctionType::get(context, {ctype, ctype}, {ctype});
-}
-
-static mlir::FunctionType genF32ComplexFuncType(mlir::MLIRContext *context) {
-  auto ctype = fir::ComplexType::get(context, 4);
-  auto ftype = mlir::FloatType::getF32(context);
-  return mlir::FunctionType::get(context, {ctype}, {ftype});
-}
-
-static mlir::FunctionType genF64ComplexFuncType(mlir::MLIRContext *context) {
-  auto ctype = fir::ComplexType::get(context, 8);
-  auto ftype = mlir::FloatType::getF64(context);
-  return mlir::FunctionType::get(context, {ctype}, {ftype});
-}
-
-template <int Kind, int Bits>
-static mlir::FunctionType
-genComplexComplexIntFuncType(mlir::MLIRContext *context) {
-  auto ctype = fir::ComplexType::get(context, Kind);
-  auto itype = mlir::IntegerType::get(context, Bits);
-  return mlir::FunctionType::get(context, {ctype, itype}, {ctype});
-}
-
 static mlir::Value genLibCall(fir::FirOpBuilder &builder, mlir::Location loc,
                               llvm::StringRef libFuncName,
                               mlir::FunctionType libFuncType,
                               llvm::ArrayRef<mlir::Value> args) {
   LLVM_DEBUG(llvm::dbgs() << "Generating '" << libFuncName
                           << "' call with type ";
              libFuncType.dump(); llvm::dbgs() << "\n");
   mlir::func::FuncOp funcOp = builder.getNamedFunction(libFuncName);

 }
 
 /// Mapping between mathematical intrinsic operations and MLIR operations
 /// of some appropriate dialect (math, complex, etc.) or libm calls.
 /// TODO: support remaining Fortran math intrinsics.
 ///       See https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gfortran/\
 ///       Intrinsic-Procedures.html for a reference.
 static constexpr MathOperation mathOperations[] = {
-    {"abs", "fabsf", genF32F32FuncType, genMathOp<mlir::math::AbsFOp>},
-    {"abs", "fabs", genF64F64FuncType, genMathOp<mlir::math::AbsFOp>},
-    {"abs", "llvm.fabs.f128", genF128F128FuncType,
+    {"abs", "fabsf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::AbsFOp>},
+    {"abs", "fabs", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::AbsFOp>},
+    {"abs", "llvm.fabs.f128", genFuncType<Ty::Real, 128, Ty::Real, 128>,
      genMathOp<mlir::math::AbsFOp>},
-    {"abs", "cabsf", genF32ComplexFuncType,
+    {"abs", "cabsf", genFuncType<Ty::Real, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::AbsOp>},
-    {"abs", "cabs", genF64ComplexFuncType,
+    {"abs", "cabs", genFuncType<Ty::Real, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::AbsOp>},
-    {"acos", "acosf", genF32F32FuncType, genLibCall},
-    {"acos", "acos", genF64F64FuncType, genLibCall},
-    {"acos", "cacosf", genComplexComplexFuncType<4>, genLibCall},
-    {"acos", "cacos", genComplexComplexFuncType<8>, genLibCall},
-    {"acosh", "acoshf", genF32F32FuncType, genLibCall},
-    {"acosh", "acosh", genF64F64FuncType, genLibCall},
-    {"acosh", "cacoshf", genComplexComplexFuncType<4>, genLibCall},
-    {"acosh", "cacosh", genComplexComplexFuncType<8>, genLibCall},
+    {"acos", "acosf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"acos", "acos", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"acos", "cacosf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"acos", "cacos", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
+    {"acosh", "acoshf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"acosh", "acosh", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"acosh", "cacoshf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"acosh", "cacosh", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
     // llvm.trunc behaves the same way as libm's trunc.
-    {"aint", "llvm.trunc.f32", genF32F32FuncType, genLibCall},
-    {"aint", "llvm.trunc.f64", genF64F64FuncType, genLibCall},
-    {"aint", "llvm.trunc.f80", genF80F80FuncType, genLibCall},
+    {"aint", "llvm.trunc.f32", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"aint", "llvm.trunc.f64", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"aint", "llvm.trunc.f80", genFuncType<Ty::Real, 80, Ty::Real, 80>,
+     genLibCall},
     // llvm.round behaves the same way as libm's round.
-    {"anint", "llvm.round.f32", genF32F32FuncType,
+    {"anint", "llvm.round.f32", genFuncType<Ty::Real, 32, Ty::Real, 32>,
      genMathOp<mlir::LLVM::RoundOp>},
-    {"anint", "llvm.round.f64", genF64F64FuncType,
+    {"anint", "llvm.round.f64", genFuncType<Ty::Real, 64, Ty::Real, 64>,
      genMathOp<mlir::LLVM::RoundOp>},
-    {"anint", "llvm.round.f80", genF80F80FuncType,
+    {"anint", "llvm.round.f80", genFuncType<Ty::Real, 80, Ty::Real, 80>,
      genMathOp<mlir::LLVM::RoundOp>},
-    {"asin", "asinf", genF32F32FuncType, genLibCall},
-    {"asin", "asin", genF64F64FuncType, genLibCall},
-    {"asin", "casinf", genComplexComplexFuncType<4>, genLibCall},
-    {"asin", "casin", genComplexComplexFuncType<8>, genLibCall},
-    {"asinh", "asinhf", genF32F32FuncType, genLibCall},
-    {"asinh", "asinh", genF64F64FuncType, genLibCall},
-    {"asinh", "casinhf", genComplexComplexFuncType<4>, genLibCall},
-    {"asinh", "casinh", genComplexComplexFuncType<8>, genLibCall},
-    {"atan", "atanf", genF32F32FuncType, genMathOp<mlir::math::AtanOp>},
-    {"atan", "atan", genF64F64FuncType, genMathOp<mlir::math::AtanOp>},
-    {"atan", "catanf", genComplexComplexFuncType<4>, genLibCall},
-    {"atan", "catan", genComplexComplexFuncType<8>, genLibCall},
-    {"atan2", "atan2f", genF32F32F32FuncType, genMathOp<mlir::math::Atan2Op>},
-    {"atan2", "atan2", genF64F64F64FuncType, genMathOp<mlir::math::Atan2Op>},
-    {"atanh", "atanhf", genF32F32FuncType, genLibCall},
-    {"atanh", "atanh", genF64F64FuncType, genLibCall},
-    {"atanh", "catanhf", genComplexComplexFuncType<4>, genLibCall},
-    {"atanh", "catanh", genComplexComplexFuncType<8>, genLibCall},
-    {"bessel_j0", "j0f", genF32F32FuncType, genLibCall},
-    {"bessel_j0", "j0", genF64F64FuncType, genLibCall},
-    {"bessel_j1", "j1f", genF32F32FuncType, genLibCall},
-    {"bessel_j1", "j1", genF64F64FuncType, genLibCall},
-    {"bessel_jn", "jnf", genF32IntF32FuncType<32>, genLibCall},
-    {"bessel_jn", "jn", genF64IntF64FuncType<32>, genLibCall},
-    {"bessel_y0", "y0f", genF32F32FuncType, genLibCall},
-    {"bessel_y0", "y0", genF64F64FuncType, genLibCall},
-    {"bessel_y1", "y1f", genF32F32FuncType, genLibCall},
-    {"bessel_y1", "y1", genF64F64FuncType, genLibCall},
-    {"bessel_yn", "ynf", genF32IntF32FuncType<32>, genLibCall},
-    {"bessel_yn", "yn", genF64IntF64FuncType<32>, genLibCall},
+    {"asin", "asinf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"asin", "asin", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"asin", "casinf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"asin", "casin", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
+    {"asinh", "asinhf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"asinh", "asinh", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"asinh", "casinhf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"asinh", "casinh", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
+    {"atan", "atanf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::AtanOp>},
+    {"atan", "atan", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::AtanOp>},
+    {"atan", "catanf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"atan", "catan", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
+    {"atan2", "atan2f", genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::Atan2Op>},
+    {"atan2", "atan2", genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::Atan2Op>},
+    {"atanh", "atanhf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"atanh", "atanh", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"atanh", "catanhf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"atanh", "catanh", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
+    {"bessel_j0", "j0f", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"bessel_j0", "j0", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"bessel_j1", "j1f", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"bessel_j1", "j1", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"bessel_jn", "jnf",
+     genFuncType<Ty::Real, 32, Ty::Integer, 32, Ty::Real, 32>, genLibCall},
+    {"bessel_jn", "jn",
+     genFuncType<Ty::Real, 64, Ty::Integer, 32, Ty::Real, 64>, genLibCall},
+    {"bessel_y0", "y0f", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"bessel_y0", "y0", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"bessel_y1", "y1f", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"bessel_y1", "y1", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"bessel_yn", "ynf",
+     genFuncType<Ty::Real, 32, Ty::Integer, 32, Ty::Real, 32>, genLibCall},
+    {"bessel_yn", "yn",
+     genFuncType<Ty::Real, 64, Ty::Integer, 32, Ty::Real, 64>, genLibCall},
     // math::CeilOp returns a real, while Fortran CEILING returns integer.
-    {"ceil", "ceilf", genF32F32FuncType, genMathOp<mlir::math::CeilOp>},
-    {"ceil", "ceil", genF64F64FuncType, genMathOp<mlir::math::CeilOp>},
-    {"cos", "cosf", genF32F32FuncType, genMathOp<mlir::math::CosOp>},
-    {"cos", "cos", genF64F64FuncType, genMathOp<mlir::math::CosOp>},
-    {"cos", "ccosf", genComplexComplexFuncType<4>,
+    {"ceil", "ceilf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::CeilOp>},
+    {"ceil", "ceil", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::CeilOp>},
+    {"cos", "cosf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::CosOp>},
+    {"cos", "cos", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::CosOp>},
+    {"cos", "ccosf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::CosOp>},
-    {"cos", "ccos", genComplexComplexFuncType<8>,
+    {"cos", "ccos", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::CosOp>},
-    {"cosh", "coshf", genF32F32FuncType, genLibCall},
-    {"cosh", "cosh", genF64F64FuncType, genLibCall},
-    {"cosh", "ccoshf", genComplexComplexFuncType<4>, genLibCall},
-    {"cosh", "ccosh", genComplexComplexFuncType<8>, genLibCall},
+    {"cosh", "coshf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"cosh", "cosh", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"cosh", "ccoshf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"cosh", "ccosh", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
     {"divc",
      {},
-     genComplexComplexComplexFuncType<2>,
+     genFuncType<Ty::Complex, 16, Ty::Complex, 16, Ty::Complex, 16>,
      genComplexMathOp<mlir::complex::DivOp>},
     {"divc",
      {},
-     genComplexComplexComplexFuncType<3>,
+     genFuncType<Ty::Complex, 24, Ty::Complex, 24, Ty::Complex, 24>,
      genComplexMathOp<mlir::complex::DivOp>},
-    {"divc", "__divsc3", genComplexComplexComplexFuncType<4>,
+    {"divc", "__divsc3",
+     genFuncType<Ty::Complex, 32, Ty::Complex, 32, Ty::Complex, 32>,
      genLibSplitComplexArgsCall},
-    {"divc", "__divdc3", genComplexComplexComplexFuncType<8>,
+    {"divc", "__divdc3",
+     genFuncType<Ty::Complex, 64, Ty::Complex, 64, Ty::Complex, 64>,
      genLibSplitComplexArgsCall},
-    {"divc", "__divxc3", genComplexComplexComplexFuncType<10>,
+    {"divc", "__divxc3",
+     genFuncType<Ty::Complex, 80, Ty::Complex, 80, Ty::Complex, 80>,
      genLibSplitComplexArgsCall},
-    {"divc", "__divtc3", genComplexComplexComplexFuncType<16>,
+    {"divc", "__divtc3",
+     genFuncType<Ty::Complex, 128, Ty::Complex, 128, Ty::Complex, 128>,
      genLibSplitComplexArgsCall},
-    {"erf", "erff", genF32F32FuncType, genMathOp<mlir::math::ErfOp>},
-    {"erf", "erf", genF64F64FuncType, genMathOp<mlir::math::ErfOp>},
-    {"erfc", "erfcf", genF32F32FuncType, genLibCall},
-    {"erfc", "erfc", genF64F64FuncType, genLibCall},
-    {"exp", "expf", genF32F32FuncType, genMathOp<mlir::math::ExpOp>},
-    {"exp", "exp", genF64F64FuncType, genMathOp<mlir::math::ExpOp>},
-    {"exp", "cexpf", genComplexComplexFuncType<4>,
+    {"erf", "erff", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::ErfOp>},
+    {"erf", "erf", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::ErfOp>},
+    {"erfc", "erfcf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"erfc", "erfc", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"exp", "expf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::ExpOp>},
+    {"exp", "exp", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::ExpOp>},
+    {"exp", "cexpf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::ExpOp>},
-    {"exp", "cexp", genComplexComplexFuncType<8>,
+    {"exp", "cexp", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::ExpOp>},
     // math::FloorOp returns a real, while Fortran FLOOR returns integer.
-    {"floor", "floorf", genF32F32FuncType, genMathOp<mlir::math::FloorOp>},
-    {"floor", "floor", genF64F64FuncType, genMathOp<mlir::math::FloorOp>},
-    {"gamma", "tgammaf", genF32F32FuncType, genLibCall},
-    {"gamma", "tgamma", genF64F64FuncType, genLibCall},
-    {"hypot", "hypotf", genF32F32F32FuncType, genLibCall},
-    {"hypot", "hypot", genF64F64F64FuncType, genLibCall},
-    {"log", "logf", genF32F32FuncType, genMathOp<mlir::math::LogOp>},
-    {"log", "log", genF64F64FuncType, genMathOp<mlir::math::LogOp>},
-    {"log", "clogf", genComplexComplexFuncType<4>,
+    {"floor", "floorf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::FloorOp>},
+    {"floor", "floor", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::FloorOp>},
+    {"gamma", "tgammaf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"gamma", "tgamma", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"hypot", "hypotf", genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"hypot", "hypot", genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"log", "logf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::LogOp>},
+    {"log", "log", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::LogOp>},
+    {"log", "clogf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::LogOp>},
-    {"log", "clog", genComplexComplexFuncType<8>,
+    {"log", "clog", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::LogOp>},
-    {"log10", "log10f", genF32F32FuncType, genMathOp<mlir::math::Log10Op>},
-    {"log10", "log10", genF64F64FuncType, genMathOp<mlir::math::Log10Op>},
-    {"log_gamma", "lgammaf", genF32F32FuncType, genLibCall},
-    {"log_gamma", "lgamma", genF64F64FuncType, genLibCall},
+    {"log10", "log10f", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::Log10Op>},
+    {"log10", "log10", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::Log10Op>},
+    {"log_gamma", "lgammaf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"log_gamma", "lgamma", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
     // llvm.lround behaves the same way as libm's lround.
-    {"nint", "llvm.lround.i64.f64", genIntF64FuncType<64>, genLibCall},
-    {"nint", "llvm.lround.i64.f32", genIntF32FuncType<64>, genLibCall},
-    {"nint", "llvm.lround.i32.f64", genIntF64FuncType<32>, genLibCall},
-    {"nint", "llvm.lround.i32.f32", genIntF32FuncType<32>, genLibCall},
-    {"pow", {}, genIntIntIntFuncType<8>, genMathOp<mlir::math::IPowIOp>},
-    {"pow", {}, genIntIntIntFuncType<16>, genMathOp<mlir::math::IPowIOp>},
-    {"pow", {}, genIntIntIntFuncType<32>, genMathOp<mlir::math::IPowIOp>},
-    {"pow", {}, genIntIntIntFuncType<64>, genMathOp<mlir::math::IPowIOp>},
-    {"pow", "powf", genF32F32F32FuncType, genMathOp<mlir::math::PowFOp>},
-    {"pow", "pow", genF64F64F64FuncType, genMathOp<mlir::math::PowFOp>},
-    {"pow", "cpowf", genComplexComplexComplexFuncType<4>,
+    {"nint", "llvm.lround.i64.f64", genFuncType<Ty::Integer, 64, Ty::Real, 64>,
+     genLibCall},
+    {"nint", "llvm.lround.i64.f32", genFuncType<Ty::Integer, 64, Ty::Real, 32>,
+     genLibCall},
+    {"nint", "llvm.lround.i32.f64", genFuncType<Ty::Integer, 32, Ty::Real, 64>,
+     genLibCall},
+    {"nint", "llvm.lround.i32.f32", genFuncType<Ty::Integer, 32, Ty::Real, 32>,
+     genLibCall},
+    {"pow",
+     {},
+     genFuncType<Ty::Integer, 8, Ty::Integer, 8, Ty::Integer, 8>,
+     genMathOp<mlir::math::IPowIOp>},
+    {"pow",
+     {},
+     genFuncType<Ty::Integer, 16, Ty::Integer, 16, Ty::Integer, 16>,
+     genMathOp<mlir::math::IPowIOp>},
+    {"pow",
+     {},
+     genFuncType<Ty::Integer, 32, Ty::Integer, 32, Ty::Integer, 32>,
+     genMathOp<mlir::math::IPowIOp>},
+    {"pow",
+     {},
+     genFuncType<Ty::Integer, 64, Ty::Integer, 64, Ty::Integer, 64>,
+     genMathOp<mlir::math::IPowIOp>},
+    {"pow", "powf", genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::PowFOp>},
+    {"pow", "pow", genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::PowFOp>},
+    {"pow", "cpowf",
+     genFuncType<Ty::Complex, 32, Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::PowOp>},
-    {"pow", "cpow", genComplexComplexComplexFuncType<8>,
+    {"pow", "cpow",
+     genFuncType<Ty::Complex, 64, Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::PowOp>},
-    {"pow", RTNAME_STRING(FPow4i), genF32F32IntFuncType<32>,
+    {"pow", RTNAME_STRING(FPow4i),
+     genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Integer, 32>,
      genMathOp<mlir::math::FPowIOp>},
-    {"pow", RTNAME_STRING(FPow8i), genF64F64IntFuncType<32>,
+    {"pow", RTNAME_STRING(FPow8i),
+     genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Integer, 32>,
      genMathOp<mlir::math::FPowIOp>},
-    {"pow", RTNAME_STRING(FPow4k), genF32F32IntFuncType<64>,
+    {"pow", RTNAME_STRING(FPow4k),
+     genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Integer, 64>,
      genMathOp<mlir::math::FPowIOp>},
-    {"pow", RTNAME_STRING(FPow8k), genF64F64IntFuncType<64>,
+    {"pow", RTNAME_STRING(FPow8k),
+     genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Integer, 64>,
      genMathOp<mlir::math::FPowIOp>},
-    {"pow", RTNAME_STRING(cpowi), genComplexComplexIntFuncType<4, 32>,
+    {"pow", RTNAME_STRING(cpowi),
+     genFuncType<Ty::Complex, 32, Ty::Complex, 32, Ty::Integer, 32>,
      genLibCall},
-    {"pow", RTNAME_STRING(zpowi), genComplexComplexIntFuncType<8, 32>,
+    {"pow", RTNAME_STRING(zpowi),
+     genFuncType<Ty::Complex, 64, Ty::Complex, 64, Ty::Integer, 32>,
      genLibCall},
-    {"pow", RTNAME_STRING(cpowk), genComplexComplexIntFuncType<4, 64>,
+    {"pow", RTNAME_STRING(cpowk),
+     genFuncType<Ty::Complex, 32, Ty::Complex, 32, Ty::Integer, 64>,
      genLibCall},
-    {"pow", RTNAME_STRING(zpowk), genComplexComplexIntFuncType<8, 64>,
+    {"pow", RTNAME_STRING(zpowk),
+     genFuncType<Ty::Complex, 64, Ty::Complex, 64, Ty::Integer, 64>,
      genLibCall},
-    {"sign", "copysignf", genF32F32F32FuncType,
+    {"sign", "copysignf", genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
      genMathOp<mlir::math::CopySignOp>},
-    {"sign", "copysign", genF64F64F64FuncType,
+    {"sign", "copysign", genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
      genMathOp<mlir::math::CopySignOp>},
-    {"sign", "copysignl", genF80F80F80FuncType,
+    {"sign", "copysignl", genFuncType<Ty::Real, 80, Ty::Real, 80, Ty::Real, 80>,
      genMathOp<mlir::math::CopySignOp>},
-    {"sign", "llvm.copysign.f128", genF128F128F128FuncType,
+    {"sign", "llvm.copysign.f128",
+     genFuncType<Ty::Real, 128, Ty::Real, 128, Ty::Real, 128>,
      genMathOp<mlir::math::CopySignOp>},
-    {"sin", "sinf", genF32F32FuncType, genMathOp<mlir::math::SinOp>},
-    {"sin", "sin", genF64F64FuncType, genMathOp<mlir::math::SinOp>},
-    {"sin", "csinf", genComplexComplexFuncType<4>,
+    {"sin", "sinf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::SinOp>},
+    {"sin", "sin", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::SinOp>},
+    {"sin", "csinf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::SinOp>},
-    {"sin", "csin", genComplexComplexFuncType<8>,
+    {"sin", "csin", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::SinOp>},
-    {"sinh", "sinhf", genF32F32FuncType, genLibCall},
-    {"sinh", "sinh", genF64F64FuncType, genLibCall},
-    {"sinh", "csinhf", genComplexComplexFuncType<4>, genLibCall},
-    {"sinh", "csinh", genComplexComplexFuncType<8>, genLibCall},
-    {"sqrt", "sqrtf", genF32F32FuncType, genMathOp<mlir::math::SqrtOp>},
-    {"sqrt", "sqrt", genF64F64FuncType, genMathOp<mlir::math::SqrtOp>},
-    {"sqrt", "csqrtf", genComplexComplexFuncType<4>,
+    {"sinh", "sinhf", genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
+    {"sinh", "sinh", genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"sinh", "csinhf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
+     genLibCall},
+    {"sinh", "csinh", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
+     genLibCall},
+    {"sqrt", "sqrtf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::SqrtOp>},
+    {"sqrt", "sqrt", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::SqrtOp>},
+    {"sqrt", "csqrtf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::SqrtOp>},
-    {"sqrt", "csqrt", genComplexComplexFuncType<8>,
+    {"sqrt", "csqrt", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::SqrtOp>},
-    {"tan", "tanf", genF32F32FuncType, genMathOp<mlir::math::TanOp>},
-    {"tan", "tan", genF64F64FuncType, genMathOp<mlir::math::TanOp>},
-    {"tan", "ctanf", genComplexComplexFuncType<4>,
+    {"tan", "tanf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::TanOp>},
+    {"tan", "tan", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::TanOp>},
+    {"tan", "ctanf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::TanOp>},
-    {"tan", "ctan", genComplexComplexFuncType<8>,
+    {"tan", "ctan", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::TanOp>},
-    {"tanh", "tanhf", genF32F32FuncType, genMathOp<mlir::math::TanhOp>},
-    {"tanh", "tanh", genF64F64FuncType, genMathOp<mlir::math::TanhOp>},
-    {"tanh", "ctanhf", genComplexComplexFuncType<4>,
+    {"tanh", "tanhf", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genMathOp<mlir::math::TanhOp>},
+    {"tanh", "tanh", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genMathOp<mlir::math::TanhOp>},
+    {"tanh", "ctanhf", genFuncType<Ty::Complex, 32, Ty::Complex, 32>,
      genComplexMathOp<mlir::complex::TanhOp>},
-    {"tanh", "ctanh", genComplexComplexFuncType<8>,
+    {"tanh", "ctanh", genFuncType<Ty::Complex, 64, Ty::Complex, 64>,
      genComplexMathOp<mlir::complex::TanhOp>},
 };
 
 static constexpr MathOperation ppcMathOperations[] = {
     // fcfi is just another name for fcfid, there is no llvm.ppc.fcfi.
-    {"__ppc_fcfi", "llvm.ppc.fcfid", genF64F64FuncType, genLibCall},
-    {"__ppc_fcfid", "llvm.ppc.fcfid", genF64F64FuncType, genLibCall},
-    {"__ppc_fcfud", "llvm.ppc.fcfud", genF64F64FuncType, genLibCall},
-    {"__ppc_fctid", "llvm.ppc.fctid", genF64F64FuncType, genLibCall},
-    {"__ppc_fctidz", "llvm.ppc.fctidz", genF64F64FuncType, genLibCall},
-    {"__ppc_fctiw", "llvm.ppc.fctiw", genF64F64FuncType, genLibCall},
-    {"__ppc_fctiwz", "llvm.ppc.fctiwz", genF64F64FuncType, genLibCall},
-    {"__ppc_fctudz", "llvm.ppc.fctudz", genF64F64FuncType, genLibCall},
-    {"__ppc_fctuwz", "llvm.ppc.fctuwz", genF64F64FuncType, genLibCall},
-    {"__ppc_fmadd", "llvm.fma.f32", genF32F32F32F32FuncType,
+    {"__ppc_fcfi", "llvm.ppc.fcfid", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fcfid", "llvm.ppc.fcfid", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fcfud", "llvm.ppc.fcfud", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fctid", "llvm.ppc.fctid", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fctidz", "llvm.ppc.fctidz", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fctiw", "llvm.ppc.fctiw", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fctiwz", "llvm.ppc.fctiwz", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fctudz", "llvm.ppc.fctudz", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fctuwz", "llvm.ppc.fctuwz", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fmadd", "llvm.fma.f32",
+     genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
      genMathOp<mlir::math::FmaOp>},
-    {"__ppc_fmadd", "llvm.fma.f64", genF64F64F64F64FuncType,
+    {"__ppc_fmadd", "llvm.fma.f64",
+     genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
      genMathOp<mlir::math::FmaOp>},
-    {"__ppc_fmsub", "llvm.ppc.fmsubs", genF32F32F32F32FuncType, genLibCall},
-    {"__ppc_fmsub", "llvm.ppc.fmsub", genF64F64F64F64FuncType, genLibCall},
-    {"__ppc_fnabs", "llvm.ppc.fnabss", genF32F32FuncType, genLibCall},
-    {"__ppc_fnabs", "llvm.ppc.fnabs", genF64F64FuncType, genLibCall},
-    {"__ppc_fnmadd", "llvm.ppc.fnmadds", genF32F32F32F32FuncType, genLibCall},
-    {"__ppc_fnmadd", "llvm.ppc.fnmadd", genF64F64F64F64FuncType, genLibCall},
-    {"__ppc_fnmsub", "llvm.ppc.fnmsub.f32", genF32F32F32F32FuncType,
-     genLibCall},
-    {"__ppc_fnmsub", "llvm.ppc.fnmsub.f64", genF64F64F64F64FuncType,
-     genLibCall},
-    {"__ppc_fre", "llvm.ppc.fre", genF64F64FuncType, genLibCall},
-    {"__ppc_fres", "llvm.ppc.fres", genF32F32FuncType, genLibCall},
-    {"__ppc_frsqrte", "llvm.ppc.frsqrte", genF64F64FuncType, genLibCall},
-    {"__ppc_frsqrtes", "llvm.ppc.frsqrtes", genF32F32FuncType, genLibCall},
+    {"__ppc_fmsub", "llvm.ppc.fmsubs",
+     genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"__ppc_fmsub", "llvm.ppc.fmsub",
+     genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fnabs", "llvm.ppc.fnabss", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"__ppc_fnabs", "llvm.ppc.fnabs", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fnmadd", "llvm.ppc.fnmadds",
+     genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"__ppc_fnmadd", "llvm.ppc.fnmadd",
+     genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fnmsub", "llvm.ppc.fnmsub.f32",
+     genFuncType<Ty::Real, 32, Ty::Real, 32, Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"__ppc_fnmsub", "llvm.ppc.fnmsub.f64",
+     genFuncType<Ty::Real, 64, Ty::Real, 64, Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fre", "llvm.ppc.fre", genFuncType<Ty::Real, 64, Ty::Real, 64>,
+     genLibCall},
+    {"__ppc_fres", "llvm.ppc.fres", genFuncType<Ty::Real, 32, Ty::Real, 32>,
+     genLibCall},
+    {"__ppc_frsqrte", "llvm.ppc.frsqrte",
+     genFuncType<Ty::Real, 64, Ty::Real, 64>, genLibCall},
+    {"__ppc_frsqrtes", "llvm.ppc.frsqrtes",
+     genFuncType<Ty::Real, 32, Ty::Real, 32>, genLibCall},
 };
 
 // This helper class computes a "distance" between two function types.
 // The distance measures how many narrowing conversions of actual arguments
 // and result of "from" must be made in order to use "to" instead of "from".
 // For instance, the distance between ACOS(REAL(10)) and ACOS(REAL(8)) is
 // greater than the one between ACOS(REAL(10)) and ACOS(REAL(16)). This means
 // if no implementation of ACOS(REAL(10)) is available, it is better to use
for (const fir::ExtendedValue &arg : args)
     if (arg.getUnboxed())
       scalarArgs.emplace_back(fir::getBase(arg));
     else
       mlir::emitError(loc, "nonscalar intrinsic argument");
 
   mlir::FunctionType libFuncType;
   mlir::func::FuncOp funcOp;
   if (isImm) {
-    libFuncType = genVoidIntIntFuncType<32, 32>(builder.getContext());
+    libFuncType = genFuncType<Ty::Void, 0 /* value ignored */, Ty::Integer, 32,
+                              Ty::Integer, 32>(builder.getContext());
     funcOp = builder.addNamedFunction(loc, "llvm.ppc.mtfsfi", libFuncType);
   } else {
-    libFuncType = genVoidIntF64FuncType<32>(builder.getContext());
+    libFuncType = genFuncType<Ty::Void, 0 /* value ignored */, Ty::Integer, 32,
+                              Ty::Real, 64>(builder.getContext());
     funcOp = builder.addNamedFunction(loc, "llvm.ppc.mtfsf", libFuncType);
   }
   builder.create<fir::CallOp>(loc, funcOp, scalarArgs);
 }
 
 //===----------------------------------------------------------------------===//
 // Argument lowering rules interface for intrinsic or intrinsic module
 // procedure.