[flang] support fir.unreachable in stack arrays pass

[tblah]

Summary

Some functions (e.g. the main function) end with a call to the STOP
statement instead of a func.return. This is lowered as a call to the
stop runtime function followed by a fir.unreachable. fir.unreachable is
a terminator and so this can cause functions to have no func.return.

The stack arrays pass looks to see which heap allocations have always
been freed by the time a function returns. Without any returns, the pass
does not detect any freed allocations. This patch changes this behaviour
so that fir.unreachable is checked as well as func.return.

This allows 15 heap allocations for array temporaries in spec2017
exchange2's main function to be moved to the stack.

[jeanPerier]

flang/lib/Optimizer/Transforms/StackArrays.cpp

440–441

I was trying to think if an interface trait could be used instead of doing a walk for each operation that may terminate a function. Would the Terminator trait work or is it too broad ?

[tblah]

flang/lib/Optimizer/Transforms/StackArrays.cpp

440–441

I did try Terminator, but scf branch operations are also Terminators. Terminator means something that terminates a block, not a function. There is a "ReturnLike" trait, but fir.unreachable does not implement that.

[jeanPerier]

flang/lib/Optimizer/Transforms/StackArrays.cpp

440–441

Ok, too bad. I think it might be weird for fir.unreachable to implement "ReturnLike", so I am good with your patch.

flang/lib/Optimizer/Transforms/StackArrays.cpp

void StackArraysAnalysisWrapper::analyseFunction(mlir::Operation *func) {
   solver.load<AllocationAnalysis>();
   if (failed(solver.initializeAndRun(func))) {
     llvm::errs() << "DataFlowSolver failed!";
     gotError = true;
     return;
   }
 
   LatticePoint point{func};
-  func->walk([&](mlir::func::ReturnOp child) {
-    const LatticePoint *lattice = solver.lookupState<LatticePoint>(child);
+  auto joinOperationLattice = [&](mlir::Operation *op) {
+    const LatticePoint *lattice = solver.lookupState<LatticePoint>(op);
     // there will be no lattice for an unreachable block
     if (lattice)
       point.join(*lattice);
-  });
+  };
+  func->walk([&](mlir::func::ReturnOp child) { joinOperationLattice(child); });
+  func->walk([&](fir::UnreachableOp child) { joinOperationLattice(child); });
   llvm::DenseSet<mlir::Value> freedValues;
   point.appendFreedValues(freedValues);
 
   // We only replace allocations which are definately freed on all routes
   // through the function because otherwise the allocation may have an intende
   // lifetime longer than the current stack frame (e.g. a heap allocation which
   // is then freed by another function).
   for (mlir::Value freedValue : freedValues) {

flang/test/Transforms/stack-arrays.fir

 // return satement.
 // CHECK-NEXT:       fir.freemem %[[MEM]] : !fir.heap<!fir.array<42xi32>>
 // CHECK-NEXT:       omp.terminator
 // CHECK-NEXT:     }
 // CHECK-NEXT:     omp.terminator
 // CHECK-NEXT:   }
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
+
+// function terminated by stop statement
+func.func @stop_terminator() {
+  %0 = fir.allocmem !fir.array<42xi32>
+  fir.freemem %0 : !fir.heap<!fir.array<42xi32>>
+  %c0_i32 = arith.constant 0 : i32
+  %false = arith.constant false
+  %none = fir.call @_FortranAStopStatement(%c0_i32, %false, %false) : (i32, i1, i1) -> none
+  fir.unreachable
+}
+// CHECK: func.func @stop_terminator() {
+// CHECK-NEXT: fir.alloca !fir.array<42xi32>
+// CHECK-NEXT:  %[[ZERO:.*]] = arith.constant 0 : i32
+// CHECK-NEXT:  %[[FALSE:.*]] = arith.constant false
+// CHECK-NEXT:  %[[NONE:.*]] = fir.call @_FortranAStopStatement(%[[ZERO]], %[[FALSE]], %[[FALSE]]) : (i32, i1, i1) -> none
+// CHECK-NEXT:  fir.unreachable
+// CHECK-NEXT: }