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