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), AllEnumCasesCovered(0) 944 { 945 setConditionVariable(C, Var); 946 SubExprs[COND] = cond; 947 SubExprs[BODY] = nullptr; 948 } 949 950 VarDecl *SwitchStmt::getConditionVariable() const { 951 if (!SubExprs[VAR]) 952 return nullptr; 953 954 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]); 955 return cast<VarDecl>(DS->getSingleDecl()); 956 } 957 958 void SwitchStmt::setConditionVariable(const ASTContext &C, VarDecl *V) { 959 if (!V) { 960 SubExprs[VAR] = nullptr; 961 return; 962 } 963 964 SourceRange VarRange = V->getSourceRange(); 965 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), 966 VarRange.getEnd()); 967 } 968 969 Stmt *SwitchCase::getSubStmt() { 970 if (isa<CaseStmt>(this)) 971 return cast<CaseStmt>(this)->getSubStmt(); 972 return cast<DefaultStmt>(this)->getSubStmt(); 973 } 974 975 WhileStmt::WhileStmt(const ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body, 976 SourceLocation WL) 977 : Stmt(WhileStmtClass) { 978 setConditionVariable(C, Var); 979 SubExprs[COND] = cond; 980 SubExprs[BODY] = body; 981 WhileLoc = WL; 982 } 983 984 VarDecl *WhileStmt::getConditionVariable() const { 985 if (!SubExprs[VAR]) 986 return nullptr; 987 988 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]); 989 return cast<VarDecl>(DS->getSingleDecl()); 990 } 991 992 void WhileStmt::setConditionVariable(const ASTContext &C, VarDecl *V) { 993 if (!V) { 994 SubExprs[VAR] = nullptr; 995 return; 996 } 997 998 SourceRange VarRange = V->getSourceRange(); 999 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), 1000 VarRange.getEnd()); 1001 } 1002 1003 // IndirectGotoStmt 1004 LabelDecl *IndirectGotoStmt::getConstantTarget() { 1005 if (AddrLabelExpr *E = 1006 dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts())) 1007 return E->getLabel(); 1008 return nullptr; 1009 } 1010 1011 // ReturnStmt 1012 const Expr* ReturnStmt::getRetValue() const { 1013 return cast_or_null<Expr>(RetExpr); 1014 } 1015 Expr* ReturnStmt::getRetValue() { 1016 return cast_or_null<Expr>(RetExpr); 1017 } 1018 1019 SEHTryStmt::SEHTryStmt(bool IsCXXTry, 1020 SourceLocation TryLoc, 1021 Stmt *TryBlock, 1022 Stmt *Handler) 1023 : Stmt(SEHTryStmtClass), 1024 IsCXXTry(IsCXXTry), 1025 TryLoc(TryLoc) 1026 { 1027 Children[TRY] = TryBlock; 1028 Children[HANDLER] = Handler; 1029 } 1030 1031 SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry, 1032 SourceLocation TryLoc, Stmt *TryBlock, 1033 Stmt *Handler) { 1034 return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler); 1035 } 1036 1037 SEHExceptStmt* SEHTryStmt::getExceptHandler() const { 1038 return dyn_cast<SEHExceptStmt>(getHandler()); 1039 } 1040 1041 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const { 1042 return dyn_cast<SEHFinallyStmt>(getHandler()); 1043 } 1044 1045 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc, 1046 Expr *FilterExpr, 1047 Stmt *Block) 1048 : Stmt(SEHExceptStmtClass), 1049 Loc(Loc) 1050 { 1051 Children[FILTER_EXPR] = FilterExpr; 1052 Children[BLOCK] = Block; 1053 } 1054 1055 SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc, 1056 Expr *FilterExpr, Stmt *Block) { 1057 return new(C) SEHExceptStmt(Loc,FilterExpr,Block); 1058 } 1059 1060 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc, 1061 Stmt *Block) 1062 : Stmt(SEHFinallyStmtClass), 1063 Loc(Loc), 1064 Block(Block) 1065 {} 1066 1067 SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc, 1068 Stmt *Block) { 1069 return new(C)SEHFinallyStmt(Loc,Block); 1070 } 1071 1072 CapturedStmt::Capture *CapturedStmt::getStoredCaptures() const { 1073 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1); 1074 1075 // Offset of the first Capture object. 1076 unsigned FirstCaptureOffset = 1077 llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>()); 1078 1079 return reinterpret_cast<Capture *>( 1080 reinterpret_cast<char *>(const_cast<CapturedStmt *>(this)) 1081 + FirstCaptureOffset); 1082 } 1083 1084 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind, 1085 ArrayRef<Capture> Captures, 1086 ArrayRef<Expr *> CaptureInits, 1087 CapturedDecl *CD, 1088 RecordDecl *RD) 1089 : Stmt(CapturedStmtClass), NumCaptures(Captures.size()), 1090 CapDeclAndKind(CD, Kind), TheRecordDecl(RD) { 1091 assert( S && "null captured statement"); 1092 assert(CD && "null captured declaration for captured statement"); 1093 assert(RD && "null record declaration for captured statement"); 1094 1095 // Copy initialization expressions. 1096 Stmt **Stored = getStoredStmts(); 1097 for (unsigned I = 0, N = NumCaptures; I != N; ++I) 1098 *Stored++ = CaptureInits[I]; 1099 1100 // Copy the statement being captured. 1101 *Stored = S; 1102 1103 // Copy all Capture objects. 1104 Capture *Buffer = getStoredCaptures(); 1105 std::copy(Captures.begin(), Captures.end(), Buffer); 1106 } 1107 1108 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures) 1109 : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures), 1110 CapDeclAndKind(nullptr, CR_Default), TheRecordDecl(nullptr) { 1111 getStoredStmts()[NumCaptures] = nullptr; 1112 } 1113 1114 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S, 1115 CapturedRegionKind Kind, 1116 ArrayRef<Capture> Captures, 1117 ArrayRef<Expr *> CaptureInits, 1118 CapturedDecl *CD, 1119 RecordDecl *RD) { 1120 // The layout is 1121 // 1122 // ----------------------------------------------------------- 1123 // | CapturedStmt, Init, ..., Init, S, Capture, ..., Capture | 1124 // ----------------^-------------------^---------------------- 1125 // getStoredStmts() getStoredCaptures() 1126 // 1127 // where S is the statement being captured. 1128 // 1129 assert(CaptureInits.size() == Captures.size() && "wrong number of arguments"); 1130 1131 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1); 1132 if (!Captures.empty()) { 1133 // Realign for the following Capture array. 1134 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>()); 1135 Size += sizeof(Capture) * Captures.size(); 1136 } 1137 1138 void *Mem = Context.Allocate(Size); 1139 return new (Mem) CapturedStmt(S, Kind, Captures, CaptureInits, CD, RD); 1140 } 1141 1142 CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context, 1143 unsigned NumCaptures) { 1144 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1); 1145 if (NumCaptures > 0) { 1146 // Realign for the following Capture array. 1147 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>()); 1148 Size += sizeof(Capture) * NumCaptures; 1149 } 1150 1151 void *Mem = Context.Allocate(Size); 1152 return new (Mem) CapturedStmt(EmptyShell(), NumCaptures); 1153 } 1154 1155 Stmt::child_range CapturedStmt::children() { 1156 // Children are captured field initilizers. 1157 return child_range(getStoredStmts(), getStoredStmts() + NumCaptures); 1158 } 1159 1160 bool CapturedStmt::capturesVariable(const VarDecl *Var) const { 1161 for (const auto &I : captures()) { 1162 if (!I.capturesVariable()) 1163 continue; 1164 1165 // This does not handle variable redeclarations. This should be 1166 // extended to capture variables with redeclarations, for example 1167 // a thread-private variable in OpenMP. 1168 if (I.getCapturedVar() == Var) 1169 return true; 1170 } 1171 1172 return false; 1173 } 1174 1175 StmtRange OMPClause::children() { 1176 switch(getClauseKind()) { 1177 default : break; 1178 #define OPENMP_CLAUSE(Name, Class) \ 1179 case OMPC_ ## Name : return static_cast<Class *>(this)->children(); 1180 #include "clang/Basic/OpenMPKinds.def" 1181 } 1182 llvm_unreachable("unknown OMPClause"); 1183 } 1184 1185 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { 1186 assert(VL.size() == varlist_size() && 1187 "Number of private copies is not the same as the preallocated buffer"); 1188 std::copy(VL.begin(), VL.end(), varlist_end()); 1189 } 1190 1191 OMPPrivateClause * 1192 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc, 1193 SourceLocation LParenLoc, SourceLocation EndLoc, 1194 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) { 1195 // Allocate space for private variables and initializer expressions. 1196 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause), 1197 llvm::alignOf<Expr *>()) + 1198 2 * sizeof(Expr *) * VL.size()); 1199 OMPPrivateClause *Clause = 1200 new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1201 Clause->setVarRefs(VL); 1202 Clause->setPrivateCopies(PrivateVL); 1203 return Clause; 1204 } 1205 1206 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C, 1207 unsigned N) { 1208 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause), 1209 llvm::alignOf<Expr *>()) + 1210 2 * sizeof(Expr *) * N); 1211 return new (Mem) OMPPrivateClause(N); 1212 } 1213 1214 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { 1215 assert(VL.size() == varlist_size() && 1216 "Number of private copies is not the same as the preallocated buffer"); 1217 std::copy(VL.begin(), VL.end(), varlist_end()); 1218 } 1219 1220 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) { 1221 assert(VL.size() == varlist_size() && 1222 "Number of inits is not the same as the preallocated buffer"); 1223 std::copy(VL.begin(), VL.end(), getPrivateCopies().end()); 1224 } 1225 1226 OMPFirstprivateClause * 1227 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc, 1228 SourceLocation LParenLoc, SourceLocation EndLoc, 1229 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL, 1230 ArrayRef<Expr *> InitVL) { 1231 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause), 1232 llvm::alignOf<Expr *>()) + 1233 3 * sizeof(Expr *) * VL.size()); 1234 OMPFirstprivateClause *Clause = 1235 new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1236 Clause->setVarRefs(VL); 1237 Clause->setPrivateCopies(PrivateVL); 1238 Clause->setInits(InitVL); 1239 return Clause; 1240 } 1241 1242 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C, 1243 unsigned N) { 1244 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause), 1245 llvm::alignOf<Expr *>()) + 1246 3 * sizeof(Expr *) * N); 1247 return new (Mem) OMPFirstprivateClause(N); 1248 } 1249 1250 OMPLastprivateClause *OMPLastprivateClause::Create(const ASTContext &C, 1251 SourceLocation StartLoc, 1252 SourceLocation LParenLoc, 1253 SourceLocation EndLoc, 1254 ArrayRef<Expr *> VL) { 1255 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause), 1256 llvm::alignOf<Expr *>()) + 1257 sizeof(Expr *) * VL.size()); 1258 OMPLastprivateClause *Clause = 1259 new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1260 Clause->setVarRefs(VL); 1261 return Clause; 1262 } 1263 1264 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C, 1265 unsigned N) { 1266 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause), 1267 llvm::alignOf<Expr *>()) + 1268 sizeof(Expr *) * N); 1269 return new (Mem) OMPLastprivateClause(N); 1270 } 1271 1272 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C, 1273 SourceLocation StartLoc, 1274 SourceLocation LParenLoc, 1275 SourceLocation EndLoc, 1276 ArrayRef<Expr *> VL) { 1277 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause), 1278 llvm::alignOf<Expr *>()) + 1279 sizeof(Expr *) * VL.size()); 1280 OMPSharedClause *Clause = new (Mem) OMPSharedClause(StartLoc, LParenLoc, 1281 EndLoc, VL.size()); 1282 Clause->setVarRefs(VL); 1283 return Clause; 1284 } 1285 1286 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, 1287 unsigned N) { 1288 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause), 1289 llvm::alignOf<Expr *>()) + 1290 sizeof(Expr *) * N); 1291 return new (Mem) OMPSharedClause(N); 1292 } 1293 1294 OMPLinearClause *OMPLinearClause::Create(const ASTContext &C, 1295 SourceLocation StartLoc, 1296 SourceLocation LParenLoc, 1297 SourceLocation ColonLoc, 1298 SourceLocation EndLoc, 1299 ArrayRef<Expr *> VL, Expr *Step) { 1300 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause), 1301 llvm::alignOf<Expr *>()) + 1302 sizeof(Expr *) * (VL.size() + 1)); 1303 OMPLinearClause *Clause = new (Mem) 1304 OMPLinearClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size()); 1305 Clause->setVarRefs(VL); 1306 Clause->setStep(Step); 1307 return Clause; 1308 } 1309 1310 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C, 1311 unsigned NumVars) { 1312 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause), 1313 llvm::alignOf<Expr *>()) + 1314 sizeof(Expr *) * (NumVars + 1)); 1315 return new (Mem) OMPLinearClause(NumVars); 1316 } 1317 1318 OMPAlignedClause * 1319 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc, 1320 SourceLocation LParenLoc, SourceLocation ColonLoc, 1321 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) { 1322 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause), 1323 llvm::alignOf<Expr *>()) + 1324 sizeof(Expr *) * (VL.size() + 1)); 1325 OMPAlignedClause *Clause = new (Mem) 1326 OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size()); 1327 Clause->setVarRefs(VL); 1328 Clause->setAlignment(A); 1329 return Clause; 1330 } 1331 1332 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C, 1333 unsigned NumVars) { 1334 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause), 1335 llvm::alignOf<Expr *>()) + 1336 sizeof(Expr *) * (NumVars + 1)); 1337 return new (Mem) OMPAlignedClause(NumVars); 1338 } 1339 1340 OMPCopyinClause *OMPCopyinClause::Create(const ASTContext &C, 1341 SourceLocation StartLoc, 1342 SourceLocation LParenLoc, 1343 SourceLocation EndLoc, 1344 ArrayRef<Expr *> VL) { 1345 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause), 1346 llvm::alignOf<Expr *>()) + 1347 sizeof(Expr *) * VL.size()); 1348 OMPCopyinClause *Clause = new (Mem) OMPCopyinClause(StartLoc, LParenLoc, 1349 EndLoc, VL.size()); 1350 Clause->setVarRefs(VL); 1351 return Clause; 1352 } 1353 1354 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, 1355 unsigned N) { 1356 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause), 1357 llvm::alignOf<Expr *>()) + 1358 sizeof(Expr *) * N); 1359 return new (Mem) OMPCopyinClause(N); 1360 } 1361 1362 OMPCopyprivateClause *OMPCopyprivateClause::Create(const ASTContext &C, 1363 SourceLocation StartLoc, 1364 SourceLocation LParenLoc, 1365 SourceLocation EndLoc, 1366 ArrayRef<Expr *> VL) { 1367 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause), 1368 llvm::alignOf<Expr *>()) + 1369 sizeof(Expr *) * VL.size()); 1370 OMPCopyprivateClause *Clause = 1371 new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1372 Clause->setVarRefs(VL); 1373 return Clause; 1374 } 1375 1376 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C, 1377 unsigned N) { 1378 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause), 1379 llvm::alignOf<Expr *>()) + 1380 sizeof(Expr *) * N); 1381 return new (Mem) OMPCopyprivateClause(N); 1382 } 1383 1384 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) { 1385 assert(Clauses.size() == getNumClauses() && 1386 "Number of clauses is not the same as the preallocated buffer"); 1387 std::copy(Clauses.begin(), Clauses.end(), getClauses().begin()); 1388 } 1389 1390 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) { 1391 assert(A.size() == getCollapsedNumber() && 1392 "Number of loop counters is not the same as the collapsed number"); 1393 std::copy(A.begin(), A.end(), getCounters().begin()); 1394 } 1395 1396 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) { 1397 assert(A.size() == getCollapsedNumber() && 1398 "Number of counter updates is not the same as the collapsed number"); 1399 std::copy(A.begin(), A.end(), getUpdates().begin()); 1400 } 1401 1402 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) { 1403 assert(A.size() == getCollapsedNumber() && 1404 "Number of counter finals is not the same as the collapsed number"); 1405 std::copy(A.begin(), A.end(), getFinals().begin()); 1406 } 1407 1408 OMPReductionClause *OMPReductionClause::Create( 1409 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 1410 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL, 1411 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo) { 1412 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause), 1413 llvm::alignOf<Expr *>()) + 1414 sizeof(Expr *) * VL.size()); 1415 OMPReductionClause *Clause = new (Mem) OMPReductionClause( 1416 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo); 1417 Clause->setVarRefs(VL); 1418 return Clause; 1419 } 1420 1421 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C, 1422 unsigned N) { 1423 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause), 1424 llvm::alignOf<Expr *>()) + 1425 sizeof(Expr *) * N); 1426 return new (Mem) OMPReductionClause(N); 1427 } 1428 1429 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C, 1430 SourceLocation StartLoc, 1431 SourceLocation LParenLoc, 1432 SourceLocation EndLoc, 1433 ArrayRef<Expr *> VL) { 1434 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause), 1435 llvm::alignOf<Expr *>()) + 1436 sizeof(Expr *) * VL.size()); 1437 OMPFlushClause *Clause = 1438 new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1439 Clause->setVarRefs(VL); 1440 return Clause; 1441 } 1442 1443 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) { 1444 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause), 1445 llvm::alignOf<Expr *>()) + 1446 sizeof(Expr *) * N); 1447 return new (Mem) OMPFlushClause(N); 1448 } 1449 1450 const OMPClause * 1451 OMPExecutableDirective::getSingleClause(OpenMPClauseKind K) const { 1452 auto ClauseFilter = 1453 [=](const OMPClause *C) -> bool { return C->getClauseKind() == K; }; 1454 OMPExecutableDirective::filtered_clause_iterator<decltype(ClauseFilter)> I( 1455 clauses(), ClauseFilter); 1456 1457 if (I) { 1458 auto *Clause = *I; 1459 assert(!++I && "There are at least 2 clauses of the specified kind"); 1460 return Clause; 1461 } 1462 return nullptr; 1463 } 1464 1465 OMPParallelDirective *OMPParallelDirective::Create( 1466 const ASTContext &C, 1467 SourceLocation StartLoc, 1468 SourceLocation EndLoc, 1469 ArrayRef<OMPClause *> Clauses, 1470 Stmt *AssociatedStmt) { 1471 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective), 1472 llvm::alignOf<OMPClause *>()); 1473 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 1474 sizeof(Stmt *)); 1475 OMPParallelDirective *Dir = new (Mem) OMPParallelDirective(StartLoc, EndLoc, 1476 Clauses.size()); 1477 Dir->setClauses(Clauses); 1478 Dir->setAssociatedStmt(AssociatedStmt); 1479 return Dir; 1480 } 1481 1482 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C, 1483 unsigned NumClauses, 1484 EmptyShell) { 1485 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective), 1486 llvm::alignOf<OMPClause *>()); 1487 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 1488 sizeof(Stmt *)); 1489 return new (Mem) OMPParallelDirective(NumClauses); 1490 } 1491 1492 OMPSimdDirective * 1493 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, 1494 SourceLocation EndLoc, unsigned CollapsedNum, 1495 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1496 const HelperExprs &Exprs) { 1497 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective), 1498 llvm::alignOf<OMPClause *>()); 1499 void *Mem = 1500 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 1501 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd)); 1502 OMPSimdDirective *Dir = new (Mem) 1503 OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 1504 Dir->setClauses(Clauses); 1505 Dir->setAssociatedStmt(AssociatedStmt); 1506 Dir->setIterationVariable(Exprs.IterationVarRef); 1507 Dir->setLastIteration(Exprs.LastIteration); 1508 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1509 Dir->setPreCond(Exprs.PreCond); 1510 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); 1511 Dir->setInit(Exprs.Init); 1512 Dir->setInc(Exprs.Inc); 1513 Dir->setCounters(Exprs.Counters); 1514 Dir->setUpdates(Exprs.Updates); 1515 Dir->setFinals(Exprs.Finals); 1516 return Dir; 1517 } 1518 1519 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C, 1520 unsigned NumClauses, 1521 unsigned CollapsedNum, 1522 EmptyShell) { 1523 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective), 1524 llvm::alignOf<OMPClause *>()); 1525 void *Mem = 1526 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 1527 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd)); 1528 return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses); 1529 } 1530 1531 OMPForDirective * 1532 OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc, 1533 SourceLocation EndLoc, unsigned CollapsedNum, 1534 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1535 const HelperExprs &Exprs) { 1536 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective), 1537 llvm::alignOf<OMPClause *>()); 1538 void *Mem = 1539 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 1540 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for)); 1541 OMPForDirective *Dir = 1542 new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 1543 Dir->setClauses(Clauses); 1544 Dir->setAssociatedStmt(AssociatedStmt); 1545 Dir->setIterationVariable(Exprs.IterationVarRef); 1546 Dir->setLastIteration(Exprs.LastIteration); 1547 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1548 Dir->setPreCond(Exprs.PreCond); 1549 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); 1550 Dir->setInit(Exprs.Init); 1551 Dir->setInc(Exprs.Inc); 1552 Dir->setIsLastIterVariable(Exprs.IL); 1553 Dir->setLowerBoundVariable(Exprs.LB); 1554 Dir->setUpperBoundVariable(Exprs.UB); 1555 Dir->setStrideVariable(Exprs.ST); 1556 Dir->setEnsureUpperBound(Exprs.EUB); 1557 Dir->setNextLowerBound(Exprs.NLB); 1558 Dir->setNextUpperBound(Exprs.NUB); 1559 Dir->setCounters(Exprs.Counters); 1560 Dir->setUpdates(Exprs.Updates); 1561 Dir->setFinals(Exprs.Finals); 1562 return Dir; 1563 } 1564 1565 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C, 1566 unsigned NumClauses, 1567 unsigned CollapsedNum, 1568 EmptyShell) { 1569 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective), 1570 llvm::alignOf<OMPClause *>()); 1571 void *Mem = 1572 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 1573 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for)); 1574 return new (Mem) OMPForDirective(CollapsedNum, NumClauses); 1575 } 1576 1577 OMPForSimdDirective * 1578 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, 1579 SourceLocation EndLoc, unsigned CollapsedNum, 1580 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1581 const HelperExprs &Exprs) { 1582 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective), 1583 llvm::alignOf<OMPClause *>()); 1584 void *Mem = 1585 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 1586 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd)); 1587 OMPForSimdDirective *Dir = new (Mem) 1588 OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 1589 Dir->setClauses(Clauses); 1590 Dir->setAssociatedStmt(AssociatedStmt); 1591 Dir->setIterationVariable(Exprs.IterationVarRef); 1592 Dir->setLastIteration(Exprs.LastIteration); 1593 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1594 Dir->setPreCond(Exprs.PreCond); 1595 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); 1596 Dir->setInit(Exprs.Init); 1597 Dir->setInc(Exprs.Inc); 1598 Dir->setIsLastIterVariable(Exprs.IL); 1599 Dir->setLowerBoundVariable(Exprs.LB); 1600 Dir->setUpperBoundVariable(Exprs.UB); 1601 Dir->setStrideVariable(Exprs.ST); 1602 Dir->setEnsureUpperBound(Exprs.EUB); 1603 Dir->setNextLowerBound(Exprs.NLB); 1604 Dir->setNextUpperBound(Exprs.NUB); 1605 Dir->setCounters(Exprs.Counters); 1606 Dir->setUpdates(Exprs.Updates); 1607 Dir->setFinals(Exprs.Finals); 1608 return Dir; 1609 } 1610 1611 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C, 1612 unsigned NumClauses, 1613 unsigned CollapsedNum, 1614 EmptyShell) { 1615 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective), 1616 llvm::alignOf<OMPClause *>()); 1617 void *Mem = 1618 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 1619 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd)); 1620 return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses); 1621 } 1622 1623 OMPSectionsDirective *OMPSectionsDirective::Create( 1624 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1625 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 1626 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective), 1627 llvm::alignOf<OMPClause *>()); 1628 void *Mem = 1629 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 1630 OMPSectionsDirective *Dir = 1631 new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size()); 1632 Dir->setClauses(Clauses); 1633 Dir->setAssociatedStmt(AssociatedStmt); 1634 return Dir; 1635 } 1636 1637 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C, 1638 unsigned NumClauses, 1639 EmptyShell) { 1640 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective), 1641 llvm::alignOf<OMPClause *>()); 1642 void *Mem = 1643 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 1644 return new (Mem) OMPSectionsDirective(NumClauses); 1645 } 1646 1647 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C, 1648 SourceLocation StartLoc, 1649 SourceLocation EndLoc, 1650 Stmt *AssociatedStmt) { 1651 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective), 1652 llvm::alignOf<Stmt *>()); 1653 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1654 OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc); 1655 Dir->setAssociatedStmt(AssociatedStmt); 1656 return Dir; 1657 } 1658 1659 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C, 1660 EmptyShell) { 1661 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective), 1662 llvm::alignOf<Stmt *>()); 1663 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1664 return new (Mem) OMPSectionDirective(); 1665 } 1666 1667 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C, 1668 SourceLocation StartLoc, 1669 SourceLocation EndLoc, 1670 ArrayRef<OMPClause *> Clauses, 1671 Stmt *AssociatedStmt) { 1672 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective), 1673 llvm::alignOf<OMPClause *>()); 1674 void *Mem = 1675 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 1676 OMPSingleDirective *Dir = 1677 new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size()); 1678 Dir->setClauses(Clauses); 1679 Dir->setAssociatedStmt(AssociatedStmt); 1680 return Dir; 1681 } 1682 1683 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C, 1684 unsigned NumClauses, 1685 EmptyShell) { 1686 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective), 1687 llvm::alignOf<OMPClause *>()); 1688 void *Mem = 1689 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 1690 return new (Mem) OMPSingleDirective(NumClauses); 1691 } 1692 1693 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C, 1694 SourceLocation StartLoc, 1695 SourceLocation EndLoc, 1696 Stmt *AssociatedStmt) { 1697 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective), 1698 llvm::alignOf<Stmt *>()); 1699 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1700 OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc); 1701 Dir->setAssociatedStmt(AssociatedStmt); 1702 return Dir; 1703 } 1704 1705 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C, 1706 EmptyShell) { 1707 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective), 1708 llvm::alignOf<Stmt *>()); 1709 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1710 return new (Mem) OMPMasterDirective(); 1711 } 1712 1713 OMPCriticalDirective *OMPCriticalDirective::Create( 1714 const ASTContext &C, const DeclarationNameInfo &Name, 1715 SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt) { 1716 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective), 1717 llvm::alignOf<Stmt *>()); 1718 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1719 OMPCriticalDirective *Dir = 1720 new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc); 1721 Dir->setAssociatedStmt(AssociatedStmt); 1722 return Dir; 1723 } 1724 1725 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C, 1726 EmptyShell) { 1727 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective), 1728 llvm::alignOf<Stmt *>()); 1729 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1730 return new (Mem) OMPCriticalDirective(); 1731 } 1732 1733 OMPParallelForDirective *OMPParallelForDirective::Create( 1734 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1735 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1736 const HelperExprs &Exprs) { 1737 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective), 1738 llvm::alignOf<OMPClause *>()); 1739 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 1740 sizeof(Stmt *) * 1741 numLoopChildren(CollapsedNum, OMPD_parallel_for)); 1742 OMPParallelForDirective *Dir = new (Mem) 1743 OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 1744 Dir->setClauses(Clauses); 1745 Dir->setAssociatedStmt(AssociatedStmt); 1746 Dir->setIterationVariable(Exprs.IterationVarRef); 1747 Dir->setLastIteration(Exprs.LastIteration); 1748 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1749 Dir->setPreCond(Exprs.PreCond); 1750 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); 1751 Dir->setInit(Exprs.Init); 1752 Dir->setInc(Exprs.Inc); 1753 Dir->setIsLastIterVariable(Exprs.IL); 1754 Dir->setLowerBoundVariable(Exprs.LB); 1755 Dir->setUpperBoundVariable(Exprs.UB); 1756 Dir->setStrideVariable(Exprs.ST); 1757 Dir->setEnsureUpperBound(Exprs.EUB); 1758 Dir->setNextLowerBound(Exprs.NLB); 1759 Dir->setNextUpperBound(Exprs.NUB); 1760 Dir->setCounters(Exprs.Counters); 1761 Dir->setUpdates(Exprs.Updates); 1762 Dir->setFinals(Exprs.Finals); 1763 return Dir; 1764 } 1765 1766 OMPParallelForDirective * 1767 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 1768 unsigned CollapsedNum, EmptyShell) { 1769 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective), 1770 llvm::alignOf<OMPClause *>()); 1771 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 1772 sizeof(Stmt *) * 1773 numLoopChildren(CollapsedNum, OMPD_parallel_for)); 1774 return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses); 1775 } 1776 1777 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create( 1778 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1779 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1780 const HelperExprs &Exprs) { 1781 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective), 1782 llvm::alignOf<OMPClause *>()); 1783 void *Mem = C.Allocate( 1784 Size + sizeof(OMPClause *) * Clauses.size() + 1785 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd)); 1786 OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective( 1787 StartLoc, EndLoc, CollapsedNum, Clauses.size()); 1788 Dir->setClauses(Clauses); 1789 Dir->setAssociatedStmt(AssociatedStmt); 1790 Dir->setIterationVariable(Exprs.IterationVarRef); 1791 Dir->setLastIteration(Exprs.LastIteration); 1792 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1793 Dir->setPreCond(Exprs.PreCond); 1794 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); 1795 Dir->setInit(Exprs.Init); 1796 Dir->setInc(Exprs.Inc); 1797 Dir->setIsLastIterVariable(Exprs.IL); 1798 Dir->setLowerBoundVariable(Exprs.LB); 1799 Dir->setUpperBoundVariable(Exprs.UB); 1800 Dir->setStrideVariable(Exprs.ST); 1801 Dir->setEnsureUpperBound(Exprs.EUB); 1802 Dir->setNextLowerBound(Exprs.NLB); 1803 Dir->setNextUpperBound(Exprs.NUB); 1804 Dir->setCounters(Exprs.Counters); 1805 Dir->setUpdates(Exprs.Updates); 1806 Dir->setFinals(Exprs.Finals); 1807 return Dir; 1808 } 1809 1810 OMPParallelForSimdDirective * 1811 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C, 1812 unsigned NumClauses, 1813 unsigned CollapsedNum, EmptyShell) { 1814 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective), 1815 llvm::alignOf<OMPClause *>()); 1816 void *Mem = C.Allocate( 1817 Size + sizeof(OMPClause *) * NumClauses + 1818 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd)); 1819 return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses); 1820 } 1821 1822 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create( 1823 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1824 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 1825 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective), 1826 llvm::alignOf<OMPClause *>()); 1827 void *Mem = 1828 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 1829 OMPParallelSectionsDirective *Dir = 1830 new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size()); 1831 Dir->setClauses(Clauses); 1832 Dir->setAssociatedStmt(AssociatedStmt); 1833 return Dir; 1834 } 1835 1836 OMPParallelSectionsDirective * 1837 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C, 1838 unsigned NumClauses, EmptyShell) { 1839 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective), 1840 llvm::alignOf<OMPClause *>()); 1841 void *Mem = 1842 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 1843 return new (Mem) OMPParallelSectionsDirective(NumClauses); 1844 } 1845 1846 OMPTaskDirective *OMPTaskDirective::Create(const ASTContext &C, 1847 SourceLocation StartLoc, 1848 SourceLocation EndLoc, 1849 ArrayRef<OMPClause *> Clauses, 1850 Stmt *AssociatedStmt) { 1851 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective), 1852 llvm::alignOf<OMPClause *>()); 1853 void *Mem = 1854 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 1855 OMPTaskDirective *Dir = 1856 new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size()); 1857 Dir->setClauses(Clauses); 1858 Dir->setAssociatedStmt(AssociatedStmt); 1859 return Dir; 1860 } 1861 1862 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C, 1863 unsigned NumClauses, 1864 EmptyShell) { 1865 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective), 1866 llvm::alignOf<OMPClause *>()); 1867 void *Mem = 1868 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 1869 return new (Mem) OMPTaskDirective(NumClauses); 1870 } 1871 1872 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C, 1873 SourceLocation StartLoc, 1874 SourceLocation EndLoc) { 1875 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective)); 1876 OMPTaskyieldDirective *Dir = 1877 new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc); 1878 return Dir; 1879 } 1880 1881 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C, 1882 EmptyShell) { 1883 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective)); 1884 return new (Mem) OMPTaskyieldDirective(); 1885 } 1886 1887 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C, 1888 SourceLocation StartLoc, 1889 SourceLocation EndLoc) { 1890 void *Mem = C.Allocate(sizeof(OMPBarrierDirective)); 1891 OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc); 1892 return Dir; 1893 } 1894 1895 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C, 1896 EmptyShell) { 1897 void *Mem = C.Allocate(sizeof(OMPBarrierDirective)); 1898 return new (Mem) OMPBarrierDirective(); 1899 } 1900 1901 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C, 1902 SourceLocation StartLoc, 1903 SourceLocation EndLoc) { 1904 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective)); 1905 OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc); 1906 return Dir; 1907 } 1908 1909 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C, 1910 EmptyShell) { 1911 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective)); 1912 return new (Mem) OMPTaskwaitDirective(); 1913 } 1914 1915 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C, 1916 SourceLocation StartLoc, 1917 SourceLocation EndLoc, 1918 ArrayRef<OMPClause *> Clauses) { 1919 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective), 1920 llvm::alignOf<OMPClause *>()); 1921 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size()); 1922 OMPFlushDirective *Dir = 1923 new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size()); 1924 Dir->setClauses(Clauses); 1925 return Dir; 1926 } 1927 1928 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C, 1929 unsigned NumClauses, 1930 EmptyShell) { 1931 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective), 1932 llvm::alignOf<OMPClause *>()); 1933 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses); 1934 return new (Mem) OMPFlushDirective(NumClauses); 1935 } 1936 1937 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C, 1938 SourceLocation StartLoc, 1939 SourceLocation EndLoc, 1940 Stmt *AssociatedStmt) { 1941 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective), 1942 llvm::alignOf<Stmt *>()); 1943 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1944 OMPOrderedDirective *Dir = new (Mem) OMPOrderedDirective(StartLoc, EndLoc); 1945 Dir->setAssociatedStmt(AssociatedStmt); 1946 return Dir; 1947 } 1948 1949 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C, 1950 EmptyShell) { 1951 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective), 1952 llvm::alignOf<Stmt *>()); 1953 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 1954 return new (Mem) OMPOrderedDirective(); 1955 } 1956 1957 OMPAtomicDirective * 1958 OMPAtomicDirective::Create(const ASTContext &C, SourceLocation StartLoc, 1959 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, 1960 Stmt *AssociatedStmt, Expr *X, Expr *V, Expr *E) { 1961 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective), 1962 llvm::alignOf<OMPClause *>()); 1963 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 1964 4 * sizeof(Stmt *)); 1965 OMPAtomicDirective *Dir = 1966 new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size()); 1967 Dir->setClauses(Clauses); 1968 Dir->setAssociatedStmt(AssociatedStmt); 1969 Dir->setX(X); 1970 Dir->setV(V); 1971 Dir->setExpr(E); 1972 return Dir; 1973 } 1974 1975 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C, 1976 unsigned NumClauses, 1977 EmptyShell) { 1978 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective), 1979 llvm::alignOf<OMPClause *>()); 1980 void *Mem = 1981 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 4 * sizeof(Stmt *)); 1982 return new (Mem) OMPAtomicDirective(NumClauses); 1983 } 1984 1985 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C, 1986 SourceLocation StartLoc, 1987 SourceLocation EndLoc, 1988 ArrayRef<OMPClause *> Clauses, 1989 Stmt *AssociatedStmt) { 1990 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective), 1991 llvm::alignOf<OMPClause *>()); 1992 void *Mem = 1993 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 1994 OMPTargetDirective *Dir = 1995 new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size()); 1996 Dir->setClauses(Clauses); 1997 Dir->setAssociatedStmt(AssociatedStmt); 1998 return Dir; 1999 } 2000 2001 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C, 2002 unsigned NumClauses, 2003 EmptyShell) { 2004 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective), 2005 llvm::alignOf<OMPClause *>()); 2006 void *Mem = 2007 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 2008 return new (Mem) OMPTargetDirective(NumClauses); 2009 } 2010 2011 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C, 2012 SourceLocation StartLoc, 2013 SourceLocation EndLoc, 2014 ArrayRef<OMPClause *> Clauses, 2015 Stmt *AssociatedStmt) { 2016 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective), 2017 llvm::alignOf<OMPClause *>()); 2018 void *Mem = 2019 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 2020 OMPTeamsDirective *Dir = 2021 new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size()); 2022 Dir->setClauses(Clauses); 2023 Dir->setAssociatedStmt(AssociatedStmt); 2024 return Dir; 2025 } 2026 2027 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C, 2028 unsigned NumClauses, 2029 EmptyShell) { 2030 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective), 2031 llvm::alignOf<OMPClause *>()); 2032 void *Mem = 2033 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 2034 return new (Mem) OMPTeamsDirective(NumClauses); 2035 } 2036 2037