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