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