[flang-commits] [flang] f31ac3c - [flang] Handle implied ASYNCHRONOUS attribute (#82638)
via flang-commits
flang-commits at lists.llvm.org
Fri Mar 1 14:43:35 PST 2024
Author: Peter Klausler
Date: 2024-03-01T14:43:31-08:00
New Revision: f31ac3cb1ff7958fadf6e3e431790f2d668583b4
URL: https://github.com/llvm/llvm-project/commit/f31ac3cb1ff7958fadf6e3e431790f2d668583b4
DIFF: https://github.com/llvm/llvm-project/commit/f31ac3cb1ff7958fadf6e3e431790f2d668583b4.diff
LOG: [flang] Handle implied ASYNCHRONOUS attribute (#82638)
The standard states that data objects involved in an asynchronous data
transfer statement gain the ASYNCHRONOUS attribute implicitly in the
surrounding subprogram or BLOCK scope. This attribute affects the checks
in call semantics, as an ASYNCHRONOUS actual object associated with an
ASYNCHRONOUS dummy argument must not require data copies in or out.
(Most compilers don't implement implied ASYNCHRONOUS attributes
correctly; XLF gets these right, and GNU is close.)
Added:
Modified:
flang/docs/Extensions.md
flang/include/flang/Parser/parse-tree.h
flang/lib/Evaluate/characteristics.cpp
flang/lib/Semantics/check-call.cpp
flang/lib/Semantics/resolve-names.cpp
flang/test/Semantics/call03.f90
Removed:
################################################################################
diff --git a/flang/docs/Extensions.md b/flang/docs/Extensions.md
index 46ef8f07b4a8b3..4bd93f6b6d0f2f 100644
--- a/flang/docs/Extensions.md
+++ b/flang/docs/Extensions.md
@@ -481,6 +481,11 @@ end
* Many compilers disallow a `VALUE` assumed-length character dummy
argument, which has been standard since F'2008.
We accept this usage with an optional portability warning.
+* The `ASYNCHRONOUS` attribute can be implied by usage in data
+ transfer I/O statements. Only one other compiler supports this
+ correctly. This compiler does, apart from objects in asynchronous
+ NAMELIST I/O, for which an actual asynchronous runtime implementation
+ seems unlikely.
## Behavior in cases where the standard is ambiguous or indefinite
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index a32676be0d6d97..f7b72c3af09164 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -551,7 +551,9 @@ struct ExecutionPartConstruct {
};
// R509 execution-part -> executable-construct [execution-part-construct]...
-WRAPPER_CLASS(ExecutionPart, std::list<ExecutionPartConstruct>);
+// R1101 block -> [execution-part-construct]...
+using Block = std::list<ExecutionPartConstruct>;
+WRAPPER_CLASS(ExecutionPart, Block);
// R502 program-unit ->
// main-program | external-subprogram | module | submodule | block-data
@@ -2115,9 +2117,6 @@ struct ForallConstruct {
t;
};
-// R1101 block -> [execution-part-construct]...
-using Block = std::list<ExecutionPartConstruct>;
-
// R1105 selector -> expr | variable
struct Selector {
UNION_CLASS_BOILERPLATE(Selector);
diff --git a/flang/lib/Evaluate/characteristics.cpp b/flang/lib/Evaluate/characteristics.cpp
index 80b0f346c32d38..5ec9f757b68173 100644
--- a/flang/lib/Evaluate/characteristics.cpp
+++ b/flang/lib/Evaluate/characteristics.cpp
@@ -25,6 +25,7 @@ using namespace Fortran::parser::literals;
namespace Fortran::evaluate::characteristics {
// Copy attributes from a symbol to dst based on the mapping in pairs.
+// An ASYNCHRONOUS attribute counts even if it is implied.
template <typename A, typename B>
static void CopyAttrs(const semantics::Symbol &src, A &dst,
const std::initializer_list<std::pair<semantics::Attr, B>> &pairs) {
diff --git a/flang/lib/Semantics/check-call.cpp b/flang/lib/Semantics/check-call.cpp
index fdf7805beab7ed..cd9150bdda4bd3 100644
--- a/flang/lib/Semantics/check-call.cpp
+++ b/flang/lib/Semantics/check-call.cpp
@@ -674,7 +674,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
!(dummyIsAssumedShape || dummyIsAssumedRank ||
(actualIsPointer && dummyIsPointer))) { // C1539 & C1540
messages.Say(
- "ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous %s"_err_en_US,
+ "ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE %s"_err_en_US,
dummyName);
}
}
diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index 7b40e2bbc53328..7de513d8769aed 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -1225,8 +1225,7 @@ class ConstructVisitor : public virtual DeclarationVisitor {
void Post(const parser::ForallConstruct &);
bool Pre(const parser::ForallStmt &);
void Post(const parser::ForallStmt &);
- bool Pre(const parser::BlockStmt &);
- bool Pre(const parser::EndBlockStmt &);
+ bool Pre(const parser::BlockConstruct &);
void Post(const parser::Selector &);
void Post(const parser::AssociateStmt &);
void Post(const parser::EndAssociateStmt &);
@@ -1283,6 +1282,8 @@ class ConstructVisitor : public virtual DeclarationVisitor {
void Post(const parser::CycleStmt &x) { CheckRef(x.v); }
void Post(const parser::ExitStmt &x) { CheckRef(x.v); }
+ void HandleImpliedAsynchronousInScope(const parser::Block &);
+
private:
// R1105 selector -> expr | variable
// expr is set in either case unless there were errors
@@ -6957,14 +6958,17 @@ bool ConstructVisitor::Pre(const parser::ForallStmt &) {
}
void ConstructVisitor::Post(const parser::ForallStmt &) { PopScope(); }
-bool ConstructVisitor::Pre(const parser::BlockStmt &x) {
- CheckDef(x.v);
+bool ConstructVisitor::Pre(const parser::BlockConstruct &x) {
+ const auto &[blockStmt, specPart, execPart, endBlockStmt] = x.t;
+ Walk(blockStmt);
+ CheckDef(blockStmt.statement.v);
PushScope(Scope::Kind::BlockConstruct, nullptr);
- return false;
-}
-bool ConstructVisitor::Pre(const parser::EndBlockStmt &x) {
+ Walk(specPart);
+ HandleImpliedAsynchronousInScope(execPart);
+ Walk(execPart);
+ Walk(endBlockStmt);
PopScope();
- CheckRef(x.v);
+ CheckRef(endBlockStmt.statement.v);
return false;
}
@@ -7338,6 +7342,224 @@ const DeclTypeSpec &ConstructVisitor::ToDeclTypeSpec(
}
}
+class ExecutionPartSkimmerBase {
+public:
+ template <typename A> bool Pre(const A &) { return true; }
+ template <typename A> void Post(const A &) {}
+
+ bool InNestedBlockConstruct() const { return blockDepth_ > 0; }
+
+ bool Pre(const parser::AssociateConstruct &) {
+ PushScope();
+ return true;
+ }
+ void Post(const parser::AssociateConstruct &) { PopScope(); }
+ bool Pre(const parser::Association &x) {
+ Hide(std::get<parser::Name>(x.t));
+ return true;
+ }
+ bool Pre(const parser::BlockConstruct &) {
+ PushScope();
+ ++blockDepth_;
+ return true;
+ }
+ void Post(const parser::BlockConstruct &) {
+ --blockDepth_;
+ PopScope();
+ }
+ bool Pre(const parser::EntityDecl &x) {
+ Hide(std::get<parser::ObjectName>(x.t));
+ return true;
+ }
+ void Post(const parser::ImportStmt &x) {
+ if (x.kind == common::ImportKind::None ||
+ x.kind == common::ImportKind::Only) {
+ if (!nestedScopes_.front().importOnly.has_value()) {
+ nestedScopes_.front().importOnly.emplace();
+ }
+ for (const auto &name : x.names) {
+ nestedScopes_.front().importOnly->emplace(name.source);
+ }
+ } else {
+ // no special handling needed for explicit names or IMPORT, ALL
+ }
+ }
+ void Post(const parser::UseStmt &x) {
+ if (const auto *onlyList{std::get_if<std::list<parser::Only>>(&x.u)}) {
+ for (const auto &only : *onlyList) {
+ if (const auto *name{std::get_if<parser::Name>(&only.u)}) {
+ Hide(*name);
+ } else if (const auto *rename{std::get_if<parser::Rename>(&only.u)}) {
+ if (const auto *names{
+ std::get_if<parser::Rename::Names>(&rename->u)}) {
+ Hide(std::get<0>(names->t));
+ }
+ }
+ }
+ } else {
+ // USE may or may not shadow symbols in host scopes
+ nestedScopes_.front().hasUseWithoutOnly = true;
+ }
+ }
+ bool Pre(const parser::DerivedTypeStmt &x) {
+ Hide(std::get<parser::Name>(x.t));
+ PushScope();
+ return true;
+ }
+ void Post(const parser::DerivedTypeDef &) { PopScope(); }
+ bool Pre(const parser::SelectTypeConstruct &) {
+ PushScope();
+ return true;
+ }
+ void Post(const parser::SelectTypeConstruct &) { PopScope(); }
+ bool Pre(const parser::SelectTypeStmt &x) {
+ if (const auto &maybeName{std::get<1>(x.t)}) {
+ Hide(*maybeName);
+ }
+ return true;
+ }
+ bool Pre(const parser::SelectRankConstruct &) {
+ PushScope();
+ return true;
+ }
+ void Post(const parser::SelectRankConstruct &) { PopScope(); }
+ bool Pre(const parser::SelectRankStmt &x) {
+ if (const auto &maybeName{std::get<1>(x.t)}) {
+ Hide(*maybeName);
+ }
+ return true;
+ }
+
+protected:
+ bool IsHidden(SourceName name) {
+ for (const auto &scope : nestedScopes_) {
+ if (scope.locals.find(name) != scope.locals.end()) {
+ return true; // shadowed by nested declaration
+ }
+ if (scope.hasUseWithoutOnly) {
+ break;
+ }
+ if (scope.importOnly &&
+ scope.importOnly->find(name) == scope.importOnly->end()) {
+ return true; // not imported
+ }
+ }
+ return false;
+ }
+
+ void EndWalk() { CHECK(nestedScopes_.empty()); }
+
+private:
+ void PushScope() { nestedScopes_.emplace_front(); }
+ void PopScope() { nestedScopes_.pop_front(); }
+ void Hide(const parser::Name &name) {
+ nestedScopes_.front().locals.emplace(name.source);
+ }
+
+ int blockDepth_{0};
+ struct NestedScopeInfo {
+ bool hasUseWithoutOnly{false};
+ std::set<SourceName> locals;
+ std::optional<std::set<SourceName>> importOnly;
+ };
+ std::list<NestedScopeInfo> nestedScopes_;
+};
+
+class ExecutionPartAsyncIOSkimmer : public ExecutionPartSkimmerBase {
+public:
+ explicit ExecutionPartAsyncIOSkimmer(SemanticsContext &context)
+ : context_{context} {}
+
+ void Walk(const parser::Block &block) {
+ parser::Walk(block, *this);
+ EndWalk();
+ }
+
+ const std::set<SourceName> asyncIONames() const { return asyncIONames_; }
+
+ using ExecutionPartSkimmerBase::Post;
+ using ExecutionPartSkimmerBase::Pre;
+
+ bool Pre(const parser::IoControlSpec::Asynchronous &async) {
+ if (auto folded{evaluate::Fold(
+ context_.foldingContext(), AnalyzeExpr(context_, async.v))}) {
+ if (auto str{
+ evaluate::GetScalarConstantValue<evaluate::Ascii>(*folded)}) {
+ for (char ch : *str) {
+ if (ch != ' ') {
+ inAsyncIO_ = ch == 'y' || ch == 'Y';
+ break;
+ }
+ }
+ }
+ }
+ return true;
+ }
+ void Post(const parser::ReadStmt &) { inAsyncIO_ = false; }
+ void Post(const parser::WriteStmt &) { inAsyncIO_ = false; }
+ void Post(const parser::IoControlSpec::Size &size) {
+ if (const auto *designator{
+ std::get_if<common::Indirection<parser::Designator>>(
+ &size.v.thing.thing.u)}) {
+ NoteAsyncIODesignator(designator->value());
+ }
+ }
+ void Post(const parser::InputItem &x) {
+ if (const auto *var{std::get_if<parser::Variable>(&x.u)}) {
+ if (const auto *designator{
+ std::get_if<common::Indirection<parser::Designator>>(&var->u)}) {
+ NoteAsyncIODesignator(designator->value());
+ }
+ }
+ }
+ void Post(const parser::OutputItem &x) {
+ if (const auto *expr{std::get_if<parser::Expr>(&x.u)}) {
+ if (const auto *designator{
+ std::get_if<common::Indirection<parser::Designator>>(&expr->u)}) {
+ NoteAsyncIODesignator(designator->value());
+ }
+ }
+ }
+
+private:
+ void NoteAsyncIODesignator(const parser::Designator &designator) {
+ if (inAsyncIO_ && !InNestedBlockConstruct()) {
+ const parser::Name &name{parser::GetFirstName(designator)};
+ if (!IsHidden(name.source)) {
+ asyncIONames_.insert(name.source);
+ }
+ }
+ }
+
+ SemanticsContext &context_;
+ bool inAsyncIO_{false};
+ std::set<SourceName> asyncIONames_;
+};
+
+// Any data list item or SIZE= specifier of an I/O data transfer statement
+// with ASYNCHRONOUS="YES" implicitly has the ASYNCHRONOUS attribute in the
+// local scope.
+void ConstructVisitor::HandleImpliedAsynchronousInScope(
+ const parser::Block &block) {
+ ExecutionPartAsyncIOSkimmer skimmer{context()};
+ skimmer.Walk(block);
+ for (auto name : skimmer.asyncIONames()) {
+ if (Symbol * symbol{currScope().FindSymbol(name)}) {
+ if (!symbol->attrs().test(Attr::ASYNCHRONOUS)) {
+ if (&symbol->owner() != &currScope()) {
+ symbol = &*currScope()
+ .try_emplace(name, HostAssocDetails{*symbol})
+ .first->second;
+ }
+ if (symbol->has<AssocEntityDetails>()) {
+ symbol = const_cast<Symbol *>(&GetAssociationRoot(*symbol));
+ }
+ SetImplicitAttr(*symbol, Attr::ASYNCHRONOUS);
+ }
+ }
+ }
+}
+
// ResolveNamesVisitor implementation
bool ResolveNamesVisitor::Pre(const parser::FunctionReference &x) {
@@ -8668,138 +8890,38 @@ bool ResolveNamesVisitor::Pre(const parser::Program &x) {
// References to procedures need to record that their symbols are known
// to be procedures, so that they don't get converted to objects by default.
-class ExecutionPartSkimmer {
+class ExecutionPartCallSkimmer : public ExecutionPartSkimmerBase {
public:
- explicit ExecutionPartSkimmer(ResolveNamesVisitor &resolver)
+ explicit ExecutionPartCallSkimmer(ResolveNamesVisitor &resolver)
: resolver_{resolver} {}
- void Walk(const parser::ExecutionPart *exec) {
- if (exec) {
- parser::Walk(*exec, *this);
- CHECK(nestedScopes_.empty());
- }
+ void Walk(const parser::ExecutionPart &exec) {
+ parser::Walk(exec, *this);
+ EndWalk();
}
- template <typename A> bool Pre(const A &) { return true; }
- template <typename A> void Post(const A &) {}
+ using ExecutionPartSkimmerBase::Post;
+ using ExecutionPartSkimmerBase::Pre;
+
void Post(const parser::FunctionReference &fr) {
NoteCall(Symbol::Flag::Function, fr.v, false);
}
void Post(const parser::CallStmt &cs) {
NoteCall(Symbol::Flag::Subroutine, cs.call, cs.chevrons.has_value());
}
- bool Pre(const parser::AssociateConstruct &) {
- PushScope();
- return true;
- }
- void Post(const parser::AssociateConstruct &) { PopScope(); }
- bool Pre(const parser::Association &x) {
- Hide(std::get<parser::Name>(x.t));
- return true;
- }
- bool Pre(const parser::BlockConstruct &) {
- PushScope();
- return true;
- }
- void Post(const parser::BlockConstruct &) { PopScope(); }
- bool Pre(const parser::EntityDecl &x) {
- Hide(std::get<parser::ObjectName>(x.t));
- return true;
- }
- void Post(const parser::ImportStmt &x) {
- if (x.kind == common::ImportKind::None ||
- x.kind == common::ImportKind::Only) {
- if (!nestedScopes_.front().importOnly.has_value()) {
- nestedScopes_.front().importOnly.emplace();
- }
- for (const auto &name : x.names) {
- nestedScopes_.front().importOnly->emplace(name.source);
- }
- } else {
- // no special handling needed for explicit names or IMPORT, ALL
- }
- }
- void Post(const parser::UseStmt &x) {
- if (const auto *onlyList{std::get_if<std::list<parser::Only>>(&x.u)}) {
- for (const auto &only : *onlyList) {
- if (const auto *name{std::get_if<parser::Name>(&only.u)}) {
- Hide(*name);
- } else if (const auto *rename{std::get_if<parser::Rename>(&only.u)}) {
- if (const auto *names{
- std::get_if<parser::Rename::Names>(&rename->u)}) {
- Hide(std::get<0>(names->t));
- }
- }
- }
- } else {
- // USE may or may not shadow symbols in host scopes
- nestedScopes_.front().hasUseWithoutOnly = true;
- }
- }
- bool Pre(const parser::DerivedTypeStmt &x) {
- Hide(std::get<parser::Name>(x.t));
- PushScope();
- return true;
- }
- void Post(const parser::DerivedTypeDef &) { PopScope(); }
- bool Pre(const parser::SelectTypeConstruct &) {
- PushScope();
- return true;
- }
- void Post(const parser::SelectTypeConstruct &) { PopScope(); }
- bool Pre(const parser::SelectTypeStmt &x) {
- if (const auto &maybeName{std::get<1>(x.t)}) {
- Hide(*maybeName);
- }
- return true;
- }
- bool Pre(const parser::SelectRankConstruct &) {
- PushScope();
- return true;
- }
- void Post(const parser::SelectRankConstruct &) { PopScope(); }
- bool Pre(const parser::SelectRankStmt &x) {
- if (const auto &maybeName{std::get<1>(x.t)}) {
- Hide(*maybeName);
- }
- return true;
- }
private:
void NoteCall(
Symbol::Flag flag, const parser::Call &call, bool hasCUDAChevrons) {
auto &designator{std::get<parser::ProcedureDesignator>(call.t)};
if (const auto *name{std::get_if<parser::Name>(&designator.u)}) {
- for (const auto &scope : nestedScopes_) {
- if (scope.locals.find(name->source) != scope.locals.end()) {
- return; // shadowed by nested declaration
- }
- if (scope.hasUseWithoutOnly) {
- break;
- }
- if (scope.importOnly &&
- scope.importOnly->find(name->source) == scope.importOnly->end()) {
- return; // not imported
- }
+ if (!IsHidden(name->source)) {
+ resolver_.NoteExecutablePartCall(flag, name->source, hasCUDAChevrons);
}
- resolver_.NoteExecutablePartCall(flag, name->source, hasCUDAChevrons);
}
}
- void PushScope() { nestedScopes_.emplace_front(); }
- void PopScope() { nestedScopes_.pop_front(); }
- void Hide(const parser::Name &name) {
- nestedScopes_.front().locals.emplace(name.source);
- }
-
ResolveNamesVisitor &resolver_;
-
- struct NestedScopeInfo {
- bool hasUseWithoutOnly{false};
- std::set<SourceName> locals;
- std::optional<std::set<SourceName>> importOnly;
- };
- std::list<NestedScopeInfo> nestedScopes_;
};
// Build the scope tree and resolve names in the specification parts of this
@@ -8844,7 +8966,10 @@ void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
for (auto &child : node.children()) {
ResolveSpecificationParts(child);
}
- ExecutionPartSkimmer{*this}.Walk(node.exec());
+ if (node.exec()) {
+ ExecutionPartCallSkimmer{*this}.Walk(*node.exec());
+ HandleImpliedAsynchronousInScope(node.exec()->v);
+ }
EndScopeForNode(node);
// Ensure that every object entity has a type.
for (auto &pair : *node.scope()) {
@@ -8979,8 +9104,6 @@ class DeferredCheckVisitor {
}
}
- bool Pre(const parser::BlockConstruct &x) { return true; }
-
void Post(const parser::ProcInterface &pi) {
if (const auto *name{std::get_if<parser::Name>(&pi.u)}) {
resolver_.CheckExplicitInterface(*name);
diff --git a/flang/test/Semantics/call03.f90 b/flang/test/Semantics/call03.f90
index 2aca8de93acb05..bb7a8cb05c5acb 100644
--- a/flang/test/Semantics/call03.f90
+++ b/flang/test/Semantics/call03.f90
@@ -357,19 +357,19 @@ subroutine test15(assumedrank) ! C1539
call valueassumedsize(b(::2)) ! ok
call valueassumedsize(c(::2)) ! ok
call valueassumedsize(d(::2)) ! ok
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatileassumedsize(b(::2))
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatilecontiguous(b(::2))
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatileassumedsize(c(::2))
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatilecontiguous(c(::2))
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatileassumedsize(d(::2))
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatilecontiguous(d(::2))
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatilecontiguous(assumedrank)
end subroutine
@@ -388,18 +388,66 @@ subroutine test16() ! C1540
call valueassumedsize(b) ! ok
call valueassumedsize(c) ! ok
call valueassumedsize(d) ! ok
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatileassumedsize(b)
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatilecontiguous(b)
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatileassumedsize(c)
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatilecontiguous(c)
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatileassumedsize(d)
- !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous dummy argument 'x='
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
call volatilecontiguous(d)
end subroutine
+ subroutine explicitAsyncContig(x)
+ real, asynchronous, intent(in out), contiguous :: x(:)
+ end
+ subroutine implicitAsyncContig(x)
+ real, intent(in out), contiguous :: x(:)
+ read(1,id=id,asynchronous="yes") x
+ end
+ subroutine test17explicit(x)
+ real, asynchronous, intent(in out) :: x(:)
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call explicitAsyncContig(x)
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call implicitAsyncContig(x)
+ end
+ subroutine test17implicit(x)
+ real, intent(in out) :: x(:)
+ read(1,id=id,asynchronous="yes") x
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call explicitAsyncContig(x)
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call implicitAsyncContig(x)
+ end
+ subroutine test17block(x)
+ real, intent(in out) :: x(:)
+ call explicitAsyncContig(x) ! ok
+ call implicitAsyncContig(x) ! ok
+ block
+ read(1,id=id,asynchronous="yes") x
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call explicitAsyncContig(x)
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call implicitAsyncContig(x)
+ end block
+ end
+ subroutine test17internal(x)
+ real, intent(in out) :: x(:)
+ call explicitAsyncContig(x) ! ok
+ call implicitAsyncContig(x) ! ok
+ contains
+ subroutine internal
+ read(1,id=id,asynchronous="yes") x
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call explicitAsyncContig(x)
+ !ERROR: ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous ASYNCHRONOUS or VOLATILE dummy argument 'x='
+ call implicitAsyncContig(x)
+ end
+ end
+
end module
More information about the flang-commits
mailing list