SemaStmt.cpp revision bec224b33b383c993d127ef7f618ce27df7105e6 
1//===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
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 semantic analysis for statements.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Sema/SemaInternal.h"
15#include "clang/Sema/Scope.h"
16#include "clang/Sema/ScopeInfo.h"
17#include "clang/Sema/Initialization.h"
18#include "clang/Sema/Lookup.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/CharUnits.h"
21#include "clang/AST/DeclObjC.h"
22#include "clang/AST/EvaluatedExprVisitor.h"
23#include "clang/AST/ExprCXX.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/StmtObjC.h"
26#include "clang/AST/StmtCXX.h"
27#include "clang/AST/TypeLoc.h"
28#include "clang/Lex/Preprocessor.h"
29#include "clang/Basic/TargetInfo.h"
30#include "llvm/ADT/ArrayRef.h"
31#include "llvm/ADT/STLExtras.h"
32#include "llvm/ADT/SmallPtrSet.h"
33#include "llvm/ADT/SmallString.h"
34#include "llvm/ADT/SmallVector.h"
35#include "llvm/ADT/Triple.h"
36#include "llvm/MC/MCAsmInfo.h"
37#include "llvm/MC/MCContext.h"
38#include "llvm/MC/MCInst.h"
39#include "llvm/MC/MCInstPrinter.h"
40#include "llvm/MC/MCInstrInfo.h"
41#include "llvm/MC/MCObjectFileInfo.h"
42#include "llvm/MC/MCRegisterInfo.h"
43#include "llvm/MC/MCStreamer.h"
44#include "llvm/MC/MCSubtargetInfo.h"
45#include "llvm/MC/MCTargetAsmParser.h"
46#include "llvm/MC/MCParser/MCAsmLexer.h"
47#include "llvm/MC/MCParser/MCAsmParser.h"
48#include "llvm/Support/SourceMgr.h"
49#include "llvm/Support/TargetRegistry.h"
50#include "llvm/Support/TargetSelect.h"
51using namespace clang;
52using namespace sema;
53
54StmtResult Sema::ActOnExprStmt(FullExprArg expr) {
55  Expr *E = expr.get();
56  if (!E) // FIXME: FullExprArg has no error state?
57    return StmtError();
58
59  // C99 6.8.3p2: The expression in an expression statement is evaluated as a
60  // void expression for its side effects.  Conversion to void allows any
61  // operand, even incomplete types.
62
63  // Same thing in for stmt first clause (when expr) and third clause.
64  return Owned(static_cast<Stmt*>(E));
65}
66
67
68StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
69                               bool HasLeadingEmptyMacro) {
70  return Owned(new (Context) NullStmt(SemiLoc, HasLeadingEmptyMacro));
71}
72
73StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
74                               SourceLocation EndLoc) {
75  DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
76
77  // If we have an invalid decl, just return an error.
78  if (DG.isNull()) return StmtError();
79
80  return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
81}
82
83void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
84  DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
85
86  // If we have an invalid decl, just return.
87  if (DG.isNull() || !DG.isSingleDecl()) return;
88  VarDecl *var = cast<VarDecl>(DG.getSingleDecl());
89
90  // suppress any potential 'unused variable' warning.
91  var->setUsed();
92
93  // foreach variables are never actually initialized in the way that
94  // the parser came up with.
95  var->setInit(0);
96
97  // In ARC, we don't need to retain the iteration variable of a fast
98  // enumeration loop.  Rather than actually trying to catch that
99  // during declaration processing, we remove the consequences here.
100  if (getLangOpts().ObjCAutoRefCount) {
101    QualType type = var->getType();
102
103    // Only do this if we inferred the lifetime.  Inferred lifetime
104    // will show up as a local qualifier because explicit lifetime
105    // should have shown up as an AttributedType instead.
106    if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) {
107      // Add 'const' and mark the variable as pseudo-strong.
108      var->setType(type.withConst());
109      var->setARCPseudoStrong(true);
110    }
111  }
112}
113
114/// \brief Diagnose unused '==' and '!=' as likely typos for '=' or '|='.
115///
116/// Adding a cast to void (or other expression wrappers) will prevent the
117/// warning from firing.
118static bool DiagnoseUnusedComparison(Sema &S, const Expr *E) {
119  SourceLocation Loc;
120  bool IsNotEqual, CanAssign;
121
122  if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
123    if (Op->getOpcode() != BO_EQ && Op->getOpcode() != BO_NE)
124      return false;
125
126    Loc = Op->getOperatorLoc();
127    IsNotEqual = Op->getOpcode() == BO_NE;
128    CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();
129  } else if (const CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
130    if (Op->getOperator() != OO_EqualEqual &&
131        Op->getOperator() != OO_ExclaimEqual)
132      return false;
133
134    Loc = Op->getOperatorLoc();
135    IsNotEqual = Op->getOperator() == OO_ExclaimEqual;
136    CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
137  } else {
138    // Not a typo-prone comparison.
139    return false;
140  }
141
142  // Suppress warnings when the operator, suspicious as it may be, comes from
143  // a macro expansion.
144  if (Loc.isMacroID())
145    return false;
146
147  S.Diag(Loc, diag::warn_unused_comparison)
148    << (unsigned)IsNotEqual << E->getSourceRange();
149
150  // If the LHS is a plausible entity to assign to, provide a fixit hint to
151  // correct common typos.
152  if (CanAssign) {
153    if (IsNotEqual)
154      S.Diag(Loc, diag::note_inequality_comparison_to_or_assign)
155        << FixItHint::CreateReplacement(Loc, "|=");
156    else
157      S.Diag(Loc, diag::note_equality_comparison_to_assign)
158        << FixItHint::CreateReplacement(Loc, "=");
159  }
160
161  return true;
162}
163
164void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
165  if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
166    return DiagnoseUnusedExprResult(Label->getSubStmt());
167
168  const Expr *E = dyn_cast_or_null<Expr>(S);
169  if (!E)
170    return;
171
172  const Expr *WarnExpr;
173  SourceLocation Loc;
174  SourceRange R1, R2;
175  if (SourceMgr.isInSystemMacro(E->getExprLoc()) ||
176      !E->isUnusedResultAWarning(WarnExpr, Loc, R1, R2, Context))
177    return;
178
179  // Okay, we have an unused result.  Depending on what the base expression is,
180  // we might want to make a more specific diagnostic.  Check for one of these
181  // cases now.
182  unsigned DiagID = diag::warn_unused_expr;
183  if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E))
184    E = Temps->getSubExpr();
185  if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
186    E = TempExpr->getSubExpr();
187
188  if (DiagnoseUnusedComparison(*this, E))
189    return;
190
191  E = WarnExpr;
192  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
193    if (E->getType()->isVoidType())
194      return;
195
196    // If the callee has attribute pure, const, or warn_unused_result, warn with
197    // a more specific message to make it clear what is happening.
198    if (const Decl *FD = CE->getCalleeDecl()) {
199      if (FD->getAttr<WarnUnusedResultAttr>()) {
200        Diag(Loc, diag::warn_unused_result) << R1 << R2;
201        return;
202      }
203      if (FD->getAttr<PureAttr>()) {
204        Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
205        return;
206      }
207      if (FD->getAttr<ConstAttr>()) {
208        Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
209        return;
210      }
211    }
212  } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
213    if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
214      Diag(Loc, diag::err_arc_unused_init_message) << R1;
215      return;
216    }
217    const ObjCMethodDecl *MD = ME->getMethodDecl();
218    if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
219      Diag(Loc, diag::warn_unused_result) << R1 << R2;
220      return;
221    }
222  } else if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
223    const Expr *Source = POE->getSyntacticForm();
224    if (isa<ObjCSubscriptRefExpr>(Source))
225      DiagID = diag::warn_unused_container_subscript_expr;
226    else
227      DiagID = diag::warn_unused_property_expr;
228  } else if (const CXXFunctionalCastExpr *FC
229                                       = dyn_cast<CXXFunctionalCastExpr>(E)) {
230    if (isa<CXXConstructExpr>(FC->getSubExpr()) ||
231        isa<CXXTemporaryObjectExpr>(FC->getSubExpr()))
232      return;
233  }
234  // Diagnose "(void*) blah" as a typo for "(void) blah".
235  else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
236    TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
237    QualType T = TI->getType();
238
239    // We really do want to use the non-canonical type here.
240    if (T == Context.VoidPtrTy) {
241      PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
242
243      Diag(Loc, diag::warn_unused_voidptr)
244        << FixItHint::CreateRemoval(TL.getStarLoc());
245      return;
246    }
247  }
248
249  if (E->isGLValue() && E->getType().isVolatileQualified()) {
250    Diag(Loc, diag::warn_unused_volatile) << R1 << R2;
251    return;
252  }
253
254  DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
255}
256
257void Sema::ActOnStartOfCompoundStmt() {
258  PushCompoundScope();
259}
260
261void Sema::ActOnFinishOfCompoundStmt() {
262  PopCompoundScope();
263}
264
265sema::CompoundScopeInfo &Sema::getCurCompoundScope() const {
266  return getCurFunction()->CompoundScopes.back();
267}
268
269StmtResult
270Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
271                        MultiStmtArg elts, bool isStmtExpr) {
272  unsigned NumElts = elts.size();
273  Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
274  // If we're in C89 mode, check that we don't have any decls after stmts.  If
275  // so, emit an extension diagnostic.
276  if (!getLangOpts().C99 && !getLangOpts().CPlusPlus) {
277    // Note that __extension__ can be around a decl.
278    unsigned i = 0;
279    // Skip over all declarations.
280    for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
281      /*empty*/;
282
283    // We found the end of the list or a statement.  Scan for another declstmt.
284    for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
285      /*empty*/;
286
287    if (i != NumElts) {
288      Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
289      Diag(D->getLocation(), diag::ext_mixed_decls_code);
290    }
291  }
292  // Warn about unused expressions in statements.
293  for (unsigned i = 0; i != NumElts; ++i) {
294    // Ignore statements that are last in a statement expression.
295    if (isStmtExpr && i == NumElts - 1)
296      continue;
297
298    DiagnoseUnusedExprResult(Elts[i]);
299  }
300
301  // Check for suspicious empty body (null statement) in `for' and `while'
302  // statements.  Don't do anything for template instantiations, this just adds
303  // noise.
304  if (NumElts != 0 && !CurrentInstantiationScope &&
305      getCurCompoundScope().HasEmptyLoopBodies) {
306    for (unsigned i = 0; i != NumElts - 1; ++i)
307      DiagnoseEmptyLoopBody(Elts[i], Elts[i + 1]);
308  }
309
310  return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
311}
312
313StmtResult
314Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
315                    SourceLocation DotDotDotLoc, Expr *RHSVal,
316                    SourceLocation ColonLoc) {
317  assert((LHSVal != 0) && "missing expression in case statement");
318
319  if (getCurFunction()->SwitchStack.empty()) {
320    Diag(CaseLoc, diag::err_case_not_in_switch);
321    return StmtError();
322  }
323
324  if (!getLangOpts().CPlusPlus0x) {
325    // C99 6.8.4.2p3: The expression shall be an integer constant.
326    // However, GCC allows any evaluatable integer expression.
327    if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent()) {
328      LHSVal = VerifyIntegerConstantExpression(LHSVal).take();
329      if (!LHSVal)
330        return StmtError();
331    }
332
333    // GCC extension: The expression shall be an integer constant.
334
335    if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent()) {
336      RHSVal = VerifyIntegerConstantExpression(RHSVal).take();
337      // Recover from an error by just forgetting about it.
338    }
339  }
340
341  CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
342                                        ColonLoc);
343  getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
344  return Owned(CS);
345}
346
347/// ActOnCaseStmtBody - This installs a statement as the body of a case.
348void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
349  DiagnoseUnusedExprResult(SubStmt);
350
351  CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
352  CS->setSubStmt(SubStmt);
353}
354
355StmtResult
356Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
357                       Stmt *SubStmt, Scope *CurScope) {
358  DiagnoseUnusedExprResult(SubStmt);
359
360  if (getCurFunction()->SwitchStack.empty()) {
361    Diag(DefaultLoc, diag::err_default_not_in_switch);
362    return Owned(SubStmt);
363  }
364
365  DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
366  getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
367  return Owned(DS);
368}
369
370StmtResult
371Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
372                     SourceLocation ColonLoc, Stmt *SubStmt) {
373  // If the label was multiply defined, reject it now.
374  if (TheDecl->getStmt()) {
375    Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
376    Diag(TheDecl->getLocation(), diag::note_previous_definition);
377    return Owned(SubStmt);
378  }
379
380  // Otherwise, things are good.  Fill in the declaration and return it.
381  LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
382  TheDecl->setStmt(LS);
383  if (!TheDecl->isGnuLocal())
384    TheDecl->setLocation(IdentLoc);
385  return Owned(LS);
386}
387
388StmtResult Sema::ActOnAttributedStmt(SourceLocation AttrLoc,
389                                     ArrayRef<const Attr*> Attrs,
390                                     Stmt *SubStmt) {
391  // Fill in the declaration and return it.
392  AttributedStmt *LS = AttributedStmt::Create(Context, AttrLoc, Attrs, SubStmt);
393  return Owned(LS);
394}
395
396StmtResult
397Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
398                  Stmt *thenStmt, SourceLocation ElseLoc,
399                  Stmt *elseStmt) {
400  ExprResult CondResult(CondVal.release());
401
402  VarDecl *ConditionVar = 0;
403  if (CondVar) {
404    ConditionVar = cast<VarDecl>(CondVar);
405    CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
406    if (CondResult.isInvalid())
407      return StmtError();
408  }
409  Expr *ConditionExpr = CondResult.takeAs<Expr>();
410  if (!ConditionExpr)
411    return StmtError();
412
413  DiagnoseUnusedExprResult(thenStmt);
414
415  if (!elseStmt) {
416    DiagnoseEmptyStmtBody(ConditionExpr->getLocEnd(), thenStmt,
417                          diag::warn_empty_if_body);
418  }
419
420  DiagnoseUnusedExprResult(elseStmt);
421
422  return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
423                                    thenStmt, ElseLoc, elseStmt));
424}
425
426/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
427/// the specified width and sign.  If an overflow occurs, detect it and emit
428/// the specified diagnostic.
429void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
430                                              unsigned NewWidth, bool NewSign,
431                                              SourceLocation Loc,
432                                              unsigned DiagID) {
433  // Perform a conversion to the promoted condition type if needed.
434  if (NewWidth > Val.getBitWidth()) {
435    // If this is an extension, just do it.
436    Val = Val.extend(NewWidth);
437    Val.setIsSigned(NewSign);
438
439    // If the input was signed and negative and the output is
440    // unsigned, don't bother to warn: this is implementation-defined
441    // behavior.
442    // FIXME: Introduce a second, default-ignored warning for this case?
443  } else if (NewWidth < Val.getBitWidth()) {
444    // If this is a truncation, check for overflow.
445    llvm::APSInt ConvVal(Val);
446    ConvVal = ConvVal.trunc(NewWidth);
447    ConvVal.setIsSigned(NewSign);
448    ConvVal = ConvVal.extend(Val.getBitWidth());
449    ConvVal.setIsSigned(Val.isSigned());
450    if (ConvVal != Val)
451      Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
452
453    // Regardless of whether a diagnostic was emitted, really do the
454    // truncation.
455    Val = Val.trunc(NewWidth);
456    Val.setIsSigned(NewSign);
457  } else if (NewSign != Val.isSigned()) {
458    // Convert the sign to match the sign of the condition.  This can cause
459    // overflow as well: unsigned(INTMIN)
460    // We don't diagnose this overflow, because it is implementation-defined
461    // behavior.
462    // FIXME: Introduce a second, default-ignored warning for this case?
463    llvm::APSInt OldVal(Val);
464    Val.setIsSigned(NewSign);
465  }
466}
467
468namespace {
469  struct CaseCompareFunctor {
470    bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
471                    const llvm::APSInt &RHS) {
472      return LHS.first < RHS;
473    }
474    bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
475                    const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
476      return LHS.first < RHS.first;
477    }
478    bool operator()(const llvm::APSInt &LHS,
479                    const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
480      return LHS < RHS.first;
481    }
482  };
483}
484
485/// CmpCaseVals - Comparison predicate for sorting case values.
486///
487static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
488                        const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
489  if (lhs.first < rhs.first)
490    return true;
491
492  if (lhs.first == rhs.first &&
493      lhs.second->getCaseLoc().getRawEncoding()
494       < rhs.second->getCaseLoc().getRawEncoding())
495    return true;
496  return false;
497}
498
499/// CmpEnumVals - Comparison predicate for sorting enumeration values.
500///
501static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
502                        const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
503{
504  return lhs.first < rhs.first;
505}
506
507/// EqEnumVals - Comparison preficate for uniqing enumeration values.
508///
509static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
510                       const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
511{
512  return lhs.first == rhs.first;
513}
514
515/// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
516/// potentially integral-promoted expression @p expr.
517static QualType GetTypeBeforeIntegralPromotion(Expr *&expr) {
518  if (ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(expr))
519    expr = cleanups->getSubExpr();
520  while (ImplicitCastExpr *impcast = dyn_cast<ImplicitCastExpr>(expr)) {
521    if (impcast->getCastKind() != CK_IntegralCast) break;
522    expr = impcast->getSubExpr();
523  }
524  return expr->getType();
525}
526
527StmtResult
528Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
529                             Decl *CondVar) {
530  ExprResult CondResult;
531
532  VarDecl *ConditionVar = 0;
533  if (CondVar) {
534    ConditionVar = cast<VarDecl>(CondVar);
535    CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
536    if (CondResult.isInvalid())
537      return StmtError();
538
539    Cond = CondResult.release();
540  }
541
542  if (!Cond)
543    return StmtError();
544
545  class SwitchConvertDiagnoser : public ICEConvertDiagnoser {
546    Expr *Cond;
547
548  public:
549    SwitchConvertDiagnoser(Expr *Cond)
550      : ICEConvertDiagnoser(false, true), Cond(Cond) { }
551
552    virtual DiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
553                                             QualType T) {
554      return S.Diag(Loc, diag::err_typecheck_statement_requires_integer) << T;
555    }
556
557    virtual DiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
558                                                 QualType T) {
559      return S.Diag(Loc, diag::err_switch_incomplete_class_type)
560               << T << Cond->getSourceRange();
561    }
562
563    virtual DiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
564                                                   QualType T,
565                                                   QualType ConvTy) {
566      return S.Diag(Loc, diag::err_switch_explicit_conversion) << T << ConvTy;
567    }
568
569    virtual DiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
570                                               QualType ConvTy) {
571      return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
572        << ConvTy->isEnumeralType() << ConvTy;
573    }
574
575    virtual DiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
576                                                QualType T) {
577      return S.Diag(Loc, diag::err_switch_multiple_conversions) << T;
578    }
579
580    virtual DiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
581                                            QualType ConvTy) {
582      return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
583      << ConvTy->isEnumeralType() << ConvTy;
584    }
585
586    virtual DiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
587                                                 QualType T,
588                                                 QualType ConvTy) {
589      return DiagnosticBuilder::getEmpty();
590    }
591  } SwitchDiagnoser(Cond);
592
593  CondResult
594    = ConvertToIntegralOrEnumerationType(SwitchLoc, Cond, SwitchDiagnoser,
595                                         /*AllowScopedEnumerations*/ true);
596  if (CondResult.isInvalid()) return StmtError();
597  Cond = CondResult.take();
598
599  // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
600  CondResult = UsualUnaryConversions(Cond);
601  if (CondResult.isInvalid()) return StmtError();
602  Cond = CondResult.take();
603
604  if (!CondVar) {
605    CheckImplicitConversions(Cond, SwitchLoc);
606    CondResult = MaybeCreateExprWithCleanups(Cond);
607    if (CondResult.isInvalid())
608      return StmtError();
609    Cond = CondResult.take();
610  }
611
612  getCurFunction()->setHasBranchIntoScope();
613
614  SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
615  getCurFunction()->SwitchStack.push_back(SS);
616  return Owned(SS);
617}
618
619static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
620  if (Val.getBitWidth() < BitWidth)
621    Val = Val.extend(BitWidth);
622  else if (Val.getBitWidth() > BitWidth)
623    Val = Val.trunc(BitWidth);
624  Val.setIsSigned(IsSigned);
625}
626
627StmtResult
628Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
629                            Stmt *BodyStmt) {
630  SwitchStmt *SS = cast<SwitchStmt>(Switch);
631  assert(SS == getCurFunction()->SwitchStack.back() &&
632         "switch stack missing push/pop!");
633
634  SS->setBody(BodyStmt, SwitchLoc);
635  getCurFunction()->SwitchStack.pop_back();
636
637  Expr *CondExpr = SS->getCond();
638  if (!CondExpr) return StmtError();
639
640  QualType CondType = CondExpr->getType();
641
642  Expr *CondExprBeforePromotion = CondExpr;
643  QualType CondTypeBeforePromotion =
644      GetTypeBeforeIntegralPromotion(CondExprBeforePromotion);
645
646  // C++ 6.4.2.p2:
647  // Integral promotions are performed (on the switch condition).
648  //
649  // A case value unrepresentable by the original switch condition
650  // type (before the promotion) doesn't make sense, even when it can
651  // be represented by the promoted type.  Therefore we need to find
652  // the pre-promotion type of the switch condition.
653  if (!CondExpr->isTypeDependent()) {
654    // We have already converted the expression to an integral or enumeration
655    // type, when we started the switch statement. If we don't have an
656    // appropriate type now, just return an error.
657    if (!CondType->isIntegralOrEnumerationType())
658      return StmtError();
659
660    if (CondExpr->isKnownToHaveBooleanValue()) {
661      // switch(bool_expr) {...} is often a programmer error, e.g.
662      //   switch(n && mask) { ... }  // Doh - should be "n & mask".
663      // One can always use an if statement instead of switch(bool_expr).
664      Diag(SwitchLoc, diag::warn_bool_switch_condition)
665          << CondExpr->getSourceRange();
666    }
667  }
668
669  // Get the bitwidth of the switched-on value before promotions.  We must
670  // convert the integer case values to this width before comparison.
671  bool HasDependentValue
672    = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
673  unsigned CondWidth
674    = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
675  bool CondIsSigned
676    = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
677
678  // Accumulate all of the case values in a vector so that we can sort them
679  // and detect duplicates.  This vector contains the APInt for the case after
680  // it has been converted to the condition type.
681  typedef SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
682  CaseValsTy CaseVals;
683
684  // Keep track of any GNU case ranges we see.  The APSInt is the low value.
685  typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
686  CaseRangesTy CaseRanges;
687
688  DefaultStmt *TheDefaultStmt = 0;
689
690  bool CaseListIsErroneous = false;
691
692  for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
693       SC = SC->getNextSwitchCase()) {
694
695    if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
696      if (TheDefaultStmt) {
697        Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
698        Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
699
700        // FIXME: Remove the default statement from the switch block so that
701        // we'll return a valid AST.  This requires recursing down the AST and
702        // finding it, not something we are set up to do right now.  For now,
703        // just lop the entire switch stmt out of the AST.
704        CaseListIsErroneous = true;
705      }
706      TheDefaultStmt = DS;
707
708    } else {
709      CaseStmt *CS = cast<CaseStmt>(SC);
710
711      Expr *Lo = CS->getLHS();
712
713      if (Lo->isTypeDependent() || Lo->isValueDependent()) {
714        HasDependentValue = true;
715        break;
716      }
717
718      llvm::APSInt LoVal;
719
720      if (getLangOpts().CPlusPlus0x) {
721        // C++11 [stmt.switch]p2: the constant-expression shall be a converted
722        // constant expression of the promoted type of the switch condition.
723        ExprResult ConvLo =
724          CheckConvertedConstantExpression(Lo, CondType, LoVal, CCEK_CaseValue);
725        if (ConvLo.isInvalid()) {
726          CaseListIsErroneous = true;
727          continue;
728        }
729        Lo = ConvLo.take();
730      } else {
731        // We already verified that the expression has a i-c-e value (C99
732        // 6.8.4.2p3) - get that value now.
733        LoVal = Lo->EvaluateKnownConstInt(Context);
734
735        // If the LHS is not the same type as the condition, insert an implicit
736        // cast.
737        Lo = DefaultLvalueConversion(Lo).take();
738        Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
739      }
740
741      // Convert the value to the same width/sign as the condition had prior to
742      // integral promotions.
743      //
744      // FIXME: This causes us to reject valid code:
745      //   switch ((char)c) { case 256: case 0: return 0; }
746      // Here we claim there is a duplicated condition value, but there is not.
747      ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
748                                         Lo->getLocStart(),
749                                         diag::warn_case_value_overflow);
750
751      CS->setLHS(Lo);
752
753      // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
754      if (CS->getRHS()) {
755        if (CS->getRHS()->isTypeDependent() ||
756            CS->getRHS()->isValueDependent()) {
757          HasDependentValue = true;
758          break;
759        }
760        CaseRanges.push_back(std::make_pair(LoVal, CS));
761      } else
762        CaseVals.push_back(std::make_pair(LoVal, CS));
763    }
764  }
765
766  if (!HasDependentValue) {
767    // If we don't have a default statement, check whether the
768    // condition is constant.
769    llvm::APSInt ConstantCondValue;
770    bool HasConstantCond = false;
771    if (!HasDependentValue && !TheDefaultStmt) {
772      HasConstantCond
773        = CondExprBeforePromotion->EvaluateAsInt(ConstantCondValue, Context,
774                                                 Expr::SE_AllowSideEffects);
775      assert(!HasConstantCond ||
776             (ConstantCondValue.getBitWidth() == CondWidth &&
777              ConstantCondValue.isSigned() == CondIsSigned));
778    }
779    bool ShouldCheckConstantCond = HasConstantCond;
780
781    // Sort all the scalar case values so we can easily detect duplicates.
782    std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
783
784    if (!CaseVals.empty()) {
785      for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
786        if (ShouldCheckConstantCond &&
787            CaseVals[i].first == ConstantCondValue)
788          ShouldCheckConstantCond = false;
789
790        if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
791          // If we have a duplicate, report it.
792          // First, determine if either case value has a name
793          StringRef PrevString, CurrString;
794          Expr *PrevCase = CaseVals[i-1].second->getLHS()->IgnoreParenCasts();
795          Expr *CurrCase = CaseVals[i].second->getLHS()->IgnoreParenCasts();
796          if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) {
797            PrevString = DeclRef->getDecl()->getName();
798          }
799          if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) {
800            CurrString = DeclRef->getDecl()->getName();
801          }
802          llvm::SmallString<16> CaseValStr;
803          CaseVals[i-1].first.toString(CaseValStr);
804
805          if (PrevString == CurrString)
806            Diag(CaseVals[i].second->getLHS()->getLocStart(),
807                 diag::err_duplicate_case) <<
808                 (PrevString.empty() ? CaseValStr.str() : PrevString);
809          else
810            Diag(CaseVals[i].second->getLHS()->getLocStart(),
811                 diag::err_duplicate_case_differing_expr) <<
812                 (PrevString.empty() ? CaseValStr.str() : PrevString) <<
813                 (CurrString.empty() ? CaseValStr.str() : CurrString) <<
814                 CaseValStr;
815
816          Diag(CaseVals[i-1].second->getLHS()->getLocStart(),
817               diag::note_duplicate_case_prev);
818          // FIXME: We really want to remove the bogus case stmt from the
819          // substmt, but we have no way to do this right now.
820          CaseListIsErroneous = true;
821        }
822      }
823    }
824
825    // Detect duplicate case ranges, which usually don't exist at all in
826    // the first place.
827    if (!CaseRanges.empty()) {
828      // Sort all the case ranges by their low value so we can easily detect
829      // overlaps between ranges.
830      std::stable_sort(CaseRanges.begin(), CaseRanges.end());
831
832      // Scan the ranges, computing the high values and removing empty ranges.
833      std::vector<llvm::APSInt> HiVals;
834      for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
835        llvm::APSInt &LoVal = CaseRanges[i].first;
836        CaseStmt *CR = CaseRanges[i].second;
837        Expr *Hi = CR->getRHS();
838        llvm::APSInt HiVal;
839
840        if (getLangOpts().CPlusPlus0x) {
841          // C++11 [stmt.switch]p2: the constant-expression shall be a converted
842          // constant expression of the promoted type of the switch condition.
843          ExprResult ConvHi =
844            CheckConvertedConstantExpression(Hi, CondType, HiVal,
845                                             CCEK_CaseValue);
846          if (ConvHi.isInvalid()) {
847            CaseListIsErroneous = true;
848            continue;
849          }
850          Hi = ConvHi.take();
851        } else {
852          HiVal = Hi->EvaluateKnownConstInt(Context);
853
854          // If the RHS is not the same type as the condition, insert an
855          // implicit cast.
856          Hi = DefaultLvalueConversion(Hi).take();
857          Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
858        }
859
860        // Convert the value to the same width/sign as the condition.
861        ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
862                                           Hi->getLocStart(),
863                                           diag::warn_case_value_overflow);
864
865        CR->setRHS(Hi);
866
867        // If the low value is bigger than the high value, the case is empty.
868        if (LoVal > HiVal) {
869          Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
870            << SourceRange(CR->getLHS()->getLocStart(),
871                           Hi->getLocEnd());
872          CaseRanges.erase(CaseRanges.begin()+i);
873          --i, --e;
874          continue;
875        }
876
877        if (ShouldCheckConstantCond &&
878            LoVal <= ConstantCondValue &&
879            ConstantCondValue <= HiVal)
880          ShouldCheckConstantCond = false;
881
882        HiVals.push_back(HiVal);
883      }
884
885      // Rescan the ranges, looking for overlap with singleton values and other
886      // ranges.  Since the range list is sorted, we only need to compare case
887      // ranges with their neighbors.
888      for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
889        llvm::APSInt &CRLo = CaseRanges[i].first;
890        llvm::APSInt &CRHi = HiVals[i];
891        CaseStmt *CR = CaseRanges[i].second;
892
893        // Check to see whether the case range overlaps with any
894        // singleton cases.
895        CaseStmt *OverlapStmt = 0;
896        llvm::APSInt OverlapVal(32);
897
898        // Find the smallest value >= the lower bound.  If I is in the
899        // case range, then we have overlap.
900        CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
901                                                  CaseVals.end(), CRLo,
902                                                  CaseCompareFunctor());
903        if (I != CaseVals.end() && I->first < CRHi) {
904          OverlapVal  = I->first;   // Found overlap with scalar.
905          OverlapStmt = I->second;
906        }
907
908        // Find the smallest value bigger than the upper bound.
909        I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
910        if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
911          OverlapVal  = (I-1)->first;      // Found overlap with scalar.
912          OverlapStmt = (I-1)->second;
913        }
914
915        // Check to see if this case stmt overlaps with the subsequent
916        // case range.
917        if (i && CRLo <= HiVals[i-1]) {
918          OverlapVal  = HiVals[i-1];       // Found overlap with range.
919          OverlapStmt = CaseRanges[i-1].second;
920        }
921
922        if (OverlapStmt) {
923          // If we have a duplicate, report it.
924          Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
925            << OverlapVal.toString(10);
926          Diag(OverlapStmt->getLHS()->getLocStart(),
927               diag::note_duplicate_case_prev);
928          // FIXME: We really want to remove the bogus case stmt from the
929          // substmt, but we have no way to do this right now.
930          CaseListIsErroneous = true;
931        }
932      }
933    }
934
935    // Complain if we have a constant condition and we didn't find a match.
936    if (!CaseListIsErroneous && ShouldCheckConstantCond) {
937      // TODO: it would be nice if we printed enums as enums, chars as
938      // chars, etc.
939      Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
940        << ConstantCondValue.toString(10)
941        << CondExpr->getSourceRange();
942    }
943
944    // Check to see if switch is over an Enum and handles all of its
945    // values.  We only issue a warning if there is not 'default:', but
946    // we still do the analysis to preserve this information in the AST
947    // (which can be used by flow-based analyes).
948    //
949    const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
950
951    // If switch has default case, then ignore it.
952    if (!CaseListIsErroneous  && !HasConstantCond && ET) {
953      const EnumDecl *ED = ET->getDecl();
954      typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
955        EnumValsTy;
956      EnumValsTy EnumVals;
957
958      // Gather all enum values, set their type and sort them,
959      // allowing easier comparison with CaseVals.
960      for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
961           EDI != ED->enumerator_end(); ++EDI) {
962        llvm::APSInt Val = EDI->getInitVal();
963        AdjustAPSInt(Val, CondWidth, CondIsSigned);
964        EnumVals.push_back(std::make_pair(Val, *EDI));
965      }
966      std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
967      EnumValsTy::iterator EIend =
968        std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
969
970      // See which case values aren't in enum.
971      EnumValsTy::const_iterator EI = EnumVals.begin();
972      for (CaseValsTy::const_iterator CI = CaseVals.begin();
973           CI != CaseVals.end(); CI++) {
974        while (EI != EIend && EI->first < CI->first)
975          EI++;
976        if (EI == EIend || EI->first > CI->first)
977          Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
978            << CondTypeBeforePromotion;
979      }
980      // See which of case ranges aren't in enum
981      EI = EnumVals.begin();
982      for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
983           RI != CaseRanges.end() && EI != EIend; RI++) {
984        while (EI != EIend && EI->first < RI->first)
985          EI++;
986
987        if (EI == EIend || EI->first != RI->first) {
988          Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
989            << CondTypeBeforePromotion;
990        }
991
992        llvm::APSInt Hi =
993          RI->second->getRHS()->EvaluateKnownConstInt(Context);
994        AdjustAPSInt(Hi, CondWidth, CondIsSigned);
995        while (EI != EIend && EI->first < Hi)
996          EI++;
997        if (EI == EIend || EI->first != Hi)
998          Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
999            << CondTypeBeforePromotion;
1000      }
1001
1002      // Check which enum vals aren't in switch
1003      CaseValsTy::const_iterator CI = CaseVals.begin();
1004      CaseRangesTy::const_iterator RI = CaseRanges.begin();
1005      bool hasCasesNotInSwitch = false;
1006
1007      SmallVector<DeclarationName,8> UnhandledNames;
1008
1009      for (EI = EnumVals.begin(); EI != EIend; EI++){
1010        // Drop unneeded case values
1011        llvm::APSInt CIVal;
1012        while (CI != CaseVals.end() && CI->first < EI->first)
1013          CI++;
1014
1015        if (CI != CaseVals.end() && CI->first == EI->first)
1016          continue;
1017
1018        // Drop unneeded case ranges
1019        for (; RI != CaseRanges.end(); RI++) {
1020          llvm::APSInt Hi =
1021            RI->second->getRHS()->EvaluateKnownConstInt(Context);
1022          AdjustAPSInt(Hi, CondWidth, CondIsSigned);
1023          if (EI->first <= Hi)
1024            break;
1025        }
1026
1027        if (RI == CaseRanges.end() || EI->first < RI->first) {
1028          hasCasesNotInSwitch = true;
1029          UnhandledNames.push_back(EI->second->getDeclName());
1030        }
1031      }
1032
1033      if (TheDefaultStmt && UnhandledNames.empty())
1034        Diag(TheDefaultStmt->getDefaultLoc(), diag::warn_unreachable_default);
1035
1036      // Produce a nice diagnostic if multiple values aren't handled.
1037      switch (UnhandledNames.size()) {
1038      case 0: break;
1039      case 1:
1040        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1041          ? diag::warn_def_missing_case1 : diag::warn_missing_case1)
1042          << UnhandledNames[0];
1043        break;
1044      case 2:
1045        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1046          ? diag::warn_def_missing_case2 : diag::warn_missing_case2)
1047          << UnhandledNames[0] << UnhandledNames[1];
1048        break;
1049      case 3:
1050        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1051          ? diag::warn_def_missing_case3 : diag::warn_missing_case3)
1052          << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
1053        break;
1054      default:
1055        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1056          ? diag::warn_def_missing_cases : diag::warn_missing_cases)
1057          << (unsigned)UnhandledNames.size()
1058          << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
1059        break;
1060      }
1061
1062      if (!hasCasesNotInSwitch)
1063        SS->setAllEnumCasesCovered();
1064    }
1065  }
1066
1067  DiagnoseEmptyStmtBody(CondExpr->getLocEnd(), BodyStmt,
1068                        diag::warn_empty_switch_body);
1069
1070  // FIXME: If the case list was broken is some way, we don't have a good system
1071  // to patch it up.  Instead, just return the whole substmt as broken.
1072  if (CaseListIsErroneous)
1073    return StmtError();
1074
1075  return Owned(SS);
1076}
1077
1078void
1079Sema::DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
1080                             Expr *SrcExpr) {
1081  unsigned DIAG = diag::warn_not_in_enum_assignement;
1082  if (Diags.getDiagnosticLevel(DIAG, SrcExpr->getExprLoc())
1083      == DiagnosticsEngine::Ignored)
1084    return;
1085
1086  if (const EnumType *ET = DstType->getAs<EnumType>())
1087    if (!Context.hasSameType(SrcType, DstType) &&
1088        SrcType->isIntegerType()) {
1089      if (!SrcExpr->isTypeDependent() && !SrcExpr->isValueDependent() &&
1090          SrcExpr->isIntegerConstantExpr(Context)) {
1091        // Get the bitwidth of the enum value before promotions.
1092        unsigned DstWith = Context.getIntWidth(DstType);
1093        bool DstIsSigned = DstType->isSignedIntegerOrEnumerationType();
1094
1095        llvm::APSInt RhsVal = SrcExpr->EvaluateKnownConstInt(Context);
1096        const EnumDecl *ED = ET->getDecl();
1097        typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
1098        EnumValsTy;
1099        EnumValsTy EnumVals;
1100
1101        // Gather all enum values, set their type and sort them,
1102        // allowing easier comparison with rhs constant.
1103        for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
1104             EDI != ED->enumerator_end(); ++EDI) {
1105          llvm::APSInt Val = EDI->getInitVal();
1106          AdjustAPSInt(Val, DstWith, DstIsSigned);
1107          EnumVals.push_back(std::make_pair(Val, *EDI));
1108        }
1109        if (EnumVals.empty())
1110          return;
1111        std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
1112        EnumValsTy::iterator EIend =
1113        std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
1114
1115        // See which case values aren't in enum.
1116        EnumValsTy::const_iterator EI = EnumVals.begin();
1117        while (EI != EIend && EI->first < RhsVal)
1118          EI++;
1119        if (EI == EIend || EI->first != RhsVal) {
1120          Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignement)
1121          << DstType;
1122        }
1123      }
1124    }
1125}
1126
1127StmtResult
1128Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
1129                     Decl *CondVar, Stmt *Body) {
1130  ExprResult CondResult(Cond.release());
1131
1132  VarDecl *ConditionVar = 0;
1133  if (CondVar) {
1134    ConditionVar = cast<VarDecl>(CondVar);
1135    CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
1136    if (CondResult.isInvalid())
1137      return StmtError();
1138  }
1139  Expr *ConditionExpr = CondResult.take();
1140  if (!ConditionExpr)
1141    return StmtError();
1142
1143  DiagnoseUnusedExprResult(Body);
1144
1145  if (isa<NullStmt>(Body))
1146    getCurCompoundScope().setHasEmptyLoopBodies();
1147
1148  return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
1149                                       Body, WhileLoc));
1150}
1151
1152StmtResult
1153Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
1154                  SourceLocation WhileLoc, SourceLocation CondLParen,
1155                  Expr *Cond, SourceLocation CondRParen) {
1156  assert(Cond && "ActOnDoStmt(): missing expression");
1157
1158  ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
1159  if (CondResult.isInvalid() || CondResult.isInvalid())
1160    return StmtError();
1161  Cond = CondResult.take();
1162
1163  CheckImplicitConversions(Cond, DoLoc);
1164  CondResult = MaybeCreateExprWithCleanups(Cond);
1165  if (CondResult.isInvalid())
1166    return StmtError();
1167  Cond = CondResult.take();
1168
1169  DiagnoseUnusedExprResult(Body);
1170
1171  return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
1172}
1173
1174namespace {
1175  // This visitor will traverse a conditional statement and store all
1176  // the evaluated decls into a vector.  Simple is set to true if none
1177  // of the excluded constructs are used.
1178  class DeclExtractor : public EvaluatedExprVisitor<DeclExtractor> {
1179    llvm::SmallPtrSet<VarDecl*, 8> &Decls;
1180    llvm::SmallVector<SourceRange, 10> &Ranges;
1181    bool Simple;
1182public:
1183  typedef EvaluatedExprVisitor<DeclExtractor> Inherited;
1184
1185  DeclExtractor(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls,
1186                llvm::SmallVector<SourceRange, 10> &Ranges) :
1187      Inherited(S.Context),
1188      Decls(Decls),
1189      Ranges(Ranges),
1190      Simple(true) {}
1191
1192  bool isSimple() { return Simple; }
1193
1194  // Replaces the method in EvaluatedExprVisitor.
1195  void VisitMemberExpr(MemberExpr* E) {
1196    Simple = false;
1197  }
1198
1199  // Any Stmt not whitelisted will cause the condition to be marked complex.
1200  void VisitStmt(Stmt *S) {
1201    Simple = false;
1202  }
1203
1204  void VisitBinaryOperator(BinaryOperator *E) {
1205    Visit(E->getLHS());
1206    Visit(E->getRHS());
1207  }
1208
1209  void VisitCastExpr(CastExpr *E) {
1210    Visit(E->getSubExpr());
1211  }
1212
1213  void VisitUnaryOperator(UnaryOperator *E) {
1214    // Skip checking conditionals with derefernces.
1215    if (E->getOpcode() == UO_Deref)
1216      Simple = false;
1217    else
1218      Visit(E->getSubExpr());
1219  }
1220
1221  void VisitConditionalOperator(ConditionalOperator *E) {
1222    Visit(E->getCond());
1223    Visit(E->getTrueExpr());
1224    Visit(E->getFalseExpr());
1225  }
1226
1227  void VisitParenExpr(ParenExpr *E) {
1228    Visit(E->getSubExpr());
1229  }
1230
1231  void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1232    Visit(E->getOpaqueValue()->getSourceExpr());
1233    Visit(E->getFalseExpr());
1234  }
1235
1236  void VisitIntegerLiteral(IntegerLiteral *E) { }
1237  void VisitFloatingLiteral(FloatingLiteral *E) { }
1238  void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { }
1239  void VisitCharacterLiteral(CharacterLiteral *E) { }
1240  void VisitGNUNullExpr(GNUNullExpr *E) { }
1241  void VisitImaginaryLiteral(ImaginaryLiteral *E) { }
1242
1243  void VisitDeclRefExpr(DeclRefExpr *E) {
1244    VarDecl *VD = dyn_cast<VarDecl>(E->getDecl());
1245    if (!VD) return;
1246
1247    Ranges.push_back(E->getSourceRange());
1248
1249    Decls.insert(VD);
1250  }
1251
1252  }; // end class DeclExtractor
1253
1254  // DeclMatcher checks to see if the decls are used in a non-evauluated
1255  // context.
1256  class DeclMatcher : public EvaluatedExprVisitor<DeclMatcher> {
1257    llvm::SmallPtrSet<VarDecl*, 8> &Decls;
1258    bool FoundDecl;
1259
1260public:
1261  typedef EvaluatedExprVisitor<DeclMatcher> Inherited;
1262
1263  DeclMatcher(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls, Stmt *Statement) :
1264      Inherited(S.Context), Decls(Decls), FoundDecl(false) {
1265    if (!Statement) return;
1266
1267    Visit(Statement);
1268  }
1269
1270  void VisitReturnStmt(ReturnStmt *S) {
1271    FoundDecl = true;
1272  }
1273
1274  void VisitBreakStmt(BreakStmt *S) {
1275    FoundDecl = true;
1276  }
1277
1278  void VisitGotoStmt(GotoStmt *S) {
1279    FoundDecl = true;
1280  }
1281
1282  void VisitCastExpr(CastExpr *E) {
1283    if (E->getCastKind() == CK_LValueToRValue)
1284      CheckLValueToRValueCast(E->getSubExpr());
1285    else
1286      Visit(E->getSubExpr());
1287  }
1288
1289  void CheckLValueToRValueCast(Expr *E) {
1290    E = E->IgnoreParenImpCasts();
1291
1292    if (isa<DeclRefExpr>(E)) {
1293      return;
1294    }
1295
1296    if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
1297      Visit(CO->getCond());
1298      CheckLValueToRValueCast(CO->getTrueExpr());
1299      CheckLValueToRValueCast(CO->getFalseExpr());
1300      return;
1301    }
1302
1303    if (BinaryConditionalOperator *BCO =
1304            dyn_cast<BinaryConditionalOperator>(E)) {
1305      CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr());
1306      CheckLValueToRValueCast(BCO->getFalseExpr());
1307      return;
1308    }
1309
1310    Visit(E);
1311  }
1312
1313  void VisitDeclRefExpr(DeclRefExpr *E) {
1314    if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
1315      if (Decls.count(VD))
1316        FoundDecl = true;
1317  }
1318
1319  bool FoundDeclInUse() { return FoundDecl; }
1320
1321  };  // end class DeclMatcher
1322
1323  void CheckForLoopConditionalStatement(Sema &S, Expr *Second,
1324                                        Expr *Third, Stmt *Body) {
1325    // Condition is empty
1326    if (!Second) return;
1327
1328    if (S.Diags.getDiagnosticLevel(diag::warn_variables_not_in_loop_body,
1329                                   Second->getLocStart())
1330        == DiagnosticsEngine::Ignored)
1331      return;
1332
1333    PartialDiagnostic PDiag = S.PDiag(diag::warn_variables_not_in_loop_body);
1334    llvm::SmallPtrSet<VarDecl*, 8> Decls;
1335    llvm::SmallVector<SourceRange, 10> Ranges;
1336    DeclExtractor DE(S, Decls, Ranges);
1337    DE.Visit(Second);
1338
1339    // Don't analyze complex conditionals.
1340    if (!DE.isSimple()) return;
1341
1342    // No decls found.
1343    if (Decls.size() == 0) return;
1344
1345    // Don't warn on volatile, static, or global variables.
1346    for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(),
1347                                                  E = Decls.end();
1348         I != E; ++I)
1349      if ((*I)->getType().isVolatileQualified() ||
1350          (*I)->hasGlobalStorage()) return;
1351
1352    if (DeclMatcher(S, Decls, Second).FoundDeclInUse() ||
1353        DeclMatcher(S, Decls, Third).FoundDeclInUse() ||
1354        DeclMatcher(S, Decls, Body).FoundDeclInUse())
1355      return;
1356
1357    // Load decl names into diagnostic.
1358    if (Decls.size() > 4)
1359      PDiag << 0;
1360    else {
1361      PDiag << Decls.size();
1362      for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(),
1363                                                    E = Decls.end();
1364           I != E; ++I)
1365        PDiag << (*I)->getDeclName();
1366    }
1367
1368    // Load SourceRanges into diagnostic if there is room.
1369    // Otherwise, load the SourceRange of the conditional expression.
1370    if (Ranges.size() <= PartialDiagnostic::MaxArguments)
1371      for (llvm::SmallVector<SourceRange, 10>::iterator I = Ranges.begin(),
1372                                                        E = Ranges.end();
1373           I != E; ++I)
1374        PDiag << *I;
1375    else
1376      PDiag << Second->getSourceRange();
1377
1378    S.Diag(Ranges.begin()->getBegin(), PDiag);
1379  }
1380
1381} // end namespace
1382
1383StmtResult
1384Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1385                   Stmt *First, FullExprArg second, Decl *secondVar,
1386                   FullExprArg third,
1387                   SourceLocation RParenLoc, Stmt *Body) {
1388  if (!getLangOpts().CPlusPlus) {
1389    if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
1390      // C99 6.8.5p3: The declaration part of a 'for' statement shall only
1391      // declare identifiers for objects having storage class 'auto' or
1392      // 'register'.
1393      for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
1394           DI!=DE; ++DI) {
1395        VarDecl *VD = dyn_cast<VarDecl>(*DI);
1396        if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
1397          VD = 0;
1398        if (VD == 0)
1399          Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
1400        // FIXME: mark decl erroneous!
1401      }
1402    }
1403  }
1404
1405  CheckForLoopConditionalStatement(*this, second.get(), third.get(), Body);
1406
1407  ExprResult SecondResult(second.release());
1408  VarDecl *ConditionVar = 0;
1409  if (secondVar) {
1410    ConditionVar = cast<VarDecl>(secondVar);
1411    SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
1412    if (SecondResult.isInvalid())
1413      return StmtError();
1414  }
1415
1416  Expr *Third  = third.release().takeAs<Expr>();
1417
1418  DiagnoseUnusedExprResult(First);
1419  DiagnoseUnusedExprResult(Third);
1420  DiagnoseUnusedExprResult(Body);
1421
1422  if (isa<NullStmt>(Body))
1423    getCurCompoundScope().setHasEmptyLoopBodies();
1424
1425  return Owned(new (Context) ForStmt(Context, First,
1426                                     SecondResult.take(), ConditionVar,
1427                                     Third, Body, ForLoc, LParenLoc,
1428                                     RParenLoc));
1429}
1430
1431/// In an Objective C collection iteration statement:
1432///   for (x in y)
1433/// x can be an arbitrary l-value expression.  Bind it up as a
1434/// full-expression.
1435StmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
1436  // Reduce placeholder expressions here.  Note that this rejects the
1437  // use of pseudo-object l-values in this position.
1438  ExprResult result = CheckPlaceholderExpr(E);
1439  if (result.isInvalid()) return StmtError();
1440  E = result.take();
1441
1442  CheckImplicitConversions(E);
1443
1444  result = MaybeCreateExprWithCleanups(E);
1445  if (result.isInvalid()) return StmtError();
1446
1447  return Owned(static_cast<Stmt*>(result.take()));
1448}
1449
1450ExprResult
1451Sema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {
1452  if (!collection)
1453    return ExprError();
1454
1455  // Bail out early if we've got a type-dependent expression.
1456  if (collection->isTypeDependent()) return Owned(collection);
1457
1458  // Perform normal l-value conversion.
1459  ExprResult result = DefaultFunctionArrayLvalueConversion(collection);
1460  if (result.isInvalid())
1461    return ExprError();
1462  collection = result.take();
1463
1464  // The operand needs to have object-pointer type.
1465  // TODO: should we do a contextual conversion?
1466  const ObjCObjectPointerType *pointerType =
1467    collection->getType()->getAs<ObjCObjectPointerType>();
1468  if (!pointerType)
1469    return Diag(forLoc, diag::err_collection_expr_type)
1470             << collection->getType() << collection->getSourceRange();
1471
1472  // Check that the operand provides
1473  //   - countByEnumeratingWithState:objects:count:
1474  const ObjCObjectType *objectType = pointerType->getObjectType();
1475  ObjCInterfaceDecl *iface = objectType->getInterface();
1476
1477  // If we have a forward-declared type, we can't do this check.
1478  // Under ARC, it is an error not to have a forward-declared class.
1479  if (iface &&
1480      RequireCompleteType(forLoc, QualType(objectType, 0),
1481                          getLangOpts().ObjCAutoRefCount
1482                            ? diag::err_arc_collection_forward
1483                            : 0,
1484                          collection)) {
1485    // Otherwise, if we have any useful type information, check that
1486    // the type declares the appropriate method.
1487  } else if (iface || !objectType->qual_empty()) {
1488    IdentifierInfo *selectorIdents[] = {
1489      &Context.Idents.get("countByEnumeratingWithState"),
1490      &Context.Idents.get("objects"),
1491      &Context.Idents.get("count")
1492    };
1493    Selector selector = Context.Selectors.getSelector(3, &selectorIdents[0]);
1494
1495    ObjCMethodDecl *method = 0;
1496
1497    // If there's an interface, look in both the public and private APIs.
1498    if (iface) {
1499      method = iface->lookupInstanceMethod(selector);
1500      if (!method) method = iface->lookupPrivateMethod(selector);
1501    }
1502
1503    // Also check protocol qualifiers.
1504    if (!method)
1505      method = LookupMethodInQualifiedType(selector, pointerType,
1506                                           /*instance*/ true);
1507
1508    // If we didn't find it anywhere, give up.
1509    if (!method) {
1510      Diag(forLoc, diag::warn_collection_expr_type)
1511        << collection->getType() << selector << collection->getSourceRange();
1512    }
1513
1514    // TODO: check for an incompatible signature?
1515  }
1516
1517  // Wrap up any cleanups in the expression.
1518  return Owned(MaybeCreateExprWithCleanups(collection));
1519}
1520
1521StmtResult
1522Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
1523                                 SourceLocation LParenLoc,
1524                                 Stmt *First, Expr *collection,
1525                                 SourceLocation RParenLoc) {
1526
1527  ExprResult CollectionExprResult =
1528    CheckObjCForCollectionOperand(ForLoc, collection);
1529
1530  if (First) {
1531    QualType FirstType;
1532    if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
1533      if (!DS->isSingleDecl())
1534        return StmtError(Diag((*DS->decl_begin())->getLocation(),
1535                         diag::err_toomany_element_decls));
1536
1537      VarDecl *D = cast<VarDecl>(DS->getSingleDecl());
1538      FirstType = D->getType();
1539      // C99 6.8.5p3: The declaration part of a 'for' statement shall only
1540      // declare identifiers for objects having storage class 'auto' or
1541      // 'register'.
1542      if (!D->hasLocalStorage())
1543        return StmtError(Diag(D->getLocation(),
1544                              diag::err_non_variable_decl_in_for));
1545    } else {
1546      Expr *FirstE = cast<Expr>(First);
1547      if (!FirstE->isTypeDependent() && !FirstE->isLValue())
1548        return StmtError(Diag(First->getLocStart(),
1549                   diag::err_selector_element_not_lvalue)
1550          << First->getSourceRange());
1551
1552      FirstType = static_cast<Expr*>(First)->getType();
1553    }
1554    if (!FirstType->isDependentType() &&
1555        !FirstType->isObjCObjectPointerType() &&
1556        !FirstType->isBlockPointerType())
1557        return StmtError(Diag(ForLoc, diag::err_selector_element_type)
1558                           << FirstType << First->getSourceRange());
1559  }
1560
1561  if (CollectionExprResult.isInvalid())
1562    return StmtError();
1563
1564  return Owned(new (Context) ObjCForCollectionStmt(First,
1565                                                   CollectionExprResult.take(), 0,
1566                                                   ForLoc, RParenLoc));
1567}
1568
1569namespace {
1570
1571enum BeginEndFunction {
1572  BEF_begin,
1573  BEF_end
1574};
1575
1576/// Build a variable declaration for a for-range statement.
1577static VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
1578                                     QualType Type, const char *Name) {
1579  DeclContext *DC = SemaRef.CurContext;
1580  IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1581  TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1582  VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
1583                                  TInfo, SC_Auto, SC_None);
1584  Decl->setImplicit();
1585  return Decl;
1586}
1587
1588/// Finish building a variable declaration for a for-range statement.
1589/// \return true if an error occurs.
1590static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
1591                                  SourceLocation Loc, int diag) {
1592  // Deduce the type for the iterator variable now rather than leaving it to
1593  // AddInitializerToDecl, so we can produce a more suitable diagnostic.
1594  TypeSourceInfo *InitTSI = 0;
1595  if ((!isa<InitListExpr>(Init) && Init->getType()->isVoidType()) ||
1596      SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTSI) ==
1597          Sema::DAR_Failed)
1598    SemaRef.Diag(Loc, diag) << Init->getType();
1599  if (!InitTSI) {
1600    Decl->setInvalidDecl();
1601    return true;
1602  }
1603  Decl->setTypeSourceInfo(InitTSI);
1604  Decl->setType(InitTSI->getType());
1605
1606  // In ARC, infer lifetime.
1607  // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if
1608  // we're doing the equivalent of fast iteration.
1609  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1610      SemaRef.inferObjCARCLifetime(Decl))
1611    Decl->setInvalidDecl();
1612
1613  SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1614                               /*TypeMayContainAuto=*/false);
1615  SemaRef.FinalizeDeclaration(Decl);
1616  SemaRef.CurContext->addHiddenDecl(Decl);
1617  return false;
1618}
1619
1620/// Produce a note indicating which begin/end function was implicitly called
1621/// by a C++0x for-range statement. This is often not obvious from the code,
1622/// nor from the diagnostics produced when analysing the implicit expressions
1623/// required in a for-range statement.
1624void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1625                                  BeginEndFunction BEF) {
1626  CallExpr *CE = dyn_cast<CallExpr>(E);
1627  if (!CE)
1628    return;
1629  FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1630  if (!D)
1631    return;
1632  SourceLocation Loc = D->getLocation();
1633
1634  std::string Description;
1635  bool IsTemplate = false;
1636  if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1637    Description = SemaRef.getTemplateArgumentBindingsText(
1638      FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1639    IsTemplate = true;
1640  }
1641
1642  SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1643    << BEF << IsTemplate << Description << E->getType();
1644}
1645
1646/// Build a call to 'begin' or 'end' for a C++0x for-range statement. If the
1647/// given LookupResult is non-empty, it is assumed to describe a member which
1648/// will be invoked. Otherwise, the function will be found via argument
1649/// dependent lookup.
1650static ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1651                                            SourceLocation Loc,
1652                                            VarDecl *Decl,
1653                                            BeginEndFunction BEF,
1654                                            const DeclarationNameInfo &NameInfo,
1655                                            LookupResult &MemberLookup,
1656                                            Expr *Range) {
1657  ExprResult CallExpr;
1658  if (!MemberLookup.empty()) {
1659    ExprResult MemberRef =
1660      SemaRef.BuildMemberReferenceExpr(Range, Range->getType(), Loc,
1661                                       /*IsPtr=*/false, CXXScopeSpec(),
1662                                       /*TemplateKWLoc=*/SourceLocation(),
1663                                       /*FirstQualifierInScope=*/0,
1664                                       MemberLookup,
1665                                       /*TemplateArgs=*/0);
1666    if (MemberRef.isInvalid())
1667      return ExprError();
1668    CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1669                                     Loc, 0);
1670    if (CallExpr.isInvalid())
1671      return ExprError();
1672  } else {
1673    UnresolvedSet<0> FoundNames;
1674    // C++0x [stmt.ranged]p1: For the purposes of this name lookup, namespace
1675    // std is an associated namespace.
1676    UnresolvedLookupExpr *Fn =
1677      UnresolvedLookupExpr::Create(SemaRef.Context, /*NamingClass=*/0,
1678                                   NestedNameSpecifierLoc(), NameInfo,
1679                                   /*NeedsADL=*/true, /*Overloaded=*/false,
1680                                   FoundNames.begin(), FoundNames.end(),
1681                                   /*LookInStdNamespace=*/true);
1682    CallExpr = SemaRef.BuildOverloadedCallExpr(S, Fn, Fn, Loc, &Range, 1, Loc,
1683                                               0, /*AllowTypoCorrection=*/false);
1684    if (CallExpr.isInvalid()) {
1685      SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1686        << Range->getType();
1687      return ExprError();
1688    }
1689  }
1690  if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1691                            diag::err_for_range_iter_deduction_failure)) {
1692    NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1693    return ExprError();
1694  }
1695  return CallExpr;
1696}
1697
1698}
1699
1700static bool ObjCEnumerationCollection(Expr *Collection) {
1701  return !Collection->isTypeDependent()
1702          && Collection->getType()->getAs<ObjCObjectPointerType>() != 0;
1703}
1704
1705/// ActOnCXXForRangeStmt - Check and build a C++0x for-range statement.
1706///
1707/// C++0x [stmt.ranged]:
1708///   A range-based for statement is equivalent to
1709///
1710///   {
1711///     auto && __range = range-init;
1712///     for ( auto __begin = begin-expr,
1713///           __end = end-expr;
1714///           __begin != __end;
1715///           ++__begin ) {
1716///       for-range-declaration = *__begin;
1717///       statement
1718///     }
1719///   }
1720///
1721/// The body of the loop is not available yet, since it cannot be analysed until
1722/// we have determined the type of the for-range-declaration.
1723StmtResult
1724Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1725                           Stmt *First, SourceLocation ColonLoc, Expr *Range,
1726                           SourceLocation RParenLoc) {
1727  if (!First || !Range)
1728    return StmtError();
1729
1730  if (ObjCEnumerationCollection(Range))
1731    return ActOnObjCForCollectionStmt(ForLoc, LParenLoc, First, Range,
1732                                      RParenLoc);
1733
1734  DeclStmt *DS = dyn_cast<DeclStmt>(First);
1735  assert(DS && "first part of for range not a decl stmt");
1736
1737  if (!DS->isSingleDecl()) {
1738    Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1739    return StmtError();
1740  }
1741  if (DS->getSingleDecl()->isInvalidDecl())
1742    return StmtError();
1743
1744  if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1745    return StmtError();
1746
1747  // Build  auto && __range = range-init
1748  SourceLocation RangeLoc = Range->getLocStart();
1749  VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1750                                           Context.getAutoRRefDeductType(),
1751                                           "__range");
1752  if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1753                            diag::err_for_range_deduction_failure))
1754    return StmtError();
1755
1756  // Claim the type doesn't contain auto: we've already done the checking.
1757  DeclGroupPtrTy RangeGroup =
1758    BuildDeclaratorGroup((Decl**)&RangeVar, 1, /*TypeMayContainAuto=*/false);
1759  StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
1760  if (RangeDecl.isInvalid())
1761    return StmtError();
1762
1763  return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1764                              /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1765                              RParenLoc);
1766}
1767
1768/// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1769StmtResult
1770Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1771                           Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1772                           Expr *Inc, Stmt *LoopVarDecl,
1773                           SourceLocation RParenLoc) {
1774  Scope *S = getCurScope();
1775
1776  DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1777  VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1778  QualType RangeVarType = RangeVar->getType();
1779
1780  DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1781  VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1782
1783  StmtResult BeginEndDecl = BeginEnd;
1784  ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1785
1786  if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1787    SourceLocation RangeLoc = RangeVar->getLocation();
1788
1789    const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType();
1790
1791    ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1792                                                VK_LValue, ColonLoc);
1793    if (BeginRangeRef.isInvalid())
1794      return StmtError();
1795
1796    ExprResult EndRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1797                                              VK_LValue, ColonLoc);
1798    if (EndRangeRef.isInvalid())
1799      return StmtError();
1800
1801    QualType AutoType = Context.getAutoDeductType();
1802    Expr *Range = RangeVar->getInit();
1803    if (!Range)
1804      return StmtError();
1805    QualType RangeType = Range->getType();
1806
1807    if (RequireCompleteType(RangeLoc, RangeType,
1808                            diag::err_for_range_incomplete_type))
1809      return StmtError();
1810
1811    // Build auto __begin = begin-expr, __end = end-expr.
1812    VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1813                                             "__begin");
1814    VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1815                                           "__end");
1816
1817    // Build begin-expr and end-expr and attach to __begin and __end variables.
1818    ExprResult BeginExpr, EndExpr;
1819    if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
1820      // - if _RangeT is an array type, begin-expr and end-expr are __range and
1821      //   __range + __bound, respectively, where __bound is the array bound. If
1822      //   _RangeT is an array of unknown size or an array of incomplete type,
1823      //   the program is ill-formed;
1824
1825      // begin-expr is __range.
1826      BeginExpr = BeginRangeRef;
1827      if (FinishForRangeVarDecl(*this, BeginVar, BeginRangeRef.get(), ColonLoc,
1828                                diag::err_for_range_iter_deduction_failure)) {
1829        NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1830        return StmtError();
1831      }
1832
1833      // Find the array bound.
1834      ExprResult BoundExpr;
1835      if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
1836        BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(),
1837                                                 Context.getPointerDiffType(),
1838                                                 RangeLoc));
1839      else if (const VariableArrayType *VAT =
1840               dyn_cast<VariableArrayType>(UnqAT))
1841        BoundExpr = VAT->getSizeExpr();
1842      else {
1843        // Can't be a DependentSizedArrayType or an IncompleteArrayType since
1844        // UnqAT is not incomplete and Range is not type-dependent.
1845        llvm_unreachable("Unexpected array type in for-range");
1846      }
1847
1848      // end-expr is __range + __bound.
1849      EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.get(),
1850                           BoundExpr.get());
1851      if (EndExpr.isInvalid())
1852        return StmtError();
1853      if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1854                                diag::err_for_range_iter_deduction_failure)) {
1855        NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1856        return StmtError();
1857      }
1858    } else {
1859      DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1860                                        ColonLoc);
1861      DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1862                                      ColonLoc);
1863
1864      LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1865      LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1866
1867      if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
1868        // - if _RangeT is a class type, the unqualified-ids begin and end are
1869        //   looked up in the scope of class _RangeT as if by class member access
1870        //   lookup (3.4.5), and if either (or both) finds at least one
1871        //   declaration, begin-expr and end-expr are __range.begin() and
1872        //   __range.end(), respectively;
1873        LookupQualifiedName(BeginMemberLookup, D);
1874        LookupQualifiedName(EndMemberLookup, D);
1875
1876        if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1877          Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1878            << RangeType << BeginMemberLookup.empty();
1879          return StmtError();
1880        }
1881      } else {
1882        // - otherwise, begin-expr and end-expr are begin(__range) and
1883        //   end(__range), respectively, where begin and end are looked up with
1884        //   argument-dependent lookup (3.4.2). For the purposes of this name
1885        //   lookup, namespace std is an associated namespace.
1886      }
1887
1888      BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1889                                            BEF_begin, BeginNameInfo,
1890                                            BeginMemberLookup,
1891                                            BeginRangeRef.get());
1892      if (BeginExpr.isInvalid())
1893        return StmtError();
1894
1895      EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1896                                          BEF_end, EndNameInfo,
1897                                          EndMemberLookup, EndRangeRef.get());
1898      if (EndExpr.isInvalid())
1899        return StmtError();
1900    }
1901
1902    // C++0x [decl.spec.auto]p6: BeginType and EndType must be the same.
1903    QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
1904    if (!Context.hasSameType(BeginType, EndType)) {
1905      Diag(RangeLoc, diag::err_for_range_begin_end_types_differ)
1906        << BeginType << EndType;
1907      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1908      NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1909    }
1910
1911    Decl *BeginEndDecls[] = { BeginVar, EndVar };
1912    // Claim the type doesn't contain auto: we've already done the checking.
1913    DeclGroupPtrTy BeginEndGroup =
1914      BuildDeclaratorGroup(BeginEndDecls, 2, /*TypeMayContainAuto=*/false);
1915    BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc);
1916
1917    const QualType BeginRefNonRefType = BeginType.getNonReferenceType();
1918    ExprResult BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1919                                           VK_LValue, ColonLoc);
1920    if (BeginRef.isInvalid())
1921      return StmtError();
1922
1923    ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1924                                         VK_LValue, ColonLoc);
1925    if (EndRef.isInvalid())
1926      return StmtError();
1927
1928    // Build and check __begin != __end expression.
1929    NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
1930                           BeginRef.get(), EndRef.get());
1931    NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get());
1932    NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get());
1933    if (NotEqExpr.isInvalid()) {
1934      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1935      if (!Context.hasSameType(BeginType, EndType))
1936        NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1937      return StmtError();
1938    }
1939
1940    // Build and check ++__begin expression.
1941    BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1942                                VK_LValue, ColonLoc);
1943    if (BeginRef.isInvalid())
1944      return StmtError();
1945
1946    IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
1947    IncrExpr = ActOnFinishFullExpr(IncrExpr.get());
1948    if (IncrExpr.isInvalid()) {
1949      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1950      return StmtError();
1951    }
1952
1953    // Build and check *__begin  expression.
1954    BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1955                                VK_LValue, ColonLoc);
1956    if (BeginRef.isInvalid())
1957      return StmtError();
1958
1959    ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
1960    if (DerefExpr.isInvalid()) {
1961      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1962      return StmtError();
1963    }
1964
1965    // Attach  *__begin  as initializer for VD.
1966    if (!LoopVar->isInvalidDecl()) {
1967      AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false,
1968                           /*TypeMayContainAuto=*/true);
1969      if (LoopVar->isInvalidDecl())
1970        NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1971    }
1972  } else {
1973    // The range is implicitly used as a placeholder when it is dependent.
1974    RangeVar->setUsed();
1975  }
1976
1977  return Owned(new (Context) CXXForRangeStmt(RangeDS,
1978                                     cast_or_null<DeclStmt>(BeginEndDecl.get()),
1979                                             NotEqExpr.take(), IncrExpr.take(),
1980                                             LoopVarDS, /*Body=*/0, ForLoc,
1981                                             ColonLoc, RParenLoc));
1982}
1983
1984/// FinishObjCForCollectionStmt - Attach the body to a objective-C foreach
1985/// statement.
1986StmtResult Sema::FinishObjCForCollectionStmt(Stmt *S, Stmt *B) {
1987  if (!S || !B)
1988    return StmtError();
1989  ObjCForCollectionStmt * ForStmt = cast<ObjCForCollectionStmt>(S);
1990
1991  ForStmt->setBody(B);
1992  return S;
1993}
1994
1995/// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
1996/// This is a separate step from ActOnCXXForRangeStmt because analysis of the
1997/// body cannot be performed until after the type of the range variable is
1998/// determined.
1999StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
2000  if (!S || !B)
2001    return StmtError();
2002
2003  if (isa<ObjCForCollectionStmt>(S))
2004    return FinishObjCForCollectionStmt(S, B);
2005
2006  CXXForRangeStmt *ForStmt = cast<CXXForRangeStmt>(S);
2007  ForStmt->setBody(B);
2008
2009  DiagnoseEmptyStmtBody(ForStmt->getRParenLoc(), B,
2010                        diag::warn_empty_range_based_for_body);
2011
2012  return S;
2013}
2014
2015StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
2016                               SourceLocation LabelLoc,
2017                               LabelDecl *TheDecl) {
2018  getCurFunction()->setHasBranchIntoScope();
2019  TheDecl->setUsed();
2020  return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
2021}
2022
2023StmtResult
2024Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
2025                            Expr *E) {
2026  // Convert operand to void*
2027  if (!E->isTypeDependent()) {
2028    QualType ETy = E->getType();
2029    QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
2030    ExprResult ExprRes = Owned(E);
2031    AssignConvertType ConvTy =
2032      CheckSingleAssignmentConstraints(DestTy, ExprRes);
2033    if (ExprRes.isInvalid())
2034      return StmtError();
2035    E = ExprRes.take();
2036    if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
2037      return StmtError();
2038    E = MaybeCreateExprWithCleanups(E);
2039  }
2040
2041  getCurFunction()->setHasIndirectGoto();
2042
2043  return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
2044}
2045
2046StmtResult
2047Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
2048  Scope *S = CurScope->getContinueParent();
2049  if (!S) {
2050    // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
2051    return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
2052  }
2053
2054  return Owned(new (Context) ContinueStmt(ContinueLoc));
2055}
2056
2057StmtResult
2058Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
2059  Scope *S = CurScope->getBreakParent();
2060  if (!S) {
2061    // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
2062    return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
2063  }
2064
2065  return Owned(new (Context) BreakStmt(BreakLoc));
2066}
2067
2068/// \brief Determine whether the given expression is a candidate for
2069/// copy elision in either a return statement or a throw expression.
2070///
2071/// \param ReturnType If we're determining the copy elision candidate for
2072/// a return statement, this is the return type of the function. If we're
2073/// determining the copy elision candidate for a throw expression, this will
2074/// be a NULL type.
2075///
2076/// \param E The expression being returned from the function or block, or
2077/// being thrown.
2078///
2079/// \param AllowFunctionParameter Whether we allow function parameters to
2080/// be considered NRVO candidates. C++ prohibits this for NRVO itself, but
2081/// we re-use this logic to determine whether we should try to move as part of
2082/// a return or throw (which does allow function parameters).
2083///
2084/// \returns The NRVO candidate variable, if the return statement may use the
2085/// NRVO, or NULL if there is no such candidate.
2086const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
2087                                             Expr *E,
2088                                             bool AllowFunctionParameter) {
2089  QualType ExprType = E->getType();
2090  // - in a return statement in a function with ...
2091  // ... a class return type ...
2092  if (!ReturnType.isNull()) {
2093    if (!ReturnType->isRecordType())
2094      return 0;
2095    // ... the same cv-unqualified type as the function return type ...
2096    if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
2097      return 0;
2098  }
2099
2100  // ... the expression is the name of a non-volatile automatic object
2101  // (other than a function or catch-clause parameter)) ...
2102  const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
2103  if (!DR || DR->refersToEnclosingLocal())
2104    return 0;
2105  const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
2106  if (!VD)
2107    return 0;
2108
2109  // ...object (other than a function or catch-clause parameter)...
2110  if (VD->getKind() != Decl::Var &&
2111      !(AllowFunctionParameter && VD->getKind() == Decl::ParmVar))
2112    return 0;
2113  if (VD->isExceptionVariable()) return 0;
2114
2115  // ...automatic...
2116  if (!VD->hasLocalStorage()) return 0;
2117
2118  // ...non-volatile...
2119  if (VD->getType().isVolatileQualified()) return 0;
2120  if (VD->getType()->isReferenceType()) return 0;
2121
2122  // __block variables can't be allocated in a way that permits NRVO.
2123  if (VD->hasAttr<BlocksAttr>()) return 0;
2124
2125  // Variables with higher required alignment than their type's ABI
2126  // alignment cannot use NRVO.
2127  if (VD->hasAttr<AlignedAttr>() &&
2128      Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VD->getType()))
2129    return 0;
2130
2131  return VD;
2132}
2133
2134/// \brief Perform the initialization of a potentially-movable value, which
2135/// is the result of return value.
2136///
2137/// This routine implements C++0x [class.copy]p33, which attempts to treat
2138/// returned lvalues as rvalues in certain cases (to prefer move construction),
2139/// then falls back to treating them as lvalues if that failed.
2140ExprResult
2141Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
2142                                      const VarDecl *NRVOCandidate,
2143                                      QualType ResultType,
2144                                      Expr *Value,
2145                                      bool AllowNRVO) {
2146  // C++0x [class.copy]p33:
2147  //   When the criteria for elision of a copy operation are met or would
2148  //   be met save for the fact that the source object is a function
2149  //   parameter, and the object to be copied is designated by an lvalue,
2150  //   overload resolution to select the constructor for the copy is first
2151  //   performed as if the object were designated by an rvalue.
2152  ExprResult Res = ExprError();
2153  if (AllowNRVO &&
2154      (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true))) {
2155    ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
2156                              Value->getType(), CK_NoOp, Value, VK_XValue);
2157
2158    Expr *InitExpr = &AsRvalue;
2159    InitializationKind Kind
2160      = InitializationKind::CreateCopy(Value->getLocStart(),
2161                                       Value->getLocStart());
2162    InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
2163
2164    //   [...] If overload resolution fails, or if the type of the first
2165    //   parameter of the selected constructor is not an rvalue reference
2166    //   to the object's type (possibly cv-qualified), overload resolution
2167    //   is performed again, considering the object as an lvalue.
2168    if (Seq) {
2169      for (InitializationSequence::step_iterator Step = Seq.step_begin(),
2170           StepEnd = Seq.step_end();
2171           Step != StepEnd; ++Step) {
2172        if (Step->Kind != InitializationSequence::SK_ConstructorInitialization)
2173          continue;
2174
2175        CXXConstructorDecl *Constructor
2176        = cast<CXXConstructorDecl>(Step->Function.Function);
2177
2178        const RValueReferenceType *RRefType
2179          = Constructor->getParamDecl(0)->getType()
2180                                                 ->getAs<RValueReferenceType>();
2181
2182        // If we don't meet the criteria, break out now.
2183        if (!RRefType ||
2184            !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
2185                            Context.getTypeDeclType(Constructor->getParent())))
2186          break;
2187
2188        // Promote "AsRvalue" to the heap, since we now need this
2189        // expression node to persist.
2190        Value = ImplicitCastExpr::Create(Context, Value->getType(),
2191                                         CK_NoOp, Value, 0, VK_XValue);
2192
2193        // Complete type-checking the initialization of the return type
2194        // using the constructor we found.
2195        Res = Seq.Perform(*this, Entity, Kind, MultiExprArg(&Value, 1));
2196      }
2197    }
2198  }
2199
2200  // Either we didn't meet the criteria for treating an lvalue as an rvalue,
2201  // above, or overload resolution failed. Either way, we need to try
2202  // (again) now with the return value expression as written.
2203  if (Res.isInvalid())
2204    Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
2205
2206  return Res;
2207}
2208
2209/// ActOnCapScopeReturnStmt - Utility routine to type-check return statements
2210/// for capturing scopes.
2211///
2212StmtResult
2213Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
2214  // If this is the first return we've seen, infer the return type.
2215  // [expr.prim.lambda]p4 in C++11; block literals follow a superset of those
2216  // rules which allows multiple return statements.
2217  CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
2218  QualType FnRetType = CurCap->ReturnType;
2219
2220  // For blocks/lambdas with implicit return types, we check each return
2221  // statement individually, and deduce the common return type when the block
2222  // or lambda is completed.
2223  if (CurCap->HasImplicitReturnType) {
2224    if (RetValExp && !isa<InitListExpr>(RetValExp)) {
2225      ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
2226      if (Result.isInvalid())
2227        return StmtError();
2228      RetValExp = Result.take();
2229
2230      if (!RetValExp->isTypeDependent())
2231        FnRetType = RetValExp->getType();
2232      else
2233        FnRetType = CurCap->ReturnType = Context.DependentTy;
2234    } else {
2235      if (RetValExp) {
2236        // C++11 [expr.lambda.prim]p4 bans inferring the result from an
2237        // initializer list, because it is not an expression (even
2238        // though we represent it as one). We still deduce 'void'.
2239        Diag(ReturnLoc, diag::err_lambda_return_init_list)
2240          << RetValExp->getSourceRange();
2241      }
2242
2243      FnRetType = Context.VoidTy;
2244    }
2245
2246    // Although we'll properly infer the type of the block once it's completed,
2247    // make sure we provide a return type now for better error recovery.
2248    if (CurCap->ReturnType.isNull())
2249      CurCap->ReturnType = FnRetType;
2250  }
2251  assert(!FnRetType.isNull());
2252
2253  if (BlockScopeInfo *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
2254    if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
2255      Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
2256      return StmtError();
2257    }
2258  } else {
2259    LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CurCap);
2260    if (LSI->CallOperator->getType()->getAs<FunctionType>()->getNoReturnAttr()){
2261      Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);
2262      return StmtError();
2263    }
2264  }
2265
2266  // Otherwise, verify that this result type matches the previous one.  We are
2267  // pickier with blocks than for normal functions because we don't have GCC
2268  // compatibility to worry about here.
2269  const VarDecl *NRVOCandidate = 0;
2270  if (FnRetType->isDependentType()) {
2271    // Delay processing for now.  TODO: there are lots of dependent
2272    // types we can conclusively prove aren't void.
2273  } else if (FnRetType->isVoidType()) {
2274    if (RetValExp && !isa<InitListExpr>(RetValExp) &&
2275        !(getLangOpts().CPlusPlus &&
2276          (RetValExp->isTypeDependent() ||
2277           RetValExp->getType()->isVoidType()))) {
2278      if (!getLangOpts().CPlusPlus &&
2279          RetValExp->getType()->isVoidType())
2280        Diag(ReturnLoc, diag::ext_return_has_void_expr) << "literal" << 2;
2281      else {
2282        Diag(ReturnLoc, diag::err_return_block_has_expr);
2283        RetValExp = 0;
2284      }
2285    }
2286  } else if (!RetValExp) {
2287    return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
2288  } else if (!RetValExp->isTypeDependent()) {
2289    // we have a non-void block with an expression, continue checking
2290
2291    // C99 6.8.6.4p3(136): The return statement is not an assignment. The
2292    // overlap restriction of subclause 6.5.16.1 does not apply to the case of
2293    // function return.
2294
2295    // In C++ the return statement is handled via a copy initialization.
2296    // the C version of which boils down to CheckSingleAssignmentConstraints.
2297    NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
2298    InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
2299                                                                   FnRetType,
2300                                                          NRVOCandidate != 0);
2301    ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
2302                                                     FnRetType, RetValExp);
2303    if (Res.isInvalid()) {
2304      // FIXME: Cleanup temporaries here, anyway?
2305      return StmtError();
2306    }
2307    RetValExp = Res.take();
2308    CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
2309  }
2310
2311  if (RetValExp) {
2312    CheckImplicitConversions(RetValExp, ReturnLoc);
2313    RetValExp = MaybeCreateExprWithCleanups(RetValExp);
2314  }
2315  ReturnStmt *Result = new (Context) ReturnStmt(ReturnLoc, RetValExp,
2316                                                NRVOCandidate);
2317
2318  // If we need to check for the named return value optimization,
2319  // or if we need to infer the return type,
2320  // save the return statement in our scope for later processing.
2321  if (CurCap->HasImplicitReturnType ||
2322      (getLangOpts().CPlusPlus && FnRetType->isRecordType() &&
2323       !CurContext->isDependentContext()))
2324    FunctionScopes.back()->Returns.push_back(Result);
2325
2326  return Owned(Result);
2327}
2328
2329StmtResult
2330Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
2331  // Check for unexpanded parameter packs.
2332  if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
2333    return StmtError();
2334
2335  if (isa<CapturingScopeInfo>(getCurFunction()))
2336    return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp);
2337
2338  QualType FnRetType;
2339  QualType RelatedRetType;
2340  if (const FunctionDecl *FD = getCurFunctionDecl()) {
2341    FnRetType = FD->getResultType();
2342    if (FD->hasAttr<NoReturnAttr>() ||
2343        FD->getType()->getAs<FunctionType>()->getNoReturnAttr())
2344      Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
2345        << FD->getDeclName();
2346  } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
2347    FnRetType = MD->getResultType();
2348    if (MD->hasRelatedResultType() && MD->getClassInterface()) {
2349      // In the implementation of a method with a related return type, the
2350      // type used to type-check the validity of return statements within the
2351      // method body is a pointer to the type of the class being implemented.
2352      RelatedRetType = Context.getObjCInterfaceType(MD->getClassInterface());
2353      RelatedRetType = Context.getObjCObjectPointerType(RelatedRetType);
2354    }
2355  } else // If we don't have a function/method context, bail.
2356    return StmtError();
2357
2358  ReturnStmt *Result = 0;
2359  if (FnRetType->isVoidType()) {
2360    if (RetValExp) {
2361      if (isa<InitListExpr>(RetValExp)) {
2362        // We simply never allow init lists as the return value of void
2363        // functions. This is compatible because this was never allowed before,
2364        // so there's no legacy code to deal with.
2365        NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
2366        int FunctionKind = 0;
2367        if (isa<ObjCMethodDecl>(CurDecl))
2368          FunctionKind = 1;
2369        else if (isa<CXXConstructorDecl>(CurDecl))
2370          FunctionKind = 2;
2371        else if (isa<CXXDestructorDecl>(CurDecl))
2372          FunctionKind = 3;
2373
2374        Diag(ReturnLoc, diag::err_return_init_list)
2375          << CurDecl->getDeclName() << FunctionKind
2376          << RetValExp->getSourceRange();
2377
2378        // Drop the expression.
2379        RetValExp = 0;
2380      } else if (!RetValExp->isTypeDependent()) {
2381        // C99 6.8.6.4p1 (ext_ since GCC warns)
2382        unsigned D = diag::ext_return_has_expr;
2383        if (RetValExp->getType()->isVoidType())
2384          D = diag::ext_return_has_void_expr;
2385        else {
2386          ExprResult Result = Owned(RetValExp);
2387          Result = IgnoredValueConversions(Result.take());
2388          if (Result.isInvalid())
2389            return StmtError();
2390          RetValExp = Result.take();
2391          RetValExp = ImpCastExprToType(RetValExp,
2392                                        Context.VoidTy, CK_ToVoid).take();
2393        }
2394
2395        // return (some void expression); is legal in C++.
2396        if (D != diag::ext_return_has_void_expr ||
2397            !getLangOpts().CPlusPlus) {
2398          NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
2399
2400          int FunctionKind = 0;
2401          if (isa<ObjCMethodDecl>(CurDecl))
2402            FunctionKind = 1;
2403          else if (isa<CXXConstructorDecl>(CurDecl))
2404            FunctionKind = 2;
2405          else if (isa<CXXDestructorDecl>(CurDecl))
2406            FunctionKind = 3;
2407
2408          Diag(ReturnLoc, D)
2409            << CurDecl->getDeclName() << FunctionKind
2410            << RetValExp->getSourceRange();
2411        }
2412      }
2413
2414      if (RetValExp) {
2415        CheckImplicitConversions(RetValExp, ReturnLoc);
2416        RetValExp = MaybeCreateExprWithCleanups(RetValExp);
2417      }
2418    }
2419
2420    Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
2421  } else if (!RetValExp && !FnRetType->isDependentType()) {
2422    unsigned DiagID = diag::warn_return_missing_expr;  // C90 6.6.6.4p4
2423    // C99 6.8.6.4p1 (ext_ since GCC warns)
2424    if (getLangOpts().C99) DiagID = diag::ext_return_missing_expr;
2425
2426    if (FunctionDecl *FD = getCurFunctionDecl())
2427      Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
2428    else
2429      Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
2430    Result = new (Context) ReturnStmt(ReturnLoc);
2431  } else {
2432    const VarDecl *NRVOCandidate = 0;
2433    if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
2434      // we have a non-void function with an expression, continue checking
2435
2436      if (!RelatedRetType.isNull()) {
2437        // If we have a related result type, perform an extra conversion here.
2438        // FIXME: The diagnostics here don't really describe what is happening.
2439        InitializedEntity Entity =
2440            InitializedEntity::InitializeTemporary(RelatedRetType);
2441
2442        ExprResult Res = PerformCopyInitialization(Entity, SourceLocation(),
2443                                                   RetValExp);
2444        if (Res.isInvalid()) {
2445          // FIXME: Cleanup temporaries here, anyway?
2446          return StmtError();
2447        }
2448        RetValExp = Res.takeAs<Expr>();
2449      }
2450
2451      // C99 6.8.6.4p3(136): The return statement is not an assignment. The
2452      // overlap restriction of subclause 6.5.16.1 does not apply to the case of
2453      // function return.
2454
2455      // In C++ the return statement is handled via a copy initialization,
2456      // the C version of which boils down to CheckSingleAssignmentConstraints.
2457      NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
2458      InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
2459                                                                     FnRetType,
2460                                                            NRVOCandidate != 0);
2461      ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
2462                                                       FnRetType, RetValExp);
2463      if (Res.isInvalid()) {
2464        // FIXME: Cleanup temporaries here, anyway?
2465        return StmtError();
2466      }
2467
2468      RetValExp = Res.takeAs<Expr>();
2469      if (RetValExp)
2470        CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
2471    }
2472
2473    if (RetValExp) {
2474      CheckImplicitConversions(RetValExp, ReturnLoc);
2475      RetValExp = MaybeCreateExprWithCleanups(RetValExp);
2476    }
2477    Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
2478  }
2479
2480  // If we need to check for the named return value optimization, save the
2481  // return statement in our scope for later processing.
2482  if (getLangOpts().CPlusPlus && FnRetType->isRecordType() &&
2483      !CurContext->isDependentContext())
2484    FunctionScopes.back()->Returns.push_back(Result);
2485
2486  return Owned(Result);
2487}
2488
2489/// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
2490/// ignore "noop" casts in places where an lvalue is required by an inline asm.
2491/// We emulate this behavior when -fheinous-gnu-extensions is specified, but
2492/// provide a strong guidance to not use it.
2493///
2494/// This method checks to see if the argument is an acceptable l-value and
2495/// returns false if it is a case we can handle.
2496static bool CheckAsmLValue(const Expr *E, Sema &S) {
2497  // Type dependent expressions will be checked during instantiation.
2498  if (E->isTypeDependent())
2499    return false;
2500
2501  if (E->isLValue())
2502    return false;  // Cool, this is an lvalue.
2503
2504  // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
2505  // are supposed to allow.
2506  const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
2507  if (E != E2 && E2->isLValue()) {
2508    if (!S.getLangOpts().HeinousExtensions)
2509      S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
2510        << E->getSourceRange();
2511    else
2512      S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
2513        << E->getSourceRange();
2514    // Accept, even if we emitted an error diagnostic.
2515    return false;
2516  }
2517
2518  // None of the above, just randomly invalid non-lvalue.
2519  return true;
2520}
2521
2522/// isOperandMentioned - Return true if the specified operand # is mentioned
2523/// anywhere in the decomposed asm string.
2524static bool isOperandMentioned(unsigned OpNo,
2525                         ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) {
2526  for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
2527    const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
2528    if (!Piece.isOperand()) continue;
2529
2530    // If this is a reference to the input and if the input was the smaller
2531    // one, then we have to reject this asm.
2532    if (Piece.getOperandNo() == OpNo)
2533      return true;
2534  }
2535  return false;
2536}
2537
2538StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple,
2539                              bool IsVolatile, unsigned NumOutputs,
2540                              unsigned NumInputs, IdentifierInfo **Names,
2541                              MultiExprArg constraints, MultiExprArg exprs,
2542                              Expr *asmString, MultiExprArg clobbers,
2543                              SourceLocation RParenLoc, bool MSAsm) {
2544  unsigned NumClobbers = clobbers.size();
2545  StringLiteral **Constraints =
2546    reinterpret_cast<StringLiteral**>(constraints.get());
2547  Expr **Exprs = exprs.get();
2548  StringLiteral *AsmString = cast<StringLiteral>(asmString);
2549  StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
2550
2551  SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
2552
2553  // The parser verifies that there is a string literal here.
2554  if (!AsmString->isAscii())
2555    return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
2556      << AsmString->getSourceRange());
2557
2558  for (unsigned i = 0; i != NumOutputs; i++) {
2559    StringLiteral *Literal = Constraints[i];
2560    if (!Literal->isAscii())
2561      return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2562        << Literal->getSourceRange());
2563
2564    StringRef OutputName;
2565    if (Names[i])
2566      OutputName = Names[i]->getName();
2567
2568    TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
2569    if (!Context.getTargetInfo().validateOutputConstraint(Info))
2570      return StmtError(Diag(Literal->getLocStart(),
2571                            diag::err_asm_invalid_output_constraint)
2572                       << Info.getConstraintStr());
2573
2574    // Check that the output exprs are valid lvalues.
2575    Expr *OutputExpr = Exprs[i];
2576    if (CheckAsmLValue(OutputExpr, *this)) {
2577      return StmtError(Diag(OutputExpr->getLocStart(),
2578                  diag::err_asm_invalid_lvalue_in_output)
2579        << OutputExpr->getSourceRange());
2580    }
2581
2582    OutputConstraintInfos.push_back(Info);
2583  }
2584
2585  SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
2586
2587  for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
2588    StringLiteral *Literal = Constraints[i];
2589    if (!Literal->isAscii())
2590      return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2591        << Literal->getSourceRange());
2592
2593    StringRef InputName;
2594    if (Names[i])
2595      InputName = Names[i]->getName();
2596
2597    TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
2598    if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos.data(),
2599                                                NumOutputs, Info)) {
2600      return StmtError(Diag(Literal->getLocStart(),
2601                            diag::err_asm_invalid_input_constraint)
2602                       << Info.getConstraintStr());
2603    }
2604
2605    Expr *InputExpr = Exprs[i];
2606
2607    // Only allow void types for memory constraints.
2608    if (Info.allowsMemory() && !Info.allowsRegister()) {
2609      if (CheckAsmLValue(InputExpr, *this))
2610        return StmtError(Diag(InputExpr->getLocStart(),
2611                              diag::err_asm_invalid_lvalue_in_input)
2612                         << Info.getConstraintStr()
2613                         << InputExpr->getSourceRange());
2614    }
2615
2616    if (Info.allowsRegister()) {
2617      if (InputExpr->getType()->isVoidType()) {
2618        return StmtError(Diag(InputExpr->getLocStart(),
2619                              diag::err_asm_invalid_type_in_input)
2620          << InputExpr->getType() << Info.getConstraintStr()
2621          << InputExpr->getSourceRange());
2622      }
2623    }
2624
2625    ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
2626    if (Result.isInvalid())
2627      return StmtError();
2628
2629    Exprs[i] = Result.take();
2630    InputConstraintInfos.push_back(Info);
2631  }
2632
2633  // Check that the clobbers are valid.
2634  for (unsigned i = 0; i != NumClobbers; i++) {
2635    StringLiteral *Literal = Clobbers[i];
2636    if (!Literal->isAscii())
2637      return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2638        << Literal->getSourceRange());
2639
2640    StringRef Clobber = Literal->getString();
2641
2642    if (!Context.getTargetInfo().isValidClobber(Clobber))
2643      return StmtError(Diag(Literal->getLocStart(),
2644                  diag::err_asm_unknown_register_name) << Clobber);
2645  }
2646
2647  AsmStmt *NS =
2648    new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm,
2649                          NumOutputs, NumInputs, Names, Constraints, Exprs,
2650                          AsmString, NumClobbers, Clobbers, RParenLoc);
2651  // Validate the asm string, ensuring it makes sense given the operands we
2652  // have.
2653  SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
2654  unsigned DiagOffs;
2655  if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
2656    Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
2657           << AsmString->getSourceRange();
2658    return StmtError();
2659  }
2660
2661  // Validate tied input operands for type mismatches.
2662  for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
2663    TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
2664
2665    // If this is a tied constraint, verify that the output and input have
2666    // either exactly the same type, or that they are int/ptr operands with the
2667    // same size (int/long, int*/long, are ok etc).
2668    if (!Info.hasTiedOperand()) continue;
2669
2670    unsigned TiedTo = Info.getTiedOperand();
2671    unsigned InputOpNo = i+NumOutputs;
2672    Expr *OutputExpr = Exprs[TiedTo];
2673    Expr *InputExpr = Exprs[InputOpNo];
2674
2675    if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent())
2676      continue;
2677
2678    QualType InTy = InputExpr->getType();
2679    QualType OutTy = OutputExpr->getType();
2680    if (Context.hasSameType(InTy, OutTy))
2681      continue;  // All types can be tied to themselves.
2682
2683    // Decide if the input and output are in the same domain (integer/ptr or
2684    // floating point.
2685    enum AsmDomain {
2686      AD_Int, AD_FP, AD_Other
2687    } InputDomain, OutputDomain;
2688
2689    if (InTy->isIntegerType() || InTy->isPointerType())
2690      InputDomain = AD_Int;
2691    else if (InTy->isRealFloatingType())
2692      InputDomain = AD_FP;
2693    else
2694      InputDomain = AD_Other;
2695
2696    if (OutTy->isIntegerType() || OutTy->isPointerType())
2697      OutputDomain = AD_Int;
2698    else if (OutTy->isRealFloatingType())
2699      OutputDomain = AD_FP;
2700    else
2701      OutputDomain = AD_Other;
2702
2703    // They are ok if they are the same size and in the same domain.  This
2704    // allows tying things like:
2705    //   void* to int*
2706    //   void* to int            if they are the same size.
2707    //   double to long double   if they are the same size.
2708    //
2709    uint64_t OutSize = Context.getTypeSize(OutTy);
2710    uint64_t InSize = Context.getTypeSize(InTy);
2711    if (OutSize == InSize && InputDomain == OutputDomain &&
2712        InputDomain != AD_Other)
2713      continue;
2714
2715    // If the smaller input/output operand is not mentioned in the asm string,
2716    // then we can promote the smaller one to a larger input and the asm string
2717    // won't notice.
2718    bool SmallerValueMentioned = false;
2719
2720    // If this is a reference to the input and if the input was the smaller
2721    // one, then we have to reject this asm.
2722    if (isOperandMentioned(InputOpNo, Pieces)) {
2723      // This is a use in the asm string of the smaller operand.  Since we
2724      // codegen this by promoting to a wider value, the asm will get printed
2725      // "wrong".
2726      SmallerValueMentioned |= InSize < OutSize;
2727    }
2728    if (isOperandMentioned(TiedTo, Pieces)) {
2729      // If this is a reference to the output, and if the output is the larger
2730      // value, then it's ok because we'll promote the input to the larger type.
2731      SmallerValueMentioned |= OutSize < InSize;
2732    }
2733
2734    // If the smaller value wasn't mentioned in the asm string, and if the
2735    // output was a register, just extend the shorter one to the size of the
2736    // larger one.
2737    if (!SmallerValueMentioned && InputDomain != AD_Other &&
2738        OutputConstraintInfos[TiedTo].allowsRegister())
2739      continue;
2740
2741    // Either both of the operands were mentioned or the smaller one was
2742    // mentioned.  One more special case that we'll allow: if the tied input is
2743    // integer, unmentioned, and is a constant, then we'll allow truncating it
2744    // down to the size of the destination.
2745    if (InputDomain == AD_Int && OutputDomain == AD_Int &&
2746        !isOperandMentioned(InputOpNo, Pieces) &&
2747        InputExpr->isEvaluatable(Context)) {
2748      CastKind castKind =
2749        (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
2750      InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2751      Exprs[InputOpNo] = InputExpr;
2752      NS->setInputExpr(i, InputExpr);
2753      continue;
2754    }
2755
2756    Diag(InputExpr->getLocStart(),
2757         diag::err_asm_tying_incompatible_types)
2758      << InTy << OutTy << OutputExpr->getSourceRange()
2759      << InputExpr->getSourceRange();
2760    return StmtError();
2761  }
2762
2763  return Owned(NS);
2764}
2765
2766static void patchMSAsmStrings(Sema &SemaRef, bool &IsSimple,
2767                              SourceLocation AsmLoc,
2768                              ArrayRef<Token> AsmToks,
2769                              const TargetInfo &TI,
2770                              std::vector<std::string> &AsmStrings) {
2771  assert (!AsmToks.empty() && "Didn't expect an empty AsmToks!");
2772
2773  // Assume simple asm stmt until we parse a non-register identifer.
2774  IsSimple = true;
2775
2776  SmallString<512> Asm;
2777  unsigned NumAsmStrings = 0;
2778  for (unsigned i = 0, e = AsmToks.size(); i != e; ++i) {
2779
2780    // Determine if this should be considered a new asm.
2781    bool isNewAsm = i == 0 || AsmToks[i].isAtStartOfLine() ||
2782      AsmToks[i].is(tok::kw_asm);
2783
2784    // Emit the previous asm string.
2785    if (i && isNewAsm) {
2786      AsmStrings[NumAsmStrings++] = Asm.c_str();
2787      if (AsmToks[i].is(tok::kw_asm)) {
2788        ++i; // Skip __asm
2789        assert (i != e && "Expected another token.");
2790      }
2791    }
2792
2793    // Start a new asm string with the opcode.
2794    if (isNewAsm) {
2795      Asm = AsmToks[i].getIdentifierInfo()->getName().str();
2796      continue;
2797    }
2798
2799    if (i && AsmToks[i].hasLeadingSpace())
2800      Asm += ' ';
2801
2802    // Check the operand(s).
2803    switch (AsmToks[i].getKind()) {
2804    default:
2805      //llvm_unreachable("Unknown token.");
2806      break;
2807    case tok::comma: Asm += ","; break;
2808    case tok::colon: Asm += ":"; break;
2809    case tok::l_square: Asm += "["; break;
2810    case tok::r_square: Asm += "]"; break;
2811    case tok::l_brace: Asm += "{"; break;
2812    case tok::r_brace: Asm += "}"; break;
2813    case tok::numeric_constant: {
2814      SmallString<32> TokenBuf;
2815      TokenBuf.resize(32);
2816      bool StringInvalid = false;
2817      Asm += SemaRef.PP.getSpelling(AsmToks[i], TokenBuf, &StringInvalid);
2818      assert (!StringInvalid && "Expected valid string!");
2819      break;
2820    }
2821    case tok::identifier: {
2822      StringRef Name = AsmToks[i].getIdentifierInfo()->getName();
2823
2824      // Valid registers don't need modification.
2825      if (TI.isValidGCCRegisterName(Name)) {
2826        Asm += Name;
2827        break;
2828      }
2829
2830      // TODO: Lookup the identifier.
2831      IsSimple = false;
2832      break;
2833    }
2834    } // AsmToks[i].getKind()
2835  }
2836
2837  // Emit the final (and possibly only) asm string.
2838  AsmStrings[NumAsmStrings] = Asm.c_str();
2839}
2840
2841// Build the unmodified MSAsmString.
2842static std::string buildMSAsmString(Sema &SemaRef,
2843                                    ArrayRef<Token> AsmToks,
2844                                    unsigned &NumAsmStrings) {
2845  assert (!AsmToks.empty() && "Didn't expect an empty AsmToks!");
2846  SmallString<512> Asm;
2847  SmallString<512> TokenBuf;
2848  TokenBuf.resize(512);
2849
2850  NumAsmStrings = 0;
2851  for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) {
2852    bool isNewAsm = i == 0 || AsmToks[i].isAtStartOfLine() ||
2853      AsmToks[i].is(tok::kw_asm);
2854
2855    if (isNewAsm) {
2856      ++NumAsmStrings;
2857      if (i)
2858        Asm += '\n';
2859      if (AsmToks[i].is(tok::kw_asm)) {
2860        i++; // Skip __asm
2861        assert (i != e && "Expected another token");
2862      }
2863    }
2864
2865    if (i && AsmToks[i].hasLeadingSpace() && !isNewAsm)
2866      Asm += ' ';
2867
2868    bool StringInvalid = false;
2869    Asm += SemaRef.PP.getSpelling(AsmToks[i], TokenBuf, &StringInvalid);
2870    assert (!StringInvalid && "Expected valid string!");
2871  }
2872  return Asm.c_str();
2873}
2874
2875StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc,
2876                                SourceLocation LBraceLoc,
2877                                ArrayRef<Token> AsmToks,
2878                                SourceLocation EndLoc) {
2879  // MS-style inline assembly is not fully supported, so emit a warning.
2880  Diag(AsmLoc, diag::warn_unsupported_msasm);
2881  unsigned NumClobberRegs = 0;
2882  SmallVector<StringRef,4> Clobbers;
2883  SmallVector<std::string,4> ClobberRegs;
2884
2885  // Empty asm statements don't need to instantiate the AsmParser, etc.
2886  if (AsmToks.empty()) {
2887    StringRef AsmString;
2888    MSAsmStmt *NS =
2889      new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc,
2890                              /* IsSimple */ true, /* IsVolatile */ true,
2891                              AsmToks, AsmString, Clobbers, EndLoc);
2892    return Owned(NS);
2893  }
2894
2895  unsigned NumAsmStrings;
2896  std::string AsmString = buildMSAsmString(*this, AsmToks, NumAsmStrings);
2897
2898  bool IsSimple;
2899  std::vector<std::string> PatchedAsmStrings;
2900  PatchedAsmStrings.resize(NumAsmStrings);
2901
2902  // Rewrite operands to appease the AsmParser.
2903  patchMSAsmStrings(*this, IsSimple, AsmLoc, AsmToks, Context.getTargetInfo(),
2904                    PatchedAsmStrings);
2905
2906  // patchMSAsmStrings doesn't correctly patch non-simple asm statements.
2907  if (!IsSimple) {
2908    MSAsmStmt *NS =
2909      new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc,
2910                              /* IsSimple */ true, /* IsVolatile */ true,
2911                              AsmToks, AsmString, Clobbers, EndLoc);
2912    return Owned(NS);
2913  }
2914
2915  // Initialize targets and assembly printers/parsers.
2916  llvm::InitializeAllTargetInfos();
2917  llvm::InitializeAllTargetMCs();
2918  llvm::InitializeAllAsmParsers();
2919
2920  // Get the target specific parser.
2921  std::string Error;
2922  const std::string &TT = Context.getTargetInfo().getTriple().getTriple();
2923  const llvm::Target *TheTarget(llvm::TargetRegistry::lookupTarget(TT, Error));
2924
2925  OwningPtr<llvm::MCAsmInfo> MAI(TheTarget->createMCAsmInfo(TT));
2926  OwningPtr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
2927  OwningPtr<llvm::MCObjectFileInfo> MOFI(new llvm::MCObjectFileInfo());
2928  OwningPtr<llvm::MCSubtargetInfo>
2929    STI(TheTarget->createMCSubtargetInfo(TT, "", ""));
2930
2931  for (unsigned i = 0, e = PatchedAsmStrings.size(); i != e; ++i) {
2932    llvm::SourceMgr SrcMgr;
2933    llvm::MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr);
2934    llvm::MemoryBuffer *Buffer =
2935      llvm::MemoryBuffer::getMemBuffer(PatchedAsmStrings[i], "<inline asm>");
2936
2937    // Tell SrcMgr about this buffer, which is what the parser will pick up.
2938    SrcMgr.AddNewSourceBuffer(Buffer, llvm::SMLoc());
2939
2940    OwningPtr<llvm::MCStreamer> Str;
2941    OwningPtr<llvm::MCAsmParser>
2942      Parser(createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI));
2943    OwningPtr<llvm::MCTargetAsmParser>
2944      TargetParser(TheTarget->createMCAsmParser(*STI, *Parser));
2945    // Change to the Intel dialect.
2946    Parser->setAssemblerDialect(1);
2947    Parser->setTargetParser(*TargetParser.get());
2948
2949    // Prime the lexer.
2950    Parser->Lex();
2951
2952    // Parse the opcode.
2953    StringRef IDVal;
2954    Parser->ParseIdentifier(IDVal);
2955
2956    // Canonicalize the opcode to lower case.
2957    SmallString<128> Opcode;
2958    for (unsigned i = 0, e = IDVal.size(); i != e; ++i)
2959      Opcode.push_back(tolower(IDVal[i]));
2960
2961    // Parse the operands.
2962    llvm::SMLoc IDLoc;
2963    SmallVector<llvm::MCParsedAsmOperand*, 8> Operands;
2964    bool HadError = TargetParser->ParseInstruction(Opcode.str(), IDLoc,
2965                                                   Operands);
2966    assert (!HadError && "Unexpected error parsing instruction");
2967
2968    // Match the MCInstr.
2969    SmallVector<llvm::MCInst, 2> Instrs;
2970    HadError = TargetParser->MatchInstruction(IDLoc, Operands, Instrs);
2971    assert (!HadError && "Unexpected error matching instruction");
2972    assert ((Instrs.size() == 1) && "Expected only a single instruction.");
2973
2974    // Get the instruction descriptor.
2975    llvm::MCInst Inst = Instrs[0];
2976    const llvm::MCInstrInfo *MII = TheTarget->createMCInstrInfo();
2977    const llvm::MCInstrDesc &Desc = MII->get(Inst.getOpcode());
2978    llvm::MCInstPrinter *IP =
2979      TheTarget->createMCInstPrinter(1, *MAI, *MII, *MRI, *STI);
2980
2981    // Build the list of clobbers.
2982    ClobberRegs.resize(NumClobberRegs + Desc.getNumDefs());
2983    for (unsigned i = 0, e = Desc.getNumDefs(); i != e; ++i) {
2984      const llvm::MCOperand &Op = Inst.getOperand(i);
2985      if (!Op.isReg())
2986        continue;
2987
2988      llvm::raw_string_ostream OS(ClobberRegs[NumClobberRegs]);
2989      IP->printRegName(OS, Op.getReg());
2990
2991      StringRef Clobber(OS.str());
2992      if (!Context.getTargetInfo().isValidClobber(Clobber))
2993        return StmtError(Diag(AsmLoc, diag::err_asm_unknown_register_name) <<
2994                         Clobber);
2995      // FIXME: Asm blocks may result in redundant clobbers.
2996      Clobbers.push_back(ClobberRegs[NumClobberRegs++]);
2997    }
2998  }
2999
3000  MSAsmStmt *NS =
3001    new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc,
3002                            IsSimple, /* IsVolatile */ true,
3003                            AsmToks, AsmString, Clobbers, EndLoc);
3004
3005  return Owned(NS);
3006}
3007
3008StmtResult
3009Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
3010                           SourceLocation RParen, Decl *Parm,
3011                           Stmt *Body) {
3012  VarDecl *Var = cast_or_null<VarDecl>(Parm);
3013  if (Var && Var->isInvalidDecl())
3014    return StmtError();
3015
3016  return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
3017}
3018
3019StmtResult
3020Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
3021  return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
3022}
3023
3024StmtResult
3025Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
3026                         MultiStmtArg CatchStmts, Stmt *Finally) {
3027  if (!getLangOpts().ObjCExceptions)
3028    Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
3029
3030  getCurFunction()->setHasBranchProtectedScope();
3031  unsigned NumCatchStmts = CatchStmts.size();
3032  return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
3033                                     CatchStmts.release(),
3034                                     NumCatchStmts,
3035                                     Finally));
3036}
3037
3038StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw) {
3039  if (Throw) {
3040    ExprResult Result = DefaultLvalueConversion(Throw);
3041    if (Result.isInvalid())
3042      return StmtError();
3043
3044    Throw = MaybeCreateExprWithCleanups(Result.take());
3045    QualType ThrowType = Throw->getType();
3046    // Make sure the expression type is an ObjC pointer or "void *".
3047    if (!ThrowType->isDependentType() &&
3048        !ThrowType->isObjCObjectPointerType()) {
3049      const PointerType *PT = ThrowType->getAs<PointerType>();
3050      if (!PT || !PT->getPointeeType()->isVoidType())
3051        return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
3052                         << Throw->getType() << Throw->getSourceRange());
3053    }
3054  }
3055
3056  return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
3057}
3058
3059StmtResult
3060Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
3061                           Scope *CurScope) {
3062  if (!getLangOpts().ObjCExceptions)
3063    Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
3064
3065  if (!Throw) {
3066    // @throw without an expression designates a rethrow (which much occur
3067    // in the context of an @catch clause).
3068    Scope *AtCatchParent = CurScope;
3069    while (AtCatchParent && !AtCatchParent->isAtCatchScope())
3070      AtCatchParent = AtCatchParent->getParent();
3071    if (!AtCatchParent)
3072      return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
3073  }
3074  return BuildObjCAtThrowStmt(AtLoc, Throw);
3075}
3076
3077ExprResult
3078Sema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) {
3079  ExprResult result = DefaultLvalueConversion(operand);
3080  if (result.isInvalid())
3081    return ExprError();
3082  operand = result.take();
3083
3084  // Make sure the expression type is an ObjC pointer or "void *".
3085  QualType type = operand->getType();
3086  if (!type->isDependentType() &&
3087      !type->isObjCObjectPointerType()) {
3088    const PointerType *pointerType = type->getAs<PointerType>();
3089    if (!pointerType || !pointerType->getPointeeType()->isVoidType())
3090      return Diag(atLoc, diag::error_objc_synchronized_expects_object)
3091               << type << operand->getSourceRange();
3092  }
3093
3094  // The operand to @synchronized is a full-expression.
3095  return MaybeCreateExprWithCleanups(operand);
3096}
3097
3098StmtResult
3099Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
3100                                  Stmt *SyncBody) {
3101  // We can't jump into or indirect-jump out of a @synchronized block.
3102  getCurFunction()->setHasBranchProtectedScope();
3103  return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
3104}
3105
3106/// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
3107/// and creates a proper catch handler from them.
3108StmtResult
3109Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl,
3110                         Stmt *HandlerBlock) {
3111  // There's nothing to test that ActOnExceptionDecl didn't already test.
3112  return Owned(new (Context) CXXCatchStmt(CatchLoc,
3113                                          cast_or_null<VarDecl>(ExDecl),
3114                                          HandlerBlock));
3115}
3116
3117StmtResult
3118Sema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) {
3119  getCurFunction()->setHasBranchProtectedScope();
3120  return Owned(new (Context) ObjCAutoreleasePoolStmt(AtLoc, Body));
3121}
3122
3123namespace {
3124
3125class TypeWithHandler {
3126  QualType t;
3127  CXXCatchStmt *stmt;
3128public:
3129  TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
3130  : t(type), stmt(statement) {}
3131
3132  // An arbitrary order is fine as long as it places identical
3133  // types next to each other.
3134  bool operator<(const TypeWithHandler &y) const {
3135    if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr())
3136      return true;
3137    if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
3138      return false;
3139    else
3140      return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
3141  }
3142
3143  bool operator==(const TypeWithHandler& other) const {
3144    return t == other.t;
3145  }
3146
3147  CXXCatchStmt *getCatchStmt() const { return stmt; }
3148  SourceLocation getTypeSpecStartLoc() const {
3149    return stmt->getExceptionDecl()->getTypeSpecStartLoc();
3150  }
3151};
3152
3153}
3154
3155/// ActOnCXXTryBlock - Takes a try compound-statement and a number of
3156/// handlers and creates a try statement from them.
3157StmtResult
3158Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
3159                       MultiStmtArg RawHandlers) {
3160  // Don't report an error if 'try' is used in system headers.
3161  if (!getLangOpts().CXXExceptions &&
3162      !getSourceManager().isInSystemHeader(TryLoc))
3163      Diag(TryLoc, diag::err_exceptions_disabled) << "try";
3164
3165  unsigned NumHandlers = RawHandlers.size();
3166  assert(NumHandlers > 0 &&
3167         "The parser shouldn't call this if there are no handlers.");
3168  Stmt **Handlers = RawHandlers.get();
3169
3170  SmallVector<TypeWithHandler, 8> TypesWithHandlers;
3171
3172  for (unsigned i = 0; i < NumHandlers; ++i) {
3173    CXXCatchStmt *Handler = cast<CXXCatchStmt>(Handlers[i]);
3174    if (!Handler->getExceptionDecl()) {
3175      if (i < NumHandlers - 1)
3176        return StmtError(Diag(Handler->getLocStart(),
3177                              diag::err_early_catch_all));
3178
3179      continue;
3180    }
3181
3182    const QualType CaughtType = Handler->getCaughtType();
3183    const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
3184    TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
3185  }
3186
3187  // Detect handlers for the same type as an earlier one.
3188  if (NumHandlers > 1) {
3189    llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
3190
3191    TypeWithHandler prev = TypesWithHandlers[0];
3192    for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
3193      TypeWithHandler curr = TypesWithHandlers[i];
3194
3195      if (curr == prev) {
3196        Diag(curr.getTypeSpecStartLoc(),
3197             diag::warn_exception_caught_by_earlier_handler)
3198          << curr.getCatchStmt()->getCaughtType().getAsString();
3199        Diag(prev.getTypeSpecStartLoc(),
3200             diag::note_previous_exception_handler)
3201          << prev.getCatchStmt()->getCaughtType().getAsString();
3202      }
3203
3204      prev = curr;
3205    }
3206  }
3207
3208  getCurFunction()->setHasBranchProtectedScope();
3209
3210  // FIXME: We should detect handlers that cannot catch anything because an
3211  // earlier handler catches a superclass. Need to find a method that is not
3212  // quadratic for this.
3213  // Neither of these are explicitly forbidden, but every compiler detects them
3214  // and warns.
3215
3216  return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
3217                                  Handlers, NumHandlers));
3218}
3219
3220StmtResult
3221Sema::ActOnSEHTryBlock(bool IsCXXTry,
3222                       SourceLocation TryLoc,
3223                       Stmt *TryBlock,
3224                       Stmt *Handler) {
3225  assert(TryBlock && Handler);
3226
3227  getCurFunction()->setHasBranchProtectedScope();
3228
3229  return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
3230}
3231
3232StmtResult
3233Sema::ActOnSEHExceptBlock(SourceLocation Loc,
3234                          Expr *FilterExpr,
3235                          Stmt *Block) {
3236  assert(FilterExpr && Block);
3237
3238  if(!FilterExpr->getType()->isIntegerType()) {
3239    return StmtError(Diag(FilterExpr->getExprLoc(),
3240                     diag::err_filter_expression_integral)
3241                     << FilterExpr->getType());
3242  }
3243
3244  return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
3245}
3246
3247StmtResult
3248Sema::ActOnSEHFinallyBlock(SourceLocation Loc,
3249                           Stmt *Block) {
3250  assert(Block);
3251  return Owned(SEHFinallyStmt::Create(Context,Loc,Block));
3252}
3253
3254StmtResult Sema::BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
3255                                            bool IsIfExists,
3256                                            NestedNameSpecifierLoc QualifierLoc,
3257                                            DeclarationNameInfo NameInfo,
3258                                            Stmt *Nested)
3259{
3260  return new (Context) MSDependentExistsStmt(KeywordLoc, IsIfExists,
3261                                             QualifierLoc, NameInfo,
3262                                             cast<CompoundStmt>(Nested));
3263}
3264
3265
3266StmtResult Sema::ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
3267                                            bool IsIfExists,
3268                                            CXXScopeSpec &SS,
3269                                            UnqualifiedId &Name,
3270                                            Stmt *Nested) {
3271  return BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
3272                                    SS.getWithLocInContext(Context),
3273                                    GetNameFromUnqualifiedId(Name),
3274                                    Nested);
3275}
3276