1 //===--- Stmt.cpp - Statement AST Node Implementation ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Stmt class and statement subclasses.
12 //===----------------------------------------------------------------------===//
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;
30 static struct StmtClassNameTable {
34 } StmtClassInfo[Stmt::lastStmtConstant+1];
36 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
37 static bool Initialized = false;
39 return StmtClassInfo[E];
41 // Intialize the table on the first use.
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"
49 return StmtClassInfo[E];
52 void *Stmt::operator new(size_t bytes, const ASTContext& C,
54 return ::operator new(bytes, C, alignment);
57 const char *Stmt::getStmtClassName() const {
58 return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
61 void Stmt::PrintStats() {
62 // Ensure the table is primed.
63 getStmtInfoTableEntry(Stmt::NullStmtClass);
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;
71 llvm::errs() << " " << sum << " stmts/exprs total.\n";
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
80 sum += StmtClassInfo[i].Counter*StmtClassInfo[i].Size;
83 llvm::errs() << "Total bytes = " << sum << "\n";
86 void Stmt::addStmtClass(StmtClass s) {
87 ++getStmtInfoTableEntry(s).Counter;
90 bool Stmt::StatisticsEnabled = false;
91 void Stmt::EnableStatistics() {
92 StatisticsEnabled = true;
95 Stmt *Stmt::IgnoreImplicit() {
98 if (auto *ewc = dyn_cast<ExprWithCleanups>(s))
99 s = ewc->getSubExpr();
101 if (auto *mte = dyn_cast<MaterializeTemporaryExpr>(s))
102 s = mte->GetTemporaryExpr();
104 if (auto *bte = dyn_cast<CXXBindTemporaryExpr>(s))
105 s = bte->getSubExpr();
107 while (auto *ice = dyn_cast<ImplicitCastExpr>(s))
108 s = ice->getSubExpr();
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) {
118 if (auto CapS = dyn_cast_or_null<CapturedStmt>(S))
119 S = CapS->getCapturedStmt();
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)) {
133 /// \brief Strip off all label-like statements.
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;
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();
155 // These silly little functions have to be static inline to suppress
156 // unused warnings, and they have to be defined to suppress other
158 static inline good is_good(good) { return good(); }
160 typedef Stmt::child_range children_t();
161 template <class T> good implements_children(children_t T::*) {
164 LLVM_ATTRIBUTE_UNUSED
165 static inline bad implements_children(children_t Stmt::*) {
169 typedef SourceLocation getLocStart_t() const;
170 template <class T> good implements_getLocStart(getLocStart_t T::*) {
173 LLVM_ATTRIBUTE_UNUSED
174 static inline bad implements_getLocStart(getLocStart_t Stmt::*) {
178 typedef SourceLocation getLocEnd_t() const;
179 template <class T> good implements_getLocEnd(getLocEnd_t T::*) {
182 LLVM_ATTRIBUTE_UNUSED
183 static inline bad implements_getLocEnd(getLocEnd_t Stmt::*) {
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))
195 /// Check whether the various Stmt classes implement their member
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"
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"
216 llvm_unreachable("unknown statement kind!");
219 // Amusing macro metaprogramming hack: check whether a class provides
220 // a more specific implementation of getSourceRange.
222 // See also Expr.cpp:getExprLoc().
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();
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.
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());
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"
253 llvm_unreachable("unknown statement kind!");
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"
266 llvm_unreachable("unknown statement kind");
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"
278 llvm_unreachable("unknown statement kind");
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!");
288 if (Stmts.size() == 0) {
293 Body = new (C) Stmt*[Stmts.size()];
294 std::copy(Stmts.begin(), Stmts.end(), Body);
297 void CompoundStmt::setStmts(const ASTContext &C, Stmt **Stmts,
301 this->CompoundStmtBits.NumStmts = NumStmts;
303 Body = new (C) Stmt*[NumStmts];
304 memcpy(Body, Stmts, sizeof(Stmt *) * NumStmts);
307 const char *LabelStmt::getName() const {
308 return getDecl()->getIdentifier()->getNameStart();
311 AttributedStmt *AttributedStmt::Create(const ASTContext &C, SourceLocation Loc,
312 ArrayRef<const Attr*> Attrs,
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);
320 AttributedStmt *AttributedStmt::CreateEmpty(const ASTContext &C,
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);
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!");
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!");
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!");
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!");
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!");
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!");
376 /// getNumPlusOperands - Return the number of output operands that have a "+"
378 unsigned AsmStmt::getNumPlusOperands() const {
380 for (unsigned i = 0, e = getNumOutputs(); i != e; ++i)
381 if (isOutputPlusConstraint(i))
386 char GCCAsmStmt::AsmStringPiece::getModifier() const {
387 assert(isOperand() && "Only Operands can have modifiers.");
388 return isLetter(Str[0]) ? Str[0] : '\0';
391 StringRef GCCAsmStmt::getClobber(unsigned i) const {
392 return getClobberStringLiteral(i)->getString();
395 Expr *GCCAsmStmt::getOutputExpr(unsigned i) {
396 return cast<Expr>(Exprs[i]);
399 /// getOutputConstraint - Return the constraint string for the specified
400 /// output operand. All output constraints are known to be non-empty (either
402 StringRef GCCAsmStmt::getOutputConstraint(unsigned i) const {
403 return getOutputConstraintLiteral(i)->getString();
406 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
407 return cast<Expr>(Exprs[i + NumOutputs]);
409 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
410 Exprs[i + NumOutputs] = E;
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();
419 void GCCAsmStmt::setOutputsAndInputsAndClobbers(const ASTContext &C,
420 IdentifierInfo **Names,
421 StringLiteral **Constraints,
425 StringLiteral **Clobbers,
426 unsigned NumClobbers) {
427 this->NumOutputs = NumOutputs;
428 this->NumInputs = NumInputs;
429 this->NumClobbers = NumClobbers;
431 unsigned NumExprs = NumOutputs + NumInputs;
433 C.Deallocate(this->Names);
434 this->Names = new (C) IdentifierInfo*[NumExprs];
435 std::copy(Names, Names + NumExprs, this->Names);
437 C.Deallocate(this->Exprs);
438 this->Exprs = new (C) Stmt*[NumExprs];
439 std::copy(Exprs, Exprs + NumExprs, this->Exprs);
441 C.Deallocate(this->Constraints);
442 this->Constraints = new (C) StringLiteral*[NumExprs];
443 std::copy(Constraints, Constraints + NumExprs, this->Constraints);
445 C.Deallocate(this->Clobbers);
446 this->Clobbers = new (C) StringLiteral*[NumClobbers];
447 std::copy(Clobbers, Clobbers + NumClobbers, this->Clobbers);
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;
456 // Check if this is an output operand.
457 for (unsigned i = 0, e = getNumOutputs(); i != e; ++i) {
458 if (getOutputName(i) == SymbolicName)
462 for (unsigned i = 0, e = getNumInputs(); i != e; ++i)
463 if (getInputName(i) == SymbolicName)
464 return getNumOutputs() + NumPlusOperands + i;
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;
480 // "Simple" inline asms have no constraints or operands, just convert the asm
481 // string to escape $'s.
484 for (; CurPtr != StrEnd; ++CurPtr) {
494 Pieces.push_back(AsmStringPiece(Result));
498 // CurStringPiece - The current string that we are building up as we scan the
500 std::string CurStringPiece;
502 bool HasVariants = !C.getTargetInfo().hasNoAsmVariants();
505 // Done with the string?
506 if (CurPtr == StrEnd) {
507 if (!CurStringPiece.empty())
508 Pieces.push_back(AsmStringPiece(CurStringPiece));
512 char CurChar = *CurPtr++;
514 case '$': CurStringPiece += "$$"; continue;
515 case '{': CurStringPiece += (HasVariants ? "$(" : "{"); continue;
516 case '|': CurStringPiece += (HasVariants ? "$|" : "|"); continue;
517 case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue;
521 CurStringPiece += CurChar;
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;
532 char EscapedChar = *CurPtr++;
533 if (EscapedChar == '%') { // %% -> %
534 // Escaped percentage sign.
535 CurStringPiece += '%';
539 if (EscapedChar == '=') { // %= -> Generate an unique ID.
540 CurStringPiece += "${:uid}";
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();
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.
554 const char *Begin = CurPtr - 1; // Points to the character following '%'.
555 const char *Percent = Begin - 1; // Points to '%'.
557 if (isLetter(EscapedChar)) {
558 if (CurPtr == StrEnd) { // Premature end.
559 DiagOffs = CurPtr-StrStart-1;
560 return diag::err_asm_invalid_escape;
562 EscapedChar = *CurPtr++;
565 const TargetInfo &TI = C.getTargetInfo();
566 const SourceManager &SM = C.getSourceManager();
567 const LangOptions &LO = C.getLangOpts();
569 // Handle operands that don't have asmSymbolicName (e.g., %x4).
570 if (isDigit(EscapedChar)) {
571 // %n - Assembler operand n
575 while (CurPtr != StrEnd && isDigit(*CurPtr))
576 N = N*10 + ((*CurPtr++)-'0');
578 unsigned NumOperands =
579 getNumOutputs() + getNumPlusOperands() + getNumInputs();
580 if (N >= NumOperands) {
581 DiagOffs = CurPtr-StrStart-1;
582 return diag::err_asm_invalid_operand_number;
585 // Str contains "x4" (Operand without the leading %).
586 std::string Str(Begin, CurPtr - Begin);
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);
595 Pieces.push_back(AsmStringPiece(N, Str, BeginLoc, EndLoc));
599 // Handle operands that have asmSymbolicName (e.g., %x[foo]).
600 if (EscapedChar == '[') {
601 DiagOffs = CurPtr-StrStart-1;
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;
610 StringRef SymbolicName(CurPtr, NameEnd - CurPtr);
612 int N = getNamedOperand(SymbolicName);
614 // Verify that an operand with that name exists.
615 DiagOffs = CurPtr-StrStart;
616 return diag::err_asm_unknown_symbolic_operand_name;
619 // Str contains "x[foo]" (Operand without the leading %).
620 std::string Str(Begin, NameEnd + 1 - Begin);
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);
629 Pieces.push_back(AsmStringPiece(N, Str, BeginLoc, EndLoc));
635 DiagOffs = CurPtr-StrStart-1;
636 return diag::err_asm_invalid_escape;
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;
646 AnalyzeAsmString(Pieces, C, DiagOffs);
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());
655 AsmString += "${" + llvm::utostr(Pieces[i].getOperandNo()) + ':' +
656 Pieces[i].getModifier() + '}';
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.
667 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
668 return cast<Expr>(Exprs[i]);
671 Expr *MSAsmStmt::getInputExpr(unsigned i) {
672 return cast<Expr>(Exprs[i + NumOutputs]);
674 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
675 Exprs[i + NumOutputs] = E;
678 QualType CXXCatchStmt::getCaughtType() const {
680 return ExceptionDecl->getType();
684 //===----------------------------------------------------------------------===//
686 //===----------------------------------------------------------------------===//
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) {
697 unsigned NumExprs = NumOutputs + NumInputs;
699 Names = new (C) IdentifierInfo*[NumExprs];
700 std::copy(names, names + NumExprs, Names);
702 Exprs = new (C) Stmt*[NumExprs];
703 std::copy(exprs, exprs + NumExprs, Exprs);
705 Constraints = new (C) StringLiteral*[NumExprs];
706 std::copy(constraints, constraints + NumExprs, Constraints);
708 Clobbers = new (C) StringLiteral*[NumClobbers];
709 std::copy(clobbers, clobbers + NumClobbers, Clobbers);
712 MSAsmStmt::MSAsmStmt(const ASTContext &C, SourceLocation asmloc,
713 SourceLocation lbraceloc, bool issimple, bool isvolatile,
714 ArrayRef<Token> asmtoks, unsigned numoutputs,
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()) {
723 initialize(C, asmstr, asmtoks, constraints, exprs, clobbers);
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);
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());
741 unsigned NumExprs = exprs.size();
742 assert(NumExprs == NumOutputs + NumInputs);
743 assert(NumExprs == constraints.size());
745 AsmStr = copyIntoContext(C, asmstr);
747 Exprs = new (C) Stmt*[NumExprs];
748 for (unsigned i = 0, e = NumExprs; i != e; ++i)
751 AsmToks = new (C) Token[NumAsmToks];
752 for (unsigned i = 0, e = NumAsmToks; i != e; ++i)
753 AsmToks[i] = asmtoks[i];
755 Constraints = new (C) StringRef[NumExprs];
756 for (unsigned i = 0, e = NumExprs; i != e; ++i) {
757 Constraints[i] = copyIntoContext(C, constraints[i]);
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]);
767 ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
768 Stmt *Body, SourceLocation FCL,
770 : Stmt(ObjCForCollectionStmtClass) {
771 SubExprs[ELEM] = Elem;
772 SubExprs[COLLECTION] = Collect;
773 SubExprs[BODY] = Body;
778 ObjCAtTryStmt::ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
779 Stmt **CatchStmts, unsigned NumCatchStmts,
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];
789 Stmts[NumCatchStmts + 1] = atFinallyStmt;
792 ObjCAtTryStmt *ObjCAtTryStmt::Create(const ASTContext &Context,
793 SourceLocation atTryLoc,
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,
805 ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(const ASTContext &Context,
806 unsigned NumCatchStmts,
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);
814 SourceLocation ObjCAtTryStmt::getLocEnd() const {
816 return getFinallyStmt()->getLocEnd();
818 return getCatchStmt(NumCatchStmts - 1)->getLocEnd();
819 return getTryBody()->getLocEnd();
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));
827 void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
828 return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
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));
836 void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
837 return new (Mem) CXXTryStmt(Empty, numHandlers);
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);
845 std::copy(handlers.begin(), handlers.end(), Stmts + 1);
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;
857 SubExprs[LOOPVAR] = LoopVar;
858 SubExprs[BODY] = Body;
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();
868 const Expr *CXXForRangeStmt::getRangeInit() const {
869 return const_cast<CXXForRangeStmt*>(this)->getRangeInit();
872 VarDecl *CXXForRangeStmt::getLoopVariable() {
873 Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
874 assert(LV && "No loop variable in CXXForRangeStmt");
875 return cast<VarDecl>(LV);
878 const VarDecl *CXXForRangeStmt::getLoopVariable() const {
879 return const_cast<CXXForRangeStmt*>(this)->getLoopVariable();
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)
886 setConditionVariable(C, var);
887 SubExprs[COND] = cond;
888 SubExprs[THEN] = then;
889 SubExprs[ELSE] = elsev;
892 VarDecl *IfStmt::getConditionVariable() const {
896 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
897 return cast<VarDecl>(DS->getSingleDecl());
900 void IfStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
902 SubExprs[VAR] = nullptr;
906 SourceRange VarRange = V->getSourceRange();
907 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
911 ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
912 Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
914 : Stmt(ForStmtClass), ForLoc(FL), LParenLoc(LP), RParenLoc(RP)
916 SubExprs[INIT] = Init;
917 setConditionVariable(C, condVar);
918 SubExprs[COND] = Cond;
920 SubExprs[BODY] = Body;
923 VarDecl *ForStmt::getConditionVariable() const {
924 if (!SubExprs[CONDVAR])
927 DeclStmt *DS = cast<DeclStmt>(SubExprs[CONDVAR]);
928 return cast<VarDecl>(DS->getSingleDecl());
931 void ForStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
933 SubExprs[CONDVAR] = nullptr;
937 SourceRange VarRange = V->getSourceRange();
938 SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
942 SwitchStmt::SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond)
943 : Stmt(SwitchStmtClass), FirstCase(nullptr, false) {
944 setConditionVariable(C, Var);
945 SubExprs[COND] = cond;
946 SubExprs[BODY] = nullptr;
949 VarDecl *SwitchStmt::getConditionVariable() const {
953 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
954 return cast<VarDecl>(DS->getSingleDecl());
957 void SwitchStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
959 SubExprs[VAR] = nullptr;
963 SourceRange VarRange = V->getSourceRange();
964 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
968 Stmt *SwitchCase::getSubStmt() {
969 if (isa<CaseStmt>(this))
970 return cast<CaseStmt>(this)->getSubStmt();
971 return cast<DefaultStmt>(this)->getSubStmt();
974 WhileStmt::WhileStmt(const ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body,
976 : Stmt(WhileStmtClass) {
977 setConditionVariable(C, Var);
978 SubExprs[COND] = cond;
979 SubExprs[BODY] = body;
983 VarDecl *WhileStmt::getConditionVariable() const {
987 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
988 return cast<VarDecl>(DS->getSingleDecl());
991 void WhileStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
993 SubExprs[VAR] = nullptr;
997 SourceRange VarRange = V->getSourceRange();
998 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
1003 LabelDecl *IndirectGotoStmt::getConstantTarget() {
1004 if (AddrLabelExpr *E =
1005 dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
1006 return E->getLabel();
1011 const Expr* ReturnStmt::getRetValue() const {
1012 return cast_or_null<Expr>(RetExpr);
1014 Expr* ReturnStmt::getRetValue() {
1015 return cast_or_null<Expr>(RetExpr);
1018 SEHTryStmt::SEHTryStmt(bool IsCXXTry,
1019 SourceLocation TryLoc,
1022 : Stmt(SEHTryStmtClass),
1026 Children[TRY] = TryBlock;
1027 Children[HANDLER] = Handler;
1030 SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry,
1031 SourceLocation TryLoc, Stmt *TryBlock,
1033 return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
1036 SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
1037 return dyn_cast<SEHExceptStmt>(getHandler());
1040 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
1041 return dyn_cast<SEHFinallyStmt>(getHandler());
1044 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc,
1047 : Stmt(SEHExceptStmtClass),
1050 Children[FILTER_EXPR] = FilterExpr;
1051 Children[BLOCK] = Block;
1054 SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc,
1055 Expr *FilterExpr, Stmt *Block) {
1056 return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
1059 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc,
1061 : Stmt(SEHFinallyStmtClass),
1066 SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc,
1068 return new(C)SEHFinallyStmt(Loc,Block);
1071 CapturedStmt::Capture *CapturedStmt::getStoredCaptures() const {
1072 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1074 // Offset of the first Capture object.
1075 unsigned FirstCaptureOffset =
1076 llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
1078 return reinterpret_cast<Capture *>(
1079 reinterpret_cast<char *>(const_cast<CapturedStmt *>(this))
1080 + FirstCaptureOffset);
1083 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
1084 ArrayRef<Capture> Captures,
1085 ArrayRef<Expr *> CaptureInits,
1088 : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
1089 CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
1090 assert( S && "null captured statement");
1091 assert(CD && "null captured declaration for captured statement");
1092 assert(RD && "null record declaration for captured statement");
1094 // Copy initialization expressions.
1095 Stmt **Stored = getStoredStmts();
1096 for (unsigned I = 0, N = NumCaptures; I != N; ++I)
1097 *Stored++ = CaptureInits[I];
1099 // Copy the statement being captured.
1102 // Copy all Capture objects.
1103 Capture *Buffer = getStoredCaptures();
1104 std::copy(Captures.begin(), Captures.end(), Buffer);
1107 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures)
1108 : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures),
1109 CapDeclAndKind(nullptr, CR_Default), TheRecordDecl(nullptr) {
1110 getStoredStmts()[NumCaptures] = nullptr;
1113 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S,
1114 CapturedRegionKind Kind,
1115 ArrayRef<Capture> Captures,
1116 ArrayRef<Expr *> CaptureInits,
1121 // -----------------------------------------------------------
1122 // | CapturedStmt, Init, ..., Init, S, Capture, ..., Capture |
1123 // ----------------^-------------------^----------------------
1124 // getStoredStmts() getStoredCaptures()
1126 // where S is the statement being captured.
1128 assert(CaptureInits.size() == Captures.size() && "wrong number of arguments");
1130 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1);
1131 if (!Captures.empty()) {
1132 // Realign for the following Capture array.
1133 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
1134 Size += sizeof(Capture) * Captures.size();
1137 void *Mem = Context.Allocate(Size);
1138 return new (Mem) CapturedStmt(S, Kind, Captures, CaptureInits, CD, RD);
1141 CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context,
1142 unsigned NumCaptures) {
1143 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1144 if (NumCaptures > 0) {
1145 // Realign for the following Capture array.
1146 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
1147 Size += sizeof(Capture) * NumCaptures;
1150 void *Mem = Context.Allocate(Size);
1151 return new (Mem) CapturedStmt(EmptyShell(), NumCaptures);
1154 Stmt::child_range CapturedStmt::children() {
1155 // Children are captured field initilizers.
1156 return child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
1159 bool CapturedStmt::capturesVariable(const VarDecl *Var) const {
1160 for (const auto &I : captures()) {
1161 if (!I.capturesVariable())
1164 // This does not handle variable redeclarations. This should be
1165 // extended to capture variables with redeclarations, for example
1166 // a thread-private variable in OpenMP.
1167 if (I.getCapturedVar() == Var)
1174 StmtRange OMPClause::children() {
1175 switch(getClauseKind()) {
1177 #define OPENMP_CLAUSE(Name, Class) \
1178 case OMPC_ ## Name : return static_cast<Class *>(this)->children();
1179 #include "clang/Basic/OpenMPKinds.def"
1181 llvm_unreachable("unknown OMPClause");
1184 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1185 assert(VL.size() == varlist_size() &&
1186 "Number of private copies is not the same as the preallocated buffer");
1187 std::copy(VL.begin(), VL.end(), varlist_end());
1191 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
1192 SourceLocation LParenLoc, SourceLocation EndLoc,
1193 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
1194 // Allocate space for private variables and initializer expressions.
1195 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
1196 llvm::alignOf<Expr *>()) +
1197 2 * sizeof(Expr *) * VL.size());
1198 OMPPrivateClause *Clause =
1199 new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1200 Clause->setVarRefs(VL);
1201 Clause->setPrivateCopies(PrivateVL);
1205 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
1207 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
1208 llvm::alignOf<Expr *>()) +
1209 2 * sizeof(Expr *) * N);
1210 return new (Mem) OMPPrivateClause(N);
1213 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1214 assert(VL.size() == varlist_size() &&
1215 "Number of private copies is not the same as the preallocated buffer");
1216 std::copy(VL.begin(), VL.end(), varlist_end());
1219 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
1220 assert(VL.size() == varlist_size() &&
1221 "Number of inits is not the same as the preallocated buffer");
1222 std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
1225 OMPFirstprivateClause *
1226 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
1227 SourceLocation LParenLoc, SourceLocation EndLoc,
1228 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
1229 ArrayRef<Expr *> InitVL) {
1230 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
1231 llvm::alignOf<Expr *>()) +
1232 3 * sizeof(Expr *) * VL.size());
1233 OMPFirstprivateClause *Clause =
1234 new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1235 Clause->setVarRefs(VL);
1236 Clause->setPrivateCopies(PrivateVL);
1237 Clause->setInits(InitVL);
1241 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
1243 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
1244 llvm::alignOf<Expr *>()) +
1245 3 * sizeof(Expr *) * N);
1246 return new (Mem) OMPFirstprivateClause(N);
1249 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
1250 assert(PrivateCopies.size() == varlist_size() &&
1251 "Number of private copies is not the same as the preallocated buffer");
1252 std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
1255 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
1256 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
1257 "not the same as the "
1258 "preallocated buffer");
1259 std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
1262 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
1263 assert(DstExprs.size() == varlist_size() && "Number of destination "
1264 "expressions is not the same as "
1265 "the preallocated buffer");
1266 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
1269 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
1270 assert(AssignmentOps.size() == varlist_size() &&
1271 "Number of assignment expressions is not the same as the preallocated "
1273 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
1274 getDestinationExprs().end());
1277 OMPLastprivateClause *OMPLastprivateClause::Create(
1278 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1279 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
1280 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
1281 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
1282 llvm::alignOf<Expr *>()) +
1283 5 * sizeof(Expr *) * VL.size());
1284 OMPLastprivateClause *Clause =
1285 new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1286 Clause->setVarRefs(VL);
1287 Clause->setSourceExprs(SrcExprs);
1288 Clause->setDestinationExprs(DstExprs);
1289 Clause->setAssignmentOps(AssignmentOps);
1293 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
1295 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
1296 llvm::alignOf<Expr *>()) +
1297 5 * sizeof(Expr *) * N);
1298 return new (Mem) OMPLastprivateClause(N);
1301 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
1302 SourceLocation StartLoc,
1303 SourceLocation LParenLoc,
1304 SourceLocation EndLoc,
1305 ArrayRef<Expr *> VL) {
1306 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
1307 llvm::alignOf<Expr *>()) +
1308 sizeof(Expr *) * VL.size());
1309 OMPSharedClause *Clause = new (Mem) OMPSharedClause(StartLoc, LParenLoc,
1311 Clause->setVarRefs(VL);
1315 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C,
1317 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
1318 llvm::alignOf<Expr *>()) +
1319 sizeof(Expr *) * N);
1320 return new (Mem) OMPSharedClause(N);
1323 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
1324 assert(IL.size() == varlist_size() &&
1325 "Number of inits is not the same as the preallocated buffer");
1326 std::copy(IL.begin(), IL.end(), varlist_end());
1329 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
1330 assert(UL.size() == varlist_size() &&
1331 "Number of updates is not the same as the preallocated buffer");
1332 std::copy(UL.begin(), UL.end(), getInits().end());
1335 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
1336 assert(FL.size() == varlist_size() &&
1337 "Number of final updates is not the same as the preallocated buffer");
1338 std::copy(FL.begin(), FL.end(), getUpdates().end());
1342 OMPLinearClause::Create(const ASTContext &C, SourceLocation StartLoc,
1343 SourceLocation LParenLoc, SourceLocation ColonLoc,
1344 SourceLocation EndLoc, ArrayRef<Expr *> VL,
1345 ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep) {
1346 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
1347 // (Step and CalcStep).
1348 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
1349 llvm::alignOf<Expr *>()) +
1350 (4 * VL.size() + 2) * sizeof(Expr *));
1351 OMPLinearClause *Clause = new (Mem)
1352 OMPLinearClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
1353 Clause->setVarRefs(VL);
1354 Clause->setInits(IL);
1355 // Fill update and final expressions with zeroes, they are provided later,
1356 // after the directive construction.
1357 std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
1359 std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
1361 Clause->setStep(Step);
1362 Clause->setCalcStep(CalcStep);
1366 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
1368 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
1369 // (Step and CalcStep).
1370 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
1371 llvm::alignOf<Expr *>()) +
1372 (4 * NumVars + 2) * sizeof(Expr *));
1373 return new (Mem) OMPLinearClause(NumVars);
1377 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
1378 SourceLocation LParenLoc, SourceLocation ColonLoc,
1379 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
1380 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
1381 llvm::alignOf<Expr *>()) +
1382 sizeof(Expr *) * (VL.size() + 1));
1383 OMPAlignedClause *Clause = new (Mem)
1384 OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
1385 Clause->setVarRefs(VL);
1386 Clause->setAlignment(A);
1390 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
1392 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
1393 llvm::alignOf<Expr *>()) +
1394 sizeof(Expr *) * (NumVars + 1));
1395 return new (Mem) OMPAlignedClause(NumVars);
1398 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
1399 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
1400 "not the same as the "
1401 "preallocated buffer");
1402 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
1405 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
1406 assert(DstExprs.size() == varlist_size() && "Number of destination "
1407 "expressions is not the same as "
1408 "the preallocated buffer");
1409 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
1412 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
1413 assert(AssignmentOps.size() == varlist_size() &&
1414 "Number of assignment expressions is not the same as the preallocated "
1416 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
1417 getDestinationExprs().end());
1420 OMPCopyinClause *OMPCopyinClause::Create(
1421 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1422 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
1423 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
1424 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
1425 llvm::alignOf<Expr *>()) +
1426 4 * sizeof(Expr *) * VL.size());
1427 OMPCopyinClause *Clause = new (Mem) OMPCopyinClause(StartLoc, LParenLoc,
1429 Clause->setVarRefs(VL);
1430 Clause->setSourceExprs(SrcExprs);
1431 Clause->setDestinationExprs(DstExprs);
1432 Clause->setAssignmentOps(AssignmentOps);
1436 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C,
1438 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
1439 llvm::alignOf<Expr *>()) +
1440 4 * sizeof(Expr *) * N);
1441 return new (Mem) OMPCopyinClause(N);
1444 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
1445 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
1446 "not the same as the "
1447 "preallocated buffer");
1448 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
1451 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
1452 assert(DstExprs.size() == varlist_size() && "Number of destination "
1453 "expressions is not the same as "
1454 "the preallocated buffer");
1455 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
1458 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
1459 assert(AssignmentOps.size() == varlist_size() &&
1460 "Number of assignment expressions is not the same as the preallocated "
1462 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
1463 getDestinationExprs().end());
1466 OMPCopyprivateClause *OMPCopyprivateClause::Create(
1467 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1468 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
1469 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
1470 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
1471 llvm::alignOf<Expr *>()) +
1472 4 * sizeof(Expr *) * VL.size());
1473 OMPCopyprivateClause *Clause =
1474 new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1475 Clause->setVarRefs(VL);
1476 Clause->setSourceExprs(SrcExprs);
1477 Clause->setDestinationExprs(DstExprs);
1478 Clause->setAssignmentOps(AssignmentOps);
1482 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
1484 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
1485 llvm::alignOf<Expr *>()) +
1486 4 * sizeof(Expr *) * N);
1487 return new (Mem) OMPCopyprivateClause(N);
1490 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
1491 assert(Clauses.size() == getNumClauses() &&
1492 "Number of clauses is not the same as the preallocated buffer");
1493 std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
1496 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
1497 assert(A.size() == getCollapsedNumber() &&
1498 "Number of loop counters is not the same as the collapsed number");
1499 std::copy(A.begin(), A.end(), getCounters().begin());
1502 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
1503 assert(A.size() == getCollapsedNumber() &&
1504 "Number of counter updates is not the same as the collapsed number");
1505 std::copy(A.begin(), A.end(), getUpdates().begin());
1508 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
1509 assert(A.size() == getCollapsedNumber() &&
1510 "Number of counter finals is not the same as the collapsed number");
1511 std::copy(A.begin(), A.end(), getFinals().begin());
1514 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
1516 LHSExprs.size() == varlist_size() &&
1517 "Number of LHS expressions is not the same as the preallocated buffer");
1518 std::copy(LHSExprs.begin(), LHSExprs.end(), varlist_end());
1521 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
1523 RHSExprs.size() == varlist_size() &&
1524 "Number of RHS expressions is not the same as the preallocated buffer");
1525 std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
1528 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
1529 assert(ReductionOps.size() == varlist_size() && "Number of reduction "
1530 "expressions is not the same "
1531 "as the preallocated buffer");
1532 std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
1535 OMPReductionClause *OMPReductionClause::Create(
1536 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1537 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
1538 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
1539 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
1540 ArrayRef<Expr *> ReductionOps) {
1541 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
1542 llvm::alignOf<Expr *>()) +
1543 4 * sizeof(Expr *) * VL.size());
1544 OMPReductionClause *Clause = new (Mem) OMPReductionClause(
1545 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
1546 Clause->setVarRefs(VL);
1547 Clause->setLHSExprs(LHSExprs);
1548 Clause->setRHSExprs(RHSExprs);
1549 Clause->setReductionOps(ReductionOps);
1553 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
1555 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
1556 llvm::alignOf<Expr *>()) +
1557 4 * sizeof(Expr *) * N);
1558 return new (Mem) OMPReductionClause(N);
1561 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
1562 SourceLocation StartLoc,
1563 SourceLocation LParenLoc,
1564 SourceLocation EndLoc,
1565 ArrayRef<Expr *> VL) {
1566 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
1567 llvm::alignOf<Expr *>()) +
1568 sizeof(Expr *) * VL.size());
1569 OMPFlushClause *Clause =
1570 new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
1571 Clause->setVarRefs(VL);
1575 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
1576 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
1577 llvm::alignOf<Expr *>()) +
1578 sizeof(Expr *) * N);
1579 return new (Mem) OMPFlushClause(N);
1583 OMPExecutableDirective::getSingleClause(OpenMPClauseKind K) const {
1584 auto &&I = getClausesOfKind(K);
1588 assert(!++I && "There are at least 2 clauses of the specified kind");
1594 OMPParallelDirective *OMPParallelDirective::Create(
1595 const ASTContext &C,
1596 SourceLocation StartLoc,
1597 SourceLocation EndLoc,
1598 ArrayRef<OMPClause *> Clauses,
1599 Stmt *AssociatedStmt) {
1600 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
1601 llvm::alignOf<OMPClause *>());
1602 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1604 OMPParallelDirective *Dir = new (Mem) OMPParallelDirective(StartLoc, EndLoc,
1606 Dir->setClauses(Clauses);
1607 Dir->setAssociatedStmt(AssociatedStmt);
1611 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
1612 unsigned NumClauses,
1614 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
1615 llvm::alignOf<OMPClause *>());
1616 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1618 return new (Mem) OMPParallelDirective(NumClauses);
1622 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1623 SourceLocation EndLoc, unsigned CollapsedNum,
1624 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1625 const HelperExprs &Exprs) {
1626 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
1627 llvm::alignOf<OMPClause *>());
1629 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1630 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
1631 OMPSimdDirective *Dir = new (Mem)
1632 OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1633 Dir->setClauses(Clauses);
1634 Dir->setAssociatedStmt(AssociatedStmt);
1635 Dir->setIterationVariable(Exprs.IterationVarRef);
1636 Dir->setLastIteration(Exprs.LastIteration);
1637 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1638 Dir->setPreCond(Exprs.PreCond);
1639 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1640 Dir->setInit(Exprs.Init);
1641 Dir->setInc(Exprs.Inc);
1642 Dir->setCounters(Exprs.Counters);
1643 Dir->setUpdates(Exprs.Updates);
1644 Dir->setFinals(Exprs.Finals);
1648 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
1649 unsigned NumClauses,
1650 unsigned CollapsedNum,
1652 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
1653 llvm::alignOf<OMPClause *>());
1655 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1656 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
1657 return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
1661 OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1662 SourceLocation EndLoc, unsigned CollapsedNum,
1663 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1664 const HelperExprs &Exprs) {
1665 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
1666 llvm::alignOf<OMPClause *>());
1668 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1669 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
1670 OMPForDirective *Dir =
1671 new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1672 Dir->setClauses(Clauses);
1673 Dir->setAssociatedStmt(AssociatedStmt);
1674 Dir->setIterationVariable(Exprs.IterationVarRef);
1675 Dir->setLastIteration(Exprs.LastIteration);
1676 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1677 Dir->setPreCond(Exprs.PreCond);
1678 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1679 Dir->setInit(Exprs.Init);
1680 Dir->setInc(Exprs.Inc);
1681 Dir->setIsLastIterVariable(Exprs.IL);
1682 Dir->setLowerBoundVariable(Exprs.LB);
1683 Dir->setUpperBoundVariable(Exprs.UB);
1684 Dir->setStrideVariable(Exprs.ST);
1685 Dir->setEnsureUpperBound(Exprs.EUB);
1686 Dir->setNextLowerBound(Exprs.NLB);
1687 Dir->setNextUpperBound(Exprs.NUB);
1688 Dir->setCounters(Exprs.Counters);
1689 Dir->setUpdates(Exprs.Updates);
1690 Dir->setFinals(Exprs.Finals);
1694 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
1695 unsigned NumClauses,
1696 unsigned CollapsedNum,
1698 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
1699 llvm::alignOf<OMPClause *>());
1701 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1702 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
1703 return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
1706 OMPForSimdDirective *
1707 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1708 SourceLocation EndLoc, unsigned CollapsedNum,
1709 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1710 const HelperExprs &Exprs) {
1711 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
1712 llvm::alignOf<OMPClause *>());
1714 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1715 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
1716 OMPForSimdDirective *Dir = new (Mem)
1717 OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1718 Dir->setClauses(Clauses);
1719 Dir->setAssociatedStmt(AssociatedStmt);
1720 Dir->setIterationVariable(Exprs.IterationVarRef);
1721 Dir->setLastIteration(Exprs.LastIteration);
1722 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1723 Dir->setPreCond(Exprs.PreCond);
1724 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1725 Dir->setInit(Exprs.Init);
1726 Dir->setInc(Exprs.Inc);
1727 Dir->setIsLastIterVariable(Exprs.IL);
1728 Dir->setLowerBoundVariable(Exprs.LB);
1729 Dir->setUpperBoundVariable(Exprs.UB);
1730 Dir->setStrideVariable(Exprs.ST);
1731 Dir->setEnsureUpperBound(Exprs.EUB);
1732 Dir->setNextLowerBound(Exprs.NLB);
1733 Dir->setNextUpperBound(Exprs.NUB);
1734 Dir->setCounters(Exprs.Counters);
1735 Dir->setUpdates(Exprs.Updates);
1736 Dir->setFinals(Exprs.Finals);
1740 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
1741 unsigned NumClauses,
1742 unsigned CollapsedNum,
1744 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
1745 llvm::alignOf<OMPClause *>());
1747 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1748 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
1749 return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
1752 OMPSectionsDirective *OMPSectionsDirective::Create(
1753 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1754 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1755 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
1756 llvm::alignOf<OMPClause *>());
1758 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1759 OMPSectionsDirective *Dir =
1760 new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
1761 Dir->setClauses(Clauses);
1762 Dir->setAssociatedStmt(AssociatedStmt);
1766 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
1767 unsigned NumClauses,
1769 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
1770 llvm::alignOf<OMPClause *>());
1772 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1773 return new (Mem) OMPSectionsDirective(NumClauses);
1776 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
1777 SourceLocation StartLoc,
1778 SourceLocation EndLoc,
1779 Stmt *AssociatedStmt) {
1780 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
1781 llvm::alignOf<Stmt *>());
1782 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1783 OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
1784 Dir->setAssociatedStmt(AssociatedStmt);
1788 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
1790 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
1791 llvm::alignOf<Stmt *>());
1792 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1793 return new (Mem) OMPSectionDirective();
1796 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
1797 SourceLocation StartLoc,
1798 SourceLocation EndLoc,
1799 ArrayRef<OMPClause *> Clauses,
1800 Stmt *AssociatedStmt) {
1801 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
1802 llvm::alignOf<OMPClause *>());
1804 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1805 OMPSingleDirective *Dir =
1806 new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
1807 Dir->setClauses(Clauses);
1808 Dir->setAssociatedStmt(AssociatedStmt);
1812 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
1813 unsigned NumClauses,
1815 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
1816 llvm::alignOf<OMPClause *>());
1818 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1819 return new (Mem) OMPSingleDirective(NumClauses);
1822 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
1823 SourceLocation StartLoc,
1824 SourceLocation EndLoc,
1825 Stmt *AssociatedStmt) {
1826 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
1827 llvm::alignOf<Stmt *>());
1828 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1829 OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
1830 Dir->setAssociatedStmt(AssociatedStmt);
1834 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
1836 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
1837 llvm::alignOf<Stmt *>());
1838 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1839 return new (Mem) OMPMasterDirective();
1842 OMPCriticalDirective *OMPCriticalDirective::Create(
1843 const ASTContext &C, const DeclarationNameInfo &Name,
1844 SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt) {
1845 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
1846 llvm::alignOf<Stmt *>());
1847 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1848 OMPCriticalDirective *Dir =
1849 new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc);
1850 Dir->setAssociatedStmt(AssociatedStmt);
1854 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
1856 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
1857 llvm::alignOf<Stmt *>());
1858 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1859 return new (Mem) OMPCriticalDirective();
1862 OMPParallelForDirective *OMPParallelForDirective::Create(
1863 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1864 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1865 const HelperExprs &Exprs) {
1866 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
1867 llvm::alignOf<OMPClause *>());
1868 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1870 numLoopChildren(CollapsedNum, OMPD_parallel_for));
1871 OMPParallelForDirective *Dir = new (Mem)
1872 OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1873 Dir->setClauses(Clauses);
1874 Dir->setAssociatedStmt(AssociatedStmt);
1875 Dir->setIterationVariable(Exprs.IterationVarRef);
1876 Dir->setLastIteration(Exprs.LastIteration);
1877 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1878 Dir->setPreCond(Exprs.PreCond);
1879 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1880 Dir->setInit(Exprs.Init);
1881 Dir->setInc(Exprs.Inc);
1882 Dir->setIsLastIterVariable(Exprs.IL);
1883 Dir->setLowerBoundVariable(Exprs.LB);
1884 Dir->setUpperBoundVariable(Exprs.UB);
1885 Dir->setStrideVariable(Exprs.ST);
1886 Dir->setEnsureUpperBound(Exprs.EUB);
1887 Dir->setNextLowerBound(Exprs.NLB);
1888 Dir->setNextUpperBound(Exprs.NUB);
1889 Dir->setCounters(Exprs.Counters);
1890 Dir->setUpdates(Exprs.Updates);
1891 Dir->setFinals(Exprs.Finals);
1895 OMPParallelForDirective *
1896 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1897 unsigned CollapsedNum, EmptyShell) {
1898 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
1899 llvm::alignOf<OMPClause *>());
1900 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1902 numLoopChildren(CollapsedNum, OMPD_parallel_for));
1903 return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
1906 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
1907 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1908 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1909 const HelperExprs &Exprs) {
1910 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
1911 llvm::alignOf<OMPClause *>());
1912 void *Mem = C.Allocate(
1913 Size + sizeof(OMPClause *) * Clauses.size() +
1914 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
1915 OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective(
1916 StartLoc, EndLoc, CollapsedNum, Clauses.size());
1917 Dir->setClauses(Clauses);
1918 Dir->setAssociatedStmt(AssociatedStmt);
1919 Dir->setIterationVariable(Exprs.IterationVarRef);
1920 Dir->setLastIteration(Exprs.LastIteration);
1921 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1922 Dir->setPreCond(Exprs.PreCond);
1923 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1924 Dir->setInit(Exprs.Init);
1925 Dir->setInc(Exprs.Inc);
1926 Dir->setIsLastIterVariable(Exprs.IL);
1927 Dir->setLowerBoundVariable(Exprs.LB);
1928 Dir->setUpperBoundVariable(Exprs.UB);
1929 Dir->setStrideVariable(Exprs.ST);
1930 Dir->setEnsureUpperBound(Exprs.EUB);
1931 Dir->setNextLowerBound(Exprs.NLB);
1932 Dir->setNextUpperBound(Exprs.NUB);
1933 Dir->setCounters(Exprs.Counters);
1934 Dir->setUpdates(Exprs.Updates);
1935 Dir->setFinals(Exprs.Finals);
1939 OMPParallelForSimdDirective *
1940 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1941 unsigned NumClauses,
1942 unsigned CollapsedNum, EmptyShell) {
1943 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
1944 llvm::alignOf<OMPClause *>());
1945 void *Mem = C.Allocate(
1946 Size + sizeof(OMPClause *) * NumClauses +
1947 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
1948 return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
1951 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
1952 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1953 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1954 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
1955 llvm::alignOf<OMPClause *>());
1957 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1958 OMPParallelSectionsDirective *Dir =
1959 new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
1960 Dir->setClauses(Clauses);
1961 Dir->setAssociatedStmt(AssociatedStmt);
1965 OMPParallelSectionsDirective *
1966 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
1967 unsigned NumClauses, EmptyShell) {
1968 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
1969 llvm::alignOf<OMPClause *>());
1971 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1972 return new (Mem) OMPParallelSectionsDirective(NumClauses);
1975 OMPTaskDirective *OMPTaskDirective::Create(const ASTContext &C,
1976 SourceLocation StartLoc,
1977 SourceLocation EndLoc,
1978 ArrayRef<OMPClause *> Clauses,
1979 Stmt *AssociatedStmt) {
1980 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
1981 llvm::alignOf<OMPClause *>());
1983 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1984 OMPTaskDirective *Dir =
1985 new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
1986 Dir->setClauses(Clauses);
1987 Dir->setAssociatedStmt(AssociatedStmt);
1991 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
1992 unsigned NumClauses,
1994 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
1995 llvm::alignOf<OMPClause *>());
1997 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1998 return new (Mem) OMPTaskDirective(NumClauses);
2001 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
2002 SourceLocation StartLoc,
2003 SourceLocation EndLoc) {
2004 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
2005 OMPTaskyieldDirective *Dir =
2006 new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
2010 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
2012 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
2013 return new (Mem) OMPTaskyieldDirective();
2016 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
2017 SourceLocation StartLoc,
2018 SourceLocation EndLoc) {
2019 void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
2020 OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
2024 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
2026 void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
2027 return new (Mem) OMPBarrierDirective();
2030 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
2031 SourceLocation StartLoc,
2032 SourceLocation EndLoc) {
2033 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
2034 OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
2038 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
2040 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
2041 return new (Mem) OMPTaskwaitDirective();
2044 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
2045 SourceLocation StartLoc,
2046 SourceLocation EndLoc,
2047 ArrayRef<OMPClause *> Clauses) {
2048 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
2049 llvm::alignOf<OMPClause *>());
2050 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
2051 OMPFlushDirective *Dir =
2052 new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
2053 Dir->setClauses(Clauses);
2057 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
2058 unsigned NumClauses,
2060 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
2061 llvm::alignOf<OMPClause *>());
2062 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
2063 return new (Mem) OMPFlushDirective(NumClauses);
2066 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
2067 SourceLocation StartLoc,
2068 SourceLocation EndLoc,
2069 Stmt *AssociatedStmt) {
2070 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
2071 llvm::alignOf<Stmt *>());
2072 void *Mem = C.Allocate(Size + sizeof(Stmt *));
2073 OMPOrderedDirective *Dir = new (Mem) OMPOrderedDirective(StartLoc, EndLoc);
2074 Dir->setAssociatedStmt(AssociatedStmt);
2078 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
2080 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
2081 llvm::alignOf<Stmt *>());
2082 void *Mem = C.Allocate(Size + sizeof(Stmt *));
2083 return new (Mem) OMPOrderedDirective();
2086 OMPAtomicDirective *OMPAtomicDirective::Create(
2087 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2088 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
2089 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
2090 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
2091 llvm::alignOf<OMPClause *>());
2092 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
2093 5 * sizeof(Stmt *));
2094 OMPAtomicDirective *Dir =
2095 new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
2096 Dir->setClauses(Clauses);
2097 Dir->setAssociatedStmt(AssociatedStmt);
2101 Dir->setUpdateExpr(UE);
2102 Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
2103 Dir->IsPostfixUpdate = IsPostfixUpdate;
2107 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
2108 unsigned NumClauses,
2110 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
2111 llvm::alignOf<OMPClause *>());
2113 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
2114 return new (Mem) OMPAtomicDirective(NumClauses);
2117 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
2118 SourceLocation StartLoc,
2119 SourceLocation EndLoc,
2120 ArrayRef<OMPClause *> Clauses,
2121 Stmt *AssociatedStmt) {
2122 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
2123 llvm::alignOf<OMPClause *>());
2125 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
2126 OMPTargetDirective *Dir =
2127 new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
2128 Dir->setClauses(Clauses);
2129 Dir->setAssociatedStmt(AssociatedStmt);
2133 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
2134 unsigned NumClauses,
2136 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
2137 llvm::alignOf<OMPClause *>());
2139 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
2140 return new (Mem) OMPTargetDirective(NumClauses);
2143 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
2144 SourceLocation StartLoc,
2145 SourceLocation EndLoc,
2146 ArrayRef<OMPClause *> Clauses,
2147 Stmt *AssociatedStmt) {
2148 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
2149 llvm::alignOf<OMPClause *>());
2151 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
2152 OMPTeamsDirective *Dir =
2153 new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
2154 Dir->setClauses(Clauses);
2155 Dir->setAssociatedStmt(AssociatedStmt);
2159 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
2160 unsigned NumClauses,
2162 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
2163 llvm::alignOf<OMPClause *>());
2165 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
2166 return new (Mem) OMPTeamsDirective(NumClauses);