Expr.cpp revision 8d852e35adb46e0799538dfc9c80d44f27cd3597 
1//===--- Expr.cpp - Expression AST Node Implementation --------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expr class and subclasses.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/Expr.h"
15#include "clang/AST/ExprCXX.h"
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/EvaluatedExprVisitor.h"
22#include "clang/AST/RecordLayout.h"
23#include "clang/AST/StmtVisitor.h"
24#include "clang/Lex/LiteralSupport.h"
25#include "clang/Lex/Lexer.h"
26#include "clang/Sema/SemaDiagnostic.h"
27#include "clang/Basic/Builtins.h"
28#include "clang/Basic/SourceManager.h"
29#include "clang/Basic/TargetInfo.h"
30#include "llvm/Support/ErrorHandling.h"
31#include "llvm/Support/raw_ostream.h"
32#include <algorithm>
33#include <cstring>
34using namespace clang;
35
36const CXXRecordDecl *Expr::getBestDynamicClassType() const {
37  const Expr *E = this;
38
39  while (true) {
40    E = E->IgnoreParens();
41    if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
42      if (CE->getCastKind() == CK_DerivedToBase ||
43          CE->getCastKind() == CK_UncheckedDerivedToBase ||
44          CE->getCastKind() == CK_NoOp) {
45        E = CE->getSubExpr();
46        continue;
47      }
48    }
49
50    break;
51  }
52
53  QualType DerivedType = E->getType();
54  if (const PointerType *PTy = DerivedType->getAs<PointerType>())
55    DerivedType = PTy->getPointeeType();
56
57  const RecordType *Ty = DerivedType->castAs<RecordType>();
58  Decl *D = Ty->getDecl();
59  return cast<CXXRecordDecl>(D);
60}
61
62/// isKnownToHaveBooleanValue - Return true if this is an integer expression
63/// that is known to return 0 or 1.  This happens for _Bool/bool expressions
64/// but also int expressions which are produced by things like comparisons in
65/// C.
66bool Expr::isKnownToHaveBooleanValue() const {
67  const Expr *E = IgnoreParens();
68
69  // If this value has _Bool type, it is obvious 0/1.
70  if (E->getType()->isBooleanType()) return true;
71  // If this is a non-scalar-integer type, we don't care enough to try.
72  if (!E->getType()->isIntegralOrEnumerationType()) return false;
73
74  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
75    switch (UO->getOpcode()) {
76    case UO_Plus:
77      return UO->getSubExpr()->isKnownToHaveBooleanValue();
78    default:
79      return false;
80    }
81  }
82
83  // Only look through implicit casts.  If the user writes
84  // '(int) (a && b)' treat it as an arbitrary int.
85  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
86    return CE->getSubExpr()->isKnownToHaveBooleanValue();
87
88  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
89    switch (BO->getOpcode()) {
90    default: return false;
91    case BO_LT:   // Relational operators.
92    case BO_GT:
93    case BO_LE:
94    case BO_GE:
95    case BO_EQ:   // Equality operators.
96    case BO_NE:
97    case BO_LAnd: // AND operator.
98    case BO_LOr:  // Logical OR operator.
99      return true;
100
101    case BO_And:  // Bitwise AND operator.
102    case BO_Xor:  // Bitwise XOR operator.
103    case BO_Or:   // Bitwise OR operator.
104      // Handle things like (x==2)|(y==12).
105      return BO->getLHS()->isKnownToHaveBooleanValue() &&
106             BO->getRHS()->isKnownToHaveBooleanValue();
107
108    case BO_Comma:
109    case BO_Assign:
110      return BO->getRHS()->isKnownToHaveBooleanValue();
111    }
112  }
113
114  if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
115    return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
116           CO->getFalseExpr()->isKnownToHaveBooleanValue();
117
118  return false;
119}
120
121// Amusing macro metaprogramming hack: check whether a class provides
122// a more specific implementation of getExprLoc().
123//
124// See also Stmt.cpp:{getLocStart(),getLocEnd()}.
125namespace {
126  /// This implementation is used when a class provides a custom
127  /// implementation of getExprLoc.
128  template <class E, class T>
129  SourceLocation getExprLocImpl(const Expr *expr,
130                                SourceLocation (T::*v)() const) {
131    return static_cast<const E*>(expr)->getExprLoc();
132  }
133
134  /// This implementation is used when a class doesn't provide
135  /// a custom implementation of getExprLoc.  Overload resolution
136  /// should pick it over the implementation above because it's
137  /// more specialized according to function template partial ordering.
138  template <class E>
139  SourceLocation getExprLocImpl(const Expr *expr,
140                                SourceLocation (Expr::*v)() const) {
141    return static_cast<const E*>(expr)->getLocStart();
142  }
143}
144
145SourceLocation Expr::getExprLoc() const {
146  switch (getStmtClass()) {
147  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
148#define ABSTRACT_STMT(type)
149#define STMT(type, base) \
150  case Stmt::type##Class: llvm_unreachable(#type " is not an Expr"); break;
151#define EXPR(type, base) \
152  case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
153#include "clang/AST/StmtNodes.inc"
154  }
155  llvm_unreachable("unknown statement kind");
156}
157
158//===----------------------------------------------------------------------===//
159// Primary Expressions.
160//===----------------------------------------------------------------------===//
161
162/// \brief Compute the type-, value-, and instantiation-dependence of a
163/// declaration reference
164/// based on the declaration being referenced.
165static void computeDeclRefDependence(ASTContext &Ctx, NamedDecl *D, QualType T,
166                                     bool &TypeDependent,
167                                     bool &ValueDependent,
168                                     bool &InstantiationDependent) {
169  TypeDependent = false;
170  ValueDependent = false;
171  InstantiationDependent = false;
172
173  // (TD) C++ [temp.dep.expr]p3:
174  //   An id-expression is type-dependent if it contains:
175  //
176  // and
177  //
178  // (VD) C++ [temp.dep.constexpr]p2:
179  //  An identifier is value-dependent if it is:
180
181  //  (TD)  - an identifier that was declared with dependent type
182  //  (VD)  - a name declared with a dependent type,
183  if (T->isDependentType()) {
184    TypeDependent = true;
185    ValueDependent = true;
186    InstantiationDependent = true;
187    return;
188  } else if (T->isInstantiationDependentType()) {
189    InstantiationDependent = true;
190  }
191
192  //  (TD)  - a conversion-function-id that specifies a dependent type
193  if (D->getDeclName().getNameKind()
194                                == DeclarationName::CXXConversionFunctionName) {
195    QualType T = D->getDeclName().getCXXNameType();
196    if (T->isDependentType()) {
197      TypeDependent = true;
198      ValueDependent = true;
199      InstantiationDependent = true;
200      return;
201    }
202
203    if (T->isInstantiationDependentType())
204      InstantiationDependent = true;
205  }
206
207  //  (VD)  - the name of a non-type template parameter,
208  if (isa<NonTypeTemplateParmDecl>(D)) {
209    ValueDependent = true;
210    InstantiationDependent = true;
211    return;
212  }
213
214  //  (VD) - a constant with integral or enumeration type and is
215  //         initialized with an expression that is value-dependent.
216  //  (VD) - a constant with literal type and is initialized with an
217  //         expression that is value-dependent [C++11].
218  //  (VD) - FIXME: Missing from the standard:
219  //       -  an entity with reference type and is initialized with an
220  //          expression that is value-dependent [C++11]
221  if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
222    if ((Ctx.getLangOpts().CPlusPlus0x ?
223           Var->getType()->isLiteralType() :
224           Var->getType()->isIntegralOrEnumerationType()) &&
225        (Var->getType().getCVRQualifiers() == Qualifiers::Const ||
226         Var->getType()->isReferenceType())) {
227      if (const Expr *Init = Var->getAnyInitializer())
228        if (Init->isValueDependent()) {
229          ValueDependent = true;
230          InstantiationDependent = true;
231        }
232    }
233
234    // (VD) - FIXME: Missing from the standard:
235    //      -  a member function or a static data member of the current
236    //         instantiation
237    if (Var->isStaticDataMember() &&
238        Var->getDeclContext()->isDependentContext()) {
239      ValueDependent = true;
240      InstantiationDependent = true;
241    }
242
243    return;
244  }
245
246  // (VD) - FIXME: Missing from the standard:
247  //      -  a member function or a static data member of the current
248  //         instantiation
249  if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) {
250    ValueDependent = true;
251    InstantiationDependent = true;
252  }
253}
254
255void DeclRefExpr::computeDependence(ASTContext &Ctx) {
256  bool TypeDependent = false;
257  bool ValueDependent = false;
258  bool InstantiationDependent = false;
259  computeDeclRefDependence(Ctx, getDecl(), getType(), TypeDependent,
260                           ValueDependent, InstantiationDependent);
261
262  // (TD) C++ [temp.dep.expr]p3:
263  //   An id-expression is type-dependent if it contains:
264  //
265  // and
266  //
267  // (VD) C++ [temp.dep.constexpr]p2:
268  //  An identifier is value-dependent if it is:
269  if (!TypeDependent && !ValueDependent &&
270      hasExplicitTemplateArgs() &&
271      TemplateSpecializationType::anyDependentTemplateArguments(
272                                                            getTemplateArgs(),
273                                                       getNumTemplateArgs(),
274                                                      InstantiationDependent)) {
275    TypeDependent = true;
276    ValueDependent = true;
277    InstantiationDependent = true;
278  }
279
280  ExprBits.TypeDependent = TypeDependent;
281  ExprBits.ValueDependent = ValueDependent;
282  ExprBits.InstantiationDependent = InstantiationDependent;
283
284  // Is the declaration a parameter pack?
285  if (getDecl()->isParameterPack())
286    ExprBits.ContainsUnexpandedParameterPack = true;
287}
288
289DeclRefExpr::DeclRefExpr(ASTContext &Ctx,
290                         NestedNameSpecifierLoc QualifierLoc,
291                         SourceLocation TemplateKWLoc,
292                         ValueDecl *D, bool RefersToEnclosingLocal,
293                         const DeclarationNameInfo &NameInfo,
294                         NamedDecl *FoundD,
295                         const TemplateArgumentListInfo *TemplateArgs,
296                         QualType T, ExprValueKind VK)
297  : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
298    D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) {
299  DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0;
300  if (QualifierLoc)
301    getInternalQualifierLoc() = QualifierLoc;
302  DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
303  if (FoundD)
304    getInternalFoundDecl() = FoundD;
305  DeclRefExprBits.HasTemplateKWAndArgsInfo
306    = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;
307  DeclRefExprBits.RefersToEnclosingLocal = RefersToEnclosingLocal;
308  if (TemplateArgs) {
309    bool Dependent = false;
310    bool InstantiationDependent = false;
311    bool ContainsUnexpandedParameterPack = false;
312    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
313                                               Dependent,
314                                               InstantiationDependent,
315                                               ContainsUnexpandedParameterPack);
316    if (InstantiationDependent)
317      setInstantiationDependent(true);
318  } else if (TemplateKWLoc.isValid()) {
319    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
320  }
321  DeclRefExprBits.HadMultipleCandidates = 0;
322
323  computeDependence(Ctx);
324}
325
326DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
327                                 NestedNameSpecifierLoc QualifierLoc,
328                                 SourceLocation TemplateKWLoc,
329                                 ValueDecl *D,
330                                 bool RefersToEnclosingLocal,
331                                 SourceLocation NameLoc,
332                                 QualType T,
333                                 ExprValueKind VK,
334                                 NamedDecl *FoundD,
335                                 const TemplateArgumentListInfo *TemplateArgs) {
336  return Create(Context, QualifierLoc, TemplateKWLoc, D,
337                RefersToEnclosingLocal,
338                DeclarationNameInfo(D->getDeclName(), NameLoc),
339                T, VK, FoundD, TemplateArgs);
340}
341
342DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
343                                 NestedNameSpecifierLoc QualifierLoc,
344                                 SourceLocation TemplateKWLoc,
345                                 ValueDecl *D,
346                                 bool RefersToEnclosingLocal,
347                                 const DeclarationNameInfo &NameInfo,
348                                 QualType T,
349                                 ExprValueKind VK,
350                                 NamedDecl *FoundD,
351                                 const TemplateArgumentListInfo *TemplateArgs) {
352  // Filter out cases where the found Decl is the same as the value refenenced.
353  if (D == FoundD)
354    FoundD = 0;
355
356  std::size_t Size = sizeof(DeclRefExpr);
357  if (QualifierLoc != 0)
358    Size += sizeof(NestedNameSpecifierLoc);
359  if (FoundD)
360    Size += sizeof(NamedDecl *);
361  if (TemplateArgs)
362    Size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size());
363  else if (TemplateKWLoc.isValid())
364    Size += ASTTemplateKWAndArgsInfo::sizeFor(0);
365
366  void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
367  return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,
368                               RefersToEnclosingLocal,
369                               NameInfo, FoundD, TemplateArgs, T, VK);
370}
371
372DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext &Context,
373                                      bool HasQualifier,
374                                      bool HasFoundDecl,
375                                      bool HasTemplateKWAndArgsInfo,
376                                      unsigned NumTemplateArgs) {
377  std::size_t Size = sizeof(DeclRefExpr);
378  if (HasQualifier)
379    Size += sizeof(NestedNameSpecifierLoc);
380  if (HasFoundDecl)
381    Size += sizeof(NamedDecl *);
382  if (HasTemplateKWAndArgsInfo)
383    Size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
384
385  void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
386  return new (Mem) DeclRefExpr(EmptyShell());
387}
388
389SourceRange DeclRefExpr::getSourceRange() const {
390  SourceRange R = getNameInfo().getSourceRange();
391  if (hasQualifier())
392    R.setBegin(getQualifierLoc().getBeginLoc());
393  if (hasExplicitTemplateArgs())
394    R.setEnd(getRAngleLoc());
395  return R;
396}
397SourceLocation DeclRefExpr::getLocStart() const {
398  if (hasQualifier())
399    return getQualifierLoc().getBeginLoc();
400  return getNameInfo().getLocStart();
401}
402SourceLocation DeclRefExpr::getLocEnd() const {
403  if (hasExplicitTemplateArgs())
404    return getRAngleLoc();
405  return getNameInfo().getLocEnd();
406}
407
408// FIXME: Maybe this should use DeclPrinter with a special "print predefined
409// expr" policy instead.
410std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
411  ASTContext &Context = CurrentDecl->getASTContext();
412
413  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
414    if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual)
415      return FD->getNameAsString();
416
417    SmallString<256> Name;
418    llvm::raw_svector_ostream Out(Name);
419
420    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
421      if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
422        Out << "virtual ";
423      if (MD->isStatic())
424        Out << "static ";
425    }
426
427    PrintingPolicy Policy(Context.getLangOpts());
428    std::string Proto = FD->getQualifiedNameAsString(Policy);
429    llvm::raw_string_ostream POut(Proto);
430
431    const FunctionDecl *Decl = FD;
432    if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern())
433      Decl = Pattern;
434    const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
435    const FunctionProtoType *FT = 0;
436    if (FD->hasWrittenPrototype())
437      FT = dyn_cast<FunctionProtoType>(AFT);
438
439    POut << "(";
440    if (FT) {
441      for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) {
442        if (i) POut << ", ";
443        POut << Decl->getParamDecl(i)->getType().stream(Policy);
444      }
445
446      if (FT->isVariadic()) {
447        if (FD->getNumParams()) POut << ", ";
448        POut << "...";
449      }
450    }
451    POut << ")";
452
453    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
454      Qualifiers ThisQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
455      if (ThisQuals.hasConst())
456        POut << " const";
457      if (ThisQuals.hasVolatile())
458        POut << " volatile";
459      RefQualifierKind Ref = MD->getRefQualifier();
460      if (Ref == RQ_LValue)
461        POut << " &";
462      else if (Ref == RQ_RValue)
463        POut << " &&";
464    }
465
466    typedef SmallVector<const ClassTemplateSpecializationDecl *, 8> SpecsTy;
467    SpecsTy Specs;
468    const DeclContext *Ctx = FD->getDeclContext();
469    while (Ctx && isa<NamedDecl>(Ctx)) {
470      const ClassTemplateSpecializationDecl *Spec
471                               = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
472      if (Spec && !Spec->isExplicitSpecialization())
473        Specs.push_back(Spec);
474      Ctx = Ctx->getParent();
475    }
476
477    std::string TemplateParams;
478    llvm::raw_string_ostream TOut(TemplateParams);
479    for (SpecsTy::reverse_iterator I = Specs.rbegin(), E = Specs.rend();
480         I != E; ++I) {
481      const TemplateParameterList *Params
482                  = (*I)->getSpecializedTemplate()->getTemplateParameters();
483      const TemplateArgumentList &Args = (*I)->getTemplateArgs();
484      assert(Params->size() == Args.size());
485      for (unsigned i = 0, numParams = Params->size(); i != numParams; ++i) {
486        StringRef Param = Params->getParam(i)->getName();
487        if (Param.empty()) continue;
488        TOut << Param << " = ";
489        Args.get(i).print(Policy, TOut);
490        TOut << ", ";
491      }
492    }
493
494    FunctionTemplateSpecializationInfo *FSI
495                                          = FD->getTemplateSpecializationInfo();
496    if (FSI && !FSI->isExplicitSpecialization()) {
497      const TemplateParameterList* Params
498                                  = FSI->getTemplate()->getTemplateParameters();
499      const TemplateArgumentList* Args = FSI->TemplateArguments;
500      assert(Params->size() == Args->size());
501      for (unsigned i = 0, e = Params->size(); i != e; ++i) {
502        StringRef Param = Params->getParam(i)->getName();
503        if (Param.empty()) continue;
504        TOut << Param << " = ";
505        Args->get(i).print(Policy, TOut);
506        TOut << ", ";
507      }
508    }
509
510    TOut.flush();
511    if (!TemplateParams.empty()) {
512      // remove the trailing comma and space
513      TemplateParams.resize(TemplateParams.size() - 2);
514      POut << " [" << TemplateParams << "]";
515    }
516
517    POut.flush();
518
519    if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
520      AFT->getResultType().getAsStringInternal(Proto, Policy);
521
522    Out << Proto;
523
524    Out.flush();
525    return Name.str().str();
526  }
527  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
528    SmallString<256> Name;
529    llvm::raw_svector_ostream Out(Name);
530    Out << (MD->isInstanceMethod() ? '-' : '+');
531    Out << '[';
532
533    // For incorrect code, there might not be an ObjCInterfaceDecl.  Do
534    // a null check to avoid a crash.
535    if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
536      Out << *ID;
537
538    if (const ObjCCategoryImplDecl *CID =
539        dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
540      Out << '(' << *CID << ')';
541
542    Out <<  ' ';
543    Out << MD->getSelector().getAsString();
544    Out <<  ']';
545
546    Out.flush();
547    return Name.str().str();
548  }
549  if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
550    // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
551    return "top level";
552  }
553  return "";
554}
555
556void APNumericStorage::setIntValue(ASTContext &C, const llvm::APInt &Val) {
557  if (hasAllocation())
558    C.Deallocate(pVal);
559
560  BitWidth = Val.getBitWidth();
561  unsigned NumWords = Val.getNumWords();
562  const uint64_t* Words = Val.getRawData();
563  if (NumWords > 1) {
564    pVal = new (C) uint64_t[NumWords];
565    std::copy(Words, Words + NumWords, pVal);
566  } else if (NumWords == 1)
567    VAL = Words[0];
568  else
569    VAL = 0;
570}
571
572IntegerLiteral *
573IntegerLiteral::Create(ASTContext &C, const llvm::APInt &V,
574                       QualType type, SourceLocation l) {
575  return new (C) IntegerLiteral(C, V, type, l);
576}
577
578IntegerLiteral *
579IntegerLiteral::Create(ASTContext &C, EmptyShell Empty) {
580  return new (C) IntegerLiteral(Empty);
581}
582
583FloatingLiteral *
584FloatingLiteral::Create(ASTContext &C, const llvm::APFloat &V,
585                        bool isexact, QualType Type, SourceLocation L) {
586  return new (C) FloatingLiteral(C, V, isexact, Type, L);
587}
588
589FloatingLiteral *
590FloatingLiteral::Create(ASTContext &C, EmptyShell Empty) {
591  return new (C) FloatingLiteral(C, Empty);
592}
593
594/// getValueAsApproximateDouble - This returns the value as an inaccurate
595/// double.  Note that this may cause loss of precision, but is useful for
596/// debugging dumps, etc.
597double FloatingLiteral::getValueAsApproximateDouble() const {
598  llvm::APFloat V = getValue();
599  bool ignored;
600  V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
601            &ignored);
602  return V.convertToDouble();
603}
604
605int StringLiteral::mapCharByteWidth(TargetInfo const &target,StringKind k) {
606  int CharByteWidth = 0;
607  switch(k) {
608    case Ascii:
609    case UTF8:
610      CharByteWidth = target.getCharWidth();
611      break;
612    case Wide:
613      CharByteWidth = target.getWCharWidth();
614      break;
615    case UTF16:
616      CharByteWidth = target.getChar16Width();
617      break;
618    case UTF32:
619      CharByteWidth = target.getChar32Width();
620      break;
621  }
622  assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple");
623  CharByteWidth /= 8;
624  assert((CharByteWidth==1 || CharByteWidth==2 || CharByteWidth==4)
625         && "character byte widths supported are 1, 2, and 4 only");
626  return CharByteWidth;
627}
628
629StringLiteral *StringLiteral::Create(ASTContext &C, StringRef Str,
630                                     StringKind Kind, bool Pascal, QualType Ty,
631                                     const SourceLocation *Loc,
632                                     unsigned NumStrs) {
633  // Allocate enough space for the StringLiteral plus an array of locations for
634  // any concatenated string tokens.
635  void *Mem = C.Allocate(sizeof(StringLiteral)+
636                         sizeof(SourceLocation)*(NumStrs-1),
637                         llvm::alignOf<StringLiteral>());
638  StringLiteral *SL = new (Mem) StringLiteral(Ty);
639
640  // OPTIMIZE: could allocate this appended to the StringLiteral.
641  SL->setString(C,Str,Kind,Pascal);
642
643  SL->TokLocs[0] = Loc[0];
644  SL->NumConcatenated = NumStrs;
645
646  if (NumStrs != 1)
647    memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
648  return SL;
649}
650
651StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
652  void *Mem = C.Allocate(sizeof(StringLiteral)+
653                         sizeof(SourceLocation)*(NumStrs-1),
654                         llvm::alignOf<StringLiteral>());
655  StringLiteral *SL = new (Mem) StringLiteral(QualType());
656  SL->CharByteWidth = 0;
657  SL->Length = 0;
658  SL->NumConcatenated = NumStrs;
659  return SL;
660}
661
662void StringLiteral::outputString(raw_ostream &OS) {
663  switch (getKind()) {
664  case Ascii: break; // no prefix.
665  case Wide:  OS << 'L'; break;
666  case UTF8:  OS << "u8"; break;
667  case UTF16: OS << 'u'; break;
668  case UTF32: OS << 'U'; break;
669  }
670  OS << '"';
671  static const char Hex[] = "0123456789ABCDEF";
672
673  unsigned LastSlashX = getLength();
674  for (unsigned I = 0, N = getLength(); I != N; ++I) {
675    switch (uint32_t Char = getCodeUnit(I)) {
676    default:
677      // FIXME: Convert UTF-8 back to codepoints before rendering.
678
679      // Convert UTF-16 surrogate pairs back to codepoints before rendering.
680      // Leave invalid surrogates alone; we'll use \x for those.
681      if (getKind() == UTF16 && I != N - 1 && Char >= 0xd800 &&
682          Char <= 0xdbff) {
683        uint32_t Trail = getCodeUnit(I + 1);
684        if (Trail >= 0xdc00 && Trail <= 0xdfff) {
685          Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);
686          ++I;
687        }
688      }
689
690      if (Char > 0xff) {
691        // If this is a wide string, output characters over 0xff using \x
692        // escapes. Otherwise, this is a UTF-16 or UTF-32 string, and Char is a
693        // codepoint: use \x escapes for invalid codepoints.
694        if (getKind() == Wide ||
695            (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
696          // FIXME: Is this the best way to print wchar_t?
697          OS << "\\x";
698          int Shift = 28;
699          while ((Char >> Shift) == 0)
700            Shift -= 4;
701          for (/**/; Shift >= 0; Shift -= 4)
702            OS << Hex[(Char >> Shift) & 15];
703          LastSlashX = I;
704          break;
705        }
706
707        if (Char > 0xffff)
708          OS << "\\U00"
709             << Hex[(Char >> 20) & 15]
710             << Hex[(Char >> 16) & 15];
711        else
712          OS << "\\u";
713        OS << Hex[(Char >> 12) & 15]
714           << Hex[(Char >>  8) & 15]
715           << Hex[(Char >>  4) & 15]
716           << Hex[(Char >>  0) & 15];
717        break;
718      }
719
720      // If we used \x... for the previous character, and this character is a
721      // hexadecimal digit, prevent it being slurped as part of the \x.
722      if (LastSlashX + 1 == I) {
723        switch (Char) {
724          case '0': case '1': case '2': case '3': case '4':
725          case '5': case '6': case '7': case '8': case '9':
726          case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
727          case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
728            OS << "\"\"";
729        }
730      }
731
732      assert(Char <= 0xff &&
733             "Characters above 0xff should already have been handled.");
734
735      if (isprint(Char))
736        OS << (char)Char;
737      else  // Output anything hard as an octal escape.
738        OS << '\\'
739           << (char)('0' + ((Char >> 6) & 7))
740           << (char)('0' + ((Char >> 3) & 7))
741           << (char)('0' + ((Char >> 0) & 7));
742      break;
743    // Handle some common non-printable cases to make dumps prettier.
744    case '\\': OS << "\\\\"; break;
745    case '"': OS << "\\\""; break;
746    case '\n': OS << "\\n"; break;
747    case '\t': OS << "\\t"; break;
748    case '\a': OS << "\\a"; break;
749    case '\b': OS << "\\b"; break;
750    }
751  }
752  OS << '"';
753}
754
755void StringLiteral::setString(ASTContext &C, StringRef Str,
756                              StringKind Kind, bool IsPascal) {
757  //FIXME: we assume that the string data comes from a target that uses the same
758  // code unit size and endianess for the type of string.
759  this->Kind = Kind;
760  this->IsPascal = IsPascal;
761
762  CharByteWidth = mapCharByteWidth(C.getTargetInfo(),Kind);
763  assert((Str.size()%CharByteWidth == 0)
764         && "size of data must be multiple of CharByteWidth");
765  Length = Str.size()/CharByteWidth;
766
767  switch(CharByteWidth) {
768    case 1: {
769      char *AStrData = new (C) char[Length];
770      std::memcpy(AStrData,Str.data(),Str.size());
771      StrData.asChar = AStrData;
772      break;
773    }
774    case 2: {
775      uint16_t *AStrData = new (C) uint16_t[Length];
776      std::memcpy(AStrData,Str.data(),Str.size());
777      StrData.asUInt16 = AStrData;
778      break;
779    }
780    case 4: {
781      uint32_t *AStrData = new (C) uint32_t[Length];
782      std::memcpy(AStrData,Str.data(),Str.size());
783      StrData.asUInt32 = AStrData;
784      break;
785    }
786    default:
787      assert(false && "unsupported CharByteWidth");
788  }
789}
790
791/// getLocationOfByte - Return a source location that points to the specified
792/// byte of this string literal.
793///
794/// Strings are amazingly complex.  They can be formed from multiple tokens and
795/// can have escape sequences in them in addition to the usual trigraph and
796/// escaped newline business.  This routine handles this complexity.
797///
798SourceLocation StringLiteral::
799getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
800                  const LangOptions &Features, const TargetInfo &Target) const {
801  assert((Kind == StringLiteral::Ascii || Kind == StringLiteral::UTF8) &&
802         "Only narrow string literals are currently supported");
803
804  // Loop over all of the tokens in this string until we find the one that
805  // contains the byte we're looking for.
806  unsigned TokNo = 0;
807  while (1) {
808    assert(TokNo < getNumConcatenated() && "Invalid byte number!");
809    SourceLocation StrTokLoc = getStrTokenLoc(TokNo);
810
811    // Get the spelling of the string so that we can get the data that makes up
812    // the string literal, not the identifier for the macro it is potentially
813    // expanded through.
814    SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc);
815
816    // Re-lex the token to get its length and original spelling.
817    std::pair<FileID, unsigned> LocInfo =SM.getDecomposedLoc(StrTokSpellingLoc);
818    bool Invalid = false;
819    StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);
820    if (Invalid)
821      return StrTokSpellingLoc;
822
823    const char *StrData = Buffer.data()+LocInfo.second;
824
825    // Create a lexer starting at the beginning of this token.
826    Lexer TheLexer(SM.getLocForStartOfFile(LocInfo.first), Features,
827                   Buffer.begin(), StrData, Buffer.end());
828    Token TheTok;
829    TheLexer.LexFromRawLexer(TheTok);
830
831    // Use the StringLiteralParser to compute the length of the string in bytes.
832    StringLiteralParser SLP(&TheTok, 1, SM, Features, Target);
833    unsigned TokNumBytes = SLP.GetStringLength();
834
835    // If the byte is in this token, return the location of the byte.
836    if (ByteNo < TokNumBytes ||
837        (ByteNo == TokNumBytes && TokNo == getNumConcatenated() - 1)) {
838      unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo);
839
840      // Now that we know the offset of the token in the spelling, use the
841      // preprocessor to get the offset in the original source.
842      return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features);
843    }
844
845    // Move to the next string token.
846    ++TokNo;
847    ByteNo -= TokNumBytes;
848  }
849}
850
851
852
853/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
854/// corresponds to, e.g. "sizeof" or "[pre]++".
855const char *UnaryOperator::getOpcodeStr(Opcode Op) {
856  switch (Op) {
857  case UO_PostInc: return "++";
858  case UO_PostDec: return "--";
859  case UO_PreInc:  return "++";
860  case UO_PreDec:  return "--";
861  case UO_AddrOf:  return "&";
862  case UO_Deref:   return "*";
863  case UO_Plus:    return "+";
864  case UO_Minus:   return "-";
865  case UO_Not:     return "~";
866  case UO_LNot:    return "!";
867  case UO_Real:    return "__real";
868  case UO_Imag:    return "__imag";
869  case UO_Extension: return "__extension__";
870  }
871  llvm_unreachable("Unknown unary operator");
872}
873
874UnaryOperatorKind
875UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
876  switch (OO) {
877  default: llvm_unreachable("No unary operator for overloaded function");
878  case OO_PlusPlus:   return Postfix ? UO_PostInc : UO_PreInc;
879  case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;
880  case OO_Amp:        return UO_AddrOf;
881  case OO_Star:       return UO_Deref;
882  case OO_Plus:       return UO_Plus;
883  case OO_Minus:      return UO_Minus;
884  case OO_Tilde:      return UO_Not;
885  case OO_Exclaim:    return UO_LNot;
886  }
887}
888
889OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
890  switch (Opc) {
891  case UO_PostInc: case UO_PreInc: return OO_PlusPlus;
892  case UO_PostDec: case UO_PreDec: return OO_MinusMinus;
893  case UO_AddrOf: return OO_Amp;
894  case UO_Deref: return OO_Star;
895  case UO_Plus: return OO_Plus;
896  case UO_Minus: return OO_Minus;
897  case UO_Not: return OO_Tilde;
898  case UO_LNot: return OO_Exclaim;
899  default: return OO_None;
900  }
901}
902
903
904//===----------------------------------------------------------------------===//
905// Postfix Operators.
906//===----------------------------------------------------------------------===//
907
908CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs,
909                   Expr **args, unsigned numargs, QualType t, ExprValueKind VK,
910                   SourceLocation rparenloc)
911  : Expr(SC, t, VK, OK_Ordinary,
912         fn->isTypeDependent(),
913         fn->isValueDependent(),
914         fn->isInstantiationDependent(),
915         fn->containsUnexpandedParameterPack()),
916    NumArgs(numargs) {
917
918  SubExprs = new (C) Stmt*[numargs+PREARGS_START+NumPreArgs];
919  SubExprs[FN] = fn;
920  for (unsigned i = 0; i != numargs; ++i) {
921    if (args[i]->isTypeDependent())
922      ExprBits.TypeDependent = true;
923    if (args[i]->isValueDependent())
924      ExprBits.ValueDependent = true;
925    if (args[i]->isInstantiationDependent())
926      ExprBits.InstantiationDependent = true;
927    if (args[i]->containsUnexpandedParameterPack())
928      ExprBits.ContainsUnexpandedParameterPack = true;
929
930    SubExprs[i+PREARGS_START+NumPreArgs] = args[i];
931  }
932
933  CallExprBits.NumPreArgs = NumPreArgs;
934  RParenLoc = rparenloc;
935}
936
937CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
938                   QualType t, ExprValueKind VK, SourceLocation rparenloc)
939  : Expr(CallExprClass, t, VK, OK_Ordinary,
940         fn->isTypeDependent(),
941         fn->isValueDependent(),
942         fn->isInstantiationDependent(),
943         fn->containsUnexpandedParameterPack()),
944    NumArgs(numargs) {
945
946  SubExprs = new (C) Stmt*[numargs+PREARGS_START];
947  SubExprs[FN] = fn;
948  for (unsigned i = 0; i != numargs; ++i) {
949    if (args[i]->isTypeDependent())
950      ExprBits.TypeDependent = true;
951    if (args[i]->isValueDependent())
952      ExprBits.ValueDependent = true;
953    if (args[i]->isInstantiationDependent())
954      ExprBits.InstantiationDependent = true;
955    if (args[i]->containsUnexpandedParameterPack())
956      ExprBits.ContainsUnexpandedParameterPack = true;
957
958    SubExprs[i+PREARGS_START] = args[i];
959  }
960
961  CallExprBits.NumPreArgs = 0;
962  RParenLoc = rparenloc;
963}
964
965CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
966  : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
967  // FIXME: Why do we allocate this?
968  SubExprs = new (C) Stmt*[PREARGS_START];
969  CallExprBits.NumPreArgs = 0;
970}
971
972CallExpr::CallExpr(ASTContext &C, StmtClass SC, unsigned NumPreArgs,
973                   EmptyShell Empty)
974  : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
975  // FIXME: Why do we allocate this?
976  SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs];
977  CallExprBits.NumPreArgs = NumPreArgs;
978}
979
980Decl *CallExpr::getCalleeDecl() {
981  Expr *CEE = getCallee()->IgnoreParenImpCasts();
982
983  while (SubstNonTypeTemplateParmExpr *NTTP
984                                = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
985    CEE = NTTP->getReplacement()->IgnoreParenCasts();
986  }
987
988  // If we're calling a dereference, look at the pointer instead.
989  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) {
990    if (BO->isPtrMemOp())
991      CEE = BO->getRHS()->IgnoreParenCasts();
992  } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
993    if (UO->getOpcode() == UO_Deref)
994      CEE = UO->getSubExpr()->IgnoreParenCasts();
995  }
996  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
997    return DRE->getDecl();
998  if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
999    return ME->getMemberDecl();
1000
1001  return 0;
1002}
1003
1004FunctionDecl *CallExpr::getDirectCallee() {
1005  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
1006}
1007
1008/// setNumArgs - This changes the number of arguments present in this call.
1009/// Any orphaned expressions are deleted by this, and any new operands are set
1010/// to null.
1011void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
1012  // No change, just return.
1013  if (NumArgs == getNumArgs()) return;
1014
1015  // If shrinking # arguments, just delete the extras and forgot them.
1016  if (NumArgs < getNumArgs()) {
1017    this->NumArgs = NumArgs;
1018    return;
1019  }
1020
1021  // Otherwise, we are growing the # arguments.  New an bigger argument array.
1022  unsigned NumPreArgs = getNumPreArgs();
1023  Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs];
1024  // Copy over args.
1025  for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i)
1026    NewSubExprs[i] = SubExprs[i];
1027  // Null out new args.
1028  for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs;
1029       i != NumArgs+PREARGS_START+NumPreArgs; ++i)
1030    NewSubExprs[i] = 0;
1031
1032  if (SubExprs) C.Deallocate(SubExprs);
1033  SubExprs = NewSubExprs;
1034  this->NumArgs = NumArgs;
1035}
1036
1037/// isBuiltinCall - If this is a call to a builtin, return the builtin ID.  If
1038/// not, return 0.
1039unsigned CallExpr::isBuiltinCall() const {
1040  // All simple function calls (e.g. func()) are implicitly cast to pointer to
1041  // function. As a result, we try and obtain the DeclRefExpr from the
1042  // ImplicitCastExpr.
1043  const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
1044  if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
1045    return 0;
1046
1047  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
1048  if (!DRE)
1049    return 0;
1050
1051  const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
1052  if (!FDecl)
1053    return 0;
1054
1055  if (!FDecl->getIdentifier())
1056    return 0;
1057
1058  return FDecl->getBuiltinID();
1059}
1060
1061QualType CallExpr::getCallReturnType() const {
1062  QualType CalleeType = getCallee()->getType();
1063  if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
1064    CalleeType = FnTypePtr->getPointeeType();
1065  else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
1066    CalleeType = BPT->getPointeeType();
1067  else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember))
1068    // This should never be overloaded and so should never return null.
1069    CalleeType = Expr::findBoundMemberType(getCallee());
1070
1071  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
1072  return FnType->getResultType();
1073}
1074
1075SourceRange CallExpr::getSourceRange() const {
1076  if (isa<CXXOperatorCallExpr>(this))
1077    return cast<CXXOperatorCallExpr>(this)->getSourceRange();
1078
1079  SourceLocation begin = getCallee()->getLocStart();
1080  if (begin.isInvalid() && getNumArgs() > 0)
1081    begin = getArg(0)->getLocStart();
1082  SourceLocation end = getRParenLoc();
1083  if (end.isInvalid() && getNumArgs() > 0)
1084    end = getArg(getNumArgs() - 1)->getLocEnd();
1085  return SourceRange(begin, end);
1086}
1087SourceLocation CallExpr::getLocStart() const {
1088  if (isa<CXXOperatorCallExpr>(this))
1089    return cast<CXXOperatorCallExpr>(this)->getSourceRange().getBegin();
1090
1091  SourceLocation begin = getCallee()->getLocStart();
1092  if (begin.isInvalid() && getNumArgs() > 0)
1093    begin = getArg(0)->getLocStart();
1094  return begin;
1095}
1096SourceLocation CallExpr::getLocEnd() const {
1097  if (isa<CXXOperatorCallExpr>(this))
1098    return cast<CXXOperatorCallExpr>(this)->getSourceRange().getEnd();
1099
1100  SourceLocation end = getRParenLoc();
1101  if (end.isInvalid() && getNumArgs() > 0)
1102    end = getArg(getNumArgs() - 1)->getLocEnd();
1103  return end;
1104}
1105
1106OffsetOfExpr *OffsetOfExpr::Create(ASTContext &C, QualType type,
1107                                   SourceLocation OperatorLoc,
1108                                   TypeSourceInfo *tsi,
1109                                   OffsetOfNode* compsPtr, unsigned numComps,
1110                                   Expr** exprsPtr, unsigned numExprs,
1111                                   SourceLocation RParenLoc) {
1112  void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
1113                         sizeof(OffsetOfNode) * numComps +
1114                         sizeof(Expr*) * numExprs);
1115
1116  return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, compsPtr, numComps,
1117                                exprsPtr, numExprs, RParenLoc);
1118}
1119
1120OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext &C,
1121                                        unsigned numComps, unsigned numExprs) {
1122  void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
1123                         sizeof(OffsetOfNode) * numComps +
1124                         sizeof(Expr*) * numExprs);
1125  return new (Mem) OffsetOfExpr(numComps, numExprs);
1126}
1127
1128OffsetOfExpr::OffsetOfExpr(ASTContext &C, QualType type,
1129                           SourceLocation OperatorLoc, TypeSourceInfo *tsi,
1130                           OffsetOfNode* compsPtr, unsigned numComps,
1131                           Expr** exprsPtr, unsigned numExprs,
1132                           SourceLocation RParenLoc)
1133  : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary,
1134         /*TypeDependent=*/false,
1135         /*ValueDependent=*/tsi->getType()->isDependentType(),
1136         tsi->getType()->isInstantiationDependentType(),
1137         tsi->getType()->containsUnexpandedParameterPack()),
1138    OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
1139    NumComps(numComps), NumExprs(numExprs)
1140{
1141  for(unsigned i = 0; i < numComps; ++i) {
1142    setComponent(i, compsPtr[i]);
1143  }
1144
1145  for(unsigned i = 0; i < numExprs; ++i) {
1146    if (exprsPtr[i]->isTypeDependent() || exprsPtr[i]->isValueDependent())
1147      ExprBits.ValueDependent = true;
1148    if (exprsPtr[i]->containsUnexpandedParameterPack())
1149      ExprBits.ContainsUnexpandedParameterPack = true;
1150
1151    setIndexExpr(i, exprsPtr[i]);
1152  }
1153}
1154
1155IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const {
1156  assert(getKind() == Field || getKind() == Identifier);
1157  if (getKind() == Field)
1158    return getField()->getIdentifier();
1159
1160  return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
1161}
1162
1163MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
1164                               NestedNameSpecifierLoc QualifierLoc,
1165                               SourceLocation TemplateKWLoc,
1166                               ValueDecl *memberdecl,
1167                               DeclAccessPair founddecl,
1168                               DeclarationNameInfo nameinfo,
1169                               const TemplateArgumentListInfo *targs,
1170                               QualType ty,
1171                               ExprValueKind vk,
1172                               ExprObjectKind ok) {
1173  std::size_t Size = sizeof(MemberExpr);
1174
1175  bool hasQualOrFound = (QualifierLoc ||
1176                         founddecl.getDecl() != memberdecl ||
1177                         founddecl.getAccess() != memberdecl->getAccess());
1178  if (hasQualOrFound)
1179    Size += sizeof(MemberNameQualifier);
1180
1181  if (targs)
1182    Size += ASTTemplateKWAndArgsInfo::sizeFor(targs->size());
1183  else if (TemplateKWLoc.isValid())
1184    Size += ASTTemplateKWAndArgsInfo::sizeFor(0);
1185
1186  void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>());
1187  MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo,
1188                                       ty, vk, ok);
1189
1190  if (hasQualOrFound) {
1191    // FIXME: Wrong. We should be looking at the member declaration we found.
1192    if (QualifierLoc && QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1193      E->setValueDependent(true);
1194      E->setTypeDependent(true);
1195      E->setInstantiationDependent(true);
1196    }
1197    else if (QualifierLoc &&
1198             QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())
1199      E->setInstantiationDependent(true);
1200
1201    E->HasQualifierOrFoundDecl = true;
1202
1203    MemberNameQualifier *NQ = E->getMemberQualifier();
1204    NQ->QualifierLoc = QualifierLoc;
1205    NQ->FoundDecl = founddecl;
1206  }
1207
1208  E->HasTemplateKWAndArgsInfo = (targs || TemplateKWLoc.isValid());
1209
1210  if (targs) {
1211    bool Dependent = false;
1212    bool InstantiationDependent = false;
1213    bool ContainsUnexpandedParameterPack = false;
1214    E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *targs,
1215                                                  Dependent,
1216                                                  InstantiationDependent,
1217                                             ContainsUnexpandedParameterPack);
1218    if (InstantiationDependent)
1219      E->setInstantiationDependent(true);
1220  } else if (TemplateKWLoc.isValid()) {
1221    E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
1222  }
1223
1224  return E;
1225}
1226
1227SourceRange MemberExpr::getSourceRange() const {
1228  return SourceRange(getLocStart(), getLocEnd());
1229}
1230SourceLocation MemberExpr::getLocStart() const {
1231  if (isImplicitAccess()) {
1232    if (hasQualifier())
1233      return getQualifierLoc().getBeginLoc();
1234    return MemberLoc;
1235  }
1236
1237  // FIXME: We don't want this to happen. Rather, we should be able to
1238  // detect all kinds of implicit accesses more cleanly.
1239  SourceLocation BaseStartLoc = getBase()->getLocStart();
1240  if (BaseStartLoc.isValid())
1241    return BaseStartLoc;
1242  return MemberLoc;
1243}
1244SourceLocation MemberExpr::getLocEnd() const {
1245  if (hasExplicitTemplateArgs())
1246    return getRAngleLoc();
1247  return getMemberNameInfo().getEndLoc();
1248}
1249
1250void CastExpr::CheckCastConsistency() const {
1251  switch (getCastKind()) {
1252  case CK_DerivedToBase:
1253  case CK_UncheckedDerivedToBase:
1254  case CK_DerivedToBaseMemberPointer:
1255  case CK_BaseToDerived:
1256  case CK_BaseToDerivedMemberPointer:
1257    assert(!path_empty() && "Cast kind should have a base path!");
1258    break;
1259
1260  case CK_CPointerToObjCPointerCast:
1261    assert(getType()->isObjCObjectPointerType());
1262    assert(getSubExpr()->getType()->isPointerType());
1263    goto CheckNoBasePath;
1264
1265  case CK_BlockPointerToObjCPointerCast:
1266    assert(getType()->isObjCObjectPointerType());
1267    assert(getSubExpr()->getType()->isBlockPointerType());
1268    goto CheckNoBasePath;
1269
1270  case CK_ReinterpretMemberPointer:
1271    assert(getType()->isMemberPointerType());
1272    assert(getSubExpr()->getType()->isMemberPointerType());
1273    goto CheckNoBasePath;
1274
1275  case CK_BitCast:
1276    // Arbitrary casts to C pointer types count as bitcasts.
1277    // Otherwise, we should only have block and ObjC pointer casts
1278    // here if they stay within the type kind.
1279    if (!getType()->isPointerType()) {
1280      assert(getType()->isObjCObjectPointerType() ==
1281             getSubExpr()->getType()->isObjCObjectPointerType());
1282      assert(getType()->isBlockPointerType() ==
1283             getSubExpr()->getType()->isBlockPointerType());
1284    }
1285    goto CheckNoBasePath;
1286
1287  case CK_AnyPointerToBlockPointerCast:
1288    assert(getType()->isBlockPointerType());
1289    assert(getSubExpr()->getType()->isAnyPointerType() &&
1290           !getSubExpr()->getType()->isBlockPointerType());
1291    goto CheckNoBasePath;
1292
1293  case CK_CopyAndAutoreleaseBlockObject:
1294    assert(getType()->isBlockPointerType());
1295    assert(getSubExpr()->getType()->isBlockPointerType());
1296    goto CheckNoBasePath;
1297
1298  // These should not have an inheritance path.
1299  case CK_Dynamic:
1300  case CK_ToUnion:
1301  case CK_ArrayToPointerDecay:
1302  case CK_FunctionToPointerDecay:
1303  case CK_NullToMemberPointer:
1304  case CK_NullToPointer:
1305  case CK_ConstructorConversion:
1306  case CK_IntegralToPointer:
1307  case CK_PointerToIntegral:
1308  case CK_ToVoid:
1309  case CK_VectorSplat:
1310  case CK_IntegralCast:
1311  case CK_IntegralToFloating:
1312  case CK_FloatingToIntegral:
1313  case CK_FloatingCast:
1314  case CK_ObjCObjectLValueCast:
1315  case CK_FloatingRealToComplex:
1316  case CK_FloatingComplexToReal:
1317  case CK_FloatingComplexCast:
1318  case CK_FloatingComplexToIntegralComplex:
1319  case CK_IntegralRealToComplex:
1320  case CK_IntegralComplexToReal:
1321  case CK_IntegralComplexCast:
1322  case CK_IntegralComplexToFloatingComplex:
1323  case CK_ARCProduceObject:
1324  case CK_ARCConsumeObject:
1325  case CK_ARCReclaimReturnedObject:
1326  case CK_ARCExtendBlockObject:
1327    assert(!getType()->isBooleanType() && "unheralded conversion to bool");
1328    goto CheckNoBasePath;
1329
1330  case CK_Dependent:
1331  case CK_LValueToRValue:
1332  case CK_NoOp:
1333  case CK_AtomicToNonAtomic:
1334  case CK_NonAtomicToAtomic:
1335  case CK_PointerToBoolean:
1336  case CK_IntegralToBoolean:
1337  case CK_FloatingToBoolean:
1338  case CK_MemberPointerToBoolean:
1339  case CK_FloatingComplexToBoolean:
1340  case CK_IntegralComplexToBoolean:
1341  case CK_LValueBitCast:            // -> bool&
1342  case CK_UserDefinedConversion:    // operator bool()
1343  CheckNoBasePath:
1344    assert(path_empty() && "Cast kind should not have a base path!");
1345    break;
1346  }
1347}
1348
1349const char *CastExpr::getCastKindName() const {
1350  switch (getCastKind()) {
1351  case CK_Dependent:
1352    return "Dependent";
1353  case CK_BitCast:
1354    return "BitCast";
1355  case CK_LValueBitCast:
1356    return "LValueBitCast";
1357  case CK_LValueToRValue:
1358    return "LValueToRValue";
1359  case CK_NoOp:
1360    return "NoOp";
1361  case CK_BaseToDerived:
1362    return "BaseToDerived";
1363  case CK_DerivedToBase:
1364    return "DerivedToBase";
1365  case CK_UncheckedDerivedToBase:
1366    return "UncheckedDerivedToBase";
1367  case CK_Dynamic:
1368    return "Dynamic";
1369  case CK_ToUnion:
1370    return "ToUnion";
1371  case CK_ArrayToPointerDecay:
1372    return "ArrayToPointerDecay";
1373  case CK_FunctionToPointerDecay:
1374    return "FunctionToPointerDecay";
1375  case CK_NullToMemberPointer:
1376    return "NullToMemberPointer";
1377  case CK_NullToPointer:
1378    return "NullToPointer";
1379  case CK_BaseToDerivedMemberPointer:
1380    return "BaseToDerivedMemberPointer";
1381  case CK_DerivedToBaseMemberPointer:
1382    return "DerivedToBaseMemberPointer";
1383  case CK_ReinterpretMemberPointer:
1384    return "ReinterpretMemberPointer";
1385  case CK_UserDefinedConversion:
1386    return "UserDefinedConversion";
1387  case CK_ConstructorConversion:
1388    return "ConstructorConversion";
1389  case CK_IntegralToPointer:
1390    return "IntegralToPointer";
1391  case CK_PointerToIntegral:
1392    return "PointerToIntegral";
1393  case CK_PointerToBoolean:
1394    return "PointerToBoolean";
1395  case CK_ToVoid:
1396    return "ToVoid";
1397  case CK_VectorSplat:
1398    return "VectorSplat";
1399  case CK_IntegralCast:
1400    return "IntegralCast";
1401  case CK_IntegralToBoolean:
1402    return "IntegralToBoolean";
1403  case CK_IntegralToFloating:
1404    return "IntegralToFloating";
1405  case CK_FloatingToIntegral:
1406    return "FloatingToIntegral";
1407  case CK_FloatingCast:
1408    return "FloatingCast";
1409  case CK_FloatingToBoolean:
1410    return "FloatingToBoolean";
1411  case CK_MemberPointerToBoolean:
1412    return "MemberPointerToBoolean";
1413  case CK_CPointerToObjCPointerCast:
1414    return "CPointerToObjCPointerCast";
1415  case CK_BlockPointerToObjCPointerCast:
1416    return "BlockPointerToObjCPointerCast";
1417  case CK_AnyPointerToBlockPointerCast:
1418    return "AnyPointerToBlockPointerCast";
1419  case CK_ObjCObjectLValueCast:
1420    return "ObjCObjectLValueCast";
1421  case CK_FloatingRealToComplex:
1422    return "FloatingRealToComplex";
1423  case CK_FloatingComplexToReal:
1424    return "FloatingComplexToReal";
1425  case CK_FloatingComplexToBoolean:
1426    return "FloatingComplexToBoolean";
1427  case CK_FloatingComplexCast:
1428    return "FloatingComplexCast";
1429  case CK_FloatingComplexToIntegralComplex:
1430    return "FloatingComplexToIntegralComplex";
1431  case CK_IntegralRealToComplex:
1432    return "IntegralRealToComplex";
1433  case CK_IntegralComplexToReal:
1434    return "IntegralComplexToReal";
1435  case CK_IntegralComplexToBoolean:
1436    return "IntegralComplexToBoolean";
1437  case CK_IntegralComplexCast:
1438    return "IntegralComplexCast";
1439  case CK_IntegralComplexToFloatingComplex:
1440    return "IntegralComplexToFloatingComplex";
1441  case CK_ARCConsumeObject:
1442    return "ARCConsumeObject";
1443  case CK_ARCProduceObject:
1444    return "ARCProduceObject";
1445  case CK_ARCReclaimReturnedObject:
1446    return "ARCReclaimReturnedObject";
1447  case CK_ARCExtendBlockObject:
1448    return "ARCCExtendBlockObject";
1449  case CK_AtomicToNonAtomic:
1450    return "AtomicToNonAtomic";
1451  case CK_NonAtomicToAtomic:
1452    return "NonAtomicToAtomic";
1453  case CK_CopyAndAutoreleaseBlockObject:
1454    return "CopyAndAutoreleaseBlockObject";
1455  }
1456
1457  llvm_unreachable("Unhandled cast kind!");
1458}
1459
1460Expr *CastExpr::getSubExprAsWritten() {
1461  Expr *SubExpr = 0;
1462  CastExpr *E = this;
1463  do {
1464    SubExpr = E->getSubExpr();
1465
1466    // Skip through reference binding to temporary.
1467    if (MaterializeTemporaryExpr *Materialize
1468                                  = dyn_cast<MaterializeTemporaryExpr>(SubExpr))
1469      SubExpr = Materialize->GetTemporaryExpr();
1470
1471    // Skip any temporary bindings; they're implicit.
1472    if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
1473      SubExpr = Binder->getSubExpr();
1474
1475    // Conversions by constructor and conversion functions have a
1476    // subexpression describing the call; strip it off.
1477    if (E->getCastKind() == CK_ConstructorConversion)
1478      SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
1479    else if (E->getCastKind() == CK_UserDefinedConversion)
1480      SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
1481
1482    // If the subexpression we're left with is an implicit cast, look
1483    // through that, too.
1484  } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
1485
1486  return SubExpr;
1487}
1488
1489CXXBaseSpecifier **CastExpr::path_buffer() {
1490  switch (getStmtClass()) {
1491#define ABSTRACT_STMT(x)
1492#define CASTEXPR(Type, Base) \
1493  case Stmt::Type##Class: \
1494    return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1);
1495#define STMT(Type, Base)
1496#include "clang/AST/StmtNodes.inc"
1497  default:
1498    llvm_unreachable("non-cast expressions not possible here");
1499  }
1500}
1501
1502void CastExpr::setCastPath(const CXXCastPath &Path) {
1503  assert(Path.size() == path_size());
1504  memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*));
1505}
1506
1507ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext &C, QualType T,
1508                                           CastKind Kind, Expr *Operand,
1509                                           const CXXCastPath *BasePath,
1510                                           ExprValueKind VK) {
1511  unsigned PathSize = (BasePath ? BasePath->size() : 0);
1512  void *Buffer =
1513    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1514  ImplicitCastExpr *E =
1515    new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
1516  if (PathSize) E->setCastPath(*BasePath);
1517  return E;
1518}
1519
1520ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext &C,
1521                                                unsigned PathSize) {
1522  void *Buffer =
1523    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1524  return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
1525}
1526
1527
1528CStyleCastExpr *CStyleCastExpr::Create(ASTContext &C, QualType T,
1529                                       ExprValueKind VK, CastKind K, Expr *Op,
1530                                       const CXXCastPath *BasePath,
1531                                       TypeSourceInfo *WrittenTy,
1532                                       SourceLocation L, SourceLocation R) {
1533  unsigned PathSize = (BasePath ? BasePath->size() : 0);
1534  void *Buffer =
1535    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1536  CStyleCastExpr *E =
1537    new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R);
1538  if (PathSize) E->setCastPath(*BasePath);
1539  return E;
1540}
1541
1542CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
1543  void *Buffer =
1544    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1545  return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize);
1546}
1547
1548/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
1549/// corresponds to, e.g. "<<=".
1550const char *BinaryOperator::getOpcodeStr(Opcode Op) {
1551  switch (Op) {
1552  case BO_PtrMemD:   return ".*";
1553  case BO_PtrMemI:   return "->*";
1554  case BO_Mul:       return "*";
1555  case BO_Div:       return "/";
1556  case BO_Rem:       return "%";
1557  case BO_Add:       return "+";
1558  case BO_Sub:       return "-";
1559  case BO_Shl:       return "<<";
1560  case BO_Shr:       return ">>";
1561  case BO_LT:        return "<";
1562  case BO_GT:        return ">";
1563  case BO_LE:        return "<=";
1564  case BO_GE:        return ">=";
1565  case BO_EQ:        return "==";
1566  case BO_NE:        return "!=";
1567  case BO_And:       return "&";
1568  case BO_Xor:       return "^";
1569  case BO_Or:        return "|";
1570  case BO_LAnd:      return "&&";
1571  case BO_LOr:       return "||";
1572  case BO_Assign:    return "=";
1573  case BO_MulAssign: return "*=";
1574  case BO_DivAssign: return "/=";
1575  case BO_RemAssign: return "%=";
1576  case BO_AddAssign: return "+=";
1577  case BO_SubAssign: return "-=";
1578  case BO_ShlAssign: return "<<=";
1579  case BO_ShrAssign: return ">>=";
1580  case BO_AndAssign: return "&=";
1581  case BO_XorAssign: return "^=";
1582  case BO_OrAssign:  return "|=";
1583  case BO_Comma:     return ",";
1584  }
1585
1586  llvm_unreachable("Invalid OpCode!");
1587}
1588
1589BinaryOperatorKind
1590BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
1591  switch (OO) {
1592  default: llvm_unreachable("Not an overloadable binary operator");
1593  case OO_Plus: return BO_Add;
1594  case OO_Minus: return BO_Sub;
1595  case OO_Star: return BO_Mul;
1596  case OO_Slash: return BO_Div;
1597  case OO_Percent: return BO_Rem;
1598  case OO_Caret: return BO_Xor;
1599  case OO_Amp: return BO_And;
1600  case OO_Pipe: return BO_Or;
1601  case OO_Equal: return BO_Assign;
1602  case OO_Less: return BO_LT;
1603  case OO_Greater: return BO_GT;
1604  case OO_PlusEqual: return BO_AddAssign;
1605  case OO_MinusEqual: return BO_SubAssign;
1606  case OO_StarEqual: return BO_MulAssign;
1607  case OO_SlashEqual: return BO_DivAssign;
1608  case OO_PercentEqual: return BO_RemAssign;
1609  case OO_CaretEqual: return BO_XorAssign;
1610  case OO_AmpEqual: return BO_AndAssign;
1611  case OO_PipeEqual: return BO_OrAssign;
1612  case OO_LessLess: return BO_Shl;
1613  case OO_GreaterGreater: return BO_Shr;
1614  case OO_LessLessEqual: return BO_ShlAssign;
1615  case OO_GreaterGreaterEqual: return BO_ShrAssign;
1616  case OO_EqualEqual: return BO_EQ;
1617  case OO_ExclaimEqual: return BO_NE;
1618  case OO_LessEqual: return BO_LE;
1619  case OO_GreaterEqual: return BO_GE;
1620  case OO_AmpAmp: return BO_LAnd;
1621  case OO_PipePipe: return BO_LOr;
1622  case OO_Comma: return BO_Comma;
1623  case OO_ArrowStar: return BO_PtrMemI;
1624  }
1625}
1626
1627OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
1628  static const OverloadedOperatorKind OverOps[] = {
1629    /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
1630    OO_Star, OO_Slash, OO_Percent,
1631    OO_Plus, OO_Minus,
1632    OO_LessLess, OO_GreaterGreater,
1633    OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
1634    OO_EqualEqual, OO_ExclaimEqual,
1635    OO_Amp,
1636    OO_Caret,
1637    OO_Pipe,
1638    OO_AmpAmp,
1639    OO_PipePipe,
1640    OO_Equal, OO_StarEqual,
1641    OO_SlashEqual, OO_PercentEqual,
1642    OO_PlusEqual, OO_MinusEqual,
1643    OO_LessLessEqual, OO_GreaterGreaterEqual,
1644    OO_AmpEqual, OO_CaretEqual,
1645    OO_PipeEqual,
1646    OO_Comma
1647  };
1648  return OverOps[Opc];
1649}
1650
1651InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc,
1652                           Expr **initExprs, unsigned numInits,
1653                           SourceLocation rbraceloc)
1654  : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
1655         false, false),
1656    InitExprs(C, numInits),
1657    LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0)
1658{
1659  sawArrayRangeDesignator(false);
1660  setInitializesStdInitializerList(false);
1661  for (unsigned I = 0; I != numInits; ++I) {
1662    if (initExprs[I]->isTypeDependent())
1663      ExprBits.TypeDependent = true;
1664    if (initExprs[I]->isValueDependent())
1665      ExprBits.ValueDependent = true;
1666    if (initExprs[I]->isInstantiationDependent())
1667      ExprBits.InstantiationDependent = true;
1668    if (initExprs[I]->containsUnexpandedParameterPack())
1669      ExprBits.ContainsUnexpandedParameterPack = true;
1670  }
1671
1672  InitExprs.insert(C, InitExprs.end(), initExprs, initExprs+numInits);
1673}
1674
1675void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) {
1676  if (NumInits > InitExprs.size())
1677    InitExprs.reserve(C, NumInits);
1678}
1679
1680void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) {
1681  InitExprs.resize(C, NumInits, 0);
1682}
1683
1684Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) {
1685  if (Init >= InitExprs.size()) {
1686    InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0);
1687    InitExprs.back() = expr;
1688    return 0;
1689  }
1690
1691  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
1692  InitExprs[Init] = expr;
1693  return Result;
1694}
1695
1696void InitListExpr::setArrayFiller(Expr *filler) {
1697  assert(!hasArrayFiller() && "Filler already set!");
1698  ArrayFillerOrUnionFieldInit = filler;
1699  // Fill out any "holes" in the array due to designated initializers.
1700  Expr **inits = getInits();
1701  for (unsigned i = 0, e = getNumInits(); i != e; ++i)
1702    if (inits[i] == 0)
1703      inits[i] = filler;
1704}
1705
1706bool InitListExpr::isStringLiteralInit() const {
1707  if (getNumInits() != 1)
1708    return false;
1709  const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(getType());
1710  if (!CAT || !CAT->getElementType()->isIntegerType())
1711    return false;
1712  const Expr *Init = getInit(0)->IgnoreParenImpCasts();
1713  return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init);
1714}
1715
1716SourceRange InitListExpr::getSourceRange() const {
1717  if (SyntacticForm)
1718    return SyntacticForm->getSourceRange();
1719  SourceLocation Beg = LBraceLoc, End = RBraceLoc;
1720  if (Beg.isInvalid()) {
1721    // Find the first non-null initializer.
1722    for (InitExprsTy::const_iterator I = InitExprs.begin(),
1723                                     E = InitExprs.end();
1724      I != E; ++I) {
1725      if (Stmt *S = *I) {
1726        Beg = S->getLocStart();
1727        break;
1728      }
1729    }
1730  }
1731  if (End.isInvalid()) {
1732    // Find the first non-null initializer from the end.
1733    for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(),
1734                                             E = InitExprs.rend();
1735      I != E; ++I) {
1736      if (Stmt *S = *I) {
1737        End = S->getSourceRange().getEnd();
1738        break;
1739      }
1740    }
1741  }
1742  return SourceRange(Beg, End);
1743}
1744
1745/// getFunctionType - Return the underlying function type for this block.
1746///
1747const FunctionProtoType *BlockExpr::getFunctionType() const {
1748  // The block pointer is never sugared, but the function type might be.
1749  return cast<BlockPointerType>(getType())
1750           ->getPointeeType()->castAs<FunctionProtoType>();
1751}
1752
1753SourceLocation BlockExpr::getCaretLocation() const {
1754  return TheBlock->getCaretLocation();
1755}
1756const Stmt *BlockExpr::getBody() const {
1757  return TheBlock->getBody();
1758}
1759Stmt *BlockExpr::getBody() {
1760  return TheBlock->getBody();
1761}
1762
1763
1764//===----------------------------------------------------------------------===//
1765// Generic Expression Routines
1766//===----------------------------------------------------------------------===//
1767
1768/// isUnusedResultAWarning - Return true if this immediate expression should
1769/// be warned about if the result is unused.  If so, fill in Loc and Ranges
1770/// with location to warn on and the source range[s] to report with the
1771/// warning.
1772bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc,
1773                                  SourceRange &R1, SourceRange &R2,
1774                                  ASTContext &Ctx) const {
1775  // Don't warn if the expr is type dependent. The type could end up
1776  // instantiating to void.
1777  if (isTypeDependent())
1778    return false;
1779
1780  switch (getStmtClass()) {
1781  default:
1782    if (getType()->isVoidType())
1783      return false;
1784    WarnE = this;
1785    Loc = getExprLoc();
1786    R1 = getSourceRange();
1787    return true;
1788  case ParenExprClass:
1789    return cast<ParenExpr>(this)->getSubExpr()->
1790      isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1791  case GenericSelectionExprClass:
1792    return cast<GenericSelectionExpr>(this)->getResultExpr()->
1793      isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1794  case UnaryOperatorClass: {
1795    const UnaryOperator *UO = cast<UnaryOperator>(this);
1796
1797    switch (UO->getOpcode()) {
1798    case UO_Plus:
1799    case UO_Minus:
1800    case UO_AddrOf:
1801    case UO_Not:
1802    case UO_LNot:
1803    case UO_Deref:
1804      break;
1805    case UO_PostInc:
1806    case UO_PostDec:
1807    case UO_PreInc:
1808    case UO_PreDec:                 // ++/--
1809      return false;  // Not a warning.
1810    case UO_Real:
1811    case UO_Imag:
1812      // accessing a piece of a volatile complex is a side-effect.
1813      if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
1814          .isVolatileQualified())
1815        return false;
1816      break;
1817    case UO_Extension:
1818      return UO->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1819    }
1820    WarnE = this;
1821    Loc = UO->getOperatorLoc();
1822    R1 = UO->getSubExpr()->getSourceRange();
1823    return true;
1824  }
1825  case BinaryOperatorClass: {
1826    const BinaryOperator *BO = cast<BinaryOperator>(this);
1827    switch (BO->getOpcode()) {
1828      default:
1829        break;
1830      // Consider the RHS of comma for side effects. LHS was checked by
1831      // Sema::CheckCommaOperands.
1832      case BO_Comma:
1833        // ((foo = <blah>), 0) is an idiom for hiding the result (and
1834        // lvalue-ness) of an assignment written in a macro.
1835        if (IntegerLiteral *IE =
1836              dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
1837          if (IE->getValue() == 0)
1838            return false;
1839        return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1840      // Consider '||', '&&' to have side effects if the LHS or RHS does.
1841      case BO_LAnd:
1842      case BO_LOr:
1843        if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) ||
1844            !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
1845          return false;
1846        break;
1847    }
1848    if (BO->isAssignmentOp())
1849      return false;
1850    WarnE = this;
1851    Loc = BO->getOperatorLoc();
1852    R1 = BO->getLHS()->getSourceRange();
1853    R2 = BO->getRHS()->getSourceRange();
1854    return true;
1855  }
1856  case CompoundAssignOperatorClass:
1857  case VAArgExprClass:
1858  case AtomicExprClass:
1859    return false;
1860
1861  case ConditionalOperatorClass: {
1862    // If only one of the LHS or RHS is a warning, the operator might
1863    // be being used for control flow. Only warn if both the LHS and
1864    // RHS are warnings.
1865    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1866    if (!Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
1867      return false;
1868    if (!Exp->getLHS())
1869      return true;
1870    return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1871  }
1872
1873  case MemberExprClass:
1874    WarnE = this;
1875    Loc = cast<MemberExpr>(this)->getMemberLoc();
1876    R1 = SourceRange(Loc, Loc);
1877    R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
1878    return true;
1879
1880  case ArraySubscriptExprClass:
1881    WarnE = this;
1882    Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
1883    R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
1884    R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
1885    return true;
1886
1887  case CXXOperatorCallExprClass: {
1888    // We warn about operator== and operator!= even when user-defined operator
1889    // overloads as there is no reasonable way to define these such that they
1890    // have non-trivial, desirable side-effects. See the -Wunused-comparison
1891    // warning: these operators are commonly typo'ed, and so warning on them
1892    // provides additional value as well. If this list is updated,
1893    // DiagnoseUnusedComparison should be as well.
1894    const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this);
1895    if (Op->getOperator() == OO_EqualEqual ||
1896        Op->getOperator() == OO_ExclaimEqual) {
1897      WarnE = this;
1898      Loc = Op->getOperatorLoc();
1899      R1 = Op->getSourceRange();
1900      return true;
1901    }
1902
1903    // Fallthrough for generic call handling.
1904  }
1905  case CallExprClass:
1906  case CXXMemberCallExprClass:
1907  case UserDefinedLiteralClass: {
1908    // If this is a direct call, get the callee.
1909    const CallExpr *CE = cast<CallExpr>(this);
1910    if (const Decl *FD = CE->getCalleeDecl()) {
1911      // If the callee has attribute pure, const, or warn_unused_result, warn
1912      // about it. void foo() { strlen("bar"); } should warn.
1913      //
1914      // Note: If new cases are added here, DiagnoseUnusedExprResult should be
1915      // updated to match for QoI.
1916      if (FD->getAttr<WarnUnusedResultAttr>() ||
1917          FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
1918        WarnE = this;
1919        Loc = CE->getCallee()->getLocStart();
1920        R1 = CE->getCallee()->getSourceRange();
1921
1922        if (unsigned NumArgs = CE->getNumArgs())
1923          R2 = SourceRange(CE->getArg(0)->getLocStart(),
1924                           CE->getArg(NumArgs-1)->getLocEnd());
1925        return true;
1926      }
1927    }
1928    return false;
1929  }
1930
1931  case CXXTemporaryObjectExprClass:
1932  case CXXConstructExprClass:
1933    return false;
1934
1935  case ObjCMessageExprClass: {
1936    const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
1937    if (Ctx.getLangOpts().ObjCAutoRefCount &&
1938        ME->isInstanceMessage() &&
1939        !ME->getType()->isVoidType() &&
1940        ME->getSelector().getIdentifierInfoForSlot(0) &&
1941        ME->getSelector().getIdentifierInfoForSlot(0)
1942                                               ->getName().startswith("init")) {
1943      WarnE = this;
1944      Loc = getExprLoc();
1945      R1 = ME->getSourceRange();
1946      return true;
1947    }
1948
1949    const ObjCMethodDecl *MD = ME->getMethodDecl();
1950    if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
1951      WarnE = this;
1952      Loc = getExprLoc();
1953      return true;
1954    }
1955    return false;
1956  }
1957
1958  case ObjCPropertyRefExprClass:
1959    WarnE = this;
1960    Loc = getExprLoc();
1961    R1 = getSourceRange();
1962    return true;
1963
1964  case PseudoObjectExprClass: {
1965    const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
1966
1967    // Only complain about things that have the form of a getter.
1968    if (isa<UnaryOperator>(PO->getSyntacticForm()) ||
1969        isa<BinaryOperator>(PO->getSyntacticForm()))
1970      return false;
1971
1972    WarnE = this;
1973    Loc = getExprLoc();
1974    R1 = getSourceRange();
1975    return true;
1976  }
1977
1978  case StmtExprClass: {
1979    // Statement exprs don't logically have side effects themselves, but are
1980    // sometimes used in macros in ways that give them a type that is unused.
1981    // For example ({ blah; foo(); }) will end up with a type if foo has a type.
1982    // however, if the result of the stmt expr is dead, we don't want to emit a
1983    // warning.
1984    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
1985    if (!CS->body_empty()) {
1986      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
1987        return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1988      if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back()))
1989        if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
1990          return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1991    }
1992
1993    if (getType()->isVoidType())
1994      return false;
1995    WarnE = this;
1996    Loc = cast<StmtExpr>(this)->getLParenLoc();
1997    R1 = getSourceRange();
1998    return true;
1999  }
2000  case CStyleCastExprClass: {
2001    // Ignore an explicit cast to void unless the operand is a non-trivial
2002    // volatile lvalue.
2003    const CastExpr *CE = cast<CastExpr>(this);
2004    if (CE->getCastKind() == CK_ToVoid) {
2005      if (CE->getSubExpr()->isGLValue() &&
2006          CE->getSubExpr()->getType().isVolatileQualified()) {
2007        const DeclRefExpr *DRE =
2008            dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens());
2009        if (!(DRE && isa<VarDecl>(DRE->getDecl()) &&
2010              cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) {
2011          return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc,
2012                                                          R1, R2, Ctx);
2013        }
2014      }
2015      return false;
2016    }
2017
2018    // If this is a cast to a constructor conversion, check the operand.
2019    // Otherwise, the result of the cast is unused.
2020    if (CE->getCastKind() == CK_ConstructorConversion)
2021      return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2022
2023    WarnE = this;
2024    if (const CXXFunctionalCastExpr *CXXCE =
2025            dyn_cast<CXXFunctionalCastExpr>(this)) {
2026      Loc = CXXCE->getTypeBeginLoc();
2027      R1 = CXXCE->getSubExpr()->getSourceRange();
2028    } else {
2029      const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this);
2030      Loc = CStyleCE->getLParenLoc();
2031      R1 = CStyleCE->getSubExpr()->getSourceRange();
2032    }
2033    return true;
2034  }
2035  case ImplicitCastExprClass: {
2036    const CastExpr *ICE = cast<ImplicitCastExpr>(this);
2037
2038    // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect.
2039    if (ICE->getCastKind() == CK_LValueToRValue &&
2040        ICE->getSubExpr()->getType().isVolatileQualified())
2041      return false;
2042
2043    return ICE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2044  }
2045  case CXXDefaultArgExprClass:
2046    return (cast<CXXDefaultArgExpr>(this)
2047            ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2048
2049  case CXXNewExprClass:
2050    // FIXME: In theory, there might be new expressions that don't have side
2051    // effects (e.g. a placement new with an uninitialized POD).
2052  case CXXDeleteExprClass:
2053    return false;
2054  case CXXBindTemporaryExprClass:
2055    return (cast<CXXBindTemporaryExpr>(this)
2056            ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2057  case ExprWithCleanupsClass:
2058    return (cast<ExprWithCleanups>(this)
2059            ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2060  }
2061}
2062
2063/// isOBJCGCCandidate - Check if an expression is objc gc'able.
2064/// returns true, if it is; false otherwise.
2065bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
2066  const Expr *E = IgnoreParens();
2067  switch (E->getStmtClass()) {
2068  default:
2069    return false;
2070  case ObjCIvarRefExprClass:
2071    return true;
2072  case Expr::UnaryOperatorClass:
2073    return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2074  case ImplicitCastExprClass:
2075    return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2076  case MaterializeTemporaryExprClass:
2077    return cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr()
2078                                                      ->isOBJCGCCandidate(Ctx);
2079  case CStyleCastExprClass:
2080    return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2081  case DeclRefExprClass: {
2082    const Decl *D = cast<DeclRefExpr>(E)->getDecl();
2083
2084    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2085      if (VD->hasGlobalStorage())
2086        return true;
2087      QualType T = VD->getType();
2088      // dereferencing to a  pointer is always a gc'able candidate,
2089      // unless it is __weak.
2090      return T->isPointerType() &&
2091             (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
2092    }
2093    return false;
2094  }
2095  case MemberExprClass: {
2096    const MemberExpr *M = cast<MemberExpr>(E);
2097    return M->getBase()->isOBJCGCCandidate(Ctx);
2098  }
2099  case ArraySubscriptExprClass:
2100    return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
2101  }
2102}
2103
2104bool Expr::isBoundMemberFunction(ASTContext &Ctx) const {
2105  if (isTypeDependent())
2106    return false;
2107  return ClassifyLValue(Ctx) == Expr::LV_MemberFunction;
2108}
2109
2110QualType Expr::findBoundMemberType(const Expr *expr) {
2111  assert(expr->hasPlaceholderType(BuiltinType::BoundMember));
2112
2113  // Bound member expressions are always one of these possibilities:
2114  //   x->m      x.m      x->*y      x.*y
2115  // (possibly parenthesized)
2116
2117  expr = expr->IgnoreParens();
2118  if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) {
2119    assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
2120    return mem->getMemberDecl()->getType();
2121  }
2122
2123  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) {
2124    QualType type = op->getRHS()->getType()->castAs<MemberPointerType>()
2125                      ->getPointeeType();
2126    assert(type->isFunctionType());
2127    return type;
2128  }
2129
2130  assert(isa<UnresolvedMemberExpr>(expr));
2131  return QualType();
2132}
2133
2134Expr* Expr::IgnoreParens() {
2135  Expr* E = this;
2136  while (true) {
2137    if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
2138      E = P->getSubExpr();
2139      continue;
2140    }
2141    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2142      if (P->getOpcode() == UO_Extension) {
2143        E = P->getSubExpr();
2144        continue;
2145      }
2146    }
2147    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2148      if (!P->isResultDependent()) {
2149        E = P->getResultExpr();
2150        continue;
2151      }
2152    }
2153    return E;
2154  }
2155}
2156
2157/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
2158/// or CastExprs or ImplicitCastExprs, returning their operand.
2159Expr *Expr::IgnoreParenCasts() {
2160  Expr *E = this;
2161  while (true) {
2162    if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
2163      E = P->getSubExpr();
2164      continue;
2165    }
2166    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2167      E = P->getSubExpr();
2168      continue;
2169    }
2170    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2171      if (P->getOpcode() == UO_Extension) {
2172        E = P->getSubExpr();
2173        continue;
2174      }
2175    }
2176    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2177      if (!P->isResultDependent()) {
2178        E = P->getResultExpr();
2179        continue;
2180      }
2181    }
2182    if (MaterializeTemporaryExpr *Materialize
2183                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
2184      E = Materialize->GetTemporaryExpr();
2185      continue;
2186    }
2187    if (SubstNonTypeTemplateParmExpr *NTTP
2188                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2189      E = NTTP->getReplacement();
2190      continue;
2191    }
2192    return E;
2193  }
2194}
2195
2196/// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue
2197/// casts.  This is intended purely as a temporary workaround for code
2198/// that hasn't yet been rewritten to do the right thing about those
2199/// casts, and may disappear along with the last internal use.
2200Expr *Expr::IgnoreParenLValueCasts() {
2201  Expr *E = this;
2202  while (true) {
2203    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2204      E = P->getSubExpr();
2205      continue;
2206    } else if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2207      if (P->getCastKind() == CK_LValueToRValue) {
2208        E = P->getSubExpr();
2209        continue;
2210      }
2211    } else if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2212      if (P->getOpcode() == UO_Extension) {
2213        E = P->getSubExpr();
2214        continue;
2215      }
2216    } else if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2217      if (!P->isResultDependent()) {
2218        E = P->getResultExpr();
2219        continue;
2220      }
2221    } else if (MaterializeTemporaryExpr *Materialize
2222                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
2223      E = Materialize->GetTemporaryExpr();
2224      continue;
2225    } else if (SubstNonTypeTemplateParmExpr *NTTP
2226                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2227      E = NTTP->getReplacement();
2228      continue;
2229    }
2230    break;
2231  }
2232  return E;
2233}
2234
2235Expr *Expr::IgnoreParenImpCasts() {
2236  Expr *E = this;
2237  while (true) {
2238    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2239      E = P->getSubExpr();
2240      continue;
2241    }
2242    if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) {
2243      E = P->getSubExpr();
2244      continue;
2245    }
2246    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2247      if (P->getOpcode() == UO_Extension) {
2248        E = P->getSubExpr();
2249        continue;
2250      }
2251    }
2252    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2253      if (!P->isResultDependent()) {
2254        E = P->getResultExpr();
2255        continue;
2256      }
2257    }
2258    if (MaterializeTemporaryExpr *Materialize
2259                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
2260      E = Materialize->GetTemporaryExpr();
2261      continue;
2262    }
2263    if (SubstNonTypeTemplateParmExpr *NTTP
2264                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2265      E = NTTP->getReplacement();
2266      continue;
2267    }
2268    return E;
2269  }
2270}
2271
2272Expr *Expr::IgnoreConversionOperator() {
2273  if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
2274    if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
2275      return MCE->getImplicitObjectArgument();
2276  }
2277  return this;
2278}
2279
2280/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
2281/// value (including ptr->int casts of the same size).  Strip off any
2282/// ParenExpr or CastExprs, returning their operand.
2283Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
2284  Expr *E = this;
2285  while (true) {
2286    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2287      E = P->getSubExpr();
2288      continue;
2289    }
2290
2291    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2292      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
2293      // ptr<->int casts of the same width.  We also ignore all identity casts.
2294      Expr *SE = P->getSubExpr();
2295
2296      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
2297        E = SE;
2298        continue;
2299      }
2300
2301      if ((E->getType()->isPointerType() ||
2302           E->getType()->isIntegralType(Ctx)) &&
2303          (SE->getType()->isPointerType() ||
2304           SE->getType()->isIntegralType(Ctx)) &&
2305          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
2306        E = SE;
2307        continue;
2308      }
2309    }
2310
2311    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2312      if (P->getOpcode() == UO_Extension) {
2313        E = P->getSubExpr();
2314        continue;
2315      }
2316    }
2317
2318    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2319      if (!P->isResultDependent()) {
2320        E = P->getResultExpr();
2321        continue;
2322      }
2323    }
2324
2325    if (SubstNonTypeTemplateParmExpr *NTTP
2326                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2327      E = NTTP->getReplacement();
2328      continue;
2329    }
2330
2331    return E;
2332  }
2333}
2334
2335bool Expr::isDefaultArgument() const {
2336  const Expr *E = this;
2337  if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2338    E = M->GetTemporaryExpr();
2339
2340  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
2341    E = ICE->getSubExprAsWritten();
2342
2343  return isa<CXXDefaultArgExpr>(E);
2344}
2345
2346/// \brief Skip over any no-op casts and any temporary-binding
2347/// expressions.
2348static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) {
2349  if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2350    E = M->GetTemporaryExpr();
2351
2352  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2353    if (ICE->getCastKind() == CK_NoOp)
2354      E = ICE->getSubExpr();
2355    else
2356      break;
2357  }
2358
2359  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
2360    E = BE->getSubExpr();
2361
2362  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2363    if (ICE->getCastKind() == CK_NoOp)
2364      E = ICE->getSubExpr();
2365    else
2366      break;
2367  }
2368
2369  return E->IgnoreParens();
2370}
2371
2372/// isTemporaryObject - Determines if this expression produces a
2373/// temporary of the given class type.
2374bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
2375  if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy)))
2376    return false;
2377
2378  const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this);
2379
2380  // Temporaries are by definition pr-values of class type.
2381  if (!E->Classify(C).isPRValue()) {
2382    // In this context, property reference is a message call and is pr-value.
2383    if (!isa<ObjCPropertyRefExpr>(E))
2384      return false;
2385  }
2386
2387  // Black-list a few cases which yield pr-values of class type that don't
2388  // refer to temporaries of that type:
2389
2390  // - implicit derived-to-base conversions
2391  if (isa<ImplicitCastExpr>(E)) {
2392    switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
2393    case CK_DerivedToBase:
2394    case CK_UncheckedDerivedToBase:
2395      return false;
2396    default:
2397      break;
2398    }
2399  }
2400
2401  // - member expressions (all)
2402  if (isa<MemberExpr>(E))
2403    return false;
2404
2405  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
2406    if (BO->isPtrMemOp())
2407      return false;
2408
2409  // - opaque values (all)
2410  if (isa<OpaqueValueExpr>(E))
2411    return false;
2412
2413  return true;
2414}
2415
2416bool Expr::isImplicitCXXThis() const {
2417  const Expr *E = this;
2418
2419  // Strip away parentheses and casts we don't care about.
2420  while (true) {
2421    if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
2422      E = Paren->getSubExpr();
2423      continue;
2424    }
2425
2426    if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2427      if (ICE->getCastKind() == CK_NoOp ||
2428          ICE->getCastKind() == CK_LValueToRValue ||
2429          ICE->getCastKind() == CK_DerivedToBase ||
2430          ICE->getCastKind() == CK_UncheckedDerivedToBase) {
2431        E = ICE->getSubExpr();
2432        continue;
2433      }
2434    }
2435
2436    if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
2437      if (UnOp->getOpcode() == UO_Extension) {
2438        E = UnOp->getSubExpr();
2439        continue;
2440      }
2441    }
2442
2443    if (const MaterializeTemporaryExpr *M
2444                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
2445      E = M->GetTemporaryExpr();
2446      continue;
2447    }
2448
2449    break;
2450  }
2451
2452  if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
2453    return This->isImplicit();
2454
2455  return false;
2456}
2457
2458/// hasAnyTypeDependentArguments - Determines if any of the expressions
2459/// in Exprs is type-dependent.
2460bool Expr::hasAnyTypeDependentArguments(llvm::ArrayRef<Expr *> Exprs) {
2461  for (unsigned I = 0; I < Exprs.size(); ++I)
2462    if (Exprs[I]->isTypeDependent())
2463      return true;
2464
2465  return false;
2466}
2467
2468bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const {
2469  // This function is attempting whether an expression is an initializer
2470  // which can be evaluated at compile-time.  isEvaluatable handles most
2471  // of the cases, but it can't deal with some initializer-specific
2472  // expressions, and it can't deal with aggregates; we deal with those here,
2473  // and fall back to isEvaluatable for the other cases.
2474
2475  // If we ever capture reference-binding directly in the AST, we can
2476  // kill the second parameter.
2477
2478  if (IsForRef) {
2479    EvalResult Result;
2480    return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects;
2481  }
2482
2483  switch (getStmtClass()) {
2484  default: break;
2485  case IntegerLiteralClass:
2486  case FloatingLiteralClass:
2487  case StringLiteralClass:
2488  case ObjCStringLiteralClass:
2489  case ObjCEncodeExprClass:
2490    return true;
2491  case CXXTemporaryObjectExprClass:
2492  case CXXConstructExprClass: {
2493    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
2494
2495    // Only if it's
2496    if (CE->getConstructor()->isTrivial()) {
2497      // 1) an application of the trivial default constructor or
2498      if (!CE->getNumArgs()) return true;
2499
2500      // 2) an elidable trivial copy construction of an operand which is
2501      //    itself a constant initializer.  Note that we consider the
2502      //    operand on its own, *not* as a reference binding.
2503      if (CE->isElidable() &&
2504          CE->getArg(0)->isConstantInitializer(Ctx, false))
2505        return true;
2506    }
2507
2508    // 3) a foldable constexpr constructor.
2509    break;
2510  }
2511  case CompoundLiteralExprClass: {
2512    // This handles gcc's extension that allows global initializers like
2513    // "struct x {int x;} x = (struct x) {};".
2514    // FIXME: This accepts other cases it shouldn't!
2515    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
2516    return Exp->isConstantInitializer(Ctx, false);
2517  }
2518  case InitListExprClass: {
2519    // FIXME: This doesn't deal with fields with reference types correctly.
2520    // FIXME: This incorrectly allows pointers cast to integers to be assigned
2521    // to bitfields.
2522    const InitListExpr *Exp = cast<InitListExpr>(this);
2523    unsigned numInits = Exp->getNumInits();
2524    for (unsigned i = 0; i < numInits; i++) {
2525      if (!Exp->getInit(i)->isConstantInitializer(Ctx, false))
2526        return false;
2527    }
2528    return true;
2529  }
2530  case ImplicitValueInitExprClass:
2531    return true;
2532  case ParenExprClass:
2533    return cast<ParenExpr>(this)->getSubExpr()
2534      ->isConstantInitializer(Ctx, IsForRef);
2535  case GenericSelectionExprClass:
2536    if (cast<GenericSelectionExpr>(this)->isResultDependent())
2537      return false;
2538    return cast<GenericSelectionExpr>(this)->getResultExpr()
2539      ->isConstantInitializer(Ctx, IsForRef);
2540  case ChooseExprClass:
2541    return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)
2542      ->isConstantInitializer(Ctx, IsForRef);
2543  case UnaryOperatorClass: {
2544    const UnaryOperator* Exp = cast<UnaryOperator>(this);
2545    if (Exp->getOpcode() == UO_Extension)
2546      return Exp->getSubExpr()->isConstantInitializer(Ctx, false);
2547    break;
2548  }
2549  case CXXFunctionalCastExprClass:
2550  case CXXStaticCastExprClass:
2551  case ImplicitCastExprClass:
2552  case CStyleCastExprClass: {
2553    const CastExpr *CE = cast<CastExpr>(this);
2554
2555    // If we're promoting an integer to an _Atomic type then this is constant
2556    // if the integer is constant.  We also need to check the converse in case
2557    // someone does something like:
2558    //
2559    // int a = (_Atomic(int))42;
2560    //
2561    // I doubt anyone would write code like this directly, but it's quite
2562    // possible as the result of macro expansions.
2563    if (CE->getCastKind() == CK_NonAtomicToAtomic ||
2564        CE->getCastKind() == CK_AtomicToNonAtomic)
2565      return CE->getSubExpr()->isConstantInitializer(Ctx, false);
2566
2567    // Handle bitcasts of vector constants.
2568    if (getType()->isVectorType() && CE->getCastKind() == CK_BitCast)
2569      return CE->getSubExpr()->isConstantInitializer(Ctx, false);
2570
2571    // Handle misc casts we want to ignore.
2572    // FIXME: Is it really safe to ignore all these?
2573    if (CE->getCastKind() == CK_NoOp ||
2574        CE->getCastKind() == CK_LValueToRValue ||
2575        CE->getCastKind() == CK_ToUnion ||
2576        CE->getCastKind() == CK_ConstructorConversion)
2577      return CE->getSubExpr()->isConstantInitializer(Ctx, false);
2578
2579    break;
2580  }
2581  case MaterializeTemporaryExprClass:
2582    return cast<MaterializeTemporaryExpr>(this)->GetTemporaryExpr()
2583                                            ->isConstantInitializer(Ctx, false);
2584  }
2585  return isEvaluatable(Ctx);
2586}
2587
2588namespace {
2589  /// \brief Look for a call to a non-trivial function within an expression.
2590  class NonTrivialCallFinder : public EvaluatedExprVisitor<NonTrivialCallFinder>
2591  {
2592    typedef EvaluatedExprVisitor<NonTrivialCallFinder> Inherited;
2593
2594    bool NonTrivial;
2595
2596  public:
2597    explicit NonTrivialCallFinder(ASTContext &Context)
2598      : Inherited(Context), NonTrivial(false) { }
2599
2600    bool hasNonTrivialCall() const { return NonTrivial; }
2601
2602    void VisitCallExpr(CallExpr *E) {
2603      if (CXXMethodDecl *Method
2604          = dyn_cast_or_null<CXXMethodDecl>(E->getCalleeDecl())) {
2605        if (Method->isTrivial()) {
2606          // Recurse to children of the call.
2607          Inherited::VisitStmt(E);
2608          return;
2609        }
2610      }
2611
2612      NonTrivial = true;
2613    }
2614
2615    void VisitCXXConstructExpr(CXXConstructExpr *E) {
2616      if (E->getConstructor()->isTrivial()) {
2617        // Recurse to children of the call.
2618        Inherited::VisitStmt(E);
2619        return;
2620      }
2621
2622      NonTrivial = true;
2623    }
2624
2625    void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
2626      if (E->getTemporary()->getDestructor()->isTrivial()) {
2627        Inherited::VisitStmt(E);
2628        return;
2629      }
2630
2631      NonTrivial = true;
2632    }
2633  };
2634}
2635
2636bool Expr::hasNonTrivialCall(ASTContext &Ctx) {
2637  NonTrivialCallFinder Finder(Ctx);
2638  Finder.Visit(this);
2639  return Finder.hasNonTrivialCall();
2640}
2641
2642/// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null
2643/// pointer constant or not, as well as the specific kind of constant detected.
2644/// Null pointer constants can be integer constant expressions with the
2645/// value zero, casts of zero to void*, nullptr (C++0X), or __null
2646/// (a GNU extension).
2647Expr::NullPointerConstantKind
2648Expr::isNullPointerConstant(ASTContext &Ctx,
2649                            NullPointerConstantValueDependence NPC) const {
2650  if (isValueDependent()) {
2651    switch (NPC) {
2652    case NPC_NeverValueDependent:
2653      llvm_unreachable("Unexpected value dependent expression!");
2654    case NPC_ValueDependentIsNull:
2655      if (isTypeDependent() || getType()->isIntegralType(Ctx))
2656        return NPCK_ZeroInteger;
2657      else
2658        return NPCK_NotNull;
2659
2660    case NPC_ValueDependentIsNotNull:
2661      return NPCK_NotNull;
2662    }
2663  }
2664
2665  // Strip off a cast to void*, if it exists. Except in C++.
2666  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
2667    if (!Ctx.getLangOpts().CPlusPlus) {
2668      // Check that it is a cast to void*.
2669      if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
2670        QualType Pointee = PT->getPointeeType();
2671        if (!Pointee.hasQualifiers() &&
2672            Pointee->isVoidType() &&                              // to void*
2673            CE->getSubExpr()->getType()->isIntegerType())         // from int.
2674          return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
2675      }
2676    }
2677  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
2678    // Ignore the ImplicitCastExpr type entirely.
2679    return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
2680  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
2681    // Accept ((void*)0) as a null pointer constant, as many other
2682    // implementations do.
2683    return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
2684  } else if (const GenericSelectionExpr *GE =
2685               dyn_cast<GenericSelectionExpr>(this)) {
2686    return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
2687  } else if (const CXXDefaultArgExpr *DefaultArg
2688               = dyn_cast<CXXDefaultArgExpr>(this)) {
2689    // See through default argument expressions
2690    return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
2691  } else if (isa<GNUNullExpr>(this)) {
2692    // The GNU __null extension is always a null pointer constant.
2693    return NPCK_GNUNull;
2694  } else if (const MaterializeTemporaryExpr *M
2695                                   = dyn_cast<MaterializeTemporaryExpr>(this)) {
2696    return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC);
2697  } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) {
2698    if (const Expr *Source = OVE->getSourceExpr())
2699      return Source->isNullPointerConstant(Ctx, NPC);
2700  }
2701
2702  // C++0x nullptr_t is always a null pointer constant.
2703  if (getType()->isNullPtrType())
2704    return NPCK_CXX0X_nullptr;
2705
2706  if (const RecordType *UT = getType()->getAsUnionType())
2707    if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
2708      if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
2709        const Expr *InitExpr = CLE->getInitializer();
2710        if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
2711          return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
2712      }
2713  // This expression must be an integer type.
2714  if (!getType()->isIntegerType() ||
2715      (Ctx.getLangOpts().CPlusPlus && getType()->isEnumeralType()))
2716    return NPCK_NotNull;
2717
2718  // If we have an integer constant expression, we need to *evaluate* it and
2719  // test for the value 0. Don't use the C++11 constant expression semantics
2720  // for this, for now; once the dust settles on core issue 903, we might only
2721  // allow a literal 0 here in C++11 mode.
2722  if (Ctx.getLangOpts().CPlusPlus0x) {
2723    if (!isCXX98IntegralConstantExpr(Ctx))
2724      return NPCK_NotNull;
2725  } else {
2726    if (!isIntegerConstantExpr(Ctx))
2727      return NPCK_NotNull;
2728  }
2729
2730  return (EvaluateKnownConstInt(Ctx) == 0) ? NPCK_ZeroInteger : NPCK_NotNull;
2731}
2732
2733/// \brief If this expression is an l-value for an Objective C
2734/// property, find the underlying property reference expression.
2735const ObjCPropertyRefExpr *Expr::getObjCProperty() const {
2736  const Expr *E = this;
2737  while (true) {
2738    assert((E->getValueKind() == VK_LValue &&
2739            E->getObjectKind() == OK_ObjCProperty) &&
2740           "expression is not a property reference");
2741    E = E->IgnoreParenCasts();
2742    if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
2743      if (BO->getOpcode() == BO_Comma) {
2744        E = BO->getRHS();
2745        continue;
2746      }
2747    }
2748
2749    break;
2750  }
2751
2752  return cast<ObjCPropertyRefExpr>(E);
2753}
2754
2755FieldDecl *Expr::getBitField() {
2756  Expr *E = this->IgnoreParens();
2757
2758  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2759    if (ICE->getCastKind() == CK_LValueToRValue ||
2760        (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp))
2761      E = ICE->getSubExpr()->IgnoreParens();
2762    else
2763      break;
2764  }
2765
2766  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
2767    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
2768      if (Field->isBitField())
2769        return Field;
2770
2771  if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E))
2772    if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
2773      if (Field->isBitField())
2774        return Field;
2775
2776  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) {
2777    if (BinOp->isAssignmentOp() && BinOp->getLHS())
2778      return BinOp->getLHS()->getBitField();
2779
2780    if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
2781      return BinOp->getRHS()->getBitField();
2782  }
2783
2784  return 0;
2785}
2786
2787bool Expr::refersToVectorElement() const {
2788  const Expr *E = this->IgnoreParens();
2789
2790  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2791    if (ICE->getValueKind() != VK_RValue &&
2792        ICE->getCastKind() == CK_NoOp)
2793      E = ICE->getSubExpr()->IgnoreParens();
2794    else
2795      break;
2796  }
2797
2798  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
2799    return ASE->getBase()->getType()->isVectorType();
2800
2801  if (isa<ExtVectorElementExpr>(E))
2802    return true;
2803
2804  return false;
2805}
2806
2807/// isArrow - Return true if the base expression is a pointer to vector,
2808/// return false if the base expression is a vector.
2809bool ExtVectorElementExpr::isArrow() const {
2810  return getBase()->getType()->isPointerType();
2811}
2812
2813unsigned ExtVectorElementExpr::getNumElements() const {
2814  if (const VectorType *VT = getType()->getAs<VectorType>())
2815    return VT->getNumElements();
2816  return 1;
2817}
2818
2819/// containsDuplicateElements - Return true if any element access is repeated.
2820bool ExtVectorElementExpr::containsDuplicateElements() const {
2821  // FIXME: Refactor this code to an accessor on the AST node which returns the
2822  // "type" of component access, and share with code below and in Sema.
2823  StringRef Comp = Accessor->getName();
2824
2825  // Halving swizzles do not contain duplicate elements.
2826  if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
2827    return false;
2828
2829  // Advance past s-char prefix on hex swizzles.
2830  if (Comp[0] == 's' || Comp[0] == 'S')
2831    Comp = Comp.substr(1);
2832
2833  for (unsigned i = 0, e = Comp.size(); i != e; ++i)
2834    if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos)
2835        return true;
2836
2837  return false;
2838}
2839
2840/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
2841void ExtVectorElementExpr::getEncodedElementAccess(
2842                                  SmallVectorImpl<unsigned> &Elts) const {
2843  StringRef Comp = Accessor->getName();
2844  if (Comp[0] == 's' || Comp[0] == 'S')
2845    Comp = Comp.substr(1);
2846
2847  bool isHi =   Comp == "hi";
2848  bool isLo =   Comp == "lo";
2849  bool isEven = Comp == "even";
2850  bool isOdd  = Comp == "odd";
2851
2852  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
2853    uint64_t Index;
2854
2855    if (isHi)
2856      Index = e + i;
2857    else if (isLo)
2858      Index = i;
2859    else if (isEven)
2860      Index = 2 * i;
2861    else if (isOdd)
2862      Index = 2 * i + 1;
2863    else
2864      Index = ExtVectorType::getAccessorIdx(Comp[i]);
2865
2866    Elts.push_back(Index);
2867  }
2868}
2869
2870ObjCMessageExpr::ObjCMessageExpr(QualType T,
2871                                 ExprValueKind VK,
2872                                 SourceLocation LBracLoc,
2873                                 SourceLocation SuperLoc,
2874                                 bool IsInstanceSuper,
2875                                 QualType SuperType,
2876                                 Selector Sel,
2877                                 ArrayRef<SourceLocation> SelLocs,
2878                                 SelectorLocationsKind SelLocsK,
2879                                 ObjCMethodDecl *Method,
2880                                 ArrayRef<Expr *> Args,
2881                                 SourceLocation RBracLoc,
2882                                 bool isImplicit)
2883  : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
2884         /*TypeDependent=*/false, /*ValueDependent=*/false,
2885         /*InstantiationDependent=*/false,
2886         /*ContainsUnexpandedParameterPack=*/false),
2887    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2888                                                       : Sel.getAsOpaquePtr())),
2889    Kind(IsInstanceSuper? SuperInstance : SuperClass),
2890    HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit),
2891    SuperLoc(SuperLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2892{
2893  initArgsAndSelLocs(Args, SelLocs, SelLocsK);
2894  setReceiverPointer(SuperType.getAsOpaquePtr());
2895}
2896
2897ObjCMessageExpr::ObjCMessageExpr(QualType T,
2898                                 ExprValueKind VK,
2899                                 SourceLocation LBracLoc,
2900                                 TypeSourceInfo *Receiver,
2901                                 Selector Sel,
2902                                 ArrayRef<SourceLocation> SelLocs,
2903                                 SelectorLocationsKind SelLocsK,
2904                                 ObjCMethodDecl *Method,
2905                                 ArrayRef<Expr *> Args,
2906                                 SourceLocation RBracLoc,
2907                                 bool isImplicit)
2908  : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(),
2909         T->isDependentType(), T->isInstantiationDependentType(),
2910         T->containsUnexpandedParameterPack()),
2911    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2912                                                       : Sel.getAsOpaquePtr())),
2913    Kind(Class),
2914    HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit),
2915    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2916{
2917  initArgsAndSelLocs(Args, SelLocs, SelLocsK);
2918  setReceiverPointer(Receiver);
2919}
2920
2921ObjCMessageExpr::ObjCMessageExpr(QualType T,
2922                                 ExprValueKind VK,
2923                                 SourceLocation LBracLoc,
2924                                 Expr *Receiver,
2925                                 Selector Sel,
2926                                 ArrayRef<SourceLocation> SelLocs,
2927                                 SelectorLocationsKind SelLocsK,
2928                                 ObjCMethodDecl *Method,
2929                                 ArrayRef<Expr *> Args,
2930                                 SourceLocation RBracLoc,
2931                                 bool isImplicit)
2932  : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(),
2933         Receiver->isTypeDependent(),
2934         Receiver->isInstantiationDependent(),
2935         Receiver->containsUnexpandedParameterPack()),
2936    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2937                                                       : Sel.getAsOpaquePtr())),
2938    Kind(Instance),
2939    HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit),
2940    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2941{
2942  initArgsAndSelLocs(Args, SelLocs, SelLocsK);
2943  setReceiverPointer(Receiver);
2944}
2945
2946void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args,
2947                                         ArrayRef<SourceLocation> SelLocs,
2948                                         SelectorLocationsKind SelLocsK) {
2949  setNumArgs(Args.size());
2950  Expr **MyArgs = getArgs();
2951  for (unsigned I = 0; I != Args.size(); ++I) {
2952    if (Args[I]->isTypeDependent())
2953      ExprBits.TypeDependent = true;
2954    if (Args[I]->isValueDependent())
2955      ExprBits.ValueDependent = true;
2956    if (Args[I]->isInstantiationDependent())
2957      ExprBits.InstantiationDependent = true;
2958    if (Args[I]->containsUnexpandedParameterPack())
2959      ExprBits.ContainsUnexpandedParameterPack = true;
2960
2961    MyArgs[I] = Args[I];
2962  }
2963
2964  SelLocsKind = SelLocsK;
2965  if (!isImplicit()) {
2966    if (SelLocsK == SelLoc_NonStandard)
2967      std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
2968  }
2969}
2970
2971ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2972                                         ExprValueKind VK,
2973                                         SourceLocation LBracLoc,
2974                                         SourceLocation SuperLoc,
2975                                         bool IsInstanceSuper,
2976                                         QualType SuperType,
2977                                         Selector Sel,
2978                                         ArrayRef<SourceLocation> SelLocs,
2979                                         ObjCMethodDecl *Method,
2980                                         ArrayRef<Expr *> Args,
2981                                         SourceLocation RBracLoc,
2982                                         bool isImplicit) {
2983  assert((!SelLocs.empty() || isImplicit) &&
2984         "No selector locs for non-implicit message");
2985  ObjCMessageExpr *Mem;
2986  SelectorLocationsKind SelLocsK = SelectorLocationsKind();
2987  if (isImplicit)
2988    Mem = alloc(Context, Args.size(), 0);
2989  else
2990    Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
2991  return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper,
2992                                   SuperType, Sel, SelLocs, SelLocsK,
2993                                   Method, Args, RBracLoc, isImplicit);
2994}
2995
2996ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2997                                         ExprValueKind VK,
2998                                         SourceLocation LBracLoc,
2999                                         TypeSourceInfo *Receiver,
3000                                         Selector Sel,
3001                                         ArrayRef<SourceLocation> SelLocs,
3002                                         ObjCMethodDecl *Method,
3003                                         ArrayRef<Expr *> Args,
3004                                         SourceLocation RBracLoc,
3005                                         bool isImplicit) {
3006  assert((!SelLocs.empty() || isImplicit) &&
3007         "No selector locs for non-implicit message");
3008  ObjCMessageExpr *Mem;
3009  SelectorLocationsKind SelLocsK = SelectorLocationsKind();
3010  if (isImplicit)
3011    Mem = alloc(Context, Args.size(), 0);
3012  else
3013    Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
3014  return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel,
3015                                   SelLocs, SelLocsK, Method, Args, RBracLoc,
3016                                   isImplicit);
3017}
3018
3019ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
3020                                         ExprValueKind VK,
3021                                         SourceLocation LBracLoc,
3022                                         Expr *Receiver,
3023                                         Selector Sel,
3024                                         ArrayRef<SourceLocation> SelLocs,
3025                                         ObjCMethodDecl *Method,
3026                                         ArrayRef<Expr *> Args,
3027                                         SourceLocation RBracLoc,
3028                                         bool isImplicit) {
3029  assert((!SelLocs.empty() || isImplicit) &&
3030         "No selector locs for non-implicit message");
3031  ObjCMessageExpr *Mem;
3032  SelectorLocationsKind SelLocsK = SelectorLocationsKind();
3033  if (isImplicit)
3034    Mem = alloc(Context, Args.size(), 0);
3035  else
3036    Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
3037  return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel,
3038                                   SelLocs, SelLocsK, Method, Args, RBracLoc,
3039                                   isImplicit);
3040}
3041
3042ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context,
3043                                              unsigned NumArgs,
3044                                              unsigned NumStoredSelLocs) {
3045  ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs);
3046  return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
3047}
3048
3049ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext &C,
3050                                        ArrayRef<Expr *> Args,
3051                                        SourceLocation RBraceLoc,
3052                                        ArrayRef<SourceLocation> SelLocs,
3053                                        Selector Sel,
3054                                        SelectorLocationsKind &SelLocsK) {
3055  SelLocsK = hasStandardSelectorLocs(Sel, SelLocs, Args, RBraceLoc);
3056  unsigned NumStoredSelLocs = (SelLocsK == SelLoc_NonStandard) ? SelLocs.size()
3057                                                               : 0;
3058  return alloc(C, Args.size(), NumStoredSelLocs);
3059}
3060
3061ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext &C,
3062                                        unsigned NumArgs,
3063                                        unsigned NumStoredSelLocs) {
3064  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
3065    NumArgs * sizeof(Expr *) + NumStoredSelLocs * sizeof(SourceLocation);
3066  return (ObjCMessageExpr *)C.Allocate(Size,
3067                                     llvm::AlignOf<ObjCMessageExpr>::Alignment);
3068}
3069
3070void ObjCMessageExpr::getSelectorLocs(
3071                               SmallVectorImpl<SourceLocation> &SelLocs) const {
3072  for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
3073    SelLocs.push_back(getSelectorLoc(i));
3074}
3075
3076SourceRange ObjCMessageExpr::getReceiverRange() const {
3077  switch (getReceiverKind()) {
3078  case Instance:
3079    return getInstanceReceiver()->getSourceRange();
3080
3081  case Class:
3082    return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange();
3083
3084  case SuperInstance:
3085  case SuperClass:
3086    return getSuperLoc();
3087  }
3088
3089  llvm_unreachable("Invalid ReceiverKind!");
3090}
3091
3092Selector ObjCMessageExpr::getSelector() const {
3093  if (HasMethod)
3094    return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
3095                                                               ->getSelector();
3096  return Selector(SelectorOrMethod);
3097}
3098
3099ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
3100  switch (getReceiverKind()) {
3101  case Instance:
3102    if (const ObjCObjectPointerType *Ptr
3103          = getInstanceReceiver()->getType()->getAs<ObjCObjectPointerType>())
3104      return Ptr->getInterfaceDecl();
3105    break;
3106
3107  case Class:
3108    if (const ObjCObjectType *Ty
3109          = getClassReceiver()->getAs<ObjCObjectType>())
3110      return Ty->getInterface();
3111    break;
3112
3113  case SuperInstance:
3114    if (const ObjCObjectPointerType *Ptr
3115          = getSuperType()->getAs<ObjCObjectPointerType>())
3116      return Ptr->getInterfaceDecl();
3117    break;
3118
3119  case SuperClass:
3120    if (const ObjCObjectType *Iface
3121          = getSuperType()->getAs<ObjCObjectType>())
3122      return Iface->getInterface();
3123    break;
3124  }
3125
3126  return 0;
3127}
3128
3129StringRef ObjCBridgedCastExpr::getBridgeKindName() const {
3130  switch (getBridgeKind()) {
3131  case OBC_Bridge:
3132    return "__bridge";
3133  case OBC_BridgeTransfer:
3134    return "__bridge_transfer";
3135  case OBC_BridgeRetained:
3136    return "__bridge_retained";
3137  }
3138
3139  llvm_unreachable("Invalid BridgeKind!");
3140}
3141
3142bool ChooseExpr::isConditionTrue(const ASTContext &C) const {
3143  return getCond()->EvaluateKnownConstInt(C) != 0;
3144}
3145
3146ShuffleVectorExpr::ShuffleVectorExpr(ASTContext &C, Expr **args, unsigned nexpr,
3147                                     QualType Type, SourceLocation BLoc,
3148                                     SourceLocation RP)
3149   : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary,
3150          Type->isDependentType(), Type->isDependentType(),
3151          Type->isInstantiationDependentType(),
3152          Type->containsUnexpandedParameterPack()),
3153     BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(nexpr)
3154{
3155  SubExprs = new (C) Stmt*[nexpr];
3156  for (unsigned i = 0; i < nexpr; i++) {
3157    if (args[i]->isTypeDependent())
3158      ExprBits.TypeDependent = true;
3159    if (args[i]->isValueDependent())
3160      ExprBits.ValueDependent = true;
3161    if (args[i]->isInstantiationDependent())
3162      ExprBits.InstantiationDependent = true;
3163    if (args[i]->containsUnexpandedParameterPack())
3164      ExprBits.ContainsUnexpandedParameterPack = true;
3165
3166    SubExprs[i] = args[i];
3167  }
3168}
3169
3170void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
3171                                 unsigned NumExprs) {
3172  if (SubExprs) C.Deallocate(SubExprs);
3173
3174  SubExprs = new (C) Stmt* [NumExprs];
3175  this->NumExprs = NumExprs;
3176  memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
3177}
3178
3179GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
3180                               SourceLocation GenericLoc, Expr *ControllingExpr,
3181                               TypeSourceInfo **AssocTypes, Expr **AssocExprs,
3182                               unsigned NumAssocs, SourceLocation DefaultLoc,
3183                               SourceLocation RParenLoc,
3184                               bool ContainsUnexpandedParameterPack,
3185                               unsigned ResultIndex)
3186  : Expr(GenericSelectionExprClass,
3187         AssocExprs[ResultIndex]->getType(),
3188         AssocExprs[ResultIndex]->getValueKind(),
3189         AssocExprs[ResultIndex]->getObjectKind(),
3190         AssocExprs[ResultIndex]->isTypeDependent(),
3191         AssocExprs[ResultIndex]->isValueDependent(),
3192         AssocExprs[ResultIndex]->isInstantiationDependent(),
3193         ContainsUnexpandedParameterPack),
3194    AssocTypes(new (Context) TypeSourceInfo*[NumAssocs]),
3195    SubExprs(new (Context) Stmt*[END_EXPR+NumAssocs]), NumAssocs(NumAssocs),
3196    ResultIndex(ResultIndex), GenericLoc(GenericLoc), DefaultLoc(DefaultLoc),
3197    RParenLoc(RParenLoc) {
3198  SubExprs[CONTROLLING] = ControllingExpr;
3199  std::copy(AssocTypes, AssocTypes+NumAssocs, this->AssocTypes);
3200  std::copy(AssocExprs, AssocExprs+NumAssocs, SubExprs+END_EXPR);
3201}
3202
3203GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
3204                               SourceLocation GenericLoc, Expr *ControllingExpr,
3205                               TypeSourceInfo **AssocTypes, Expr **AssocExprs,
3206                               unsigned NumAssocs, SourceLocation DefaultLoc,
3207                               SourceLocation RParenLoc,
3208                               bool ContainsUnexpandedParameterPack)
3209  : Expr(GenericSelectionExprClass,
3210         Context.DependentTy,
3211         VK_RValue,
3212         OK_Ordinary,
3213         /*isTypeDependent=*/true,
3214         /*isValueDependent=*/true,
3215         /*isInstantiationDependent=*/true,
3216         ContainsUnexpandedParameterPack),
3217    AssocTypes(new (Context) TypeSourceInfo*[NumAssocs]),
3218    SubExprs(new (Context) Stmt*[END_EXPR+NumAssocs]), NumAssocs(NumAssocs),
3219    ResultIndex(-1U), GenericLoc(GenericLoc), DefaultLoc(DefaultLoc),
3220    RParenLoc(RParenLoc) {
3221  SubExprs[CONTROLLING] = ControllingExpr;
3222  std::copy(AssocTypes, AssocTypes+NumAssocs, this->AssocTypes);
3223  std::copy(AssocExprs, AssocExprs+NumAssocs, SubExprs+END_EXPR);
3224}
3225
3226//===----------------------------------------------------------------------===//
3227//  DesignatedInitExpr
3228//===----------------------------------------------------------------------===//
3229
3230IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const {
3231  assert(Kind == FieldDesignator && "Only valid on a field designator");
3232  if (Field.NameOrField & 0x01)
3233    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
3234  else
3235    return getField()->getIdentifier();
3236}
3237
3238DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
3239                                       unsigned NumDesignators,
3240                                       const Designator *Designators,
3241                                       SourceLocation EqualOrColonLoc,
3242                                       bool GNUSyntax,
3243                                       Expr **IndexExprs,
3244                                       unsigned NumIndexExprs,
3245                                       Expr *Init)
3246  : Expr(DesignatedInitExprClass, Ty,
3247         Init->getValueKind(), Init->getObjectKind(),
3248         Init->isTypeDependent(), Init->isValueDependent(),
3249         Init->isInstantiationDependent(),
3250         Init->containsUnexpandedParameterPack()),
3251    EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
3252    NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
3253  this->Designators = new (C) Designator[NumDesignators];
3254
3255  // Record the initializer itself.
3256  child_range Child = children();
3257  *Child++ = Init;
3258
3259  // Copy the designators and their subexpressions, computing
3260  // value-dependence along the way.
3261  unsigned IndexIdx = 0;
3262  for (unsigned I = 0; I != NumDesignators; ++I) {
3263    this->Designators[I] = Designators[I];
3264
3265    if (this->Designators[I].isArrayDesignator()) {
3266      // Compute type- and value-dependence.
3267      Expr *Index = IndexExprs[IndexIdx];
3268      if (Index->isTypeDependent() || Index->isValueDependent())
3269        ExprBits.ValueDependent = true;
3270      if (Index->isInstantiationDependent())
3271        ExprBits.InstantiationDependent = true;
3272      // Propagate unexpanded parameter packs.
3273      if (Index->containsUnexpandedParameterPack())
3274        ExprBits.ContainsUnexpandedParameterPack = true;
3275
3276      // Copy the index expressions into permanent storage.
3277      *Child++ = IndexExprs[IndexIdx++];
3278    } else if (this->Designators[I].isArrayRangeDesignator()) {
3279      // Compute type- and value-dependence.
3280      Expr *Start = IndexExprs[IndexIdx];
3281      Expr *End = IndexExprs[IndexIdx + 1];
3282      if (Start->isTypeDependent() || Start->isValueDependent() ||
3283          End->isTypeDependent() || End->isValueDependent()) {
3284        ExprBits.ValueDependent = true;
3285        ExprBits.InstantiationDependent = true;
3286      } else if (Start->isInstantiationDependent() ||
3287                 End->isInstantiationDependent()) {
3288        ExprBits.InstantiationDependent = true;
3289      }
3290
3291      // Propagate unexpanded parameter packs.
3292      if (Start->containsUnexpandedParameterPack() ||
3293          End->containsUnexpandedParameterPack())
3294        ExprBits.ContainsUnexpandedParameterPack = true;
3295
3296      // Copy the start/end expressions into permanent storage.
3297      *Child++ = IndexExprs[IndexIdx++];
3298      *Child++ = IndexExprs[IndexIdx++];
3299    }
3300  }
3301
3302  assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
3303}
3304
3305DesignatedInitExpr *
3306DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
3307                           unsigned NumDesignators,
3308                           Expr **IndexExprs, unsigned NumIndexExprs,
3309                           SourceLocation ColonOrEqualLoc,
3310                           bool UsesColonSyntax, Expr *Init) {
3311  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
3312                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
3313  return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
3314                                      ColonOrEqualLoc, UsesColonSyntax,
3315                                      IndexExprs, NumIndexExprs, Init);
3316}
3317
3318DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
3319                                                    unsigned NumIndexExprs) {
3320  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
3321                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
3322  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
3323}
3324
3325void DesignatedInitExpr::setDesignators(ASTContext &C,
3326                                        const Designator *Desigs,
3327                                        unsigned NumDesigs) {
3328  Designators = new (C) Designator[NumDesigs];
3329  NumDesignators = NumDesigs;
3330  for (unsigned I = 0; I != NumDesigs; ++I)
3331    Designators[I] = Desigs[I];
3332}
3333
3334SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
3335  DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
3336  if (size() == 1)
3337    return DIE->getDesignator(0)->getSourceRange();
3338  return SourceRange(DIE->getDesignator(0)->getStartLocation(),
3339                     DIE->getDesignator(size()-1)->getEndLocation());
3340}
3341
3342SourceRange DesignatedInitExpr::getSourceRange() const {
3343  SourceLocation StartLoc;
3344  Designator &First =
3345    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
3346  if (First.isFieldDesignator()) {
3347    if (GNUSyntax)
3348      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
3349    else
3350      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
3351  } else
3352    StartLoc =
3353      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
3354  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
3355}
3356
3357Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
3358  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
3359  char* Ptr = static_cast<char*>(static_cast<void *>(this));
3360  Ptr += sizeof(DesignatedInitExpr);
3361  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3362  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
3363}
3364
3365Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
3366  assert(D.Kind == Designator::ArrayRangeDesignator &&
3367         "Requires array range designator");
3368  char* Ptr = static_cast<char*>(static_cast<void *>(this));
3369  Ptr += sizeof(DesignatedInitExpr);
3370  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3371  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
3372}
3373
3374Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
3375  assert(D.Kind == Designator::ArrayRangeDesignator &&
3376         "Requires array range designator");
3377  char* Ptr = static_cast<char*>(static_cast<void *>(this));
3378  Ptr += sizeof(DesignatedInitExpr);
3379  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3380  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
3381}
3382
3383/// \brief Replaces the designator at index @p Idx with the series
3384/// of designators in [First, Last).
3385void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
3386                                          const Designator *First,
3387                                          const Designator *Last) {
3388  unsigned NumNewDesignators = Last - First;
3389  if (NumNewDesignators == 0) {
3390    std::copy_backward(Designators + Idx + 1,
3391                       Designators + NumDesignators,
3392                       Designators + Idx);
3393    --NumNewDesignators;
3394    return;
3395  } else if (NumNewDesignators == 1) {
3396    Designators[Idx] = *First;
3397    return;
3398  }
3399
3400  Designator *NewDesignators
3401    = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
3402  std::copy(Designators, Designators + Idx, NewDesignators);
3403  std::copy(First, Last, NewDesignators + Idx);
3404  std::copy(Designators + Idx + 1, Designators + NumDesignators,
3405            NewDesignators + Idx + NumNewDesignators);
3406  Designators = NewDesignators;
3407  NumDesignators = NumDesignators - 1 + NumNewDesignators;
3408}
3409
3410ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
3411                             Expr **exprs, unsigned nexprs,
3412                             SourceLocation rparenloc)
3413  : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary,
3414         false, false, false, false),
3415    NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
3416  Exprs = new (C) Stmt*[nexprs];
3417  for (unsigned i = 0; i != nexprs; ++i) {
3418    if (exprs[i]->isTypeDependent())
3419      ExprBits.TypeDependent = true;
3420    if (exprs[i]->isValueDependent())
3421      ExprBits.ValueDependent = true;
3422    if (exprs[i]->isInstantiationDependent())
3423      ExprBits.InstantiationDependent = true;
3424    if (exprs[i]->containsUnexpandedParameterPack())
3425      ExprBits.ContainsUnexpandedParameterPack = true;
3426
3427    Exprs[i] = exprs[i];
3428  }
3429}
3430
3431const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
3432  if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
3433    e = ewc->getSubExpr();
3434  if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e))
3435    e = m->GetTemporaryExpr();
3436  e = cast<CXXConstructExpr>(e)->getArg(0);
3437  while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3438    e = ice->getSubExpr();
3439  return cast<OpaqueValueExpr>(e);
3440}
3441
3442PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext &Context, EmptyShell sh,
3443                                           unsigned numSemanticExprs) {
3444  void *buffer = Context.Allocate(sizeof(PseudoObjectExpr) +
3445                                    (1 + numSemanticExprs) * sizeof(Expr*),
3446                                  llvm::alignOf<PseudoObjectExpr>());
3447  return new(buffer) PseudoObjectExpr(sh, numSemanticExprs);
3448}
3449
3450PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs)
3451  : Expr(PseudoObjectExprClass, shell) {
3452  PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1;
3453}
3454
3455PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext &C, Expr *syntax,
3456                                           ArrayRef<Expr*> semantics,
3457                                           unsigned resultIndex) {
3458  assert(syntax && "no syntactic expression!");
3459  assert(semantics.size() && "no semantic expressions!");
3460
3461  QualType type;
3462  ExprValueKind VK;
3463  if (resultIndex == NoResult) {
3464    type = C.VoidTy;
3465    VK = VK_RValue;
3466  } else {
3467    assert(resultIndex < semantics.size());
3468    type = semantics[resultIndex]->getType();
3469    VK = semantics[resultIndex]->getValueKind();
3470    assert(semantics[resultIndex]->getObjectKind() == OK_Ordinary);
3471  }
3472
3473  void *buffer = C.Allocate(sizeof(PseudoObjectExpr) +
3474                              (1 + semantics.size()) * sizeof(Expr*),
3475                            llvm::alignOf<PseudoObjectExpr>());
3476  return new(buffer) PseudoObjectExpr(type, VK, syntax, semantics,
3477                                      resultIndex);
3478}
3479
3480PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK,
3481                                   Expr *syntax, ArrayRef<Expr*> semantics,
3482                                   unsigned resultIndex)
3483  : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary,
3484         /*filled in at end of ctor*/ false, false, false, false) {
3485  PseudoObjectExprBits.NumSubExprs = semantics.size() + 1;
3486  PseudoObjectExprBits.ResultIndex = resultIndex + 1;
3487
3488  for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) {
3489    Expr *E = (i == 0 ? syntax : semantics[i-1]);
3490    getSubExprsBuffer()[i] = E;
3491
3492    if (E->isTypeDependent())
3493      ExprBits.TypeDependent = true;
3494    if (E->isValueDependent())
3495      ExprBits.ValueDependent = true;
3496    if (E->isInstantiationDependent())
3497      ExprBits.InstantiationDependent = true;
3498    if (E->containsUnexpandedParameterPack())
3499      ExprBits.ContainsUnexpandedParameterPack = true;
3500
3501    if (isa<OpaqueValueExpr>(E))
3502      assert(cast<OpaqueValueExpr>(E)->getSourceExpr() != 0 &&
3503             "opaque-value semantic expressions for pseudo-object "
3504             "operations must have sources");
3505  }
3506}
3507
3508//===----------------------------------------------------------------------===//
3509//  ExprIterator.
3510//===----------------------------------------------------------------------===//
3511
3512Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
3513Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
3514Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
3515const Expr* ConstExprIterator::operator[](size_t idx) const {
3516  return cast<Expr>(I[idx]);
3517}
3518const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
3519const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
3520
3521//===----------------------------------------------------------------------===//
3522//  Child Iterators for iterating over subexpressions/substatements
3523//===----------------------------------------------------------------------===//
3524
3525// UnaryExprOrTypeTraitExpr
3526Stmt::child_range UnaryExprOrTypeTraitExpr::children() {
3527  // If this is of a type and the type is a VLA type (and not a typedef), the
3528  // size expression of the VLA needs to be treated as an executable expression.
3529  // Why isn't this weirdness documented better in StmtIterator?
3530  if (isArgumentType()) {
3531    if (const VariableArrayType* T = dyn_cast<VariableArrayType>(
3532                                   getArgumentType().getTypePtr()))
3533      return child_range(child_iterator(T), child_iterator());
3534    return child_range();
3535  }
3536  return child_range(&Argument.Ex, &Argument.Ex + 1);
3537}
3538
3539// ObjCMessageExpr
3540Stmt::child_range ObjCMessageExpr::children() {
3541  Stmt **begin;
3542  if (getReceiverKind() == Instance)
3543    begin = reinterpret_cast<Stmt **>(this + 1);
3544  else
3545    begin = reinterpret_cast<Stmt **>(getArgs());
3546  return child_range(begin,
3547                     reinterpret_cast<Stmt **>(getArgs() + getNumArgs()));
3548}
3549
3550ObjCArrayLiteral::ObjCArrayLiteral(llvm::ArrayRef<Expr *> Elements,
3551                                   QualType T, ObjCMethodDecl *Method,
3552                                   SourceRange SR)
3553  : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary,
3554         false, false, false, false),
3555    NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method)
3556{
3557  Expr **SaveElements = getElements();
3558  for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
3559    if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent())
3560      ExprBits.ValueDependent = true;
3561    if (Elements[I]->isInstantiationDependent())
3562      ExprBits.InstantiationDependent = true;
3563    if (Elements[I]->containsUnexpandedParameterPack())
3564      ExprBits.ContainsUnexpandedParameterPack = true;
3565
3566    SaveElements[I] = Elements[I];
3567  }
3568}
3569
3570ObjCArrayLiteral *ObjCArrayLiteral::Create(ASTContext &C,
3571                                           llvm::ArrayRef<Expr *> Elements,
3572                                           QualType T, ObjCMethodDecl * Method,
3573                                           SourceRange SR) {
3574  void *Mem = C.Allocate(sizeof(ObjCArrayLiteral)
3575                         + Elements.size() * sizeof(Expr *));
3576  return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR);
3577}
3578
3579ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(ASTContext &C,
3580                                                unsigned NumElements) {
3581
3582  void *Mem = C.Allocate(sizeof(ObjCArrayLiteral)
3583                         + NumElements * sizeof(Expr *));
3584  return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements);
3585}
3586
3587ObjCDictionaryLiteral::ObjCDictionaryLiteral(
3588                                             ArrayRef<ObjCDictionaryElement> VK,
3589                                             bool HasPackExpansions,
3590                                             QualType T, ObjCMethodDecl *method,
3591                                             SourceRange SR)
3592  : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
3593         false, false),
3594    NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR),
3595    DictWithObjectsMethod(method)
3596{
3597  KeyValuePair *KeyValues = getKeyValues();
3598  ExpansionData *Expansions = getExpansionData();
3599  for (unsigned I = 0; I < NumElements; I++) {
3600    if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() ||
3601        VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent())
3602      ExprBits.ValueDependent = true;
3603    if (VK[I].Key->isInstantiationDependent() ||
3604        VK[I].Value->isInstantiationDependent())
3605      ExprBits.InstantiationDependent = true;
3606    if (VK[I].EllipsisLoc.isInvalid() &&
3607        (VK[I].Key->containsUnexpandedParameterPack() ||
3608         VK[I].Value->containsUnexpandedParameterPack()))
3609      ExprBits.ContainsUnexpandedParameterPack = true;
3610
3611    KeyValues[I].Key = VK[I].Key;
3612    KeyValues[I].Value = VK[I].Value;
3613    if (Expansions) {
3614      Expansions[I].EllipsisLoc = VK[I].EllipsisLoc;
3615      if (VK[I].NumExpansions)
3616        Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1;
3617      else
3618        Expansions[I].NumExpansionsPlusOne = 0;
3619    }
3620  }
3621}
3622
3623ObjCDictionaryLiteral *
3624ObjCDictionaryLiteral::Create(ASTContext &C,
3625                              ArrayRef<ObjCDictionaryElement> VK,
3626                              bool HasPackExpansions,
3627                              QualType T, ObjCMethodDecl *method,
3628                              SourceRange SR) {
3629  unsigned ExpansionsSize = 0;
3630  if (HasPackExpansions)
3631    ExpansionsSize = sizeof(ExpansionData) * VK.size();
3632
3633  void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) +
3634                         sizeof(KeyValuePair) * VK.size() + ExpansionsSize);
3635  return new (Mem) ObjCDictionaryLiteral(VK, HasPackExpansions, T, method, SR);
3636}
3637
3638ObjCDictionaryLiteral *
3639ObjCDictionaryLiteral::CreateEmpty(ASTContext &C, unsigned NumElements,
3640                                   bool HasPackExpansions) {
3641  unsigned ExpansionsSize = 0;
3642  if (HasPackExpansions)
3643    ExpansionsSize = sizeof(ExpansionData) * NumElements;
3644  void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) +
3645                         sizeof(KeyValuePair) * NumElements + ExpansionsSize);
3646  return new (Mem) ObjCDictionaryLiteral(EmptyShell(), NumElements,
3647                                         HasPackExpansions);
3648}
3649
3650ObjCSubscriptRefExpr *ObjCSubscriptRefExpr::Create(ASTContext &C,
3651                                                   Expr *base,
3652                                                   Expr *key, QualType T,
3653                                                   ObjCMethodDecl *getMethod,
3654                                                   ObjCMethodDecl *setMethod,
3655                                                   SourceLocation RB) {
3656  void *Mem = C.Allocate(sizeof(ObjCSubscriptRefExpr));
3657  return new (Mem) ObjCSubscriptRefExpr(base, key, T, VK_LValue,
3658                                        OK_ObjCSubscript,
3659                                        getMethod, setMethod, RB);
3660}
3661
3662AtomicExpr::AtomicExpr(SourceLocation BLoc, Expr **args, unsigned nexpr,
3663                       QualType t, AtomicOp op, SourceLocation RP)
3664  : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary,
3665         false, false, false, false),
3666    NumSubExprs(nexpr), BuiltinLoc(BLoc), RParenLoc(RP), Op(op)
3667{
3668  assert(nexpr == getNumSubExprs(op) && "wrong number of subexpressions");
3669  for (unsigned i = 0; i < nexpr; i++) {
3670    if (args[i]->isTypeDependent())
3671      ExprBits.TypeDependent = true;
3672    if (args[i]->isValueDependent())
3673      ExprBits.ValueDependent = true;
3674    if (args[i]->isInstantiationDependent())
3675      ExprBits.InstantiationDependent = true;
3676    if (args[i]->containsUnexpandedParameterPack())
3677      ExprBits.ContainsUnexpandedParameterPack = true;
3678
3679    SubExprs[i] = args[i];
3680  }
3681}
3682
3683unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) {
3684  switch (Op) {
3685  case AO__c11_atomic_init:
3686  case AO__c11_atomic_load:
3687  case AO__atomic_load_n:
3688    return 2;
3689
3690  case AO__c11_atomic_store:
3691  case AO__c11_atomic_exchange:
3692  case AO__atomic_load:
3693  case AO__atomic_store:
3694  case AO__atomic_store_n:
3695  case AO__atomic_exchange_n:
3696  case AO__c11_atomic_fetch_add:
3697  case AO__c11_atomic_fetch_sub:
3698  case AO__c11_atomic_fetch_and:
3699  case AO__c11_atomic_fetch_or:
3700  case AO__c11_atomic_fetch_xor:
3701  case AO__atomic_fetch_add:
3702  case AO__atomic_fetch_sub:
3703  case AO__atomic_fetch_and:
3704  case AO__atomic_fetch_or:
3705  case AO__atomic_fetch_xor:
3706  case AO__atomic_fetch_nand:
3707  case AO__atomic_add_fetch:
3708  case AO__atomic_sub_fetch:
3709  case AO__atomic_and_fetch:
3710  case AO__atomic_or_fetch:
3711  case AO__atomic_xor_fetch:
3712  case AO__atomic_nand_fetch:
3713    return 3;
3714
3715  case AO__atomic_exchange:
3716    return 4;
3717
3718  case AO__c11_atomic_compare_exchange_strong:
3719  case AO__c11_atomic_compare_exchange_weak:
3720    return 5;
3721
3722  case AO__atomic_compare_exchange:
3723  case AO__atomic_compare_exchange_n:
3724    return 6;
3725  }
3726  llvm_unreachable("unknown atomic op");
3727}
3728