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 while (1) { 507 // Done with the string? 508 if (CurPtr == StrEnd) { 509 if (!CurStringPiece.empty()) 510 Pieces.push_back(AsmStringPiece(CurStringPiece)); 511 return 0; 512 } 513 514 char CurChar = *CurPtr++; 515 switch (CurChar) { 516 case '$': CurStringPiece += "$$"; continue; 517 case '{': CurStringPiece += (HasVariants ? "$(" : "{"); continue; 518 case '|': CurStringPiece += (HasVariants ? "$|" : "|"); continue; 519 case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue; 520 case '%': 521 break; 522 default: 523 CurStringPiece += CurChar; 524 continue; 525 } 526 527 // Escaped "%" character in asm string. 528 if (CurPtr == StrEnd) { 529 // % at end of string is invalid (no escape). 530 DiagOffs = CurPtr-StrStart-1; 531 return diag::err_asm_invalid_escape; 532 } 533 534 char EscapedChar = *CurPtr++; 535 if (EscapedChar == '%') { // %% -> % 536 // Escaped percentage sign. 537 CurStringPiece += '%'; 538 continue; 539 } 540 541 if (EscapedChar == '=') { // %= -> Generate an unique ID. 542 CurStringPiece += "${:uid}"; 543 continue; 544 } 545 546 // Otherwise, we have an operand. If we have accumulated a string so far, 547 // add it to the Pieces list. 548 if (!CurStringPiece.empty()) { 549 Pieces.push_back(AsmStringPiece(CurStringPiece)); 550 CurStringPiece.clear(); 551 } 552 553 // Handle operands that have asmSymbolicName (e.g., %x[foo]) and those that 554 // don't (e.g., %x4). 'x' following the '%' is the constraint modifier. 555 556 const char *Begin = CurPtr - 1; // Points to the character following '%'. 557 const char *Percent = Begin - 1; // Points to '%'. 558 559 if (isLetter(EscapedChar)) { 560 if (CurPtr == StrEnd) { // Premature end. 561 DiagOffs = CurPtr-StrStart-1; 562 return diag::err_asm_invalid_escape; 563 } 564 EscapedChar = *CurPtr++; 565 } 566 567 const TargetInfo &TI = C.getTargetInfo(); 568 const SourceManager &SM = C.getSourceManager(); 569 const LangOptions &LO = C.getLangOpts(); 570 571 // Handle operands that don't have asmSymbolicName (e.g., %x4). 572 if (isDigit(EscapedChar)) { 573 // %n - Assembler operand n 574 unsigned N = 0; 575 576 --CurPtr; 577 while (CurPtr != StrEnd && isDigit(*CurPtr)) 578 N = N*10 + ((*CurPtr++)-'0'); 579 580 unsigned NumOperands = 581 getNumOutputs() + getNumPlusOperands() + getNumInputs(); 582 if (N >= NumOperands) { 583 DiagOffs = CurPtr-StrStart-1; 584 return diag::err_asm_invalid_operand_number; 585 } 586 587 // Str contains "x4" (Operand without the leading %). 588 std::string Str(Begin, CurPtr - Begin); 589 590 // (BeginLoc, EndLoc) represents the range of the operand we are currently 591 // processing. Unlike Str, the range includes the leading '%'. 592 SourceLocation BeginLoc = 593 getAsmString()->getLocationOfByte(Percent - StrStart, SM, LO, TI); 594 SourceLocation EndLoc = 595 getAsmString()->getLocationOfByte(CurPtr - StrStart, SM, LO, TI); 596 597 Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc); 598 continue; 599 } 600 601 // Handle operands that have asmSymbolicName (e.g., %x[foo]). 602 if (EscapedChar == '[') { 603 DiagOffs = CurPtr-StrStart-1; 604 605 // Find the ']'. 606 const char *NameEnd = (const char*)memchr(CurPtr, ']', StrEnd-CurPtr); 607 if (NameEnd == nullptr) 608 return diag::err_asm_unterminated_symbolic_operand_name; 609 if (NameEnd == CurPtr) 610 return diag::err_asm_empty_symbolic_operand_name; 611 612 StringRef SymbolicName(CurPtr, NameEnd - CurPtr); 613 614 int N = getNamedOperand(SymbolicName); 615 if (N == -1) { 616 // Verify that an operand with that name exists. 617 DiagOffs = CurPtr-StrStart; 618 return diag::err_asm_unknown_symbolic_operand_name; 619 } 620 621 // Str contains "x[foo]" (Operand without the leading %). 622 std::string Str(Begin, NameEnd + 1 - Begin); 623 624 // (BeginLoc, EndLoc) represents the range of the operand we are currently 625 // processing. Unlike Str, the range includes the leading '%'. 626 SourceLocation BeginLoc = 627 getAsmString()->getLocationOfByte(Percent - StrStart, SM, LO, TI); 628 SourceLocation EndLoc = 629 getAsmString()->getLocationOfByte(NameEnd + 1 - StrStart, SM, LO, TI); 630 631 Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc); 632 633 CurPtr = NameEnd+1; 634 continue; 635 } 636 637 DiagOffs = CurPtr-StrStart-1; 638 return diag::err_asm_invalid_escape; 639 } 640 } 641 642 /// Assemble final IR asm string (GCC-style). 643 std::string GCCAsmStmt::generateAsmString(const ASTContext &C) const { 644 // Analyze the asm string to decompose it into its pieces. We know that Sema 645 // has already done this, so it is guaranteed to be successful. 646 SmallVector<GCCAsmStmt::AsmStringPiece, 4> Pieces; 647 unsigned DiagOffs; 648 AnalyzeAsmString(Pieces, C, DiagOffs); 649 650 std::string AsmString; 651 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) { 652 if (Pieces[i].isString()) 653 AsmString += Pieces[i].getString(); 654 else if (Pieces[i].getModifier() == '\0') 655 AsmString += '$' + llvm::utostr(Pieces[i].getOperandNo()); 656 else 657 AsmString += "${" + llvm::utostr(Pieces[i].getOperandNo()) + ':' + 658 Pieces[i].getModifier() + '}'; 659 } 660 return AsmString; 661 } 662 663 /// Assemble final IR asm string (MS-style). 664 std::string MSAsmStmt::generateAsmString(const ASTContext &C) const { 665 // FIXME: This needs to be translated into the IR string representation. 666 return AsmStr; 667 } 668 669 Expr *MSAsmStmt::getOutputExpr(unsigned i) { 670 return cast<Expr>(Exprs[i]); 671 } 672 673 Expr *MSAsmStmt::getInputExpr(unsigned i) { 674 return cast<Expr>(Exprs[i + NumOutputs]); 675 } 676 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) { 677 Exprs[i + NumOutputs] = E; 678 } 679 680 //===----------------------------------------------------------------------===// 681 // Constructors 682 //===----------------------------------------------------------------------===// 683 684 GCCAsmStmt::GCCAsmStmt(const ASTContext &C, SourceLocation asmloc, 685 bool issimple, bool isvolatile, unsigned numoutputs, 686 unsigned numinputs, IdentifierInfo **names, 687 StringLiteral **constraints, Expr **exprs, 688 StringLiteral *asmstr, unsigned numclobbers, 689 StringLiteral **clobbers, SourceLocation rparenloc) 690 : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs, 691 numinputs, numclobbers), RParenLoc(rparenloc), AsmStr(asmstr) { 692 693 unsigned NumExprs = NumOutputs + NumInputs; 694 695 Names = new (C) IdentifierInfo*[NumExprs]; 696 std::copy(names, names + NumExprs, Names); 697 698 Exprs = new (C) Stmt*[NumExprs]; 699 std::copy(exprs, exprs + NumExprs, Exprs); 700 701 Constraints = new (C) StringLiteral*[NumExprs]; 702 std::copy(constraints, constraints + NumExprs, Constraints); 703 704 Clobbers = new (C) StringLiteral*[NumClobbers]; 705 std::copy(clobbers, clobbers + NumClobbers, Clobbers); 706 } 707 708 MSAsmStmt::MSAsmStmt(const ASTContext &C, SourceLocation asmloc, 709 SourceLocation lbraceloc, bool issimple, bool isvolatile, 710 ArrayRef<Token> asmtoks, unsigned numoutputs, 711 unsigned numinputs, 712 ArrayRef<StringRef> constraints, ArrayRef<Expr*> exprs, 713 StringRef asmstr, ArrayRef<StringRef> clobbers, 714 SourceLocation endloc) 715 : AsmStmt(MSAsmStmtClass, asmloc, issimple, isvolatile, numoutputs, 716 numinputs, clobbers.size()), LBraceLoc(lbraceloc), 717 EndLoc(endloc), NumAsmToks(asmtoks.size()) { 718 719 initialize(C, asmstr, asmtoks, constraints, exprs, clobbers); 720 } 721 722 static StringRef copyIntoContext(const ASTContext &C, StringRef str) { 723 return str.copy(C); 724 } 725 726 void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr, 727 ArrayRef<Token> asmtoks, 728 ArrayRef<StringRef> constraints, 729 ArrayRef<Expr*> exprs, 730 ArrayRef<StringRef> clobbers) { 731 assert(NumAsmToks == asmtoks.size()); 732 assert(NumClobbers == clobbers.size()); 733 734 assert(exprs.size() == NumOutputs + NumInputs); 735 assert(exprs.size() == constraints.size()); 736 737 AsmStr = copyIntoContext(C, asmstr); 738 739 Exprs = new (C) Stmt*[exprs.size()]; 740 std::copy(exprs.begin(), exprs.end(), Exprs); 741 742 AsmToks = new (C) Token[asmtoks.size()]; 743 std::copy(asmtoks.begin(), asmtoks.end(), AsmToks); 744 745 Constraints = new (C) StringRef[exprs.size()]; 746 std::transform(constraints.begin(), constraints.end(), Constraints, 747 [&](StringRef Constraint) { 748 return copyIntoContext(C, Constraint); 749 }); 750 751 Clobbers = new (C) StringRef[NumClobbers]; 752 // FIXME: Avoid the allocation/copy if at all possible. 753 std::transform(clobbers.begin(), clobbers.end(), Clobbers, 754 [&](StringRef Clobber) { 755 return copyIntoContext(C, Clobber); 756 }); 757 } 758 759 IfStmt::IfStmt(const ASTContext &C, SourceLocation IL, VarDecl *var, Expr *cond, 760 Stmt *then, SourceLocation EL, Stmt *elsev) 761 : Stmt(IfStmtClass), IfLoc(IL), ElseLoc(EL) 762 { 763 setConditionVariable(C, var); 764 SubExprs[COND] = cond; 765 SubExprs[THEN] = then; 766 SubExprs[ELSE] = elsev; 767 } 768 769 VarDecl *IfStmt::getConditionVariable() const { 770 if (!SubExprs[VAR]) 771 return nullptr; 772 773 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]); 774 return cast<VarDecl>(DS->getSingleDecl()); 775 } 776 777 void IfStmt::setConditionVariable(const ASTContext &C, VarDecl *V) { 778 if (!V) { 779 SubExprs[VAR] = nullptr; 780 return; 781 } 782 783 SourceRange VarRange = V->getSourceRange(); 784 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), 785 VarRange.getEnd()); 786 } 787 788 ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar, 789 Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP, 790 SourceLocation RP) 791 : Stmt(ForStmtClass), ForLoc(FL), LParenLoc(LP), RParenLoc(RP) 792 { 793 SubExprs[INIT] = Init; 794 setConditionVariable(C, condVar); 795 SubExprs[COND] = Cond; 796 SubExprs[INC] = Inc; 797 SubExprs[BODY] = Body; 798 } 799 800 VarDecl *ForStmt::getConditionVariable() const { 801 if (!SubExprs[CONDVAR]) 802 return nullptr; 803 804 DeclStmt *DS = cast<DeclStmt>(SubExprs[CONDVAR]); 805 return cast<VarDecl>(DS->getSingleDecl()); 806 } 807 808 void ForStmt::setConditionVariable(const ASTContext &C, VarDecl *V) { 809 if (!V) { 810 SubExprs[CONDVAR] = nullptr; 811 return; 812 } 813 814 SourceRange VarRange = V->getSourceRange(); 815 SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), 816 VarRange.getEnd()); 817 } 818 819 SwitchStmt::SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond) 820 : Stmt(SwitchStmtClass), FirstCase(nullptr, false) { 821 setConditionVariable(C, Var); 822 SubExprs[COND] = cond; 823 SubExprs[BODY] = nullptr; 824 } 825 826 VarDecl *SwitchStmt::getConditionVariable() const { 827 if (!SubExprs[VAR]) 828 return nullptr; 829 830 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]); 831 return cast<VarDecl>(DS->getSingleDecl()); 832 } 833 834 void SwitchStmt::setConditionVariable(const ASTContext &C, VarDecl *V) { 835 if (!V) { 836 SubExprs[VAR] = nullptr; 837 return; 838 } 839 840 SourceRange VarRange = V->getSourceRange(); 841 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), 842 VarRange.getEnd()); 843 } 844 845 Stmt *SwitchCase::getSubStmt() { 846 if (isa<CaseStmt>(this)) 847 return cast<CaseStmt>(this)->getSubStmt(); 848 return cast<DefaultStmt>(this)->getSubStmt(); 849 } 850 851 WhileStmt::WhileStmt(const ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body, 852 SourceLocation WL) 853 : Stmt(WhileStmtClass) { 854 setConditionVariable(C, Var); 855 SubExprs[COND] = cond; 856 SubExprs[BODY] = body; 857 WhileLoc = WL; 858 } 859 860 VarDecl *WhileStmt::getConditionVariable() const { 861 if (!SubExprs[VAR]) 862 return nullptr; 863 864 DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]); 865 return cast<VarDecl>(DS->getSingleDecl()); 866 } 867 868 void WhileStmt::setConditionVariable(const ASTContext &C, VarDecl *V) { 869 if (!V) { 870 SubExprs[VAR] = nullptr; 871 return; 872 } 873 874 SourceRange VarRange = V->getSourceRange(); 875 SubExprs[VAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), 876 VarRange.getEnd()); 877 } 878 879 // IndirectGotoStmt 880 LabelDecl *IndirectGotoStmt::getConstantTarget() { 881 if (AddrLabelExpr *E = 882 dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts())) 883 return E->getLabel(); 884 return nullptr; 885 } 886 887 // ReturnStmt 888 const Expr* ReturnStmt::getRetValue() const { 889 return cast_or_null<Expr>(RetExpr); 890 } 891 Expr* ReturnStmt::getRetValue() { 892 return cast_or_null<Expr>(RetExpr); 893 } 894 895 SEHTryStmt::SEHTryStmt(bool IsCXXTry, 896 SourceLocation TryLoc, 897 Stmt *TryBlock, 898 Stmt *Handler) 899 : Stmt(SEHTryStmtClass), 900 IsCXXTry(IsCXXTry), 901 TryLoc(TryLoc) 902 { 903 Children[TRY] = TryBlock; 904 Children[HANDLER] = Handler; 905 } 906 907 SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry, 908 SourceLocation TryLoc, Stmt *TryBlock, 909 Stmt *Handler) { 910 return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler); 911 } 912 913 SEHExceptStmt* SEHTryStmt::getExceptHandler() const { 914 return dyn_cast<SEHExceptStmt>(getHandler()); 915 } 916 917 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const { 918 return dyn_cast<SEHFinallyStmt>(getHandler()); 919 } 920 921 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc, 922 Expr *FilterExpr, 923 Stmt *Block) 924 : Stmt(SEHExceptStmtClass), 925 Loc(Loc) 926 { 927 Children[FILTER_EXPR] = FilterExpr; 928 Children[BLOCK] = Block; 929 } 930 931 SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc, 932 Expr *FilterExpr, Stmt *Block) { 933 return new(C) SEHExceptStmt(Loc,FilterExpr,Block); 934 } 935 936 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc, 937 Stmt *Block) 938 : Stmt(SEHFinallyStmtClass), 939 Loc(Loc), 940 Block(Block) 941 {} 942 943 SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc, 944 Stmt *Block) { 945 return new(C)SEHFinallyStmt(Loc,Block); 946 } 947 948 CapturedStmt::Capture::Capture(SourceLocation Loc, VariableCaptureKind Kind, 949 VarDecl *Var) 950 : VarAndKind(Var, Kind), Loc(Loc) { 951 switch (Kind) { 952 case VCK_This: 953 assert(!Var && "'this' capture cannot have a variable!"); 954 break; 955 case VCK_ByRef: 956 assert(Var && "capturing by reference must have a variable!"); 957 break; 958 case VCK_ByCopy: 959 assert(Var && "capturing by copy must have a variable!"); 960 assert( 961 (Var->getType()->isScalarType() || (Var->getType()->isReferenceType() && 962 Var->getType() 963 ->castAs<ReferenceType>() 964 ->getPointeeType() 965 ->isScalarType())) && 966 "captures by copy are expected to have a scalar type!"); 967 break; 968 case VCK_VLAType: 969 assert(!Var && 970 "Variable-length array type capture cannot have a variable!"); 971 break; 972 } 973 } 974 975 CapturedStmt::Capture *CapturedStmt::getStoredCaptures() const { 976 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1); 977 978 // Offset of the first Capture object. 979 unsigned FirstCaptureOffset = 980 llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>()); 981 982 return reinterpret_cast<Capture *>( 983 reinterpret_cast<char *>(const_cast<CapturedStmt *>(this)) 984 + FirstCaptureOffset); 985 } 986 987 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind, 988 ArrayRef<Capture> Captures, 989 ArrayRef<Expr *> CaptureInits, 990 CapturedDecl *CD, 991 RecordDecl *RD) 992 : Stmt(CapturedStmtClass), NumCaptures(Captures.size()), 993 CapDeclAndKind(CD, Kind), TheRecordDecl(RD) { 994 assert( S && "null captured statement"); 995 assert(CD && "null captured declaration for captured statement"); 996 assert(RD && "null record declaration for captured statement"); 997 998 // Copy initialization expressions. 999 Stmt **Stored = getStoredStmts(); 1000 for (unsigned I = 0, N = NumCaptures; I != N; ++I) 1001 *Stored++ = CaptureInits[I]; 1002 1003 // Copy the statement being captured. 1004 *Stored = S; 1005 1006 // Copy all Capture objects. 1007 Capture *Buffer = getStoredCaptures(); 1008 std::copy(Captures.begin(), Captures.end(), Buffer); 1009 } 1010 1011 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures) 1012 : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures), 1013 CapDeclAndKind(nullptr, CR_Default), TheRecordDecl(nullptr) { 1014 getStoredStmts()[NumCaptures] = nullptr; 1015 } 1016 1017 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S, 1018 CapturedRegionKind Kind, 1019 ArrayRef<Capture> Captures, 1020 ArrayRef<Expr *> CaptureInits, 1021 CapturedDecl *CD, 1022 RecordDecl *RD) { 1023 // The layout is 1024 // 1025 // ----------------------------------------------------------- 1026 // | CapturedStmt, Init, ..., Init, S, Capture, ..., Capture | 1027 // ----------------^-------------------^---------------------- 1028 // getStoredStmts() getStoredCaptures() 1029 // 1030 // where S is the statement being captured. 1031 // 1032 assert(CaptureInits.size() == Captures.size() && "wrong number of arguments"); 1033 1034 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1); 1035 if (!Captures.empty()) { 1036 // Realign for the following Capture array. 1037 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>()); 1038 Size += sizeof(Capture) * Captures.size(); 1039 } 1040 1041 void *Mem = Context.Allocate(Size); 1042 return new (Mem) CapturedStmt(S, Kind, Captures, CaptureInits, CD, RD); 1043 } 1044 1045 CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context, 1046 unsigned NumCaptures) { 1047 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1); 1048 if (NumCaptures > 0) { 1049 // Realign for the following Capture array. 1050 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<Capture>()); 1051 Size += sizeof(Capture) * NumCaptures; 1052 } 1053 1054 void *Mem = Context.Allocate(Size); 1055 return new (Mem) CapturedStmt(EmptyShell(), NumCaptures); 1056 } 1057 1058 Stmt::child_range CapturedStmt::children() { 1059 // Children are captured field initilizers. 1060 return child_range(getStoredStmts(), getStoredStmts() + NumCaptures); 1061 } 1062 1063 bool CapturedStmt::capturesVariable(const VarDecl *Var) const { 1064 for (const auto &I : captures()) { 1065 if (!I.capturesVariable()) 1066 continue; 1067 1068 // This does not handle variable redeclarations. This should be 1069 // extended to capture variables with redeclarations, for example 1070 // a thread-private variable in OpenMP. 1071 if (I.getCapturedVar() == Var) 1072 return true; 1073 } 1074 1075 return false; 1076 } 1077