Stmt.cpp revision 235633 
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"
24using namespace clang;
25
26static struct StmtClassNameTable {
27  const char *Name;
28  unsigned Counter;
29  unsigned Size;
30} StmtClassInfo[Stmt::lastStmtConstant+1];
31
32static 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
48const char *Stmt::getStmtClassName() const {
49  return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
50}
51
52void 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
77void Stmt::addStmtClass(StmtClass s) {
78  ++getStmtInfoTableEntry(s).Counter;
79}
80
81bool Stmt::StatisticsEnabled = false;
82void Stmt::EnableStatistics() {
83  StatisticsEnabled = true;
84}
85
86Stmt *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.
102const 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
116namespace {
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.
149static 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
157Stmt::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
169SourceRange 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().
185namespace {
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
223SourceLocation 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
235SourceLocation 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
247void 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
256const 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
261SourceRange ReturnStmt::getSourceRange() const {
262  if (RetExpr)
263    return SourceRange(RetLoc, RetExpr->getLocEnd());
264  else
265    return SourceRange(RetLoc);
266}
267
268bool 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
290Expr *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 '+').
297StringRef 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.
303unsigned 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
311Expr *AsmStmt::getInputExpr(unsigned i) {
312  return cast<Expr>(Exprs[i + NumOutputs]);
313}
314void 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.
321StringRef AsmStmt::getInputConstraint(unsigned i) const {
322  return getInputConstraintLiteral(i)->getString();
323}
324
325
326void 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.
360int 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.
380unsigned 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
518QualType CXXCatchStmt::getCaughtType() const {
519  if (ExceptionDecl)
520    return ExceptionDecl->getType();
521  return QualType();
522}
523
524//===----------------------------------------------------------------------===//
525// Constructors
526//===----------------------------------------------------------------------===//
527
528AsmStmt::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
553ObjCForCollectionStmt::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
564ObjCAtTryStmt::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
579ObjCAtTryStmt *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
592ObjCAtTryStmt *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
601SourceRange 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
613CXXTryStmt *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
623CXXTryStmt *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
632CXXTryStmt::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
640CXXForRangeStmt::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
653Expr *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
660const Expr *CXXForRangeStmt::getRangeInit() const {
661  return const_cast<CXXForRangeStmt*>(this)->getRangeInit();
662}
663
664VarDecl *CXXForRangeStmt::getLoopVariable() {
665  Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
666  assert(LV && "No loop variable in CXXForRangeStmt");
667  return cast<VarDecl>(LV);
668}
669
670const VarDecl *CXXForRangeStmt::getLoopVariable() const {
671  return const_cast<CXXForRangeStmt*>(this)->getLoopVariable();
672}
673
674IfStmt::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
684VarDecl *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
692void 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
703ForStmt::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
715VarDecl *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
723void 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
734SwitchStmt::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
742VarDecl *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
750void 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
761Stmt *SwitchCase::getSubStmt() {
762  if (isa<CaseStmt>(this))
763    return cast<CaseStmt>(this)->getSubStmt();
764  return cast<DefaultStmt>(this)->getSubStmt();
765}
766
767WhileStmt::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
776VarDecl *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
784void 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
796LabelDecl *IndirectGotoStmt::getConstantTarget() {
797  if (AddrLabelExpr *E =
798        dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
799    return E->getLabel();
800  return 0;
801}
802
803// ReturnStmt
804const Expr* ReturnStmt::getRetValue() const {
805  return cast_or_null<Expr>(RetExpr);
806}
807Expr* ReturnStmt::getRetValue() {
808  return cast_or_null<Expr>(RetExpr);
809}
810
811SEHTryStmt::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
823SEHTryStmt* 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
831SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
832  return dyn_cast<SEHExceptStmt>(getHandler());
833}
834
835SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
836  return dyn_cast<SEHFinallyStmt>(getHandler());
837}
838
839SEHExceptStmt::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
849SEHExceptStmt* SEHExceptStmt::Create(ASTContext &C,
850                                     SourceLocation Loc,
851                                     Expr *FilterExpr,
852                                     Stmt *Block) {
853  return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
854}
855
856SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc,
857                               Stmt *Block)
858  : Stmt(SEHFinallyStmtClass),
859    Loc(Loc),
860    Block(Block)
861{}
862
863SEHFinallyStmt* SEHFinallyStmt::Create(ASTContext &C,
864                                       SourceLocation Loc,
865                                       Stmt *Block) {
866  return new(C)SEHFinallyStmt(Loc,Block);
867}
868