[flang][openacc] Support array section with constant lb or ub for data operand

[clementval]

Summary

Add support for array section with constant lower or upper bound.
The current lowering will trigger a TODO when the array is assumed size
or if the lower or upper bound is a variable.

Depends on D148721

[clementval]

Rebase

[razvanlupusoru]

Nice! This looks great!

[jeanPerier]

Few questions, looks good to me otherwise.

flang/lib/Lower/OpenACC.cpp

121

Isn't it possible to extract the Expr<SomeType> at that from lower and to lower that to cover all cases, or do you need to do something special for the constant bounds case?

156

Why not using the symbol map to retrieve the upper bound value? Outside of the compile time constant shape case, the upper bound cannot be retrieved from the Symbol shape at that point.

Special casing the constant upper bounds makes some sense, to avoid the "ub = extent + lb -1" computation, in the generated IR but MLIR folds that easily if the extent and lb are constants.

161

Should there be a TODO if ubound is not set after that (to cover assumed shapes, allocatable, pointers and explicit shape with non constant bounds).

[clementval]

flang/lib/Lower/OpenACC.cpp

121

It is just for cosmetic reason.

156

Good point. I'll update that.

161

They should be caught by the TODO in createOpAndAddOperand.

[clementval]

Add extent when upper bound is not available

[jeanPerier]

flang/lib/Lower/OpenACC.cpp

121

OK, thanks for explaining.

flang/lib/Lower/OpenACC.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/OpenACC.h"
 #include "flang/Common/idioms.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/StatementContext.h"
+#include "flang/Lower/Support/Utils.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "llvm/Frontend/OpenACC/ACC.h.inc"
std::visit(
             },
             [&](const Fortran::parser::Name &name) {
               addOperands(*name.symbol);
             }},
         accObject.u);
   }
 }
 
+static llvm::SmallVector<mlir::Value>
+genBoundsOps(fir::FirOpBuilder &builder, mlir::Location loc,
+             Fortran::lower::AbstractConverter &converter,
+             const std::list<Fortran::parser::SectionSubscript> &subscripts,
+             std::stringstream &asFortran, const Fortran::parser::Name &name) {
+  int dimension = 0;
+  mlir::Type i64Ty = builder.getI64Type();
+  mlir::Type boundTy = builder.getType<mlir::acc::DataBoundsType>();
+  llvm::SmallVector<mlir::Value> bounds;
+  for (const auto &subscript : subscripts) {
+    if (const auto *triplet{
+            std::get_if<Fortran::parser::SubscriptTriplet>(&subscript.u)}) {
+      if (dimension != 0)
+        asFortran << ',';
+      mlir::Value lbound, ubound, extent;
+      std::optional<std::int64_t> lval, uval;
+      const auto &lower{std::get<0>(triplet->t)};
+      if (lower) {
+        lval = Fortran::semantics::GetIntValue(lower);
+        if (lval) {
+          lbound = builder.createIntegerConstant(loc, i64Ty, *lval);
+          asFortran << *lval;
+        } else {
+          TODO(loc, "non constant lower bound in array section");
+        }
+      }
+      asFortran << ':';
+      const auto &upper{std::get<1>(triplet->t)};
+      if (upper) {
+        uval = Fortran::semantics::GetIntValue(upper);
+        if (uval) {
+          ubound = builder.createIntegerConstant(loc, i64Ty, *uval);
+          asFortran << *uval;
+        } else {
+          TODO(loc, "non constant upper bound in array section");
+        }
+      }
+      if (lower && upper) {
+        if (lval && uval && *uval < *lval) {
+          mlir::emitError(loc, "zero sized array section");
+          break;
+        } else if (std::get<2>(triplet->t)) {
+          const auto &strideExpr{std::get<2>(triplet->t)};
+          if (strideExpr) {
+            mlir::emitError(loc, "stride cannot be specified on "
+                                 "an OpenACC array section");
+            break;
+          }
+        }
+      }
+      if (!ubound) {
+        fir::ExtendedValue x = converter.getSymbolExtendedValue(*name.symbol);
+        extent = fir::factory::readExtent(builder, loc, x, dimension);
+      }
+      mlir::Value empty;
+      mlir::Value bound = builder.create<mlir::acc::DataBoundsOp>(
+          loc, boundTy, lbound, ubound, extent, empty, false, empty);
+      bounds.push_back(bound);
+      ++dimension;
+    }
+  }
+  return bounds;
+}
+
 template <typename Op>
 static void
 genDataOperandOperations(const Fortran::parser::AccObjectList &objectList,
                          Fortran::lower::AbstractConverter &converter,
                          Fortran::semantics::SemanticsContext &semanticsContext,
                          Fortran::lower::StatementContext &stmtCtx,
                          llvm::SmallVectorImpl<mlir::Value> &dataOperands,
                          mlir::acc::DataClause dataClause, bool structured) {
 
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
 
   auto createOpAndAddOperand = [&](Fortran::lower::SymbolRef sym,
-                                   llvm::StringRef name, mlir::Location loc) {
+                                   llvm::StringRef name,
+                                   mlir::Location loc) -> Op {
     mlir::Value symAddr = converter.getSymbolAddress(sym);
     // TODO: Might need revisiting to handle for non-shared clauses
     if (!symAddr) {
       if (const auto *details =
               sym->detailsIf<Fortran::semantics::HostAssocDetails>())
         symAddr = converter.getSymbolAddress(details->symbol());
     }
 
     if (!symAddr)
       llvm::report_fatal_error("could not retrieve symbol address");
 
+    if (symAddr.getType().isa<fir::BaseBoxType>())
+      TODO(loc, "data operand operation creation for box types");
     Op op = builder.create<Op>(loc, symAddr.getType(), symAddr);
     op.setNameAttr(builder.getStringAttr(name));
     op.setStructured(structured);
     op.setDataClause(dataClause);
     op->setAttr(Op::getOperandSegmentSizeAttr(),
                 builder.getDenseI32ArrayAttr({1, 0, 0}));
     dataOperands.push_back(op.getAccPtr());
+    return op;
   };
 
   for (const auto &accObject : objectList.v) {
     std::visit(
         Fortran::common::visitors{
             [&](const Fortran::parser::Designator &designator) {
               mlir::Location operandLocation =
                   converter.genLocation(designator.source);
               if (auto expr{Fortran::semantics::AnalyzeExpr(semanticsContext,
                                                             designator)}) {
                 if ((*expr).Rank() > 0 &&
                     Fortran::parser::Unwrap<Fortran::parser::ArrayElement>(
                         designator)) {
-                  TODO(operandLocation, "OpenACC array section data operand");
+                  const auto *arrayElement =
+                      Fortran::parser::Unwrap<Fortran::parser::ArrayElement>(
+                          designator);
+                  llvm::SmallVector<mlir::Value> bounds;
+                  const auto *dataRef =
+                      std::get_if<Fortran::parser::DataRef>(&designator.u);
+                  const Fortran::parser::Name &name =
+                      Fortran::parser::GetLastName(*dataRef);
+                  std::stringstream asFortran;
+                  asFortran << name.ToString();
+                  if (!arrayElement->subscripts.empty()) {
+                    asFortran << '(';
+                    bounds =
+                        genBoundsOps(builder, operandLocation, converter,
+                                     arrayElement->subscripts, asFortran, name);
+                  }
+                  asFortran << ')';
+                  Op op = createOpAndAddOperand(*name.symbol, asFortran.str(),
+                                                operandLocation);
+                  op->insertOperands(1, bounds);
+                  op->setAttr(Op::getOperandSegmentSizeAttr(),
+                              builder.getDenseI32ArrayAttr(
+                                  {1, 0, static_cast<int32_t>(bounds.size())}));
                 } else if (Fortran::parser::Unwrap<
                                Fortran::parser::StructureComponent>(
                                designator)) {
                   TODO(operandLocation, "OpenACC derived-type data operand");
                 } else {
                   // Scalar or full array.
                   if (const auto *dataRef{std::get_if<Fortran::parser::DataRef>(
                           &designator.u)}) {

flang/test/Lower/OpenACC/acc-enter-data.f90

 ! This test checks lowering of OpenACC enter data directive.
 
 ! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
 
 subroutine acc_enter_data
   integer :: async = 1
   real, dimension(10, 10) :: a, b, c
   real, pointer :: d
   logical :: ifCondition = .TRUE.
 
+!CHECK: %[[EXTENT_C10:.*]] = arith.constant 10 : index
 !CHECK: %[[A:.*]] = fir.alloca !fir.array<10x10xf32> {{{.*}}uniq_name = "{{.*}}Ea"}
 !CHECK: %[[B:.*]] = fir.alloca !fir.array<10x10xf32> {{{.*}}uniq_name = "{{.*}}Eb"}
 !CHECK: %[[C:.*]] = fir.alloca !fir.array<10x10xf32> {{{.*}}uniq_name = "{{.*}}Ec"}
 !CHECK: %[[D:.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "d", uniq_name = "{{.*}}Ed"}
 
   !$acc enter data create(a)
 !CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[A]] : !fir.ref<!fir.array<10x10xf32>>)   -> !fir.ref<!fir.array<10x10xf32>> {name = "a", structured = false}
 !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref<!fir.array<10x10xf32>>){{$}}
!CHECK: acc.enter_data wait(%[[WAIT2]], %[[WAIT3]] : i32, i32) dataOperands(%[[CREATE_A]] : !fir.ref<!fir.array<10x10xf32>>)
 
   !$acc enter data create(a) wait(devnum: 1: queues: 1, 2)
 !CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[A]] : !fir.ref<!fir.array<10x10xf32>>)   -> !fir.ref<!fir.array<10x10xf32>> {name = "a", structured = false}
 !CHECK: %[[WAIT4:.*]] = arith.constant 1 : i32
 !CHECK: %[[WAIT5:.*]] = arith.constant 2 : i32
 !CHECK: %[[WAIT6:.*]] = arith.constant 1 : i32
 !CHECK: acc.enter_data wait_devnum(%[[WAIT6]] : i32) wait(%[[WAIT4]], %[[WAIT5]] : i32, i32) dataOperands(%[[CREATE_A]] : !fir.ref<!fir.array<10x10xf32>>)
 
+  !$acc enter data copyin(a(1:10,1:5))
+!CHECK: %[[LB1:.*]] = arith.constant 1 : i64
+!CHECK: %[[UB1:.*]] = arith.constant 10 : i64
+!CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB1]] : i64) upperbound(%[[UB1]] : i64)
+!CHECK: %[[LB2:.*]] = arith.constant 1 : i64
+!CHECK: %[[UB2:.*]] = arith.constant 5 : i64
+!CHECK: %[[BOUND2:.*]] = acc.bounds lowerbound(%[[LB2]] : i64) upperbound(%[[UB2]] : i64)
+!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[A]] : !fir.ref<!fir.array<10x10xf32>>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref<!fir.array<10x10xf32>> {name = "a(1:10,1:5)", structured = false}
+!CHECK: acc.enter_data dataOperands(%[[COPYIN_A]] : !fir.ref<!fir.array<10x10xf32>>)
+
+  !$acc enter data copyin(a(1:,1:5))
+!CHECK: %[[LB1:.*]] = arith.constant 1 : i64
+!CHECK: %[[BOUND1:.*]] = acc.bounds   lowerbound(%[[LB1]] : i64) extent(%[[EXTENT_C10]] : index)
+!CHECK: %[[LB2:.*]] = arith.constant 1 : i64
+!CHECK: %[[UB2:.*]] = arith.constant 5 : i64
+!CHECK: %[[BOUND2:.*]] = acc.bounds   lowerbound(%[[LB2]] : i64) upperbound(%[[UB2]] : i64)
+!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[A]] : !fir.ref<!fir.array<10x10xf32>>)   bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref<!fir.array<10x10xf32>> {name = "a(1:,1:5)", structured = false}
+!CHECK: acc.enter_data   dataOperands(%[[COPYIN_A]] : !fir.ref<!fir.array<10x10xf32>>)
+
+  !$acc enter data copyin(a(:10,1:5))
+!CHECK: %[[UB1:.*]] = arith.constant 10 : i64
+!CHECK: %[[BOUND1:.*]] = acc.bounds   upperbound(%[[UB1]] : i64)
+!CHECK: %[[LB2:.*]] = arith.constant 1 : i64
+!CHECK: %[[UB2:.*]] = arith.constant 5 : i64
+!CHECK: %[[BOUND2:.*]] = acc.bounds   lowerbound(%[[LB2]] : i64) upperbound(%[[UB2]] : i64)
+!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[A]] : !fir.ref<!fir.array<10x10xf32>>)   bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref<!fir.array<10x10xf32>> {name = "a(:10,1:5)", structured = false}
+!CHECK: acc.enter_data   dataOperands(%[[COPYIN_A]] : !fir.ref<!fir.array<10x10xf32>>)
+
 end subroutine acc_enter_data
+
+
+subroutine acc_enter_data_dummy(a)
+  real :: a(1:10)
+
+!CHECK-LABEL: func.func @_QPacc_enter_data_dummy
+!CHECK-SAME:    %[[A:.*]]: !fir.ref<!fir.array<10xf32>> {fir.bindc_name = "a"}
+
+  !$acc enter data create(a(5:10))
+!CHECK: %[[LB1:.*]] = arith.constant 5 : i64
+!CHECK: %[[UB1:.*]] = arith.constant 10 : i64
+!CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB1]] : i64) upperbound(%[[UB1]] : i64)
+!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[A]] : !fir.ref<!fir.array<10xf32>>)   bounds(%[[BOUND1]]) -> !fir.ref<!fir.array<10xf32>> {name = "a(5:10)", structured = false}
+!CHECK: acc.enter_data   dataOperands(%[[CREATE1]] : !fir.ref<!fir.array<10xf32>>)
+
+end subroutine