[flang][openacc] Relax required clauses on acc data as portability warning

[clementval]

Summary

Some compilers accept !$acc data without any clauses. For portability
reason, this patch relaxes the strict error to a simple portability warning.

[vzakhari]

Looks good to me. Thank you!

[razvanlupusoru]

Looks good to me. I thought about whether generating empty acc.data vs nothing is better - I am comfortable with this approach. Thank you!

flang/docs/OpenACC.md

 .. contents::
    :local:
 ```
 
 ## Intentional deviation from the specification
 * The end directive for combined construct can omit the `loop` keyword.
 * An `!$acc routine` with no parallelism clause is treated as if the `seq`
   clause was present.
+* The restriction on `!$acc data` required clauses is emitted as a portability
+  warning instead of an error as other compiler accepts it.

flang/lib/Lower/OpenACC.cpp

static void genACCDataOp(Fortran::lower::AbstractConverter &converter,
   llvm::SmallVector<mlir::Value> operands;
   llvm::SmallVector<int32_t> operandSegments;
   addOperand(operands, operandSegments, ifCond);
   addOperand(operands, operandSegments, async);
   addOperand(operands, operandSegments, waitDevnum);
   addOperands(operands, operandSegments, waitOperands);
   addOperands(operands, operandSegments, dataClauseOperands);
 
+  if (dataClauseOperands.empty() && !hasDefaultNone && !hasDefaultPresent)
+    return;
+
   auto dataOp = createRegionOp<mlir::acc::DataOp, mlir::acc::TerminatorOp>(
       builder, currentLocation, operands, operandSegments);
 
   dataOp.setAsyncAttr(addAsyncAttr);
   dataOp.setWaitAttr(addWaitAttr);
 
   if (hasDefaultNone)
     dataOp.setDefaultAttr(mlir::acc::ClauseDefaultValue::None);

flang/lib/Semantics/check-acc-structure.cpp

void AccStructureChecker::Leave(const parser::OpenACCBlockConstruct &x) {
   case llvm::acc::Directive::ACCD_serial:
     // Restriction - line 1004-1005
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
         computeConstructOnlyAllowedAfterDeviceTypeClauses);
     // Restriction - line 1001
     CheckNoBranching(block, GetContext().directive, blockDir.source);
     break;
   case llvm::acc::Directive::ACCD_data:
-    // Restriction - line 1249-1250
-    CheckRequireAtLeastOneOf();
+    // Restriction - 2.6.5 pt 1
+    // Only a warning is emitted here for portability reason.
+    CheckRequireAtLeastOneOf(/*warnInsteadOfError=*/true);
     // Restriction is not formally in the specification but all compilers emit
     // an error and it is likely to be omitted from the spec.
     CheckNoBranching(block, GetContext().directive, blockDir.source);
     break;
   case llvm::acc::Directive::ACCD_host_data:
     // Restriction - line 1746
     CheckRequireAtLeastOneOf();
     break;

flang/lib/Semantics/check-directive-structure.h

protected:
   // Check illegal branching out of `Parser::Block` for `Parser::Name` based
   // nodes (example `Parser::ExitStmt`)
   void CheckNoBranching(const parser::Block &block, D directive,
       const parser::CharBlock &directiveSource);
 
   // Check that only clauses in set are after the specific clauses.
   void CheckOnlyAllowedAfter(C clause, common::EnumSet<C, ClauseEnumSize> set);
 
-  void CheckRequireAtLeastOneOf();
+  void CheckRequireAtLeastOneOf(bool warnInsteadOfError = false);
 
   void CheckAllowed(C clause);
 
   void CheckAtLeastOneClause();
 
   void CheckNotAllowedIfClause(
       C clause, common::EnumSet<C, ClauseEnumSize> set);
 
DirectiveStructureChecker<D, C, PC, ClauseEnumSize>::ClauseSetToString(
   });
   return list;
 }
 
 // Check that at least one clause in the required set is present on the
 // directive.
 template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
 void DirectiveStructureChecker<D, C, PC,
-    ClauseEnumSize>::CheckRequireAtLeastOneOf() {
+    ClauseEnumSize>::CheckRequireAtLeastOneOf(bool warnInsteadOfError) {
   if (GetContext().requiredClauses.empty())
     return;
   for (auto cl : GetContext().actualClauses) {
     if (GetContext().requiredClauses.test(cl))
       return;
   }
   // No clause matched in the actual clauses list
+  if (warnInsteadOfError)
+    context_.Say(GetContext().directiveSource,
+        "At least one of %s clause should appear on the %s directive"_port_en_US,
+        ClauseSetToString(GetContext().requiredClauses),
+        ContextDirectiveAsFortran());
+  else
     context_.Say(GetContext().directiveSource,
         "At least one of %s clause must appear on the %s directive"_err_en_US,
         ClauseSetToString(GetContext().requiredClauses),
         ContextDirectiveAsFortran());
 }
 
 template <typename D, typename C, typename PC, std::size_t ClauseEnumSize>
 std::string DirectiveStructureChecker<D, C, PC,
     ClauseEnumSize>::ContextDirectiveAsFortran() {
   return parser::ToUpperCaseLetters(
       getDirectiveName(GetContext().directive).str());
 }

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

! CHECK: } attributes {defaultAttr = #acc<defaultvalue none>}
 
   !$acc data default(present)
   !$acc end data
 
 ! CHECK: acc.data {
 ! CHECK:   acc.terminator
 ! CHECK: } attributes {defaultAttr = #acc<defaultvalue present>}
 
+  !$acc data
+  !$acc end data
+! CHECK-NOT: acc.data
+
 end subroutine acc_data
 

flang/test/Semantics/OpenACC/acc-data.f90

program openacc_data_validity
 
   !ERROR: At most one IF clause can appear on the DATA directive
   !$acc data copy(i) if(.true.) if(.true.)
   !$acc end data
 
   !ERROR: At least one of COPYOUT, DELETE, DETACH clause must appear on the EXIT DATA directive
   !$acc exit data
 
-  !ERROR: At least one of ATTACH, COPY, COPYIN, COPYOUT, CREATE, DEFAULT, DEVICEPTR, NO_CREATE, PRESENT clause must appear on the DATA directive
+  !PORTABILITY: At least one of ATTACH, COPY, COPYIN, COPYOUT, CREATE, DEFAULT, DEVICEPTR, NO_CREATE, PRESENT clause should appear on the DATA directive
   !$acc data
   !$acc end data
 
   !$acc data copy(aa) if(.true.)
   !$acc end data
 
   !$acc data copy(aa) if(ifCondition)
   !$acc end data