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
getStmtInfoTableEntry(Stmt::StmtClass E)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
operator new(size_t bytes,const ASTContext & C,unsigned alignment)52 void *Stmt::operator new(size_t bytes, const ASTContext& C,
53 unsigned alignment) {
54 return ::operator new(bytes, C, alignment);
55 }
56
getStmtClassName() const57 const char *Stmt::getStmtClassName() const {
58 return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
59 }
60
PrintStats()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
addStmtClass(StmtClass s)86 void Stmt::addStmtClass(StmtClass s) {
87 ++getStmtInfoTableEntry(s).Counter;
88 }
89
90 bool Stmt::StatisticsEnabled = false;
EnableStatistics()91 void Stmt::EnableStatistics() {
92 StatisticsEnabled = true;
93 }
94
IgnoreImplicit()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.
IgnoreContainers(bool IgnoreCaptured)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.
stripLabelLikeStatements() const137 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.
is_good(good)158 static inline good is_good(good) { return good(); }
159
160 typedef Stmt::child_range children_t();
implements_children(children_t T::*)161 template <class T> good implements_children(children_t T::*) {
162 return good();
163 }
164 LLVM_ATTRIBUTE_UNUSED
implements_children(children_t Stmt::*)165 static inline bad implements_children(children_t Stmt::*) {
166 return bad();
167 }
168
169 typedef SourceLocation getLocStart_t() const;
implements_getLocStart(getLocStart_t T::*)170 template <class T> good implements_getLocStart(getLocStart_t T::*) {
171 return good();
172 }
173 LLVM_ATTRIBUTE_UNUSED
implements_getLocStart(getLocStart_t Stmt::*)174 static inline bad implements_getLocStart(getLocStart_t Stmt::*) {
175 return bad();
176 }
177
178 typedef SourceLocation getLocEnd_t() const;
implements_getLocEnd(getLocEnd_t T::*)179 template <class T> good implements_getLocEnd(getLocEnd_t T::*) {
180 return good();
181 }
182 LLVM_ATTRIBUTE_UNUSED
implements_getLocEnd(getLocEnd_t Stmt::*)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
check_implementations()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
children()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>
getSourceRangeImpl(const Stmt * stmt,SourceRange (T::* v)()const)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>
getSourceRangeImpl(const Stmt * stmt,SourceRange (Stmt::* v)()const)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
getSourceRange() const244 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
getLocStart() const256 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
getLocEnd() const269 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
CompoundStmt(const ASTContext & C,ArrayRef<Stmt * > Stmts,SourceLocation LB,SourceLocation RB)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
setStmts(const ASTContext & C,Stmt ** Stmts,unsigned NumStmts)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
getName() const307 const char *LabelStmt::getName() const {
308 return getDecl()->getIdentifier()->getNameStart();
309 }
310
Create(const ASTContext & C,SourceLocation Loc,ArrayRef<const Attr * > Attrs,Stmt * SubStmt)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
CreateEmpty(const ASTContext & C,unsigned NumAttrs)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
generateAsmString(const ASTContext & C) const328 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
getOutputConstraint(unsigned i) const336 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
getOutputExpr(unsigned i) const344 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
getInputConstraint(unsigned i) const352 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
getInputExpr(unsigned i) const360 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
getClobber(unsigned i) const368 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.
getNumPlusOperands() const378 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
getModifier() const386 char GCCAsmStmt::AsmStringPiece::getModifier() const {
387 assert(isOperand() && "Only Operands can have modifiers.");
388 return isLetter(Str[0]) ? Str[0] : '\0';
389 }
390
getClobber(unsigned i) const391 StringRef GCCAsmStmt::getClobber(unsigned i) const {
392 return getClobberStringLiteral(i)->getString();
393 }
394
getOutputExpr(unsigned i)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 '+').
getOutputConstraint(unsigned i) const402 StringRef GCCAsmStmt::getOutputConstraint(unsigned i) const {
403 return getOutputConstraintLiteral(i)->getString();
404 }
405
getInputExpr(unsigned i)406 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
407 return cast<Expr>(Exprs[i + NumOutputs]);
408 }
setInputExpr(unsigned i,Expr * E)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.
getInputConstraint(unsigned i) const415 StringRef GCCAsmStmt::getInputConstraint(unsigned i) const {
416 return getInputConstraintLiteral(i)->getString();
417 }
418
setOutputsAndInputsAndClobbers(const ASTContext & C,IdentifierInfo ** Names,StringLiteral ** Constraints,Stmt ** Exprs,unsigned NumOutputs,unsigned NumInputs,StringLiteral ** Clobbers,unsigned NumClobbers)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.
getNamedOperand(StringRef SymbolicName) const453 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.
AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> & Pieces,const ASTContext & C,unsigned & DiagOffs) const473 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).
generateAsmString(const ASTContext & C) const641 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).
generateAsmString(const ASTContext & C) const662 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
getOutputExpr(unsigned i)667 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
668 return cast<Expr>(Exprs[i]);
669 }
670
getInputExpr(unsigned i)671 Expr *MSAsmStmt::getInputExpr(unsigned i) {
672 return cast<Expr>(Exprs[i + NumOutputs]);
673 }
setInputExpr(unsigned i,Expr * E)674 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
675 Exprs[i + NumOutputs] = E;
676 }
677
getCaughtType() const678 QualType CXXCatchStmt::getCaughtType() const {
679 if (ExceptionDecl)
680 return ExceptionDecl->getType();
681 return QualType();
682 }
683
684 //===----------------------------------------------------------------------===//
685 // Constructors
686 //===----------------------------------------------------------------------===//
687
GCCAsmStmt(const ASTContext & C,SourceLocation asmloc,bool issimple,bool isvolatile,unsigned numoutputs,unsigned numinputs,IdentifierInfo ** names,StringLiteral ** constraints,Expr ** exprs,StringLiteral * asmstr,unsigned numclobbers,StringLiteral ** clobbers,SourceLocation rparenloc)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
MSAsmStmt(const ASTContext & C,SourceLocation asmloc,SourceLocation lbraceloc,bool issimple,bool isvolatile,ArrayRef<Token> asmtoks,unsigned numoutputs,unsigned numinputs,ArrayRef<StringRef> constraints,ArrayRef<Expr * > exprs,StringRef asmstr,ArrayRef<StringRef> clobbers,SourceLocation endloc)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
copyIntoContext(const ASTContext & C,StringRef str)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
initialize(const ASTContext & C,StringRef asmstr,ArrayRef<Token> asmtoks,ArrayRef<StringRef> constraints,ArrayRef<Expr * > exprs,ArrayRef<StringRef> clobbers)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
ObjCForCollectionStmt(Stmt * Elem,Expr * Collect,Stmt * Body,SourceLocation FCL,SourceLocation RPL)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
ObjCAtTryStmt(SourceLocation atTryLoc,Stmt * atTryStmt,Stmt ** CatchStmts,unsigned NumCatchStmts,Stmt * atFinallyStmt)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
Create(const ASTContext & Context,SourceLocation atTryLoc,Stmt * atTryStmt,Stmt ** CatchStmts,unsigned NumCatchStmts,Stmt * atFinallyStmt)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
CreateEmpty(const ASTContext & Context,unsigned NumCatchStmts,bool HasFinally)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
getLocEnd() const814 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
Create(const ASTContext & C,SourceLocation tryLoc,Stmt * tryBlock,ArrayRef<Stmt * > handlers)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
Create(const ASTContext & C,EmptyShell Empty,unsigned numHandlers)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
CXXTryStmt(SourceLocation tryLoc,Stmt * tryBlock,ArrayRef<Stmt * > handlers)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
CXXForRangeStmt(DeclStmt * Range,DeclStmt * BeginEndStmt,Expr * Cond,Expr * Inc,DeclStmt * LoopVar,Stmt * Body,SourceLocation FL,SourceLocation CL,SourceLocation RPL)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
getRangeInit()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
getRangeInit() const868 const Expr *CXXForRangeStmt::getRangeInit() const {
869 return const_cast<CXXForRangeStmt*>(this)->getRangeInit();
870 }
871
getLoopVariable()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
getLoopVariable() const878 const VarDecl *CXXForRangeStmt::getLoopVariable() const {
879 return const_cast<CXXForRangeStmt*>(this)->getLoopVariable();
880 }
881
IfStmt(const ASTContext & C,SourceLocation IL,VarDecl * var,Expr * cond,Stmt * then,SourceLocation EL,Stmt * elsev)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
getConditionVariable() const892 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
setConditionVariable(const ASTContext & C,VarDecl * V)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
ForStmt(const ASTContext & C,Stmt * Init,Expr * Cond,VarDecl * condVar,Expr * Inc,Stmt * Body,SourceLocation FL,SourceLocation LP,SourceLocation RP)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
getConditionVariable() const923 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
setConditionVariable(const ASTContext & C,VarDecl * V)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
SwitchStmt(const ASTContext & C,VarDecl * Var,Expr * cond)942 SwitchStmt::SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond)
943 : Stmt(SwitchStmtClass), FirstCase(nullptr, false) {
944 setConditionVariable(C, Var);
945 SubExprs[COND] = cond;
946 SubExprs[BODY] = nullptr;
947 }
948
getConditionVariable() const949 VarDecl *SwitchStmt::getConditionVariable() const {
950 if (!SubExprs[VAR])
951 return nullptr;
952
953 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
954 return cast<VarDecl>(DS->getSingleDecl());
955 }
956
setConditionVariable(const ASTContext & C,VarDecl * V)957 void SwitchStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
958 if (!V) {
959 SubExprs[VAR] = nullptr;
960 return;
961 }
962
963 SourceRange VarRange = V->getSourceRange();
964 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
965 VarRange.getEnd());
966 }
967
getSubStmt()968 Stmt *SwitchCase::getSubStmt() {
969 if (isa<CaseStmt>(this))
970 return cast<CaseStmt>(this)->getSubStmt();
971 return cast<DefaultStmt>(this)->getSubStmt();
972 }
973
WhileStmt(const ASTContext & C,VarDecl * Var,Expr * cond,Stmt * body,SourceLocation WL)974 WhileStmt::WhileStmt(const ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body,
975 SourceLocation WL)
976 : Stmt(WhileStmtClass) {
977 setConditionVariable(C, Var);
978 SubExprs[COND] = cond;
979 SubExprs[BODY] = body;
980 WhileLoc = WL;
981 }
982
getConditionVariable() const983 VarDecl *WhileStmt::getConditionVariable() const {
984 if (!SubExprs[VAR])
985 return nullptr;
986
987 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
988 return cast<VarDecl>(DS->getSingleDecl());
989 }
990
setConditionVariable(const ASTContext & C,VarDecl * V)991 void WhileStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
992 if (!V) {
993 SubExprs[VAR] = nullptr;
994 return;
995 }
996
997 SourceRange VarRange = V->getSourceRange();
998 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
999 VarRange.getEnd());
1000 }
1001
1002 // IndirectGotoStmt
getConstantTarget()1003 LabelDecl *IndirectGotoStmt::getConstantTarget() {
1004 if (AddrLabelExpr *E =
1005 dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
1006 return E->getLabel();
1007 return nullptr;
1008 }
1009
1010 // ReturnStmt
getRetValue() const1011 const Expr* ReturnStmt::getRetValue() const {
1012 return cast_or_null<Expr>(RetExpr);
1013 }
getRetValue()1014 Expr* ReturnStmt::getRetValue() {
1015 return cast_or_null<Expr>(RetExpr);
1016 }
1017
SEHTryStmt(bool IsCXXTry,SourceLocation TryLoc,Stmt * TryBlock,Stmt * Handler)1018 SEHTryStmt::SEHTryStmt(bool IsCXXTry,
1019 SourceLocation TryLoc,
1020 Stmt *TryBlock,
1021 Stmt *Handler)
1022 : Stmt(SEHTryStmtClass),
1023 IsCXXTry(IsCXXTry),
1024 TryLoc(TryLoc)
1025 {
1026 Children[TRY] = TryBlock;
1027 Children[HANDLER] = Handler;
1028 }
1029
Create(const ASTContext & C,bool IsCXXTry,SourceLocation TryLoc,Stmt * TryBlock,Stmt * Handler)1030 SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry,
1031 SourceLocation TryLoc, Stmt *TryBlock,
1032 Stmt *Handler) {
1033 return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
1034 }
1035
getExceptHandler() const1036 SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
1037 return dyn_cast<SEHExceptStmt>(getHandler());
1038 }
1039
getFinallyHandler() const1040 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
1041 return dyn_cast<SEHFinallyStmt>(getHandler());
1042 }
1043
SEHExceptStmt(SourceLocation Loc,Expr * FilterExpr,Stmt * Block)1044 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc,
1045 Expr *FilterExpr,
1046 Stmt *Block)
1047 : Stmt(SEHExceptStmtClass),
1048 Loc(Loc)
1049 {
1050 Children[FILTER_EXPR] = FilterExpr;
1051 Children[BLOCK] = Block;
1052 }
1053
Create(const ASTContext & C,SourceLocation Loc,Expr * FilterExpr,Stmt * Block)1054 SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc,
1055 Expr *FilterExpr, Stmt *Block) {
1056 return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
1057 }
1058
SEHFinallyStmt(SourceLocation Loc,Stmt * Block)1059 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc,
1060 Stmt *Block)
1061 : Stmt(SEHFinallyStmtClass),
1062 Loc(Loc),
1063 Block(Block)
1064 {}
1065
Create(const ASTContext & C,SourceLocation Loc,Stmt * Block)1066 SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc,
1067 Stmt *Block) {
1068 return new(C)SEHFinallyStmt(Loc,Block);
1069 }
1070
getStoredCaptures() const1071 CapturedStmt::Capture *CapturedStmt::getStoredCaptures() const {
1072 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1073
1074 // Offset of the first Capture object.
1075 unsigned FirstCaptureOffset =
1076 llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
1077
1078 return reinterpret_cast<Capture *>(
1079 reinterpret_cast<char *>(const_cast<CapturedStmt *>(this))
1080 + FirstCaptureOffset);
1081 }
1082
CapturedStmt(Stmt * S,CapturedRegionKind Kind,ArrayRef<Capture> Captures,ArrayRef<Expr * > CaptureInits,CapturedDecl * CD,RecordDecl * RD)1083 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
1084 ArrayRef<Capture> Captures,
1085 ArrayRef<Expr *> CaptureInits,
1086 CapturedDecl *CD,
1087 RecordDecl *RD)
1088 : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
1089 CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
1090 assert( S && "null captured statement");
1091 assert(CD && "null captured declaration for captured statement");
1092 assert(RD && "null record declaration for captured statement");
1093
1094 // Copy initialization expressions.
1095 Stmt **Stored = getStoredStmts();
1096 for (unsigned I = 0, N = NumCaptures; I != N; ++I)
1097 *Stored++ = CaptureInits[I];
1098
1099 // Copy the statement being captured.
1100 *Stored = S;
1101
1102 // Copy all Capture objects.
1103 Capture *Buffer = getStoredCaptures();
1104 std::copy(Captures.begin(), Captures.end(), Buffer);
1105 }
1106
CapturedStmt(EmptyShell Empty,unsigned NumCaptures)1107 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures)
1108 : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures),
1109 CapDeclAndKind(nullptr, CR_Default), TheRecordDecl(nullptr) {
1110 getStoredStmts()[NumCaptures] = nullptr;
1111 }
1112
Create(const ASTContext & Context,Stmt * S,CapturedRegionKind Kind,ArrayRef<Capture> Captures,ArrayRef<Expr * > CaptureInits,CapturedDecl * CD,RecordDecl * RD)1113 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S,
1114 CapturedRegionKind Kind,
1115 ArrayRef<Capture> Captures,
1116 ArrayRef<Expr *> CaptureInits,
1117 CapturedDecl *CD,
1118 RecordDecl *RD) {
1119 // The layout is
1120 //
1121 // -----------------------------------------------------------
1122 // | CapturedStmt, Init, ..., Init, S, Capture, ..., Capture |
1123 // ----------------^-------------------^----------------------
1124 // getStoredStmts() getStoredCaptures()
1125 //
1126 // where S is the statement being captured.
1127 //
1128 assert(CaptureInits.size() == Captures.size() && "wrong number of arguments");
1129
1130 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1);
1131 if (!Captures.empty()) {
1132 // Realign for the following Capture array.
1133 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
1134 Size += sizeof(Capture) * Captures.size();
1135 }
1136
1137 void *Mem = Context.Allocate(Size);
1138 return new (Mem) CapturedStmt(S, Kind, Captures, CaptureInits, CD, RD);
1139 }
1140
CreateDeserialized(const ASTContext & Context,unsigned NumCaptures)1141 CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context,
1142 unsigned NumCaptures) {
1143 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1144 if (NumCaptures > 0) {
1145 // Realign for the following Capture array.
1146 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>());
1147 Size += sizeof(Capture) * NumCaptures;
1148 }
1149
1150 void *Mem = Context.Allocate(Size);
1151 return new (Mem) CapturedStmt(EmptyShell(), NumCaptures);
1152 }
1153
children()1154 Stmt::child_range CapturedStmt::children() {
1155 // Children are captured field initilizers.
1156 return child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
1157 }
1158
capturesVariable(const VarDecl * Var) const1159 bool CapturedStmt::capturesVariable(const VarDecl *Var) const {
1160 for (const auto &I : captures()) {
1161 if (!I.capturesVariable())
1162 continue;
1163
1164 // This does not handle variable redeclarations. This should be
1165 // extended to capture variables with redeclarations, for example
1166 // a thread-private variable in OpenMP.
1167 if (I.getCapturedVar() == Var)
1168 return true;
1169 }
1170
1171 return false;
1172 }
1173
children()1174 StmtRange OMPClause::children() {
1175 switch(getClauseKind()) {
1176 default : break;
1177 #define OPENMP_CLAUSE(Name, Class) \
1178 case OMPC_ ## Name : return static_cast<Class *>(this)->children();
1179 #include "clang/Basic/OpenMPKinds.def"
1180 }
1181 llvm_unreachable("unknown OMPClause");
1182 }
1183
setPrivateCopies(ArrayRef<Expr * > VL)1184 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1185 assert(VL.size() == varlist_size() &&
1186 "Number of private copies is not the same as the preallocated buffer");
1187 std::copy(VL.begin(), VL.end(), varlist_end());
1188 }
1189
1190 OMPPrivateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PrivateVL)1191 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
1192 SourceLocation LParenLoc, SourceLocation EndLoc,
1193 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
1194 // Allocate space for private variables and initializer expressions.
1195 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
1196 llvm::alignOf<Expr *>()) +
1197 2 * sizeof(Expr *) * VL.size());
1198 OMPPrivateClause *Clause =
1199 new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1200 Clause->setVarRefs(VL);
1201 Clause->setPrivateCopies(PrivateVL);
1202 return Clause;
1203 }
1204
CreateEmpty(const ASTContext & C,unsigned N)1205 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
1206 unsigned N) {
1207 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
1208 llvm::alignOf<Expr *>()) +
1209 2 * sizeof(Expr *) * N);
1210 return new (Mem) OMPPrivateClause(N);
1211 }
1212
setPrivateCopies(ArrayRef<Expr * > VL)1213 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1214 assert(VL.size() == varlist_size() &&
1215 "Number of private copies is not the same as the preallocated buffer");
1216 std::copy(VL.begin(), VL.end(), varlist_end());
1217 }
1218
setInits(ArrayRef<Expr * > VL)1219 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
1220 assert(VL.size() == varlist_size() &&
1221 "Number of inits is not the same as the preallocated buffer");
1222 std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
1223 }
1224
1225 OMPFirstprivateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PrivateVL,ArrayRef<Expr * > InitVL)1226 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
1227 SourceLocation LParenLoc, SourceLocation EndLoc,
1228 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
1229 ArrayRef<Expr *> InitVL) {
1230 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
1231 llvm::alignOf<Expr *>()) +
1232 3 * sizeof(Expr *) * VL.size());
1233 OMPFirstprivateClause *Clause =
1234 new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1235 Clause->setVarRefs(VL);
1236 Clause->setPrivateCopies(PrivateVL);
1237 Clause->setInits(InitVL);
1238 return Clause;
1239 }
1240
CreateEmpty(const ASTContext & C,unsigned N)1241 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
1242 unsigned N) {
1243 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
1244 llvm::alignOf<Expr *>()) +
1245 3 * sizeof(Expr *) * N);
1246 return new (Mem) OMPFirstprivateClause(N);
1247 }
1248
setPrivateCopies(ArrayRef<Expr * > PrivateCopies)1249 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
1250 assert(PrivateCopies.size() == varlist_size() &&
1251 "Number of private copies is not the same as the preallocated buffer");
1252 std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
1253 }
1254
setSourceExprs(ArrayRef<Expr * > SrcExprs)1255 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
1256 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
1257 "not the same as the "
1258 "preallocated buffer");
1259 std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
1260 }
1261
setDestinationExprs(ArrayRef<Expr * > DstExprs)1262 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
1263 assert(DstExprs.size() == varlist_size() && "Number of destination "
1264 "expressions is not the same as "
1265 "the preallocated buffer");
1266 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
1267 }
1268
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)1269 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
1270 assert(AssignmentOps.size() == varlist_size() &&
1271 "Number of assignment expressions is not the same as the preallocated "
1272 "buffer");
1273 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
1274 getDestinationExprs().end());
1275 }
1276
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)1277 OMPLastprivateClause *OMPLastprivateClause::Create(
1278 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1279 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
1280 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
1281 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
1282 llvm::alignOf<Expr *>()) +
1283 5 * sizeof(Expr *) * VL.size());
1284 OMPLastprivateClause *Clause =
1285 new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1286 Clause->setVarRefs(VL);
1287 Clause->setSourceExprs(SrcExprs);
1288 Clause->setDestinationExprs(DstExprs);
1289 Clause->setAssignmentOps(AssignmentOps);
1290 return Clause;
1291 }
1292
CreateEmpty(const ASTContext & C,unsigned N)1293 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
1294 unsigned N) {
1295 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
1296 llvm::alignOf<Expr *>()) +
1297 5 * sizeof(Expr *) * N);
1298 return new (Mem) OMPLastprivateClause(N);
1299 }
1300
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)1301 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
1302 SourceLocation StartLoc,
1303 SourceLocation LParenLoc,
1304 SourceLocation EndLoc,
1305 ArrayRef<Expr *> VL) {
1306 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
1307 llvm::alignOf<Expr *>()) +
1308 sizeof(Expr *) * VL.size());
1309 OMPSharedClause *Clause = new (Mem) OMPSharedClause(StartLoc, LParenLoc,
1310 EndLoc, VL.size());
1311 Clause->setVarRefs(VL);
1312 return Clause;
1313 }
1314
CreateEmpty(const ASTContext & C,unsigned N)1315 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C,
1316 unsigned N) {
1317 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
1318 llvm::alignOf<Expr *>()) +
1319 sizeof(Expr *) * N);
1320 return new (Mem) OMPSharedClause(N);
1321 }
1322
setInits(ArrayRef<Expr * > IL)1323 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
1324 assert(IL.size() == varlist_size() &&
1325 "Number of inits is not the same as the preallocated buffer");
1326 std::copy(IL.begin(), IL.end(), varlist_end());
1327 }
1328
setUpdates(ArrayRef<Expr * > UL)1329 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
1330 assert(UL.size() == varlist_size() &&
1331 "Number of updates is not the same as the preallocated buffer");
1332 std::copy(UL.begin(), UL.end(), getInits().end());
1333 }
1334
setFinals(ArrayRef<Expr * > FL)1335 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
1336 assert(FL.size() == varlist_size() &&
1337 "Number of final updates is not the same as the preallocated buffer");
1338 std::copy(FL.begin(), FL.end(), getUpdates().end());
1339 }
1340
1341 OMPLinearClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > IL,Expr * Step,Expr * CalcStep)1342 OMPLinearClause::Create(const ASTContext &C, SourceLocation StartLoc,
1343 SourceLocation LParenLoc, SourceLocation ColonLoc,
1344 SourceLocation EndLoc, ArrayRef<Expr *> VL,
1345 ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep) {
1346 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
1347 // (Step and CalcStep).
1348 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
1349 llvm::alignOf<Expr *>()) +
1350 (4 * VL.size() + 2) * sizeof(Expr *));
1351 OMPLinearClause *Clause = new (Mem)
1352 OMPLinearClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
1353 Clause->setVarRefs(VL);
1354 Clause->setInits(IL);
1355 // Fill update and final expressions with zeroes, they are provided later,
1356 // after the directive construction.
1357 std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
1358 nullptr);
1359 std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
1360 nullptr);
1361 Clause->setStep(Step);
1362 Clause->setCalcStep(CalcStep);
1363 return Clause;
1364 }
1365
CreateEmpty(const ASTContext & C,unsigned NumVars)1366 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
1367 unsigned NumVars) {
1368 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
1369 // (Step and CalcStep).
1370 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
1371 llvm::alignOf<Expr *>()) +
1372 (4 * NumVars + 2) * sizeof(Expr *));
1373 return new (Mem) OMPLinearClause(NumVars);
1374 }
1375
1376 OMPAlignedClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,Expr * A)1377 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
1378 SourceLocation LParenLoc, SourceLocation ColonLoc,
1379 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
1380 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
1381 llvm::alignOf<Expr *>()) +
1382 sizeof(Expr *) * (VL.size() + 1));
1383 OMPAlignedClause *Clause = new (Mem)
1384 OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
1385 Clause->setVarRefs(VL);
1386 Clause->setAlignment(A);
1387 return Clause;
1388 }
1389
CreateEmpty(const ASTContext & C,unsigned NumVars)1390 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
1391 unsigned NumVars) {
1392 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
1393 llvm::alignOf<Expr *>()) +
1394 sizeof(Expr *) * (NumVars + 1));
1395 return new (Mem) OMPAlignedClause(NumVars);
1396 }
1397
setSourceExprs(ArrayRef<Expr * > SrcExprs)1398 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
1399 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
1400 "not the same as the "
1401 "preallocated buffer");
1402 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
1403 }
1404
setDestinationExprs(ArrayRef<Expr * > DstExprs)1405 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
1406 assert(DstExprs.size() == varlist_size() && "Number of destination "
1407 "expressions is not the same as "
1408 "the preallocated buffer");
1409 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
1410 }
1411
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)1412 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
1413 assert(AssignmentOps.size() == varlist_size() &&
1414 "Number of assignment expressions is not the same as the preallocated "
1415 "buffer");
1416 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
1417 getDestinationExprs().end());
1418 }
1419
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)1420 OMPCopyinClause *OMPCopyinClause::Create(
1421 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1422 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
1423 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
1424 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
1425 llvm::alignOf<Expr *>()) +
1426 4 * sizeof(Expr *) * VL.size());
1427 OMPCopyinClause *Clause = new (Mem) OMPCopyinClause(StartLoc, LParenLoc,
1428 EndLoc, VL.size());
1429 Clause->setVarRefs(VL);
1430 Clause->setSourceExprs(SrcExprs);
1431 Clause->setDestinationExprs(DstExprs);
1432 Clause->setAssignmentOps(AssignmentOps);
1433 return Clause;
1434 }
1435
CreateEmpty(const ASTContext & C,unsigned N)1436 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C,
1437 unsigned N) {
1438 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
1439 llvm::alignOf<Expr *>()) +
1440 4 * sizeof(Expr *) * N);
1441 return new (Mem) OMPCopyinClause(N);
1442 }
1443
setSourceExprs(ArrayRef<Expr * > SrcExprs)1444 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
1445 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
1446 "not the same as the "
1447 "preallocated buffer");
1448 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
1449 }
1450
setDestinationExprs(ArrayRef<Expr * > DstExprs)1451 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
1452 assert(DstExprs.size() == varlist_size() && "Number of destination "
1453 "expressions is not the same as "
1454 "the preallocated buffer");
1455 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
1456 }
1457
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)1458 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
1459 assert(AssignmentOps.size() == varlist_size() &&
1460 "Number of assignment expressions is not the same as the preallocated "
1461 "buffer");
1462 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
1463 getDestinationExprs().end());
1464 }
1465
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)1466 OMPCopyprivateClause *OMPCopyprivateClause::Create(
1467 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1468 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
1469 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
1470 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
1471 llvm::alignOf<Expr *>()) +
1472 4 * sizeof(Expr *) * VL.size());
1473 OMPCopyprivateClause *Clause =
1474 new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
1475 Clause->setVarRefs(VL);
1476 Clause->setSourceExprs(SrcExprs);
1477 Clause->setDestinationExprs(DstExprs);
1478 Clause->setAssignmentOps(AssignmentOps);
1479 return Clause;
1480 }
1481
CreateEmpty(const ASTContext & C,unsigned N)1482 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
1483 unsigned N) {
1484 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
1485 llvm::alignOf<Expr *>()) +
1486 4 * sizeof(Expr *) * N);
1487 return new (Mem) OMPCopyprivateClause(N);
1488 }
1489
setClauses(ArrayRef<OMPClause * > Clauses)1490 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
1491 assert(Clauses.size() == getNumClauses() &&
1492 "Number of clauses is not the same as the preallocated buffer");
1493 std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
1494 }
1495
setCounters(ArrayRef<Expr * > A)1496 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
1497 assert(A.size() == getCollapsedNumber() &&
1498 "Number of loop counters is not the same as the collapsed number");
1499 std::copy(A.begin(), A.end(), getCounters().begin());
1500 }
1501
setUpdates(ArrayRef<Expr * > A)1502 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
1503 assert(A.size() == getCollapsedNumber() &&
1504 "Number of counter updates is not the same as the collapsed number");
1505 std::copy(A.begin(), A.end(), getUpdates().begin());
1506 }
1507
setFinals(ArrayRef<Expr * > A)1508 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
1509 assert(A.size() == getCollapsedNumber() &&
1510 "Number of counter finals is not the same as the collapsed number");
1511 std::copy(A.begin(), A.end(), getFinals().begin());
1512 }
1513
setLHSExprs(ArrayRef<Expr * > LHSExprs)1514 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
1515 assert(
1516 LHSExprs.size() == varlist_size() &&
1517 "Number of LHS expressions is not the same as the preallocated buffer");
1518 std::copy(LHSExprs.begin(), LHSExprs.end(), varlist_end());
1519 }
1520
setRHSExprs(ArrayRef<Expr * > RHSExprs)1521 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
1522 assert(
1523 RHSExprs.size() == varlist_size() &&
1524 "Number of RHS expressions is not the same as the preallocated buffer");
1525 std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
1526 }
1527
setReductionOps(ArrayRef<Expr * > ReductionOps)1528 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
1529 assert(ReductionOps.size() == varlist_size() && "Number of reduction "
1530 "expressions is not the same "
1531 "as the preallocated buffer");
1532 std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
1533 }
1534
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VL,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo,ArrayRef<Expr * > LHSExprs,ArrayRef<Expr * > RHSExprs,ArrayRef<Expr * > ReductionOps)1535 OMPReductionClause *OMPReductionClause::Create(
1536 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
1537 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
1538 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
1539 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
1540 ArrayRef<Expr *> ReductionOps) {
1541 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
1542 llvm::alignOf<Expr *>()) +
1543 4 * sizeof(Expr *) * VL.size());
1544 OMPReductionClause *Clause = new (Mem) OMPReductionClause(
1545 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
1546 Clause->setVarRefs(VL);
1547 Clause->setLHSExprs(LHSExprs);
1548 Clause->setRHSExprs(RHSExprs);
1549 Clause->setReductionOps(ReductionOps);
1550 return Clause;
1551 }
1552
CreateEmpty(const ASTContext & C,unsigned N)1553 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
1554 unsigned N) {
1555 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
1556 llvm::alignOf<Expr *>()) +
1557 4 * sizeof(Expr *) * N);
1558 return new (Mem) OMPReductionClause(N);
1559 }
1560
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)1561 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
1562 SourceLocation StartLoc,
1563 SourceLocation LParenLoc,
1564 SourceLocation EndLoc,
1565 ArrayRef<Expr *> VL) {
1566 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
1567 llvm::alignOf<Expr *>()) +
1568 sizeof(Expr *) * VL.size());
1569 OMPFlushClause *Clause =
1570 new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
1571 Clause->setVarRefs(VL);
1572 return Clause;
1573 }
1574
CreateEmpty(const ASTContext & C,unsigned N)1575 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
1576 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
1577 llvm::alignOf<Expr *>()) +
1578 sizeof(Expr *) * N);
1579 return new (Mem) OMPFlushClause(N);
1580 }
1581
1582 const OMPClause *
getSingleClause(OpenMPClauseKind K) const1583 OMPExecutableDirective::getSingleClause(OpenMPClauseKind K) const {
1584 auto ClauseFilter =
1585 [=](const OMPClause *C) -> bool { return C->getClauseKind() == K; };
1586 OMPExecutableDirective::filtered_clause_iterator<decltype(ClauseFilter)> I(
1587 clauses(), ClauseFilter);
1588
1589 if (I) {
1590 auto *Clause = *I;
1591 assert(!++I && "There are at least 2 clauses of the specified kind");
1592 return Clause;
1593 }
1594 return nullptr;
1595 }
1596
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt)1597 OMPParallelDirective *OMPParallelDirective::Create(
1598 const ASTContext &C,
1599 SourceLocation StartLoc,
1600 SourceLocation EndLoc,
1601 ArrayRef<OMPClause *> Clauses,
1602 Stmt *AssociatedStmt) {
1603 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
1604 llvm::alignOf<OMPClause *>());
1605 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1606 sizeof(Stmt *));
1607 OMPParallelDirective *Dir = new (Mem) OMPParallelDirective(StartLoc, EndLoc,
1608 Clauses.size());
1609 Dir->setClauses(Clauses);
1610 Dir->setAssociatedStmt(AssociatedStmt);
1611 return Dir;
1612 }
1613
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)1614 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
1615 unsigned NumClauses,
1616 EmptyShell) {
1617 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
1618 llvm::alignOf<OMPClause *>());
1619 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1620 sizeof(Stmt *));
1621 return new (Mem) OMPParallelDirective(NumClauses);
1622 }
1623
1624 OMPSimdDirective *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,unsigned CollapsedNum,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt,const HelperExprs & Exprs)1625 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1626 SourceLocation EndLoc, unsigned CollapsedNum,
1627 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1628 const HelperExprs &Exprs) {
1629 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
1630 llvm::alignOf<OMPClause *>());
1631 void *Mem =
1632 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1633 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
1634 OMPSimdDirective *Dir = new (Mem)
1635 OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1636 Dir->setClauses(Clauses);
1637 Dir->setAssociatedStmt(AssociatedStmt);
1638 Dir->setIterationVariable(Exprs.IterationVarRef);
1639 Dir->setLastIteration(Exprs.LastIteration);
1640 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1641 Dir->setPreCond(Exprs.PreCond);
1642 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1643 Dir->setInit(Exprs.Init);
1644 Dir->setInc(Exprs.Inc);
1645 Dir->setCounters(Exprs.Counters);
1646 Dir->setUpdates(Exprs.Updates);
1647 Dir->setFinals(Exprs.Finals);
1648 return Dir;
1649 }
1650
CreateEmpty(const ASTContext & C,unsigned NumClauses,unsigned CollapsedNum,EmptyShell)1651 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
1652 unsigned NumClauses,
1653 unsigned CollapsedNum,
1654 EmptyShell) {
1655 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
1656 llvm::alignOf<OMPClause *>());
1657 void *Mem =
1658 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1659 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
1660 return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
1661 }
1662
1663 OMPForDirective *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,unsigned CollapsedNum,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt,const HelperExprs & Exprs)1664 OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1665 SourceLocation EndLoc, unsigned CollapsedNum,
1666 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1667 const HelperExprs &Exprs) {
1668 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
1669 llvm::alignOf<OMPClause *>());
1670 void *Mem =
1671 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1672 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
1673 OMPForDirective *Dir =
1674 new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1675 Dir->setClauses(Clauses);
1676 Dir->setAssociatedStmt(AssociatedStmt);
1677 Dir->setIterationVariable(Exprs.IterationVarRef);
1678 Dir->setLastIteration(Exprs.LastIteration);
1679 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1680 Dir->setPreCond(Exprs.PreCond);
1681 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1682 Dir->setInit(Exprs.Init);
1683 Dir->setInc(Exprs.Inc);
1684 Dir->setIsLastIterVariable(Exprs.IL);
1685 Dir->setLowerBoundVariable(Exprs.LB);
1686 Dir->setUpperBoundVariable(Exprs.UB);
1687 Dir->setStrideVariable(Exprs.ST);
1688 Dir->setEnsureUpperBound(Exprs.EUB);
1689 Dir->setNextLowerBound(Exprs.NLB);
1690 Dir->setNextUpperBound(Exprs.NUB);
1691 Dir->setCounters(Exprs.Counters);
1692 Dir->setUpdates(Exprs.Updates);
1693 Dir->setFinals(Exprs.Finals);
1694 return Dir;
1695 }
1696
CreateEmpty(const ASTContext & C,unsigned NumClauses,unsigned CollapsedNum,EmptyShell)1697 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
1698 unsigned NumClauses,
1699 unsigned CollapsedNum,
1700 EmptyShell) {
1701 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
1702 llvm::alignOf<OMPClause *>());
1703 void *Mem =
1704 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1705 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
1706 return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
1707 }
1708
1709 OMPForSimdDirective *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,unsigned CollapsedNum,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt,const HelperExprs & Exprs)1710 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1711 SourceLocation EndLoc, unsigned CollapsedNum,
1712 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1713 const HelperExprs &Exprs) {
1714 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
1715 llvm::alignOf<OMPClause *>());
1716 void *Mem =
1717 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1718 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
1719 OMPForSimdDirective *Dir = new (Mem)
1720 OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1721 Dir->setClauses(Clauses);
1722 Dir->setAssociatedStmt(AssociatedStmt);
1723 Dir->setIterationVariable(Exprs.IterationVarRef);
1724 Dir->setLastIteration(Exprs.LastIteration);
1725 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1726 Dir->setPreCond(Exprs.PreCond);
1727 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1728 Dir->setInit(Exprs.Init);
1729 Dir->setInc(Exprs.Inc);
1730 Dir->setIsLastIterVariable(Exprs.IL);
1731 Dir->setLowerBoundVariable(Exprs.LB);
1732 Dir->setUpperBoundVariable(Exprs.UB);
1733 Dir->setStrideVariable(Exprs.ST);
1734 Dir->setEnsureUpperBound(Exprs.EUB);
1735 Dir->setNextLowerBound(Exprs.NLB);
1736 Dir->setNextUpperBound(Exprs.NUB);
1737 Dir->setCounters(Exprs.Counters);
1738 Dir->setUpdates(Exprs.Updates);
1739 Dir->setFinals(Exprs.Finals);
1740 return Dir;
1741 }
1742
CreateEmpty(const ASTContext & C,unsigned NumClauses,unsigned CollapsedNum,EmptyShell)1743 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
1744 unsigned NumClauses,
1745 unsigned CollapsedNum,
1746 EmptyShell) {
1747 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
1748 llvm::alignOf<OMPClause *>());
1749 void *Mem =
1750 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1751 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
1752 return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
1753 }
1754
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt)1755 OMPSectionsDirective *OMPSectionsDirective::Create(
1756 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1757 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1758 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
1759 llvm::alignOf<OMPClause *>());
1760 void *Mem =
1761 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1762 OMPSectionsDirective *Dir =
1763 new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
1764 Dir->setClauses(Clauses);
1765 Dir->setAssociatedStmt(AssociatedStmt);
1766 return Dir;
1767 }
1768
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)1769 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
1770 unsigned NumClauses,
1771 EmptyShell) {
1772 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
1773 llvm::alignOf<OMPClause *>());
1774 void *Mem =
1775 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1776 return new (Mem) OMPSectionsDirective(NumClauses);
1777 }
1778
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,Stmt * AssociatedStmt)1779 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
1780 SourceLocation StartLoc,
1781 SourceLocation EndLoc,
1782 Stmt *AssociatedStmt) {
1783 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
1784 llvm::alignOf<Stmt *>());
1785 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1786 OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
1787 Dir->setAssociatedStmt(AssociatedStmt);
1788 return Dir;
1789 }
1790
CreateEmpty(const ASTContext & C,EmptyShell)1791 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
1792 EmptyShell) {
1793 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
1794 llvm::alignOf<Stmt *>());
1795 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1796 return new (Mem) OMPSectionDirective();
1797 }
1798
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt)1799 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
1800 SourceLocation StartLoc,
1801 SourceLocation EndLoc,
1802 ArrayRef<OMPClause *> Clauses,
1803 Stmt *AssociatedStmt) {
1804 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
1805 llvm::alignOf<OMPClause *>());
1806 void *Mem =
1807 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1808 OMPSingleDirective *Dir =
1809 new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
1810 Dir->setClauses(Clauses);
1811 Dir->setAssociatedStmt(AssociatedStmt);
1812 return Dir;
1813 }
1814
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)1815 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
1816 unsigned NumClauses,
1817 EmptyShell) {
1818 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
1819 llvm::alignOf<OMPClause *>());
1820 void *Mem =
1821 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1822 return new (Mem) OMPSingleDirective(NumClauses);
1823 }
1824
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,Stmt * AssociatedStmt)1825 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
1826 SourceLocation StartLoc,
1827 SourceLocation EndLoc,
1828 Stmt *AssociatedStmt) {
1829 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
1830 llvm::alignOf<Stmt *>());
1831 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1832 OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
1833 Dir->setAssociatedStmt(AssociatedStmt);
1834 return Dir;
1835 }
1836
CreateEmpty(const ASTContext & C,EmptyShell)1837 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
1838 EmptyShell) {
1839 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
1840 llvm::alignOf<Stmt *>());
1841 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1842 return new (Mem) OMPMasterDirective();
1843 }
1844
Create(const ASTContext & C,const DeclarationNameInfo & Name,SourceLocation StartLoc,SourceLocation EndLoc,Stmt * AssociatedStmt)1845 OMPCriticalDirective *OMPCriticalDirective::Create(
1846 const ASTContext &C, const DeclarationNameInfo &Name,
1847 SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt) {
1848 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
1849 llvm::alignOf<Stmt *>());
1850 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1851 OMPCriticalDirective *Dir =
1852 new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc);
1853 Dir->setAssociatedStmt(AssociatedStmt);
1854 return Dir;
1855 }
1856
CreateEmpty(const ASTContext & C,EmptyShell)1857 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
1858 EmptyShell) {
1859 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
1860 llvm::alignOf<Stmt *>());
1861 void *Mem = C.Allocate(Size + sizeof(Stmt *));
1862 return new (Mem) OMPCriticalDirective();
1863 }
1864
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,unsigned CollapsedNum,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt,const HelperExprs & Exprs)1865 OMPParallelForDirective *OMPParallelForDirective::Create(
1866 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1867 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1868 const HelperExprs &Exprs) {
1869 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
1870 llvm::alignOf<OMPClause *>());
1871 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1872 sizeof(Stmt *) *
1873 numLoopChildren(CollapsedNum, OMPD_parallel_for));
1874 OMPParallelForDirective *Dir = new (Mem)
1875 OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1876 Dir->setClauses(Clauses);
1877 Dir->setAssociatedStmt(AssociatedStmt);
1878 Dir->setIterationVariable(Exprs.IterationVarRef);
1879 Dir->setLastIteration(Exprs.LastIteration);
1880 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1881 Dir->setPreCond(Exprs.PreCond);
1882 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1883 Dir->setInit(Exprs.Init);
1884 Dir->setInc(Exprs.Inc);
1885 Dir->setIsLastIterVariable(Exprs.IL);
1886 Dir->setLowerBoundVariable(Exprs.LB);
1887 Dir->setUpperBoundVariable(Exprs.UB);
1888 Dir->setStrideVariable(Exprs.ST);
1889 Dir->setEnsureUpperBound(Exprs.EUB);
1890 Dir->setNextLowerBound(Exprs.NLB);
1891 Dir->setNextUpperBound(Exprs.NUB);
1892 Dir->setCounters(Exprs.Counters);
1893 Dir->setUpdates(Exprs.Updates);
1894 Dir->setFinals(Exprs.Finals);
1895 return Dir;
1896 }
1897
1898 OMPParallelForDirective *
CreateEmpty(const ASTContext & C,unsigned NumClauses,unsigned CollapsedNum,EmptyShell)1899 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1900 unsigned CollapsedNum, EmptyShell) {
1901 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
1902 llvm::alignOf<OMPClause *>());
1903 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1904 sizeof(Stmt *) *
1905 numLoopChildren(CollapsedNum, OMPD_parallel_for));
1906 return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
1907 }
1908
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,unsigned CollapsedNum,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt,const HelperExprs & Exprs)1909 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
1910 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1911 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1912 const HelperExprs &Exprs) {
1913 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
1914 llvm::alignOf<OMPClause *>());
1915 void *Mem = C.Allocate(
1916 Size + sizeof(OMPClause *) * Clauses.size() +
1917 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
1918 OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective(
1919 StartLoc, EndLoc, CollapsedNum, Clauses.size());
1920 Dir->setClauses(Clauses);
1921 Dir->setAssociatedStmt(AssociatedStmt);
1922 Dir->setIterationVariable(Exprs.IterationVarRef);
1923 Dir->setLastIteration(Exprs.LastIteration);
1924 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1925 Dir->setPreCond(Exprs.PreCond);
1926 Dir->setCond(Exprs.Cond, Exprs.SeparatedCond);
1927 Dir->setInit(Exprs.Init);
1928 Dir->setInc(Exprs.Inc);
1929 Dir->setIsLastIterVariable(Exprs.IL);
1930 Dir->setLowerBoundVariable(Exprs.LB);
1931 Dir->setUpperBoundVariable(Exprs.UB);
1932 Dir->setStrideVariable(Exprs.ST);
1933 Dir->setEnsureUpperBound(Exprs.EUB);
1934 Dir->setNextLowerBound(Exprs.NLB);
1935 Dir->setNextUpperBound(Exprs.NUB);
1936 Dir->setCounters(Exprs.Counters);
1937 Dir->setUpdates(Exprs.Updates);
1938 Dir->setFinals(Exprs.Finals);
1939 return Dir;
1940 }
1941
1942 OMPParallelForSimdDirective *
CreateEmpty(const ASTContext & C,unsigned NumClauses,unsigned CollapsedNum,EmptyShell)1943 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1944 unsigned NumClauses,
1945 unsigned CollapsedNum, EmptyShell) {
1946 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
1947 llvm::alignOf<OMPClause *>());
1948 void *Mem = C.Allocate(
1949 Size + sizeof(OMPClause *) * NumClauses +
1950 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
1951 return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
1952 }
1953
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt)1954 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
1955 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1956 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1957 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
1958 llvm::alignOf<OMPClause *>());
1959 void *Mem =
1960 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1961 OMPParallelSectionsDirective *Dir =
1962 new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
1963 Dir->setClauses(Clauses);
1964 Dir->setAssociatedStmt(AssociatedStmt);
1965 return Dir;
1966 }
1967
1968 OMPParallelSectionsDirective *
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)1969 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
1970 unsigned NumClauses, EmptyShell) {
1971 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
1972 llvm::alignOf<OMPClause *>());
1973 void *Mem =
1974 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1975 return new (Mem) OMPParallelSectionsDirective(NumClauses);
1976 }
1977
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt)1978 OMPTaskDirective *OMPTaskDirective::Create(const ASTContext &C,
1979 SourceLocation StartLoc,
1980 SourceLocation EndLoc,
1981 ArrayRef<OMPClause *> Clauses,
1982 Stmt *AssociatedStmt) {
1983 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
1984 llvm::alignOf<OMPClause *>());
1985 void *Mem =
1986 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1987 OMPTaskDirective *Dir =
1988 new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
1989 Dir->setClauses(Clauses);
1990 Dir->setAssociatedStmt(AssociatedStmt);
1991 return Dir;
1992 }
1993
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)1994 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
1995 unsigned NumClauses,
1996 EmptyShell) {
1997 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
1998 llvm::alignOf<OMPClause *>());
1999 void *Mem =
2000 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
2001 return new (Mem) OMPTaskDirective(NumClauses);
2002 }
2003
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc)2004 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
2005 SourceLocation StartLoc,
2006 SourceLocation EndLoc) {
2007 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
2008 OMPTaskyieldDirective *Dir =
2009 new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
2010 return Dir;
2011 }
2012
CreateEmpty(const ASTContext & C,EmptyShell)2013 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
2014 EmptyShell) {
2015 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
2016 return new (Mem) OMPTaskyieldDirective();
2017 }
2018
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc)2019 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
2020 SourceLocation StartLoc,
2021 SourceLocation EndLoc) {
2022 void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
2023 OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
2024 return Dir;
2025 }
2026
CreateEmpty(const ASTContext & C,EmptyShell)2027 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
2028 EmptyShell) {
2029 void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
2030 return new (Mem) OMPBarrierDirective();
2031 }
2032
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc)2033 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
2034 SourceLocation StartLoc,
2035 SourceLocation EndLoc) {
2036 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
2037 OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
2038 return Dir;
2039 }
2040
CreateEmpty(const ASTContext & C,EmptyShell)2041 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
2042 EmptyShell) {
2043 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
2044 return new (Mem) OMPTaskwaitDirective();
2045 }
2046
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses)2047 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
2048 SourceLocation StartLoc,
2049 SourceLocation EndLoc,
2050 ArrayRef<OMPClause *> Clauses) {
2051 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
2052 llvm::alignOf<OMPClause *>());
2053 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
2054 OMPFlushDirective *Dir =
2055 new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
2056 Dir->setClauses(Clauses);
2057 return Dir;
2058 }
2059
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)2060 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
2061 unsigned NumClauses,
2062 EmptyShell) {
2063 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
2064 llvm::alignOf<OMPClause *>());
2065 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
2066 return new (Mem) OMPFlushDirective(NumClauses);
2067 }
2068
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,Stmt * AssociatedStmt)2069 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
2070 SourceLocation StartLoc,
2071 SourceLocation EndLoc,
2072 Stmt *AssociatedStmt) {
2073 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
2074 llvm::alignOf<Stmt *>());
2075 void *Mem = C.Allocate(Size + sizeof(Stmt *));
2076 OMPOrderedDirective *Dir = new (Mem) OMPOrderedDirective(StartLoc, EndLoc);
2077 Dir->setAssociatedStmt(AssociatedStmt);
2078 return Dir;
2079 }
2080
CreateEmpty(const ASTContext & C,EmptyShell)2081 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
2082 EmptyShell) {
2083 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
2084 llvm::alignOf<Stmt *>());
2085 void *Mem = C.Allocate(Size + sizeof(Stmt *));
2086 return new (Mem) OMPOrderedDirective();
2087 }
2088
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt,Expr * X,Expr * V,Expr * E,Expr * UE,bool IsXLHSInRHSPart,bool IsPostfixUpdate)2089 OMPAtomicDirective *OMPAtomicDirective::Create(
2090 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2091 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
2092 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
2093 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
2094 llvm::alignOf<OMPClause *>());
2095 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
2096 5 * sizeof(Stmt *));
2097 OMPAtomicDirective *Dir =
2098 new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
2099 Dir->setClauses(Clauses);
2100 Dir->setAssociatedStmt(AssociatedStmt);
2101 Dir->setX(X);
2102 Dir->setV(V);
2103 Dir->setExpr(E);
2104 Dir->setUpdateExpr(UE);
2105 Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
2106 Dir->IsPostfixUpdate = IsPostfixUpdate;
2107 return Dir;
2108 }
2109
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)2110 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
2111 unsigned NumClauses,
2112 EmptyShell) {
2113 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
2114 llvm::alignOf<OMPClause *>());
2115 void *Mem =
2116 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
2117 return new (Mem) OMPAtomicDirective(NumClauses);
2118 }
2119
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt)2120 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
2121 SourceLocation StartLoc,
2122 SourceLocation EndLoc,
2123 ArrayRef<OMPClause *> Clauses,
2124 Stmt *AssociatedStmt) {
2125 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
2126 llvm::alignOf<OMPClause *>());
2127 void *Mem =
2128 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
2129 OMPTargetDirective *Dir =
2130 new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
2131 Dir->setClauses(Clauses);
2132 Dir->setAssociatedStmt(AssociatedStmt);
2133 return Dir;
2134 }
2135
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)2136 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
2137 unsigned NumClauses,
2138 EmptyShell) {
2139 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
2140 llvm::alignOf<OMPClause *>());
2141 void *Mem =
2142 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
2143 return new (Mem) OMPTargetDirective(NumClauses);
2144 }
2145
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc,ArrayRef<OMPClause * > Clauses,Stmt * AssociatedStmt)2146 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
2147 SourceLocation StartLoc,
2148 SourceLocation EndLoc,
2149 ArrayRef<OMPClause *> Clauses,
2150 Stmt *AssociatedStmt) {
2151 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
2152 llvm::alignOf<OMPClause *>());
2153 void *Mem =
2154 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
2155 OMPTeamsDirective *Dir =
2156 new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
2157 Dir->setClauses(Clauses);
2158 Dir->setAssociatedStmt(AssociatedStmt);
2159 return Dir;
2160 }
2161
CreateEmpty(const ASTContext & C,unsigned NumClauses,EmptyShell)2162 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
2163 unsigned NumClauses,
2164 EmptyShell) {
2165 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
2166 llvm::alignOf<OMPClause *>());
2167 void *Mem =
2168 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
2169 return new (Mem) OMPTeamsDirective(NumClauses);
2170 }
2171
2172