[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

147

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 ↗

(On Diff #282649)

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 ↗

(On Diff #282677)

The refactoring of ActOnOpenMPDeclareMapperDirective seems unrelated.

[ABataev]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

3329 ↗

(On Diff #282677)

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/StmtOpenMP.h

 #define LLVM_CLANG_AST_STMTOPENMP_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"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/PointerUnion.h"
+#include "llvm/Support/TrailingObjects.h"
 
 namespace clang {
 
 //===----------------------------------------------------------------------===//
 // AST classes for directives.
 //===----------------------------------------------------------------------===//
 
+/// Contains data for OpenMP executable 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;
+  /// 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) {}
+
+public:
+  static OMPChildren *Create(const ASTContext &C,
+                             ArrayRef<OMPClause *> Clauses);
+  static OMPChildren *Create(const ASTContext &C, ArrayRef<OMPClause *> Clauses,
+                             Stmt *S, unsigned NumChildren = 0);
+  static OMPChildren *CreateEmpty(const ASTContext &C, unsigned NumClauses,
+                                  bool HasAssociatedStmt = false,
+                                  unsigned NumChildren = 0);
+
+  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]);
+  }
+};
+
 /// 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)
+                         OMPChildren *Data = nullptr)
       : 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)), Data(Data) {}
 
-  /// 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) {
+    auto *Data = OMPChildren::Create(C, Clauses, AssociatedStmt, NumChildren);
+    return new (C) T(std::forward<Params>(P)..., Data);
+  }
+
+  template <typename T, typename... Params>
+  static T *createEmptyDirective(const ASTContext &C, unsigned NumClauses,
+                                 bool HasAssociatedStmt, unsigned NumChildren,
+                                 Params &&... P) {
+    auto *Data =
+        OMPChildren::CreateEmpty(C, NumClauses, HasAssociatedStmt, NumChildren);
+    return new (C) T(std::forward<Params>(P)..., Data);
+  }
 
-  /// 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) {
+    auto *Data =
+        OMPChildren::CreateEmpty(C, NumClauses, HasAssociatedStmt, NumChildren);
+    return new (C) T(Data);
   }
 
 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 *> {
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.
   ///
   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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                       unsigned NumClauses)
+                       OMPChildren *Data)
       : OMPExecutableDirective(this, OMPParallelDirectiveClass,
                                llvm::omp::OMPD_parallel, StartLoc, EndLoc,
-                               NumClauses, 1),
-        HasCancel(false) {}
+                               Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPParallelDirective(unsigned NumClauses)
+  explicit OMPParallelDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPParallelDirectiveClass,
                                llvm::omp::OMPD_parallel, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        HasCancel(false) {}
+                               SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   template <typename T>
   OMPLoopDirective(const T *That, 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, OMPChildren *Data)
+      : OMPExecutableDirective(That, SC, Kind, StartLoc, EndLoc, Data),
         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;
+    Data->getChildren()[CalcLastIterationOffset] = CLI;
   }
-  void setCond(Expr *Cond) {
-    *std::next(child_begin(), CondOffset) = Cond;
-  }
-  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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                   unsigned CollapsedNum, unsigned NumClauses)
+                   unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPSimdDirectiveClass, llvm::omp::OMPD_simd,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses) {}
+                         StartLoc, EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPSimdDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPSimdDirectiveClass, llvm::omp::OMPD_simd,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                  unsigned CollapsedNum, unsigned NumClauses)
+                  unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPForDirectiveClass, llvm::omp::OMPD_for,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         StartLoc, EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPForDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPForDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPForDirectiveClass, llvm::omp::OMPD_for,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+                         Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPForSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                      unsigned CollapsedNum, unsigned NumClauses)
+                      unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPForSimdDirectiveClass,
                          llvm::omp::OMPD_for_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPForSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPForSimdDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPForSimdDirectiveClass,
                          llvm::omp::OMPD_for_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                       unsigned NumClauses)
+                       OMPChildren *Data)
       : OMPExecutableDirective(this, OMPSectionsDirectiveClass,
                                llvm::omp::OMPD_sections, StartLoc, EndLoc,
-                               NumClauses, 1),
-        HasCancel(false) {}
+                               Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPSectionsDirective(unsigned NumClauses)
+  explicit OMPSectionsDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPSectionsDirectiveClass,
                                llvm::omp::OMPD_sections, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        HasCancel(false) {}
+                               SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  OMPSectionDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+  OMPSectionDirective(SourceLocation StartLoc, SourceLocation EndLoc,
+                      OMPChildren *Data)
       : OMPExecutableDirective(this, OMPSectionDirectiveClass,
-                               llvm::omp::OMPD_section, StartLoc, EndLoc, 0, 1),
-        HasCancel(false) {}
+                               llvm::omp::OMPD_section, StartLoc, EndLoc,
+                               Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPSectionDirective()
+  explicit OMPSectionDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPSectionDirectiveClass,
                                llvm::omp::OMPD_section, SourceLocation(),
-                               SourceLocation(), 0, 1),
-        HasCancel(false) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPSingleDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
+                     OMPChildren *Data)
       : OMPExecutableDirective(this, OMPSingleDirectiveClass,
-                               llvm::omp::OMPD_single, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+                               llvm::omp::OMPD_single, StartLoc, EndLoc, Data) {
+  }
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPSingleDirective(unsigned NumClauses)
+  explicit OMPSingleDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPSingleDirectiveClass,
                                llvm::omp::OMPD_single, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  OMPMasterDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+  OMPMasterDirective(SourceLocation StartLoc, SourceLocation EndLoc,
+                     OMPChildren *Data)
       : OMPExecutableDirective(this, OMPMasterDirectiveClass,
-                               llvm::omp::OMPD_master, StartLoc, EndLoc, 0, 1) {
+                               llvm::omp::OMPD_master, StartLoc, EndLoc, Data) {
   }
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPMasterDirective()
+  explicit OMPMasterDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPMasterDirectiveClass,
                                llvm::omp::OMPD_master, SourceLocation(),
-                               SourceLocation(), 0, 1) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPCriticalDirective(const DeclarationNameInfo &Name, SourceLocation StartLoc,
-                       SourceLocation EndLoc, unsigned NumClauses)
+                       SourceLocation EndLoc, OMPChildren *Data)
       : OMPExecutableDirective(this, OMPCriticalDirectiveClass,
                                llvm::omp::OMPD_critical, StartLoc, EndLoc,
-                               NumClauses, 1),
+                               Data),
         DirName(Name) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPCriticalDirective(unsigned NumClauses)
+  explicit OMPCriticalDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPCriticalDirectiveClass,
                                llvm::omp::OMPD_critical, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        DirName() {}
+                               SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPParallelForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                          unsigned CollapsedNum, unsigned NumClauses)
+                          unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelForDirectiveClass,
                          llvm::omp::OMPD_parallel_for, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPParallelForDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPParallelForDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelForDirectiveClass,
                          llvm::omp::OMPD_parallel_for, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPParallelForSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                              unsigned CollapsedNum, unsigned NumClauses)
+                              unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_for_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPParallelForSimdDirective(unsigned CollapsedNum,
-                                       unsigned NumClauses)
+  explicit OMPParallelForSimdDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_for_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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;
-
-  /// Special reference expression for handling task reduction. Used to store
-  /// the taskgroup descriptor returned by the runtime functions.
-  Expr *TaskRedRef = nullptr;
+  friend class OMPExecutableDirective;
 
   OMPParallelMasterDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned NumClauses)
+                             OMPChildren *Data)
       : OMPExecutableDirective(this, OMPParallelMasterDirectiveClass,
                                llvm::omp::OMPD_parallel_master, StartLoc,
-                               EndLoc, NumClauses, 1) {}
+                               EndLoc, Data) {}
 
-  explicit OMPParallelMasterDirective(unsigned NumClauses)
+  explicit OMPParallelMasterDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPParallelMasterDirectiveClass,
                                llvm::omp::OMPD_parallel_master,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               1) {}
+                               SourceLocation(), SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPParallelSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                               unsigned NumClauses)
+                               OMPChildren *Data)
       : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
                                llvm::omp::OMPD_parallel_sections, StartLoc,
-                               EndLoc, NumClauses, 1),
-        HasCancel(false) {}
+                               EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPParallelSectionsDirective(unsigned NumClauses)
+  explicit OMPParallelSectionsDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
                                llvm::omp::OMPD_parallel_sections,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               1),
-        HasCancel(false) {}
+                               SourceLocation(), SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTaskDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                   unsigned NumClauses)
+                   OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTaskDirectiveClass,
-                               llvm::omp::OMPD_task, StartLoc, EndLoc,
-                               NumClauses, 1),
-        HasCancel(false) {}
+                               llvm::omp::OMPD_task, StartLoc, EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTaskDirective(unsigned NumClauses)
+  explicit OMPTaskDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTaskDirectiveClass,
                                llvm::omp::OMPD_task, SourceLocation(),
-                               SourceLocation(), NumClauses, 1),
-        HasCancel(false) {}
+                               SourceLocation(), Data) {}
 
   /// 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) {}
+                               llvm::omp::OMPD_taskyield, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPTaskyieldDirective()
       : OMPExecutableDirective(this, 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) {}
+                               llvm::omp::OMPD_barrier, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPBarrierDirective()
       : OMPExecutableDirective(this, 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) {}
+                               llvm::omp::OMPD_taskwait, StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPTaskwaitDirective()
       : OMPExecutableDirective(this, 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTaskgroupDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                        unsigned NumClauses)
+                        OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass,
                                llvm::omp::OMPD_taskgroup, StartLoc, EndLoc,
-                               NumClauses, 2) {}
+                               Data) {}
 
   /// Build an empty directive.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPTaskgroupDirective(unsigned NumClauses)
+  explicit OMPTaskgroupDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass,
                                llvm::omp::OMPD_taskgroup, SourceLocation(),
-                               SourceLocation(), NumClauses, 2) {}
+                               SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPFlushDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                    unsigned NumClauses)
+                    OMPChildren *Data)
       : OMPExecutableDirective(this, OMPFlushDirectiveClass,
-                               llvm::omp::OMPD_flush, StartLoc, EndLoc,
-                               NumClauses, 0) {}
+                               llvm::omp::OMPD_flush, StartLoc, EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPFlushDirective(unsigned NumClauses)
+  explicit OMPFlushDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPFlushDirectiveClass,
                                llvm::omp::OMPD_flush, SourceLocation(),
-                               SourceLocation(), NumClauses, 0) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPDepobjDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
+                     OMPChildren *Data)
       : OMPExecutableDirective(this, OMPDepobjDirectiveClass,
-                               llvm::omp::OMPD_depobj, StartLoc, EndLoc,
-                               NumClauses, 0) {}
+                               llvm::omp::OMPD_depobj, StartLoc, EndLoc, Data) {
+  }
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPDepobjDirective(unsigned NumClauses)
+  explicit OMPDepobjDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPDepobjDirectiveClass,
                                llvm::omp::OMPD_depobj, SourceLocation(),
-                               SourceLocation(), NumClauses, 0) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPOrderedDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                      unsigned NumClauses)
+                      OMPChildren *Data)
       : OMPExecutableDirective(this, OMPOrderedDirectiveClass,
                                llvm::omp::OMPD_ordered, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+                               Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPOrderedDirective(unsigned NumClauses)
+  explicit OMPOrderedDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPOrderedDirectiveClass,
                                llvm::omp::OMPD_ordered, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPAtomicDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
+                     OMPChildren *Data)
       : OMPExecutableDirective(this, OMPAtomicDirectiveClass,
-                               llvm::omp::OMPD_atomic, StartLoc, EndLoc,
-                               NumClauses, 5),
-        IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
+                               llvm::omp::OMPD_atomic, StartLoc, EndLoc, Data) {
+  }
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPAtomicDirective(unsigned NumClauses)
+  explicit OMPAtomicDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPAtomicDirectiveClass,
                                llvm::omp::OMPD_atomic, SourceLocation(),
-                               SourceLocation(), NumClauses, 5),
-        IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
+                               SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
+                     OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetDirectiveClass,
-                               llvm::omp::OMPD_target, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+                               llvm::omp::OMPD_target, StartLoc, EndLoc, Data) {
+  }
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetDirective(unsigned NumClauses)
+  explicit OMPTargetDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetDirectiveClass,
                                llvm::omp::OMPD_target, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetDataDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                         unsigned NumClauses)
+                         OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetDataDirectiveClass,
                                llvm::omp::OMPD_target_data, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+                               Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetDataDirective(unsigned NumClauses)
+  explicit OMPTargetDataDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetDataDirectiveClass,
                                llvm::omp::OMPD_target_data, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetEnterDataDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                              unsigned NumClauses)
+                              OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetEnterDataDirectiveClass,
                                llvm::omp::OMPD_target_enter_data, StartLoc,
-                               EndLoc, NumClauses, /*NumChildren=*/1) {}
+                               EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetEnterDataDirective(unsigned NumClauses)
+  explicit OMPTargetEnterDataDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetEnterDataDirectiveClass,
                                llvm::omp::OMPD_target_enter_data,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               /*NumChildren=*/1) {}
+                               SourceLocation(), SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetExitDataDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned NumClauses)
+                             OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetExitDataDirectiveClass,
                                llvm::omp::OMPD_target_exit_data, StartLoc,
-                               EndLoc, NumClauses, /*NumChildren=*/1) {}
+                               EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetExitDataDirective(unsigned NumClauses)
+  explicit OMPTargetExitDataDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetExitDataDirectiveClass,
                                llvm::omp::OMPD_target_exit_data,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               /*NumChildren=*/1) {}
+                               SourceLocation(), SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned NumClauses)
+                             OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetParallelDirectiveClass,
                                llvm::omp::OMPD_target_parallel, StartLoc,
-                               EndLoc, NumClauses, /*NumChildren=*/1) {}
+                               EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetParallelDirective(unsigned NumClauses)
+  explicit OMPTargetParallelDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetParallelDirectiveClass,
                                llvm::omp::OMPD_target_parallel,
-                               SourceLocation(), SourceLocation(), NumClauses,
-                               /*NumChildren=*/1) {}
+                               SourceLocation(), SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetParallelForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                                unsigned CollapsedNum, unsigned NumClauses)
+                                unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetParallelForDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTargetParallelForDirective(unsigned CollapsedNum,
-                                         unsigned NumClauses)
+                                         OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetParallelForDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTeamsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                    unsigned NumClauses)
+                    OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTeamsDirectiveClass,
-                               llvm::omp::OMPD_teams, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+                               llvm::omp::OMPD_teams, StartLoc, EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTeamsDirective(unsigned NumClauses)
+  explicit OMPTeamsDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTeamsDirectiveClass,
                                llvm::omp::OMPD_teams, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation(), Data) {}
 
 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,
                                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,
                                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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPCancelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                     unsigned NumClauses)
+                     OMPChildren *Data)
       : OMPExecutableDirective(this, OMPCancelDirectiveClass,
-                               llvm::omp::OMPD_cancel, StartLoc, EndLoc,
-                               NumClauses, 0),
-        CancelRegion(llvm::omp::OMPD_unknown) {}
+                               llvm::omp::OMPD_cancel, StartLoc, EndLoc, Data) {
+  }
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  explicit OMPCancelDirective(unsigned NumClauses)
+  explicit OMPCancelDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPCancelDirectiveClass,
                                llvm::omp::OMPD_cancel, SourceLocation(),
-                               SourceLocation(), NumClauses, 0),
-        CancelRegion(llvm::omp::OMPD_unknown) {}
+                               SourceLocation(), Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTaskLoopDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                       unsigned CollapsedNum, unsigned NumClauses)
+                       unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTaskLoopDirectiveClass,
                          llvm::omp::OMPD_taskloop, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPTaskLoopDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPTaskLoopDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTaskLoopDirectiveClass,
                          llvm::omp::OMPD_taskloop, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTaskLoopSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                           unsigned CollapsedNum, unsigned NumClauses)
+                           unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_taskloop_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPTaskLoopSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPTaskLoopSimdDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_taskloop_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPMasterTaskLoopDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned CollapsedNum, unsigned NumClauses)
+                             unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_master_taskloop, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPMasterTaskLoopDirective(unsigned CollapsedNum,
-                                      unsigned NumClauses)
+  explicit OMPMasterTaskLoopDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_master_taskloop, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPMasterTaskLoopSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                                 unsigned CollapsedNum, unsigned NumClauses)
+                                 unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_master_taskloop_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPMasterTaskLoopSimdDirective(unsigned CollapsedNum,
-                                          unsigned NumClauses)
+                                          OMPChildren *Data)
       : OMPLoopDirective(this, OMPMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_master_taskloop_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPParallelMasterTaskLoopDirective(SourceLocation StartLoc,
                                      SourceLocation EndLoc,
-                                     unsigned CollapsedNum, unsigned NumClauses)
+                                     unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPParallelMasterTaskLoopDirective(unsigned CollapsedNum,
-                                              unsigned NumClauses)
+                                              OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelMasterTaskLoopDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+                         Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPParallelMasterTaskLoopSimdDirective(SourceLocation StartLoc,
                                          SourceLocation EndLoc,
                                          unsigned CollapsedNum,
-                                         unsigned NumClauses)
+                                         OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop_simd,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses) {}
+                         StartLoc, EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPParallelMasterTaskLoopSimdDirective(unsigned CollapsedNum,
-                                                  unsigned NumClauses)
+                                                  OMPChildren *Data)
       : OMPLoopDirective(this, OMPParallelMasterTaskLoopSimdDirectiveClass,
                          llvm::omp::OMPD_parallel_master_taskloop_simd,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPDistributeDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                         unsigned CollapsedNum, unsigned NumClauses)
+                         unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeDirectiveClass,
                          llvm::omp::OMPD_distribute, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPDistributeDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPDistributeDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeDirectiveClass,
                          llvm::omp::OMPD_distribute, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetUpdateDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                           unsigned NumClauses)
+                           OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetUpdateDirectiveClass,
                                llvm::omp::OMPD_target_update, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+                               Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetUpdateDirective(unsigned NumClauses)
+  explicit OMPTargetUpdateDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetUpdateDirectiveClass,
                                llvm::omp::OMPD_target_update, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPDistributeParallelForDirective(SourceLocation StartLoc,
                                     SourceLocation EndLoc,
-                                    unsigned CollapsedNum, unsigned NumClauses)
+                                    unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPDistributeParallelForDirective(unsigned CollapsedNum,
-                                             unsigned NumClauses)
+                                             OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+                         Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPDistributeParallelForSimdDirective(SourceLocation StartLoc,
                                         SourceLocation EndLoc,
                                         unsigned CollapsedNum,
-                                        unsigned NumClauses)
+                                        OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPDistributeParallelForSimdDirective(unsigned CollapsedNum,
-                                                 unsigned NumClauses)
+                                                 OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_parallel_for_simd,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPDistributeSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                             unsigned CollapsedNum, unsigned NumClauses)
+                             unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPDistributeSimdDirective(unsigned CollapsedNum,
-                                      unsigned NumClauses)
+  explicit OMPDistributeSimdDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_distribute_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetParallelForSimdDirective(SourceLocation StartLoc,
                                     SourceLocation EndLoc,
-                                    unsigned CollapsedNum, unsigned NumClauses)
+                                    unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTargetParallelForSimdDirective(unsigned CollapsedNum,
-                                             unsigned NumClauses)
+                                             OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_target_parallel_for_simd,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                         unsigned CollapsedNum, unsigned NumClauses)
+                         unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetSimdDirectiveClass,
                          llvm::omp::OMPD_target_simd, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPTargetSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
+  explicit OMPTargetSimdDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetSimdDirectiveClass,
                          llvm::omp::OMPD_target_simd, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTeamsDistributeDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                              unsigned CollapsedNum, unsigned NumClauses)
+                              unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_teams_distribute, StartLoc, EndLoc,
-                         CollapsedNum, NumClauses) {}
+                         CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  explicit OMPTeamsDistributeDirective(unsigned CollapsedNum,
-                                       unsigned NumClauses)
+  explicit OMPTeamsDistributeDirective(unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_teams_distribute, SourceLocation(),
-                         SourceLocation(), CollapsedNum, NumClauses) {}
+                         SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTeamsDistributeSimdDirective(SourceLocation StartLoc,
                                   SourceLocation EndLoc, unsigned CollapsedNum,
-                                  unsigned NumClauses)
+                                  OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTeamsDistributeSimdDirective(unsigned CollapsedNum,
-                                           unsigned NumClauses)
+                                           OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_simd,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTeamsDistributeParallelForSimdDirective(SourceLocation StartLoc,
                                              SourceLocation EndLoc,
                                              unsigned CollapsedNum,
-                                             unsigned NumClauses)
+                                             OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for_simd,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses) {}
+                         StartLoc, EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTeamsDistributeParallelForSimdDirective(unsigned CollapsedNum,
-                                                      unsigned NumClauses)
+                                                      OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeParallelForSimdDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for_simd,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTeamsDistributeParallelForDirective(SourceLocation StartLoc,
                                          SourceLocation EndLoc,
                                          unsigned CollapsedNum,
-                                         unsigned NumClauses)
+                                         OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         StartLoc, EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTeamsDistributeParallelForDirective(unsigned CollapsedNum,
-                                                  unsigned NumClauses)
+                                                  OMPChildren *Data)
       : OMPLoopDirective(this, OMPTeamsDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_teams_distribute_parallel_for,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses),
-        HasCancel(false) {}
+                         Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetTeamsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                          unsigned NumClauses)
+                          OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetTeamsDirectiveClass,
                                llvm::omp::OMPD_target_teams, StartLoc, EndLoc,
-                               NumClauses, 1) {}
+                               Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPTargetTeamsDirective(unsigned NumClauses)
+  explicit OMPTargetTeamsDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPTargetTeamsDirectiveClass,
                                llvm::omp::OMPD_target_teams, SourceLocation(),
-                               SourceLocation(), NumClauses, 1) {}
+                               SourceLocation(), Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetTeamsDistributeDirective(SourceLocation StartLoc,
                                     SourceLocation EndLoc,
-                                    unsigned CollapsedNum, unsigned NumClauses)
+                                    unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTargetTeamsDistributeDirective(unsigned CollapsedNum,
-                                             unsigned NumClauses)
+                                             OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetTeamsDistributeDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetTeamsDistributeParallelForDirective(SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                unsigned CollapsedNum,
-                                               unsigned NumClauses)
+                                               OMPChildren *Data)
       : OMPLoopDirective(this,
                          OMPTargetTeamsDistributeParallelForDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute_parallel_for,
-                         StartLoc, EndLoc, CollapsedNum, NumClauses),
-        HasCancel(false) {}
+                         StartLoc, EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTargetTeamsDistributeParallelForDirective(unsigned CollapsedNum,
-                                                        unsigned NumClauses)
+                                                        OMPChildren *Data)
       : OMPLoopDirective(
             this, OMPTargetTeamsDistributeParallelForDirectiveClass,
             llvm::omp::OMPD_target_teams_distribute_parallel_for,
-            SourceLocation(), SourceLocation(), CollapsedNum, NumClauses),
-        HasCancel(false) {}
+            SourceLocation(), SourceLocation(), CollapsedNum, Data) {}
 
   /// 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetTeamsDistributeParallelForSimdDirective(SourceLocation StartLoc,
                                                    SourceLocation EndLoc,
                                                    unsigned CollapsedNum,
-                                                   unsigned NumClauses)
+                                                   OMPChildren *Data)
       : OMPLoopDirective(
             this, OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
             llvm::omp::OMPD_target_teams_distribute_parallel_for_simd, StartLoc,
-            EndLoc, CollapsedNum, NumClauses) {}
+            EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTargetTeamsDistributeParallelForSimdDirective(
-      unsigned CollapsedNum, unsigned NumClauses)
+      unsigned CollapsedNum, OMPChildren *Data)
       : OMPLoopDirective(
             this, OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
             llvm::omp::OMPD_target_teams_distribute_parallel_for_simd,
-            SourceLocation(), SourceLocation(), CollapsedNum, NumClauses) {}
+            SourceLocation(), SourceLocation(), CollapsedNum, Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPTargetTeamsDistributeSimdDirective(SourceLocation StartLoc,
                                         SourceLocation EndLoc,
                                         unsigned CollapsedNum,
-                                        unsigned NumClauses)
+                                        OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute_simd, StartLoc,
-                         EndLoc, CollapsedNum, NumClauses) {}
+                         EndLoc, CollapsedNum, Data) {}
 
   /// Build an empty directive.
   ///
   /// \param CollapsedNum Number of collapsed nested loops.
-  /// \param NumClauses Number of clauses.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   explicit OMPTargetTeamsDistributeSimdDirective(unsigned CollapsedNum,
-                                                 unsigned NumClauses)
+                                                 OMPChildren *Data)
       : OMPLoopDirective(this, OMPTargetTeamsDistributeSimdDirectiveClass,
                          llvm::omp::OMPD_target_teams_distribute_simd,
                          SourceLocation(), SourceLocation(), CollapsedNum,
-                         NumClauses) {}
+                         Data) {}
 
 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.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
   OMPScanDirective(SourceLocation StartLoc, SourceLocation EndLoc,
-                   unsigned NumClauses)
+                   OMPChildren *Data)
       : OMPExecutableDirective(this, OMPScanDirectiveClass,
-                               llvm::omp::OMPD_scan, StartLoc, EndLoc,
-                               NumClauses, 0) {}
+                               llvm::omp::OMPD_scan, StartLoc, EndLoc, Data) {}
 
   /// Build an empty directive.
+  /// \param Data Data storage, containing info about associated clauses,
+  /// statements and child expressions.
   ///
-  /// \param NumClauses Number of clauses.
-  ///
-  explicit OMPScanDirective(unsigned NumClauses)
+  explicit OMPScanDirective(OMPChildren *Data)
       : OMPExecutableDirective(this, OMPScanDirectiveClass,
                                llvm::omp::OMPD_scan, SourceLocation(),
-                               SourceLocation(), NumClauses, 0) {}
+                               SourceLocation(), Data) {}
 
 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/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() &&
+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(const ASTContext &C,
+                                 ArrayRef<OMPClause *> Clauses) {
+  auto *Data = CreateEmpty(C, Clauses.size());
+  Data->setClauses(Clauses);
+  return Data;
+}
+
+OMPChildren *OMPChildren::Create(const ASTContext &C,
+                                 ArrayRef<OMPClause *> Clauses, Stmt *S,
+                                 unsigned NumChildren) {
+  auto *Data = CreateEmpty(C, Clauses.size(), S, NumChildren);
+  Data->setClauses(Clauses);
+  if (S)
+    Data->setAssociatedStmt(S);
+  return Data;
+}
+
+OMPChildren *OMPChildren::CreateEmpty(const ASTContext &C, unsigned NumClauses,
+                                      bool HasAssociatedStmt,
+                                      unsigned NumChildren) {
+  void *Mem =
+      C.Allocate(totalSizeToAlloc<OMPClause *, Stmt *>(
+                     NumClauses, NumChildren + (HasAssociatedStmt ? 1 : 0)),
+                 alignof(OMPChildren));
+  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/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
   E->RParenLoc = readSourceLocation();
   E->SrcExpr = Record.readSubExpr();
 }
 
 //===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
 
+static void readOMPChildren(ASTRecordReader &Record, OMPChildren *Data) {
+  SmallVector<OMPClause *, 4> Clauses(Data->getNumClauses());
+  for (unsigned I = 0, E = Data->getNumClauses(); I < E; ++I)
+    Clauses[I] = Record.readOMPClause();
+  Data->setClauses(Clauses);
+  if (Data->hasAssociatedStmt())
+    Data->setAssociatedStmt(Record.readSubStmt());
+  for (unsigned I = 0, E = Data->getNumChildren(); I < E; ++I)
+    Data->getChildren()[I] = Record.readSubStmt();
+}
+
 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
+  if (E->Data) {
+    // Skip NumClauses, NumChildren and HasAssociatedStmt fields.
+    Record.skipInts(3);
+  }
   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());
+  if (OMPChildren *Data = E->Data)
+    readOMPChildren(Record, Data);
 }
 
 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], Empty);

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getLeaveLoc());
   Code = serialization::STMT_SEH_LEAVE;
 }
 
 //===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
+
+static void writeOMPChildren(ASTRecordWriter &Record, OMPChildren *Data) {
+  for (unsigned I = 0, E = Data->getNumClauses(); I < E; ++I)
+    Record.writeOMPClause(Data->getClauses()[I]);
+  if (Data->hasAssociatedStmt())
+    Record.AddStmt(Data->getAssociatedStmt());
+  for (unsigned I = 0, E = Data->getNumChildren(); I < E; ++I)
+    Record.AddStmt(Data->getChildren()[I]);
+}
+
 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
+  if (OMPChildren *Data = E->Data) {
+    Record.writeUInt32(Data->getNumClauses());
+    Record.writeUInt32(Data->getNumChildren());
+    Record.writeBool(Data->hasAssociatedStmt());
+  }
   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());
+  if (OMPChildren *Data = E->Data)
+    writeOMPChildren(Record, Data);
 }
 
 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'