[flang] Add two semantic checks about BIND(C) attribute

[peixin]

Summary

As Fortran 2018 C1546, an elemental procedure shall not have the BIND
attribute.

As 18.3.6, it does not mention that an array with VALUE can be
interoperable. It is not reasonable to pass an array by value when the
array is too large. Forbid it to be consistent with gfortran/ifort.

[jeanPerier]

LGTM, thanks

flang/lib/Lower/CallInterface.cpp

if (obj.attrs.test(Attrs::Allocatable) || obj.attrs.test(Attrs::Pointer)) {
       Property prop = Property::BaseAddress;
       if (isValueAttr) {
         if (isBindC || (!type.isa<fir::SequenceType>() &&
                         !obj.attrs.test(Attrs::Optional) &&
                         dynamicType.category() !=
                             Fortran::common::TypeCategory::Derived)) {
           passBy = PassEntityBy::Value;
           prop = Property::Value;
-          if (type.isa<fir::SequenceType>())
-            fir::emitFatalError(
-                loc, "array with VALUE attribute is not interoperable");
           if (fir::isa_builtin_cptr_type(type)) {
             auto recTy = type.dyn_cast<fir::RecordType>();
             mlir::Type fieldTy = recTy.getTypeList()[0].second;
             passType = fir::ReferenceType::get(fieldTy);
           } else {
             passType = type;
           }
         } else {

flang/lib/Semantics/check-declarations.cpp

messages_.Say(
         "VALUE attribute may not apply to an INTENT(IN OUT) argument"_err_en_US);
   } else if (IsIntentOut(symbol)) {
     messages_.Say(
         "VALUE attribute may not apply to an INTENT(OUT) argument"_err_en_US);
   }
   if (symbol.attrs().test(Attr::VOLATILE)) {
     messages_.Say("VALUE attribute may not apply to a VOLATILE"_err_en_US);
   }
-  if (innermostSymbol_ && IsBindCProcedure(*innermostSymbol_) &&
-      IsOptional(symbol)) {
+  if (innermostSymbol_ && IsBindCProcedure(*innermostSymbol_)) {
+    if (IsOptional(symbol)) {
       messages_.Say(
           "VALUE attribute may not apply to an OPTIONAL in a BIND(C) procedure"_err_en_US);
     }
+    if (symbol.Rank() > 0) {
+      messages_.Say(
+          "VALUE attribute may not apply to an array in a BIND(C) procedure"_err_en_US);
+    }
+  }
   if (derived) {
     if (FindCoarrayUltimateComponent(*derived)) {
       messages_.Say(
           "VALUE attribute may not apply to a type with a coarray ultimate component"_err_en_US);
     }
   }
 }
 
static const std::string *DefinesBindCName(const Symbol &symbol) {
   }
 }
 
 void CheckHelper::CheckBindC(const Symbol &symbol) {
   if (!symbol.attrs().test(Attr::BIND_C)) {
     return;
   }
   CheckConflicting(symbol, Attr::BIND_C, Attr::PARAMETER);
+  CheckConflicting(symbol, Attr::BIND_C, Attr::ELEMENTAL);
   if (symbol.has<ObjectEntityDetails>() && !symbol.owner().IsModule()) {
     messages_.Say(symbol.name(),
         "A variable with BIND(C) attribute may only appear in the specification part of a module"_err_en_US);
     context_.SetError(symbol);
   }
   if (const std::string * name{DefinesBindCName(symbol)}) {
     auto pair{bindC_.emplace(*name, symbol)};
     if (!pair.second) {

flang/test/Semantics/bind-c08.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+! Check for C1546 and 18.3.6
+
+! ERROR: 'test1' may not have both the BIND(C) and ELEMENTAL attributes
+elemental subroutine test1() bind(c)
+end
+
+subroutine test3(x) bind(c)
+  ! ERROR: VALUE attribute may not apply to an array in a BIND(C) procedure
+  integer, value :: x(100)
+end