lib/AST/Stmt.cpp

   1 //===- Stmt.cpp - Statement AST Node Implementation -----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the Stmt class and statement subclasses.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/AST/Stmt.h"
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/ASTDiagnostic.h"
  16 #include "clang/AST/Decl.h"
  17 #include "clang/AST/DeclGroup.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/AST/ExprCXX.h"
  20 #include "clang/AST/ExprObjC.h"
  21 #include "clang/AST/ExprOpenMP.h"
  22 #include "clang/AST/StmtCXX.h"
  23 #include "clang/AST/StmtObjC.h"
  24 #include "clang/AST/StmtOpenMP.h"
  25 #include "clang/AST/Type.h"
  26 #include "clang/Basic/CharInfo.h"
  27 #include "clang/Basic/LLVM.h"
  28 #include "clang/Basic/SourceLocation.h"
  29 #include "clang/Basic/TargetInfo.h"
  30 #include "clang/Lex/Token.h"
  31 #include "llvm/ADT/SmallVector.h"
  32 #include "llvm/ADT/StringExtras.h"
  33 #include "llvm/ADT/StringRef.h"
  34 #include "llvm/Support/Casting.h"
  35 #include "llvm/Support/Compiler.h"
  36 #include "llvm/Support/ErrorHandling.h"
  37 #include "llvm/Support/MathExtras.h"
  38 #include "llvm/Support/raw_ostream.h"
  39 #include <algorithm>
  40 #include <cassert>
  41 #include <cstring>
  42 #include <string>
  43 #include <utility>
  44 #include <type_traits>
  45
  46 using namespace clang;
  47
  48 static struct StmtClassNameTable {
  49   const char *Name;
  50   unsigned Counter;
  51   unsigned Size;
  52 } StmtClassInfo[Stmt::lastStmtConstant+1];
  53
  54 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
  55   static bool Initialized = false;
  56   if (Initialized)
  57     return StmtClassInfo[E];
  58
  59   // Initialize the table on the first use.
  60   Initialized = true;
  61 #define ABSTRACT_STMT(STMT)
  62 #define STMT(CLASS, PARENT) \
  63   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS;    \
  64   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);
  65 #include "clang/AST/StmtNodes.inc"
  66
  67   return StmtClassInfo[E];
  68 }
  69
  70 void *Stmt::operator new(size_t bytes, const ASTContext& C,
  71                          unsigned alignment) {
  72   return ::operator new(bytes, C, alignment);
  73 }
  74
  75 const char *Stmt::getStmtClassName() const {
  76   return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
  77 }
  78
  79 // Check that no statement / expression class is polymorphic. LLVM style RTTI
  80 // should be used instead. If absolutely needed an exception can still be added
  81 // here by defining the appropriate macro (but please don't do this).
  82 #define STMT(CLASS, PARENT) \
  83   static_assert(!std::is_polymorphic<CLASS>::value, \
  84                 #CLASS " should not be polymorphic!");
  85 #include "clang/AST/StmtNodes.inc"
  86
  87 // Check that no statement / expression class has a non-trival destructor.
  88 // Statements and expressions are allocated with the BumpPtrAllocator from
  89 // ASTContext and therefore their destructor is not executed.
  90 #define STMT(CLASS, PARENT)                                                    \
  91   static_assert(std::is_trivially_destructible<CLASS>::value,                  \
  92                 #CLASS " should be trivially destructible!");
  93 // FIXME: InitListExpr is not trivially destructible due to its ASTVector.
  94 #define INITLISTEXPR(CLASS, PARENT)
  95 #include "clang/AST/StmtNodes.inc"
  96
  97 void Stmt::PrintStats() {
  98   // Ensure the table is primed.
  99   getStmtInfoTableEntry(Stmt::NullStmtClass);
 100
 101   unsigned sum = 0;
 102   llvm::errs() << "\n*** Stmt/Expr Stats:\n";
 103   for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
 104     if (StmtClassInfo[i].Name == nullptr) continue;
 105     sum += StmtClassInfo[i].Counter;
 106   }
 107   llvm::errs() << "  " << sum << " stmts/exprs total.\n";
 108   sum = 0;
 109   for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
 110     if (StmtClassInfo[i].Name == nullptr) continue;
 111     if (StmtClassInfo[i].Counter == 0) continue;
 112     llvm::errs() << "    " << StmtClassInfo[i].Counter << " "
 113                  << StmtClassInfo[i].Name << ", " << StmtClassInfo[i].Size
 114                  << " each (" << StmtClassInfo[i].Counter*StmtClassInfo[i].Size
 115                  << " bytes)\n";
 116     sum += StmtClassInfo[i].Counter*StmtClassInfo[i].Size;
 117   }
 118
 119   llvm::errs() << "Total bytes = " << sum << "\n";
 120 }
 121
 122 void Stmt::addStmtClass(StmtClass s) {
 123   ++getStmtInfoTableEntry(s).Counter;
 124 }
 125
 126 bool Stmt::StatisticsEnabled = false;
 127 void Stmt::EnableStatistics() {
 128   StatisticsEnabled = true;
 129 }
 130
 131 /// Skip no-op (attributed, compound) container stmts and skip captured
 132 /// stmt at the top, if \a IgnoreCaptured is true.
 133 Stmt *Stmt::IgnoreContainers(bool IgnoreCaptured) {
 134   Stmt *S = this;
 135   if (IgnoreCaptured)
 136     if (auto CapS = dyn_cast_or_null<CapturedStmt>(S))
 137       S = CapS->getCapturedStmt();
 138   while (true) {
 139     if (auto AS = dyn_cast_or_null<AttributedStmt>(S))
 140       S = AS->getSubStmt();
 141     else if (auto CS = dyn_cast_or_null<CompoundStmt>(S)) {
 142       if (CS->size() != 1)
 143         break;
 144       S = CS->body_back();
 145     } else
 146       break;
 147   }
 148   return S;
 149 }
 150
 151 /// Strip off all label-like statements.
 152 ///
 153 /// This will strip off label statements, case statements, attributed
 154 /// statements and default statements recursively.
 155 const Stmt *Stmt::stripLabelLikeStatements() const {
 156   const Stmt *S = this;
 157   while (true) {
 158     if (const auto *LS = dyn_cast<LabelStmt>(S))
 159       S = LS->getSubStmt();
 160     else if (const auto *SC = dyn_cast<SwitchCase>(S))
 161       S = SC->getSubStmt();
 162     else if (const auto *AS = dyn_cast<AttributedStmt>(S))
 163       S = AS->getSubStmt();
 164     else
 165       return S;
 166   }
 167 }
 168
 169 namespace {
 170
 171   struct good {};
 172   struct bad {};
 173
 174   // These silly little functions have to be static inline to suppress
 175   // unused warnings, and they have to be defined to suppress other
 176   // warnings.
 177   static good is_good(good) { return good(); }
 178
 179   typedef Stmt::child_range children_t();
 180   template <class T> good implements_children(children_t T::*) {
 181     return good();
 182   }
 183   LLVM_ATTRIBUTE_UNUSED
 184   static bad implements_children(children_t Stmt::*) {
 185     return bad();
 186   }
 187
 188   typedef SourceLocation getBeginLoc_t() const;
 189   template <class T> good implements_getBeginLoc(getBeginLoc_t T::*) {
 190     return good();
 191   }
 192   LLVM_ATTRIBUTE_UNUSED
 193   static bad implements_getBeginLoc(getBeginLoc_t Stmt::*) { return bad(); }
 194
 195   typedef SourceLocation getLocEnd_t() const;
 196   template <class T> good implements_getEndLoc(getLocEnd_t T::*) {
 197     return good();
 198   }
 199   LLVM_ATTRIBUTE_UNUSED
 200   static bad implements_getEndLoc(getLocEnd_t Stmt::*) { return bad(); }
 201
 202 #define ASSERT_IMPLEMENTS_children(type) \
 203   (void) is_good(implements_children(&type::children))
 204 #define ASSERT_IMPLEMENTS_getBeginLoc(type)                                    \
 205   (void)is_good(implements_getBeginLoc(&type::getBeginLoc))
 206 #define ASSERT_IMPLEMENTS_getEndLoc(type)                                      \
 207   (void)is_good(implements_getEndLoc(&type::getEndLoc))
 208
 209 } // namespace
 210
 211 /// Check whether the various Stmt classes implement their member
 212 /// functions.
 213 LLVM_ATTRIBUTE_UNUSED
 214 static inline void check_implementations() {
 215 #define ABSTRACT_STMT(type)
 216 #define STMT(type, base)                                                       \
 217   ASSERT_IMPLEMENTS_children(type);                                            \
 218   ASSERT_IMPLEMENTS_getBeginLoc(type);                                         \
 219   ASSERT_IMPLEMENTS_getEndLoc(type);
 220 #include "clang/AST/StmtNodes.inc"
 221 }
 222
 223 Stmt::child_range Stmt::children() {
 224   switch (getStmtClass()) {
 225   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
 226 #define ABSTRACT_STMT(type)
 227 #define STMT(type, base) \
 228   case Stmt::type##Class: \
 229     return static_cast<type*>(this)->children();
 230 #include "clang/AST/StmtNodes.inc"
 231   }
 232   llvm_unreachable("unknown statement kind!");
 233 }
 234
 235 // Amusing macro metaprogramming hack: check whether a class provides
 236 // a more specific implementation of getSourceRange.
 237 //
 238 // See also Expr.cpp:getExprLoc().
 239 namespace {
 240
 241   /// This implementation is used when a class provides a custom
 242   /// implementation of getSourceRange.
 243   template <class S, class T>
 244   SourceRange getSourceRangeImpl(const Stmt *stmt,
 245                                  SourceRange (T::*v)() const) {
 246     return static_cast<const S*>(stmt)->getSourceRange();
 247   }
 248
 249   /// This implementation is used when a class doesn't provide a custom
 250   /// implementation of getSourceRange.  Overload resolution should pick it over
 251   /// the implementation above because it's more specialized according to
 252   /// function template partial ordering.
 253   template <class S>
 254   SourceRange getSourceRangeImpl(const Stmt *stmt,
 255                                  SourceRange (Stmt::*v)() const) {
 256     return SourceRange(static_cast<const S *>(stmt)->getBeginLoc(),
 257                        static_cast<const S *>(stmt)->getEndLoc());
 258   }
 259
 260 } // namespace
 261
 262 SourceRange Stmt::getSourceRange() const {
 263   switch (getStmtClass()) {
 264   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
 265 #define ABSTRACT_STMT(type)
 266 #define STMT(type, base) \
 267   case Stmt::type##Class: \
 268     return getSourceRangeImpl<type>(this, &type::getSourceRange);
 269 #include "clang/AST/StmtNodes.inc"
 270   }
 271   llvm_unreachable("unknown statement kind!");
 272 }
 273
 274 SourceLocation Stmt::getBeginLoc() const {
 275   //  llvm::errs() << "getBeginLoc() for " << getStmtClassName() << "\n";
 276   switch (getStmtClass()) {
 277   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
 278 #define ABSTRACT_STMT(type)
 279 #define STMT(type, base)                                                       \
 280   case Stmt::type##Class:                                                      \
 281     return static_cast<const type *>(this)->getBeginLoc();
 282 #include "clang/AST/StmtNodes.inc"
 283   }
 284   llvm_unreachable("unknown statement kind");
 285 }
 286
 287 SourceLocation Stmt::getEndLoc() const {
 288   switch (getStmtClass()) {
 289   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
 290 #define ABSTRACT_STMT(type)
 291 #define STMT(type, base)                                                       \
 292   case Stmt::type##Class:                                                      \
 293     return static_cast<const type *>(this)->getEndLoc();
 294 #include "clang/AST/StmtNodes.inc"
 295   }
 296   llvm_unreachable("unknown statement kind");
 297 }
 298
 299 int64_t Stmt::getID(const ASTContext &Context) const {
 300   return Context.getAllocator().identifyKnownAlignedObject<Stmt>(this);
 301 }
 302
 303 CompoundStmt::CompoundStmt(ArrayRef<Stmt *> Stmts, SourceLocation LB,
 304                            SourceLocation RB)
 305     : Stmt(CompoundStmtClass), RBraceLoc(RB) {
 306   CompoundStmtBits.NumStmts = Stmts.size();
 307   setStmts(Stmts);
 308   CompoundStmtBits.LBraceLoc = LB;
 309 }
 310
 311 void CompoundStmt::setStmts(ArrayRef<Stmt *> Stmts) {
 312   assert(CompoundStmtBits.NumStmts == Stmts.size() &&
 313          "NumStmts doesn't fit in bits of CompoundStmtBits.NumStmts!");
 314
 315   std::copy(Stmts.begin(), Stmts.end(), body_begin());
 316 }
 317
 318 CompoundStmt *CompoundStmt::Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
 319                                    SourceLocation LB, SourceLocation RB) {
 320   void *Mem =
 321       C.Allocate(totalSizeToAlloc<Stmt *>(Stmts.size()), alignof(CompoundStmt));
 322   return new (Mem) CompoundStmt(Stmts, LB, RB);
 323 }
 324
 325 CompoundStmt *CompoundStmt::CreateEmpty(const ASTContext &C,
 326                                         unsigned NumStmts) {
 327   void *Mem =
 328       C.Allocate(totalSizeToAlloc<Stmt *>(NumStmts), alignof(CompoundStmt));
 329   CompoundStmt *New = new (Mem) CompoundStmt(EmptyShell());
 330   New->CompoundStmtBits.NumStmts = NumStmts;
 331   return New;
 332 }
 333
 334 const Expr *ValueStmt::getExprStmt() const {
 335   const Stmt *S = this;
 336   do {
 337     if (const auto *E = dyn_cast<Expr>(S))
 338       return E;
 339
 340     if (const auto *LS = dyn_cast<LabelStmt>(S))
 341       S = LS->getSubStmt();
 342     else if (const auto *AS = dyn_cast<AttributedStmt>(S))
 343       S = AS->getSubStmt();
 344     else
 345       llvm_unreachable("unknown kind of ValueStmt");
 346   } while (isa<ValueStmt>(S));
 347
 348   return nullptr;
 349 }
 350
 351 const char *LabelStmt::getName() const {
 352   return getDecl()->getIdentifier()->getNameStart();
 353 }
 354
 355 AttributedStmt *AttributedStmt::Create(const ASTContext &C, SourceLocation Loc,
 356                                        ArrayRef<const Attr*> Attrs,
 357                                        Stmt *SubStmt) {
 358   assert(!Attrs.empty() && "Attrs should not be empty");
 359   void *Mem = C.Allocate(totalSizeToAlloc<const Attr *>(Attrs.size()),
 360                          alignof(AttributedStmt));
 361   return new (Mem) AttributedStmt(Loc, Attrs, SubStmt);
 362 }
 363
 364 AttributedStmt *AttributedStmt::CreateEmpty(const ASTContext &C,
 365                                             unsigned NumAttrs) {
 366   assert(NumAttrs > 0 && "NumAttrs should be greater than zero");
 367   void *Mem = C.Allocate(totalSizeToAlloc<const Attr *>(NumAttrs),
 368                          alignof(AttributedStmt));
 369   return new (Mem) AttributedStmt(EmptyShell(), NumAttrs);
 370 }
 371
 372 std::string AsmStmt::generateAsmString(const ASTContext &C) const {
 373   if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
 374     return gccAsmStmt->generateAsmString(C);
 375   if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
 376     return msAsmStmt->generateAsmString(C);
 377   llvm_unreachable("unknown asm statement kind!");
 378 }
 379
 380 StringRef AsmStmt::getOutputConstraint(unsigned i) const {
 381   if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
 382     return gccAsmStmt->getOutputConstraint(i);
 383   if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
 384     return msAsmStmt->getOutputConstraint(i);
 385   llvm_unreachable("unknown asm statement kind!");
 386 }
 387
 388 const Expr *AsmStmt::getOutputExpr(unsigned i) const {
 389   if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
 390     return gccAsmStmt->getOutputExpr(i);
 391   if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
 392     return msAsmStmt->getOutputExpr(i);
 393   llvm_unreachable("unknown asm statement kind!");
 394 }
 395
 396 StringRef AsmStmt::getInputConstraint(unsigned i) const {
 397   if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
 398     return gccAsmStmt->getInputConstraint(i);
 399   if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
 400     return msAsmStmt->getInputConstraint(i);
 401   llvm_unreachable("unknown asm statement kind!");
 402 }
 403
 404 const Expr *AsmStmt::getInputExpr(unsigned i) const {
 405   if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
 406     return gccAsmStmt->getInputExpr(i);
 407   if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
 408     return msAsmStmt->getInputExpr(i);
 409   llvm_unreachable("unknown asm statement kind!");
 410 }
 411
 412 StringRef AsmStmt::getClobber(unsigned i) const {
 413   if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
 414     return gccAsmStmt->getClobber(i);
 415   if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
 416     return msAsmStmt->getClobber(i);
 417   llvm_unreachable("unknown asm statement kind!");
 418 }
 419
 420 /// getNumPlusOperands - Return the number of output operands that have a "+"
 421 /// constraint.
 422 unsigned AsmStmt::getNumPlusOperands() const {
 423   unsigned Res = 0;
 424   for (unsigned i = 0, e = getNumOutputs(); i != e; ++i)
 425     if (isOutputPlusConstraint(i))
 426       ++Res;
 427   return Res;
 428 }
 429
 430 char GCCAsmStmt::AsmStringPiece::getModifier() const {
 431   assert(isOperand() && "Only Operands can have modifiers.");
 432   return isLetter(Str[0]) ? Str[0] : '\0';
 433 }
 434
 435 StringRef GCCAsmStmt::getClobber(unsigned i) const {
 436   return getClobberStringLiteral(i)->getString();
 437 }
 438
 439 Expr *GCCAsmStmt::getOutputExpr(unsigned i) {
 440   return cast<Expr>(Exprs[i]);
 441 }
 442
 443 /// getOutputConstraint - Return the constraint string for the specified
 444 /// output operand.  All output constraints are known to be non-empty (either
 445 /// '=' or '+').
 446 StringRef GCCAsmStmt::getOutputConstraint(unsigned i) const {
 447   return getOutputConstraintLiteral(i)->getString();
 448 }
 449
 450 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
 451   return cast<Expr>(Exprs[i + NumOutputs]);
 452 }
 453
 454 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
 455   Exprs[i + NumOutputs] = E;
 456 }
 457
 458 AddrLabelExpr *GCCAsmStmt::getLabelExpr(unsigned i) const {
 459   return cast<AddrLabelExpr>(Exprs[i + NumInputs]);
 460 }
 461
 462 StringRef GCCAsmStmt::getLabelName(unsigned i) const {
 463   return getLabelExpr(i)->getLabel()->getName();
 464 }
 465
 466 /// getInputConstraint - Return the specified input constraint.  Unlike output
 467 /// constraints, these can be empty.
 468 StringRef GCCAsmStmt::getInputConstraint(unsigned i) const {
 469   return getInputConstraintLiteral(i)->getString();
 470 }
 471
 472 void GCCAsmStmt::setOutputsAndInputsAndClobbers(const ASTContext &C,
 473                                                 IdentifierInfo **Names,
 474                                                 StringLiteral **Constraints,
 475                                                 Stmt **Exprs,
 476                                                 unsigned NumOutputs,
 477                                                 unsigned NumInputs,
 478                                                 unsigned NumLabels,
 479                                                 StringLiteral **Clobbers,
 480                                                 unsigned NumClobbers) {
 481   this->NumOutputs = NumOutputs;
 482   this->NumInputs = NumInputs;
 483   this->NumClobbers = NumClobbers;
 484   this->NumLabels = NumLabels;
 485   assert(!(NumOutputs && NumLabels) && "asm goto cannot have outputs");
 486
 487   unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
 488
 489   C.Deallocate(this->Names);
 490   this->Names = new (C) IdentifierInfo*[NumExprs];
 491   std::copy(Names, Names + NumExprs, this->Names);
 492
 493   C.Deallocate(this->Exprs);
 494   this->Exprs = new (C) Stmt*[NumExprs];
 495   std::copy(Exprs, Exprs + NumExprs, this->Exprs);
 496
 497   unsigned NumConstraints = NumOutputs + NumInputs;
 498   C.Deallocate(this->Constraints);
 499   this->Constraints = new (C) StringLiteral*[NumConstraints];
 500   std::copy(Constraints, Constraints + NumConstraints, this->Constraints);
 501
 502   C.Deallocate(this->Clobbers);
 503   this->Clobbers = new (C) StringLiteral*[NumClobbers];
 504   std::copy(Clobbers, Clobbers + NumClobbers, this->Clobbers);
 505 }
 506
 507 /// getNamedOperand - Given a symbolic operand reference like %[foo],
 508 /// translate this into a numeric value needed to reference the same operand.
 509 /// This returns -1 if the operand name is invalid.
 510 int GCCAsmStmt::getNamedOperand(StringRef SymbolicName) const {
 511   unsigned NumPlusOperands = 0;
 512
 513   // Check if this is an output operand.
 514   for (unsigned i = 0, e = getNumOutputs(); i != e; ++i) {
 515     if (getOutputName(i) == SymbolicName)
 516       return i;
 517   }
 518
 519   for (unsigned i = 0, e = getNumInputs(); i != e; ++i)
 520     if (getInputName(i) == SymbolicName)
 521       return getNumOutputs() + NumPlusOperands + i;
 522
 523   for (unsigned i = 0, e = getNumLabels(); i != e; ++i)
 524     if (getLabelName(i) == SymbolicName)
 525       return i + getNumInputs();
 526
 527   // Not found.
 528   return -1;
 529 }
 530
 531 /// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing
 532 /// it into pieces.  If the asm string is erroneous, emit errors and return
 533 /// true, otherwise return false.
 534 unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece>&Pieces,
 535                                 const ASTContext &C, unsigned &DiagOffs) const {
 536   StringRef Str = getAsmString()->getString();
 537   const char *StrStart = Str.begin();
 538   const char *StrEnd = Str.end();
 539   const char *CurPtr = StrStart;
 540
 541   // "Simple" inline asms have no constraints or operands, just convert the asm
 542   // string to escape $'s.
 543   if (isSimple()) {
 544     std::string Result;
 545     for (; CurPtr != StrEnd; ++CurPtr) {
 546       switch (*CurPtr) {
 547       case '$':
 548         Result += "$$";
 549         break;
 550       default:
 551         Result += *CurPtr;
 552         break;
 553       }
 554     }
 555     Pieces.push_back(AsmStringPiece(Result));
 556     return 0;
 557   }
 558
 559   // CurStringPiece - The current string that we are building up as we scan the
 560   // asm string.
 561   std::string CurStringPiece;
 562
 563   bool HasVariants = !C.getTargetInfo().hasNoAsmVariants();
 564
 565   unsigned LastAsmStringToken = 0;
 566   unsigned LastAsmStringOffset = 0;
 567
 568   while (true) {
 569     // Done with the string?
 570     if (CurPtr == StrEnd) {
 571       if (!CurStringPiece.empty())
 572         Pieces.push_back(AsmStringPiece(CurStringPiece));
 573       return 0;
 574     }
 575
 576     char CurChar = *CurPtr++;
 577     switch (CurChar) {
 578     case '$': CurStringPiece += "$$"; continue;
 579     case '{': CurStringPiece += (HasVariants ? "$(" : "{"); continue;
 580     case '|': CurStringPiece += (HasVariants ? "$|" : "|"); continue;
 581     case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue;
 582     case '%':
 583       break;
 584     default:
 585       CurStringPiece += CurChar;
 586       continue;
 587     }
 588
 589     // Escaped "%" character in asm string.
 590     if (CurPtr == StrEnd) {
 591       // % at end of string is invalid (no escape).
 592       DiagOffs = CurPtr-StrStart-1;
 593       return diag::err_asm_invalid_escape;
 594     }
 595     // Handle escaped char and continue looping over the asm string.
 596     char EscapedChar = *CurPtr++;
 597     switch (EscapedChar) {
 598     default:
 599       break;
 600     case '%': // %% -> %
 601     case '{': // %{ -> {
 602     case '}': // %} -> }
 603       CurStringPiece += EscapedChar;
 604       continue;
 605     case '=': // %= -> Generate a unique ID.
 606       CurStringPiece += "${:uid}";
 607       continue;
 608     }
 609
 610     // Otherwise, we have an operand.  If we have accumulated a string so far,
 611     // add it to the Pieces list.
 612     if (!CurStringPiece.empty()) {
 613       Pieces.push_back(AsmStringPiece(CurStringPiece));
 614       CurStringPiece.clear();
 615     }
 616
 617     // Handle operands that have asmSymbolicName (e.g., %x[foo]) and those that
 618     // don't (e.g., %x4). 'x' following the '%' is the constraint modifier.
 619
 620     const char *Begin = CurPtr - 1; // Points to the character following '%'.
 621     const char *Percent = Begin - 1; // Points to '%'.
 622
 623     if (isLetter(EscapedChar)) {
 624       if (CurPtr == StrEnd) { // Premature end.
 625         DiagOffs = CurPtr-StrStart-1;
 626         return diag::err_asm_invalid_escape;
 627       }
 628       EscapedChar = *CurPtr++;
 629     }
 630
 631     const TargetInfo &TI = C.getTargetInfo();
 632     const SourceManager &SM = C.getSourceManager();
 633     const LangOptions &LO = C.getLangOpts();
 634
 635     // Handle operands that don't have asmSymbolicName (e.g., %x4).
 636     if (isDigit(EscapedChar)) {
 637       // %n - Assembler operand n
 638       unsigned N = 0;
 639
 640       --CurPtr;
 641       while (CurPtr != StrEnd && isDigit(*CurPtr))
 642         N = N*10 + ((*CurPtr++)-'0');
 643
 644       unsigned NumOperands = getNumOutputs() + getNumPlusOperands() +
 645                              getNumInputs() + getNumLabels();
 646       if (N >= NumOperands) {
 647         DiagOffs = CurPtr-StrStart-1;
 648         return diag::err_asm_invalid_operand_number;
 649       }
 650
 651       // Str contains "x4" (Operand without the leading %).
 652       std::string Str(Begin, CurPtr - Begin);
 653
 654       // (BeginLoc, EndLoc) represents the range of the operand we are currently
 655       // processing. Unlike Str, the range includes the leading '%'.
 656       SourceLocation BeginLoc = getAsmString()->getLocationOfByte(
 657           Percent - StrStart, SM, LO, TI, &LastAsmStringToken,
 658           &LastAsmStringOffset);
 659       SourceLocation EndLoc = getAsmString()->getLocationOfByte(
 660           CurPtr - StrStart, SM, LO, TI, &LastAsmStringToken,
 661           &LastAsmStringOffset);
 662
 663       Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc);
 664       continue;
 665     }
 666
 667     // Handle operands that have asmSymbolicName (e.g., %x[foo]).
 668     if (EscapedChar == '[') {
 669       DiagOffs = CurPtr-StrStart-1;
 670
 671       // Find the ']'.
 672       const char *NameEnd = (const char*)memchr(CurPtr, ']', StrEnd-CurPtr);
 673       if (NameEnd == nullptr)
 674         return diag::err_asm_unterminated_symbolic_operand_name;
 675       if (NameEnd == CurPtr)
 676         return diag::err_asm_empty_symbolic_operand_name;
 677
 678       StringRef SymbolicName(CurPtr, NameEnd - CurPtr);
 679
 680       int N = getNamedOperand(SymbolicName);
 681       if (N == -1) {
 682         // Verify that an operand with that name exists.
 683         DiagOffs = CurPtr-StrStart;
 684         return diag::err_asm_unknown_symbolic_operand_name;
 685       }
 686
 687       // Str contains "x[foo]" (Operand without the leading %).
 688       std::string Str(Begin, NameEnd + 1 - Begin);
 689
 690       // (BeginLoc, EndLoc) represents the range of the operand we are currently
 691       // processing. Unlike Str, the range includes the leading '%'.
 692       SourceLocation BeginLoc = getAsmString()->getLocationOfByte(
 693           Percent - StrStart, SM, LO, TI, &LastAsmStringToken,
 694           &LastAsmStringOffset);
 695       SourceLocation EndLoc = getAsmString()->getLocationOfByte(
 696           NameEnd + 1 - StrStart, SM, LO, TI, &LastAsmStringToken,
 697           &LastAsmStringOffset);
 698
 699       Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc);
 700
 701       CurPtr = NameEnd+1;
 702       continue;
 703     }
 704
 705     DiagOffs = CurPtr-StrStart-1;
 706     return diag::err_asm_invalid_escape;
 707   }
 708 }
 709
 710 /// Assemble final IR asm string (GCC-style).
 711 std::string GCCAsmStmt::generateAsmString(const ASTContext &C) const {
 712   // Analyze the asm string to decompose it into its pieces.  We know that Sema
 713   // has already done this, so it is guaranteed to be successful.
 714   SmallVector<GCCAsmStmt::AsmStringPiece, 4> Pieces;
 715   unsigned DiagOffs;
 716   AnalyzeAsmString(Pieces, C, DiagOffs);
 717
 718   std::string AsmString;
 719   for (const auto &Piece : Pieces) {
 720     if (Piece.isString())
 721       AsmString += Piece.getString();
 722     else if (Piece.getModifier() == '\0')
 723       AsmString += '$' + llvm::utostr(Piece.getOperandNo());
 724     else
 725       AsmString += "${" + llvm::utostr(Piece.getOperandNo()) + ':' +
 726                    Piece.getModifier() + '}';
 727   }
 728   return AsmString;
 729 }
 730
 731 /// Assemble final IR asm string (MS-style).
 732 std::string MSAsmStmt::generateAsmString(const ASTContext &C) const {
 733   // FIXME: This needs to be translated into the IR string representation.
 734   return AsmStr;
 735 }
 736
 737 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
 738   return cast<Expr>(Exprs[i]);
 739 }
 740
 741 Expr *MSAsmStmt::getInputExpr(unsigned i) {
 742   return cast<Expr>(Exprs[i + NumOutputs]);
 743 }
 744
 745 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
 746   Exprs[i + NumOutputs] = E;
 747 }
 748
 749 //===----------------------------------------------------------------------===//
 750 // Constructors
 751 //===----------------------------------------------------------------------===//
 752
 753 GCCAsmStmt::GCCAsmStmt(const ASTContext &C, SourceLocation asmloc,
 754                        bool issimple, bool isvolatile, unsigned numoutputs,
 755                        unsigned numinputs, IdentifierInfo **names,
 756                        StringLiteral **constraints, Expr **exprs,
 757                        StringLiteral *asmstr, unsigned numclobbers,
 758                        StringLiteral **clobbers, unsigned numlabels,
 759                        SourceLocation rparenloc)
 760     : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
 761               numinputs, numclobbers),
 762               RParenLoc(rparenloc), AsmStr(asmstr), NumLabels(numlabels) {
 763   unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
 764
 765   Names = new (C) IdentifierInfo*[NumExprs];
 766   std::copy(names, names + NumExprs, Names);
 767
 768   Exprs = new (C) Stmt*[NumExprs];
 769   std::copy(exprs, exprs + NumExprs, Exprs);
 770
 771   unsigned NumConstraints = NumOutputs + NumInputs;
 772   Constraints = new (C) StringLiteral*[NumConstraints];
 773   std::copy(constraints, constraints + NumConstraints, Constraints);
 774
 775   Clobbers = new (C) StringLiteral*[NumClobbers];
 776   std::copy(clobbers, clobbers + NumClobbers, Clobbers);
 777 }
 778
 779 MSAsmStmt::MSAsmStmt(const ASTContext &C, SourceLocation asmloc,
 780                      SourceLocation lbraceloc, bool issimple, bool isvolatile,
 781                      ArrayRef<Token> asmtoks, unsigned numoutputs,
 782                      unsigned numinputs,
 783                      ArrayRef<StringRef> constraints, ArrayRef<Expr*> exprs,
 784                      StringRef asmstr, ArrayRef<StringRef> clobbers,
 785                      SourceLocation endloc)
 786     : AsmStmt(MSAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
 787               numinputs, clobbers.size()), LBraceLoc(lbraceloc),
 788               EndLoc(endloc), NumAsmToks(asmtoks.size()) {
 789   initialize(C, asmstr, asmtoks, constraints, exprs, clobbers);
 790 }
 791
 792 static StringRef copyIntoContext(const ASTContext &C, StringRef str) {
 793   return str.copy(C);
 794 }
 795
 796 void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr,
 797                            ArrayRef<Token> asmtoks,
 798                            ArrayRef<StringRef> constraints,
 799                            ArrayRef<Expr*> exprs,
 800                            ArrayRef<StringRef> clobbers) {
 801   assert(NumAsmToks == asmtoks.size());
 802   assert(NumClobbers == clobbers.size());
 803
 804   assert(exprs.size() == NumOutputs + NumInputs);
 805   assert(exprs.size() == constraints.size());
 806
 807   AsmStr = copyIntoContext(C, asmstr);
 808
 809   Exprs = new (C) Stmt*[exprs.size()];
 810   std::copy(exprs.begin(), exprs.end(), Exprs);
 811
 812   AsmToks = new (C) Token[asmtoks.size()];
 813   std::copy(asmtoks.begin(), asmtoks.end(), AsmToks);
 814
 815   Constraints = new (C) StringRef[exprs.size()];
 816   std::transform(constraints.begin(), constraints.end(), Constraints,
 817                  [&](StringRef Constraint) {
 818                    return copyIntoContext(C, Constraint);
 819                  });
 820
 821   Clobbers = new (C) StringRef[NumClobbers];
 822   // FIXME: Avoid the allocation/copy if at all possible.
 823   std::transform(clobbers.begin(), clobbers.end(), Clobbers,
 824                  [&](StringRef Clobber) {
 825                    return copyIntoContext(C, Clobber);
 826                  });
 827 }
 828
 829 IfStmt::IfStmt(const ASTContext &Ctx, SourceLocation IL, bool IsConstexpr,
 830                Stmt *Init, VarDecl *Var, Expr *Cond, Stmt *Then,
 831                SourceLocation EL, Stmt *Else)
 832     : Stmt(IfStmtClass) {
 833   bool HasElse = Else != nullptr;
 834   bool HasVar = Var != nullptr;
 835   bool HasInit = Init != nullptr;
 836   IfStmtBits.HasElse = HasElse;
 837   IfStmtBits.HasVar = HasVar;
 838   IfStmtBits.HasInit = HasInit;
 839
 840   setConstexpr(IsConstexpr);
 841
 842   setCond(Cond);
 843   setThen(Then);
 844   if (HasElse)
 845     setElse(Else);
 846   if (HasVar)
 847     setConditionVariable(Ctx, Var);
 848   if (HasInit)
 849     setInit(Init);
 850
 851   setIfLoc(IL);
 852   if (HasElse)
 853     setElseLoc(EL);
 854 }
 855
 856 IfStmt::IfStmt(EmptyShell Empty, bool HasElse, bool HasVar, bool HasInit)
 857     : Stmt(IfStmtClass, Empty) {
 858   IfStmtBits.HasElse = HasElse;
 859   IfStmtBits.HasVar = HasVar;
 860   IfStmtBits.HasInit = HasInit;
 861 }
 862
 863 IfStmt *IfStmt::Create(const ASTContext &Ctx, SourceLocation IL,
 864                        bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
 865                        Stmt *Then, SourceLocation EL, Stmt *Else) {
 866   bool HasElse = Else != nullptr;
 867   bool HasVar = Var != nullptr;
 868   bool HasInit = Init != nullptr;
 869   void *Mem = Ctx.Allocate(
 870       totalSizeToAlloc<Stmt *, SourceLocation>(
 871           NumMandatoryStmtPtr + HasElse + HasVar + HasInit, HasElse),
 872       alignof(IfStmt));
 873   return new (Mem)
 874       IfStmt(Ctx, IL, IsConstexpr, Init, Var, Cond, Then, EL, Else);
 875 }
 876
 877 IfStmt *IfStmt::CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar,
 878                             bool HasInit) {
 879   void *Mem = Ctx.Allocate(
 880       totalSizeToAlloc<Stmt *, SourceLocation>(
 881           NumMandatoryStmtPtr + HasElse + HasVar + HasInit, HasElse),
 882       alignof(IfStmt));
 883   return new (Mem) IfStmt(EmptyShell(), HasElse, HasVar, HasInit);
 884 }
 885
 886 VarDecl *IfStmt::getConditionVariable() {
 887   auto *DS = getConditionVariableDeclStmt();
 888   if (!DS)
 889     return nullptr;
 890   return cast<VarDecl>(DS->getSingleDecl());
 891 }
 892
 893 void IfStmt::setConditionVariable(const ASTContext &Ctx, VarDecl *V) {
 894   assert(hasVarStorage() &&
 895          "This if statement has no storage for a condition variable!");
 896
 897   if (!V) {
 898     getTrailingObjects<Stmt *>()[varOffset()] = nullptr;
 899     return;
 900   }
 901
 902   SourceRange VarRange = V->getSourceRange();
 903   getTrailingObjects<Stmt *>()[varOffset()] = new (Ctx)
 904       DeclStmt(DeclGroupRef(V), VarRange.getBegin(), VarRange.getEnd());
 905 }
 906
 907 bool IfStmt::isObjCAvailabilityCheck() const {
 908   return isa<ObjCAvailabilityCheckExpr>(getCond());
 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), 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   ForStmtBits.ForLoc = FL;
 922 }
 923
 924 VarDecl *ForStmt::getConditionVariable() const {
 925   if (!SubExprs[CONDVAR])
 926     return nullptr;
 927
 928   auto *DS = cast<DeclStmt>(SubExprs[CONDVAR]);
 929   return cast<VarDecl>(DS->getSingleDecl());
 930 }
 931
 932 void ForStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
 933   if (!V) {
 934     SubExprs[CONDVAR] = nullptr;
 935     return;
 936   }
 937
 938   SourceRange VarRange = V->getSourceRange();
 939   SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
 940                                        VarRange.getEnd());
 941 }
 942
 943 SwitchStmt::SwitchStmt(const ASTContext &Ctx, Stmt *Init, VarDecl *Var,
 944                        Expr *Cond)
 945     : Stmt(SwitchStmtClass), FirstCase(nullptr) {
 946   bool HasInit = Init != nullptr;
 947   bool HasVar = Var != nullptr;
 948   SwitchStmtBits.HasInit = HasInit;
 949   SwitchStmtBits.HasVar = HasVar;
 950   SwitchStmtBits.AllEnumCasesCovered = false;
 951
 952   setCond(Cond);
 953   setBody(nullptr);
 954   if (HasInit)
 955     setInit(Init);
 956   if (HasVar)
 957     setConditionVariable(Ctx, Var);
 958
 959   setSwitchLoc(SourceLocation{});
 960 }
 961
 962 SwitchStmt::SwitchStmt(EmptyShell Empty, bool HasInit, bool HasVar)
 963     : Stmt(SwitchStmtClass, Empty) {
 964   SwitchStmtBits.HasInit = HasInit;
 965   SwitchStmtBits.HasVar = HasVar;
 966   SwitchStmtBits.AllEnumCasesCovered = false;
 967 }
 968
 969 SwitchStmt *SwitchStmt::Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var,
 970                                Expr *Cond) {
 971   bool HasInit = Init != nullptr;
 972   bool HasVar = Var != nullptr;
 973   void *Mem = Ctx.Allocate(
 974       totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasInit + HasVar),
 975       alignof(SwitchStmt));
 976   return new (Mem) SwitchStmt(Ctx, Init, Var, Cond);
 977 }
 978
 979 SwitchStmt *SwitchStmt::CreateEmpty(const ASTContext &Ctx, bool HasInit,
 980                                     bool HasVar) {
 981   void *Mem = Ctx.Allocate(
 982       totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasInit + HasVar),
 983       alignof(SwitchStmt));
 984   return new (Mem) SwitchStmt(EmptyShell(), HasInit, HasVar);
 985 }
 986
 987 VarDecl *SwitchStmt::getConditionVariable() {
 988   auto *DS = getConditionVariableDeclStmt();
 989   if (!DS)
 990     return nullptr;
 991   return cast<VarDecl>(DS->getSingleDecl());
 992 }
 993
 994 void SwitchStmt::setConditionVariable(const ASTContext &Ctx, VarDecl *V) {
 995   assert(hasVarStorage() &&
 996          "This switch statement has no storage for a condition variable!");
 997
 998   if (!V) {
 999     getTrailingObjects<Stmt *>()[varOffset()] = nullptr;
1000     return;
1001   }
1002
1003   SourceRange VarRange = V->getSourceRange();
1004   getTrailingObjects<Stmt *>()[varOffset()] = new (Ctx)
1005       DeclStmt(DeclGroupRef(V), VarRange.getBegin(), VarRange.getEnd());
1006 }
1007
1008 WhileStmt::WhileStmt(const ASTContext &Ctx, VarDecl *Var, Expr *Cond,
1009                      Stmt *Body, SourceLocation WL)
1010     : Stmt(WhileStmtClass) {
1011   bool HasVar = Var != nullptr;
1012   WhileStmtBits.HasVar = HasVar;
1013
1014   setCond(Cond);
1015   setBody(Body);
1016   if (HasVar)
1017     setConditionVariable(Ctx, Var);
1018
1019   setWhileLoc(WL);
1020 }
1021
1022 WhileStmt::WhileStmt(EmptyShell Empty, bool HasVar)
1023     : Stmt(WhileStmtClass, Empty) {
1024   WhileStmtBits.HasVar = HasVar;
1025 }
1026
1027 WhileStmt *WhileStmt::Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond,
1028                              Stmt *Body, SourceLocation WL) {
1029   bool HasVar = Var != nullptr;
1030   void *Mem =
1031       Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasVar),
1032                    alignof(WhileStmt));
1033   return new (Mem) WhileStmt(Ctx, Var, Cond, Body, WL);
1034 }
1035
1036 WhileStmt *WhileStmt::CreateEmpty(const ASTContext &Ctx, bool HasVar) {
1037   void *Mem =
1038       Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasVar),
1039                    alignof(WhileStmt));
1040   return new (Mem) WhileStmt(EmptyShell(), HasVar);
1041 }
1042
1043 VarDecl *WhileStmt::getConditionVariable() {
1044   auto *DS = getConditionVariableDeclStmt();
1045   if (!DS)
1046     return nullptr;
1047   return cast<VarDecl>(DS->getSingleDecl());
1048 }
1049
1050 void WhileStmt::setConditionVariable(const ASTContext &Ctx, VarDecl *V) {
1051   assert(hasVarStorage() &&
1052          "This while statement has no storage for a condition variable!");
1053
1054   if (!V) {
1055     getTrailingObjects<Stmt *>()[varOffset()] = nullptr;
1056     return;
1057   }
1058
1059   SourceRange VarRange = V->getSourceRange();
1060   getTrailingObjects<Stmt *>()[varOffset()] = new (Ctx)
1061       DeclStmt(DeclGroupRef(V), VarRange.getBegin(), VarRange.getEnd());
1062 }
1063
1064 // IndirectGotoStmt
1065 LabelDecl *IndirectGotoStmt::getConstantTarget() {
1066   if (auto *E = dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
1067     return E->getLabel();
1068   return nullptr;
1069 }
1070
1071 // ReturnStmt
1072 ReturnStmt::ReturnStmt(SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
1073     : Stmt(ReturnStmtClass), RetExpr(E) {
1074   bool HasNRVOCandidate = NRVOCandidate != nullptr;
1075   ReturnStmtBits.HasNRVOCandidate = HasNRVOCandidate;
1076   if (HasNRVOCandidate)
1077     setNRVOCandidate(NRVOCandidate);
1078   setReturnLoc(RL);
1079 }
1080
1081 ReturnStmt::ReturnStmt(EmptyShell Empty, bool HasNRVOCandidate)
1082     : Stmt(ReturnStmtClass, Empty) {
1083   ReturnStmtBits.HasNRVOCandidate = HasNRVOCandidate;
1084 }
1085
1086 ReturnStmt *ReturnStmt::Create(const ASTContext &Ctx, SourceLocation RL,
1087                                Expr *E, const VarDecl *NRVOCandidate) {
1088   bool HasNRVOCandidate = NRVOCandidate != nullptr;
1089   void *Mem = Ctx.Allocate(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),
1090                            alignof(ReturnStmt));
1091   return new (Mem) ReturnStmt(RL, E, NRVOCandidate);
1092 }
1093
1094 ReturnStmt *ReturnStmt::CreateEmpty(const ASTContext &Ctx,
1095                                     bool HasNRVOCandidate) {
1096   void *Mem = Ctx.Allocate(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),
1097                            alignof(ReturnStmt));
1098   return new (Mem) ReturnStmt(EmptyShell(), HasNRVOCandidate);
1099 }
1100
1101 // CaseStmt
1102 CaseStmt *CaseStmt::Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
1103                            SourceLocation caseLoc, SourceLocation ellipsisLoc,
1104                            SourceLocation colonLoc) {
1105   bool CaseStmtIsGNURange = rhs != nullptr;
1106   void *Mem = Ctx.Allocate(
1107       totalSizeToAlloc<Stmt *, SourceLocation>(
1108           NumMandatoryStmtPtr + CaseStmtIsGNURange, CaseStmtIsGNURange),
1109       alignof(CaseStmt));
1110   return new (Mem) CaseStmt(lhs, rhs, caseLoc, ellipsisLoc, colonLoc);
1111 }
1112
1113 CaseStmt *CaseStmt::CreateEmpty(const ASTContext &Ctx,
1114                                 bool CaseStmtIsGNURange) {
1115   void *Mem = Ctx.Allocate(
1116       totalSizeToAlloc<Stmt *, SourceLocation>(
1117           NumMandatoryStmtPtr + CaseStmtIsGNURange, CaseStmtIsGNURange),
1118       alignof(CaseStmt));
1119   return new (Mem) CaseStmt(EmptyShell(), CaseStmtIsGNURange);
1120 }
1121
1122 SEHTryStmt::SEHTryStmt(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock,
1123                        Stmt *Handler)
1124     : Stmt(SEHTryStmtClass), IsCXXTry(IsCXXTry), TryLoc(TryLoc) {
1125   Children[TRY]     = TryBlock;
1126   Children[HANDLER] = Handler;
1127 }
1128
1129 SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry,
1130                                SourceLocation TryLoc, Stmt *TryBlock,
1131                                Stmt *Handler) {
1132   return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
1133 }
1134
1135 SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
1136   return dyn_cast<SEHExceptStmt>(getHandler());
1137 }
1138
1139 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
1140   return dyn_cast<SEHFinallyStmt>(getHandler());
1141 }
1142
1143 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
1144     : Stmt(SEHExceptStmtClass), Loc(Loc) {
1145   Children[FILTER_EXPR] = FilterExpr;
1146   Children[BLOCK]       = Block;
1147 }
1148
1149 SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc,
1150                                      Expr *FilterExpr, Stmt *Block) {
1151   return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
1152 }
1153
1154 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc, Stmt *Block)
1155     : Stmt(SEHFinallyStmtClass), Loc(Loc), Block(Block) {}
1156
1157 SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc,
1158                                        Stmt *Block) {
1159   return new(C)SEHFinallyStmt(Loc,Block);
1160 }
1161
1162 CapturedStmt::Capture::Capture(SourceLocation Loc, VariableCaptureKind Kind,
1163                                VarDecl *Var)
1164     : VarAndKind(Var, Kind), Loc(Loc) {
1165   switch (Kind) {
1166   case VCK_This:
1167     assert(!Var && "'this' capture cannot have a variable!");
1168     break;
1169   case VCK_ByRef:
1170     assert(Var && "capturing by reference must have a variable!");
1171     break;
1172   case VCK_ByCopy:
1173     assert(Var && "capturing by copy must have a variable!");
1174     assert(
1175         (Var->getType()->isScalarType() || (Var->getType()->isReferenceType() &&
1176                                             Var->getType()
1177                                                 ->castAs<ReferenceType>()
1178                                                 ->getPointeeType()
1179                                                 ->isScalarType())) &&
1180         "captures by copy are expected to have a scalar type!");
1181     break;
1182   case VCK_VLAType:
1183     assert(!Var &&
1184            "Variable-length array type capture cannot have a variable!");
1185     break;
1186   }
1187 }
1188
1189 CapturedStmt::VariableCaptureKind
1190 CapturedStmt::Capture::getCaptureKind() const {
1191   return VarAndKind.getInt();
1192 }
1193
1194 VarDecl *CapturedStmt::Capture::getCapturedVar() const {
1195   assert((capturesVariable() || capturesVariableByCopy()) &&
1196          "No variable available for 'this' or VAT capture");
1197   return VarAndKind.getPointer();
1198 }
1199
1200 CapturedStmt::Capture *CapturedStmt::getStoredCaptures() const {
1201   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1202
1203   // Offset of the first Capture object.
1204   unsigned FirstCaptureOffset = llvm::alignTo(Size, alignof(Capture));
1205
1206   return reinterpret_cast<Capture *>(
1207       reinterpret_cast<char *>(const_cast<CapturedStmt *>(this))
1208       + FirstCaptureOffset);
1209 }
1210
1211 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
1212                            ArrayRef<Capture> Captures,
1213                            ArrayRef<Expr *> CaptureInits,
1214                            CapturedDecl *CD,
1215                            RecordDecl *RD)
1216   : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
1217     CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
1218   assert( S && "null captured statement");
1219   assert(CD && "null captured declaration for captured statement");
1220   assert(RD && "null record declaration for captured statement");
1221
1222   // Copy initialization expressions.
1223   Stmt **Stored = getStoredStmts();
1224   for (unsigned I = 0, N = NumCaptures; I != N; ++I)
1225     *Stored++ = CaptureInits[I];
1226
1227   // Copy the statement being captured.
1228   *Stored = S;
1229
1230   // Copy all Capture objects.
1231   Capture *Buffer = getStoredCaptures();
1232   std::copy(Captures.begin(), Captures.end(), Buffer);
1233 }
1234
1235 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures)
1236   : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures),
1237     CapDeclAndKind(nullptr, CR_Default) {
1238   getStoredStmts()[NumCaptures] = nullptr;
1239 }
1240
1241 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S,
1242                                    CapturedRegionKind Kind,
1243                                    ArrayRef<Capture> Captures,
1244                                    ArrayRef<Expr *> CaptureInits,
1245                                    CapturedDecl *CD,
1246                                    RecordDecl *RD) {
1247   // The layout is
1248   //
1249   // -----------------------------------------------------------
1250   // | CapturedStmt, Init, ..., Init, S, Capture, ..., Capture |
1251   // ----------------^-------------------^----------------------
1252   //                 getStoredStmts()    getStoredCaptures()
1253   //
1254   // where S is the statement being captured.
1255   //
1256   assert(CaptureInits.size() == Captures.size() && "wrong number of arguments");
1257
1258   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1);
1259   if (!Captures.empty()) {
1260     // Realign for the following Capture array.
1261     Size = llvm::alignTo(Size, alignof(Capture));
1262     Size += sizeof(Capture) * Captures.size();
1263   }
1264
1265   void *Mem = Context.Allocate(Size);
1266   return new (Mem) CapturedStmt(S, Kind, Captures, CaptureInits, CD, RD);
1267 }
1268
1269 CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context,
1270                                                unsigned NumCaptures) {
1271   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1272   if (NumCaptures > 0) {
1273     // Realign for the following Capture array.
1274     Size = llvm::alignTo(Size, alignof(Capture));
1275     Size += sizeof(Capture) * NumCaptures;
1276   }
1277
1278   void *Mem = Context.Allocate(Size);
1279   return new (Mem) CapturedStmt(EmptyShell(), NumCaptures);
1280 }
1281
1282 Stmt::child_range CapturedStmt::children() {
1283   // Children are captured field initializers.
1284   return child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
1285 }
1286
1287 Stmt::const_child_range CapturedStmt::children() const {
1288   return const_child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
1289 }
1290
1291 CapturedDecl *CapturedStmt::getCapturedDecl() {
1292   return CapDeclAndKind.getPointer();
1293 }
1294
1295 const CapturedDecl *CapturedStmt::getCapturedDecl() const {
1296   return CapDeclAndKind.getPointer();
1297 }
1298
1299 /// Set the outlined function declaration.
1300 void CapturedStmt::setCapturedDecl(CapturedDecl *D) {
1301   assert(D && "null CapturedDecl");
1302   CapDeclAndKind.setPointer(D);
1303 }
1304
1305 /// Retrieve the captured region kind.
1306 CapturedRegionKind CapturedStmt::getCapturedRegionKind() const {
1307   return CapDeclAndKind.getInt();
1308 }
1309
1310 /// Set the captured region kind.
1311 void CapturedStmt::setCapturedRegionKind(CapturedRegionKind Kind) {
1312   CapDeclAndKind.setInt(Kind);
1313 }
1314
1315 bool CapturedStmt::capturesVariable(const VarDecl *Var) const {
1316   for (const auto &I : captures()) {
1317     if (!I.capturesVariable() && !I.capturesVariableByCopy())
1318       continue;
1319     if (I.getCapturedVar()->getCanonicalDecl() == Var->getCanonicalDecl())
1320       return true;
1321   }
1322
1323   return false;
1324 }