[flang] Control SUM simplification with a pass option.

[vzakhari]

Summary

The current code may not always work correctly, e.g.:
https://github.com/llvm/llvm-project/issues/57072

I added 'enable-experimental' pass option so that SUM simplification
may be enabled in LIT tests, but it is not enabled when the pass
is added to the passes pipeline.

[Leporacanthicus]

As the fix for the bug mentioned is relatively simple, I'd suggest we fix the bug instead of introducing this sort of workaround.

[Leporacanthicus]

Review for the fix here:
https://reviews.llvm.org/D131671

[vzakhari]

Besides my comment in https://reviews.llvm.org/D131671#inline-1267048 I have another concern about the current SUM inlining. The current Fortran runtime implementation uses Kahan summation for the reduction, so I think we should have some control for SUM inlining to do the same. Otherwise, I am afraid after enabling this pass in the driver we may get accuracy issues for tests that pass with the current Fortran runtime.

I think it is still worth making SUM inlining experimental at this point.

[Leporacanthicus]

LGTM. I do expect this to be short-lived [or at least for the SUM operations!]

flang/include/flang/Optimizer/Transforms/Passes.td

 def SimplifyIntrinsics : Pass<"simplify-intrinsics", "mlir::ModuleOp"> {
   let summary = "Intrinsics simplification";
   let description = [{
     Qualifying intrinsics calls are replaced with calls to a specialized and
     simplified function. The simplified function is added to the current module.
     This function can be inlined by a general purpose inlining pass.
   }];
   let constructor = "::fir::createSimplifyIntrinsicsPass()";
+
+  let options = [
+    Option<"enableExperimental", "enable-experimental", "bool",
+           /*default=*/"false",
+           "Enable experimental code that may not always work correctly">
+  ];
 }
 
 def MemoryAllocationOpt : Pass<"memory-allocation-opt", "mlir::func::FuncOp"> {
   let summary = "Convert stack to heap allocations and vice versa.";
   let description = [{
     Convert stack allocations to heap allocations and vice versa based on
     estimated size, lifetime, usage patterns, the call tree, etc.
   }];

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
         // Replace call to runtime function for SUM when it has single
         // argument (no dim or mask argument) for 1D arrays with either
         // Integer4 or Real8 types. Other forms are ignored.
         // The new function is added to the module.
         //
         // Prototype for runtime call (from sum.cpp):
         // RTNAME(Sum<T>)(const Descriptor &x, const char *source, int line,
         //                int dim, const Descriptor *mask)
-        if (funcName.startswith("_FortranASum")) {
+        //
+        // Disable SUM inlining by default, because it fatally fails on some
+        // FIR yet.
+        if (enableExperimental && funcName.startswith("_FortranASum")) {
           mlir::Operation::operand_range args = call.getArgs();
           // args[1] and args[2] are source filename and line number, ignored.
           const mlir::Value &dim = args[3];
           const mlir::Value &mask = args[4];
           // dim is zero when it is absent, which is an implementation
           // detail in the runtime library.
           bool dimAndMaskAbsent = isZero(dim) && isOperandAbsent(mask);
           unsigned rank = getDimCount(args[0]);

flang/test/Transforms/simplifyintrinsics.fir

-// RUN: fir-opt --split-input-file --simplify-intrinsics %s | FileCheck %s
+// RUN: fir-opt --split-input-file --simplify-intrinsics='enable-experimental=true' %s | FileCheck %s
 
 // Call to SUM with 1D I32 array is replaced.
 module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {
   func.func @sum_1d_array_int(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {
     %c10 = arith.constant 10 : index
     %0 = fir.alloca i32 {bindc_name = "test_sum_2", uniq_name = "_QFtest_sum_2Etest_sum_2"}
     %1 = fir.shape %c10 : (index) -> !fir.shape<1>
     %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>