[fir] Add fir reduction builder

[clementval]

Summary

This patch introduces a bunch of builder functions
to create function calls to runtime reduction functions.

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: Jean Perier <[e-mail]>
Co-authored-by: mleair <[e-mail]>

[clementval]

Extract base of test to be used by other

[rovka]

Just some initial comments (haven't managed to look through everything yet).

flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h

31 ↗

(On Diff #389294)

62 ↗

(On Diff #389294)

Can we get rid of all of this duplication by using std::is_integral etc?

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

Should we use backticks or something around function names? It reads really strange otherwise.
Also, isn't this actually AllDim?

flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h

57 ↗

(On Diff #389294)

[kiranchandramohan]

If RuntimeCalltestBase can be factored out into a separate patch, the other patches can be tested or reviewed independently.

[awarzynski]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

Should we use backticks or something around function names?

+1

Also, what is the difference between genAllDescriptor and genAll? Why do we need both?

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

15

21

Same suggestion in other places.

26–27

Move next to other "// Commonly used types" in RuntimeCallTest?

flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h

21 ↗

(On Diff #389294)

87–93 ↗

(On Diff #389294)

[awarzynski]

In D114460#3151536, @kiranchandramohan wrote:

If RuntimeCalltestBase can be factored out into a separate patch, the other patches can be tested or reviewed independently.

I second that. I appreciate that there's a lot of repetition here, but I would really help if this was split into smaller patches.

[clementval]

In D114460#3151536, @kiranchandramohan wrote:

If RuntimeCalltestBase can be factored out into a separate patch, the other patches can be tested or reviewed independently.

Done in D114557. I'm going to rebase other patch on this.

[clementval]

Rebase on D114557

[clementval]

In D114460#3151536, @kiranchandramohan wrote:

If RuntimeCalltestBase can be factored out into a separate patch, the other patches can be tested or reviewed independently.

Should I move flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h as well to the initial patch? It would makes sense since all other need this file.

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

The comments are pretty clear on the differences.

[rovka]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

But to clarify: the runtime sometimes has different entry points for the same intrinsic, for special cases. In this case, IIUC, there's All and AllDim, both of which implement the ALL intrinsic. If you look in the standard, you'll see there's 2 variants: ALL(MASK) or ALL(MASK, DIM).

[kiranchandramohan]

In D114460#3152380, @clementval wrote:

In D114460#3151536, @kiranchandramohan wrote:

If RuntimeCalltestBase can be factored out into a separate patch, the other patches can be tested or reviewed independently.

Should I move flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h as well to the initial patch? It would makes sense since all other need this file.

Yes, that would be good. You can cite other patches which are consumers.

[awarzynski]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

(...) to clarify (...)

Many thanks @rovka !

If you look in the standard (...)

Ah, I see! In fact, I think that it would make a lot of sense to refer to the standard here and to use the notation from there as well (like in Diana's comment).

The comments are pretty clear on the differences.

I disagree. There is genAllDescriptor and genAll, but there's no reference to any "descriptor" in the comments, arguments or the implementation. Also, both methods seem to "Generate call to all runtime routine", but one returns an mlir::Value, whereas the other is void. If both basically generate a call, then why are the interfaces completely different? I appreciate the this implementation may depend on the APIs in the runtime, but it still does not explain what this "descriptor" in genAllDescriptor is and what are the return values are.

[kiranchandramohan]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

For the descriptor version, the result is in an array for which a descriptor is needed. It is probably created by the runtime.

[clementval]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

I disagree. There is genAllDescriptor and genAll, but there's no reference to any "descriptor" in the comments, arguments or the implementation. Also, both methods seem to "Generate call to all runtime routine", but one returns an mlir::Value, whereas the other is void. If both basically generate a call, then why are the interfaces completely different? I appreciate the this implementation may depend on the APIs in the runtime, but it still does not explain what this "descriptor" in genAllDescriptor is and what are the return values are.

There is a reference to descriptor in the comment and there is a result argument which is the "descriptor".

[clementval]

flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h

62 ↗

(On Diff #389294)

Not sure I see where do you want us to go here. Do you have an example?

[clementval]

Rebase on D114557

[clementval]

In D114460#3153122, @kiranchandramohan wrote:

In D114460#3152380, @clementval wrote:

In D114460#3151536, @kiranchandramohan wrote:

If RuntimeCalltestBase can be factored out into a separate patch, the other patches can be tested or reviewed independently.

Should I move flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h as well to the initial patch? It would makes sense since all other need this file.

Yes, that would be good. You can cite other patches which are consumers.

RTBuilder.h moved to D114557

[clementval]

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

21

Does this really help?

26–27

Are you talking about seqTy or result? Not sure if the comment moved with the update.

[clementval]

Add tick around intrinsic function name.

[rovka]

flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h

62 ↗

(On Diff #389294)

Moved discussion to https://reviews.llvm.org/D114557

[clementval]

Add tick around instrinsic function name in Reduction.h

[awarzynski]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

8

22

Thank you all for clarifying. This is starting to make sense. I still believe that the comments for these hooks should be improved and clarify the underlying logic. Please see my suggestion at the top of this file. WDYT?

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

21

Yes. _FortranAll is somewhat self-explanatory. But 2 is a magic number without the comment.

26–27

Both are re-defined multiple times. So is undef, dim and a few other. I'd keep only keep the bare minimum in every test that's unique to a particular case being tested. Reduced code-duplication, makes this file shorter.

[clementval]

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

21

Fells like more work for not so much

26–27

Values have to be created right here otherwise the test does not make sense. Type can be moved to the SetUp.

[awarzynski]

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

26–27

Values have to be created right here otherwise the test does not make sense.

Why not? Do you think that this way it will be clearer or is there a technical reason?

[clementval]

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

26–27

No technical reason but I think it's clearer to create the operations used in the call right here.

[awarzynski]

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

26–27

👍🏻

[awarzynski]

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

21

Not that much work:

Add `/*fctName=*/

awk '($1 ~ /checkCallOpFromResultBox/) && !($2 ~ /fctNam/) {printf("%s /*fctName=*/%s %s\n", $1, $2, $3)}' flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

Add `/*nbArgs=*/

awk '($1 ~ /checkCallOpFromResultBox/) && !($3 ~ /nbArgs/) {printf("%s %s /*nbArgs=*/%s\n", $1, $2, $3)}' flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

This is not a blocker for me.

[clementval]

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

21

Editing is quite easy as you mentioned. But updating all the patches is time consuming. I personally don't see the value of adding this. If someone else lean on your side I'll do the update.

[rovka]

Just some nits, otherwise LGTM (but please wait for Andrzej and Kiran to have another look too).

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

29

flang/lib/Optimizer/Builder/Runtime/Reduction.cpp

455

465

554

What happens if one of these is actually used before it's implemented in the runtime? Will that be a linker error? Or is it caught sooner?

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

225

251

280

[clementval]

Address review comments

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

I'm not sure your comment represents what's happening. It describes what happens in the runtime but here we are just interested to generate the call and anything related to the runtime should be documented there.

flang/lib/Optimizer/Builder/Runtime/Reduction.cpp

554

I guess it will result in a linker error.

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

225

It is actually used for Min and Max that's why it is Mxx

251

Same here used for both min and max

280

Same here used for both min and max,

[awarzynski]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

I'm not sure your comment represents what's happening.

Sure, it's just a suggestion and what I got from the conversation here. How could we improve it?

It describes what happens in the runtime

That wasn't the intention. However, as I understand, the implementation here is dictated by the implementation of the runtime. So one cannot really explain this API without discussing the runtime.

Please, feel free to discard my suggestion. However, I would really appreciate if you added some other additional documentation instead. Something that would hint the reasons behind genAllDescriptor and genAll having almost completely different signatures. That's the most visible difference here ATM.

[clementval]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

Honestly, I'm not sure I follow you here. The signature are not *completely* different. One takes a box (descriptor) to hold the result and the other is a specialized version for rank one so no box and a return value. The comments on both functions are mentioning that. How it is handle in the runtime does not belong here IMO since we are just creating a call to the runtime.

[awarzynski]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

IMHO, the comments and naming used here are clear to somebody already familiar with this API and the wider context of how runtime calls are generated, but not so much to somebody new to this. Personally, I was missing that context when reading this file for the first time and the comments from @rovka and @kiranchandramohan really helped clarifying that. Thank you! Preserving their comments as extra documentation in this file felt like a natural and a low-cost thing to do that would be beneficial to the future Flang developers.

This is not a blocker for me.

[clementval]

Add comment explaining descriptor resultBox

[clementval]

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

22

Added a description extracted from comments

[awarzynski]

LGTM, thanks for all the updates! I've left a couple of comments, but these are non-blockers.

flang/lib/Optimizer/Builder/Runtime/Reduction.cpp

723

What's the magic 0 here?

872

[nit] Not used (apart from the following line), so may just delete (it's not like ty suggests what this type is for)

[clementval]

In D114460#3161429, @awarzynski wrote:

LGTM, thanks for all the updates! I've left a couple of comments, but these are non-blockers.

Thanks for the review. I'll address the two comments before landing it.

[clementval]

Addressed comment before landed. Mark as done.

[clementval]

Add missing macro

flang/include/flang/Optimizer/Builder/Runtime/Reduction.h

+//===-- Reduction.h -- generate calls to reduction runtime API --*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_OPTIMIZER_BUILDER_RUNTIME_REDUCTION_H
+#define FORTRAN_OPTIMIZER_BUILDER_RUNTIME_REDUCTION_H
+
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+
+namespace fir {
+class ExtendedValue;
+class FirOpBuilder;
+} // namespace fir
+
+namespace fir::runtime {
+
+/// Generate call to all runtime routine.
+/// This calls the descriptor based runtime call implementation of the all
+/// intrinsic.
+void genAllDescriptor(fir::FirOpBuilder &builder, mlir::Location loc,
+                      mlir::Value resultBox, mlir::Value maskBox,
+                      mlir::Value dim);
+
+/// Generate call to any runtime routine.
+/// This calls the descriptor based runtime call implementation of the any
+/// intrinsic.
+void genAnyDescriptor(fir::FirOpBuilder &builder, mlir::Location loc,
+                      mlir::Value resultBox, mlir::Value maskBox,
+                      mlir::Value dim);
+
+/// Generate call to all runtime routine. This version of all is specialized
+/// for rank 1 mask arguments.
+/// This calls the version that returns a scalar logical value.
+mlir::Value genAll(fir::FirOpBuilder &builder, mlir::Location loc,
+                   mlir::Value maskBox, mlir::Value dim);
+
+/// Generate call to any runtime routine. This version of any is specialized
+/// for rank 1 mask arguments.
+/// This calls the version that returns a scalar logical value.
+mlir::Value genAny(fir::FirOpBuilder &builder, mlir::Location loc,
+                   mlir::Value maskBox, mlir::Value dim);
+
+/// Generate call to Count runtime routine. This routine is a specialized
+/// version when mask is a rank one array or the dim argument is not
+/// specified by the user.
+mlir::Value genCount(fir::FirOpBuilder &builder, mlir::Location loc,
+                     mlir::Value maskBox, mlir::Value dim);
+
+/// Generate call to general CountDim runtime routine. This routine has a
+/// descriptor result.
+void genCountDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                 mlir::Value resultBox, mlir::Value maskBox, mlir::Value dim,
+                 mlir::Value kind);
+
+/// Generate call to DotProduct intrinsic runtime routine.
+mlir::Value genDotProduct(fir::FirOpBuilder &builder, mlir::Location loc,
+                          mlir::Value vectorABox, mlir::Value vectorBBox,
+                          mlir::Value resultBox);
+
+/// Generate call to Maxloc intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+void genMaxloc(fir::FirOpBuilder &builder, mlir::Location loc,
+               mlir::Value resultBox, mlir::Value arrayBox, mlir::Value maskBox,
+               mlir::Value kind, mlir::Value back);
+
+/// Generate call to Maxloc intrinsic runtime routine. This is the version
+/// that takes a dim argument.
+void genMaxlocDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                  mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
+                  mlir::Value maskBox, mlir::Value kind, mlir::Value back);
+
+/// Generate call to Minloc intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+void genMinloc(fir::FirOpBuilder &builder, mlir::Location loc,
+               mlir::Value resultBox, mlir::Value arrayBox, mlir::Value maskBox,
+               mlir::Value kind, mlir::Value back);
+
+/// Generate call to Minloc intrinsic runtime routine. This is the version
+/// that takes a dim argument.
+void genMinlocDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                  mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
+                  mlir::Value maskBox, mlir::Value kind, mlir::Value back);
+
+/// Generate call to Maxval intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value genMaxval(fir::FirOpBuilder &builder, mlir::Location loc,
+                      mlir::Value arrayBox, mlir::Value maskBox);
+
+/// Generate call to Maxval intrinsic runtime routine. This is the version
+/// that that handles 1 dimensional character arrays  with no DIM argument.
+void genMaxvalChar(fir::FirOpBuilder &builder, mlir::Location loc,
+                   mlir::Value resultBox, mlir::Value arrayBox,
+                   mlir::Value maskBox);
+
+/// Generate call to Maxval intrinsic runtime routine. This is the version
+/// that takes arrays of any rank with a dim argument specified.
+void genMaxvalDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                  mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
+                  mlir::Value maskBox);
+
+/// Generate call to Minval intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value genMinval(fir::FirOpBuilder &builder, mlir::Location loc,
+                      mlir::Value arrayBox, mlir::Value maskBox);
+
+/// Generate call to Minval intrinsic runtime routine. This is the version
+/// that that handles 1 dimensional character arrays with no DIM argument.
+void genMinvalChar(fir::FirOpBuilder &builder, mlir::Location loc,
+                   mlir::Value resultBox, mlir::Value arrayBox,
+                   mlir::Value maskBox);
+
+/// Generate call to Minval intrinsic runtime routine. This is the version
+/// that takes arrays of any rank with a dim argument specified.
+void genMinvalDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                  mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
+                  mlir::Value maskBox);
+
+/// Generate call to Product intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value genProduct(fir::FirOpBuilder &builder, mlir::Location loc,
+                       mlir::Value arrayBox, mlir::Value maskBox,
+                       mlir::Value resultBox);
+
+/// Generate call to Product intrinsic runtime routine. This is the version
+/// that takes arrays of any rank with a dim argument specified.
+void genProductDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                   mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
+                   mlir::Value maskBox);
+
+/// Generate call to Sum intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value genSum(fir::FirOpBuilder &builder, mlir::Location loc,
+                   mlir::Value arrayBox, mlir::Value maskBox,
+                   mlir::Value resultBox);
+
+/// Generate call to Sum intrinsic runtime routine. This is the version
+/// that takes arrays of any rank with a dim argument specified.
+void genSumDim(fir::FirOpBuilder &builder, mlir::Location loc,
+               mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
+               mlir::Value maskBox);
+
+} // namespace fir::runtime
+
+#endif // FORTRAN_OPTIMIZER_BUILDER_RUNTIME_REDUCTION_H

flang/include/flang/Optimizer/Dialect/FIRTypes.td

let description = [{
     It is meant to implement indirection that cannot be expressed directly
     in Fortran, but are needed to implement some Fortran features (e.g,
     double indirections).
   }];
 
   let parameters = (ins "mlir::Type":$eleTy);
 
   let assemblyFormat = "`<` $eleTy `>`";
+
+  let builders = [
+    TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType), [{
+      return Base::get(elementType.getContext(), elementType);
+    }]>,
+  ];
 }
 
 def fir_PointerType : FIR_Type<"Pointer", "ptr"> {
   let summary = "Reference to a POINTER attribute type";
 
   let description = [{
     The type of entities with the POINTER attribute.  These pointers are
     explicitly distinguished to disallow the composition of multiple levels of

flang/lib/Optimizer/Builder/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FIRBuilder
   BoxValue.cpp
   Character.cpp
   Complex.cpp
   DoLoopHelper.cpp
   FIRBuilder.cpp
   MutableBox.cpp
+  Runtime/Reduction.cpp
 
   DEPENDS
   FIRDialect
   FIRSupport
   ${dialect_libs}
 
   LINK_LIBS
   FIRDialect
   FIRSupport
   ${dialect_libs}
 )

flang/lib/Optimizer/Builder/Runtime/Reduction.cpp

+//===-- Reduction.cpp -- generate reduction intrinsics runtime calls- -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Builder/Runtime/Reduction.h"
+#include "flang/Lower/Todo.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/Character.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
+#include "flang/Runtime/reduction.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+
+using namespace Fortran::runtime;
+
+/// Placeholder for real*10 version of Maxval Intrinsic
+struct ForcedMaxvalReal10 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(MaxvalReal10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF80(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for real*16 version of Maxval Intrinsic
+struct ForcedMaxvalReal16 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(MaxvalReal16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF128(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for integer*16 version of Maxval Intrinsic
+struct ForcedMaxvalInteger16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(MaxvalInteger16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::IntegerType::get(ctx, 128);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for real*10 version of Minval Intrinsic
+struct ForcedMinvalReal10 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(MinvalReal10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF80(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for real*16 version of Minval Intrinsic
+struct ForcedMinvalReal16 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(MinvalReal16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF128(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for integer*16 version of Minval Intrinsic
+struct ForcedMinvalInteger16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(MinvalInteger16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::IntegerType::get(ctx, 128);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for real*10 version of Product Intrinsic
+struct ForcedProductReal10 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(ProductReal10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF80(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for real*16 version of Product Intrinsic
+struct ForcedProductReal16 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(ProductReal16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF128(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for integer*16 version of Product Intrinsic
+struct ForcedProductInteger16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(ProductInteger16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::IntegerType::get(ctx, 128);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for complex(10) version of Product Intrinsic
+struct ForcedProductComplex10 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(CppProductComplex10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::ComplexType::get(mlir::FloatType::getF80(ctx));
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      auto resTy = fir::ReferenceType::get(ty);
+      return mlir::FunctionType::get(
+          ctx, {resTy, boxTy, strTy, intTy, intTy, boxTy}, {});
+    };
+  }
+};
+
+/// Placeholder for complex(16) version of Product Intrinsic
+struct ForcedProductComplex16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(CppProductComplex16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::ComplexType::get(mlir::FloatType::getF128(ctx));
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      auto resTy = fir::ReferenceType::get(ty);
+      return mlir::FunctionType::get(
+          ctx, {resTy, boxTy, strTy, intTy, intTy, boxTy}, {});
+    };
+  }
+};
+
+/// Placeholder for real*10 version of DotProduct Intrinsic
+struct ForcedDotProductReal10 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(DotProductReal10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF80(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, boxTy, strTy, intTy}, {ty});
+    };
+  }
+};
+
+/// Placeholder for real*16 version of DotProduct Intrinsic
+struct ForcedDotProductReal16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(DotProductReal16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF128(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, boxTy, strTy, intTy}, {ty});
+    };
+  }
+};
+
+/// Placeholder for complex(10) version of DotProduct Intrinsic
+struct ForcedDotProductComplex10 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(CppDotProductComplex10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::ComplexType::get(mlir::FloatType::getF80(ctx));
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      auto resTy = fir::ReferenceType::get(ty);
+      return mlir::FunctionType::get(ctx, {resTy, boxTy, boxTy, strTy, intTy},
+                                     {});
+    };
+  }
+};
+
+/// Placeholder for complex(16) version of DotProduct Intrinsic
+struct ForcedDotProductComplex16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(CppDotProductComplex16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::ComplexType::get(mlir::FloatType::getF128(ctx));
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      auto resTy = fir::ReferenceType::get(ty);
+      return mlir::FunctionType::get(ctx, {resTy, boxTy, boxTy, strTy, intTy},
+                                     {});
+    };
+  }
+};
+
+/// Placeholder for integer*16 version of DotProduct Intrinsic
+struct ForcedDotProductInteger16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(DotProductInteger16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::IntegerType::get(ctx, 128);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, boxTy, strTy, intTy}, {ty});
+    };
+  }
+};
+
+/// Placeholder for real*10 version of Sum Intrinsic
+struct ForcedSumReal10 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(SumReal10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF80(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for real*16 version of Sum Intrinsic
+struct ForcedSumReal16 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(SumReal16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::FloatType::getF128(ctx);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for integer*16 version of Sum Intrinsic
+struct ForcedSumInteger16 {
+  static constexpr const char *name = ExpandAndQuoteKey(RTNAME(SumInteger16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::IntegerType::get(ctx, 128);
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      return mlir::FunctionType::get(ctx, {boxTy, strTy, intTy, intTy, boxTy},
+                                     {ty});
+    };
+  }
+};
+
+/// Placeholder for complex(10) version of Sum Intrinsic
+struct ForcedSumComplex10 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(CppSumComplex10));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::ComplexType::get(mlir::FloatType::getF80(ctx));
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      auto resTy = fir::ReferenceType::get(ty);
+      return mlir::FunctionType::get(
+          ctx, {resTy, boxTy, strTy, intTy, intTy, boxTy}, {});
+    };
+  }
+};
+
+/// Placeholder for complex(16) version of Sum Intrinsic
+struct ForcedSumComplex16 {
+  static constexpr const char *name =
+      ExpandAndQuoteKey(RTNAME(CppSumComplex16));
+  static constexpr fir::runtime::FuncTypeBuilderFunc getTypeModel() {
+    return [](mlir::MLIRContext *ctx) {
+      auto ty = mlir::ComplexType::get(mlir::FloatType::getF128(ctx));
+      auto boxTy =
+          fir::runtime::getModel<const Fortran::runtime::Descriptor &>()(ctx);
+      auto strTy = fir::ReferenceType::get(mlir::IntegerType::get(ctx, 8));
+      auto intTy = mlir::IntegerType::get(ctx, 8 * sizeof(int));
+      auto resTy = fir::ReferenceType::get(ty);
+      return mlir::FunctionType::get(
+          ctx, {resTy, boxTy, strTy, intTy, intTy, boxTy}, {});
+    };
+  }
+};
+
+/// Generate call to specialized runtime function that takes a mask and
+/// dim argument. The All, Any, and Count intrinsics use this pattern.
+template <typename FN>
+mlir::Value genSpecial2Args(FN func, fir::FirOpBuilder &builder,
+                            mlir::Location loc, mlir::Value maskBox,
+                            mlir::Value dim) {
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
+  auto args = fir::runtime::createArguments(builder, loc, fTy, maskBox,
+                                            sourceFile, sourceLine, dim);
+  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
+}
+
+/// Generate calls to reduction intrinsics such as All and Any.
+/// These are the descriptor based implementations that take two
+/// arguments (mask, dim).
+template <typename FN>
+static void genReduction2Args(FN func, fir::FirOpBuilder &builder,
+                              mlir::Location loc, mlir::Value resultBox,
+                              mlir::Value maskBox, mlir::Value dim) {
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, resultBox, maskBox, dim, sourceFile, sourceLine);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// Generate calls to reduction intrinsics such as Maxval and Minval.
+/// These take arguments such as (array, dim, mask).
+template <typename FN>
+static void genReduction3Args(FN func, fir::FirOpBuilder &builder,
+                              mlir::Location loc, mlir::Value resultBox,
+                              mlir::Value arrayBox, mlir::Value dim,
+                              mlir::Value maskBox) {
+
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
+  auto args =
+      fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, dim,
+                                    sourceFile, sourceLine, maskBox);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// Generate calls to reduction intrinsics such as Maxloc and Minloc.
+/// These take arguments such as (array, mask, kind, back).
+template <typename FN>
+static void genReduction4Args(FN func, fir::FirOpBuilder &builder,
+                              mlir::Location loc, mlir::Value resultBox,
+                              mlir::Value arrayBox, mlir::Value maskBox,
+                              mlir::Value kind, mlir::Value back) {
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
+  auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
+                                            arrayBox, kind, sourceFile,
+                                            sourceLine, maskBox, back);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// Generate calls to reduction intrinsics such as Maxloc and Minloc.
+/// These take arguments such as (array, dim, mask, kind, back).
+template <typename FN>
+static void
+genReduction5Args(FN func, fir::FirOpBuilder &builder, mlir::Location loc,
+                  mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
+                  mlir::Value maskBox, mlir::Value kind, mlir::Value back) {
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
+  auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
+                                            arrayBox, kind, dim, sourceFile,
+                                            sourceLine, maskBox, back);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// Generate call to all runtime routine.
+/// This calls the descriptor based runtime call implementation of the `all`
+/// intrinsic.
+void fir::runtime::genAllDescriptor(fir::FirOpBuilder &builder,
+                                    mlir::Location loc, mlir::Value resultBox,
+                                    mlir::Value maskBox, mlir::Value dim) {
+  auto allFunc = fir::runtime::getRuntimeFunc<mkRTKey(AllDim)>(loc, builder);
+  genReduction2Args(allFunc, builder, loc, resultBox, maskBox, dim);
+}
+
+/// Generate call to any runtime routine.
+/// This calls the descriptor based runtime call implementation of the `any`
+/// intrinsic.
+void fir::runtime::genAnyDescriptor(fir::FirOpBuilder &builder,
+                                    mlir::Location loc, mlir::Value resultBox,
+                                    mlir::Value maskBox, mlir::Value dim) {
+  auto anyFunc = fir::runtime::getRuntimeFunc<mkRTKey(AnyDim)>(loc, builder);
+  genReduction2Args(anyFunc, builder, loc, resultBox, maskBox, dim);
+}
+
+/// Generate call to `all` intrinsic runtime routine. This routine is
+/// specialized for mask arguments with rank == 1.
+mlir::Value fir::runtime::genAll(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 mlir::Value maskBox, mlir::Value dim) {
+  auto allFunc = fir::runtime::getRuntimeFunc<mkRTKey(All)>(loc, builder);
+  return genSpecial2Args(allFunc, builder, loc, maskBox, dim);
+}
+
+/// Generate call to `any` intrinsic runtime routine. This routine is
+/// specialized for mask arguments with rank == 1.
+mlir::Value fir::runtime::genAny(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 mlir::Value maskBox, mlir::Value dim) {
+  auto anyFunc = fir::runtime::getRuntimeFunc<mkRTKey(Any)>(loc, builder);
+  return genSpecial2Args(anyFunc, builder, loc, maskBox, dim);
+}
+
+/// Generate call to `count` runtime routine. This routine is a specialized
+/// version when mask is a rank one array or the dim argument is not
+/// specified by the user.
+mlir::Value fir::runtime::genCount(fir::FirOpBuilder &builder,
+                                   mlir::Location loc, mlir::Value maskBox,
+                                   mlir::Value dim) {
+  auto countFunc = fir::runtime::getRuntimeFunc<mkRTKey(Count)>(loc, builder);
+  return genSpecial2Args(countFunc, builder, loc, maskBox, dim);
+}
+
+/// Generate call to general CountDim runtime routine. This routine has a
+/// descriptor result.
+void fir::runtime::genCountDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                               mlir::Value resultBox, mlir::Value maskBox,
+                               mlir::Value dim, mlir::Value kind) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(CountDim)>(loc, builder);
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, resultBox, maskBox, dim, kind, sourceFile, sourceLine);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// Generate call to `maxloc` intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+void fir::runtime::genMaxloc(fir::FirOpBuilder &builder, mlir::Location loc,
+                             mlir::Value resultBox, mlir::Value arrayBox,
+                             mlir::Value maskBox, mlir::Value kind,
+                             mlir::Value back) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(Maxloc)>(loc, builder);
+  genReduction4Args(func, builder, loc, resultBox, arrayBox, maskBox, kind,
+                    back);
+}
+
+/// Generate call to `maxloc` intrinsic runtime routine. This is the version
+/// that takes a dim argument.
+void fir::runtime::genMaxlocDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                                mlir::Value resultBox, mlir::Value arrayBox,
+                                mlir::Value dim, mlir::Value maskBox,
+                                mlir::Value kind, mlir::Value back) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(MaxlocDim)>(loc, builder);
+  genReduction5Args(func, builder, loc, resultBox, arrayBox, dim, maskBox, kind,
+                    back);
+}
+
+/// Generate call to `maxval` intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value fir::runtime::genMaxval(fir::FirOpBuilder &builder,
+                                    mlir::Location loc, mlir::Value arrayBox,
+                                    mlir::Value maskBox) {
+  mlir::FuncOp func;
+  auto ty = arrayBox.getType();
+  auto arrTy = fir::dyn_cast_ptrOrBoxEleTy(ty);
+  auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
+  auto dim = builder.createIntegerConstant(loc, builder.getIndexType(), 0);
+
+  if (eleTy.isF32())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalReal4)>(loc, builder);
+  else if (eleTy.isF64())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalReal8)>(loc, builder);
+  else if (eleTy.isF80())
+    func = fir::runtime::getRuntimeFunc<ForcedMaxvalReal10>(loc, builder);
+  else if (eleTy.isF128())
+    func = fir::runtime::getRuntimeFunc<ForcedMaxvalReal16>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(1)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalInteger1)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(2)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalInteger2)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(4)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalInteger4)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalInteger8)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16)))
+    func = fir::runtime::getRuntimeFunc<ForcedMaxvalInteger16>(loc, builder);
+  else
+    fir::emitFatalError(loc, "invalid type in Maxval lowering");
+
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox);
+
+  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
+}
+
+/// Generate call to `maxval` intrinsic runtime routine. This is the version
+/// that handles any rank array with the dim argument specified.
+void fir::runtime::genMaxvalDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                                mlir::Value resultBox, mlir::Value arrayBox,
+                                mlir::Value dim, mlir::Value maskBox) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalDim)>(loc, builder);
+  genReduction3Args(func, builder, loc, resultBox, arrayBox, dim, maskBox);
+}
+
+/// Generate call to `maxval` intrinsic runtime routine. This is the version
+/// that handles character arrays of rank 1 and without a DIM argument.
+void fir::runtime::genMaxvalChar(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 mlir::Value resultBox, mlir::Value arrayBox,
+                                 mlir::Value maskBox) {
+  auto func =
+      fir::runtime::getRuntimeFunc<mkRTKey(MaxvalCharacter)>(loc, builder);
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, resultBox, arrayBox, sourceFile, sourceLine, maskBox);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// Generate call to `minloc` intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+void fir::runtime::genMinloc(fir::FirOpBuilder &builder, mlir::Location loc,
+                             mlir::Value resultBox, mlir::Value arrayBox,
+                             mlir::Value maskBox, mlir::Value kind,
+                             mlir::Value back) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(Minloc)>(loc, builder);
+  genReduction4Args(func, builder, loc, resultBox, arrayBox, maskBox, kind,
+                    back);
+}
+
+/// Generate call to `minloc` intrinsic runtime routine. This is the version
+/// that takes a dim argument.
+void fir::runtime::genMinlocDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                                mlir::Value resultBox, mlir::Value arrayBox,
+                                mlir::Value dim, mlir::Value maskBox,
+                                mlir::Value kind, mlir::Value back) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(MinlocDim)>(loc, builder);
+  genReduction5Args(func, builder, loc, resultBox, arrayBox, dim, maskBox, kind,
+                    back);
+}
+
+/// Generate call to `minval` intrinsic runtime routine. This is the version
+/// that handles any rank array with the dim argument specified.
+void fir::runtime::genMinvalDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                                mlir::Value resultBox, mlir::Value arrayBox,
+                                mlir::Value dim, mlir::Value maskBox) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalDim)>(loc, builder);
+  genReduction3Args(func, builder, loc, resultBox, arrayBox, dim, maskBox);
+}
+
+/// Generate call to `minval` intrinsic runtime routine. This is the version
+/// that handles character arrays of rank 1 and without a DIM argument.
+void fir::runtime::genMinvalChar(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 mlir::Value resultBox, mlir::Value arrayBox,
+                                 mlir::Value maskBox) {
+  auto func =
+      fir::runtime::getRuntimeFunc<mkRTKey(MinvalCharacter)>(loc, builder);
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, resultBox, arrayBox, sourceFile, sourceLine, maskBox);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// Generate call to `minval` intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value fir::runtime::genMinval(fir::FirOpBuilder &builder,
+                                    mlir::Location loc, mlir::Value arrayBox,
+                                    mlir::Value maskBox) {
+  mlir::FuncOp func;
+  auto ty = arrayBox.getType();
+  auto arrTy = fir::dyn_cast_ptrOrBoxEleTy(ty);
+  auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
+  auto dim = builder.createIntegerConstant(loc, builder.getIndexType(), 0);
+
+  if (eleTy.isF32())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalReal4)>(loc, builder);
+  else if (eleTy.isF64())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalReal8)>(loc, builder);
+  else if (eleTy.isF80())
+    func = fir::runtime::getRuntimeFunc<ForcedMinvalReal10>(loc, builder);
+  else if (eleTy.isF128())
+    func = fir::runtime::getRuntimeFunc<ForcedMinvalReal16>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(1)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalInteger1)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(2)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalInteger2)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(4)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalInteger4)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalInteger8)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16)))
+    func = fir::runtime::getRuntimeFunc<ForcedMinvalInteger16>(loc, builder);
+  else
+    fir::emitFatalError(loc, "invalid type in Minval lowering");
+
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox);
+
+  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
+}
+
+/// Generate call to `product` intrinsic runtime routine. This is the version
+/// that handles any rank array with the dim argument specified.
+void fir::runtime::genProductDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 mlir::Value resultBox, mlir::Value arrayBox,
+                                 mlir::Value dim, mlir::Value maskBox) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(ProductDim)>(loc, builder);
+  genReduction3Args(func, builder, loc, resultBox, arrayBox, dim, maskBox);
+}
+
+/// Generate call to `product` intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value fir::runtime::genProduct(fir::FirOpBuilder &builder,
+                                     mlir::Location loc, mlir::Value arrayBox,
+                                     mlir::Value maskBox,
+                                     mlir::Value resultBox) {
+  mlir::FuncOp func;
+  auto ty = arrayBox.getType();
+  auto arrTy = fir::dyn_cast_ptrOrBoxEleTy(ty);
+  auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
+  auto dim = builder.createIntegerConstant(loc, builder.getIndexType(), 0);
+
+  if (eleTy.isF32())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(ProductReal4)>(loc, builder);
+  else if (eleTy.isF64())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(ProductReal8)>(loc, builder);
+  else if (eleTy.isF80())
+    func = fir::runtime::getRuntimeFunc<ForcedProductReal10>(loc, builder);
+  else if (eleTy.isF128())
+    func = fir::runtime::getRuntimeFunc<ForcedProductReal16>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(1)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(ProductInteger1)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(2)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(ProductInteger2)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(4)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(ProductInteger4)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(ProductInteger8)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16)))
+    func = fir::runtime::getRuntimeFunc<ForcedProductInteger16>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 4))
+    func =
+        fir::runtime::getRuntimeFunc<mkRTKey(CppProductComplex4)>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 8))
+    func =
+        fir::runtime::getRuntimeFunc<mkRTKey(CppProductComplex8)>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 10))
+    func = fir::runtime::getRuntimeFunc<ForcedProductComplex10>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 16))
+    func = fir::runtime::getRuntimeFunc<ForcedProductComplex16>(loc, builder);
+  else
+    fir::emitFatalError(loc, "invalid type in Product lowering");
+
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  if (fir::isa_complex(eleTy)) {
+    auto sourceLine =
+        fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
+    auto args =
+        fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox,
+                                      sourceFile, sourceLine, dim, maskBox);
+    builder.create<fir::CallOp>(loc, func, args);
+    return resultBox;
+  }
+
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox);
+
+  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
+}
+
+/// Generate call to `dot_product` intrinsic runtime routine.
+mlir::Value fir::runtime::genDotProduct(fir::FirOpBuilder &builder,
+                                        mlir::Location loc,
+                                        mlir::Value vectorABox,
+                                        mlir::Value vectorBBox,
+                                        mlir::Value resultBox) {
+  mlir::FuncOp func;
+  auto ty = vectorABox.getType();
+  auto arrTy = fir::dyn_cast_ptrOrBoxEleTy(ty);
+  auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
+
+  if (eleTy.isF32())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(DotProductReal4)>(loc, builder);
+  else if (eleTy.isF64())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(DotProductReal8)>(loc, builder);
+  else if (eleTy.isF80())
+    func = fir::runtime::getRuntimeFunc<ForcedDotProductReal10>(loc, builder);
+  else if (eleTy.isF128())
+    func = fir::runtime::getRuntimeFunc<ForcedDotProductReal16>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 4))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(CppDotProductComplex4)>(
+        loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 8))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(CppDotProductComplex8)>(
+        loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 10))
+    func =
+        fir::runtime::getRuntimeFunc<ForcedDotProductComplex10>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 16))
+    func =
+        fir::runtime::getRuntimeFunc<ForcedDotProductComplex16>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(1)))
+    func =
+        fir::runtime::getRuntimeFunc<mkRTKey(DotProductInteger1)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(2)))
+    func =
+        fir::runtime::getRuntimeFunc<mkRTKey(DotProductInteger2)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(4)))
+    func =
+        fir::runtime::getRuntimeFunc<mkRTKey(DotProductInteger4)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8)))
+    func =
+        fir::runtime::getRuntimeFunc<mkRTKey(DotProductInteger8)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16)))
+    func =
+        fir::runtime::getRuntimeFunc<ForcedDotProductInteger16>(loc, builder);
+  else if (eleTy.isa<fir::LogicalType>())
+    func =
+        fir::runtime::getRuntimeFunc<mkRTKey(DotProductLogical)>(loc, builder);
+  else
+    fir::emitFatalError(loc, "invalid type in DotProduct lowering");
+
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+
+  if (fir::isa_complex(eleTy)) {
+    auto sourceLine =
+        fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
+    auto args =
+        fir::runtime::createArguments(builder, loc, fTy, resultBox, vectorABox,
+                                      vectorBBox, sourceFile, sourceLine);
+    builder.create<fir::CallOp>(loc, func, args);
+    return resultBox;
+  }
+
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
+  auto args = fir::runtime::createArguments(builder, loc, fTy, vectorABox,
+                                            vectorBBox, sourceFile, sourceLine);
+  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
+}
+/// Generate call to Sum intrinsic runtime routine. This is the version
+/// that handles any rank array with the dim argument specified.
+void fir::runtime::genSumDim(fir::FirOpBuilder &builder, mlir::Location loc,
+                             mlir::Value resultBox, mlir::Value arrayBox,
+                             mlir::Value dim, mlir::Value maskBox) {
+  auto func = fir::runtime::getRuntimeFunc<mkRTKey(SumDim)>(loc, builder);
+  genReduction3Args(func, builder, loc, resultBox, arrayBox, dim, maskBox);
+}
+
+/// Generate call to `sum` intrinsic runtime routine. This is the version
+/// that does not take a dim argument.
+mlir::Value fir::runtime::genSum(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 mlir::Value arrayBox, mlir::Value maskBox,
+                                 mlir::Value resultBox) {
+  mlir::FuncOp func;
+  auto ty = arrayBox.getType();
+  auto arrTy = fir::dyn_cast_ptrOrBoxEleTy(ty);
+  auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
+  auto dim = builder.createIntegerConstant(loc, builder.getIndexType(), 0);
+
+  if (eleTy.isF32())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(SumReal4)>(loc, builder);
+  else if (eleTy.isF64())
+    func = fir::runtime::getRuntimeFunc<mkRTKey(SumReal8)>(loc, builder);
+  else if (eleTy.isF80())
+    func = fir::runtime::getRuntimeFunc<ForcedSumReal10>(loc, builder);
+  else if (eleTy.isF128())
+    func = fir::runtime::getRuntimeFunc<ForcedSumReal16>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(1)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(SumInteger1)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(2)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(SumInteger2)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(4)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(SumInteger4)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8)))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(SumInteger8)>(loc, builder);
+  else if (eleTy ==
+           builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16)))
+    func = fir::runtime::getRuntimeFunc<ForcedSumInteger16>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 4))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(CppSumComplex4)>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 8))
+    func = fir::runtime::getRuntimeFunc<mkRTKey(CppSumComplex8)>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 10))
+    func = fir::runtime::getRuntimeFunc<ForcedSumComplex10>(loc, builder);
+  else if (eleTy == fir::ComplexType::get(builder.getContext(), 16))
+    func = fir::runtime::getRuntimeFunc<ForcedSumComplex16>(loc, builder);
+  else
+    fir::emitFatalError(loc, "invalid type in Sum lowering");
+
+  auto fTy = func.getType();
+  auto sourceFile = fir::factory::locationToFilename(builder, loc);
+  if (fir::isa_complex(eleTy)) {
+    auto sourceLine =
+        fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
+    auto args =
+        fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox,
+                                      sourceFile, sourceLine, dim, maskBox);
+    builder.create<fir::CallOp>(loc, func, args);
+    return resultBox;
+  }
+
+  auto sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
+  auto args = fir::runtime::createArguments(
+      builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox);
+
+  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
+}

flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp

+//===- ReductionTest.cpp -- Reduction runtime builder unit tests ----------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Builder/Runtime/Reduction.h"
+#include "RuntimeCallTestBase.h"
+#include "gtest/gtest.h"
+
+TEST_F(RuntimeCallTest, genAllTest) {
+  auto loc = firBuilder->getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Value undef = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value all = fir::runtime::genAll(*firBuilder, loc, undef, dim);
+  checkCallOp(all.getDefiningOp(), "_FortranAAll", 2);
+}
+
+TEST_F(RuntimeCallTest, genAllDescriptorTest) {
+  auto loc = firBuilder->getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  fir::runtime::genAllDescriptor(*firBuilder, loc, result, mask, dim);
+  checkCallOpFromResultBox(result, "_FortranAAllDim", 3);
+}
+
+TEST_F(RuntimeCallTest, genAnyTest) {
+  auto loc = firBuilder->getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Value undef = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value any = fir::runtime::genAny(*firBuilder, loc, undef, dim);
+  checkCallOp(any.getDefiningOp(), "_FortranAAny", 2);
+}
+
+TEST_F(RuntimeCallTest, genAnyDescriptorTest) {
+  auto loc = firBuilder->getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  fir::runtime::genAnyDescriptor(*firBuilder, loc, result, mask, dim);
+  checkCallOpFromResultBox(result, "_FortranAAnyDim", 3);
+}
+
+TEST_F(RuntimeCallTest, genCountTest) {
+  auto loc = firBuilder->getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Value undef = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value count = fir::runtime::genCount(*firBuilder, loc, undef, dim);
+  checkCallOp(count.getDefiningOp(), "_FortranACount", 2);
+}
+
+TEST_F(RuntimeCallTest, genCountDimTest) {
+  auto loc = firBuilder->getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value kind = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  fir::runtime::genCountDim(*firBuilder, loc, result, mask, dim, kind);
+  checkCallOpFromResultBox(result, "_FortranACountDim", 4);
+}
+
+void testGenMaxVal(
+    fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
+  auto loc = builder.getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value max = fir::runtime::genMaxval(builder, loc, undef, mask);
+  checkCallOp(max.getDefiningOp(), fctName, 3);
+}
+
+TEST_F(RuntimeCallTest, genMaxValTest) {
+  testGenMaxVal(*firBuilder, f32Ty, "_FortranAMaxvalReal4");
+  testGenMaxVal(*firBuilder, f64Ty, "_FortranAMaxvalReal8");
+  testGenMaxVal(*firBuilder, f80Ty, "_FortranAMaxvalReal10");
+  testGenMaxVal(*firBuilder, f128Ty, "_FortranAMaxvalReal16");
+
+  testGenMaxVal(*firBuilder, i8Ty, "_FortranAMaxvalInteger1");
+  testGenMaxVal(*firBuilder, i16Ty, "_FortranAMaxvalInteger2");
+  testGenMaxVal(*firBuilder, i32Ty, "_FortranAMaxvalInteger4");
+  testGenMaxVal(*firBuilder, i64Ty, "_FortranAMaxvalInteger8");
+  testGenMaxVal(*firBuilder, i128Ty, "_FortranAMaxvalInteger16");
+}
+
+void testGenMinVal(
+    fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
+  auto loc = builder.getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value min = fir::runtime::genMinval(builder, loc, undef, mask);
+  checkCallOp(min.getDefiningOp(), fctName, 3);
+}
+
+TEST_F(RuntimeCallTest, genMinValTest) {
+  testGenMinVal(*firBuilder, f32Ty, "_FortranAMinvalReal4");
+  testGenMinVal(*firBuilder, f64Ty, "_FortranAMinvalReal8");
+  testGenMinVal(*firBuilder, f80Ty, "_FortranAMinvalReal10");
+  testGenMinVal(*firBuilder, f128Ty, "_FortranAMinvalReal16");
+
+  testGenMinVal(*firBuilder, i8Ty, "_FortranAMinvalInteger1");
+  testGenMinVal(*firBuilder, i16Ty, "_FortranAMinvalInteger2");
+  testGenMinVal(*firBuilder, i32Ty, "_FortranAMinvalInteger4");
+  testGenMinVal(*firBuilder, i64Ty, "_FortranAMinvalInteger8");
+  testGenMinVal(*firBuilder, i128Ty, "_FortranAMinvalInteger16");
+}
+
+void testGenSum(
+    fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
+  auto loc = builder.getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value sum = fir::runtime::genSum(builder, loc, undef, mask, result);
+  if (fir::isa_complex(eleTy))
+    checkCallOpFromResultBox(result, fctName, 4);
+  else
+    checkCallOp(sum.getDefiningOp(), fctName, 3);
+}
+
+TEST_F(RuntimeCallTest, genSumTest) {
+  testGenSum(*firBuilder, f32Ty, "_FortranASumReal4");
+  testGenSum(*firBuilder, f64Ty, "_FortranASumReal8");
+  testGenSum(*firBuilder, f80Ty, "_FortranASumReal10");
+  testGenSum(*firBuilder, f128Ty, "_FortranASumReal16");
+  testGenSum(*firBuilder, i8Ty, "_FortranASumInteger1");
+  testGenSum(*firBuilder, i16Ty, "_FortranASumInteger2");
+  testGenSum(*firBuilder, i32Ty, "_FortranASumInteger4");
+  testGenSum(*firBuilder, i64Ty, "_FortranASumInteger8");
+  testGenSum(*firBuilder, i128Ty, "_FortranASumInteger16");
+  testGenSum(*firBuilder, c4Ty, "_FortranACppSumComplex4");
+  testGenSum(*firBuilder, c8Ty, "_FortranACppSumComplex8");
+  testGenSum(*firBuilder, c10Ty, "_FortranACppSumComplex10");
+  testGenSum(*firBuilder, c16Ty, "_FortranACppSumComplex16");
+}
+
+void testGenProduct(
+    fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
+  auto loc = builder.getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value prod =
+      fir::runtime::genProduct(builder, loc, undef, mask, result);
+  if (fir::isa_complex(eleTy))
+    checkCallOpFromResultBox(result, fctName, 4);
+  else
+    checkCallOp(prod.getDefiningOp(), fctName, 3);
+}
+
+TEST_F(RuntimeCallTest, genProduct) {
+  testGenProduct(*firBuilder, f32Ty, "_FortranAProductReal4");
+  testGenProduct(*firBuilder, f64Ty, "_FortranAProductReal8");
+  testGenProduct(*firBuilder, f80Ty, "_FortranAProductReal10");
+  testGenProduct(*firBuilder, f128Ty, "_FortranAProductReal16");
+  testGenProduct(*firBuilder, i8Ty, "_FortranAProductInteger1");
+  testGenProduct(*firBuilder, i16Ty, "_FortranAProductInteger2");
+  testGenProduct(*firBuilder, i32Ty, "_FortranAProductInteger4");
+  testGenProduct(*firBuilder, i64Ty, "_FortranAProductInteger8");
+  testGenProduct(*firBuilder, i128Ty, "_FortranAProductInteger16");
+  testGenProduct(*firBuilder, c4Ty, "_FortranACppProductComplex4");
+  testGenProduct(*firBuilder, c8Ty, "_FortranACppProductComplex8");
+  testGenProduct(*firBuilder, c10Ty, "_FortranACppProductComplex10");
+  testGenProduct(*firBuilder, c16Ty, "_FortranACppProductComplex16");
+}
+
+void testGenDotProduct(
+    fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
+  auto loc = builder.getUnknownLoc();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value b = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value prod = fir::runtime::genDotProduct(builder, loc, a, b, result);
+  if (fir::isa_complex(eleTy))
+    checkCallOpFromResultBox(result, fctName, 3);
+  else
+    checkCallOp(prod.getDefiningOp(), fctName, 2);
+}
+
+TEST_F(RuntimeCallTest, genDotProduct) {
+  testGenDotProduct(*firBuilder, f32Ty, "_FortranADotProductReal4");
+  testGenDotProduct(*firBuilder, f64Ty, "_FortranADotProductReal8");
+  testGenDotProduct(*firBuilder, f80Ty, "_FortranADotProductReal10");
+  testGenDotProduct(*firBuilder, f128Ty, "_FortranADotProductReal16");
+  testGenDotProduct(*firBuilder, i8Ty, "_FortranADotProductInteger1");
+  testGenDotProduct(*firBuilder, i16Ty, "_FortranADotProductInteger2");
+  testGenDotProduct(*firBuilder, i32Ty, "_FortranADotProductInteger4");
+  testGenDotProduct(*firBuilder, i64Ty, "_FortranADotProductInteger8");
+  testGenDotProduct(*firBuilder, i128Ty, "_FortranADotProductInteger16");
+  testGenDotProduct(*firBuilder, c4Ty, "_FortranACppDotProductComplex4");
+  testGenDotProduct(*firBuilder, c8Ty, "_FortranACppDotProductComplex8");
+  testGenDotProduct(*firBuilder, c10Ty, "_FortranACppDotProductComplex10");
+  testGenDotProduct(*firBuilder, c16Ty, "_FortranACppDotProductComplex16");
+}
+
+void checkGenMxxloc(fir::FirOpBuilder &builder,
+    void (*genFct)(fir::FirOpBuilder &, Location, mlir::Value, mlir::Value,
+        mlir::Value, mlir::Value, mlir::Value),
+    llvm::StringRef fctName, unsigned nbArgs) {
+  auto loc = builder.getUnknownLoc();
+  mlir::Type i32Ty = builder.getI32Type();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value kind = builder.createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value back = builder.createIntegerConstant(loc, i32Ty, 1);
+  genFct(builder, loc, result, a, mask, kind, back);
+  checkCallOpFromResultBox(result, fctName, nbArgs);
+}
+
+TEST_F(RuntimeCallTest, genMaxlocTest) {
+  checkGenMxxloc(*firBuilder, fir::runtime::genMaxloc, "_FortranAMaxloc", 5);
+}
+
+TEST_F(RuntimeCallTest, genMinlocTest) {
+  checkGenMxxloc(*firBuilder, fir::runtime::genMinloc, "_FortranAMinloc", 5);
+}
+
+void checkGenMxxlocDim(fir::FirOpBuilder &builder,
+    void (*genFct)(fir::FirOpBuilder &, Location, mlir::Value, mlir::Value,
+        mlir::Value, mlir::Value, mlir::Value, mlir::Value),
+    llvm::StringRef fctName, unsigned nbArgs) {
+  auto loc = builder.getUnknownLoc();
+  auto i32Ty = builder.getI32Type();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value kind = builder.createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value dim = builder.createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value back = builder.createIntegerConstant(loc, i32Ty, 1);
+  genFct(builder, loc, result, a, dim, mask, kind, back);
+  checkCallOpFromResultBox(result, fctName, nbArgs);
+}
+
+TEST_F(RuntimeCallTest, genMaxlocDimTest) {
+  checkGenMxxlocDim(
+      *firBuilder, fir::runtime::genMaxlocDim, "_FortranAMaxlocDim", 6);
+}
+
+TEST_F(RuntimeCallTest, genMinlocDimTest) {
+  checkGenMxxlocDim(
+      *firBuilder, fir::runtime::genMinlocDim, "_FortranAMinlocDim", 6);
+}
+
+void checkGenMxxvalChar(fir::FirOpBuilder &builder,
+    void (*genFct)(
+        fir::FirOpBuilder &, Location, mlir::Value, mlir::Value, mlir::Value),
+    llvm::StringRef fctName, unsigned nbArgs) {
+  auto loc = builder.getUnknownLoc();
+  auto i32Ty = builder.getI32Type();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  genFct(builder, loc, result, a, mask);
+  checkCallOpFromResultBox(result, fctName, nbArgs);
+}
+
+TEST_F(RuntimeCallTest, genMaxvalCharTest) {
+  checkGenMxxvalChar(
+      *firBuilder, fir::runtime::genMaxvalChar, "_FortranAMaxvalCharacter", 3);
+}
+
+TEST_F(RuntimeCallTest, genMinvalCharTest) {
+  checkGenMxxvalChar(
+      *firBuilder, fir::runtime::genMinvalChar, "_FortranAMinvalCharacter", 3);
+}
+
+void checkGen4argsDim(fir::FirOpBuilder &builder,
+    void (*genFct)(fir::FirOpBuilder &, Location, mlir::Value, mlir::Value,
+        mlir::Value, mlir::Value),
+    llvm::StringRef fctName, unsigned nbArgs) {
+  auto loc = builder.getUnknownLoc();
+  auto i32Ty = builder.getI32Type();
+  mlir::Type seqTy =
+      fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
+  mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
+  mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
+  mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
+  mlir::Value dim = builder.createIntegerConstant(loc, i32Ty, 1);
+  genFct(builder, loc, result, a, dim, mask);
+  checkCallOpFromResultBox(result, fctName, nbArgs);
+}
+
+TEST_F(RuntimeCallTest, genMaxvalDimTest) {
+  checkGen4argsDim(
+      *firBuilder, fir::runtime::genMaxvalDim, "_FortranAMaxvalDim", 4);
+}
+
+TEST_F(RuntimeCallTest, genMinvalDimTest) {
+  checkGen4argsDim(
+      *firBuilder, fir::runtime::genMinvalDim, "_FortranAMinvalDim", 4);
+}
+
+TEST_F(RuntimeCallTest, genProductDimTest) {
+  checkGen4argsDim(
+      *firBuilder, fir::runtime::genProductDim, "_FortranAProductDim", 4);
+}
+
+TEST_F(RuntimeCallTest, genSumDimTest) {
+  checkGen4argsDim(*firBuilder, fir::runtime::genSumDim, "_FortranASumDim", 4);
+}

flang/unittests/Optimizer/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 set(LIBS
   FIRBuilder
   FIRCodeGen
   FIRDialect
   FIRSupport
   ${dialect_libs}
 )
 
 add_flang_unittest(FlangOptimizerTests
   Builder/CharacterTest.cpp
   Builder/ComplexTest.cpp
   Builder/DoLoopHelperTest.cpp
   Builder/FIRBuilderTest.cpp
+  Builder/Runtime/ReductionTest.cpp
   FIRContextTest.cpp
   InternalNamesTest.cpp
   KindMappingTest.cpp
   RTBuilder.cpp
 )
 target_link_libraries(FlangOptimizerTests
   PRIVATE
   ${LIBS})