[flang][RFC][WIP} Inline sum - not ready to use

[Leporacanthicus]

Summary

This is not a finished implementation, it is mostly "to encourage
discussion", not intended to be reviewed in detail, more as a "this
is how this could be done".

Known issues:

• Only supports sum, although where it is implemented will also be

called for the PRODUCT intrinsic.

• It doesn't support all types.
• Only supports one dimensional arrays. There's nothing

stopping this from being multi-dimensional, just more code
needed.

• Need specific tests for "does it inline" or "should not inline".
• Need a way to disable this feature.

I'm sure there are OTHER issues too.

[peixin]

We may need one option like -finline-intrinsic={value}, in which the value can be one intrinsic name or all, or some kind(several intrinsic functions with similar feature). I tried to inline some functions in classic flang, but it did not give higher performance in all cases.

flang/lib/Lower/IntrinsicCall.cpp

genProdOrSum(FN func, FD funcDim, mlir::Type resultType,
   assert(args.size() == 3);
 
   // Handle required array argument
   fir::BoxValue arryTmp = builder.createBox(loc, args[0]);
   mlir::Value array = fir::getBase(arryTmp);
   int rank = arryTmp.rank();
   assert(rank >= 1);
 
+  bool absentMask = isStaticallyAbsent(args[2]);
   // Handle optional mask argument
-  auto mask = isStaticallyAbsent(args[2])
-                  ? builder.create<fir::AbsentOp>(
+  auto mask = absentMask ? builder.create<fir::AbsentOp>(
                                loc, fir::BoxType::get(builder.getI1Type()))
                          : builder.createBox(loc, args[2]);
 
   bool absentDim = isStaticallyAbsent(args[1]);
 
-  // We call the type specific versions because the result is scalar
-  // in the case below.
-  if (absentDim || rank == 1) {
-    mlir::Type ty = array.getType();
-    mlir::Type arrTy = fir::dyn_cast_ptrOrBoxEleTy(ty);
-    auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
+
+  // Inline 1D array sum - when they are the basic SUM(arr) form.
+  // For now, don't support complex types.
+  if (rank == 1 && absentDim && absentMask && !fir::isa_complex(eleTy)) {
+    mlir::IndexType idxTy = builder.getIndexType();
+    mlir::Value one = builder.createIntegerConstant(loc, idxTy, 1);
+    mlir::Value lo =
+        fir::factory::readLowerBound(builder, loc, arryTmp, 0, one);
+    mlir::Value up = fir::factory::readExtent(builder, loc, arryTmp, 0);
+    mlir::Value step = one;
+
+    mlir::Value init;
+    if (eleTy.isa<mlir::IntegerType>())
+      init = builder.createIntegerConstant(loc, eleTy, 0);
+    else
+      init = builder.createRealZeroConstant(loc, eleTy);
+
+    auto savedPt = builder.saveInsertionPoint();
+    builder.setInsertionPointToStart(builder.getAllocaBlock());
+    auto sum = builder.create<fir::AllocaOp>(loc, eleTy);
+    builder.restoreInsertionPoint(savedPt);
+    builder.create<fir::StoreOp>(loc, init, sum);
+
+    auto loop = builder.create<fir::DoLoopOp>(loc, lo, up, step);
+
+    auto insPt = builder.saveInsertionPoint();
+    builder.setInsertionPointToStart(loop.getBody());
+
+    mlir::Type eleRefTy = builder.getRefType(eleTy);
+    // Get zero-based index by subtracting the lower bound.
+    mlir::Value index =
+        builder.create<mlir::arith::SubIOp>(loc, loop.getInductionVar(), lo);
+    auto addr = builder.create<fir::CoordinateOp>(loc, eleRefTy, array, index);
+    mlir::Value elem = builder.create<fir::LoadOp>(loc, addr);
+    mlir::Value sumVal = builder.create<fir::LoadOp>(loc, sum);
+
+    mlir::Value res;
+    if (eleTy.isa<mlir::IntegerType>())
+      res = builder.create<mlir::arith::AddIOp>(loc, elem, sumVal);
+    else
+      res = builder.create<mlir::arith::AddFOp>(loc, elem, sumVal);
+    builder.create<fir::StoreOp>(loc, res, sum);
+
+    builder.restoreInsertionPoint(insPt);
+    return builder.create<fir::LoadOp>(loc, sum);
+  }
+
+  // We call the type specific versions because the result is scalar
+  // in the case below.
+  if (absentDim || rank == 1) {
     if (fir::isa_complex(eleTy)) {
       mlir::Value result = builder.createTemporary(loc, eleTy);
       func(builder, loc, array, mask, result);
       return builder.create<fir::LoadOp>(loc, result);
     }
     auto resultBox = builder.create<fir::AbsentOp>(
         loc, fir::BoxType::get(builder.getI1Type()));
     return func(builder, loc, array, mask, resultBox);