clang  7.0.0svn
Expr.h
Go to the documentation of this file.
1 //===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//
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 defines the Expr interface and subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_EXPR_H
15 #define LLVM_CLANG_AST_EXPR_H
16 
17 #include "clang/AST/APValue.h"
18 #include "clang/AST/ASTVector.h"
19 #include "clang/AST/Decl.h"
22 #include "clang/AST/Stmt.h"
23 #include "clang/AST/TemplateBase.h"
24 #include "clang/AST/Type.h"
25 #include "clang/Basic/CharInfo.h"
27 #include "clang/Basic/SyncScope.h"
28 #include "clang/Basic/TypeTraits.h"
29 #include "llvm/ADT/APFloat.h"
30 #include "llvm/ADT/APSInt.h"
31 #include "llvm/ADT/SmallVector.h"
32 #include "llvm/ADT/StringRef.h"
33 #include "llvm/Support/AtomicOrdering.h"
34 #include "llvm/Support/Compiler.h"
35 
36 namespace clang {
37  class APValue;
38  class ASTContext;
39  class BlockDecl;
40  class CXXBaseSpecifier;
41  class CXXMemberCallExpr;
42  class CXXOperatorCallExpr;
43  class CastExpr;
44  class Decl;
45  class IdentifierInfo;
46  class MaterializeTemporaryExpr;
47  class NamedDecl;
48  class ObjCPropertyRefExpr;
49  class OpaqueValueExpr;
50  class ParmVarDecl;
51  class StringLiteral;
52  class TargetInfo;
53  class ValueDecl;
54 
55 /// A simple array of base specifiers.
57 
58 /// An adjustment to be made to the temporary created when emitting a
59 /// reference binding, which accesses a particular subobject of that temporary.
61  enum {
65  } Kind;
66 
67  struct DTB {
70  };
71 
72  struct P {
75  };
76 
77  union {
80  struct P Ptr;
81  };
82 
85  : Kind(DerivedToBaseAdjustment) {
88  }
89 
91  : Kind(FieldAdjustment) {
92  this->Field = Field;
93  }
94 
96  : Kind(MemberPointerAdjustment) {
97  this->Ptr.MPT = MPT;
98  this->Ptr.RHS = RHS;
99  }
100 };
101 
102 /// Expr - This represents one expression. Note that Expr's are subclasses of
103 /// Stmt. This allows an expression to be transparently used any place a Stmt
104 /// is required.
105 ///
106 class Expr : public Stmt {
107  QualType TR;
108 
109 protected:
111  bool TD, bool VD, bool ID, bool ContainsUnexpandedParameterPack)
112  : Stmt(SC)
113  {
114  ExprBits.TypeDependent = TD;
115  ExprBits.ValueDependent = VD;
116  ExprBits.InstantiationDependent = ID;
117  ExprBits.ValueKind = VK;
118  ExprBits.ObjectKind = OK;
119  assert(ExprBits.ObjectKind == OK && "truncated kind");
120  ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
121  setType(T);
122  }
123 
124  /// Construct an empty expression.
125  explicit Expr(StmtClass SC, EmptyShell) : Stmt(SC) { }
126 
127 public:
128  QualType getType() const { return TR; }
129  void setType(QualType t) {
130  // In C++, the type of an expression is always adjusted so that it
131  // will not have reference type (C++ [expr]p6). Use
132  // QualType::getNonReferenceType() to retrieve the non-reference
133  // type. Additionally, inspect Expr::isLvalue to determine whether
134  // an expression that is adjusted in this manner should be
135  // considered an lvalue.
136  assert((t.isNull() || !t->isReferenceType()) &&
137  "Expressions can't have reference type");
138 
139  TR = t;
140  }
141 
142  /// isValueDependent - Determines whether this expression is
143  /// value-dependent (C++ [temp.dep.constexpr]). For example, the
144  /// array bound of "Chars" in the following example is
145  /// value-dependent.
146  /// @code
147  /// template<int Size, char (&Chars)[Size]> struct meta_string;
148  /// @endcode
149  bool isValueDependent() const { return ExprBits.ValueDependent; }
150 
151  /// Set whether this expression is value-dependent or not.
152  void setValueDependent(bool VD) {
153  ExprBits.ValueDependent = VD;
154  }
155 
156  /// isTypeDependent - Determines whether this expression is
157  /// type-dependent (C++ [temp.dep.expr]), which means that its type
158  /// could change from one template instantiation to the next. For
159  /// example, the expressions "x" and "x + y" are type-dependent in
160  /// the following code, but "y" is not type-dependent:
161  /// @code
162  /// template<typename T>
163  /// void add(T x, int y) {
164  /// x + y;
165  /// }
166  /// @endcode
167  bool isTypeDependent() const { return ExprBits.TypeDependent; }
168 
169  /// Set whether this expression is type-dependent or not.
170  void setTypeDependent(bool TD) {
171  ExprBits.TypeDependent = TD;
172  }
173 
174  /// Whether this expression is instantiation-dependent, meaning that
175  /// it depends in some way on a template parameter, even if neither its type
176  /// nor (constant) value can change due to the template instantiation.
177  ///
178  /// In the following example, the expression \c sizeof(sizeof(T() + T())) is
179  /// instantiation-dependent (since it involves a template parameter \c T), but
180  /// is neither type- nor value-dependent, since the type of the inner
181  /// \c sizeof is known (\c std::size_t) and therefore the size of the outer
182  /// \c sizeof is known.
183  ///
184  /// \code
185  /// template<typename T>
186  /// void f(T x, T y) {
187  /// sizeof(sizeof(T() + T());
188  /// }
189  /// \endcode
190  ///
192  return ExprBits.InstantiationDependent;
193  }
194 
195  /// Set whether this expression is instantiation-dependent or not.
197  ExprBits.InstantiationDependent = ID;
198  }
199 
200  /// Whether this expression contains an unexpanded parameter
201  /// pack (for C++11 variadic templates).
202  ///
203  /// Given the following function template:
204  ///
205  /// \code
206  /// template<typename F, typename ...Types>
207  /// void forward(const F &f, Types &&...args) {
208  /// f(static_cast<Types&&>(args)...);
209  /// }
210  /// \endcode
211  ///
212  /// The expressions \c args and \c static_cast<Types&&>(args) both
213  /// contain parameter packs.
215  return ExprBits.ContainsUnexpandedParameterPack;
216  }
217 
218  /// Set the bit that describes whether this expression
219  /// contains an unexpanded parameter pack.
220  void setContainsUnexpandedParameterPack(bool PP = true) {
221  ExprBits.ContainsUnexpandedParameterPack = PP;
222  }
223 
224  /// getExprLoc - Return the preferred location for the arrow when diagnosing
225  /// a problem with a generic expression.
226  SourceLocation getExprLoc() const LLVM_READONLY;
227 
228  /// isUnusedResultAWarning - Return true if this immediate expression should
229  /// be warned about if the result is unused. If so, fill in expr, location,
230  /// and ranges with expr to warn on and source locations/ranges appropriate
231  /// for a warning.
232  bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,
233  SourceRange &R1, SourceRange &R2,
234  ASTContext &Ctx) const;
235 
236  /// isLValue - True if this expression is an "l-value" according to
237  /// the rules of the current language. C and C++ give somewhat
238  /// different rules for this concept, but in general, the result of
239  /// an l-value expression identifies a specific object whereas the
240  /// result of an r-value expression is a value detached from any
241  /// specific storage.
242  ///
243  /// C++11 divides the concept of "r-value" into pure r-values
244  /// ("pr-values") and so-called expiring values ("x-values"), which
245  /// identify specific objects that can be safely cannibalized for
246  /// their resources. This is an unfortunate abuse of terminology on
247  /// the part of the C++ committee. In Clang, when we say "r-value",
248  /// we generally mean a pr-value.
249  bool isLValue() const { return getValueKind() == VK_LValue; }
250  bool isRValue() const { return getValueKind() == VK_RValue; }
251  bool isXValue() const { return getValueKind() == VK_XValue; }
252  bool isGLValue() const { return getValueKind() != VK_RValue; }
253 
264  LV_ArrayTemporary
265  };
266  /// Reasons why an expression might not be an l-value.
267  LValueClassification ClassifyLValue(ASTContext &Ctx) const;
268 
275  MLV_LValueCast, // Specialized form of MLV_InvalidExpression.
286  MLV_ArrayTemporary
287  };
288  /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
289  /// does not have an incomplete type, does not have a const-qualified type,
290  /// and if it is a structure or union, does not have any member (including,
291  /// recursively, any member or element of all contained aggregates or unions)
292  /// with a const-qualified type.
293  ///
294  /// \param Loc [in,out] - A source location which *may* be filled
295  /// in with the location of the expression making this a
296  /// non-modifiable lvalue, if specified.
298  isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc = nullptr) const;
299 
300  /// The return type of classify(). Represents the C++11 expression
301  /// taxonomy.
303  public:
304  /// The various classification results. Most of these mean prvalue.
305  enum Kinds {
308  CL_Function, // Functions cannot be lvalues in C.
309  CL_Void, // Void cannot be an lvalue in C.
310  CL_AddressableVoid, // Void expression whose address can be taken in C.
311  CL_DuplicateVectorComponents, // A vector shuffle with dupes.
312  CL_MemberFunction, // An expression referring to a member function
314  CL_ClassTemporary, // A temporary of class type, or subobject thereof.
315  CL_ArrayTemporary, // A temporary of array type.
316  CL_ObjCMessageRValue, // ObjC message is an rvalue
317  CL_PRValue // A prvalue for any other reason, of any other type
318  };
319  /// The results of modification testing.
321  CM_Untested, // testModifiable was false.
323  CM_RValue, // Not modifiable because it's an rvalue
324  CM_Function, // Not modifiable because it's a function; C++ only
325  CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext
326  CM_NoSetterProperty,// Implicit assignment to ObjC property without setter
331  CM_IncompleteType
332  };
333 
334  private:
335  friend class Expr;
336 
337  unsigned short Kind;
338  unsigned short Modifiable;
339 
340  explicit Classification(Kinds k, ModifiableType m)
341  : Kind(k), Modifiable(m)
342  {}
343 
344  public:
346 
347  Kinds getKind() const { return static_cast<Kinds>(Kind); }
349  assert(Modifiable != CM_Untested && "Did not test for modifiability.");
350  return static_cast<ModifiableType>(Modifiable);
351  }
352  bool isLValue() const { return Kind == CL_LValue; }
353  bool isXValue() const { return Kind == CL_XValue; }
354  bool isGLValue() const { return Kind <= CL_XValue; }
355  bool isPRValue() const { return Kind >= CL_Function; }
356  bool isRValue() const { return Kind >= CL_XValue; }
357  bool isModifiable() const { return getModifiable() == CM_Modifiable; }
358 
359  /// Create a simple, modifiably lvalue
361  return Classification(CL_LValue, CM_Modifiable);
362  }
363 
364  };
365  /// Classify - Classify this expression according to the C++11
366  /// expression taxonomy.
367  ///
368  /// C++11 defines ([basic.lval]) a new taxonomy of expressions to replace the
369  /// old lvalue vs rvalue. This function determines the type of expression this
370  /// is. There are three expression types:
371  /// - lvalues are classical lvalues as in C++03.
372  /// - prvalues are equivalent to rvalues in C++03.
373  /// - xvalues are expressions yielding unnamed rvalue references, e.g. a
374  /// function returning an rvalue reference.
375  /// lvalues and xvalues are collectively referred to as glvalues, while
376  /// prvalues and xvalues together form rvalues.
378  return ClassifyImpl(Ctx, nullptr);
379  }
380 
381  /// ClassifyModifiable - Classify this expression according to the
382  /// C++11 expression taxonomy, and see if it is valid on the left side
383  /// of an assignment.
384  ///
385  /// This function extends classify in that it also tests whether the
386  /// expression is modifiable (C99 6.3.2.1p1).
387  /// \param Loc A source location that might be filled with a relevant location
388  /// if the expression is not modifiable.
390  return ClassifyImpl(Ctx, &Loc);
391  }
392 
393  /// getValueKindForType - Given a formal return or parameter type,
394  /// give its value kind.
396  if (const ReferenceType *RT = T->getAs<ReferenceType>())
397  return (isa<LValueReferenceType>(RT)
398  ? VK_LValue
399  : (RT->getPointeeType()->isFunctionType()
400  ? VK_LValue : VK_XValue));
401  return VK_RValue;
402  }
403 
404  /// getValueKind - The value kind that this expression produces.
406  return static_cast<ExprValueKind>(ExprBits.ValueKind);
407  }
408 
409  /// getObjectKind - The object kind that this expression produces.
410  /// Object kinds are meaningful only for expressions that yield an
411  /// l-value or x-value.
413  return static_cast<ExprObjectKind>(ExprBits.ObjectKind);
414  }
415 
417  ExprObjectKind OK = getObjectKind();
418  return (OK == OK_Ordinary || OK == OK_BitField);
419  }
420 
421  /// setValueKind - Set the value kind produced by this expression.
422  void setValueKind(ExprValueKind Cat) { ExprBits.ValueKind = Cat; }
423 
424  /// setObjectKind - Set the object kind produced by this expression.
425  void setObjectKind(ExprObjectKind Cat) { ExprBits.ObjectKind = Cat; }
426 
427 private:
428  Classification ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const;
429 
430 public:
431 
432  /// Returns true if this expression is a gl-value that
433  /// potentially refers to a bit-field.
434  ///
435  /// In C++, whether a gl-value refers to a bitfield is essentially
436  /// an aspect of the value-kind type system.
437  bool refersToBitField() const { return getObjectKind() == OK_BitField; }
438 
439  /// If this expression refers to a bit-field, retrieve the
440  /// declaration of that bit-field.
441  ///
442  /// Note that this returns a non-null pointer in subtly different
443  /// places than refersToBitField returns true. In particular, this can
444  /// return a non-null pointer even for r-values loaded from
445  /// bit-fields, but it will return null for a conditional bit-field.
446  FieldDecl *getSourceBitField();
447 
448  const FieldDecl *getSourceBitField() const {
449  return const_cast<Expr*>(this)->getSourceBitField();
450  }
451 
452  Decl *getReferencedDeclOfCallee();
454  return const_cast<Expr*>(this)->getReferencedDeclOfCallee();
455  }
456 
457  /// If this expression is an l-value for an Objective C
458  /// property, find the underlying property reference expression.
459  const ObjCPropertyRefExpr *getObjCProperty() const;
460 
461  /// Check if this expression is the ObjC 'self' implicit parameter.
462  bool isObjCSelfExpr() const;
463 
464  /// Returns whether this expression refers to a vector element.
465  bool refersToVectorElement() const;
466 
467  /// Returns whether this expression refers to a global register
468  /// variable.
469  bool refersToGlobalRegisterVar() const;
470 
471  /// Returns whether this expression has a placeholder type.
472  bool hasPlaceholderType() const {
473  return getType()->isPlaceholderType();
474  }
475 
476  /// Returns whether this expression has a specific placeholder type.
479  if (const BuiltinType *BT = dyn_cast<BuiltinType>(getType()))
480  return BT->getKind() == K;
481  return false;
482  }
483 
484  /// isKnownToHaveBooleanValue - Return true if this is an integer expression
485  /// that is known to return 0 or 1. This happens for _Bool/bool expressions
486  /// but also int expressions which are produced by things like comparisons in
487  /// C.
488  bool isKnownToHaveBooleanValue() const;
489 
490  /// isIntegerConstantExpr - Return true if this expression is a valid integer
491  /// constant expression, and, if so, return its value in Result. If not a
492  /// valid i-c-e, return false and fill in Loc (if specified) with the location
493  /// of the invalid expression.
494  ///
495  /// Note: This does not perform the implicit conversions required by C++11
496  /// [expr.const]p5.
497  bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx,
498  SourceLocation *Loc = nullptr,
499  bool isEvaluated = true) const;
500  bool isIntegerConstantExpr(const ASTContext &Ctx,
501  SourceLocation *Loc = nullptr) const;
502 
503  /// isCXX98IntegralConstantExpr - Return true if this expression is an
504  /// integral constant expression in C++98. Can only be used in C++.
505  bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const;
506 
507  /// isCXX11ConstantExpr - Return true if this expression is a constant
508  /// expression in C++11. Can only be used in C++.
509  ///
510  /// Note: This does not perform the implicit conversions required by C++11
511  /// [expr.const]p5.
512  bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr,
513  SourceLocation *Loc = nullptr) const;
514 
515  /// isPotentialConstantExpr - Return true if this function's definition
516  /// might be usable in a constant expression in C++11, if it were marked
517  /// constexpr. Return false if the function can never produce a constant
518  /// expression, along with diagnostics describing why not.
519  static bool isPotentialConstantExpr(const FunctionDecl *FD,
521  PartialDiagnosticAt> &Diags);
522 
523  /// isPotentialConstantExprUnevaluted - Return true if this expression might
524  /// be usable in a constant expression in C++11 in an unevaluated context, if
525  /// it were in function FD marked constexpr. Return false if the function can
526  /// never produce a constant expression, along with diagnostics describing
527  /// why not.
528  static bool isPotentialConstantExprUnevaluated(Expr *E,
529  const FunctionDecl *FD,
531  PartialDiagnosticAt> &Diags);
532 
533  /// isConstantInitializer - Returns true if this expression can be emitted to
534  /// IR as a constant, and thus can be used as a constant initializer in C.
535  /// If this expression is not constant and Culprit is non-null,
536  /// it is used to store the address of first non constant expr.
537  bool isConstantInitializer(ASTContext &Ctx, bool ForRef,
538  const Expr **Culprit = nullptr) const;
539 
540  /// EvalStatus is a struct with detailed info about an evaluation in progress.
541  struct EvalStatus {
542  /// Whether the evaluated expression has side effects.
543  /// For example, (f() && 0) can be folded, but it still has side effects.
545 
546  /// Whether the evaluation hit undefined behavior.
547  /// For example, 1.0 / 0.0 can be folded to Inf, but has undefined behavior.
548  /// Likewise, INT_MAX + 1 can be folded to INT_MIN, but has UB.
550 
551  /// Diag - If this is non-null, it will be filled in with a stack of notes
552  /// indicating why evaluation failed (or why it failed to produce a constant
553  /// expression).
554  /// If the expression is unfoldable, the notes will indicate why it's not
555  /// foldable. If the expression is foldable, but not a constant expression,
556  /// the notes will describes why it isn't a constant expression. If the
557  /// expression *is* a constant expression, no notes will be produced.
559 
561  : HasSideEffects(false), HasUndefinedBehavior(false), Diag(nullptr) {}
562 
563  // hasSideEffects - Return true if the evaluated expression has
564  // side effects.
565  bool hasSideEffects() const {
566  return HasSideEffects;
567  }
568  };
569 
570  /// EvalResult is a struct with detailed info about an evaluated expression.
572  /// Val - This is the value the expression can be folded to.
574 
575  // isGlobalLValue - Return true if the evaluated lvalue expression
576  // is global.
577  bool isGlobalLValue() const;
578  };
579 
580  /// EvaluateAsRValue - Return true if this is a constant which we can fold to
581  /// an rvalue using any crazy technique (that has nothing to do with language
582  /// standards) that we want to, even if the expression has side-effects. If
583  /// this function returns true, it returns the folded constant in Result. If
584  /// the expression is a glvalue, an lvalue-to-rvalue conversion will be
585  /// applied.
586  bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const;
587 
588  /// EvaluateAsBooleanCondition - Return true if this is a constant
589  /// which we can fold and convert to a boolean condition using
590  /// any crazy technique that we want to, even if the expression has
591  /// side-effects.
592  bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const;
593 
595  SE_NoSideEffects, ///< Strictly evaluate the expression.
596  SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not
597  ///< arbitrary unmodeled side effects.
598  SE_AllowSideEffects ///< Allow any unmodeled side effect.
599  };
600 
601  /// EvaluateAsInt - Return true if this is a constant which we can fold and
602  /// convert to an integer, using any crazy technique that we want to.
603  bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx,
604  SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;
605 
606  /// EvaluateAsFloat - Return true if this is a constant which we can fold and
607  /// convert to a floating point value, using any crazy technique that we
608  /// want to.
609  bool
610  EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,
611  SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;
612 
613  /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
614  /// constant folded without side-effects, but discard the result.
615  bool isEvaluatable(const ASTContext &Ctx,
616  SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;
617 
618  /// HasSideEffects - This routine returns true for all those expressions
619  /// which have any effect other than producing a value. Example is a function
620  /// call, volatile variable read, or throwing an exception. If
621  /// IncludePossibleEffects is false, this call treats certain expressions with
622  /// potential side effects (such as function call-like expressions,
623  /// instantiation-dependent expressions, or invocations from a macro) as not
624  /// having side effects.
625  bool HasSideEffects(const ASTContext &Ctx,
626  bool IncludePossibleEffects = true) const;
627 
628  /// Determine whether this expression involves a call to any function
629  /// that is not trivial.
630  bool hasNonTrivialCall(const ASTContext &Ctx) const;
631 
632  /// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded
633  /// integer. This must be called on an expression that constant folds to an
634  /// integer.
635  llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx,
636  SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;
637 
638  void EvaluateForOverflow(const ASTContext &Ctx) const;
639 
640  /// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an
641  /// lvalue with link time known address, with no side-effects.
642  bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const;
643 
644  /// EvaluateAsInitializer - Evaluate an expression as if it were the
645  /// initializer of the given declaration. Returns true if the initializer
646  /// can be folded to a constant, and produces any relevant notes. In C++11,
647  /// notes will be produced if the expression is not a constant expression.
648  bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx,
649  const VarDecl *VD,
651 
652  /// EvaluateWithSubstitution - Evaluate an expression as if from the context
653  /// of a call to the given function with the given arguments, inside an
654  /// unevaluated context. Returns true if the expression could be folded to a
655  /// constant.
656  bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
657  const FunctionDecl *Callee,
659  const Expr *This = nullptr) const;
660 
661  /// Indicates how the constant expression will be used.
662  enum ConstExprUsage { EvaluateForCodeGen, EvaluateForMangling };
663 
664  /// Evaluate an expression that is required to be a constant expression.
665  bool EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage,
666  const ASTContext &Ctx) const;
667 
668  /// If the current Expr is a pointer, this will try to statically
669  /// determine the number of bytes available where the pointer is pointing.
670  /// Returns true if all of the above holds and we were able to figure out the
671  /// size, false otherwise.
672  ///
673  /// \param Type - How to evaluate the size of the Expr, as defined by the
674  /// "type" parameter of __builtin_object_size
675  bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
676  unsigned Type) const;
677 
678  /// Enumeration used to describe the kind of Null pointer constant
679  /// returned from \c isNullPointerConstant().
681  /// Expression is not a Null pointer constant.
682  NPCK_NotNull = 0,
683 
684  /// Expression is a Null pointer constant built from a zero integer
685  /// expression that is not a simple, possibly parenthesized, zero literal.
686  /// C++ Core Issue 903 will classify these expressions as "not pointers"
687  /// once it is adopted.
688  /// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
690 
691  /// Expression is a Null pointer constant built from a literal zero.
693 
694  /// Expression is a C++11 nullptr.
696 
697  /// Expression is a GNU-style __null constant.
698  NPCK_GNUNull
699  };
700 
701  /// Enumeration used to describe how \c isNullPointerConstant()
702  /// should cope with value-dependent expressions.
704  /// Specifies that the expression should never be value-dependent.
705  NPC_NeverValueDependent = 0,
706 
707  /// Specifies that a value-dependent expression of integral or
708  /// dependent type should be considered a null pointer constant.
710 
711  /// Specifies that a value-dependent expression should be considered
712  /// to never be a null pointer constant.
713  NPC_ValueDependentIsNotNull
714  };
715 
716  /// isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to
717  /// a Null pointer constant. The return value can further distinguish the
718  /// kind of NULL pointer constant that was detected.
719  NullPointerConstantKind isNullPointerConstant(
720  ASTContext &Ctx,
722 
723  /// isOBJCGCCandidate - Return true if this expression may be used in a read/
724  /// write barrier.
725  bool isOBJCGCCandidate(ASTContext &Ctx) const;
726 
727  /// Returns true if this expression is a bound member function.
728  bool isBoundMemberFunction(ASTContext &Ctx) const;
729 
730  /// Given an expression of bound-member type, find the type
731  /// of the member. Returns null if this is an *overloaded* bound
732  /// member expression.
733  static QualType findBoundMemberType(const Expr *expr);
734 
735  /// IgnoreImpCasts - Skip past any implicit casts which might
736  /// surround this expression. Only skips ImplicitCastExprs.
737  Expr *IgnoreImpCasts() LLVM_READONLY;
738 
739  /// IgnoreImplicit - Skip past any implicit AST nodes which might
740  /// surround this expression.
741  Expr *IgnoreImplicit() LLVM_READONLY {
742  return cast<Expr>(Stmt::IgnoreImplicit());
743  }
744 
745  const Expr *IgnoreImplicit() const LLVM_READONLY {
746  return const_cast<Expr*>(this)->IgnoreImplicit();
747  }
748 
749  /// IgnoreParens - Ignore parentheses. If this Expr is a ParenExpr, return
750  /// its subexpression. If that subexpression is also a ParenExpr,
751  /// then this method recursively returns its subexpression, and so forth.
752  /// Otherwise, the method returns the current Expr.
753  Expr *IgnoreParens() LLVM_READONLY;
754 
755  /// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
756  /// or CastExprs, returning their operand.
757  Expr *IgnoreParenCasts() LLVM_READONLY;
758 
759  /// Ignore casts. Strip off any CastExprs, returning their operand.
760  Expr *IgnoreCasts() LLVM_READONLY;
761 
762  /// IgnoreParenImpCasts - Ignore parentheses and implicit casts. Strip off
763  /// any ParenExpr or ImplicitCastExprs, returning their operand.
764  Expr *IgnoreParenImpCasts() LLVM_READONLY;
765 
766  /// IgnoreConversionOperator - Ignore conversion operator. If this Expr is a
767  /// call to a conversion operator, return the argument.
768  Expr *IgnoreConversionOperator() LLVM_READONLY;
769 
770  const Expr *IgnoreConversionOperator() const LLVM_READONLY {
771  return const_cast<Expr*>(this)->IgnoreConversionOperator();
772  }
773 
774  const Expr *IgnoreParenImpCasts() const LLVM_READONLY {
775  return const_cast<Expr*>(this)->IgnoreParenImpCasts();
776  }
777 
778  /// Ignore parentheses and lvalue casts. Strip off any ParenExpr and
779  /// CastExprs that represent lvalue casts, returning their operand.
780  Expr *IgnoreParenLValueCasts() LLVM_READONLY;
781 
782  const Expr *IgnoreParenLValueCasts() const LLVM_READONLY {
783  return const_cast<Expr*>(this)->IgnoreParenLValueCasts();
784  }
785 
786  /// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
787  /// value (including ptr->int casts of the same size). Strip off any
788  /// ParenExpr or CastExprs, returning their operand.
789  Expr *IgnoreParenNoopCasts(ASTContext &Ctx) LLVM_READONLY;
790 
791  /// Ignore parentheses and derived-to-base casts.
792  Expr *ignoreParenBaseCasts() LLVM_READONLY;
793 
794  const Expr *ignoreParenBaseCasts() const LLVM_READONLY {
795  return const_cast<Expr*>(this)->ignoreParenBaseCasts();
796  }
797 
798  /// Determine whether this expression is a default function argument.
799  ///
800  /// Default arguments are implicitly generated in the abstract syntax tree
801  /// by semantic analysis for function calls, object constructions, etc. in
802  /// C++. Default arguments are represented by \c CXXDefaultArgExpr nodes;
803  /// this routine also looks through any implicit casts to determine whether
804  /// the expression is a default argument.
805  bool isDefaultArgument() const;
806 
807  /// Determine whether the result of this expression is a
808  /// temporary object of the given class type.
809  bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const;
810 
811  /// Whether this expression is an implicit reference to 'this' in C++.
812  bool isImplicitCXXThis() const;
813 
814  const Expr *IgnoreImpCasts() const LLVM_READONLY {
815  return const_cast<Expr*>(this)->IgnoreImpCasts();
816  }
817  const Expr *IgnoreParens() const LLVM_READONLY {
818  return const_cast<Expr*>(this)->IgnoreParens();
819  }
820  const Expr *IgnoreParenCasts() const LLVM_READONLY {
821  return const_cast<Expr*>(this)->IgnoreParenCasts();
822  }
823  /// Strip off casts, but keep parentheses.
824  const Expr *IgnoreCasts() const LLVM_READONLY {
825  return const_cast<Expr*>(this)->IgnoreCasts();
826  }
827 
828  const Expr *IgnoreParenNoopCasts(ASTContext &Ctx) const LLVM_READONLY {
829  return const_cast<Expr*>(this)->IgnoreParenNoopCasts(Ctx);
830  }
831 
832  static bool hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs);
833 
834  /// For an expression of class type or pointer to class type,
835  /// return the most derived class decl the expression is known to refer to.
836  ///
837  /// If this expression is a cast, this method looks through it to find the
838  /// most derived decl that can be inferred from the expression.
839  /// This is valid because derived-to-base conversions have undefined
840  /// behavior if the object isn't dynamically of the derived type.
841  const CXXRecordDecl *getBestDynamicClassType() const;
842 
843  /// Get the inner expression that determines the best dynamic class.
844  /// If this is a prvalue, we guarantee that it is of the most-derived type
845  /// for the object itself.
846  const Expr *getBestDynamicClassTypeExpr() const;
847 
848  /// Walk outwards from an expression we want to bind a reference to and
849  /// find the expression whose lifetime needs to be extended. Record
850  /// the LHSs of comma expressions and adjustments needed along the path.
851  const Expr *skipRValueSubobjectAdjustments(
853  SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
857  return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
858  }
859 
860  static bool classof(const Stmt *T) {
861  return T->getStmtClass() >= firstExprConstant &&
862  T->getStmtClass() <= lastExprConstant;
863  }
864 };
865 
866 //===----------------------------------------------------------------------===//
867 // Primary Expressions.
868 //===----------------------------------------------------------------------===//
869 
870 /// OpaqueValueExpr - An expression referring to an opaque object of a
871 /// fixed type and value class. These don't correspond to concrete
872 /// syntax; instead they're used to express operations (usually copy
873 /// operations) on values whose source is generally obvious from
874 /// context.
875 class OpaqueValueExpr : public Expr {
876  friend class ASTStmtReader;
877  Expr *SourceExpr;
878  SourceLocation Loc;
879 
880 public:
883  Expr *SourceExpr = nullptr)
884  : Expr(OpaqueValueExprClass, T, VK, OK,
885  T->isDependentType() ||
886  (SourceExpr && SourceExpr->isTypeDependent()),
887  T->isDependentType() ||
888  (SourceExpr && SourceExpr->isValueDependent()),
889  T->isInstantiationDependentType() ||
890  (SourceExpr && SourceExpr->isInstantiationDependent()),
891  false),
892  SourceExpr(SourceExpr), Loc(Loc) {
893  setIsUnique(false);
894  }
895 
896  /// Given an expression which invokes a copy constructor --- i.e. a
897  /// CXXConstructExpr, possibly wrapped in an ExprWithCleanups ---
898  /// find the OpaqueValueExpr that's the source of the construction.
899  static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);
900 
901  explicit OpaqueValueExpr(EmptyShell Empty)
902  : Expr(OpaqueValueExprClass, Empty) { }
903 
904  /// Retrieve the location of this expression.
905  SourceLocation getLocation() const { return Loc; }
906 
907  SourceLocation getLocStart() const LLVM_READONLY {
908  return SourceExpr ? SourceExpr->getLocStart() : Loc;
909  }
910  SourceLocation getLocEnd() const LLVM_READONLY {
911  return SourceExpr ? SourceExpr->getLocEnd() : Loc;
912  }
913  SourceLocation getExprLoc() const LLVM_READONLY {
914  if (SourceExpr) return SourceExpr->getExprLoc();
915  return Loc;
916  }
917 
920  }
921 
924  }
925 
926  /// The source expression of an opaque value expression is the
927  /// expression which originally generated the value. This is
928  /// provided as a convenience for analyses that don't wish to
929  /// precisely model the execution behavior of the program.
930  ///
931  /// The source expression is typically set when building the
932  /// expression which binds the opaque value expression in the first
933  /// place.
934  Expr *getSourceExpr() const { return SourceExpr; }
935 
936  void setIsUnique(bool V) {
937  assert((!V || SourceExpr) &&
938  "unique OVEs are expected to have source expressions");
939  OpaqueValueExprBits.IsUnique = V;
940  }
941 
942  bool isUnique() const { return OpaqueValueExprBits.IsUnique; }
943 
944  static bool classof(const Stmt *T) {
945  return T->getStmtClass() == OpaqueValueExprClass;
946  }
947 };
948 
949 /// A reference to a declared variable, function, enum, etc.
950 /// [C99 6.5.1p2]
951 ///
952 /// This encodes all the information about how a declaration is referenced
953 /// within an expression.
954 ///
955 /// There are several optional constructs attached to DeclRefExprs only when
956 /// they apply in order to conserve memory. These are laid out past the end of
957 /// the object, and flags in the DeclRefExprBitfield track whether they exist:
958 ///
959 /// DeclRefExprBits.HasQualifier:
960 /// Specifies when this declaration reference expression has a C++
961 /// nested-name-specifier.
962 /// DeclRefExprBits.HasFoundDecl:
963 /// Specifies when this declaration reference expression has a record of
964 /// a NamedDecl (different from the referenced ValueDecl) which was found
965 /// during name lookup and/or overload resolution.
966 /// DeclRefExprBits.HasTemplateKWAndArgsInfo:
967 /// Specifies when this declaration reference expression has an explicit
968 /// C++ template keyword and/or template argument list.
969 /// DeclRefExprBits.RefersToEnclosingVariableOrCapture
970 /// Specifies when this declaration reference expression (validly)
971 /// refers to an enclosed local or a captured variable.
972 class DeclRefExpr final
973  : public Expr,
974  private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc,
975  NamedDecl *, ASTTemplateKWAndArgsInfo,
976  TemplateArgumentLoc> {
977  /// The declaration that we are referencing.
978  ValueDecl *D;
979 
980  /// The location of the declaration name itself.
981  SourceLocation Loc;
982 
983  /// Provides source/type location info for the declaration name
984  /// embedded in D.
985  DeclarationNameLoc DNLoc;
986 
987  size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const {
988  return hasQualifier() ? 1 : 0;
989  }
990 
991  size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
992  return hasFoundDecl() ? 1 : 0;
993  }
994 
995  size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
996  return hasTemplateKWAndArgsInfo() ? 1 : 0;
997  }
998 
999  /// Test whether there is a distinct FoundDecl attached to the end of
1000  /// this DRE.
1001  bool hasFoundDecl() const { return DeclRefExprBits.HasFoundDecl; }
1002 
1003  DeclRefExpr(const ASTContext &Ctx,
1004  NestedNameSpecifierLoc QualifierLoc,
1005  SourceLocation TemplateKWLoc,
1006  ValueDecl *D, bool RefersToEnlosingVariableOrCapture,
1007  const DeclarationNameInfo &NameInfo,
1008  NamedDecl *FoundD,
1009  const TemplateArgumentListInfo *TemplateArgs,
1010  QualType T, ExprValueKind VK);
1011 
1012  /// Construct an empty declaration reference expression.
1013  explicit DeclRefExpr(EmptyShell Empty)
1014  : Expr(DeclRefExprClass, Empty) { }
1015 
1016  /// Computes the type- and value-dependence flags for this
1017  /// declaration reference expression.
1018  void computeDependence(const ASTContext &C);
1019 
1020 public:
1021  DeclRefExpr(ValueDecl *D, bool RefersToEnclosingVariableOrCapture, QualType T,
1023  const DeclarationNameLoc &LocInfo = DeclarationNameLoc())
1024  : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
1025  D(D), Loc(L), DNLoc(LocInfo) {
1026  DeclRefExprBits.HasQualifier = 0;
1027  DeclRefExprBits.HasTemplateKWAndArgsInfo = 0;
1028  DeclRefExprBits.HasFoundDecl = 0;
1029  DeclRefExprBits.HadMultipleCandidates = 0;
1030  DeclRefExprBits.RefersToEnclosingVariableOrCapture =
1031  RefersToEnclosingVariableOrCapture;
1032  computeDependence(D->getASTContext());
1033  }
1034 
1035  static DeclRefExpr *
1036  Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
1037  SourceLocation TemplateKWLoc, ValueDecl *D,
1038  bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc,
1039  QualType T, ExprValueKind VK, NamedDecl *FoundD = nullptr,
1040  const TemplateArgumentListInfo *TemplateArgs = nullptr);
1041 
1042  static DeclRefExpr *
1043  Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
1044  SourceLocation TemplateKWLoc, ValueDecl *D,
1045  bool RefersToEnclosingVariableOrCapture,
1046  const DeclarationNameInfo &NameInfo, QualType T, ExprValueKind VK,
1047  NamedDecl *FoundD = nullptr,
1048  const TemplateArgumentListInfo *TemplateArgs = nullptr);
1049 
1050  /// Construct an empty declaration reference expression.
1051  static DeclRefExpr *CreateEmpty(const ASTContext &Context,
1052  bool HasQualifier,
1053  bool HasFoundDecl,
1054  bool HasTemplateKWAndArgsInfo,
1055  unsigned NumTemplateArgs);
1056 
1057  ValueDecl *getDecl() { return D; }
1058  const ValueDecl *getDecl() const { return D; }
1059  void setDecl(ValueDecl *NewD) { D = NewD; }
1060 
1062  return DeclarationNameInfo(getDecl()->getDeclName(), Loc, DNLoc);
1063  }
1064 
1065  SourceLocation getLocation() const { return Loc; }
1066  void setLocation(SourceLocation L) { Loc = L; }
1067  SourceLocation getLocStart() const LLVM_READONLY;
1068  SourceLocation getLocEnd() const LLVM_READONLY;
1069 
1070  /// Determine whether this declaration reference was preceded by a
1071  /// C++ nested-name-specifier, e.g., \c N::foo.
1072  bool hasQualifier() const { return DeclRefExprBits.HasQualifier; }
1073 
1074  /// If the name was qualified, retrieves the nested-name-specifier
1075  /// that precedes the name, with source-location information.
1077  if (!hasQualifier())
1078  return NestedNameSpecifierLoc();
1079  return *getTrailingObjects<NestedNameSpecifierLoc>();
1080  }
1081 
1082  /// If the name was qualified, retrieves the nested-name-specifier
1083  /// that precedes the name. Otherwise, returns NULL.
1085  return getQualifierLoc().getNestedNameSpecifier();
1086  }
1087 
1088  /// Get the NamedDecl through which this reference occurred.
1089  ///
1090  /// This Decl may be different from the ValueDecl actually referred to in the
1091  /// presence of using declarations, etc. It always returns non-NULL, and may
1092  /// simple return the ValueDecl when appropriate.
1093 
1095  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
1096  }
1097 
1098  /// Get the NamedDecl through which this reference occurred.
1099  /// See non-const variant.
1100  const NamedDecl *getFoundDecl() const {
1101  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
1102  }
1103 
1105  return DeclRefExprBits.HasTemplateKWAndArgsInfo;
1106  }
1107 
1108  /// Retrieve the location of the template keyword preceding
1109  /// this name, if any.
1111  if (!hasTemplateKWAndArgsInfo()) return SourceLocation();
1112  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
1113  }
1114 
1115  /// Retrieve the location of the left angle bracket starting the
1116  /// explicit template argument list following the name, if any.
1118  if (!hasTemplateKWAndArgsInfo()) return SourceLocation();
1119  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
1120  }
1121 
1122  /// Retrieve the location of the right angle bracket ending the
1123  /// explicit template argument list following the name, if any.
1125  if (!hasTemplateKWAndArgsInfo()) return SourceLocation();
1126  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
1127  }
1128 
1129  /// Determines whether the name in this declaration reference
1130  /// was preceded by the template keyword.
1131  bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
1132 
1133  /// Determines whether this declaration reference was followed by an
1134  /// explicit template argument list.
1135  bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
1136 
1137  /// Copies the template arguments (if present) into the given
1138  /// structure.
1140  if (hasExplicitTemplateArgs())
1141  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
1142  getTrailingObjects<TemplateArgumentLoc>(), List);
1143  }
1144 
1145  /// Retrieve the template arguments provided as part of this
1146  /// template-id.
1148  if (!hasExplicitTemplateArgs())
1149  return nullptr;
1150 
1151  return getTrailingObjects<TemplateArgumentLoc>();
1152  }
1153 
1154  /// Retrieve the number of template arguments provided as part of this
1155  /// template-id.
1156  unsigned getNumTemplateArgs() const {
1157  if (!hasExplicitTemplateArgs())
1158  return 0;
1159 
1160  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
1161  }
1162 
1164  return {getTemplateArgs(), getNumTemplateArgs()};
1165  }
1166 
1167  /// Returns true if this expression refers to a function that
1168  /// was resolved from an overloaded set having size greater than 1.
1169  bool hadMultipleCandidates() const {
1170  return DeclRefExprBits.HadMultipleCandidates;
1171  }
1172  /// Sets the flag telling whether this expression refers to
1173  /// a function that was resolved from an overloaded set having size
1174  /// greater than 1.
1175  void setHadMultipleCandidates(bool V = true) {
1176  DeclRefExprBits.HadMultipleCandidates = V;
1177  }
1178 
1179  /// Does this DeclRefExpr refer to an enclosing local or a captured
1180  /// variable?
1182  return DeclRefExprBits.RefersToEnclosingVariableOrCapture;
1183  }
1184 
1185  static bool classof(const Stmt *T) {
1186  return T->getStmtClass() == DeclRefExprClass;
1187  }
1188 
1189  // Iterators
1192  }
1193 
1196  }
1197 
1199  friend class ASTStmtReader;
1200  friend class ASTStmtWriter;
1201 };
1202 
1203 /// [C99 6.4.2.2] - A predefined identifier such as __func__.
1204 class PredefinedExpr : public Expr {
1205 public:
1206  enum IdentType {
1209  LFunction, // Same as Function, but as wide string.
1213  /// The same as PrettyFunction, except that the
1214  /// 'virtual' keyword is omitted for virtual member functions.
1215  PrettyFunctionNoVirtual
1216  };
1217 
1218 private:
1219  SourceLocation Loc;
1220  IdentType Type;
1221  Stmt *FnName;
1222 
1223 public:
1225  StringLiteral *SL);
1226 
1227  /// Construct an empty predefined expression.
1228  explicit PredefinedExpr(EmptyShell Empty)
1229  : Expr(PredefinedExprClass, Empty), Loc(), Type(Func), FnName(nullptr) {}
1230 
1231  IdentType getIdentType() const { return Type; }
1232 
1233  SourceLocation getLocation() const { return Loc; }
1234  void setLocation(SourceLocation L) { Loc = L; }
1235 
1236  StringLiteral *getFunctionName();
1238  return const_cast<PredefinedExpr *>(this)->getFunctionName();
1239  }
1240 
1241  static StringRef getIdentTypeName(IdentType IT);
1242  static std::string ComputeName(IdentType IT, const Decl *CurrentDecl);
1243 
1244  SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
1245  SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
1246 
1247  static bool classof(const Stmt *T) {
1248  return T->getStmtClass() == PredefinedExprClass;
1249  }
1250 
1251  // Iterators
1252  child_range children() { return child_range(&FnName, &FnName + 1); }
1254  return const_child_range(&FnName, &FnName + 1);
1255  }
1256 
1257  friend class ASTStmtReader;
1258 };
1259 
1260 /// Used by IntegerLiteral/FloatingLiteral to store the numeric without
1261 /// leaking memory.
1262 ///
1263 /// For large floats/integers, APFloat/APInt will allocate memory from the heap
1264 /// to represent these numbers. Unfortunately, when we use a BumpPtrAllocator
1265 /// to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with
1266 /// the APFloat/APInt values will never get freed. APNumericStorage uses
1267 /// ASTContext's allocator for memory allocation.
1269  union {
1270  uint64_t VAL; ///< Used to store the <= 64 bits integer value.
1271  uint64_t *pVal; ///< Used to store the >64 bits integer value.
1272  };
1273  unsigned BitWidth;
1274 
1275  bool hasAllocation() const { return llvm::APInt::getNumWords(BitWidth) > 1; }
1276 
1277  APNumericStorage(const APNumericStorage &) = delete;
1278  void operator=(const APNumericStorage &) = delete;
1279 
1280 protected:
1281  APNumericStorage() : VAL(0), BitWidth(0) { }
1282 
1283  llvm::APInt getIntValue() const {
1284  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
1285  if (NumWords > 1)
1286  return llvm::APInt(BitWidth, NumWords, pVal);
1287  else
1288  return llvm::APInt(BitWidth, VAL);
1289  }
1290  void setIntValue(const ASTContext &C, const llvm::APInt &Val);
1291 };
1292 
1294 public:
1295  llvm::APInt getValue() const { return getIntValue(); }
1296  void setValue(const ASTContext &C, const llvm::APInt &Val) {
1297  setIntValue(C, Val);
1298  }
1299 };
1300 
1302 public:
1303  llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const {
1304  return llvm::APFloat(Semantics, getIntValue());
1305  }
1306  void setValue(const ASTContext &C, const llvm::APFloat &Val) {
1307  setIntValue(C, Val.bitcastToAPInt());
1308  }
1309 };
1310 
1311 class IntegerLiteral : public Expr, public APIntStorage {
1312  SourceLocation Loc;
1313 
1314  /// Construct an empty integer literal.
1315  explicit IntegerLiteral(EmptyShell Empty)
1316  : Expr(IntegerLiteralClass, Empty) { }
1317 
1318 public:
1319  // type should be IntTy, LongTy, LongLongTy, UnsignedIntTy, UnsignedLongTy,
1320  // or UnsignedLongLongTy
1321  IntegerLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
1322  SourceLocation l);
1323 
1324  /// Returns a new integer literal with value 'V' and type 'type'.
1325  /// \param type - either IntTy, LongTy, LongLongTy, UnsignedIntTy,
1326  /// UnsignedLongTy, or UnsignedLongLongTy which should match the size of V
1327  /// \param V - the value that the returned integer literal contains.
1328  static IntegerLiteral *Create(const ASTContext &C, const llvm::APInt &V,
1329  QualType type, SourceLocation l);
1330  /// Returns a new empty integer literal.
1331  static IntegerLiteral *Create(const ASTContext &C, EmptyShell Empty);
1332 
1333  SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
1334  SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
1335 
1336  /// Retrieve the location of the literal.
1337  SourceLocation getLocation() const { return Loc; }
1338 
1339  void setLocation(SourceLocation Location) { Loc = Location; }
1340 
1341  static bool classof(const Stmt *T) {
1342  return T->getStmtClass() == IntegerLiteralClass;
1343  }
1344 
1345  // Iterators
1348  }
1351  }
1352 };
1353 
1354 class FixedPointLiteral : public Expr, public APIntStorage {
1355  SourceLocation Loc;
1356  unsigned Scale;
1357 
1358  /// \brief Construct an empty integer literal.
1359  explicit FixedPointLiteral(EmptyShell Empty)
1360  : Expr(FixedPointLiteralClass, Empty) {}
1361 
1362  public:
1363  FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
1364  SourceLocation l, unsigned Scale);
1365 
1366  // Store the int as is without any bit shifting.
1367  static FixedPointLiteral *CreateFromRawInt(const ASTContext &C,
1368  const llvm::APInt &V,
1369  QualType type, SourceLocation l,
1370  unsigned Scale);
1371 
1372  SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
1373  SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
1374 
1375  /// \brief Retrieve the location of the literal.
1376  SourceLocation getLocation() const { return Loc; }
1377 
1378  void setLocation(SourceLocation Location) { Loc = Location; }
1379 
1380  static bool classof(const Stmt *T) {
1381  return T->getStmtClass() == FixedPointLiteralClass;
1382  }
1383 
1384  std::string getValueAsString(unsigned Radix) const;
1385 
1386  // Iterators
1389  }
1392  }
1393 };
1394 
1395 class CharacterLiteral : public Expr {
1396 public:
1402  UTF32
1403  };
1404 
1405 private:
1406  unsigned Value;
1407  SourceLocation Loc;
1408 public:
1409  // type should be IntTy
1411  SourceLocation l)
1412  : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
1413  false, false),
1414  Value(value), Loc(l) {
1415  CharacterLiteralBits.Kind = kind;
1416  }
1417 
1418  /// Construct an empty character literal.
1419  CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }
1420 
1421  SourceLocation getLocation() const { return Loc; }
1423  return static_cast<CharacterKind>(CharacterLiteralBits.Kind);
1424  }
1425 
1426  SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
1427  SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
1428 
1429  unsigned getValue() const { return Value; }
1430 
1431  void setLocation(SourceLocation Location) { Loc = Location; }
1432  void setKind(CharacterKind kind) { CharacterLiteralBits.Kind = kind; }
1433  void setValue(unsigned Val) { Value = Val; }
1434 
1435  static bool classof(const Stmt *T) {
1436  return T->getStmtClass() == CharacterLiteralClass;
1437  }
1438 
1439  // Iterators
1442  }
1445  }
1446 };
1447 
1448 class FloatingLiteral : public Expr, private APFloatStorage {
1449  SourceLocation Loc;
1450 
1451  FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
1453 
1454  /// Construct an empty floating-point literal.
1455  explicit FloatingLiteral(const ASTContext &C, EmptyShell Empty);
1456 
1457 public:
1458  static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V,
1459  bool isexact, QualType Type, SourceLocation L);
1460  static FloatingLiteral *Create(const ASTContext &C, EmptyShell Empty);
1461 
1462  llvm::APFloat getValue() const {
1463  return APFloatStorage::getValue(getSemantics());
1464  }
1465  void setValue(const ASTContext &C, const llvm::APFloat &Val) {
1466  assert(&getSemantics() == &Val.getSemantics() && "Inconsistent semantics");
1467  APFloatStorage::setValue(C, Val);
1468  }
1469 
1470  /// Get a raw enumeration value representing the floating-point semantics of
1471  /// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
1473  return static_cast<APFloatSemantics>(FloatingLiteralBits.Semantics);
1474  }
1475 
1476  /// Set the raw enumeration value representing the floating-point semantics of
1477  /// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
1479  FloatingLiteralBits.Semantics = Sem;
1480  }
1481 
1482  /// Return the APFloat semantics this literal uses.
1483  const llvm::fltSemantics &getSemantics() const;
1484 
1485  /// Set the APFloat semantics this literal uses.
1486  void setSemantics(const llvm::fltSemantics &Sem);
1487 
1488  bool isExact() const { return FloatingLiteralBits.IsExact; }
1489  void setExact(bool E) { FloatingLiteralBits.IsExact = E; }
1490 
1491  /// getValueAsApproximateDouble - This returns the value as an inaccurate
1492  /// double. Note that this may cause loss of precision, but is useful for
1493  /// debugging dumps, etc.
1494  double getValueAsApproximateDouble() const;
1495 
1496  SourceLocation getLocation() const { return Loc; }
1497  void setLocation(SourceLocation L) { Loc = L; }
1498 
1499  SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
1500  SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
1501 
1502  static bool classof(const Stmt *T) {
1503  return T->getStmtClass() == FloatingLiteralClass;
1504  }
1505 
1506  // Iterators
1509  }
1512  }
1513 };
1514 
1515 /// ImaginaryLiteral - We support imaginary integer and floating point literals,
1516 /// like "1.0i". We represent these as a wrapper around FloatingLiteral and
1517 /// IntegerLiteral classes. Instances of this class always have a Complex type
1518 /// whose element type matches the subexpression.
1519 ///
1520 class ImaginaryLiteral : public Expr {
1521  Stmt *Val;
1522 public:
1524  : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false,
1525  false, false),
1526  Val(val) {}
1527 
1528  /// Build an empty imaginary literal.
1530  : Expr(ImaginaryLiteralClass, Empty) { }
1531 
1532  const Expr *getSubExpr() const { return cast<Expr>(Val); }
1533  Expr *getSubExpr() { return cast<Expr>(Val); }
1534  void setSubExpr(Expr *E) { Val = E; }
1535 
1536  SourceLocation getLocStart() const LLVM_READONLY { return Val->getLocStart(); }
1537  SourceLocation getLocEnd() const LLVM_READONLY { return Val->getLocEnd(); }
1538 
1539  static bool classof(const Stmt *T) {
1540  return T->getStmtClass() == ImaginaryLiteralClass;
1541  }
1542 
1543  // Iterators
1544  child_range children() { return child_range(&Val, &Val+1); }
1546  return const_child_range(&Val, &Val + 1);
1547  }
1548 };
1549 
1550 /// StringLiteral - This represents a string literal expression, e.g. "foo"
1551 /// or L"bar" (wide strings). The actual string is returned by getBytes()
1552 /// is NOT null-terminated, and the length of the string is determined by
1553 /// calling getByteLength(). The C type for a string is always a
1554 /// ConstantArrayType. In C++, the char type is const qualified, in C it is
1555 /// not.
1556 ///
1557 /// Note that strings in C can be formed by concatenation of multiple string
1558 /// literal pptokens in translation phase #6. This keeps track of the locations
1559 /// of each of these pieces.
1560 ///
1561 /// Strings in C can also be truncated and extended by assigning into arrays,
1562 /// e.g. with constructs like:
1563 /// char X[2] = "foobar";
1564 /// In this case, getByteLength() will return 6, but the string literal will
1565 /// have type "char[2]".
1566 class StringLiteral : public Expr {
1567 public:
1568  enum StringKind {
1573  UTF32
1574  };
1575 
1576 private:
1577  friend class ASTStmtReader;
1578 
1579  union {
1580  const char *asChar;
1581  const uint16_t *asUInt16;
1582  const uint32_t *asUInt32;
1583  } StrData;
1584  unsigned Length;
1585  unsigned CharByteWidth : 4;
1586  unsigned Kind : 3;
1587  unsigned IsPascal : 1;
1588  unsigned NumConcatenated;
1589  SourceLocation TokLocs[1];
1590 
1591  StringLiteral(QualType Ty) :
1592  Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary, false, false, false,
1593  false) {}
1594 
1595  static int mapCharByteWidth(TargetInfo const &target,StringKind k);
1596 
1597 public:
1598  /// This is the "fully general" constructor that allows representation of
1599  /// strings formed from multiple concatenated tokens.
1600  static StringLiteral *Create(const ASTContext &C, StringRef Str,
1601  StringKind Kind, bool Pascal, QualType Ty,
1602  const SourceLocation *Loc, unsigned NumStrs);
1603 
1604  /// Simple constructor for string literals made from one token.
1605  static StringLiteral *Create(const ASTContext &C, StringRef Str,
1606  StringKind Kind, bool Pascal, QualType Ty,
1607  SourceLocation Loc) {
1608  return Create(C, Str, Kind, Pascal, Ty, &Loc, 1);
1609  }
1610 
1611  /// Construct an empty string literal.
1612  static StringLiteral *CreateEmpty(const ASTContext &C, unsigned NumStrs);
1613 
1614  StringRef getString() const {
1615  assert(CharByteWidth==1
1616  && "This function is used in places that assume strings use char");
1617  return StringRef(StrData.asChar, getByteLength());
1618  }
1619 
1620  /// Allow access to clients that need the byte representation, such as
1621  /// ASTWriterStmt::VisitStringLiteral().
1622  StringRef getBytes() const {
1623  // FIXME: StringRef may not be the right type to use as a result for this.
1624  if (CharByteWidth == 1)
1625  return StringRef(StrData.asChar, getByteLength());
1626  if (CharByteWidth == 4)
1627  return StringRef(reinterpret_cast<const char*>(StrData.asUInt32),
1628  getByteLength());
1629  assert(CharByteWidth == 2 && "unsupported CharByteWidth");
1630  return StringRef(reinterpret_cast<const char*>(StrData.asUInt16),
1631  getByteLength());
1632  }
1633 
1634  void outputString(raw_ostream &OS) const;
1635 
1636  uint32_t getCodeUnit(size_t i) const {
1637  assert(i < Length && "out of bounds access");
1638  if (CharByteWidth == 1)
1639  return static_cast<unsigned char>(StrData.asChar[i]);
1640  if (CharByteWidth == 4)
1641  return StrData.asUInt32[i];
1642  assert(CharByteWidth == 2 && "unsupported CharByteWidth");
1643  return StrData.asUInt16[i];
1644  }
1645 
1646  unsigned getByteLength() const { return CharByteWidth*Length; }
1647  unsigned getLength() const { return Length; }
1648  unsigned getCharByteWidth() const { return CharByteWidth; }
1649 
1650  /// Sets the string data to the given string data.
1651  void setString(const ASTContext &C, StringRef Str,
1652  StringKind Kind, bool IsPascal);
1653 
1654  StringKind getKind() const { return static_cast<StringKind>(Kind); }
1655 
1656 
1657  bool isAscii() const { return Kind == Ascii; }
1658  bool isWide() const { return Kind == Wide; }
1659  bool isUTF8() const { return Kind == UTF8; }
1660  bool isUTF16() const { return Kind == UTF16; }
1661  bool isUTF32() const { return Kind == UTF32; }
1662  bool isPascal() const { return IsPascal; }
1663 
1664  bool containsNonAscii() const {
1665  StringRef Str = getString();
1666  for (unsigned i = 0, e = Str.size(); i != e; ++i)
1667  if (!isASCII(Str[i]))
1668  return true;
1669  return false;
1670  }
1671 
1672  bool containsNonAsciiOrNull() const {
1673  StringRef Str = getString();
1674  for (unsigned i = 0, e = Str.size(); i != e; ++i)
1675  if (!isASCII(Str[i]) || !Str[i])
1676  return true;
1677  return false;
1678  }
1679 
1680  /// getNumConcatenated - Get the number of string literal tokens that were
1681  /// concatenated in translation phase #6 to form this string literal.
1682  unsigned getNumConcatenated() const { return NumConcatenated; }
1683 
1684  SourceLocation getStrTokenLoc(unsigned TokNum) const {
1685  assert(TokNum < NumConcatenated && "Invalid tok number");
1686  return TokLocs[TokNum];
1687  }
1688  void setStrTokenLoc(unsigned TokNum, SourceLocation L) {
1689  assert(TokNum < NumConcatenated && "Invalid tok number");
1690  TokLocs[TokNum] = L;
1691  }
1692 
1693  /// getLocationOfByte - Return a source location that points to the specified
1694  /// byte of this string literal.
1695  ///
1696  /// Strings are amazingly complex. They can be formed from multiple tokens
1697  /// and can have escape sequences in them in addition to the usual trigraph
1698  /// and escaped newline business. This routine handles this complexity.
1699  ///
1701  getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
1702  const LangOptions &Features, const TargetInfo &Target,
1703  unsigned *StartToken = nullptr,
1704  unsigned *StartTokenByteOffset = nullptr) const;
1705 
1707  tokloc_iterator tokloc_begin() const { return TokLocs; }
1708  tokloc_iterator tokloc_end() const { return TokLocs + NumConcatenated; }
1709 
1710  SourceLocation getLocStart() const LLVM_READONLY { return TokLocs[0]; }
1711  SourceLocation getLocEnd() const LLVM_READONLY {
1712  return TokLocs[NumConcatenated - 1];
1713  }
1714 
1715  static bool classof(const Stmt *T) {
1716  return T->getStmtClass() == StringLiteralClass;
1717  }
1718 
1719  // Iterators
1722  }
1725  }
1726 };
1727 
1728 /// ParenExpr - This represents a parethesized expression, e.g. "(1)". This
1729 /// AST node is only formed if full location information is requested.
1730 class ParenExpr : public Expr {
1731  SourceLocation L, R;
1732  Stmt *Val;
1733 public:
1735  : Expr(ParenExprClass, val->getType(),
1736  val->getValueKind(), val->getObjectKind(),
1737  val->isTypeDependent(), val->isValueDependent(),
1738  val->isInstantiationDependent(),
1739  val->containsUnexpandedParameterPack()),
1740  L(l), R(r), Val(val) {}
1741 
1742  /// Construct an empty parenthesized expression.
1743  explicit ParenExpr(EmptyShell Empty)
1744  : Expr(ParenExprClass, Empty) { }
1745 
1746  const Expr *getSubExpr() const { return cast<Expr>(Val); }
1747  Expr *getSubExpr() { return cast<Expr>(Val); }
1748  void setSubExpr(Expr *E) { Val = E; }
1749 
1750  SourceLocation getLocStart() const LLVM_READONLY { return L; }
1751  SourceLocation getLocEnd() const LLVM_READONLY { return R; }
1752 
1753  /// Get the location of the left parentheses '('.
1754  SourceLocation getLParen() const { return L; }
1755  void setLParen(SourceLocation Loc) { L = Loc; }
1756 
1757  /// Get the location of the right parentheses ')'.
1758  SourceLocation getRParen() const { return R; }
1759  void setRParen(SourceLocation Loc) { R = Loc; }
1760 
1761  static bool classof(const Stmt *T) {
1762  return T->getStmtClass() == ParenExprClass;
1763  }
1764 
1765  // Iterators
1766  child_range children() { return child_range(&Val, &Val+1); }
1768  return const_child_range(&Val, &Val + 1);
1769  }
1770 };
1771 
1772 /// UnaryOperator - This represents the unary-expression's (except sizeof and
1773 /// alignof), the postinc/postdec operators from postfix-expression, and various
1774 /// extensions.
1775 ///
1776 /// Notes on various nodes:
1777 ///
1778 /// Real/Imag - These return the real/imag part of a complex operand. If
1779 /// applied to a non-complex value, the former returns its operand and the
1780 /// later returns zero in the type of the operand.
1781 ///
1782 class UnaryOperator : public Expr {
1783 public:
1785 
1786 private:
1787  unsigned Opc : 5;
1788  unsigned CanOverflow : 1;
1789  SourceLocation Loc;
1790  Stmt *Val;
1791 public:
1792  UnaryOperator(Expr *input, Opcode opc, QualType type, ExprValueKind VK,
1793  ExprObjectKind OK, SourceLocation l, bool CanOverflow)
1794  : Expr(UnaryOperatorClass, type, VK, OK,
1795  input->isTypeDependent() || type->isDependentType(),
1796  input->isValueDependent(),
1797  (input->isInstantiationDependent() ||
1798  type->isInstantiationDependentType()),
1799  input->containsUnexpandedParameterPack()),
1800  Opc(opc), CanOverflow(CanOverflow), Loc(l), Val(input) {}
1801 
1802  /// Build an empty unary operator.
1803  explicit UnaryOperator(EmptyShell Empty)
1804  : Expr(UnaryOperatorClass, Empty), Opc(UO_AddrOf) { }
1805 
1806  Opcode getOpcode() const { return static_cast<Opcode>(Opc); }
1807  void setOpcode(Opcode O) { Opc = O; }
1808 
1809  Expr *getSubExpr() const { return cast<Expr>(Val); }
1810  void setSubExpr(Expr *E) { Val = E; }
1811 
1812  /// getOperatorLoc - Return the location of the operator.
1813  SourceLocation getOperatorLoc() const { return Loc; }
1814  void setOperatorLoc(SourceLocation L) { Loc = L; }
1815 
1816  /// Returns true if the unary operator can cause an overflow. For instance,
1817  /// signed int i = INT_MAX; i++;
1818  /// signed char c = CHAR_MAX; c++;
1819  /// Due to integer promotions, c++ is promoted to an int before the postfix
1820  /// increment, and the result is an int that cannot overflow. However, i++
1821  /// can overflow.
1822  bool canOverflow() const { return CanOverflow; }
1823  void setCanOverflow(bool C) { CanOverflow = C; }
1824 
1825  /// isPostfix - Return true if this is a postfix operation, like x++.
1826  static bool isPostfix(Opcode Op) {
1827  return Op == UO_PostInc || Op == UO_PostDec;
1828  }
1829 
1830  /// isPrefix - Return true if this is a prefix operation, like --x.
1831  static bool isPrefix(Opcode Op) {
1832  return Op == UO_PreInc || Op == UO_PreDec;
1833  }
1834 
1835  bool isPrefix() const { return isPrefix(getOpcode()); }
1836  bool isPostfix() const { return isPostfix(getOpcode()); }
1837 
1838  static bool isIncrementOp(Opcode Op) {
1839  return Op == UO_PreInc || Op == UO_PostInc;
1840  }
1841  bool isIncrementOp() const {
1842  return isIncrementOp(getOpcode());
1843  }
1844 
1845  static bool isDecrementOp(Opcode Op) {
1846  return Op == UO_PreDec || Op == UO_PostDec;
1847  }
1848  bool isDecrementOp() const {
1849  return isDecrementOp(getOpcode());
1850  }
1851 
1852  static bool isIncrementDecrementOp(Opcode Op) { return Op <= UO_PreDec; }
1853  bool isIncrementDecrementOp() const {
1854  return isIncrementDecrementOp(getOpcode());
1855  }
1856 
1857  static bool isArithmeticOp(Opcode Op) {
1858  return Op >= UO_Plus && Op <= UO_LNot;
1859  }
1860  bool isArithmeticOp() const { return isArithmeticOp(getOpcode()); }
1861 
1862  /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
1863  /// corresponds to, e.g. "sizeof" or "[pre]++"
1864  static StringRef getOpcodeStr(Opcode Op);
1865 
1866  /// Retrieve the unary opcode that corresponds to the given
1867  /// overloaded operator.
1868  static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix);
1869 
1870  /// Retrieve the overloaded operator kind that corresponds to
1871  /// the given unary opcode.
1872  static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);
1873 
1874  SourceLocation getLocStart() const LLVM_READONLY {
1875  return isPostfix() ? Val->getLocStart() : Loc;
1876  }
1877  SourceLocation getLocEnd() const LLVM_READONLY {
1878  return isPostfix() ? Loc : Val->getLocEnd();
1879  }
1880  SourceLocation getExprLoc() const LLVM_READONLY { return Loc; }
1881 
1882  static bool classof(const Stmt *T) {
1883  return T->getStmtClass() == UnaryOperatorClass;
1884  }
1885 
1886  // Iterators
1887  child_range children() { return child_range(&Val, &Val+1); }
1889  return const_child_range(&Val, &Val + 1);
1890  }
1891 };
1892 
1893 /// Helper class for OffsetOfExpr.
1894 
1895 // __builtin_offsetof(type, identifier(.identifier|[expr])*)
1897 public:
1898  /// The kind of offsetof node we have.
1899  enum Kind {
1900  /// An index into an array.
1901  Array = 0x00,
1902  /// A field.
1903  Field = 0x01,
1904  /// A field in a dependent type, known only by its name.
1905  Identifier = 0x02,
1906  /// An implicit indirection through a C++ base class, when the
1907  /// field found is in a base class.
1908  Base = 0x03
1909  };
1910 
1911 private:
1912  enum { MaskBits = 2, Mask = 0x03 };
1913 
1914  /// The source range that covers this part of the designator.
1915  SourceRange Range;
1916 
1917  /// The data describing the designator, which comes in three
1918  /// different forms, depending on the lower two bits.
1919  /// - An unsigned index into the array of Expr*'s stored after this node
1920  /// in memory, for [constant-expression] designators.
1921  /// - A FieldDecl*, for references to a known field.
1922  /// - An IdentifierInfo*, for references to a field with a given name
1923  /// when the class type is dependent.
1924  /// - A CXXBaseSpecifier*, for references that look at a field in a
1925  /// base class.
1926  uintptr_t Data;
1927 
1928 public:
1929  /// Create an offsetof node that refers to an array element.
1930  OffsetOfNode(SourceLocation LBracketLoc, unsigned Index,
1931  SourceLocation RBracketLoc)
1932  : Range(LBracketLoc, RBracketLoc), Data((Index << 2) | Array) {}
1933 
1934  /// Create an offsetof node that refers to a field.
1936  : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
1937  Data(reinterpret_cast<uintptr_t>(Field) | OffsetOfNode::Field) {}
1938 
1939  /// Create an offsetof node that refers to an identifier.
1941  SourceLocation NameLoc)
1942  : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
1943  Data(reinterpret_cast<uintptr_t>(Name) | Identifier) {}
1944 
1945  /// Create an offsetof node that refers into a C++ base class.
1947  : Range(), Data(reinterpret_cast<uintptr_t>(Base) | OffsetOfNode::Base) {}
1948 
1949  /// Determine what kind of offsetof node this is.
1950  Kind getKind() const { return static_cast<Kind>(Data & Mask); }
1951 
1952  /// For an array element node, returns the index into the array
1953  /// of expressions.
1954  unsigned getArrayExprIndex() const {
1955  assert(getKind() == Array);
1956  return Data >> 2;
1957  }
1958 
1959  /// For a field offsetof node, returns the field.
1960  FieldDecl *getField() const {
1961  assert(getKind() == Field);
1962  return reinterpret_cast<FieldDecl *>(Data & ~(uintptr_t)Mask);
1963  }
1964 
1965  /// For a field or identifier offsetof node, returns the name of
1966  /// the field.
1967  IdentifierInfo *getFieldName() const;
1968 
1969  /// For a base class node, returns the base specifier.
1971  assert(getKind() == Base);
1972  return reinterpret_cast<CXXBaseSpecifier *>(Data & ~(uintptr_t)Mask);
1973  }
1974 
1975  /// Retrieve the source range that covers this offsetof node.
1976  ///
1977  /// For an array element node, the source range contains the locations of
1978  /// the square brackets. For a field or identifier node, the source range
1979  /// contains the location of the period (if there is one) and the
1980  /// identifier.
1981  SourceRange getSourceRange() const LLVM_READONLY { return Range; }
1982  SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
1983  SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
1984 };
1985 
1986 /// OffsetOfExpr - [C99 7.17] - This represents an expression of the form
1987 /// offsetof(record-type, member-designator). For example, given:
1988 /// @code
1989 /// struct S {
1990 /// float f;
1991 /// double d;
1992 /// };
1993 /// struct T {
1994 /// int i;
1995 /// struct S s[10];
1996 /// };
1997 /// @endcode
1998 /// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).
1999 
2000 class OffsetOfExpr final
2001  : public Expr,
2002  private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
2003  SourceLocation OperatorLoc, RParenLoc;
2004  // Base type;
2005  TypeSourceInfo *TSInfo;
2006  // Number of sub-components (i.e. instances of OffsetOfNode).
2007  unsigned NumComps;
2008  // Number of sub-expressions (i.e. array subscript expressions).
2009  unsigned NumExprs;
2010 
2011  size_t numTrailingObjects(OverloadToken<OffsetOfNode>) const {
2012  return NumComps;
2013  }
2014 
2016  SourceLocation OperatorLoc, TypeSourceInfo *tsi,
2018  SourceLocation RParenLoc);
2019 
2020  explicit OffsetOfExpr(unsigned numComps, unsigned numExprs)
2021  : Expr(OffsetOfExprClass, EmptyShell()),
2022  TSInfo(nullptr), NumComps(numComps), NumExprs(numExprs) {}
2023 
2024 public:
2025 
2026  static OffsetOfExpr *Create(const ASTContext &C, QualType type,
2027  SourceLocation OperatorLoc, TypeSourceInfo *tsi,
2028  ArrayRef<OffsetOfNode> comps,
2029  ArrayRef<Expr*> exprs, SourceLocation RParenLoc);
2030 
2031  static OffsetOfExpr *CreateEmpty(const ASTContext &C,
2032  unsigned NumComps, unsigned NumExprs);
2033 
2034  /// getOperatorLoc - Return the location of the operator.
2035  SourceLocation getOperatorLoc() const { return OperatorLoc; }
2036  void setOperatorLoc(SourceLocation L) { OperatorLoc = L; }
2037 
2038  /// Return the location of the right parentheses.
2039  SourceLocation getRParenLoc() const { return RParenLoc; }
2040  void setRParenLoc(SourceLocation R) { RParenLoc = R; }
2041 
2043  return TSInfo;
2044  }
2046  TSInfo = tsi;
2047  }
2048 
2049  const OffsetOfNode &getComponent(unsigned Idx) const {
2050  assert(Idx < NumComps && "Subscript out of range");
2051  return getTrailingObjects<OffsetOfNode>()[Idx];
2052  }
2053 
2054  void setComponent(unsigned Idx, OffsetOfNode ON) {
2055  assert(Idx < NumComps && "Subscript out of range");
2056  getTrailingObjects<OffsetOfNode>()[Idx] = ON;
2057  }
2058 
2059  unsigned getNumComponents() const {
2060  return NumComps;
2061  }
2062 
2063  Expr* getIndexExpr(unsigned Idx) {
2064  assert(Idx < NumExprs && "Subscript out of range");
2065  return getTrailingObjects<Expr *>()[Idx];
2066  }
2067 
2068  const Expr *getIndexExpr(unsigned Idx) const {
2069  assert(Idx < NumExprs && "Subscript out of range");
2070  return getTrailingObjects<Expr *>()[Idx];
2071  }
2072 
2073  void setIndexExpr(unsigned Idx, Expr* E) {
2074  assert(Idx < NumComps && "Subscript out of range");
2075  getTrailingObjects<Expr *>()[Idx] = E;
2076  }
2077 
2078  unsigned getNumExpressions() const {
2079  return NumExprs;
2080  }
2081 
2082  SourceLocation getLocStart() const LLVM_READONLY { return OperatorLoc; }
2083  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
2084 
2085  static bool classof(const Stmt *T) {
2086  return T->getStmtClass() == OffsetOfExprClass;
2087  }
2088 
2089  // Iterators
2091  Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
2092  return child_range(begin, begin + NumExprs);
2093  }
2095  Stmt *const *begin =
2096  reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
2097  return const_child_range(begin, begin + NumExprs);
2098  }
2100 };
2101 
2102 /// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)
2103 /// expression operand. Used for sizeof/alignof (C99 6.5.3.4) and
2104 /// vec_step (OpenCL 1.1 6.11.12).
2106  union {
2109  } Argument;
2110  SourceLocation OpLoc, RParenLoc;
2111 
2112 public:
2114  QualType resultType, SourceLocation op,
2115  SourceLocation rp) :
2116  Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary,
2117  false, // Never type-dependent (C++ [temp.dep.expr]p3).
2118  // Value-dependent if the argument is type-dependent.
2119  TInfo->getType()->isDependentType(),
2120  TInfo->getType()->isInstantiationDependentType(),
2121  TInfo->getType()->containsUnexpandedParameterPack()),
2122  OpLoc(op), RParenLoc(rp) {
2123  UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
2124  UnaryExprOrTypeTraitExprBits.IsType = true;
2125  Argument.Ty = TInfo;
2126  }
2127 
2129  QualType resultType, SourceLocation op,
2130  SourceLocation rp);
2131 
2132  /// Construct an empty sizeof/alignof expression.
2134  : Expr(UnaryExprOrTypeTraitExprClass, Empty) { }
2135 
2137  return static_cast<UnaryExprOrTypeTrait>(UnaryExprOrTypeTraitExprBits.Kind);
2138  }
2139  void setKind(UnaryExprOrTypeTrait K) { UnaryExprOrTypeTraitExprBits.Kind = K;}
2140 
2141  bool isArgumentType() const { return UnaryExprOrTypeTraitExprBits.IsType; }
2143  return getArgumentTypeInfo()->getType();
2144  }
2146  assert(isArgumentType() && "calling getArgumentType() when arg is expr");
2147  return Argument.Ty;
2148  }
2150  assert(!isArgumentType() && "calling getArgumentExpr() when arg is type");
2151  return static_cast<Expr*>(Argument.Ex);
2152  }
2153  const Expr *getArgumentExpr() const {
2154  return const_cast<UnaryExprOrTypeTraitExpr*>(this)->getArgumentExpr();
2155  }
2156 
2157  void setArgument(Expr *E) {
2158  Argument.Ex = E;
2159  UnaryExprOrTypeTraitExprBits.IsType = false;
2160  }
2162  Argument.Ty = TInfo;
2163  UnaryExprOrTypeTraitExprBits.IsType = true;
2164  }
2165 
2166  /// Gets the argument type, or the type of the argument expression, whichever
2167  /// is appropriate.
2169  return isArgumentType() ? getArgumentType() : getArgumentExpr()->getType();
2170  }
2171 
2172  SourceLocation getOperatorLoc() const { return OpLoc; }
2173  void setOperatorLoc(SourceLocation L) { OpLoc = L; }
2174 
2175  SourceLocation getRParenLoc() const { return RParenLoc; }
2176  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
2177 
2178  SourceLocation getLocStart() const LLVM_READONLY { return OpLoc; }
2179  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
2180 
2181  static bool classof(const Stmt *T) {
2182  return T->getStmtClass() == UnaryExprOrTypeTraitExprClass;
2183  }
2184 
2185  // Iterators
2187  const_child_range children() const;
2188 };
2189 
2190 //===----------------------------------------------------------------------===//
2191 // Postfix Operators.
2192 //===----------------------------------------------------------------------===//
2193 
2194 /// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
2195 class ArraySubscriptExpr : public Expr {
2196  enum { LHS, RHS, END_EXPR=2 };
2197  Stmt* SubExprs[END_EXPR];
2198  SourceLocation RBracketLoc;
2199 public:
2202  SourceLocation rbracketloc)
2203  : Expr(ArraySubscriptExprClass, t, VK, OK,
2204  lhs->isTypeDependent() || rhs->isTypeDependent(),
2205  lhs->isValueDependent() || rhs->isValueDependent(),
2206  (lhs->isInstantiationDependent() ||
2207  rhs->isInstantiationDependent()),
2208  (lhs->containsUnexpandedParameterPack() ||
2209  rhs->containsUnexpandedParameterPack())),
2210  RBracketLoc(rbracketloc) {
2211  SubExprs[LHS] = lhs;
2212  SubExprs[RHS] = rhs;
2213  }
2214 
2215  /// Create an empty array subscript expression.
2217  : Expr(ArraySubscriptExprClass, Shell) { }
2218 
2219  /// An array access can be written A[4] or 4[A] (both are equivalent).
2220  /// - getBase() and getIdx() always present the normalized view: A[4].
2221  /// In this case getBase() returns "A" and getIdx() returns "4".
2222  /// - getLHS() and getRHS() present the syntactic view. e.g. for
2223  /// 4[A] getLHS() returns "4".
2224  /// Note: Because vector element access is also written A[4] we must
2225  /// predicate the format conversion in getBase and getIdx only on the
2226  /// the type of the RHS, as it is possible for the LHS to be a vector of
2227  /// integer type
2228  Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
2229  const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
2230  void setLHS(Expr *E) { SubExprs[LHS] = E; }
2231 
2232  Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
2233  const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
2234  void setRHS(Expr *E) { SubExprs[RHS] = E; }
2235 
2237  return getRHS()->getType()->isIntegerType() ? getLHS() : getRHS();
2238  }
2239 
2240  const Expr *getBase() const {
2241  return getRHS()->getType()->isIntegerType() ? getLHS() : getRHS();
2242  }
2243 
2245  return getRHS()->getType()->isIntegerType() ? getRHS() : getLHS();
2246  }
2247 
2248  const Expr *getIdx() const {
2249  return getRHS()->getType()->isIntegerType() ? getRHS() : getLHS();
2250  }
2251 
2252  SourceLocation getLocStart() const LLVM_READONLY {
2253  return getLHS()->getLocStart();
2254  }
2255  SourceLocation getLocEnd() const LLVM_READONLY { return RBracketLoc; }
2256 
2257  SourceLocation getRBracketLoc() const { return RBracketLoc; }
2258  void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
2259 
2260  SourceLocation getExprLoc() const LLVM_READONLY {
2261  return getBase()->getExprLoc();
2262  }
2263 
2264  static bool classof(const Stmt *T) {
2265  return T->getStmtClass() == ArraySubscriptExprClass;
2266  }
2267 
2268  // Iterators
2270  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
2271  }
2273  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
2274  }
2275 };
2276 
2277 /// CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
2278 /// CallExpr itself represents a normal function call, e.g., "f(x, 2)",
2279 /// while its subclasses may represent alternative syntax that (semantically)
2280 /// results in a function call. For example, CXXOperatorCallExpr is
2281 /// a subclass for overloaded operator calls that use operator syntax, e.g.,
2282 /// "str1 + str2" to resolve to a function call.
2283 class CallExpr : public Expr {
2284  enum { FN=0, PREARGS_START=1 };
2285  Stmt **SubExprs;
2286  unsigned NumArgs;
2287  SourceLocation RParenLoc;
2288 
2289  void updateDependenciesFromArg(Expr *Arg);
2290 
2291 protected:
2292  // These versions of the constructor are for derived classes.
2293  CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
2294  ArrayRef<Expr *> preargs, ArrayRef<Expr *> args, QualType t,
2295  ExprValueKind VK, SourceLocation rparenloc);
2296  CallExpr(const ASTContext &C, StmtClass SC, Expr *fn, ArrayRef<Expr *> args,
2297  QualType t, ExprValueKind VK, SourceLocation rparenloc);
2298  CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
2299  EmptyShell Empty);
2300 
2301  Stmt *getPreArg(unsigned i) {
2302  assert(i < getNumPreArgs() && "Prearg access out of range!");
2303  return SubExprs[PREARGS_START+i];
2304  }
2305  const Stmt *getPreArg(unsigned i) const {
2306  assert(i < getNumPreArgs() && "Prearg access out of range!");
2307  return SubExprs[PREARGS_START+i];
2308  }
2309  void setPreArg(unsigned i, Stmt *PreArg) {
2310  assert(i < getNumPreArgs() && "Prearg access out of range!");
2311  SubExprs[PREARGS_START+i] = PreArg;
2312  }
2313 
2314  unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; }
2315 
2316 public:
2317  CallExpr(const ASTContext& C, Expr *fn, ArrayRef<Expr*> args, QualType t,
2318  ExprValueKind VK, SourceLocation rparenloc);
2319 
2320  /// Build an empty call expression.
2321  CallExpr(const ASTContext &C, StmtClass SC, EmptyShell Empty);
2322 
2323  const Expr *getCallee() const { return cast<Expr>(SubExprs[FN]); }
2324  Expr *getCallee() { return cast<Expr>(SubExprs[FN]); }
2325  void setCallee(Expr *F) { SubExprs[FN] = F; }
2326 
2327  Decl *getCalleeDecl();
2328  const Decl *getCalleeDecl() const {
2329  return const_cast<CallExpr*>(this)->getCalleeDecl();
2330  }
2331 
2332  /// If the callee is a FunctionDecl, return it. Otherwise return 0.
2333  FunctionDecl *getDirectCallee();
2335  return const_cast<CallExpr*>(this)->getDirectCallee();
2336  }
2337 
2338  /// getNumArgs - Return the number of actual arguments to this call.
2339  ///
2340  unsigned getNumArgs() const { return NumArgs; }
2341 
2342  /// Retrieve the call arguments.
2344  return reinterpret_cast<Expr **>(SubExprs+getNumPreArgs()+PREARGS_START);
2345  }
2346  const Expr *const *getArgs() const {
2347  return reinterpret_cast<Expr **>(SubExprs + getNumPreArgs() +
2348  PREARGS_START);
2349  }
2350 
2351  /// getArg - Return the specified argument.
2352  Expr *getArg(unsigned Arg) {
2353  assert(Arg < NumArgs && "Arg access out of range!");
2354  return cast_or_null<Expr>(SubExprs[Arg + getNumPreArgs() + PREARGS_START]);
2355  }
2356  const Expr *getArg(unsigned Arg) const {
2357  assert(Arg < NumArgs && "Arg access out of range!");
2358  return cast_or_null<Expr>(SubExprs[Arg + getNumPreArgs() + PREARGS_START]);
2359  }
2360 
2361  /// setArg - Set the specified argument.
2362  void setArg(unsigned Arg, Expr *ArgExpr) {
2363  assert(Arg < NumArgs && "Arg access out of range!");
2364  SubExprs[Arg+getNumPreArgs()+PREARGS_START] = ArgExpr;
2365  }
2366 
2367  /// setNumArgs - This changes the number of arguments present in this call.
2368  /// Any orphaned expressions are deleted by this, and any new operands are set
2369  /// to null.
2370  void setNumArgs(const ASTContext& C, unsigned NumArgs);
2371 
2374  typedef llvm::iterator_range<arg_iterator> arg_range;
2375  typedef llvm::iterator_range<const_arg_iterator> arg_const_range;
2376 
2377  arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
2378  arg_const_range arguments() const {
2379  return arg_const_range(arg_begin(), arg_end());
2380  }
2381 
2382  arg_iterator arg_begin() { return SubExprs+PREARGS_START+getNumPreArgs(); }
2383  arg_iterator arg_end() {
2384  return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs();
2385  }
2386  const_arg_iterator arg_begin() const {
2387  return SubExprs+PREARGS_START+getNumPreArgs();
2388  }
2389  const_arg_iterator arg_end() const {
2390  return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs();
2391  }
2392 
2393  /// This method provides fast access to all the subexpressions of
2394  /// a CallExpr without going through the slower virtual child_iterator
2395  /// interface. This provides efficient reverse iteration of the
2396  /// subexpressions. This is currently used for CFG construction.
2398  return llvm::makeArrayRef(SubExprs,
2399  getNumPreArgs() + PREARGS_START + getNumArgs());
2400  }
2401 
2402  /// getNumCommas - Return the number of commas that must have been present in
2403  /// this function call.
2404  unsigned getNumCommas() const { return NumArgs ? NumArgs - 1 : 0; }
2405 
2406  /// getBuiltinCallee - If this is a call to a builtin, return the builtin ID
2407  /// of the callee. If not, return 0.
2408  unsigned getBuiltinCallee() const;
2409 
2410  /// Returns \c true if this is a call to a builtin which does not
2411  /// evaluate side-effects within its arguments.
2412  bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const;
2413 
2414  /// getCallReturnType - Get the return type of the call expr. This is not
2415  /// always the type of the expr itself, if the return type is a reference
2416  /// type.
2417  QualType getCallReturnType(const ASTContext &Ctx) const;
2418 
2419  SourceLocation getRParenLoc() const { return RParenLoc; }
2420  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
2421 
2422  SourceLocation getLocStart() const LLVM_READONLY;
2423  SourceLocation getLocEnd() const LLVM_READONLY;
2424 
2425  /// Return true if this is a call to __assume() or __builtin_assume() with
2426  /// a non-value-dependent constant parameter evaluating as false.
2427  bool isBuiltinAssumeFalse(const ASTContext &Ctx) const;
2428 
2429  bool isCallToStdMove() const {
2430  const FunctionDecl* FD = getDirectCallee();
2431  return getNumArgs() == 1 && FD && FD->isInStdNamespace() &&
2432  FD->getIdentifier() && FD->getIdentifier()->isStr("move");
2433  }
2434 
2435  static bool classof(const Stmt *T) {
2436  return T->getStmtClass() >= firstCallExprConstant &&
2437  T->getStmtClass() <= lastCallExprConstant;
2438  }
2439 
2440  // Iterators
2442  return child_range(&SubExprs[0],
2443  &SubExprs[0]+NumArgs+getNumPreArgs()+PREARGS_START);
2444  }
2445 
2447  return const_child_range(&SubExprs[0], &SubExprs[0] + NumArgs +
2448  getNumPreArgs() + PREARGS_START);
2449  }
2450 };
2451 
2452 /// Extra data stored in some MemberExpr objects.
2454  /// The nested-name-specifier that qualifies the name, including
2455  /// source-location information.
2457 
2458  /// The DeclAccessPair through which the MemberDecl was found due to
2459  /// name qualifiers.
2461 };
2462 
2463 /// MemberExpr - [C99 6.5.2.3] Structure and Union Members. X->F and X.F.
2464 ///
2465 class MemberExpr final
2466  : public Expr,
2467  private llvm::TrailingObjects<MemberExpr, MemberExprNameQualifier,
2468  ASTTemplateKWAndArgsInfo,
2469  TemplateArgumentLoc> {
2470  /// Base - the expression for the base pointer or structure references. In
2471  /// X.F, this is "X".
2472  Stmt *Base;
2473 
2474  /// MemberDecl - This is the decl being referenced by the field/member name.
2475  /// In X.F, this is the decl referenced by F.
2476  ValueDecl *MemberDecl;
2477 
2478  /// MemberDNLoc - Provides source/type location info for the
2479  /// declaration name embedded in MemberDecl.
2480  DeclarationNameLoc MemberDNLoc;
2481 
2482  /// MemberLoc - This is the location of the member name.
2483  SourceLocation MemberLoc;
2484 
2485  /// This is the location of the -> or . in the expression.
2486  SourceLocation OperatorLoc;
2487 
2488  /// IsArrow - True if this is "X->F", false if this is "X.F".
2489  bool IsArrow : 1;
2490 
2491  /// True if this member expression used a nested-name-specifier to
2492  /// refer to the member, e.g., "x->Base::f", or found its member via a using
2493  /// declaration. When true, a MemberExprNameQualifier
2494  /// structure is allocated immediately after the MemberExpr.
2495  bool HasQualifierOrFoundDecl : 1;
2496 
2497  /// True if this member expression specified a template keyword
2498  /// and/or a template argument list explicitly, e.g., x->f<int>,
2499  /// x->template f, x->template f<int>.
2500  /// When true, an ASTTemplateKWAndArgsInfo structure and its
2501  /// TemplateArguments (if any) are present.
2502  bool HasTemplateKWAndArgsInfo : 1;
2503 
2504  /// True if this member expression refers to a method that
2505  /// was resolved from an overloaded set having size greater than 1.
2506  bool HadMultipleCandidates : 1;
2507 
2508  size_t numTrailingObjects(OverloadToken<MemberExprNameQualifier>) const {
2509  return HasQualifierOrFoundDecl ? 1 : 0;
2510  }
2511 
2512  size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
2513  return HasTemplateKWAndArgsInfo ? 1 : 0;
2514  }
2515 
2516 public:
2517  MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc,
2518  ValueDecl *memberdecl, const DeclarationNameInfo &NameInfo,
2520  : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(),
2521  base->isValueDependent(), base->isInstantiationDependent(),
2522  base->containsUnexpandedParameterPack()),
2523  Base(base), MemberDecl(memberdecl), MemberDNLoc(NameInfo.getInfo()),
2524  MemberLoc(NameInfo.getLoc()), OperatorLoc(operatorloc),
2525  IsArrow(isarrow), HasQualifierOrFoundDecl(false),
2526  HasTemplateKWAndArgsInfo(false), HadMultipleCandidates(false) {
2527  assert(memberdecl->getDeclName() == NameInfo.getName());
2528  }
2529 
2530  // NOTE: this constructor should be used only when it is known that
2531  // the member name can not provide additional syntactic info
2532  // (i.e., source locations for C++ operator names or type source info
2533  // for constructors, destructors and conversion operators).
2534  MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc,
2535  ValueDecl *memberdecl, SourceLocation l, QualType ty,
2537  : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(),
2538  base->isValueDependent(), base->isInstantiationDependent(),
2539  base->containsUnexpandedParameterPack()),
2540  Base(base), MemberDecl(memberdecl), MemberDNLoc(), MemberLoc(l),
2541  OperatorLoc(operatorloc), IsArrow(isarrow),
2542  HasQualifierOrFoundDecl(false), HasTemplateKWAndArgsInfo(false),
2543  HadMultipleCandidates(false) {}
2544 
2545  static MemberExpr *Create(const ASTContext &C, Expr *base, bool isarrow,
2546  SourceLocation OperatorLoc,
2547  NestedNameSpecifierLoc QualifierLoc,
2548  SourceLocation TemplateKWLoc, ValueDecl *memberdecl,
2549  DeclAccessPair founddecl,
2550  DeclarationNameInfo MemberNameInfo,
2551  const TemplateArgumentListInfo *targs, QualType ty,
2552  ExprValueKind VK, ExprObjectKind OK);
2553 
2554  void setBase(Expr *E) { Base = E; }
2555  Expr *getBase() const { return cast<Expr>(Base); }
2556 
2557  /// Retrieve the member declaration to which this expression refers.
2558  ///
2559  /// The returned declaration will be a FieldDecl or (in C++) a VarDecl (for
2560  /// static data members), a CXXMethodDecl, or an EnumConstantDecl.
2561  ValueDecl *getMemberDecl() const { return MemberDecl; }
2562  void setMemberDecl(ValueDecl *D) { MemberDecl = D; }
2563 
2564  /// Retrieves the declaration found by lookup.
2566  if (!HasQualifierOrFoundDecl)
2567  return DeclAccessPair::make(getMemberDecl(),
2568  getMemberDecl()->getAccess());
2569  return getTrailingObjects<MemberExprNameQualifier>()->FoundDecl;
2570  }
2571 
2572  /// Determines whether this member expression actually had
2573  /// a C++ nested-name-specifier prior to the name of the member, e.g.,
2574  /// x->Base::foo.
2575  bool hasQualifier() const { return getQualifier() != nullptr; }
2576 
2577  /// If the member name was qualified, retrieves the
2578  /// nested-name-specifier that precedes the member name, with source-location
2579  /// information.
2581  if (!HasQualifierOrFoundDecl)
2582  return NestedNameSpecifierLoc();
2583 
2584  return getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc;
2585  }
2586 
2587  /// If the member name was qualified, retrieves the
2588  /// nested-name-specifier that precedes the member name. Otherwise, returns
2589  /// NULL.
2591  return getQualifierLoc().getNestedNameSpecifier();
2592  }
2593 
2594  /// Retrieve the location of the template keyword preceding
2595  /// the member name, if any.
2597  if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2598  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
2599  }
2600 
2601  /// Retrieve the location of the left angle bracket starting the
2602  /// explicit template argument list following the member name, if any.
2604  if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2605  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
2606  }
2607 
2608  /// Retrieve the location of the right angle bracket ending the
2609  /// explicit template argument list following the member name, if any.
2611  if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2612  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
2613  }
2614 
2615  /// Determines whether the member name was preceded by the template keyword.
2616  bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
2617 
2618  /// Determines whether the member name was followed by an
2619  /// explicit template argument list.
2620  bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
2621 
2622  /// Copies the template arguments (if present) into the given
2623  /// structure.
2625  if (hasExplicitTemplateArgs())
2626  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
2627  getTrailingObjects<TemplateArgumentLoc>(), List);
2628  }
2629 
2630  /// Retrieve the template arguments provided as part of this
2631  /// template-id.
2633  if (!hasExplicitTemplateArgs())
2634  return nullptr;
2635 
2636  return getTrailingObjects<TemplateArgumentLoc>();
2637  }
2638 
2639  /// Retrieve the number of template arguments provided as part of this
2640  /// template-id.
2641  unsigned getNumTemplateArgs() const {
2642  if (!hasExplicitTemplateArgs())
2643  return 0;
2644 
2645  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
2646  }
2647 
2649  return {getTemplateArgs(), getNumTemplateArgs()};
2650  }
2651 
2652  /// Retrieve the member declaration name info.
2654  return DeclarationNameInfo(MemberDecl->getDeclName(),
2655  MemberLoc, MemberDNLoc);
2656  }
2657 
2658  SourceLocation getOperatorLoc() const LLVM_READONLY { return OperatorLoc; }
2659 
2660  bool isArrow() const { return IsArrow; }
2661  void setArrow(bool A) { IsArrow = A; }
2662 
2663  /// getMemberLoc - Return the location of the "member", in X->F, it is the
2664  /// location of 'F'.
2665  SourceLocation getMemberLoc() const { return MemberLoc; }
2666  void setMemberLoc(SourceLocation L) { MemberLoc = L; }
2667 
2668  SourceLocation getLocStart() const LLVM_READONLY;
2669  SourceLocation getLocEnd() const LLVM_READONLY;
2670 
2671  SourceLocation getExprLoc() const LLVM_READONLY { return MemberLoc; }
2672 
2673  /// Determine whether the base of this explicit is implicit.
2674  bool isImplicitAccess() const {
2675  return getBase() && getBase()->isImplicitCXXThis();
2676  }
2677 
2678  /// Returns true if this member expression refers to a method that
2679  /// was resolved from an overloaded set having size greater than 1.
2680  bool hadMultipleCandidates() const {
2681  return HadMultipleCandidates;
2682  }
2683  /// Sets the flag telling whether this expression refers to
2684  /// a method that was resolved from an overloaded set having size
2685  /// greater than 1.
2686  void setHadMultipleCandidates(bool V = true) {
2687  HadMultipleCandidates = V;
2688  }
2689 
2690  /// Returns true if virtual dispatch is performed.
2691  /// If the member access is fully qualified, (i.e. X::f()), virtual
2692  /// dispatching is not performed. In -fapple-kext mode qualified
2693  /// calls to virtual method will still go through the vtable.
2694  bool performsVirtualDispatch(const LangOptions &LO) const {
2695  return LO.AppleKext || !hasQualifier();
2696  }
2697 
2698  static bool classof(const Stmt *T) {
2699  return T->getStmtClass() == MemberExprClass;
2700  }
2701 
2702  // Iterators
2703  child_range children() { return child_range(&Base, &Base+1); }
2705  return const_child_range(&Base, &Base + 1);
2706  }
2707 
2709  friend class ASTReader;
2710  friend class ASTStmtWriter;
2711 };
2712 
2713 /// CompoundLiteralExpr - [C99 6.5.2.5]
2714 ///
2715 class CompoundLiteralExpr : public Expr {
2716  /// LParenLoc - If non-null, this is the location of the left paren in a
2717  /// compound literal like "(int){4}". This can be null if this is a
2718  /// synthesized compound expression.
2719  SourceLocation LParenLoc;
2720 
2721  /// The type as written. This can be an incomplete array type, in
2722  /// which case the actual expression type will be different.
2723  /// The int part of the pair stores whether this expr is file scope.
2724  llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope;
2725  Stmt *Init;
2726 public:
2728  QualType T, ExprValueKind VK, Expr *init, bool fileScope)
2729  : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary,
2730  tinfo->getType()->isDependentType(),
2731  init->isValueDependent(),
2732  (init->isInstantiationDependent() ||
2733  tinfo->getType()->isInstantiationDependentType()),
2734  init->containsUnexpandedParameterPack()),
2735  LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {}
2736 
2737  /// Construct an empty compound literal.
2739  : Expr(CompoundLiteralExprClass, Empty) { }
2740 
2741  const Expr *getInitializer() const { return cast<Expr>(Init); }
2742  Expr *getInitializer() { return cast<Expr>(Init); }
2743  void setInitializer(Expr *E) { Init = E; }
2744 
2745  bool isFileScope() const { return TInfoAndScope.getInt(); }
2746  void setFileScope(bool FS) { TInfoAndScope.setInt(FS); }
2747 
2748  SourceLocation getLParenLoc() const { return LParenLoc; }
2749  void setLParenLoc(SourceLocation L) { LParenLoc = L; }
2750 
2752  return TInfoAndScope.getPointer();
2753  }
2755  TInfoAndScope.setPointer(tinfo);
2756  }
2757 
2758  SourceLocation getLocStart() const LLVM_READONLY {
2759  // FIXME: Init should never be null.
2760  if (!Init)
2761  return SourceLocation();
2762  if (LParenLoc.isInvalid())
2763  return Init->getLocStart();
2764  return LParenLoc;
2765  }
2766  SourceLocation getLocEnd() const LLVM_READONLY {
2767  // FIXME: Init should never be null.
2768  if (!Init)
2769  return SourceLocation();
2770  return Init->getLocEnd();
2771  }
2772 
2773  static bool classof(const Stmt *T) {
2774  return T->getStmtClass() == CompoundLiteralExprClass;
2775  }
2776 
2777  // Iterators
2778  child_range children() { return child_range(&Init, &Init+1); }
2780  return const_child_range(&Init, &Init + 1);
2781  }
2782 };
2783 
2784 /// CastExpr - Base class for type casts, including both implicit
2785 /// casts (ImplicitCastExpr) and explicit casts that have some
2786 /// representation in the source code (ExplicitCastExpr's derived
2787 /// classes).
2788 class CastExpr : public Expr {
2789 private:
2790  Stmt *Op;
2791 
2792  bool CastConsistency() const;
2793 
2794  const CXXBaseSpecifier * const *path_buffer() const {
2795  return const_cast<CastExpr*>(this)->path_buffer();
2796  }
2797  CXXBaseSpecifier **path_buffer();
2798 
2799  void setBasePathSize(unsigned basePathSize) {
2800  CastExprBits.BasePathSize = basePathSize;
2801  assert(CastExprBits.BasePathSize == basePathSize &&
2802  "basePathSize doesn't fit in bits of CastExprBits.BasePathSize!");
2803  }
2804 
2805 protected:
2807  Expr *op, unsigned BasePathSize)
2808  : Expr(SC, ty, VK, OK_Ordinary,
2809  // Cast expressions are type-dependent if the type is
2810  // dependent (C++ [temp.dep.expr]p3).
2811  ty->isDependentType(),
2812  // Cast expressions are value-dependent if the type is
2813  // dependent or if the subexpression is value-dependent.
2814  ty->isDependentType() || (op && op->isValueDependent()),
2815  (ty->isInstantiationDependentType() ||
2816  (op && op->isInstantiationDependent())),
2817  // An implicit cast expression doesn't (lexically) contain an
2818  // unexpanded pack, even if its target type does.
2819  ((SC != ImplicitCastExprClass &&
2820  ty->containsUnexpandedParameterPack()) ||
2821  (op && op->containsUnexpandedParameterPack()))),
2822  Op(op) {
2823  CastExprBits.Kind = kind;
2824  setBasePathSize(BasePathSize);
2825  assert(CastConsistency());
2826  }
2827 
2828  /// Construct an empty cast.
2829  CastExpr(StmtClass SC, EmptyShell Empty, unsigned BasePathSize)
2830  : Expr(SC, Empty) {
2831  setBasePathSize(BasePathSize);
2832  }
2833 
2834 public:
2835  CastKind getCastKind() const { return (CastKind) CastExprBits.Kind; }
2836  void setCastKind(CastKind K) { CastExprBits.Kind = K; }
2837 
2838  static const char *getCastKindName(CastKind CK);
2839  const char *getCastKindName() const { return getCastKindName(getCastKind()); }
2840 
2841  Expr *getSubExpr() { return cast<Expr>(Op); }
2842  const Expr *getSubExpr() const { return cast<Expr>(Op); }
2843  void setSubExpr(Expr *E) { Op = E; }
2844 
2845  /// Retrieve the cast subexpression as it was written in the source
2846  /// code, looking through any implicit casts or other intermediate nodes
2847  /// introduced by semantic analysis.
2848  Expr *getSubExprAsWritten();
2849  const Expr *getSubExprAsWritten() const {
2850  return const_cast<CastExpr *>(this)->getSubExprAsWritten();
2851  }
2852 
2853  /// If this cast applies a user-defined conversion, retrieve the conversion
2854  /// function that it invokes.
2855  NamedDecl *getConversionFunction() const;
2856 
2858  typedef const CXXBaseSpecifier * const *path_const_iterator;
2859  bool path_empty() const { return CastExprBits.BasePathSize == 0; }
2860  unsigned path_size() const { return CastExprBits.BasePathSize; }
2861  path_iterator path_begin() { return path_buffer(); }
2862  path_iterator path_end() { return path_buffer() + path_size(); }
2863  path_const_iterator path_begin() const { return path_buffer(); }
2864  path_const_iterator path_end() const { return path_buffer() + path_size(); }
2865 
2867  assert(getCastKind() == CK_ToUnion);
2868  return getTargetFieldForToUnionCast(getType(), getSubExpr()->getType());
2869  }
2870 
2871  static const FieldDecl *getTargetFieldForToUnionCast(QualType unionType,
2872  QualType opType);
2873  static const FieldDecl *getTargetFieldForToUnionCast(const RecordDecl *RD,
2874  QualType opType);
2875 
2876  static bool classof(const Stmt *T) {
2877  return T->getStmtClass() >= firstCastExprConstant &&
2878  T->getStmtClass() <= lastCastExprConstant;
2879  }
2880 
2881  // Iterators
2882  child_range children() { return child_range(&Op, &Op+1); }
2883  const_child_range children() const { return const_child_range(&Op, &Op + 1); }
2884 };
2885 
2886 /// ImplicitCastExpr - Allows us to explicitly represent implicit type
2887 /// conversions, which have no direct representation in the original
2888 /// source code. For example: converting T[]->T*, void f()->void
2889 /// (*f)(), float->double, short->int, etc.
2890 ///
2891 /// In C, implicit casts always produce rvalues. However, in C++, an
2892 /// implicit cast whose result is being bound to a reference will be
2893 /// an lvalue or xvalue. For example:
2894 ///
2895 /// @code
2896 /// class Base { };
2897 /// class Derived : public Base { };
2898 /// Derived &&ref();
2899 /// void f(Derived d) {
2900 /// Base& b = d; // initializer is an ImplicitCastExpr
2901 /// // to an lvalue of type Base
2902 /// Base&& r = ref(); // initializer is an ImplicitCastExpr
2903 /// // to an xvalue of type Base
2904 /// }
2905 /// @endcode
2906 class ImplicitCastExpr final
2907  : public CastExpr,
2908  private llvm::TrailingObjects<ImplicitCastExpr, CXXBaseSpecifier *> {
2909 private:
2911  unsigned BasePathLength, ExprValueKind VK)
2912  : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength) {
2913  }
2914 
2915  /// Construct an empty implicit cast.
2916  explicit ImplicitCastExpr(EmptyShell Shell, unsigned PathSize)
2917  : CastExpr(ImplicitCastExprClass, Shell, PathSize) { }
2918 
2919 public:
2920  enum OnStack_t { OnStack };
2922  ExprValueKind VK)
2923  : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, 0) {
2924  }
2925 
2926  static ImplicitCastExpr *Create(const ASTContext &Context, QualType T,
2927  CastKind Kind, Expr *Operand,
2928  const CXXCastPath *BasePath,
2929  ExprValueKind Cat);
2930 
2931  static ImplicitCastExpr *CreateEmpty(const ASTContext &Context,
2932  unsigned PathSize);
2933 
2934  SourceLocation getLocStart() const LLVM_READONLY {
2935  return getSubExpr()->getLocStart();
2936  }
2937  SourceLocation getLocEnd() const LLVM_READONLY {
2938  return getSubExpr()->getLocEnd();
2939  }
2940 
2941  static bool classof(const Stmt *T) {
2942  return T->getStmtClass() == ImplicitCastExprClass;
2943  }
2944 
2946  friend class CastExpr;
2947 };
2948 
2950  Expr *e = this;
2951  while (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
2952  e = ice->getSubExpr();
2953  return e;
2954 }
2955 
2956 /// ExplicitCastExpr - An explicit cast written in the source
2957 /// code.
2958 ///
2959 /// This class is effectively an abstract class, because it provides
2960 /// the basic representation of an explicitly-written cast without
2961 /// specifying which kind of cast (C cast, functional cast, static
2962 /// cast, etc.) was written; specific derived classes represent the
2963 /// particular style of cast and its location information.
2964 ///
2965 /// Unlike implicit casts, explicit cast nodes have two different
2966 /// types: the type that was written into the source code, and the
2967 /// actual type of the expression as determined by semantic
2968 /// analysis. These types may differ slightly. For example, in C++ one
2969 /// can cast to a reference type, which indicates that the resulting
2970 /// expression will be an lvalue or xvalue. The reference type, however,
2971 /// will not be used as the type of the expression.
2972 class ExplicitCastExpr : public CastExpr {
2973  /// TInfo - Source type info for the (written) type
2974  /// this expression is casting to.
2975  TypeSourceInfo *TInfo;
2976 
2977 protected:
2979  CastKind kind, Expr *op, unsigned PathSize,
2980  TypeSourceInfo *writtenTy)
2981  : CastExpr(SC, exprTy, VK, kind, op, PathSize), TInfo(writtenTy) {}
2982 
2983  /// Construct an empty explicit cast.
2984  ExplicitCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize)
2985  : CastExpr(SC, Shell, PathSize) { }
2986 
2987 public:
2988  /// getTypeInfoAsWritten - Returns the type source info for the type
2989  /// that this expression is casting to.
2990  TypeSourceInfo *getTypeInfoAsWritten() const { return TInfo; }
2991  void setTypeInfoAsWritten(TypeSourceInfo *writtenTy) { TInfo = writtenTy; }
2992 
2993  /// getTypeAsWritten - Returns the type that this expression is
2994  /// casting to, as written in the source code.
2995  QualType getTypeAsWritten() const { return TInfo->getType(); }
2996 
2997  static bool classof(const Stmt *T) {
2998  return T->getStmtClass() >= firstExplicitCastExprConstant &&
2999  T->getStmtClass() <= lastExplicitCastExprConstant;
3000  }
3001 };
3002 
3003 /// CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style
3004 /// cast in C++ (C++ [expr.cast]), which uses the syntax
3005 /// (Type)expr. For example: @c (int)f.
3006 class CStyleCastExpr final
3007  : public ExplicitCastExpr,
3008  private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *> {
3009  SourceLocation LPLoc; // the location of the left paren
3010  SourceLocation RPLoc; // the location of the right paren
3011 
3013  unsigned PathSize, TypeSourceInfo *writtenTy,
3015  : ExplicitCastExpr(CStyleCastExprClass, exprTy, vk, kind, op, PathSize,
3016  writtenTy), LPLoc(l), RPLoc(r) {}
3017 
3018  /// Construct an empty C-style explicit cast.
3019  explicit CStyleCastExpr(EmptyShell Shell, unsigned PathSize)
3020  : ExplicitCastExpr(CStyleCastExprClass, Shell, PathSize) { }
3021 
3022 public:
3023  static CStyleCastExpr *Create(const ASTContext &Context, QualType T,
3024  ExprValueKind VK, CastKind K,
3025  Expr *Op, const CXXCastPath *BasePath,
3026  TypeSourceInfo *WrittenTy, SourceLocation L,
3027  SourceLocation R);
3028 
3029  static CStyleCastExpr *CreateEmpty(const ASTContext &Context,
3030  unsigned PathSize);
3031 
3032  SourceLocation getLParenLoc() const { return LPLoc; }
3033  void setLParenLoc(SourceLocation L) { LPLoc = L; }
3034 
3035  SourceLocation getRParenLoc() const { return RPLoc; }
3036  void setRParenLoc(SourceLocation L) { RPLoc = L; }
3037 
3038  SourceLocation getLocStart() const LLVM_READONLY { return LPLoc; }
3039  SourceLocation getLocEnd() const LLVM_READONLY {
3040  return getSubExpr()->getLocEnd();
3041  }
3042 
3043  static bool classof(const Stmt *T) {
3044  return T->getStmtClass() == CStyleCastExprClass;
3045  }
3046 
3048  friend class CastExpr;
3049 };
3050 
3051 /// A builtin binary operation expression such as "x + y" or "x <= y".
3052 ///
3053 /// This expression node kind describes a builtin binary operation,
3054 /// such as "x + y" for integer values "x" and "y". The operands will
3055 /// already have been converted to appropriate types (e.g., by
3056 /// performing promotions or conversions).
3057 ///
3058 /// In C++, where operators may be overloaded, a different kind of
3059 /// expression node (CXXOperatorCallExpr) is used to express the
3060 /// invocation of an overloaded operator with operator syntax. Within
3061 /// a C++ template, whether BinaryOperator or CXXOperatorCallExpr is
3062 /// used to store an expression "x + y" depends on the subexpressions
3063 /// for x and y. If neither x or y is type-dependent, and the "+"
3064 /// operator resolves to a built-in operation, BinaryOperator will be
3065 /// used to express the computation (x and y may still be
3066 /// value-dependent). If either x or y is type-dependent, or if the
3067 /// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
3068 /// be used to express the computation.
3069 class BinaryOperator : public Expr {
3070 public:
3072 
3073 private:
3074  unsigned Opc : 6;
3075 
3076  // This is only meaningful for operations on floating point types and 0
3077  // otherwise.
3078  unsigned FPFeatures : 2;
3079  SourceLocation OpLoc;
3080 
3081  enum { LHS, RHS, END_EXPR };
3082  Stmt* SubExprs[END_EXPR];
3083 public:
3084 
3085  BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
3087  SourceLocation opLoc, FPOptions FPFeatures)
3088  : Expr(BinaryOperatorClass, ResTy, VK, OK,
3089  lhs->isTypeDependent() || rhs->isTypeDependent(),
3090  lhs->isValueDependent() || rhs->isValueDependent(),
3091  (lhs->isInstantiationDependent() ||
3092  rhs->isInstantiationDependent()),
3093  (lhs->containsUnexpandedParameterPack() ||
3094  rhs->containsUnexpandedParameterPack())),
3095  Opc(opc), FPFeatures(FPFeatures.getInt()), OpLoc(opLoc) {
3096  SubExprs[LHS] = lhs;
3097  SubExprs[RHS] = rhs;
3098  assert(!isCompoundAssignmentOp() &&
3099  "Use CompoundAssignOperator for compound assignments");
3100  }
3101 
3102  /// Construct an empty binary operator.
3103  explicit BinaryOperator(EmptyShell Empty)
3104  : Expr(BinaryOperatorClass, Empty), Opc(BO_Comma) { }
3105 
3106  SourceLocation getExprLoc() const LLVM_READONLY { return OpLoc; }
3107  SourceLocation getOperatorLoc() const { return OpLoc; }
3108  void setOperatorLoc(SourceLocation L) { OpLoc = L; }
3109 
3110  Opcode getOpcode() const { return static_cast<Opcode>(Opc); }
3111  void setOpcode(Opcode O) { Opc = O; }
3112 
3113  Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3114  void setLHS(Expr *E) { SubExprs[LHS] = E; }
3115  Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3116  void setRHS(Expr *E) { SubExprs[RHS] = E; }
3117 
3118  SourceLocation getLocStart() const LLVM_READONLY {
3119  return getLHS()->getLocStart();
3120  }
3121  SourceLocation getLocEnd() const LLVM_READONLY {
3122  return getRHS()->getLocEnd();
3123  }
3124 
3125  /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
3126  /// corresponds to, e.g. "<<=".
3127  static StringRef getOpcodeStr(Opcode Op);
3128 
3129  StringRef getOpcodeStr() const { return getOpcodeStr(getOpcode()); }
3130 
3131  /// Retrieve the binary opcode that corresponds to the given
3132  /// overloaded operator.
3133  static Opcode getOverloadedOpcode(OverloadedOperatorKind OO);
3134 
3135  /// Retrieve the overloaded operator kind that corresponds to
3136  /// the given binary opcode.
3137  static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);
3138 
3139  /// predicates to categorize the respective opcodes.
3140  bool isPtrMemOp() const { return Opc == BO_PtrMemD || Opc == BO_PtrMemI; }
3141  static bool isMultiplicativeOp(Opcode Opc) {
3142  return Opc >= BO_Mul && Opc <= BO_Rem;
3143  }
3145  static bool isAdditiveOp(Opcode Opc) { return Opc == BO_Add || Opc==BO_Sub; }
3146  bool isAdditiveOp() const { return isAdditiveOp(getOpcode()); }
3147  static bool isShiftOp(Opcode Opc) { return Opc == BO_Shl || Opc == BO_Shr; }
3148  bool isShiftOp() const { return isShiftOp(getOpcode()); }
3149 
3150  static bool isBitwiseOp(Opcode Opc) { return Opc >= BO_And && Opc <= BO_Or; }
3151  bool isBitwiseOp() const { return isBitwiseOp(getOpcode()); }
3152 
3153  static bool isRelationalOp(Opcode Opc) { return Opc >= BO_LT && Opc<=BO_GE; }
3154  bool isRelationalOp() const { return isRelationalOp(getOpcode()); }
3155 
3156  static bool isEqualityOp(Opcode Opc) { return Opc == BO_EQ || Opc == BO_NE; }
3157  bool isEqualityOp() const { return isEqualityOp(getOpcode()); }
3158 
3159  static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; }
3160  bool isComparisonOp() const { return isComparisonOp(getOpcode()); }
3161 
3162  static Opcode negateComparisonOp(Opcode Opc) {
3163  switch (Opc) {
3164  default:
3165  llvm_unreachable("Not a comparison operator.");
3166  case BO_LT: return BO_GE;
3167  case BO_GT: return BO_LE;
3168  case BO_LE: return BO_GT;
3169  case BO_GE: return BO_LT;
3170  case BO_EQ: return BO_NE;
3171  case BO_NE: return BO_EQ;
3172  }
3173  }
3174 
3175  static Opcode reverseComparisonOp(Opcode Opc) {
3176  switch (Opc) {
3177  default:
3178  llvm_unreachable("Not a comparison operator.");
3179  case BO_LT: return BO_GT;
3180  case BO_GT: return BO_LT;
3181  case BO_LE: return BO_GE;
3182  case BO_GE: return BO_LE;
3183  case BO_EQ:
3184  case BO_NE:
3185  return Opc;
3186  }
3187  }
3188 
3189  static bool isLogicalOp(Opcode Opc) { return Opc == BO_LAnd || Opc==BO_LOr; }
3190  bool isLogicalOp() const { return isLogicalOp(getOpcode()); }
3191 
3192  static bool isAssignmentOp(Opcode Opc) {
3193  return Opc >= BO_Assign && Opc <= BO_OrAssign;
3194  }
3195  bool isAssignmentOp() const { return isAssignmentOp(getOpcode()); }
3196 
3197  static bool isCompoundAssignmentOp(Opcode Opc) {
3198  return Opc > BO_Assign && Opc <= BO_OrAssign;
3199  }
3200  bool isCompoundAssignmentOp() const {
3201  return isCompoundAssignmentOp(getOpcode());
3202  }
3203  static Opcode getOpForCompoundAssignment(Opcode Opc) {
3204  assert(isCompoundAssignmentOp(Opc));
3205  if (Opc >= BO_AndAssign)
3206  return Opcode(unsigned(Opc) - BO_AndAssign + BO_And);
3207  else
3208  return Opcode(unsigned(Opc) - BO_MulAssign + BO_Mul);
3209  }
3210 
3211  static bool isShiftAssignOp(Opcode Opc) {
3212  return Opc == BO_ShlAssign || Opc == BO_ShrAssign;
3213  }
3214  bool isShiftAssignOp() const {
3215  return isShiftAssignOp(getOpcode());
3216  }
3217 
3218  // Return true if a binary operator using the specified opcode and operands
3219  // would match the 'p = (i8*)nullptr + n' idiom for casting a pointer-sized
3220  // integer to a pointer.
3221  static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc,
3222  Expr *LHS, Expr *RHS);
3223 
3224  static bool classof(const Stmt *S) {
3225  return S->getStmtClass() >= firstBinaryOperatorConstant &&
3226  S->getStmtClass() <= lastBinaryOperatorConstant;
3227  }
3228 
3229  // Iterators
3231  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
3232  }
3234  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
3235  }
3236 
3237  // Set the FP contractability status of this operator. Only meaningful for
3238  // operations on floating point types.
3239  void setFPFeatures(FPOptions F) { FPFeatures = F.getInt(); }
3240 
3241  FPOptions getFPFeatures() const { return FPOptions(FPFeatures); }
3242 
3243  // Get the FP contractability status of this operator. Only meaningful for
3244  // operations on floating point types.
3246  return FPOptions(FPFeatures).allowFPContractWithinStatement();
3247  }
3248 
3249 protected:
3250  BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
3252  SourceLocation opLoc, FPOptions FPFeatures, bool dead2)
3253  : Expr(CompoundAssignOperatorClass, ResTy, VK, OK,
3254  lhs->isTypeDependent() || rhs->isTypeDependent(),
3255  lhs->isValueDependent() || rhs->isValueDependent(),
3256  (lhs->isInstantiationDependent() ||
3257  rhs->isInstantiationDependent()),
3258  (lhs->containsUnexpandedParameterPack() ||
3259  rhs->containsUnexpandedParameterPack())),
3260  Opc(opc), FPFeatures(FPFeatures.getInt()), OpLoc(opLoc) {
3261  SubExprs[LHS] = lhs;
3262  SubExprs[RHS] = rhs;
3263  }
3264 
3266  : Expr(SC, Empty), Opc(BO_MulAssign) { }
3267 };
3268 
3269 /// CompoundAssignOperator - For compound assignments (e.g. +=), we keep
3270 /// track of the type the operation is performed in. Due to the semantics of
3271 /// these operators, the operands are promoted, the arithmetic performed, an
3272 /// implicit conversion back to the result type done, then the assignment takes
3273 /// place. This captures the intermediate type which the computation is done
3274 /// in.
3276  QualType ComputationLHSType;
3277  QualType ComputationResultType;
3278 public:
3279  CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResType,
3281  QualType CompLHSType, QualType CompResultType,
3282  SourceLocation OpLoc, FPOptions FPFeatures)
3283  : BinaryOperator(lhs, rhs, opc, ResType, VK, OK, OpLoc, FPFeatures,
3284  true),
3285  ComputationLHSType(CompLHSType),
3286  ComputationResultType(CompResultType) {
3287  assert(isCompoundAssignmentOp() &&
3288  "Only should be used for compound assignments");
3289  }
3290 
3291  /// Build an empty compound assignment operator expression.
3293  : BinaryOperator(CompoundAssignOperatorClass, Empty) { }
3294 
3295  // The two computation types are the type the LHS is converted
3296  // to for the computation and the type of the result; the two are
3297  // distinct in a few cases (specifically, int+=ptr and ptr-=ptr).
3298  QualType getComputationLHSType() const { return ComputationLHSType; }
3299  void setComputationLHSType(QualType T) { ComputationLHSType = T; }
3300 
3301  QualType getComputationResultType() const { return ComputationResultType; }
3302  void setComputationResultType(QualType T) { ComputationResultType = T; }
3303 
3304  static bool classof(const Stmt *S) {
3305  return S->getStmtClass() == CompoundAssignOperatorClass;
3306  }
3307 };
3308 
3309 /// AbstractConditionalOperator - An abstract base class for
3310 /// ConditionalOperator and BinaryConditionalOperator.
3312  SourceLocation QuestionLoc, ColonLoc;
3313  friend class ASTStmtReader;
3314 
3315 protected:
3318  bool TD, bool VD, bool ID,
3319  bool ContainsUnexpandedParameterPack,
3320  SourceLocation qloc,
3321  SourceLocation cloc)
3322  : Expr(SC, T, VK, OK, TD, VD, ID, ContainsUnexpandedParameterPack),
3323  QuestionLoc(qloc), ColonLoc(cloc) {}
3324 
3326  : Expr(SC, Empty) { }
3327 
3328 public:
3329  // getCond - Return the expression representing the condition for
3330  // the ?: operator.
3331  Expr *getCond() const;
3332 
3333  // getTrueExpr - Return the subexpression representing the value of
3334  // the expression if the condition evaluates to true.
3335  Expr *getTrueExpr() const;
3336 
3337  // getFalseExpr - Return the subexpression representing the value of
3338  // the expression if the condition evaluates to false. This is
3339  // the same as getRHS.
3340  Expr *getFalseExpr() const;
3341 
3342  SourceLocation getQuestionLoc() const { return QuestionLoc; }
3344 
3345  static bool classof(const Stmt *T) {
3346  return T->getStmtClass() == ConditionalOperatorClass ||
3347  T->getStmtClass() == BinaryConditionalOperatorClass;
3348  }
3349 };
3350 
3351 /// ConditionalOperator - The ?: ternary operator. The GNU "missing
3352 /// middle" extension is a BinaryConditionalOperator.
3354  enum { COND, LHS, RHS, END_EXPR };
3355  Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
3356 
3357  friend class ASTStmtReader;
3358 public:
3360  SourceLocation CLoc, Expr *rhs,
3362  : AbstractConditionalOperator(ConditionalOperatorClass, t, VK, OK,
3363  // FIXME: the type of the conditional operator doesn't
3364  // depend on the type of the conditional, but the standard
3365  // seems to imply that it could. File a bug!
3366  (lhs->isTypeDependent() || rhs->isTypeDependent()),
3367  (cond->isValueDependent() || lhs->isValueDependent() ||
3368  rhs->isValueDependent()),
3369  (cond->isInstantiationDependent() ||
3370  lhs->isInstantiationDependent() ||
3371  rhs->isInstantiationDependent()),
3372  (cond->containsUnexpandedParameterPack() ||
3373  lhs->containsUnexpandedParameterPack() ||
3374  rhs->containsUnexpandedParameterPack()),
3375  QLoc, CLoc) {
3376  SubExprs[COND] = cond;
3377  SubExprs[LHS] = lhs;
3378  SubExprs[RHS] = rhs;
3379  }
3380 
3381  /// Build an empty conditional operator.
3383  : AbstractConditionalOperator(ConditionalOperatorClass, Empty) { }
3384 
3385  // getCond - Return the expression representing the condition for
3386  // the ?: operator.
3387  Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3388 
3389  // getTrueExpr - Return the subexpression representing the value of
3390  // the expression if the condition evaluates to true.
3391  Expr *getTrueExpr() const { return cast<Expr>(SubExprs[LHS]); }
3392 
3393  // getFalseExpr - Return the subexpression representing the value of
3394  // the expression if the condition evaluates to false. This is
3395  // the same as getRHS.
3396  Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }
3397 
3398  Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3399  Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3400 
3401  SourceLocation getLocStart() const LLVM_READONLY {
3402  return getCond()->getLocStart();
3403  }
3404  SourceLocation getLocEnd() const LLVM_READONLY {
3405  return getRHS()->getLocEnd();
3406  }
3407 
3408  static bool classof(const Stmt *T) {
3409  return T->getStmtClass() == ConditionalOperatorClass;
3410  }
3411 
3412  // Iterators
3414  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
3415  }
3417  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
3418  }
3419 };
3420 
3421 /// BinaryConditionalOperator - The GNU extension to the conditional
3422 /// operator which allows the middle operand to be omitted.
3423 ///
3424 /// This is a different expression kind on the assumption that almost
3425 /// every client ends up needing to know that these are different.
3427  enum { COMMON, COND, LHS, RHS, NUM_SUBEXPRS };
3428 
3429  /// - the common condition/left-hand-side expression, which will be
3430  /// evaluated as the opaque value
3431  /// - the condition, expressed in terms of the opaque value
3432  /// - the left-hand-side, expressed in terms of the opaque value
3433  /// - the right-hand-side
3434  Stmt *SubExprs[NUM_SUBEXPRS];
3435  OpaqueValueExpr *OpaqueValue;
3436 
3437  friend class ASTStmtReader;
3438 public:
3440  Expr *cond, Expr *lhs, Expr *rhs,
3441  SourceLocation qloc, SourceLocation cloc,
3443  : AbstractConditionalOperator(BinaryConditionalOperatorClass, t, VK, OK,
3444  (common->isTypeDependent() || rhs->isTypeDependent()),
3445  (common->isValueDependent() || rhs->isValueDependent()),
3446  (common->isInstantiationDependent() ||
3447  rhs->isInstantiationDependent()),
3448  (common->containsUnexpandedParameterPack() ||
3449  rhs->containsUnexpandedParameterPack()),
3450  qloc, cloc),
3451  OpaqueValue(opaqueValue) {
3452  SubExprs[COMMON] = common;
3453  SubExprs[COND] = cond;
3454  SubExprs[LHS] = lhs;
3455  SubExprs[RHS] = rhs;
3456  assert(OpaqueValue->getSourceExpr() == common && "Wrong opaque value");
3457  }
3458 
3459  /// Build an empty conditional operator.
3461  : AbstractConditionalOperator(BinaryConditionalOperatorClass, Empty) { }
3462 
3463  /// getCommon - Return the common expression, written to the
3464  /// left of the condition. The opaque value will be bound to the
3465  /// result of this expression.
3466  Expr *getCommon() const { return cast<Expr>(SubExprs[COMMON]); }
3467 
3468  /// getOpaqueValue - Return the opaque value placeholder.
3469  OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; }
3470 
3471  /// getCond - Return the condition expression; this is defined
3472  /// in terms of the opaque value.
3473  Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3474 
3475  /// getTrueExpr - Return the subexpression which will be
3476  /// evaluated if the condition evaluates to true; this is defined
3477  /// in terms of the opaque value.
3478  Expr *getTrueExpr() const {
3479  return cast<Expr>(SubExprs[LHS]);
3480  }
3481 
3482  /// getFalseExpr - Return the subexpression which will be
3483  /// evaluated if the condnition evaluates to false; this is
3484  /// defined in terms of the opaque value.
3485  Expr *getFalseExpr() const {
3486  return cast<Expr>(SubExprs[RHS]);
3487  }
3488 
3489  SourceLocation getLocStart() const LLVM_READONLY {
3490  return getCommon()->getLocStart();
3491  }
3492  SourceLocation getLocEnd() const LLVM_READONLY {
3493  return getFalseExpr()->getLocEnd();
3494  }
3495 
3496  static bool classof(const Stmt *T) {
3497  return T->getStmtClass() == BinaryConditionalOperatorClass;
3498  }
3499 
3500  // Iterators
3502  return child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
3503  }
3505  return const_child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
3506  }
3507 };
3508 
3510  if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
3511  return co->getCond();
3512  return cast<BinaryConditionalOperator>(this)->getCond();
3513 }
3514 
3516  if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
3517  return co->getTrueExpr();
3518  return cast<BinaryConditionalOperator>(this)->getTrueExpr();
3519 }
3520 
3522  if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
3523  return co->getFalseExpr();
3524  return cast<BinaryConditionalOperator>(this)->getFalseExpr();
3525 }
3526 
3527 /// AddrLabelExpr - The GNU address of label extension, representing &&label.
3528 class AddrLabelExpr : public Expr {
3529  SourceLocation AmpAmpLoc, LabelLoc;
3530  LabelDecl *Label;
3531 public:
3533  QualType t)
3534  : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary, false, false, false,
3535  false),
3536  AmpAmpLoc(AALoc), LabelLoc(LLoc), Label(L) {}
3537 
3538  /// Build an empty address of a label expression.
3539  explicit AddrLabelExpr(EmptyShell Empty)
3540  : Expr(AddrLabelExprClass, Empty) { }
3541 
3542  SourceLocation getAmpAmpLoc() const { return AmpAmpLoc; }
3543  void setAmpAmpLoc(SourceLocation L) { AmpAmpLoc = L; }
3544  SourceLocation getLabelLoc() const { return LabelLoc; }
3545  void setLabelLoc(SourceLocation L) { LabelLoc = L; }
3546 
3547  SourceLocation getLocStart() const LLVM_READONLY { return AmpAmpLoc; }
3548  SourceLocation getLocEnd() const LLVM_READONLY { return LabelLoc; }
3549 
3550  LabelDecl *getLabel() const { return Label; }
3551  void setLabel(LabelDecl *L) { Label = L; }
3552 
3553  static bool classof(const Stmt *T) {
3554  return T->getStmtClass() == AddrLabelExprClass;
3555  }
3556 
3557  // Iterators
3560  }
3563  }
3564 };
3565 
3566 /// StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
3567 /// The StmtExpr contains a single CompoundStmt node, which it evaluates and
3568 /// takes the value of the last subexpression.
3569 ///
3570 /// A StmtExpr is always an r-value; values "returned" out of a
3571 /// StmtExpr will be copied.
3572 class StmtExpr : public Expr {
3573  Stmt *SubStmt;
3574  SourceLocation LParenLoc, RParenLoc;
3575 public:
3576  // FIXME: Does type-dependence need to be computed differently?
3577  // FIXME: Do we need to compute instantiation instantiation-dependence for
3578  // statements? (ugh!)
3580  SourceLocation lp, SourceLocation rp) :
3581  Expr(StmtExprClass, T, VK_RValue, OK_Ordinary,
3582  T->isDependentType(), false, false, false),
3583  SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) { }
3584 
3585  /// Build an empty statement expression.
3586  explicit StmtExpr(EmptyShell Empty) : Expr(StmtExprClass, Empty) { }
3587 
3588  CompoundStmt *getSubStmt() { return cast<CompoundStmt>(SubStmt); }
3589  const CompoundStmt *getSubStmt() const { return cast<CompoundStmt>(SubStmt); }
3590  void setSubStmt(CompoundStmt *S) { SubStmt = S; }
3591 
3592  SourceLocation getLocStart() const LLVM_READONLY { return LParenLoc; }
3593  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
3594 
3595  SourceLocation getLParenLoc() const { return LParenLoc; }
3596  void setLParenLoc(SourceLocation L) { LParenLoc = L; }
3597  SourceLocation getRParenLoc() const { return RParenLoc; }
3598  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3599 
3600  static bool classof(const Stmt *T) {
3601  return T->getStmtClass() == StmtExprClass;
3602  }
3603 
3604  // Iterators
3605  child_range children() { return child_range(&SubStmt, &SubStmt+1); }
3607  return const_child_range(&SubStmt, &SubStmt + 1);
3608  }
3609 };
3610 
3611 /// ShuffleVectorExpr - clang-specific builtin-in function
3612 /// __builtin_shufflevector.
3613 /// This AST node represents a operator that does a constant
3614 /// shuffle, similar to LLVM's shufflevector instruction. It takes
3615 /// two vectors and a variable number of constant indices,
3616 /// and returns the appropriately shuffled vector.
3617 class ShuffleVectorExpr : public Expr {
3618  SourceLocation BuiltinLoc, RParenLoc;
3619 
3620  // SubExprs - the list of values passed to the __builtin_shufflevector
3621  // function. The first two are vectors, and the rest are constant
3622  // indices. The number of values in this list is always
3623  // 2+the number of indices in the vector type.
3624  Stmt **SubExprs;
3625  unsigned NumExprs;
3626 
3627 public:
3629  SourceLocation BLoc, SourceLocation RP);
3630 
3631  /// Build an empty vector-shuffle expression.
3633  : Expr(ShuffleVectorExprClass, Empty), SubExprs(nullptr) { }
3634 
3635  SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
3636  void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }
3637 
3638  SourceLocation getRParenLoc() const { return RParenLoc; }
3639  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3640 
3641  SourceLocation getLocStart() const LLVM_READONLY { return BuiltinLoc; }
3642  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
3643 
3644  static bool classof(const Stmt *T) {
3645  return T->getStmtClass() == ShuffleVectorExprClass;
3646  }
3647 
3648  /// getNumSubExprs - Return the size of the SubExprs array. This includes the
3649  /// constant expression, the actual arguments passed in, and the function
3650  /// pointers.
3651  unsigned getNumSubExprs() const { return NumExprs; }
3652 
3653  /// Retrieve the array of expressions.
3654  Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
3655 
3656  /// getExpr - Return the Expr at the specified index.
3657  Expr *getExpr(unsigned Index) {
3658  assert((Index < NumExprs) && "Arg access out of range!");
3659  return cast<Expr>(SubExprs[Index]);
3660  }
3661  const Expr *getExpr(unsigned Index) const {
3662  assert((Index < NumExprs) && "Arg access out of range!");
3663  return cast<Expr>(SubExprs[Index]);
3664  }
3665 
3666  void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);
3667 
3668  llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const {
3669  assert((N < NumExprs - 2) && "Shuffle idx out of range!");
3670  return getExpr(N+2)->EvaluateKnownConstInt(Ctx);
3671  }
3672 
3673  // Iterators
3675  return child_range(&SubExprs[0], &SubExprs[0]+NumExprs);
3676  }
3678  return const_child_range(&SubExprs[0], &SubExprs[0] + NumExprs);
3679  }
3680 };
3681 
3682 /// ConvertVectorExpr - Clang builtin function __builtin_convertvector
3683 /// This AST node provides support for converting a vector type to another
3684 /// vector type of the same arity.
3685 class ConvertVectorExpr : public Expr {
3686 private:
3687  Stmt *SrcExpr;
3688  TypeSourceInfo *TInfo;
3689  SourceLocation BuiltinLoc, RParenLoc;
3690 
3691  friend class ASTReader;
3692  friend class ASTStmtReader;
3693  explicit ConvertVectorExpr(EmptyShell Empty) : Expr(ConvertVectorExprClass, Empty) {}
3694 
3695 public:
3698  SourceLocation BuiltinLoc, SourceLocation RParenLoc)
3699  : Expr(ConvertVectorExprClass, DstType, VK, OK,
3700  DstType->isDependentType(),
3701  DstType->isDependentType() || SrcExpr->isValueDependent(),
3702  (DstType->isInstantiationDependentType() ||
3703  SrcExpr->isInstantiationDependent()),
3704  (DstType->containsUnexpandedParameterPack() ||
3705  SrcExpr->containsUnexpandedParameterPack())),
3706  SrcExpr(SrcExpr), TInfo(TI), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {}
3707 
3708  /// getSrcExpr - Return the Expr to be converted.
3709  Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }
3710 
3711  /// getTypeSourceInfo - Return the destination type.
3713  return TInfo;
3714  }
3716  TInfo = ti;
3717  }
3718 
3719  /// getBuiltinLoc - Return the location of the __builtin_convertvector token.
3720  SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
3721 
3722  /// getRParenLoc - Return the location of final right parenthesis.
3723  SourceLocation getRParenLoc() const { return RParenLoc; }
3724 
3725  SourceLocation getLocStart() const LLVM_READONLY { return BuiltinLoc; }
3726  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
3727 
3728  static bool classof(const Stmt *T) {
3729  return T->getStmtClass() == ConvertVectorExprClass;
3730  }
3731 
3732  // Iterators
3733  child_range children() { return child_range(&SrcExpr, &SrcExpr+1); }
3735  return const_child_range(&SrcExpr, &SrcExpr + 1);
3736  }
3737 };
3738 
3739 /// ChooseExpr - GNU builtin-in function __builtin_choose_expr.
3740 /// This AST node is similar to the conditional operator (?:) in C, with
3741 /// the following exceptions:
3742 /// - the test expression must be a integer constant expression.
3743 /// - the expression returned acts like the chosen subexpression in every
3744 /// visible way: the type is the same as that of the chosen subexpression,
3745 /// and all predicates (whether it's an l-value, whether it's an integer
3746 /// constant expression, etc.) return the same result as for the chosen
3747 /// sub-expression.
3748 class ChooseExpr : public Expr {
3749  enum { COND, LHS, RHS, END_EXPR };
3750  Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
3751  SourceLocation BuiltinLoc, RParenLoc;
3752  bool CondIsTrue;
3753 public:
3754  ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
3756  SourceLocation RP, bool condIsTrue,
3757  bool TypeDependent, bool ValueDependent)
3758  : Expr(ChooseExprClass, t, VK, OK, TypeDependent, ValueDependent,
3759  (cond->isInstantiationDependent() ||
3760  lhs->isInstantiationDependent() ||
3761  rhs->isInstantiationDependent()),
3762  (cond->containsUnexpandedParameterPack() ||
3763  lhs->containsUnexpandedParameterPack() ||
3764  rhs->containsUnexpandedParameterPack())),
3765  BuiltinLoc(BLoc), RParenLoc(RP), CondIsTrue(condIsTrue) {
3766  SubExprs[COND] = cond;
3767  SubExprs[LHS] = lhs;
3768  SubExprs[RHS] = rhs;
3769  }
3770 
3771  /// Build an empty __builtin_choose_expr.
3772  explicit ChooseExpr(EmptyShell Empty) : Expr(ChooseExprClass, Empty) { }
3773 
3774  /// isConditionTrue - Return whether the condition is true (i.e. not
3775  /// equal to zero).
3776  bool isConditionTrue() const {
3777  assert(!isConditionDependent() &&
3778  "Dependent condition isn't true or false");
3779  return CondIsTrue;
3780  }
3781  void setIsConditionTrue(bool isTrue) { CondIsTrue = isTrue; }
3782 
3783  bool isConditionDependent() const {
3784  return getCond()->isTypeDependent() || getCond()->isValueDependent();
3785  }
3786 
3787  /// getChosenSubExpr - Return the subexpression chosen according to the
3788  /// condition.
3790  return isConditionTrue() ? getLHS() : getRHS();
3791  }
3792 
3793  Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3794  void setCond(Expr *E) { SubExprs[COND] = E; }
3795  Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3796  void setLHS(Expr *E) { SubExprs[LHS] = E; }
3797  Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3798  void setRHS(Expr *E) { SubExprs[RHS] = E; }
3799 
3800  SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
3801  void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }
3802 
3803  SourceLocation getRParenLoc() const { return RParenLoc; }
3804  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3805 
3806  SourceLocation getLocStart() const LLVM_READONLY { return BuiltinLoc; }
3807  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
3808 
3809  static bool classof(const Stmt *T) {
3810  return T->getStmtClass() == ChooseExprClass;
3811  }
3812 
3813  // Iterators
3815  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
3816  }
3818  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
3819  }
3820 };
3821 
3822 /// GNUNullExpr - Implements the GNU __null extension, which is a name
3823 /// for a null pointer constant that has integral type (e.g., int or
3824 /// long) and is the same size and alignment as a pointer. The __null
3825 /// extension is typically only used by system headers, which define
3826 /// NULL as __null in C++ rather than using 0 (which is an integer
3827 /// that may not match the size of a pointer).
3828 class GNUNullExpr : public Expr {
3829  /// TokenLoc - The location of the __null keyword.
3830  SourceLocation TokenLoc;
3831 
3832 public:
3834  : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary, false, false, false,
3835  false),
3836  TokenLoc(Loc) { }
3837 
3838  /// Build an empty GNU __null expression.
3839  explicit GNUNullExpr(EmptyShell Empty) : Expr(GNUNullExprClass, Empty) { }
3840 
3841  /// getTokenLocation - The location of the __null token.
3842  SourceLocation getTokenLocation() const { return TokenLoc; }
3843  void setTokenLocation(SourceLocation L) { TokenLoc = L; }
3844 
3845  SourceLocation getLocStart() const LLVM_READONLY { return TokenLoc; }
3846  SourceLocation getLocEnd() const LLVM_READONLY { return TokenLoc; }
3847 
3848  static bool classof(const Stmt *T) {
3849  return T->getStmtClass() == GNUNullExprClass;
3850  }
3851 
3852  // Iterators
3855  }
3858  }
3859 };
3860 
3861 /// Represents a call to the builtin function \c __builtin_va_arg.
3862 class VAArgExpr : public Expr {
3863  Stmt *Val;
3864  llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
3865  SourceLocation BuiltinLoc, RParenLoc;
3866 public:
3868  SourceLocation RPLoc, QualType t, bool IsMS)
3869  : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary, t->isDependentType(),
3870  false, (TInfo->getType()->isInstantiationDependentType() ||
3871  e->isInstantiationDependent()),
3872  (TInfo->getType()->containsUnexpandedParameterPack() ||
3873  e->containsUnexpandedParameterPack())),
3874  Val(e), TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {}
3875 
3876  /// Create an empty __builtin_va_arg expression.
3877  explicit VAArgExpr(EmptyShell Empty)
3878  : Expr(VAArgExprClass, Empty), Val(nullptr), TInfo(nullptr, false) {}
3879 
3880  const Expr *getSubExpr() const { return cast<Expr>(Val); }
3881  Expr *getSubExpr() { return cast<Expr>(Val); }
3882  void setSubExpr(Expr *E) { Val = E; }
3883 
3884  /// Returns whether this is really a Win64 ABI va_arg expression.
3885  bool isMicrosoftABI() const { return TInfo.getInt(); }
3886  void setIsMicrosoftABI(bool IsMS) { TInfo.setInt(IsMS); }
3887 
3888  TypeSourceInfo *getWrittenTypeInfo() const { return TInfo.getPointer(); }
3889  void setWrittenTypeInfo(TypeSourceInfo *TI) { TInfo.setPointer(TI); }
3890 
3891  SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
3892  void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }
3893 
3894  SourceLocation getRParenLoc() const { return RParenLoc; }
3895  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3896 
3897  SourceLocation getLocStart() const LLVM_READONLY { return BuiltinLoc; }
3898  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
3899 
3900  static bool classof(const Stmt *T) {
3901  return T->getStmtClass() == VAArgExprClass;
3902  }
3903 
3904  // Iterators
3905  child_range children() { return child_range(&Val, &Val+1); }
3907  return const_child_range(&Val, &Val + 1);
3908  }
3909 };
3910 
3911 /// Describes an C or C++ initializer list.
3912 ///
3913 /// InitListExpr describes an initializer list, which can be used to
3914 /// initialize objects of different types, including
3915 /// struct/class/union types, arrays, and vectors. For example:
3916 ///
3917 /// @code
3918 /// struct foo x = { 1, { 2, 3 } };
3919 /// @endcode
3920 ///
3921 /// Prior to semantic analysis, an initializer list will represent the
3922 /// initializer list as written by the user, but will have the
3923 /// placeholder type "void". This initializer list is called the
3924 /// syntactic form of the initializer, and may contain C99 designated
3925 /// initializers (represented as DesignatedInitExprs), initializations
3926 /// of subobject members without explicit braces, and so on. Clients
3927 /// interested in the original syntax of the initializer list should
3928 /// use the syntactic form of the initializer list.
3929 ///
3930 /// After semantic analysis, the initializer list will represent the
3931 /// semantic form of the initializer, where the initializations of all
3932 /// subobjects are made explicit with nested InitListExpr nodes and
3933 /// C99 designators have been eliminated by placing the designated
3934 /// initializations into the subobject they initialize. Additionally,
3935 /// any "holes" in the initialization, where no initializer has been
3936 /// specified for a particular subobject, will be replaced with
3937 /// implicitly-generated ImplicitValueInitExpr expressions that
3938 /// value-initialize the subobjects. Note, however, that the
3939 /// initializer lists may still have fewer initializers than there are
3940 /// elements to initialize within the object.
3941 ///
3942 /// After semantic analysis has completed, given an initializer list,
3943 /// method isSemanticForm() returns true if and only if this is the
3944 /// semantic form of the initializer list (note: the same AST node
3945 /// may at the same time be the syntactic form).
3946 /// Given the semantic form of the initializer list, one can retrieve
3947 /// the syntactic form of that initializer list (when different)
3948 /// using method getSyntacticForm(); the method returns null if applied
3949 /// to a initializer list which is already in syntactic form.
3950 /// Similarly, given the syntactic form (i.e., an initializer list such
3951 /// that isSemanticForm() returns false), one can retrieve the semantic
3952 /// form using method getSemanticForm().
3953 /// Since many initializer lists have the same syntactic and semantic forms,
3954 /// getSyntacticForm() may return NULL, indicating that the current
3955 /// semantic initializer list also serves as its syntactic form.
3956 class InitListExpr : public Expr {
3957  // FIXME: Eliminate this vector in favor of ASTContext allocation
3959  InitExprsTy InitExprs;
3960  SourceLocation LBraceLoc, RBraceLoc;
3961 
3962  /// The alternative form of the initializer list (if it exists).
3963  /// The int part of the pair stores whether this initializer list is
3964  /// in semantic form. If not null, the pointer points to:
3965  /// - the syntactic form, if this is in semantic form;
3966  /// - the semantic form, if this is in syntactic form.
3967  llvm::PointerIntPair<InitListExpr *, 1, bool> AltForm;
3968 
3969  /// Either:
3970  /// If this initializer list initializes an array with more elements than
3971  /// there are initializers in the list, specifies an expression to be used
3972  /// for value initialization of the rest of the elements.
3973  /// Or
3974  /// If this initializer list initializes a union, specifies which
3975  /// field within the union will be initialized.
3976  llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;
3977 
3978 public:
3979  InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
3980  ArrayRef<Expr*> initExprs, SourceLocation rbraceloc);
3981 
3982  /// Build an empty initializer list.
3983  explicit InitListExpr(EmptyShell Empty)
3984  : Expr(InitListExprClass, Empty), AltForm(nullptr, true) { }
3985 
3986  unsigned getNumInits() const { return InitExprs.size(); }
3987 
3988  /// Retrieve the set of initializers.
3989  Expr **getInits() { return reinterpret_cast<Expr **>(InitExprs.data()); }
3990 
3991  /// Retrieve the set of initializers.
3992  Expr * const *getInits() const {
3993  return reinterpret_cast<Expr * const *>(InitExprs.data());
3994  }
3995 
3997  return llvm::makeArrayRef(getInits(), getNumInits());
3998  }
3999 
4001  return llvm::makeArrayRef(getInits(), getNumInits());
4002  }
4003 
4004  const Expr *getInit(unsigned Init) const {
4005  assert(Init < getNumInits() && "Initializer access out of range!");
4006  return cast_or_null<Expr>(InitExprs[Init]);
4007  }
4008 
4009  Expr *getInit(unsigned Init) {
4010  assert(Init < getNumInits() && "Initializer access out of range!");
4011  return cast_or_null<Expr>(InitExprs[Init]);
4012  }
4013 
4014  void setInit(unsigned Init, Expr *expr) {
4015  assert(Init < getNumInits() && "Initializer access out of range!");
4016  InitExprs[Init] = expr;
4017 
4018  if (expr) {
4019  ExprBits.TypeDependent |= expr->isTypeDependent();
4020  ExprBits.ValueDependent |= expr->isValueDependent();
4021  ExprBits.InstantiationDependent |= expr->isInstantiationDependent();
4022  ExprBits.ContainsUnexpandedParameterPack |=
4024  }
4025  }
4026 
4027  /// Reserve space for some number of initializers.
4028  void reserveInits(const ASTContext &C, unsigned NumInits);
4029 
4030  /// Specify the number of initializers
4031  ///
4032  /// If there are more than @p NumInits initializers, the remaining
4033  /// initializers will be destroyed. If there are fewer than @p
4034  /// NumInits initializers, NULL expressions will be added for the
4035  /// unknown initializers.
4036  void resizeInits(const ASTContext &Context, unsigned NumInits);
4037 
4038  /// Updates the initializer at index @p Init with the new
4039  /// expression @p expr, and returns the old expression at that
4040  /// location.
4041  ///
4042  /// When @p Init is out of range for this initializer list, the
4043  /// initializer list will be extended with NULL expressions to
4044  /// accommodate the new entry.
4045  Expr *updateInit(const ASTContext &C, unsigned Init, Expr *expr);
4046 
4047  /// If this initializer list initializes an array with more elements
4048  /// than there are initializers in the list, specifies an expression to be
4049  /// used for value initialization of the rest of the elements.
4051  return ArrayFillerOrUnionFieldInit.dyn_cast<Expr *>();
4052  }
4053  const Expr *getArrayFiller() const {
4054  return const_cast<InitListExpr *>(this)->getArrayFiller();
4055  }
4056  void setArrayFiller(Expr *filler);
4057 
4058  /// Return true if this is an array initializer and its array "filler"
4059  /// has been set.
4060  bool hasArrayFiller() const { return getArrayFiller(); }
4061 
4062  /// If this initializes a union, specifies which field in the
4063  /// union to initialize.
4064  ///
4065  /// Typically, this field is the first named field within the
4066  /// union. However, a designated initializer can specify the
4067  /// initialization of a different field within the union.
4069  return ArrayFillerOrUnionFieldInit.dyn_cast<FieldDecl *>();
4070  }
4072  return const_cast<InitListExpr *>(this)->getInitializedFieldInUnion();
4073  }
4075  assert((FD == nullptr
4076  || getInitializedFieldInUnion() == nullptr
4077  || getInitializedFieldInUnion() == FD)
4078  && "Only one field of a union may be initialized at a time!");
4079  ArrayFillerOrUnionFieldInit = FD;
4080  }
4081 
4082  // Explicit InitListExpr's originate from source code (and have valid source
4083  // locations). Implicit InitListExpr's are created by the semantic analyzer.
4084  bool isExplicit() const {
4085  return LBraceLoc.isValid() && RBraceLoc.isValid();
4086  }
4087 
4088  // Is this an initializer for an array of characters, initialized by a string
4089  // literal or an @encode?
4090  bool isStringLiteralInit() const;
4091 
4092  /// Is this a transparent initializer list (that is, an InitListExpr that is
4093  /// purely syntactic, and whose semantics are that of the sole contained
4094  /// initializer)?
4095  bool isTransparent() const;
4096 
4097  /// Is this the zero initializer {0} in a language which considers it
4098  /// idiomatic?
4099  bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const;
4100 
4101  SourceLocation getLBraceLoc() const { return LBraceLoc; }
4102  void setLBraceLoc(SourceLocation Loc) { LBraceLoc = Loc; }
4103  SourceLocation getRBraceLoc() const { return RBraceLoc; }
4104  void setRBraceLoc(SourceLocation Loc) { RBraceLoc = Loc; }
4105 
4106  bool isSemanticForm() const { return AltForm.getInt(); }
4108  return isSemanticForm() ? nullptr : AltForm.getPointer();
4109  }
4110  bool isSyntacticForm() const {
4111  return !AltForm.getInt() || !AltForm.getPointer();
4112  }
4114  return isSemanticForm() ? AltForm.getPointer() : nullptr;
4115  }
4116 
4118  AltForm.setPointer(Init);
4119  AltForm.setInt(true);
4120  Init->AltForm.setPointer(this);
4121  Init->AltForm.setInt(false);
4122  }
4123 
4125  return InitListExprBits.HadArrayRangeDesignator != 0;
4126  }
4127  void sawArrayRangeDesignator(bool ARD = true) {
4128  InitListExprBits.HadArrayRangeDesignator = ARD;
4129  }
4130 
4131  SourceLocation getLocStart() const LLVM_READONLY;
4132  SourceLocation getLocEnd() const LLVM_READONLY;
4133 
4134  static bool classof(const Stmt *T) {
4135  return T->getStmtClass() == InitListExprClass;
4136  }
4137 
4138  // Iterators
4140  const_child_range CCR = const_cast<const InitListExpr *>(this)->children();
4141  return child_range(cast_away_const(CCR.begin()),
4142  cast_away_const(CCR.end()));
4143  }
4144 
4146  // FIXME: This does not include the array filler expression.
4147  if (InitExprs.empty())
4149  return const_child_range(&InitExprs[0], &InitExprs[0] + InitExprs.size());
4150  }
4151 
4156 
4157  iterator begin() { return InitExprs.begin(); }
4158  const_iterator begin() const { return InitExprs.begin(); }
4159  iterator end() { return InitExprs.end(); }
4160  const_iterator end() const { return InitExprs.end(); }
4161  reverse_iterator rbegin() { return InitExprs.rbegin(); }
4162  const_reverse_iterator rbegin() const { return InitExprs.rbegin(); }
4163  reverse_iterator rend() { return InitExprs.rend(); }
4164  const_reverse_iterator rend() const { return InitExprs.rend(); }
4165 
4166  friend class ASTStmtReader;
4167  friend class ASTStmtWriter;
4168 };
4169 
4170 /// Represents a C99 designated initializer expression.
4171 ///
4172 /// A designated initializer expression (C99 6.7.8) contains one or
4173 /// more designators (which can be field designators, array
4174 /// designators, or GNU array-range designators) followed by an
4175 /// expression that initializes the field or element(s) that the
4176 /// designators refer to. For example, given:
4177 ///
4178 /// @code
4179 /// struct point {
4180 /// double x;
4181 /// double y;
4182 /// };
4183 /// struct point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
4184 /// @endcode
4185 ///
4186 /// The InitListExpr contains three DesignatedInitExprs, the first of
4187 /// which covers @c [2].y=1.0. This DesignatedInitExpr will have two
4188 /// designators, one array designator for @c [2] followed by one field
4189 /// designator for @c .y. The initialization expression will be 1.0.
4191  : public Expr,
4192  private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
4193 public:
4194  /// Forward declaration of the Designator class.
4195  class Designator;
4196 
4197 private:
4198  /// The location of the '=' or ':' prior to the actual initializer
4199  /// expression.
4200  SourceLocation EqualOrColonLoc;
4201 
4202  /// Whether this designated initializer used the GNU deprecated
4203  /// syntax rather than the C99 '=' syntax.
4204  unsigned GNUSyntax : 1;
4205 
4206  /// The number of designators in this initializer expression.
4207  unsigned NumDesignators : 15;
4208 
4209  /// The number of subexpressions of this initializer expression,
4210  /// which contains both the initializer and any additional
4211  /// expressions used by array and array-range designators.
4212  unsigned NumSubExprs : 16;
4213 
4214  /// The designators in this designated initialization
4215  /// expression.
4216  Designator *Designators;
4217 
4218  DesignatedInitExpr(const ASTContext &C, QualType Ty,
4219  llvm::ArrayRef<Designator> Designators,
4220  SourceLocation EqualOrColonLoc, bool GNUSyntax,
4221  ArrayRef<Expr *> IndexExprs, Expr *Init);
4222 
4223  explicit DesignatedInitExpr(unsigned NumSubExprs)
4224  : Expr(DesignatedInitExprClass, EmptyShell()),
4225  NumDesignators(0), NumSubExprs(NumSubExprs), Designators(nullptr) { }
4226 
4227 public:
4228  /// A field designator, e.g., ".x".
4230  /// Refers to the field that is being initialized. The low bit
4231  /// of this field determines whether this is actually a pointer
4232  /// to an IdentifierInfo (if 1) or a FieldDecl (if 0). When
4233  /// initially constructed, a field designator will store an
4234  /// IdentifierInfo*. After semantic analysis has resolved that
4235  /// name, the field designator will instead store a FieldDecl*.
4237 
4238  /// The location of the '.' in the designated initializer.
4239  unsigned DotLoc;
4240 
4241  /// The location of the field name in the designated initializer.
4242  unsigned FieldLoc;
4243  };
4244 
4245  /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
4247  /// Location of the first index expression within the designated
4248  /// initializer expression's list of subexpressions.
4249  unsigned Index;
4250  /// The location of the '[' starting the array range designator.
4251  unsigned LBracketLoc;
4252  /// The location of the ellipsis separating the start and end
4253  /// indices. Only valid for GNU array-range designators.
4254  unsigned EllipsisLoc;
4255  /// The location of the ']' terminating the array range designator.
4256  unsigned RBracketLoc;
4257  };
4258 
4259  /// Represents a single C99 designator.
4260  ///
4261  /// @todo This class is infuriatingly similar to clang::Designator,
4262  /// but minor differences (storing indices vs. storing pointers)
4263  /// keep us from reusing it. Try harder, later, to rectify these
4264  /// differences.
4265  class Designator {
4266  /// The kind of designator this describes.
4267  enum {
4269  ArrayDesignator,
4270  ArrayRangeDesignator
4271  } Kind;
4272 
4273  union {
4274  /// A field designator, e.g., ".x".
4276  /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
4277  struct ArrayOrRangeDesignator ArrayOrRange;
4278  };
4279  friend class DesignatedInitExpr;
4280 
4281  public:
4283 
4284  /// Initializes a field designator.
4285  Designator(const IdentifierInfo *FieldName, SourceLocation DotLoc,
4286  SourceLocation FieldLoc)
4287  : Kind(FieldDesignator) {
4288  Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
4289  Field.DotLoc = DotLoc.getRawEncoding();
4290  Field.FieldLoc = FieldLoc.getRawEncoding();
4291  }
4292 
4293  /// Initializes an array designator.
4294  Designator(unsigned Index, SourceLocation LBracketLoc,
4295  SourceLocation RBracketLoc)
4296  : Kind(ArrayDesignator) {
4297  ArrayOrRange.Index = Index;
4298  ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
4299  ArrayOrRange.EllipsisLoc = SourceLocation().getRawEncoding();
4300  ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
4301  }
4302 
4303  /// Initializes a GNU array-range designator.
4304  Designator(unsigned Index, SourceLocation LBracketLoc,
4305  SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
4306  : Kind(ArrayRangeDesignator) {
4307  ArrayOrRange.Index = Index;
4308  ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
4309  ArrayOrRange.EllipsisLoc = EllipsisLoc.getRawEncoding();
4310  ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
4311  }
4312 
4313  bool isFieldDesignator() const { return Kind == FieldDesignator; }
4314  bool isArrayDesignator() const { return Kind == ArrayDesignator; }
4315  bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }
4316 
4317  IdentifierInfo *getFieldName() const;
4318 
4319  FieldDecl *getField() const {
4320  assert(Kind == FieldDesignator && "Only valid on a field designator");
4321  if (Field.NameOrField & 0x01)
4322  return nullptr;
4323  else
4324  return reinterpret_cast<FieldDecl *>(Field.NameOrField);
4325  }
4326 
4327  void setField(FieldDecl *FD) {
4328  assert(Kind == FieldDesignator && "Only valid on a field designator");
4329  Field.NameOrField = reinterpret_cast<uintptr_t>(FD);
4330  }
4331 
4333  assert(Kind == FieldDesignator && "Only valid on a field designator");
4335  }
4336 
4338  assert(Kind == FieldDesignator && "Only valid on a field designator");
4339  return SourceLocation::getFromRawEncoding(Field.FieldLoc);
4340  }
4341 
4343  assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
4344  "Only valid on an array or array-range designator");
4345  return SourceLocation::getFromRawEncoding(ArrayOrRange.LBracketLoc);
4346  }
4347 
4349  assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
4350  "Only valid on an array or array-range designator");
4351  return SourceLocation::getFromRawEncoding(ArrayOrRange.RBracketLoc);
4352  }
4353 
4355  assert(Kind == ArrayRangeDesignator &&
4356  "Only valid on an array-range designator");
4357  return SourceLocation::getFromRawEncoding(ArrayOrRange.EllipsisLoc);
4358  }
4359 
4360  unsigned getFirstExprIndex() const {
4361  assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
4362  "Only valid on an array or array-range designator");
4363  return ArrayOrRange.Index;
4364  }
4365 
4366  SourceLocation getLocStart() const LLVM_READONLY {
4367  if (Kind == FieldDesignator)
4368  return getDotLoc().isInvalid()? getFieldLoc() : getDotLoc();
4369  else
4370  return getLBracketLoc();
4371  }
4372  SourceLocation getLocEnd() const LLVM_READONLY {
4373  return Kind == FieldDesignator ? getFieldLoc() : getRBracketLoc();
4374  }
4375  SourceRange getSourceRange() const LLVM_READONLY {
4376  return SourceRange(getLocStart(), getLocEnd());
4377  }
4378  };
4379 
4380  static DesignatedInitExpr *Create(const ASTContext &C,
4381  llvm::ArrayRef<Designator> Designators,
4382  ArrayRef<Expr*> IndexExprs,
4383  SourceLocation EqualOrColonLoc,
4384  bool GNUSyntax, Expr *Init);
4385 
4386  static DesignatedInitExpr *CreateEmpty(const ASTContext &C,
4387  unsigned NumIndexExprs);
4388 
4389  /// Returns the number of designators in this initializer.
4390  unsigned size() const { return NumDesignators; }
4391 
4392  // Iterator access to the designators.
4394  return {Designators, NumDesignators};
4395  }
4396 
4398  return {Designators, NumDesignators};
4399  }
4400 
4401  Designator *getDesignator(unsigned Idx) { return &designators()[Idx]; }
4402  const Designator *getDesignator(unsigned Idx) const {
4403  return &designators()[Idx];
4404  }
4405 
4406  void setDesignators(const ASTContext &C, const Designator *Desigs,
4407  unsigned NumDesigs);
4408 
4409  Expr *getArrayIndex(const Designator &D) const;
4410  Expr *getArrayRangeStart(const Designator &D) const;
4411  Expr *getArrayRangeEnd(const Designator &D) const;
4412 
4413  /// Retrieve the location of the '=' that precedes the
4414  /// initializer value itself, if present.
4415  SourceLocation getEqualOrColonLoc() const { return EqualOrColonLoc; }
4416  void setEqualOrColonLoc(SourceLocation L) { EqualOrColonLoc = L; }
4417 
4418  /// Determines whether this designated initializer used the
4419  /// deprecated GNU syntax for designated initializers.
4420  bool usesGNUSyntax() const { return GNUSyntax; }
4421  void setGNUSyntax(bool GNU) { GNUSyntax = GNU; }
4422 
4423  /// Retrieve the initializer value.
4424  Expr *getInit() const {
4425  return cast<Expr>(*const_cast<DesignatedInitExpr*>(this)->child_begin());
4426  }
4427 
4428  void setInit(Expr *init) {
4429  *child_begin() = init;
4430  }
4431 
4432  /// Retrieve the total number of subexpressions in this
4433  /// designated initializer expression, including the actual
4434  /// initialized value and any expressions that occur within array
4435  /// and array-range designators.
4436  unsigned getNumSubExprs() const { return NumSubExprs; }
4437 
4438  Expr *getSubExpr(unsigned Idx) const {
4439  assert(Idx < NumSubExprs && "Subscript out of range");
4440  return cast<Expr>(getTrailingObjects<Stmt *>()[Idx]);
4441  }
4442 
4443  void setSubExpr(unsigned Idx, Expr *E) {
4444  assert(Idx < NumSubExprs && "Subscript out of range");
4445  getTrailingObjects<Stmt *>()[Idx] = E;
4446  }
4447 
4448  /// Replaces the designator at index @p Idx with the series
4449  /// of designators in [First, Last).
4450  void ExpandDesignator(const ASTContext &C, unsigned Idx,
4451  const Designator *First, const Designator *Last);
4452 
4453  SourceRange getDesignatorsSourceRange() const;
4454 
4455  SourceLocation getLocStart() const LLVM_READONLY;
4456  SourceLocation getLocEnd() const LLVM_READONLY;
4457 
4458  static bool classof(const Stmt *T) {
4459  return T->getStmtClass() == DesignatedInitExprClass;
4460  }
4461 
4462  // Iterators
4464  Stmt **begin = getTrailingObjects<Stmt *>();
4465  return child_range(begin, begin + NumSubExprs);
4466  }
4468  Stmt * const *begin = getTrailingObjects<Stmt *>();
4469  return const_child_range(begin, begin + NumSubExprs);
4470  }
4471 
4473 };
4474 
4475 /// Represents a place-holder for an object not to be initialized by
4476 /// anything.
4477 ///
4478 /// This only makes sense when it appears as part of an updater of a
4479 /// DesignatedInitUpdateExpr (see below). The base expression of a DIUE
4480 /// initializes a big object, and the NoInitExpr's mark the spots within the
4481 /// big object not to be overwritten by the updater.
4482 ///
4483 /// \see DesignatedInitUpdateExpr
4484 class NoInitExpr : public Expr {
4485 public:
4486  explicit NoInitExpr(QualType ty)
4487  : Expr(NoInitExprClass, ty, VK_RValue, OK_Ordinary,
4488  false, false, ty->isInstantiationDependentType(), false) { }
4489 
4490  explicit NoInitExpr(EmptyShell Empty)
4491  : Expr(NoInitExprClass, Empty) { }
4492 
4493  static bool classof(const Stmt *T) {
4494  return T->getStmtClass() == NoInitExprClass;
4495  }
4496 
4497  SourceLocation getLocStart() const LLVM_READONLY { return SourceLocation(); }
4498  SourceLocation getLocEnd() const LLVM_READONLY { return SourceLocation(); }
4499 
4500  // Iterators
4503  }
4506  }
4507 };
4508 
4509 // In cases like:
4510 // struct Q { int a, b, c; };
4511 // Q *getQ();
4512 // void foo() {
4513 // struct A { Q q; } a = { *getQ(), .q.b = 3 };
4514 // }
4515 //
4516 // We will have an InitListExpr for a, with type A, and then a
4517 // DesignatedInitUpdateExpr for "a.q" with type Q. The "base" for this DIUE
4518 // is the call expression *getQ(); the "updater" for the DIUE is ".q.b = 3"
4519 //
4521  // BaseAndUpdaterExprs[0] is the base expression;
4522  // BaseAndUpdaterExprs[1] is an InitListExpr overwriting part of the base.
4523  Stmt *BaseAndUpdaterExprs[2];
4524 
4525 public:
4527  Expr *baseExprs, SourceLocation rBraceLoc);
4528 
4530  : Expr(DesignatedInitUpdateExprClass, Empty) { }
4531 
4532  SourceLocation getLocStart() const LLVM_READONLY;
4533  SourceLocation getLocEnd() const LLVM_READONLY;
4534 
4535  static bool classof(const Stmt *T) {
4536  return T->getStmtClass() == DesignatedInitUpdateExprClass;
4537  }
4538 
4539  Expr *getBase() const { return cast<Expr>(BaseAndUpdaterExprs[0]); }
4540  void setBase(Expr *Base) { BaseAndUpdaterExprs[0] = Base; }
4541 
4543  return cast<InitListExpr>(BaseAndUpdaterExprs[1]);
4544  }
4545  void setUpdater(Expr *Updater) { BaseAndUpdaterExprs[1] = Updater; }
4546 
4547  // Iterators
4548  // children = the base and the updater
4550  return child_range(&BaseAndUpdaterExprs[0], &BaseAndUpdaterExprs[0] + 2);
4551  }
4553  return const_child_range(&BaseAndUpdaterExprs[0],
4554  &BaseAndUpdaterExprs[0] + 2);
4555  }
4556 };
4557 
4558 /// Represents a loop initializing the elements of an array.
4559 ///
4560 /// The need to initialize the elements of an array occurs in a number of
4561 /// contexts:
4562 ///
4563 /// * in the implicit copy/move constructor for a class with an array member
4564 /// * when a lambda-expression captures an array by value
4565 /// * when a decomposition declaration decomposes an array
4566 ///
4567 /// There are two subexpressions: a common expression (the source array)
4568 /// that is evaluated once up-front, and a per-element initializer that
4569 /// runs once for each array element.
4570 ///
4571 /// Within the per-element initializer, the common expression may be referenced
4572 /// via an OpaqueValueExpr, and the current index may be obtained via an
4573 /// ArrayInitIndexExpr.
4574 class ArrayInitLoopExpr : public Expr {
4575  Stmt *SubExprs[2];
4576 
4577  explicit ArrayInitLoopExpr(EmptyShell Empty)
4578  : Expr(ArrayInitLoopExprClass, Empty), SubExprs{} {}
4579 
4580 public:
4581  explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
4582  : Expr(ArrayInitLoopExprClass, T, VK_RValue, OK_Ordinary, false,
4583  CommonInit->isValueDependent() || ElementInit->isValueDependent(),
4584  T->isInstantiationDependentType(),
4585  CommonInit->containsUnexpandedParameterPack() ||
4586  ElementInit->containsUnexpandedParameterPack()),
4587  SubExprs{CommonInit, ElementInit} {}
4588 
4589  /// Get the common subexpression shared by all initializations (the source
4590  /// array).
4592  return cast<OpaqueValueExpr>(SubExprs[0]);
4593  }
4594 
4595  /// Get the initializer to use for each array element.
4596  Expr *getSubExpr() const { return cast<Expr>(SubExprs[1]); }
4597 
4598  llvm::APInt getArraySize() const {
4599  return cast<ConstantArrayType>(getType()->castAsArrayTypeUnsafe())
4600  ->getSize();
4601  }
4602 
4603  static bool classof(const Stmt *S) {
4604  return S->getStmtClass() == ArrayInitLoopExprClass;
4605  }
4606 
4607  SourceLocation getLocStart() const LLVM_READONLY {
4608  return getCommonExpr()->getLocStart();
4609  }
4610  SourceLocation getLocEnd() const LLVM_READONLY {
4611  return getCommonExpr()->getLocEnd();
4612  }
4613 
4615  return child_range(SubExprs, SubExprs + 2);
4616  }
4618  return const_child_range(SubExprs, SubExprs + 2);
4619  }
4620 
4621  friend class ASTReader;
4622  friend class ASTStmtReader;
4623  friend class ASTStmtWriter;
4624 };
4625 
4626 /// Represents the index of the current element of an array being
4627 /// initialized by an ArrayInitLoopExpr. This can only appear within the
4628 /// subexpression of an ArrayInitLoopExpr.
4629 class ArrayInitIndexExpr : public Expr {
4630  explicit ArrayInitIndexExpr(EmptyShell Empty)
4631  : Expr(ArrayInitIndexExprClass, Empty) {}
4632 
4633 public:
4635  : Expr(ArrayInitIndexExprClass, T, VK_RValue, OK_Ordinary,
4636  false, false, false, false) {}
4637 
4638  static bool classof(const Stmt *S) {
4639  return S->getStmtClass() == ArrayInitIndexExprClass;
4640  }
4641 
4642  SourceLocation getLocStart() const LLVM_READONLY { return SourceLocation(); }
4643  SourceLocation getLocEnd() const LLVM_READONLY { return SourceLocation(); }
4644 
4647  }
4650  }
4651 
4652  friend class ASTReader;
4653  friend class ASTStmtReader;
4654 };
4655 
4656 /// Represents an implicitly-generated value initialization of
4657 /// an object of a given type.
4658 ///
4659 /// Implicit value initializations occur within semantic initializer
4660 /// list expressions (InitListExpr) as placeholders for subobject
4661 /// initializations not explicitly specified by the user.
4662 ///
4663 /// \see InitListExpr
4664 class ImplicitValueInitExpr : public Expr {
4665 public:
4667  : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary,
4668  false, false, ty->isInstantiationDependentType(), false) { }
4669 
4670  /// Construct an empty implicit value initialization.
4672  : Expr(ImplicitValueInitExprClass, Empty) { }
4673 
4674  static bool classof(const Stmt *T) {
4675  return T->getStmtClass() == ImplicitValueInitExprClass;
4676  }
4677 
4678  SourceLocation getLocStart() const LLVM_READONLY { return SourceLocation(); }
4679  SourceLocation getLocEnd() const LLVM_READONLY { return SourceLocation(); }
4680 
4681  // Iterators
4684  }
4687  }
4688 };
4689 
4690 class ParenListExpr : public Expr {
4691  Stmt **Exprs;
4692  unsigned NumExprs;
4693  SourceLocation LParenLoc, RParenLoc;
4694 
4695 public:
4696  ParenListExpr(const ASTContext& C, SourceLocation lparenloc,
4697  ArrayRef<Expr*> exprs, SourceLocation rparenloc);
4698 
4699  /// Build an empty paren list.
4700  explicit ParenListExpr(EmptyShell Empty) : Expr(ParenListExprClass, Empty) { }
4701 
4702  unsigned getNumExprs() const { return NumExprs; }
4703 
4704  const Expr* getExpr(unsigned Init) const {
4705  assert(Init < getNumExprs() && "Initializer access out of range!");
4706  return cast_or_null<Expr>(Exprs[Init]);
4707  }
4708 
4709  Expr* getExpr(unsigned Init) {
4710  assert(Init < getNumExprs() && "Initializer access out of range!");
4711  return cast_or_null<Expr>(Exprs[Init]);
4712  }
4713 
4714  Expr **getExprs() { return reinterpret_cast<Expr **>(Exprs); }
4715 
4717  return llvm::makeArrayRef(getExprs(), getNumExprs());
4718  }
4719 
4720  SourceLocation getLParenLoc() const { return LParenLoc; }
4721  SourceLocation getRParenLoc() const { return RParenLoc; }
4722 
4723  SourceLocation getLocStart() const LLVM_READONLY { return LParenLoc; }
4724  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
4725 
4726  static bool classof(const Stmt *T) {
4727  return T->getStmtClass() == ParenListExprClass;
4728  }
4729 
4730  // Iterators
4732  return child_range(&Exprs[0], &Exprs[0]+NumExprs);
4733  }
4735  return const_child_range(&Exprs[0], &Exprs[0] + NumExprs);
4736  }
4737 
4738  friend class ASTStmtReader;
4739  friend class ASTStmtWriter;
4740 };
4741 
4742 /// Represents a C11 generic selection.
4743 ///
4744 /// A generic selection (C11 6.5.1.1) contains an unevaluated controlling
4745 /// expression, followed by one or more generic associations. Each generic
4746 /// association specifies a type name and an expression, or "default" and an
4747 /// expression (in which case it is known as a default generic association).
4748 /// The type and value of the generic selection are identical to those of its
4749 /// result expression, which is defined as the expression in the generic
4750 /// association with a type name that is compatible with the type of the
4751 /// controlling expression, or the expression in the default generic association
4752 /// if no types are compatible. For example:
4753 ///
4754 /// @code
4755 /// _Generic(X, double: 1, float: 2, default: 3)
4756 /// @endcode
4757 ///
4758 /// The above expression evaluates to 1 if 1.0 is substituted for X, 2 if 1.0f
4759 /// or 3 if "hello".
4760 ///
4761 /// As an extension, generic selections are allowed in C++, where the following
4762 /// additional semantics apply:
4763 ///
4764 /// Any generic selection whose controlling expression is type-dependent or
4765 /// which names a dependent type in its association list is result-dependent,
4766 /// which means that the choice of result expression is dependent.
4767 /// Result-dependent generic associations are both type- and value-dependent.
4768 class GenericSelectionExpr : public Expr {
4769  enum { CONTROLLING, END_EXPR };
4770  TypeSourceInfo **AssocTypes;
4771  Stmt **SubExprs;
4772  unsigned NumAssocs, ResultIndex;
4773  SourceLocation GenericLoc, DefaultLoc, RParenLoc;
4774 
4775 public:
4776  GenericSelectionExpr(const ASTContext &Context,
4777  SourceLocation GenericLoc, Expr *ControllingExpr,
4778  ArrayRef<TypeSourceInfo*> AssocTypes,
4779  ArrayRef<Expr*> AssocExprs,
4780  SourceLocation DefaultLoc, SourceLocation RParenLoc,
4781  bool ContainsUnexpandedParameterPack,
4782  unsigned ResultIndex);
4783 
4784  /// This constructor is used in the result-dependent case.
4785  GenericSelectionExpr(const ASTContext &Context,
4786  SourceLocation GenericLoc, Expr *ControllingExpr,
4787  ArrayRef<TypeSourceInfo*> AssocTypes,
4788  ArrayRef<Expr*> AssocExprs,
4789  SourceLocation DefaultLoc, SourceLocation RParenLoc,
4790  bool ContainsUnexpandedParameterPack);
4791 
4793  : Expr(GenericSelectionExprClass, Empty) { }
4794 
4795  unsigned getNumAssocs() const { return NumAssocs; }
4796 
4797  SourceLocation getGenericLoc() const { return GenericLoc; }
4798  SourceLocation getDefaultLoc() const { return DefaultLoc; }
4799  SourceLocation getRParenLoc() const { return RParenLoc; }
4800 
4801  const Expr *getAssocExpr(unsigned i) const {
4802  return cast<Expr>(SubExprs[END_EXPR+i]);
4803  }
4804  Expr *getAssocExpr(unsigned i) { return cast<Expr>(SubExprs[END_EXPR+i]); }
4806  return NumAssocs
4807  ? llvm::makeArrayRef(
4808  &reinterpret_cast<Expr **>(SubExprs)[END_EXPR], NumAssocs)
4809  : None;
4810  }
4811  const TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) const {
4812  return AssocTypes[i];
4813  }
4814  TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) { return AssocTypes[i]; }
4816  return NumAssocs ? llvm::makeArrayRef(&AssocTypes[0], NumAssocs) : None;
4817  }
4818 
4819  QualType getAssocType(unsigned i) const {
4820  if (const TypeSourceInfo *TS = getAssocTypeSourceInfo(i))
4821  return TS->getType();
4822  else
4823  return QualType();
4824  }
4825 
4826  const Expr *getControllingExpr() const {
4827  return cast<Expr>(SubExprs[CONTROLLING]);
4828  }
4829  Expr *getControllingExpr() { return cast<Expr>(SubExprs[CONTROLLING]); }
4830 
4831  /// Whether this generic selection is result-dependent.
4832  bool isResultDependent() const { return ResultIndex == -1U; }
4833 
4834  /// The zero-based index of the result expression's generic association in
4835  /// the generic selection's association list. Defined only if the
4836  /// generic selection is not result-dependent.
4837  unsigned getResultIndex() const {
4838  assert(!isResultDependent() && "Generic selection is result-dependent");
4839  return ResultIndex;
4840  }
4841 
4842  /// The generic selection's result expression. Defined only if the
4843  /// generic selection is not result-dependent.