OpenMP Metadirective with user defined condition

[alokmishra.besu]

Summary

This is a patch to implement dynamic extension to the user condition selector for OpenMP Metadirective.

[jdoerfert]

I think you forgot to add the tests to the commit :)

[alokmishra.besu]

Adding test case

[alokmishra.besu]

Fixed build error and test files

[ABataev]

clang/include/clang/AST/OpenMPClause.h

863

final

866

Reformat the patch

868

Bad idea. If you need to store other clauses in this clause, use tail allocation.

906

Must return ArrayRef

clang/include/clang/AST/StmtOpenMP.h

348

1. final
2. Comments?

350

This must be a part of the tail-allocated data members, otherwise you won't be able to correctly handle list of children nodes

clang/lib/Serialization/ASTReader.cpp

11902

Serialization for inner clauses

clang/test/OpenMP/metadirective_default.c

1–13

This is not a test, check other files in this directory

[alokmishra.besu]

Fixed formatting issues and replaced SmallVector with ArrayRef .

Working on the test cases.

clang/include/clang/AST/StmtOpenMP.h

350

This is not the associated statement. It is a newly generated statement which will only be used in CodeGen. I don't think we need to handle a list of children node for this one.

[alokmishra.besu]

Updated the test files

[jdoerfert]

Apologies for my delay.

In D76211#1940445, @alokmishra.besu wrote:

Updated the test files

It seems there is only an AST dump test case. Where is the codegen tests (and others)?

[jdoerfert]

clang/lib/Sema/SemaOpenMP.cpp

5800

Style: start names with upper case letter.

5816

You need to use Diag here. See other uses in this file.

5833

Doesn't this produce:

if (when1) case1;
if (when2) case2;
...

while we need:

if (when1) case1;
else if (when2) case2;
...

11986

I think a simple if (DKind == ...) makes more sense here.

[tomdeakin]

Is there an update on this?

[alokmishra.besu]

Updated the test cases.
Fixed an issue where correct code was not generated if directive variant was not provided in when/default clause

[jdoerfert]

Are you planning to add support for the actual OpenMP selectors as well?
All the other traits, scoring, etc. I left a comment below that points you to the right place as we have almost all of that already ready to be reused.
On this note, I would recommend you take a look at the OpenMP 5.1 draft, it contains proper wording for a dynamic context extension, and we will need support in the declare variant as well. That means we need to allow dynamic expressions in OMPTraitInfo and similar places eventually anyway.

We need more tests:

• verify all parser errors
• verify semantic errors wrt the directives
• verify the condition is captured properly, e.g., if it is in a parallel region
• verify complex conditions work, e.g., globals, calls, constexpr expressions, template arguments, ...
• verify an "empty" metadirective works
• verify we exclude directives & conditions that should not be emitted

Fixed an issue where correct code was not generated if directive variant was not provided in when/default clause

We need a test for that too.

clang/include/clang-c/Index.h

2581–2583

Doc string missing, see above.

clang/include/clang/AST/OpenMPClause.h

866

This looks like it is tailored towards a single user condition. You should use a OMPTraitInfo object here, see how it is done for declare variant (which has the same kind of context selector): https://github.com/llvm/llvm-project/blob/master/clang/lib/Parse/ParseOpenMP.cpp#L1388

868

This doesn't seem to be addressed but I'm actually unsure what the clauses of a when clause are?

888

The comment above refers to A and looks pretty much like it is copy and pasted from elsewhere.

903

Why does the clause have a directive kind?

clang/include/clang/Basic/DiagnosticSemaKinds.td

10133 ↗

(On Diff #255575)

Unsure about the bang above. We should probably have other errors of this kind with wording you can use. Also, the order of clauses is not important (for almost everything).

clang/test/OpenMP/metadirective_codegen.cpp

39 ↗

(On Diff #255575)

We need to check for the code of the outlined functions as well, from this it is not clear that there is a omp for in the second case. The formatting of these check lines is also problematic. Maybe start by using the llvm/utils/update_cc_test_checks.py script.

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

95

This is not rebased, directives are now declared in the tablegen file:
llvm/include/llvm/Frontend/OpenMP/OMP.td

[jdoerfert]

Update for @alokmishra.besu via arcanist as the webinterface doesn't allow patches over 2MB

[alokmishra.besu]

In D76211#2212203, @jdoerfert wrote:

Are you planning to add support for the actual OpenMP selectors as well?
All the other traits, scoring, etc. I left a comment below that points you to the right place as we have almost all of that already ready to be reused.
On this note, I would recommend you take a look at the OpenMP 5.1 draft, it contains proper wording for a dynamic context extension, and we will need support in the declare variant as well. That means we need to allow dynamic expressions in OMPTraitInfo and similar places eventually anyway.

The idea of this patch is to implement user condition for metadirective.
Anyways I will be adding support for other OpenMP selectors as well. I think doing that in a different patch will be a better idea, as there are lots of things to consider.
I do take this point and will update this patch to support future extension to other selectors.

We need more tests:

• verify all parser errors
• verify semantic errors wrt the directives
• verify the condition is captured properly, e.g., if it is in a parallel region
• verify complex conditions work, e.g., globals, calls, constexpr expressions, template arguments, ...
• verify an "empty" metadirective works
• verify we exclude directives & conditions that should not be emitted

Fixed an issue where correct code was not generated if directive variant was not provided in when/default clause

We need a test for that too.

Will update all these test cases soon.
.

In D76211#2212214, @jdoerfert wrote:

Update for @alokmishra.besu via arcanist as the webinterface doesn't allow patches over 2MB

Currently trying to figure out how to use arcanist. :)

[jdoerfert]

reverse ping?

[alokmishra.besu]

Updated patch to make it extendable to more selectors
Implemented device_arch and implementation_vendor selectors as well

[jdoerfert]

Some comments but I haven't gone through all of it. The tests are still missing.

clang/lib/Sema/SemaOpenMP.cpp

5786

i is not a name for whatever this is. Don't use auto if the type is not obvious, consider a reverse range adapter.

5789

NULL is a poor substitute for nullptr, use the latter, always.

5849

Do not reimplement parts of logic already existing. Use the same mechanism to find a match we use in other places. See ActOnOpenMPCall, and the llvm/Frontend/OpenMP/OMPContext.h.

[jdoerfert]

Are you still working on this?

[jdoerfert]

reverse ping. Do you have an estimate when you update this?

clang/include/clang-c/Index.h

enum CXCursorKind {
    * A declaration whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed declarations have the same operations as any other kind
    * of declaration; one can extract their location information,
    * spelling, find their definitions, etc. However, the specific kind
    * of the declaration is not reported.
    */
   CXCursor_UnexposedDecl                 = 1,
   /** A C or C++ struct. */
   CXCursor_StructDecl                    = 2,
   /** A C or C++ union. */
   CXCursor_UnionDecl                     = 3,
   /** A C++ class. */
   CXCursor_ClassDecl                     = 4,
   /** An enumeration. */
   CXCursor_EnumDecl                      = 5,
   /**
    * A field (in C) or non-static data member (in C++) in a
    * struct, union, or C++ class.
    */
   CXCursor_FieldDecl                     = 6,
   /** An enumerator constant. */
   CXCursor_EnumConstantDecl              = 7,
   /** A function. */
   CXCursor_FunctionDecl                  = 8,
   /** A variable. */
   CXCursor_VarDecl                       = 9,
   /** A function or method parameter. */
   CXCursor_ParmDecl                      = 10,
   /** An Objective-C \@interface. */
   CXCursor_ObjCInterfaceDecl             = 11,
   /** An Objective-C \@interface for a category. */
   CXCursor_ObjCCategoryDecl              = 12,
   /** An Objective-C \@protocol declaration. */
   CXCursor_ObjCProtocolDecl              = 13,
   /** An Objective-C \@property declaration. */
   CXCursor_ObjCPropertyDecl              = 14,
   /** An Objective-C instance variable. */
   CXCursor_ObjCIvarDecl                  = 15,
   /** An Objective-C instance method. */
   CXCursor_ObjCInstanceMethodDecl        = 16,
   /** An Objective-C class method. */
   CXCursor_ObjCClassMethodDecl           = 17,
   /** An Objective-C \@implementation. */
   CXCursor_ObjCImplementationDecl        = 18,
   /** An Objective-C \@implementation for a category. */
   CXCursor_ObjCCategoryImplDecl          = 19,
   /** A typedef. */
   CXCursor_TypedefDecl                   = 20,
   /** A C++ class method. */
   CXCursor_CXXMethod                     = 21,
   /** A C++ namespace. */
   CXCursor_Namespace                     = 22,
   /** A linkage specification, e.g. 'extern "C"'. */
   CXCursor_LinkageSpec                   = 23,
   /** A C++ constructor. */
   CXCursor_Constructor                   = 24,
   /** A C++ destructor. */
   CXCursor_Destructor                    = 25,
   /** A C++ conversion function. */
   CXCursor_ConversionFunction            = 26,
   /** A C++ template type parameter. */
   CXCursor_TemplateTypeParameter         = 27,
   /** A C++ non-type template parameter. */
   CXCursor_NonTypeTemplateParameter      = 28,
   /** A C++ template template parameter. */
   CXCursor_TemplateTemplateParameter     = 29,
   /** A C++ function template. */
   CXCursor_FunctionTemplate              = 30,
   /** A C++ class template. */
   CXCursor_ClassTemplate                 = 31,
   /** A C++ class template partial specialization. */
   CXCursor_ClassTemplatePartialSpecialization = 32,
   /** A C++ namespace alias declaration. */
   CXCursor_NamespaceAlias                = 33,
   /** A C++ using directive. */
   CXCursor_UsingDirective                = 34,
   /** A C++ using declaration. */
   CXCursor_UsingDeclaration              = 35,
   /** A C++ alias declaration */
   CXCursor_TypeAliasDecl                 = 36,
   /** An Objective-C \@synthesize definition. */
   CXCursor_ObjCSynthesizeDecl            = 37,
   /** An Objective-C \@dynamic definition. */
   CXCursor_ObjCDynamicDecl               = 38,
   /** An access specifier. */
   CXCursor_CXXAccessSpecifier            = 39,
 
   CXCursor_FirstDecl                     = CXCursor_UnexposedDecl,
   CXCursor_LastDecl                      = CXCursor_CXXAccessSpecifier,
 
   /* References */
   CXCursor_FirstRef                      = 40, /* Decl references */
   CXCursor_ObjCSuperClassRef             = 40,
   CXCursor_ObjCProtocolRef               = 41,
   CXCursor_ObjCClassRef                  = 42,
   /**
    * A reference to a type declaration.
    *
    * A type reference occurs anywhere where a type is named but not
    * declared. For example, given:
    *
    * \code
    * typedef unsigned size_type;
    * size_type size;
    * \endcode
    *
    * The typedef is a declaration of size_type (CXCursor_TypedefDecl),
    * while the type of the variable "size" is referenced. The cursor
    * referenced by the type of size is the typedef for size_type.
    */
   CXCursor_TypeRef                       = 43,
   CXCursor_CXXBaseSpecifier              = 44,
   /**
    * A reference to a class template, function template, template
    * template parameter, or class template partial specialization.
    */
   CXCursor_TemplateRef                   = 45,
   /**
    * A reference to a namespace or namespace alias.
    */
   CXCursor_NamespaceRef                  = 46,
   /**
    * A reference to a member of a struct, union, or class that occurs in
    * some non-expression context, e.g., a designated initializer.
    */
   CXCursor_MemberRef                     = 47,
   /**
    * A reference to a labeled statement.
    *
    * This cursor kind is used to describe the jump to "start_over" in the
    * goto statement in the following example:
    *
    * \code
    *   start_over:
    *     ++counter;
    *
    *     goto start_over;
    * \endcode
    *
    * A label reference cursor refers to a label statement.
    */
   CXCursor_LabelRef                      = 48,
 
   /**
    * A reference to a set of overloaded functions or function templates
    * that has not yet been resolved to a specific function or function template.
    *
    * An overloaded declaration reference cursor occurs in C++ templates where
    * a dependent name refers to a function. For example:
    *
enum CXCursorKind {
    * instantiation time, "swap" may also refer to other functions found via
    * argument-dependent lookup (e.g., the "swap" function at the end of the
    * example).
    *
    * The functions \c clang_getNumOverloadedDecls() and
    * \c clang_getOverloadedDecl() can be used to retrieve the definitions
    * referenced by this cursor.
    */
   CXCursor_OverloadedDeclRef             = 49,
 
   /**
    * A reference to a variable that occurs in some non-expression
    * context, e.g., a C++ lambda capture list.
    */
   CXCursor_VariableRef                   = 50,
 
   CXCursor_LastRef                       = CXCursor_VariableRef,
 
   /* Error conditions */
   CXCursor_FirstInvalid                  = 70,
   CXCursor_InvalidFile                   = 70,
   CXCursor_NoDeclFound                   = 71,
   CXCursor_NotImplemented                = 72,
   CXCursor_InvalidCode                   = 73,
   CXCursor_LastInvalid                   = CXCursor_InvalidCode,
 
   /* Expressions */
   CXCursor_FirstExpr                     = 100,
 
   /**
    * An expression whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed expressions have the same operations as any other kind
    * of expression; one can extract their location information,
    * spelling, children, etc. However, the specific kind of the
    * expression is not reported.
    */
   CXCursor_UnexposedExpr                 = 100,
 
   /**
    * An expression that refers to some value declaration, such
    * as a function, variable, or enumerator.
    */
   CXCursor_DeclRefExpr                   = 101,
 
   /**
    * An expression that refers to a member of a struct, union,
    * class, Objective-C class, etc.
    */
   CXCursor_MemberRefExpr                 = 102,
 
   /** An expression that calls a function. */
   CXCursor_CallExpr                      = 103,
 
   /** An expression that sends a message to an Objective-C
    object or class. */
   CXCursor_ObjCMessageExpr               = 104,
 
   /** An expression that represents a block literal. */
   CXCursor_BlockExpr                     = 105,
 
   /** An integer literal.
    */
   CXCursor_IntegerLiteral                = 106,
 
   /** A floating point number literal.
    */
   CXCursor_FloatingLiteral               = 107,
 
   /** An imaginary number literal.
    */
   CXCursor_ImaginaryLiteral              = 108,
 
   /** A string literal.
    */
   CXCursor_StringLiteral                 = 109,
 
   /** A character literal.
    */
   CXCursor_CharacterLiteral              = 110,
 
   /** A parenthesized expression, e.g. "(1)".
    *
    * This AST node is only formed if full location information is requested.
    */
   CXCursor_ParenExpr                     = 111,
 
   /** This represents the unary-expression's (except sizeof and
    * alignof).
    */
   CXCursor_UnaryOperator                 = 112,
 
   /** [C99 6.5.2.1] Array Subscripting.
    */
   CXCursor_ArraySubscriptExpr            = 113,
 
   /** A builtin binary operation expression such as "x + y" or
    * "x <= y".
    */
   CXCursor_BinaryOperator                = 114,
 
   /** Compound assignment such as "+=".
    */
   CXCursor_CompoundAssignOperator        = 115,
 
   /** The ?: ternary operator.
    */
   CXCursor_ConditionalOperator           = 116,
 
   /** An explicit cast in C (C99 6.5.4) or a C-style cast in C++
    * (C++ [expr.cast]), which uses the syntax (Type)expr.
    *
    * For example: (int)f.
    */
   CXCursor_CStyleCastExpr                = 117,
 
   /** [C99 6.5.2.5]
    */
   CXCursor_CompoundLiteralExpr           = 118,
 
   /** Describes an C or C++ initializer list.
    */
   CXCursor_InitListExpr                  = 119,
 
   /** The GNU address of label extension, representing &&label.
    */
   CXCursor_AddrLabelExpr                 = 120,
 
   /** This is the GNU Statement Expression extension: ({int X=4; X;})
    */
   CXCursor_StmtExpr                      = 121,
 
   /** Represents a C11 generic selection.
    */
   CXCursor_GenericSelectionExpr          = 122,
 
   /** Implements the GNU __null extension, which is a name for a null
    * pointer constant that has integral type (e.g., int or long) and is the same
    * size and alignment as a pointer.
    *
    * The __null extension is typically only used by system headers, which define
    * NULL as __null in C++ rather than using 0 (which is an integer that may not
    * match the size of a pointer).
    */
   CXCursor_GNUNullExpr                   = 123,
 
   /** C++'s static_cast<> expression.
    */
   CXCursor_CXXStaticCastExpr             = 124,
 
   /** C++'s dynamic_cast<> expression.
    */
   CXCursor_CXXDynamicCastExpr            = 125,
 
   /** C++'s reinterpret_cast<> expression.
    */
   CXCursor_CXXReinterpretCastExpr        = 126,
 
   /** C++'s const_cast<> expression.
    */
   CXCursor_CXXConstCastExpr              = 127,
 
   /** Represents an explicit C++ type conversion that uses "functional"
    * notion (C++ [expr.type.conv]).
    *
    * Example:
    * \code
    *   x = int(0.5);
    * \endcode
    */
   CXCursor_CXXFunctionalCastExpr         = 128,
 
   /** A C++ typeid expression (C++ [expr.typeid]).
    */
   CXCursor_CXXTypeidExpr                 = 129,
 
   /** [C++ 2.13.5] C++ Boolean Literal.
    */
   CXCursor_CXXBoolLiteralExpr            = 130,
 
   /** [C++0x 2.14.7] C++ Pointer Literal.
    */
   CXCursor_CXXNullPtrLiteralExpr         = 131,
 
   /** Represents the "this" expression in C++
    */
   CXCursor_CXXThisExpr                   = 132,
 
   /** [C++ 15] C++ Throw Expression.
    *
    * This handles 'throw' and 'throw' assignment-expression. When
    * assignment-expression isn't present, Op will be null.
    */
   CXCursor_CXXThrowExpr                  = 133,
 
   /** A new expression for memory allocation and constructor calls, e.g:
    * "new CXXNewExpr(foo)".
    */
   CXCursor_CXXNewExpr                    = 134,
 
   /** A delete expression for memory deallocation and destructor calls,
    * e.g. "delete[] pArray".
    */
   CXCursor_CXXDeleteExpr                 = 135,
 
   /** A unary expression. (noexcept, sizeof, or other traits)
    */
   CXCursor_UnaryExpr                     = 136,
 
   /** An Objective-C string literal i.e. @"foo".
    */
   CXCursor_ObjCStringLiteral             = 137,
 
   /** An Objective-C \@encode expression.
    */
   CXCursor_ObjCEncodeExpr                = 138,
 
   /** An Objective-C \@selector expression.
    */
   CXCursor_ObjCSelectorExpr              = 139,
 
   /** An Objective-C \@protocol expression.
    */
   CXCursor_ObjCProtocolExpr              = 140,
 
   /** An Objective-C "bridged" cast expression, which casts between
    * Objective-C pointers and C pointers, transferring ownership in the process.
    *
    * \code
    *   NSString *str = (__bridge_transfer NSString *)CFCreateString();
    * \endcode
    */
   CXCursor_ObjCBridgedCastExpr           = 141,
 
   /** Represents a C++0x pack expansion that produces a sequence of
    * expressions.
    *
    * A pack expansion expression contains a pattern (which itself is an
    * expression) followed by an ellipsis. For example:
    *
    * \code
    * template<typename F, typename ...Types>
    * void forward(F f, Types &&...args) {
    *  f(static_cast<Types&&>(args)...);
    * }
    * \endcode
    */
   CXCursor_PackExpansionExpr             = 142,
 
   /** Represents an expression that computes the length of a parameter
    * pack.
    *
    * \code
    * template<typename ...Types>
    * struct count {
    *   static const unsigned value = sizeof...(Types);
    * };
    * \endcode
    */
   CXCursor_SizeOfPackExpr                = 143,
 
   /* Represents a C++ lambda expression that produces a local function
    * object.
    *
    * \code
    * void abssort(float *x, unsigned N) {
    *   std::sort(x, x + N,
    *             [](float a, float b) {
    *               return std::abs(a) < std::abs(b);
    *             });
    * }
    * \endcode
    */
   CXCursor_LambdaExpr                    = 144,
 
   /** Objective-c Boolean Literal.
    */
   CXCursor_ObjCBoolLiteralExpr           = 145,
 
   /** Represents the "self" expression in an Objective-C method.
    */
   CXCursor_ObjCSelfExpr                  = 146,
 
   /** OpenMP 4.0 [2.4, Array Section].
    */
   CXCursor_OMPArraySectionExpr           = 147,
 
   /** Represents an @available(...) check.
    */
   CXCursor_ObjCAvailabilityCheckExpr     = 148,
 
   /**
    * Fixed point literal
    */
   CXCursor_FixedPointLiteral             = 149,
 
   CXCursor_LastExpr                      = CXCursor_FixedPointLiteral,
 
   /* Statements */
   CXCursor_FirstStmt                     = 200,
   /**
    * A statement whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed statements have the same operations as any other kind of
    * statement; one can extract their location information, spelling,
    * children, etc. However, the specific kind of the statement is not
    * reported.
    */
   CXCursor_UnexposedStmt                 = 200,
 
   /** A labelled statement in a function.
    *
    * This cursor kind is used to describe the "start_over:" label statement in
    * the following example:
    *
    * \code
    *   start_over:
    *     ++counter;
    * \endcode
    *
    */
   CXCursor_LabelStmt                     = 201,
 
   /** A group of statements like { stmt stmt }.
    *
    * This cursor kind is used to describe compound statements, e.g. function
    * bodies.
    */
   CXCursor_CompoundStmt                  = 202,
 
   /** A case statement.
    */
   CXCursor_CaseStmt                      = 203,
 
   /** A default statement.
    */
   CXCursor_DefaultStmt                   = 204,
 
   /** An if statement
    */
   CXCursor_IfStmt                        = 205,
 
   /** A switch statement.
    */
   CXCursor_SwitchStmt                    = 206,
 
   /** A while statement.
    */
   CXCursor_WhileStmt                     = 207,
 
   /** A do statement.
    */
   CXCursor_DoStmt                        = 208,
 
   /** A for statement.
    */
   CXCursor_ForStmt                       = 209,
 
   /** A goto statement.
    */
   CXCursor_GotoStmt                      = 210,
 
   /** An indirect goto statement.
    */
   CXCursor_IndirectGotoStmt              = 211,
 
   /** A continue statement.
    */
   CXCursor_ContinueStmt                  = 212,
 
   /** A break statement.
    */
   CXCursor_BreakStmt                     = 213,
 
   /** A return statement.
    */
   CXCursor_ReturnStmt                    = 214,
 
   /** A GCC inline assembly statement extension.
    */
   CXCursor_GCCAsmStmt                    = 215,
   CXCursor_AsmStmt                       = CXCursor_GCCAsmStmt,
 
   /** Objective-C's overall \@try-\@catch-\@finally statement.
    */
   CXCursor_ObjCAtTryStmt                 = 216,
 
   /** Objective-C's \@catch statement.
    */
   CXCursor_ObjCAtCatchStmt               = 217,
 
   /** Objective-C's \@finally statement.
    */
   CXCursor_ObjCAtFinallyStmt             = 218,
 
   /** Objective-C's \@throw statement.
    */
   CXCursor_ObjCAtThrowStmt               = 219,
 
   /** Objective-C's \@synchronized statement.
    */
   CXCursor_ObjCAtSynchronizedStmt        = 220,
 
   /** Objective-C's autorelease pool statement.
    */
   CXCursor_ObjCAutoreleasePoolStmt       = 221,
 
   /** Objective-C's collection statement.
    */
   CXCursor_ObjCForCollectionStmt         = 222,
 
   /** C++'s catch statement.
    */
   CXCursor_CXXCatchStmt                  = 223,
 
   /** C++'s try statement.
    */
   CXCursor_CXXTryStmt                    = 224,
 
   /** C++'s for (* : *) statement.
    */
   CXCursor_CXXForRangeStmt               = 225,
 
   /** Windows Structured Exception Handling's try statement.
    */
   CXCursor_SEHTryStmt                    = 226,
 
   /** Windows Structured Exception Handling's except statement.
    */
   CXCursor_SEHExceptStmt                 = 227,
 
   /** Windows Structured Exception Handling's finally statement.
    */
   CXCursor_SEHFinallyStmt                = 228,
 
   /** A MS inline assembly statement extension.
    */
   CXCursor_MSAsmStmt                     = 229,
 
   /** The null statement ";": C99 6.8.3p3.
    *
    * This cursor kind is used to describe the null statement.
    */
   CXCursor_NullStmt                      = 230,
 
   /** Adaptor class for mixing declarations with statements and
    * expressions.
    */
   CXCursor_DeclStmt                      = 231,
 
   /** OpenMP parallel directive.
    */
   CXCursor_OMPParallelDirective          = 232,
 
   /** OpenMP SIMD directive.
    */
   CXCursor_OMPSimdDirective              = 233,
 
   /** OpenMP for directive.
    */
   CXCursor_OMPForDirective               = 234,
 
   /** OpenMP sections directive.
    */
   CXCursor_OMPSectionsDirective          = 235,
 
   /** OpenMP section directive.
    */
   CXCursor_OMPSectionDirective           = 236,
 
   /** OpenMP single directive.
    */
   CXCursor_OMPSingleDirective            = 237,
 
   /** OpenMP parallel for directive.
    */
   CXCursor_OMPParallelForDirective       = 238,
 
   /** OpenMP parallel sections directive.
    */
   CXCursor_OMPParallelSectionsDirective  = 239,
 
   /** OpenMP task directive.
    */
   CXCursor_OMPTaskDirective              = 240,
 
   /** OpenMP master directive.
    */
   CXCursor_OMPMasterDirective            = 241,
 
   /** OpenMP critical directive.
    */
   CXCursor_OMPCriticalDirective          = 242,
 
   /** OpenMP taskyield directive.
    */
   CXCursor_OMPTaskyieldDirective         = 243,
 
   /** OpenMP barrier directive.
    */
   CXCursor_OMPBarrierDirective           = 244,
 
   /** OpenMP taskwait directive.
    */
   CXCursor_OMPTaskwaitDirective          = 245,
 
   /** OpenMP flush directive.
    */
   CXCursor_OMPFlushDirective             = 246,
 
   /** Windows Structured Exception Handling's leave statement.
    */
   CXCursor_SEHLeaveStmt                  = 247,
 
   /** OpenMP ordered directive.
    */
   CXCursor_OMPOrderedDirective           = 248,
 
   /** OpenMP atomic directive.
    */
   CXCursor_OMPAtomicDirective            = 249,
 
   /** OpenMP for SIMD directive.
    */
   CXCursor_OMPForSimdDirective           = 250,
 
   /** OpenMP parallel for SIMD directive.
    */
   CXCursor_OMPParallelForSimdDirective   = 251,
 
   /** OpenMP target directive.
    */
   CXCursor_OMPTargetDirective            = 252,
 
   /** OpenMP teams directive.
    */
   CXCursor_OMPTeamsDirective             = 253,
 
   /** OpenMP taskgroup directive.
    */
   CXCursor_OMPTaskgroupDirective         = 254,
 
   /** OpenMP cancellation point directive.
    */
   CXCursor_OMPCancellationPointDirective = 255,
 
   /** OpenMP cancel directive.
    */
   CXCursor_OMPCancelDirective            = 256,
 
   /** OpenMP target data directive.
    */
   CXCursor_OMPTargetDataDirective        = 257,
 
   /** OpenMP taskloop directive.
    */
   CXCursor_OMPTaskLoopDirective          = 258,
 
   /** OpenMP taskloop simd directive.
    */
   CXCursor_OMPTaskLoopSimdDirective      = 259,
 
   /** OpenMP distribute directive.
    */
   CXCursor_OMPDistributeDirective        = 260,
 
   /** OpenMP target enter data directive.
    */
   CXCursor_OMPTargetEnterDataDirective   = 261,
 
   /** OpenMP target exit data directive.
    */
   CXCursor_OMPTargetExitDataDirective    = 262,
 
   /** OpenMP target parallel directive.
    */
   CXCursor_OMPTargetParallelDirective    = 263,
 
   /** OpenMP target parallel for directive.
    */
   CXCursor_OMPTargetParallelForDirective = 264,
 
   /** OpenMP target update directive.
    */
   CXCursor_OMPTargetUpdateDirective      = 265,
 
   /** OpenMP distribute parallel for directive.
    */
   CXCursor_OMPDistributeParallelForDirective = 266,
 
   /** OpenMP distribute parallel for simd directive.
    */
   CXCursor_OMPDistributeParallelForSimdDirective = 267,
enum CXCursorKind {
   CXCursor_OMPMasterTaskLoopDirective = 281,
 
   /** OpenMP parallel master taskloop directive.
    */
   CXCursor_OMPParallelMasterTaskLoopDirective = 282,
 
   /** OpenMP master taskloop simd directive.
    */
   CXCursor_OMPMasterTaskLoopSimdDirective      = 283,
 
   /** OpenMP parallel master taskloop simd directive.
    */
   CXCursor_OMPParallelMasterTaskLoopSimdDirective      = 284,
 
   /** OpenMP parallel master directive.
    */
   CXCursor_OMPParallelMasterDirective      = 285,
 
   /** OpenMP depobj directive.
    */
   CXCursor_OMPDepobjDirective             = 286,
 
-  CXCursor_LastStmt = CXCursor_OMPDepobjDirective,
+  CXCursor_OMPMetaDirective  = 287,
+
+  CXCursor_LastStmt = CXCursor_OMPMetaDirective,
 
   /**
    * Cursor that represents the translation unit itself.
    *
    * The translation unit cursor exists primarily to act as the root
    * cursor for traversing the contents of a translation unit.
    */
   CXCursor_TranslationUnit               = 300,
 
   /* Attributes */
   CXCursor_FirstAttr                     = 400,
   /**
    * An attribute whose specific kind is not exposed via this
    * interface.
    */
   CXCursor_UnexposedAttr                 = 400,
 
   CXCursor_IBActionAttr                  = 401,
   CXCursor_IBOutletAttr                  = 402,
   CXCursor_IBOutletCollectionAttr        = 403,
   CXCursor_CXXFinalAttr                  = 404,
   CXCursor_CXXOverrideAttr               = 405,
   CXCursor_AnnotateAttr                  = 406,
   CXCursor_AsmLabelAttr                  = 407,
enum CXCursorKind {
   CXCursor_FlagEnum                      = 437,
   CXCursor_ConvergentAttr                = 438,
   CXCursor_WarnUnusedAttr                = 439,
   CXCursor_WarnUnusedResultAttr          = 440,
   CXCursor_AlignedAttr                   = 441,
   CXCursor_LastAttr                      = CXCursor_AlignedAttr,
 
   /* Preprocessing */
   CXCursor_PreprocessingDirective        = 500,
   CXCursor_MacroDefinition               = 501,
   CXCursor_MacroExpansion                = 502,
   CXCursor_MacroInstantiation            = CXCursor_MacroExpansion,
   CXCursor_InclusionDirective            = 503,
   CXCursor_FirstPreprocessing            = CXCursor_PreprocessingDirective,
   CXCursor_LastPreprocessing             = CXCursor_InclusionDirective,
 
   /* Extra Declarations */
   /**
    * A module import declaration.
    */
   CXCursor_ModuleImportDecl              = 600,
   CXCursor_TypeAliasTemplateDecl         = 601,
   /**
    * A static_assert or _Static_assert node
    */
   CXCursor_StaticAssert                  = 602,
   /**
    * a friend declaration.
    */
   CXCursor_FriendDecl                    = 603,
   CXCursor_FirstExtraDecl                = CXCursor_ModuleImportDecl,
   CXCursor_LastExtraDecl                 = CXCursor_FriendDecl,
 
   /**
    * A code completion overload candidate.
    */
   CXCursor_OverloadCandidate             = 700
 };
 
 /**
  * A cursor representing some element in the abstract syntax tree for
  * a translation unit.
  *
  * The cursor abstraction unifies the different kinds of entities in a
  * program--declaration, statements, expressions, references to declarations,

clang/include/clang/AST/OpenMPClause.h

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() == OMPC_collapse;
   }
 };
 
+/// This represents 'when' clause in the '#pragma omp ...' directive
+///
+/// \code
+/// #pragma omp metadirective when(user={condition(N<10)}: parallel)
+/// \endcode
+/// In this example directive '#pragma omp metadirective' has simple 'when'
+/// clause with user defined condition.
+class OMPWhenClause : public OMPClause {
+  friend class OMPClauseReader;
+
+  Expr *expr;
+  OpenMPDirectiveKind DKind;
+  SmallVector<OMPClause *, 5> Clauses;
+
+  /// Location of '('.
+  SourceLocation LParenLoc;
+
+  void setExpr(Expr *E) { expr = E; }
+
+public:
+  /// Build 'when' clause with argument \a A ('none' or 'shared').
+  ///
+  /// \param A Argument of the clause ('none' or 'shared').
+  /// \param ALoc Starting location of the argument.
+  /// \param StartLoc Starting location of the clause.
+  /// \param LParenLoc Location of '('.
+  /// \param EndLoc Ending location of the clause.
+  OMPWhenClause(Expr *expr, OpenMPDirectiveKind dKind,
+                SmallVector<OMPClause *, 5> clauses, SourceLocation StartLoc,
+                SourceLocation LParenLoc, SourceLocation EndLoc)
+      : OMPClause(OMPC_when, StartLoc, EndLoc),
+        expr(expr), DKind(dKind), Clauses(clauses), LParenLoc(LParenLoc) {}
+
+  /// Build an empty clause.
+  OMPWhenClause()
+      : OMPClause(OMPC_when, SourceLocation(), SourceLocation()) {}
+
+  /// Sets the location of '('.
+  void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
+
+  /// Returns the location of '('.
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+
+  /// Returns the associated condition expression
+  Expr *getExpr() const { return expr; }
+
+  /// Returns the directive variant
+  OpenMPDirectiveKind getDKind() { return DKind; }
+
+  /// Returns the clauses associated with the directive variants
+  SmallVector<OMPClause *, 5> getClauses() { return Clauses; }
+
+  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() == OMPC_when;
+  }
+};
+
 /// This represents 'default' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp parallel default(shared)
 /// \endcode
 /// In this example directive '#pragma omp parallel' has simple 'default'
 /// clause with kind 'shared'.
 class OMPDefaultClause : public OMPClause {

clang/include/clang/AST/RecursiveASTVisitor.h

 }
 
 template <typename Derived>
 bool
 RecursiveASTVisitor<Derived>::TraverseOMPLoopDirective(OMPLoopDirective *S) {
   return TraverseOMPExecutableDirective(S);
 }
 
+DEF_TRAVERSE_STMT(OMPMetaDirective,
+                  { TRY_TO(TraverseOMPExecutableDirective(S)); })
+
 DEF_TRAVERSE_STMT(OMPParallelDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPForDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })

 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) {
+  TRY_TO(TraverseStmt(C->getExpr()));
+  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

public:
   const Stmt *getStructuredBlock() const;
 
   Stmt *getStructuredBlock() {
     return const_cast<Stmt *>(
         const_cast<const OMPExecutableDirective *>(this)->getStructuredBlock());
   }
 };
 
+class OMPMetaDirective : public OMPExecutableDirective {
+  friend class ASTStmtReader;
+  Stmt* IfStmt;
+
+  OMPMetaDirective(SourceLocation StartLoc, SourceLocation EndLoc,
+                   unsigned NumClauses)
+    : OMPExecutableDirective(this, OMPMetaDirectiveClass,
+                             llvm::omp::OMPD_metadirective, StartLoc, EndLoc,
+                             NumClauses, 1) {}
+  explicit OMPMetaDirective(unsigned NumClauses)
+    : OMPExecutableDirective(this, OMPMetaDirectiveClass,
+                             llvm::omp::OMPD_metadirective, SourceLocation(),
+                             SourceLocation(), NumClauses, 1) {}
+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);
+
+  void setIfStmt(Stmt* stmt) { IfStmt = stmt; }
+  Stmt* getIfStmt() const { return IfStmt; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == OMPMetaDirectiveClass;
+  }
+};
+
 /// This represents '#pragma omp parallel' directive.
 ///
 /// \code
 /// #pragma omp parallel private(a,b) reduction(+: c,d)
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clauses 'private'
 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
 /// variables 'c' and 'd'.

clang/include/clang/Basic/OpenMPKinds.def

 #define OPENMP_ORDER_KIND(Name)
 #endif
 #ifndef OPENMP_FLUSH_CLAUSE
 #define OPENMP_FLUSH_CLAUSE(Name)
 #endif
 #ifndef OPENMP_DEPOBJ_CLAUSE
 #define OPENMP_DEPOBJ_CLAUSE(Name)
 #endif
+#ifndef OPENMP_METADIRECTIVE_CLAUSE
+#define OPENMP_METADIRECTIVE_CLAUSE(Name)
+#endif
  
 // OpenMP clauses.
 OPENMP_CLAUSE(allocator, OMPAllocatorClause)
 OPENMP_CLAUSE(if, OMPIfClause)
 OPENMP_CLAUSE(final, OMPFinalClause)
 OPENMP_CLAUSE(num_threads, OMPNumThreadsClause)
 OPENMP_CLAUSE(safelen, OMPSafelenClause)
 OPENMP_CLAUSE(simdlen, OMPSimdlenClause)
 OPENMP_CLAUSE(collapse, OMPCollapseClause)

 OPENMP_CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
 OPENMP_CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
 OPENMP_CLAUSE(allocate, OMPAllocateClause)
 OPENMP_CLAUSE(nontemporal, OMPNontemporalClause)
 OPENMP_CLAUSE(order, OMPOrderClause)
 OPENMP_CLAUSE(depobj, OMPDepobjClause)
 OPENMP_CLAUSE(destroy, OMPDestroyClause)
 OPENMP_CLAUSE(detach, OMPDetachClause)
+OPENMP_CLAUSE(when, OMPWhenClause)
 
 // Clauses allowed for OpenMP directive 'parallel'.
 OPENMP_PARALLEL_CLAUSE(if)
 OPENMP_PARALLEL_CLAUSE(num_threads)
 OPENMP_PARALLEL_CLAUSE(default)
 OPENMP_PARALLEL_CLAUSE(proc_bind)
 OPENMP_PARALLEL_CLAUSE(private)
 OPENMP_PARALLEL_CLAUSE(firstprivate)

 OPENMP_FLUSH_CLAUSE(acquire)
 OPENMP_FLUSH_CLAUSE(release)
 
 // Clauses allowed for OpenMP directive 'depobj'.
 OPENMP_DEPOBJ_CLAUSE(depend)
 OPENMP_DEPOBJ_CLAUSE(destroy)
 OPENMP_DEPOBJ_CLAUSE(update)
 
+// Clauses allowed for OpenMP directive 'metadirective'.
+OPENMP_METADIRECTIVE_CLAUSE(when)
+OPENMP_METADIRECTIVE_CLAUSE(default)
+
+#undef OPENMP_METADIRECTIVE_CLAUSE
 #undef OPENMP_DEPOBJ_CLAUSE
 #undef OPENMP_FLUSH_CLAUSE
 #undef OPENMP_ORDER_KIND
 #undef OPENMP_LASTPRIVATE_KIND
 #undef OPENMP_DECLARE_VARIANT_CLAUSE
 #undef OPENMP_DEVICE_TYPE_KIND
 #undef OPENMP_ALLOCATE_CLAUSE
 #undef OPENMP_DECLARE_MAPPER_CLAUSE

clang/include/clang/Basic/StmtNodes.td

 def SEHLeaveStmt : StmtNode<Stmt>;
 def MSDependentExistsStmt : StmtNode<Stmt>;
 
 // OpenCL Extensions.
 def AsTypeExpr : StmtNode<Expr>;
 
 // OpenMP Directives.
 def OMPExecutableDirective : StmtNode<Stmt, 1>;
+def OMPMetaDirective : StmtNode<OMPExecutableDirective>;
 def OMPLoopDirective : StmtNode<OMPExecutableDirective, 1>;
 def OMPParallelDirective : StmtNode<OMPExecutableDirective>;
 def OMPSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPForDirective : StmtNode<OMPLoopDirective>;
 def OMPForSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPSectionsDirective : StmtNode<OMPExecutableDirective>;
 def OMPSectionDirective : StmtNode<OMPExecutableDirective>;
 def OMPSingleDirective : StmtNode<OMPExecutableDirective>;

clang/include/clang/Parse/Parser.h

bool ParseOpenMPSimpleVarList(
       const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> &
           Callback,
       bool AllowScopeSpecifier);
   /// Parses declarative or executable directive.
   ///
   /// \param StmtCtx The context in which we're parsing the directive.
   StmtResult
   ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx);
+  /// Parses clause for metadirective
+  ///
+  OMPClause* ParseOpenMPMetaClause(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

public:
 
   /// Check if the current region is an OpenMP loop region and if it is,
   /// mark loop control variable, used in \p Init for loop initialization, as
   /// private by default.
   /// \param Init First part of the for loop.
   void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
 
   // OpenMP directives and clauses.
+  /// Called on well-formed '\#pragma omp metadirective' after parsing
+  /// of the  associated statement.
+  StmtResult ActOnOpenMPMetaDirective(ArrayRef<OMPClause *> Clauses,
+                                      Stmt *AStmt,
+                                      SourceLocation StartLoc,
+                                      SourceLocation EndLoc);
   /// Called on correct id-expression from the '#pragma omp
   /// threadprivate'.
   ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec,
                                      const DeclarationNameInfo &Id,
                                      OpenMPDirectiveKind Kind);
   /// Called on well-formed '#pragma omp threadprivate'.
   DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
                                      SourceLocation Loc,
OMPClause *ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc,
                                      SourceLocation EndLoc);
 
   OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
                                      unsigned Argument,
                                      SourceLocation ArgumentLoc,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc);
+  /// Called on well-formed 'when' clause.
+  OMPClause *ActOnOpenMPWhenClause(Expr* Expr,
+                                   OpenMPDirectiveKind DKind,
+                                   SmallVector<OMPClause*, 5> Clauses,
+                                   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);
   /// Called on well-formed 'proc_bind' clause.
   OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind,

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
       EXPR_USER_DEFINED_LITERAL,
 
       /// A CXXStdInitializerListExpr record.
       EXPR_CXX_STD_INITIALIZER_LIST,
 
       /// A CXXBoolLiteralExpr record.
       EXPR_CXX_BOOL_LITERAL,
 
       EXPR_CXX_NULL_PTR_LITERAL,  // CXXNullPtrLiteralExpr
       EXPR_CXX_TYPEID_EXPR,       // CXXTypeidExpr (of expr).
       EXPR_CXX_TYPEID_TYPE,       // CXXTypeidExpr (of type).
       EXPR_CXX_THIS,              // CXXThisExpr
       EXPR_CXX_THROW,             // CXXThrowExpr
       EXPR_CXX_DEFAULT_ARG,       // CXXDefaultArgExpr
       EXPR_CXX_DEFAULT_INIT,      // CXXDefaultInitExpr
       EXPR_CXX_BIND_TEMPORARY,    // CXXBindTemporaryExpr
 
       EXPR_CXX_SCALAR_VALUE_INIT, // CXXScalarValueInitExpr
       EXPR_CXX_NEW,               // CXXNewExpr
       EXPR_CXX_DELETE,            // CXXDeleteExpr
       EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr
 
       EXPR_EXPR_WITH_CLEANUPS,    // ExprWithCleanups
 
       EXPR_CXX_DEPENDENT_SCOPE_MEMBER,   // CXXDependentScopeMemberExpr
       EXPR_CXX_DEPENDENT_SCOPE_DECL_REF, // DependentScopeDeclRefExpr
       EXPR_CXX_UNRESOLVED_CONSTRUCT,     // CXXUnresolvedConstructExpr
       EXPR_CXX_UNRESOLVED_MEMBER,        // UnresolvedMemberExpr
       EXPR_CXX_UNRESOLVED_LOOKUP,        // UnresolvedLookupExpr
 
       EXPR_CXX_EXPRESSION_TRAIT,  // ExpressionTraitExpr
       EXPR_CXX_NOEXCEPT,          // CXXNoexceptExpr
 
       EXPR_OPAQUE_VALUE,          // OpaqueValueExpr
       EXPR_BINARY_CONDITIONAL_OPERATOR,  // BinaryConditionalOperator
       EXPR_TYPE_TRAIT,            // TypeTraitExpr
       EXPR_ARRAY_TYPE_TRAIT,      // ArrayTypeTraitIntExpr
 
       EXPR_PACK_EXPANSION,        // PackExpansionExpr
       EXPR_SIZEOF_PACK,           // SizeOfPackExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM, // SubstNonTypeTemplateParmExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK,// SubstNonTypeTemplateParmPackExpr
       EXPR_FUNCTION_PARM_PACK,    // FunctionParmPackExpr
       EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr
       EXPR_CXX_FOLD,              // CXXFoldExpr
       EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr
       EXPR_REQUIRES,              // RequiresExpr
 
       // CUDA
       EXPR_CUDA_KERNEL_CALL,       // CUDAKernelCallExpr
 
       // OpenCL
       EXPR_ASTYPE,                 // AsTypeExpr
 
       // Microsoft
       EXPR_CXX_PROPERTY_REF_EXPR, // MSPropertyRefExpr
       EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR, // MSPropertySubscriptExpr
       EXPR_CXX_UUIDOF_EXPR,       // CXXUuidofExpr (of expr).
       EXPR_CXX_UUIDOF_TYPE,       // CXXUuidofExpr (of type).
       STMT_SEH_LEAVE,             // SEHLeaveStmt
       STMT_SEH_EXCEPT,            // SEHExceptStmt
       STMT_SEH_FINALLY,           // SEHFinallyStmt
       STMT_SEH_TRY,               // SEHTryStmt
 
       // OpenMP directives
+      STMT_OMP_META_DIRECTIVE,
       STMT_OMP_PARALLEL_DIRECTIVE,
       STMT_OMP_SIMD_DIRECTIVE,
       STMT_OMP_FOR_DIRECTIVE,
       STMT_OMP_FOR_SIMD_DIRECTIVE,
       STMT_OMP_SECTIONS_DIRECTIVE,
       STMT_OMP_SECTION_DIRECTIVE,
       STMT_OMP_SINGLE_DIRECTIVE,
       STMT_OMP_MASTER_DIRECTIVE,
enum StmtCode {
       STMT_OMP_TARGET_TEAMS_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
       EXPR_OMP_ARRAY_SECTION,
 
       // ARC
       EXPR_OBJC_BRIDGED_CAST,     // ObjCBridgedCastExpr
 
       STMT_MS_DEPENDENT_EXISTS,   // MSDependentExistsStmt
       EXPR_LAMBDA,                // LambdaExpr
       STMT_COROUTINE_BODY,
       STMT_CORETURN,
       EXPR_COAWAIT,
       EXPR_COYIELD,
       EXPR_DEPENDENT_COAWAIT,
     };
 

clang/lib/AST/OpenMPClause.cpp

const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
   case OMPC_dynamic_allocators:
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_order:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     break;
   }
 
   return nullptr;
 }
 
 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
   auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
   case OMPC_dynamic_allocators:
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_order:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     break;
   }
 
   return nullptr;
 }
 
 /// Gets the address of the original, non-captured, expression used in the
 /// clause as the preinitializer.
void OMPNontemporalClause::setPrivateRefs(ArrayRef<Expr *> VL) {
   assert(VL.size() == varlist_size() && "Number of private references is not "
                                         "the same as the preallocated buffer");
   std::copy(VL.begin(), VL.end(), varlist_end());
 }
 
 //===----------------------------------------------------------------------===//
 //  OpenMP clauses printing methods
 //===----------------------------------------------------------------------===//
+void OMPClausePrinter::VisitOMPWhenClause(OMPWhenClause *Node) {
+  OS << "when(";
+  if(Node->getExpr() != NULL)
+    Node->getExpr()->printPretty(OS, nullptr, Policy, 0);
+  OS << ")";
+}
 
 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
   OS << "if(";
   if (Node->getNameModifier() != llvm::omp::OMPD_unknown)
     OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
   OS << ")";
 }

clang/lib/AST/StmtOpenMP.cpp

 }
 
 void OMPLoopDirective::setFinalsConditions(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() &&
          "Number of finals conditions is not the same as the collapsed number");
   llvm::copy(A, getFinalsConditions().begin());
 }
 
+OMPMetaDirective *OMPMetaDirective::Create(
+    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Stmt *IfStmt) {
+  unsigned Size = llvm::alignTo(sizeof(OMPMetaDirective), alignof(OMPClause *));
+  void *Mem =
+      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
+  OMPMetaDirective *Dir = new (Mem) OMPMetaDirective(StartLoc, EndLoc,
+                                                     Clauses.size());
+  Dir->setClauses(Clauses);
+  Dir->setAssociatedStmt(AssociatedStmt);
+  Dir->setIfStmt(IfStmt);
+  return Dir;
+}
+
+OMPMetaDirective *OMPMetaDirective::CreateEmpty(const ASTContext &C,
+                                                unsigned NumClauses,
+                                                EmptyShell) {
+  unsigned Size = llvm::alignTo(sizeof(OMPMetaDirective), alignof(OMPClause *));
+  void *Mem =
+      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
+  return new (Mem) OMPMetaDirective(NumClauses);
+}
+
 OMPParallelDirective *OMPParallelDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
   unsigned Size =
       llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *));
   void *Mem =
       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
   OMPParallelDirective *Dir =

clang/lib/AST/StmtPrinter.cpp

if (Clause && !Clause->isImplicit()) {
       OS << ' ';
       Printer.Visit(Clause);
     }
   OS << NL;
   if (!ForceNoStmt && S->hasAssociatedStmt())
     PrintStmt(S->getInnermostCapturedStmt()->getCapturedStmt());
 }
 
+void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) {
+  Indent() << "#pragma omp metadirective";
+  PrintOMPExecutableDirective(Node);
+}
+
 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
   Indent() << "#pragma omp parallel";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
   Indent() << "#pragma omp simd";
   PrintOMPExecutableDirective(Node);

clang/lib/AST/StmtProfile.cpp

if (C->getNumForLoops())
     Profiler->VisitStmt(C->getNumForLoops());
 }
 
 void OMPClauseProfiler::VisitOMPDetachClause(const OMPDetachClause *C) {
   if (Expr *Evt = C->getEventHandler())
     Profiler->VisitStmt(Evt);
 }
 
+void OMPClauseProfiler::VisitOMPWhenClause(const OMPWhenClause *C) {
+  if(C->getExpr())
+    Profiler->VisitStmt(C->getExpr());
+}
+
 void OMPClauseProfiler::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
 
 void OMPClauseProfiler::VisitOMPProcBindClause(const OMPProcBindClause *C) { }
 
 void OMPClauseProfiler::VisitOMPUnifiedAddressClause(
     const OMPUnifiedAddressClause *C) {}
 
 void OMPClauseProfiler::VisitOMPUnifiedSharedMemoryClause(
StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
   OMPClauseProfiler P(this);
   ArrayRef<OMPClause *> Clauses = S->clauses();
   for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
        I != E; ++I)
     if (*I)
       P.Visit(*I);
 }
 
+void StmtProfiler::VisitOMPMetaDirective(const OMPMetaDirective *S) {
+  VisitOMPExecutableDirective(S);
+}
+
 void StmtProfiler::VisitOMPLoopDirective(const OMPLoopDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 

clang/lib/Basic/OpenMPKinds.cpp

#include "clang/Basic/OpenMPKinds.def"
   case OMPC_unified_address:
   case OMPC_unified_shared_memory:
   case OMPC_reverse_offload:
   case OMPC_dynamic_allocators:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     break;
   }
   llvm_unreachable("Invalid OpenMP simple clause kind");
 }
 
 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
                                                  unsigned Type) {
   switch (Kind) {
#include "clang/Basic/OpenMPKinds.def"
   case OMPC_unified_address:
   case OMPC_unified_shared_memory:
   case OMPC_reverse_offload:
   case OMPC_dynamic_allocators:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     break;
   }
   llvm_unreachable("Invalid OpenMP simple clause kind");
 }
 
 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
                                         OpenMPClauseKind CKind,
                                         unsigned OpenMPVersion) {
   assert(unsigned(DKind) <= unsigned(OMPD_unknown));
   assert(CKind <= OMPC_unknown);
   // Nontemporal clause is not supported in OpenMP < 5.0.
   if (OpenMPVersion < 50 && CKind == OMPC_nontemporal)
     return false;
   // Order clause is not supported in OpenMP < 5.0.
   if (OpenMPVersion < 50 && CKind == OMPC_order)
     return false;
   switch (DKind) {
+  case OMPD_metadirective:
+    switch(CKind) {
+#define OPENMP_METADIRECTIVE_CLAUSE(Name)                                      \
+  case OMPC_##Name:                                                            \
+      return true;
+#include "clang/Basic/OpenMPKinds.def"
+    default:
+      break;
+    }
+    break;
   case OMPD_parallel:
     switch (CKind) {
 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
   case OMPC_##Name:                                                            \
     return true;
 #include "clang/Basic/OpenMPKinds.def"
     default:
       break;
return Kind == OMPD_distribute_parallel_for ||
          Kind == OMPD_target_teams_distribute_parallel_for_simd;
 }
 
 void clang::getOpenMPCaptureRegions(
     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
     OpenMPDirectiveKind DKind) {
   assert(DKind <= OMPD_unknown);
   switch (DKind) {
+  case OMPD_metadirective:
+    CaptureRegions.push_back(OMPD_metadirective);
+    break;
   case OMPD_parallel:
   case OMPD_parallel_for:
   case OMPD_parallel_for_simd:
   case OMPD_parallel_master:
   case OMPD_parallel_sections:
   case OMPD_distribute_parallel_for:
   case OMPD_distribute_parallel_for_simd:
     CaptureRegions.push_back(OMPD_parallel);

clang/lib/CodeGen/CGOpenMPRuntime.cpp

emitNumTeamsForTargetDirective(CodeGenFunction &CGF,
   case OMPD_declare_mapper:
   case OMPD_taskloop:
   case OMPD_taskloop_simd:
   case OMPD_master_taskloop:
   case OMPD_master_taskloop_simd:
   case OMPD_parallel_master_taskloop:
   case OMPD_parallel_master_taskloop_simd:
   case OMPD_requires:
+  case OMPD_metadirective:
   case OMPD_unknown:
     break;
   }
   llvm_unreachable("Unexpected directive kind.");
 }
 
 static llvm::Value *getNumThreads(CodeGenFunction &CGF, const CapturedStmt *CS,
                                   llvm::Value *DefaultThreadLimitVal) {
emitNumThreadsForTargetDirective(CodeGenFunction &CGF,
   case OMPD_declare_mapper:
   case OMPD_taskloop:
   case OMPD_taskloop_simd:
   case OMPD_master_taskloop:
   case OMPD_master_taskloop_simd:
   case OMPD_parallel_master_taskloop:
   case OMPD_parallel_master_taskloop_simd:
   case OMPD_requires:
+  case OMPD_metadirective:
   case OMPD_unknown:
     break;
   }
   llvm_unreachable("Unsupported directive kind.");
 }
 
 namespace {
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
if (const auto *NestedDir =
     case OMPD_declare_mapper:
     case OMPD_taskloop:
     case OMPD_taskloop_simd:
     case OMPD_master_taskloop:
     case OMPD_master_taskloop_simd:
     case OMPD_parallel_master_taskloop:
     case OMPD_parallel_master_taskloop_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
     case OMPD_unknown:
       llvm_unreachable("Unexpected directive.");
     }
   }
 
   return nullptr;
 }
 
if (RequiresDeviceCodegen) {
     case OMPD_declare_mapper:
     case OMPD_taskloop:
     case OMPD_taskloop_simd:
     case OMPD_master_taskloop:
     case OMPD_master_taskloop_simd:
     case OMPD_parallel_master_taskloop:
     case OMPD_parallel_master_taskloop_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
     case OMPD_unknown:
       llvm_unreachable("Unknown target directive for OpenMP device codegen.");
     }
     return;
   }
 
   if (const auto *E = dyn_cast<OMPExecutableDirective>(S)) {
     if (!E->hasAssociatedStmt() || !E->getAssociatedStmt())
auto &&ThenGen = [this, &D, Device, &InputInfo,
     case OMPD_target_teams_distribute_simd:
     case OMPD_target_teams_distribute_parallel_for:
     case OMPD_target_teams_distribute_parallel_for_simd:
     case OMPD_target_teams:
     case OMPD_target_parallel:
     case OMPD_target_parallel_for:
     case OMPD_target_parallel_for_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
     case OMPD_unknown:
       llvm_unreachable("Unexpected standalone target data directive.");
       break;
     }
     CGF.EmitRuntimeCall(createRuntimeFunction(RTLFn), OffloadingArgs);
   };
 
   auto &&TargetThenGen = [this, &ThenGen, &D, &InputInfo, &MapTypesArray](

clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp

if (const auto *NestedDir =
     case OMPD_declare_mapper:
     case OMPD_taskloop:
     case OMPD_taskloop_simd:
     case OMPD_master_taskloop:
     case OMPD_master_taskloop_simd:
     case OMPD_parallel_master_taskloop:
     case OMPD_parallel_master_taskloop_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
     case OMPD_unknown:
       llvm_unreachable("Unexpected directive.");
     }
   }
 
   return false;
 }
 
static bool supportsSPMDExecutionMode(ASTContext &Ctx,
   case OMPD_declare_mapper:
   case OMPD_taskloop:
   case OMPD_taskloop_simd:
   case OMPD_master_taskloop:
   case OMPD_master_taskloop_simd:
   case OMPD_parallel_master_taskloop:
   case OMPD_parallel_master_taskloop_simd:
   case OMPD_requires:
+  case OMPD_metadirective:
   case OMPD_unknown:
     break;
   }
   llvm_unreachable(
       "Unknown programming model for OpenMP directive on NVPTX target.");
 }
 
 /// Check if the directive is loops based and has schedule clause at all or has
if (const auto *NestedDir =
     case OMPD_declare_mapper:
     case OMPD_taskloop:
     case OMPD_taskloop_simd:
     case OMPD_master_taskloop:
     case OMPD_master_taskloop_simd:
     case OMPD_parallel_master_taskloop:
     case OMPD_parallel_master_taskloop_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
     case OMPD_unknown:
       llvm_unreachable("Unexpected directive.");
     }
   }
 
   return false;
 }
 
static bool supportsLightweightRuntime(ASTContext &Ctx,
   case OMPD_declare_mapper:
   case OMPD_taskloop:
   case OMPD_taskloop_simd:
   case OMPD_master_taskloop:
   case OMPD_master_taskloop_simd:
   case OMPD_parallel_master_taskloop:
   case OMPD_parallel_master_taskloop_simd:
   case OMPD_requires:
+  case OMPD_metadirective:
   case OMPD_unknown:
     break;
   }
   llvm_unreachable(
       "Unknown programming model for OpenMP directive on NVPTX target.");
 }
 
 void CGOpenMPRuntimeNVPTX::emitNonSPMDKernel(const OMPExecutableDirective &D,

clang/lib/CodeGen/CGStmt.cpp

case Stmt::CXXTryStmtClass:
     EmitCXXTryStmt(cast<CXXTryStmt>(*S));
     break;
   case Stmt::CXXForRangeStmtClass:
     EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S), Attrs);
     break;
   case Stmt::SEHTryStmtClass:
     EmitSEHTryStmt(cast<SEHTryStmt>(*S));
     break;
+  case Stmt::OMPMetaDirectiveClass:
+    EmitOMPMetaDirective(cast<OMPMetaDirective>(*S));
+    break;
   case Stmt::OMPParallelDirectiveClass:
     EmitOMPParallelDirective(cast<OMPParallelDirective>(*S));
     break;
   case Stmt::OMPSimdDirectiveClass:
     EmitOMPSimdDirective(cast<OMPSimdDirective>(*S));
     break;
   case Stmt::OMPForDirectiveClass:
     EmitOMPForDirective(cast<OMPForDirective>(*S));

clang/lib/CodeGen/CGStmtOpenMP.cpp

static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
   case OMPC_dynamic_allocators:
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_order:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     llvm_unreachable("Clause is not allowed in 'omp atomic'.");
   }
 }
 
 void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
   llvm::AtomicOrdering AO = llvm::AtomicOrdering::Monotonic;
   bool MemOrderingSpecified = false;
   if (S.getSingleClause<OMPSeqCstClause>()) {
auto &&CodeGen = [this, &S](CodeGenFunction &CGF, PrePostActionTy &Action) {
     EmitOMPTaskLoopBasedDirective(S);
   };
   auto LPCRegion =
       CGOpenMPRuntime::LastprivateConditionalRAII::disable(*this, S);
   OMPLexicalScope Scope(*this, S);
   CGM.getOpenMPRuntime().emitMasterRegion(*this, CodeGen, S.getBeginLoc());
 }
 
+void CodeGenFunction::EmitOMPMetaDirective(const OMPMetaDirective &S) {
+  Stmt *I = S.getIfStmt();
+  EmitIfStmt(cast<IfStmt>(*I));
+}
+
 void CodeGenFunction::EmitOMPParallelMasterTaskLoopDirective(
     const OMPParallelMasterTaskLoopDirective &S) {
   auto &&CodeGen = [this, &S](CodeGenFunction &CGF, PrePostActionTy &Action) {
     auto &&TaskLoopCodeGen = [&S](CodeGenFunction &CGF,
                                   PrePostActionTy &Action) {
       Action.Enter(CGF);
       CGF.EmitOMPTaskLoopBasedDirective(S);
     };

clang/lib/CodeGen/CodeGenFunction.h

OMPTargetDataInfo(Address BasePointersArray, Address PointersArray,
                       Address SizesArray, unsigned NumberOfTargetItems)
         : BasePointersArray(BasePointersArray), PointersArray(PointersArray),
           SizesArray(SizesArray), NumberOfTargetItems(NumberOfTargetItems) {}
   };
   void EmitOMPTargetTaskBasedDirective(const OMPExecutableDirective &S,
                                        const RegionCodeGenTy &BodyGen,
                                        OMPTargetDataInfo &InputInfo);
 
+  void EmitOMPMetaDirective(const OMPMetaDirective &S);
   void EmitOMPParallelDirective(const OMPParallelDirective &S);
   void EmitOMPSimdDirective(const OMPSimdDirective &S);
   void EmitOMPForDirective(const OMPForDirective &S);
   void EmitOMPForSimdDirective(const OMPForSimdDirective &S);
   void EmitOMPSectionsDirective(const OMPSectionsDirective &S);
   void EmitOMPSectionDirective(const OMPSectionDirective &S);
   void EmitOMPSingleDirective(const OMPSingleDirective &S);
   void EmitOMPMasterDirective(const OMPMasterDirective &S);

clang/lib/Parse/ParseOpenMP.cpp

Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
   case OMPD_teams_distribute:
   case OMPD_teams_distribute_simd:
   case OMPD_teams_distribute_parallel_for_simd:
   case OMPD_teams_distribute_parallel_for:
   case OMPD_target_teams:
   case OMPD_target_teams_distribute:
   case OMPD_target_teams_distribute_parallel_for:
   case OMPD_target_teams_distribute_parallel_for_simd:
+  case OMPD_metadirective:
   case OMPD_target_teams_distribute_simd:
     Diag(Tok, diag::err_omp_unexpected_directive)
         << 1 << getOpenMPDirectiveName(DKind);
     break;
   }
   while (Tok.isNot(tok::annot_pragma_openmp_end))
     ConsumeAnyToken();
   ConsumeAnyToken();
Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
   OpenMPDirectiveKind DKind = parseOpenMPDirectiveKind(*this);
   OpenMPDirectiveKind CancelRegion = OMPD_unknown;
   // Name of critical directive.
   DeclarationNameInfo DirName;
   StmtResult Directive = StmtError();
   bool HasAssociatedStatement = true;
 
   switch (DKind) {
+  case OMPD_metadirective: {
+    ConsumeToken();
+    ParseScope OMPDirectiveScope(this, ScopeFlags);
+    Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);
+
+    while (Tok.isNot(tok::annot_pragma_openmp_end)) {
+      OpenMPClauseKind CKind =
+          Tok.isAnnotation()
+              ? OMPC_unknown
+              : getOpenMPClauseKind(PP.getSpelling(Tok));
+      Actions.StartOpenMPClause(CKind);
+      OMPClause *Clause = ParseOpenMPMetaClause(DKind, CKind);
+      FirstClauses[CKind].setInt(true);
+      if (Clause) {
+        FirstClauses[CKind].setPointer(Clause);
+        Clauses.push_back(Clause);
+      }
+
+      // Skip ',' if any.
+      if (Tok.is(tok::comma))
+        ConsumeToken();
+      Actions.EndOpenMPClause();
+      //Consume trailing ')' if any
+      if(Tok.is(tok::r_paren))
+        ConsumeToken();
+    }
+    // End location of the directive.
+    EndLoc = Tok.getLocation();
+    // Consume final annot_pragma_openmp_end.
+    ConsumeAnnotationToken();
+
+    // The body is a block scope like in Lambdas and Blocks.
+    Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
+    StmtResult AssociatedStmt = (Sema::CompoundScopeRAII(Actions), ParseStatement());
+    AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
+    Directive = Actions.ActOnOpenMPExecutableDirective(
+        DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc,
+        EndLoc);
+
+    // Exit scope.
+    Actions.EndOpenMPDSABlock(Directive.get());
+    OMPDirectiveScope.Exit();
+    break;
+  }
   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();
bool Parser::ParseOpenMPSimpleVarList(
   }
 
   // Parse ')'.
   IsCorrect = !T.consumeClose() && IsCorrect;
 
   return !IsCorrect;
 }
 
+OMPClause *Parser::ParseOpenMPMetaClause(OpenMPDirectiveKind DKind,
+                                         OpenMPClauseKind CKind) {
+  OMPClause *Clause = nullptr;
+  bool ErrorFound = false;
+  bool WrongDirective = false;
+  SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
+                                                 FirstClauses(OMPC_unknown + 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;
+  }
+  switch (CKind) {
+  case OMPC_default:
+  case 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)))
+      return nullptr;
+
+    Expr *expr = NULL;
+    if(CKind == OMPC_when) {
+      //parse and get condition expression to pass to the When clause
+      OMPTraitInfo TI;
+      parseOMPContextSelectors(Loc, TI);
+      expr = TI.Sets.front().Selectors.front().ScoreOrCondition;
+
+      // Parse ':'
+      if (Tok.is(tok::colon))
+        ConsumeAnyToken();
+      else {
+        Diag(Tok, diag::warn_pragma_expected_colon) << "when clause";
+        return nullptr;
+      }
+    }
+    OpenMPDirectiveKind DirKind = OMPD_unknown;
+    SmallVector<OMPClause *, 5> Clauses;
+    if(!Tok.is(tok::r_paren)) {
+      DirKind = parseOpenMPDirectiveKind(*this);
+      Tok.setKind(tok::identifier);
+      ConsumeToken();
+      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));
+        Actions.StartOpenMPClause(CKind);
+        OMPClause *Clause = ParseOpenMPClause(DKind, CKind,
+                                              !FirstClauses[CKind].getInt());
+        FirstClauses[CKind].setInt(true);
+        if (Clause) {
+          FirstClauses[CKind].setPointer(Clause);
+          Clauses.push_back(Clause);
+        }
+
+        // Skip ',' if any.
+        if (Tok.is(tok::comma))
+          ConsumeToken();
+        Actions.EndOpenMPClause();
+      }
+      //Consume )
+      ConsumeToken();
+    }
+
+    if (WrongDirective)
+      return nullptr;
+
+    Clause = Actions.ActOnOpenMPWhenClause(expr, DirKind, Clauses, Loc,
+                                           DelimLoc, Tok.getLocation());
+    break;
+  }
+  case OMPC_final:
+  case OMPC_num_threads:
+  case OMPC_safelen:
+  case OMPC_simdlen:
+  case OMPC_collapse:
+  case OMPC_ordered:
+  case OMPC_device:
+  case OMPC_num_teams:
+  case OMPC_thread_limit:
+  case OMPC_priority:
+  case OMPC_grainsize:
+  case OMPC_num_tasks:
+  case OMPC_hint:
+  case OMPC_allocator:
+  case OMPC_proc_bind:
+  case OMPC_atomic_default_mem_order:
+  case OMPC_order:
+  case OMPC_schedule:
+  case OMPC_dist_schedule:
+  case OMPC_defaultmap:
+  case OMPC_if:
+  case OMPC_nowait:
+  case OMPC_untied:
+  case OMPC_mergeable:
+  case OMPC_read:
+  case OMPC_write:
+  case OMPC_update:
+  case OMPC_capture:
+  case OMPC_seq_cst:
+  case OMPC_acq_rel:
+  case OMPC_acquire:
+  case OMPC_release:
+  case OMPC_relaxed:
+  case OMPC_threads:
+  case OMPC_simd:
+  case OMPC_nogroup:
+  case OMPC_unified_address:
+  case OMPC_unified_shared_memory:
+  case OMPC_reverse_offload:
+  case OMPC_dynamic_allocators:
+  case OMPC_private:
+  case OMPC_firstprivate:
+  case OMPC_lastprivate:
+  case OMPC_shared:
+  case OMPC_reduction:
+  case OMPC_task_reduction:
+  case OMPC_in_reduction:
+  case OMPC_linear:
+  case OMPC_aligned:
+  case OMPC_copyin:
+  case OMPC_copyprivate:
+  case OMPC_flush:
+  case OMPC_depend:
+  case OMPC_map:
+  case OMPC_to:
+  case OMPC_from:
+  case OMPC_use_device_ptr:
+  case OMPC_is_device_ptr:
+  case OMPC_allocate:
+  case OMPC_nontemporal:
+  case OMPC_device_type:
+  case OMPC_unknown:
+  case OMPC_threadprivate:
+  case OMPC_uniform:
+  case OMPC_match:
+  case OMPC_depobj:
+  case OMPC_destroy:
+  case OMPC_detach:
+    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 |
 ///       lastprivate-clause | reduction-clause | proc_bind-clause |
 ///       schedule-clause | copyin-clause | copyprivate-clause | untied-clause |
OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
   case OMPC_unknown:
     Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
         << getOpenMPDirectiveName(DKind);
     SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
     break;
   case OMPC_threadprivate:
   case OMPC_uniform:
   case OMPC_match:
+  case OMPC_when:
     if (!WrongDirective)
       Diag(Tok, diag::err_omp_unexpected_clause)
           << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
     SkipUntil(tok::comma, tok::annot_pragma_openmp_end, StopBeforeMatch);
     break;
   }
   return ErrorFound ? nullptr : Clause;
 }

clang/lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Stmt *S) {
   case Stmt::OMPTargetParallelForSimdDirectiveClass:
   case Stmt::OMPTargetSimdDirectiveClass:
   case Stmt::OMPTargetTeamsDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
   case Stmt::OMPTargetUpdateDirectiveClass:
+  case Stmt::OMPMetaDirectiveClass:
   case Stmt::OMPTaskDirectiveClass:
   case Stmt::OMPTaskgroupDirectiveClass:
   case Stmt::OMPTaskLoopDirectiveClass:
   case Stmt::OMPTaskLoopSimdDirectiveClass:
   case Stmt::OMPTaskwaitDirectiveClass:
   case Stmt::OMPTaskyieldDirectiveClass:
   case Stmt::OMPTeamsDirectiveClass:
   case Stmt::OMPTeamsDistributeDirectiveClass:

clang/lib/Sema/SemaOpenMP.cpp

if (isOpenMPTargetExecutionDirective(S->getCurrentDirective())) {
         Visit(E);
     }
   }
 };
 } // namespace
 
 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_teams:
   case OMPD_teams_distribute:
   case OMPD_teams_distribute_simd: {
for (ArrayRef<Expr *> ImplicitMap : ImplicitMaps) {
       } else {
         ErrorFound = true;
       }
     }
   }
 
   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);
     if (LangOpts.OpenMP >= 50)
       AllowedNameModifiers.push_back(OMPD_simd);
     break;
for (OMPClause *C : Clauses) {
       case OMPC_unknown:
       case OMPC_unified_address:
       case OMPC_unified_shared_memory:
       case OMPC_reverse_offload:
       case OMPC_dynamic_allocators:
       case OMPC_atomic_default_mem_order:
       case OMPC_device_type:
       case OMPC_match:
+      case OMPC_when:
         llvm_unreachable("Unexpected clause");
       }
       for (Stmt *CC : C->children()) {
         if (CC)
           DSAChecker.Visit(CC);
       }
     }
     for (const auto &P : DSAChecker.getVarsWithInheritedDSA())
for (OMPDeclareVariantAttr *A :
       Expr *VariantRef = A->getVariantFuncRef();
       auto *DRE = cast<DeclRefExpr>(VariantRef->IgnoreParenImpCasts());
       auto *F = cast<FunctionDecl>(DRE->getDecl());
       if (!F->isDefined() && F->isTemplateInstantiation())
         InstantiateFunctionDefinition(Loc, F->getFirstDecl());
       MarkFunctionReferenced(Loc, F, MightBeOdrUse);
     }
   }
 }
 
+StmtResult Sema::ActOnOpenMPMetaDirective(ArrayRef<OMPClause *> Clauses,
+                                          Stmt *AStmt,
+                                          SourceLocation StartLoc,
+                                          SourceLocation EndLoc) {
+  if (!AStmt)
+    return StmtError();
+
+  StmtResult IfStmt = StmtError();
+  Stmt* ElseStmt = NULL;
+
+  for(auto i = Clauses.rbegin(); i < Clauses.rend(); i++) {
+    Expr *expr = ((OMPWhenClause*)*i)->getExpr();
+    Stmt *stmt = NULL;
+
+    OpenMPDirectiveKind DKind = ((OMPWhenClause*)*i)->getDKind();
+    DeclarationNameInfo DirName;
+    SmallVector<OMPClause *, 5> clauses = ((OMPWhenClause*)*i)->getClauses();
+
+    StartOpenMPDSABlock(DKind, DirName, getCurScope(), StartLoc);
+    if(DKind != OMPD_unknown)
+      stmt = ActOnOpenMPExecutableDirective(DKind, DirName, OMPD_unknown,
+                                            clauses, AStmt,
+                                            StartLoc, EndLoc).get();
+    EndOpenMPDSABlock(stmt);
+
+    if(expr == NULL) {
+      if(ElseStmt != NULL) {
+        llvm::errs() << "Misplaced default clause! Only one default clause is";
+        llvm::errs() << " allowed in metadirective in the end\n";
+        return StmtError();
+      }
+      if(DKind == OMPD_unknown)
+        ElseStmt = AStmt;
+      else
+        ElseStmt = stmt;
+      continue;
+    }
+
+    if(stmt == NULL)
+      stmt = AStmt;
+
+    IfStmt = ActOnIfStmt(SourceLocation(), false, NULL,
+                         ActOnCondition(getCurScope(), SourceLocation(), expr,
+                                        Sema::ConditionKind::Boolean),
+                         stmt, SourceLocation(), ElseStmt);
+  }
+
+  return OMPMetaDirective::Create(Context, StartLoc, EndLoc, Clauses,
+                                  AStmt, IfStmt.get());
+}
+
 StmtResult Sema::ActOnOpenMPParallelDirective(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();
 
   setFunctionHasBranchProtectedScope();
 
   return OMPParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
                                       DSAStack->isCancelRegion());
OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
   case OMPC_reverse_offload:
   case OMPC_dynamic_allocators:
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_order:
   case OMPC_destroy:
+  case OMPC_when:
     llvm_unreachable("Clause is not allowed.");
   }
   return Res;
 }
 
 // An OpenMP directive such as 'target parallel' has two captured regions:
 // for the 'target' and 'parallel' respectively.  This function returns
 // the region in which to capture expressions associated with a clause.
case OMPC_if:
     case OMPD_master:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_teams_distribute:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with if-clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_num_threads:
     switch (DKind) {
     case OMPD_target_parallel:
case OMPC_num_threads:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_teams_distribute:
     case OMPD_teams_distribute_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with num_threads-clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_num_teams:
     switch (DKind) {
     case OMPD_target_teams:
case OMPC_num_teams:
     case OMPD_master:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with num_teams-clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_thread_limit:
     switch (DKind) {
     case OMPD_target_teams:
case OMPC_thread_limit:
     case OMPD_master:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with thread_limit-clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_schedule:
     switch (DKind) {
     case OMPD_parallel_for:
case OMPC_schedule:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_target_teams:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with schedule clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_dist_schedule:
     switch (DKind) {
     case OMPD_teams_distribute_parallel_for:
case OMPC_dist_schedule:
     case OMPD_single:
     case OMPD_master:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_target_teams:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with schedule clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_device:
     switch (DKind) {
     case OMPD_target_update:
case OMPC_device:
     case OMPD_master:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with num_teams-clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_grainsize:
   case OMPC_num_tasks:
   case OMPC_final:
case OMPC_priority:
     case OMPD_master:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
+    case OMPD_metadirective:
       llvm_unreachable("Unexpected OpenMP directive with grainsize-clause");
     case OMPD_unknown:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_firstprivate:
   case OMPC_lastprivate:
   case OMPC_reduction:
static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_order:
   case OMPC_destroy:
   case OMPC_detach:
     llvm_unreachable("Unexpected OpenMP clause.");
+  case OMPC_when:
+    switch (DKind) {
+    case OMPD_metadirective:
+      CaptureRegion = OMPD_metadirective;
+      break;
+    case OMPD_parallel_master:
+    case OMPD_declare_mapper:
+    case OMPD_allocate:
+    case OMPD_declare_variant:
+    case OMPD_master_taskloop:
+    case OMPD_parallel_master_taskloop:
+    case OMPD_master_taskloop_simd:
+    case OMPD_parallel_master_taskloop_simd:
+    case OMPD_target_parallel:
+    case OMPD_target_parallel_for:
+    case OMPD_target_parallel_for_simd:
+    case OMPD_target_teams_distribute_parallel_for:
+    case OMPD_target_teams_distribute_parallel_for_simd:
+    case OMPD_teams_distribute_parallel_for:
+    case OMPD_teams_distribute_parallel_for_simd:
+    case OMPD_target_update:
+    case OMPD_target_enter_data:
+    case OMPD_target_exit_data:
+    case OMPD_cancel:
+    case OMPD_parallel:
+    case OMPD_parallel_sections:
+    case OMPD_parallel_for:
+    case OMPD_parallel_for_simd:
+    case OMPD_target:
+    case OMPD_target_simd:
+    case OMPD_target_teams:
+    case OMPD_target_teams_distribute:
+    case OMPD_target_teams_distribute_simd:
+    case OMPD_distribute_parallel_for:
+    case OMPD_distribute_parallel_for_simd:
+    case OMPD_task:
+    case OMPD_taskloop:
+    case OMPD_taskloop_simd:
+    case OMPD_target_data:
+    case OMPD_threadprivate:
+    case OMPD_taskyield:
+    case OMPD_barrier:
+    case OMPD_taskwait:
+    case OMPD_cancellation_point:
+    case OMPD_flush:
+    case OMPD_declare_reduction:
+    case OMPD_declare_simd:
+    case OMPD_declare_target:
+    case OMPD_end_declare_target:
+    case OMPD_teams:
+    case OMPD_simd:
+    case OMPD_for:
+    case OMPD_for_simd:
+    case OMPD_sections:
+    case OMPD_section:
+    case OMPD_single:
+    case OMPD_master:
+    case OMPD_critical:
+    case OMPD_taskgroup:
+    case OMPD_distribute:
+    case OMPD_ordered:
+    case OMPD_atomic:
+    case OMPD_distribute_simd:
+    case OMPD_teams_distribute:
+    case OMPD_teams_distribute_simd:
+    case OMPD_requires:
+    case OMPD_depobj:
+      llvm_unreachable("Unexpected OpenMP directive with when clause");
+    case OMPD_unknown:
+      llvm_unreachable("Unknown OpenMP directive");
+    }
+    break;
   }
   return CaptureRegion;
 }
 
 OMPClause *Sema::ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
                                      Expr *Condition, SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation NameModifierLoc,
OMPClause *Sema::ActOnOpenMPSimpleClause(
   case OMPC_unified_shared_memory:
   case OMPC_reverse_offload:
   case OMPC_dynamic_allocators:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     llvm_unreachable("Clause is not allowed.");
   }
   return Res;
 }
 
 static std::string
 getListOfPossibleValues(OpenMPClauseKind K, unsigned First, unsigned Last,
                         ArrayRef<unsigned> Exclude = llvm::None) {
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(Expr *Expr,
+                                       OpenMPDirectiveKind DKind,
+                                       SmallVector<OMPClause *, 5> Clauses,
+                                       SourceLocation StartLoc,
+                                       SourceLocation LParenLoc,
+                                       SourceLocation EndLoc) {
+  return new (Context) OMPWhenClause(Expr, DKind, Clauses, 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,
                                    /*Last=*/unsigned(OMP_DEFAULT_unknown))
         << getOpenMPClauseName(OMPC_default);
OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
   case OMPC_dynamic_allocators:
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_order:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     llvm_unreachable("Clause is not allowed.");
   }
   return Res;
 }
 
 static bool checkScheduleModifiers(Sema &S, OpenMPScheduleClauseModifier M1,
                                    OpenMPScheduleClauseModifier M2,
                                    SourceLocation M1Loc, SourceLocation M2Loc) {
OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind,
   case OMPC_use_device_ptr:
   case OMPC_is_device_ptr:
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_nontemporal:
   case OMPC_order:
   case OMPC_detach:
+  case OMPC_when:
     llvm_unreachable("Clause is not allowed.");
   }
   return Res;
 }
 
 OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc,
                                          SourceLocation EndLoc) {
   DSAStack->setNowaitRegion();
OMPClause *Sema::ActOnOpenMPVarListClause(
   case OMPC_reverse_offload:
   case OMPC_dynamic_allocators:
   case OMPC_atomic_default_mem_order:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_order:
   case OMPC_destroy:
   case OMPC_detach:
+  case OMPC_when:
     llvm_unreachable("Clause is not allowed.");
   }
   return Res;
 }
 
 ExprResult Sema::getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
                                        ExprObjectKind OK, SourceLocation Loc) {
   ExprResult Res = BuildDeclRefExpr(

clang/lib/Sema/TreeTransform.h

#include "clang/Basic/OpenMPKinds.def"
   /// Subclasses may override this routine to provide different behavior.
   OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
     return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
                                                EndLoc);
   }
 
+  /// Build a new OpenMP 'when' clause.
+  ///
+  /// By default, performs semantic analysis to build the new OpenMP clause.
+  /// Subclasses may override this routine to provide different behavior.
+  OMPClause *RebuildOMPWhenClause(Expr* expr,
+                                  OpenMPDirectiveKind DKind,
+                                  SmallVector<OMPClause *, 5> Clauses,
+                                  SourceLocation StartLoc,
+                                  SourceLocation LParenLoc,
+                                  SourceLocation EndLoc) {
+    return getSema().ActOnOpenMPWhenClause(expr, DKind, Clauses, StartLoc,
+                                           LParenLoc, EndLoc);
+  }
+
   /// Build a new OpenMP 'default' clause.
   ///
   /// By default, performs semantic analysis to build the new OpenMP clause.
   /// Subclasses may override this routine to provide different behavior.
   OMPClause *RebuildOMPDefaultClause(DefaultKind Kind, SourceLocation KindKwLoc,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc) {
StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
 
   return getDerived().RebuildOMPExecutableDirective(
       D->getDirectiveKind(), DirName, CancelRegion, TClauses,
       AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc());
 }
 
 template <typename Derived>
 StmtResult
+TreeTransform<Derived>::TransformOMPMetaDirective(OMPMetaDirective *D) {
+  DeclarationNameInfo DirName;
+  getDerived().getSema().StartOpenMPDSABlock(OMPD_metadirective, DirName,
+                                             nullptr, D->getBeginLoc());
+  StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
+  getDerived().getSema().EndOpenMPDSABlock(Res.get());
+  return Res;
+}
+
+template <typename Derived>
+StmtResult
 TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
   DeclarationNameInfo DirName;
   getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr,
                                              D->getBeginLoc());
   StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
   getDerived().getSema().EndOpenMPDSABlock(Res.get());
   return Res;
 }
TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
   ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
   if (E.isInvalid())
     return nullptr;
   return getDerived().RebuildOMPCollapseClause(
       E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
 }
 
 template <typename Derived>
 OMPClause *
+TreeTransform<Derived>::TransformOMPWhenClause(OMPWhenClause *C) {
+  ExprResult E = getDerived().TransformExpr(C->getExpr());
+  if (E.isInvalid())
+    return nullptr;
+  return getDerived().RebuildOMPWhenClause(C->getExpr(), C->getDKind(),
+                                           C->getClauses(), C->getBeginLoc(),
+                                           C->getLParenLoc(), C->getEndLoc());
+}
+
+template <typename Derived>
+OMPClause *
 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
   return getDerived().RebuildOMPDefaultClause(
       C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getBeginLoc(),
       C->getLParenLoc(), C->getEndLoc());
 }
 
 template <typename Derived>
 OMPClause *

clang/lib/Serialization/ASTReader.cpp

 
 OMPClause *ASTRecordReader::readOMPClause() {
   return OMPClauseReader(*this).readClause();
 }
 
 OMPClause *OMPClauseReader::readClause() {
   OMPClause *C = nullptr;
   switch (Record.readInt()) {
+  case OMPC_when:
+    C = new (Context) OMPWhenClause();
+    break;
   case OMPC_if:
     C = new (Context) OMPIfClause();
     break;
   case OMPC_final:
     C = new (Context) OMPFinalClause();
     break;
   case OMPC_num_threads:
     C = new (Context) OMPNumThreadsClause();
void OMPClauseReader::VisitOMPAllocatorClause(OMPAllocatorClause *C) {
   C->setLParenLoc(Record.readSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
   C->setNumForLoops(Record.readSubExpr());
   C->setLParenLoc(Record.readSourceLocation());
 }
 
+void OMPClauseReader::VisitOMPWhenClause(OMPWhenClause *C) {
+  C->setExpr(Record.readSubExpr());
+  C->setLParenLoc(Record.readSourceLocation());
+}
+
 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
   C->setDefaultKind(static_cast<llvm::omp::DefaultKind>(Record.readInt()));
   C->setLParenLoc(Record.readSourceLocation());
   C->setDefaultKindKwLoc(Record.readSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
   C->setProcBindKind(static_cast<llvm::omp::ProcBindKind>(Record.readInt()));

clang/lib/Serialization/ASTReaderStmt.cpp

for (unsigned i = 0; i < CollapsedNum; ++i)
     Sub.push_back(Record.readSubExpr());
   D->setDependentInits(Sub);
   Sub.clear();
   for (unsigned i = 0; i < CollapsedNum; ++i)
     Sub.push_back(Record.readSubExpr());
   D->setFinalsConditions(Sub);
 }
 
+void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) {
+  VisitStmt(D);
+  // The NumClauses field was read in ReadStmtFromStream.
+  Record.skipInts(1);
+  VisitOMPExecutableDirective(D);
+}
+
 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
   Record.skipInts(1);
   VisitOMPExecutableDirective(D);
   D->setHasCancel(Record.readInt());
 }
 
while (true) {
 
     case STMT_MS_DEPENDENT_EXISTS:
       S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
                                               NestedNameSpecifierLoc(),
                                               DeclarationNameInfo(),
                                               nullptr);
       break;
 
+    case STMT_OMP_META_DIRECTIVE:
+      S =
+        OMPMetaDirective::CreateEmpty(Context,
+                                      Record[ASTStmtReader::NumStmtFields],
+                                      Empty);
+      break;
+
     case STMT_OMP_PARALLEL_DIRECTIVE:
       S =
         OMPParallelDirective::CreateEmpty(Context,
                                           Record[ASTStmtReader::NumStmtFields],
                                           Empty);
       break;
 
     case STMT_OMP_SIMD_DIRECTIVE: {

clang/lib/Serialization/ASTWriter.cpp

void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) {
   Record.AddSourceLocation(C->getLParenLoc());
 }
 
 void OMPClauseWriter::VisitOMPDetachClause(OMPDetachClause *C) {
   Record.AddStmt(C->getEventHandler());
   Record.AddSourceLocation(C->getLParenLoc());
 }
 
+void OMPClauseWriter::VisitOMPWhenClause(OMPWhenClause *C) {
+  Record.AddStmt(C->getExpr());
+  Record.AddSourceLocation(C->getLParenLoc());
+}
+
 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) {
   Record.push_back(unsigned(C->getDefaultKind()));
   Record.AddSourceLocation(C->getLParenLoc());
   Record.AddSourceLocation(C->getDefaultKindKwLoc());
 }
 
 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) {
   Record.push_back(unsigned(C->getProcBindKind()));

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
   for (Stmt *S : D->dependent_counters())
     Record.AddStmt(S);
   for (Stmt *S : D->dependent_inits())
     Record.AddStmt(S);
   for (Stmt *S : D->finals_conditions())
     Record.AddStmt(S);
 }
 
+void ASTStmtWriter::VisitOMPMetaDirective(OMPMetaDirective *D) {
+  VisitStmt(D);
+  Record.push_back(D->getNumClauses());
+  VisitOMPExecutableDirective(D);
+  Code = serialization::STMT_OMP_META_DIRECTIVE;
+}
+
 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
   VisitStmt(D);
   Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Record.push_back(D->hasCancel() ? 1 : 0);
   Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
 }
 

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::OMPTeamsDistributeSimdDirectiveClass:
     case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
     case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
     case Stmt::OMPTargetTeamsDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
+    case Stmt::OMPMetaDirectiveClass:
     case Stmt::CapturedStmtClass: {
       const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
       Engine.addAbortedBlock(node, currBldrCtx->getBlock());
       break;
     }
 
     case Stmt::ParenExprClass:
       llvm_unreachable("ParenExprs already handled.");

clang/test/OpenMP/metadirective_default.c

+#include <stdio.h>
+#include <omp.h>
+
+int main()
+{
+  int N = 5;
+#pragma omp metadirective when(user={condition(N>10)}: parallel) \
+                          default(parallel for)
+  for(int i=0; i<N; i++)
+    printf("Printig from thread = %d\n", omp_get_thread_num());
+
+  return 0;
+}

clang/test/OpenMP/metadirective_when.c

+#include <stdio.h>
+#include <omp.h>
+
+int main()
+{
+  int N = 15;
+#pragma omp metadirective when(user={condition(N>10)}: parallel for)
+  for(int i=0; i<N; i++)
+    printf("Printig from thread = %d\n", omp_get_thread_num());
+
+  return 0;
+}

clang/tools/libclang/CIndex.cpp

 void OMPClauseEnqueue::VisitOMPAllocatorClause(const OMPAllocatorClause *C) {
   Visitor->AddStmt(C->getAllocator());
 }
 
 void OMPClauseEnqueue::VisitOMPCollapseClause(const OMPCollapseClause *C) {
   Visitor->AddStmt(C->getNumForLoops());
 }
 
+void OMPClauseEnqueue::VisitOMPWhenClause(const OMPWhenClause *C) {
+  Visitor->AddStmt(C->getExpr());
+}
+
 void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
 
 void OMPClauseEnqueue::VisitOMPProcBindClause(const OMPProcBindClause *C) { }
 
 void OMPClauseEnqueue::VisitOMPScheduleClause(const OMPScheduleClause *C) {
   VisitOMPClauseWithPreInit(C);
   Visitor->AddStmt(C->getChunkSize());
 }
CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_ObjCSynthesizeDecl:
     return cxstring::createRef("ObjCSynthesizeDecl");
   case CXCursor_ObjCDynamicDecl:
     return cxstring::createRef("ObjCDynamicDecl");
   case CXCursor_CXXAccessSpecifier:
     return cxstring::createRef("CXXAccessSpecifier");
   case CXCursor_ModuleImportDecl:
     return cxstring::createRef("ModuleImport");
+  case CXCursor_OMPMetaDirective:
+    return cxstring::createRef("OMPMetaDirective");
   case CXCursor_OMPParallelDirective:
     return cxstring::createRef("OMPParallelDirective");
   case CXCursor_OMPSimdDirective:
     return cxstring::createRef("OMPSimdDirective");
   case CXCursor_OMPForDirective:
     return cxstring::createRef("OMPForDirective");
   case CXCursor_OMPForSimdDirective:
     return cxstring::createRef("OMPForSimdDirective");

clang/tools/libclang/CXCursor.cpp

case Stmt::ObjCMessageExprClass: {
     }
     CXCursor C = { K, 0, { Parent, S, TU } };
     return getSelectorIdentifierCursor(SelectorIdIndex, C);
   }
       
   case Stmt::MSDependentExistsStmtClass:
     K = CXCursor_UnexposedStmt;
     break;
+  case Stmt::OMPMetaDirectiveClass:
+    K = CXCursor_OMPMetaDirective;
+    break;
   case Stmt::OMPParallelDirectiveClass:
     K = CXCursor_OMPParallelDirective;
     break;
   case Stmt::OMPSimdDirectiveClass:
     K = CXCursor_OMPSimdDirective;
     break;
   case Stmt::OMPForDirectiveClass:
     K = CXCursor_OMPForDirective;

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

 __OMP_DIRECTIVE(allocate)
 __OMP_DIRECTIVE_EXT(declare_variant, "declare variant")
 __OMP_DIRECTIVE_EXT(master_taskloop, "master taskloop")
 __OMP_DIRECTIVE_EXT(parallel_master_taskloop, "parallel master taskloop")
 __OMP_DIRECTIVE_EXT(master_taskloop_simd, "master taskloop simd")
 __OMP_DIRECTIVE_EXT(parallel_master_taskloop_simd,
                     "parallel master taskloop simd")
 __OMP_DIRECTIVE(depobj)
+__OMP_DIRECTIVE(metadirective)
 
 // Has to be the last because Clang implicitly expects it to be.
 __OMP_DIRECTIVE(unknown)
 
 #undef __OMP_DIRECTIVE_EXT
 #undef __OMP_DIRECTIVE
 #undef OMP_DIRECTIVE