Meta directive runtime support

[abidmalikwaterloo]

Summary

The patch extends the current implementation
for runtime support. The current patch build AST
of the when clauses in sorted order using the
context selector score

[jdoerfert]

This contains a lot of unrelated changes, leftover comments, etc. As you clean up the code, please also include tests. Clang format the patch, go over the new code and make sure you follow the coding style. Remove unneeded parts (e.g., a map into which you simply push objects then take them out to push them into a vector).

Also, have you seen D120573?

[abidmalikwaterloo]

I quickly went through the D120573. There are many overlapping.

[abidmalikwaterloo]

Is it okay if I can put comments on the patch?

[jdoerfert]

In D122255#3400636, @abidmalikwaterloo wrote:

Is it okay if I can put comments on the patch?

Not sure what you mean but feel free.

[abidmalikwaterloo]

would it make sense to submit separate patches for when (OMPC_when) and otherwise (OMPC_otherwise) clauses? The D120573 also has OMPC_when support.

[abidmalikwaterloo]

There should be an update to D122255. It should not create the new one.D123598
--->
I did the following :
arc patch D122255
"did something/cleaning"
git commit -a
arc diff
---->

[abidmalikwaterloo]

I update it but it created a new patch D123598.
I marked it Abandon. Not sure how to delete it.
I am submitting it again after cleaning the codes
and adding some basic tests.

[abidmalikwaterloo]

Added tests

[abidmalikwaterloo]

The last update removed all previous updates. Can you point me to the correct way to do it?
I did the following :
arc patch D122255
"did something/cleaning"
git commit -a --amend
arc diff

[abidmalikwaterloo]

Cleaned the code and added tests.

[abidmalikwaterloo]

Should I update the patch? I am waiting for quick feedback on the concept of handling conditions.

[ABataev]

clang/include/clang/AST/OpenMPClause.h

8980

condition?

9014–9015

make it private

9021

const

9026

const

clang/include/clang/AST/StmtOpenMP.h

5889

Remove this change

clang/include/clang/Basic/DiagnosticSemaKinds.td

11085

We do not use explamations in messages, better to have something only single default ...

clang/include/clang/Sema/Sema.h

11212

Comment for this new function

11721

formatting

clang/lib/AST/OpenMPClause.cpp

1675–1678

Is this correct? Just default( is expected to be printed?

clang/lib/AST/StmtPrinter.cpp

720

Do not insert empty line here

721–722

formatting

726

use isa

728

Camel naming style expceted

729

formatting, use nullptr instead of NULL (or just C)

730

Formatting

clang/lib/Parse/ParseOpenMP.cpp

2488

What is this?

2539

Restore original code here

2562–2571

Remove this extra stuff

2618

What A stands after, what does it mean?

[abidmalikwaterloo]

clang/include/clang/AST/OpenMPClause.h

9014–9015

Any reason behind this? I went through other classes, this function is public in some and private in some.

[ABataev]

clang/include/clang/AST/OpenMPClause.h

9014–9015

The AST is immutable, such functions are/must be used in very rare places.

[abidmalikwaterloo]

Updated and clean the code based on the comments from
the reviewer!

[abidmalikwaterloo]

Ping!

clang/lib/AST/OpenMPClause.cpp

1675–1678

This function is called from StmtPrinter::PrintOMPExecutableDirective in StmtPrinter.CPP. The enclosed Directive and the second matching brace will be printed. See line # 670 in StmtPrinter.CPP

clang/lib/Parse/ParseOpenMP.cpp

2488

comment removed

[jdoerfert]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11085

"allowed in" what? Also, there is no test for this, or is there?

clang/lib/AST/OpenMPClause.cpp

1675–1678

The problem is this doesn't make sense. For one, StmtPrinter calls this function conditionally, so you might end up with a lonely closing parenthesis. Also, why would we split the parenthesis into two places?

1740

I'm assuming we already have a printer for trait selectors, no? Doesn't OMPTraitInfo::print do this already and actually handle scores?

clang/lib/AST/StmtPrinter.cpp

728

clang/lib/Parse/ParseOpenMP.cpp

2539

There are plenty of formatting changes in this file and elsewhere. Please retore the original code or properly clang-format the patch.

2619

typo

2669

We don't use comments like these.

2710

This seems to be copied from somewhere. It is unclear why a metadirective needs to have an associated openmp region.

clang/lib/Sema/SemaOpenMP.cpp

4945

Still unrelated newlines.

7751

Code style, ArchMatch.

7800

Why does this perform partial trait matching? We should have code for this. Also, the logic for device_arch and vendor (which is most what there is), is not what we want. Reuse the existing matching logic instead.

clang/lib/Sema/SemaStmt.cpp

4826

Unrelated. Please go over the patch and avoid these in the future. We have so many comments that point out these things that now the comments make it hard to read/review.

clang/test/OpenMP/metadirective_ast_print_new_1.cpp

21

I doubt clang format handles the metadirective well but maybe format the code first without the pragma. This is hard to read. Also the other tests.

You only have ast print tests, what about the rest? Messages (errors/warnings) and codegen?

llvm/lib/Frontend/OpenMP/OMPContext.cpp

375

This does not sort scores properly and for some reason uses a Map as a intermediate storage.
Instead, please combine this with the function below, which already has a proper score comparator.

[abidmalikwaterloo]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11085

It should be "Only one default clause is allowed.

clang/lib/AST/OpenMPClause.cpp

1740

Looked into the function. OMPTraitInfo::print can be used. The function needs to be extended as well to take the other traits as well.

clang/lib/Sema/SemaOpenMP.cpp

7800

Ok. What do you mean by existing matching logic?

clang/lib/Sema/SemaStmt.cpp

4826

An accidental tap. Removed

[abidmalikwaterloo]

clang/include/clang/AST/RecursiveASTVisitor.h

3281

If it is not the user's condition or score then what will happen?

clang/lib/Sema/SemaOpenMP.cpp

7800

@jdoerfert I agree that the implementation is incomplete in terms of trait matching. It can be completed. However, I am not clear about your comments about the existing matching logic. I checked OMPContext.CPP and other files. There are functions that can be used to match the traits. But, I could not find any existing logic that can be used here.

[jdoerfert]

clang/lib/AST/OpenMPClause.cpp

1740

The function needs to be extended as well to take the other traits as well.

What traits are not handled there?

clang/lib/Sema/SemaOpenMP.cpp

7800

I mean getBestVariantMatchForContext and similar functions in llvm/lib/Frontend/OpenMP/OMPContext.cpp.

[abidmalikwaterloo]

I will work on the patch in parts. I am planning to submit taking care of comments except for comments for SemaOpenMP and code generation.

clang/lib/AST/OpenMPClause.cpp

1740

No. It handles everything in terms of printing. I have updated the code. Will upload it as well.

clang/lib/Parse/ParseOpenMP.cpp

2710

correcrted.

clang/lib/Sema/SemaOpenMP.cpp

7800

OK.

[abidmalikwaterloo]

Updated the PrintStmt.cpp according to the comments

[ABataev]

clang/lib/AST/OpenMPClause.cpp

20

Remove empty comment

1680–1681

if (Stmt *S = Node->getDirective())

2526–2534

Remove those empty new lines

[abidmalikwaterloo]

Clean the formatting comments. The patch is out of attention
for a while. Still need to work on the context selector part
as a next step.

[abidmalikwaterloo]

Rebase the patch to origin/main with all updates. Made changes
to make it buildable using the new changes.
(WIP).

clang/include/clang/AST/OpenMPClause.h

 template <typename T> using const_ptr = std::add_pointer_t<std::add_const_t<T>>;
 
 template <class ImplClass, typename RetTy = void>
 class OMPClauseVisitor
     : public OMPClauseVisitorBase<ImplClass, std::add_pointer_t, RetTy> {};
 template<class ImplClass, typename RetTy = void>
 class ConstOMPClauseVisitor :
       public OMPClauseVisitorBase <ImplClass, const_ptr, RetTy> {};
          
-class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
-  raw_ostream &OS;
-  const PrintingPolicy &Policy;
-
-  /// Process clauses with list of variables.
-  template <typename T> void VisitOMPClauseList(T *Node, char StartSym);
-  /// Process motion clauses.
-  template <typename T> void VisitOMPMotionClause(T *Node);
-
-public:
-  OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
-      : OS(OS), Policy(Policy) {}
-
-#define GEN_CLANG_CLAUSE_CLASS
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
-#include "llvm/Frontend/OpenMP/OMP.inc"
-};
-
 struct OMPTraitProperty {
   llvm::omp::TraitProperty Kind = llvm::omp::TraitProperty::invalid;
 
   /// The raw string as we parsed it. This is needed for the `isa` trait set
   /// (which accepts anything) and (later) extensions.
   StringRef RawString;
 };
 struct OMPTraitSelector {
public:
   Stmt::child_range getAssociatedStmtAsRange() {
     if (!HasAssociatedStmt)
       return Stmt::child_range(Stmt::child_iterator(), Stmt::child_iterator());
     return Stmt::child_range(&getTrailingObjects<Stmt *>()[NumChildren],
                              &getTrailingObjects<Stmt *>()[NumChildren + 1]);
   }
 };
 
+/// This captures 'when' clause in the '#pragma omp metadirective'
+/// \code
+/// #pragma omp metadirective when(user={condition(N<100)}:parallel for)
+/// \endcode
+/// In the above example, the metadirective has a condition clause which when
+/// satisfied will use the parallel for directive with the code enclosed by the
+/// directive.
+class OMPWhenClause final : public OMPClause {
+  friend class OMPClauseReader;
+  friend class OMPExecutableDirective;
+  template <typename T> friend class OMPDeclarativeDirective; 
+
+  OMPTraitInfo *TI;
+  OpenMPDirectiveKind DKind;
+  Stmt *Directive;
+
+  /// Location of '('.
+  SourceLocation LParenLoc;
+  
+  /// Sets the location of '('.
+  ///
+  /// \param Loc Location of '('.
+  void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
+
+public:
+  /// Build 'when' clause with argument \a A ('none' or 'shared').
+  ///
+  /// \param T TraitInfor containing information about the context selector
+  /// \param DKind The directive associated with the when clause
+  /// \param D The statement associated with the when clause
+  /// \param StartLoc Starting location of the clause.
+  /// \param LParenLoc Location of '('.
+  /// \param EndLoc Ending location of the clause.
+  OMPWhenClause(OMPTraitInfo &T, OpenMPDirectiveKind dKind, Stmt *D,
+                SourceLocation StartLoc, SourceLocation LParenLoc,
+                SourceLocation EndLoc)
+      : OMPClause(llvm::omp::OMPC_when, StartLoc, EndLoc), TI(&T), DKind(dKind),
+        Directive(D), LParenLoc(LParenLoc) {}
+
+  /// Build an empty clause.
+  OMPWhenClause()
+      : OMPClause(llvm::omp::OMPC_when, SourceLocation(), SourceLocation()) {}
+
+  /// Returns the location of '('.
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+
+  /// Returns the directive variant kind
+  OpenMPDirectiveKind getDKind() const { return DKind; }
+
+  Stmt *getDirective() const { return Directive; }
+
+  /// Returns the OMPTraitInfo
+  OMPTraitInfo &getTI() const { return *TI; }
+
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+  child_range used_children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+  const_child_range used_children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  static bool classof(const OMPClause *T) {
+    return T->getClauseKind() == llvm::omp::OMPC_when;
+  }
+};
+
+class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
+  raw_ostream &OS;
+  const PrintingPolicy &Policy;
+
+  /// Process clauses with list of variables.
+  template <typename T> void VisitOMPClauseList(T *Node, char StartSym);
+  /// Process motion clauses.
+  template <typename T> void VisitOMPMotionClause(T *Node);
+
+public:
+  OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
+      : OS(OS), Policy(Policy) {}
+      
+  void VisitOMPWhenClause(OMPWhenClause *Node);
+  
+#define GEN_CLANG_CLAUSE_CLASS
+#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
+#include "llvm/Frontend/OpenMP/OMP.inc"
+};
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_OPENMPCLAUSE_H

clang/include/clang/AST/RecursiveASTVisitor.h

 #define GEN_CLANG_CLAUSE_CLASS
 #define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);
 #include "llvm/Frontend/OpenMP/OMP.inc"
   /// Process clauses with list of variables.
   template <typename T> bool VisitOMPClauseList(T *Node);
   /// Process clauses with pre-initis.
   bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);
   bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);
+  bool VisitOMPWhenClause(OMPWhenClause *C);
   
   bool PostVisitStmt(Stmt *S);
 };
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseTypeConstraint(
     const TypeConstraint *C) {
   if (!getDerived().shouldVisitImplicitCode()) {
     TRY_TO(TraverseConceptReferenceHelper(*C));

 template <typename Derived>
 bool
 RecursiveASTVisitor<Derived>::VisitOMPCollapseClause(OMPCollapseClause *C) {
   TRY_TO(TraverseStmt(C->getNumForLoops()));
   return true;
 }
 
 template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitOMPWhenClause(OMPWhenClause *C) {
+  for (const OMPTraitSet &Set : C->getTI().Sets) {
+    for (const OMPTraitSelector &Selector : Set.Selectors) {
+      if (Selector.Kind == llvm::omp::TraitSelector::user_condition &&
+          Selector.ScoreOrCondition)
+        TRY_TO(TraverseStmt(Selector.ScoreOrCondition));
+    }
+  }
+  return true;
+}
+
+template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *) {
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPProcBindClause(OMPProcBindClause *) {
   return true;
 }

clang/include/clang/AST/StmtOpenMP.h

protected:
   OMPExecutableDirective(StmtClass SC, OpenMPDirectiveKind K,
                          SourceLocation StartLoc, SourceLocation EndLoc)
       : Stmt(SC), Kind(K), StartLoc(std::move(StartLoc)),
         EndLoc(std::move(EndLoc)) {}
 
   template <typename T, typename... Params>
   static T *createDirective(const ASTContext &C, ArrayRef<OMPClause *> Clauses,
                             Stmt *AssociatedStmt, unsigned NumChildren,
-                            Params &&... P) {
+                            Params &&...P) {
     void *Mem =
         C.Allocate(sizeof(T) + OMPChildren::size(Clauses.size(), AssociatedStmt,
                                                  NumChildren),
                    alignof(T));
 
     auto *Data = OMPChildren::Create(reinterpret_cast<T *>(Mem) + 1, Clauses,
                                      AssociatedStmt, NumChildren);
     auto *Inst = new (Mem) T(std::forward<Params>(P)...);
     Inst->Data = Data;
     return Inst;
   }
 
   template <typename T, typename... Params>
   static T *createEmptyDirective(const ASTContext &C, unsigned NumClauses,
                                  bool HasAssociatedStmt, unsigned NumChildren,
-                                 Params &&... P) {
+                                 Params &&...P) {
     void *Mem =
         C.Allocate(sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
                                                  NumChildren),
                    alignof(T));
     auto *Data =
         OMPChildren::CreateEmpty(reinterpret_cast<T *>(Mem) + 1, NumClauses,
                                  HasAssociatedStmt, NumChildren);
     auto *Inst = new (Mem) T(std::forward<Params>(P)...);
public:
 
   template <typename SpecificClause>
   const SpecificClause *getSingleClause() const {
     return getSingleClause<SpecificClause>(clauses());
   }
 
   /// Returns true if the current directive has one or more clauses of a
   /// specific kind.
-  template <typename SpecificClause>
-  bool hasClausesOfKind() const {
+  template <typename SpecificClause> bool hasClausesOfKind() const {
     auto Clauses = getClausesOfKind<SpecificClause>();
     return Clauses.begin() != Clauses.end();
   }
 
   /// Returns starting location of directive kind.
   SourceLocation getBeginLoc() const { return StartLoc; }
   /// Returns ending location of directive.
   SourceLocation getEndLoc() const { return EndLoc; }
public:
   /// Creates an empty directive.
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPTaskgroupDirective *CreateEmpty(const ASTContext &C,
                                             unsigned NumClauses, EmptyShell);
 
-
   /// Returns reference to the task_reduction return variable.
   const Expr *getReductionRef() const {
     return const_cast<OMPTaskgroupDirective *>(this)->getReductionRef();
   }
   Expr *getReductionRef() { return cast_or_null<Expr>(Data->getChildren()[0]); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPTaskgroupDirectiveClass;
public:
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.
   /// \param Clauses List of clauses.
   /// \param AssociatedStmt Statement, associated with the directive.
   /// \param Exprs Helper expressions for CodeGen.
   ///
-  static OMPDistributeParallelForSimdDirective *Create(
-      const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+  static OMPDistributeParallelForSimdDirective *
+  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
          unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
          Stmt *AssociatedStmt, const HelperExprs &Exprs);
 
   /// Creates an empty directive with the place for \a NumClauses clauses.
   ///
   /// \param C AST context.
   /// \param CollapsedNum Number of collapsed nested loops.
   /// \param NumClauses Number of clauses.
   ///
-  static OMPDistributeParallelForSimdDirective *CreateEmpty(
-      const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
+  static OMPDistributeParallelForSimdDirective *
+  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
               EmptyShell);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPDistributeParallelForSimdDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp distribute simd' composite directive.
 ///
public:
   /// Creates an empty directive with the place for \a NumClauses clauses.
   ///
   /// \param C AST context.
   /// \param CollapsedNum Number of collapsed nested loops.
   /// \param NumClauses Number of clauses.
   ///
   static OMPTargetSimdDirective *CreateEmpty(const ASTContext &C,
                                              unsigned NumClauses,
-                                             unsigned CollapsedNum,
-                                             EmptyShell);
+                                             unsigned CollapsedNum, EmptyShell);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPTargetSimdDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp teams distribute' directive.
 ///
public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.
   /// \param AssociatedStmt Statement, associated with the directive.
   ///
-  static OMPTargetTeamsDirective *Create(const ASTContext &C,
-                                         SourceLocation StartLoc,
-                                         SourceLocation EndLoc,
-                                         ArrayRef<OMPClause *> Clauses,
-                                         Stmt *AssociatedStmt);
+  static OMPTargetTeamsDirective *
+  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+         ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
 
   /// Creates an empty directive with the place for \a NumClauses clauses.
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPTargetTeamsDirective *CreateEmpty(const ASTContext &C,
                                               unsigned NumClauses, EmptyShell);
Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
          Stmt *AssociatedStmt, const HelperExprs &Exprs);
 
   /// Creates an empty directive with the place for \a NumClauses clauses.
   ///
   /// \param C AST context.
   /// \param CollapsedNum Number of collapsed nested loops.
   /// \param NumClauses Number of clauses.
   ///
-  static OMPTargetTeamsDistributeDirective *
-  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
+  static OMPTargetTeamsDistributeDirective *CreateEmpty(const ASTContext &C,
+                                                        unsigned NumClauses,
+                                                        unsigned CollapsedNum,
                                                         EmptyShell);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPTargetTeamsDistributeDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp target teams distribute parallel for' combined
 /// directive.

 
 public:
   static OMPMetaDirective *Create(const ASTContext &C, SourceLocation StartLoc,
                                   SourceLocation EndLoc,
                                   ArrayRef<OMPClause *> Clauses,
                                   Stmt *AssociatedStmt, Stmt *IfStmt);
   static OMPMetaDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                        EmptyShell);
   Stmt *getIfStmt() const { return IfStmt; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPMetaDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp loop' directive.
 ///

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_omp_instantiation_not_supported
     : Error<"instantiation of '%0' not supported yet">;
 def err_omp_adjust_arg_multiple_clauses : Error<
   "'adjust_arg' argument %0 used in multiple clauses">;
 def err_omp_clause_requires_dispatch_construct : Error<
   "'%0' clause requires 'dispatch' context selector">;
 def err_omp_append_args_with_varargs : Error<
   "'append_args' is not allowed with varargs functions">;
 def err_openmp_vla_in_task_untied : Error<
   "variable length arrays are not supported in OpenMP tasking regions with 'untied' clause">;
 def warn_omp_unterminated_declare_target : Warning<
   "expected '#pragma omp end declare target' at end of file to match '#pragma omp %0'">,
   InGroup<SourceUsesOpenMP>;
+def err_omp_misplaced_default_clause : Error<
+  "Only one 'default clause' is allowed">;
 } // end of OpenMP category
 
 let CategoryName = "Related Result Type Issue" in {
 // Objective-C related result type compatibility
 def warn_related_result_type_compatibility_class : Warning<
   "method is expected to return an instance of its class type "
   "%diff{$, but is declared to return $|"
   ", but is declared to return different type}0,1">;

clang/include/clang/Parse/Parser.h

bool ParseOpenMPSimpleVarList(
       bool AllowScopeSpecifier);
   /// Parses declarative or executable directive.
   ///
   /// \param StmtCtx The context in which we're parsing the directive.
   /// \param ReadDirectiveWithinMetadirective true if directive is within a
   /// metadirective and therefore ends on the closing paren.
   StmtResult ParseOpenMPDeclarativeOrExecutableDirective(
       ParsedStmtContext StmtCtx, bool ReadDirectiveWithinMetadirective = false);
+
+  /// Parse clause for metadirective
+  ///
+  /// \param Dkind Kind of current directive
+  /// \param CKind Kind of current clause
+  /// 
+  OMPClause *ParseOpenMPMetaDirectiveClause(OpenMPDirectiveKind DKind,
+                                            OpenMPClauseKind CKind);
   /// Parses clause of kind \a CKind for directive of a kind \a Kind.
   ///
   /// \param DKind Kind of current directive.
   /// \param CKind Kind of current clause.
   /// \param FirstClause true, if this is the first clause of a kind \a CKind
   /// in current directive.
   ///
   OMPClause *ParseOpenMPClause(OpenMPDirectiveKind DKind,

clang/include/clang/Sema/Sema.h

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
+#include "llvm/Frontend/OpenMP/OMPContext.h"
 #include <deque>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <vector>
 
 namespace llvm {
   class APSInt;
public:
 
   /// End of OpenMP region.
   ///
   /// \param S Statement associated with the current OpenMP region.
   /// \param Clauses List of clauses for the current OpenMP region.
   ///
   /// \returns Statement for finished OpenMP region.
   StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
+  
+  /// Called on well-formed
   StmtResult ActOnOpenMPExecutableDirective(
       OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
       OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
       Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
+   
+  /// Called on meta directive    
+  StmtResult ActOnOpenMPExecutableMetaDirective( 
+      OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, 
+      OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
+      Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
   /// Called on well-formed '\#pragma omp parallel' after parsing
   /// of the  associated statement.
   StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                           Stmt *AStmt,
                                           SourceLocation StartLoc,
                                           SourceLocation EndLoc);
   using VarsWithInheritedDSAType =
       llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;
public:
 
   OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
                                      unsigned Argument,
                                      SourceLocation ArgumentLoc,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'when' clause.
-  OMPClause *ActOnOpenMPWhenClause(OMPTraitInfo &TI, SourceLocation StartLoc,
+  OMPClause *ActOnOpenMPWhenClause(OMPTraitInfo &TI, OpenMPDirectiveKind DKind,
+                                   StmtResult Directive,
+                                   SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc);
   /// Called on well-formed 'default' clause.
   OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,
                                       SourceLocation KindLoc,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc);

clang/lib/AST/OpenMPClause.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclOpenMP.h"
+#include "clang/AST/StmtOpenMP.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace clang;
const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
   return nullptr;
 }
 
 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
   auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
   return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
 }
 
-const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
+const OMPClauseWithPostUpdate *
+OMPClauseWithPostUpdate::get(const OMPClause *C) {
   switch (C->getClauseKind()) {
   case OMPC_lastprivate:
     return static_cast<const OMPLastprivateClause *>(C);
   case OMPC_reduction:
     return static_cast<const OMPReductionClause *>(C);
   case OMPC_task_reduction:
     return static_cast<const OMPTaskReductionClause *>(C);
   case OMPC_in_reduction:
OMPLinearClause *OMPLinearClause::Create(
   Clause->setPostUpdateExpr(PostUpdate);
   return Clause;
 }
 
 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
                                               unsigned NumVars) {
   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
   // (Step and CalcStep), list of used expression + step.
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars  +1));
+  void *Mem =
+      C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars + 1));
   return new (Mem) OMPLinearClause(NumVars);
 }
 
 OMPClause::child_range OMPLinearClause::used_children() {
   // Range includes only non-nullptr elements.
   return child_range(
       reinterpret_cast<Stmt **>(getUsedExprs().begin()),
       reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr)));
OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
   OMPDependClause *Clause = new (Mem)
       OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
   Clause->setDependencyKind(Data.DepKind);
   Clause->setDependencyLoc(Data.DepLoc);
   Clause->setColonLoc(Data.ColonLoc);
   Clause->setOmpAllMemoryLoc(Data.OmpAllMemoryLoc);
   Clause->setModifier(DepModifier);
   Clause->setVarRefs(VL);
-  for (unsigned I = 0 ; I < NumLoops; ++I)
+  for (unsigned I = 0; I < NumLoops; ++I)
     Clause->setLoopData(I, nullptr);
   return Clause;
 }
 
 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
                                               unsigned NumLoops) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<Expr *>(N + /*depend-modifier*/ 1 + NumLoops),

 
 OMPBindClause *OMPBindClause::CreateEmpty(const ASTContext &C) {
   return new (C) OMPBindClause();
 }
 //===----------------------------------------------------------------------===//
 //  OpenMP clauses printing methods
 //===----------------------------------------------------------------------===//
 
+void OMPClausePrinter::VisitOMPWhenClause(OMPWhenClause *Node) {
+  OMPTraitInfo &TI = Node->getTI();
+  if (TI.Sets.empty())
+    OS << "default(";
+  else
+    OS << "when(";
+  TI.print(OS, Policy);
+
+  if (Stmt *S = Node->getDirective()) {
+    OS << ":";
+    OMPExecutableDirective *D = cast<OMPExecutableDirective>(S);
+    auto DKind = D->getDirectiveKind();
+    OS << getOpenMPDirectiveName(DKind);
+
+    OMPClausePrinter Printer(OS, Policy);
+    ArrayRef<OMPClause *> Clauses = D->clauses();
+    for (auto *Clause : Clauses)
+      if (Clause && !Clause->isImplicit()) {
+        OS << ' ';
+        Printer.Visit(Clause);
+      }
+  }
+  OS << ")";
+}
+
 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
   OS << "if(";
   if (Node->getNameModifier() != OMPD_unknown)
     OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
   OS << ")";
 }
 
void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
   Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
   OS << ")";
 }
 
 void OMPClausePrinter::VisitOMPSizesClause(OMPSizesClause *Node) {
   OS << "sizes(";
   bool First = true;
   for (auto *Size : Node->getSizesRefs()) {
     if (!First)
       OS << ", ";
     Size->printPretty(OS, nullptr, Policy, 0);
     First = false;
   }
   OS << ")";
 }
 
 void OMPClausePrinter::VisitOMPFullClause(OMPFullClause *Node) { OS << "full"; }
void OMPClausePrinter::VisitOMPNocontextClause(OMPNocontextClause *Node) {
   OS << "nocontext";
   if (Expr *E = Node->getCondition()) {
     OS << "(";
     E->printPretty(OS, nullptr, Policy, 0);
     OS << ")";
   }
 }
 
-template<typename T>
+template <typename T>
 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
   for (typename T::varlist_iterator I = Node->varlist_begin(),
                                     E = Node->varlist_end();
        I != E; ++I) {
     assert(*I && "Expected non-null Stmt");
     OS << (I == Node->varlist_begin() ? StartSym : ',');
     if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
       if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
   VisitOMPMotionClause(Node);
 }
 
 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
   VisitOMPMotionClause(Node);
 }
 
 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
-  OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
-                           OMPC_dist_schedule, Node->getDistScheduleKind());
+  OS << "dist_schedule("
+     << getOpenMPSimpleClauseTypeName(OMPC_dist_schedule,
+                                      Node->getDistScheduleKind());
   if (auto *E = Node->getChunkSize()) {
     OS << ", ";
     E->printPretty(OS, nullptr, Policy);
   }
   OS << ")";
 }
 
 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {

 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
   if (!Node->varlist_empty()) {
     OS << "is_device_ptr";
     VisitOMPClauseList(Node, '(');
     OS << ")";
   }
 }
 
-void OMPClausePrinter::VisitOMPHasDeviceAddrClause(OMPHasDeviceAddrClause *Node) {
+void OMPClausePrinter::VisitOMPHasDeviceAddrClause(
+    OMPHasDeviceAddrClause *Node) {
   if (!Node->varlist_empty()) {
     OS << "has_device_addr";
     VisitOMPClauseList(Node, '(');
     OS << ")";
   }
 }
 
 void OMPClausePrinter::VisitOMPNontemporalClause(OMPNontemporalClause *Node) {
for (const OMPTraitSelector &Selector : Set.Selectors) {
         VMI.addTrait(Set.Kind, Property.Kind, Property.RawString, ScorePtr);
 
       if (Set.Kind != TraitSet::construct)
         continue;
 
       // TODO: This might not hold once we implement SIMD properly.
       assert(Selector.Properties.size() == 1 &&
              Selector.Properties.front().Kind ==
-                 getOpenMPContextTraitPropertyForSelector(
-                     Selector.Kind) &&
+                 getOpenMPContextTraitPropertyForSelector(Selector.Kind) &&
              "Ill-formed construct selector!");
     }
   }
 }
 
 void OMPTraitInfo::print(llvm::raw_ostream &OS,
                          const PrintingPolicy &Policy) const {
   bool FirstSet = true;
   for (const OMPTraitSet &Set : Sets) {
     if (!FirstSet)
       OS << ", ";
     FirstSet = false;
     OS << getOpenMPContextTraitSetName(Set.Kind) << "={";
 
     bool FirstSelector = true;
     for (const OMPTraitSelector &Selector : Set.Selectors) {
       if (!FirstSelector)
         OS << ", ";
       FirstSelector = false;
       OS << getOpenMPContextTraitSelectorName(Selector.Kind);
 
       bool AllowsTraitScore = false;
       bool RequiresProperty = false;
-      isValidTraitSelectorForTraitSet(
-          Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
+      isValidTraitSelectorForTraitSet(Selector.Kind, Set.Kind, AllowsTraitScore,
+                                      RequiresProperty);
 
       if (!RequiresProperty)
         continue;
 
       OS << "(";
       if (Selector.Kind == TraitSelector::user_condition) {
         if (Selector.ScoreOrCondition)
           Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy);
std::string OMPTraitInfo::getMangledName() const {
   std::string MangledName;
   llvm::raw_string_ostream OS(MangledName);
   for (const OMPTraitSet &Set : Sets) {
     OS << '$' << 'S' << unsigned(Set.Kind);
     for (const OMPTraitSelector &Selector : Set.Selectors) {
 
       bool AllowsTraitScore = false;
       bool RequiresProperty = false;
-      isValidTraitSelectorForTraitSet(
-          Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
+      isValidTraitSelectorForTraitSet(Selector.Kind, Set.Kind, AllowsTraitScore,
+                                      RequiresProperty);
       OS << '$' << 's' << unsigned(Selector.Kind);
 
-      if (!RequiresProperty ||
-          Selector.Kind == TraitSelector::user_condition)
+      if (!RequiresProperty || Selector.Kind == TraitSelector::user_condition)
         continue;
 
       for (const OMPTraitProperty &Property : Selector.Properties)
         OS << '$' << 'P'
            << getOpenMPContextTraitPropertyName(Property.Kind,
                                                 Property.RawString);
     }
   }

clang/lib/AST/StmtPrinter.cpp

 //===----------------------------------------------------------------------===//
 
 void StmtPrinter::VisitOMPCanonicalLoop(OMPCanonicalLoop *Node) {
   PrintStmt(Node->getLoopStmt());
 }
 
 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
                                               bool ForceNoStmt) {
   OMPClausePrinter Printer(OS, Policy);
   ArrayRef<OMPClause *> Clauses = S->clauses();
-  for (auto *Clause : Clauses)
-    if (Clause && !Clause->isImplicit()) {
+  for (auto *Clause : Clauses){    
+    if (Clause && !Clause->isImplicit()){
       OS << ' ';
       Printer.Visit(Clause);
-    }
+      if (isa<OMPMetaDirective>(S)){
+        OMPWhenClause *WhenClause = dyn_cast<OMPWhenClause>(Clause);
+        if (WhenClause!=nullptr){
+          if (WhenClause->getDKind() != llvm::omp::OMPD_unknown){
+            Printer.VisitOMPWhenClause(WhenClause);
+            }
+         }
+      }
+    } 
   OS << NL;
   if (!ForceNoStmt && S->hasAssociatedStmt())
     PrintStmt(S->getRawStmt());
 }
 
 void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) {
   Indent() << "#pragma omp metadirective";
   PrintOMPExecutableDirective(Node);

clang/lib/Parse/ParseOpenMP.cpp

 ///         'distribute paralle for simd' | 'distribute simd' | 'target parallel
 ///         for simd' | 'target simd' | 'teams distribute' | 'teams distribute
 ///         simd' | 'teams distribute parallel for simd' | 'teams distribute
 ///         parallel for' | 'target teams' | 'target teams distribute' | 'target
 ///         teams distribute parallel for' | 'target teams distribute parallel
 ///         for simd' | 'target teams distribute simd' | 'masked' {clause}
 ///         annot_pragma_openmp_end
 ///
 StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective(
     ParsedStmtContext StmtCtx, bool ReadDirectiveWithinMetadirective) {
   if (!ReadDirectiveWithinMetadirective)
     assert(Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&
            "Not an OpenMP directive!");
   ParsingOpenMPDirectiveRAII DirScope(*this);
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
   SmallVector<OMPClause *, 5> Clauses;
   SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
case OMPD_metadirective: {
     // First iteration of parsing all clauses of metadirective.
     // This iteration only parses and collects all context selector ignoring the
     // associated directives.
     TentativeParsingAction TPA(*this);
     ASTContext &ASTContext = Actions.getASTContext();
 
     BalancedDelimiterTracker T(*this, tok::l_paren,
                                tok::annot_pragma_openmp_end);
+                                                          
     while (Tok.isNot(tok::annot_pragma_openmp_end)) {
       OpenMPClauseKind CKind = Tok.isAnnotation()
                                    ? OMPC_unknown
                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
+                                   
       SourceLocation Loc = ConsumeToken();
 
       // Parse '('.
       if (T.expectAndConsume(diag::err_expected_lparen_after,
                              getOpenMPClauseName(CKind).data()))
         return Directive;
 
       OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
       if (CKind == OMPC_when) {
         // parse and get OMPTraitInfo to pass to the When clause
         parseOMPContextSelectors(Loc, TI);
         if (TI.Sets.size() == 0) {
           Diag(Tok, diag::err_omp_expected_context_selector) << "when clause";
           TPA.Commit();
           return Directive;
         }
 
-        // Parse ':'
+        // Parse ':' // You have parsed the OpenMP Context in the meta directive 
         if (Tok.is(tok::colon))
           ConsumeAnyToken();
         else {
           Diag(Tok, diag::err_omp_expected_colon) << "when clause";
           TPA.Commit();
           return Directive;
         }
       }
+      
       // Skip Directive for now. We will parse directive in the second iteration
       int paren = 0;
       while (Tok.isNot(tok::r_paren) || paren != 0) {
         if (Tok.is(tok::l_paren))
           paren++;
         if (Tok.is(tok::r_paren))
           paren--;
         if (Tok.is(tok::annot_pragma_openmp_end)) {
           Diag(Tok, diag::err_omp_expected_punc)
               << getOpenMPClauseName(CKind) << 0;
           TPA.Commit();
           return Directive;
         }
-        ConsumeAnyToken();
-      }
+        ConsumeAnyToken();  
+      } 
+      
       // Parse ')'
       if (Tok.is(tok::r_paren))
         T.consumeClose();
       
       VariantMatchInfo VMI;
       TI.getAsVariantMatchInfo(ASTContext, VMI);
       
-      VMIs.push_back(VMI);
-    }
+      if (CKind == OMPC_when )  
+         VMIs.push_back(VMI);
+    } 
     
+    // This is the end of the first iteration
+    // The pointer is moved back
     TPA.Revert();
     // End of the first iteration. Parser is reset to the start of metadirective
 
+
     std::function<void(StringRef)> DiagUnknownTrait =
         [this, Loc](StringRef ISATrait) {
           // TODO Track the selector locations in a way that is accessible here
           // to improve the diagnostic location.
           Diag(Loc, diag::warn_unknown_declare_variant_isa_trait) << ISATrait;
         };
-    TargetOMPContext OMPCtx(ASTContext, std::move(DiagUnknownTrait),
+    // TargetOMPContext OMPCtx(ASTContext, std::move(DiagUnknownTrait),
+
+    TargetOMPContext OMPCtx(ASTContext, /* DiagUnknownTrait */ nullptr,
                             /* CurrentFunctionDecl */ nullptr,
                             ArrayRef<llvm::omp::TraitProperty>());
     
-    // A single match is returned for OpenMP 5.0
-    int BestIdx = getBestVariantMatchForContext(VMIs, OMPCtx);
+    // Array SortedCluases will be used for sorting  clauses
+    // based on the context selector score                      
+    SmallVector<std::pair<unsigned, llvm::APInt>> SortedCluases;
+    
+    // The function will get the score for each clause and sort it 
+    // based on the score number
+    
+    getArrayVariantMatchForContext(VMIs, OMPCtx, SortedCluases) ;          
+                                    
+    ParseScope OMPDirectiveScope(this, ScopeFlags); 
+    Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);  
     
-    int Idx = 0;
-    // In OpenMP 5.0 metadirective is either replaced by another directive or
-    // ignored.
-    // TODO: In OpenMP 5.1 generate multiple directives based upon the matches
-    // found by getBestWhenMatchForContext.
-    while (Tok.isNot(tok::annot_pragma_openmp_end)) {
-      // OpenMP 5.0 implementation - Skip to the best index found.
-      if (Idx++ != BestIdx) {
-        ConsumeToken();  // Consume clause name
-        T.consumeOpen(); // Consume '('
-        int paren = 0;
-        // Skip everything inside the clause
-        while (Tok.isNot(tok::r_paren) || paren != 0) {
-          if (Tok.is(tok::l_paren))
-            paren++;
-          if (Tok.is(tok::r_paren))
-            paren--;
-          ConsumeAnyToken();
-        }
-        // Parse ')'
-        if (Tok.is(tok::r_paren))
-          T.consumeClose();
-        continue;
-      }
+    while(Tok.isNot(tok::annot_pragma_openmp_end)){
     
       OpenMPClauseKind CKind = Tok.isAnnotation()
                                    ? OMPC_unknown
                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
+
       SourceLocation Loc = ConsumeToken();
 
       // Parse '('.
       T.consumeOpen();
 
       // Skip ContextSelectors for when clause
       if (CKind == OMPC_when) {
         OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
while(Tok.isNot(tok::annot_pragma_openmp_end)){
         break;
       }
 
       // Parse Directive
       Directive = ParseOpenMPDeclarativeOrExecutableDirective(
           StmtCtx,
           /*ReadDirectiveWithinMetadirective=*/true);
       break;
+                                   
+      Actions.StartOpenMPClause(CKind);
+      OMPClause *Clause = ParseOpenMPMetaDirectiveClause( DKind, CKind);
+      
+      FirstClauses[(unsigned) CKind].setInt(true);
+      if (Clause) {
+        FirstClauses[(unsigned) CKind].setPointer(Clause);
+        Clauses.push_back(Clause);
+      } 
+      
+      if (Tok.is(tok::comma))
+        ConsumeToken();
+      
+      Actions.EndOpenMPClause();
+      
+      if (Tok.is(tok::r_paren))
+        ConsumeAnyToken();  
+          
     }
-    break;
-  }
+   
+    // End location of the directive
+    EndLoc = Tok.getLocation();
+   
+    //Consume final annot_pragma_openmp_end
+    ConsumeAnnotationToken();
+   
+    SmallVector<OMPClause *, 5> Clauses_new;
+    unsigned count = 0;
+   
+    // SortedClauses has index and score, and are sorted with respect to the
+    // the context score. The first iteration will take each element. The 
+    // first element will have the highiest score. The element will have the
+    // index of the cluase for the best score. The second iteration tries to
+    // find that specific clause by checking the count numder with the 
+    // index (Iteration1.first)  
+    for ( auto &Iteration1 : SortedCluases){
+    count = 0;
+    for ( auto &Iteration2 : Clauses){
+      if ( count == Iteration1.first ){
+        Clauses_new.push_back(Iteration2);
+        break;
+      } else count++;
+    }
+    }
+   // Adding the default clasue at the end
+   Clauses_new.push_back(Clauses.back());
+   
+   // Parsing the OpenMP region which will take the
+   // metadirective
+   
+   Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
+   ParsingOpenMPDirectiveRAII NormalScope(*this, /*value=*/ false);
+   // This is parsing the region
+   StmtResult AStmt = ParseStatement();
+   
+   StmtResult AssociatedStmt = (Sema::CompoundScopeRAII(Actions), AStmt);
+   // Ending of the parallel region
+   AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses_new);
+   Directive = Actions.ActOnOpenMPExecutableDirective(
+     DKind, DirName, CancelRegion, Clauses_new, AssociatedStmt.get(), Loc, 
+    EndLoc);
+   // Exit scope
+   Actions.EndOpenMPDSABlock(Directive.get());
+   break;
+  } // end of case OMPD_metadirective:
   case OMPD_threadprivate: {
     // FIXME: Should this be permitted in C++?
     if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) ==
         ParsedStmtContext()) {
       Diag(Tok, diag::err_omp_immediate_directive)
           << getOpenMPDirectiveName(DKind) << 0;
     }
     ConsumeToken();
do {
     // Parse ','
     if (Tok.is(tok::comma))
       ConsumeAnyToken();
   } while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end));
   T.consumeClose();
   return Actions.ActOnOpenMPUsesAllocatorClause(Loc, T.getOpenLocation(),
                                                 T.getCloseLocation(), Data);
 }
+/// Parsing of OpenMP MetaDirective Clauses
+
+OMPClause *Parser::ParseOpenMPMetaDirectiveClause(OpenMPDirectiveKind DKind,
+                                         OpenMPClauseKind CKind) {
+  OMPClause *Clause = nullptr;
+  bool ErrorFound = false;
+  bool WrongDirective = false;
+  SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
+              llvm::omp::Clause_enumSize + 1>
+      FirstClauses(llvm::omp::Clause_enumSize + 1);
+
+  // Check if it is called from metadirective.
+  if (DKind != OMPD_metadirective) {
+    Diag(Tok, diag::err_omp_unexpected_clause)
+        << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
+    ErrorFound = true;
+  }
+
+  // Check if clause is allowed for the given directive.
+  if (CKind != OMPC_unknown &&
+      !isAllowedClauseForDirective(DKind, CKind, getLangOpts().OpenMP)) {
+    Diag(Tok, diag::err_omp_unexpected_clause)
+        << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
+    ErrorFound = true;
+    WrongDirective = true;
+  }
+
+ // Check if clause is not allowed
+ if (CKind == OMPC_unknown) {
+    Diag(Tok, diag::err_omp_unexpected_clause)
+        << getOpenMPClauseName(CKind) << "Unknown clause: Not allowed";
+    ErrorFound = true;
+    WrongDirective = true;
+  }
+  
+  if (CKind == OMPC_default || CKind == OMPC_when) {
+    SourceLocation Loc = ConsumeToken();
+    SourceLocation DelimLoc;
+    // Parse '('.
+    BalancedDelimiterTracker T(*this, tok::l_paren,
+                               tok::annot_pragma_openmp_end);
+    if (T.expectAndConsume(diag::err_expected_lparen_after,
+                           getOpenMPClauseName(CKind).data()))
+      return nullptr;
+
+    OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
+    if (CKind == OMPC_when) {
+      // parse and get condition expression to pass to the When clause
+      parseOMPContextSelectors(Loc, TI);
+
+      // Parse ':'
+      if (Tok.is(tok::colon))
+        ConsumeAnyToken();
+      else {
+        Diag(Tok, diag::warn_pragma_expected_colon) << "when clause";
+        return nullptr;
+      }
+    }
+
+    // Parse Directive
+    OpenMPDirectiveKind DirKind = OMPD_unknown;
+    SmallVector<OMPClause *, 5> Clauses;
+    StmtResult AssociatedStmt;
+    StmtResult Directive = StmtError();
+
+    if (Tok.isNot(tok::r_paren)) {
+      ParsingOpenMPDirectiveRAII DirScope(*this);
+      ParenBraceBracketBalancer BalancerRAIIObj(*this);
+      DeclarationNameInfo DirName;
+      unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
+                            Scope::CompoundStmtScope |
+                            Scope::OpenMPDirectiveScope;
+
+      DirKind = parseOpenMPDirectiveKind(*this);
+      ConsumeToken();
+      ParseScope OMPDirectiveScope(this, ScopeFlags);
+      Actions.StartOpenMPDSABlock(DirKind, DirName, Actions.getCurScope(), Loc);
+      
+      int paren = 0;
+      
+      while (Tok.isNot(tok::r_paren) || paren != 0) {
+        if (Tok.is(tok::l_paren))
+          paren++;
+        if (Tok.is(tok::r_paren))
+          paren--;
+  
+        OpenMPClauseKind CKind = Tok.isAnnotation()
+                                     ? OMPC_unknown
+                                     : getOpenMPClauseKind(PP.getSpelling(Tok));
+         
+        if (CKind == OMPC_unknown &&
+          !isAllowedClauseForDirective(DirKind, CKind, getLangOpts().OpenMP)) {
+        Diag(Tok, diag::err_omp_unexpected_clause)
+            << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
+        ErrorFound = true;
+        WrongDirective = true;
+    }
+                               
+        Actions.StartOpenMPClause(CKind);
+        OMPClause *Clause = ParseOpenMPClause(
+            DirKind, CKind, !FirstClauses[(unsigned)CKind].getInt());
+        FirstClauses[(unsigned)CKind].setInt(true);
+        if (Clause) {
+          FirstClauses[(unsigned)CKind].setPointer(Clause);
+          Clauses.push_back(Clause);
+        }
+
+        // Skip ',' if any.
+        if (Tok.is(tok::comma))
+          ConsumeToken();
+        Actions.EndOpenMPClause();
+      }
+  
+      Actions.ActOnOpenMPRegionStart(DirKind, getCurScope());
+      ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
+
+      /* Get Stmt and revert back */
+      TentativeParsingAction TPA(*this);
+      while (Tok.isNot(tok::annot_pragma_openmp_end)) {
+        ConsumeAnyToken();
+      }
+      
+      ConsumeAnnotationToken();
+      ParseScope InnerStmtScope(this, Scope::DeclScope,
+                                getLangOpts().C99 || getLangOpts().CPlusPlus,
+                                Tok.is(tok::l_brace));
+                                                      
+      StmtResult AStmt = ParseStatement();
+      InnerStmtScope.Exit();
+      TPA.Revert();
+      /* End Get Stmt */
+
+      AssociatedStmt = (Sema::CompoundScopeRAII(Actions), AStmt);
+      AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
+  
+      Directive = Actions.ActOnOpenMPExecutableDirective(
+          DirKind, DirName, OMPD_unknown, llvm::makeArrayRef(Clauses),
+          AssociatedStmt.get(), Loc, Tok.getLocation());
+  
+      Actions.EndOpenMPDSABlock(Directive.get());
+      OMPDirectiveScope.Exit();
+    }
+    // Parse ')'
+    T.consumeClose();
+
+    if (WrongDirective)
+      return nullptr;
+
+    Clause = Actions.ActOnOpenMPWhenClause(TI, DirKind, Directive, Loc,
+                                           DelimLoc, Tok.getLocation());
+  } else {
+    ErrorFound = false;
+    Diag(Tok, diag::err_omp_unexpected_clause)
+        << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);     
+  }
+    
+  return ErrorFound ? nullptr : Clause;
+}
 
 /// Parsing of OpenMP clauses.
 ///
 ///    clause:
 ///       if-clause | final-clause | num_threads-clause | safelen-clause |
 ///       default-clause | private-clause | firstprivate-clause | shared-clause
 ///       | linear-clause | aligned-clause | collapse-clause | bind-clause |
 ///       lastprivate-clause | reduction-clause | proc_bind-clause |

clang/lib/Sema/SemaOpenMP.cpp

 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Frontend/OpenMP/OMPAssume.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
+#include "llvm/Frontend/OpenMP/OMPContext.h"
 #include <set>
 
 using namespace clang;
 using namespace llvm::omp;
 
 //===----------------------------------------------------------------------===//
 // Stack of data-sharing attributes for variables
 //===----------------------------------------------------------------------===//
if (isOpenMPWorksharingDirective(DKind))
     Traits.emplace_back(llvm::omp::TraitProperty::construct_for_for);
   if (isOpenMPSimdDirective(DKind))
     Traits.emplace_back(llvm::omp::TraitProperty::construct_simd_simd);
   Stack->handleConstructTrait(Traits, ScopeEntry);
 }
 
 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   switch (DKind) {
+  case OMPD_metadirective:
   case OMPD_parallel:
   case OMPD_parallel_for:
   case OMPD_parallel_for_simd:
   case OMPD_parallel_sections:
   case OMPD_parallel_master:
   case OMPD_parallel_masked:
   case OMPD_parallel_loop:
   case OMPD_teams:
void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_requires:
   case OMPD_declare_variant:
   case OMPD_begin_declare_variant:
   case OMPD_end_declare_variant:
-  case OMPD_metadirective:
     llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
   default:
     llvm_unreachable("Unknown OpenMP directive");
   }
   DSAStack->setContext(CurContext);
   handleDeclareVariantConstructTrait(DSAStack, DKind, /* ScopeEntry */ true);
 }
if (Ordered && Order) {
     S.Diag(Ordered->getBeginLoc(), diag::note_omp_ordered_param)
         << 0 << SourceRange(Ordered->getBeginLoc(), Ordered->getEndLoc());
     return true;
   }
   return false;
 }
 
 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
-                                      ArrayRef<OMPClause *> Clauses) {
+                                      ArrayRef<OMPClause *> Clauses){
   handleDeclareVariantConstructTrait(DSAStack, DSAStack->getCurrentDirective(),
                                      /* ScopeEntry */ false);
   if (DSAStack->getCurrentDirective() == OMPD_atomic ||
       DSAStack->getCurrentDirective() == OMPD_critical ||
       DSAStack->getCurrentDirective() == OMPD_section ||
       DSAStack->getCurrentDirective() == OMPD_master ||
       DSAStack->getCurrentDirective() == OMPD_masked)
     return S;
Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic
              : SC->getSecondScheduleModifierLoc(),
          diag::err_omp_simple_clause_incompatible_with_ordered)
         << getOpenMPClauseName(OMPC_schedule)
         << getOpenMPSimpleClauseTypeName(OMPC_schedule,
                                          OMPC_SCHEDULE_MODIFIER_nonmonotonic)
         << SourceRange(OC->getBeginLoc(), OC->getEndLoc());
     ErrorFound = true;
   }
+  
   // OpenMP 5.0, 2.9.2 Worksharing-Loop Construct, Restrictions.
   // If an order(concurrent) clause is present, an ordered clause may not appear
   // on the same directive.
   if (checkOrderedOrderSpecified(*this, Clauses))
     ErrorFound = true;
   if (!LCs.empty() && OC && OC->getNumForLoops()) {
     for (const OMPLinearClause *C : LCs) {
       Diag(C->getBeginLoc(), diag::err_omp_linear_ordered)
           << SourceRange(OC->getBeginLoc(), OC->getEndLoc());
     }
     ErrorFound = true;
-  }
+  } 
   if (isOpenMPWorksharingDirective(DSAStack->getCurrentDirective()) &&
       isOpenMPSimdDirective(DSAStack->getCurrentDirective()) && OC &&
       OC->getNumForLoops()) {
     Diag(OC->getBeginLoc(), diag::err_omp_ordered_simd)
         << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
     ErrorFound = true;
   }
   if (ErrorFound) {
     return StmtError();
   }
   StmtResult SR = S;
-  unsigned CompletedRegions = 0;
+  unsigned CompletedRegions = 0;  
   for (OpenMPDirectiveKind ThisCaptureRegion : llvm::reverse(CaptureRegions)) {
+  
     // Mark all variables in private list clauses as used in inner region.
     // Required for proper codegen of combined directives.
     // TODO: add processing for other clauses.
     if (ThisCaptureRegion != OMPD_unknown) {
       for (const clang::OMPClauseWithPreInit *C : PICs) {
         OpenMPDirectiveKind CaptureRegion = C->getCaptureRegion();
         // Find the particular capture region for the clause if the
         // directive is a combined one with multiple capture regions.
         // If the directive is not a combined one, the capture region
         // associated with the clause is OMPD_unknown and is generated
         // only once.
         if (CaptureRegion == ThisCaptureRegion ||
             CaptureRegion == OMPD_unknown) {
           if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) {
             for (Decl *D : DS->decls())
               MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D));
           }
         }
       }
     }
+    
     if (ThisCaptureRegion == OMPD_target) {
       // Capture allocator traits in the target region. They are used implicitly
       // and, thus, are not captured by default.
       for (OMPClause *C : Clauses) {
         if (const auto *UAC = dyn_cast<OMPUsesAllocatorsClause>(C)) {
           for (unsigned I = 0, End = UAC->getNumberOfAllocators(); I < End;
                ++I) {
             OMPUsesAllocatorsClause::Data D = UAC->getAllocatorData(I);
             if (Expr *E = D.AllocatorTraits)
               MarkDeclarationsReferencedInExpr(E);
           }
           continue;
         }
       }
     }
+    
     if (ThisCaptureRegion == OMPD_parallel) {
       // Capture temp arrays for inscan reductions and locals in aligned
       // clauses.
       for (OMPClause *C : Clauses) {
         if (auto *RC = dyn_cast<OMPReductionClause>(C)) {
           if (RC->getModifier() != OMPC_REDUCTION_inscan)
             continue;
           for (Expr *E : RC->copy_array_temps())
             MarkDeclarationsReferencedInExpr(E);
         }
         if (auto *AC = dyn_cast<OMPAlignedClause>(C)) {
           for (Expr *E : AC->varlists())
             MarkDeclarationsReferencedInExpr(E);
         }
       }
     }
+    
     if (++CompletedRegions == CaptureRegions.size())
       DSAStack->setBodyComplete();
+  
     SR = ActOnCapturedRegionEnd(SR.get());
+    
   }
+  
   return SR;
 }
 
 static bool checkCancelRegion(Sema &SemaRef, OpenMPDirectiveKind CurrentRegion,
                               OpenMPDirectiveKind CancelRegion,
                               SourceLocation StartLoc) {
   // CancelRegion is only needed for cancel and cancellation_point.
   if (CurrentRegion != OMPD_cancel && CurrentRegion != OMPD_cancellation_point)
if (AStmt && !CurContext->isDependentContext() && Kind != OMPD_atomic &&
     // mappers.
     if (LangOpts.OpenMP >= 50)
       processImplicitMapsWithDefaultMappers(*this, DSAStack,
                                             ClausesWithImplicit);
   }
 
   llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
   switch (Kind) {
+
+  case OMPD_metadirective:
+    Res = ActOnOpenMPMetaDirective(ClausesWithImplicit, AStmt, StartLoc, 
+              EndLoc);
+    AllowedNameModifiers.push_back(OMPD_metadirective); 
+    break;
   case OMPD_parallel:
     Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
                                        EndLoc);
     AllowedNameModifiers.push_back(OMPD_parallel);
     break;
   case OMPD_simd:
     Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
                                    VarsWithInheritedDSA);
auto *NewAttr = OMPDeclareVariantAttr::CreateImplicit(
       Context, VariantRef, &TI, const_cast<Expr **>(AdjustArgsNothing.data()),
       AdjustArgsNothing.size(),
       const_cast<Expr **>(AdjustArgsNeedDevicePtr.data()),
       AdjustArgsNeedDevicePtr.size(),
       const_cast<OMPInteropInfo *>(AppendArgs.data()), AppendArgs.size(), SR);
   FD->addAttr(NewAttr);
 }
 
+StmtResult Sema::ActOnOpenMPMetaDirective(ArrayRef<OMPClause *> Clauses,
+                                              Stmt *AStmt,
+                                              SourceLocation StartLoc,
+                                              SourceLocation EndLoc){
+  if (!AStmt)
+    return StmtError();
+
+  auto *CS = cast<CapturedStmt>(AStmt);
+  // 1.2.2 OpenMP Language Terminology
+  // Structured block - An executable statement with a single entry at the
+  // top and a single exit at the bottom.
+  // The point of exit cannot be a branch out of the structured block.
+  // longjmp() and throw() must not violate the entry/exit criteria.
+  
+  CS->getCapturedDecl()->setNothrow();
+
+  StmtResult IfStmt = StmtError();
+  Stmt *ElseStmt = nullptr;
+
+  for (auto i = Clauses.rbegin(); i < Clauses.rend(); i++) {
+    OMPWhenClause *WhenClause = dyn_cast<OMPWhenClause>(*i);
+    Expr *WhenCondExpr = nullptr;
+    Stmt *ThenStmt = nullptr;
+    OpenMPDirectiveKind DKind = WhenClause->getDKind();
+
+    if (DKind != OMPD_unknown)
+      ThenStmt = CompoundStmt::Create(Context, {WhenClause->getDirective()},
+                                      FPOptionsOverride(), SourceLocation(),
+                                      SourceLocation());
+
+    for (const OMPTraitSet &Set : WhenClause->getTI().Sets){
+      for (const OMPTraitSelector &Selector : Set.Selectors){
+        switch (Selector.Kind){
+        case TraitSelector::device_arch:{
+          bool ArchMatch = false;
+          for (const OMPTraitProperty &Property : Selector.Properties){
+            for (auto &T : getLangOpts().OMPTargetTriples){
+              if (T.getArchName() == Property.RawString){
+                ArchMatch = true;
+                break;
+              }
+            }
+            if (ArchMatch)
+              break;
+          }
+          // Create a true/false boolean expression and assign to WhenCondExpr
+          auto *C = new (Context)
+              CXXBoolLiteralExpr(ArchMatch, Context.BoolTy, StartLoc);
+          WhenCondExpr = dyn_cast<Expr>(C);
+          break;
+        }
+        case TraitSelector::user_condition:{
+          assert(Selector.ScoreOrCondition &&
+                 "Ill-formed user condition, expected condition expression!");
+
+          WhenCondExpr = Selector.ScoreOrCondition;
+          break;
+        }
+        case TraitSelector::implementation_vendor:{
+          bool vendorMatch = false;
+          for (const OMPTraitProperty &Property : Selector.Properties){
+            for (auto &T : getLangOpts().OMPTargetTriples){
+              if (T.getVendorName() == Property.RawString){
+                vendorMatch = true;
+                break;
+              }
+            }
+            if (vendorMatch)
+              break;
+          }
+          // Create a true/false boolean expression and assign to WhenCondExpr
+          auto *WhenCondition = new (Context)
+              CXXBoolLiteralExpr(vendorMatch, Context.BoolTy, StartLoc);
+          WhenCondExpr = dyn_cast<Expr>(WhenCondition);
+          break;
+        }
+        case TraitSelector::device_isa:
+        case TraitSelector::device_kind:
+        case TraitSelector::implementation_extension:
+        default:
+          break;
+        }
+      }
+    }
+
+    if (WhenCondExpr == nullptr) {
+      if (ElseStmt != nullptr) {
+        Diag(WhenClause->getBeginLoc(), diag::err_omp_misplaced_default_clause);
+        return StmtError();
+      }
+      if (DKind == OMPD_unknown)
+        ElseStmt = CompoundStmt::Create(Context, {CS->getCapturedStmt()},
+                                        FPOptionsOverride(), SourceLocation(),
+                                        SourceLocation());
+      else
+        ElseStmt = ThenStmt;
+      continue;
+    }
+
+    if (ThenStmt == NULL)
+      ThenStmt = CompoundStmt::Create(Context, {CS->getCapturedStmt()},
+                                      FPOptionsOverride(), SourceLocation(),
+                                      SourceLocation());
+
+    IfStmt =
+        ActOnIfStmt(SourceLocation(), /*false*/ IfStatementKind::Ordinary, SourceLocation(), nullptr,
+                    ActOnCondition(getCurScope(), SourceLocation(),
+                                   WhenCondExpr, Sema::ConditionKind::Boolean),
+                    SourceLocation(), ThenStmt, SourceLocation(), ElseStmt);
+    ElseStmt = IfStmt.get();
+  }
+
+  return OMPMetaDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
+                                  IfStmt.get());                                            
+}
+
 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
-                                              SourceLocation EndLoc) {
+                                              SourceLocation EndLoc){
   if (!AStmt)
     return StmtError();
 
   auto *CS = cast<CapturedStmt>(AStmt);
   // 1.2.2 OpenMP Language Terminology
   // Structured block - An executable statement with a single entry at the
   // top and a single exit at the bottom.
   // The point of exit cannot be a branch out of the structured block.
for (unsigned I = First; I < Last; ++I) {
     if (I + Skipped + 2 == Last)
       Out << " or ";
     else if (I + Skipped + 1 != Last)
       Out << ", ";
   }
   return std::string(Out.str());
 }
 
+OMPClause *
+Sema::ActOnOpenMPWhenClause(OMPTraitInfo &TI, OpenMPDirectiveKind DKind,
+                            StmtResult Directive, SourceLocation StartLoc,
+                            SourceLocation LParenLoc, SourceLocation EndLoc) {
+  return new (Context)
+      OMPWhenClause(TI, DKind, Directive.get(), StartLoc, LParenLoc, EndLoc);
+}
+
+
+
+
 OMPClause *Sema::ActOnOpenMPDefaultClause(DefaultKind Kind,
                                           SourceLocation KindKwLoc,
                                           SourceLocation StartLoc,
                                           SourceLocation LParenLoc,
                                           SourceLocation EndLoc) {
   if (Kind == OMP_DEFAULT_unknown) {
     Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
         << getListOfPossibleValues(OMPC_default, /*First=*/0,

clang/lib/Sema/SemaStmt.cpp

StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) {
 
   CapturedDecl *CD = RSI->TheCapturedDecl;
   RecordDecl *RD = RSI->TheRecordDecl;
 
   CapturedStmt *Res = CapturedStmt::Create(
       getASTContext(), S, static_cast<CapturedRegionKind>(RSI->CapRegionKind),
       Captures, CaptureInits, CD, RD);
 
-  CD->setBody(Res->getCapturedStmt());
+  CD->setBody(Res->getCapturedStmt());   
   RD->completeDefinition();
 
   return Res;
 }

clang/test/OpenMP/metadirective_ast_print_new_1.cpp

+// RUN: %clang_cc1 -verify  -fopenmp  -ast-print %s -o - | FileCheck %s
+// expected-no-diagnostics
+void bar(){
+        int i=0;
+}
+
+void myfoo(void){
+
+        int N = 13;
+        int b,n;
+        int a[100];
+
+        #pragma omp metadirective when(user={condition(N>10)}:  target teams ) default(parallel for)
+                for (int i = 0; i < N; i++)
+                bar();
+
+}
+
+// CHECK: void bar()
+// CHECK: #pragma omp metadirective when(user={condition(N > 10)}: target teams) default(parallel for)

clang/test/OpenMP/metadirective_ast_print_new_2.cpp

+// RUN: %clang_cc1 -verify  -fopenmp  -ast-print %s -o - | FileCheck %s
+// expected-no-diagnostics
+
+void bar(){
+  int i=0;  
+}
+
+void myfoo(void){
+
+  int N = 13;
+  int b,n;
+  int a[100];
+
+  
+  #pragma omp  metadirective when (user = {condition(N>10)}: target  teams distribute parallel for ) \
+          when (user = {condition(N==10)}: parallel for )\
+          when (user = {condition(N==13)}: parallel for simd) \
+          when ( device={arch("arm")}:   target teams num_teams(512) thread_limit(32))\
+          when ( device={arch("nvptx")}: target teams num_teams(512) thread_limit(32))\
+          default ( parallel for)\
+
+  {    for (int i = 0; i < N; i++)
+    bar();
+  }
+}
+
+// CHECK: bar()
+// CHECK: myfoo
+// CHECK: #pragma omp metadirective when(user={condition(N > 10)}: target teams distribute parallel for) when(user={condition(N == 13)}: parallel for simd) when(device={arch(nvptx)}: target teams)

clang/test/OpenMP/metadirective_ast_print_new_3.cpp

+// RUN: %clang_cc1 -verify  -fopenmp  -ast-print %s -o - | FileCheck %s
+// expected-no-diagnostics
+
+int main() {
+  int N = 15;
+#pragma omp metadirective when(user = {condition(N > 10)} : parallel for)\
+        default(target teams) 
+  for (int i = 0; i < N; i++)
+    ;
+
+
+#pragma omp metadirective when(device = {arch("nvptx64")}, user = {condition(N >= 100)} : parallel for)\
+          default(target parallel for)
+  for (int i = 0; i < N; i++)
+    ;
+  return 0;
+}
+
+
+
+// CHECK: #pragma omp metadirective when(user={condition(N > 10)}: parallel for) default(target teams)
+// CHECK: #pragma omp metadirective when(device={arch(nvptx64)}, user={condition(N >= 100)}: parallel for) default(target parallel for)

llvm/include/llvm/Frontend/OpenMP/OMPContext.h

bool isVariantApplicableInContext(const VariantMatchInfo &VMI,
                                   const OMPContext &Ctx,
                                   bool DeviceSetOnly = false);
 
 /// Return the index (into \p VMIs) of the variant with the highest score
 /// from the ones applicble in \p Ctx. See llvm::isVariantApplicableInContext.
 int getBestVariantMatchForContext(const SmallVectorImpl<VariantMatchInfo> &VMIs,
                                   const OMPContext &Ctx);
 
+/// Sort array \p A of clause index  with score
+/// This will be used to produce AST clauses
+/// in a sorted order with the clause with the highiest order
+/// on the top and default clause at the bottom
+void getArrayVariantMatchForContext(
+    const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx,
+    SmallVector<std::pair<unsigned, APInt>> &A);
+
+// new--
 } // namespace omp
 
 template <> struct DenseMapInfo<omp::TraitProperty> {
   static inline omp::TraitProperty getEmptyKey() {
     return omp::TraitProperty(-1);
   }
   static inline omp::TraitProperty getTombstoneKey() {
     return omp::TraitProperty(-2);

llvm/lib/Frontend/OpenMP/OMPContext.cpp

 
 #include "llvm/Frontend/OpenMP/OMPContext.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include <map>
 #define DEBUG_TYPE "openmp-ir-builder"
 
 using namespace llvm;
 using namespace omp;
 
 OMPContext::OMPContext(bool IsDeviceCompilation, Triple TargetTriple) {
   // Add the appropriate device kind trait based on the triple and the
   // IsDeviceCompilation flag.
for (TraitProperty Property : VMI.ConstructTraits) {
     Score += (1ULL << ConstructMatches[ConstructIdx++]);
   }
 
   LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Variant has a score of " << Score
                     << "\n");
   return Score;
 }
 
+/// Takes \p VMI and \p Ctx and sort the
+/// scores using \p VectorOfClauses
+void llvm::omp::getArrayVariantMatchForContext(
+    const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx,
+    SmallVector<std::pair<unsigned, APInt>> &VectorOfClauses) {
+
+  // APInt BestScore(64, 0);
+  APInt Score(64, 0);
+  // The MapOfClauses will contain the index of the cluase and its context socre
+  llvm::DenseMap<unsigned, llvm::APInt> MapOfCluases;
+
+  for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
+    const VariantMatchInfo &VMI = VMIs[u];
+
+    SmallVector<unsigned, 8> ConstructMatches;
+    // If the variant is not applicable its not the best.
+    if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
+                                            /* DeviceSetOnly */ false)) {
+      Score = 0;
+      // adding index and its corresdoning score
+      MapOfCluases.insert({u, Score});
+      continue;
+    }
+    // Else get the score
+    Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
+    MapOfCluases.insert({u, Score});
+  }
+
+  for (auto &it : MapOfCluases)
+    VectorOfClauses.push_back(it);
+
+  // The following Lamda will sort the VectorOfClauses based on the score
+  std::sort(VectorOfClauses.begin(), VectorOfClauses.end(),
+            [](std::pair<unsigned, APInt> &a, std::pair<unsigned, APInt> &b) {
+              return a.second.ugt(b.second);
+            });
+}
+
 int llvm::omp::getBestVariantMatchForContext(
     const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx) {
 
   APInt BestScore(64, 0);
   int BestVMIIdx = -1;
   const VariantMatchInfo *BestVMI = nullptr;
 
   for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {