[flang]Avoid asking for operands when there are none

[Leporacanthicus]

Summary

Fix one encountered (issue #57072) and two potential scenarios where the
code would ask for an operand that isn't there.

Add test for the encountered case.

[vzakhari]

Thank you for the changes, but I think this is not enough in general, so it may still make sense to make this code "experimental" for the time being. I would like to enable the pass in the driver so that DOT_PRODUCT inlining kicks in, but I cannot do this because SUM inlining fails many tests. TBH, I also see issues with DOT_PRODUCT inlining currently, but I hope I will be able to resolve them soon and enable the pass in the driver.

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

331–332

I do not think the check above is enough. As I understand, the main goal of this code is to skip fir.convert, but we should expect that we can meet any instruction producing !fix.box, e.g. consider that previous passes generated fir.store/fir.load of a !fir.box in the middle for whatever reason. I think we should actually check for a set of expected operations in the chain and bail out otherwise.

349

Please remove.

[vzakhari]

My internal testing passed with this patch and the pass enabled in the driver, so it should probably be okay. At the same time, I am still uncomfortable with the wide range of operations that we pass through during the analysis. Can you please check explicitly for operations expected in the chain, i.e. check explicitly for fir.convert and return conservative results otherwise?

[Leporacanthicus]

Updated check for expected operation (always fir::ConvertOp) instead of
checking for number of operands. Assert to capture should number of operands
be zero.

Remove spurious include of iostream.

[Leporacanthicus]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

331–332

I think I've done this correctly - I'm slightly worried it's TOO restrictive....

[vzakhari]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

331–332

I understand your concern. I guess we will have to see what critical cases we might be missing here by analyzing benchmarks.

I think you may keep the loop so that we skip multiple fir.convert operations in a raw (e.g. see getArgElementType below). This can be done in a separate commit, though.

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

mlir::func::FuncOp SimplifyIntrinsicsPass::getOrCreateFunction(
   bodyGenerator(builder, newFunc);
 
   // Now back to where we were adding code earlier...
   builder.restoreInsertionPoint(insertPt);
 
   return newFunc;
 }
 
+fir::ConvertOp expectConvertOp(mlir::Value val) {
+  if (fir::ConvertOp op =
+          mlir::dyn_cast_or_null<fir::ConvertOp>(val.getDefiningOp()))
+    return op;
+  LLVM_DEBUG(llvm::dbgs() << "Didn't find expected fir::ConvertOp\n");
+  return nullptr;
+}
+
 static bool isOperandAbsent(mlir::Value val) {
-  if (mlir::Operation *op = val.getDefiningOp())
+  if (auto op = expectConvertOp(val)) {
+    assert(op->getOperands().size() != 0);
     return mlir::isa_and_nonnull<fir::AbsentOp>(
         op->getOperand(0).getDefiningOp());
+  }
   return false;
 }
 
 static bool isZero(mlir::Value val) {
-  if (mlir::Operation *op = val.getDefiningOp())
+  if (auto op = expectConvertOp(val)) {
+    assert(op->getOperands().size() != 0);
     if (mlir::Operation *defOp = op->getOperand(0).getDefiningOp())
       return mlir::matchPattern(defOp, mlir::m_Zero());
+  }
   return false;
 }
 
 static mlir::Value findShape(mlir::Value val) {
-  mlir::Operation *defOp = val.getDefiningOp();
-  while (defOp) {
-    defOp = defOp->getOperand(0).getDefiningOp();
-    if (fir::EmboxOp box = mlir::dyn_cast_or_null<fir::EmboxOp>(defOp))
+  if (auto op = expectConvertOp(val)) {
+    assert(op->getOperands().size() != 0);
+    if (auto box =
+            mlir::dyn_cast<fir::EmboxOp>(op->getOperand(0).getDefiningOp()))
       return box.getShape();
   }
   return {};
 }
 
 static unsigned getDimCount(mlir::Value val) {
   if (mlir::Value shapeVal = findShape(val)) {
     mlir::Type resType = shapeVal.getDefiningOp()->getResultTypes()[0];
     return fir::getRankOfShapeType(resType);
   }
   return 0;
 }
 
 /// Given the call operation's box argument \p val, discover
 /// the element type of the underlying array object.
 /// \returns the element type or llvm::None if the type cannot
 /// be reliably found.
 /// We expect that the argument is a result of fir.convert
 /// with the destination type of !fir.box<none>.
 static llvm::Optional<mlir::Type> getArgElementType(mlir::Value val) {
   mlir::Operation *defOp;
   do {

flang/test/Transforms/simplifyintrinsics.fir

 // CHECK:           fir.do_loop %[[ITER:.*]] = %{{.*}} to %[[EXTENT]] step %[[CINDEX_1]] {
 // CHECK:             %{{.*}} = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 // CHECK:           }
 // CHECK:           return %{{.*}} : i32
 // CHECK:         }
 
 // -----
 
+// Check that the compiler accepts unknown size arrays.
+module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {
+  func.func @sum_dim() {
+    %arr = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+    %var = fir.alloca !fir.array<8x8xi32>  
+    %size = arith.constant 8 : index
+    %c1 = arith.constant 1 : index
+    %c1_i32 = arith.constant 1 : i32
+    %lineno = arith.constant 12 : i32
+    %shape = fir.shape %size, %size : (index, index) -> !fir.shape<2>
+    %slice = fir.slice %c1, %size, %c1, %c1, %size, %c1 : (index, index, index, index, index, index) -> !fir.slice<2>
+    %box_array = fir.embox %var(%shape) [%slice] : (!fir.ref<!fir.array<8x8xi32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?x?xi32>>
+    %box_none = fir.convert %arr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+    %box_none2 = fir.convert %box_array : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+    %absent = fir.absent !fir.box<i1>
+    %file = fir.address_of(@filename) : !fir.ref<!fir.char<1,16>>
+    %file_ref = fir.convert %file : (!fir.ref<!fir.char<1,16>>) -> !fir.ref<i8>
+    %absent_none = fir.convert %absent : (!fir.box<i1>) -> !fir.box<none>
+    %res = fir.call @_FortranASumDim(%box_none, %box_none2, %c1_i32, %file_ref, %lineno, %absent_none) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>) -> none
+    func.return
+  }
+}
+
+// Just check that SOMETHING is being output.
+// CHECK-LABEL @sum_dim() {
+// CHECK: return
+
+// -----
+
 func.func @dot_f32(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f32 {
   %0 = fir.alloca f32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}
   %1 = fir.address_of(@_QQcl.2E2F646F742E66393000) : !fir.ref<!fir.char<1,10>>
   %c3_i32 = arith.constant 3 : i32
   %2 = fir.convert %arg0 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
   %3 = fir.convert %arg1 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
   %4 = fir.convert %1 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
   %5 = fir.call @_FortranADotProductReal4(%2, %3, %4, %c3_i32) : (!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f32
   fir.store %5 to %0 : !fir.ref<f32>
   %6 = fir.load %0 : !fir.ref<f32>
   return %6 : f32
 }
-func.func private @_FortranADotProductReal4(!fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> f32 attributes {fir.runtime}
-fir.global linkonce @_QQcl.2E2F646F742E66393000 constant : !fir.char<1,10> {
-  %0 = fir.string_lit "./dot.f90\00"(10) : !fir.char<1,10>
-  fir.has_value %0 : !fir.char<1,10>
-}
-
 // CHECK-LABEL:   func.func @dot_f32(
 // CHECK-SAME:                      %[[A:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"},
 // CHECK-SAME:                      %[[B:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "b"}) -> f32 {
 // CHECK:           %[[RESLOC:.*]] = fir.alloca f32 {bindc_name = "dot", uniq_name = "_QFdotEdot"}
 // CHECK:           %[[ACAST:.*]] = fir.convert %[[A]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
 // CHECK:           %[[BCAST:.*]] = fir.convert %[[B]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
 // CHECK:           %[[RES:.*]] = fir.call @_FortranADotProductReal4_f32_f32_simplified(%[[ACAST]], %[[BCAST]]) : (!fir.box<none>, !fir.box<none>) -> f32
 // CHECK:           fir.store %[[RES]] to %[[RESLOC]] : !fir.ref<f32>