[OPENMP]Redesign of OMPExecutableDirective representation.

[ABataev]

Summary

Introduced OMPChildren class to handle all associated clauses, statement
and child expressions/statements. It allows to represent some directives
more correctly (like flush, depobj etc. with pseudo clauses, ordered
depend directives, which are standalone, and target data directives).
ALso, it will make easier to avoid using of CapturedStmt in directives,
if required (atomic, tile etc. directives).
Also, it simplifies serialization/deserialization of the executable
directives.

[ABataev]

Rebase

[Meinersbur]

AFAICS this extract out the handling of subnodes of OMPExecutableDirectives into the OMPChildren class which is made optional since OMPChildren *OMPExecutableDirectives::Data can be nullptr. However, since it also stores clauses, it seems that about every executable directive will need to have one anyway. Hence I don't see how it makes the representation of some executable directives more correct.

OMPChildren also handles clauses for OMPExecutableDirectives but not for declarative directives. Should handling of of clauses also be extracted into into its own class? That would make (de-)serialization easier for those as well.

There is no effect on D76342 (except a requiring a rebase), since the OMPTileDirective has children and thus does not profit from the functionality of OMPChildren becoming optional. Since I don't see a relation to D76342, more , I am indifferent to whether this should be merged.

Trailing objects is a technique to ensure that all substmts are consecutive in memory (so StmtIterator can iterator over them). For OMPExeuctableDirectives, only the associated statement is returned by the StmtIterator, i.e. all the children could be made regular class members without the complication of computing the offset. I'd prefer that change over OMPChildren.

clang/include/clang/AST/StmtOpenMP.h

145

This looks like the equivalent to ignoreCaptures from D76342. Could you document it what it does differently from IgnoreContainers/getCapturedStmt/getInnermostCapturedStmt/getBody/getStructuredBlock?

[ABataev]

In D83261#2161217, @Meinersbur wrote:

AFAICS this extract out the handling of subnodes of OMPExecutableDirectives into the OMPChildren class which is made optional since OMPChildren *OMPExecutableDirectives::Data can be nullptr. However, since it also stores clauses, it seems that about every executable directive will need to have one anyway. Hence I don't see how it makes the representation of some executable directives more correct.

1. OMPChildren class uses standard TrailingObjects harness instead of manual calculation.
2. Child Stmt* based nodes are not related to the AsssociatedStmt* anymore and can exist independently.

OMPChildren also handles clauses for OMPExecutableDirectives but not for declarative directives. Should handling of of clauses also be extracted into into its own class? That would make (de-)serialization easier for those as well.

This class is only for executable directives.

There is no effect on D76342 (except a requiring a rebase), since the OMPTileDirective has children and thus does not profit from the functionality of OMPChildren becoming optional. Since I don't see a relation to D76342, more , I am indifferent to whether this should be merged.

There should be an additional patch, which, I hope, should simplify things for loop-based directives.

Trailing objects is a technique to ensure that all substmts are consecutive in memory (so StmtIterator can iterator over them). For OMPExeuctableDirectives, only the associated statement is returned by the StmtIterator, i.e. all the children could be made regular class members without the complication of computing the offset. I'd prefer that change over OMPChildren.

There are also used_children, which are used by the clang analyzer for, at least, use of uninitialized variables diagnostics.

[Meinersbur]

In D83261#2162561, @ABataev wrote:

1. OMPChildren class uses standard TrailingObjects harness instead of manual calculation.

I was going to argue that OMPExecutableDirective could derive from TrailingObjects as well, but it requires a template parameter for its final subclass. Good point!

2. Child Stmt* based nodes are not related to the AsssociatedStmt* anymore and can exist independently.

It moved into the OMPChildren class. Not sure whether it is better.

OMPChildren also handles clauses for OMPExecutableDirectives but not for declarative directives. Should handling of of clauses also be extracted into into its own class? That would make (de-)serialization easier for those as well.

This class is only for executable directives.

Nearly all directives have clauses. At the moment they all implement their own clause list. I don't see why clause management should be centralized for executable statements only.

There is no effect on D76342 (except a requiring a rebase), since the OMPTileDirective has children and thus does not profit from the functionality of OMPChildren becoming optional. Since I don't see a relation to D76342, more , I am indifferent to whether this should be merged.

There should be an additional patch, which, I hope, should simplify things for loop-based directives.

OK. What does this patch do? Are you going to upload it as well?

Trailing objects is a technique to ensure that all substmts are consecutive in memory (so StmtIterator can iterator over them). For OMPExeuctableDirectives, only the associated statement is returned by the StmtIterator, i.e. all the children could be made regular class members without the complication of computing the offset. I'd prefer that change over OMPChildren.

There are also used_children, which are used by the clang analyzer for, at least, use of uninitialized variables diagnostics.

OK, I see.

[ABataev]

In D83261#2162904, @Meinersbur wrote:

In D83261#2162561, @ABataev wrote:

1. OMPChildren class uses standard TrailingObjects harness instead of manual calculation.

I was going to argue that OMPExecutableDirective could derive from TrailingObjects as well, but it requires a template parameter for its final subclass. Good point!

2. Child Stmt* based nodes are not related to the AsssociatedStmt* anymore and can exist independently.

It moved into the OMPChildren class. Not sure whether it is better.

What I mean, that previously child nodes could not exist without AssociatedStmt, i.e. you have to have AssociatedStmt to have other children. It is solved (though, of course, can be implemented in a different way with the current design).

OMPChildren also handles clauses for OMPExecutableDirectives but not for declarative directives. Should handling of of clauses also be extracted into into its own class? That would make (de-)serialization easier for those as well.

This class is only for executable directives.

Nearly all directives have clauses. At the moment they all implement their own clause list. I don't see why clause management should be centralized for executable statements only.

Sure, we can make OMPChildren common for declarative and executable directives. Do you want me to do it?

There is no effect on D76342 (except a requiring a rebase), since the OMPTileDirective has children and thus does not profit from the functionality of OMPChildren becoming optional. Since I don't see a relation to D76342, more , I am indifferent to whether this should be merged.

There should be an additional patch, which, I hope, should simplify things for loop-based directives.

OK. What does this patch do? Are you going to upload it as well?

At first, need to deal with this one, at least come to an agreement with the design.

Trailing objects is a technique to ensure that all substmts are consecutive in memory (so StmtIterator can iterator over them). For OMPExeuctableDirectives, only the associated statement is returned by the StmtIterator, i.e. all the children could be made regular class members without the complication of computing the offset. I'd prefer that change over OMPChildren.

There are also used_children, which are used by the clang analyzer for, at least, use of uninitialized variables diagnostics.

OK, I see.

[Meinersbur]

In D83261#2162561, @ABataev wrote:

1. OMPChildren class uses standard TrailingObjects harness instead of manual calculation.

Note that that having a separate object defeats the purpose of TrailingObjects of having just a single allocation per AST node. If we do separate objects, we could also have member pointers to arrays.

In D83261#2164929, @ABataev wrote:

Sure, we can make OMPChildren common for declarative and executable directives. Do you want me to do it?

Yes, I think it would increase its usefulness and remove code duplication of handling clauses.

There should be an additional patch, which, I hope, should simplify things for loop-based directives.

OK. What does this patch do? Are you going to upload it as well?

At first, need to deal with this one, at least come to an agreement with the design.

The reviewer list is surprisingly small. Aren't there any others with stakes in the class hierarchy?

[ABataev]

In D83261#2166766, @Meinersbur wrote:

In D83261#2162561, @ABataev wrote:

1. OMPChildren class uses standard TrailingObjects harness instead of manual calculation.

Note that that having a separate object defeats the purpose of TrailingObjects of having just a single allocation per AST node. If we do separate objects, we could also have member pointers to arrays.

I know. Will check what I can do about it.

In D83261#2164929, @ABataev wrote:

Sure, we can make OMPChildren common for declarative and executable directives. Do you want me to do it?

Yes, I think it would increase its usefulness and remove code duplication of handling clauses.

There should be an additional patch, which, I hope, should simplify things for loop-based directives.

OK. What does this patch do? Are you going to upload it as well?

At first, need to deal with this one, at least come to an agreement with the design.

The reviewer list is surprisingly small. Aren't there any others with stakes in the class hierarchy?

[ABataev]

1. Added OMPChildren to the declartive directive to simplify their representation.
2. Reduce memory fragmentation for declare mapper.
3. Removed previously introduced memory fragmentation.

[riccibruno]

clang/lib/Sema/SemaExpr.cpp

345

I'd like to point out that in general there is no need to pass a string to a diagnostic instead of a NamedDecl *. Doing so will bypass the customisation points NamedDecl::getNameForDiagnostic and NamedDecl::printName.

[ABataev]

Fixed diagnostic emission for declare mapper

[Meinersbur]

I think the ActOnOpenMPDeclareMapperDirective changes should be separated into its own patch. Otherwise, LGTM.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

3329

The refactoring of ActOnOpenMPDeclareMapperDirective seems unrelated.

[ABataev]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

3329

These changes are required by the redesign of the declare mapper representation.

[cchen]

In PR45212 comment 5 (https://bugs.llvm.org/show_bug.cgi?id=45212#c5), there is a reduced test case that failed after adding this patch. The assertion is from OMPChildren::getInnermostCapturedStmt.

Test case:

#include <cmath>
#include <omp.h>
#include <iostream>

class Myclass
{
  public:
	  double A[10];
	  double B[10];

          void add(int i)
          {
            for (int k = 0; k < 10; k++) {
#pragma omp atomic
              B[k] += A[i];
            }
          }
};

int main(int argc, char* argv[]){
  Myclass foo;
 
  for (int i = 0; i < 10; i++) {
      foo.A[i] = i;
      foo.B[i] = 0;
  }

#pragma omp target teams distribute parallel for
  for (int i = 0; i < 10; i++) {
      foo.add(i);
  }

  printf("Correctness check: B[2]= %f \n",foo.B[2]);
  return 0;
}

Backtrace:

Assertion failed: (isa<X>(Val) && "cast<Ty>() argument of incompatible type!"), function cast, file /Users/cchen/workspace/llvm-project/llvm/include/llvm/Support/Casting.h, line 269.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /Users/cchen/llvm/bin/clang-10 -cc1 -triple nvptx64 -aux-triple x86_64-apple-darwin18.7.0 -Wundef-prefix=TARGET_OS_ -Werror=undef-prefix -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -emit-llvm -disable-free -main-file-name test.cpp -mrelocation-model static -mframe-pointer=all -fno-rounding-math -fno-verbose-asm -no-integrated-as -fcompatibility-qualified-id-block-type-checking -target-cpu sm_35 -fno-split-dwarf-inlining -debugger-tuning=gdb -target-linker-version 512.4 -resource-dir /Users/cchen/llvm/lib/clang/12.0.0 -internal-isystem /Users/cchen/llvm/lib/clang/12.0.0/include/openmp_wrappers -include __clang_openmp_device_functions.h -internal-isystem /Users/cchen/llvm/bin/../include/c++/v1 -internal-isystem /usr/include/c++/v1 -internal-isystem /Users/cchen/llvm/bin/../include/c++/v1 -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/include -internal-isystem /Users/cchen/llvm/lib/clang/12.0.0/include -internal-externc-isystem /usr/include -internal-isystem /usr/local/include -internal-isystem /Users/cchen/llvm/lib/clang/12.0.0/include -internal-externc-isystem /usr/include -fdeprecated-macro -fno-dwarf-directory-asm -fdebug-compilation-dir /Users/cchen/workspace/llvm-project/bugfix/45212 -ferror-limit 19 -fopenmp -fopenmp-version=50 -fopenmp-cuda-parallel-target-regions -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -fcolor-diagnostics -fopenmp-is-device -fopenmp-host-ir-file-path /var/folders/rx/8phxx7k53pqghv8kjxkbv2ch006fcl/T/test-c282ef.bc -o /var/folders/rx/8phxx7k53pqghv8kjxkbv2ch006fcl/T/test-f0824e.ll -x c++ test.cpp
1.	test.cpp:20:1: current parser token 'int'
2.	test.cpp:5:7: LLVM IR generation of declaration 'Myclass'
0  clang-10                 0x0000000108bead4c llvm::sys::PrintStackTrace(llvm::raw_ostream&) + 60
1  clang-10                 0x0000000108beb309 PrintStackTraceSignalHandler(void*) + 25
2  clang-10                 0x0000000108be8c46 llvm::sys::RunSignalHandlers() + 118
3  clang-10                 0x0000000108bed070 SignalHandler(int) + 208
4  libsystem_platform.dylib 0x00007fff7bd98b5d _sigtramp + 29
5  clang-10                 0x000000010fdc6ae2 llvm::DenseMapInfo<llvm::codeview::GloballyHashedType>::Tombstone + 2998754
6  libsystem_c.dylib        0x00007fff7bc526a6 abort + 127
7  libsystem_c.dylib        0x00007fff7bc1b20d basename_r + 0
8  clang-10                 0x000000010e908344 llvm::cast_retty<clang::CapturedStmt, clang::Stmt*>::ret_type llvm::cast<clang::CapturedStmt, clang::Stmt>(clang::Stmt*) + 100
9  clang-10                 0x000000010d4097b3 clang::OMPChildren::getInnermostCapturedStmt(llvm::ArrayRef<llvm::omp::Directive>) + 227
10 clang-10                 0x000000010d3f67d5 clang::OMPExecutableDirective::getInnermostCapturedStmt() + 197
11 clang-10                 0x000000010959a555 clang::OMPExecutableDirective::getInnermostCapturedStmt() const + 21
12 clang-10                 0x0000000109599d89 clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1305
13 clang-10                 0x0000000109599eab clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1595
14 clang-10                 0x0000000109599eab clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1595
15 clang-10                 0x0000000109599eab clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1595
16 clang-10                 0x000000010959a6f0 clang::CodeGen::CGOpenMPRuntime::emitTargetFunctions(clang::GlobalDecl) + 320
17 clang-10                 0x000000010959b97e clang::CodeGen::CGOpenMPRuntime::emitTargetGlobal(clang::GlobalDecl) + 142
18 clang-10                 0x000000010973c53e clang::CodeGen::CodeGenModule::EmitGlobal(clang::GlobalDecl) + 926
19 clang-10                 0x0000000109746a8a clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl*) + 266
20 clang-10                 0x0000000109937553 (anonymous namespace)::CodeGeneratorImpl::EmitDeferredDecls() + 179
21 clang-10                 0x000000010993748d (anonymous namespace)::CodeGeneratorImpl::HandlingTopLevelDeclRAII::~HandlingTopLevelDeclRAII() + 77
22 clang-10                 0x00000001099373f5 (anonymous namespace)::CodeGeneratorImpl::HandlingTopLevelDeclRAII::~HandlingTopLevelDeclRAII() + 21
23 clang-10                 0x0000000109932410 (anonymous namespace)::CodeGeneratorImpl::HandleTopLevelDecl(clang::DeclGroupRef) + 176
24 clang-10                 0x00000001096f5d6e clang::BackendConsumer::HandleTopLevelDecl(clang::DeclGroupRef) + 222
25 clang-10                 0x000000010ca8cd14 clang::ParseAST(clang::Sema&, bool, bool) + 548
26 clang-10                 0x0000000109e76e82 clang::ASTFrontendAction::ExecuteAction() + 322
27 clang-10                 0x00000001096f4f17 clang::CodeGenAction::ExecuteAction() + 2391
28 clang-10                 0x0000000109e76411 clang::FrontendAction::Execute() + 129
29 clang-10                 0x0000000109dbd367 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) + 2087
30 clang-10                 0x0000000109fce131 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) + 1761
31 clang-10                 0x00000001063404ec cc1_main(llvm::ArrayRef<char const*>, char const*, void*) + 1388
32 clang-10                 0x0000000106333a02 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) + 434
33 clang-10                 0x00000001063326d5 main + 1509
34 libdyld.dylib            0x00007fff7bbad3d5 start + 1

Edit: Removing "#pragma omp atomic" in line 14 can avoid the asserts.

[ABataev]

In D83261#2224619, @cchen wrote:

In PR45212 comment 5 (https://bugs.llvm.org/show_bug.cgi?id=45212#c5), there is a reduced test case that failed after adding this patch. The assertion is from OMPChildren::getInnermostCapturedStmt.

Test case:

#include <cmath>
#include <omp.h>
#include <iostream>

class Myclass
{
  public:
	  double A[10];
	  double B[10];

          void add(int i)
          {
            for (int k = 0; k < 10; k++) {
#pragma omp atomic
              B[k] += A[i];
            }
          }
};

int main(int argc, char* argv[]){
  Myclass foo;
 
  for (int i = 0; i < 10; i++) {
      foo.A[i] = i;
      foo.B[i] = 0;
  }

#pragma omp target teams distribute parallel for
  for (int i = 0; i < 10; i++) {
      foo.add(i);
  }

  printf("Correctness check: B[2]= %f \n",foo.B[2]);
  return 0;
}

Backtrace:

Assertion failed: (isa<X>(Val) && "cast<Ty>() argument of incompatible type!"), function cast, file /Users/cchen/workspace/llvm-project/llvm/include/llvm/Support/Casting.h, line 269.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /Users/cchen/llvm/bin/clang-10 -cc1 -triple nvptx64 -aux-triple x86_64-apple-darwin18.7.0 -Wundef-prefix=TARGET_OS_ -Werror=undef-prefix -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -emit-llvm -disable-free -main-file-name test.cpp -mrelocation-model static -mframe-pointer=all -fno-rounding-math -fno-verbose-asm -no-integrated-as -fcompatibility-qualified-id-block-type-checking -target-cpu sm_35 -fno-split-dwarf-inlining -debugger-tuning=gdb -target-linker-version 512.4 -resource-dir /Users/cchen/llvm/lib/clang/12.0.0 -internal-isystem /Users/cchen/llvm/lib/clang/12.0.0/include/openmp_wrappers -include __clang_openmp_device_functions.h -internal-isystem /Users/cchen/llvm/bin/../include/c++/v1 -internal-isystem /usr/include/c++/v1 -internal-isystem /Users/cchen/llvm/bin/../include/c++/v1 -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/include -internal-isystem /Users/cchen/llvm/lib/clang/12.0.0/include -internal-externc-isystem /usr/include -internal-isystem /usr/local/include -internal-isystem /Users/cchen/llvm/lib/clang/12.0.0/include -internal-externc-isystem /usr/include -fdeprecated-macro -fno-dwarf-directory-asm -fdebug-compilation-dir /Users/cchen/workspace/llvm-project/bugfix/45212 -ferror-limit 19 -fopenmp -fopenmp-version=50 -fopenmp-cuda-parallel-target-regions -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -fcolor-diagnostics -fopenmp-is-device -fopenmp-host-ir-file-path /var/folders/rx/8phxx7k53pqghv8kjxkbv2ch006fcl/T/test-c282ef.bc -o /var/folders/rx/8phxx7k53pqghv8kjxkbv2ch006fcl/T/test-f0824e.ll -x c++ test.cpp
1.	test.cpp:20:1: current parser token 'int'
2.	test.cpp:5:7: LLVM IR generation of declaration 'Myclass'
0  clang-10                 0x0000000108bead4c llvm::sys::PrintStackTrace(llvm::raw_ostream&) + 60
1  clang-10                 0x0000000108beb309 PrintStackTraceSignalHandler(void*) + 25
2  clang-10                 0x0000000108be8c46 llvm::sys::RunSignalHandlers() + 118
3  clang-10                 0x0000000108bed070 SignalHandler(int) + 208
4  libsystem_platform.dylib 0x00007fff7bd98b5d _sigtramp + 29
5  clang-10                 0x000000010fdc6ae2 llvm::DenseMapInfo<llvm::codeview::GloballyHashedType>::Tombstone + 2998754
6  libsystem_c.dylib        0x00007fff7bc526a6 abort + 127
7  libsystem_c.dylib        0x00007fff7bc1b20d basename_r + 0
8  clang-10                 0x000000010e908344 llvm::cast_retty<clang::CapturedStmt, clang::Stmt*>::ret_type llvm::cast<clang::CapturedStmt, clang::Stmt>(clang::Stmt*) + 100
9  clang-10                 0x000000010d4097b3 clang::OMPChildren::getInnermostCapturedStmt(llvm::ArrayRef<llvm::omp::Directive>) + 227
10 clang-10                 0x000000010d3f67d5 clang::OMPExecutableDirective::getInnermostCapturedStmt() + 197
11 clang-10                 0x000000010959a555 clang::OMPExecutableDirective::getInnermostCapturedStmt() const + 21
12 clang-10                 0x0000000109599d89 clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1305
13 clang-10                 0x0000000109599eab clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1595
14 clang-10                 0x0000000109599eab clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1595
15 clang-10                 0x0000000109599eab clang::CodeGen::CGOpenMPRuntime::scanForTargetRegionsFunctions(clang::Stmt const*, llvm::StringRef) + 1595
16 clang-10                 0x000000010959a6f0 clang::CodeGen::CGOpenMPRuntime::emitTargetFunctions(clang::GlobalDecl) + 320
17 clang-10                 0x000000010959b97e clang::CodeGen::CGOpenMPRuntime::emitTargetGlobal(clang::GlobalDecl) + 142
18 clang-10                 0x000000010973c53e clang::CodeGen::CodeGenModule::EmitGlobal(clang::GlobalDecl) + 926
19 clang-10                 0x0000000109746a8a clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl*) + 266
20 clang-10                 0x0000000109937553 (anonymous namespace)::CodeGeneratorImpl::EmitDeferredDecls() + 179
21 clang-10                 0x000000010993748d (anonymous namespace)::CodeGeneratorImpl::HandlingTopLevelDeclRAII::~HandlingTopLevelDeclRAII() + 77
22 clang-10                 0x00000001099373f5 (anonymous namespace)::CodeGeneratorImpl::HandlingTopLevelDeclRAII::~HandlingTopLevelDeclRAII() + 21
23 clang-10                 0x0000000109932410 (anonymous namespace)::CodeGeneratorImpl::HandleTopLevelDecl(clang::DeclGroupRef) + 176
24 clang-10                 0x00000001096f5d6e clang::BackendConsumer::HandleTopLevelDecl(clang::DeclGroupRef) + 222
25 clang-10                 0x000000010ca8cd14 clang::ParseAST(clang::Sema&, bool, bool) + 548
26 clang-10                 0x0000000109e76e82 clang::ASTFrontendAction::ExecuteAction() + 322
27 clang-10                 0x00000001096f4f17 clang::CodeGenAction::ExecuteAction() + 2391
28 clang-10                 0x0000000109e76411 clang::FrontendAction::Execute() + 129
29 clang-10                 0x0000000109dbd367 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) + 2087
30 clang-10                 0x0000000109fce131 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) + 1761
31 clang-10                 0x00000001063404ec cc1_main(llvm::ArrayRef<char const*>, char const*, void*) + 1388
32 clang-10                 0x0000000106333a02 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) + 434
33 clang-10                 0x00000001063326d5 main + 1509
34 libdyld.dylib            0x00007fff7bbad3d5 start + 1

Edit: Removing "#pragma omp atomic" in line 14 can avoid the asserts.

Must be fixed in fbd6d2c54e57a4968d29bb22742dd49759b3ecd0

clang/include/clang/AST/DeclOpenMP.h

 //===- DeclOpenMP.h - Classes for representing OpenMP directives -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines OpenMP nodes for declarative directives.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_DECLOPENMP_H
 #define LLVM_CLANG_AST_DECLOPENMP_H
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/Type.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/TrailingObjects.h"
 
 namespace clang {
 
+/// This is a basic class for representing single OpenMP declarative directive.
+///
+template <typename U> class OMPDeclarativeDirective : public U {
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+
+  /// Get the clauses storage.
+  MutableArrayRef<OMPClause *> getClauses() {
+    if (!Data)
+      return llvm::None;
+    return Data->getClauses();
+  }
+
+protected:
+  /// Data, associated with the directive.
+  OMPChildren *Data = nullptr;
+
+  /// Build instance of directive.
+  ///
+  /// \param StartLoc Starting location of the directive (directive keyword).
+  ///
+  template <typename... Params>
+  OMPDeclarativeDirective(Params &&... P) : U(std::forward<Params>(P)...) {}
+
+  template <typename T, typename... Params>
+  static T *createDirective(const ASTContext &C, DeclContext *DC,
+                            ArrayRef<OMPClause *> Clauses, unsigned NumChildren,
+                            Params &&... P) {
+    auto *Inst = new (C, DC, size(Clauses.size(), NumChildren))
+        T(DC, std::forward<Params>(P)...);
+    Inst->Data = OMPChildren::Create(Inst + 1, Clauses,
+                                     /*AssociatedStmt=*/nullptr, NumChildren);
+    Inst->Data->setClauses(Clauses);
+    return Inst;
+  }
+
+  template <typename T, typename... Params>
+  static T *createEmptyDirective(const ASTContext &C, unsigned ID,
+                                 unsigned NumClauses, unsigned NumChildren,
+                                 Params &&... P) {
+    auto *Inst = new (C, ID, size(NumClauses, NumChildren))
+        T(nullptr, std::forward<Params>(P)...);
+    Inst->Data = OMPChildren::CreateEmpty(
+        Inst + 1, NumClauses, /*HasAssociatedStmt=*/false, NumChildren);
+    return Inst;
+  }
+
+  static size_t size(unsigned NumClauses, unsigned NumChildren) {
+    return OMPChildren::size(NumClauses, /*HasAssociatedStmt=*/false,
+                             NumChildren);
+  }
+
+public:
+  /// Get number of clauses.
+  unsigned getNumClauses() const {
+    if (!Data)
+      return 0;
+    return Data->getNumClauses();
+  }
+
+  /// Returns specified clause.
+  ///
+  /// \param I Number of clause.
+  ///
+  OMPClause *getClause(unsigned I) const { return clauses()[I]; }
+
+  ArrayRef<OMPClause *> clauses() const {
+    if (!Data)
+      return llvm::None;
+    return Data->getClauses();
+  }
+};
+
 /// This represents '#pragma omp threadprivate ...' directive.
 /// For example, in the following, both 'a' and 'A::b' are threadprivate:
 ///
 /// \code
 /// int a;
 /// #pragma omp threadprivate(a)
 /// struct A {
 ///   static int b;
 /// #pragma omp threadprivate(b)
 /// };
 /// \endcode
 ///
-class OMPThreadPrivateDecl final
-    : public Decl,
-      private llvm::TrailingObjects<OMPThreadPrivateDecl, Expr *> {
-  friend class ASTDeclReader;
-  friend TrailingObjects;
-
-  unsigned NumVars;
+class OMPThreadPrivateDecl final : public OMPDeclarativeDirective<Decl> {
+  friend class OMPDeclarativeDirective<Decl>;
 
   virtual void anchor();
 
-  OMPThreadPrivateDecl(Kind DK, DeclContext *DC, SourceLocation L) :
-    Decl(DK, DC, L), NumVars(0) { }
+  OMPThreadPrivateDecl(DeclContext *DC = nullptr,
+                       SourceLocation L = SourceLocation())
+      : OMPDeclarativeDirective<Decl>(OMPThreadPrivate, DC, L) {}
 
   ArrayRef<const Expr *> getVars() const {
-    return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumVars);
+    auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
+    return llvm::makeArrayRef(Storage, Data->getNumChildren());
   }
 
   MutableArrayRef<Expr *> getVars() {
-    return MutableArrayRef<Expr *>(getTrailingObjects<Expr *>(), NumVars);
+    auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
+    return llvm::makeMutableArrayRef(Storage, Data->getNumChildren());
   }
 
   void setVars(ArrayRef<Expr *> VL);
 
 public:
   static OMPThreadPrivateDecl *Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L,
                                       ArrayRef<Expr *> VL);
   static OMPThreadPrivateDecl *CreateDeserialized(ASTContext &C,
                                                   unsigned ID, unsigned N);
 
   typedef MutableArrayRef<Expr *>::iterator varlist_iterator;
   typedef ArrayRef<const Expr *>::iterator varlist_const_iterator;
   typedef llvm::iterator_range<varlist_iterator> varlist_range;
   typedef llvm::iterator_range<varlist_const_iterator> varlist_const_range;
 
-  unsigned varlist_size() const { return NumVars; }
-  bool varlist_empty() const { return NumVars == 0; }
+  unsigned varlist_size() const { return Data->getNumChildren(); }
+  bool varlist_empty() const { return Data->getChildren().empty(); }
 
   varlist_range varlists() {
     return varlist_range(varlist_begin(), varlist_end());
   }
   varlist_const_range varlists() const {
     return varlist_const_range(varlist_begin(), varlist_end());
   }
   varlist_iterator varlist_begin() { return getVars().begin(); }

 /// This represents '#pragma omp declare mapper ...' directive. Map clauses are
 /// allowed to use with this directive. The following example declares a user
 /// defined mapper for the type 'struct vec'. This example instructs the fields
 /// 'len' and 'data' should be mapped when mapping instances of 'struct vec'.
 ///
 /// \code
 /// #pragma omp declare mapper(mid: struct vec v) map(v.len, v.data[0:N])
 /// \endcode
-class OMPDeclareMapperDecl final : public ValueDecl, public DeclContext {
+class OMPDeclareMapperDecl final : public OMPDeclarativeDirective<ValueDecl>,
+                                   public DeclContext {
+  friend class OMPDeclarativeDirective<ValueDecl>;
   friend class ASTDeclReader;
-
-  /// Clauses associated with this mapper declaration
-  MutableArrayRef<OMPClause *> Clauses;
+  friend class ASTDeclWriter;
 
   /// Mapper variable, which is 'v' in the example above
   Expr *MapperVarRef = nullptr;
 
   /// Name of the mapper variable
   DeclarationName VarName;
 
   LazyDeclPtr PrevDeclInScope;
 
   void anchor() override;
 
-  OMPDeclareMapperDecl(Kind DK, DeclContext *DC, SourceLocation L,
-                       DeclarationName Name, QualType Ty,
-                       DeclarationName VarName,
+  OMPDeclareMapperDecl(DeclContext *DC, SourceLocation L, DeclarationName Name,
+                       QualType Ty, DeclarationName VarName,
                        OMPDeclareMapperDecl *PrevDeclInScope)
-      : ValueDecl(DK, DC, L, Name, Ty), DeclContext(DK), VarName(VarName),
+      : OMPDeclarativeDirective<ValueDecl>(OMPDeclareMapper, DC, L, Name, Ty),
+        DeclContext(OMPDeclareMapper), VarName(VarName),
         PrevDeclInScope(PrevDeclInScope) {}
 
   void setPrevDeclInScope(OMPDeclareMapperDecl *Prev) {
     PrevDeclInScope = Prev;
   }
 
-  /// Sets an array of clauses to this mapper declaration
-  void setClauses(ArrayRef<OMPClause *> CL);
-
 public:
   /// Creates declare mapper node.
   static OMPDeclareMapperDecl *Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L, DeclarationName Name,
                                       QualType T, DeclarationName VarName,
+                                      ArrayRef<OMPClause *> Clauses,
                                       OMPDeclareMapperDecl *PrevDeclInScope);
   /// Creates deserialized declare mapper node.
   static OMPDeclareMapperDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                                   unsigned N);
 
-  /// Creates an array of clauses to this mapper declaration and intializes
-  /// them.
-  void CreateClauses(ASTContext &C, ArrayRef<OMPClause *> CL);
-
   using clauselist_iterator = MutableArrayRef<OMPClause *>::iterator;
   using clauselist_const_iterator = ArrayRef<const OMPClause *>::iterator;
   using clauselist_range = llvm::iterator_range<clauselist_iterator>;
   using clauselist_const_range =
       llvm::iterator_range<clauselist_const_iterator>;
 
-  unsigned clauselist_size() const { return Clauses.size(); }
-  bool clauselist_empty() const { return Clauses.empty(); }
+  unsigned clauselist_size() const { return Data->getNumClauses(); }
+  bool clauselist_empty() const { return Data->getClauses().empty(); }
 
   clauselist_range clauselists() {
     return clauselist_range(clauselist_begin(), clauselist_end());
   }
   clauselist_const_range clauselists() const {
     return clauselist_const_range(clauselist_begin(), clauselist_end());
   }
-  clauselist_iterator clauselist_begin() { return Clauses.begin(); }
-  clauselist_iterator clauselist_end() { return Clauses.end(); }
-  clauselist_const_iterator clauselist_begin() const { return Clauses.begin(); }
-  clauselist_const_iterator clauselist_end() const { return Clauses.end(); }
+  clauselist_iterator clauselist_begin() { return Data->getClauses().begin(); }
+  clauselist_iterator clauselist_end() { return Data->getClauses().end(); }
+  clauselist_const_iterator clauselist_begin() const {
+    return Data->getClauses().begin();
+  }
+  clauselist_const_iterator clauselist_end() const {
+    return Data->getClauses().end();
+  }
 
   /// Get the variable declared in the mapper
-  Expr *getMapperVarRef() { return MapperVarRef; }
-  const Expr *getMapperVarRef() const { return MapperVarRef; }
+  Expr *getMapperVarRef() { return cast_or_null<Expr>(Data->getChildren()[0]); }
+  const Expr *getMapperVarRef() const {
+    return cast_or_null<Expr>(Data->getChildren()[0]);
+  }
   /// Set the variable declared in the mapper
-  void setMapperVarRef(Expr *MapperVarRefE) { MapperVarRef = MapperVarRefE; }
+  void setMapperVarRef(Expr *MapperVarRefE) {
+    Data->getChildren()[0] = MapperVarRefE;
+  }
 
   /// Get the name of the variable declared in the mapper
   DeclarationName getVarName() { return VarName; }
 
   /// Get reference to previous declare mapper construct in the same
   /// scope with the same name.
   OMPDeclareMapperDecl *getPrevDeclInScope();
   const OMPDeclareMapperDecl *getPrevDeclInScope() const;

 
 /// This represents '#pragma omp requires...' directive.
 /// For example
 ///
 /// \code
 /// #pragma omp requires unified_address
 /// \endcode
 ///
-class OMPRequiresDecl final
-    : public Decl,
-      private llvm::TrailingObjects<OMPRequiresDecl, OMPClause *> {
+class OMPRequiresDecl final : public OMPDeclarativeDirective<Decl> {
+  friend class OMPDeclarativeDirective<Decl>;
   friend class ASTDeclReader;
-  friend TrailingObjects;
-
-  // Number of clauses associated with this requires declaration
-  unsigned NumClauses = 0;
 
   virtual void anchor();
 
-  OMPRequiresDecl(Kind DK, DeclContext *DC, SourceLocation L)
-      : Decl(DK, DC, L), NumClauses(0) {}
-
-  /// Returns an array of immutable clauses associated with this requires
-  /// declaration
-  ArrayRef<const OMPClause *> getClauses() const {
-    return llvm::makeArrayRef(getTrailingObjects<OMPClause *>(), NumClauses);
-  }
-
-  /// Returns an array of clauses associated with this requires declaration
-  MutableArrayRef<OMPClause *> getClauses() {
-    return MutableArrayRef<OMPClause *>(getTrailingObjects<OMPClause *>(),
-                                        NumClauses);
-  }
-
-  /// Sets an array of clauses to this requires declaration
-  void setClauses(ArrayRef<OMPClause *> CL);
+  OMPRequiresDecl(DeclContext *DC, SourceLocation L)
+      : OMPDeclarativeDirective<Decl>(OMPRequires, DC, L) {}
 
 public:
   /// Create requires node.
   static OMPRequiresDecl *Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation L, ArrayRef<OMPClause *> CL);
   /// Create deserialized requires node.
   static OMPRequiresDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                              unsigned N);
 
   using clauselist_iterator = MutableArrayRef<OMPClause *>::iterator;
   using clauselist_const_iterator = ArrayRef<const OMPClause *>::iterator;
   using clauselist_range = llvm::iterator_range<clauselist_iterator>;
   using clauselist_const_range = llvm::iterator_range<clauselist_const_iterator>;
 
-  unsigned clauselist_size() const { return NumClauses; }
-  bool clauselist_empty() const { return NumClauses == 0; }
+  unsigned clauselist_size() const { return Data->getNumClauses(); }
+  bool clauselist_empty() const { return Data->getClauses().empty(); }
 
   clauselist_range clauselists() {
     return clauselist_range(clauselist_begin(), clauselist_end());
   }
   clauselist_const_range clauselists() const {
     return clauselist_const_range(clauselist_begin(), clauselist_end());
   }
-  clauselist_iterator clauselist_begin() { return getClauses().begin(); }
-  clauselist_iterator clauselist_end() { return getClauses().end(); }
+  clauselist_iterator clauselist_begin() { return Data->getClauses().begin(); }
+  clauselist_iterator clauselist_end() { return Data->getClauses().end(); }
   clauselist_const_iterator clauselist_begin() const {
-    return getClauses().begin();
+    return Data->getClauses().begin();
   }
   clauselist_const_iterator clauselist_end() const {
-    return getClauses().end();
+    return Data->getClauses().end();
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == OMPRequires; }
 };
 
 /// This represents '#pragma omp allocate ...' directive.
 /// For example, in the following, the default allocator is used for both 'a'
 /// and 'A::b':
 ///
 /// \code
 /// int a;
 /// #pragma omp allocate(a)
 /// struct A {
 ///   static int b;
 /// #pragma omp allocate(b)
 /// };
 /// \endcode
 ///
-class OMPAllocateDecl final
-    : public Decl,
-      private llvm::TrailingObjects<OMPAllocateDecl, Expr *, OMPClause *> {
+class OMPAllocateDecl final : public OMPDeclarativeDirective<Decl> {
+  friend class OMPDeclarativeDirective<Decl>;
   friend class ASTDeclReader;
-  friend TrailingObjects;
-
-  /// Number of variable within the allocate directive.
-  unsigned NumVars = 0;
-  /// Number of clauses associated with the allocate directive.
-  unsigned NumClauses = 0;
-
-  size_t numTrailingObjects(OverloadToken<Expr *>) const {
-    return NumVars;
-  }
-  size_t numTrailingObjects(OverloadToken<OMPClause *>) const {
-    return NumClauses;
-  }
 
   virtual void anchor();
 
-  OMPAllocateDecl(Kind DK, DeclContext *DC, SourceLocation L)
-      : Decl(DK, DC, L) {}
+  OMPAllocateDecl(DeclContext *DC, SourceLocation L)
+      : OMPDeclarativeDirective<Decl>(OMPAllocate, DC, L) {}
 
   ArrayRef<const Expr *> getVars() const {
-    return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumVars);
+    auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
+    return llvm::makeArrayRef(Storage, Data->getNumChildren());
   }
 
   MutableArrayRef<Expr *> getVars() {
-    return MutableArrayRef<Expr *>(getTrailingObjects<Expr *>(), NumVars);
+    auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
+    return llvm::makeMutableArrayRef(Storage, Data->getNumChildren());
   }
 
   void setVars(ArrayRef<Expr *> VL);
 
-  /// Returns an array of immutable clauses associated with this directive.
-  ArrayRef<OMPClause *> getClauses() const {
-    return llvm::makeArrayRef(getTrailingObjects<OMPClause *>(), NumClauses);
-  }
-
-  /// Returns an array of clauses associated with this directive.
-  MutableArrayRef<OMPClause *> getClauses() {
-    return MutableArrayRef<OMPClause *>(getTrailingObjects<OMPClause *>(),
-                                        NumClauses);
-  }
-
-  /// Sets an array of clauses to this requires declaration
-  void setClauses(ArrayRef<OMPClause *> CL);
-
 public:
   static OMPAllocateDecl *Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation L, ArrayRef<Expr *> VL,
                                  ArrayRef<OMPClause *> CL);
   static OMPAllocateDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                              unsigned NVars, unsigned NClauses);
 
   typedef MutableArrayRef<Expr *>::iterator varlist_iterator;
   typedef ArrayRef<const Expr *>::iterator varlist_const_iterator;
   typedef llvm::iterator_range<varlist_iterator> varlist_range;
   typedef llvm::iterator_range<varlist_const_iterator> varlist_const_range;
   using clauselist_iterator = MutableArrayRef<OMPClause *>::iterator;
   using clauselist_const_iterator = ArrayRef<const OMPClause *>::iterator;
   using clauselist_range = llvm::iterator_range<clauselist_iterator>;
   using clauselist_const_range = llvm::iterator_range<clauselist_const_iterator>;
 
-
-  unsigned varlist_size() const { return NumVars; }
-  bool varlist_empty() const { return NumVars == 0; }
-  unsigned clauselist_size() const { return NumClauses; }
-  bool clauselist_empty() const { return NumClauses == 0; }
+  unsigned varlist_size() const { return Data->getNumChildren(); }
+  bool varlist_empty() const { return Data->getChildren().empty(); }
+  unsigned clauselist_size() const { return Data->getNumClauses(); }
+  bool clauselist_empty() const { return Data->getClauses().empty(); }
 
   varlist_range varlists() {
     return varlist_range(varlist_begin(), varlist_end());
   }
   varlist_const_range varlists() const {
     return varlist_const_range(varlist_begin(), varlist_end());
   }
   varlist_iterator varlist_begin() { return getVars().begin(); }
   varlist_iterator varlist_end() { return getVars().end(); }
   varlist_const_iterator varlist_begin() const { return getVars().begin(); }
   varlist_const_iterator varlist_end() const { return getVars().end(); }
 
   clauselist_range clauselists() {
     return clauselist_range(clauselist_begin(), clauselist_end());
   }
   clauselist_const_range clauselists() const {
     return clauselist_const_range(clauselist_begin(), clauselist_end());
   }
-  clauselist_iterator clauselist_begin() { return getClauses().begin(); }
-  clauselist_iterator clauselist_end() { return getClauses().end(); }
+  clauselist_iterator clauselist_begin() { return Data->getClauses().begin(); }
+  clauselist_iterator clauselist_end() { return Data->getClauses().end(); }
   clauselist_const_iterator clauselist_begin() const {
-    return getClauses().begin();
+    return Data->getClauses().begin();
   }
   clauselist_const_iterator clauselist_end() const {
-    return getClauses().end();
+    return Data->getClauses().end();
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == OMPAllocate; }
 };
 
 } // end namespace clang
 
 #endif

clang/include/clang/AST/OpenMPClause.h

 /// There are clauses for executable directives, clauses for declarative
 /// directives and clauses which can be used in both kinds of directives.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_OPENMPCLAUSE_H
 #define LLVM_CLANG_AST_OPENMPCLAUSE_H
 
+#include "clang/AST/ASTFwd.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtIterator.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/OpenMPKinds.h"
struct TargetOMPContext final : public llvm::omp::OMPContext {
   bool matchesISATrait(StringRef RawString) const override;
 
 private:
   std::function<bool(StringRef)> FeatureValidityCheck;
   std::function<void(StringRef)> DiagUnknownTrait;
   llvm::StringMap<bool> FeatureMap;
 };
 
+/// Contains data for OpenMP directives: clauses, children
+/// expressions/statements (helpers for codegen) and associated statement, if
+/// any.
+class OMPChildren final
+    : private llvm::TrailingObjects<OMPChildren, OMPClause *, Stmt *> {
+  friend class OMPClauseReader;
+  friend class TrailingObjects;
+  friend class OMPExecutableDirective;
+  template <typename T> friend class OMPDeclarativeDirective;
+
+  /// Numbers of clauses.
+  unsigned NumClauses = 0;
+  /// Number of child expressions/stmts.
+  unsigned NumChildren = 0;
+  /// true if the directive has associated statement.
+  bool HasAssociatedStmt = false;
+
+  /// Define the sizes of each trailing object array except the last one. This
+  /// is required for TrailingObjects to work properly.
+  size_t numTrailingObjects(OverloadToken<OMPClause *>) const {
+    return NumClauses;
+  }
+
+  OMPChildren() = delete;
+
+  OMPChildren(unsigned NumClauses, unsigned NumChildren, bool HasAssociatedStmt)
+      : NumClauses(NumClauses), NumChildren(NumChildren),
+        HasAssociatedStmt(HasAssociatedStmt) {}
+
+  static size_t size(unsigned NumClauses, bool HasAssociatedStmt,
+                     unsigned NumChildren);
+
+  static OMPChildren *Create(void *Mem, ArrayRef<OMPClause *> Clauses);
+  static OMPChildren *Create(void *Mem, ArrayRef<OMPClause *> Clauses, Stmt *S,
+                             unsigned NumChildren = 0);
+  static OMPChildren *CreateEmpty(void *Mem, unsigned NumClauses,
+                                  bool HasAssociatedStmt = false,
+                                  unsigned NumChildren = 0);
+
+public:
+  unsigned getNumClauses() const { return NumClauses; }
+  unsigned getNumChildren() const { return NumChildren; }
+  bool hasAssociatedStmt() const { return HasAssociatedStmt; }
+
+  /// Set associated statement.
+  void setAssociatedStmt(Stmt *S) {
+    getTrailingObjects<Stmt *>()[NumChildren] = S;
+  }
+
+  void setChildren(ArrayRef<Stmt *> Children);
+
+  /// Sets the list of variables for this clause.
+  ///
+  /// \param Clauses The list of clauses for the directive.
+  ///
+  void setClauses(ArrayRef<OMPClause *> Clauses);
+
+  /// Returns statement associated with the directive.
+  const Stmt *getAssociatedStmt() const {
+    return const_cast<OMPChildren *>(this)->getAssociatedStmt();
+  }
+  Stmt *getAssociatedStmt() {
+    assert(HasAssociatedStmt &&
+           "Expected directive with the associated statement.");
+    return getTrailingObjects<Stmt *>()[NumChildren];
+  }
+
+  /// Get the clauses storage.
+  MutableArrayRef<OMPClause *> getClauses() {
+    return llvm::makeMutableArrayRef(getTrailingObjects<OMPClause *>(),
+                                     NumClauses);
+  }
+  ArrayRef<OMPClause *> getClauses() const {
+    return const_cast<OMPChildren *>(this)->getClauses();
+  }
+
+  /// Returns the captured statement associated with the
+  /// component region within the (combined) directive.
+  ///
+  /// \param RegionKind Component region kind.
+  const CapturedStmt *
+  getCapturedStmt(OpenMPDirectiveKind RegionKind,
+                  ArrayRef<OpenMPDirectiveKind> CaptureRegions) const {
+    assert(llvm::any_of(
+               CaptureRegions,
+               [=](const OpenMPDirectiveKind K) { return K == RegionKind; }) &&
+           "RegionKind not found in OpenMP CaptureRegions.");
+    auto *CS = cast<CapturedStmt>(getAssociatedStmt());
+    for (auto ThisCaptureRegion : CaptureRegions) {
+      if (ThisCaptureRegion == RegionKind)
+        return CS;
+      CS = cast<CapturedStmt>(CS->getCapturedStmt());
+    }
+    llvm_unreachable("Incorrect RegionKind specified for directive.");
+  }
+
+  /// Get innermost captured statement for the construct.
+  CapturedStmt *
+  getInnermostCapturedStmt(ArrayRef<OpenMPDirectiveKind> CaptureRegions) {
+    assert(hasAssociatedStmt() && "Must have associated captured statement.");
+    assert(!CaptureRegions.empty() &&
+           "At least one captured statement must be provided.");
+    auto *CS = cast<CapturedStmt>(getAssociatedStmt());
+    for (unsigned Level = CaptureRegions.size(); Level > 1; --Level)
+      CS = cast<CapturedStmt>(CS->getCapturedStmt());
+    return CS;
+  }
+
+  const CapturedStmt *
+  getInnermostCapturedStmt(ArrayRef<OpenMPDirectiveKind> CaptureRegions) const {
+    return const_cast<OMPChildren *>(this)->getInnermostCapturedStmt(
+        CaptureRegions);
+  }
+
+  MutableArrayRef<Stmt *> getChildren();
+  ArrayRef<Stmt *> getChildren() const {
+    return const_cast<OMPChildren *>(this)->getChildren();
+  }
+
+  Stmt *getRawStmt() {
+    assert(HasAssociatedStmt &&
+           "Expected directive with the associated statement.");
+    if (auto *CS = dyn_cast<CapturedStmt>(getAssociatedStmt())) {
+      Stmt *S = nullptr;
+      do {
+        S = CS->getCapturedStmt();
+        CS = dyn_cast<CapturedStmt>(S);
+      } while (CS);
+      return S;
+    }
+    return getAssociatedStmt();
+  }
+  const Stmt *getRawStmt() const {
+    return const_cast<OMPChildren *>(this)->getRawStmt();
+  }
+
+  Stmt::child_range getAssociatedStmtAsRange() {
+    if (!HasAssociatedStmt)
+      return Stmt::child_range(Stmt::child_iterator(), Stmt::child_iterator());
+    return Stmt::child_range(&getTrailingObjects<Stmt *>()[NumChildren],
+                             &getTrailingObjects<Stmt *>()[NumChildren + 1]);
+  }
+};
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_OPENMPCLAUSE_H

clang/include/clang/AST/StmtOpenMP.h

 //===- StmtOpenMP.h - Classes for OpenMP directives  ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// This file defines OpenMP AST classes for executable directives and
 /// clauses.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_STMTOPENMP_H
 #define LLVM_CLANG_AST_STMTOPENMP_H
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/SourceLocation.h"
 
 namespace clang {
 
 //===----------------------------------------------------------------------===//
 // AST classes for directives.
 //===----------------------------------------------------------------------===//
 
 /// This is a basic class for representing single OpenMP executable
 /// directive.
 ///
 class OMPExecutableDirective : public Stmt {
   friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+
   /// Kind of the directive.
-  OpenMPDirectiveKind Kind;
+  OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown;
   /// Starting location of the directive (directive keyword).
   SourceLocation StartLoc;
   /// Ending location of the directive.
   SourceLocation EndLoc;
-  /// Numbers of clauses.
-  const unsigned NumClauses;
-  /// Number of child expressions/stmts.
-  const unsigned NumChildren;
-  /// Offset from this to the start of clauses.
-  /// There are NumClauses pointers to clauses, they are followed by
-  /// NumChildren pointers to child stmts/exprs (if the directive type
-  /// requires an associated stmt, then it has to be the first of them).
-  const unsigned ClausesOffset;
 
   /// Get the clauses storage.
   MutableArrayRef<OMPClause *> getClauses() {
-    OMPClause **ClauseStorage = reinterpret_cast<OMPClause **>(
-        reinterpret_cast<char *>(this) + ClausesOffset);
-    return MutableArrayRef<OMPClause *>(ClauseStorage, NumClauses);
+    if (!Data)
+      return llvm::None;
+    return Data->getClauses();
   }
 
 protected:
+  /// Data, associated with the directive.
+  OMPChildren *Data = nullptr;
+
   /// Build instance of directive of class \a K.
   ///
   /// \param SC Statement class.
   /// \param K Kind of OpenMP directive.
   /// \param StartLoc Starting location of the directive (directive keyword).
   /// \param EndLoc Ending location of the directive.
   ///
-  template <typename T>
-  OMPExecutableDirective(const T *, StmtClass SC, OpenMPDirectiveKind K,
-                         SourceLocation StartLoc, SourceLocation EndLoc,
-                         unsigned NumClauses, unsigned NumChildren)
+  OMPExecutableDirective(StmtClass SC, OpenMPDirectiveKind K,
+                         SourceLocation StartLoc, SourceLocation EndLoc)
       : Stmt(SC), Kind(K), StartLoc(std::move(StartLoc)),
-        EndLoc(std::move(EndLoc)), NumClauses(NumClauses),
-        NumChildren(NumChildren),
-        ClausesOffset(llvm::alignTo(sizeof(T), alignof(OMPClause *))) {}
+        EndLoc(std::move(EndLoc)) {}
 
-  /// Sets the list of variables for this clause.
-  ///
-  /// \param Clauses The list of clauses for the directive.
-  ///
-  void setClauses(ArrayRef<OMPClause *> Clauses);
+  template <typename T, typename... Params>
+  static T *createDirective(const ASTContext &C, ArrayRef<OMPClause *> Clauses,
+                            Stmt *AssociatedStmt, unsigned NumChildren,
+                            Params &&... P) {
+    void *Mem =
+        C.Allocate(sizeof(T) + OMPChildren::size(Clauses.size(), AssociatedStmt,
+                                                 NumChildren),
+                   alignof(T));
+
+    auto *Data = OMPChildren::Create(reinterpret_cast<T *>(Mem) + 1, Clauses,
+                                     AssociatedStmt, NumChildren);
+    auto *Inst = new (Mem) T(std::forward<Params>(P)...);
+    Inst->Data = Data;
+    return Inst;
+  }
+
+  template <typename T, typename... Params>
+  static T *createEmptyDirective(const ASTContext &C, unsigned NumClauses,
+                                 bool HasAssociatedStmt, unsigned NumChildren,
+                                 Params &&... P) {
+    void *Mem =
+        C.Allocate(sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
+                                                 NumChildren),
+                   alignof(T));
+    auto *Data =
+        OMPChildren::CreateEmpty(reinterpret_cast<T *>(Mem) + 1, NumClauses,
+                                 HasAssociatedStmt, NumChildren);
+    auto *Inst = new (Mem) T(std::forward<Params>(P)...);
+    Inst->Data = Data;
+    return Inst;
+  }
 
-  /// Set the associated statement for the directive.
-  ///
-  /// /param S Associated statement.
-  ///
-  void setAssociatedStmt(Stmt *S) {
-    assert(hasAssociatedStmt() && "no associated statement.");
-    *child_begin() = S;
+  template <typename T>
+  static T *createEmptyDirective(const ASTContext &C, unsigned NumClauses,
+                                 bool HasAssociatedStmt = false,
+                                 unsigned NumChildren = 0) {
+    void *Mem =
+        C.Allocate(sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
+                                                 NumChildren),
+                   alignof(T));
+    auto *Data =
+        OMPChildren::CreateEmpty(reinterpret_cast<T *>(Mem) + 1, NumClauses,
+                                 HasAssociatedStmt, NumChildren);
+    auto *Inst = new (Mem) T;
+    Inst->Data = Data;
+    return Inst;
   }
 
 public:
   /// Iterates over expressions/statements used in the construct.
   class used_clauses_child_iterator
       : public llvm::iterator_adaptor_base<
             used_clauses_child_iterator, ArrayRef<OMPClause *>::iterator,
             std::forward_iterator_tag, Stmt *, ptrdiff_t, Stmt *, Stmt *> {
class used_clauses_child_iterator
     }
 
   public:
     explicit used_clauses_child_iterator(ArrayRef<OMPClause *> Clauses)
         : used_clauses_child_iterator::iterator_adaptor_base(Clauses.begin()),
           End(Clauses.end()) {
       if (this->I != End) {
         ChildI = (*this->I)->used_children().begin();
         ChildEnd = (*this->I)->used_children().end();
         MoveToNext();
       }
     }
     Stmt *operator*() const { return *ChildI; }
     Stmt *operator->() const { return **this; }
 
     used_clauses_child_iterator &operator++() {
       ++ChildI;
public:
   void setLocStart(SourceLocation Loc) { StartLoc = Loc; }
   /// Set ending location of directive.
   ///
   /// \param Loc New ending location of directive.
   ///
   void setLocEnd(SourceLocation Loc) { EndLoc = Loc; }
 
   /// Get number of clauses.
-  unsigned getNumClauses() const { return NumClauses; }
+  unsigned getNumClauses() const {
+    if (!Data)
+      return 0;
+    return Data->getNumClauses();
+  }
 
   /// Returns specified clause.
   ///
-  /// \param i Number of clause.
+  /// \param I Number of clause.
   ///
-  OMPClause *getClause(unsigned i) const { return clauses()[i]; }
+  OMPClause *getClause(unsigned I) const { return clauses()[I]; }
 
   /// Returns true if directive has associated statement.
-  bool hasAssociatedStmt() const { return NumChildren > 0; }
+  bool hasAssociatedStmt() const { return Data && Data->hasAssociatedStmt(); }
 
   /// Returns statement associated with the directive.
   const Stmt *getAssociatedStmt() const {
-    assert(hasAssociatedStmt() && "no associated statement.");
-    return *child_begin();
+    return const_cast<OMPExecutableDirective *>(this)->getAssociatedStmt();
   }
   Stmt *getAssociatedStmt() {
-    assert(hasAssociatedStmt() && "no associated statement.");
-    return *child_begin();
+    assert(hasAssociatedStmt() &&
+           "Expected directive with the associated statement.");
+    return Data->getAssociatedStmt();
   }
 
   /// Returns the captured statement associated with the
   /// component region within the (combined) directive.
-  //
-  // \param RegionKind Component region kind.
+  ///
+  /// \param RegionKind Component region kind.
   const CapturedStmt *getCapturedStmt(OpenMPDirectiveKind RegionKind) const {
+    assert(hasAssociatedStmt() &&
+           "Expected directive with the associated statement.");
     SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
     getOpenMPCaptureRegions(CaptureRegions, getDirectiveKind());
-    assert(std::any_of(
-               CaptureRegions.begin(), CaptureRegions.end(),
-               [=](const OpenMPDirectiveKind K) { return K == RegionKind; }) &&
-           "RegionKind not found in OpenMP CaptureRegions.");
-    auto *CS = cast<CapturedStmt>(getAssociatedStmt());
-    for (auto ThisCaptureRegion : CaptureRegions) {
-      if (ThisCaptureRegion == RegionKind)
-        return CS;
-      CS = cast<CapturedStmt>(CS->getCapturedStmt());
-    }
-    llvm_unreachable("Incorrect RegionKind specified for directive.");
+    return Data->getCapturedStmt(RegionKind, CaptureRegions);
   }
 
   /// Get innermost captured statement for the construct.
   CapturedStmt *getInnermostCapturedStmt() {
-    assert(hasAssociatedStmt() && getAssociatedStmt() &&
-           "Must have associated statement.");
+    assert(hasAssociatedStmt() &&
+           "Expected directive with the associated statement.");
     SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
     getOpenMPCaptureRegions(CaptureRegions, getDirectiveKind());
-    assert(!CaptureRegions.empty() &&
-           "At least one captured statement must be provided.");
-    auto *CS = cast<CapturedStmt>(getAssociatedStmt());
-    for (unsigned Level = CaptureRegions.size(); Level > 1; --Level)
-      CS = cast<CapturedStmt>(CS->getCapturedStmt());
-    return CS;
+    return Data->getInnermostCapturedStmt(CaptureRegions);
   }
 
   const CapturedStmt *getInnermostCapturedStmt() const {
     return const_cast<OMPExecutableDirective *>(this)
         ->getInnermostCapturedStmt();
   }
 
   OpenMPDirectiveKind getDirectiveKind() const { return Kind; }
 
   static bool classof(const Stmt *S) {
     return S->getStmtClass() >= firstOMPExecutableDirectiveConstant &&
            S->getStmtClass() <= lastOMPExecutableDirectiveConstant;
   }
 
   child_range children() {
-    if (!hasAssociatedStmt())
+    if (!Data)
       return child_range(child_iterator(), child_iterator());
-    Stmt **ChildStorage = reinterpret_cast<Stmt **>(getClauses().end());
-    /// Do not mark all the special expression/statements as children, except
-    /// for the associated statement.
-    return child_range(ChildStorage, ChildStorage + 1);
+    return Data->getAssociatedStmtAsRange();
   }
 
   const_child_range children() const {
-    if (!hasAssociatedStmt())
-      return const_child_range(const_child_iterator(), const_child_iterator());
-    Stmt **ChildStorage = reinterpret_cast<Stmt **>(
-        const_cast<OMPExecutableDirective *>(this)->getClauses().end());
-    return const_child_range(ChildStorage, ChildStorage + 1);
+    return const_cast<OMPExecutableDirective *>(this)->children();
   }
 
-  ArrayRef<OMPClause *> clauses() { return getClauses(); }
-
   ArrayRef<OMPClause *> clauses() const {
-    return const_cast<OMPExecutableDirective *>(this)->getClauses();
+    if (!Data)
+      return llvm::None;
+    return Data->getClauses();
   }
 
   /// Returns whether or not this is a Standalone directive.
   ///
   /// Stand-alone directives are executable directives
   /// that have no associated user code.
   bool isStandaloneDirective() const;
 
   /// Returns the AST node representing OpenMP structured-block of this
   /// OpenMP executable directive,
   /// Prerequisite: Executable Directive must not be Standalone directive.
-  const Stmt *getStructuredBlock() const;
+  const Stmt *getStructuredBlock() const {
+    return const_cast<OMPExecutableDirective *>(this)->getStructuredBlock();
+  }
+  Stmt *getStructuredBlock();
 
-  Stmt *getStructuredBlock() {
-    return const_cast<Stmt *>(
-        const_cast<const OMPExecutableDirective *>(this)->getStructuredBlock());
+  const Stmt *getRawStmt() const {
+    return const_cast<OMPExecutableDirective *>(this)->getRawStmt();
+  }
+  Stmt *getRawStmt() {
+    assert(hasAssociatedStmt() &&
+           "Expected directive with the associated statement.");
+    return Data->getRawStmt();
   }
 };
 
 /// 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'.
 ///
 class OMPParallelDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive (directive keyword).
   /// \param EndLoc Ending Location of the directive.
   ///
-  OMPParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                       unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPParallelDirectiveClass,
-                               llvm::omp::OMPD_parallel, StartLoc, EndLoc,
-                               NumClauses, 1),
-        HasCancel(false) {}
+  OMPParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPParallelDirectiveClass,
+                               llvm::omp::OMPD_parallel, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPParallelDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPParallelDirectiveClass,
+  explicit OMPParallelDirective()
+      : OMPExecutableDirective(OMPParallelDirectiveClass,
                                llvm::omp::OMPD_parallel, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        HasCancel(false) {}
+                               SourceLocation()) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) { Data->getChildren()[0] = E; }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPParallelDirective *CreateEmpty(const ASTContext &C,
                                            unsigned NumClauses, EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[0]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPParallelDirective *>(this)->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPParallelDirectiveClass;
   }
 };
 
 /// This is a common base class for loop directives ('omp simd', 'omp
 /// for', 'omp for simd' etc.). It is responsible for the loop code generation.
 ///
 class OMPLoopDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   /// Number of collapsed loops as specified by 'collapse' clause.
-  unsigned CollapsedNum;
+  unsigned CollapsedNum = 0;
 
   /// Offsets to the stored exprs.
   /// This enumeration contains offsets to all the pointers to children
   /// expressions stored in OMPLoopDirective.
   /// The first 9 children are necessary for all the loop directives,
   /// the next 8 are specific to the worksharing ones, and the next 11 are
   /// used for combined constructs containing two pragmas associated to loops.
   /// After the fixed children, three arrays of length CollapsedNum are
   /// allocated: loop counters, their updates and final values.
   /// PrevLowerBound and PrevUpperBound are used to communicate blocking
   /// information in composite constructs which require loop blocking
   /// DistInc is used to generate the increment expression for the distribute
   /// loop when combined with a further nested loop
   /// PrevEnsureUpperBound is used as the EnsureUpperBound expression for the
   /// for loop when combined with a previous distribute loop in the same pragma
   /// (e.g. 'distribute parallel for')
   ///
   enum {
-    AssociatedStmtOffset = 0,
-    IterationVariableOffset = 1,
-    LastIterationOffset = 2,
-    CalcLastIterationOffset = 3,
-    PreConditionOffset = 4,
-    CondOffset = 5,
-    InitOffset = 6,
-    IncOffset = 7,
-    PreInitsOffset = 8,
+    IterationVariableOffset = 0,
+    LastIterationOffset = 1,
+    CalcLastIterationOffset = 2,
+    PreConditionOffset = 3,
+    CondOffset = 4,
+    InitOffset = 5,
+    IncOffset = 6,
+    PreInitsOffset = 7,
     // The '...End' enumerators do not correspond to child expressions - they
     // specify the offset to the end (and start of the following counters/
     // updates/finals/dependent_counters/dependent_inits/finals_conditions
     // arrays).
-    DefaultEnd = 9,
+    DefaultEnd = 8,
     // The following 8 exprs are used by worksharing and distribute loops only.
-    IsLastIterVariableOffset = 9,
-    LowerBoundVariableOffset = 10,
-    UpperBoundVariableOffset = 11,
-    StrideVariableOffset = 12,
-    EnsureUpperBoundOffset = 13,
-    NextLowerBoundOffset = 14,
-    NextUpperBoundOffset = 15,
-    NumIterationsOffset = 16,
+    IsLastIterVariableOffset = 8,
+    LowerBoundVariableOffset = 9,
+    UpperBoundVariableOffset = 10,
+    StrideVariableOffset = 11,
+    EnsureUpperBoundOffset = 12,
+    NextLowerBoundOffset = 13,
+    NextUpperBoundOffset = 14,
+    NumIterationsOffset = 15,
     // Offset to the end for worksharing loop directives.
-    WorksharingEnd = 17,
-    PrevLowerBoundVariableOffset = 17,
-    PrevUpperBoundVariableOffset = 18,
-    DistIncOffset = 19,
-    PrevEnsureUpperBoundOffset = 20,
-    CombinedLowerBoundVariableOffset = 21,
-    CombinedUpperBoundVariableOffset = 22,
-    CombinedEnsureUpperBoundOffset = 23,
-    CombinedInitOffset = 24,
-    CombinedConditionOffset = 25,
-    CombinedNextLowerBoundOffset = 26,
-    CombinedNextUpperBoundOffset = 27,
-    CombinedDistConditionOffset = 28,
-    CombinedParForInDistConditionOffset = 29,
+    WorksharingEnd = 16,
+    PrevLowerBoundVariableOffset = 16,
+    PrevUpperBoundVariableOffset = 17,
+    DistIncOffset = 18,
+    PrevEnsureUpperBoundOffset = 19,
+    CombinedLowerBoundVariableOffset = 20,
+    CombinedUpperBoundVariableOffset = 21,
+    CombinedEnsureUpperBoundOffset = 22,
+    CombinedInitOffset = 23,
+    CombinedConditionOffset = 24,
+    CombinedNextLowerBoundOffset = 25,
+    CombinedNextUpperBoundOffset = 26,
+    CombinedDistConditionOffset = 27,
+    CombinedParForInDistConditionOffset = 28,
     // Offset to the end (and start of the following
     // counters/updates/finals/dependent_counters/dependent_inits/finals_conditions
     // arrays) for combined distribute loop directives.
-    CombinedDistributeEnd = 30,
+    CombinedDistributeEnd = 29,
   };
 
   /// Get the counters storage.
   MutableArrayRef<Expr *> getCounters() {
-    Expr **Storage = reinterpret_cast<Expr **>(
-        &(*(std::next(child_begin(), getArraysOffset(getDirectiveKind())))));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind())]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
   /// Get the private counters storage.
   MutableArrayRef<Expr *> getPrivateCounters() {
-    Expr **Storage = reinterpret_cast<Expr **>(&*std::next(
-        child_begin(), getArraysOffset(getDirectiveKind()) + CollapsedNum));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
+                             CollapsedNum]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
   /// Get the updates storage.
   MutableArrayRef<Expr *> getInits() {
-    Expr **Storage = reinterpret_cast<Expr **>(
-        &*std::next(child_begin(),
-                    getArraysOffset(getDirectiveKind()) + 2 * CollapsedNum));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
+                             2 * CollapsedNum]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
   /// Get the updates storage.
   MutableArrayRef<Expr *> getUpdates() {
-    Expr **Storage = reinterpret_cast<Expr **>(
-        &*std::next(child_begin(),
-                    getArraysOffset(getDirectiveKind()) + 3 * CollapsedNum));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
+                             3 * CollapsedNum]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
   /// Get the final counter updates storage.
   MutableArrayRef<Expr *> getFinals() {
-    Expr **Storage = reinterpret_cast<Expr **>(
-        &*std::next(child_begin(),
-                    getArraysOffset(getDirectiveKind()) + 4 * CollapsedNum));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
+                             4 * CollapsedNum]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
   /// Get the dependent counters storage.
   MutableArrayRef<Expr *> getDependentCounters() {
-    Expr **Storage = reinterpret_cast<Expr **>(
-        &*std::next(child_begin(),
-                    getArraysOffset(getDirectiveKind()) + 5 * CollapsedNum));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
+                             5 * CollapsedNum]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
   /// Get the dependent inits storage.
   MutableArrayRef<Expr *> getDependentInits() {
-    Expr **Storage = reinterpret_cast<Expr **>(
-        &*std::next(child_begin(),
-                    getArraysOffset(getDirectiveKind()) + 6 * CollapsedNum));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
+                             6 * CollapsedNum]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
   /// Get the finals conditions storage.
   MutableArrayRef<Expr *> getFinalsConditions() {
-    Expr **Storage = reinterpret_cast<Expr **>(
-        &*std::next(child_begin(),
-                    getArraysOffset(getDirectiveKind()) + 7 * CollapsedNum));
-    return MutableArrayRef<Expr *>(Storage, CollapsedNum);
+    auto **Storage = reinterpret_cast<Expr **>(
+        &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
+                             7 * CollapsedNum]);
+    return llvm::makeMutableArrayRef(Storage, CollapsedNum);
   }
 
 protected:
   /// Build instance of loop directive of class \a Kind.
   ///
   /// \param SC Statement class.
   /// \param Kind Kind of OpenMP directive.
   /// \param StartLoc Starting location of the directive (directive keyword).
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed loops from 'collapse' clause.
-  /// \param NumClauses Number of clauses.
-  /// \param NumSpecialChildren Number of additional directive-specific stmts.
   ///
-  template <typename T>
-  OMPLoopDirective(const T *That, StmtClass SC, OpenMPDirectiveKind Kind,
+  OMPLoopDirective(StmtClass SC, OpenMPDirectiveKind Kind,
                    SourceLocation StartLoc, SourceLocation EndLoc,
-                   unsigned CollapsedNum, unsigned NumClauses,
-                   unsigned NumSpecialChildren = 0)
-      : OMPExecutableDirective(That, SC, Kind, StartLoc, EndLoc, NumClauses,
-                               numLoopChildren(CollapsedNum, Kind) +
-                                   NumSpecialChildren),
+                   unsigned CollapsedNum)
+      : OMPExecutableDirective(SC, Kind, StartLoc, EndLoc),
         CollapsedNum(CollapsedNum) {}
 
   /// Offset to the start of children expression arrays.
   static unsigned getArraysOffset(OpenMPDirectiveKind Kind) {
     if (isOpenMPLoopBoundSharingDirective(Kind))
       return CombinedDistributeEnd;
     if (isOpenMPWorksharingDirective(Kind) || isOpenMPTaskLoopDirective(Kind) ||
         isOpenMPDistributeDirective(Kind))
       return WorksharingEnd;
     return DefaultEnd;
   }
 
   /// Children number.
   static unsigned numLoopChildren(unsigned CollapsedNum,
                                   OpenMPDirectiveKind Kind) {
     return getArraysOffset(Kind) +
            8 * CollapsedNum; // Counters, PrivateCounters, Inits,
                              // Updates, Finals, DependentCounters,
                              // DependentInits, FinalsConditions.
   }
 
   void setIterationVariable(Expr *IV) {
-    *std::next(child_begin(), IterationVariableOffset) = IV;
+    Data->getChildren()[IterationVariableOffset] = IV;
   }
   void setLastIteration(Expr *LI) {
-    *std::next(child_begin(), LastIterationOffset) = LI;
+    Data->getChildren()[LastIterationOffset] = LI;
   }
   void setCalcLastIteration(Expr *CLI) {
-    *std::next(child_begin(), CalcLastIterationOffset) = CLI;
-  }
-  void setPreCond(Expr *PC) {
-    *std::next(child_begin(), PreConditionOffset) = PC;
-  }
-  void setCond(Expr *Cond) {
-    *std::next(child_begin(), CondOffset) = Cond;
+    Data->getChildren()[CalcLastIterationOffset] = CLI;
   }
-  void setInit(Expr *Init) { *std::next(child_begin(), InitOffset) = Init; }
-  void setInc(Expr *Inc) { *std::next(child_begin(), IncOffset) = Inc; }
+  void setPreCond(Expr *PC) { Data->getChildren()[PreConditionOffset] = PC; }
+  void setCond(Expr *Cond) { Data->getChildren()[CondOffset] = Cond; }
+  void setInit(Expr *Init) { Data->getChildren()[InitOffset] = Init; }
+  void setInc(Expr *Inc) { Data->getChildren()[IncOffset] = Inc; }
   void setPreInits(Stmt *PreInits) {
-    *std::next(child_begin(), PreInitsOffset) = PreInits;
+    Data->getChildren()[PreInitsOffset] = PreInits;
   }
   void setIsLastIterVariable(Expr *IL) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), IsLastIterVariableOffset) = IL;
+    Data->getChildren()[IsLastIterVariableOffset] = IL;
   }
   void setLowerBoundVariable(Expr *LB) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), LowerBoundVariableOffset) = LB;
+    Data->getChildren()[LowerBoundVariableOffset] = LB;
   }
   void setUpperBoundVariable(Expr *UB) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), UpperBoundVariableOffset) = UB;
+    Data->getChildren()[UpperBoundVariableOffset] = UB;
   }
   void setStrideVariable(Expr *ST) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), StrideVariableOffset) = ST;
+    Data->getChildren()[StrideVariableOffset] = ST;
   }
   void setEnsureUpperBound(Expr *EUB) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), EnsureUpperBoundOffset) = EUB;
+    Data->getChildren()[EnsureUpperBoundOffset] = EUB;
   }
   void setNextLowerBound(Expr *NLB) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), NextLowerBoundOffset) = NLB;
+    Data->getChildren()[NextLowerBoundOffset] = NLB;
   }
   void setNextUpperBound(Expr *NUB) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), NextUpperBoundOffset) = NUB;
+    Data->getChildren()[NextUpperBoundOffset] = NUB;
   }
   void setNumIterations(Expr *NI) {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    *std::next(child_begin(), NumIterationsOffset) = NI;
+    Data->getChildren()[NumIterationsOffset] = NI;
   }
   void setPrevLowerBoundVariable(Expr *PrevLB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), PrevLowerBoundVariableOffset) = PrevLB;
+    Data->getChildren()[PrevLowerBoundVariableOffset] = PrevLB;
   }
   void setPrevUpperBoundVariable(Expr *PrevUB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), PrevUpperBoundVariableOffset) = PrevUB;
+    Data->getChildren()[PrevUpperBoundVariableOffset] = PrevUB;
   }
   void setDistInc(Expr *DistInc) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), DistIncOffset) = DistInc;
+    Data->getChildren()[DistIncOffset] = DistInc;
   }
   void setPrevEnsureUpperBound(Expr *PrevEUB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), PrevEnsureUpperBoundOffset) = PrevEUB;
+    Data->getChildren()[PrevEnsureUpperBoundOffset] = PrevEUB;
   }
   void setCombinedLowerBoundVariable(Expr *CombLB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), CombinedLowerBoundVariableOffset) = CombLB;
+    Data->getChildren()[CombinedLowerBoundVariableOffset] = CombLB;
   }
   void setCombinedUpperBoundVariable(Expr *CombUB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), CombinedUpperBoundVariableOffset) = CombUB;
+    Data->getChildren()[CombinedUpperBoundVariableOffset] = CombUB;
   }
   void setCombinedEnsureUpperBound(Expr *CombEUB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), CombinedEnsureUpperBoundOffset) = CombEUB;
+    Data->getChildren()[CombinedEnsureUpperBoundOffset] = CombEUB;
   }
   void setCombinedInit(Expr *CombInit) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), CombinedInitOffset) = CombInit;
+    Data->getChildren()[CombinedInitOffset] = CombInit;
   }
   void setCombinedCond(Expr *CombCond) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), CombinedConditionOffset) = CombCond;
+    Data->getChildren()[CombinedConditionOffset] = CombCond;
   }
   void setCombinedNextLowerBound(Expr *CombNLB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), CombinedNextLowerBoundOffset) = CombNLB;
+    Data->getChildren()[CombinedNextLowerBoundOffset] = CombNLB;
   }
   void setCombinedNextUpperBound(Expr *CombNUB) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    *std::next(child_begin(), CombinedNextUpperBoundOffset) = CombNUB;
+    Data->getChildren()[CombinedNextUpperBoundOffset] = CombNUB;
   }
   void setCombinedDistCond(Expr *CombDistCond) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound distribute sharing directive");
-    *std::next(child_begin(), CombinedDistConditionOffset) = CombDistCond;
+    Data->getChildren()[CombinedDistConditionOffset] = CombDistCond;
   }
   void setCombinedParForInDistCond(Expr *CombParForInDistCond) {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound distribute sharing directive");
-    *std::next(child_begin(),
-               CombinedParForInDistConditionOffset) = CombParForInDistCond;
+    Data->getChildren()[CombinedParForInDistConditionOffset] =
+        CombParForInDistCond;
   }
   void setCounters(ArrayRef<Expr *> A);
   void setPrivateCounters(ArrayRef<Expr *> A);
   void setInits(ArrayRef<Expr *> A);
   void setUpdates(ArrayRef<Expr *> A);
   void setFinals(ArrayRef<Expr *> A);
   void setDependentCounters(ArrayRef<Expr *> A);
   void setDependentInits(ArrayRef<Expr *> A);
void clear(unsigned Size) {
       DistCombinedFields.ParForInDistCond = nullptr;
     }
   };
 
   /// Get number of collapsed loops.
   unsigned getCollapsedNumber() const { return CollapsedNum; }
 
   Expr *getIterationVariable() const {
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), IterationVariableOffset)));
+    return cast<Expr>(Data->getChildren()[IterationVariableOffset]);
   }
   Expr *getLastIteration() const {
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), LastIterationOffset)));
+    return cast<Expr>(Data->getChildren()[LastIterationOffset]);
   }
   Expr *getCalcLastIteration() const {
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CalcLastIterationOffset)));
+    return cast<Expr>(Data->getChildren()[CalcLastIterationOffset]);
   }
   Expr *getPreCond() const {
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), PreConditionOffset)));
-  }
-  Expr *getCond() const {
-    return const_cast<Expr *>(
-        reinterpret_cast<const Expr *>(*std::next(child_begin(), CondOffset)));
-  }
-  Expr *getInit() const {
-    return const_cast<Expr *>(
-        reinterpret_cast<const Expr *>(*std::next(child_begin(), InitOffset)));
-  }
-  Expr *getInc() const {
-    return const_cast<Expr *>(
-        reinterpret_cast<const Expr *>(*std::next(child_begin(), IncOffset)));
+    return cast<Expr>(Data->getChildren()[PreConditionOffset]);
   }
+  Expr *getCond() const { return cast<Expr>(Data->getChildren()[CondOffset]); }
+  Expr *getInit() const { return cast<Expr>(Data->getChildren()[InitOffset]); }
+  Expr *getInc() const { return cast<Expr>(Data->getChildren()[IncOffset]); }
   const Stmt *getPreInits() const {
-    return *std::next(child_begin(), PreInitsOffset);
+    return Data->getChildren()[PreInitsOffset];
   }
-  Stmt *getPreInits() { return *std::next(child_begin(), PreInitsOffset); }
+  Stmt *getPreInits() { return Data->getChildren()[PreInitsOffset]; }
   Expr *getIsLastIterVariable() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), IsLastIterVariableOffset)));
+    return cast<Expr>(Data->getChildren()[IsLastIterVariableOffset]);
   }
   Expr *getLowerBoundVariable() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), LowerBoundVariableOffset)));
+    return cast<Expr>(Data->getChildren()[LowerBoundVariableOffset]);
   }
   Expr *getUpperBoundVariable() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), UpperBoundVariableOffset)));
+    return cast<Expr>(Data->getChildren()[UpperBoundVariableOffset]);
   }
   Expr *getStrideVariable() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), StrideVariableOffset)));
+    return cast<Expr>(Data->getChildren()[StrideVariableOffset]);
   }
   Expr *getEnsureUpperBound() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), EnsureUpperBoundOffset)));
+    return cast<Expr>(Data->getChildren()[EnsureUpperBoundOffset]);
   }
   Expr *getNextLowerBound() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), NextLowerBoundOffset)));
+    return cast<Expr>(Data->getChildren()[NextLowerBoundOffset]);
   }
   Expr *getNextUpperBound() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), NextUpperBoundOffset)));
+    return cast<Expr>(Data->getChildren()[NextUpperBoundOffset]);
   }
   Expr *getNumIterations() const {
     assert((isOpenMPWorksharingDirective(getDirectiveKind()) ||
             isOpenMPTaskLoopDirective(getDirectiveKind()) ||
             isOpenMPDistributeDirective(getDirectiveKind())) &&
            "expected worksharing loop directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), NumIterationsOffset)));
+    return cast<Expr>(Data->getChildren()[NumIterationsOffset]);
   }
   Expr *getPrevLowerBoundVariable() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), PrevLowerBoundVariableOffset)));
+    return cast<Expr>(Data->getChildren()[PrevLowerBoundVariableOffset]);
   }
   Expr *getPrevUpperBoundVariable() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), PrevUpperBoundVariableOffset)));
+    return cast<Expr>(Data->getChildren()[PrevUpperBoundVariableOffset]);
   }
   Expr *getDistInc() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), DistIncOffset)));
+    return cast<Expr>(Data->getChildren()[DistIncOffset]);
   }
   Expr *getPrevEnsureUpperBound() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), PrevEnsureUpperBoundOffset)));
+    return cast<Expr>(Data->getChildren()[PrevEnsureUpperBoundOffset]);
   }
   Expr *getCombinedLowerBoundVariable() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedLowerBoundVariableOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedLowerBoundVariableOffset]);
   }
   Expr *getCombinedUpperBoundVariable() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedUpperBoundVariableOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedUpperBoundVariableOffset]);
   }
   Expr *getCombinedEnsureUpperBound() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedEnsureUpperBoundOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedEnsureUpperBoundOffset]);
   }
   Expr *getCombinedInit() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedInitOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedInitOffset]);
   }
   Expr *getCombinedCond() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedConditionOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedConditionOffset]);
   }
   Expr *getCombinedNextLowerBound() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedNextLowerBoundOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedNextLowerBoundOffset]);
   }
   Expr *getCombinedNextUpperBound() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedNextUpperBoundOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedNextUpperBoundOffset]);
   }
   Expr *getCombinedDistCond() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound distribute sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedDistConditionOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedDistConditionOffset]);
   }
   Expr *getCombinedParForInDistCond() const {
     assert(isOpenMPLoopBoundSharingDirective(getDirectiveKind()) &&
            "expected loop bound distribute sharing directive");
-    return const_cast<Expr *>(reinterpret_cast<const Expr *>(
-        *std::next(child_begin(), CombinedParForInDistConditionOffset)));
+    return cast<Expr>(Data->getChildren()[CombinedParForInDistConditionOffset]);
   }
   /// Try to find the next loop sub-statement in the specified statement \p
   /// CurStmt.
   /// \param TryImperfectlyNestedLoops true, if we need to try to look for the
   /// imperfectly nested loop.
   static Stmt *tryToFindNextInnerLoop(Stmt *CurStmt,
                                       bool TryImperfectlyNestedLoops);
   static const Stmt *tryToFindNextInnerLoop(const Stmt *CurStmt,

 /// #pragma omp simd private(a,b) linear(i,j:s) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp simd' has clauses 'private'
 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
 ///
 class OMPSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                   unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPSimdDirectiveClass, llvm::omp::OMPD_simd,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses) {}
+                   unsigned CollapsedNum)
+      : OMPLoopDirective(OMPSimdDirectiveClass, llvm::omp::OMPD_simd, StartLoc,
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPSimdDirectiveClass, llvm::omp::OMPD_simd,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+  explicit OMPSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPSimdDirectiveClass, llvm::omp::OMPD_simd,
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp for private(a,b) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp for' has clauses 'private' with the
 /// variables 'a' and 'b' and 'reduction' with operator '+' and variables 'c'
 /// and 'd'.
 ///
 class OMPForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
+  friend class OMPExecutableDirective;
   /// true if current directive has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                  unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPForDirectiveClass, llvm::omp::OMPD_for,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                  unsigned CollapsedNum)
+      : OMPLoopDirective(OMPForDirectiveClass, llvm::omp::OMPD_for, StartLoc,
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPForDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPForDirectiveClass, llvm::omp::OMPD_for,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+  explicit OMPForDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPForDirectiveClass, llvm::omp::OMPD_for,
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) {
+    Data->getChildren()[numLoopChildren(getCollapsedNumber(),
+                                        llvm::omp::OMPD_for)] = E;
+  }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   /// \param C AST context.
   /// \param CollapsedNum Number of collapsed nested loops.
   /// \param NumClauses Number of clauses.
   ///
   static OMPForDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                       unsigned CollapsedNum, EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_for)]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPForDirective *>(this)->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPForDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp for simd' directive.
 ///
 /// \code
 /// #pragma omp for simd private(a,b) linear(i,j:s) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp for simd' has clauses 'private'
 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
 ///
 class OMPForSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPForSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                      unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPForSimdDirectiveClass,
-                         llvm::omp::OMPD_for_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                      unsigned CollapsedNum)
+      : OMPLoopDirective(OMPForSimdDirectiveClass, llvm::omp::OMPD_for_simd,
+                         StartLoc, EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPForSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPForSimdDirectiveClass,
-                         llvm::omp::OMPD_for_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+  explicit OMPForSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPForSimdDirectiveClass, llvm::omp::OMPD_for_simd,
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp sections private(a,b) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp sections' has clauses 'private' with
 /// the variables 'a' and 'b' and 'reduction' with operator '+' and variables
 /// 'c' and 'd'.
 ///
 class OMPSectionsDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
   /// true if current directive has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                       unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPSectionsDirectiveClass,
-                               llvm::omp::OMPD_sections, StartLoc, EndLoc,
-                               NumClauses, 1),
-        HasCancel(false) {}
+  OMPSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPSectionsDirectiveClass,
+                               llvm::omp::OMPD_sections, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPSectionsDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPSectionsDirectiveClass,
+  explicit OMPSectionsDirective()
+      : OMPExecutableDirective(OMPSectionsDirectiveClass,
                                llvm::omp::OMPD_sections, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        HasCancel(false) {}
+                               SourceLocation()) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) { Data->getChildren()[0] = E; }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPSectionsDirective *CreateEmpty(const ASTContext &C,
                                            unsigned NumClauses, EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[0]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPSectionsDirective *>(this)->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPSectionsDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp section' directive.
 ///
 /// \code
 /// #pragma omp section
 /// \endcode
 ///
 class OMPSectionDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// true if current directive has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   ///
   OMPSectionDirective(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPExecutableDirective(this, OMPSectionDirectiveClass,
-                               llvm::omp::OMPD_section, StartLoc, EndLoc, 0, 1),
-        HasCancel(false) {}
+      : OMPExecutableDirective(OMPSectionDirectiveClass,
+                               llvm::omp::OMPD_section, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPSectionDirective()
-      : OMPExecutableDirective(this, OMPSectionDirectiveClass,
+      : OMPExecutableDirective(OMPSectionDirectiveClass,
                                llvm::omp::OMPD_section, SourceLocation(),
-                               SourceLocation(), 0, 1),
-        HasCancel(false) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param AssociatedStmt Statement, associated with the directive.

 /// \code
 /// #pragma omp single private(a,b) copyprivate(c,d)
 /// \endcode
 /// In this example directive '#pragma omp single' has clauses 'private' with
 /// the variables 'a' and 'b' and 'copyprivate' with variables 'c' and 'd'.
 ///
 class OMPSingleDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPSingleDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPSingleDirectiveClass,
-                               llvm::omp::OMPD_single, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+  OMPSingleDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPSingleDirectiveClass, llvm::omp::OMPD_single,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPSingleDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPSingleDirectiveClass,
-                               llvm::omp::OMPD_single, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+  explicit OMPSingleDirective()
+      : OMPExecutableDirective(OMPSingleDirectiveClass, llvm::omp::OMPD_single,
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// This represents '#pragma omp master' directive.
 ///
 /// \code
 /// #pragma omp master
 /// \endcode
 ///
 class OMPMasterDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   ///
   OMPMasterDirective(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPExecutableDirective(this, OMPMasterDirectiveClass,
-                               llvm::omp::OMPD_master, StartLoc, EndLoc, 0, 1) {
-  }
+      : OMPExecutableDirective(OMPMasterDirectiveClass, llvm::omp::OMPD_master,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPMasterDirective()
-      : OMPExecutableDirective(this, OMPMasterDirectiveClass,
-                               llvm::omp::OMPD_master, SourceLocation(),
-                               SourceLocation(), 0, 1) {}
+      : OMPExecutableDirective(OMPMasterDirectiveClass, llvm::omp::OMPD_master,
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param AssociatedStmt Statement, associated with the directive.

 /// This represents '#pragma omp critical' directive.
 ///
 /// \code
 /// #pragma omp critical
 /// \endcode
 ///
 class OMPCriticalDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Name of the directive.
   DeclarationNameInfo DirName;
   /// Build directive with the given start and end location.
   ///
   /// \param Name Name of the directive.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
   OMPCriticalDirective(const DeclarationNameInfo &Name, SourceLocation StartLoc,
-                       SourceLocation EndLoc, unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPCriticalDirectiveClass,
-                               llvm::omp::OMPD_critical, StartLoc, EndLoc,
-                               NumClauses, 1),
+                       SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPCriticalDirectiveClass,
+                               llvm::omp::OMPD_critical, StartLoc, EndLoc),
         DirName(Name) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPCriticalDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPCriticalDirectiveClass,
+  explicit OMPCriticalDirective()
+      : OMPExecutableDirective(OMPCriticalDirectiveClass,
                                llvm::omp::OMPD_critical, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        DirName() {}
+                               SourceLocation()) {}
 
   /// Set name of the directive.
   ///
   /// \param Name Name of the directive.
   ///
   void setDirectiveName(const DeclarationNameInfo &Name) { DirName = Name; }
 
 public:

 /// #pragma omp parallel for private(a,b) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp parallel for' has clauses 'private'
 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
 /// variables 'c' and 'd'.
 ///
 class OMPParallelForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
   /// true if current region has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPParallelForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                          unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelForDirectiveClass,
+                          unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelForDirectiveClass,
                          llvm::omp::OMPD_parallel_for, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPParallelForDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelForDirectiveClass,
+  explicit OMPParallelForDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelForDirectiveClass,
                          llvm::omp::OMPD_parallel_for, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), CollapsedNum) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) {
+    Data->getChildren()[numLoopChildren(getCollapsedNumber(),
+                                        llvm::omp::OMPD_parallel_for)] = E;
+  }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   /// \param NumClauses Number of clauses.
   ///
   static OMPParallelForDirective *CreateEmpty(const ASTContext &C,
                                               unsigned NumClauses,
                                               unsigned CollapsedNum,
                                               EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_parallel_for)]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPParallelForDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPParallelForDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp parallel for simd' directive.
 ///
 /// \code
 /// #pragma omp parallel for simd private(a,b) linear(i,j:s) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp parallel for simd' has clauses
 /// 'private' with the variables 'a' and 'b', 'linear' with variables 'i', 'j'
 /// and linear step 's', 'reduction' with operator '+' and variables 'c' and
 /// 'd'.
 ///
 class OMPParallelForSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPParallelForSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                              unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
+                              unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_for_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPParallelForSimdDirective(unsigned CollapsedNum,
-                                       unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
+  explicit OMPParallelForSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_for_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// \code
 /// #pragma omp parallel master private(a,b)
 /// \endcode
 /// In this example directive '#pragma omp parallel master' has clauses
 /// 'private' with the variables 'a' and 'b'
 ///
 class OMPParallelMasterDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
-
-  OMPParallelMasterDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPParallelMasterDirectiveClass,
+  OMPParallelMasterDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPParallelMasterDirectiveClass,
                                llvm::omp::OMPD_parallel_master, StartLoc,
-                               EndLoc, NumClauses, 1) {}
+                               EndLoc) {}
 
-  explicit OMPParallelMasterDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPParallelMasterDirectiveClass,
+  explicit OMPParallelMasterDirective()
+      : OMPExecutableDirective(OMPParallelMasterDirectiveClass,
                                llvm::omp::OMPD_parallel_master,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               1) {}
+                               SourceLocation(), SourceLocation()) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) { Data->getChildren()[0] = E; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.
public:
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPParallelMasterDirective *
   CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[0]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPParallelMasterDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPParallelMasterDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp parallel sections' directive.
 ///
 /// \code
 /// #pragma omp parallel sections private(a,b) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp parallel sections' has clauses
 /// 'private' with the variables 'a' and 'b' and 'reduction' with operator '+'
 /// and variables 'c' and 'd'.
 ///
 class OMPParallelSectionsDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
   /// true if current directive has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPParallelSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                               unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
+  OMPParallelSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPParallelSectionsDirectiveClass,
                                llvm::omp::OMPD_parallel_sections, StartLoc,
-                               EndLoc, NumClauses, 1),
-        HasCancel(false) {}
+                               EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPParallelSectionsDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
+  explicit OMPParallelSectionsDirective()
+      : OMPExecutableDirective(OMPParallelSectionsDirectiveClass,
                                llvm::omp::OMPD_parallel_sections,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               1),
-        HasCancel(false) {}
+                               SourceLocation(), SourceLocation()) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) { Data->getChildren()[0] = E; }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPParallelSectionsDirective *
   CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[0]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPParallelSectionsDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPParallelSectionsDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp task' directive.
 ///
 /// \code
 /// #pragma omp task private(a,b) final(d)
 /// \endcode
 /// In this example directive '#pragma omp task' has clauses 'private' with the
 /// variables 'a' and 'b' and 'final' with condition 'd'.
 ///
 class OMPTaskDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// true if this directive has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPTaskDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                   unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTaskDirectiveClass,
-                               llvm::omp::OMPD_task, StartLoc, EndLoc,
-                               NumClauses, 1),
-        HasCancel(false) {}
+  OMPTaskDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTaskDirectiveClass, llvm::omp::OMPD_task,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTaskDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTaskDirectiveClass,
-                               llvm::omp::OMPD_task, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        HasCancel(false) {}
+  explicit OMPTaskDirective()
+      : OMPExecutableDirective(OMPTaskDirectiveClass, llvm::omp::OMPD_task,
+                               SourceLocation(), SourceLocation()) {}
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.

 /// This represents '#pragma omp taskyield' directive.
 ///
 /// \code
 /// #pragma omp taskyield
 /// \endcode
 ///
 class OMPTaskyieldDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   ///
   OMPTaskyieldDirective(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPExecutableDirective(this, OMPTaskyieldDirectiveClass,
-                               llvm::omp::OMPD_taskyield, StartLoc, EndLoc, 0,
-                               0) {}
+      : OMPExecutableDirective(OMPTaskyieldDirectiveClass,
+                               llvm::omp::OMPD_taskyield, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPTaskyieldDirective()
-      : OMPExecutableDirective(this, OMPTaskyieldDirectiveClass,
+      : OMPExecutableDirective(OMPTaskyieldDirectiveClass,
                                llvm::omp::OMPD_taskyield, SourceLocation(),
-                               SourceLocation(), 0, 0) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   ///

 /// This represents '#pragma omp barrier' directive.
 ///
 /// \code
 /// #pragma omp barrier
 /// \endcode
 ///
 class OMPBarrierDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   ///
   OMPBarrierDirective(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPExecutableDirective(this, OMPBarrierDirectiveClass,
-                               llvm::omp::OMPD_barrier, StartLoc, EndLoc, 0,
-                               0) {}
+      : OMPExecutableDirective(OMPBarrierDirectiveClass,
+                               llvm::omp::OMPD_barrier, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPBarrierDirective()
-      : OMPExecutableDirective(this, OMPBarrierDirectiveClass,
+      : OMPExecutableDirective(OMPBarrierDirectiveClass,
                                llvm::omp::OMPD_barrier, SourceLocation(),
-                               SourceLocation(), 0, 0) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   ///

 /// This represents '#pragma omp taskwait' directive.
 ///
 /// \code
 /// #pragma omp taskwait
 /// \endcode
 ///
 class OMPTaskwaitDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   ///
   OMPTaskwaitDirective(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass,
-                               llvm::omp::OMPD_taskwait, StartLoc, EndLoc, 0,
-                               0) {}
+      : OMPExecutableDirective(OMPTaskwaitDirectiveClass,
+                               llvm::omp::OMPD_taskwait, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPTaskwaitDirective()
-      : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass,
+      : OMPExecutableDirective(OMPTaskwaitDirectiveClass,
                                llvm::omp::OMPD_taskwait, SourceLocation(),
-                               SourceLocation(), 0, 0) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   ///

 /// This represents '#pragma omp taskgroup' directive.
 ///
 /// \code
 /// #pragma omp taskgroup
 /// \endcode
 ///
 class OMPTaskgroupDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPTaskgroupDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                        unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass,
-                               llvm::omp::OMPD_taskgroup, StartLoc, EndLoc,
-                               NumClauses, 2) {}
+  OMPTaskgroupDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTaskgroupDirectiveClass,
+                               llvm::omp::OMPD_taskgroup, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTaskgroupDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass,
+  explicit OMPTaskgroupDirective()
+      : OMPExecutableDirective(OMPTaskgroupDirectiveClass,
                                llvm::omp::OMPD_taskgroup, SourceLocation(),
-                               SourceLocation(), NumClauses, 2) {}
+                               SourceLocation()) {}
 
   /// Sets the task_reduction return variable.
-  void setReductionRef(Expr *RR) {
-    *std::next(child_begin(), 1) = RR;
-  }
+  void setReductionRef(Expr *RR) { Data->getChildren()[0] = RR; }
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.
public:
   /// \param NumClauses Number of clauses.
   ///
   static OMPTaskgroupDirective *CreateEmpty(const ASTContext &C,
                                             unsigned NumClauses, EmptyShell);
 
 
   /// Returns reference to the task_reduction return variable.
   const Expr *getReductionRef() const {
-    return static_cast<const Expr *>(*std::next(child_begin(), 1));
-  }
-  Expr *getReductionRef() {
-    return static_cast<Expr *>(*std::next(child_begin(), 1));
+    return const_cast<OMPTaskgroupDirective *>(this)->getReductionRef();
   }
+  Expr *getReductionRef() { return cast_or_null<Expr>(Data->getChildren()[0]); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPTaskgroupDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp flush' directive.
 ///
 /// \code
 /// #pragma omp flush(a,b)
 /// \endcode
 /// In this example directive '#pragma omp flush' has 2 arguments- variables 'a'
 /// and 'b'.
 /// 'omp flush' directive does not have clauses but have an optional list of
 /// variables to flush. This list of variables is stored within some fake clause
 /// FlushClause.
 class OMPFlushDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPFlushDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                    unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPFlushDirectiveClass,
-                               llvm::omp::OMPD_flush, StartLoc, EndLoc,
-                               NumClauses, 0) {}
+  OMPFlushDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPFlushDirectiveClass, llvm::omp::OMPD_flush,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPFlushDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPFlushDirectiveClass,
-                               llvm::omp::OMPD_flush, SourceLocation(),
-                               SourceLocation(), NumClauses, 0) {}
+  explicit OMPFlushDirective()
+      : OMPExecutableDirective(OMPFlushDirectiveClass, llvm::omp::OMPD_flush,
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses (only single OMPFlushClause clause is

 ///
 /// \code
 /// #pragma omp depobj(a) depend(in:x,y)
 /// \endcode
 /// In this example directive '#pragma omp  depobj' initializes a depobj object
 /// 'a' with dependence type 'in' and a list with 'x' and 'y' locators.
 class OMPDepobjDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPDepobjDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPDepobjDirectiveClass,
-                               llvm::omp::OMPD_depobj, StartLoc, EndLoc,
-                               NumClauses, 0) {}
+  OMPDepobjDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPDepobjDirectiveClass, llvm::omp::OMPD_depobj,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPDepobjDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPDepobjDirectiveClass,
-                               llvm::omp::OMPD_depobj, SourceLocation(),
-                               SourceLocation(), NumClauses, 0) {}
+  explicit OMPDepobjDirective()
+      : OMPExecutableDirective(OMPDepobjDirectiveClass, llvm::omp::OMPD_depobj,
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// This represents '#pragma omp ordered' directive.
 ///
 /// \code
 /// #pragma omp ordered
 /// \endcode
 ///
 class OMPOrderedDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPOrderedDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                      unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPOrderedDirectiveClass,
-                               llvm::omp::OMPD_ordered, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+  OMPOrderedDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPOrderedDirectiveClass,
+                               llvm::omp::OMPD_ordered, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPOrderedDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPOrderedDirectiveClass,
+  explicit OMPOrderedDirective()
+      : OMPExecutableDirective(OMPOrderedDirectiveClass,
                                llvm::omp::OMPD_ordered, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.
   /// \param AssociatedStmt Statement, associated with the directive.
   ///
   static OMPOrderedDirective *
   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
 
   /// Creates an empty directive.
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
+  /// \param IsStandalone true, if the the standalone directive is created.
   ///
   static OMPOrderedDirective *CreateEmpty(const ASTContext &C,
-                                          unsigned NumClauses, EmptyShell);
+                                          unsigned NumClauses,
+                                          bool IsStandalone, EmptyShell);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPOrderedDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp atomic' directive.
 ///
 /// \code
 /// #pragma omp atomic capture
 /// \endcode
 /// In this example directive '#pragma omp atomic' has clause 'capture'.
 ///
 class OMPAtomicDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Used for 'atomic update' or 'atomic capture' constructs. They may
   /// have atomic expressions of forms
   /// \code
   /// x = x binop expr;
   /// x = expr binop x;
   /// \endcode
   /// This field is true for the first form of the expression and false for the
   /// second. Required for correct codegen of non-associative operations (like
   /// << or >>).
-  bool IsXLHSInRHSPart;
+  bool IsXLHSInRHSPart = false;
   /// Used for 'atomic update' or 'atomic capture' constructs. They may
   /// have atomic expressions of forms
   /// \code
   /// v = x; <update x>;
   /// <update x>; v = x;
   /// \endcode
   /// This field is true for the first(postfix) form of the expression and false
   /// otherwise.
-  bool IsPostfixUpdate;
+  bool IsPostfixUpdate = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPAtomicDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPAtomicDirectiveClass,
-                               llvm::omp::OMPD_atomic, StartLoc, EndLoc,
-                               NumClauses, 5),
-        IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
+  OMPAtomicDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPAtomicDirectiveClass, llvm::omp::OMPD_atomic,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPAtomicDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPAtomicDirectiveClass,
-                               llvm::omp::OMPD_atomic, SourceLocation(),
-                               SourceLocation(), NumClauses, 5),
-        IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
+  explicit OMPAtomicDirective()
+      : OMPExecutableDirective(OMPAtomicDirectiveClass, llvm::omp::OMPD_atomic,
+                               SourceLocation(), SourceLocation()) {}
 
   /// Set 'x' part of the associated expression/statement.
-  void setX(Expr *X) { *std::next(child_begin()) = X; }
+  void setX(Expr *X) { Data->getChildren()[0] = X; }
   /// Set helper expression of the form
   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
-  void setUpdateExpr(Expr *UE) { *std::next(child_begin(), 2) = UE; }
+  void setUpdateExpr(Expr *UE) { Data->getChildren()[1] = UE; }
   /// Set 'v' part of the associated expression/statement.
-  void setV(Expr *V) { *std::next(child_begin(), 3) = V; }
+  void setV(Expr *V) { Data->getChildren()[2] = V; }
   /// Set 'expr' part of the associated expression/statement.
-  void setExpr(Expr *E) { *std::next(child_begin(), 4) = E; }
+  void setExpr(Expr *E) { Data->getChildren()[3] = E; }
 
 public:
   /// Creates directive with a list of \a Clauses and 'x', 'v' and 'expr'
   /// parts of the atomic construct (see Section 2.12.6, atomic Construct, for
   /// detailed description of 'x', 'v' and 'expr').
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
public:
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPAtomicDirective *CreateEmpty(const ASTContext &C,
                                          unsigned NumClauses, EmptyShell);
 
   /// Get 'x' part of the associated expression/statement.
-  Expr *getX() { return cast_or_null<Expr>(*std::next(child_begin())); }
+  Expr *getX() { return cast_or_null<Expr>(Data->getChildren()[0]); }
   const Expr *getX() const {
-    return cast_or_null<Expr>(*std::next(child_begin()));
+    return cast_or_null<Expr>(Data->getChildren()[0]);
   }
   /// Get helper expression of the form
   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
-  Expr *getUpdateExpr() {
-    return cast_or_null<Expr>(*std::next(child_begin(), 2));
-  }
+  Expr *getUpdateExpr() { return cast_or_null<Expr>(Data->getChildren()[1]); }
   const Expr *getUpdateExpr() const {
-    return cast_or_null<Expr>(*std::next(child_begin(), 2));
+    return cast_or_null<Expr>(Data->getChildren()[1]);
   }
   /// Return true if helper update expression has form
   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' and false if it has form
   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
   bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
   /// Return true if 'v' expression must be updated to original value of
   /// 'x', false if 'v' must be updated to the new value of 'x'.
   bool isPostfixUpdate() const { return IsPostfixUpdate; }
   /// Get 'v' part of the associated expression/statement.
-  Expr *getV() { return cast_or_null<Expr>(*std::next(child_begin(), 3)); }
+  Expr *getV() { return cast_or_null<Expr>(Data->getChildren()[2]); }
   const Expr *getV() const {
-    return cast_or_null<Expr>(*std::next(child_begin(), 3));
+    return cast_or_null<Expr>(Data->getChildren()[2]);
   }
   /// Get 'expr' part of the associated expression/statement.
-  Expr *getExpr() { return cast_or_null<Expr>(*std::next(child_begin(), 4)); }
+  Expr *getExpr() { return cast_or_null<Expr>(Data->getChildren()[3]); }
   const Expr *getExpr() const {
-    return cast_or_null<Expr>(*std::next(child_begin(), 4));
+    return cast_or_null<Expr>(Data->getChildren()[3]);
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPAtomicDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp target' directive.
 ///
 /// \code
 /// #pragma omp target if(a)
 /// \endcode
 /// In this example directive '#pragma omp target' has clause 'if' with
 /// condition 'a'.
 ///
 class OMPTargetDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPTargetDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetDirectiveClass,
-                               llvm::omp::OMPD_target, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+  OMPTargetDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTargetDirectiveClass, llvm::omp::OMPD_target,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetDirectiveClass,
-                               llvm::omp::OMPD_target, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+  explicit OMPTargetDirective()
+      : OMPExecutableDirective(OMPTargetDirectiveClass, llvm::omp::OMPD_target,
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// #pragma omp target data device(0) if(a) map(b[:])
 /// \endcode
 /// In this example directive '#pragma omp target data' has clauses 'device'
 /// with the value '0', 'if' with condition 'a' and 'map' with array
 /// section 'b[:]'.
 ///
 class OMPTargetDataDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
-  /// \param NumClauses The number of clauses.
   ///
-  OMPTargetDataDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                         unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetDataDirectiveClass,
-                               llvm::omp::OMPD_target_data, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+  OMPTargetDataDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTargetDataDirectiveClass,
+                               llvm::omp::OMPD_target_data, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetDataDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetDataDirectiveClass,
+  explicit OMPTargetDataDirective()
+      : OMPExecutableDirective(OMPTargetDataDirectiveClass,
                                llvm::omp::OMPD_target_data, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// #pragma omp target enter data device(0) if(a) map(b[:])
 /// \endcode
 /// In this example directive '#pragma omp target enter data' has clauses
 /// 'device' with the value '0', 'if' with condition 'a' and 'map' with array
 /// section 'b[:]'.
 ///
 class OMPTargetEnterDataDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
-  /// \param NumClauses The number of clauses.
   ///
-  OMPTargetEnterDataDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                              unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetEnterDataDirectiveClass,
+  OMPTargetEnterDataDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTargetEnterDataDirectiveClass,
                                llvm::omp::OMPD_target_enter_data, StartLoc,
-                               EndLoc, NumClauses, /*NumChildren=*/1) {}
+                               EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetEnterDataDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetEnterDataDirectiveClass,
+  explicit OMPTargetEnterDataDirective()
+      : OMPExecutableDirective(OMPTargetEnterDataDirectiveClass,
                                llvm::omp::OMPD_target_enter_data,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               /*NumChildren=*/1) {}
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// #pragma omp target exit data device(0) if(a) map(b[:])
 /// \endcode
 /// In this example directive '#pragma omp target exit data' has clauses
 /// 'device' with the value '0', 'if' with condition 'a' and 'map' with array
 /// section 'b[:]'.
 ///
 class OMPTargetExitDataDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
-  /// \param NumClauses The number of clauses.
   ///
-  OMPTargetExitDataDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetExitDataDirectiveClass,
+  OMPTargetExitDataDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTargetExitDataDirectiveClass,
                                llvm::omp::OMPD_target_exit_data, StartLoc,
-                               EndLoc, NumClauses, /*NumChildren=*/1) {}
+                               EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetExitDataDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetExitDataDirectiveClass,
+  explicit OMPTargetExitDataDirective()
+      : OMPExecutableDirective(OMPTargetExitDataDirectiveClass,
                                llvm::omp::OMPD_target_exit_data,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               /*NumChildren=*/1) {}
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// \code
 /// #pragma omp target parallel if(a)
 /// \endcode
 /// In this example directive '#pragma omp target parallel' has clause 'if' with
 /// condition 'a'.
 ///
 class OMPTargetParallelDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
   bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPTargetParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetParallelDirectiveClass,
+  OMPTargetParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTargetParallelDirectiveClass,
                                llvm::omp::OMPD_target_parallel, StartLoc,
-                               EndLoc, NumClauses, /*NumChildren=*/1) {}
+                               EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetParallelDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetParallelDirectiveClass,
+  explicit OMPTargetParallelDirective()
+      : OMPExecutableDirective(OMPTargetParallelDirectiveClass,
                                llvm::omp::OMPD_target_parallel,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               /*NumChildren=*/1) {}
+                               SourceLocation(), SourceLocation()) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) { Data->getChildren()[0] = E; }
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
public:
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPTargetParallelDirective *
   CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[0]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPTargetParallelDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPTargetParallelDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp target parallel for' directive.
 ///
 /// \code
 /// #pragma omp target parallel for private(a,b) reduction(+:c,d)
 /// \endcode
 /// In this example directive '#pragma omp target parallel for' has clauses
 /// 'private' with the variables 'a' and 'b' and 'reduction' with operator '+'
 /// and variables 'c' and 'd'.
 ///
 class OMPTargetParallelForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
   /// true if current region has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTargetParallelForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                                unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetParallelForDirectiveClass,
+                                unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetParallelForDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTargetParallelForDirective(unsigned CollapsedNum,
-                                         unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetParallelForDirectiveClass,
+  explicit OMPTargetParallelForDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetParallelForDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), CollapsedNum) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) {
+    Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_target_parallel_for)] = E;
+  }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   /// \param NumClauses Number of clauses.
   ///
   static OMPTargetParallelForDirective *CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     unsigned CollapsedNum,
                                                     EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_target_parallel_for)]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPTargetParallelForDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPTargetParallelForDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp teams' directive.
 ///
 /// \code
 /// #pragma omp teams if(a)
 /// \endcode
 /// In this example directive '#pragma omp teams' has clause 'if' with
 /// condition 'a'.
 ///
 class OMPTeamsDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPTeamsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                    unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTeamsDirectiveClass,
-                               llvm::omp::OMPD_teams, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+  OMPTeamsDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTeamsDirectiveClass, llvm::omp::OMPD_teams,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTeamsDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTeamsDirectiveClass,
-                               llvm::omp::OMPD_teams, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+  explicit OMPTeamsDirective()
+      : OMPExecutableDirective(OMPTeamsDirectiveClass, llvm::omp::OMPD_teams,
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 ///
 /// \code
 /// #pragma omp cancellation point for
 /// \endcode
 ///
 /// In this example a cancellation point is created for innermost 'for' region.
 class OMPCancellationPointDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
-  OpenMPDirectiveKind CancelRegion;
+  friend class OMPExecutableDirective;
+  OpenMPDirectiveKind CancelRegion = llvm::omp::OMPD_unknown;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPCancellationPointDirective(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass,
+      : OMPExecutableDirective(OMPCancellationPointDirectiveClass,
                                llvm::omp::OMPD_cancellation_point, StartLoc,
-                               EndLoc, 0, 0),
-        CancelRegion(llvm::omp::OMPD_unknown) {}
+                               EndLoc) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPCancellationPointDirective()
-      : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass,
+      : OMPExecutableDirective(OMPCancellationPointDirectiveClass,
                                llvm::omp::OMPD_cancellation_point,
-                               SourceLocation(), SourceLocation(), 0, 0),
-        CancelRegion(llvm::omp::OMPD_unknown) {}
+                               SourceLocation(), SourceLocation()) {}
 
   /// Set cancel region for current cancellation point.
   /// \param CR Cancellation region.
   void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; }
 
 public:
   /// Creates directive.
   ///

 ///
 /// \code
 /// #pragma omp cancel for
 /// \endcode
 ///
 /// In this example a cancel is created for innermost 'for' region.
 class OMPCancelDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
-  OpenMPDirectiveKind CancelRegion;
+  friend class OMPExecutableDirective;
+  OpenMPDirectiveKind CancelRegion = llvm::omp::OMPD_unknown;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPCancelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPCancelDirectiveClass,
-                               llvm::omp::OMPD_cancel, StartLoc, EndLoc,
-                               NumClauses, 0),
-        CancelRegion(llvm::omp::OMPD_unknown) {}
+  OMPCancelDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPCancelDirectiveClass, llvm::omp::OMPD_cancel,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  explicit OMPCancelDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPCancelDirectiveClass,
-                               llvm::omp::OMPD_cancel, SourceLocation(),
-                               SourceLocation(), NumClauses, 0),
-        CancelRegion(llvm::omp::OMPD_unknown) {}
+  explicit OMPCancelDirective()
+      : OMPExecutableDirective(OMPCancelDirectiveClass, llvm::omp::OMPD_cancel,
+                               SourceLocation(), SourceLocation()) {}
 
   /// Set cancel region for current cancellation point.
   /// \param CR Cancellation region.
   void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; }
 
 public:
   /// Creates directive.
   ///

 /// #pragma omp taskloop private(a,b) grainsize(val) num_tasks(num)
 /// \endcode
 /// In this example directive '#pragma omp taskloop' has clauses 'private'
 /// with the variables 'a' and 'b', 'grainsize' with expression 'val' and
 /// 'num_tasks' with expression 'num'.
 ///
 class OMPTaskLoopDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTaskLoopDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                       unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTaskLoopDirectiveClass,
-                         llvm::omp::OMPD_taskloop, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                       unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTaskLoopDirectiveClass, llvm::omp::OMPD_taskloop,
+                         StartLoc, EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTaskLoopDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTaskLoopDirectiveClass,
-                         llvm::omp::OMPD_taskloop, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+  explicit OMPTaskLoopDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTaskLoopDirectiveClass, llvm::omp::OMPD_taskloop,
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.

 /// #pragma omp taskloop simd private(a,b) grainsize(val) num_tasks(num)
 /// \endcode
 /// In this example directive '#pragma omp taskloop simd' has clauses 'private'
 /// with the variables 'a' and 'b', 'grainsize' with expression 'val' and
 /// 'num_tasks' with expression 'num'.
 ///
 class OMPTaskLoopSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTaskLoopSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                           unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTaskLoopSimdDirectiveClass,
+                           unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_taskloop_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTaskLoopSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTaskLoopSimdDirectiveClass,
+  explicit OMPTaskLoopSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_taskloop_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp master taskloop private(a,b) grainsize(val) num_tasks(num)
 /// \endcode
 /// In this example directive '#pragma omp master taskloop' has clauses
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
 class OMPMasterTaskLoopDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPMasterTaskLoopDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPMasterTaskLoopDirectiveClass,
+                             unsigned CollapsedNum)
+      : OMPLoopDirective(OMPMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_master_taskloop, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPMasterTaskLoopDirective(unsigned CollapsedNum,
-                                      unsigned NumClauses)
-      : OMPLoopDirective(this, OMPMasterTaskLoopDirectiveClass,
+  explicit OMPMasterTaskLoopDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_master_taskloop, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), CollapsedNum) {}
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.

 /// #pragma omp master taskloop simd private(a,b) grainsize(val) num_tasks(num)
 /// \endcode
 /// In this example directive '#pragma omp master taskloop simd' has clauses
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
 class OMPMasterTaskLoopSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPMasterTaskLoopSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                                 unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPMasterTaskLoopSimdDirectiveClass,
+                                 unsigned CollapsedNum)
+      : OMPLoopDirective(OMPMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_master_taskloop_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPMasterTaskLoopSimdDirective(unsigned CollapsedNum,
-                                          unsigned NumClauses)
-      : OMPLoopDirective(this, OMPMasterTaskLoopSimdDirectiveClass,
+  explicit OMPMasterTaskLoopSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_master_taskloop_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \p Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// num_tasks(num)
 /// \endcode
 /// In this example directive '#pragma omp parallel master taskloop' has clauses
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
 class OMPParallelMasterTaskLoopDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
-  bool HasCancel;
+  bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPParallelMasterTaskLoopDirective(SourceLocation StartLoc,
                                      SourceLocation EndLoc,
-                                     unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelMasterTaskLoopDirectiveClass,
+                                     unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPParallelMasterTaskLoopDirective(unsigned CollapsedNum,
-                                              unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelMasterTaskLoopDirectiveClass,
+  explicit OMPParallelMasterTaskLoopDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.

 /// num_tasks(num)
 /// \endcode
 /// In this example directive '#pragma omp parallel master taskloop simd' has
 /// clauses 'private' with the variables 'a' and 'b', 'grainsize' with
 /// expression 'val' and 'num_tasks' with expression 'num'.
 ///
 class OMPParallelMasterTaskLoopSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPParallelMasterTaskLoopSimdDirective(SourceLocation StartLoc,
                                          SourceLocation EndLoc,
-                                         unsigned CollapsedNum,
-                                         unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelMasterTaskLoopSimdDirectiveClass,
+                                         unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop_simd,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses) {}
+                         StartLoc, EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPParallelMasterTaskLoopSimdDirective(unsigned CollapsedNum,
-                                                  unsigned NumClauses)
-      : OMPLoopDirective(this, OMPParallelMasterTaskLoopSimdDirectiveClass,
+  explicit OMPParallelMasterTaskLoopSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPParallelMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop_simd,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \p Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// \code
 /// #pragma omp distribute private(a,b)
 /// \endcode
 /// In this example directive '#pragma omp distribute' has clauses 'private'
 /// with the variables 'a' and 'b'
 ///
 class OMPDistributeDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPDistributeDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                         unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeDirectiveClass,
+                         unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeDirectiveClass,
                          llvm::omp::OMPD_distribute, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPDistributeDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeDirectiveClass,
+  explicit OMPDistributeDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeDirectiveClass,
                          llvm::omp::OMPD_distribute, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp target update to(a) from(b) device(1)
 /// \endcode
 /// In this example directive '#pragma omp target update' has clause 'to' with
 /// argument 'a', clause 'from' with argument 'b' and clause 'device' with
 /// argument '1'.
 ///
 class OMPTargetUpdateDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
-  /// \param NumClauses The number of clauses.
   ///
-  OMPTargetUpdateDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                           unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetUpdateDirectiveClass,
-                               llvm::omp::OMPD_target_update, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+  OMPTargetUpdateDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTargetUpdateDirectiveClass,
+                               llvm::omp::OMPD_target_update, StartLoc,
+                               EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetUpdateDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetUpdateDirectiveClass,
+  explicit OMPTargetUpdateDirective()
+      : OMPExecutableDirective(OMPTargetUpdateDirectiveClass,
                                llvm::omp::OMPD_target_update, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// \code
 /// #pragma omp distribute parallel for private(a,b)
 /// \endcode
 /// In this example directive '#pragma omp distribute parallel for' has clause
 /// 'private' with the variables 'a' and 'b'
 ///
 class OMPDistributeParallelForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
   bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPDistributeParallelForDirective(SourceLocation StartLoc,
                                     SourceLocation EndLoc,
-                                    unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeParallelForDirectiveClass,
+                                    unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPDistributeParallelForDirective(unsigned CollapsedNum,
-                                             unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeParallelForDirectiveClass,
+  explicit OMPDistributeParallelForDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) {
+    Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_distribute_parallel_for)] = E;
+  }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   /// \param NumClauses Number of clauses.
   ///
   static OMPDistributeParallelForDirective *CreateEmpty(const ASTContext &C,
                                                         unsigned NumClauses,
                                                         unsigned CollapsedNum,
                                                         EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_distribute_parallel_for)]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPDistributeParallelForDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPDistributeParallelForDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp distribute parallel for simd' composite
 /// directive.
 ///
 /// \code
 /// #pragma omp distribute parallel for simd private(x)
 /// \endcode
 /// In this example directive '#pragma omp distribute parallel for simd' has
 /// clause 'private' with the variables 'x'
 ///
 class OMPDistributeParallelForSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPDistributeParallelForSimdDirective(SourceLocation StartLoc,
                                         SourceLocation EndLoc,
-                                        unsigned CollapsedNum,
-                                        unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeParallelForSimdDirectiveClass,
+                                        unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPDistributeParallelForSimdDirective(unsigned CollapsedNum,
-                                                 unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeParallelForSimdDirectiveClass,
+  explicit OMPDistributeParallelForSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for_simd,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// \code
 /// #pragma omp distribute simd private(x)
 /// \endcode
 /// In this example directive '#pragma omp distribute simd' has clause
 /// 'private' with the variables 'x'
 ///
 class OMPDistributeSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPDistributeSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeSimdDirectiveClass,
+                             unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPDistributeSimdDirective(unsigned CollapsedNum,
-                                      unsigned NumClauses)
-      : OMPLoopDirective(this, OMPDistributeSimdDirectiveClass,
+  explicit OMPDistributeSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp target parallel for simd private(a) map(b) safelen(c)
 /// \endcode
 /// In this example directive '#pragma omp target parallel for simd' has clauses
 /// 'private' with the variable 'a', 'map' with the variable 'b' and 'safelen'
 /// with the variable 'c'.
 ///
 class OMPTargetParallelForSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTargetParallelForSimdDirective(SourceLocation StartLoc,
                                     SourceLocation EndLoc,
-                                    unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetParallelForSimdDirectiveClass,
+                                    unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTargetParallelForSimdDirective(unsigned CollapsedNum,
-                                             unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetParallelForSimdDirectiveClass,
+  explicit OMPTargetParallelForSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for_simd,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp target simd private(a) map(b) safelen(c)
 /// \endcode
 /// In this example directive '#pragma omp target simd' has clauses 'private'
 /// with the variable 'a', 'map' with the variable 'b' and 'safelen' with
 /// the variable 'c'.
 ///
 class OMPTargetSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTargetSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                         unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetSimdDirectiveClass,
+                         unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetSimdDirectiveClass,
                          llvm::omp::OMPD_target_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTargetSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetSimdDirectiveClass,
+  explicit OMPTargetSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetSimdDirectiveClass,
                          llvm::omp::OMPD_target_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// \code
 /// #pragma omp teams distribute private(a,b)
 /// \endcode
 /// In this example directive '#pragma omp teams distribute' has clauses
 /// 'private' with the variables 'a' and 'b'
 ///
 class OMPTeamsDistributeDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTeamsDistributeDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                              unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeDirectiveClass,
+                              unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_teams_distribute, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTeamsDistributeDirective(unsigned CollapsedNum,
-                                       unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeDirectiveClass,
+  explicit OMPTeamsDistributeDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_teams_distribute, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// \code
 /// #pragma omp teams distribute simd private(a,b)
 /// \endcode
 /// In this example directive '#pragma omp teams distribute simd'
 /// has clause 'private' with the variables 'a' and 'b'
 ///
 class OMPTeamsDistributeSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTeamsDistributeSimdDirective(SourceLocation StartLoc,
-                                  SourceLocation EndLoc, unsigned CollapsedNum,
-                                  unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeSimdDirectiveClass,
+                                  SourceLocation EndLoc, unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTeamsDistributeSimdDirective(unsigned CollapsedNum,
-                                           unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeSimdDirectiveClass,
+  explicit OMPTeamsDistributeSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_simd,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp teams distribute parallel for simd private(x)
 /// \endcode
 /// In this example directive '#pragma omp teams distribute parallel for simd'
 /// has clause 'private' with the variables 'x'
 ///
 class OMPTeamsDistributeParallelForSimdDirective final
     : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTeamsDistributeParallelForSimdDirective(SourceLocation StartLoc,
                                              SourceLocation EndLoc,
-                                             unsigned CollapsedNum,
-                                             unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeParallelForSimdDirectiveClass,
+                                             unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for_simd,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses) {}
+                         StartLoc, EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTeamsDistributeParallelForSimdDirective(unsigned CollapsedNum,
-                                                      unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeParallelForSimdDirectiveClass,
+  explicit OMPTeamsDistributeParallelForSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for_simd,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// \code
 /// #pragma omp teams distribute parallel for private(x)
 /// \endcode
 /// In this example directive '#pragma omp teams distribute parallel for'
 /// has clause 'private' with the variables 'x'
 ///
 class OMPTeamsDistributeParallelForDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
   bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTeamsDistributeParallelForDirective(SourceLocation StartLoc,
                                          SourceLocation EndLoc,
-                                         unsigned CollapsedNum,
-                                         unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeParallelForDirectiveClass,
+                                         unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         StartLoc, EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTeamsDistributeParallelForDirective(unsigned CollapsedNum,
-                                                  unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTeamsDistributeParallelForDirectiveClass,
+  explicit OMPTeamsDistributeParallelForDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTeamsDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) {
+    Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_teams_distribute_parallel_for)] =
+        E;
+  }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   /// \param CollapsedNum Number of collapsed nested loops.
   /// \param NumClauses Number of clauses.
   ///
   static OMPTeamsDistributeParallelForDirective *
   CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
               EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(), llvm::omp::OMPD_teams_distribute_parallel_for)]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPTeamsDistributeParallelForDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPTeamsDistributeParallelForDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp target teams' directive.
 ///
 /// \code
 /// #pragma omp target teams if(a>0)
 /// \endcode
 /// In this example directive '#pragma omp target teams' has clause 'if' with
 /// condition 'a>0'.
 ///
 class OMPTargetTeamsDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPTargetTeamsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                          unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetTeamsDirectiveClass,
-                               llvm::omp::OMPD_target_teams, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+  OMPTargetTeamsDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPTargetTeamsDirectiveClass,
+                               llvm::omp::OMPD_target_teams, StartLoc, EndLoc) {
+  }
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetTeamsDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPTargetTeamsDirectiveClass,
+  explicit OMPTargetTeamsDirective()
+      : OMPExecutableDirective(OMPTargetTeamsDirectiveClass,
                                llvm::omp::OMPD_target_teams, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.

 /// \code
 /// #pragma omp target teams distribute private(x)
 /// \endcode
 /// In this example directive '#pragma omp target teams distribute' has clause
 /// 'private' with the variables 'x'
 ///
 class OMPTargetTeamsDistributeDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTargetTeamsDistributeDirective(SourceLocation StartLoc,
                                     SourceLocation EndLoc,
-                                    unsigned CollapsedNum, unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetTeamsDistributeDirectiveClass,
+                                    unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTargetTeamsDistributeDirective(unsigned CollapsedNum,
-                                             unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetTeamsDistributeDirectiveClass,
+  explicit OMPTargetTeamsDistributeDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// #pragma omp target teams distribute parallel for private(x)
 /// \endcode
 /// In this example directive '#pragma omp target teams distribute parallel
 /// for' has clause 'private' with the variables 'x'
 ///
 class OMPTargetTeamsDistributeParallelForDirective final
     : public OMPLoopDirective {
   friend class ASTStmtReader;
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
+  friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
   bool HasCancel = false;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTargetTeamsDistributeParallelForDirective(SourceLocation StartLoc,
                                                SourceLocation EndLoc,
-                                               unsigned CollapsedNum,
-                                               unsigned NumClauses)
-      : OMPLoopDirective(this,
-                         OMPTargetTeamsDistributeParallelForDirectiveClass,
+                                               unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetTeamsDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute_parallel_for,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         StartLoc, EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTargetTeamsDistributeParallelForDirective(unsigned CollapsedNum,
-                                                        unsigned NumClauses)
-      : OMPLoopDirective(
-            this, OMPTargetTeamsDistributeParallelForDirectiveClass,
+  explicit OMPTargetTeamsDistributeParallelForDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetTeamsDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute_parallel_for,
-            SourceLocation(), SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
   /// Sets special task reduction descriptor.
-  void setTaskReductionRefExpr(Expr *E) { TaskRedRef = E; }
+  void setTaskReductionRefExpr(Expr *E) {
+    Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(),
+        llvm::omp::OMPD_target_teams_distribute_parallel_for)] = E;
+  }
 
   /// Set cancel state.
   void setHasCancel(bool Has) { HasCancel = Has; }
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
public:
   /// \param CollapsedNum Number of collapsed nested loops.
   /// \param NumClauses Number of clauses.
   ///
   static OMPTargetTeamsDistributeParallelForDirective *
   CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
               EmptyShell);
 
   /// Returns special task reduction reference expression.
-  Expr *getTaskReductionRefExpr() { return TaskRedRef; }
-  const Expr *getTaskReductionRefExpr() const { return TaskRedRef; }
+  Expr *getTaskReductionRefExpr() {
+    return cast_or_null<Expr>(Data->getChildren()[numLoopChildren(
+        getCollapsedNumber(),
+        llvm::omp::OMPD_target_teams_distribute_parallel_for)]);
+  }
+  const Expr *getTaskReductionRefExpr() const {
+    return const_cast<OMPTargetTeamsDistributeParallelForDirective *>(this)
+        ->getTaskReductionRefExpr();
+  }
 
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() ==
            OMPTargetTeamsDistributeParallelForDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp target teams distribute parallel for simd'
 /// combined directive.
 ///
 /// \code
 /// #pragma omp target teams distribute parallel for simd private(x)
 /// \endcode
 /// In this example directive '#pragma omp target teams distribute parallel
 /// for simd' has clause 'private' with the variables 'x'
 ///
 class OMPTargetTeamsDistributeParallelForSimdDirective final
     : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTargetTeamsDistributeParallelForSimdDirective(SourceLocation StartLoc,
                                                    SourceLocation EndLoc,
-                                                   unsigned CollapsedNum,
-                                                   unsigned NumClauses)
+                                                   unsigned CollapsedNum)
       : OMPLoopDirective(
-            this, OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
+            OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
             llvm::omp::OMPD_target_teams_distribute_parallel_for_simd, StartLoc,
-            EndLoc, CollapsedNum, NumClauses) {}
+            EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   explicit OMPTargetTeamsDistributeParallelForSimdDirective(
-      unsigned CollapsedNum, unsigned NumClauses)
+      unsigned CollapsedNum)
       : OMPLoopDirective(
-            this, OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
+            OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
             llvm::omp::OMPD_target_teams_distribute_parallel_for_simd,
-            SourceLocation(), SourceLocation(), CollapsedNum, NumClauses) {}
+            SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 /// \code
 /// #pragma omp target teams distribute simd private(x)
 /// \endcode
 /// In this example directive '#pragma omp target teams distribute simd'
 /// has clause 'private' with the variables 'x'
 ///
 class OMPTargetTeamsDistributeSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
   OMPTargetTeamsDistributeSimdDirective(SourceLocation StartLoc,
                                         SourceLocation EndLoc,
-                                        unsigned CollapsedNum,
-                                        unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetTeamsDistributeSimdDirectiveClass,
+                                        unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
   ///
-  explicit OMPTargetTeamsDistributeSimdDirective(unsigned CollapsedNum,
-                                                 unsigned NumClauses)
-      : OMPLoopDirective(this, OMPTargetTeamsDistributeSimdDirectiveClass,
+  explicit OMPTargetTeamsDistributeSimdDirective(unsigned CollapsedNum)
+      : OMPLoopDirective(OMPTargetTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute_simd,
-                         SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         SourceLocation(), SourceLocation(), CollapsedNum) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param CollapsedNum Number of collapsed loops.

 ///
 /// \code
 /// #pragma omp scan inclusive(a)
 /// \endcode
 /// In this example directive '#pragma omp scan' has clause 'inclusive' with
 /// list item 'a'.
 class OMPScanDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
-  /// \param NumClauses Number of clauses.
   ///
-  OMPScanDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                   unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPScanDirectiveClass,
-                               llvm::omp::OMPD_scan, StartLoc, EndLoc,
-                               NumClauses, 0) {}
+  OMPScanDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPScanDirectiveClass, llvm::omp::OMPD_scan,
+                               StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPScanDirective(unsigned NumClauses)
-      : OMPExecutableDirective(this, OMPScanDirectiveClass,
-                               llvm::omp::OMPD_scan, SourceLocation(),
-                               SourceLocation(), NumClauses, 0) {}
+  explicit OMPScanDirective()
+      : OMPExecutableDirective(OMPScanDirectiveClass, llvm::omp::OMPD_scan,
+                               SourceLocation(), SourceLocation()) {}
 
 public:
   /// Creates directive with a list of \a Clauses.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses (only single OMPFlushClause clause is

clang/include/clang/Sema/Sema.h

public:
 
   /// Check variable declaration in 'omp declare mapper' construct.
   TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D);
   /// Check if the specified type is allowed to be used in 'omp declare
   /// mapper' construct.
   QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc,
                                         TypeResult ParsedType);
   /// Called on start of '#pragma omp declare mapper'.
-  OMPDeclareMapperDecl *ActOnOpenMPDeclareMapperDirectiveStart(
+  DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(
       Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType,
       SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS,
+      Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses,
       Decl *PrevDeclInScope = nullptr);
   /// Build the mapper variable of '#pragma omp declare mapper'.
-  void ActOnOpenMPDeclareMapperDirectiveVarDecl(OMPDeclareMapperDecl *DMD,
-                                                Scope *S, QualType MapperType,
+  ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S,
+                                                      QualType MapperType,
                                                       SourceLocation StartLoc,
                                                       DeclarationName VN);
-  /// Called at the end of '#pragma omp declare mapper'.
-  DeclGroupPtrTy
-  ActOnOpenMPDeclareMapperDirectiveEnd(OMPDeclareMapperDecl *D, Scope *S,
-                                       ArrayRef<OMPClause *> ClauseList);
+  bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const;
+  StringRef getOpenMPDeclareMapperVarName() const;
 
   /// Called on the start of target region i.e. '#pragma omp declare target'.
   bool ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc);
   /// Called at the end of target region i.e. '#pragme omp end declare target'.
   void ActOnFinishOpenMPDeclareTargetDirective();
   /// Searches for the provided declaration name for OpenMP declare target
   /// directive.
   NamedDecl *

clang/include/clang/Serialization/ASTRecordReader.h

 #include "clang/Lex/Token.h"
 #include "clang/Serialization/ASTReader.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 
 namespace clang {
 class OMPTraitInfo;
+class OMPChildren;
 
 /// An object for streaming information from a record.
 class ASTRecordReader
     : public serialization::DataStreamBasicReader<ASTRecordReader> {
   using ModuleFile = serialization::ModuleFile;
 
   ASTReader *Reader;
   ModuleFile *F;
public:
   }
 
   /// Read an OMPTraitInfo object, advancing Idx.
   OMPTraitInfo *readOMPTraitInfo();
 
   /// Read an OpenMP clause, advancing Idx.
   OMPClause *readOMPClause();
 
+  /// Read an OpenMP children, advancing Idx.
+  void readOMPChildren(OMPChildren *Data);
+
   /// Read a source location, advancing Idx.
   SourceLocation readSourceLocation() {
     return Reader->ReadSourceLocation(*F, Record, Idx);
   }
 
   /// Read a source range, advancing Idx.
   SourceRange readSourceRange() {
     return Reader->ReadSourceRange(*F, Record, Idx);

clang/include/clang/Serialization/ASTRecordWriter.h

public:
 
   void AddCXXDefinitionData(const CXXRecordDecl *D);
 
   /// Write an OMPTraitInfo object.
   void writeOMPTraitInfo(const OMPTraitInfo *TI);
 
   void writeOMPClause(OMPClause *C);
 
+  /// Writes data related to the OpenMP directives.
+  void writeOMPChildren(OMPChildren *Data);
+
   /// Emit a string.
   void AddString(StringRef Str) {
     return Writer->AddString(Str, *Record);
   }
 
   /// Emit a path.
   void AddPath(StringRef Path) {
     return Writer->AddPath(Path, *Record);

clang/lib/AST/DeclOpenMP.cpp

 #include "clang/AST/Expr.h"
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // OMPThreadPrivateDecl Implementation.
 //===----------------------------------------------------------------------===//
 
-void OMPThreadPrivateDecl::anchor() { }
+void OMPThreadPrivateDecl::anchor() {}
 
 OMPThreadPrivateDecl *OMPThreadPrivateDecl::Create(ASTContext &C,
                                                    DeclContext *DC,
                                                    SourceLocation L,
                                                    ArrayRef<Expr *> VL) {
-  OMPThreadPrivateDecl *D =
-      new (C, DC, additionalSizeToAlloc<Expr *>(VL.size()))
-          OMPThreadPrivateDecl(OMPThreadPrivate, DC, L);
-  D->NumVars = VL.size();
+  auto *D = OMPDeclarativeDirective::createDirective<OMPThreadPrivateDecl>(
+      C, DC, llvm::None, VL.size(), L);
   D->setVars(VL);
   return D;
 }
 
 OMPThreadPrivateDecl *OMPThreadPrivateDecl::CreateDeserialized(ASTContext &C,
                                                                unsigned ID,
                                                                unsigned N) {
-  OMPThreadPrivateDecl *D = new (C, ID, additionalSizeToAlloc<Expr *>(N))
-      OMPThreadPrivateDecl(OMPThreadPrivate, nullptr, SourceLocation());
-  D->NumVars = N;
-  return D;
+  return OMPDeclarativeDirective::createEmptyDirective<OMPThreadPrivateDecl>(
+      C, ID, 0, N);
 }
 
 void OMPThreadPrivateDecl::setVars(ArrayRef<Expr *> VL) {
-  assert(VL.size() == NumVars &&
+  assert(VL.size() == Data->getNumChildren() &&
          "Number of variables is not the same as the preallocated buffer");
-  std::uninitialized_copy(VL.begin(), VL.end(), getTrailingObjects<Expr *>());
+  llvm::copy(VL, getVars().begin());
 }
 
 //===----------------------------------------------------------------------===//
 // OMPAllocateDecl Implementation.
 //===----------------------------------------------------------------------===//
 
 void OMPAllocateDecl::anchor() { }
 
 OMPAllocateDecl *OMPAllocateDecl::Create(ASTContext &C, DeclContext *DC,
                                          SourceLocation L, ArrayRef<Expr *> VL,
                                          ArrayRef<OMPClause *> CL) {
-  OMPAllocateDecl *D = new (
-      C, DC, additionalSizeToAlloc<Expr *, OMPClause *>(VL.size(), CL.size()))
-      OMPAllocateDecl(OMPAllocate, DC, L);
-  D->NumVars = VL.size();
+  auto *D = OMPDeclarativeDirective::createDirective<OMPAllocateDecl>(
+      C, DC, CL, VL.size(), L);
   D->setVars(VL);
-  D->NumClauses = CL.size();
-  D->setClauses(CL);
   return D;
 }
 
 OMPAllocateDecl *OMPAllocateDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                                      unsigned NVars,
                                                      unsigned NClauses) {
-  OMPAllocateDecl *D =
-      new (C, ID, additionalSizeToAlloc<Expr *, OMPClause *>(NVars, NClauses))
-          OMPAllocateDecl(OMPAllocate, nullptr, SourceLocation());
-  D->NumVars = NVars;
-  D->NumClauses = NClauses;
-  return D;
+  return OMPDeclarativeDirective::createEmptyDirective<OMPAllocateDecl>(
+      C, ID, NClauses, NVars, SourceLocation());
 }
 
 void OMPAllocateDecl::setVars(ArrayRef<Expr *> VL) {
-  assert(VL.size() == NumVars &&
-         "Number of variables is not the same as the preallocated buffer");
-  std::uninitialized_copy(VL.begin(), VL.end(), getTrailingObjects<Expr *>());
-}
-
-void OMPAllocateDecl::setClauses(ArrayRef<OMPClause *> CL) {
-  assert(CL.size() == NumClauses &&
+  assert(VL.size() == Data->getNumChildren() &&
          "Number of variables is not the same as the preallocated buffer");
-  std::uninitialized_copy(CL.begin(), CL.end(),
-                          getTrailingObjects<OMPClause *>());
+  llvm::copy(VL, getVars().begin());
 }
 
 //===----------------------------------------------------------------------===//
 // OMPRequiresDecl Implementation.
 //===----------------------------------------------------------------------===//
 
 void OMPRequiresDecl::anchor() {}
 
 OMPRequiresDecl *OMPRequiresDecl::Create(ASTContext &C, DeclContext *DC,
                                          SourceLocation L,
                                          ArrayRef<OMPClause *> CL) {
-  OMPRequiresDecl *D =
-      new (C, DC, additionalSizeToAlloc<OMPClause *>(CL.size()))
-      OMPRequiresDecl(OMPRequires, DC, L);
-  D->NumClauses = CL.size();
-  D->setClauses(CL);
-  return D;
+  return OMPDeclarativeDirective::createDirective<OMPRequiresDecl>(C, DC, CL, 0,
+                                                                   L);
 }
 
 OMPRequiresDecl *OMPRequiresDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                                      unsigned N) {
-  OMPRequiresDecl *D = new (C, ID, additionalSizeToAlloc<OMPClause *>(N))
-      OMPRequiresDecl(OMPRequires, nullptr, SourceLocation());
-  D->NumClauses = N;
-  return D;
-}
-
-void OMPRequiresDecl::setClauses(ArrayRef<OMPClause *> CL) {
-  assert(CL.size() == NumClauses &&
-         "Number of clauses is not the same as the preallocated buffer");
-  std::uninitialized_copy(CL.begin(), CL.end(),
-                          getTrailingObjects<OMPClause *>());
+  return OMPDeclarativeDirective::createEmptyDirective<OMPRequiresDecl>(
+      C, ID, N, 0, SourceLocation());
 }
 
 //===----------------------------------------------------------------------===//
 // OMPDeclareReductionDecl Implementation.
 //===----------------------------------------------------------------------===//
 
 OMPDeclareReductionDecl::OMPDeclareReductionDecl(
     Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,

 }
 
 //===----------------------------------------------------------------------===//
 // OMPDeclareMapperDecl Implementation.
 //===----------------------------------------------------------------------===//
 
 void OMPDeclareMapperDecl::anchor() {}
 
-OMPDeclareMapperDecl *
-OMPDeclareMapperDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
-                             DeclarationName Name, QualType T,
-                             DeclarationName VarName,
-                             OMPDeclareMapperDecl *PrevDeclInScope) {
-  return new (C, DC) OMPDeclareMapperDecl(OMPDeclareMapper, DC, L, Name, T,
-                                          VarName, PrevDeclInScope);
+OMPDeclareMapperDecl *OMPDeclareMapperDecl::Create(
+    ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name,
+    QualType T, DeclarationName VarName, ArrayRef<OMPClause *> Clauses,
+  return OMPDeclarativeDirective::createDirective<OMPDeclareMapperDecl>(
+      C, DC, Clauses, 1, L, Name, T, VarName, PrevDeclInScope);
 }
 
 OMPDeclareMapperDecl *OMPDeclareMapperDecl::CreateDeserialized(ASTContext &C,
                                                                unsigned ID,
                                                                unsigned N) {
-  auto *D = new (C, ID)
-      OMPDeclareMapperDecl(OMPDeclareMapper, /*DC=*/nullptr, SourceLocation(),
-                           DeclarationName(), QualType(), DeclarationName(),
-                           /*PrevDeclInScope=*/nullptr);
-  if (N) {
-    auto **ClauseStorage = C.Allocate<OMPClause *>(N);
-    D->Clauses = llvm::makeMutableArrayRef<OMPClause *>(ClauseStorage, N);
-  }
-  return D;
-}
-
-/// Creates an array of clauses to this mapper declaration and intializes
-/// them. The space used to store clause pointers is dynamically allocated,
-/// because we do not know the number of clauses when creating
-/// OMPDeclareMapperDecl
-void OMPDeclareMapperDecl::CreateClauses(ASTContext &C,
-                                         ArrayRef<OMPClause *> CL) {
-  assert(Clauses.empty() && "Number of clauses should be 0 on initialization");
-  size_t NumClauses = CL.size();
-  if (NumClauses) {
-    auto **ClauseStorage = C.Allocate<OMPClause *>(NumClauses);
-    Clauses = llvm::makeMutableArrayRef<OMPClause *>(ClauseStorage, NumClauses);
-    setClauses(CL);
-  }
-}
-
-void OMPDeclareMapperDecl::setClauses(ArrayRef<OMPClause *> CL) {
-  assert(CL.size() == Clauses.size() &&
-         "Number of clauses is not the same as the preallocated buffer");
-  std::uninitialized_copy(CL.begin(), CL.end(), Clauses.data());
+  return OMPDeclarativeDirective::createEmptyDirective<OMPDeclareMapperDecl>(
+      C, ID, N, 1, SourceLocation(), DeclarationName(), QualType(),
+      DeclarationName(), /*PrevDeclInScope=*/nullptr);
 }
 
 OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() {
   return cast_or_null<OMPDeclareMapperDecl>(
       PrevDeclInScope.get(getASTContext().getExternalSource()));
 }
 
 const OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() const {

clang/lib/AST/StmtOpenMP.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/StmtOpenMP.h"
 
 using namespace clang;
 using namespace llvm::omp;
 
-void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
-  assert(Clauses.size() == getNumClauses() &&
+size_t OMPChildren::size(unsigned NumClauses, bool HasAssociatedStmt,
+                         unsigned NumChildren) {
+  return llvm::alignTo(
+      totalSizeToAlloc<OMPClause *, Stmt *>(
+          NumClauses, NumChildren + (HasAssociatedStmt ? 1 : 0)),
+      alignof(OMPChildren));
+}
+
+void OMPChildren::setClauses(ArrayRef<OMPClause *> Clauses) {
+  assert(Clauses.size() == NumClauses &&
          "Number of clauses is not the same as the preallocated buffer");
-  std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
+  llvm::copy(Clauses, getTrailingObjects<OMPClause *>());
+}
+
+MutableArrayRef<Stmt *> OMPChildren::getChildren() {
+  return llvm::makeMutableArrayRef(getTrailingObjects<Stmt *>(), NumChildren);
+}
+
+OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses) {
+  auto *Data = CreateEmpty(Mem, Clauses.size());
+  Data->setClauses(Clauses);
+  return Data;
+}
+
+OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses,
+                                 Stmt *S, unsigned NumChildren) {
+  auto *Data = CreateEmpty(Mem, Clauses.size(), S, NumChildren);
+  Data->setClauses(Clauses);
+  if (S)
+    Data->setAssociatedStmt(S);
+  return Data;
+}
+
+OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses,
+                                      bool HasAssociatedStmt,
+                                      unsigned NumChildren) {
+  return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt);
 }
 
 bool OMPExecutableDirective::isStandaloneDirective() const {
   // Special case: 'omp target enter data', 'omp target exit data',
   // 'omp target update' are stand-alone directives, but for implementation
   // reasons they have empty synthetic structured block, to simplify codegen.
   if (isa<OMPTargetEnterDataDirective>(this) ||
       isa<OMPTargetExitDataDirective>(this) ||
       isa<OMPTargetUpdateDirective>(this))
     return true;
-  return !hasAssociatedStmt() || !getAssociatedStmt();
+  return !hasAssociatedStmt();
 }
 
-const Stmt *OMPExecutableDirective::getStructuredBlock() const {
+Stmt *OMPExecutableDirective::getStructuredBlock() {
   assert(!isStandaloneDirective() &&
          "Standalone Executable Directives don't have Structured Blocks.");
   if (auto *LD = dyn_cast<OMPLoopDirective>(this))
     return LD->getBody();
-  return getInnermostCapturedStmt()->getCapturedStmt();
+  return getRawStmt();
 }
 
 Stmt *OMPLoopDirective::tryToFindNextInnerLoop(Stmt *CurStmt,
                                                bool TryImperfectlyNestedLoops) {
   Stmt *OrigStmt = CurStmt;
   CurStmt = CurStmt->IgnoreContainers();
   // Additional work for imperfectly nested loops, introduced in OpenMP 5.0.
   if (TryImperfectlyNestedLoops) {
if (auto *CS = dyn_cast<CompoundStmt>(CurStmt)) {
         CurStmt = OrigStmt;
     }
   }
   return CurStmt;
 }
 
 Stmt *OMPLoopDirective::getBody() {
   // This relies on the loop form is already checked by Sema.
-  Stmt *Body =
-      getInnermostCapturedStmt()->getCapturedStmt()->IgnoreContainers();
+  Stmt *Body = Data->getRawStmt()->IgnoreContainers();
   if (auto *For = dyn_cast<ForStmt>(Body)) {
     Body = For->getBody();
   } else {
     assert(isa<CXXForRangeStmt>(Body) &&
            "Expected canonical for loop or range-based for loop.");
     Body = cast<CXXForRangeStmt>(Body)->getBody();
   }
   for (unsigned Cnt = 1; Cnt < CollapsedNum; ++Cnt) {
     Body = tryToFindNextInnerLoop(Body, /*TryImperfectlyNestedLoops=*/true);
     if (auto *For = dyn_cast<ForStmt>(Body)) {
       Body = For->getBody();
     } else {
       assert(isa<CXXForRangeStmt>(Body) &&
              "Expected canonical for loop or range-based for loop.");
       Body = cast<CXXForRangeStmt>(Body)->getBody();
     }
   }
   return Body;
 }
 
 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() &&
          "Number of loop counters is not the same as the collapsed number");
-  std::copy(A.begin(), A.end(), getCounters().begin());
+  llvm::copy(A, getCounters().begin());
 }
 
 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() && "Number of loop private counters "
                                              "is not the same as the collapsed "
                                              "number");
-  std::copy(A.begin(), A.end(), getPrivateCounters().begin());
+  llvm::copy(A, getPrivateCounters().begin());
 }
 
 void OMPLoopDirective::setInits(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() &&
          "Number of counter inits is not the same as the collapsed number");
-  std::copy(A.begin(), A.end(), getInits().begin());
+  llvm::copy(A, getInits().begin());
 }
 
 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() &&
          "Number of counter updates is not the same as the collapsed number");
-  std::copy(A.begin(), A.end(), getUpdates().begin());
+  llvm::copy(A, getUpdates().begin());
 }
 
 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() &&
          "Number of counter finals is not the same as the collapsed number");
-  std::copy(A.begin(), A.end(), getFinals().begin());
+  llvm::copy(A, getFinals().begin());
 }
 
 void OMPLoopDirective::setDependentCounters(ArrayRef<Expr *> A) {
   assert(
       A.size() == getCollapsedNumber() &&
       "Number of dependent counters is not the same as the collapsed number");
   llvm::copy(A, getDependentCounters().begin());
 }
assert(A.size() == getCollapsedNumber() &&
          "Number of finals conditions is not the same as the collapsed number");
   llvm::copy(A, getFinalsConditions().begin());
 }
 
 OMPParallelDirective *OMPParallelDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPParallelDirective *Dir =
-      new (Mem) OMPParallelDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPParallelDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
   Dir->setTaskReductionRefExpr(TaskRedRef);
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
                                                         unsigned NumClauses,
                                                         EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPParallelDirective(NumClauses);
+  return createEmptyDirective<OMPParallelDirective>(C, NumClauses,
+                                                    /*HasAssociatedStmt=*/true,
+                                                    /*NumChildren=*/1);
 }
 
 OMPSimdDirective *
 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation EndLoc, unsigned CollapsedNum,
                          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
                          const HelperExprs &Exprs) {
-  unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
-  OMPSimdDirective *Dir = new (Mem)
-      OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPSimdDirective>(
+      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setCounters(Exprs.Counters);
   Dir->setPrivateCounters(Exprs.PrivateCounters);
   Dir->setInits(Exprs.Inits);
   Dir->setUpdates(Exprs.Updates);
   Dir->setFinals(Exprs.Finals);
   Dir->setDependentCounters(Exprs.DependentCounters);
   Dir->setDependentInits(Exprs.DependentInits);
   Dir->setFinalsConditions(Exprs.FinalsConditions);
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
                                                 unsigned NumClauses,
                                                 unsigned CollapsedNum,
                                                 EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
-  return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_simd), CollapsedNum);
 }
 
 OMPForDirective *OMPForDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
-  unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
-  OMPForDirective *Dir =
-      new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPForDirective>(
+      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1,
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPForDirective *OMPForDirective::Create(
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
                                               unsigned NumClauses,
                                               unsigned CollapsedNum,
                                               EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
-  return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPForDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum);
 }
 
 OMPForSimdDirective *
 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
                             SourceLocation EndLoc, unsigned CollapsedNum,
                             ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
                             const HelperExprs &Exprs) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
-  OMPForSimdDirective *Dir = new (Mem)
-      OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPForSimdDirective>(
+      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
                                                       unsigned NumClauses,
                                                       unsigned CollapsedNum,
                                                       EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
-  return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPForSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum);
 }
 
 OMPSectionsDirective *OMPSectionsDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPSectionsDirective *Dir =
-      new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt,
+                                                    /*NumChildren=*/1, StartLoc,
+                                                    EndLoc);
   Dir->setTaskReductionRefExpr(TaskRedRef);
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
                                                         unsigned NumClauses,
                                                         EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPSectionsDirective(NumClauses);
+  return createEmptyDirective<OMPSectionsDirective>(C, NumClauses,
+                                                    /*HasAssociatedStmt=*/true,
+                                                    /*NumChildren=*/1);
 }
 
 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
                                                  SourceLocation StartLoc,
                                                  SourceLocation EndLoc,
                                                  Stmt *AssociatedStmt,
                                                  bool HasCancel) {
-  unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
-  void *Mem = C.Allocate(Size + sizeof(Stmt *));
-  OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir =
+      createDirective<OMPSectionDirective>(C, llvm::None, AssociatedStmt,
+                                           /*NumChildre=*/0, StartLoc, EndLoc);
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
                                                       EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
-  void *Mem = C.Allocate(Size + sizeof(Stmt *));
-  return new (Mem) OMPSectionDirective();
+  return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,
+                                                   /*HasAssociatedStmt=*/true);
 }
 
 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses,
                                                Stmt *AssociatedStmt) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPSingleDirective *Dir =
-      new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,
+                                             /*NumChildren=*/0, StartLoc,
+                                             EndLoc);
 }
 
 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPSingleDirective(NumClauses);
+  return createEmptyDirective<OMPSingleDirective>(C, NumClauses,
+                                                  /*HasAssociatedStmt=*/true);
 }
 
 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                Stmt *AssociatedStmt) {
-  unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
-  void *Mem = C.Allocate(Size + sizeof(Stmt *));
-  OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPMasterDirective>(C, llvm::None, AssociatedStmt,
+                                             /*NumChildren=*/0, StartLoc,
+                                             EndLoc);
 }
 
 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
                                                     EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
-  void *Mem = C.Allocate(Size + sizeof(Stmt *));
-  return new (Mem) OMPMasterDirective();
+  return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0,
+                                                  /*HasAssociatedStmt=*/true);
 }
 
 OMPCriticalDirective *OMPCriticalDirective::Create(
     const ASTContext &C, const DeclarationNameInfo &Name,
     SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPCriticalDirective *Dir =
-      new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,
+                                               /*NumChildren=*/0, Name,
+                                               StartLoc, EndLoc);
 }
 
 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
                                                         unsigned NumClauses,
                                                         EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPCriticalDirective(NumClauses);
+  return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,
+                                                    /*HasAssociatedStmt=*/true);
 }
 
 OMPParallelForDirective *OMPParallelForDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_parallel_for));
-  OMPParallelForDirective *Dir = new (Mem)
-      OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPParallelForDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPParallelForDirective *OMPParallelForDirective::Create(
   Dir->setTaskReductionRefExpr(TaskRedRef);
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPParallelForDirective *
 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                      unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_parallel_for));
-  return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPParallelForDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum);
 }
 
 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
-  OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPParallelForSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPParallelForSimdDirective *
 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
                                          unsigned NumClauses,
                                          unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
-  return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPParallelForSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum);
 }
 
 OMPParallelMasterDirective *OMPParallelMasterDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelMasterDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  auto *Dir =
-      new (Mem) OMPParallelMasterDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPParallelMasterDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
   Dir->setTaskReductionRefExpr(TaskRedRef);
   return Dir;
 }
 
-OMPParallelMasterDirective *OMPParallelMasterDirective::CreateEmpty(const ASTContext &C,
-                                                        unsigned NumClauses,
-                                                        EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelMasterDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPParallelMasterDirective(NumClauses);
+OMPParallelMasterDirective *
+OMPParallelMasterDirective::CreateEmpty(const ASTContext &C,
+                                        unsigned NumClauses, EmptyShell) {
+  return createEmptyDirective<OMPParallelMasterDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
 }
 
 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPParallelSectionsDirective *Dir =
-      new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPParallelSectionsDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
   Dir->setTaskReductionRefExpr(TaskRedRef);
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPParallelSectionsDirective *
 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
                                           unsigned NumClauses, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPParallelSectionsDirective(NumClauses);
+  return createEmptyDirective<OMPParallelSectionsDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
 }
 
 OMPTaskDirective *
 OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
                          Stmt *AssociatedStmt, bool HasCancel) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTaskDirective *Dir =
-      new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTaskDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
                                                 unsigned NumClauses,
                                                 EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPTaskDirective(NumClauses);
+  return createEmptyDirective<OMPTaskDirective>(C, NumClauses,
+                                                /*HasAssociatedStmt=*/true);
 }
 
 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
                                                      SourceLocation StartLoc,
                                                      SourceLocation EndLoc) {
-  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
-  OMPTaskyieldDirective *Dir =
-      new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
-  return Dir;
+  return new (C) OMPTaskyieldDirective(StartLoc, EndLoc);
 }
 
 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
                                                           EmptyShell) {
-  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
-  return new (Mem) OMPTaskyieldDirective();
+  return new (C) OMPTaskyieldDirective();
 }
 
 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
                                                  SourceLocation StartLoc,
                                                  SourceLocation EndLoc) {
-  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
-  OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
-  return Dir;
+  return new (C) OMPBarrierDirective(StartLoc, EndLoc);
 }
 
 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
                                                       EmptyShell) {
-  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
-  return new (Mem) OMPBarrierDirective();
+  return new (C) OMPBarrierDirective();
 }
 
 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
                                                    SourceLocation StartLoc,
                                                    SourceLocation EndLoc) {
-  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
-  OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
-  return Dir;
+  return new (C) OMPTaskwaitDirective(StartLoc, EndLoc);
 }
 
 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
                                                         EmptyShell) {
-  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
-  return new (Mem) OMPTaskwaitDirective();
+  return new (C) OMPTaskwaitDirective();
 }
 
 OMPTaskgroupDirective *OMPTaskgroupDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
-                                    sizeof(OMPClause *) * Clauses.size(),
-                                alignof(Stmt *));
-  void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
-  OMPTaskgroupDirective *Dir =
-      new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTaskgroupDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
   Dir->setReductionRef(ReductionRef);
-  Dir->setClauses(Clauses);
   return Dir;
 }
 
 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
                                                           unsigned NumClauses,
                                                           EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
-                                    sizeof(OMPClause *) * NumClauses,
-                                alignof(Stmt *));
-  void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
-  return new (Mem) OMPTaskgroupDirective(NumClauses);
+  return createEmptyDirective<OMPTaskgroupDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
 }
 
 OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     OpenMPDirectiveKind CancelRegion) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
-  void *Mem = C.Allocate(Size);
-  OMPCancellationPointDirective *Dir =
-      new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
+  auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc);
   Dir->setCancelRegion(CancelRegion);
   return Dir;
 }
 
 OMPCancellationPointDirective *
 OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
-  void *Mem = C.Allocate(Size);
-  return new (Mem) OMPCancellationPointDirective();
+  return new (C) OMPCancellationPointDirective();
 }
 
 OMPCancelDirective *
 OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
                            OpenMPDirectiveKind CancelRegion) {
-  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
-                                    sizeof(OMPClause *) * Clauses.size(),
-                                alignof(Stmt *));
-  void *Mem = C.Allocate(Size);
-  OMPCancelDirective *Dir =
-      new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
+  auto *Dir = createDirective<OMPCancelDirective>(
+      C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
+      EndLoc);
   Dir->setCancelRegion(CancelRegion);
   return Dir;
 }
 
 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
-                                    sizeof(OMPClause *) * NumClauses,
-                                alignof(Stmt *));
-  void *Mem = C.Allocate(Size);
-  return new (Mem) OMPCancelDirective(NumClauses);
+  return createEmptyDirective<OMPCancelDirective>(C, NumClauses);
 }
 
 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
                                              SourceLocation StartLoc,
                                              SourceLocation EndLoc,
                                              ArrayRef<OMPClause *> Clauses) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
-  OMPFlushDirective *Dir =
-      new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  return Dir;
+  return createDirective<OMPFlushDirective>(
+      C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
+      EndLoc);
 }
 
 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
                                                   unsigned NumClauses,
                                                   EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
-  return new (Mem) OMPFlushDirective(NumClauses);
+  return createEmptyDirective<OMPFlushDirective>(C, NumClauses);
 }
 
 OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPDepobjDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size(),
-                         alignof(OMPDepobjDirective));
-  auto *Dir = new (Mem) OMPDepobjDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  return Dir;
+  return createDirective<OMPDepobjDirective>(
+      C, Clauses, /*AssociatedStmt=*/nullptr,
+      /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPDepobjDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses,
-                         alignof(OMPDepobjDirective));
-  return new (Mem) OMPDepobjDirective(NumClauses);
+  return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);
 }
 
 OMPScanDirective *OMPScanDirective::Create(const ASTContext &C,
                                            SourceLocation StartLoc,
                                            SourceLocation EndLoc,
                                            ArrayRef<OMPClause *> Clauses) {
-  unsigned Size = llvm::alignTo(sizeof(OMPScanDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size(),
-                         alignof(OMPScanDirective));
-  auto *Dir = new (Mem) OMPScanDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  return Dir;
+  return createDirective<OMPScanDirective>(C, Clauses,
+                                           /*AssociatedStmt=*/nullptr,
+                                           /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C,
                                                 unsigned NumClauses,
                                                 EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPScanDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses,
-                         alignof(OMPScanDirective));
-  return new (Mem) OMPScanDirective(NumClauses);
+  return createEmptyDirective<OMPScanDirective>(C, NumClauses);
 }
 
 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
                                                  SourceLocation StartLoc,
                                                  SourceLocation EndLoc,
                                                  ArrayRef<OMPClause *> Clauses,
                                                  Stmt *AssociatedStmt) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
-  OMPOrderedDirective *Dir =
-      new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPOrderedDirective>(
+      C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt),
+      /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
                                                       unsigned NumClauses,
+                                                      bool IsStandalone,
                                                       EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
-  return new (Mem) OMPOrderedDirective(NumClauses);
+  return createEmptyDirective<OMPOrderedDirective>(C, NumClauses,
+                                                   !IsStandalone);
 }
 
 OMPAtomicDirective *OMPAtomicDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
     Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                         5 * sizeof(Stmt *));
-  OMPAtomicDirective *Dir =
-      new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPAtomicDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/4, StartLoc, EndLoc);
   Dir->setX(X);
   Dir->setV(V);
   Dir->setExpr(E);
   Dir->setUpdateExpr(UE);
   Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
   Dir->IsPostfixUpdate = IsPostfixUpdate;
   return Dir;
 }
 
 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
-  return new (Mem) OMPAtomicDirective(NumClauses);
+  return createEmptyDirective<OMPAtomicDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4);
 }
 
 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses,
                                                Stmt *AssociatedStmt) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTargetDirective *Dir =
-      new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPTargetDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPTargetDirective(NumClauses);
+  return createEmptyDirective<OMPTargetDirective>(C, NumClauses,
+                                                  /*HasAssociatedStmt=*/true);
 }
 
 OMPTargetParallelDirective *OMPTargetParallelDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTargetParallelDirective *Dir =
-      new (Mem) OMPTargetParallelDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetParallelDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
   Dir->setTaskReductionRefExpr(TaskRedRef);
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPTargetParallelDirective *
 OMPTargetParallelDirective::CreateEmpty(const ASTContext &C,
                                         unsigned NumClauses, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPTargetParallelDirective(NumClauses);
+  return createEmptyDirective<OMPTargetParallelDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
 }
 
 OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
-  OMPTargetParallelForDirective *Dir = new (Mem) OMPTargetParallelForDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetParallelForDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,
+      EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPTargetParallelForDirective *
 OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C,
                                            unsigned NumClauses,
                                            unsigned CollapsedNum, EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
-  return new (Mem) OMPTargetParallelForDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTargetParallelForDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1,
+      CollapsedNum);
 }
 
 OMPTargetDataDirective *OMPTargetDataDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
-  void *Mem = C.Allocate(
-      llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
-      sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTargetDataDirective *Dir =
-      new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPTargetDataDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
                                                             unsigned N,
                                                             EmptyShell) {
-  void *Mem = C.Allocate(
-      llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
-      sizeof(OMPClause *) * N + sizeof(Stmt *));
-  return new (Mem) OMPTargetDataDirective(N);
+  return createEmptyDirective<OMPTargetDataDirective>(
+      C, N, /*HasAssociatedStmt=*/true);
 }
 
 OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
-  void *Mem = C.Allocate(
-      llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
-      sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTargetEnterDataDirective *Dir =
-      new (Mem) OMPTargetEnterDataDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPTargetEnterDataDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPTargetEnterDataDirective *
 OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
                                          EmptyShell) {
-  void *Mem = C.Allocate(
-      llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
-      sizeof(OMPClause *) * N + sizeof(Stmt *));
-  return new (Mem) OMPTargetEnterDataDirective(N);
+  return createEmptyDirective<OMPTargetEnterDataDirective>(
+      C, N, /*HasAssociatedStmt=*/true);
 }
 
 OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
-  void *Mem = C.Allocate(
-      llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
-      sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTargetExitDataDirective *Dir =
-      new (Mem) OMPTargetExitDataDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPTargetExitDataDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPTargetExitDataDirective *
 OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
                                         EmptyShell) {
-  void *Mem = C.Allocate(
-      llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
-      sizeof(OMPClause *) * N + sizeof(Stmt *));
-  return new (Mem) OMPTargetExitDataDirective(N);
+  return createEmptyDirective<OMPTargetExitDataDirective>(
+      C, N, /*HasAssociatedStmt=*/true);
 }
 
 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
                                              SourceLocation StartLoc,
                                              SourceLocation EndLoc,
                                              ArrayRef<OMPClause *> Clauses,
                                              Stmt *AssociatedStmt) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTeamsDirective *Dir =
-      new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPTeamsDirective>(
+      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
                                                   unsigned NumClauses,
                                                   EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPTeamsDirective(NumClauses);
+  return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,
+                                                 /*HasAssociatedStmt=*/true);
 }
 
 OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, bool HasCancel) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
-  OMPTaskLoopDirective *Dir = new (Mem)
-      OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTaskLoopDirective>(
+      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
                                                         unsigned NumClauses,
                                                         unsigned CollapsedNum,
                                                         EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
-  return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTaskLoopDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum);
 }
 
 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
-  OMPTaskLoopSimdDirective *Dir = new (Mem)
-      OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
   Dir->setFinalsConditions(Exprs.FinalsConditions);
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPTaskLoopSimdDirective *
 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                       unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
-  return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTaskLoopSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum);
 }
 
 OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, bool HasCancel) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop));
-  OMPMasterTaskLoopDirective *Dir = new (Mem) OMPMasterTaskLoopDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create(
   Dir->setHasCancel(HasCancel);
   return Dir;
 }
 
 OMPMasterTaskLoopDirective *
 OMPMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
                                         unsigned NumClauses,
                                         unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop));
-  return new (Mem) OMPMasterTaskLoopDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPMasterTaskLoopDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum);
 }
 
 OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                 sizeof(Stmt *) *
-                     numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd));
-  auto *Dir = new (Mem) OMPMasterTaskLoopSimdDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,
+      EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create(
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPMasterTaskLoopSimdDirective *
 OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
                                             unsigned NumClauses,
                                             unsigned CollapsedNum, EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                 sizeof(Stmt *) *
-                     numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd));
-  return new (Mem) OMPMasterTaskLoopSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
 }
 
 OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, bool HasCancel) {
-  unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop));
-  auto *Dir = new (Mem) OMPParallelMasterTaskLoopDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
+      EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
   return Dir;
 }
 
 OMPParallelMasterTaskLoopDirective *
 OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
                                                 unsigned NumClauses,
                                                 unsigned CollapsedNum,
                                                 EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop));
-  return new (Mem) OMPParallelMasterTaskLoopDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop),
+      CollapsedNum);
 }
 
 OMPParallelMasterTaskLoopSimdDirective *
 OMPParallelMasterTaskLoopSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd));
-  auto *Dir = new (Mem) OMPParallelMasterTaskLoopSimdDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPParallelMasterTaskLoopSimdDirective::Create(
   return Dir;
 }
 
 OMPParallelMasterTaskLoopSimdDirective *
 OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     unsigned CollapsedNum,
                                                     EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd));
-  return new (Mem)
-      OMPParallelMasterTaskLoopSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
+      CollapsedNum);
 }
 
 OMPDistributeDirective *OMPDistributeDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_distribute));
-  OMPDistributeDirective *Dir = new (Mem)
-      OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPDistributeDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPDistributeDirective *OMPDistributeDirective::Create(
   Dir->setFinalsConditions(Exprs.FinalsConditions);
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPDistributeDirective *
 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                     unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_distribute));
-  return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPDistributeDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum);
 }
 
 OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTargetUpdateDirective *Dir =
-      new (Mem) OMPTargetUpdateDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
+                                                   /*NumChildren=*/0, StartLoc,
+                                                   EndLoc);
 }
 
 OMPTargetUpdateDirective *
 OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                       EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPTargetUpdateDirective(NumClauses);
+  return createEmptyDirective<OMPTargetUpdateDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true);
 }
 
 OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
-  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
-  OMPDistributeParallelForDirective *Dir =
-      new (Mem) OMPDistributeParallelForDirective(StartLoc, EndLoc,
-                                                  CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPDistributeParallelForDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
+      EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
   return Dir;
 }
 
 OMPDistributeParallelForDirective *
 OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
                                                unsigned NumClauses,
                                                unsigned CollapsedNum,
                                                EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
-  return new (Mem) OMPDistributeParallelForDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPDistributeParallelForDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1,
+      CollapsedNum);
 }
 
 OMPDistributeParallelForSimdDirective *
 OMPDistributeParallelForSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
-  OMPDistributeParallelForSimdDirective *Dir = new (Mem)
-      OMPDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
-                                            Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPDistributeParallelForSimdDirective::Create(
   return Dir;
 }
 
 OMPDistributeParallelForSimdDirective *
 OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
                                                    unsigned NumClauses,
                                                    unsigned CollapsedNum,
                                                    EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
-  return new (Mem)
-      OMPDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
+      CollapsedNum);
 }
 
 OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_distribute_simd));
-  OMPDistributeSimdDirective *Dir = new (Mem) OMPDistributeSimdDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPDistributeSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPDistributeSimdDirective *
 OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C,
                                         unsigned NumClauses,
                                         unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_distribute_simd));
-  return new (Mem) OMPDistributeSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPDistributeSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum);
 }
 
 OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
-  OMPTargetParallelForSimdDirective *Dir =
-      new (Mem) OMPTargetParallelForSimdDirective(StartLoc, EndLoc,
-                                                  CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
+      EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
   return Dir;
 }
 
 OMPTargetParallelForSimdDirective *
 OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C,
                                                unsigned NumClauses,
                                                unsigned CollapsedNum,
                                                EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
-  return new (Mem) OMPTargetParallelForSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTargetParallelForSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd),
+      CollapsedNum);
 }
 
 OMPTargetSimdDirective *
 OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
                                SourceLocation EndLoc, unsigned CollapsedNum,
                                ArrayRef<OMPClause *> Clauses,
                                Stmt *AssociatedStmt, const HelperExprs &Exprs) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_target_simd));
-  OMPTargetSimdDirective *Dir = new (Mem)
-      OMPTargetSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setCounters(Exprs.Counters);
   Dir->setPrivateCounters(Exprs.PrivateCounters);
   Dir->setInits(Exprs.Inits);
   Dir->setUpdates(Exprs.Updates);
   Dir->setFinals(Exprs.Finals);
   Dir->setDependentCounters(Exprs.DependentCounters);
   Dir->setDependentInits(Exprs.DependentInits);
   Dir->setFinalsConditions(Exprs.FinalsConditions);
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPTargetSimdDirective *
 OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                     unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                         sizeof(Stmt *) *
-                             numLoopChildren(CollapsedNum, OMPD_target_simd));
-  return new (Mem) OMPTargetSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTargetSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum);
 }
 
 OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
-  OMPTeamsDistributeDirective *Dir = new (Mem) OMPTeamsDistributeDirective(
-      StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTeamsDistributeDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
+      CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create(
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPTeamsDistributeDirective *
 OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
                                          unsigned NumClauses,
                                          unsigned CollapsedNum, EmptyShell) {
-  unsigned Size =
-      llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
-  return new (Mem) OMPTeamsDistributeDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTeamsDistributeDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum);
 }
 
 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                 sizeof(Stmt *) *
-                     numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd));
-  OMPTeamsDistributeSimdDirective *Dir =
-      new (Mem) OMPTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum,
-                                                Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,
+      EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create(
   Dir->setFinalsConditions(Exprs.FinalsConditions);
   Dir->setPreInits(Exprs.PreInits);
   return Dir;
 }
 
 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty(
     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
     EmptyShell) {
-  unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
-                                alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                 sizeof(Stmt *) *
-                     numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd));
-  return new (Mem) OMPTeamsDistributeSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);
 }
 
 OMPTeamsDistributeParallelForSimdDirective *
 OMPTeamsDistributeParallelForSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
-                            alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
-                 sizeof(Stmt *) *
-                     numLoopChildren(CollapsedNum,
-                                     OMPD_teams_distribute_parallel_for_simd));
-  OMPTeamsDistributeParallelForSimdDirective *Dir = new (Mem)
-      OMPTeamsDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
-                                                 Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTeamsDistributeParallelForSimdDirective::Create(
   return Dir;
 }
 
 OMPTeamsDistributeParallelForSimdDirective *
 OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
                                                         unsigned NumClauses,
                                                         unsigned CollapsedNum,
                                                         EmptyShell) {
-  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
-                            alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
-                 sizeof(Stmt *) *
-                     numLoopChildren(CollapsedNum,
-                                     OMPD_teams_distribute_parallel_for_simd));
-  return new (Mem)
-      OMPTeamsDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
+      CollapsedNum);
 }
 
 OMPTeamsDistributeParallelForDirective *
 OMPTeamsDistributeParallelForDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
-  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
-                            alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for));
-  OMPTeamsDistributeParallelForDirective *Dir = new (Mem)
-      OMPTeamsDistributeParallelForDirective(StartLoc, EndLoc, CollapsedNum,
-                                             Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTeamsDistributeParallelForDirective::Create(
   return Dir;
 }
 
 OMPTeamsDistributeParallelForDirective *
 OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     unsigned CollapsedNum,
                                                     EmptyShell) {
-  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
-                            alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for));
-  return new (Mem)
-      OMPTeamsDistributeParallelForDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
+      CollapsedNum);
 }
 
 OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
-  auto Size =
-      llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
-  OMPTargetTeamsDirective *Dir =
-      new (Mem) OMPTargetTeamsDirective(StartLoc, EndLoc, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
-  return Dir;
+  return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
+                                                  /*NumChildren=*/0, StartLoc,
+                                                  EndLoc);
 }
 
 OMPTargetTeamsDirective *
 OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                      EmptyShell) {
-  auto Size =
-      llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
-  void *Mem =
-      C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
-  return new (Mem) OMPTargetTeamsDirective(NumClauses);
+  return createEmptyDirective<OMPTargetTeamsDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true);
 }
 
 OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
-                            alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_target_teams_distribute));
-  OMPTargetTeamsDistributeDirective *Dir =
-      new (Mem) OMPTargetTeamsDistributeDirective(StartLoc, EndLoc, CollapsedNum,
-                                                  Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
+      EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create(
   return Dir;
 }
 
 OMPTargetTeamsDistributeDirective *
 OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
                                                unsigned NumClauses,
                                                unsigned CollapsedNum,
                                                EmptyShell) {
-  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
-                            alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-           numLoopChildren(CollapsedNum, OMPD_target_teams_distribute));
-  return new (Mem) OMPTargetTeamsDistributeDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_target_teams_distribute),
+      CollapsedNum);
 }
 
 OMPTargetTeamsDistributeParallelForDirective *
 OMPTargetTeamsDistributeParallelForDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
-  auto Size =
-      llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
-                    alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum,
-                          OMPD_target_teams_distribute_parallel_for));
-  OMPTargetTeamsDistributeParallelForDirective *Dir =
-      new (Mem) OMPTargetTeamsDistributeParallelForDirective(
-           StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
+          1,
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTargetTeamsDistributeParallelForDirective::Create(
   return Dir;
 }
 
 OMPTargetTeamsDistributeParallelForDirective *
 OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
                                                           unsigned NumClauses,
                                                           unsigned CollapsedNum,
                                                           EmptyShell) {
-  auto Size =
-      llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
-                    alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-           numLoopChildren(CollapsedNum,
-                           OMPD_target_teams_distribute_parallel_for));
-  return new (Mem)
-      OMPTargetTeamsDistributeParallelForDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
+          1,
+      CollapsedNum);
 }
 
 OMPTargetTeamsDistributeParallelForSimdDirective *
 OMPTargetTeamsDistributeParallelForSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  auto Size =
-      llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForSimdDirective),
-                    alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum,
-                          OMPD_target_teams_distribute_parallel_for_simd));
-  OMPTargetTeamsDistributeParallelForSimdDirective *Dir =
-      new (Mem) OMPTargetTeamsDistributeParallelForSimdDirective(
-           StartLoc, EndLoc, CollapsedNum, Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
+      C, Clauses, AssociatedStmt,
+                      OMPD_target_teams_distribute_parallel_for_simd),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTargetTeamsDistributeParallelForSimdDirective::Create(
   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
   return Dir;
 }
 
 OMPTargetTeamsDistributeParallelForSimdDirective *
 OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
     EmptyShell) {
-  auto Size =
-      llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForSimdDirective),
-                    alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum,
-                          OMPD_target_teams_distribute_parallel_for_simd));
-  return new (Mem) OMPTargetTeamsDistributeParallelForSimdDirective(
-      CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+                      OMPD_target_teams_distribute_parallel_for_simd),
+      CollapsedNum);
 }
 
 OMPTargetTeamsDistributeSimdDirective *
 OMPTargetTeamsDistributeSimdDirective::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     const HelperExprs &Exprs) {
-  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
-                            alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * Clauses.size() +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd));
-  OMPTargetTeamsDistributeSimdDirective *Dir = new (Mem)
-      OMPTargetTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum,
-                                            Clauses.size());
-  Dir->setClauses(Clauses);
-  Dir->setAssociatedStmt(AssociatedStmt);
+  auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
+      C, Clauses, AssociatedStmt,
+      numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
+      StartLoc, EndLoc, CollapsedNum);
   Dir->setIterationVariable(Exprs.IterationVarRef);
   Dir->setLastIteration(Exprs.LastIteration);
   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   Dir->setPreCond(Exprs.PreCond);
   Dir->setCond(Exprs.Cond);
   Dir->setInit(Exprs.Init);
   Dir->setInc(Exprs.Inc);
   Dir->setIsLastIterVariable(Exprs.IL);
OMPTargetTeamsDistributeSimdDirective::Create(
   return Dir;
 }
 
 OMPTargetTeamsDistributeSimdDirective *
 OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C,
                                                    unsigned NumClauses,
                                                    unsigned CollapsedNum,
                                                    EmptyShell) {
-  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
-                            alignof(OMPClause *));
-  void *Mem = C.Allocate(
-      Size + sizeof(OMPClause *) * NumClauses +
-      sizeof(Stmt *) *
-          numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd));
-  return new (Mem)
-      OMPTargetTeamsDistributeSimdDirective(CollapsedNum, NumClauses);
+  return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
+      C, NumClauses, /*HasAssociatedStmt=*/true,
+      numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
+      CollapsedNum);
 }

clang/lib/CodeGen/CGStmtOpenMP.cpp

static llvm::Function *emitOutlinedOrderedFunction(CodeGenModule &CGM,
   CGF.CapturedStmtInfo = &CapStmtInfo;
   llvm::Function *Fn = CGF.GenerateOpenMPCapturedStmtFunction(*S, Loc);
   Fn->setDoesNotRecurse();
   return Fn;
 }
 
 void CodeGenFunction::EmitOMPOrderedDirective(const OMPOrderedDirective &S) {
   if (S.hasClausesOfKind<OMPDependClause>()) {
-    assert(!S.getAssociatedStmt() &&
+    assert(!S.hasAssociatedStmt() &&
            "No associated statement must be in ordered depend construct.");
     for (const auto *DC : S.getClausesOfKind<OMPDependClause>())
       CGM.getOpenMPRuntime().emitDoacrossOrdered(*this, DC);
     return;
   }
   const auto *C = S.getSingleClause<OMPSIMDClause>();
   auto &&CodeGen = [&S, C, this](CodeGenFunction &CGF,
                                  PrePostActionTy &Action) {

clang/lib/Parse/ParseOpenMP.cpp

Parser::ParseOpenMPDeclareMapperDirective(AccessSpecifier AS) {
   // Consume ')'.
   IsCorrect &= !T.consumeClose();
   if (!IsCorrect) {
     SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch);
     return DeclGroupPtrTy();
   }
 
   // Enter scope.
-  OMPDeclareMapperDecl *DMD = Actions.ActOnOpenMPDeclareMapperDirectiveStart(
-      getCurScope(), Actions.getCurLexicalContext(), MapperId, MapperType,
-      Range.getBegin(), VName, AS);
   DeclarationNameInfo DirName;
   SourceLocation Loc = Tok.getLocation();
   unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
                         Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope;
   ParseScope OMPDirectiveScope(this, ScopeFlags);
   Actions.StartOpenMPDSABlock(OMPD_declare_mapper, DirName, getCurScope(), Loc);
 
   // Add the mapper variable declaration.
-  Actions.ActOnOpenMPDeclareMapperDirectiveVarDecl(
-      DMD, getCurScope(), MapperType, Range.getBegin(), VName);
+  ExprResult MapperVarRef = Actions.ActOnOpenMPDeclareMapperDirectiveVarDecl(
+      getCurScope(), MapperType, Range.getBegin(), VName);
 
   // Parse map clauses.
   SmallVector<OMPClause *, 6> Clauses;
   while (Tok.isNot(tok::annot_pragma_openmp_end)) {
     OpenMPClauseKind CKind = Tok.isAnnotation()
                                  ? OMPC_unknown
                                  : getOpenMPClauseKind(PP.getSpelling(Tok));
     Actions.StartOpenMPClause(CKind);
     OMPClause *Clause =
-        ParseOpenMPClause(OMPD_declare_mapper, CKind, Clauses.size() == 0);
+        ParseOpenMPClause(OMPD_declare_mapper, CKind, Clauses.empty());
     if (Clause)
       Clauses.push_back(Clause);
     else
       IsCorrect = false;
     // Skip ',' if any.
     if (Tok.is(tok::comma))
       ConsumeToken();
     Actions.EndOpenMPClause();
   }
   if (Clauses.empty()) {
     Diag(Tok, diag::err_omp_expected_clause)
         << getOpenMPDirectiveName(OMPD_declare_mapper);
     IsCorrect = false;
   }
 
   // Exit scope.
   Actions.EndOpenMPDSABlock(nullptr);
   OMPDirectiveScope.Exit();
-
-  DeclGroupPtrTy DGP =
-      Actions.ActOnOpenMPDeclareMapperDirectiveEnd(DMD, getCurScope(), Clauses);
+  DeclGroupPtrTy DG = Actions.ActOnOpenMPDeclareMapperDirective(
+      getCurScope(), Actions.getCurLexicalContext(), MapperId, MapperType,
+      Range.getBegin(), VName, AS, MapperVarRef.get(), Clauses);
   if (!IsCorrect)
     return DeclGroupPtrTy();
-  return DGP;
+
+  return DG;
 }
 
 TypeResult Parser::parseOpenMPDeclareMapperVarDecl(SourceRange &Range,
                                                    DeclarationName &Name,
                                                    AccessSpecifier AS) {
   // Parse the common declaration-specifiers piece.
   Parser::DeclSpecContext DSC = Parser::DeclSpecContext::DSC_type_specifier;
   DeclSpec DS(AttrFactory);

clang/lib/Sema/SemaExpr.cpp

if (LangOpts.OpenMP && DRD && !CurContext->containsDecl(D) &&
     Diag(D->getLocation(), diag::note_entity_declared_at) << D;
     return true;
   }
 
   // [OpenMP 5.0], 2.19.7.3. declare mapper Directive, Restrictions
   //  List-items in map clauses on this construct may only refer to the declared
   //  variable var and entities that could be referenced by a procedure defined
   //  at the same location
-  auto *DMD = dyn_cast<OMPDeclareMapperDecl>(CurContext);
-  if (LangOpts.OpenMP && DMD && !CurContext->containsDecl(D) &&
-      isa<VarDecl>(D)) {
+  if (LangOpts.OpenMP && isa<VarDecl>(D) &&
+      !isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(D))) {
     Diag(Loc, diag::err_omp_declare_mapper_wrong_var)
-        << DMD->getVarName().getAsString();
+        << getOpenMPDeclareMapperVarName();
     Diag(D->getLocation(), diag::note_entity_declared_at) << D;
     return true;
   }
 
   DiagnoseAvailabilityOfDecl(D, Locs, UnknownObjCClass, ObjCPropertyAccess,
                              AvoidPartialAvailabilityChecks, ClassReceiver);
 
   DiagnoseUnusedOfDecl(*this, D, Loc);

clang/lib/Sema/SemaOpenMP.cpp

struct SharingMapTy {
     llvm::DenseSet<CanonicalDeclPtr<Decl>> ImplicitTaskFirstprivates;
     /// List of globals marked as declare target link in this target region
     /// (isOpenMPTargetExecutionDirective(Directive) == true).
     llvm::SmallVector<DeclRefExpr *, 4> DeclareTargetLinkVarDecls;
     /// List of decls used in inclusive/exclusive clauses of the scan directive.
     llvm::DenseSet<CanonicalDeclPtr<Decl>> UsedInScanDirective;
     llvm::DenseMap<CanonicalDeclPtr<const Decl>, UsesAllocatorsDeclKind>
         UsesAllocatorsDecls;
+    Expr *DeclareMapperVar = nullptr;
     SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name,
                  Scope *CurScope, SourceLocation Loc)
         : Directive(DKind), DirectiveName(Name), CurScope(CurScope),
           ConstructLoc(Loc) {}
     SharingMapTy() = default;
   };
 
   using StackTy = SmallVector<SharingMapTy, 4>;
public:
   }
   Optional<UsesAllocatorsDeclKind> isUsesAllocatorsDecl(const Decl *D) const {
     const SharingMapTy &StackElem = getTopOfStack();
     auto I = StackElem.UsesAllocatorsDecls.find(D);
     if (I == StackElem.UsesAllocatorsDecls.end())
       return None;
     return I->getSecond();
   }
+
+  void addDeclareMapperVarRef(Expr *Ref) {
+    SharingMapTy &StackElem = getTopOfStack();
+    StackElem.DeclareMapperVar = Ref;
+  }
+  const Expr *getDeclareMapperVarRef() const {
+    const SharingMapTy *Top = getTopOfStackOrNull();
+    return Top ? Top->DeclareMapperVar : nullptr;
+  }
 };
 
 bool isImplicitTaskingRegion(OpenMPDirectiveKind DKind) {
   return isOpenMPParallelDirective(DKind) || isOpenMPTeamsDirective(DKind);
 }
 
 bool isImplicitOrExplicitTaskingRegion(OpenMPDirectiveKind DKind) {
   return isImplicitTaskingRegion(DKind) || isOpenMPTaskingDirective(DKind) ||
QualType Sema::ActOnOpenMPDeclareMapperType(SourceLocation TyLoc,
   //  The type must be of struct, union or class type in C and C++
   if (!MapperType->isStructureOrClassType() && !MapperType->isUnionType()) {
     Diag(TyLoc, diag::err_omp_mapper_wrong_type);
     return QualType();
   }
   return MapperType;
 }
 
-OMPDeclareMapperDecl *Sema::ActOnOpenMPDeclareMapperDirectiveStart(
+Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareMapperDirective(
     Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType,
     SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS,
-    Decl *PrevDeclInScope) {
+    Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses, Decl *PrevDeclInScope) {
   LookupResult Lookup(*this, Name, SourceLocation(), LookupOMPMapperName,
                       forRedeclarationInCurContext());
   // [OpenMP 5.0], 2.19.7.3 declare mapper Directive, Restrictions
   //  A mapper-identifier may not be redeclared in the current scope for the
   //  same type or for a type that is compatible according to the base language
   //  rules.
   llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes;
   OMPDeclareMapperDecl *PrevDMD = nullptr;
Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareMapperDirective(
   bool Invalid = false;
   if (I != PreviousRedeclTypes.end()) {
     Diag(StartLoc, diag::err_omp_declare_mapper_redefinition)
         << MapperType << Name;
     Diag(I->second, diag::note_previous_definition);
     Invalid = true;
   }
   auto *DMD = OMPDeclareMapperDecl::Create(Context, DC, StartLoc, Name,
-                                           MapperType, VN, PrevDMD);
+                                           MapperType, VN, Clauses, PrevDMD);
+  if (S)
+    PushOnScopeChains(DMD, S);
+  else
     DC->addDecl(DMD);
   DMD->setAccess(AS);
   if (Invalid)
     DMD->setInvalidDecl();
 
-  // Enter new function scope.
-  PushFunctionScope();
-  setFunctionHasBranchProtectedScope();
-
-  CurContext = DMD;
+  auto *VD = cast<DeclRefExpr>(MapperVarRef)->getDecl();
+  VD->setDeclContext(DMD);
+  VD->setLexicalDeclContext(DMD);
+  DMD->addDecl(VD);
+  DMD->setMapperVarRef(MapperVarRef);
 
-  return DMD;
+  return DeclGroupPtrTy::make(DeclGroupRef(DMD));
 }
 
-void Sema::ActOnOpenMPDeclareMapperDirectiveVarDecl(OMPDeclareMapperDecl *DMD,
-                                                    Scope *S,
-                                                    QualType MapperType,
-                                                    SourceLocation StartLoc,
-                                                    DeclarationName VN) {
-  VarDecl *VD = buildVarDecl(*this, StartLoc, MapperType, VN.getAsString());
+ExprResult
+Sema::ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S, QualType MapperType,
+  TypeSourceInfo *TInfo =
+      Context.getTrivialTypeSourceInfo(MapperType, StartLoc);
+  auto *VD = VarDecl::Create(Context, Context.getTranslationUnitDecl(),
+                             StartLoc, StartLoc, VN.getAsIdentifierInfo(),
+                             MapperType, TInfo, SC_None);
   if (S)
-    PushOnScopeChains(VD, S);
-  else
-    DMD->addDecl(VD);
-  Expr *MapperVarRefExpr = buildDeclRefExpr(*this, VD, MapperType, StartLoc);
-  DMD->setMapperVarRef(MapperVarRefExpr);
+    PushOnScopeChains(VD, S, /*AddToContext=*/false);
+  Expr *E = buildDeclRefExpr(*this, VD, MapperType, StartLoc);
+  DSAStack->addDeclareMapperVarRef(E);
+  return E;
 }
 
-Sema::DeclGroupPtrTy
-Sema::ActOnOpenMPDeclareMapperDirectiveEnd(OMPDeclareMapperDecl *D, Scope *S,
-                                           ArrayRef<OMPClause *> ClauseList) {
-  PopDeclContext();
-  PopFunctionScopeInfo();
-
-  if (D) {
-    if (S)
-      PushOnScopeChains(D, S, /*AddToContext=*/false);
-    D->CreateClauses(Context, ClauseList);
-  }
+bool Sema::isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const {
+  assert(LangOpts.OpenMP && "Expected OpenMP mode.");
+  const Expr *Ref = DSAStack->getDeclareMapperVarRef();
+  if (const auto *DRE = cast_or_null<DeclRefExpr>(Ref))
+    return VD->getCanonicalDecl() == DRE->getDecl()->getCanonicalDecl();
+  return true;
 
-  return DeclGroupPtrTy::make(DeclGroupRef(D));
+StringRef Sema::getOpenMPDeclareMapperVarName() const {
+  assert(LangOpts.OpenMP && "Expected OpenMP mode.");
+  return cast<DeclRefExpr>(DSAStack->getDeclareMapperVarRef())
+      ->getDecl()
+      ->getName();
 }
 
 OMPClause *Sema::ActOnOpenMPNumTeamsClause(Expr *NumTeams,
                                            SourceLocation StartLoc,
                                            SourceLocation LParenLoc,
                                            SourceLocation EndLoc) {
   Expr *ValExpr = NumTeams;
   Stmt *HelperValStmt = nullptr;

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (SubstMapperTy.isNull())
     return nullptr;
   // Create an instantiated copy of mapper.
   auto *PrevDeclInScope = D->getPrevDeclInScope();
   if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
     PrevDeclInScope = cast<OMPDeclareMapperDecl>(
         SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
             ->get<Decl *>());
   }
-  OMPDeclareMapperDecl *NewDMD = SemaRef.ActOnOpenMPDeclareMapperDirectiveStart(
-      /*S=*/nullptr, Owner, D->getDeclName(), SubstMapperTy, D->getLocation(),
-      VN, D->getAccess(), PrevDeclInScope);
-  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDMD);
-  SmallVector<OMPClause *, 6> Clauses;
   bool IsCorrect = true;
-  if (!RequiresInstantiation) {
-    // Copy the mapper variable.
-    NewDMD->setMapperVarRef(D->getMapperVarRef());
-    // Copy map clauses from the original mapper.
-    for (OMPClause *C : D->clauselists())
-      Clauses.push_back(C);
-  } else {
-    // Instantiate the mapper variable.
-    DeclarationNameInfo DirName;
-    SemaRef.StartOpenMPDSABlock(llvm::omp::OMPD_declare_mapper, DirName,
-                                /*S=*/nullptr,
-                                (*D->clauselist_begin())->getBeginLoc());
-    SemaRef.ActOnOpenMPDeclareMapperDirectiveVarDecl(
-        NewDMD, /*S=*/nullptr, SubstMapperTy, D->getLocation(), VN);
-    SemaRef.CurrentInstantiationScope->InstantiatedLocal(
-        cast<DeclRefExpr>(D->getMapperVarRef())->getDecl(),
-        cast<DeclRefExpr>(NewDMD->getMapperVarRef())->getDecl());
-    auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
-    Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
-                                     ThisContext);
-    // Instantiate map clauses.
-    for (OMPClause *C : D->clauselists()) {
-      auto *OldC = cast<OMPMapClause>(C);
-      SmallVector<Expr *, 4> NewVars;
-      for (Expr *OE : OldC->varlists()) {
-        Expr *NE = SemaRef.SubstExpr(OE, TemplateArgs).get();
-        if (!NE) {
-          IsCorrect = false;
-          break;
-        }
-        NewVars.push_back(NE);
-      }
-      if (!IsCorrect)
-        break;
-      NestedNameSpecifierLoc NewQualifierLoc =
-          SemaRef.SubstNestedNameSpecifierLoc(OldC->getMapperQualifierLoc(),
-                                              TemplateArgs);
-      CXXScopeSpec SS;
-      SS.Adopt(NewQualifierLoc);
-      DeclarationNameInfo NewNameInfo = SemaRef.SubstDeclarationNameInfo(
-          OldC->getMapperIdInfo(), TemplateArgs);
-      OMPVarListLocTy Locs(OldC->getBeginLoc(), OldC->getLParenLoc(),
-                           OldC->getEndLoc());
-      OMPClause *NewC = SemaRef.ActOnOpenMPMapClause(
-          OldC->getMapTypeModifiers(), OldC->getMapTypeModifiersLoc(), SS,
-          NewNameInfo, OldC->getMapType(), OldC->isImplicitMapType(),
-          OldC->getMapLoc(), OldC->getColonLoc(), NewVars, Locs);
-      Clauses.push_back(NewC);
-    }
-    SemaRef.EndOpenMPDSABlock(nullptr);
-  }
-  (void)SemaRef.ActOnOpenMPDeclareMapperDirectiveEnd(NewDMD, /*S=*/nullptr,
-                                                     Clauses);
+  SmallVector<OMPClause *, 6> Clauses;
+  ExprResult MapperVarRef = SemaRef.ActOnOpenMPDeclareMapperDirectiveVarDecl(
+      /*S=*/nullptr, SubstMapperTy, D->getLocation(), VN);
+      cast<DeclRefExpr>(MapperVarRef.get())->getDecl());
+    DeclarationNameInfo NewNameInfo =
+        SemaRef.SubstDeclarationNameInfo(OldC->getMapperIdInfo(), TemplateArgs);
   if (!IsCorrect)
     return nullptr;
+  Sema::DeclGroupPtrTy DG = SemaRef.ActOnOpenMPDeclareMapperDirective(
+      /*S=*/nullptr, Owner, D->getDeclName(), SubstMapperTy, D->getLocation(),
+      VN, D->getAccess(), MapperVarRef.get(), Clauses, PrevDeclInScope);
+  Decl *NewDMD = DG.get().getSingleDecl();
+  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDMD);
   return NewDMD;
 }
 
 Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
     OMPCapturedExprDecl * /*D*/) {
   llvm_unreachable("Should not be met in templates");
 }
 

clang/lib/Serialization/ASTReader.cpp

for (auto &Selector : Set.Selectors) {
         Selector.ScoreOrCondition = readExprRef();
       Selector.Properties.resize(readUInt32());
       for (auto &Property : Selector.Properties)
         Property.Kind = readEnum<llvm::omp::TraitProperty>();
     }
   }
   return &TI;
 }
+
+void ASTRecordReader::readOMPChildren(OMPChildren *Data) {
+  if (!Data)
+    return;
+  if (Reader->ReadingKind == ASTReader::Read_Stmt) {
+    // Skip NumClauses, NumChildren and HasAssociatedStmt fields.
+    skipInts(3);
+  }
+  SmallVector<OMPClause *, 4> Clauses(Data->getNumClauses());
+  for (unsigned I = 0, E = Data->getNumClauses(); I < E; ++I)
+    Clauses[I] = readOMPClause();
+  Data->setClauses(Clauses);
+  if (Data->hasAssociatedStmt())
+    Data->setAssociatedStmt(readStmt());
+  for (unsigned I = 0, E = Data->getNumChildren(); I < E; ++I)
+    Data->getChildren()[I] = readStmt();
+}

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
 
   if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
     if (T *Existing = ExistingRes)
       Reader.getContext().setPrimaryMergedDecl(static_cast<T *>(D),
                                                Existing->getCanonicalDecl());
 }
 
 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
+  Record.readOMPChildren(D->Data);
   VisitDecl(D);
-  unsigned NumVars = D->varlist_size();
-  SmallVector<Expr *, 16> Vars;
-  Vars.reserve(NumVars);
-  for (unsigned i = 0; i != NumVars; ++i) {
-    Vars.push_back(Record.readExpr());
-  }
-  D->setVars(Vars);
 }
 
 void ASTDeclReader::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
+  Record.readOMPChildren(D->Data);
   VisitDecl(D);
-  unsigned NumVars = D->varlist_size();
-  unsigned NumClauses = D->clauselist_size();
-  SmallVector<Expr *, 16> Vars;
-  Vars.reserve(NumVars);
-  for (unsigned i = 0; i != NumVars; ++i) {
-    Vars.push_back(Record.readExpr());
-  }
-  D->setVars(Vars);
-  SmallVector<OMPClause *, 8> Clauses;
-  Clauses.reserve(NumClauses);
-  for (unsigned I = 0; I != NumClauses; ++I)
-    Clauses.push_back(Record.readOMPClause());
-  D->setClauses(Clauses);
 }
 
 void ASTDeclReader::VisitOMPRequiresDecl(OMPRequiresDecl * D) {
+  Record.readOMPChildren(D->Data);
   VisitDecl(D);
-  unsigned NumClauses = D->clauselist_size();
-  SmallVector<OMPClause *, 8> Clauses;
-  Clauses.reserve(NumClauses);
-  for (unsigned I = 0; I != NumClauses; ++I)
-    Clauses.push_back(Record.readOMPClause());
-  D->setClauses(Clauses);
 }
 
 void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
   VisitValueDecl(D);
   D->setLocation(readSourceLocation());
   Expr *In = Record.readExpr();
   Expr *Out = Record.readExpr();
   D->setCombinerData(In, Out);
   Expr *Combiner = Record.readExpr();
   D->setCombiner(Combiner);
   Expr *Orig = Record.readExpr();
   Expr *Priv = Record.readExpr();
   D->setInitializerData(Orig, Priv);
   Expr *Init = Record.readExpr();
   auto IK = static_cast<OMPDeclareReductionDecl::InitKind>(Record.readInt());
   D->setInitializer(Init, IK);
   D->PrevDeclInScope = readDeclID();
 }
 
 void ASTDeclReader::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
+  Record.readOMPChildren(D->Data);
   VisitValueDecl(D);
-  D->setLocation(readSourceLocation());
-  Expr *MapperVarRefE = Record.readExpr();
-  D->setMapperVarRef(MapperVarRefE);
   D->VarName = Record.readDeclarationName();
   D->PrevDeclInScope = readDeclID();
-  unsigned NumClauses = D->clauselist_size();
-  SmallVector<OMPClause *, 8> Clauses;
-  Clauses.reserve(NumClauses);
-  for (unsigned I = 0; I != NumClauses; ++I)
-    Clauses.push_back(Record.readOMPClause());
-  D->setClauses(Clauses);
 }
 
 void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
   VisitVarDecl(D);
 }
 
 //===----------------------------------------------------------------------===//
 // Attribute Reading
Decl *ASTReader::ReadDeclRecord(DeclID ID) {
   case DECL_CXX_CTOR_INITIALIZERS:
     Error("attempt to read a C++ ctor initializer record as a declaration");
     return nullptr;
   case DECL_IMPORT:
     // Note: last entry of the ImportDecl record is the number of stored source
     // locations.
     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
     break;
-  case DECL_OMP_THREADPRIVATE:
-    D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record.readInt());
+  case DECL_OMP_THREADPRIVATE: {
+    Record.skipInts(1);
+    unsigned NumChildren = Record.readInt();
+    Record.skipInts(1);
+    D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, NumChildren);
     break;
+  }
   case DECL_OMP_ALLOCATE: {
-    unsigned NumVars = Record.readInt();
     unsigned NumClauses = Record.readInt();
+    unsigned NumVars = Record.readInt();
+    Record.skipInts(1);
     D = OMPAllocateDecl::CreateDeserialized(Context, ID, NumVars, NumClauses);
     break;
   }
-  case DECL_OMP_REQUIRES:
-    D = OMPRequiresDecl::CreateDeserialized(Context, ID, Record.readInt());
+  case DECL_OMP_REQUIRES: {
+    unsigned NumClauses = Record.readInt();
+    Record.skipInts(2);
+    D = OMPRequiresDecl::CreateDeserialized(Context, ID, NumClauses);
     break;
+  }
   case DECL_OMP_DECLARE_REDUCTION:
     D = OMPDeclareReductionDecl::CreateDeserialized(Context, ID);
     break;
-  case DECL_OMP_DECLARE_MAPPER:
-    D = OMPDeclareMapperDecl::CreateDeserialized(Context, ID, Record.readInt());
+  case DECL_OMP_DECLARE_MAPPER: {
+    unsigned NumClauses = Record.readInt();
+    Record.skipInts(2);
+    D = OMPDeclareMapperDecl::CreateDeserialized(Context, ID, NumClauses);
     break;
+  }
   case DECL_OMP_CAPTUREDEXPR:
     D = OMPCapturedExprDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_PRAGMA_COMMENT:
     D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record.readInt());
     break;
   case DECL_PRAGMA_DETECT_MISMATCH:
     D = PragmaDetectMismatchDecl::CreateDeserialized(Context, ID,

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
   E->SrcExpr = Record.readSubExpr();
 }
 
 //===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
 
 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
+  Record.readOMPChildren(E->Data);
   E->setLocStart(readSourceLocation());
   E->setLocEnd(readSourceLocation());
-  SmallVector<OMPClause *, 5> Clauses;
-  for (unsigned i = 0; i < E->getNumClauses(); ++i)
-    Clauses.push_back(Record.readOMPClause());
-  E->setClauses(Clauses);
-  if (E->hasAssociatedStmt())
-    E->setAssociatedStmt(Record.readSubStmt());
 }
 
 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
   VisitStmt(D);
-  // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
-  Record.skipInts(2);
+  // Field CollapsedNum was read in ReadStmtFromStream.
+  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setIterationVariable(Record.readSubExpr());
-  D->setLastIteration(Record.readSubExpr());
-  D->setCalcLastIteration(Record.readSubExpr());
-  D->setPreCond(Record.readSubExpr());
-  D->setCond(Record.readSubExpr());
-  D->setInit(Record.readSubExpr());
-  D->setInc(Record.readSubExpr());
-  D->setPreInits(Record.readSubStmt());
-  if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
-      isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
-      isOpenMPDistributeDirective(D->getDirectiveKind())) {
-    D->setIsLastIterVariable(Record.readSubExpr());
-    D->setLowerBoundVariable(Record.readSubExpr());
-    D->setUpperBoundVariable(Record.readSubExpr());
-    D->setStrideVariable(Record.readSubExpr());
-    D->setEnsureUpperBound(Record.readSubExpr());
-    D->setNextLowerBound(Record.readSubExpr());
-    D->setNextUpperBound(Record.readSubExpr());
-    D->setNumIterations(Record.readSubExpr());
-  }
-  if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
-    D->setPrevLowerBoundVariable(Record.readSubExpr());
-    D->setPrevUpperBoundVariable(Record.readSubExpr());
-    D->setDistInc(Record.readSubExpr());
-    D->setPrevEnsureUpperBound(Record.readSubExpr());
-    D->setCombinedLowerBoundVariable(Record.readSubExpr());
-    D->setCombinedUpperBoundVariable(Record.readSubExpr());
-    D->setCombinedEnsureUpperBound(Record.readSubExpr());
-    D->setCombinedInit(Record.readSubExpr());
-    D->setCombinedCond(Record.readSubExpr());
-    D->setCombinedNextLowerBound(Record.readSubExpr());
-    D->setCombinedNextUpperBound(Record.readSubExpr());
-    D->setCombinedDistCond(Record.readSubExpr());
-    D->setCombinedParForInDistCond(Record.readSubExpr());
-  }
-  SmallVector<Expr *, 4> Sub;
-  unsigned CollapsedNum = D->getCollapsedNumber();
-  Sub.reserve(CollapsedNum);
-  for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.readSubExpr());
-  D->setCounters(Sub);
-  Sub.clear();
-  for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.readSubExpr());
-  D->setPrivateCounters(Sub);
-  Sub.clear();
-  for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.readSubExpr());
-  D->setInits(Sub);
-  Sub.clear();
-  for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.readSubExpr());
-  D->setUpdates(Sub);
-  Sub.clear();
-  for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.readSubExpr());
-  D->setFinals(Sub);
-  Sub.clear();
-  for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.readSubExpr());
-  D->setDependentCounters(Sub);
-  Sub.clear();
-  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::VisitOMPParallelDirective(OMPParallelDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
   D->DirName = Record.readDeclarationNameInfo();
 }
 
 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPParallelForSimdDirective(
     OMPParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPParallelMasterDirective(
     OMPParallelMasterDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitOMPParallelSectionsDirective(
     OMPParallelSectionsDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setReductionRef(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setX(Record.readSubExpr());
-  D->setV(Record.readSubExpr());
-  D->setExpr(Record.readSubExpr());
-  D->setUpdateExpr(Record.readSubExpr());
-  D->IsXLHSInRHSPart = Record.readInt() != 0;
-  D->IsPostfixUpdate = Record.readInt() != 0;
+  D->IsXLHSInRHSPart = Record.readBool();
+  D->IsPostfixUpdate = Record.readBool();
 }
 
 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
   VisitStmt(D);
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
     OMPTargetEnterDataDirective *D) {
   VisitStmt(D);
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetExitDataDirective(
     OMPTargetExitDataDirective *D) {
   VisitStmt(D);
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetParallelDirective(
     OMPTargetParallelDirective *D) {
   VisitStmt(D);
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
   D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPTargetParallelForDirective(
     OMPTargetParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPCancellationPointDirective(
     OMPCancellationPointDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
-  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
+  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
 }
 
 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
+  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
 }
 
 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
     OMPMasterTaskLoopDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
     OMPMasterTaskLoopSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
     OMPParallelMasterTaskLoopDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
     OMPParallelMasterTaskLoopSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
   VisitStmt(D);
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
     OMPDistributeParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
     OMPDistributeParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPDistributeSimdDirective(

 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
     OMPTeamsDistributeParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
     OMPTeamsDistributeParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
   VisitStmt(D);
-  // The NumClauses field was read in ReadStmtFromStream.
-  Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
     OMPTargetTeamsDistributeDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
     OMPTargetTeamsDistributeParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setTaskReductionRefExpr(Record.readSubExpr());
-  D->setHasCancel(Record.readInt());
+  D->setHasCancel(Record.readBool());
 }
 
 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
     OMPTargetTeamsDistributeParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
while (true) {
     case STMT_OMP_PARALLEL_DIRECTIVE:
       S =
         OMPParallelDirective::CreateEmpty(Context,
                                           Record[ASTStmtReader::NumStmtFields],
                                           Empty);
       break;
 
     case STMT_OMP_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
                                         CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_FOR_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                        Empty);
       break;
     }
 
     case STMT_OMP_FOR_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                            Empty);
       break;
     }
 
     case STMT_OMP_SECTIONS_DIRECTIVE:
       S = OMPSectionsDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
case STMT_OMP_MASTER_DIRECTIVE:
       break;
 
     case STMT_OMP_CRITICAL_DIRECTIVE:
       S = OMPCriticalDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
                                                CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
                                                    CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_PARALLEL_MASTER_DIRECTIVE:
       S = OMPParallelMasterDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
case STMT_OMP_DEPOBJ_DIRECTIVE:
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_SCAN_DIRECTIVE:
       S = OMPScanDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
-    case STMT_OMP_ORDERED_DIRECTIVE:
-      S = OMPOrderedDirective::CreateEmpty(
-          Context, Record[ASTStmtReader::NumStmtFields], Empty);
+    case STMT_OMP_ORDERED_DIRECTIVE: {
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
+      bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2];
+      S = OMPOrderedDirective::CreateEmpty(Context, NumClauses,
+                                           !HasAssociatedStmt, Empty);
       break;
+    }
 
     case STMT_OMP_ATOMIC_DIRECTIVE:
       S = OMPAtomicDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_TARGET_DIRECTIVE:
       S = OMPTargetDirective::CreateEmpty(
case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
       break;
 
     case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
       S = OMPTargetParallelDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
                                                      CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
       S = OMPTargetUpdateDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
       break;
 
     case STMT_OMP_CANCEL_DIRECTIVE:
       S = OMPCancelDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_TASKLOOP_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                             Empty);
       break;
     }
 
     case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
                                                 CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_MASTER_TASKLOOP_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
                                                   CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPMasterTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
                                                       CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPParallelMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
                                                           CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(
           Context, NumClauses, CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                               Empty);
       break;
     }
 
     case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
                                                          CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses,
                                                              CollapsedNum,
                                                              Empty);
       break;
     }
 
     case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
                                                   CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
                                                          CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
                                               Empty);
       break;
     }
 
      case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
        S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
                                                     CollapsedNum, Empty);
        break;
     }
 
     case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
-      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
-      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
                                                        CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
           Context, NumClauses, CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
           Context, NumClauses, CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TARGET_TEAMS_DIRECTIVE:
       S = OMPTargetTeamsDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
                                                          CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
           Context, NumClauses, CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
           Context, NumClauses, CollapsedNum, Empty);
       break;
     }
 
     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
-      auto NumClauses = Record[ASTStmtReader::NumStmtFields];
-      auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
+      unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
+      unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
       S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
           Context, NumClauses, CollapsedNum, Empty);
       break;
     }
 
     case EXPR_CXX_OPERATOR_CALL:
       S = CXXOperatorCallExpr::CreateEmpty(
           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],

clang/lib/Serialization/ASTWriter.cpp

for (const auto &Selector : Set.Selectors) {
       if (Selector.ScoreOrCondition)
         writeExprRef(Selector.ScoreOrCondition);
       writeUInt32(Selector.Properties.size());
       for (const auto &Property : Selector.Properties)
         writeEnum(Property.Kind);
     }
   }
 }
+
+void ASTRecordWriter::writeOMPChildren(OMPChildren *Data) {
+  if (!Data)
+    return;
+  writeUInt32(Data->getNumClauses());
+  writeUInt32(Data->getNumChildren());
+  writeBool(Data->hasAssociatedStmt());
+  for (unsigned I = 0, E = Data->getNumClauses(); I < E; ++I)
+    writeOMPClause(Data->getClauses()[I]);
+  if (Data->hasAssociatedStmt())
+    AddStmt(Data->getAssociatedStmt());
+  for (unsigned I = 0, E = Data->getNumChildren(); I < E; ++I)
+    AddStmt(Data->getChildren()[I]);
+}

clang/lib/Serialization/ASTWriterDecl.cpp

if (MostRecent != First) {
     (void)Writer.GetDeclRef(MostRecent);
   } else {
     // We use the sentinel value 0 to indicate an only declaration.
     Record.push_back(0);
   }
 }
 
 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
-  Record.push_back(D->varlist_size());
+  Record.writeOMPChildren(D->Data);
   VisitDecl(D);
-  for (auto *I : D->varlists())
-    Record.AddStmt(I);
   Code = serialization::DECL_OMP_THREADPRIVATE;
 }
 
 void ASTDeclWriter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
-  Record.push_back(D->varlist_size());
-  Record.push_back(D->clauselist_size());
+  Record.writeOMPChildren(D->Data);
   VisitDecl(D);
-  for (auto *I : D->varlists())
-    Record.AddStmt(I);
-  for (OMPClause *C : D->clauselists())
-    Record.writeOMPClause(C);
   Code = serialization::DECL_OMP_ALLOCATE;
 }
 
 void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
-  Record.push_back(D->clauselist_size());
+  Record.writeOMPChildren(D->Data);
   VisitDecl(D);
-  for (OMPClause *C : D->clauselists())
-    Record.writeOMPClause(C);
   Code = serialization::DECL_OMP_REQUIRES;
 }
 
 void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
   VisitValueDecl(D);
   Record.AddSourceLocation(D->getBeginLoc());
   Record.AddStmt(D->getCombinerIn());
   Record.AddStmt(D->getCombinerOut());
   Record.AddStmt(D->getCombiner());
   Record.AddStmt(D->getInitOrig());
   Record.AddStmt(D->getInitPriv());
   Record.AddStmt(D->getInitializer());
   Record.push_back(D->getInitializerKind());
   Record.AddDeclRef(D->getPrevDeclInScope());
   Code = serialization::DECL_OMP_DECLARE_REDUCTION;
 }
 
 void ASTDeclWriter::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
-  Record.push_back(D->clauselist_size());
+  Record.writeOMPChildren(D->Data);
   VisitValueDecl(D);
-  Record.AddSourceLocation(D->getBeginLoc());
-  Record.AddStmt(D->getMapperVarRef());
   Record.AddDeclarationName(D->getVarName());
   Record.AddDeclRef(D->getPrevDeclInScope());
-  for (OMPClause *C : D->clauselists())
-    Record.writeOMPClause(C);
   Code = serialization::DECL_OMP_DECLARE_MAPPER;
 }
 
 void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
   VisitVarDecl(D);
   Code = serialization::DECL_OMP_CAPTUREDEXPR;
 }
 

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getLeaveLoc());
   Code = serialization::STMT_SEH_LEAVE;
 }
 
 //===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
+
 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
+  Record.writeOMPChildren(E->Data);
   Record.AddSourceLocation(E->getBeginLoc());
   Record.AddSourceLocation(E->getEndLoc());
-  for (unsigned i = 0; i < E->getNumClauses(); ++i) {
-    Record.writeOMPClause(E->getClause(i));
-  }
-  if (E->hasAssociatedStmt())
-    Record.AddStmt(E->getAssociatedStmt());
 }
 
 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
-  Record.push_back(D->getCollapsedNumber());
+  Record.writeUInt32(D->getCollapsedNumber());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getIterationVariable());
-  Record.AddStmt(D->getLastIteration());
-  Record.AddStmt(D->getCalcLastIteration());
-  Record.AddStmt(D->getPreCond());
-  Record.AddStmt(D->getCond());
-  Record.AddStmt(D->getInit());
-  Record.AddStmt(D->getInc());
-  Record.AddStmt(D->getPreInits());
-  if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
-      isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
-      isOpenMPDistributeDirective(D->getDirectiveKind())) {
-    Record.AddStmt(D->getIsLastIterVariable());
-    Record.AddStmt(D->getLowerBoundVariable());
-    Record.AddStmt(D->getUpperBoundVariable());
-    Record.AddStmt(D->getStrideVariable());
-    Record.AddStmt(D->getEnsureUpperBound());
-    Record.AddStmt(D->getNextLowerBound());
-    Record.AddStmt(D->getNextUpperBound());
-    Record.AddStmt(D->getNumIterations());
-  }
-  if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
-    Record.AddStmt(D->getPrevLowerBoundVariable());
-    Record.AddStmt(D->getPrevUpperBoundVariable());
-    Record.AddStmt(D->getDistInc());
-    Record.AddStmt(D->getPrevEnsureUpperBound());
-    Record.AddStmt(D->getCombinedLowerBoundVariable());
-    Record.AddStmt(D->getCombinedUpperBoundVariable());
-    Record.AddStmt(D->getCombinedEnsureUpperBound());
-    Record.AddStmt(D->getCombinedInit());
-    Record.AddStmt(D->getCombinedCond());
-    Record.AddStmt(D->getCombinedNextLowerBound());
-    Record.AddStmt(D->getCombinedNextUpperBound());
-    Record.AddStmt(D->getCombinedDistCond());
-    Record.AddStmt(D->getCombinedParForInDistCond());
-  }
-  for (auto I : D->counters()) {
-    Record.AddStmt(I);
-  }
-  for (auto I : D->private_counters()) {
-    Record.AddStmt(I);
-  }
-  for (auto I : D->inits()) {
-    Record.AddStmt(I);
-  }
-  for (auto I : D->updates()) {
-    Record.AddStmt(I);
-  }
-  for (auto I : D->finals()) {
-    Record.AddStmt(I);
-  }
-  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::VisitOMPParallelDirective(OMPParallelDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_FOR_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Record.AddDeclarationNameInfo(D->getDirectiveName());
   Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPParallelForSimdDirective(
     OMPParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPParallelMasterDirective(
     OMPParallelMasterDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
   Code = serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPParallelSectionsDirective(
     OMPParallelSectionsDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_TASK_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getX());
-  Record.AddStmt(D->getV());
-  Record.AddStmt(D->getExpr());
-  Record.AddStmt(D->getUpdateExpr());
-  Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
-  Record.push_back(D->isPostfixUpdate() ? 1 : 0);
+  Record.writeBool(D->isXLHSInRHSPart());
+  Record.writeBool(D->isPostfixUpdate());
   Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
     OMPTargetEnterDataDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetExitDataDirective(
     OMPTargetExitDataDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetParallelDirective(
     OMPTargetParallelDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
   Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetParallelForDirective(
     OMPTargetParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.AddStmt(D->getReductionRef());
   Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_DEPOBJ_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPScanDirective(OMPScanDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_SCAN_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPCancellationPointDirective(
     OMPCancellationPointDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
-  Record.push_back(uint64_t(D->getCancelRegion()));
+  Record.writeEnum(D->getCancelRegion());
   Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
-  Record.push_back(uint64_t(D->getCancelRegion()));
+  Record.writeEnum(D->getCancelRegion());
   Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(
     OMPMasterTaskLoopDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
     OMPMasterTaskLoopSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
     OMPParallelMasterTaskLoopDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
     OMPParallelMasterTaskLoopSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
     OMPDistributeParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
     OMPDistributeParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
 }
void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
     OMPTeamsDistributeParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
     OMPTeamsDistributeParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
   VisitStmt(D);
-  Record.push_back(D->getNumClauses());
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
     OMPTargetTeamsDistributeDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
     OMPTargetTeamsDistributeParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  Record.AddStmt(D->getTaskReductionRefExpr());
-  Record.push_back(D->hasCancel() ? 1 : 0);
+  Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
     OMPTargetTeamsDistributeParallelForSimdDirective *D) {
   VisitOMPLoopDirective(D);
   Code = serialization::
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;

clang/test/AST/ast-dump-openmp-ordered.c

 // CHECK-NEXT:         | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:         | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT:         | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | `-CompoundStmt {{.*}} <col:31, line:18:3>
 // CHECK-NEXT:         | |   `-OMPOrderedDirective {{.*}} <line:17:1, col:35> openmp_standalone_directive
-// CHECK-NEXT:         | |     |-OMPDependClause {{.*}} <col:21, <invalid sloc>>
-// CHECK-NEXT:         | |     `-<<<NULL>>>
+// CHECK-NEXT:         | |     `-OMPDependClause {{.*}} <col:21, <invalid sloc>>
 // CHECK-NEXT:         | |-ImplicitParamDecl {{.*}} <line:15:1> col:1 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-ordered.c:15:1) *const restrict'
 // CHECK-NEXT:         | `-VarDecl {{.*}} <line:16:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT:         |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT:         `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'