[OpenMP] Add parsing/sema support for omp_all_memory reserved locator

[mikerice]

Summary

Adds support for the reserved locator 'omp_all_memory' for use
in depend clauses with 'out' or 'inout' dependence-types.

[ABataev]

clang/include/clang/AST/OpenMPClause.h

4762

I think we need also to store the location of this modifier

[mikerice]

Added the source location of 'omp_all_memory' to the clause.

[ABataev]

clang/include/clang/AST/OpenMPClause.h

4804

setOmpAllMemory?

4857

isOmpAllMemory?

clang/include/clang/Sema/Sema.h

11436–11445

Would be good this "fat" list of parameters to a structure.

11536–11541

Same, worth trying to combine params to a struct

clang/lib/AST/OpenMPClause.cpp

1040–1045

Same, many params already

clang/lib/Parse/ParseOpenMP.cpp

4360–4361

Shall we add it to the list of modifiers, just like in, out, inout?

[mikerice]

Use dependency kind to represent 'omp_all_memory' which fits nicely for codegen.
Add struct to OMPDependClause to reduce parameter passing.
Move OpenMPVarListDataTy so it can be shared between parsing and sema to reduce parameters in calls.

[mikerice]

Thanks for the review @ABataev. Any more comments on this update?

[ABataev]

clang/lib/Parse/ParseOpenMP.cpp

4360–4361

Why cannot use getOpenMPSimpleClauseType or something like this?

[mikerice]

Add a function to parse reserved locators.

clang/lib/Parse/ParseOpenMP.cpp

4360–4361

Since depend clauses would allow the modifiers differently based on context we'd need to modify and complicate getOpenMPSimpleClauseType to handle that. I kind of like a new routine to handle reserved modifiers instead, then it is more obvious what is happening in the code and new reserved locators can be easily added. What do you think?

[ABataev]

LG

clang/include/clang/AST/OpenMPClause.h

class OMPDependClause final
   SourceLocation DepLoc;
 
   /// Colon location.
   SourceLocation ColonLoc;
 
   /// Number of loops, associated with the depend clause.
   unsigned NumLoops = 0;
 
+  /// True if the 'omp_all_memory' reserved locator is present.
+  bool IsOmpAllMemory = false;
+
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   /// \param NumLoops Number of loops that is associated with this depend
   /// clause.
+  /// \param IsOmpAllMemory True if the 'omp_all_memory' locator is present.
   OMPDependClause(SourceLocation StartLoc, SourceLocation LParenLoc,
-                  SourceLocation EndLoc, unsigned N, unsigned NumLoops)
+                  SourceLocation EndLoc, unsigned N, unsigned NumLoops,
+                  bool IsOmpAllMemory)
       : OMPVarListClause<OMPDependClause>(llvm::omp::OMPC_depend, StartLoc,
                                           LParenLoc, EndLoc, N),
-        NumLoops(NumLoops) {}
+        NumLoops(NumLoops), IsOmpAllMemory(IsOmpAllMemory) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   /// \param NumLoops Number of loops that is associated with this depend
   /// clause.
-  explicit OMPDependClause(unsigned N, unsigned NumLoops)
+  explicit OMPDependClause(unsigned N, unsigned NumLoops, bool IsOmpAllMemory)
       : OMPVarListClause<OMPDependClause>(llvm::omp::OMPC_depend,
                                           SourceLocation(), SourceLocation(),
                                           SourceLocation(), N),
-        NumLoops(NumLoops) {}
+        NumLoops(NumLoops), IsOmpAllMemory(IsOmpAllMemory) {}
 
   /// Set dependency kind.
   void setDependencyKind(OpenMPDependClauseKind K) { DepKind = K; }
 
   /// Set dependency kind and its location.
   void setDependencyLoc(SourceLocation Loc) { DepLoc = Loc; }
 
   /// Set colon location.
   void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
 
   /// Sets optional dependency modifier.
   void setModifier(Expr *DepModifier);
 
+  /// Sets whether 'omp_all_memory' is present in clause.
+  void setIsOmpAllMemory(bool OmpAllMemory) { IsOmpAllMemory = OmpAllMemory; }
+
 public:
   /// Creates clause with a list of variables \a VL.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param DepKind Dependency type.
   /// \param DepLoc Location of the dependency type.
   /// \param ColonLoc Colon location.
   /// \param VL List of references to the variables.
   /// \param NumLoops Number of loops that is associated with this depend
   /// clause.
+  /// \param IsOmpAllMemory True if 'omp_all_memory' is present.
   static OMPDependClause *Create(const ASTContext &C, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc, Expr *DepModifier,
                                  OpenMPDependClauseKind DepKind,
                                  SourceLocation DepLoc, SourceLocation ColonLoc,
-                                 ArrayRef<Expr *> VL, unsigned NumLoops);
+                                 ArrayRef<Expr *> VL, unsigned NumLoops,
+                                 bool IsOmpAllMemory);
 
   /// Creates an empty clause with \a N variables.
   ///
   /// \param C AST context.
   /// \param N The number of variables.
   /// \param NumLoops Number of loops that is associated with this depend
   /// clause.
+  /// \param IsOmpAllMemory True if 'omp_all_memory' is present.
   static OMPDependClause *CreateEmpty(const ASTContext &C, unsigned N,
-                                      unsigned NumLoops);
+                                      unsigned NumLoops, bool IsOmpAllMemory);
 
   /// Get dependency type.
   OpenMPDependClauseKind getDependencyKind() const { return DepKind; }
 
   /// Return optional depend modifier.
   Expr *getModifier();
   const Expr *getModifier() const {
     return const_cast<OMPDependClause *>(this)->getModifier();
   }
 
   /// Get dependency type location.
   SourceLocation getDependencyLoc() const { return DepLoc; }
 
   /// Get colon location.
   SourceLocation getColonLoc() const { return ColonLoc; }
 
   /// Get number of loops associated with the clause.
   unsigned getNumLoops() const { return NumLoops; }
 
+  /// Get whether 'omp_all_memory' is present in clause.
+  bool getIsOmpAllMemory() const { return IsOmpAllMemory; }
+
   /// Set the loop data for the depend clauses with 'sink|source' kind of
   /// dependency.
   void setLoopData(unsigned NumLoop, Expr *Cnt);
 
   /// Get the loop data.
   Expr *getLoopData(unsigned NumLoop);
   const Expr *getLoopData(unsigned NumLoop) const;
 

clang/include/clang/Basic/DiagnosticParseKinds.td

def ext_omp_attributes : ExtWarn<
   InGroup<OpenMP51Ext>;
 def warn_omp51_compat_attributes : Warning<
   "specifying OpenMP directives with [[]] is incompatible with OpenMP "
   "standards before OpenMP 5.1">,
   InGroup<OpenMPPre51Compat>, DefaultIgnore;
 def err_omp_expected_colon : Error<"missing ':' in %0">;
 def err_omp_expected_context_selector
     : Error<"expected valid context selector in %0">;
+def err_omp_requires_out_inout_depend_type : Error<
+  "reserved locator 'omp_all_memory' requires 'out' or 'inout' "
+  "dependency types">;
+def warn_omp_more_one_omp_all_memory : Warning<
+  "reserved locator 'omp_all_memory' cannot be specified more than once">,
+  InGroup<OpenMPClauses>;
 
 // Pragma loop support.
 def err_pragma_loop_missing_argument : Error<
   "missing argument; expected %select{an integer value|"
   "'enable'%select{|, 'full'}1%select{|, 'assume_safety'}2 or 'disable'}0">;
 def err_pragma_loop_invalid_option : Error<
   "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, "
   "vectorize_width, interleave, interleave_count, unroll, unroll_count, "

clang/include/clang/Parse/Parser.h

struct OpenMPVarListDataTy {
     MapTypeModifiers;
     SmallVector<SourceLocation, NumberOfOMPMapClauseModifiers>
     MapTypeModifiersLoc;
     SmallVector<OpenMPMotionModifierKind, NumberOfOMPMotionModifiers>
         MotionModifiers;
     SmallVector<SourceLocation, NumberOfOMPMotionModifiers> MotionModifiersLoc;
     bool IsMapTypeImplicit = false;
     SourceLocation ExtraModifierLoc;
+    bool IsOmpAllMemory = false;
   };
 
   /// Parses clauses with list.
   bool ParseOpenMPVarList(OpenMPDirectiveKind DKind, OpenMPClauseKind Kind,
                           SmallVectorImpl<Expr *> &Vars,
                           OpenMPVarListDataTy &Data);
   bool ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType,
                           bool ObjectHadErrors, bool EnteringContext,

clang/include/clang/Sema/Sema.h

OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc,
                                                 SourceLocation EndLoc);
 
   /// Called on well-formed 'atomic_default_mem_order' clause.
   OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause(
       OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc,
       SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
 
   OMPClause *ActOnOpenMPVarListClause(
       OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *DepModOrTailExpr,
       const OMPVarListLocTy &Locs, SourceLocation ColonLoc,
       CXXScopeSpec &ReductionOrMapperIdScopeSpec,
       DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,
       ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
       ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,
       SourceLocation ExtraModifierLoc,
       ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
-      ArrayRef<SourceLocation> MotionModifiersLoc);
+      ArrayRef<SourceLocation> MotionModifiersLoc, bool IsOmpAllMemory);
   /// Called on well-formed 'inclusive' clause.
   OMPClause *ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList,
                                         SourceLocation StartLoc,
                                         SourceLocation LParenLoc,
                                         SourceLocation EndLoc);
   /// Called on well-formed 'exclusive' clause.
   OMPClause *ActOnOpenMPExclusiveClause(ArrayRef<Expr *> VarList,
                                         SourceLocation StartLoc,
                                         SourceLocation LParenLoc,
OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc);
   /// Called on well-formed 'depobj' pseudo clause.
   OMPClause *ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'depend' clause.
   OMPClause *
   ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
                           SourceLocation DepLoc, SourceLocation ColonLoc,
                           ArrayRef<Expr *> VarList, SourceLocation StartLoc,
-                          SourceLocation LParenLoc, SourceLocation EndLoc);
+                          SourceLocation LParenLoc, SourceLocation EndLoc,
+                          bool IsOmpAllMemory);
   /// Called on well-formed 'device' clause.
   OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
                                      Expr *Device, SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation ModifierLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'map' clause.
   OMPClause *ActOnOpenMPMapClause(
       ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,

clang/lib/AST/OpenMPClause.cpp

OMPDepobjClause *OMPDepobjClause::Create(const ASTContext &C,
   Clause->setDepobj(Depobj);
   return Clause;
 }
 
 OMPDepobjClause *OMPDepobjClause::CreateEmpty(const ASTContext &C) {
   return new (C) OMPDepobjClause();
 }
 
-OMPDependClause *
-OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
-                        SourceLocation LParenLoc, SourceLocation EndLoc,
-                        Expr *DepModifier, OpenMPDependClauseKind DepKind,
-                        SourceLocation DepLoc, SourceLocation ColonLoc,
-                        ArrayRef<Expr *> VL, unsigned NumLoops) {
+OMPDependClause *OMPDependClause::Create(
+    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    SourceLocation EndLoc, Expr *DepModifier, OpenMPDependClauseKind DepKind,
+    SourceLocation DepLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
+    unsigned NumLoops, bool IsOmpAllMemory) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<Expr *>(VL.size() + /*depend-modifier*/ 1 + NumLoops),
       alignof(OMPDependClause));
-  OMPDependClause *Clause = new (Mem)
-      OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
+  OMPDependClause *Clause = new (Mem) OMPDependClause(
+      StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops, IsOmpAllMemory);
   Clause->setVarRefs(VL);
   Clause->setDependencyKind(DepKind);
   Clause->setDependencyLoc(DepLoc);
+  Clause->setIsOmpAllMemory(IsOmpAllMemory);
   Clause->setColonLoc(ColonLoc);
   Clause->setModifier(DepModifier);
   for (unsigned I = 0 ; I < NumLoops; ++I)
     Clause->setLoopData(I, nullptr);
   return Clause;
 }
 
 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
-                                              unsigned NumLoops) {
+                                              unsigned NumLoops,
+                                              bool IsOmpAllMemory) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<Expr *>(N + /*depend-modifier*/ 1 + NumLoops),
                  alignof(OMPDependClause));
-  return new (Mem) OMPDependClause(N, NumLoops);
+  return new (Mem) OMPDependClause(N, NumLoops, IsOmpAllMemory);
 }
 
 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
   assert((getDependencyKind() == OMPC_DEPEND_sink ||
           getDependencyKind() == OMPC_DEPEND_source) &&
          NumLoop < NumLoops &&
          "Expected sink or source depend + loop index must be less number of "
          "loops.");

 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
   OS << "depend(";
   if (Expr *DepModifier = Node->getModifier()) {
     DepModifier->printPretty(OS, nullptr, Policy);
     OS << ", ";
   }
   OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
                                       Node->getDependencyKind());
-  if (!Node->varlist_empty()) {
+  if (!Node->varlist_empty() || Node->getIsOmpAllMemory())
     OS << " :";
-    VisitOMPClauseList(Node, ' ');
+  if (Node->getIsOmpAllMemory()) {
+    OS << (Node->varlist_empty() ? " " : ",");
+    OS << "omp_all_memory";
   }
   OS << ")";
 }
 
 template <typename T>
 static void PrintMapper(raw_ostream &OS, T *Node,
                         const PrintingPolicy &Policy) {
   OS << '(';

clang/lib/Parse/ParseOpenMP.cpp

bool IsComma =
       (Kind == OMPC_depend && Data.ExtraModifier != OMPC_DEPEND_unknown) ||
       (Kind == OMPC_adjust_args &&
        Data.ExtraModifier != OMPC_ADJUST_ARGS_unknown);
   const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned);
   while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) &&
                      Tok.isNot(tok::annot_pragma_openmp_end))) {
     ParseScope OMPListScope(this, Scope::OpenMPDirectiveScope);
     ColonProtectionRAIIObject ColonRAII(*this, MayHaveTail);
+    if (getLangOpts().OpenMP >= 51 && Kind == OMPC_depend &&
+        Tok.is(tok::identifier) &&
+        Tok.getIdentifierInfo()->isStr("omp_all_memory")) {
+      if (Data.ExtraModifier != OMPC_DEPEND_out &&
+          Data.ExtraModifier != OMPC_DEPEND_inout)
+        Diag(Tok, diag::err_omp_requires_out_inout_depend_type);
+      else if (Data.IsOmpAllMemory)
+        Diag(Tok, diag::warn_omp_more_one_omp_all_memory);
+      Data.IsOmpAllMemory = true;
+      ConsumeToken();
+    } else {
       // Parse variable
       ExprResult VarExpr =
           Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
       if (VarExpr.isUsable()) {
         Vars.push_back(VarExpr.get());
       } else {
         SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
                   StopBeforeMatch);
       }
+    }
     // Skip ',' if any
     IsComma = Tok.is(tok::comma);
     if (IsComma)
       ConsumeToken();
     else if (Tok.isNot(tok::r_paren) &&
              Tok.isNot(tok::annot_pragma_openmp_end) &&
              (!MayHaveTail || Tok.isNot(tok::colon)))
       Diag(Tok, diag::err_omp_expected_punc)
OMPClause *Parser::ParseOpenMPVarListClause(OpenMPDirectiveKind DKind,
   if (ParseOnly)
     return nullptr;
   OMPVarListLocTy Locs(Loc, LOpen, Data.RLoc);
   return Actions.ActOnOpenMPVarListClause(
       Kind, Vars, Data.DepModOrTailExpr, Locs, Data.ColonLoc,
       Data.ReductionOrMapperIdScopeSpec, Data.ReductionOrMapperId,
       Data.ExtraModifier, Data.MapTypeModifiers, Data.MapTypeModifiersLoc,
       Data.IsMapTypeImplicit, Data.ExtraModifierLoc, Data.MotionModifiers,
-      Data.MotionModifiersLoc);
+      Data.MotionModifiersLoc, Data.IsOmpAllMemory);
 }

clang/lib/Sema/SemaOpenMP.cpp

OMPClause *Sema::ActOnOpenMPVarListClause(
     OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *DepModOrTailExpr,
     const OMPVarListLocTy &Locs, SourceLocation ColonLoc,
     CXXScopeSpec &ReductionOrMapperIdScopeSpec,
     DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,
     ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
     ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,
     SourceLocation ExtraModifierLoc,
     ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
-    ArrayRef<SourceLocation> MotionModifiersLoc) {
+    ArrayRef<SourceLocation> MotionModifiersLoc, bool IsOmpAllMemory) {
   SourceLocation StartLoc = Locs.StartLoc;
   SourceLocation LParenLoc = Locs.LParenLoc;
   SourceLocation EndLoc = Locs.EndLoc;
   OMPClause *Res = nullptr;
   switch (Kind) {
   case OMPC_private:
     Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc);
     break;
OMPClause *Sema::ActOnOpenMPVarListClause(
   case OMPC_flush:
     Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc);
     break;
   case OMPC_depend:
     assert(0 <= ExtraModifier && ExtraModifier <= OMPC_DEPEND_unknown &&
            "Unexpected depend modifier.");
     Res = ActOnOpenMPDependClause(
         DepModOrTailExpr, static_cast<OpenMPDependClauseKind>(ExtraModifier),
-        ExtraModifierLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc);
+        ExtraModifierLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc,
+        IsOmpAllMemory);
     break;
   case OMPC_map:
     assert(0 <= ExtraModifier && ExtraModifier <= OMPC_MAP_unknown &&
            "Unexpected map modifier.");
     Res = ActOnOpenMPMapClause(
         MapTypeModifiers, MapTypeModifiersLoc, ReductionOrMapperIdScopeSpec,
         ReductionOrMapperId, static_cast<OpenMPMapClauseKind>(ExtraModifier),
         IsMapTypeImplicit, ExtraModifierLoc, ColonLoc, VarList, Locs);
OMPClause *Sema::ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
   if (!Depobj->isLValue()) {
     Diag(Depobj->getExprLoc(), diag::err_omp_expected_omp_depend_t_lvalue)
         << 1 << Depobj->getSourceRange();
   }
 
   return OMPDepobjClause::Create(Context, StartLoc, LParenLoc, EndLoc, Depobj);
 }
 
-OMPClause *
-Sema::ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
-                              SourceLocation DepLoc, SourceLocation ColonLoc,
-                              ArrayRef<Expr *> VarList, SourceLocation StartLoc,
-                              SourceLocation LParenLoc, SourceLocation EndLoc) {
+OMPClause *Sema::ActOnOpenMPDependClause(
+    Expr *DepModifier, OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
+    SourceLocation ColonLoc, ArrayRef<Expr *> VarList, SourceLocation StartLoc,
+    SourceLocation LParenLoc, SourceLocation EndLoc, bool IsOmpAllMemory) {
   if (DSAStack->getCurrentDirective() == OMPD_ordered &&
       DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink) {
     Diag(DepLoc, diag::err_omp_unexpected_clause_value)
         << "'source' or 'sink'" << getOpenMPClauseName(OMPC_depend);
     return nullptr;
   }
   if (DSAStack->getCurrentDirective() == OMPD_taskwait &&
       DepKind == OMPC_DEPEND_mutexinoutset) {
OMPClause *Sema::ActOnOpenMPDependClause(
   if (!CurContext->isDependentContext() && DepKind == OMPC_DEPEND_sink &&
       TotalDepCount > VarList.size() &&
       DSAStack->getParentOrderedRegionParam().first &&
       DSAStack->getParentLoopControlVariable(VarList.size() + 1)) {
     Diag(EndLoc, diag::err_omp_depend_sink_expected_loop_iteration)
         << 1 << DSAStack->getParentLoopControlVariable(VarList.size() + 1);
   }
   if (DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink &&
-      Vars.empty())
+      !IsOmpAllMemory && Vars.empty())
     return nullptr;
 
-  auto *C = OMPDependClause::Create(Context, StartLoc, LParenLoc, EndLoc,
-                                    DepModifier, DepKind, DepLoc, ColonLoc,
-                                    Vars, TotalDepCount.getZExtValue());
+  auto *C = OMPDependClause::Create(
+      Context, StartLoc, LParenLoc, EndLoc, DepModifier, DepKind, DepLoc,
+      ColonLoc, Vars, TotalDepCount.getZExtValue(), IsOmpAllMemory);
   if ((DepKind == OMPC_DEPEND_sink || DepKind == OMPC_DEPEND_source) &&
       DSAStack->isParentOrderedRegion())
     DSAStack->addDoacrossDependClause(C, OpsOffs);
   return C;
 }
 
 OMPClause *Sema::ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
                                          Expr *Device, SourceLocation StartLoc,

clang/lib/Sema/TreeTransform.h

   /// Build a new OpenMP 'depend' pseudo clause.
   ///
   /// By default, performs semantic analysis to build the new OpenMP clause.
   /// Subclasses may override this routine to provide different behavior.
   OMPClause *
   RebuildOMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
                          SourceLocation DepLoc, SourceLocation ColonLoc,
                          ArrayRef<Expr *> VarList, SourceLocation StartLoc,
-                         SourceLocation LParenLoc, SourceLocation EndLoc) {
+                         SourceLocation LParenLoc, SourceLocation EndLoc,
+                         bool IsOmpAllMemory) {
     return getSema().ActOnOpenMPDependClause(DepModifier, DepKind, DepLoc,
                                              ColonLoc, VarList, StartLoc,
-                                             LParenLoc, EndLoc);
+                                             LParenLoc, EndLoc, IsOmpAllMemory);
   }
 
   /// Build a new OpenMP 'device' clause.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   OMPClause *RebuildOMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
                                     Expr *Device, SourceLocation StartLoc,
for (auto *VE : C->varlists()) {
     ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
     if (EVar.isInvalid())
       return nullptr;
     Vars.push_back(EVar.get());
   }
   return getDerived().RebuildOMPDependClause(
       DepModifier, C->getDependencyKind(), C->getDependencyLoc(),
       C->getColonLoc(), Vars, C->getBeginLoc(), C->getLParenLoc(),
-      C->getEndLoc());
+      C->getEndLoc(), C->getIsOmpAllMemory());
 }
 
 template <typename Derived>
 OMPClause *
 TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
   ExprResult E = getDerived().TransformExpr(C->getDevice());
   if (E.isInvalid())
     return nullptr;

clang/lib/Serialization/ASTReader.cpp

case llvm::omp::OMPC_flush:
     C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
     break;
   case llvm::omp::OMPC_depobj:
     C = OMPDepobjClause::CreateEmpty(Context);
     break;
   case llvm::omp::OMPC_depend: {
     unsigned NumVars = Record.readInt();
     unsigned NumLoops = Record.readInt();
-    C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
+    C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops,
+                                     Record.readBool());
     break;
   }
   case llvm::omp::OMPC_device:
     C = new (Context) OMPDeviceClause();
     break;
   case llvm::omp::OMPC_map: {
     OMPMappableExprListSizeTy Sizes;
     Sizes.NumVars = Record.readInt();

clang/lib/Serialization/ASTWriter.cpp

 void OMPClauseWriter::VisitOMPDepobjClause(OMPDepobjClause *C) {
   Record.AddStmt(C->getDepobj());
   Record.AddSourceLocation(C->getLParenLoc());
 }
 
 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) {
   Record.push_back(C->varlist_size());
   Record.push_back(C->getNumLoops());
+  Record.writeBool(C->getIsOmpAllMemory());
   Record.AddSourceLocation(C->getLParenLoc());
   Record.AddStmt(C->getModifier());
   Record.push_back(C->getDependencyKind());
   Record.AddSourceLocation(C->getDependencyLoc());
   Record.AddSourceLocation(C->getColonLoc());
   for (auto *VE : C->varlists())
     Record.AddStmt(VE);
   for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)

clang/test/OpenMP/task_ast_print.cpp

-// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -ast-print %s | FileCheck %s
-// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s
-// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
-
-// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=50 -ast-print %s | FileCheck %s
-// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s
-// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
+// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -ast-print %s | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
+
+// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=51 -ast-print %s | FileCheck %s
+// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 typedef void *omp_depend_t;
 typedef unsigned long omp_event_handle_t;
 
#pragma omp task in_reduction(min: arr1) depend(iterator(i=0:argc, unsigned j=argc:0:a), out: argv[i][j])
   // CHECK-NEXT: #pragma omp parallel reduction(+: arr1)
   // CHECK-NEXT: #pragma omp task in_reduction(min: arr1) depend(iterator(int i = 0:argc, unsigned int j = argc:0:a), out : argv[i][j])
   foo();
   // CHECK-NEXT: foo();
   // CHECK-NEXT: #pragma omp task in_reduction(+: arr1)
 #pragma omp task in_reduction(+: arr1)
   foo();
   // CHECK-NEXT: foo();
+  // CHECK-NEXT: #pragma omp task depend(out : arr,omp_all_memory)
+#pragma omp task depend(out: omp_all_memory, arr)
+  foo();
+  // CHECK-NEXT: foo();
+  // CHECK-NEXT: #pragma omp task depend(inout : b,arr,a,x,omp_all_memory)
+#pragma omp task depend(inout: b, arr, omp_all_memory, a, x)
+  foo();
+  // CHECK-NEXT: foo();
+  // CHECK-NEXT: #pragma omp task depend(inout : omp_all_memory)
+#pragma omp task depend(inout: omp_all_memory)
+  foo();
+  // CHECK-NEXT: foo();
   return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x);
 }
 
 extern template int S<int>::TS;
 extern template long S<long>::TS;
 
 #endif

clang/test/OpenMP/task_depend_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
-// RUN: %clang_cc1 -verify=expected,omp51 -fopenmp-version=51 -fopenmp -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
+// RUN: %clang_cc1 -verify=expected,omp51,omp51warn -fopenmp-version=51 -fopenmp -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp-simd -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp-simd -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
-// RUN: %clang_cc1 -verify=expected,omp51 -fopenmp-version=51 -fopenmp-simd -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
+// RUN: %clang_cc1 -verify=expected,omp51,omp51warn -fopenmp-version=51 -fopenmp-simd -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
 
 typedef void *omp_depend_t;
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
int main(int argc, char **argv, char *env[]) {
   #pragma omp task depend(iterator(vector argc = 0:2):argc) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp50-error {{expected integral or pointer type as the iterator-type, not 'vector'}} omp50-error {{expected depend modifier(iterator) or 'in', 'out', 'inout', 'mutexinoutset' or 'depobj' in OpenMP clause 'depend'}} omp50-error {{expected ','}} omp51-error {{expected integral or pointer type as the iterator-type, not 'vector'}} omp51-error {{expected depend modifier(iterator) or 'in', 'out', 'inout', 'mutexinoutset', 'depobj' or 'inoutset' in OpenMP clause 'depend'}} omp51-error {{expected ','}}
   #pragma omp task depend(iterator(vector *argc = nullptr:nullptr+2:0), in:argc) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp50-error {{invalid operands to binary expression ('std::nullptr_t' and 'int')}} omp50-error {{iterator step expression 0 evaluates to 0}} omp51-error {{invalid operands to binary expression ('std::nullptr_t' and 'int')}} omp51-error {{iterator step expression 0 evaluates to 0}}
   #pragma omp task depend(iterator(vector *argc = 0:vector():argc), in:argc) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp50-error {{converting 'vector' to incompatible type 'vector *'}} omp51-error {{converting 'vector' to incompatible type 'vector *'}}
   foo();
 #pragma omp task depend(iterator(unsigned argc = 0:10), in : argc) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}}
   argc = 0;
 #pragma omp task depend(iterator(i = 0:10, i = 0:10), in : argv[i]) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp45-error {{use of undeclared identifier 'i'}} omp50-error {{redefinition of 'i'}} omp50-note {{previous definition is here}}  omp51-error {{redefinition of 'i'}} omp51-note {{previous definition is here}}
   i = 0; // expected-error {{use of undeclared identifier 'i'}}
-
+#pragma omp task depend(in: argc, omp_all_memory) // omp45-error {{use of undeclared identifier 'omp_all_memory'}} omp50-error {{use of undeclared identifier 'omp_all_memory'}} omp51-error {{reserved locator 'omp_all_memory' requires 'out' or 'inout' dependency types}}
+#pragma omp task depend(out: omp_all_memory, argc, omp_all_memory) // omp45-error {{use of undeclared identifier 'omp_all_memory'}} omp45-error {{use of undeclared identifier 'omp_all_memory'}} omp50-error {{use of undeclared identifier 'omp_all_memory'}} omp50-error {{use of undeclared identifier 'omp_all_memory'}} omp51warn-warning {{reserved locator 'omp_all_memory' cannot be specified more than once}}
+  // expected-error@+1 {{use of undeclared identifier 'omp_all_memory'}}
+#pragma omp task depend(out: argc) private(argc) allocate(argc, omp_all_memory)
+  argc = 0;
   return 0;
 }