[flang] Document and use intrinsic subroutine argument intents

[jeanPerier]

Summary

Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument
of intrinsic procedure calls.

• Adding a common::Intent field to the IntrinsicDummyArgument

in the intrinsic table.

• Propagating it to the DummyDataObject intent field so that it can

later be used in CheckExplicitDataArg semantic checks.

• Add related tests.
• Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime.

Note 1: The added intent field is useless for all intrinsic
functions since none of them have intent out/inout arguments (I think,
but did not thoroughly checked). Since the table is not that small, the
change leads in a ~10ko increase in intrinsics.cpp.o (RL mode, gcc 8.3).
Since we are talking a bout a 0.03% space increase and that I am not sure how true
it is that all intrinsic functions will always have intent in arguments,
I ruled that this was OK.

Note 2: For the C846 fix, I considered adding an "Intrinsic" attribute
to characteristics::Procedure Attr, it worked but then seemed like a
bad idea to me since we would think that we are in an intrinsic call
when calling bar in the program below since characteristic built from
an intrinsic name can be used for user procedure.

subroutine foo(bar)
  procedure(acos) bar
  y = bar(x)
end subroutine

[PeteSteinfeld]

All builds, tests, and looks good.

[klausler]

flang/include/flang/Evaluate/characteristics.h

236

Another possibility: implement a GetIntent(), then implement HasIntent() using GetIntent() or with comparisons.

flang/lib/Semantics/check-call.cpp

316

Are all ALLOCATABLE coarrays really acceptable as actual arguments to INTENT(OUT) intrinsic subroutine arguments?

[jeanPerier]

Change DummyArgument::HasIntent to DummyArgument::GetIntent.

[jeanPerier]

flang/include/flang/Evaluate/characteristics.h

236

Thanks, GetIntent is more flexible. I dropped HasIntent since it does not bring much on top of GetIntent for the use site in lowering.

flang/lib/Semantics/check-call.cpp

316

What I am sure of is that C846 does not apply to intrinsic procedure, and that is is clearly OK for some intrinsic subroutine to have ALLOCATBLE coarrays as actual argument of INTENT(OUT) intrinsic arguments.

What I am not sure of is that it is OK in all intrinsic subroutine. e.g.: is it OK for COUNT argument of SYSTEM_CLOCK to get a coarray allocatable argument ? I can't find a rule that prevents it given C846 clearly does not apply for SYSTEM_CLOCK and SYSTEM_CLOCK says nothing about coarray/coindexed arguments.

I can't find narrower sort of allocable coarrays that would always be forbidden in intrinsic subroutine INTENT(OUT) arguments. Maybe coindexed objects should always be banned from INTENT(OUT), but the problem seems orthogonal to allocatables, all INTENT(OUT) intrinsic argument specific that implicitly tells that coarray are ok (by restricting things on their coranks) bans coindexed objects, whether their base is allocatable or not. Even then, it seems left to each intrinsic to define this (since some are explicitly banning them).

My conclusion from this is that we cannot derive a generic rules about allocatable coarrays in INTENT(OUT) intrinsic subroutine argument that we could enforce here. However, we may want to strengthen case by case intrinsic checks in intrinsic.cpp. For instance its clear coindexed objects are not OK in move_alloc and we are not complaining about this (both before or after this patch).

Why I am sure it is OK for at least some intrinsics
C846 :

An INTENT (OUT) dummy argument of a nonintrinsic procedure shall not be an allocatable coarray or
have a subobject that is an allocatable coarray.

MOVE_ALLOC TO argument that is INTENT(OUT) clearly accepts allocatable coarray actual arguments (16.9.137):

TO be type compatible (7.3.2.3) with FROM and have the same rank and corank.
It shall be allocatable and shall not be a coindexed object.
It shall be polymorphic if FROM is polymorphic. It is an INTENT (OUT) argument.
Each nondeferred parameter of the declared type of TO shall have the same value as the corresponding parameter of the declared type of FROM.

Why I am not sure this is OK for all subroutines
I can't find something that clearly forbids it, but I agree it's weird to allow it in all intrinsic subroutines.

Regrading the actual <-> dummy association rules, they are rules that prevents allocatable coindexed objects to be passed to intent(out)/intent(intout), but nothing regarding coarrays arguments (My understanding is that coarray are not coindexed objects):

15.5.2.4 .6 If the actual argument is a coindexed object with an allocatable ultimate component, the dummy argument shall have the INTENT (IN) or the VALUE attribute.
15.5.2.6 If the actual argument is a coindexed object, the dummy argument shall have the INTENT (IN) attribute.

It looks like it's up to each intrinsic definition in the standard to rule what's allowed here. However, I feel like there may be gaps in the "old" subroutines that may not have been updated regarding coarrays. The atomic subroutine all specify that coindexed object are not OK for their STAT argument that is INTENT(OUT). However, no such restriction is given for the STATUS field of GET_COMMAND for instance. That sounds weird to me. I am surprised allocable coarrays are something we would want in SYSTEM_CLOCK arguments, supporting this would bring some implementation complexity here.

[klausler]

flang/lib/Semantics/check-call.cpp

316

Anything that can change the address of a coarray allocatable on an image implies synchronization, it's pretty heavyweight.

Can we allow INTENT(OUT) ALLOCATABLE coarrays only where they are explicitly allowed and necessary (MOVE_ALLOC) and disallow them otherwise?

[jeanPerier]

Only allow INTENT(OUT) allocatable coarrays in intrinsics where they are
explicitly allowed intstead of all intrinsics.

[jeanPerier]

flang/lib/Semantics/check-call.cpp

316

Sounds like a safer approach. I have modified the patch to only allow this in MOVE_ALLOC.

flang/include/flang/Evaluate/characteristics.h

struct DummyArgument {
   bool operator==(const DummyArgument &) const;
   bool operator!=(const DummyArgument &that) const { return !(*this == that); }
   static std::optional<DummyArgument> Characterize(
       const semantics::Symbol &, const IntrinsicProcTable &);
   static std::optional<DummyArgument> FromActual(
       std::string &&, const Expr<SomeType> &, FoldingContext &);
   bool IsOptional() const;
   void SetOptional(bool = true);
+  bool HasIntent(common::Intent) const;
+  void SetIntent(common::Intent);
   bool CanBePassedViaImplicitInterface() const;
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
   // name and pass are not characteristics and so does not participate in
   // operator== but are needed to determine if procedures are distinguishable
   std::string name;
   bool pass{false}; // is this the PASS argument of its procedure
   std::variant<DummyDataObject, DummyProcedure, AlternateReturn> u;
 };

flang/lib/Evaluate/characteristics.cpp

std::visit(common::visitors{
                  [value](DummyProcedure &proc) {
                    proc.attrs.set(DummyProcedure::Attr::Optional, value);
                  },
                  [](AlternateReturn &) { DIE("cannot set optional"); },
              },
       u);
 }
 
+void DummyArgument::SetIntent(common::Intent intent) {
+  std::visit(common::visitors{
+                 [intent](DummyDataObject &data) { data.intent = intent; },
+                 [intent](DummyProcedure &proc) { proc.intent = intent; },
+                 [](AlternateReturn &) { DIE("cannot set intent"); },
+             },
+      u);
+}
+
+bool DummyArgument::HasIntent(common::Intent intent) const {
+  return std::visit(common::visitors{
+                        [intent](const DummyDataObject &data) {
+                          return data.intent == intent;
+                        },
+                        [intent](const DummyProcedure &proc) {
+                          return proc.intent == intent;
+                        },
+                        [](const AlternateReturn &) { return false; },
+                    },
+      u);
+}
+
 bool DummyArgument::CanBePassedViaImplicitInterface() const {
   if (const auto *object{std::get_if<DummyDataObject>(&u)}) {
     return object->CanBePassedViaImplicitInterface();
   } else {
     return true;
   }
 }
 

flang/lib/Evaluate/intrinsics.cpp

ENUM_CLASS(Optionality, required, optional,
     repeats, // for MAX/MIN and their several variants
 )
 
 struct IntrinsicDummyArgument {
   const char *keyword{nullptr};
   TypePattern typePattern;
   Rank rank{Rank::elemental};
   Optionality optionality{Optionality::required};
+  common::Intent intent{common::Intent::In};
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 };
 
 // constexpr abbreviations for popular arguments:
 // DefaultingKIND is a KIND= argument whose default value is the appropriate
 // KIND(0), KIND(0.0), KIND(''), &c. value for the function result.
 static constexpr IntrinsicDummyArgument DefaultingKIND{"kind",
     {IntType, KindCode::kindArg}, Rank::scalar,
static const SpecificIntrinsicInterface specificIntrinsicFunction[]{
     {{"sinh", {{"x", DefaultReal}}, DefaultReal}},
     {{"sngl", {{"a", AnyReal}}, DefaultReal}, "real", true},
     {{"sqrt", {{"x", DefaultReal}}, DefaultReal}},
     {{"tan", {{"x", DefaultReal}}, DefaultReal}},
     {{"tanh", {{"x", DefaultReal}}, DefaultReal}},
 };
 
 static const IntrinsicInterface intrinsicSubroutine[]{
-    {"cpu_time", {{"time", AnyReal, Rank::scalar}}, {}, Rank::elemental,
-        IntrinsicClass::impureSubroutine},
+    {"cpu_time",
+        {{"time", AnyReal, Rank::scalar, Optionality::required,
+            common::Intent::Out}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"date_and_time",
-        {{"date", DefaultChar, Rank::scalar, Optionality::optional},
-            {"time", DefaultChar, Rank::scalar, Optionality::optional},
-            {"zone", DefaultChar, Rank::scalar, Optionality::optional},
-            {"values", AnyInt, Rank::vector, Optionality::optional}},
+        {{"date", DefaultChar, Rank::scalar, Optionality::optional,
+             common::Intent::Out},
+            {"time", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"zone", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"values", AnyInt, Rank::vector, Optionality::optional,
+                common::Intent::Out}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"execute_command_line",
         {{"command", DefaultChar, Rank::scalar},
             {"wait", AnyLogical, Rank::scalar, Optionality::optional},
-            {"exitstat", AnyInt, Rank::scalar, Optionality::optional},
-            {"cmdstat", AnyInt, Rank::scalar, Optionality::optional},
-            {"cmdmsg", DefaultChar, Rank::scalar, Optionality::optional}},
+            {"exitstat", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::InOut},
+            {"cmdstat", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"cmdmsg", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::InOut}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"get_command",
-        {{"command", DefaultChar, Rank::scalar, Optionality::optional},
-            {"length", AnyInt, Rank::scalar, Optionality::optional},
-            {"status", AnyInt, Rank::scalar, Optionality::optional},
-            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
+        {{"command", DefaultChar, Rank::scalar, Optionality::optional,
+             common::Intent::Out},
+            {"length", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"status", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::InOut}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"get_command_argument",
         {{"number", AnyInt, Rank::scalar},
-            {"value", DefaultChar, Rank::scalar, Optionality::optional},
-            {"length", AnyInt, Rank::scalar, Optionality::optional},
-            {"status", AnyInt, Rank::scalar, Optionality::optional},
-            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
+            {"value", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"length", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"status", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::InOut}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"get_environment_variable",
         {{"name", DefaultChar, Rank::scalar},
-            {"value", DefaultChar, Rank::scalar, Optionality::optional},
-            {"length", AnyInt, Rank::scalar, Optionality::optional},
-            {"status", AnyInt, Rank::scalar, Optionality::optional},
+            {"value", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"length", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"status", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
             {"trim_name", AnyLogical, Rank::scalar, Optionality::optional},
-            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
+            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::InOut}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"move_alloc",
-        {{"from", SameType, Rank::known}, {"to", SameType, Rank::known},
-            {"stat", AnyInt, Rank::scalar, Optionality::optional},
-            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
+        {{"from", SameType, Rank::known, Optionality::required,
+             common::Intent::InOut},
+            {"to", SameType, Rank::known, Optionality::required,
+                common::Intent::Out},
+            {"stat", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
+                common::Intent::InOut}},
         {}, Rank::elemental, IntrinsicClass::pureSubroutine},
     {"mvbits",
         {{"from", SameInt}, {"frompos", AnyInt}, {"len", AnyInt},
-            {"to", SameInt}, {"topos", AnyInt}},
+            {"to", SameInt, Rank::elemental, Optionality::required,
+                common::Intent::Out},
+            {"topos", AnyInt}},
         {}, Rank::elemental, IntrinsicClass::elementalSubroutine}, // elemental
     {"random_init",
         {{"repeatable", AnyLogical, Rank::scalar},
             {"image_distinct", AnyLogical, Rank::scalar}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
-    {"random_number", {{"harvest", AnyReal, Rank::known}}, {}, Rank::elemental,
-        IntrinsicClass::impureSubroutine},
+    {"random_number",
+        {{"harvest", AnyReal, Rank::known, Optionality::required,
+            common::Intent::Out}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"random_seed",
-        {{"size", DefaultInt, Rank::scalar, Optionality::optional},
+        {{"size", DefaultInt, Rank::scalar, Optionality::optional,
+             common::Intent::Out},
             {"put", DefaultInt, Rank::vector, Optionality::optional},
-            {"get", DefaultInt, Rank::vector, Optionality::optional}},
+            {"get", DefaultInt, Rank::vector, Optionality::optional,
+                common::Intent::Out}},
         {}, Rank::elemental,
         IntrinsicClass::impureSubroutine}, // TODO: at most one argument can be
                                            // present
     {"system_clock",
-        {{"count", AnyInt, Rank::scalar, Optionality::optional},
-            {"count_rate", AnyIntOrReal, Rank::scalar, Optionality::optional},
-            {"count_max", AnyInt, Rank::scalar, Optionality::optional}},
+        {{"count", AnyInt, Rank::scalar, Optionality::optional,
+             common::Intent::Out},
+            {"count_rate", AnyIntOrReal, Rank::scalar, Optionality::optional,
+                common::Intent::Out},
+            {"count_max", AnyInt, Rank::scalar, Optionality::optional,
+                common::Intent::Out}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
 };
 
 // TODO: Intrinsic subroutine EVENT_QUERY
 // TODO: Atomic intrinsic subroutines: ATOMIC_ADD &al.
 // TODO: Collective intrinsic subroutines: CO_BROADCAST &al.
 
 // Intrinsic interface matching against the arguments of a particular
if (const auto &arg{rearranged[j]}) {
         auto category{d.typePattern.categorySet.LeastElement().value()};
         characteristics::TypeAndShape typeAndShape{
             DynamicType{category, defaults.GetDefaultKind(category)}};
         dummyArgs.emplace_back(std::string{d.keyword},
             characteristics::DummyDataObject{std::move(typeAndShape)});
       }
       dummyArgs.back().SetOptional();
     }
+    dummyArgs.back().SetIntent(d.intent);
   }
   characteristics::Procedure::Attrs attrs;
   if (elementalRank > 0) {
     attrs.set(characteristics::Procedure::Attr::Elemental);
   }
   if (call.isSubroutineCall) {
     return SpecificCall{
         SpecificIntrinsic{
if (specific.generic) {
       genericName = std::string(specific.generic);
     }
     characteristics::FunctionResult fResult{GetSpecificType(specific.result)};
     characteristics::DummyArguments args;
     int dummies{specific.CountArguments()};
     for (int j{0}; j < dummies; ++j) {
       characteristics::DummyDataObject dummy{
           GetSpecificType(specific.dummy[j].typePattern)};
-      dummy.intent = common::Intent::In;
+      dummy.intent = specific.dummy[j].intent;
       args.emplace_back(
           std::string{specific.dummy[j].keyword}, std::move(dummy));
     }
     characteristics::Procedure::Attrs attrs;
     attrs.set(characteristics::Procedure::Attr::Pure)
         .set(characteristics::Procedure::Attr::Elemental);
     characteristics::Procedure chars{
         std::move(fResult), std::move(args), attrs};
llvm::raw_ostream &TypePattern::Dump(llvm::raw_ostream &o) const {
   return o;
 }
 
 llvm::raw_ostream &IntrinsicDummyArgument::Dump(llvm::raw_ostream &o) const {
   if (keyword) {
     o << keyword << '=';
   }
   return typePattern.Dump(o)
-      << ' ' << EnumToString(rank) << ' ' << EnumToString(optionality);
+      << ' ' << EnumToString(rank) << ' ' << EnumToString(optionality)
+      << EnumToString(intent);
 }
 
 llvm::raw_ostream &IntrinsicInterface::Dump(llvm::raw_ostream &o) const {
   o << name;
   char sep{'('};
   for (const auto &d : dummy) {
     if (d.typePattern.kindCode == KindCode::none) {
       break;

flang/lib/Semantics/check-call.h

 }
 namespace Fortran::evaluate {
 class FoldingContext;
 }
 
 namespace Fortran::semantics {
 class Scope;
 
-// The Boolean flag argument should be true when the called procedure
+// Argument treatingExternalAsImplicit should be true when the called procedure
 // does not actually have an explicit interface at the call site, but
 // its characteristics are known because it is a subroutine or function
 // defined at the top level in the same source file.
 void CheckArguments(const evaluate::characteristics::Procedure &,
     evaluate::ActualArguments &, evaluate::FoldingContext &, const Scope &,
-    bool treatingExternalAsImplicit = false);
+    bool treatingExternalAsImplicit, bool isIntrinsicCall);
 
 // Checks actual arguments against a procedure with an explicit interface.
 // Reports a buffer of errors when not compatible.
 parser::Messages CheckExplicitInterface(
     const evaluate::characteristics::Procedure &, evaluate::ActualArguments &,
-    const evaluate::FoldingContext &, const Scope &);
+    const evaluate::FoldingContext &, const Scope &, bool isIntrinsicCall);
 
 // Checks actual arguments for the purpose of resolving a generic interface.
 bool CheckInterfaceForGeneric(const evaluate::characteristics::Procedure &,
     evaluate::ActualArguments &, const evaluate::FoldingContext &);
 } // namespace Fortran::semantics
 #endif

flang/lib/Semantics/check-call.cpp

for (const auto &pair : actual.parameters()) {
     }
   }
   return true;
 }
 
 static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
     const std::string &dummyName, evaluate::Expr<evaluate::SomeType> &actual,
     characteristics::TypeAndShape &actualType, bool isElemental,
-    bool actualIsArrayElement, evaluate::FoldingContext &context,
-    const Scope *scope) {
+    bool actualIsArrayElement, bool isIntrinsicCall,
+    evaluate::FoldingContext &context, const Scope *scope) {
 
   // Basic type & rank checking
   parser::ContextualMessages &messages{context.messages()};
   PadShortCharacterActual(actual, dummy.type, actualType, context, messages);
   ConvertIntegerActual(actual, dummy.type, actualType, messages);
   bool typesCompatible{dummy.type.type().IsTkCompatibleWith(actualType.type())};
   if (typesCompatible) {
     if (isElemental) {
if (actualIsPointer) {
           dummyName);
     }
     if (actualLastObject && actualLastObject->IsAssumedShape()) {
       messages.Say(
           "Element of assumed-shape array may not be associated with a %s array"_err_en_US,
           dummyName);
     }
   }
-  if (actualLastObject && actualLastObject->IsCoarray() &&
+  if (!isIntrinsicCall && actualLastObject && actualLastObject->IsCoarray() &&
       IsAllocatable(*actualLastSymbol) &&
       dummy.intent == common::Intent::Out) { // C846
     messages.Say(
         "ALLOCATABLE coarray '%s' may not be associated with INTENT(OUT) %s"_err_en_US,
         actualLastSymbol->name(), dummyName);
   }
 
   // Definability
messages.Say(
         "Assumed-type argument may not be forwarded as procedure %s"_err_en_US,
         dummyName);
   }
 }
 
 static void CheckExplicitInterfaceArg(evaluate::ActualArgument &arg,
     const characteristics::DummyArgument &dummy,
     const characteristics::Procedure &proc, evaluate::FoldingContext &context,
-    const Scope *scope) {
+    const Scope *scope, bool isIntrinsicCall) {
   auto &messages{context.messages()};
   std::string dummyName{"dummy argument"};
   if (!dummy.name.empty()) {
     dummyName += " '"s + parser::ToLowerCaseLetters(dummy.name) + "='";
   }
   std::visit(
       common::visitors{
           [&](const characteristics::DummyDataObject &object) {
             if (auto *expr{arg.UnwrapExpr()}) {
               if (auto type{characteristics::TypeAndShape::Characterize(
                       *expr, context)}) {
                 arg.set_dummyIntent(object.intent);
                 bool isElemental{object.type.Rank() == 0 && proc.IsElemental()};
                 CheckExplicitDataArg(object, dummyName, *expr, *type,
-                    isElemental, IsArrayElement(*expr), context, scope);
+                    isElemental, IsArrayElement(*expr), isIntrinsicCall,
+                    context, scope);
               } else if (object.type.type().IsTypelessIntrinsicArgument() &&
                   std::holds_alternative<evaluate::BOZLiteralConstant>(
                       expr->u)) {
                 // ok
               } else {
                 messages.Say(
                     "Actual argument '%s' associated with %s is not a variable or typed expression"_err_en_US,
                     expr->AsFortran(), dummyName);
for (auto &bad : kwArgs) {
           "Argument keyword '%s=' is not recognized for this procedure reference"_err_en_US,
           *x.keyword());
     }
   }
 }
 
 static parser::Messages CheckExplicitInterface(
     const characteristics::Procedure &proc, evaluate::ActualArguments &actuals,
-    const evaluate::FoldingContext &context, const Scope *scope) {
+    const evaluate::FoldingContext &context, const Scope *scope,
+    bool isIntrinsicCall) {
   parser::Messages buffer;
   parser::ContextualMessages messages{context.messages().at(), &buffer};
   RearrangeArguments(proc, actuals, messages);
   if (buffer.empty()) {
     int index{0};
     evaluate::FoldingContext localContext{context, messages};
     for (auto &actual : actuals) {
       const auto &dummy{proc.dummyArguments.at(index++)};
       if (actual) {
-        CheckExplicitInterfaceArg(*actual, dummy, proc, localContext, scope);
+        CheckExplicitInterfaceArg(
+            *actual, dummy, proc, localContext, scope, isIntrinsicCall);
       } else if (!dummy.IsOptional()) {
         if (dummy.name.empty()) {
           messages.Say(
               "Dummy argument #%d is not OPTIONAL and is not associated with "
               "an actual argument in this procedure reference"_err_en_US,
               index);
         } else {
           messages.Say("Dummy argument '%s=' (#%d) is not OPTIONAL and is not "
                        "associated with an actual argument in this procedure "
                        "reference"_err_en_US,
               dummy.name, index);
         }
       }
     }
   }
   return buffer;
 }
 
 parser::Messages CheckExplicitInterface(const characteristics::Procedure &proc,
     evaluate::ActualArguments &actuals, const evaluate::FoldingContext &context,
-    const Scope &scope) {
-  return CheckExplicitInterface(proc, actuals, context, &scope);
+    const Scope &scope, bool isIntrinsicCall) {
+  return CheckExplicitInterface(
+      proc, actuals, context, &scope, isIntrinsicCall);
 }
 
 bool CheckInterfaceForGeneric(const characteristics::Procedure &proc,
     evaluate::ActualArguments &actuals,
     const evaluate::FoldingContext &context) {
-  return CheckExplicitInterface(proc, actuals, context, nullptr).empty();
+  return CheckExplicitInterface(
+      proc, actuals, context, nullptr, false /* isIntrinsicCall */)
+      .empty();
 }
 
 void CheckArguments(const characteristics::Procedure &proc,
     evaluate::ActualArguments &actuals, evaluate::FoldingContext &context,
-    const Scope &scope, bool treatingExternalAsImplicit) {
+    const Scope &scope, bool treatingExternalAsImplicit, bool isIntrinsicCall) {
   bool explicitInterface{proc.HasExplicitInterface()};
   if (explicitInterface) {
-    auto buffer{CheckExplicitInterface(proc, actuals, context, scope)};
+    auto buffer{
+        CheckExplicitInterface(proc, actuals, context, scope, isIntrinsicCall)};
     if (treatingExternalAsImplicit && !buffer.empty()) {
       if (auto *msg{context.messages().Say(
               "Warning: if the procedure's interface were explicit, this reference would be in error:"_en_US)}) {
         buffer.AttachTo(*msg);
       }
     }
     if (auto *msgs{context.messages().messages()}) {
       msgs->Merge(std::move(buffer));

flang/lib/Semantics/expression.cpp

auto chars{
       characteristics::Procedure::Characterize(proc, context_.intrinsics())};
   if (chars) {
     bool treatExternalAsImplicit{IsExternalCalledImplicitly(callSite, proc)};
     if (treatExternalAsImplicit && !chars->CanBeCalledViaImplicitInterface()) {
       Say(callSite,
           "References to the procedure '%s' require an explicit interface"_en_US,
           DEREF(proc.GetSymbol()).name());
     }
+    bool isIntrinsicCall{proc.GetSpecificIntrinsic() != nullptr};
     semantics::CheckArguments(*chars, arguments, GetFoldingContext(),
-        context_.FindScope(callSite), treatExternalAsImplicit);
+        context_.FindScope(callSite), treatExternalAsImplicit, isIntrinsicCall);
     const Symbol *procSymbol{proc.GetSymbol()};
     if (procSymbol && !IsPureProcedure(*procSymbol)) {
       if (const semantics::Scope *
           pure{semantics::FindPureProcedureContaining(
               context_.FindScope(callSite))}) {
         Say(callSite,
             "Procedure '%s' referenced in pure subprogram '%s' must be pure too"_err_en_US,
             procSymbol->name(), DEREF(pure->symbol()).name());

flang/test/Semantics/call03.f90

subroutine test11(in) ! C15.5.2.4(20)
     call intentout(in)
     !ERROR: Actual argument associated with INTENT(OUT) dummy argument 'x=' must be definable
     call intentout(3.14159)
     !ERROR: Actual argument associated with INTENT(OUT) dummy argument 'x=' must be definable
     call intentout(in + 1.)
     call intentout(x) ! ok
     !ERROR: Actual argument associated with INTENT(OUT) dummy argument 'x=' must be definable
     call intentout((x))
+    !ERROR: Actual argument associated with INTENT(OUT) dummy argument 'count=' must be definable
+    call system_clock(count=2)
     !ERROR: Actual argument associated with INTENT(IN OUT) dummy argument 'x=' must be definable
     call intentinout(in)
     !ERROR: Actual argument associated with INTENT(IN OUT) dummy argument 'x=' must be definable
     call intentinout(3.14159)
     !ERROR: Actual argument associated with INTENT(IN OUT) dummy argument 'x=' must be definable
     call intentinout(in + 1.)
     call intentinout(x) ! ok
     !ERROR: Actual argument associated with INTENT(IN OUT) dummy argument 'x=' must be definable
     call intentinout((x))
+    !ERROR: Actual argument associated with INTENT(IN OUT) dummy argument 'exitstat=' must be definable
+    call execute_command_line(command="echo hello", exitstat=0)
   end subroutine
 
   subroutine test12 ! 15.5.2.4(21)
     real :: a(1)
     integer :: j(1)
     j(1) = 1
     !ERROR: Actual argument associated with INTENT(OUT) dummy argument 'x=' must be definable
     call intentout(a(j))