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