[flang][openmp] Add General Semantic Checks for Allocate Directive

[I_Perry]

Summary

This patch adds semantic checks for the General Restrictions of the Allocate Directive.

Since the requires directive is not yet implemented in Flang, the restriction
"allocate directives that appear in a target region must specify an allocator clause unless a requires directive with the dynamic_allocators clause is present in the same compilation unit"
will need to be updated at a later time.

A different patch will be made with the Fortran specific restrictions of this directive.

I have used the code from https://reviews.llvm.org/D89395 for the CheckObjectListStructure function.

[Rin]

flang/test/Semantics/omp-allocate03.f90

16

This test is currently failing as it is not throwing any errors, although one is expected.

[Rin]

Fix failing test

[kiranchandramohan]

I) Are you handling only a subset of the restrictions here? I see the following in,

1. General restrictions.

-> allocate directives that appear in a target region must specify an allocator clause unless a requires directive with the dynamic_allocators clause is present in the same compilation unit.

2. Fortran specific restrictions.

-> List items specified in the allocate directive must not have the ALLOCATABLE attribute unless the directive is associated with an allocate statement.
-> List items specified in an allocate directive that is associated with an allocate statement must be variables that are allocated by the allocate statement.
-> Multiple directives can only be associated with an allocate statement if list items are specified on each allocate directive.
-> If a list item has the SAVE attribute, is a common block name, or is declared in the scope of a module, then only predefined memory allocator parameters can be used in the allocator clause.
-> A type parameter inquiry cannot appear in an allocate directive.

Since the requires directive is not there I am assuming that only a subset of the check in the general restrictions can be checked now.
Please provide a clarification saying that only a subset of checks are implemented or implement the above checks.

II) A few files have no newline at end of file.

[Rin]

In D91159#2397842, @kiranchandramohan wrote:

I) Are you handling only a subset of the restrictions here? I see the following in,

1. General restrictions.

-> allocate directives that appear in a target region must specify an allocator clause unless a requires directive with the dynamic_allocators clause is present in the same compilation unit.

2. Fortran specific restrictions.

-> List items specified in the allocate directive must not have the ALLOCATABLE attribute unless the directive is associated with an allocate statement.
-> List items specified in an allocate directive that is associated with an allocate statement must be variables that are allocated by the allocate statement.
-> Multiple directives can only be associated with an allocate statement if list items are specified on each allocate directive.
-> If a list item has the SAVE attribute, is a common block name, or is declared in the scope of a module, then only predefined memory allocator parameters can be used in the allocator clause.
-> A type parameter inquiry cannot appear in an allocate directive.

Since the requires directive is not there I am assuming that only a subset of the check in the general restrictions can be checked now.
Please provide a clarification saying that only a subset of checks are implemented or implement the above checks.

II) A few files have no newline at end of file.

I) So sorry about that. Don't know how I managed to miss all of those. I'll start working on them.
II) My editor seems to be doing that, I'll fix it with the next update.

[Rin]

Add semantic check for allocate directives within target region

[Rin]

Rebase with Parser for Allocate Directive patch

[kiranchandramohan]

flang/include/flang/Parser/parse-tree.h

3807–3808

Can you post another patch without these conflicts?

[Rin]

Get rid of conflicts

[Rin]

Get rid of conflicts

[kiranchandramohan]

First few comments.

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

475

Can you reuse the following function?
void OmpStructureChecker::CheckIsVarPartOfAnotherVar

954–955

Why are all these removed in this patch?

flang/lib/Semantics/resolve-directives.cpp

121–122

Why is this change in OpenACC required?

462–463

Is it possible to do the semantic checks without these two globals?
If not this should be initialized with braces.

flang/test/Semantics/omp-allocate01.f90

25

Check newline in all test files.

[clementval]

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

954–955

This would break any allowance check on these clauses. I don't see the reason to remove them in this patch.

flang/lib/Semantics/resolve-directives.cpp

121–122

Please revert this change. OpenACC part should not be touch for OpenMP related code.

1018

I guess you can query the current context instead of using this global variable.

1333

I would remove those two globals and for the inTarget you can query the context stack. There is an example in OpenACC (https://github.com/llvm/llvm-project/blob/d02eac0c000984865dd1ce2474715538f8439470/flang/lib/Semantics/check-acc-structure.cpp#L67)

For the hasAllocator you can probably go through the list here to get the information.

1429

Can you reuse the ResolveOmpName function instead of this one?

[Rin]

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

475

Yes, this function wasn't yet here when I started working on this patch. I will reuse this function instead.

954–955

I think I was getting some errors about redefinition of those checks. I'll look into this and re add them next update.

flang/lib/Semantics/resolve-directives.cpp

121–122

It's not, I will revert this next update.

flang/test/Semantics/omp-allocate01.f90

25

Will do.

flang/test/Semantics/omp-allocate03.f90

16

I notice here I took care of only the DeclarativeAllocate case and not the Executable one. I will change this in the next update.

[Rin]

Remove unnecessary global variables and add variable check and test for ExecutableAllocateDirective case

[Rin]

flang/lib/Semantics/resolve-directives.cpp

1333

Thanks for your example @clementval. It was really helpful.

1429

I don't see how ResolveOmpName checks the Scope similarly to the way ResolveOmpObjectScope does. I'm not sure how I could reuse it. I'll take another look at it though.

[clementval]

flang/lib/Semantics/resolve-directives.cpp

1429

Fine as well if you cannot reuse it. Can you maybe add a comment on the function to tell how it is different then ResolveOmpName?

[kiranchandramohan]

Rebasing on main.

[clementval]

flang/lib/Semantics/resolve-directives.cpp

488

Would be even nicer to have a generic function like bool IsNestedInDirective(const llvm::omg::Directive dir) so it can be reused later for other check. Might even be in the common class For OpenACC and OpenMP.

No need to do it in this revision but just keep the idea in mind.

[I_Perry]

I'll take this patch over from Rin and take it to completion.

[clementval]

In D91159#2652965, @I_Perry wrote:

I'll take this patch over from Rin and take it to completion.

Thanks!

[I_Perry]

flang/lib/Semantics/resolve-directives.cpp

488

I'm looking into making a more generic function for this purpose as part of this patch, do you know if anyone has implemented anything like IsNestedInDirective
already at this point?

[clementval]

flang/lib/Semantics/resolve-directives.cpp

488

There are couple of functions that are close to this but I'm not aware of a IsNestedInDirective at this point.

https://github.com/llvm/llvm-project/blob/9d08f276d79b59e3d1ad3db3db19077284524ca3/flang/lib/Semantics/check-acc-structure.cpp#L67

https://github.com/llvm/llvm-project/blob/9d08f276d79b59e3d1ad3db3db19077284524ca3/flang/lib/Semantics/check-directive-structure.h#L254

The closest is probably this one:
https://github.com/llvm/llvm-project/blob/9d08f276d79b59e3d1ad3db3db19077284524ca3/flang/lib/Semantics/check-directive-structure.h#L243

[I_Perry]

This update changes the function IsInsideTargetDirective to the more generic IsNestedInDirective and adds a comment explaining when to use ResolveOmpObjectScope over ResolveOmpName.

[kiranchandramohan]

Two first comments. I will do a detailed review later.

flang/lib/Semantics/resolve-directives.cpp

1346

This variable is not used and will cause a warning.

1480

I think ResolveOmpObjectScope should only be called if it is an allocate directive. Please reorder the operands of the && operation. The omp-do01.f90 test will also pass.

[I_Perry]

Adressed comments

Removed an unused variable and changed the order of an && expression, which was causing test omp-do01.f90 to fail.

[I_Perry]

Fixed incorrect formatting.

[kiranchandramohan]

LGTM.

@clementval do you have more comments?

flang/lib/Semantics/resolve-directives.cpp

1345

Nit: Can probably use parser::Unwrap on the clauselist to check for the allocator.

1436–1440

Nit: Can ResolveName be used instead of the above 5 lines?

1442

Nit: Add a TODO above to check whether the following code needs to be in ResolveOmpName as well.

[clementval]

In D91159#2699965, @kiranchandramohan wrote:

LGTM.

@clementval do you have more comments?

LGTM

[I_Perry]

Patch ready for merge.

[I_Perry]

@kiranchandramohan @awarzynski This patch has been rebased against main, all tests pass and it is ready for merge.

[I_Perry]

Addressed nit comments.

[clementval]

In D91159#2708868, @I_Perry wrote:

Addressed nit comments.

Do you have access to land the patch?

[I_Perry]

In D91159#2708872, @clementval wrote:

In D91159#2708868, @I_Perry wrote:

Addressed nit comments.

Do you have access to land the patch?

I do not, however both @awarzynski and @kiranchandramohan have offered to merge this patch (which should be ready now).

[clementval]

I do not, however both @awarzynski and @kiranchandramohan have offered to merge this patch (which should be ready now).

Ok good. I'll let them merge it then.

flang/include/flang/Parser/parse-tree.h

struct OpenMPLoopConstruct {
   std::tuple<OmpBeginLoopDirective, std::optional<DoConstruct>,
       std::optional<OmpEndLoopDirective>>
       t;
 };
 
 struct OpenMPConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPConstruct);
   std::variant<OpenMPStandaloneConstruct, OpenMPSectionsConstruct,
       OpenMPLoopConstruct, OpenMPBlockConstruct, OpenMPAtomicConstruct,
-      OpenMPExecutableAllocate, OpenMPDeclarativeAllocate,
+      OpenMPDeclarativeAllocate, OpenMPExecutableAllocate,
       OpenMPCriticalConstruct>
       u;
 };
 
 // Parse tree nodes for OpenACC 3.1 directives and clauses
 
 struct AccObject {
   UNION_CLASS_BOILERPLATE(AccObject);

flang/include/flang/Semantics/symbol.h

ENUM_CLASS(Flag,
       AccCommonBlock, AccThreadPrivate, AccReduction, AccNone, AccPreDetermined,
       // OpenMP data-sharing attribute
       OmpShared, OmpPrivate, OmpLinear, OmpFirstPrivate, OmpLastPrivate,
       // OpenMP data-mapping attribute
       OmpMapTo, OmpMapFrom, OmpMapAlloc, OmpMapRelease, OmpMapDelete,
       // OpenMP data-copying attribute
       OmpCopyIn, OmpCopyPrivate,
       // OpenMP miscellaneous flags
-      OmpCommonBlock, OmpReduction, OmpAllocate, OmpDeclareSimd,
-      OmpDeclareTarget, OmpThreadprivate, OmpDeclareReduction, OmpFlushed,
-      OmpCriticalLock, OmpIfSpecified, OmpNone, OmpPreDetermined, OmpAligned);
+      OmpCommonBlock, OmpReduction, OmpAligned, OmpAllocate,
+      OmpAllocateDirective, OmpDeclareSimd, OmpDeclareTarget, OmpThreadprivate,
+      OmpDeclareReduction, OmpFlushed, OmpCriticalLock, OmpIfSpecified, OmpNone,
+      OmpPreDetermined);
   using Flags = common::EnumSet<Flag, Flag_enumSize>;
 
   const Scope &owner() const { return *owner_; }
   const SourceName &name() const { return name_; }
   Attrs &attrs() { return attrs_; }
   const Attrs &attrs() const { return attrs_; }
   Flags &flags() { return flags_; }
   const Flags &flags() const { return flags_; }

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

private:
   void CheckAllowedMapTypes(const parser::OmpMapType::Type &,
       const std::list<parser::OmpMapType::Type> &);
   llvm::StringRef getClauseName(llvm::omp::Clause clause) override;
   llvm::StringRef getDirectiveName(llvm::omp::Directive directive) override;
 
   void CheckDependList(const parser::DataRef &);
   void CheckDependArraySection(
       const common::Indirection<parser::ArrayElement> &, const parser::Name &);
-  void CheckIsVarPartOfAnotherVar(const parser::OmpObjectList &objList);
+  void CheckIsVarPartOfAnotherVar(
+      const parser::CharBlock &source, const parser::OmpObjectList &objList);
   void CheckIntentInPointer(
       const parser::OmpObjectList &, const llvm::omp::Clause);
   void GetSymbolsInObjectList(const parser::OmpObjectList &, SymbolSourceMap &);
   void CheckDefinableObjects(SymbolSourceMap &, const llvm::omp::Clause);
   void CheckPrivateSymbolsInOuterCxt(
       SymbolSourceMap &, DirectivesClauseTriple &, const llvm::omp::Clause);
   const parser::Name GetLoopIndex(const parser::DoConstruct *x);
   void SetLoopInfo(const parser::OpenMPLoopConstruct &x);

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

 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPDeclareSimdConstruct &) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPDeclarativeAllocate &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
+  const auto &objectList{std::get<parser::OmpObjectList>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_allocate);
+  CheckIsVarPartOfAnotherVar(dir.source, objectList);
 }
 
-void OmpStructureChecker::Leave(const parser::OpenMPDeclarativeAllocate &) {
+void OmpStructureChecker::Leave(const parser::OpenMPDeclarativeAllocate &x) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPDeclareTargetConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   PushContext(dir.source, llvm::omp::Directive::OMPD_declare_target);
   const auto &spec{std::get<parser::OmpDeclareTargetSpecifier>(x.t)};
   if (std::holds_alternative<parser::OmpDeclareTargetWithClause>(spec.u)) {
     SetClauseSets(llvm::omp::Directive::OMPD_declare_target);
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPDeclareTargetConstruct &) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPExecutableAllocate &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
+  const auto &objectList{std::get<std::optional<parser::OmpObjectList>>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_allocate);
+  if (objectList)
+    CheckIsVarPartOfAnotherVar(dir.source, *objectList);
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPExecutableAllocate &) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(
     const parser::OpenMPSimpleStandaloneConstruct &x) {
if (const auto &expr{x.v}) {
     // 2.8.3 Loop SIMD Construct Restriction
     if (llvm::omp::doSimdSet.test(GetContext().directive)) {
       context_.Say(GetContext().clauseSource,
           "No ORDERED clause with a parameter can be specified "
           "on the %s directive"_err_en_US,
           ContextDirectiveAsFortran());
     }
   }
 }
 
 void OmpStructureChecker::Enter(const parser::OmpClause::Shared &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_shared);
-  CheckIsVarPartOfAnotherVar(x.v);
+  CheckIsVarPartOfAnotherVar(GetContext().clauseSource, x.v);
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::Private &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_private);
-  CheckIsVarPartOfAnotherVar(x.v);
+  CheckIsVarPartOfAnotherVar(GetContext().clauseSource, x.v);
   CheckIntentInPointer(x.v, llvm::omp::Clause::OMPC_private);
 }
 
 void OmpStructureChecker::CheckIsVarPartOfAnotherVar(
-    const parser::OmpObjectList &objList) {
+    const parser::CharBlock &source, const parser::OmpObjectList &objList) {
+
   for (const auto &ompObject : objList.v) {
+    std::visit(
+        common::visitors{
+            [&](const parser::Designator &designator) {
+              if (std::get_if<parser::DataRef>(&designator.u)) {
                 if ((parser::Unwrap<parser::StructureComponent>(ompObject)) ||
                     (parser::Unwrap<parser::ArrayElement>(ompObject))) {
-      context_.Say(GetContext().clauseSource,
+                  context_.Say(source,
                       "A variable that is part of another variable (as an "
                       "array or structure element)"
-          " cannot appear in a PRIVATE or SHARED clause."_err_en_US);
+                      " cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive."_err_en_US);
                 }
               }
+            },
+            [&](const parser::Name &name) {},
+        },
+        ompObject.u);
   }
+}
+
 void OmpStructureChecker::Enter(const parser::OmpClause::Firstprivate &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_firstprivate);
   CheckIsLoopIvPartOfClause(llvmOmpClause::OMPC_firstprivate, x.v);
 
   SymbolSourceMap currSymbols;
   GetSymbolsInObjectList(x.v, currSymbols);
 
   DirectivesClauseTriple dirClauseTriple;

flang/lib/Semantics/resolve-directives.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "resolve-directives.h"

 class AccAttributeVisitor : DirectiveAttributeVisitor<llvm::acc::Directive> {
 public:
   explicit AccAttributeVisitor(SemanticsContext &context)
       : DirectiveAttributeVisitor(context) {}
 
   template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
   template <typename A> bool Pre(const A &) { return true; }
   template <typename A> void Post(const A &) {}
 
   bool Pre(const parser::OpenACCBlockConstruct &);
   void Post(const parser::OpenACCBlockConstruct &) { PopContext(); }
   bool Pre(const parser::OpenACCCombinedConstruct &);
   void Post(const parser::OpenACCCombinedConstruct &) { PopContext(); }
 
   bool Pre(const parser::OpenACCDeclarativeConstruct &);
   void Post(const parser::OpenACCDeclarativeConstruct &) { PopContext(); }
 
   bool Pre(const parser::OpenACCRoutineConstruct &);
if (name) {
       ResolveOmpName(*name, Symbol::Flag::OmpDeclareSimd);
     }
     return true;
   }
   void Post(const parser::OpenMPDeclareSimdConstruct &) { PopContext(); }
   bool Pre(const parser::OpenMPThreadprivate &);
   void Post(const parser::OpenMPThreadprivate &) { PopContext(); }
 
+  bool Pre(const parser::OpenMPDeclarativeAllocate &);
+  void Post(const parser::OpenMPDeclarativeAllocate &) { PopContext(); }
+
+  bool Pre(const parser::OpenMPExecutableAllocate &);
+  void Post(const parser::OpenMPExecutableAllocate &);
+
   // 2.15.3 Data-Sharing Attribute Clauses
   void Post(const parser::OmpDefaultClause &);
   bool Pre(const parser::OmpClause::Shared &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpShared);
     return false;
   }
   bool Pre(const parser::OmpClause::Private &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpPrivate);
private:
   static constexpr Symbol::Flags ompFlagsRequireMark{
       Symbol::Flag::OmpThreadprivate};
 
   static constexpr Symbol::Flags dataCopyingAttributeFlags{
       Symbol::Flag::OmpCopyIn, Symbol::Flag::OmpCopyPrivate};
 
   std::vector<const parser::Name *> allocateNames_; // on one directive
   UnorderedSymbolSet privateDataSharingAttributeObjects_; // on one directive
   UnorderedSymbolSet stmtFunctionExprSymbols_;
   std::multimap<const parser::Label,
       std::pair<parser::CharBlock, std::optional<DirContext>>>
       sourceLabels_;
   std::map<const parser::Label,
       std::pair<parser::CharBlock, std::optional<DirContext>>>
       targetLabels_;
   parser::CharBlock currentStatementSource_;
 
   void AddAllocateName(const parser::Name *&object) {
     allocateNames_.push_back(object);
   }
   void ClearAllocateNames() { allocateNames_.clear(); }
 
   void AddPrivateDataSharingAttributeObjects(SymbolRef object) {
     privateDataSharingAttributeObjects_.insert(object);
   }
   void ClearPrivateDataSharingAttributeObjects() {
     privateDataSharingAttributeObjects_.clear();
   }
 
   // Predetermined DSA rules
   void PrivatizeAssociatedLoopIndexAndCheckLoopLevel(
       const parser::OpenMPLoopConstruct &);
   void ResolveSeqLoopIndexInParallelOrTaskConstruct(const parser::Name &);
 
+  bool IsNestedInDirective(llvm::omp::Directive directive);
   void ResolveOmpObjectList(const parser::OmpObjectList &, Symbol::Flag);
   void ResolveOmpObject(const parser::OmpObject &, Symbol::Flag);
   Symbol *ResolveOmp(const parser::Name &, Symbol::Flag, Scope &);
   Symbol *ResolveOmp(Symbol &, Symbol::Flag, Scope &);
   Symbol *ResolveOmpCommonBlockName(const parser::Name *);
   void ResolveOmpNameList(const std::list<parser::Name> &, Symbol::Flag);
   void ResolveOmpName(const parser::Name &, Symbol::Flag);
   Symbol *ResolveName(const parser::Name *);
+  Symbol *ResolveOmpObjectScope(const parser::Name *);
   Symbol *DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
   Symbol *DeclareOrMarkOtherAccessEntity(Symbol &, Symbol::Flag);
   void CheckMultipleAppearances(
       const parser::Name &, const Symbol &, Symbol::Flag);
 
   void CheckDataCopyingClause(
       const parser::Name &, const Symbol &, Symbol::Flag);
   void CheckAssocLoopLevel(std::int64_t level, const parser::OmpClause *clause);

 }
 
 bool OmpAttributeVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
   switch (beginDir.v) {
   case llvm::omp::Directive::OMPD_master:
   case llvm::omp::Directive::OMPD_ordered:
   case llvm::omp::Directive::OMPD_parallel:
   case llvm::omp::Directive::OMPD_single:
   case llvm::omp::Directive::OMPD_target:
   case llvm::omp::Directive::OMPD_target_data:
   case llvm::omp::Directive::OMPD_task:
   case llvm::omp::Directive::OMPD_teams:
   case llvm::omp::Directive::OMPD_workshare:
   case llvm::omp::Directive::OMPD_parallel_workshare:
   case llvm::omp::Directive::OMPD_target_teams:

 
 bool OmpAttributeVisitor::Pre(const parser::OpenMPThreadprivate &x) {
   PushContext(x.source, llvm::omp::Directive::OMPD_threadprivate);
   const auto &list{std::get<parser::OmpObjectList>(x.t)};
   ResolveOmpObjectList(list, Symbol::Flag::OmpThreadprivate);
   return true;
 }
 
+bool OmpAttributeVisitor::Pre(const parser::OpenMPDeclarativeAllocate &x) {
+  PushContext(x.source, llvm::omp::Directive::OMPD_allocate);
+  const auto &list{std::get<parser::OmpObjectList>(x.t)};
+  ResolveOmpObjectList(list, Symbol::Flag::OmpAllocateDirective);
+  return false;
+}
+
+bool OmpAttributeVisitor::Pre(const parser::OpenMPExecutableAllocate &x) {
+  PushContext(x.source, llvm::omp::Directive::OMPD_allocate);
+  const auto &list{std::get<std::optional<parser::OmpObjectList>>(x.t)};
+  if (list)
+    ResolveOmpObjectList(*list, Symbol::Flag::OmpAllocateDirective);
+  return true;
+}
+
 void OmpAttributeVisitor::Post(const parser::OmpDefaultClause &x) {
   if (!dirContext_.empty()) {
     switch (x.v) {
     case parser::OmpDefaultClause::Type::Private:
       SetContextDefaultDSA(Symbol::Flag::OmpPrivate);
       break;
     case parser::OmpDefaultClause::Type::Firstprivate:
       SetContextDefaultDSA(Symbol::Flag::OmpFirstPrivate);
       break;
     case parser::OmpDefaultClause::Type::Shared:
       SetContextDefaultDSA(Symbol::Flag::OmpShared);
       break;
     case parser::OmpDefaultClause::Type::None:
       SetContextDefaultDSA(Symbol::Flag::OmpNone);
       break;
     }
   }
 }
 
+bool OmpAttributeVisitor::IsNestedInDirective(llvm::omp::Directive directive) {
+  if (dirContext_.size() >= 1) {
+    for (std::size_t i = dirContext_.size() - 1; i > 0; --i) {
+      if (dirContext_[i - 1].directive == directive)
+        return true;
+    }
+  }
+  return false;
+}
+
+void OmpAttributeVisitor::Post(const parser::OpenMPExecutableAllocate &x) {
+  bool hasAllocator = false;
+  const auto &clauseList{std::get<parser::OmpClauseList>(x.t)};
+  for (const auto &clause : clauseList.v) {
+    if (std::get_if<parser::OmpClause::Allocator>(&clause.u))
+      hasAllocator = true;
+  }
+
+  if (IsNestedInDirective(llvm::omp::Directive::OMPD_target) && !hasAllocator)
+    // TODO: expand this check to exclude the case when a requires
+    //       directive with the dynamic_allocators clause is present
+    //       in the same compilation unit (OMP5.0 2.11.3).
+    context_.Say(x.source,
+        "ALLOCATE directives that appear in a TARGET region "
+        "must specify an allocator clause"_err_en_US);
+  PopContext();
+}
+
 // For OpenMP constructs, check all the data-refs within the constructs
 // and adjust the symbol for each Name if necessary
 void OmpAttributeVisitor::Post(const parser::Name &name) {
   auto *symbol{name.symbol};
   if (symbol && !dirContext_.empty() && GetContext().withinConstruct) {
     if (!symbol->owner().IsDerivedType() && !symbol->has<ProcEntityDetails>() &&
         !IsObjectWithDSA(*symbol)) {
       // TODO: create a separate function to go through the rules for
Symbol *OmpAttributeVisitor::ResolveOmpCommonBlockName(
   if (auto *commonBlockSymbol{
           name ? GetContext().scope.FindCommonBlock(name->source) : nullptr}) {
     name->symbol = commonBlockSymbol;
     return commonBlockSymbol;
   }
   return nullptr;
 }
 
+// Use this function over ResolveOmpName when an omp object's scope needs
+// resolving, it's symbol flag isn't important and a simple check for resolution
+// failure is desired. Using ResolveOmpName means needing to work with the
+// context to check for failure, whereas here a pointer comparison is all that's
+// needed.
+Symbol *OmpAttributeVisitor::ResolveOmpObjectScope(const parser::Name *name) {
+
+  if (auto *prev{name ? GetContext().scope.parent().FindSymbol(name->source)
+                      : nullptr}) {
+    name->symbol = prev;
+    return nullptr;
+  }
+
+  if (auto *ompSymbol{
+          name ? GetContext().scope.FindSymbol(name->source) : nullptr}) {
+    name->symbol = ompSymbol;
+    return ompSymbol;
+  }
+  return nullptr;
+}
+
 void OmpAttributeVisitor::ResolveOmpObjectList(
     const parser::OmpObjectList &ompObjectList, Symbol::Flag ompFlag) {
   for (const auto &ompObject : ompObjectList.v) {
     ResolveOmpObject(ompObject, ompFlag);
   }
 }
 
 void OmpAttributeVisitor::ResolveOmpObject(
std::visit(
                   if (privateDataSharingAttributeFlags.test(ompFlag)) {
                     CheckPrivateDSAObject(*name, *symbol, ompFlag);
                   }
 
                   if (ompFlag == Symbol::Flag::OmpAllocate) {
                     AddAllocateName(name);
                   }
                 }
+                if (ompFlag == Symbol::Flag::OmpAllocateDirective && ResolveOmpObjectScope(name) == nullptr) {
+                  context_.Say(designator.source, // 2.15.3
+                      "List items must be declared in the same scoping unit "
+                      "in which the ALLOCATE directive appears"_err_en_US);
+                }
               }
             } else {
               // Array sections to be changed to substrings as needed
               if (AnalyzeExpr(context_, designator)) {
                 if (std::holds_alternative<parser::Substring>(designator.u)) {
                   context_.Say(designator.source,
                       "Substrings are not allowed on OpenMP "
                       "directives or clauses"_err_en_US);

flang/test/Semantics/omp-allocate01.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! OpenMP Version 5.0
+! 2.11.3 allocate Directive 
+! The allocate directive must appear in the same scope as the declarations of
+! each of its list items and must follow all such declarations.
+
+subroutine allocate()
+use omp_lib
+  integer :: x
+  contains
+    subroutine sema()
+    integer :: a, b
+    real, dimension (:,:), allocatable :: darray   
+
+    !ERROR: List items must be declared in the same scoping unit in which the ALLOCATE directive appears
+    !$omp allocate(x)
+        print *, a
+
+    !ERROR: List items must be declared in the same scoping unit in which the ALLOCATE directive appears
+    !$omp allocate(x) allocator(omp_default_mem_alloc)
+      allocate ( darray(a, b) ) 
+    end subroutine sema
+
+end subroutine allocate

flang/test/Semantics/omp-allocate02.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! OpenMP Version 5.0
+! 2.11.3 allocate Directive 
+! At most one allocator clause can appear on the allocate directive.
+
+subroutine allocate()
+use omp_lib
+  integer :: x, y
+  integer :: a, b
+  real, dimension (:,:), allocatable :: darray 
+
+  !$omp allocate(x, y) allocator(omp_default_mem_alloc)
+
+  !ERROR: At most one ALLOCATOR clause can appear on the ALLOCATE directive
+  !$omp allocate(x, y) allocator(omp_default_mem_alloc) allocator(omp_default_mem_alloc)
+
+  !$omp allocate(x) allocator(omp_default_mem_alloc)
+      allocate ( darray(a, b) )
+
+  !ERROR: At most one ALLOCATOR clause can appear on the ALLOCATE directive
+  !$omp allocate(x) allocator(omp_default_mem_alloc) allocator(omp_default_mem_alloc)
+      allocate ( darray(a, b) )
+  
+end subroutine allocate

flang/test/Semantics/omp-allocate03.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! OpenMP Version 5.0
+! 2.11.3 allocate Directive 
+! A variable that is part of another variable (as an array or 
+! structure element) cannot appear in an allocate directive.
+subroutine allocate()
+use omp_lib
+
+  type my_type
+    integer :: array(10)
+  end type my_type
+  type(my_type) :: my_var
+  real, dimension (:,:), allocatable :: darray
+  integer :: a, b
+
+  !!ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in an ALLOCATE directive
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
+  !$omp allocate(my_var%array)
+
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
+  !$omp allocate(darray, my_var%array) allocator(omp_default_mem_alloc)
+    allocate ( darray(a, b) )
+  
+end subroutine allocate

flang/test/Semantics/omp-allocate04.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! OpenMP Version 5.0
+! 2.11.3 allocate Directive 
+! Only the allocator clause is allowed on the allocate directive
+subroutine allocate()
+use omp_lib
+  
+  integer :: x, y
+
+  !$omp allocate(x) allocator(omp_default_mem_alloc)
+
+  !ERROR: PRIVATE clause is not allowed on the ALLOCATE directive
+  !$omp allocate(y) private(y)
+end subroutine allocate

flang/test/Semantics/omp-allocate05.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! OpenMP Version 5.0
+! 2.11.3 allocate Directive 
+! allocate directives that appear in a target region must specify an allocator 
+! clause unless a requires directive with the dynamic_allocators clause is present 
+! in the same compilation unit.
+
+subroutine allocate()
+use omp_lib
+  integer :: a, b
+  real, dimension (:,:), allocatable :: darray   
+
+  !$omp target
+      !$omp allocate allocator(omp_default_mem_alloc)
+          allocate ( darray(a, b) )
+  !$omp end target
+
+  !$omp target
+      !ERROR: ALLOCATE directives that appear in a TARGET region must specify an allocator clause
+      !$omp allocate
+          allocate ( darray(a, b) ) 
+  !$omp end target
+
+end subroutine allocate

flang/test/Semantics/omp-parallel-private01.f90

 !RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 parallel private Clause
 program omp_parallel_private
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
     integer :: array(10)
   end type my_type
 
   type(my_type) :: my_var
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel private(my_var%array)
   do i = 1, 10
     c(i) = a(i) + b(i) + k
     my_var%array(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_private

flang/test/Semantics/omp-parallel-private02.f90

 !RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 parallel private Clause
 program omp_parallel_private
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   integer :: array(10)
 
   do i = 1, 10
     array(i) = i
   end do
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel private(array(i))
   do i = 1, 10
     c(i) = a(i) + b(i) + k
     array(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_private

flang/test/Semantics/omp-parallel-private03.f90

program omp_parallel_private
 
   real :: arr(10)
   integer :: intx = 10
 
   do i = 1, 10
     arr(i) = 0.0
   end do
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel private(arr(i),intx)
   do i = 1, 10
     c(i) = a(i) + b(i) + k
     my_var%array(i) = k+intx
     arr(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_private

flang/test/Semantics/omp-parallel-private04.f90

program omp_parallel_private
 
   real :: arr(10)
   integer :: intx = 10
 
   do i = 1, 10
     arr(i) = 0.0
   end do
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel private(arr,intx,my_var%array(1))
   do i = 1, 10
     c(i) = a(i) + b(i) + k
     my_var%array(i) = k+intx
     arr(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_private

flang/test/Semantics/omp-parallel-shared01.f90

 !RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.2 parallel shared Clause
 program omp_parallel_shared
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
   integer :: array(10)
   end type my_type
 
   type(my_type) :: my_var
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel shared(my_var%array)
   do i = 1, 10
     c(i) = a(i) + b(i) +  k
     my_var%array(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_shared

flang/test/Semantics/omp-parallel-shared02.f90

 !RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.2 parallel shared Clause
 program omp_parallel_shared
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   integer :: array(10)
 
   do i = 1, 10
     array(i) = i
   end do
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel shared(array(i))
   do i = 1, 10
     c(i) = a(i) + b(i) + k
     array(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_shared

flang/test/Semantics/omp-parallel-shared03.f90

program omp_parallel_shared
 
   real :: arr(10)
   integer :: intx = 10
 
   do i = 1, 10
     arr(i) = 0.0
   end do
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel shared(arr(i),intx)
   do i = 1, 10
      c(i) = a(i) + b(i) + k
      my_var%array(i) = k+intx
      arr(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_shared

flang/test/Semantics/omp-parallel-shared04.f90

program omp_parallel_shared
 
   real :: arr(10)
   integer :: intx = 10
 
   do i = 1, 10
     arr(i) = 0.0
   end do
 
-  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause.
+  !ERROR: A variable that is part of another variable (as an array or structure element) cannot appear in a PRIVATE or SHARED clause or on the ALLOCATE directive.
   !$omp parallel shared(arr,intx,my_var%array(1))
   do i = 1, 10
     c(i) = a(i) + b(i) + k
     my_var%array(i) = k+intx
     arr(i) = k
   end do
   !$omp end parallel
 end program omp_parallel_shared

llvm/include/llvm/Frontend/OpenMP/OMP.td

let allowedOnceClauses = [
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
   ];
 }
 def OMP_Allocate : Directive<"allocate"> {
-  let allowedClauses = [
+  let allowedOnceClauses = [
     VersionedClause<OMPC_Allocator>
   ];
 }
 def OMP_DeclareVariant : Directive<"declare variant"> {
   let allowedClauses = [
     VersionedClause<OMPC_Match>
   ];
 }