[flang][hlfir] Parse unordered attribute for elemental operations.

[vzakhari]

Summary

By default, hlfir.elemental and hlfir.elemental_addr must process
the elements in order. The unordered attribute may be set,
if it is safe to process the elements out of order.
This patch just adds parsing support for the new attribute.

[jeanPerier]

Looks good

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

1244

I agree that I do not see in which case we would currently generate a body with side effects. The only case I can think of is if we were to inline some "ordered" hlfir.elemental inside an hlfir.elemental_addr: the hlfir.elemental_addr should inherit the "ordered". But this is a risky optimization as there may be other Fortran rules to consider when doing this.
Having the attribute offers more flexibility, so I think it is fine to have it.

[tblah]

LGTM

[vzakhari]

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

1244

Thank you for the review! I will remove the TODO comment then.

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

let description = [{
     based indices iterating over the elemental expression shape.
     Given these indices, the element value for the given iteration
     can be computed in the region and yielded with the hlfir.yield_element
     operation.
 
     The shape and typeparams operands represent the extents and type
     parameters of the resulting array value.
 
-    Currently there is no way to control the iteration order of a hlfir
-    elemental operation and so operations in the body of the elemental must
-    not have side effects. If this is changed, an attribute must be added so
-    that the elemental inlining pass can skip these impure elementals.
+    The unordered attribute can be set to allow out of order processing
+    of the indices. This is safe only if the operations in the body
+    of the elemental do not have side effects.
 
 
     Example: Y + X,  with Integer :: X(10, 20), Y(10,20)
     ```
       %0 = fir.shape %c10, %c20 : (index, index) -> !fir.shape<2>
       %5 = hlfir.elemental %0 : (!fir.shape<2>) -> !hlfir.expr<10x20xi32> {
       ^bb0(%i: index, %j: index):
         %6 = hlfir.designate %x (%i, %j)  : (!fir.ref<!fir.array<10x20xi32>>, index, index) -> !fir.ref<i32>
         %7 = hlfir.designate %y (%i, %j)  : (!fir.ref<!fir.array<10x20xi32>>, index, index) -> !fir.ref<i32>
         %8 = fir.load %6 : !fir.ref<i32>
         %9 = fir.load %7 : !fir.ref<i32>
         %10 = arith.addi %8, %9 : i32
         hlfir.yield_element %10 : i32
       }
     ```
   }];
 
   let arguments = (ins
     AnyShapeType:$shape,
-    Variadic<AnyIntegerType>:$typeparams
+    Variadic<AnyIntegerType>:$typeparams,
+    OptionalAttr<UnitAttr>:$unordered
   );
 
   let results = (outs hlfir_ExprType);
   let regions = (region SizedRegion<1>:$region);
 
   let assemblyFormat = [{
-    $shape (`typeparams` $typeparams^)?
+    $shape (`typeparams` $typeparams^)? (`unordered` $unordered^)?
     attr-dict `:` functional-type(operands, results)
     $region
     }];
 
   let extraClassDeclaration = [{
       mlir::Block *getBody() { return &getRegion().front(); }
 
       /// Get the indices iterating over the shape.
       mlir::Block::BlockArgListType getIndices() {
        return getBody()->getArguments();
       }
       /// ElementalOpInterface implementation.
 
-      mlir::Region& getElementalRegion() {return getRegion();}
+      mlir::Region& getElementalRegion() { return getRegion(); }
       mlir::Value getElementEntity();
-      mlir::Region* getElementCleanup() {return nullptr;}
+      mlir::Region* getElementCleanup() { return nullptr; }
 
       /// Must this elemental be evaluated in order?
-      /// TODO: add attribute and set it in lowering.
-      bool isOrdered() {return true;}
+      bool isOrdered() { return !getUnordered(); }
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "mlir::Type":$result_type, "mlir::Value":$shape,
       CArg<"mlir::ValueRange", "{}">:$typeparams)>];
 
 }
hlfir.region_assign {
         hlfir.yield %x_element_addr : !fir.ref<f32>
       }
     }
     ```
   }];
 
   let arguments = (ins
     fir_ShapeType:$shape,
-    Variadic<AnyIntegerType>:$typeparams);
+    Variadic<AnyIntegerType>:$typeparams,
+    OptionalAttr<UnitAttr>:$unordered
+  );
 
   let regions = (region  SizedRegion<1>:$body,
                          MaxSizedRegion<1>:$cleanup);
 
   let builders = [
     OpBuilder<(ins "mlir::Value":$shape)>
   ];
 
   let assemblyFormat = [{
-    $shape (`typeparams` $typeparams^)?
+    $shape (`typeparams` $typeparams^)? (`unordered` $unordered^)?
     attr-dict `:` type(operands) $body
     custom<YieldOpCleanup>($cleanup)}];
 
   let extraClassDeclaration = [{
     mlir::Region::BlockArgListType getIndices() {
       return getBody().getArguments();
     }
 
     /// Return the hlfir::YieldOp terminator of the operation
     /// body. It yields the variable element address.
     /// This should only be called once the ElementalAddrOp has been built.
     hlfir::YieldOp getYieldOp();
 
     /// ElementalOpInterface implementation.
 
-    mlir::Region& getElementalRegion() {return getBody();}
+    mlir::Region& getElementalRegion() { return getBody(); }
     mlir::Value getElementEntity();
     mlir::Region* getElementCleanup();
 
     /// Must this elemental be evaluated in order?
-    /// TODO: add attribute and set it in lowering.
-    bool isOrdered() {return true;}
+    bool isOrdered() { return !getUnordered(); }
   }];
 
   let hasVerifier = 1;
 }
 
 /// Define ODS constraints to verify that a region ends with a yield of a
 /// certain type.
 def YieldIntegerOrEmpty : CPred<"yieldsIntegerOrEmpty($_self)">;

flang/test/HLFIR/element-addr.fir

 // CHECK:               %[[VAL_9:.*]] = fir.load %[[VAL_8]] : !fir.ref<i32>
 // CHECK:               %[[VAL_10:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_9]])  typeparams %[[VAL_3]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>, i32, index) -> !fir.boxchar<1>
 // CHECK:               hlfir.yield %[[VAL_10]] : !fir.boxchar<1>
 // CHECK:             } cleanup {
 // CHECK:               %[[VAL_11:.*]] = fir.box_addr %[[VAL_4]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
 // CHECK:               fir.freemem %[[VAL_11]] : !fir.heap<!fir.array<?xi32>>
 // CHECK:             }
 // CHECK:           }
+
+func.func @unordered() {
+  %c10 = arith.constant 10 : index
+  %c20 = arith.constant 20 : index
+  %0 = fir.shape %c10, %c20 : (index, index) -> !fir.shape<2>
+  hlfir.region_assign {
+    %addr = fir.undefined !fir.ref<!fir.array<10x20xf32>>
+    hlfir.yield %addr : !fir.ref<!fir.array<10x20xf32>>
+  } to {
+    hlfir.elemental_addr %0 unordered : !fir.shape<2> {
+    ^bb0(%i: index, %j: index):
+      %addr = fir.undefined !fir.ref<f32>
+      hlfir.yield %addr : !fir.ref<f32>
+    }
+  }
+  return
+}
+// CHECK-LABEL:   func.func @unordered() {
+// CHECK:           %[[VAL_0:.*]] = arith.constant 10 : index
+// CHECK:           %[[VAL_1:.*]] = arith.constant 20 : index
+// CHECK:           %[[VAL_2:.*]] = fir.shape %[[VAL_0]], %[[VAL_1]] : (index, index) -> !fir.shape<2>
+// CHECK:           hlfir.region_assign {
+// CHECK:             %[[VAL_3:.*]] = fir.undefined !fir.ref<!fir.array<10x20xf32>>
+// CHECK:             hlfir.yield %[[VAL_3]] : !fir.ref<!fir.array<10x20xf32>>
+// CHECK:           } to {
+// CHECK:             hlfir.elemental_addr %[[VAL_2]] unordered : !fir.shape<2> {
+// CHECK:             ^bb0(%[[VAL_4:.*]]: index, %[[VAL_5:.*]]: index):
+// CHECK:               %[[VAL_6:.*]] = fir.undefined !fir.ref<f32>
+// CHECK:               hlfir.yield %[[VAL_6]] : !fir.ref<f32>
+// CHECK:             }
+// CHECK:           }
+// CHECK:           return
+// CHECK:         }

flang/test/HLFIR/elemental.fir

 // CHECK-SAME: %[[VAL_3:[^:]*]]: i32
 // CHECK:  %[[VAL_4:.*]] = fir.shape
 // CHECK:  %[[VAL_5:.*]] = hlfir.elemental %[[VAL_4]] typeparams %[[VAL_3]] : (!fir.shape<2>, i32) -> !hlfir.expr<?x?x!fir.type<pdt(param:i32){field:f32}>> {
 // CHECK:  ^bb0(%[[VAL_6:.*]]: index, %[[VAL_7:.*]]: index):
 // CHECK:    %[[VAL_8:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_6]], %[[VAL_7]])  typeparams %[[VAL_3]] : (!fir.box<!fir.array<?x?x!fir.type<pdt(param:i32){field:f32}>>>, index, index, i32) -> !fir.box<!fir.type<pdt(param:i32){field:f32}>>
 // CHECK:    %[[VAL_9:.*]] = hlfir.as_expr %[[VAL_8]] : (!fir.box<!fir.type<pdt(param:i32){field:f32}>>) -> !hlfir.expr<!fir.type<pdt(param:i32){field:f32}>>
 // CHECK:    hlfir.yield_element %[[VAL_9]] : !hlfir.expr<!fir.type<pdt(param:i32){field:f32}>>
 // CHECK:  }
+
+func.func @unordered() {
+  %c10 = arith.constant 10 : index
+  %c20 = arith.constant 20 : index
+  %0 = fir.shape %c10, %c20 : (index, index) -> !fir.shape<2>
+  %3 = hlfir.elemental %0 unordered : (!fir.shape<2>) -> !hlfir.expr<10x20xi32> {
+  ^bb0(%i: index, %j: index):
+    %c0 = arith.constant 0 : i32
+    hlfir.yield_element %c0 : i32
+  }
+  return
+}
+// CHECK-LABEL:   func.func @unordered() {
+// CHECK:           %[[VAL_0:.*]] = arith.constant 10 : index
+// CHECK:           %[[VAL_1:.*]] = arith.constant 20 : index
+// CHECK:           %[[VAL_2:.*]] = fir.shape %[[VAL_0]], %[[VAL_1]] : (index, index) -> !fir.shape<2>
+// CHECK:           %[[VAL_3:.*]] = hlfir.elemental %[[VAL_2]] unordered : (!fir.shape<2>) -> !hlfir.expr<10x20xi32> {
+// CHECK:           ^bb0(%[[VAL_4:.*]]: index, %[[VAL_5:.*]]: index):
+// CHECK:             %[[VAL_6:.*]] = arith.constant 0 : i32
+// CHECK:             hlfir.yield_element %[[VAL_6]] : i32
+// CHECK:           }
+// CHECK:           return
+// CHECK:         }