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