[flang][hlfir] Add hlfir.copy_in and hlfir.copy_out operations

[jeanPerier]

Summary

These operations implement the optional copy of a non contiguous
variable into a temporary before a call, and the copy back from the
temporary after the call.

[clementval]

LGTM

[PeteSteinfeld]

All builds and tests correctly, but it looks like some changes are needed to HLFIROps.td.

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

533

Should this be "copies the data"?

534–537

I didn't understand this sentence.

541

Should read "In such cases ..."

579–587

"getHandleNullBox()" is not used anywhere. Do we need it?

Both of these functions would read more clearly if their names evoked the fact that they return bools. For example, "handlesNullAddr".

I couldn't find a definition of "getHandleOptional" anywhere.

[vzakhari]

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

530

nit: maybe mention the return value (result(0)) in this case, so that "Otherwise" below does not look lonely.

560

Can you please document this parameter? Is the intended usage to produce !fir.box, when the temporary value is "don't care" after the call, and !fir.ref otherwise?

577

nit: it seems a two-bit enum could have been more clear, but I can accept bool for this purpose as well :)

598

typo? $var is provided **and** $was_copied is true?

[jeanPerier]

Simplify the operation and answers comments:

• Instead of indicating with a flag how a variable can be optional (null box or null address in box), pass an extra boolean value when the input is optional to indicate if it is present.
• Instead of allowing the operation to return a raw address of box, always returns a box: the box is always created, and it is needed anway when there is a copy-back.

[jeanPerier]

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

534–537

Rephrased the sentence and removed the part in parenthesis that brings little here.

560

I changed the operation to always return a fir.box because it made things a lot simpler, so I removed this boolean.

577

Fair point, an MLIR enum would have save custom printing/parsing. I anyway removed this while simplifying the operation.

579–587

I removed those while reworking the operation. This patch is like adding am API for review, the actual usage of the API will come in a later patch.

I couldn't find a definition of "getHandleOptional" anywhere.

MLIR generates getters automatically for all the names after "let arguments = " it convert the snake case .td name syntax (handle_optional) to camel case (getHandleOptional). See https://mlir.llvm.org/docs/DefiningDialects/Operations/#operation-arguments for more details.

[vzakhari]

Thank you for the update! LGTM

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Optimizer/Dialect/FIRTypes.td

 
 def fir_VoidType : FIR_Type<"Void", "void"> {
   let genStorageClass = 0;
 }
 
 // Whether a type is a BaseBoxType
 def IsBaseBoxTypePred
         : CPred<"$_self.isa<::fir::BaseBoxType>()">;
+def fir_BaseBoxType : Type<IsBaseBoxTypePred, "fir.box or fir.class type">;
 
 // Generalized FIR and standard dialect types representing intrinsic types
 def AnyIntegerLike : TypeConstraint<Or<[SignlessIntegerLike.predicate,
     AnySignedInteger.predicate, fir_IntegerType.predicate]>, "any integer">;
 def AnyLogicalLike : TypeConstraint<Or<[BoolLike.predicate,
     fir_LogicalType.predicate]>, "any logical">;
 def AnyRealLike : TypeConstraint<Or<[FloatLike.predicate,
     fir_RealType.predicate]>, "any real">;

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

let description = [{
     in bufferization instead.
   }];
 
   let arguments = (ins hlfir_ExprType:$expr);
 
   let assemblyFormat = "$expr attr-dict `:` qualified(type($expr))";
 }
 
+def hlfir_CopyInOp : hlfir_Op<"copy_in", []> {
+  let summary = "copy a variable into a contiguous temporary if it is not contiguous";
+  let description = [{
+    Copy a variable into a contiguous temporary if the variable is not
+    an absent optional and is not contiguous at runtime. When a copy is made this
+    operation returns the temporary as first result, otherwise, it returns the
+    potentially absent variable storage. The second result indicates if a copy
+    was made.
+
+    This operation is meant to be used in combination with the hlfir.copy_out
+    operation that deletes the temporary if it was created and copies the data
+    back if needed.
+    This operation allows passing non contiguous arrays to contiguous dummy
+    arguments, which is possible in Fortran procedure references.
+
+    To deal with the optional case, an extra boolean value can be pass to the
+    operation. In such cases, the copy-in will only be done if "var_is_present"
+    is true and, when it is false, the original value will be returned instead.
+  }];
+
+  let arguments = (ins fir_BaseBoxType:$var,
+                   Optional<I1>:$var_is_present);
+
+  let results = (outs fir_BaseBoxType, I1);
+
+  let assemblyFormat = [{
+    $var (`handle_optional` $var_is_present^)?
+    attr-dict `:` functional-type(operands, results)
+  }];
+
+  let builders = [
+    OpBuilder<(ins "mlir::Value":$var, "mlir::Value":$var_is_present)>
+  ];
+
+  let extraClassDeclaration = [{
+    /// Get the resulting copied-in fir.box or fir.class.
+    mlir::Value getCopiedIn() {
+      return getResult(0);
+    }
+
+    /// Get the result indicating if a copy was made.
+    mlir::Value getWasCopied() {
+      return getResult(1);
+    }
+  }];
+}
+
+def hlfir_CopyOutOp : hlfir_Op<"copy_out", []> {
+  let summary = "copy out a variable after a copy in";
+  let description = [{
+    If the variable was copied in a temporary in the related hlfir.copy_in,
+    optionally copy back the temporary value to it (that may have been
+    modified between the hlfir.copy_in and hlfir.copy_out). Then deallocate
+    the temporary.
+    The copy back is done if $var is provided and $was_copied is true.
+    The deallocation of $temp is done if $was_copied is true.
+  }];
+
+  let arguments = (ins fir_BaseBoxType:$temp,
+                       I1:$was_copied,
+                       Optional<fir_BaseBoxType>:$var);
+
+  let assemblyFormat = [{
+    $temp `,` $was_copied (`to` $var^)?
+    attr-dict `:` functional-type(operands, results)
+  }];
+}
+
 #endif // FORTRAN_DIALECT_HLFIR_OPS

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

 //===----------------------------------------------------------------------===//
 
 void hlfir::NullOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &odsState) {
   return build(builder, odsState,
                fir::ReferenceType::get(builder.getNoneType()));
 }
 
+//===----------------------------------------------------------------------===//
+// CopyInOp
+//===----------------------------------------------------------------------===//
+
+void hlfir::CopyInOp::build(mlir::OpBuilder &builder,
+                            mlir::OperationState &odsState, mlir::Value var,
+                            mlir::Value var_is_present) {
+  return build(builder, odsState, var.getType(), var, var_is_present);
+}
+
 #define GET_OP_CLASSES
 #include "flang/Optimizer/HLFIR/HLFIROps.cpp.inc"

flang/test/HLFIR/copy-in-out.fir

+// Test hlfir.copy_in and hlfir.copy_out operation parse, verify (no errors),
+// and unparse.
+
+// RUN: fir-opt %s | fir-opt | FileCheck %s
+
+func.func @test_copy_in(%box: !fir.box<!fir.array<?xf64>>, %is_present: i1) {
+  %0:2 = hlfir.copy_in %box : (!fir.box<!fir.array<?xf64>>) -> (!fir.box<!fir.array<?xf64>>, i1)
+  %1:2 = hlfir.copy_in %box handle_optional %is_present : (!fir.box<!fir.array<?xf64>>, i1) -> (!fir.box<!fir.array<?xf64>>, i1)
+  return
+}
+// CHECK-LABEL:   func.func @test_copy_in(
+// CHECK-SAME:    %[[VAL_0:.*]]: !fir.box<!fir.array<?xf64>>,
+// CHECK-SAME:    %[[VAL_1:.*]]: i1
+// CHECK:  %[[VAL_2:.*]]:2 = hlfir.copy_in %[[VAL_0]]  : (!fir.box<!fir.array<?xf64>>) -> (!fir.box<!fir.array<?xf64>>, i1)
+// CHECK:  %[[VAL_3:.*]]:2 = hlfir.copy_in %[[VAL_0]] handle_optional %[[VAL_1]] : (!fir.box<!fir.array<?xf64>>, i1) -> (!fir.box<!fir.array<?xf64>>, i1)
+
+func.func @test_copy_out(%box: !fir.box<!fir.array<?xf64>>, %temp: !fir.box<!fir.array<?xf64>>, %was_copied: i1) {
+  hlfir.copy_out %temp, %was_copied : (!fir.box<!fir.array<?xf64>>, i1) -> ()
+  hlfir.copy_out %temp, %was_copied to %box : (!fir.box<!fir.array<?xf64>>, i1, !fir.box<!fir.array<?xf64>>) -> ()
+  return
+}
+// CHECK-LABEL:   func.func @test_copy_out(
+// CHECK-SAME:    %[[VAL_0:[^:]*]]: !fir.box<!fir.array<?xf64>>,
+// CHECK-SAME:    %[[VAL_1:.*]]: !fir.box<!fir.array<?xf64>>,
+// CHECK-SAME:    %[[VAL_2:.*]]: i1) {
+// CHECK:  hlfir.copy_out %[[VAL_1]], %[[VAL_2]] : (!fir.box<!fir.array<?xf64>>, i1) -> ()
+// CHECK:  hlfir.copy_out %[[VAL_1]], %[[VAL_2]] to %[[VAL_0]] : (!fir.box<!fir.array<?xf64>>, i1, !fir.box<!fir.array<?xf64>>) -> ()