Home | History | Annotate | Download | only in AST 
      1 //===--- Stmt.cpp - Statement AST Node Implementation ---------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements the Stmt class and statement subclasses.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "clang/AST/ASTContext.h"
     15 #include "clang/AST/ASTDiagnostic.h"
     16 #include "clang/AST/ExprCXX.h"
     17 #include "clang/AST/ExprObjC.h"
     18 #include "clang/AST/Stmt.h"
     19 #include "clang/AST/StmtCXX.h"
     20 #include "clang/AST/StmtObjC.h"
     21 #include "clang/AST/StmtOpenMP.h"
     22 #include "clang/AST/Type.h"
     23 #include "clang/Basic/CharInfo.h"
     24 #include "clang/Basic/TargetInfo.h"
     25 #include "clang/Lex/Token.h"
     26 #include "llvm/ADT/StringExtras.h"
     27 #include "llvm/Support/raw_ostream.h"
     28 using namespace clang;
     29 
     30 static struct StmtClassNameTable {
     31   const char *Name;
     32   unsigned Counter;
     33   unsigned Size;
     34 } StmtClassInfo[Stmt::lastStmtConstant+1];
     35 
     36 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
     37   static bool Initialized = false;
     38   if (Initialized)
     39     return StmtClassInfo[E];
     40 
     41   // Intialize the table on the first use.
     42   Initialized = true;
     43 #define ABSTRACT_STMT(STMT)
     44 #define STMT(CLASS, PARENT) \
     45   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS;    \
     46   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);
     47 #include "clang/AST/StmtNodes.inc"
     48 
     49   return StmtClassInfo[E];
     50 }
     51 
     52 void *Stmt::operator new(size_t bytes, const ASTContext& C,
     53                          unsigned alignment) {
     54   return ::operator new(bytes, C, alignment);
     55 }
     56 
     57 const char *Stmt::getStmtClassName() const {
     58   return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
     59 }
     60 
     61 void Stmt::PrintStats() {
     62   // Ensure the table is primed.
     63   getStmtInfoTableEntry(Stmt::NullStmtClass);
     64 
     65   unsigned sum = 0;
     66   llvm::errs() << "\n*** Stmt/Expr Stats:\n";
     67   for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
     68     if (StmtClassInfo[i].Name == nullptr) continue;
     69     sum += StmtClassInfo[i].Counter;
     70   }
     71   llvm::errs() << "  " << sum << " stmts/exprs total.\n";
     72   sum = 0;
     73   for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
     74     if (StmtClassInfo[i].Name == nullptr) continue;
     75     if (StmtClassInfo[i].Counter == 0) continue;
     76     llvm::errs() << "    " << StmtClassInfo[i].Counter << " "
     77                  << StmtClassInfo[i].Name << ", " << StmtClassInfo[i].Size
     78                  << " each (" << StmtClassInfo[i].Counter*StmtClassInfo[i].Size
     79                  << " bytes)\n";
     80     sum += StmtClassInfo[i].Counter*StmtClassInfo[i].Size;
     81   }
     82 
     83   llvm::errs() << "Total bytes = " << sum << "\n";
     84 }
     85 
     86 void Stmt::addStmtClass(StmtClass s) {
     87   ++getStmtInfoTableEntry(s).Counter;
     88 }
     89 
     90 bool Stmt::StatisticsEnabled = false;
     91 void Stmt::EnableStatistics() {
     92   StatisticsEnabled = true;
     93 }
     94 
     95 Stmt *Stmt::IgnoreImplicit() {
     96   Stmt *s = this;
     97 
     98   if (auto *ewc = dyn_cast<ExprWithCleanups>(s))
     99     s = ewc->getSubExpr();
    100 
    101   if (auto *mte = dyn_cast<MaterializeTemporaryExpr>(s))
    102     s = mte->GetTemporaryExpr();
    103 
    104   if (auto *bte = dyn_cast<CXXBindTemporaryExpr>(s))
    105     s = bte->getSubExpr();
    106 
    107   while (auto *ice = dyn_cast<ImplicitCastExpr>(s))
    108     s = ice->getSubExpr();
    109 
    110   return s;
    111 }
    112 
    113 /// \brief Skip no-op (attributed, compound) container stmts and skip captured
    114 /// stmt at the top, if \a IgnoreCaptured is true.
    115 Stmt *Stmt::IgnoreContainers(bool IgnoreCaptured) {
    116   Stmt *S = this;
    117   if (IgnoreCaptured)
    118     if (auto CapS = dyn_cast_or_null<CapturedStmt>(S))
    119       S = CapS->getCapturedStmt();
    120   while (true) {
    121     if (auto AS = dyn_cast_or_null<AttributedStmt>(S))
    122       S = AS->getSubStmt();
    123     else if (auto CS = dyn_cast_or_null<CompoundStmt>(S)) {
    124       if (CS->size() != 1)
    125         break;
    126       S = CS->body_back();
    127     } else
    128       break;
    129   }
    130   return S;
    131 }
    132 
    133 /// \brief Strip off all label-like statements.
    134 ///
    135 /// This will strip off label statements, case statements, attributed
    136 /// statements and default statements recursively.
    137 const Stmt *Stmt::stripLabelLikeStatements() const {
    138   const Stmt *S = this;
    139   while (true) {
    140     if (const LabelStmt *LS = dyn_cast<LabelStmt>(S))
    141       S = LS->getSubStmt();
    142     else if (const SwitchCase *SC = dyn_cast<SwitchCase>(S))
    143       S = SC->getSubStmt();
    144     else if (const AttributedStmt *AS = dyn_cast<AttributedStmt>(S))
    145       S = AS->getSubStmt();
    146     else
    147       return S;
    148   }
    149 }
    150 
    151 namespace {
    152   struct good {};
    153   struct bad {};
    154 
    155   // These silly little functions have to be static inline to suppress
    156   // unused warnings, and they have to be defined to suppress other
    157   // warnings.
    158   static inline good is_good(good) { return good(); }
    159 
    160   typedef Stmt::child_range children_t();
    161   template <class T> good implements_children(children_t T::*) {
    162     return good();
    163   }
    164   LLVM_ATTRIBUTE_UNUSED
    165   static inline bad implements_children(children_t Stmt::*) {
    166     return bad();
    167   }
    168 
    169   typedef SourceLocation getLocStart_t() const;
    170   template <class T> good implements_getLocStart(getLocStart_t T::*) {
    171     return good();
    172   }
    173   LLVM_ATTRIBUTE_UNUSED
    174   static inline bad implements_getLocStart(getLocStart_t Stmt::*) {
    175     return bad();
    176   }
    177 
    178   typedef SourceLocation getLocEnd_t() const;
    179   template <class T> good implements_getLocEnd(getLocEnd_t T::*) {
    180     return good();
    181   }
    182   LLVM_ATTRIBUTE_UNUSED
    183   static inline bad implements_getLocEnd(getLocEnd_t Stmt::*) {
    184     return bad();
    185   }
    186 
    187 #define ASSERT_IMPLEMENTS_children(type) \
    188   (void) is_good(implements_children(&type::children))
    189 #define ASSERT_IMPLEMENTS_getLocStart(type) \
    190   (void) is_good(implements_getLocStart(&type::getLocStart))
    191 #define ASSERT_IMPLEMENTS_getLocEnd(type) \
    192   (void) is_good(implements_getLocEnd(&type::getLocEnd))
    193 }
    194 
    195 /// Check whether the various Stmt classes implement their member
    196 /// functions.
    197 LLVM_ATTRIBUTE_UNUSED
    198 static inline void check_implementations() {
    199 #define ABSTRACT_STMT(type)
    200 #define STMT(type, base) \
    201   ASSERT_IMPLEMENTS_children(type); \
    202   ASSERT_IMPLEMENTS_getLocStart(type); \
    203   ASSERT_IMPLEMENTS_getLocEnd(type);
    204 #include "clang/AST/StmtNodes.inc"
    205 }
    206 
    207 Stmt::child_range Stmt::children() {
    208   switch (getStmtClass()) {
    209   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    210 #define ABSTRACT_STMT(type)
    211 #define STMT(type, base) \
    212   case Stmt::type##Class: \
    213     return static_cast<type*>(this)->children();
    214 #include "clang/AST/StmtNodes.inc"
    215   }
    216   llvm_unreachable("unknown statement kind!");
    217 }
    218 
    219 // Amusing macro metaprogramming hack: check whether a class provides
    220 // a more specific implementation of getSourceRange.
    221 //
    222 // See also Expr.cpp:getExprLoc().
    223 namespace {
    224   /// This implementation is used when a class provides a custom
    225   /// implementation of getSourceRange.
    226   template <class S, class T>
    227   SourceRange getSourceRangeImpl(const Stmt *stmt,
    228                                  SourceRange (T::*v)() const) {
    229     return static_cast<const S*>(stmt)->getSourceRange();
    230   }
    231 
    232   /// This implementation is used when a class doesn't provide a custom
    233   /// implementation of getSourceRange.  Overload resolution should pick it over
    234   /// the implementation above because it's more specialized according to
    235   /// function template partial ordering.
    236   template <class S>
    237   SourceRange getSourceRangeImpl(const Stmt *stmt,
    238                                  SourceRange (Stmt::*v)() const) {
    239     return SourceRange(static_cast<const S*>(stmt)->getLocStart(),
    240                        static_cast<const S*>(stmt)->getLocEnd());
    241   }
    242 }
    243 
    244 SourceRange Stmt::getSourceRange() const {
    245   switch (getStmtClass()) {
    246   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    247 #define ABSTRACT_STMT(type)
    248 #define STMT(type, base) \
    249   case Stmt::type##Class: \
    250     return getSourceRangeImpl<type>(this, &type::getSourceRange);
    251 #include "clang/AST/StmtNodes.inc"
    252   }
    253   llvm_unreachable("unknown statement kind!");
    254 }
    255 
    256 SourceLocation Stmt::getLocStart() const {
    257 //  llvm::errs() << "getLocStart() for " << getStmtClassName() << "\n";
    258   switch (getStmtClass()) {
    259   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    260 #define ABSTRACT_STMT(type)
    261 #define STMT(type, base) \
    262   case Stmt::type##Class: \
    263     return static_cast<const type*>(this)->getLocStart();
    264 #include "clang/AST/StmtNodes.inc"
    265   }
    266   llvm_unreachable("unknown statement kind");
    267 }
    268 
    269 SourceLocation Stmt::getLocEnd() const {
    270   switch (getStmtClass()) {
    271   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
    272 #define ABSTRACT_STMT(type)
    273 #define STMT(type, base) \
    274   case Stmt::type##Class: \
    275     return static_cast<const type*>(this)->getLocEnd();
    276 #include "clang/AST/StmtNodes.inc"
    277   }
    278   llvm_unreachable("unknown statement kind");
    279 }
    280 
    281 CompoundStmt::CompoundStmt(const ASTContext &C, ArrayRef<Stmt*> Stmts,
    282                            SourceLocation LB, SourceLocation RB)
    283   : Stmt(CompoundStmtClass), LBraceLoc(LB), RBraceLoc(RB) {
    284   CompoundStmtBits.NumStmts = Stmts.size();
    285   assert(CompoundStmtBits.NumStmts == Stmts.size() &&
    286          "NumStmts doesn't fit in bits of CompoundStmtBits.NumStmts!");
    287 
    288   if (Stmts.size() == 0) {
    289     Body = nullptr;
    290     return;
    291   }
    292 
    293   Body = new (C) Stmt*[Stmts.size()];
    294   std::copy(Stmts.begin(), Stmts.end(), Body);
    295 }
    296 
    297 void CompoundStmt::setStmts(const ASTContext &C, Stmt **Stmts,
    298                             unsigned NumStmts) {
    299   if (this->Body)
    300     C.Deallocate(Body);
    301   this->CompoundStmtBits.NumStmts = NumStmts;
    302 
    303   Body = new (C) Stmt*[NumStmts];
    304   memcpy(Body, Stmts, sizeof(Stmt *) * NumStmts);
    305 }
    306 
    307 const char *LabelStmt::getName() const {
    308   return getDecl()->getIdentifier()->getNameStart();
    309 }
    310 
    311 AttributedStmt *AttributedStmt::Create(const ASTContext &C, SourceLocation Loc,
    312                                        ArrayRef<const Attr*> Attrs,
    313                                        Stmt *SubStmt) {
    314   assert(!Attrs.empty() && "Attrs should not be empty");
    315   void *Mem = C.Allocate(sizeof(AttributedStmt) + sizeof(Attr *) * Attrs.size(),
    316                          llvm::alignOf<AttributedStmt>());
    317   return new (Mem) AttributedStmt(Loc, Attrs, SubStmt);
    318 }
    319 
    320 AttributedStmt *AttributedStmt::CreateEmpty(const ASTContext &C,
    321                                             unsigned NumAttrs) {
    322   assert(NumAttrs > 0 && "NumAttrs should be greater than zero");
    323   void *Mem = C.Allocate(sizeof(AttributedStmt) + sizeof(Attr *) * NumAttrs,
    324                          llvm::alignOf<AttributedStmt>());
    325   return new (Mem) AttributedStmt(EmptyShell(), NumAttrs);
    326 }
    327 
    328 std::string AsmStmt::generateAsmString(const ASTContext &C) const {
    329   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    330     return gccAsmStmt->generateAsmString(C);
    331   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    332     return msAsmStmt->generateAsmString(C);
    333   llvm_unreachable("unknown asm statement kind!");
    334 }
    335 
    336 StringRef AsmStmt::getOutputConstraint(unsigned i) const {
    337   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    338     return gccAsmStmt->getOutputConstraint(i);
    339   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    340     return msAsmStmt->getOutputConstraint(i);
    341   llvm_unreachable("unknown asm statement kind!");
    342 }
    343 
    344 const Expr *AsmStmt::getOutputExpr(unsigned i) const {
    345   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    346     return gccAsmStmt->getOutputExpr(i);
    347   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    348     return msAsmStmt->getOutputExpr(i);
    349   llvm_unreachable("unknown asm statement kind!");
    350 }
    351 
    352 StringRef AsmStmt::getInputConstraint(unsigned i) const {
    353   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    354     return gccAsmStmt->getInputConstraint(i);
    355   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    356     return msAsmStmt->getInputConstraint(i);
    357   llvm_unreachable("unknown asm statement kind!");
    358 }
    359 
    360 const Expr *AsmStmt::getInputExpr(unsigned i) const {
    361   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    362     return gccAsmStmt->getInputExpr(i);
    363   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    364     return msAsmStmt->getInputExpr(i);
    365   llvm_unreachable("unknown asm statement kind!");
    366 }
    367 
    368 StringRef AsmStmt::getClobber(unsigned i) const {
    369   if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
    370     return gccAsmStmt->getClobber(i);
    371   if (const MSAsmStmt *msAsmStmt = dyn_cast<MSAsmStmt>(this))
    372     return msAsmStmt->getClobber(i);
    373   llvm_unreachable("unknown asm statement kind!");
    374 }
    375 
    376 /// getNumPlusOperands - Return the number of output operands that have a "+"
    377 /// constraint.
    378 unsigned AsmStmt::getNumPlusOperands() const {
    379   unsigned Res = 0;
    380   for (unsigned i = 0, e = getNumOutputs(); i != e; ++i)
    381     if (isOutputPlusConstraint(i))
    382       ++Res;
    383   return Res;
    384 }
    385 
    386 char GCCAsmStmt::AsmStringPiece::getModifier() const {
    387   assert(isOperand() && "Only Operands can have modifiers.");
    388   return isLetter(Str[0]) ? Str[0] : '\0';
    389 }
    390 
    391 StringRef GCCAsmStmt::getClobber(unsigned i) const {
    392   return getClobberStringLiteral(i)->getString();
    393 }
    394 
    395 Expr *GCCAsmStmt::getOutputExpr(unsigned i) {
    396   return cast<Expr>(Exprs[i]);
    397 }
    398 
    399 /// getOutputConstraint - Return the constraint string for the specified
    400 /// output operand.  All output constraints are known to be non-empty (either
    401 /// '=' or '+').
    402 StringRef GCCAsmStmt::getOutputConstraint(unsigned i) const {
    403   return getOutputConstraintLiteral(i)->getString();
    404 }
    405 
    406 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
    407   return cast<Expr>(Exprs[i + NumOutputs]);
    408 }
    409 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
    410   Exprs[i + NumOutputs] = E;
    411 }
    412 
    413 /// getInputConstraint - Return the specified input constraint.  Unlike output
    414 /// constraints, these can be empty.
    415 StringRef GCCAsmStmt::getInputConstraint(unsigned i) const {
    416   return getInputConstraintLiteral(i)->getString();
    417 }
    418 
    419 void GCCAsmStmt::setOutputsAndInputsAndClobbers(const ASTContext &C,
    420                                                 IdentifierInfo **Names,
    421                                                 StringLiteral **Constraints,
    422                                                 Stmt **Exprs,
    423                                                 unsigned NumOutputs,
    424                                                 unsigned NumInputs,
    425                                                 StringLiteral **Clobbers,
    426                                                 unsigned NumClobbers) {
    427   this->NumOutputs = NumOutputs;
    428   this->NumInputs = NumInputs;
    429   this->NumClobbers = NumClobbers;
    430 
    431   unsigned NumExprs = NumOutputs + NumInputs;
    432 
    433   C.Deallocate(this->Names);
    434   this->Names = new (C) IdentifierInfo*[NumExprs];
    435   std::copy(Names, Names + NumExprs, this->Names);
    436 
    437   C.Deallocate(this->Exprs);
    438   this->Exprs = new (C) Stmt*[NumExprs];
    439   std::copy(Exprs, Exprs + NumExprs, this->Exprs);
    440 
    441   C.Deallocate(this->Constraints);
    442   this->Constraints = new (C) StringLiteral*[NumExprs];
    443   std::copy(Constraints, Constraints + NumExprs, this->Constraints);
    444 
    445   C.Deallocate(this->Clobbers);
    446   this->Clobbers = new (C) StringLiteral*[NumClobbers];
    447   std::copy(Clobbers, Clobbers + NumClobbers, this->Clobbers);
    448 }
    449 
    450 /// getNamedOperand - Given a symbolic operand reference like %[foo],
    451 /// translate this into a numeric value needed to reference the same operand.
    452 /// This returns -1 if the operand name is invalid.
    453 int GCCAsmStmt::getNamedOperand(StringRef SymbolicName) const {
    454   unsigned NumPlusOperands = 0;
    455 
    456   // Check if this is an output operand.
    457   for (unsigned i = 0, e = getNumOutputs(); i != e; ++i) {
    458     if (getOutputName(i) == SymbolicName)
    459       return i;
    460   }
    461 
    462   for (unsigned i = 0, e = getNumInputs(); i != e; ++i)
    463     if (getInputName(i) == SymbolicName)
    464       return getNumOutputs() + NumPlusOperands + i;
    465 
    466   // Not found.
    467   return -1;
    468 }
    469 
    470 /// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing
    471 /// it into pieces.  If the asm string is erroneous, emit errors and return
    472 /// true, otherwise return false.
    473 unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece>&Pieces,
    474                                 const ASTContext &C, unsigned &DiagOffs) const {
    475   StringRef Str = getAsmString()->getString();
    476   const char *StrStart = Str.begin();
    477   const char *StrEnd = Str.end();
    478   const char *CurPtr = StrStart;
    479 
    480   // "Simple" inline asms have no constraints or operands, just convert the asm
    481   // string to escape $'s.
    482   if (isSimple()) {
    483     std::string Result;
    484     for (; CurPtr != StrEnd; ++CurPtr) {
    485       switch (*CurPtr) {
    486       case '$':
    487         Result += "$$";
    488         break;
    489       default:
    490         Result += *CurPtr;
    491         break;
    492       }
    493     }
    494     Pieces.push_back(AsmStringPiece(Result));
    495     return 0;
    496   }
    497 
    498   // CurStringPiece - The current string that we are building up as we scan the
    499   // asm string.
    500   std::string CurStringPiece;
    501 
    502   bool HasVariants = !C.getTargetInfo().hasNoAsmVariants();
    503 
    504   while (1) {
    505     // Done with the string?
    506     if (CurPtr == StrEnd) {
    507       if (!CurStringPiece.empty())
    508         Pieces.push_back(AsmStringPiece(CurStringPiece));
    509       return 0;
    510     }
    511 
    512     char CurChar = *CurPtr++;
    513     switch (CurChar) {
    514     case '$': CurStringPiece += "$$"; continue;
    515     case '{': CurStringPiece += (HasVariants ? "$(" : "{"); continue;
    516     case '|': CurStringPiece += (HasVariants ? "$|" : "|"); continue;
    517     case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue;
    518     case '%':
    519       break;
    520     default:
    521       CurStringPiece += CurChar;
    522       continue;
    523     }
    524 
    525     // Escaped "%" character in asm string.
    526     if (CurPtr == StrEnd) {
    527       // % at end of string is invalid (no escape).
    528       DiagOffs = CurPtr-StrStart-1;
    529       return diag::err_asm_invalid_escape;
    530     }
    531 
    532     char EscapedChar = *CurPtr++;
    533     if (EscapedChar == '%') {  // %% -> %
    534       // Escaped percentage sign.
    535       CurStringPiece += '%';
    536       continue;
    537     }
    538 
    539     if (EscapedChar == '=') {  // %= -> Generate an unique ID.
    540       CurStringPiece += "${:uid}";
    541       continue;
    542     }
    543 
    544     // Otherwise, we have an operand.  If we have accumulated a string so far,
    545     // add it to the Pieces list.
    546     if (!CurStringPiece.empty()) {
    547       Pieces.push_back(AsmStringPiece(CurStringPiece));
    548       CurStringPiece.clear();
    549     }
    550 
    551     // Handle operands that have asmSymbolicName (e.g., %x[foo]) and those that
    552     // don't (e.g., %x4). 'x' following the '%' is the constraint modifier.
    553 
    554     const char *Begin = CurPtr - 1; // Points to the character following '%'.
    555     const char *Percent = Begin - 1; // Points to '%'.
    556 
    557     if (isLetter(EscapedChar)) {
    558       if (CurPtr == StrEnd) { // Premature end.
    559         DiagOffs = CurPtr-StrStart-1;
    560         return diag::err_asm_invalid_escape;
    561       }
    562       EscapedChar = *CurPtr++;
    563     }
    564 
    565     const TargetInfo &TI = C.getTargetInfo();
    566     const SourceManager &SM = C.getSourceManager();
    567     const LangOptions &LO = C.getLangOpts();
    568 
    569     // Handle operands that don't have asmSymbolicName (e.g., %x4).
    570     if (isDigit(EscapedChar)) {
    571       // %n - Assembler operand n
    572       unsigned N = 0;
    573 
    574       --CurPtr;
    575       while (CurPtr != StrEnd && isDigit(*CurPtr))
    576         N = N*10 + ((*CurPtr++)-'0');
    577 
    578       unsigned NumOperands =
    579         getNumOutputs() + getNumPlusOperands() + getNumInputs();
    580       if (N >= NumOperands) {
    581         DiagOffs = CurPtr-StrStart-1;
    582         return diag::err_asm_invalid_operand_number;
    583       }
    584 
    585       // Str contains "x4" (Operand without the leading %).
    586       std::string Str(Begin, CurPtr - Begin);
    587 
    588       // (BeginLoc, EndLoc) represents the range of the operand we are currently
    589       // processing. Unlike Str, the range includes the leading '%'.
    590       SourceLocation BeginLoc =
    591           getAsmString()->getLocationOfByte(Percent - StrStart, SM, LO, TI);
    592       SourceLocation EndLoc =
    593           getAsmString()->getLocationOfByte(CurPtr - StrStart, SM, LO, TI);
    594 
    595       Pieces.push_back(AsmStringPiece(N, Str, BeginLoc, EndLoc));
    596       continue;
    597     }
    598 
    599     // Handle operands that have asmSymbolicName (e.g., %x[foo]).
    600     if (EscapedChar == '[') {
    601       DiagOffs = CurPtr-StrStart-1;
    602 
    603       // Find the ']'.
    604       const char *NameEnd = (const char*)memchr(CurPtr, ']', StrEnd-CurPtr);
    605       if (NameEnd == nullptr)
    606         return diag::err_asm_unterminated_symbolic_operand_name;
    607       if (NameEnd == CurPtr)
    608         return diag::err_asm_empty_symbolic_operand_name;
    609 
    610       StringRef SymbolicName(CurPtr, NameEnd - CurPtr);
    611 
    612       int N = getNamedOperand(SymbolicName);
    613       if (N == -1) {
    614         // Verify that an operand with that name exists.
    615         DiagOffs = CurPtr-StrStart;
    616         return diag::err_asm_unknown_symbolic_operand_name;
    617       }
    618 
    619       // Str contains "x[foo]" (Operand without the leading %).
    620       std::string Str(Begin, NameEnd + 1 - Begin);
    621 
    622       // (BeginLoc, EndLoc) represents the range of the operand we are currently
    623       // processing. Unlike Str, the range includes the leading '%'.
    624       SourceLocation BeginLoc =
    625           getAsmString()->getLocationOfByte(Percent - StrStart, SM, LO, TI);
    626       SourceLocation EndLoc =
    627           getAsmString()->getLocationOfByte(NameEnd + 1 - StrStart, SM, LO, TI);
    628 
    629       Pieces.push_back(AsmStringPiece(N, Str, BeginLoc, EndLoc));
    630 
    631       CurPtr = NameEnd+1;
    632       continue;
    633     }
    634 
    635     DiagOffs = CurPtr-StrStart-1;
    636     return diag::err_asm_invalid_escape;
    637   }
    638 }
    639 
    640 /// Assemble final IR asm string (GCC-style).
    641 std::string GCCAsmStmt::generateAsmString(const ASTContext &C) const {
    642   // Analyze the asm string to decompose it into its pieces.  We know that Sema
    643   // has already done this, so it is guaranteed to be successful.
    644   SmallVector<GCCAsmStmt::AsmStringPiece, 4> Pieces;
    645   unsigned DiagOffs;
    646   AnalyzeAsmString(Pieces, C, DiagOffs);
    647 
    648   std::string AsmString;
    649   for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
    650     if (Pieces[i].isString())
    651       AsmString += Pieces[i].getString();
    652     else if (Pieces[i].getModifier() == '\0')
    653       AsmString += '$' + llvm::utostr(Pieces[i].getOperandNo());
    654     else
    655       AsmString += "${" + llvm::utostr(Pieces[i].getOperandNo()) + ':' +
    656                    Pieces[i].getModifier() + '}';
    657   }
    658   return AsmString;
    659 }
    660 
    661 /// Assemble final IR asm string (MS-style).
    662 std::string MSAsmStmt::generateAsmString(const ASTContext &C) const {
    663   // FIXME: This needs to be translated into the IR string representation.
    664   return AsmStr;
    665 }
    666 
    667 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
    668   return cast<Expr>(Exprs[i]);
    669 }
    670 
    671 Expr *MSAsmStmt::getInputExpr(unsigned i) {
    672   return cast<Expr>(Exprs[i + NumOutputs]);
    673 }
    674 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
    675   Exprs[i + NumOutputs] = E;
    676 }
    677 
    678 QualType CXXCatchStmt::getCaughtType() const {
    679   if (ExceptionDecl)
    680     return ExceptionDecl->getType();
    681   return QualType();
    682 }
    683 
    684 //===----------------------------------------------------------------------===//
    685 // Constructors
    686 //===----------------------------------------------------------------------===//
    687 
    688 GCCAsmStmt::GCCAsmStmt(const ASTContext &C, SourceLocation asmloc,
    689                        bool issimple, bool isvolatile, unsigned numoutputs,
    690                        unsigned numinputs, IdentifierInfo **names,
    691                        StringLiteral **constraints, Expr **exprs,
    692                        StringLiteral *asmstr, unsigned numclobbers,
    693                        StringLiteral **clobbers, SourceLocation rparenloc)
    694   : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
    695             numinputs, numclobbers), RParenLoc(rparenloc), AsmStr(asmstr) {
    696 
    697   unsigned NumExprs = NumOutputs + NumInputs;
    698 
    699   Names = new (C) IdentifierInfo*[NumExprs];
    700   std::copy(names, names + NumExprs, Names);
    701 
    702   Exprs = new (C) Stmt*[NumExprs];
    703   std::copy(exprs, exprs + NumExprs, Exprs);
    704 
    705   Constraints = new (C) StringLiteral*[NumExprs];
    706   std::copy(constraints, constraints + NumExprs, Constraints);
    707 
    708   Clobbers = new (C) StringLiteral*[NumClobbers];
    709   std::copy(clobbers, clobbers + NumClobbers, Clobbers);
    710 }
    711 
    712 MSAsmStmt::MSAsmStmt(const ASTContext &C, SourceLocation asmloc,
    713                      SourceLocation lbraceloc, bool issimple, bool isvolatile,
    714                      ArrayRef<Token> asmtoks, unsigned numoutputs,
    715                      unsigned numinputs,
    716                      ArrayRef<StringRef> constraints, ArrayRef<Expr*> exprs,
    717                      StringRef asmstr, ArrayRef<StringRef> clobbers,
    718                      SourceLocation endloc)
    719   : AsmStmt(MSAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
    720             numinputs, clobbers.size()), LBraceLoc(lbraceloc),
    721             EndLoc(endloc), NumAsmToks(asmtoks.size()) {
    722 
    723   initialize(C, asmstr, asmtoks, constraints, exprs, clobbers);
    724 }
    725 
    726 static StringRef copyIntoContext(const ASTContext &C, StringRef str) {
    727   size_t size = str.size();
    728   char *buffer = new (C) char[size];
    729   memcpy(buffer, str.data(), size);
    730   return StringRef(buffer, size);
    731 }
    732 
    733 void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr,
    734                            ArrayRef<Token> asmtoks,
    735                            ArrayRef<StringRef> constraints,
    736                            ArrayRef<Expr*> exprs,
    737                            ArrayRef<StringRef> clobbers) {
    738   assert(NumAsmToks == asmtoks.size());
    739   assert(NumClobbers == clobbers.size());
    740 
    741   unsigned NumExprs = exprs.size();
    742   assert(NumExprs == NumOutputs + NumInputs);
    743   assert(NumExprs == constraints.size());
    744 
    745   AsmStr = copyIntoContext(C, asmstr);
    746 
    747   Exprs = new (C) Stmt*[NumExprs];
    748   for (unsigned i = 0, e = NumExprs; i != e; ++i)
    749     Exprs[i] = exprs[i];
    750 
    751   AsmToks = new (C) Token[NumAsmToks];
    752   for (unsigned i = 0, e = NumAsmToks; i != e; ++i)
    753     AsmToks[i] = asmtoks[i];
    754 
    755   Constraints = new (C) StringRef[NumExprs];
    756   for (unsigned i = 0, e = NumExprs; i != e; ++i) {
    757     Constraints[i] = copyIntoContext(C, constraints[i]);
    758   }
    759 
    760   Clobbers = new (C) StringRef[NumClobbers];
    761   for (unsigned i = 0, e = NumClobbers; i != e; ++i) {
    762     // FIXME: Avoid the allocation/copy if at all possible.
    763     Clobbers[i] = copyIntoContext(C, clobbers[i]);
    764   }
    765 }
    766 
    767 ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
    768                                              Stmt *Body,  SourceLocation FCL,
    769                                              SourceLocation RPL)
    770 : Stmt(ObjCForCollectionStmtClass) {
    771   SubExprs[ELEM] = Elem;
    772   SubExprs[COLLECTION] = Collect;
    773   SubExprs[BODY] = Body;
    774   ForLoc = FCL;
    775   RParenLoc = RPL;
    776 }
    777 
    778 ObjCAtTryStmt::ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
    779                              Stmt **CatchStmts, unsigned NumCatchStmts,
    780                              Stmt *atFinallyStmt)
    781   : Stmt(ObjCAtTryStmtClass), AtTryLoc(atTryLoc),
    782     NumCatchStmts(NumCatchStmts), HasFinally(atFinallyStmt != nullptr) {
    783   Stmt **Stmts = getStmts();
    784   Stmts[0] = atTryStmt;
    785   for (unsigned I = 0; I != NumCatchStmts; ++I)
    786     Stmts[I + 1] = CatchStmts[I];
    787 
    788   if (HasFinally)
    789     Stmts[NumCatchStmts + 1] = atFinallyStmt;
    790 }
    791 
    792 ObjCAtTryStmt *ObjCAtTryStmt::Create(const ASTContext &Context,
    793                                      SourceLocation atTryLoc,
    794                                      Stmt *atTryStmt,
    795                                      Stmt **CatchStmts,
    796                                      unsigned NumCatchStmts,
    797                                      Stmt *atFinallyStmt) {
    798   unsigned Size = sizeof(ObjCAtTryStmt) +
    799     (1 + NumCatchStmts + (atFinallyStmt != nullptr)) * sizeof(Stmt *);
    800   void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
    801   return new (Mem) ObjCAtTryStmt(atTryLoc, atTryStmt, CatchStmts, NumCatchStmts,
    802                                  atFinallyStmt);
    803 }
    804 
    805 ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(const ASTContext &Context,
    806                                           unsigned NumCatchStmts,
    807                                           bool HasFinally) {
    808   unsigned Size = sizeof(ObjCAtTryStmt) +
    809     (1 + NumCatchStmts + HasFinally) * sizeof(Stmt *);
    810   void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
    811   return new (Mem) ObjCAtTryStmt(EmptyShell(), NumCatchStmts, HasFinally);
    812 }
    813 
    814 SourceLocation ObjCAtTryStmt::getLocEnd() const {
    815   if (HasFinally)
    816     return getFinallyStmt()->getLocEnd();
    817   if (NumCatchStmts)
    818     return getCatchStmt(NumCatchStmts - 1)->getLocEnd();
    819   return getTryBody()->getLocEnd();
    820 }
    821 
    822 CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, SourceLocation tryLoc,
    823                                Stmt *tryBlock, ArrayRef<Stmt*> handlers) {
    824   std::size_t Size = sizeof(CXXTryStmt);
    825   Size += ((handlers.size() + 1) * sizeof(Stmt));
    826 
    827   void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
    828   return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
    829 }
    830 
    831 CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, EmptyShell Empty,
    832                                unsigned numHandlers) {
    833   std::size_t Size = sizeof(CXXTryStmt);
    834   Size += ((numHandlers + 1) * sizeof(Stmt));
    835 
    836   void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
    837   return new (Mem) CXXTryStmt(Empty, numHandlers);
    838 }
    839 
    840 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
    841                        ArrayRef<Stmt*> handlers)
    842   : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
    843   Stmt **Stmts = reinterpret_cast<Stmt **>(this + 1);
    844   Stmts[0] = tryBlock;
    845   std::copy(handlers.begin(), handlers.end(), Stmts + 1);
    846 }
    847 
    848 CXXForRangeStmt::CXXForRangeStmt(DeclStmt *Range, DeclStmt *BeginEndStmt,
    849                                  Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
    850                                  Stmt *Body, SourceLocation FL,
    851                                  SourceLocation CL, SourceLocation RPL)
    852   : Stmt(CXXForRangeStmtClass), ForLoc(FL), ColonLoc(CL), RParenLoc(RPL) {
    853   SubExprs[RANGE] = Range;
    854   SubExprs[BEGINEND] = BeginEndStmt;
    855   SubExprs[COND] = Cond;
    856   SubExprs[INC] = Inc;
    857   SubExprs[LOOPVAR] = LoopVar;
    858   SubExprs[BODY] = Body;
    859 }
    860 
    861 Expr *CXXForRangeStmt::getRangeInit() {
    862   DeclStmt *RangeStmt = getRangeStmt();
    863   VarDecl *RangeDecl = dyn_cast_or_null<VarDecl>(RangeStmt->getSingleDecl());
    864   assert(RangeDecl && "for-range should have a single var decl");
    865   return RangeDecl->getInit();
    866 }
    867 
    868 const Expr *CXXForRangeStmt::getRangeInit() const {
    869   return const_cast<CXXForRangeStmt*>(this)->getRangeInit();
    870 }
    871 
    872 VarDecl *CXXForRangeStmt::getLoopVariable() {
    873   Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
    874   assert(LV && "No loop variable in CXXForRangeStmt");
    875   return cast<VarDecl>(LV);
    876 }
    877 
    878 const VarDecl *CXXForRangeStmt::getLoopVariable() const {
    879   return const_cast<CXXForRangeStmt*>(this)->getLoopVariable();
    880 }
    881 
    882 IfStmt::IfStmt(const ASTContext &C, SourceLocation IL, VarDecl *var, Expr *cond,
    883                Stmt *then, SourceLocation EL, Stmt *elsev)
    884   : Stmt(IfStmtClass), IfLoc(IL), ElseLoc(EL)
    885 {
    886   setConditionVariable(C, var);
    887   SubExprs[COND] = cond;
    888   SubExprs[THEN] = then;
    889   SubExprs[ELSE] = elsev;
    890 }
    891 
    892 VarDecl *IfStmt::getConditionVariable() const {
    893   if (!SubExprs[VAR])
    894     return nullptr;
    895 
    896   DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
    897   return cast<VarDecl>(DS->getSingleDecl());
    898 }
    899 
    900 void IfStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
    901   if (!V) {
    902     SubExprs[VAR] = nullptr;
    903     return;
    904   }
    905 
    906   SourceRange VarRange = V->getSourceRange();
    907   SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    908                                    VarRange.getEnd());
    909 }
    910 
    911 ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
    912                  Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
    913                  SourceLocation RP)
    914   : Stmt(ForStmtClass), ForLoc(FL), LParenLoc(LP), RParenLoc(RP)
    915 {
    916   SubExprs[INIT] = Init;
    917   setConditionVariable(C, condVar);
    918   SubExprs[COND] = Cond;
    919   SubExprs[INC] = Inc;
    920   SubExprs[BODY] = Body;
    921 }
    922 
    923 VarDecl *ForStmt::getConditionVariable() const {
    924   if (!SubExprs[CONDVAR])
    925     return nullptr;
    926 
    927   DeclStmt *DS = cast<DeclStmt>(SubExprs[CONDVAR]);
    928   return cast<VarDecl>(DS->getSingleDecl());
    929 }
    930 
    931 void ForStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
    932   if (!V) {
    933     SubExprs[CONDVAR] = nullptr;
    934     return;
    935   }
    936 
    937   SourceRange VarRange = V->getSourceRange();
    938   SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    939                                        VarRange.getEnd());
    940 }
    941 
    942 SwitchStmt::SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond)
    943     : Stmt(SwitchStmtClass), FirstCase(nullptr, false) {
    944   setConditionVariable(C, Var);
    945   SubExprs[COND] = cond;
    946   SubExprs[BODY] = nullptr;
    947 }
    948 
    949 VarDecl *SwitchStmt::getConditionVariable() const {
    950   if (!SubExprs[VAR])
    951     return nullptr;
    952 
    953   DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
    954   return cast<VarDecl>(DS->getSingleDecl());
    955 }
    956 
    957 void SwitchStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
    958   if (!V) {
    959     SubExprs[VAR] = nullptr;
    960     return;
    961   }
    962 
    963   SourceRange VarRange = V->getSourceRange();
    964   SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    965                                    VarRange.getEnd());
    966 }
    967 
    968 Stmt *SwitchCase::getSubStmt() {
    969   if (isa<CaseStmt>(this))
    970     return cast<CaseStmt>(this)->getSubStmt();
    971   return cast<DefaultStmt>(this)->getSubStmt();
    972 }
    973 
    974 WhileStmt::WhileStmt(const ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body,
    975                      SourceLocation WL)
    976   : Stmt(WhileStmtClass) {
    977   setConditionVariable(C, Var);
    978   SubExprs[COND] = cond;
    979   SubExprs[BODY] = body;
    980   WhileLoc = WL;
    981 }
    982 
    983 VarDecl *WhileStmt::getConditionVariable() const {
    984   if (!SubExprs[VAR])
    985     return nullptr;
    986 
    987   DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
    988   return cast<VarDecl>(DS->getSingleDecl());
    989 }
    990 
    991 void WhileStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
    992   if (!V) {
    993     SubExprs[VAR] = nullptr;
    994     return;
    995   }
    996 
    997   SourceRange VarRange = V->getSourceRange();
    998   SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
    999                                    VarRange.getEnd());
   1000 }
   1001 
   1002 // IndirectGotoStmt
   1003 LabelDecl *IndirectGotoStmt::getConstantTarget() {
   1004   if (AddrLabelExpr *E =
   1005         dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
   1006     return E->getLabel();
   1007   return nullptr;
   1008 }
   1009 
   1010 // ReturnStmt
   1011 const Expr* ReturnStmt::getRetValue() const {
   1012   return cast_or_null<Expr>(RetExpr);
   1013 }
   1014 Expr* ReturnStmt::getRetValue() {
   1015   return cast_or_null<Expr>(RetExpr);
   1016 }
   1017 
   1018 SEHTryStmt::SEHTryStmt(bool IsCXXTry,
   1019                        SourceLocation TryLoc,
   1020                        Stmt *TryBlock,
   1021                        Stmt *Handler)
   1022   : Stmt(SEHTryStmtClass),
   1023     IsCXXTry(IsCXXTry),
   1024     TryLoc(TryLoc)
   1025 {
   1026   Children[TRY]     = TryBlock;
   1027   Children[HANDLER] = Handler;
   1028 }
   1029 
   1030 SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry,
   1031                                SourceLocation TryLoc, Stmt *TryBlock,
   1032                                Stmt *Handler) {
   1033   return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
   1034 }
   1035 
   1036 SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
   1037   return dyn_cast<SEHExceptStmt>(getHandler());
   1038 }
   1039 
   1040 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
   1041   return dyn_cast<SEHFinallyStmt>(getHandler());
   1042 }
   1043 
   1044 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc,
   1045                              Expr *FilterExpr,
   1046                              Stmt *Block)
   1047   : Stmt(SEHExceptStmtClass),
   1048     Loc(Loc)
   1049 {
   1050   Children[FILTER_EXPR] = FilterExpr;
   1051   Children[BLOCK]       = Block;
   1052 }
   1053 
   1054 SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc,
   1055                                      Expr *FilterExpr, Stmt *Block) {
   1056   return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
   1057 }
   1058 
   1059 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc,
   1060                                Stmt *Block)
   1061   : Stmt(SEHFinallyStmtClass),
   1062     Loc(Loc),
   1063     Block(Block)
   1064 {}
   1065 
   1066 SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc,
   1067                                        Stmt *Block) {
   1068   return new(C)SEHFinallyStmt(Loc,Block);
   1069 }
   1070 
   1071 CapturedStmt::Capture *CapturedStmt::getStoredCaptures() const {
   1072   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
   1073 
   1074   // Offset of the first Capture object.
   1075   unsigned FirstCaptureOffset =
   1076     llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
   1077 
   1078   return reinterpret_cast<Capture *>(
   1079       reinterpret_cast<char *>(const_cast<CapturedStmt *>(this))
   1080       + FirstCaptureOffset);
   1081 }
   1082 
   1083 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
   1084                            ArrayRef<Capture> Captures,
   1085                            ArrayRef<Expr *> CaptureInits,
   1086                            CapturedDecl *CD,
   1087                            RecordDecl *RD)
   1088   : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
   1089     CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
   1090   assert( S && "null captured statement");
   1091   assert(CD && "null captured declaration for captured statement");
   1092   assert(RD && "null record declaration for captured statement");
   1093 
   1094   // Copy initialization expressions.
   1095   Stmt **Stored = getStoredStmts();
   1096   for (unsigned I = 0, N = NumCaptures; I != N; ++I)
   1097     *Stored++ = CaptureInits[I];
   1098 
   1099   // Copy the statement being captured.
   1100   *Stored = S;
   1101 
   1102   // Copy all Capture objects.
   1103   Capture *Buffer = getStoredCaptures();
   1104   std::copy(Captures.begin(), Captures.end(), Buffer);
   1105 }
   1106 
   1107 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures)
   1108   : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures),
   1109     CapDeclAndKind(nullptr, CR_Default), TheRecordDecl(nullptr) {
   1110   getStoredStmts()[NumCaptures] = nullptr;
   1111 }
   1112 
   1113 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S,
   1114                                    CapturedRegionKind Kind,
   1115                                    ArrayRef<Capture> Captures,
   1116                                    ArrayRef<Expr *> CaptureInits,
   1117                                    CapturedDecl *CD,
   1118                                    RecordDecl *RD) {
   1119   // The layout is
   1120   //
   1121   // -----------------------------------------------------------
   1122   // | CapturedStmt, Init, ..., Init, S, Capture, ..., Capture |
   1123   // ----------------^-------------------^----------------------
   1124   //                 getStoredStmts()    getStoredCaptures()
   1125   //
   1126   // where S is the statement being captured.
   1127   //
   1128   assert(CaptureInits.size() == Captures.size() && "wrong number of arguments");
   1129 
   1130   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1);
   1131   if (!Captures.empty()) {
   1132     // Realign for the following Capture array.
   1133     Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
   1134     Size += sizeof(Capture) * Captures.size();
   1135   }
   1136 
   1137   void *Mem = Context.Allocate(Size);
   1138   return new (Mem) CapturedStmt(S, Kind, Captures, CaptureInits, CD, RD);
   1139 }
   1140 
   1141 CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context,
   1142                                                unsigned NumCaptures) {
   1143   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
   1144   if (NumCaptures > 0) {
   1145     // Realign for the following Capture array.
   1146     Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
   1147     Size += sizeof(Capture) * NumCaptures;
   1148   }
   1149 
   1150   void *Mem = Context.Allocate(Size);
   1151   return new (Mem) CapturedStmt(EmptyShell(), NumCaptures);
   1152 }
   1153 
   1154 Stmt::child_range CapturedStmt::children() {
   1155   // Children are captured field initilizers.
   1156   return child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
   1157 }
   1158 
   1159 bool CapturedStmt::capturesVariable(const VarDecl *Var) const {
   1160   for (const auto &I : captures()) {
   1161     if (!I.capturesVariable())
   1162       continue;
   1163 
   1164     // This does not handle variable redeclarations. This should be
   1165     // extended to capture variables with redeclarations, for example
   1166     // a thread-private variable in OpenMP.
   1167     if (I.getCapturedVar() == Var)
   1168       return true;
   1169   }
   1170 
   1171   return false;
   1172 }
   1173 
   1174 StmtRange OMPClause::children() {
   1175   switch(getClauseKind()) {
   1176   default : break;
   1177 #define OPENMP_CLAUSE(Name, Class)                                       \
   1178   case OMPC_ ## Name : return static_cast<Class *>(this)->children();
   1179 #include "clang/Basic/OpenMPKinds.def"
   1180   }
   1181   llvm_unreachable("unknown OMPClause");
   1182 }
   1183 
   1184 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
   1185   assert(VL.size() == varlist_size() &&
   1186          "Number of private copies is not the same as the preallocated buffer");
   1187   std::copy(VL.begin(), VL.end(), varlist_end());
   1188 }
   1189 
   1190 OMPPrivateClause *
   1191 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
   1192                          SourceLocation LParenLoc, SourceLocation EndLoc,
   1193                          ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
   1194   // Allocate space for private variables and initializer expressions.
   1195   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
   1196                                                   llvm::alignOf<Expr *>()) +
   1197                          2 * sizeof(Expr *) * VL.size());
   1198   OMPPrivateClause *Clause =
   1199       new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   1200   Clause->setVarRefs(VL);
   1201   Clause->setPrivateCopies(PrivateVL);
   1202   return Clause;
   1203 }
   1204 
   1205 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
   1206                                                 unsigned N) {
   1207   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
   1208                                                   llvm::alignOf<Expr *>()) +
   1209                          2 * sizeof(Expr *) * N);
   1210   return new (Mem) OMPPrivateClause(N);
   1211 }
   1212 
   1213 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
   1214   assert(VL.size() == varlist_size() &&
   1215          "Number of private copies is not the same as the preallocated buffer");
   1216   std::copy(VL.begin(), VL.end(), varlist_end());
   1217 }
   1218 
   1219 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
   1220   assert(VL.size() == varlist_size() &&
   1221          "Number of inits is not the same as the preallocated buffer");
   1222   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
   1223 }
   1224 
   1225 OMPFirstprivateClause *
   1226 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
   1227                               SourceLocation LParenLoc, SourceLocation EndLoc,
   1228                               ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
   1229                               ArrayRef<Expr *> InitVL) {
   1230   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
   1231                                                   llvm::alignOf<Expr *>()) +
   1232                          3 * sizeof(Expr *) * VL.size());
   1233   OMPFirstprivateClause *Clause =
   1234       new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   1235   Clause->setVarRefs(VL);
   1236   Clause->setPrivateCopies(PrivateVL);
   1237   Clause->setInits(InitVL);
   1238   return Clause;
   1239 }
   1240 
   1241 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
   1242                                                           unsigned N) {
   1243   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
   1244                                                   llvm::alignOf<Expr *>()) +
   1245                          3 * sizeof(Expr *) * N);
   1246   return new (Mem) OMPFirstprivateClause(N);
   1247 }
   1248 
   1249 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
   1250   assert(PrivateCopies.size() == varlist_size() &&
   1251          "Number of private copies is not the same as the preallocated buffer");
   1252   std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
   1253 }
   1254 
   1255 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
   1256   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
   1257                                               "not the same as the "
   1258                                               "preallocated buffer");
   1259   std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
   1260 }
   1261 
   1262 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
   1263   assert(DstExprs.size() == varlist_size() && "Number of destination "
   1264                                               "expressions is not the same as "
   1265                                               "the preallocated buffer");
   1266   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
   1267 }
   1268 
   1269 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
   1270   assert(AssignmentOps.size() == varlist_size() &&
   1271          "Number of assignment expressions is not the same as the preallocated "
   1272          "buffer");
   1273   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
   1274             getDestinationExprs().end());
   1275 }
   1276 
   1277 OMPLastprivateClause *OMPLastprivateClause::Create(
   1278     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
   1279     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
   1280     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
   1281   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
   1282                                                   llvm::alignOf<Expr *>()) +
   1283                          5 * sizeof(Expr *) * VL.size());
   1284   OMPLastprivateClause *Clause =
   1285       new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   1286   Clause->setVarRefs(VL);
   1287   Clause->setSourceExprs(SrcExprs);
   1288   Clause->setDestinationExprs(DstExprs);
   1289   Clause->setAssignmentOps(AssignmentOps);
   1290   return Clause;
   1291 }
   1292 
   1293 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
   1294                                                         unsigned N) {
   1295   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
   1296                                                   llvm::alignOf<Expr *>()) +
   1297                          5 * sizeof(Expr *) * N);
   1298   return new (Mem) OMPLastprivateClause(N);
   1299 }
   1300 
   1301 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
   1302                                          SourceLocation StartLoc,
   1303                                          SourceLocation LParenLoc,
   1304                                          SourceLocation EndLoc,
   1305                                          ArrayRef<Expr *> VL) {
   1306   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
   1307                                                   llvm::alignOf<Expr *>()) +
   1308                          sizeof(Expr *) * VL.size());
   1309   OMPSharedClause *Clause = new (Mem) OMPSharedClause(StartLoc, LParenLoc,
   1310                                                       EndLoc, VL.size());
   1311   Clause->setVarRefs(VL);
   1312   return Clause;
   1313 }
   1314 
   1315 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C,
   1316                                               unsigned N) {
   1317   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
   1318                                                   llvm::alignOf<Expr *>()) +
   1319                          sizeof(Expr *) * N);
   1320   return new (Mem) OMPSharedClause(N);
   1321 }
   1322 
   1323 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
   1324   assert(IL.size() == varlist_size() &&
   1325          "Number of inits is not the same as the preallocated buffer");
   1326   std::copy(IL.begin(), IL.end(), varlist_end());
   1327 }
   1328 
   1329 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
   1330   assert(UL.size() == varlist_size() &&
   1331          "Number of updates is not the same as the preallocated buffer");
   1332   std::copy(UL.begin(), UL.end(), getInits().end());
   1333 }
   1334 
   1335 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
   1336   assert(FL.size() == varlist_size() &&
   1337          "Number of final updates is not the same as the preallocated buffer");
   1338   std::copy(FL.begin(), FL.end(), getUpdates().end());
   1339 }
   1340 
   1341 OMPLinearClause *
   1342 OMPLinearClause::Create(const ASTContext &C, SourceLocation StartLoc,
   1343                         SourceLocation LParenLoc, SourceLocation ColonLoc,
   1344                         SourceLocation EndLoc, ArrayRef<Expr *> VL,
   1345                         ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep) {
   1346   // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
   1347   // (Step and CalcStep).
   1348   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
   1349                                                   llvm::alignOf<Expr *>()) +
   1350                          (4 * VL.size() + 2) * sizeof(Expr *));
   1351   OMPLinearClause *Clause = new (Mem)
   1352       OMPLinearClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
   1353   Clause->setVarRefs(VL);
   1354   Clause->setInits(IL);
   1355   // Fill update and final expressions with zeroes, they are provided later,
   1356   // after the directive construction.
   1357   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
   1358             nullptr);
   1359   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
   1360             nullptr);
   1361   Clause->setStep(Step);
   1362   Clause->setCalcStep(CalcStep);
   1363   return Clause;
   1364 }
   1365 
   1366 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
   1367                                               unsigned NumVars) {
   1368   // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
   1369   // (Step and CalcStep).
   1370   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
   1371                                                   llvm::alignOf<Expr *>()) +
   1372                          (4 * NumVars + 2) * sizeof(Expr *));
   1373   return new (Mem) OMPLinearClause(NumVars);
   1374 }
   1375 
   1376 OMPAlignedClause *
   1377 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
   1378                          SourceLocation LParenLoc, SourceLocation ColonLoc,
   1379                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
   1380   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
   1381                                                   llvm::alignOf<Expr *>()) +
   1382                          sizeof(Expr *) * (VL.size() + 1));
   1383   OMPAlignedClause *Clause = new (Mem)
   1384       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
   1385   Clause->setVarRefs(VL);
   1386   Clause->setAlignment(A);
   1387   return Clause;
   1388 }
   1389 
   1390 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
   1391                                                 unsigned NumVars) {
   1392   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
   1393                                                   llvm::alignOf<Expr *>()) +
   1394                          sizeof(Expr *) * (NumVars + 1));
   1395   return new (Mem) OMPAlignedClause(NumVars);
   1396 }
   1397 
   1398 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
   1399   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
   1400                                               "not the same as the "
   1401                                               "preallocated buffer");
   1402   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
   1403 }
   1404 
   1405 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
   1406   assert(DstExprs.size() == varlist_size() && "Number of destination "
   1407                                               "expressions is not the same as "
   1408                                               "the preallocated buffer");
   1409   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
   1410 }
   1411 
   1412 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
   1413   assert(AssignmentOps.size() == varlist_size() &&
   1414          "Number of assignment expressions is not the same as the preallocated "
   1415          "buffer");
   1416   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
   1417             getDestinationExprs().end());
   1418 }
   1419 
   1420 OMPCopyinClause *OMPCopyinClause::Create(
   1421     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
   1422     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
   1423     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
   1424   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
   1425                                                   llvm::alignOf<Expr *>()) +
   1426                          4 * sizeof(Expr *) * VL.size());
   1427   OMPCopyinClause *Clause = new (Mem) OMPCopyinClause(StartLoc, LParenLoc,
   1428                                                       EndLoc, VL.size());
   1429   Clause->setVarRefs(VL);
   1430   Clause->setSourceExprs(SrcExprs);
   1431   Clause->setDestinationExprs(DstExprs);
   1432   Clause->setAssignmentOps(AssignmentOps);
   1433   return Clause;
   1434 }
   1435 
   1436 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C,
   1437                                               unsigned N) {
   1438   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
   1439                                                   llvm::alignOf<Expr *>()) +
   1440                          4 * sizeof(Expr *) * N);
   1441   return new (Mem) OMPCopyinClause(N);
   1442 }
   1443 
   1444 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
   1445   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
   1446                                               "not the same as the "
   1447                                               "preallocated buffer");
   1448   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
   1449 }
   1450 
   1451 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
   1452   assert(DstExprs.size() == varlist_size() && "Number of destination "
   1453                                               "expressions is not the same as "
   1454                                               "the preallocated buffer");
   1455   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
   1456 }
   1457 
   1458 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
   1459   assert(AssignmentOps.size() == varlist_size() &&
   1460          "Number of assignment expressions is not the same as the preallocated "
   1461          "buffer");
   1462   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
   1463             getDestinationExprs().end());
   1464 }
   1465 
   1466 OMPCopyprivateClause *OMPCopyprivateClause::Create(
   1467     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
   1468     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
   1469     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
   1470   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
   1471                                                   llvm::alignOf<Expr *>()) +
   1472                          4 * sizeof(Expr *) * VL.size());
   1473   OMPCopyprivateClause *Clause =
   1474       new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   1475   Clause->setVarRefs(VL);
   1476   Clause->setSourceExprs(SrcExprs);
   1477   Clause->setDestinationExprs(DstExprs);
   1478   Clause->setAssignmentOps(AssignmentOps);
   1479   return Clause;
   1480 }
   1481 
   1482 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
   1483                                                         unsigned N) {
   1484   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
   1485                                                   llvm::alignOf<Expr *>()) +
   1486                          4 * sizeof(Expr *) * N);
   1487   return new (Mem) OMPCopyprivateClause(N);
   1488 }
   1489 
   1490 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
   1491   assert(Clauses.size() == getNumClauses() &&
   1492          "Number of clauses is not the same as the preallocated buffer");
   1493   std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
   1494 }
   1495 
   1496 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
   1497   assert(A.size() == getCollapsedNumber() &&
   1498          "Number of loop counters is not the same as the collapsed number");
   1499   std::copy(A.begin(), A.end(), getCounters().begin());
   1500 }
   1501 
   1502 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
   1503   assert(A.size() == getCollapsedNumber() &&
   1504          "Number of counter updates is not the same as the collapsed number");
   1505   std::copy(A.begin(), A.end(), getUpdates().begin());
   1506 }
   1507 
   1508 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
   1509   assert(A.size() == getCollapsedNumber() &&
   1510          "Number of counter finals is not the same as the collapsed number");
   1511   std::copy(A.begin(), A.end(), getFinals().begin());
   1512 }
   1513 
   1514 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
   1515   assert(
   1516       LHSExprs.size() == varlist_size() &&
   1517       "Number of LHS expressions is not the same as the preallocated buffer");
   1518   std::copy(LHSExprs.begin(), LHSExprs.end(), varlist_end());
   1519 }
   1520 
   1521 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
   1522   assert(
   1523       RHSExprs.size() == varlist_size() &&
   1524       "Number of RHS expressions is not the same as the preallocated buffer");
   1525   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
   1526 }
   1527 
   1528 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
   1529   assert(ReductionOps.size() == varlist_size() && "Number of reduction "
   1530                                                   "expressions is not the same "
   1531                                                   "as the preallocated buffer");
   1532   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
   1533 }
   1534 
   1535 OMPReductionClause *OMPReductionClause::Create(
   1536     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
   1537     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
   1538     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
   1539     ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
   1540     ArrayRef<Expr *> ReductionOps) {
   1541   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
   1542                                                   llvm::alignOf<Expr *>()) +
   1543                          4 * sizeof(Expr *) * VL.size());
   1544   OMPReductionClause *Clause = new (Mem) OMPReductionClause(
   1545       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
   1546   Clause->setVarRefs(VL);
   1547   Clause->setLHSExprs(LHSExprs);
   1548   Clause->setRHSExprs(RHSExprs);
   1549   Clause->setReductionOps(ReductionOps);
   1550   return Clause;
   1551 }
   1552 
   1553 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
   1554                                                     unsigned N) {
   1555   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
   1556                                                   llvm::alignOf<Expr *>()) +
   1557                          4 * sizeof(Expr *) * N);
   1558   return new (Mem) OMPReductionClause(N);
   1559 }
   1560 
   1561 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
   1562                                        SourceLocation StartLoc,
   1563                                        SourceLocation LParenLoc,
   1564                                        SourceLocation EndLoc,
   1565                                        ArrayRef<Expr *> VL) {
   1566   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
   1567                                                   llvm::alignOf<Expr *>()) +
   1568                          sizeof(Expr *) * VL.size());
   1569   OMPFlushClause *Clause =
   1570       new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
   1571   Clause->setVarRefs(VL);
   1572   return Clause;
   1573 }
   1574 
   1575 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
   1576   void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
   1577                                                   llvm::alignOf<Expr *>()) +
   1578                          sizeof(Expr *) * N);
   1579   return new (Mem) OMPFlushClause(N);
   1580 }
   1581 
   1582 const OMPClause *
   1583 OMPExecutableDirective::getSingleClause(OpenMPClauseKind K) const {
   1584   auto ClauseFilter =
   1585       [=](const OMPClause *C) -> bool { return C->getClauseKind() == K; };
   1586   OMPExecutableDirective::filtered_clause_iterator<decltype(ClauseFilter)> I(
   1587       clauses(), ClauseFilter);
   1588 
   1589   if (I) {
   1590     auto *Clause = *I;
   1591     assert(!++I && "There are at least 2 clauses of the specified kind");
   1592     return Clause;
   1593   }
   1594   return nullptr;
   1595 }
   1596 
   1597 OMPParallelDirective *OMPParallelDirective::Create(
   1598                                               const ASTContext &C,
   1599                                               SourceLocation StartLoc,
   1600                                               SourceLocation EndLoc,
   1601                                               ArrayRef<OMPClause *> Clauses,
   1602                                               Stmt *AssociatedStmt) {
   1603   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
   1604                                            llvm::alignOf<OMPClause *>());
   1605   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
   1606                          sizeof(Stmt *));
   1607   OMPParallelDirective *Dir = new (Mem) OMPParallelDirective(StartLoc, EndLoc,
   1608                                                              Clauses.size());
   1609   Dir->setClauses(Clauses);
   1610   Dir->setAssociatedStmt(AssociatedStmt);
   1611   return Dir;
   1612 }
   1613 
   1614 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
   1615                                                         unsigned NumClauses,
   1616                                                         EmptyShell) {
   1617   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
   1618                                            llvm::alignOf<OMPClause *>());
   1619   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
   1620                          sizeof(Stmt *));
   1621   return new (Mem) OMPParallelDirective(NumClauses);
   1622 }
   1623 
   1624 OMPSimdDirective *
   1625 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
   1626                          SourceLocation EndLoc, unsigned CollapsedNum,
   1627                          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1628                          const HelperExprs &Exprs) {
   1629   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
   1630                                            llvm::alignOf<OMPClause *>());
   1631   void *Mem =
   1632       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
   1633                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
   1634   OMPSimdDirective *Dir = new (Mem)
   1635       OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
   1636   Dir->setClauses(Clauses);
   1637   Dir->setAssociatedStmt(AssociatedStmt);
   1638   Dir->setIterationVariable(Exprs.IterationVarRef);
   1639   Dir->setLastIteration(Exprs.LastIteration);
   1640   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1641   Dir->setPreCond(Exprs.PreCond);
   1642   Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
   1643   Dir->setInit(Exprs.Init);
   1644   Dir->setInc(Exprs.Inc);
   1645   Dir->setCounters(Exprs.Counters);
   1646   Dir->setUpdates(Exprs.Updates);
   1647   Dir->setFinals(Exprs.Finals);
   1648   return Dir;
   1649 }
   1650 
   1651 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
   1652                                                 unsigned NumClauses,
   1653                                                 unsigned CollapsedNum,
   1654                                                 EmptyShell) {
   1655   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
   1656                                            llvm::alignOf<OMPClause *>());
   1657   void *Mem =
   1658       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
   1659                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
   1660   return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
   1661 }
   1662 
   1663 OMPForDirective *
   1664 OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc,
   1665                         SourceLocation EndLoc, unsigned CollapsedNum,
   1666                         ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1667                         const HelperExprs &Exprs) {
   1668   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
   1669                                            llvm::alignOf<OMPClause *>());
   1670   void *Mem =
   1671       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
   1672                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
   1673   OMPForDirective *Dir =
   1674       new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
   1675   Dir->setClauses(Clauses);
   1676   Dir->setAssociatedStmt(AssociatedStmt);
   1677   Dir->setIterationVariable(Exprs.IterationVarRef);
   1678   Dir->setLastIteration(Exprs.LastIteration);
   1679   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1680   Dir->setPreCond(Exprs.PreCond);
   1681   Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
   1682   Dir->setInit(Exprs.Init);
   1683   Dir->setInc(Exprs.Inc);
   1684   Dir->setIsLastIterVariable(Exprs.IL);
   1685   Dir->setLowerBoundVariable(Exprs.LB);
   1686   Dir->setUpperBoundVariable(Exprs.UB);
   1687   Dir->setStrideVariable(Exprs.ST);
   1688   Dir->setEnsureUpperBound(Exprs.EUB);
   1689   Dir->setNextLowerBound(Exprs.NLB);
   1690   Dir->setNextUpperBound(Exprs.NUB);
   1691   Dir->setCounters(Exprs.Counters);
   1692   Dir->setUpdates(Exprs.Updates);
   1693   Dir->setFinals(Exprs.Finals);
   1694   return Dir;
   1695 }
   1696 
   1697 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
   1698                                               unsigned NumClauses,
   1699                                               unsigned CollapsedNum,
   1700                                               EmptyShell) {
   1701   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
   1702                                            llvm::alignOf<OMPClause *>());
   1703   void *Mem =
   1704       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
   1705                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
   1706   return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
   1707 }
   1708 
   1709 OMPForSimdDirective *
   1710 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
   1711                             SourceLocation EndLoc, unsigned CollapsedNum,
   1712                             ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1713                             const HelperExprs &Exprs) {
   1714   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
   1715                                            llvm::alignOf<OMPClause *>());
   1716   void *Mem =
   1717       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
   1718                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
   1719   OMPForSimdDirective *Dir = new (Mem)
   1720       OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
   1721   Dir->setClauses(Clauses);
   1722   Dir->setAssociatedStmt(AssociatedStmt);
   1723   Dir->setIterationVariable(Exprs.IterationVarRef);
   1724   Dir->setLastIteration(Exprs.LastIteration);
   1725   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1726   Dir->setPreCond(Exprs.PreCond);
   1727   Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
   1728   Dir->setInit(Exprs.Init);
   1729   Dir->setInc(Exprs.Inc);
   1730   Dir->setIsLastIterVariable(Exprs.IL);
   1731   Dir->setLowerBoundVariable(Exprs.LB);
   1732   Dir->setUpperBoundVariable(Exprs.UB);
   1733   Dir->setStrideVariable(Exprs.ST);
   1734   Dir->setEnsureUpperBound(Exprs.EUB);
   1735   Dir->setNextLowerBound(Exprs.NLB);
   1736   Dir->setNextUpperBound(Exprs.NUB);
   1737   Dir->setCounters(Exprs.Counters);
   1738   Dir->setUpdates(Exprs.Updates);
   1739   Dir->setFinals(Exprs.Finals);
   1740   return Dir;
   1741 }
   1742 
   1743 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
   1744                                                       unsigned NumClauses,
   1745                                                       unsigned CollapsedNum,
   1746                                                       EmptyShell) {
   1747   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
   1748                                            llvm::alignOf<OMPClause *>());
   1749   void *Mem =
   1750       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
   1751                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
   1752   return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
   1753 }
   1754 
   1755 OMPSectionsDirective *OMPSectionsDirective::Create(
   1756     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1757     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   1758   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
   1759                                            llvm::alignOf<OMPClause *>());
   1760   void *Mem =
   1761       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
   1762   OMPSectionsDirective *Dir =
   1763       new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
   1764   Dir->setClauses(Clauses);
   1765   Dir->setAssociatedStmt(AssociatedStmt);
   1766   return Dir;
   1767 }
   1768 
   1769 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
   1770                                                         unsigned NumClauses,
   1771                                                         EmptyShell) {
   1772   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
   1773                                            llvm::alignOf<OMPClause *>());
   1774   void *Mem =
   1775       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
   1776   return new (Mem) OMPSectionsDirective(NumClauses);
   1777 }
   1778 
   1779 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
   1780                                                  SourceLocation StartLoc,
   1781                                                  SourceLocation EndLoc,
   1782                                                  Stmt *AssociatedStmt) {
   1783   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
   1784                                            llvm::alignOf<Stmt *>());
   1785   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   1786   OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
   1787   Dir->setAssociatedStmt(AssociatedStmt);
   1788   return Dir;
   1789 }
   1790 
   1791 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
   1792                                                       EmptyShell) {
   1793   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
   1794                                            llvm::alignOf<Stmt *>());
   1795   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   1796   return new (Mem) OMPSectionDirective();
   1797 }
   1798 
   1799 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
   1800                                                SourceLocation StartLoc,
   1801                                                SourceLocation EndLoc,
   1802                                                ArrayRef<OMPClause *> Clauses,
   1803                                                Stmt *AssociatedStmt) {
   1804   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
   1805                                            llvm::alignOf<OMPClause *>());
   1806   void *Mem =
   1807       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
   1808   OMPSingleDirective *Dir =
   1809       new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
   1810   Dir->setClauses(Clauses);
   1811   Dir->setAssociatedStmt(AssociatedStmt);
   1812   return Dir;
   1813 }
   1814 
   1815 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
   1816                                                     unsigned NumClauses,
   1817                                                     EmptyShell) {
   1818   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
   1819                                            llvm::alignOf<OMPClause *>());
   1820   void *Mem =
   1821       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
   1822   return new (Mem) OMPSingleDirective(NumClauses);
   1823 }
   1824 
   1825 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
   1826                                                SourceLocation StartLoc,
   1827                                                SourceLocation EndLoc,
   1828                                                Stmt *AssociatedStmt) {
   1829   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
   1830                                            llvm::alignOf<Stmt *>());
   1831   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   1832   OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
   1833   Dir->setAssociatedStmt(AssociatedStmt);
   1834   return Dir;
   1835 }
   1836 
   1837 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
   1838                                                     EmptyShell) {
   1839   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
   1840                                            llvm::alignOf<Stmt *>());
   1841   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   1842   return new (Mem) OMPMasterDirective();
   1843 }
   1844 
   1845 OMPCriticalDirective *OMPCriticalDirective::Create(
   1846     const ASTContext &C, const DeclarationNameInfo &Name,
   1847     SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt) {
   1848   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
   1849                                            llvm::alignOf<Stmt *>());
   1850   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   1851   OMPCriticalDirective *Dir =
   1852       new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc);
   1853   Dir->setAssociatedStmt(AssociatedStmt);
   1854   return Dir;
   1855 }
   1856 
   1857 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
   1858                                                         EmptyShell) {
   1859   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
   1860                                            llvm::alignOf<Stmt *>());
   1861   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   1862   return new (Mem) OMPCriticalDirective();
   1863 }
   1864 
   1865 OMPParallelForDirective *OMPParallelForDirective::Create(
   1866     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1867     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1868     const HelperExprs &Exprs) {
   1869   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
   1870                                            llvm::alignOf<OMPClause *>());
   1871   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
   1872                          sizeof(Stmt *) *
   1873                              numLoopChildren(CollapsedNum, OMPD_parallel_for));
   1874   OMPParallelForDirective *Dir = new (Mem)
   1875       OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
   1876   Dir->setClauses(Clauses);
   1877   Dir->setAssociatedStmt(AssociatedStmt);
   1878   Dir->setIterationVariable(Exprs.IterationVarRef);
   1879   Dir->setLastIteration(Exprs.LastIteration);
   1880   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1881   Dir->setPreCond(Exprs.PreCond);
   1882   Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
   1883   Dir->setInit(Exprs.Init);
   1884   Dir->setInc(Exprs.Inc);
   1885   Dir->setIsLastIterVariable(Exprs.IL);
   1886   Dir->setLowerBoundVariable(Exprs.LB);
   1887   Dir->setUpperBoundVariable(Exprs.UB);
   1888   Dir->setStrideVariable(Exprs.ST);
   1889   Dir->setEnsureUpperBound(Exprs.EUB);
   1890   Dir->setNextLowerBound(Exprs.NLB);
   1891   Dir->setNextUpperBound(Exprs.NUB);
   1892   Dir->setCounters(Exprs.Counters);
   1893   Dir->setUpdates(Exprs.Updates);
   1894   Dir->setFinals(Exprs.Finals);
   1895   return Dir;
   1896 }
   1897 
   1898 OMPParallelForDirective *
   1899 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
   1900                                      unsigned CollapsedNum, EmptyShell) {
   1901   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
   1902                                            llvm::alignOf<OMPClause *>());
   1903   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
   1904                          sizeof(Stmt *) *
   1905                              numLoopChildren(CollapsedNum, OMPD_parallel_for));
   1906   return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
   1907 }
   1908 
   1909 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
   1910     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1911     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1912     const HelperExprs &Exprs) {
   1913   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
   1914                                            llvm::alignOf<OMPClause *>());
   1915   void *Mem = C.Allocate(
   1916       Size + sizeof(OMPClause *) * Clauses.size() +
   1917       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
   1918   OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective(
   1919       StartLoc, EndLoc, CollapsedNum, Clauses.size());
   1920   Dir->setClauses(Clauses);
   1921   Dir->setAssociatedStmt(AssociatedStmt);
   1922   Dir->setIterationVariable(Exprs.IterationVarRef);
   1923   Dir->setLastIteration(Exprs.LastIteration);
   1924   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1925   Dir->setPreCond(Exprs.PreCond);
   1926   Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
   1927   Dir->setInit(Exprs.Init);
   1928   Dir->setInc(Exprs.Inc);
   1929   Dir->setIsLastIterVariable(Exprs.IL);
   1930   Dir->setLowerBoundVariable(Exprs.LB);
   1931   Dir->setUpperBoundVariable(Exprs.UB);
   1932   Dir->setStrideVariable(Exprs.ST);
   1933   Dir->setEnsureUpperBound(Exprs.EUB);
   1934   Dir->setNextLowerBound(Exprs.NLB);
   1935   Dir->setNextUpperBound(Exprs.NUB);
   1936   Dir->setCounters(Exprs.Counters);
   1937   Dir->setUpdates(Exprs.Updates);
   1938   Dir->setFinals(Exprs.Finals);
   1939   return Dir;
   1940 }
   1941 
   1942 OMPParallelForSimdDirective *
   1943 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
   1944                                          unsigned NumClauses,
   1945                                          unsigned CollapsedNum, EmptyShell) {
   1946   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
   1947                                            llvm::alignOf<OMPClause *>());
   1948   void *Mem = C.Allocate(
   1949       Size + sizeof(OMPClause *) * NumClauses +
   1950       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
   1951   return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
   1952 }
   1953 
   1954 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
   1955     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1956     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   1957   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
   1958                                            llvm::alignOf<OMPClause *>());
   1959   void *Mem =
   1960       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
   1961   OMPParallelSectionsDirective *Dir =
   1962       new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
   1963   Dir->setClauses(Clauses);
   1964   Dir->setAssociatedStmt(AssociatedStmt);
   1965   return Dir;
   1966 }
   1967 
   1968 OMPParallelSectionsDirective *
   1969 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
   1970                                           unsigned NumClauses, EmptyShell) {
   1971   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
   1972                                            llvm::alignOf<OMPClause *>());
   1973   void *Mem =
   1974       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
   1975   return new (Mem) OMPParallelSectionsDirective(NumClauses);
   1976 }
   1977 
   1978 OMPTaskDirective *OMPTaskDirective::Create(const ASTContext &C,
   1979                                            SourceLocation StartLoc,
   1980                                            SourceLocation EndLoc,
   1981                                            ArrayRef<OMPClause *> Clauses,
   1982                                            Stmt *AssociatedStmt) {
   1983   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
   1984                                            llvm::alignOf<OMPClause *>());
   1985   void *Mem =
   1986       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
   1987   OMPTaskDirective *Dir =
   1988       new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
   1989   Dir->setClauses(Clauses);
   1990   Dir->setAssociatedStmt(AssociatedStmt);
   1991   return Dir;
   1992 }
   1993 
   1994 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
   1995                                                 unsigned NumClauses,
   1996                                                 EmptyShell) {
   1997   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
   1998                                            llvm::alignOf<OMPClause *>());
   1999   void *Mem =
   2000       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
   2001   return new (Mem) OMPTaskDirective(NumClauses);
   2002 }
   2003 
   2004 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
   2005                                                      SourceLocation StartLoc,
   2006                                                      SourceLocation EndLoc) {
   2007   void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
   2008   OMPTaskyieldDirective *Dir =
   2009       new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
   2010   return Dir;
   2011 }
   2012 
   2013 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
   2014                                                           EmptyShell) {
   2015   void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
   2016   return new (Mem) OMPTaskyieldDirective();
   2017 }
   2018 
   2019 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
   2020                                                  SourceLocation StartLoc,
   2021                                                  SourceLocation EndLoc) {
   2022   void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
   2023   OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
   2024   return Dir;
   2025 }
   2026 
   2027 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
   2028                                                       EmptyShell) {
   2029   void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
   2030   return new (Mem) OMPBarrierDirective();
   2031 }
   2032 
   2033 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
   2034                                                    SourceLocation StartLoc,
   2035                                                    SourceLocation EndLoc) {
   2036   void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
   2037   OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
   2038   return Dir;
   2039 }
   2040 
   2041 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
   2042                                                         EmptyShell) {
   2043   void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
   2044   return new (Mem) OMPTaskwaitDirective();
   2045 }
   2046 
   2047 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
   2048                                              SourceLocation StartLoc,
   2049                                              SourceLocation EndLoc,
   2050                                              ArrayRef<OMPClause *> Clauses) {
   2051   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
   2052                                            llvm::alignOf<OMPClause *>());
   2053   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
   2054   OMPFlushDirective *Dir =
   2055       new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
   2056   Dir->setClauses(Clauses);
   2057   return Dir;
   2058 }
   2059 
   2060 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
   2061                                                   unsigned NumClauses,
   2062                                                   EmptyShell) {
   2063   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
   2064                                            llvm::alignOf<OMPClause *>());
   2065   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
   2066   return new (Mem) OMPFlushDirective(NumClauses);
   2067 }
   2068 
   2069 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
   2070                                                  SourceLocation StartLoc,
   2071                                                  SourceLocation EndLoc,
   2072                                                  Stmt *AssociatedStmt) {
   2073   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
   2074                                            llvm::alignOf<Stmt *>());
   2075   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   2076   OMPOrderedDirective *Dir = new (Mem) OMPOrderedDirective(StartLoc, EndLoc);
   2077   Dir->setAssociatedStmt(AssociatedStmt);
   2078   return Dir;
   2079 }
   2080 
   2081 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
   2082                                                       EmptyShell) {
   2083   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
   2084                                            llvm::alignOf<Stmt *>());
   2085   void *Mem = C.Allocate(Size + sizeof(Stmt *));
   2086   return new (Mem) OMPOrderedDirective();
   2087 }
   2088 
   2089 OMPAtomicDirective *OMPAtomicDirective::Create(
   2090     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   2091     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
   2092     Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
   2093   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
   2094                                            llvm::alignOf<OMPClause *>());
   2095   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
   2096                          5 * sizeof(Stmt *));
   2097   OMPAtomicDirective *Dir =
   2098       new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
   2099   Dir->setClauses(Clauses);
   2100   Dir->setAssociatedStmt(AssociatedStmt);
   2101   Dir->setX(X);
   2102   Dir->setV(V);
   2103   Dir->setExpr(E);
   2104   Dir->setUpdateExpr(UE);
   2105   Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
   2106   Dir->IsPostfixUpdate = IsPostfixUpdate;
   2107   return Dir;
   2108 }
   2109 
   2110 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
   2111                                                     unsigned NumClauses,
   2112                                                     EmptyShell) {
   2113   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
   2114                                            llvm::alignOf<OMPClause *>());
   2115   void *Mem =
   2116       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
   2117   return new (Mem) OMPAtomicDirective(NumClauses);
   2118 }
   2119 
   2120 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
   2121                                                SourceLocation StartLoc,
   2122                                                SourceLocation EndLoc,
   2123                                                ArrayRef<OMPClause *> Clauses,
   2124                                                Stmt *AssociatedStmt) {
   2125   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
   2126                                            llvm::alignOf<OMPClause *>());
   2127   void *Mem =
   2128       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
   2129   OMPTargetDirective *Dir =
   2130       new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
   2131   Dir->setClauses(Clauses);
   2132   Dir->setAssociatedStmt(AssociatedStmt);
   2133   return Dir;
   2134 }
   2135 
   2136 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
   2137                                                     unsigned NumClauses,
   2138                                                     EmptyShell) {
   2139   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
   2140                                            llvm::alignOf<OMPClause *>());
   2141   void *Mem =
   2142       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
   2143   return new (Mem) OMPTargetDirective(NumClauses);
   2144 }
   2145 
   2146 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
   2147                                              SourceLocation StartLoc,
   2148                                              SourceLocation EndLoc,
   2149                                              ArrayRef<OMPClause *> Clauses,
   2150                                              Stmt *AssociatedStmt) {
   2151   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
   2152                                            llvm::alignOf<OMPClause *>());
   2153   void *Mem =
   2154       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
   2155   OMPTeamsDirective *Dir =
   2156       new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
   2157   Dir->setClauses(Clauses);
   2158   Dir->setAssociatedStmt(AssociatedStmt);
   2159   return Dir;
   2160 }
   2161 
   2162 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
   2163                                                   unsigned NumClauses,
   2164                                                   EmptyShell) {
   2165   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
   2166                                            llvm::alignOf<OMPClause *>());
   2167   void *Mem =
   2168       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
   2169   return new (Mem) OMPTeamsDirective(NumClauses);
   2170 }
   2171 
   2172