[clang][AST] Make use of some unused space in Stmt Bitfields

[njames93]

Summary

Some nodes have 4 bytes of free space in their Bitfields, this can be filled with a small field from the actual class instance

[njames93]

Extend more nodes

[njames93]

Fix some failed tests

[njames93]

Extended changes to Stmts

[njames93]

Trunk rebase to fix buildbot

[njames93]

libarcher tests should be fixed now for pre-merge CI failure.

[njames93]

Remove openMP changes.

clang/include/clang/AST/Expr.h

child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
 class FixedPointLiteral : public Expr, public APIntStorage {
-  SourceLocation Loc;
-  unsigned Scale;
-
   /// \brief Construct an empty fixed-point literal.
   explicit FixedPointLiteral(EmptyShell Empty)
       : Expr(FixedPointLiteralClass, Empty) {}
 
  public:
   FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
                     SourceLocation l, unsigned Scale);
 
   // Store the int as is without any bit shifting.
   static FixedPointLiteral *CreateFromRawInt(const ASTContext &C,
                                              const llvm::APInt &V,
                                              QualType type, SourceLocation l,
                                              unsigned Scale);
 
   /// Returns an empty fixed-point literal.
   static FixedPointLiteral *Create(const ASTContext &C, EmptyShell Empty);
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return FixedPointLiteralBits.Loc;
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return FixedPointLiteralBits.Loc;
+  }
 
   /// \brief Retrieve the location of the literal.
-  SourceLocation getLocation() const { return Loc; }
+  SourceLocation getLocation() const { return FixedPointLiteralBits.Loc; }
 
-  void setLocation(SourceLocation Location) { Loc = Location; }
+  void setLocation(SourceLocation Location) {
+    FixedPointLiteralBits.Loc = Location;
+  }
 
-  unsigned getScale() const { return Scale; }
-  void setScale(unsigned S) { Scale = S; }
+  unsigned getScale() const { return FixedPointLiteralBits.Scale; }
+  void setScale(unsigned S) { FixedPointLiteralBits.Scale = S; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == FixedPointLiteralClass;
   }
 
   std::string getValueAsString(unsigned Radix) const;
 
   // Iterators
enum CharacterKind {
     Ascii,
     Wide,
     UTF8,
     UTF16,
     UTF32
   };
 
 private:
-  unsigned Value;
   SourceLocation Loc;
+
 public:
   // type should be IntTy
   CharacterLiteral(unsigned value, CharacterKind kind, QualType type,
                    SourceLocation l)
-      : Expr(CharacterLiteralClass, type, VK_PRValue, OK_Ordinary),
-        Value(value), Loc(l) {
+      : Expr(CharacterLiteralClass, type, VK_PRValue, OK_Ordinary), Loc(l) {
     CharacterLiteralBits.Kind = kind;
+    CharacterLiteralBits.Value = value;
     setDependence(ExprDependence::None);
   }
 
   /// Construct an empty character literal.
   CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }
 
   SourceLocation getLocation() const { return Loc; }
   CharacterKind getKind() const {
     return static_cast<CharacterKind>(CharacterLiteralBits.Kind);
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
   SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
 
-  unsigned getValue() const { return Value; }
+  unsigned getValue() const { return CharacterLiteralBits.Value; }
 
   void setLocation(SourceLocation Location) { Loc = Location; }
   void setKind(CharacterKind kind) { CharacterLiteralBits.Kind = kind; }
-  void setValue(unsigned Val) { Value = Val; }
+  void setValue(unsigned Val) { CharacterLiteralBits.Value = Val; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CharacterLiteralClass;
   }
 
   static void print(unsigned val, CharacterKind Kind, raw_ostream &OS);
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
 class FloatingLiteral : public Expr, private APFloatStorage {
-  SourceLocation Loc;
-
   FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
                   QualType Type, SourceLocation L);
 
   /// Construct an empty floating-point literal.
   explicit FloatingLiteral(const ASTContext &C, EmptyShell Empty);
 
 public:
   static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V,
public:
   bool isExact() const { return FloatingLiteralBits.IsExact; }
   void setExact(bool E) { FloatingLiteralBits.IsExact = E; }
 
   /// getValueAsApproximateDouble - This returns the value as an inaccurate
   /// double.  Note that this may cause loss of precision, but is useful for
   /// debugging dumps, etc.
   double getValueAsApproximateDouble() const;
 
-  SourceLocation getLocation() const { return Loc; }
-  void setLocation(SourceLocation L) { Loc = L; }
+  SourceLocation getLocation() const { return FloatingLiteralBits.Loc; }
+  void setLocation(SourceLocation L) { FloatingLiteralBits.Loc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return FloatingLiteralBits.Loc;
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return FloatingLiteralBits.Loc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == FloatingLiteralClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());

 };
 
 // This represents a use of the __builtin_sycl_unique_stable_name, which takes a
 // type-id, and at CodeGen time emits a unique string representation of the
 // type in a way that permits us to properly encode information about the SYCL
 // kernels.
 class SYCLUniqueStableNameExpr final : public Expr {
   friend class ASTStmtReader;
-  SourceLocation OpLoc, LParen, RParen;
+  SourceLocation LParen, RParen;
   TypeSourceInfo *TypeInfo;
 
   SYCLUniqueStableNameExpr(EmptyShell Empty, QualType ResultTy);
   SYCLUniqueStableNameExpr(SourceLocation OpLoc, SourceLocation LParen,
                            SourceLocation RParen, QualType ResultTy,
                            TypeSourceInfo *TSI);
 
   void setTypeSourceInfo(TypeSourceInfo *Ty) { TypeInfo = Ty; }
 
-  void setLocation(SourceLocation L) { OpLoc = L; }
+  void setLocation(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
   void setLParenLocation(SourceLocation L) { LParen = L; }
   void setRParenLocation(SourceLocation L) { RParen = L; }
 
 public:
   TypeSourceInfo *getTypeSourceInfo() { return TypeInfo; }
 
   const TypeSourceInfo *getTypeSourceInfo() const { return TypeInfo; }
 
   static SYCLUniqueStableNameExpr *
   Create(const ASTContext &Ctx, SourceLocation OpLoc, SourceLocation LParen,
          SourceLocation RParen, TypeSourceInfo *TSI);
 
   static SYCLUniqueStableNameExpr *CreateEmpty(const ASTContext &Ctx);
 
   SourceLocation getBeginLoc() const { return getLocation(); }
   SourceLocation getEndLoc() const { return RParen; }
-  SourceLocation getLocation() const { return OpLoc; }
+  SourceLocation getLocation() const { return ExprWithSourceLocBits.Loc; }
   SourceLocation getLParenLocation() const { return LParen; }
   SourceLocation getRParenLocation() const { return RParen; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SYCLUniqueStableNameExprClass;
   }
 
   // Iterators
public:
   // Get the generated name of the type.  Note that this only works after all
   // kernels have been instantiated.
   static std::string ComputeName(ASTContext &Context, QualType Ty);
 };
 
 /// ParenExpr - This represents a parethesized expression, e.g. "(1)".  This
 /// AST node is only formed if full location information is requested.
 class ParenExpr : public Expr {
-  SourceLocation L, R;
+  SourceLocation R;
   Stmt *Val;
 public:
   ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
       : Expr(ParenExprClass, val->getType(), val->getValueKind(),
              val->getObjectKind()),
-        L(l), R(r), Val(val) {
+        R(r), Val(val) {
+    ExprWithSourceLocBits.Loc = l;
     setDependence(computeDependence(this));
   }
 
   /// Construct an empty parenthesized expression.
   explicit ParenExpr(EmptyShell Empty)
     : Expr(ParenExprClass, Empty) { }
 
   const Expr *getSubExpr() const { return cast<Expr>(Val); }
   Expr *getSubExpr() { return cast<Expr>(Val); }
   void setSubExpr(Expr *E) { Val = E; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return L; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return R; }
 
   /// Get the location of the left parentheses '('.
-  SourceLocation getLParen() const { return L; }
-  void setLParen(SourceLocation Loc) { L = Loc; }
+  SourceLocation getLParen() const { return ExprWithSourceLocBits.Loc; }
+  void setLParen(SourceLocation Loc) { ExprWithSourceLocBits.Loc = Loc; }
 
   /// Get the location of the right parentheses ')'.
   SourceLocation getRParen() const { return R; }
   void setRParen(SourceLocation Loc) { R = Loc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ParenExprClass;
   }

 /// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).
 
 class OffsetOfExpr final
     : public Expr,
       private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
   SourceLocation OperatorLoc, RParenLoc;
   // Base type;
   TypeSourceInfo *TSInfo;
-  // Number of sub-components (i.e. instances of OffsetOfNode).
-  unsigned NumComps;
-  // Number of sub-expressions (i.e. array subscript expressions).
-  unsigned NumExprs;
 
   size_t numTrailingObjects(OverloadToken<OffsetOfNode>) const {
-    return NumComps;
+    return OffsetOfExprBits.NumComps;
   }
 
   OffsetOfExpr(const ASTContext &C, QualType type,
                SourceLocation OperatorLoc, TypeSourceInfo *tsi,
                ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
                SourceLocation RParenLoc);
 
   explicit OffsetOfExpr(unsigned numComps, unsigned numExprs)
-    : Expr(OffsetOfExprClass, EmptyShell()),
-      TSInfo(nullptr), NumComps(numComps), NumExprs(numExprs) {}
+      : Expr(OffsetOfExprClass, EmptyShell()), TSInfo(nullptr) {
+    OffsetOfExprBits.NumComps = numComps;
+    OffsetOfExprBits.NumExprs = numExprs;
+  }
 
 public:
 
   static OffsetOfExpr *Create(const ASTContext &C, QualType type,
                               SourceLocation OperatorLoc, TypeSourceInfo *tsi,
                               ArrayRef<OffsetOfNode> comps,
                               ArrayRef<Expr*> exprs, SourceLocation RParenLoc);
 
public:
   TypeSourceInfo *getTypeSourceInfo() const {
     return TSInfo;
   }
   void setTypeSourceInfo(TypeSourceInfo *tsi) {
     TSInfo = tsi;
   }
 
   const OffsetOfNode &getComponent(unsigned Idx) const {
-    assert(Idx < NumComps && "Subscript out of range");
+    assert(Idx < OffsetOfExprBits.NumComps && "Subscript out of range");
     return getTrailingObjects<OffsetOfNode>()[Idx];
   }
 
   void setComponent(unsigned Idx, OffsetOfNode ON) {
-    assert(Idx < NumComps && "Subscript out of range");
+    assert(Idx < OffsetOfExprBits.NumComps && "Subscript out of range");
     getTrailingObjects<OffsetOfNode>()[Idx] = ON;
   }
 
-  unsigned getNumComponents() const {
-    return NumComps;
-  }
+  unsigned getNumComponents() const { return OffsetOfExprBits.NumComps; }
 
   Expr* getIndexExpr(unsigned Idx) {
-    assert(Idx < NumExprs && "Subscript out of range");
+    assert(Idx < OffsetOfExprBits.NumExprs && "Subscript out of range");
     return getTrailingObjects<Expr *>()[Idx];
   }
 
   const Expr *getIndexExpr(unsigned Idx) const {
-    assert(Idx < NumExprs && "Subscript out of range");
+    assert(Idx < OffsetOfExprBits.NumExprs && "Subscript out of range");
     return getTrailingObjects<Expr *>()[Idx];
   }
 
   void setIndexExpr(unsigned Idx, Expr* E) {
-    assert(Idx < NumComps && "Subscript out of range");
+    assert(Idx < OffsetOfExprBits.NumComps && "Subscript out of range");
     getTrailingObjects<Expr *>()[Idx] = E;
   }
 
-  unsigned getNumExpressions() const {
-    return NumExprs;
-  }
+  unsigned getNumExpressions() const { return OffsetOfExprBits.NumExprs; }
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; }
   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OffsetOfExprClass;
   }
 
   // Iterators
   child_range children() {
     Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
-    return child_range(begin, begin + NumExprs);
+    return child_range(begin, begin + OffsetOfExprBits.NumExprs);
   }
   const_child_range children() const {
     Stmt *const *begin =
         reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
-    return const_child_range(begin, begin + NumExprs);
+    return const_child_range(begin, begin + OffsetOfExprBits.NumExprs);
   }
   friend TrailingObjects;
 };
 
 /// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)
 /// expression operand.  Used for sizeof/alignof (C99 6.5.3.4) and
 /// vec_step (OpenCL 1.1 6.11.12).
 class UnaryExprOrTypeTraitExpr : public Expr {
   union {
     TypeSourceInfo *Ty;
     Stmt *Ex;
   } Argument;
-  SourceLocation OpLoc, RParenLoc;
+  SourceLocation RParenLoc;
 
 public:
   UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo,
                            QualType resultType, SourceLocation op,
                            SourceLocation rp)
       : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_PRValue,
              OK_Ordinary),
-        OpLoc(op), RParenLoc(rp) {
+        RParenLoc(rp) {
     assert(ExprKind <= UETT_Last && "invalid enum value!");
     UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
+    UnaryExprOrTypeTraitExprBits.OpLoc = op;
     assert(static_cast<unsigned>(ExprKind) ==
                UnaryExprOrTypeTraitExprBits.Kind &&
            "UnaryExprOrTypeTraitExprBits.Kind overflow!");
     UnaryExprOrTypeTraitExprBits.IsType = true;
     Argument.Ty = TInfo;
     setDependence(computeDependence(this));
   }
 
public:
   }
 
   /// Gets the argument type, or the type of the argument expression, whichever
   /// is appropriate.
   QualType getTypeOfArgument() const {
     return isArgumentType() ? getArgumentType() : getArgumentExpr()->getType();
   }
 
-  SourceLocation getOperatorLoc() const { return OpLoc; }
-  void setOperatorLoc(SourceLocation L) { OpLoc = L; }
+  SourceLocation getOperatorLoc() const {
+    return UnaryExprOrTypeTraitExprBits.OpLoc;
+  }
+  void setOperatorLoc(SourceLocation L) {
+    UnaryExprOrTypeTraitExprBits.OpLoc = L;
+  }
 
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return OpLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return UnaryExprOrTypeTraitExprBits.OpLoc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == UnaryExprOrTypeTraitExprClass;
   }
 
   // Iterators
   child_range children();
class ArraySubscriptExpr : public Expr {
   bool lhsIsBase() const { return getRHS()->getType()->isIntegerType(); }
 
 public:
   ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, ExprValueKind VK,
                      ExprObjectKind OK, SourceLocation rbracketloc)
       : Expr(ArraySubscriptExprClass, t, VK, OK) {
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = rbracketloc;
+    ExprWithSourceLocBits.Loc = rbracketloc;
     setDependence(computeDependence(this));
   }
 
   /// Create an empty array subscript expression.
   explicit ArraySubscriptExpr(EmptyShell Shell)
     : Expr(ArraySubscriptExprClass, Shell) { }
 
   /// An array access can be written A[4] or 4[A] (both are equivalent).
public:
   Expr *getIdx() { return lhsIsBase() ? getRHS() : getLHS(); }
   const Expr *getIdx() const { return lhsIsBase() ? getRHS() : getLHS(); }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getLHS()->getBeginLoc();
   }
   SourceLocation getEndLoc() const { return getRBracketLoc(); }
 
-  SourceLocation getRBracketLoc() const {
-    return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
-  }
-  void setRBracketLoc(SourceLocation L) {
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
-  }
+  SourceLocation getRBracketLoc() const { return ExprWithSourceLocBits.Loc; }
+  void setRBracketLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
   SourceLocation getExprLoc() const LLVM_READONLY {
     return getBase()->getExprLoc();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ArraySubscriptExprClass;
   }

 public:
   MatrixSubscriptExpr(Expr *Base, Expr *RowIdx, Expr *ColumnIdx, QualType T,
                       SourceLocation RBracketLoc)
       : Expr(MatrixSubscriptExprClass, T, Base->getValueKind(),
              OK_MatrixComponent) {
     SubExprs[BASE] = Base;
     SubExprs[ROW_IDX] = RowIdx;
     SubExprs[COLUMN_IDX] = ColumnIdx;
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = RBracketLoc;
+    ExprWithSourceLocBits.Loc = RBracketLoc;
     setDependence(computeDependence(this));
   }
 
   /// Create an empty matrix subscript expression.
   explicit MatrixSubscriptExpr(EmptyShell Shell)
       : Expr(MatrixSubscriptExprClass, Shell) {}
 
   bool isIncomplete() const {
public:
   }
 
   SourceLocation getEndLoc() const { return getRBracketLoc(); }
 
   SourceLocation getExprLoc() const LLVM_READONLY {
     return getBase()->getExprLoc();
   }
 
-  SourceLocation getRBracketLoc() const {
-    return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
-  }
-  void setRBracketLoc(SourceLocation L) {
-    ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
-  }
+  SourceLocation getRBracketLoc() const { return ExprWithSourceLocBits.Loc; }
+  void setRBracketLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MatrixSubscriptExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
public:
   const_child_range children() const {
     return const_child_range(&Base, &Base + 1);
   }
 };
 
 /// CompoundLiteralExpr - [C99 6.5.2.5]
 ///
 class CompoundLiteralExpr : public Expr {
-  /// LParenLoc - If non-null, this is the location of the left paren in a
-  /// compound literal like "(int){4}".  This can be null if this is a
-  /// synthesized compound expression.
-  SourceLocation LParenLoc;
-
   /// The type as written.  This can be an incomplete array type, in
   /// which case the actual expression type will be different.
   /// The int part of the pair stores whether this expr is file scope.
   llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope;
   Stmt *Init;
 public:
   CompoundLiteralExpr(SourceLocation lparenloc, TypeSourceInfo *tinfo,
                       QualType T, ExprValueKind VK, Expr *init, bool fileScope)
       : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary),
-        LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {
+        TInfoAndScope(tinfo, fileScope), Init(init) {
+    ExprWithSourceLocBits.Loc = lparenloc;
     setDependence(computeDependence(this));
   }
 
   /// Construct an empty compound literal.
   explicit CompoundLiteralExpr(EmptyShell Empty)
     : Expr(CompoundLiteralExprClass, Empty) { }
 
   const Expr *getInitializer() const { return cast<Expr>(Init); }
   Expr *getInitializer() { return cast<Expr>(Init); }
   void setInitializer(Expr *E) { Init = E; }
 
   bool isFileScope() const { return TInfoAndScope.getInt(); }
   void setFileScope(bool FS) { TInfoAndScope.setInt(FS); }
 
-  SourceLocation getLParenLoc() const { return LParenLoc; }
-  void setLParenLoc(SourceLocation L) { LParenLoc = L; }
+  SourceLocation getLParenLoc() const { return ExprWithSourceLocBits.Loc; }
+  void setLParenLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
   TypeSourceInfo *getTypeSourceInfo() const {
     return TInfoAndScope.getPointer();
   }
   void setTypeSourceInfo(TypeSourceInfo *tinfo) {
     TInfoAndScope.setPointer(tinfo);
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     // FIXME: Init should never be null.
     if (!Init)
       return SourceLocation();
-    if (LParenLoc.isInvalid())
+    if (ExprWithSourceLocBits.Loc.isInvalid())
       return Init->getBeginLoc();
-    return LParenLoc;
+    return ExprWithSourceLocBits.Loc;
   }
   SourceLocation getEndLoc() const LLVM_READONLY {
     // FIXME: Init should never be null.
     if (!Init)
       return SourceLocation();
     return Init->getEndLoc();
   }
 
inline size_t BinaryOperator::offsetOfTrailingStorage() const {
   assert(BinaryOperatorBits.HasFPFeatures);
   return isa<CompoundAssignOperator>(this) ? sizeof(CompoundAssignOperator)
                                            : sizeof(BinaryOperator);
 }
 
 /// AbstractConditionalOperator - An abstract base class for
 /// ConditionalOperator and BinaryConditionalOperator.
 class AbstractConditionalOperator : public Expr {
-  SourceLocation QuestionLoc, ColonLoc;
+  SourceLocation ColonLoc;
   friend class ASTStmtReader;
 
 protected:
   AbstractConditionalOperator(StmtClass SC, QualType T, ExprValueKind VK,
                               ExprObjectKind OK, SourceLocation qloc,
                               SourceLocation cloc)
-      : Expr(SC, T, VK, OK), QuestionLoc(qloc), ColonLoc(cloc) {}
+      : Expr(SC, T, VK, OK), ColonLoc(cloc) {
+    ExprWithSourceLocBits.Loc = qloc;
+  }
 
   AbstractConditionalOperator(StmtClass SC, EmptyShell Empty)
     : Expr(SC, Empty) { }
 
 public:
   // getCond - Return the expression representing the condition for
   //   the ?: operator.
   Expr *getCond() const;
 
   // getTrueExpr - Return the subexpression representing the value of
   //   the expression if the condition evaluates to true.
   Expr *getTrueExpr() const;
 
   // getFalseExpr - Return the subexpression representing the value of
   //   the expression if the condition evaluates to false.  This is
   //   the same as getRHS.
   Expr *getFalseExpr() const;
 
-  SourceLocation getQuestionLoc() const { return QuestionLoc; }
+  SourceLocation getQuestionLoc() const { return ExprWithSourceLocBits.Loc; }
   SourceLocation getColonLoc() const { return ColonLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ConditionalOperatorClass ||
            T->getStmtClass() == BinaryConditionalOperatorClass;
   }
 };
 

 inline Expr *AbstractConditionalOperator::getFalseExpr() const {
   if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
     return co->getFalseExpr();
   return cast<BinaryConditionalOperator>(this)->getFalseExpr();
 }
 
 /// AddrLabelExpr - The GNU address of label extension, representing &&label.
 class AddrLabelExpr : public Expr {
-  SourceLocation AmpAmpLoc, LabelLoc;
+  SourceLocation LabelLoc;
   LabelDecl *Label;
 public:
   AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelDecl *L,
                 QualType t)
-      : Expr(AddrLabelExprClass, t, VK_PRValue, OK_Ordinary), AmpAmpLoc(AALoc),
-        LabelLoc(LLoc), Label(L) {
+      : Expr(AddrLabelExprClass, t, VK_PRValue, OK_Ordinary), LabelLoc(LLoc),
+        Label(L) {
+    ExprWithSourceLocBits.Loc = AALoc;
     setDependence(ExprDependence::None);
   }
 
   /// Build an empty address of a label expression.
   explicit AddrLabelExpr(EmptyShell Empty)
     : Expr(AddrLabelExprClass, Empty) { }
 
-  SourceLocation getAmpAmpLoc() const { return AmpAmpLoc; }
-  void setAmpAmpLoc(SourceLocation L) { AmpAmpLoc = L; }
+  SourceLocation getAmpAmpLoc() const { return ExprWithSourceLocBits.Loc; }
+  void setAmpAmpLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
   SourceLocation getLabelLoc() const { return LabelLoc; }
   void setLabelLoc(SourceLocation L) { LabelLoc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AmpAmpLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return LabelLoc; }
 
   LabelDecl *getLabel() const { return Label; }
   void setLabel(LabelDecl *L) { Label = L; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == AddrLabelExprClass;
   }

 class ShuffleVectorExpr : public Expr {
   SourceLocation BuiltinLoc, RParenLoc;
 
   // SubExprs - the list of values passed to the __builtin_shufflevector
   // function. The first two are vectors, and the rest are constant
   // indices.  The number of values in this list is always
   // 2+the number of indices in the vector type.
   Stmt **SubExprs;
-  unsigned NumExprs;
 
 public:
   ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type,
                     SourceLocation BLoc, SourceLocation RP);
 
   /// Build an empty vector-shuffle expression.
   explicit ShuffleVectorExpr(EmptyShell Empty)
     : Expr(ShuffleVectorExprClass, Empty), SubExprs(nullptr) { }
public:
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ShuffleVectorExprClass;
   }
 
   /// getNumSubExprs - Return the size of the SubExprs array.  This includes the
   /// constant expression, the actual arguments passed in, and the function
   /// pointers.
-  unsigned getNumSubExprs() const { return NumExprs; }
+  unsigned getNumSubExprs() const { return ShuffleVectorExprBits.NumExprs; }
 
   /// Retrieve the array of expressions.
   Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
 
   /// getExpr - Return the Expr at the specified index.
   Expr *getExpr(unsigned Index) {
-    assert((Index < NumExprs) && "Arg access out of range!");
+    assert((Index < ShuffleVectorExprBits.NumExprs) &&
+           "Arg access out of range!");
     return cast<Expr>(SubExprs[Index]);
   }
   const Expr *getExpr(unsigned Index) const {
-    assert((Index < NumExprs) && "Arg access out of range!");
+    assert((Index < ShuffleVectorExprBits.NumExprs) &&
+           "Arg access out of range!");
     return cast<Expr>(SubExprs[Index]);
   }
 
   void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);
 
   llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const {
-    assert((N < NumExprs - 2) && "Shuffle idx out of range!");
+    assert((N < ShuffleVectorExprBits.NumExprs - 2) &&
+           "Shuffle idx out of range!");
     return getExpr(N+2)->EvaluateKnownConstInt(Ctx);
   }
 
   // Iterators
   child_range children() {
-    return child_range(&SubExprs[0], &SubExprs[0]+NumExprs);
+    return child_range(&SubExprs[0],
+                       &SubExprs[0] + ShuffleVectorExprBits.NumExprs);
   }
   const_child_range children() const {
-    return const_child_range(&SubExprs[0], &SubExprs[0] + NumExprs);
+    return const_child_range(&SubExprs[0],
+                             &SubExprs[0] + ShuffleVectorExprBits.NumExprs);
   }
 };
 
 /// ConvertVectorExpr - Clang builtin function __builtin_convertvector
 /// This AST node provides support for converting a vector type to another
 /// vector type of the same arity.
 class ConvertVectorExpr : public Expr {
 private:

 /// - the expression returned acts like the chosen subexpression in every
 ///   visible way: the type is the same as that of the chosen subexpression,
 ///   and all predicates (whether it's an l-value, whether it's an integer
 ///   constant expression, etc.) return the same result as for the chosen
 ///   sub-expression.
 class ChooseExpr : public Expr {
   enum { COND, LHS, RHS, END_EXPR };
   Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
-  SourceLocation BuiltinLoc, RParenLoc;
-  bool CondIsTrue;
+  SourceLocation RParenLoc;
+
 public:
   ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t,
              ExprValueKind VK, ExprObjectKind OK, SourceLocation RP,
              bool condIsTrue)
-      : Expr(ChooseExprClass, t, VK, OK), BuiltinLoc(BLoc), RParenLoc(RP),
-        CondIsTrue(condIsTrue) {
+      : Expr(ChooseExprClass, t, VK, OK), RParenLoc(RP) {
+    ChooseExprBits.CondIsTrue = condIsTrue;
+    ChooseExprBits.BuiltinLoc = BLoc;
     SubExprs[COND] = cond;
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
 
     setDependence(computeDependence(this));
   }
 
   /// Build an empty __builtin_choose_expr.
   explicit ChooseExpr(EmptyShell Empty) : Expr(ChooseExprClass, Empty) { }
 
   /// isConditionTrue - Return whether the condition is true (i.e. not
   /// equal to zero).
   bool isConditionTrue() const {
     assert(!isConditionDependent() &&
            "Dependent condition isn't true or false");
-    return CondIsTrue;
+    return ChooseExprBits.CondIsTrue;
   }
-  void setIsConditionTrue(bool isTrue) { CondIsTrue = isTrue; }
+  void setIsConditionTrue(bool isTrue) { ChooseExprBits.CondIsTrue = isTrue; }
 
   bool isConditionDependent() const {
     return getCond()->isTypeDependent() || getCond()->isValueDependent();
   }
 
   /// getChosenSubExpr - Return the subexpression chosen according to the
   /// condition.
   Expr *getChosenSubExpr() const {
     return isConditionTrue() ? getLHS() : getRHS();
   }
 
   Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
   void setCond(Expr *E) { SubExprs[COND] = E; }
   Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
   void setLHS(Expr *E) { SubExprs[LHS] = E; }
   Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
   void setRHS(Expr *E) { SubExprs[RHS] = E; }
 
-  SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
-  void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }
+  SourceLocation getBuiltinLoc() const { return ChooseExprBits.BuiltinLoc; }
+  void setBuiltinLoc(SourceLocation L) { ChooseExprBits.BuiltinLoc = L; }
 
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return BuiltinLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ChooseExprBits.BuiltinLoc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ChooseExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
   }
   const_child_range children() const {
     return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
   }
 };
 
 /// GNUNullExpr - Implements the GNU __null extension, which is a name
 /// for a null pointer constant that has integral type (e.g., int or
 /// long) and is the same size and alignment as a pointer. The __null
 /// extension is typically only used by system headers, which define
 /// NULL as __null in C++ rather than using 0 (which is an integer
 /// that may not match the size of a pointer).
 class GNUNullExpr : public Expr {
   /// TokenLoc - The location of the __null keyword.
-  SourceLocation TokenLoc;
 
 public:
   GNUNullExpr(QualType Ty, SourceLocation Loc)
-      : Expr(GNUNullExprClass, Ty, VK_PRValue, OK_Ordinary), TokenLoc(Loc) {
+      : Expr(GNUNullExprClass, Ty, VK_PRValue, OK_Ordinary) {
+    ExprWithSourceLocBits.Loc = Loc;
     setDependence(ExprDependence::None);
   }
 
   /// Build an empty GNU __null expression.
   explicit GNUNullExpr(EmptyShell Empty) : Expr(GNUNullExprClass, Empty) { }
 
   /// getTokenLocation - The location of the __null token.
-  SourceLocation getTokenLocation() const { return TokenLoc; }
-  void setTokenLocation(SourceLocation L) { TokenLoc = L; }
+  SourceLocation getTokenLocation() const { return ExprWithSourceLocBits.Loc; }
+  void setTokenLocation(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return TokenLoc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return TokenLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GNUNullExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
public:
   const_child_range children() const {
     return const_child_range(&Val, &Val + 1);
   }
 };
 
 /// Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(),
 /// __builtin_FUNCTION(), __builtin_FILE(), or __builtin_source_location().
 class SourceLocExpr final : public Expr {
-  SourceLocation BuiltinLoc, RParenLoc;
+  SourceLocation RParenLoc;
   DeclContext *ParentContext;
 
 public:
   enum IdentKind { Function, File, Line, Column, SourceLocStruct };
 
   SourceLocExpr(const ASTContext &Ctx, IdentKind Type, QualType ResultTy,
                 SourceLocation BLoc, SourceLocation RParenLoc,
                 DeclContext *Context);
bool isIntType() const {
     llvm_unreachable("unknown source location expression kind");
   }
 
   /// If the SourceLocExpr has been resolved return the subexpression
   /// representing the resolved value. Otherwise return null.
   const DeclContext *getParentContext() const { return ParentContext; }
   DeclContext *getParentContext() { return ParentContext; }
 
-  SourceLocation getLocation() const { return BuiltinLoc; }
-  SourceLocation getBeginLoc() const { return BuiltinLoc; }
+  SourceLocation getLocation() const { return SourceLocExprBits.BuiltinLoc; }
+  SourceLocation getBeginLoc() const { return SourceLocExprBits.BuiltinLoc; }
   SourceLocation getEndLoc() const { return RParenLoc; }
 
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(child_iterator(), child_iterator());

 /// form using method getSemanticForm().
 /// Since many initializer lists have the same syntactic and semantic forms,
 /// getSyntacticForm() may return NULL, indicating that the current
 /// semantic initializer list also serves as its syntactic form.
 class InitListExpr : public Expr {
   // FIXME: Eliminate this vector in favor of ASTContext allocation
   typedef ASTVector<Stmt *> InitExprsTy;
   InitExprsTy InitExprs;
-  SourceLocation LBraceLoc, RBraceLoc;
+  SourceLocation RBraceLoc;
 
   /// The alternative form of the initializer list (if it exists).
   /// The int part of the pair stores whether this initializer list is
   /// in semantic form. If not null, the pointer points to:
   ///   - the syntactic form, if this is in semantic form;
   ///   - the semantic form, if this is in syntactic form.
   llvm::PointerIntPair<InitListExpr *, 1, bool> AltForm;
 
void setInitializedFieldInUnion(FieldDecl *FD) {
     ArrayFillerOrUnionFieldInit = FD;
   }
 
   // Explicit InitListExpr's originate from source code (and have valid source
   // locations). Implicit InitListExpr's are created by the semantic analyzer.
   // FIXME: This is wrong; InitListExprs created by semantic analysis have
   // valid source locations too!
   bool isExplicit() const {
-    return LBraceLoc.isValid() && RBraceLoc.isValid();
+    return InitListExprBits.LBraceLoc.isValid() && RBraceLoc.isValid();
   }
 
   // Is this an initializer for an array of characters, initialized by a string
   // literal or an @encode?
   bool isStringLiteralInit() const;
 
   /// Is this a transparent initializer list (that is, an InitListExpr that is
   /// purely syntactic, and whose semantics are that of the sole contained
   /// initializer)?
   bool isTransparent() const;
 
   /// Is this the zero initializer {0} in a language which considers it
   /// idiomatic?
   bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const;
 
-  SourceLocation getLBraceLoc() const { return LBraceLoc; }
-  void setLBraceLoc(SourceLocation Loc) { LBraceLoc = Loc; }
+  SourceLocation getLBraceLoc() const { return InitListExprBits.LBraceLoc; }
+  void setLBraceLoc(SourceLocation Loc) { InitListExprBits.LBraceLoc = Loc; }
   SourceLocation getRBraceLoc() const { return RBraceLoc; }
   void setRBraceLoc(SourceLocation Loc) { RBraceLoc = Loc; }
 
   bool isSemanticForm() const { return AltForm.getInt(); }
   InitListExpr *getSemanticForm() const {
     return isSemanticForm() ? nullptr : AltForm.getPointer();
   }
   bool isSyntacticForm() const {
public:
   /// Forward declaration of the Designator class.
   class Designator;
 
 private:
   /// The location of the '=' or ':' prior to the actual initializer
   /// expression.
   SourceLocation EqualOrColonLoc;
 
-  /// Whether this designated initializer used the GNU deprecated
-  /// syntax rather than the C99 '=' syntax.
-  unsigned GNUSyntax : 1;
-
-  /// The number of designators in this initializer expression.
-  unsigned NumDesignators : 15;
-
-  /// The number of subexpressions of this initializer expression,
-  /// which contains both the initializer and any additional
-  /// expressions used by array and array-range designators.
-  unsigned NumSubExprs : 16;
-
   /// The designators in this designated initialization
   /// expression.
   Designator *Designators;
 
   DesignatedInitExpr(const ASTContext &C, QualType Ty,
                      llvm::ArrayRef<Designator> Designators,
                      SourceLocation EqualOrColonLoc, bool GNUSyntax,
                      ArrayRef<Expr *> IndexExprs, Expr *Init);
 
   explicit DesignatedInitExpr(unsigned NumSubExprs)
-    : Expr(DesignatedInitExprClass, EmptyShell()),
-      NumDesignators(0), NumSubExprs(NumSubExprs), Designators(nullptr) { }
+      : Expr(DesignatedInitExprClass, EmptyShell()), Designators(nullptr) {
+    DesignatedInitExprBits.NumDesignators = 0;
+    DesignatedInitExprBits.NumSubExprs = NumSubExprs;
+  }
 
 public:
   /// A field designator, e.g., ".x".
   struct FieldDesignator {
     /// Refers to the field that is being initialized. The low bit
     /// of this field determines whether this is actually a pointer
     /// to an IdentifierInfo (if 1) or a FieldDecl (if 0). When
     /// initially constructed, a field designator will store an
static DesignatedInitExpr *Create(const ASTContext &C,
                                     ArrayRef<Expr*> IndexExprs,
                                     SourceLocation EqualOrColonLoc,
                                     bool GNUSyntax, Expr *Init);
 
   static DesignatedInitExpr *CreateEmpty(const ASTContext &C,
                                          unsigned NumIndexExprs);
 
   /// Returns the number of designators in this initializer.
-  unsigned size() const { return NumDesignators; }
+  unsigned size() const { return DesignatedInitExprBits.NumDesignators; }
 
   // Iterator access to the designators.
   llvm::MutableArrayRef<Designator> designators() {
-    return {Designators, NumDesignators};
+    return {Designators, DesignatedInitExprBits.NumDesignators};
   }
 
   llvm::ArrayRef<Designator> designators() const {
-    return {Designators, NumDesignators};
+    return {Designators, DesignatedInitExprBits.NumDesignators};
   }
 
   Designator *getDesignator(unsigned Idx) { return &designators()[Idx]; }
   const Designator *getDesignator(unsigned Idx) const {
     return &designators()[Idx];
   }
 
   void setDesignators(const ASTContext &C, const Designator *Desigs,
public:
   void setEqualOrColonLoc(SourceLocation L) { EqualOrColonLoc = L; }
 
   /// Whether this designated initializer should result in direct-initialization
   /// of the designated subobject (eg, '{.foo{1, 2, 3}}').
   bool isDirectInit() const { return EqualOrColonLoc.isInvalid(); }
 
   /// Determines whether this designated initializer used the
   /// deprecated GNU syntax for designated initializers.
-  bool usesGNUSyntax() const { return GNUSyntax; }
-  void setGNUSyntax(bool GNU) { GNUSyntax = GNU; }
+  bool usesGNUSyntax() const { return DesignatedInitExprBits.GNUSyntax; }
+  void setGNUSyntax(bool GNU) { DesignatedInitExprBits.GNUSyntax = GNU; }
 
   /// Retrieve the initializer value.
   Expr *getInit() const {
     return cast<Expr>(*const_cast<DesignatedInitExpr*>(this)->child_begin());
   }
 
   void setInit(Expr *init) {
     *child_begin() = init;
   }
 
   /// Retrieve the total number of subexpressions in this
   /// designated initializer expression, including the actual
   /// initialized value and any expressions that occur within array
   /// and array-range designators.
-  unsigned getNumSubExprs() const { return NumSubExprs; }
+  unsigned getNumSubExprs() const { return DesignatedInitExprBits.NumSubExprs; }
 
   Expr *getSubExpr(unsigned Idx) const {
-    assert(Idx < NumSubExprs && "Subscript out of range");
+    assert(Idx < DesignatedInitExprBits.NumSubExprs &&
+           "Subscript out of range");
     return cast<Expr>(getTrailingObjects<Stmt *>()[Idx]);
   }
 
   void setSubExpr(unsigned Idx, Expr *E) {
-    assert(Idx < NumSubExprs && "Subscript out of range");
+    assert(Idx < DesignatedInitExprBits.NumSubExprs &&
+           "Subscript out of range");
     getTrailingObjects<Stmt *>()[Idx] = E;
   }
 
   /// Replaces the designator at index @p Idx with the series
   /// of designators in [First, Last).
   void ExpandDesignator(const ASTContext &C, unsigned Idx,
                         const Designator *First, const Designator *Last);
 
   SourceRange getDesignatorsSourceRange() const;
 
   SourceLocation getBeginLoc() const LLVM_READONLY;
   SourceLocation getEndLoc() const LLVM_READONLY;
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == DesignatedInitExprClass;
   }
 
   // Iterators
   child_range children() {
     Stmt **begin = getTrailingObjects<Stmt *>();
-    return child_range(begin, begin + NumSubExprs);
+    return child_range(begin, begin + DesignatedInitExprBits.NumSubExprs);
   }
   const_child_range children() const {
     Stmt * const *begin = getTrailingObjects<Stmt *>();
-    return const_child_range(begin, begin + NumSubExprs);
+    return const_child_range(begin, begin + DesignatedInitExprBits.NumSubExprs);
   }
 
   friend TrailingObjects;
 };
 
 /// Represents a place-holder for an object not to be initialized by
 /// anything.
 ///
ConstAssociationIterator Begin(getTrailingObjects<Stmt *>() +
                                        AssocExprStartIndex,
                                    getTrailingObjects<TypeSourceInfo *>(),
                                    /*Offset=*/0, ResultIndex);
     ConstAssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
                                  /*Offset=*/NumAssocs, ResultIndex);
     return llvm::make_range(Begin, End);
   }
 
-  SourceLocation getGenericLoc() const {
-    return GenericSelectionExprBits.GenericLoc;
-  }
+  SourceLocation getGenericLoc() const { return ExprWithSourceLocBits.Loc; }
   SourceLocation getDefaultLoc() const { return DefaultLoc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   SourceLocation getBeginLoc() const { return getGenericLoc(); }
   SourceLocation getEndLoc() const { return getRParenLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GenericSelectionExprClass;
   }

 /// the following is legal:  "V.xy = V.zw" if V is a 4 element extended vector.
 ///
 /// Note that the base may have either vector or pointer to vector type, just
 /// like a struct field reference.
 ///
 class ExtVectorElementExpr : public Expr {
   Stmt *Base;
   IdentifierInfo *Accessor;
-  SourceLocation AccessorLoc;
+
 public:
   ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base,
                        IdentifierInfo &accessor, SourceLocation loc)
       : Expr(ExtVectorElementExprClass, ty, VK,
              (VK == VK_PRValue ? OK_Ordinary : OK_VectorComponent)),
-        Base(base), Accessor(&accessor), AccessorLoc(loc) {
+        Base(base), Accessor(&accessor) {
+    ExprWithSourceLocBits.Loc = loc;
     setDependence(computeDependence(this));
   }
 
   /// Build an empty vector element expression.
   explicit ExtVectorElementExpr(EmptyShell Empty)
     : Expr(ExtVectorElementExprClass, Empty) { }
 
   const Expr *getBase() const { return cast<Expr>(Base); }
   Expr *getBase() { return cast<Expr>(Base); }
   void setBase(Expr *E) { Base = E; }
 
   IdentifierInfo &getAccessor() const { return *Accessor; }
   void setAccessor(IdentifierInfo *II) { Accessor = II; }
 
-  SourceLocation getAccessorLoc() const { return AccessorLoc; }
-  void setAccessorLoc(SourceLocation L) { AccessorLoc = L; }
+  SourceLocation getAccessorLoc() const { return ExprWithSourceLocBits.Loc; }
+  void setAccessorLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
   /// getNumElements - Get the number of components being selected.
   unsigned getNumElements() const;
 
   /// containsDuplicateElements - Return true if any element access is
   /// repeated.
   bool containsDuplicateElements() const;
 
   /// getEncodedElementAccess - Encode the elements accessed into an llvm
   /// aggregate Constant of ConstantInt(s).
   void getEncodedElementAccess(SmallVectorImpl<uint32_t> &Elts) const;
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getBase()->getBeginLoc();
   }
-  SourceLocation getEndLoc() const LLVM_READONLY { return AccessorLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
 
   /// isArrow - Return true if the base expression is a pointer to vector,
   /// return false if the base expression is a vector.
   bool isArrow() const;
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ExtVectorElementExprClass;
   }
#include "clang/Basic/Builtins.def"
   };
 
 private:
   /// Location of sub-expressions.
   /// The location of Scope sub-expression is NumSubExprs - 1, which is
   /// not fixed, therefore is not defined in enum.
   enum { PTR, ORDER, VAL1, ORDER_FAIL, VAL2, WEAK, END_EXPR };
   Stmt *SubExprs[END_EXPR + 1];
-  unsigned NumSubExprs;
   SourceLocation BuiltinLoc, RParenLoc;
-  AtomicOp Op;
 
   friend class ASTStmtReader;
 public:
   AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, QualType t,
              AtomicOp op, SourceLocation RP);
 
   /// Determine the number of arguments the specified atomic builtin
   /// should have.
   static unsigned getNumSubExprs(AtomicOp Op);
 
   /// Build an empty AtomicExpr.
   explicit AtomicExpr(EmptyShell Empty) : Expr(AtomicExprClass, Empty) { }
 
   Expr *getPtr() const {
     return cast<Expr>(SubExprs[PTR]);
   }
   Expr *getOrder() const {
     return cast<Expr>(SubExprs[ORDER]);
   }
   Expr *getScope() const {
     assert(getScopeModel() && "No scope");
-    return cast<Expr>(SubExprs[NumSubExprs - 1]);
+    return cast<Expr>(SubExprs[AtomicExprBits.NumSubExprs - 1]);
   }
   Expr *getVal1() const {
-    if (Op == AO__c11_atomic_init || Op == AO__opencl_atomic_init)
+    if (AtomicExprBits.Op == AO__c11_atomic_init ||
+        AtomicExprBits.Op == AO__opencl_atomic_init)
       return cast<Expr>(SubExprs[ORDER]);
-    assert(NumSubExprs > VAL1);
+    assert(AtomicExprBits.NumSubExprs > VAL1);
     return cast<Expr>(SubExprs[VAL1]);
   }
   Expr *getOrderFail() const {
-    assert(NumSubExprs > ORDER_FAIL);
+    assert(AtomicExprBits.NumSubExprs > ORDER_FAIL);
     return cast<Expr>(SubExprs[ORDER_FAIL]);
   }
   Expr *getVal2() const {
-    if (Op == AO__atomic_exchange)
+    if (AtomicExprBits.Op == AO__atomic_exchange)
       return cast<Expr>(SubExprs[ORDER_FAIL]);
-    assert(NumSubExprs > VAL2);
+    assert(AtomicExprBits.NumSubExprs > VAL2);
     return cast<Expr>(SubExprs[VAL2]);
   }
   Expr *getWeak() const {
-    assert(NumSubExprs > WEAK);
+    assert(AtomicExprBits.NumSubExprs > WEAK);
     return cast<Expr>(SubExprs[WEAK]);
   }
   QualType getValueType() const;
 
-  AtomicOp getOp() const { return Op; }
-  unsigned getNumSubExprs() const { return NumSubExprs; }
+  AtomicOp getOp() const { return static_cast<AtomicOp>(AtomicExprBits.Op); }
+  unsigned getNumSubExprs() const { return AtomicExprBits.NumSubExprs; }
 
   Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
   const Expr * const *getSubExprs() const {
     return reinterpret_cast<Expr * const *>(SubExprs);
   }
 
   bool isVolatile() const {
     return getPtr()->getType()->getPointeeType().isVolatileQualified();
public:
   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == AtomicExprClass;
   }
 
   // Iterators
   child_range children() {
-    return child_range(SubExprs, SubExprs+NumSubExprs);
+    return child_range(SubExprs, SubExprs + AtomicExprBits.NumSubExprs);
   }
   const_child_range children() const {
-    return const_child_range(SubExprs, SubExprs + NumSubExprs);
+    return const_child_range(SubExprs, SubExprs + AtomicExprBits.NumSubExprs);
   }
 
   /// Get atomic scope model for the atomic op code.
   /// \return empty atomic scope model if the atomic op code does not have
   ///   scope operand.
   static std::unique_ptr<AtomicScopeModel> getScopeModel(AtomicOp Op) {
     auto Kind =
         (Op >= AO__opencl_atomic_load && Op <= AO__opencl_atomic_fetch_max)
public:
   std::unique_ptr<AtomicScopeModel> getScopeModel() const {
     return getScopeModel(getOp());
   }
 };
 
 /// TypoExpr - Internal placeholder for expressions where typo correction
 /// still needs to be performed and/or an error diagnostic emitted.
 class TypoExpr : public Expr {
-  // The location for the typo name.
-  SourceLocation TypoLoc;
-
 public:
   TypoExpr(QualType T, SourceLocation TypoLoc)
-      : Expr(TypoExprClass, T, VK_LValue, OK_Ordinary), TypoLoc(TypoLoc) {
+      : Expr(TypoExprClass, T, VK_LValue, OK_Ordinary) {
+    ExprWithSourceLocBits.Loc = TypoLoc;
     assert(T->isDependentType() && "TypoExpr given a non-dependent type");
     setDependence(ExprDependence::TypeValueInstantiation |
                   ExprDependence::Error);
   }
 
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return TypoLoc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return TypoLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == TypoExprClass;
   }
-
 };
 
 /// Frontend produces RecoveryExprs on semantic errors that prevent creating
 /// other well-formed expressions. E.g. when type-checking of a binary operator
 /// fails, we cannot produce a BinaryOperator expression. Instead, we can choose
 /// to produce a recovery expression storing left and right operands.
 ///
 /// RecoveryExpr does not have any semantic meaning in C++, it is only useful to

 public:
   static RecoveryExpr *Create(ASTContext &Ctx, QualType T,
                               SourceLocation BeginLoc, SourceLocation EndLoc,
                               ArrayRef<Expr *> SubExprs);
   static RecoveryExpr *CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs);
 
   ArrayRef<Expr *> subExpressions() {
     auto *B = getTrailingObjects<Expr *>();
-    return llvm::makeArrayRef(B, B + NumExprs);
+    return llvm::makeArrayRef(B, B + RecoveryExprBits.NumExprs);
   }
 
   ArrayRef<const Expr *> subExpressions() const {
     return const_cast<RecoveryExpr *>(this)->subExpressions();
   }
 
   child_range children() {
     Stmt **B = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
-    return child_range(B, B + NumExprs);
+    return child_range(B, B + RecoveryExprBits.NumExprs);
   }
 
-  SourceLocation getBeginLoc() const { return BeginLoc; }
+  SourceLocation getBeginLoc() const { return RecoveryExprBits.BeginLoc; }
   SourceLocation getEndLoc() const { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == RecoveryExprClass;
   }
 
 private:
   RecoveryExpr(ASTContext &Ctx, QualType T, SourceLocation BeginLoc,
                SourceLocation EndLoc, ArrayRef<Expr *> SubExprs);
   RecoveryExpr(EmptyShell Empty, unsigned NumSubExprs)
-      : Expr(RecoveryExprClass, Empty), NumExprs(NumSubExprs) {}
+      : Expr(RecoveryExprClass, Empty) {
+    RecoveryExprBits.NumExprs = NumSubExprs;
+  }
 
-  size_t numTrailingObjects(OverloadToken<Stmt *>) const { return NumExprs; }
+  size_t numTrailingObjects(OverloadToken<Stmt *>) const {
+    return RecoveryExprBits.NumExprs;
+  }
 
-  SourceLocation BeginLoc, EndLoc;
-  unsigned NumExprs;
+  SourceLocation EndLoc;
   friend TrailingObjects;
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_EXPR_H

clang/include/clang/AST/ExprCXX.h

 
 /// The null pointer literal (C++11 [lex.nullptr])
 ///
 /// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
 class CXXNullPtrLiteralExpr : public Expr {
 public:
   CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)
       : Expr(CXXNullPtrLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
-    CXXNullPtrLiteralExprBits.Loc = Loc;
+    ExprWithSourceLocBits.Loc = Loc;
     setDependence(ExprDependence::None);
   }
 
   explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
       : Expr(CXXNullPtrLiteralExprClass, Empty) {}
 
   SourceLocation getBeginLoc() const { return getLocation(); }
   SourceLocation getEndLoc() const { return getLocation(); }
 
-  SourceLocation getLocation() const { return CXXNullPtrLiteralExprBits.Loc; }
-  void setLocation(SourceLocation L) { CXXNullPtrLiteralExprBits.Loc = L; }
+  SourceLocation getLocation() const { return ExprWithSourceLocBits.Loc; }
+  void setLocation(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXNullPtrLiteralExprClass;
   }
 
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }

 /// A member reference to an MSPropertyDecl.
 ///
 /// This expression always has pseudo-object type, and therefore it is
 /// typically not encountered in a fully-typechecked expression except
 /// within the syntactic form of a PseudoObjectExpr.
 class MSPropertyRefExpr : public Expr {
   Expr *BaseExpr;
   MSPropertyDecl *TheDecl;
-  SourceLocation MemberLoc;
-  bool IsArrow;
   NestedNameSpecifierLoc QualifierLoc;
 
 public:
   friend class ASTStmtReader;
 
   MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow,
                     QualType ty, ExprValueKind VK,
                     NestedNameSpecifierLoc qualifierLoc, SourceLocation nameLoc)
       : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary), BaseExpr(baseExpr),
-        TheDecl(decl), MemberLoc(nameLoc), IsArrow(isArrow),
-        QualifierLoc(qualifierLoc) {
+        TheDecl(decl), QualifierLoc(qualifierLoc) {
+    MSPropertyRefExprBits.IsArrow = isArrow;
+    MSPropertyRefExprBits.MemberLoc = nameLoc;
     setDependence(computeDependence(this));
   }
 
   MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {}
 
   SourceRange getSourceRange() const LLVM_READONLY {
     return SourceRange(getBeginLoc(), getEndLoc());
   }
 
   bool isImplicitAccess() const {
     return getBaseExpr() && getBaseExpr()->isImplicitCXXThis();
   }
 
   SourceLocation getBeginLoc() const {
     if (!isImplicitAccess())
       return BaseExpr->getBeginLoc();
     else if (QualifierLoc)
       return QualifierLoc.getBeginLoc();
     else
-        return MemberLoc;
+      return MSPropertyRefExprBits.MemberLoc;
   }
 
   SourceLocation getEndLoc() const { return getMemberLoc(); }
 
   child_range children() {
     return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1);
   }
 
   const_child_range children() const {
     auto Children = const_cast<MSPropertyRefExpr *>(this)->children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MSPropertyRefExprClass;
   }
 
   Expr *getBaseExpr() const { return BaseExpr; }
   MSPropertyDecl *getPropertyDecl() const { return TheDecl; }
-  bool isArrow() const { return IsArrow; }
-  SourceLocation getMemberLoc() const { return MemberLoc; }
+  bool isArrow() const { return MSPropertyRefExprBits.IsArrow; }
+  SourceLocation getMemberLoc() const {
+    return MSPropertyRefExprBits.MemberLoc;
+  }
   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
 };
 
 /// MS property subscript expression.
 /// MSVC supports 'property' attribute and allows to apply it to the
 /// declaration of an empty array in a class or structure definition.
 /// For example:
 /// \code
 /// __declspec(property(get=GetX, put=PutX)) int x[];
 /// \endcode
 /// The above statement indicates that x[] can be used with one or more array
 /// indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b), and
 /// p->x[a][b] = i will be turned into p->PutX(a, b, i).
 /// This is a syntactic pseudo-object expression.
 class MSPropertySubscriptExpr : public Expr {
   friend class ASTStmtReader;
 
   enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };
 
   Stmt *SubExprs[NUM_SUBEXPRS];
-  SourceLocation RBracketLoc;
 
   void setBase(Expr *Base) { SubExprs[BASE_EXPR] = Base; }
   void setIdx(Expr *Idx) { SubExprs[IDX_EXPR] = Idx; }
 
 public:
   MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK,
                           ExprObjectKind OK, SourceLocation RBracketLoc)
-      : Expr(MSPropertySubscriptExprClass, Ty, VK, OK),
-        RBracketLoc(RBracketLoc) {
+      : Expr(MSPropertySubscriptExprClass, Ty, VK, OK) {
+    ExprWithSourceLocBits.Loc = RBracketLoc;
     SubExprs[BASE_EXPR] = Base;
     SubExprs[IDX_EXPR] = Idx;
     setDependence(computeDependence(this));
   }
 
   /// Create an empty array subscript expression.
   explicit MSPropertySubscriptExpr(EmptyShell Shell)
       : Expr(MSPropertySubscriptExprClass, Shell) {}
 
   Expr *getBase() { return cast<Expr>(SubExprs[BASE_EXPR]); }
   const Expr *getBase() const { return cast<Expr>(SubExprs[BASE_EXPR]); }
 
   Expr *getIdx() { return cast<Expr>(SubExprs[IDX_EXPR]); }
   const Expr *getIdx() const { return cast<Expr>(SubExprs[IDX_EXPR]); }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getBase()->getBeginLoc();
   }
 
-  SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
 
-  SourceLocation getRBracketLoc() const { return RBracketLoc; }
-  void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
+  SourceLocation getRBracketLoc() const { return ExprWithSourceLocBits.Loc; }
+  void setRBracketLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
   SourceLocation getExprLoc() const LLVM_READONLY {
     return getBase()->getExprLoc();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MSPropertySubscriptExprClass;
   }
CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
                     DeclContext *UsedContext)
       : Expr(SC,
              Param->hasUnparsedDefaultArg()
                  ? Param->getType().getNonReferenceType()
                  : Param->getDefaultArg()->getType(),
              Param->getDefaultArg()->getValueKind(),
              Param->getDefaultArg()->getObjectKind()),
         Param(Param), UsedContext(UsedContext) {
-    CXXDefaultArgExprBits.Loc = Loc;
+    ExprWithSourceLocBits.Loc = Loc;
     setDependence(computeDependence(this));
   }
 
 public:
   CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
 
   // \p Param is the parameter whose default argument is used by this
   // expression.
public:
   // Retrieve the actual argument to the function call.
   const Expr *getExpr() const { return getParam()->getDefaultArg(); }
   Expr *getExpr() { return getParam()->getDefaultArg(); }
 
   const DeclContext *getUsedContext() const { return UsedContext; }
   DeclContext *getUsedContext() { return UsedContext; }
 
   /// Retrieve the location where this default argument was actually used.
-  SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; }
+  SourceLocation getUsedLocation() const { return ExprWithSourceLocBits.Loc; }
 
   /// Default argument expressions have no representation in the
   /// source, so they have an empty source range.
   SourceLocation getBeginLoc() const { return SourceLocation(); }
   SourceLocation getEndLoc() const { return SourceLocation(); }
 
   SourceLocation getExprLoc() const { return getUsedLocation(); }
 
public:
 
   const DeclContext *getUsedContext() const { return UsedContext; }
   DeclContext *getUsedContext() { return UsedContext; }
 
   /// Retrieve the location where this default initializer expression was
   /// actually used.
   SourceLocation getUsedLocation() const { return getBeginLoc(); }
 
-  SourceLocation getBeginLoc() const { return CXXDefaultInitExprBits.Loc; }
-  SourceLocation getEndLoc() const { return CXXDefaultInitExprBits.Loc; }
+  SourceLocation getBeginLoc() const { return ExprWithSourceLocBits.Loc; }
+  SourceLocation getEndLoc() const { return ExprWithSourceLocBits.Loc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXDefaultInitExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());

 /// Represents a call to an inherited base class constructor from an
 /// inheriting constructor. This call implicitly forwards the arguments from
 /// the enclosing context (an inheriting constructor) to the specified inherited
 /// base class constructor.
 class CXXInheritedCtorInitExpr : public Expr {
 private:
   CXXConstructorDecl *Constructor = nullptr;
 
-  /// The location of the using declaration.
-  SourceLocation Loc;
-
-  /// Whether this is the construction of a virtual base.
-  unsigned ConstructsVirtualBase : 1;
-
-  /// Whether the constructor is inherited from a virtual base class of the
-  /// class that we construct.
-  unsigned InheritedFromVirtualBase : 1;
-
 public:
   friend class ASTStmtReader;
 
   /// Construct a C++ inheriting construction expression.
   CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T,
                            CXXConstructorDecl *Ctor, bool ConstructsVirtualBase,
                            bool InheritedFromVirtualBase)
       : Expr(CXXInheritedCtorInitExprClass, T, VK_PRValue, OK_Ordinary),
-        Constructor(Ctor), Loc(Loc),
-        ConstructsVirtualBase(ConstructsVirtualBase),
-        InheritedFromVirtualBase(InheritedFromVirtualBase) {
+        Constructor(Ctor) {
+    CXXInheritedCtorInitExprBits.Loc = Loc;
+    CXXInheritedCtorInitExprBits.ConstructsVirtualBase = ConstructsVirtualBase;
+    CXXInheritedCtorInitExprBits.InheritedFromVirtualBase =
+        InheritedFromVirtualBase;
     assert(!T->isDependentType());
     setDependence(ExprDependence::None);
   }
 
   /// Construct an empty C++ inheriting construction expression.
   explicit CXXInheritedCtorInitExpr(EmptyShell Empty)
-      : Expr(CXXInheritedCtorInitExprClass, Empty),
-        ConstructsVirtualBase(false), InheritedFromVirtualBase(false) {}
+      : Expr(CXXInheritedCtorInitExprClass, Empty) {
+    CXXInheritedCtorInitExprBits.ConstructsVirtualBase = false;
+    CXXInheritedCtorInitExprBits.InheritedFromVirtualBase = false;
+  }
 
   /// Get the constructor that this expression will call.
   CXXConstructorDecl *getConstructor() const { return Constructor; }
 
   /// Determine whether this constructor is actually constructing
   /// a base class (rather than a complete object).
-  bool constructsVBase() const { return ConstructsVirtualBase; }
+  bool constructsVBase() const {
+    return CXXInheritedCtorInitExprBits.ConstructsVirtualBase;
+  }
   CXXConstructExpr::ConstructionKind getConstructionKind() const {
-    return ConstructsVirtualBase ? CXXConstructExpr::CK_VirtualBase
-                                 : CXXConstructExpr::CK_NonVirtualBase;
+    return CXXInheritedCtorInitExprBits.ConstructsVirtualBase
+               ? CXXConstructExpr::CK_VirtualBase
   }
 
   /// Determine whether the inherited constructor is inherited from a
   /// virtual base of the object we construct. If so, we are not responsible
   /// for calling the inherited constructor (the complete object constructor
   /// does that), and so we don't need to pass any arguments.
-  bool inheritedFromVBase() const { return InheritedFromVirtualBase; }
+  bool inheritedFromVBase() const {
+    return CXXInheritedCtorInitExprBits.InheritedFromVirtualBase;
+  }
 
-  SourceLocation getLocation() const LLVM_READONLY { return Loc; }
-  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
+  SourceLocation getLocation() const LLVM_READONLY {
+    return CXXInheritedCtorInitExprBits.Loc;
+  }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return CXXInheritedCtorInitExprBits.Loc;
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return CXXInheritedCtorInitExprBits.Loc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXInheritedCtorInitExprClass;
   }
 
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }

 
 public:
   /// Create an explicitly-written scalar-value initialization
   /// expression.
   CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo,
                          SourceLocation RParenLoc)
       : Expr(CXXScalarValueInitExprClass, Type, VK_PRValue, OK_Ordinary),
         TypeInfo(TypeInfo) {
-    CXXScalarValueInitExprBits.RParenLoc = RParenLoc;
+    ExprWithSourceLocBits.Loc = RParenLoc;
     setDependence(computeDependence(this));
   }
 
   explicit CXXScalarValueInitExpr(EmptyShell Shell)
       : Expr(CXXScalarValueInitExprClass, Shell) {}
 
   TypeSourceInfo *getTypeSourceInfo() const {
     return TypeInfo;
   }
 
-  SourceLocation getRParenLoc() const {
-    return CXXScalarValueInitExprBits.RParenLoc;
-  }
+  SourceLocation getRParenLoc() const { return ExprWithSourceLocBits.Loc; }
 
   SourceLocation getBeginLoc() const LLVM_READONLY;
   SourceLocation getEndLoc() const { return getRParenLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXScalarValueInitExprClass;
   }
 

 /// for scalar types. A pseudo-destructor expression has no run-time semantics
 /// beyond evaluating the base expression.
 class CXXPseudoDestructorExpr : public Expr {
   friend class ASTStmtReader;
 
   /// The base expression (that is being destroyed).
   Stmt *Base = nullptr;
 
-  /// Whether the operator was an arrow ('->'); otherwise, it was a
-  /// period ('.').
-  bool IsArrow : 1;
-
-  /// The location of the '.' or '->' operator.
-  SourceLocation OperatorLoc;
-
   /// The nested-name-specifier that follows the operator, if present.
   NestedNameSpecifierLoc QualifierLoc;
 
   /// The type that precedes the '::' in a qualified pseudo-destructor
   /// expression.
   TypeSourceInfo *ScopeType = nullptr;
 
   /// The location of the '::' in a qualified pseudo-destructor
CXXPseudoDestructorExpr(const ASTContext &Context,
                           Expr *Base, bool isArrow, SourceLocation OperatorLoc,
                           NestedNameSpecifierLoc QualifierLoc,
                           TypeSourceInfo *ScopeType,
                           SourceLocation ColonColonLoc,
                           SourceLocation TildeLoc,
                           PseudoDestructorTypeStorage DestroyedType);
 
   explicit CXXPseudoDestructorExpr(EmptyShell Shell)
-      : Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(false) {}
+      : Expr(CXXPseudoDestructorExprClass, Shell) {
+    CXXPseudoDestructorExprBits.IsArrow = false;
+  }
 
   Expr *getBase() const { return cast<Expr>(Base); }
 
   /// Determines whether this member expression actually had
   /// a C++ nested-name-specifier prior to the name of the member, e.g.,
   /// x->Base::foo.
   bool hasQualifier() const { return QualifierLoc.hasQualifier(); }
 
   /// Retrieves the nested-name-specifier that qualifies the type name,
   /// with source-location information.
   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
 
   /// If the member name was qualified, retrieves the
   /// nested-name-specifier that precedes the member name. Otherwise, returns
   /// null.
   NestedNameSpecifier *getQualifier() const {
     return QualifierLoc.getNestedNameSpecifier();
   }
 
   /// Determine whether this pseudo-destructor expression was written
   /// using an '->' (otherwise, it used a '.').
-  bool isArrow() const { return IsArrow; }
+  bool isArrow() const { return CXXPseudoDestructorExprBits.IsArrow; }
 
   /// Retrieve the location of the '.' or '->' operator.
-  SourceLocation getOperatorLoc() const { return OperatorLoc; }
+  SourceLocation getOperatorLoc() const {
+    return CXXPseudoDestructorExprBits.OperatorLoc;
+  }
 
   /// Retrieve the scope type in a qualified pseudo-destructor
   /// expression.
   ///
   /// Pseudo-destructor expressions can have extra qualification within them
   /// that is not part of the nested-name-specifier, e.g., \c p->T::~T().
   /// Here, if the object type of the expression is (or may be) a scalar type,
   /// \p T may also be a scalar type and, therefore, cannot be part of a

 /// __array_rank and __array_extent.
 ///
 /// Example:
 /// \code
 ///   __array_rank(int[10][20]) == 2
 ///   __array_extent(int, 1)    == 20
 /// \endcode
 class ArrayTypeTraitExpr : public Expr {
-  /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
-  unsigned ATT : 2;
 
   /// The value of the type trait. Unspecified if dependent.
   uint64_t Value = 0;
 
   /// The array dimension being queried, or -1 if not used.
   Expr *Dimension;
 
-  /// The location of the type trait keyword.
-  SourceLocation Loc;
-
   /// The location of the closing paren.
   SourceLocation RParen;
 
   /// The type being queried.
   TypeSourceInfo *QueriedType = nullptr;
 
 public:
   friend class ASTStmtReader;
 
   ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
                      TypeSourceInfo *queried, uint64_t value, Expr *dimension,
                      SourceLocation rparen, QualType ty)
-      : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary), ATT(att),
-        Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
+      : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary),
+        Value(value), Dimension(dimension), RParen(rparen),
         QueriedType(queried) {
+    ArrayTypeTraitExprBits.ATT = att;
+    ArrayTypeTraitExprBits.Loc = loc;
     assert(att <= ATT_Last && "invalid enum value!");
-    assert(static_cast<unsigned>(att) == ATT && "ATT overflow!");
+    assert(static_cast<unsigned>(att) == ArrayTypeTraitExprBits.ATT &&
+           "ATT overflow!");
     setDependence(computeDependence(this));
   }
 
   explicit ArrayTypeTraitExpr(EmptyShell Empty)
-      : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}
+      : Expr(ArrayTypeTraitExprClass, Empty) {
+    ArrayTypeTraitExprBits.ATT = 0;
+  }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ArrayTypeTraitExprBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return RParen; }
 
-  ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }
+  ArrayTypeTrait getTrait() const {
+    return static_cast<ArrayTypeTrait>(ArrayTypeTraitExprBits.ATT);
+  }
 
   QualType getQueriedType() const { return QueriedType->getType(); }
 
   TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }
 
   uint64_t getValue() const { assert(!isTypeDependent()); return Value; }
 
   Expr *getDimensionExpression() const { return Dimension; }

 ///
 /// Example:
 /// \code
 ///   __is_lvalue_expr(std::cout) == true
 ///   __is_lvalue_expr(1) == false
 /// \endcode
 class ExpressionTraitExpr : public Expr {
   /// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
-  unsigned ET : 31;
-
-  /// The value of the type trait. Unspecified if dependent.
-  unsigned Value : 1;
-
-  /// The location of the type trait keyword.
-  SourceLocation Loc;
+  unsigned ET;
 
   /// The location of the closing paren.
   SourceLocation RParen;
 
   /// The expression being queried.
   Expr* QueriedExpression = nullptr;
 
 public:
   friend class ASTStmtReader;
 
   ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried,
                       bool value, SourceLocation rparen, QualType resultType)
       : Expr(ExpressionTraitExprClass, resultType, VK_PRValue, OK_Ordinary),
-        ET(et), Value(value), Loc(loc), RParen(rparen),
-        QueriedExpression(queried) {
+        ET(et), RParen(rparen), QueriedExpression(queried) {
     assert(et <= ET_Last && "invalid enum value!");
     assert(static_cast<unsigned>(et) == ET && "ET overflow!");
+    ExpressionTraitExprBits.Value = value;
+    ExpressionTraitExprBits.Loc = loc;
     setDependence(computeDependence(this));
   }
 
   explicit ExpressionTraitExpr(EmptyShell Empty)
-      : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {}
+      : Expr(ExpressionTraitExprClass, Empty), ET(0) {
+    ExpressionTraitExprBits.Value = 0;
+  }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExpressionTraitExprBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return RParen; }
 
   ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }
 
   Expr *getQueriedExpression() const { return QueriedExpression; }
 
-  bool getValue() const { return Value; }
+  bool getValue() const { return ExpressionTraitExprBits.Value; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ExpressionTraitExprClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());

 /// Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
 ///
 /// The noexcept expression tests whether a given expression might throw. Its
 /// result is a boolean constant.
 class CXXNoexceptExpr : public Expr {
   friend class ASTStmtReader;
 
   Stmt *Operand;
-  SourceRange Range;
+  SourceLocation RParenLoc;
 
 public:
   CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val,
                   SourceLocation Keyword, SourceLocation RParen)
       : Expr(CXXNoexceptExprClass, Ty, VK_PRValue, OK_Ordinary),
-        Operand(Operand), Range(Keyword, RParen) {
+        Operand(Operand), RParenLoc(RParen) {
     CXXNoexceptExprBits.Value = Val == CT_Cannot;
+    CXXNoexceptExprBits.KeywordLoc = Keyword;
     setDependence(computeDependence(this, Val));
   }
 
   CXXNoexceptExpr(EmptyShell Empty) : Expr(CXXNoexceptExprClass, Empty) {}
 
   Expr *getOperand() const { return static_cast<Expr *>(Operand); }
 
-  SourceLocation getBeginLoc() const { return Range.getBegin(); }
-  SourceLocation getEndLoc() const { return Range.getEnd(); }
-  SourceRange getSourceRange() const { return Range; }
+  SourceLocation getBeginLoc() const { return CXXNoexceptExprBits.KeywordLoc; }
+  SourceLocation getEndLoc() const { return RParenLoc; }
+  SourceRange getSourceRange() const {
+    return {CXXNoexceptExprBits.KeywordLoc, RParenLoc};
+  }
 
   bool getValue() const { return CXXNoexceptExprBits.Value; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXNoexceptExprClass;
   }
 
   // Iterators

 
 public:
   SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind,
                                SourceLocation Loc,
                                NonTypeTemplateParmDecl *Param, bool RefParam,
                                Expr *Replacement)
       : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary),
         ParamAndRef(Param, RefParam), Replacement(Replacement) {
-    SubstNonTypeTemplateParmExprBits.NameLoc = Loc;
+    ExprWithSourceLocBits.Loc = Loc;
     setDependence(computeDependence(this));
   }
 
-  SourceLocation getNameLoc() const {
-    return SubstNonTypeTemplateParmExprBits.NameLoc;
-  }
+  SourceLocation getNameLoc() const { return ExprWithSourceLocBits.Loc; }
   SourceLocation getBeginLoc() const { return getNameLoc(); }
   SourceLocation getEndLoc() const { return getNameLoc(); }
 
   Expr *getReplacement() const { return cast<Expr>(Replacement); }
 
   NonTypeTemplateParmDecl *getParameter() const {
     return ParamAndRef.getPointer();
   }

 ///    ( ... op expr )
 ///    ( expr op ... op expr )
 class CXXFoldExpr : public Expr {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
   enum SubExpr { Callee, LHS, RHS, Count };
 
-  SourceLocation LParenLoc;
   SourceLocation EllipsisLoc;
   SourceLocation RParenLoc;
   // When 0, the number of expansions is not known. Otherwise, this is one more
   // than the number of expansions.
   unsigned NumExpansions;
   Stmt *SubExprs[SubExpr::Count];
-  BinaryOperatorKind Opcode;
 
 public:
   CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
               SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode,
               SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc,
               Optional<unsigned> NumExpansions)
       : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary),
-        LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
-        NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
+        EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
+        NumExpansions(NumExpansions ? *NumExpansions + 1 : 0) {
+    CXXFoldExprBits.LParenLoc = LParenLoc;
+    CXXFoldExprBits.Opcode = Opcode;
     SubExprs[SubExpr::Callee] = Callee;
     SubExprs[SubExpr::LHS] = LHS;
     SubExprs[SubExpr::RHS] = RHS;
     setDependence(computeDependence(this));
   }
 
   CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {}
 
public:
   bool isLeftFold() const { return !isRightFold(); }
 
   /// Get the pattern, that is, the operand that contains an unexpanded pack.
   Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); }
 
   /// Get the operand that doesn't contain a pack, for a binary fold.
   Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); }
 
-  SourceLocation getLParenLoc() const { return LParenLoc; }
+  SourceLocation getLParenLoc() const { return CXXFoldExprBits.LParenLoc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
-  BinaryOperatorKind getOperator() const { return Opcode; }
+  BinaryOperatorKind getOperator() const {
+    return BinaryOperatorKind(CXXFoldExprBits.Opcode);
+  }
 
   Optional<unsigned> getNumExpansions() const {
     if (NumExpansions)
       return NumExpansions - 1;
     return None;
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
-    if (LParenLoc.isValid())
-      return LParenLoc;
+    if (CXXFoldExprBits.LParenLoc.isValid())
+      return CXXFoldExprBits.LParenLoc;
     if (isLeftFold())
       return getEllipsisLoc();
     return getLHS()->getBeginLoc();
   }
 
   SourceLocation getEndLoc() const LLVM_READONLY {
     if (RParenLoc.isValid())
       return RParenLoc;

 ///        resumed
 ///     -- otherwise, control passes back to the resumer.
 /// If the coroutine is not suspended, or when it is resumed, the 'resume'
 /// expression is evaluated, and its result is the result of the overall
 /// expression.
 class CoroutineSuspendExpr : public Expr {
   friend class ASTStmtReader;
 
-  SourceLocation KeywordLoc;
-
   enum SubExpr { Operand, Common, Ready, Suspend, Resume, Count };
 
   Stmt *SubExprs[SubExpr::Count];
   OpaqueValueExpr *OpaqueValue = nullptr;
 
 public:
   CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Operand,
                        Expr *Common, Expr *Ready, Expr *Suspend, Expr *Resume,
                        OpaqueValueExpr *OpaqueValue)
       : Expr(SC, Resume->getType(), Resume->getValueKind(),
              Resume->getObjectKind()),
-        KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) {
+        OpaqueValue(OpaqueValue) {
+    CoroutineSuspendExprBits.KeywordLoc = KeywordLoc;
     SubExprs[SubExpr::Operand] = Operand;
     SubExprs[SubExpr::Common] = Common;
     SubExprs[SubExpr::Ready] = Ready;
     SubExprs[SubExpr::Suspend] = Suspend;
     SubExprs[SubExpr::Resume] = Resume;
     setDependence(computeDependence(this));
   }
 
   CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty,
                        Expr *Operand, Expr *Common)
-      : Expr(SC, Ty, VK_PRValue, OK_Ordinary), KeywordLoc(KeywordLoc) {
+      : Expr(SC, Ty, VK_PRValue, OK_Ordinary) {
     assert(Common->isTypeDependent() && Ty->isDependentType() &&
            "wrong constructor for non-dependent co_await/co_yield expression");
+    CoroutineSuspendExprBits.KeywordLoc = KeywordLoc;
     SubExprs[SubExpr::Operand] = Operand;
     SubExprs[SubExpr::Common] = Common;
     SubExprs[SubExpr::Ready] = nullptr;
     SubExprs[SubExpr::Suspend] = nullptr;
     SubExprs[SubExpr::Resume] = nullptr;
     setDependence(computeDependence(this));
   }
 
Expr *getResumeExpr() const {
     return static_cast<Expr*>(SubExprs[SubExpr::Resume]);
   }
 
   // The syntactic operand written in the code
   Expr *getOperand() const {
     return static_cast<Expr *>(SubExprs[SubExpr::Operand]);
   }
 
-  SourceLocation getKeywordLoc() const { return KeywordLoc; }
+  SourceLocation getKeywordLoc() const {
+    return CoroutineSuspendExprBits.KeywordLoc;
+  }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return CoroutineSuspendExprBits.KeywordLoc;
+  }
 
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getOperand()->getEndLoc();
   }
 
   child_range children() {
     return child_range(SubExprs, SubExprs + SubExpr::Count);
   }
public:
   }
 };
 
 /// Represents a 'co_await' expression while the type of the promise
 /// is dependent.
 class DependentCoawaitExpr : public Expr {
   friend class ASTStmtReader;
 
-  SourceLocation KeywordLoc;
   Stmt *SubExprs[2];
 
 public:
   DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op,
                        UnresolvedLookupExpr *OpCoawait)
-      : Expr(DependentCoawaitExprClass, Ty, VK_PRValue, OK_Ordinary),
-        KeywordLoc(KeywordLoc) {
+      : Expr(DependentCoawaitExprClass, Ty, VK_PRValue, OK_Ordinary) {
     // NOTE: A co_await expression is dependent on the coroutines promise
     // type and may be dependent even when the `Op` expression is not.
     assert(Ty->isDependentType() &&
            "wrong constructor for non-dependent co_await/co_yield expression");
+    ExprWithSourceLocBits.Loc = KeywordLoc;
     SubExprs[0] = Op;
     SubExprs[1] = OpCoawait;
     setDependence(computeDependence(this));
   }
 
   DependentCoawaitExpr(EmptyShell Empty)
       : Expr(DependentCoawaitExprClass, Empty) {}
 
   Expr *getOperand() const { return cast<Expr>(SubExprs[0]); }
 
   UnresolvedLookupExpr *getOperatorCoawaitLookup() const {
     return cast<UnresolvedLookupExpr>(SubExprs[1]);
   }
 
-  SourceLocation getKeywordLoc() const { return KeywordLoc; }
+  SourceLocation getKeywordLoc() const { return ExprWithSourceLocBits.Loc; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
 
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getOperand()->getEndLoc();
   }
 
   child_range children() { return child_range(SubExprs, SubExprs + 2); }
 
   const_child_range children() const {

clang/include/clang/AST/ExprObjC.h

 
 class ASTContext;
 class CXXBaseSpecifier;
 
 /// ObjCStringLiteral, used for Objective-C string literals
 /// i.e. @"foo".
 class ObjCStringLiteral : public Expr {
   Stmt *String;
-  SourceLocation AtLoc;
 
 public:
   ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)
-      : Expr(ObjCStringLiteralClass, T, VK_PRValue, OK_Ordinary), String(SL),
-        AtLoc(L) {
+      : Expr(ObjCStringLiteralClass, T, VK_PRValue, OK_Ordinary), String(SL) {
+    ExprWithSourceLocBits.Loc = L;
     setDependence(ExprDependence::None);
   }
   explicit ObjCStringLiteral(EmptyShell Empty)
       : Expr(ObjCStringLiteralClass, Empty) {}
 
   StringLiteral *getString() { return cast<StringLiteral>(String); }
   const StringLiteral *getString() const { return cast<StringLiteral>(String); }
   void setString(StringLiteral *S) { String = S; }
 
-  SourceLocation getAtLoc() const { return AtLoc; }
-  void setAtLoc(SourceLocation L) { AtLoc = L; }
+  SourceLocation getAtLoc() const { return ExprWithSourceLocBits.Loc; }
+  void setAtLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return String->getEndLoc(); }
 
   // Iterators
   child_range children() { return child_range(&String, &String+1); }
 
   const_child_range children() const {
     return const_child_range(&String, &String + 1);
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCStringLiteralClass;
   }
 };
 
 /// ObjCBoolLiteralExpr - Objective-C Boolean Literal.
 class ObjCBoolLiteralExpr : public Expr {
-  bool Value;
-  SourceLocation Loc;
-
 public:
   ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l)
-      : Expr(ObjCBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary), Value(val),
-        Loc(l) {
+      : Expr(ObjCBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
+    ObjCBoolLiteralExprBits.Value = val;
+    ObjCBoolLiteralExprBits.Loc = l;
     setDependence(ExprDependence::None);
   }
   explicit ObjCBoolLiteralExpr(EmptyShell Empty)
       : Expr(ObjCBoolLiteralExprClass, Empty) {}
 
-  bool getValue() const { return Value; }
-  void setValue(bool V) { Value = V; }
+  bool getValue() const { return ObjCBoolLiteralExprBits.Value; }
+  void setValue(bool V) { ObjCBoolLiteralExprBits.Value = V; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ObjCBoolLiteralExprBits.Loc;
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ObjCBoolLiteralExprBits.Loc;
+  }
 
-  SourceLocation getLocation() const { return Loc; }
-  void setLocation(SourceLocation L) { Loc = L; }
+  SourceLocation getLocation() const { return ObjCBoolLiteralExprBits.Loc; }
+  void setLocation(SourceLocation L) { ObjCBoolLiteralExprBits.Loc = L; }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
public:
   }
 };
 
 /// ObjCArrayLiteral - used for objective-c array containers; as in:
 /// @[@"Hello", NSApp, [NSNumber numberWithInt:42]];
 class ObjCArrayLiteral final
     : public Expr,
       private llvm::TrailingObjects<ObjCArrayLiteral, Expr *> {
-  unsigned NumElements;
   SourceRange Range;
   ObjCMethodDecl *ArrayWithObjectsMethod;
 
   ObjCArrayLiteral(ArrayRef<Expr *> Elements,
                    QualType T, ObjCMethodDecl * Method,
                    SourceRange SR);
 
   explicit ObjCArrayLiteral(EmptyShell Empty, unsigned NumElements)
-      : Expr(ObjCArrayLiteralClass, Empty), NumElements(NumElements) {}
+      : Expr(ObjCArrayLiteralClass, Empty) {
+    ObjCArrayLiteralBits.NumElements = NumElements;
+  }
 
 public:
   friend class ASTStmtReader;
   friend TrailingObjects;
 
   static ObjCArrayLiteral *Create(const ASTContext &C,
                                   ArrayRef<Expr *> Elements,
                                   QualType T, ObjCMethodDecl * Method,
public:
   Expr **getElements() { return getTrailingObjects<Expr *>(); }
 
   /// Retrieve elements of array of literals.
   const Expr * const *getElements() const {
     return getTrailingObjects<Expr *>();
   }
 
   /// getNumElements - Return number of elements of objective-c array literal.
-  unsigned getNumElements() const { return NumElements; }
+  unsigned getNumElements() const { return ObjCArrayLiteralBits.NumElements; }
 
   /// getElement - Return the Element at the specified index.
   Expr *getElement(unsigned Index) {
-    assert((Index < NumElements) && "Arg access out of range!");
+    assert((Index < ObjCArrayLiteralBits.NumElements) &&
+           "Arg access out of range!");
     return getElements()[Index];
   }
   const Expr *getElement(unsigned Index) const {
-    assert((Index < NumElements) && "Arg access out of range!");
+    assert((Index < ObjCArrayLiteralBits.NumElements) &&
+           "Arg access out of range!");
     return getElements()[Index];
   }
 
   ObjCMethodDecl *getArrayWithObjectsMethod() const {
     return ArrayWithObjectsMethod;
   }
 
   // Iterators
   child_range children() {
     return child_range(reinterpret_cast<Stmt **>(getElements()),
-                       reinterpret_cast<Stmt **>(getElements()) + NumElements);
+                       reinterpret_cast<Stmt **>(getElements()) +
+                           ObjCArrayLiteralBits.NumElements);
   }
 
   const_child_range children() const {
     auto Children = const_cast<ObjCArrayLiteral *>(this)->children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const Stmt *T) {

 
 /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary
 /// literals; as in:  @{@"name" : NSUserName(), @"date" : [NSDate date] };
 class ObjCDictionaryLiteral final
     : public Expr,
       private llvm::TrailingObjects<ObjCDictionaryLiteral,
                                     ObjCDictionaryLiteral_KeyValuePair,
                                     ObjCDictionaryLiteral_ExpansionData> {
-  /// The number of elements in this dictionary literal.
-  unsigned NumElements : 31;
-
-  /// Determine whether this dictionary literal has any pack expansions.
-  ///
-  /// If the dictionary literal has pack expansions, then there will
-  /// be an array of pack expansion data following the array of
-  /// key/value pairs, which provide the locations of the ellipses (if
-  /// any) and number of elements in the expansion (if known). If
-  /// there are no pack expansions, we optimize away this storage.
-  unsigned HasPackExpansions : 1;
 
   SourceRange Range;
   ObjCMethodDecl *DictWithObjectsMethod;
 
   using KeyValuePair = ObjCDictionaryLiteral_KeyValuePair;
   using ExpansionData = ObjCDictionaryLiteral_ExpansionData;
 
   ObjCDictionaryLiteral(ArrayRef<ObjCDictionaryElement> VK,
                         bool HasPackExpansions,
                         QualType T, ObjCMethodDecl *method,
                         SourceRange SR);
 
   explicit ObjCDictionaryLiteral(EmptyShell Empty, unsigned NumElements,
                                  bool HasPackExpansions)
-      : Expr(ObjCDictionaryLiteralClass, Empty), NumElements(NumElements),
-        HasPackExpansions(HasPackExpansions) {}
+      : Expr(ObjCDictionaryLiteralClass, Empty) {
+    ObjCDictionaryLiteralBits.NumElements = NumElements;
+    ObjCDictionaryLiteralBits.HasPackExpansions = HasPackExpansions;
+  }
 
   size_t numTrailingObjects(OverloadToken<KeyValuePair>) const {
-    return NumElements;
+    return ObjCDictionaryLiteralBits.NumElements;
   }
 
 public:
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
   friend TrailingObjects;
 
   static ObjCDictionaryLiteral *Create(const ASTContext &C,
                                        ArrayRef<ObjCDictionaryElement> VK,
                                        bool HasPackExpansions,
                                        QualType T, ObjCMethodDecl *method,
                                        SourceRange SR);
 
   static ObjCDictionaryLiteral *CreateEmpty(const ASTContext &C,
                                             unsigned NumElements,
                                             bool HasPackExpansions);
 
   /// getNumElements - Return number of elements of objective-c dictionary
   /// literal.
-  unsigned getNumElements() const { return NumElements; }
+  unsigned getNumElements() const {
+    return ObjCDictionaryLiteralBits.NumElements;
+  }
 
   ObjCDictionaryElement getKeyValueElement(unsigned Index) const {
-    assert((Index < NumElements) && "Arg access out of range!");
+    assert((Index < ObjCDictionaryLiteralBits.NumElements) &&
+           "Arg access out of range!");
     const KeyValuePair &KV = getTrailingObjects<KeyValuePair>()[Index];
     ObjCDictionaryElement Result = { KV.Key, KV.Value, SourceLocation(), None };
-    if (HasPackExpansions) {
+    if (ObjCDictionaryLiteralBits.HasPackExpansions) {
       const ExpansionData &Expansion =
           getTrailingObjects<ExpansionData>()[Index];
       Result.EllipsisLoc = Expansion.EllipsisLoc;
       if (Expansion.NumExpansionsPlusOne > 0)
         Result.NumExpansions = Expansion.NumExpansionsPlusOne - 1;
     }
     return Result;
   }
public:
   child_range children() {
     // Note: we're taking advantage of the layout of the KeyValuePair struct
     // here. If that struct changes, this code will need to change as well.
     static_assert(sizeof(KeyValuePair) == sizeof(Stmt *) * 2,
                   "KeyValuePair is expected size");
     return child_range(
         reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()),
         reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()) +
-            NumElements * 2);
+            ObjCDictionaryLiteralBits.NumElements * 2);
   }
 
   const_child_range children() const {
     auto Children = const_cast<ObjCDictionaryLiteral *>(this)->children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const Stmt *T) {

 /// This is used as: \@protocol(foo), as in:
 /// \code
 ///   [obj conformsToProtocol:@protocol(foo)]
 /// \endcode
 ///
 /// The return type is "Protocol*".
 class ObjCProtocolExpr : public Expr {
   ObjCProtocolDecl *TheProtocol;
-  SourceLocation AtLoc, ProtoLoc, RParenLoc;
+  SourceLocation ProtoLoc, RParenLoc;
 
 public:
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
   ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, SourceLocation at,
                    SourceLocation protoLoc, SourceLocation rp)
       : Expr(ObjCProtocolExprClass, T, VK_PRValue, OK_Ordinary),
-        TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {
+        TheProtocol(protocol), ProtoLoc(protoLoc), RParenLoc(rp) {
+    ExprWithSourceLocBits.Loc = at;
     setDependence(ExprDependence::None);
   }
   explicit ObjCProtocolExpr(EmptyShell Empty)
       : Expr(ObjCProtocolExprClass, Empty) {}
 
   ObjCProtocolDecl *getProtocol() const { return TheProtocol; }
   void setProtocol(ObjCProtocolDecl *P) { TheProtocol = P; }
 
   SourceLocation getProtocolIdLoc() const { return ProtoLoc; }
-  SourceLocation getAtLoc() const { return AtLoc; }
+  SourceLocation getAtLoc() const { return ExprWithSourceLocBits.Loc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
-  void setAtLoc(SourceLocation L) { AtLoc = L; }
+  void setAtLoc(SourceLocation L) { ExprWithSourceLocBits.Loc = L; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCProtocolExprClass;
   }
 };
 
 /// ObjCIvarRefExpr - A reference to an ObjC instance variable.
 class ObjCIvarRefExpr : public Expr {
   ObjCIvarDecl *D;
   Stmt *Base;
-  SourceLocation Loc;
 
   /// OpLoc - This is the location of '.' or '->'
   SourceLocation OpLoc;
 
-  // True if this is "X->F", false if this is "X.F".
-  bool IsArrow : 1;
-
-  // True if ivar reference has no base (self assumed).
-  bool IsFreeIvar : 1;
-
 public:
   ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, SourceLocation l,
                   SourceLocation oploc, Expr *base, bool arrow = false,
                   bool freeIvar = false)
       : Expr(ObjCIvarRefExprClass, t, VK_LValue,
              d->isBitField() ? OK_BitField : OK_Ordinary),
-        D(d), Base(base), Loc(l), OpLoc(oploc), IsArrow(arrow),
-        IsFreeIvar(freeIvar) {
+        D(d), Base(base), OpLoc(oploc) {
+    ObjCIvarRefExprBits.Loc = l;
+    ObjCIvarRefExprBits.IsArrow = arrow;
+    ObjCIvarRefExprBits.IsFreeIvar = freeIvar;
     setDependence(computeDependence(this));
   }
 
   explicit ObjCIvarRefExpr(EmptyShell Empty)
       : Expr(ObjCIvarRefExprClass, Empty) {}
 
   ObjCIvarDecl *getDecl() { return D; }
   const ObjCIvarDecl *getDecl() const { return D; }
   void setDecl(ObjCIvarDecl *d) { D = d; }
 
   const Expr *getBase() const { return cast<Expr>(Base); }
   Expr *getBase() { return cast<Expr>(Base); }
   void setBase(Expr * base) { Base = base; }
 
-  bool isArrow() const { return IsArrow; }
-  bool isFreeIvar() const { return IsFreeIvar; }
-  void setIsArrow(bool A) { IsArrow = A; }
-  void setIsFreeIvar(bool A) { IsFreeIvar = A; }
+  bool isArrow() const { return ObjCIvarRefExprBits.IsArrow; }
+  bool isFreeIvar() const { return ObjCIvarRefExprBits.IsFreeIvar; }
+  void setIsArrow(bool A) { ObjCIvarRefExprBits.IsArrow = A; }
+  void setIsFreeIvar(bool A) { ObjCIvarRefExprBits.IsFreeIvar = A; }
 
-  SourceLocation getLocation() const { return Loc; }
-  void setLocation(SourceLocation L) { Loc = L; }
+  SourceLocation getLocation() const { return ObjCIvarRefExprBits.Loc; }
+  void setLocation(SourceLocation L) { ObjCIvarRefExprBits.Loc = L; }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
-    return isFreeIvar() ? Loc : getBase()->getBeginLoc();
+    return isFreeIvar() ? ObjCIvarRefExprBits.Loc : getBase()->getBeginLoc();
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ObjCIvarRefExprBits.Loc;
   }
-  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
 
   SourceLocation getOpLoc() const { return OpLoc; }
   void setOpLoc(SourceLocation L) { OpLoc = L; }
 
   // Iterators
   child_range children() { return child_range(&Base, &Base+1); }
 
   const_child_range children() const {
else
       f &= ~flag;
     SetterAndMethodRefFlags.setInt(f);
   }
 };
 
 /// ObjCSubscriptRefExpr - used for array and dictionary subscripting.
 /// array[4] = array[3]; dictionary[key] = dictionary[alt_key];
 class ObjCSubscriptRefExpr : public Expr {
-  // Location of ']' in an indexing expression.
-  SourceLocation RBracket;
-
   // array/dictionary base expression.
   // for arrays, this is a numeric expression. For dictionaries, this is
   // an objective-c object pointer expression.
   enum { BASE, KEY, END_EXPR };
   Stmt* SubExprs[END_EXPR];
 
   ObjCMethodDecl *GetAtIndexMethodDecl;
 
   // For immutable objects this is null. When ObjCSubscriptRefExpr is to read
   // an indexed object this is null too.
   ObjCMethodDecl *SetAtIndexMethodDecl;
 
 public:
   ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T, ExprValueKind VK,
                        ExprObjectKind OK, ObjCMethodDecl *getMethod,
                        ObjCMethodDecl *setMethod, SourceLocation RB)
-      : Expr(ObjCSubscriptRefExprClass, T, VK, OK), RBracket(RB),
+      : Expr(ObjCSubscriptRefExprClass, T, VK, OK),
         GetAtIndexMethodDecl(getMethod), SetAtIndexMethodDecl(setMethod) {
+    ExprWithSourceLocBits.Loc = RB;
     SubExprs[BASE] = base;
     SubExprs[KEY] = key;
     setDependence(computeDependence(this));
   }
 
   explicit ObjCSubscriptRefExpr(EmptyShell Empty)
       : Expr(ObjCSubscriptRefExprClass, Empty) {}
 
-  SourceLocation getRBracket() const { return RBracket; }
-  void setRBracket(SourceLocation RB) { RBracket = RB; }
+  SourceLocation getRBracket() const { return ExprWithSourceLocBits.Loc; }
+  void setRBracket(SourceLocation RB) { ExprWithSourceLocBits.Loc = RB; }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return SubExprs[BASE]->getBeginLoc();
   }
 
-  SourceLocation getEndLoc() const LLVM_READONLY { return RBracket; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ExprWithSourceLocBits.Loc;
+  }
 
   Expr *getBaseExpr() const { return cast<Expr>(SubExprs[BASE]); }
   void setBaseExpr(Stmt *S) { SubExprs[BASE] = S; }
 
   Expr *getKeyExpr() const { return cast<Expr>(SubExprs[KEY]); }
   void setKeyExpr(Stmt *S) { SubExprs[KEY] = S; }
 
   ObjCMethodDecl *getAtIndexMethodDecl() const {

 };
 
 /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
 /// (similar in spirit to MemberExpr).
 class ObjCIsaExpr : public Expr {
   /// Base - the expression for the base object pointer.
   Stmt *Base;
 
-  /// IsaMemberLoc - This is the location of the 'isa'.
-  SourceLocation IsaMemberLoc;
-
   /// OpLoc - This is the location of '.' or '->'
   SourceLocation OpLoc;
 
-  /// IsArrow - True if this is "X->F", false if this is "X.F".
-  bool IsArrow;
-
 public:
   ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc,
               QualType ty)
       : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary), Base(base),
-        IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) {
+        OpLoc(oploc) {
+    ObjCIsaExprBits.IsArrow = isarrow;
+    ObjCIsaExprBits.IsaMemberLoc = l;
     setDependence(computeDependence(this));
   }
 
   /// Build an empty expression.
   explicit ObjCIsaExpr(EmptyShell Empty) : Expr(ObjCIsaExprClass, Empty) {}
 
   void setBase(Expr *E) { Base = E; }
   Expr *getBase() const { return cast<Expr>(Base); }
 
-  bool isArrow() const { return IsArrow; }
-  void setArrow(bool A) { IsArrow = A; }
+  bool isArrow() const { return ObjCIsaExprBits.IsArrow; }
+  void setArrow(bool A) { ObjCIsaExprBits.IsArrow = A; }
 
   /// getMemberLoc - Return the location of the "member", in X->F, it is the
   /// location of 'F'.
-  SourceLocation getIsaMemberLoc() const { return IsaMemberLoc; }
-  void setIsaMemberLoc(SourceLocation L) { IsaMemberLoc = L; }
+  SourceLocation getIsaMemberLoc() const {
+    return ObjCIsaExprBits.IsaMemberLoc;
+  }
+  void setIsaMemberLoc(SourceLocation L) { ObjCIsaExprBits.IsaMemberLoc = L; }
 
   SourceLocation getOpLoc() const { return OpLoc; }
   void setOpLoc(SourceLocation L) { OpLoc = L; }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getBase()->getBeginLoc();
   }
 
   SourceLocation getBaseLocEnd() const LLVM_READONLY {
     return getBase()->getEndLoc();
   }
 
-  SourceLocation getEndLoc() const LLVM_READONLY { return IsaMemberLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return ObjCIsaExprBits.IsaMemberLoc;
+  }
 
-  SourceLocation getExprLoc() const LLVM_READONLY { return IsaMemberLoc; }
+  SourceLocation getExprLoc() const LLVM_READONLY {
+    return ObjCIsaExprBits.IsaMemberLoc;
+  }
 
   // Iterators
   child_range children() { return child_range(&Base, &Base+1); }
 
   const_child_range children() const {
     return const_child_range(&Base, &Base + 1);
   }
 
: public ExplicitCastExpr,
       private llvm::TrailingObjects<ObjCBridgedCastExpr, CXXBaseSpecifier *> {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
   friend class CastExpr;
   friend TrailingObjects;
 
   SourceLocation LParenLoc;
   SourceLocation BridgeKeywordLoc;
-  unsigned Kind : 2;
 
 public:
   ObjCBridgedCastExpr(SourceLocation LParenLoc, ObjCBridgeCastKind Kind,
                       CastKind CK, SourceLocation BridgeKeywordLoc,
                       TypeSourceInfo *TSInfo, Expr *Operand)
       : ExplicitCastExpr(ObjCBridgedCastExprClass, TSInfo->getType(),
                          VK_PRValue, CK, Operand, 0, false, TSInfo),
-        LParenLoc(LParenLoc), BridgeKeywordLoc(BridgeKeywordLoc), Kind(Kind) {}
+        LParenLoc(LParenLoc), BridgeKeywordLoc(BridgeKeywordLoc) {
+    ObjCBridgedCastExprBits.Kind = Kind;
+  }
 
   /// Construct an empty Objective-C bridged cast.
   explicit ObjCBridgedCastExpr(EmptyShell Shell)
       : ExplicitCastExpr(ObjCBridgedCastExprClass, Shell, 0, false) {}
 
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Determine which kind of bridge is being performed via this cast.
   ObjCBridgeCastKind getBridgeKind() const {
-    return static_cast<ObjCBridgeCastKind>(Kind);
+    return static_cast<ObjCBridgeCastKind>(ObjCBridgedCastExprBits.Kind);
   }
 
   /// Retrieve the kind of bridge being performed as a string.
   StringRef getBridgeKindName() const;
 
   /// The location of the bridge keyword.
   SourceLocation getBridgeKeywordLoc() const { return BridgeKeywordLoc; }
 

clang/include/clang/AST/Stmt.h

class StmtBitfields {
     friend class ASTStmtWriter;
     friend class Stmt;
 
     /// The statement class.
     unsigned sClass : 8;
   };
   enum { NumStmtBits = 8 };
 
+  class StmtWithSourceLocBitfields {
+    friend class ASTStmtReader;
+    friend class SEHExceptStmt;
+    friend class SEHFinallyStmt;
+    friend class SEHLeaveStmt;
+    friend class CXXCatchStmt;
+    friend class CXXForRangeStmt;
+    friend class ObjCAtFinallyStmt;
+    friend class ObjCAtSynchronizedStmt;
+    friend class ObjCAtThrowStmt;
+    friend class ObjCAutoreleasePoolStmt;
+    friend class ForStmt;
+    friend class DoStmt;
+    friend class BreakStmt;
+    friend class ContinueStmt;
+    friend class GotoStmt;
+    friend class IndirectGotoStmt;
+
+    unsigned : NumStmtBits;
+    unsigned : 32 - NumStmtBits;
+
+    SourceLocation Loc;
+  };
+
   class NullStmtBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class NullStmt;
 
     unsigned : NumStmtBits;
 
     /// True if the null statement was preceded by an empty macro, e.g:
class CompoundStmtBitfields {
     SourceLocation LBraceLoc;
   };
 
   class LabelStmtBitfields {
     friend class LabelStmt;
 
     unsigned : NumStmtBits;
 
+    unsigned SideEntry : 1;
+
     SourceLocation IdentLoc;
   };
 
   class AttributedStmtBitfields {
     friend class ASTStmtReader;
     friend class AttributedStmt;
 
     unsigned : NumStmtBits;
class WhileStmtBitfields {
 
     /// True if the WhileStmt has storage for a condition variable.
     unsigned HasVar : 1;
 
     /// The location of the "while".
     SourceLocation WhileLoc;
   };
 
-  class DoStmtBitfields {
-    friend class DoStmt;
+  class ReturnStmtBitfields {
+    friend class ReturnStmt;
 
     unsigned : NumStmtBits;
 
-    /// The location of the "do".
-    SourceLocation DoLoc;
+    /// True if this ReturnStmt has storage for an NRVO candidate.
+    unsigned HasNRVOCandidate : 1;
+
+    /// The location of the "return".
+    SourceLocation RetLoc;
   };
 
-  class ForStmtBitfields {
-    friend class ForStmt;
+  class SwitchCaseBitfields {
+    friend class SwitchCase;
+    friend class CaseStmt;
 
     unsigned : NumStmtBits;
 
-    /// The location of the "for".
-    SourceLocation ForLoc;
+    /// Used by CaseStmt to store whether it is a case statement
+    /// of the form case LHS ... RHS (a GNU extension).
+    unsigned CaseStmtIsGNURange : 1;
+
+    /// The location of the "case" or "default" keyword.
+    SourceLocation KeywordLoc;
   };
 
-  class GotoStmtBitfields {
-    friend class GotoStmt;
-    friend class IndirectGotoStmt;
+  class AsmStmtBitfields {
+    friend class ASTStmtReader;
+    friend class AsmStmt;
+    friend class GCCAsmStmt;
+    friend class MSAsmStmt;
 
     unsigned : NumStmtBits;
 
-    /// The location of the "goto".
-    SourceLocation GotoLoc;
+    /// True if the assembly statement does not have any input or output
+    /// operands.
+    unsigned IsSimple : 1;
+
+    /// If true, treat this inline assembly as having side effects.
+    /// This assembly statement should not be optimized, deleted or moved.
+    unsigned IsVolatile : 1;
+
+    // Padding so that NumOutputs in aligned to 16 bytes for faster access
+    unsigned : 16 - 2 - NumStmtBits;
+
+    unsigned NumOutputs : 16;
+
+    SourceLocation AsmLoc;
   };
 
-  class ContinueStmtBitfields {
-    friend class ContinueStmt;
+  class SEHTryStmtBitfields {
+    friend class ASTStmtReader;
+    friend class SEHTryStmt;
 
     unsigned : NumStmtBits;
 
-    /// The location of the "continue".
-    SourceLocation ContinueLoc;
+    unsigned IsCXXTry : 1;
+    SourceLocation TryLoc;
   };
 
-  class BreakStmtBitfields {
-    friend class BreakStmt;
+  class CapturedStmtBitfields {
+    friend class ASTStmtReader;
+    friend class CapturedStmt;
 
     unsigned : NumStmtBits;
+    /// The number of variable captured, including 'this'.
+    unsigned NumCaptures;
+  };
+
+  //===--- C++ Statement bitfields classes ---===//
 
-    /// The location of the "break".
-    SourceLocation BreakLoc;
+  class CXXTryStmtBitfields {
+    friend class ASTStmtReader;
+    friend class CXXTryStmt;
+
+    unsigned : NumStmtBits;
+    unsigned NumHandlers : 32 - NumStmtBits;
+    SourceLocation TryLoc;
   };
 
-  class ReturnStmtBitfields {
-    friend class ReturnStmt;
+  class MSDependentExistsStmtBitfields {
+    friend class ASTStmtReader;
+    friend class MSDependentExistsStmt;
 
     unsigned : NumStmtBits;
+    unsigned IsIfExists : 1;
+    SourceLocation KeywordLoc;
+  };
 
-    /// True if this ReturnStmt has storage for an NRVO candidate.
-    unsigned HasNRVOCandidate : 1;
+  class CoroutineBodyStmtBitfields {
+    friend class ASTStmtReader;
+    friend class CoroutineBodyStmt;
 
-    /// The location of the "return".
-    SourceLocation RetLoc;
+    unsigned : NumStmtBits;
+    unsigned : 32 - NumStmtBits;
+    unsigned NumParams;
   };
 
-  class SwitchCaseBitfields {
-    friend class SwitchCase;
-    friend class CaseStmt;
+  class CoreturnStmtBitfields {
+    friend class ASTStmtReader;
+    friend class CoreturnStmt;
 
     unsigned : NumStmtBits;
+    unsigned IsImplicit : 1;
+    SourceLocation CoreturnLoc;
+  };
 
-    /// Used by CaseStmt to store whether it is a case statement
-    /// of the form case LHS ... RHS (a GNU extension).
-    unsigned CaseStmtIsGNURange : 1;
+  //===--- ObjC Statement bitfields classes ---===//
 
-    /// The location of the "case" or "default" keyword.
-    SourceLocation KeywordLoc;
+  class ObjCAtTryStmtBitfields {
+    friend class ASTStmtReader;
+    friend class ObjCAtTryStmt;
+
+    unsigned : NumStmtBits;
+
+    // Whether this statement has a \@finally statement.
+    unsigned HasFinally : 1;
+
+    // Pad out so NumCatchStmts is on a 16bit boundary.
+    unsigned : 16 - NumStmtBits - 1;
+
+    // The number of catch blocks in this statement.
+    unsigned NumCatchStmts : 16;
+
+    // The location of the @ in the \@try.
+    SourceLocation AtTryLoc;
   };
 
   //===--- Expression bitfields classes ---===//
 
   class ExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class AtomicExpr; // ctor
     friend class BlockDeclRefExpr; // ctor
class ExprBitfields {
     unsigned : NumStmtBits;
 
     unsigned ValueKind : 2;
     unsigned ObjectKind : 3;
     unsigned /*ExprDependence*/ Dependent : llvm::BitWidth<ExprDependence>;
   };
   enum { NumExprBits = NumStmtBits + 5 + llvm::BitWidth<ExprDependence> };
 
+  /// A few Expr nodes only contain a \c SourceLocation that can be pulled into
+  /// the bitfield. This just saves having to create a new Bitfield for each of
+  /// those nodes.
+  class ExprWithSourceLocBitFields {
+    friend class ASTStmtReader;
+    friend class SYCLUniqueStableNameExpr;
+    friend class ParenExpr;
+    friend class AddrLabelExpr;
+    friend class AbstractConditionalOperator;
+    friend class GNUNullExpr;
+    friend class ExtVectorElementExpr;
+    friend class TypoExpr;
+    friend class DependentCoawaitExpr;
+    friend class MSPropertySubscriptExpr;
+    friend class ObjCStringLiteral;
+    friend class ObjCProtocolExpr;
+    friend class ObjCSubscriptRefExpr;
+    friend class ArraySubscriptExpr;
+    friend class MatrixSubscriptExpr;
+    friend class ASTStmtReader;
+    friend class SubstNonTypeTemplateParmExpr;
+    friend class ASTStmtReader;
+    friend class CXXScalarValueInitExpr;
+    friend class ASTStmtReader;
+    friend class CXXDefaultInitExpr;
+    friend class CompoundLiteralExpr;
+    friend class ASTStmtReader;
+    friend class CXXDefaultArgExpr;
+    friend class CXXNullPtrLiteralExpr;
+    friend class ASTStmtReader;
+    friend class GenericSelectionExpr;
+
+    unsigned : NumExprBits;
+    unsigned : 32 - NumExprBits;
+    SourceLocation Loc;
+  };
+
   class ConstantExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class ConstantExpr;
 
     unsigned : NumExprBits;
 
     /// The kind of result that is tail-allocated.
protected:
 
   class FloatingLiteralBitfields {
     friend class FloatingLiteral;
 
     unsigned : NumExprBits;
 
     unsigned Semantics : 3; // Provides semantics for APFloat construction
     unsigned IsExact : 1;
+
+    SourceLocation Loc;
+  };
+
+  class FixedPointLiteralBitfields {
+    friend class FixedPointLiteral;
+
+    unsigned : NumExprBits;
+
+    unsigned Scale : 8;
+
+    SourceLocation Loc;
   };
 
   class StringLiteralBitfields {
     friend class ASTStmtReader;
     friend class StringLiteral;
 
     unsigned : NumExprBits;
 
protected:
   };
 
   class CharacterLiteralBitfields {
     friend class CharacterLiteral;
 
     unsigned : NumExprBits;
 
     unsigned Kind : 3;
+
+    unsigned Value;
   };
 
   class UnaryOperatorBitfields {
     friend class UnaryOperator;
 
     unsigned : NumExprBits;
 
     unsigned Opc : 5;
     unsigned CanOverflow : 1;
     //
     /// This is only meaningful for operations on floating point
     /// types when additional values need to be in trailing storage.
     /// It is 0 otherwise.
     unsigned HasFPFeatures : 1;
 
     SourceLocation Loc;
   };
 
+  class OffsetOfExprBitfields {
+    friend class OffsetOfExpr;
+
+    unsigned : NumExprBits;
+    unsigned : 32 - NumExprBits;
+    unsigned NumComps : 16;
+    unsigned NumExprs : 16;
+  };
+
   class UnaryExprOrTypeTraitExprBitfields {
     friend class UnaryExprOrTypeTraitExpr;
 
     unsigned : NumExprBits;
 
     unsigned Kind : 3;
     unsigned IsType : 1; // true if operand is a type, false if an expression.
-  };
-
-  class ArrayOrMatrixSubscriptExprBitfields {
-    friend class ArraySubscriptExpr;
-    friend class MatrixSubscriptExpr;
 
-    unsigned : NumExprBits;
-
-    SourceLocation RBracketLoc;
+    SourceLocation OpLoc;
   };
 
   class CallExprBitfields {
     friend class CallExpr;
 
     unsigned : NumExprBits;
 
     unsigned NumPreArgs : 1;
class CastExprBitfields {
     unsigned : NumExprBits;
 
     unsigned Kind : 7;
     unsigned PartOfExplicitCast : 1; // Only set for ImplicitCastExpr.
 
     /// True if the call expression has some floating-point features.
     unsigned HasFPFeatures : 1;
 
+    /// Padding used by the derived classes to store various bits. If you
+    /// need to add some data here, shrink this padding and add your data
+    /// above. NumCastExprBits also needs to be updated.
+    unsigned : 32 - NumExprBits - 7 - 1 - 1;
+
     /// The number of CXXBaseSpecifiers in the cast. 14 bits would be enough
     /// here. ([implimits] Direct and indirect base classes [16384]).
     unsigned BasePathSize;
   };
 
+  enum { NumCastExprBits = NumExprBits + 7 + 1 + 1 };
+
   class BinaryOperatorBitfields {
     friend class BinaryOperator;
 
     unsigned : NumExprBits;
 
     unsigned Opc : 6;
 
     /// This is only meaningful for operations on floating point
     /// types when additional values need to be in trailing storage.
     /// It is 0 otherwise.
     unsigned HasFPFeatures : 1;
 
     SourceLocation OpLoc;
   };
 
+  class ShuffleVectorExprBitfields {
+    friend class ShuffleVectorExpr;
+
+    unsigned : NumExprBits;
+
+    unsigned NumExprs;
+  };
+
   class InitListExprBitfields {
     friend class InitListExpr;
 
     unsigned : NumExprBits;
 
     /// Whether this initializer list originally had a GNU array-range
     /// designator in it. This is a temporary marker used by CodeGen.
     unsigned HadArrayRangeDesignator : 1;
+
+    SourceLocation LBraceLoc;
   };
 
   class ParenListExprBitfields {
     friend class ASTStmtReader;
     friend class ParenListExpr;
 
     unsigned : NumExprBits;
 
     /// The number of expressions in the paren list.
     unsigned NumExprs;
   };
 
-  class GenericSelectionExprBitfields {
-    friend class ASTStmtReader;
-    friend class GenericSelectionExpr;
-
-    unsigned : NumExprBits;
-
-    /// The location of the "_Generic".
-    SourceLocation GenericLoc;
-  };
-
   class PseudoObjectExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class PseudoObjectExpr;
 
     unsigned : NumExprBits;
 
     // These don't need to be particularly wide, because they're
     // strictly limited by the forms of expressions we permit.
     unsigned NumSubExprs : 8;
     unsigned ResultIndex : 32 - 8 - NumExprBits;
   };
 
   class SourceLocExprBitfields {
     friend class ASTStmtReader;
     friend class SourceLocExpr;
 
     unsigned : NumExprBits;
 
     /// The kind of source location builtin represented by the SourceLocExpr.
-    /// Ex. __builtin_LINE, __builtin_FUNCTION, etc.
+    /// Ex. __builtin_LINE, __builtin_FUNCTION, ect.
     unsigned Kind : 3;
+
+    SourceLocation BuiltinLoc;
+  };
+
+  class DesignatedInitExprBitfields {
+    friend class ASTStmtReader;
+    friend class DesignatedInitExpr;
+
+    unsigned : NumExprBits;
+
+    /// Whether this designated initializer used the GNU deprecated
+    /// syntax rather than the C99 '=' syntax.
+    unsigned GNUSyntax : 1;
+
+    /// The number of designators in this initializer expression.
+    unsigned NumDesignators : 15;
+
+    /// The number of subexpressions of this initializer expression,
+    /// which contains both the initializer and any additional
+    /// expressions used by array and array-range designators.
+    unsigned NumSubExprs : 16;
+  };
+
+  class AtomicExprBitfields {
+    friend class ASTStmtReader;
+    friend class AtomicExpr;
+
+    unsigned : NumExprBits;
+
+    unsigned Op : 6;
+
+    unsigned NumSubExprs;
+  };
+
+  class RecoveryExprBitfields {
+    friend class ASTStmtReader;
+    friend class RecoveryExpr;
+
+    unsigned : NumExprBits;
+
+    unsigned NumExprs : 32 - NumExprBits;
+
+    SourceLocation BeginLoc;
   };
 
   class StmtExprBitfields {
     friend class ASTStmtReader;
     friend class StmtExpr;
 
     unsigned : NumExprBits;
 
     /// The number of levels of template parameters enclosing this statement
     /// expression. Used to determine if a statement expression remains
     /// dependent after instantiation.
     unsigned TemplateDepth;
   };
 
+  class ChooseExprBitfields {
+    friend class ASTStmtReader;
+    friend class ChooseExpr;
+
+    unsigned : NumExprBits;
+    unsigned CondIsTrue : 1;
+    SourceLocation BuiltinLoc;
+  };
+
   //===--- C++ Expression bitfields classes ---===//
 
   class CXXOperatorCallExprBitfields {
     friend class ASTStmtReader;
     friend class CXXOperatorCallExpr;
 
     unsigned : NumCallExprBits;
 
class CXXBoolLiteralExprBitfields {
 
     /// The value of the boolean literal.
     unsigned Value : 1;
 
     /// The location of the boolean literal.
     SourceLocation Loc;
   };
 
-  class CXXNullPtrLiteralExprBitfields {
-    friend class CXXNullPtrLiteralExpr;
+  class MSPropertyRefExprBitfields {
+    friend class ASTStmtReader;
+    friend class MSPropertyRefExpr;
 
     unsigned : NumExprBits;
 
-    /// The location of the null pointer literal.
-    SourceLocation Loc;
+    unsigned IsArrow : 1;
+    SourceLocation MemberLoc;
   };
 
   class CXXThisExprBitfields {
     friend class CXXThisExpr;
 
     unsigned : NumExprBits;
 
     /// Whether this is an implicit "this".
class CXXThrowExprBitfields {
 
     /// Whether the thrown variable (if any) is in scope.
     unsigned IsThrownVariableInScope : 1;
 
     /// The location of the "throw".
     SourceLocation ThrowLoc;
   };
 
-  class CXXDefaultArgExprBitfields {
-    friend class ASTStmtReader;
-    friend class CXXDefaultArgExpr;
-
-    unsigned : NumExprBits;
-
-    /// The location where the default argument expression was used.
-    SourceLocation Loc;
-  };
-
-  class CXXDefaultInitExprBitfields {
-    friend class ASTStmtReader;
-    friend class CXXDefaultInitExpr;
-
-    unsigned : NumExprBits;
-
-    /// The location where the default initializer expression was used.
-    SourceLocation Loc;
-  };
-
-  class CXXScalarValueInitExprBitfields {
-    friend class ASTStmtReader;
-    friend class CXXScalarValueInitExpr;
-
-    unsigned : NumExprBits;
-
-    SourceLocation RParenLoc;
-  };
-
   class CXXNewExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class CXXNewExpr;
 
     unsigned : NumExprBits;
 
     /// Was the usage ::new, i.e. is the global new to be used?
class CXXDeleteExprBitfields {
     /// Does the usual deallocation function for the element type require
     /// a size_t argument?
     unsigned UsualArrayDeleteWantsSize : 1;
 
     /// Location of the expression.
     SourceLocation Loc;
   };
 
+  class CXXPseudoDestructorExprBitfields {
+    friend class ASTStmtReader;
+    friend class CXXPseudoDestructorExpr;
+
+    unsigned : NumExprBits;
+
+    /// Whether the operator was an arrow ('->'); otherwise, it was a
+    /// period ('.').
+    unsigned IsArrow : 1;
+
+    /// The location of the '.' or '->' operator.
+    SourceLocation OperatorLoc;
+  };
+
   class TypeTraitExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class TypeTraitExpr;
 
     unsigned : NumExprBits;
 
     /// The kind of type trait, which is a value of a TypeTrait enumerator.
     unsigned Kind : 8;
 
     /// If this expression is not value-dependent, this indicates whether
     /// the trait evaluated true or false.
     unsigned Value : 1;
 
     /// The number of arguments to this type trait. According to [implimits]
     /// 8 bits would be enough, but we require (and test for) at least 16 bits
     /// to mirror FunctionType.
     unsigned NumArgs;
   };
 
+  class ArrayTypeTraitExprBitfields {
+    friend class ASTStmtReader;
+    friend class ArrayTypeTraitExpr;
+
+    unsigned : NumExprBits;
+
+    /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
+    unsigned ATT : 2;
+    /// The location of the type trait keyword.
+    SourceLocation Loc;
+  };
+
+  class ExpressionTraitExprBitfields {
+    friend class ASTStmtReader;
+    friend class ExpressionTraitExpr;
+
+    unsigned : NumExprBits;
+    /// The value of the type trait. Unspecified if dependent.
+    unsigned Value : 1;
+
+    /// The location of the type trait keyword.
+    SourceLocation Loc;
+  };
+
   class DependentScopeDeclRefExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class DependentScopeDeclRefExpr;
 
     unsigned : NumExprBits;
 
     /// Whether the name includes info for explicit template
class CXXConstructExprBitfields {
     unsigned ListInitialization : 1;
     unsigned StdInitListInitialization : 1;
     unsigned ZeroInitialization : 1;
     unsigned ConstructionKind : 3;
 
     SourceLocation Loc;
   };
 
+  class CXXInheritedCtorInitExprBitfields {
+    friend class ASTStmtReader;
+    friend class CXXInheritedCtorInitExpr;
+    unsigned : NumExprBits;
+
+    /// Whether this is the construction of a virtual base.
+    unsigned ConstructsVirtualBase : 1;
+
+    /// Whether the constructor is inherited from a virtual base class of the
+    /// class that we construct.
+    unsigned InheritedFromVirtualBase : 1;
+
+    /// The location of the using declaration.
+    SourceLocation Loc;
+  };
+
   class ExprWithCleanupsBitfields {
     friend class ASTStmtReader; // deserialization
     friend class ExprWithCleanups;
 
     unsigned : NumExprBits;
 
     // When false, it must not have side effects.
     unsigned CleanupsHaveSideEffects : 1;

 
   class CXXNoexceptExprBitfields {
     friend class ASTStmtReader;
     friend class CXXNoexceptExpr;
 
     unsigned : NumExprBits;
 
     unsigned Value : 1;
-  };
-
-  class SubstNonTypeTemplateParmExprBitfields {
-    friend class ASTStmtReader;
-    friend class SubstNonTypeTemplateParmExpr;
 
-    unsigned : NumExprBits;
-
-    /// The location of the non-type template parameter reference.
-    SourceLocation NameLoc;
+    SourceLocation KeywordLoc;
   };
 
   class LambdaExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class LambdaExpr;
 
     unsigned : NumExprBits;
 
     /// The default capture kind, which is a value of type
     /// LambdaCaptureDefault.
     unsigned CaptureDefault : 2;
 
     /// Whether this lambda had an explicit parameter list vs. an
     /// implicit (and empty) parameter list.
     unsigned ExplicitParams : 1;
 
     /// Whether this lambda had the result type explicitly specified.
     unsigned ExplicitResultType : 1;
 
     /// The number of captures.
     unsigned NumCaptures : 16;
   };
 
+  class CXXFoldExprBitfields {
+    friend class ASTStmtReader;
+    friend class CXXFoldExpr;
+
+    unsigned : NumExprBits;
+    unsigned Opcode : 6;
+    SourceLocation LParenLoc;
+  };
+
   class RequiresExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class RequiresExpr;
 
     unsigned : NumExprBits;
 
     unsigned IsSatisfied : 1;
     SourceLocation RequiresKWLoc;
   };
 
   //===--- C++ Coroutines TS bitfields classes ---===//
 
+  class CoroutineSuspendExprBitfields {
+    friend class CoroutineSuspendExpr;
+    friend class ASTStmtReader;
+
+    unsigned : NumExprBits;
+
+    unsigned : 32 - NumExprBits;
+
+    SourceLocation KeywordLoc;
+  };
+
+  enum { NumCoroutineSuspendExprBits = NumExprBits };
+
   class CoawaitExprBitfields {
     friend class CoawaitExpr;
 
-    unsigned : NumExprBits;
+    unsigned : NumCoroutineSuspendExprBits;
 
     unsigned IsImplicit : 1;
   };
 
+  static_assert(sizeof(CoawaitExprBitfields) <= 4,
+                "CoawaitExprBitfields must be <= than 4 bytes to"
+                "avoid trashing CoroutineSuspendExprBitfields::KeywordLoc!");
+
   //===--- Obj-C Expression bitfields classes ---===//
 
   class ObjCIndirectCopyRestoreExprBitfields {
     friend class ObjCIndirectCopyRestoreExpr;
 
     unsigned : NumExprBits;
 
     unsigned ShouldCopy : 1;
   };
 
+  class ObjCBoolLiteralExprBitfields {
+    friend class ObjCBoolLiteralExpr;
+
+    unsigned : NumExprBits;
+
+    unsigned Value : 1;
+    SourceLocation Loc;
+  };
+
+  class ObjCArrayLiteralBitfields {
+    friend class ObjCArrayLiteral;
+
+    unsigned : NumExprBits;
+
+    unsigned NumElements;
+  };
+
+  class ObjCDictionaryLiteralBitfields {
+    friend class ASTStmtReader;
+    friend class ASTStmtWriter;
+    friend class ObjCDictionaryLiteral;
+
+    unsigned : NumExprBits;
+
+    /// Determine whether this dictionary literal has any pack expansions.
+    ///
+    /// If the dictionary literal has pack expansions, then there will
+    /// be an array of pack expansion data following the array of
+    /// key/value pairs, which provide the locations of the ellipses (if
+    /// any) and number of elements in the expansion (if known). If
+    /// there are no pack expansions, we optimize away this storage.
+    unsigned HasPackExpansions : 1;
+
+    /// The number of elements in this dictionary literal.
+    unsigned NumElements;
+  };
+
+  class ObjCIvarRefExprBitfields {
+    friend class ObjCIvarRefExpr;
+
+    unsigned : NumExprBits;
+
+    // True if this is "X->F", false if this is "X.F".
+    unsigned IsArrow : 1;
+
+    // True if ivar reference has no base (self assumed).
+    unsigned IsFreeIvar : 1;
+
+    SourceLocation Loc;
+  };
+
+  class ObjCIsaExprBitfields {
+    friend class ObjCIsaExpr;
+
+    unsigned : NumExprBits;
+
+    /// IsArrow - True if this is "X->F", false if this is "X.F".
+    unsigned IsArrow : 1;
+
+    /// IsaMemberLoc - This is the location of the 'isa'.
+    SourceLocation IsaMemberLoc;
+  };
+
+  class ObjCBridgedCastExprBitfields {
+    friend class ASTStmtReader;
+    friend class ObjCBridgedCastExpr;
+
+    unsigned : NumCastExprBits;
+
+    unsigned Kind : 2;
+  };
+
+  static_assert(sizeof(ObjCBridgedCastExprBitfields) <= 4,
+                "ObjCBridgedCastExprBitfields must be <= than 4 bytes to"
+                "avoid trashing CastExprBitfields::BasePathSize!");
+
   //===--- Clang Extensions bitfields classes ---===//
 
   class OpaqueValueExprBitfields {
     friend class ASTStmtReader;
     friend class OpaqueValueExpr;
 
     unsigned : NumExprBits;
 
     /// The OVE is a unique semantic reference to its source expression if this
     /// bit is set to true.
     unsigned IsUnique : 1;
 
     SourceLocation Loc;
   };
 
   union {
     // Same order as in StmtNodes.td.
     // Statements
     StmtBitfields StmtBits;
+    StmtWithSourceLocBitfields StmtWithSourceLocBits;
     NullStmtBitfields NullStmtBits;
     CompoundStmtBitfields CompoundStmtBits;
     LabelStmtBitfields LabelStmtBits;
     AttributedStmtBitfields AttributedStmtBits;
     IfStmtBitfields IfStmtBits;
     SwitchStmtBitfields SwitchStmtBits;
     WhileStmtBitfields WhileStmtBits;
-    DoStmtBitfields DoStmtBits;
-    ForStmtBitfields ForStmtBits;
-    GotoStmtBitfields GotoStmtBits;
-    ContinueStmtBitfields ContinueStmtBits;
-    BreakStmtBitfields BreakStmtBits;
     ReturnStmtBitfields ReturnStmtBits;
     SwitchCaseBitfields SwitchCaseBits;
+    AsmStmtBitfields AsmStmtBits;
+    SEHTryStmtBitfields SEHTryStmtBits;
+    CapturedStmtBitfields CapturedStmtBits;
+
+    // C++ Statements
+    CXXTryStmtBitfields CXXTryStmtBits;
+    MSDependentExistsStmtBitfields MSDependentExistsStmtBits;
+    CoroutineBodyStmtBitfields CoroutineBodyStmtBits;
+    CoreturnStmtBitfields CoreturnStmtBits;
+
+    // ObjC Statements
+    ObjCAtTryStmtBitfields ObjCAtTryStmtBits;
 
     // Expressions
     ExprBitfields ExprBits;
+    ExprWithSourceLocBitFields ExprWithSourceLocBits;
     ConstantExprBitfields ConstantExprBits;
     PredefinedExprBitfields PredefinedExprBits;
     DeclRefExprBitfields DeclRefExprBits;
     FloatingLiteralBitfields FloatingLiteralBits;
+    FixedPointLiteralBitfields FixedPointLiteralBits;
     StringLiteralBitfields StringLiteralBits;
     CharacterLiteralBitfields CharacterLiteralBits;
     UnaryOperatorBitfields UnaryOperatorBits;
+    OffsetOfExprBitfields OffsetOfExprBits;
     UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits;
-    ArrayOrMatrixSubscriptExprBitfields ArrayOrMatrixSubscriptExprBits;
     CallExprBitfields CallExprBits;
     MemberExprBitfields MemberExprBits;
     CastExprBitfields CastExprBits;
     BinaryOperatorBitfields BinaryOperatorBits;
+    ShuffleVectorExprBitfields ShuffleVectorExprBits;
     InitListExprBitfields InitListExprBits;
     ParenListExprBitfields ParenListExprBits;
-    GenericSelectionExprBitfields GenericSelectionExprBits;
     PseudoObjectExprBitfields PseudoObjectExprBits;
     SourceLocExprBitfields SourceLocExprBits;
+    DesignatedInitExprBitfields DesignatedInitExprBits;
+    AtomicExprBitfields AtomicExprBits;
+    RecoveryExprBitfields RecoveryExprBits;
 
     // GNU Extensions.
     StmtExprBitfields StmtExprBits;
+    ChooseExprBitfields ChooseExprBits;
 
     // C++ Expressions
     CXXOperatorCallExprBitfields CXXOperatorCallExprBits;
     CXXRewrittenBinaryOperatorBitfields CXXRewrittenBinaryOperatorBits;
     CXXBoolLiteralExprBitfields CXXBoolLiteralExprBits;
-    CXXNullPtrLiteralExprBitfields CXXNullPtrLiteralExprBits;
+    MSPropertyRefExprBitfields MSPropertyRefExprBits;
     CXXThisExprBitfields CXXThisExprBits;
     CXXThrowExprBitfields CXXThrowExprBits;
-    CXXDefaultArgExprBitfields CXXDefaultArgExprBits;
-    CXXDefaultInitExprBitfields CXXDefaultInitExprBits;
-    CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits;
     CXXNewExprBitfields CXXNewExprBits;
     CXXDeleteExprBitfields CXXDeleteExprBits;
+    CXXPseudoDestructorExprBitfields CXXPseudoDestructorExprBits;
     TypeTraitExprBitfields TypeTraitExprBits;
+    ArrayTypeTraitExprBitfields ArrayTypeTraitExprBits;
+    ExpressionTraitExprBitfields ExpressionTraitExprBits;
     DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits;
     CXXConstructExprBitfields CXXConstructExprBits;
+    CXXInheritedCtorInitExprBitfields CXXInheritedCtorInitExprBits;
     ExprWithCleanupsBitfields ExprWithCleanupsBits;
     CXXUnresolvedConstructExprBitfields CXXUnresolvedConstructExprBits;
     CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits;
     OverloadExprBitfields OverloadExprBits;
     UnresolvedLookupExprBitfields UnresolvedLookupExprBits;
     UnresolvedMemberExprBitfields UnresolvedMemberExprBits;
     CXXNoexceptExprBitfields CXXNoexceptExprBits;
-    SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits;
     LambdaExprBitfields LambdaExprBits;
+    CXXFoldExprBitfields CXXFoldExprBits;
     RequiresExprBitfields RequiresExprBits;
 
     // C++ Coroutines TS expressions
+    CoroutineSuspendExprBitfields CoroutineSuspendExprBits;
     CoawaitExprBitfields CoawaitBits;
 
     // Obj-C Expressions
     ObjCIndirectCopyRestoreExprBitfields ObjCIndirectCopyRestoreExprBits;
+    ObjCBoolLiteralExprBitfields ObjCBoolLiteralExprBits;
+    ObjCArrayLiteralBitfields ObjCArrayLiteralBits;
+    ObjCDictionaryLiteralBitfields ObjCDictionaryLiteralBits;
+    ObjCIvarRefExprBitfields ObjCIvarRefExprBits;
+    ObjCIsaExprBitfields ObjCIsaExprBits;
+    ObjCBridgedCastExprBitfields ObjCBridgedCastExprBits;
 
     // Clang Extensions
     OpaqueValueExprBitfields OpaqueValueExprBits;
   };
 
 public:
   // Only allow allocation of Stmts using the allocator in ASTContext
   // or by doing a placement new.
public:
   }
 };
 
 /// LabelStmt - Represents a label, which has a substatement.  For example:
 ///    foo: return;
 class LabelStmt : public ValueStmt {
   LabelDecl *TheDecl;
   Stmt *SubStmt;
-  bool SideEntry = false;
 
 public:
   /// Build a label statement.
   LabelStmt(SourceLocation IL, LabelDecl *D, Stmt *substmt)
       : ValueStmt(LabelStmtClass), TheDecl(D), SubStmt(substmt) {
+    LabelStmtBits.SideEntry = false;
     setIdentLoc(IL);
   }
 
   /// Build an empty label statement.
   explicit LabelStmt(EmptyShell Empty) : ValueStmt(LabelStmtClass, Empty) {}
 
   SourceLocation getIdentLoc() const { return LabelStmtBits.IdentLoc; }
   void setIdentLoc(SourceLocation L) { LabelStmtBits.IdentLoc = L; }
public:
 
   const_child_range children() const {
     return const_child_range(&SubStmt, &SubStmt + 1);
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == LabelStmtClass;
   }
-  bool isSideEntry() const { return SideEntry; }
-  void setSideEntry(bool SE) { SideEntry = SE; }
+  bool isSideEntry() const { return LabelStmtBits.SideEntry; }
+  void setSideEntry(bool SE) { LabelStmtBits.SideEntry = SE; }
 };
 
 /// Represents an attribute applied to a statement.
 ///
 /// Represents an attribute applied to a statement. For example:
 ///   [[omp::for(...)]] for (...) { ... }
 class AttributedStmt final
     : public ValueStmt,
public:
   }
 
   void setCond(Expr *Cond) { SubExprs[COND] = reinterpret_cast<Stmt *>(Cond); }
 
   Stmt *getBody() { return SubExprs[BODY]; }
   const Stmt *getBody() const { return SubExprs[BODY]; }
   void setBody(Stmt *Body) { SubExprs[BODY] = Body; }
 
-  SourceLocation getDoLoc() const { return DoStmtBits.DoLoc; }
-  void setDoLoc(SourceLocation L) { DoStmtBits.DoLoc = L; }
+  SourceLocation getDoLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setDoLoc(SourceLocation L) { StmtWithSourceLocBits.Loc = L; }
   SourceLocation getWhileLoc() const { return WhileLoc; }
   void setWhileLoc(SourceLocation L) { WhileLoc = L; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getBeginLoc() const { return getDoLoc(); }
   SourceLocation getEndLoc() const { return getRParenLoc(); }
 
public:
   const Expr *getInc()  const { return reinterpret_cast<Expr*>(SubExprs[INC]); }
   const Stmt *getBody() const { return SubExprs[BODY]; }
 
   void setInit(Stmt *S) { SubExprs[INIT] = S; }
   void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); }
   void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); }
   void setBody(Stmt *S) { SubExprs[BODY] = S; }
 
-  SourceLocation getForLoc() const { return ForStmtBits.ForLoc; }
-  void setForLoc(SourceLocation L) { ForStmtBits.ForLoc = L; }
+  SourceLocation getForLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setForLoc(SourceLocation L) { StmtWithSourceLocBits.Loc = L; }
   SourceLocation getLParenLoc() const { return LParenLoc; }
   void setLParenLoc(SourceLocation L) { LParenLoc = L; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getBeginLoc() const { return getForLoc(); }
   SourceLocation getEndLoc() const { return getBody()->getEndLoc(); }
 
public:
   }
 
   /// Build an empty goto statement.
   explicit GotoStmt(EmptyShell Empty) : Stmt(GotoStmtClass, Empty) {}
 
   LabelDecl *getLabel() const { return Label; }
   void setLabel(LabelDecl *D) { Label = D; }
 
-  SourceLocation getGotoLoc() const { return GotoStmtBits.GotoLoc; }
-  void setGotoLoc(SourceLocation L) { GotoStmtBits.GotoLoc = L; }
+  SourceLocation getGotoLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setGotoLoc(SourceLocation L) { StmtWithSourceLocBits.Loc = L; }
   SourceLocation getLabelLoc() const { return LabelLoc; }
   void setLabelLoc(SourceLocation L) { LabelLoc = L; }
 
   SourceLocation getBeginLoc() const { return getGotoLoc(); }
   SourceLocation getEndLoc() const { return getLabelLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GotoStmtClass;
IndirectGotoStmt(SourceLocation gotoLoc, SourceLocation starLoc, Expr *target)
     setTarget(target);
     setGotoLoc(gotoLoc);
   }
 
   /// Build an empty indirect goto statement.
   explicit IndirectGotoStmt(EmptyShell Empty)
       : Stmt(IndirectGotoStmtClass, Empty) {}
 
-  void setGotoLoc(SourceLocation L) { GotoStmtBits.GotoLoc = L; }
-  SourceLocation getGotoLoc() const { return GotoStmtBits.GotoLoc; }
+  void setGotoLoc(SourceLocation L) { StmtWithSourceLocBits.Loc = L; }
+  SourceLocation getGotoLoc() const { return StmtWithSourceLocBits.Loc; }
   void setStarLoc(SourceLocation L) { StarLoc = L; }
   SourceLocation getStarLoc() const { return StarLoc; }
 
   Expr *getTarget() { return reinterpret_cast<Expr *>(Target); }
   const Expr *getTarget() const {
     return reinterpret_cast<const Expr *>(Target);
   }
   void setTarget(Expr *E) { Target = reinterpret_cast<Stmt *>(E); }

 public:
   ContinueStmt(SourceLocation CL) : Stmt(ContinueStmtClass) {
     setContinueLoc(CL);
   }
 
   /// Build an empty continue statement.
   explicit ContinueStmt(EmptyShell Empty) : Stmt(ContinueStmtClass, Empty) {}
 
-  SourceLocation getContinueLoc() const { return ContinueStmtBits.ContinueLoc; }
-  void setContinueLoc(SourceLocation L) { ContinueStmtBits.ContinueLoc = L; }
+  SourceLocation getContinueLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setContinueLoc(SourceLocation L) { StmtWithSourceLocBits.Loc = L; }
 
   SourceLocation getBeginLoc() const { return getContinueLoc(); }
   SourceLocation getEndLoc() const { return getContinueLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ContinueStmtClass;
   }
 

 public:
   BreakStmt(SourceLocation BL) : Stmt(BreakStmtClass) {
     setBreakLoc(BL);
   }
 
   /// Build an empty break statement.
   explicit BreakStmt(EmptyShell Empty) : Stmt(BreakStmtClass, Empty) {}
 
-  SourceLocation getBreakLoc() const { return BreakStmtBits.BreakLoc; }
-  void setBreakLoc(SourceLocation L) { BreakStmtBits.BreakLoc = L; }
+  SourceLocation getBreakLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setBreakLoc(SourceLocation L) { StmtWithSourceLocBits.Loc = L; }
 
   SourceLocation getBeginLoc() const { return getBreakLoc(); }
   SourceLocation getEndLoc() const { return getBreakLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == BreakStmtClass;
   }
 
public:
   }
 };
 
 /// AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
 class AsmStmt : public Stmt {
 protected:
   friend class ASTStmtReader;
 
-  SourceLocation AsmLoc;
-
-  /// True if the assembly statement does not have any input or output
-  /// operands.
-  bool IsSimple;
-
-  /// If true, treat this inline assembly as having side effects.
-  /// This assembly statement should not be optimized, deleted or moved.
-  bool IsVolatile;
-
-  unsigned NumOutputs;
   unsigned NumInputs;
   unsigned NumClobbers;
 
   Stmt **Exprs = nullptr;
 
   AsmStmt(StmtClass SC, SourceLocation asmloc, bool issimple, bool isvolatile,
           unsigned numoutputs, unsigned numinputs, unsigned numclobbers)
-      : Stmt (SC), AsmLoc(asmloc), IsSimple(issimple), IsVolatile(isvolatile),
-        NumOutputs(numoutputs), NumInputs(numinputs),
-        NumClobbers(numclobbers) {}
+      : Stmt(SC), NumInputs(numinputs), NumClobbers(numclobbers) {
+    AsmStmtBits.AsmLoc = asmloc;
+    AsmStmtBits.IsSimple = issimple;
+    AsmStmtBits.IsVolatile = isvolatile;
+    AsmStmtBits.NumOutputs = numoutputs;
+  }
 
 public:
   /// Build an empty inline-assembly statement.
   explicit AsmStmt(StmtClass SC, EmptyShell Empty) : Stmt(SC, Empty) {}
 
-  SourceLocation getAsmLoc() const { return AsmLoc; }
-  void setAsmLoc(SourceLocation L) { AsmLoc = L; }
+  SourceLocation getAsmLoc() const { return AsmStmtBits.AsmLoc; }
+  void setAsmLoc(SourceLocation L) { AsmStmtBits.AsmLoc = L; }
 
-  bool isSimple() const { return IsSimple; }
-  void setSimple(bool V) { IsSimple = V; }
+  bool isSimple() const { return AsmStmtBits.IsSimple; }
+  void setSimple(bool V) { AsmStmtBits.IsSimple = V; }
 
-  bool isVolatile() const { return IsVolatile; }
-  void setVolatile(bool V) { IsVolatile = V; }
+  bool isVolatile() const { return AsmStmtBits.IsVolatile; }
+  void setVolatile(bool V) { AsmStmtBits.IsVolatile = V; }
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return {}; }
   SourceLocation getEndLoc() const LLVM_READONLY { return {}; }
 
   //===--- Asm String Analysis ---===//
 
   /// Assemble final IR asm string.
   std::string generateAsmString(const ASTContext &C) const;
 
   //===--- Output operands ---===//
 
-  unsigned getNumOutputs() const { return NumOutputs; }
+  unsigned getNumOutputs() const { return AsmStmtBits.NumOutputs; }
 
   /// getOutputConstraint - Return the constraint string for the specified
   /// output operand.  All output constraints are known to be non-empty (either
   /// '=' or '+').
   StringRef getOutputConstraint(unsigned i) const;
 
   /// isOutputPlusConstraint - Return true if the specified output constraint
   /// is a "+" constraint (which is both an input and an output) or false if it
public:
 
   // Input expr iterators.
 
   using inputs_iterator = ExprIterator;
   using const_inputs_iterator = ConstExprIterator;
   using inputs_range = llvm::iterator_range<inputs_iterator>;
   using inputs_const_range = llvm::iterator_range<const_inputs_iterator>;
 
-  inputs_iterator begin_inputs() {
-    return &Exprs[0] + NumOutputs;
-  }
+  inputs_iterator begin_inputs() { return &Exprs[0] + AsmStmtBits.NumOutputs; }
 
   inputs_iterator end_inputs() {
-    return &Exprs[0] + NumOutputs + NumInputs;
+    return &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs;
   }
 
   inputs_range inputs() { return inputs_range(begin_inputs(), end_inputs()); }
 
   const_inputs_iterator begin_inputs() const {
-    return &Exprs[0] + NumOutputs;
+    return &Exprs[0] + AsmStmtBits.NumOutputs;
   }
 
   const_inputs_iterator end_inputs() const {
-    return &Exprs[0] + NumOutputs + NumInputs;
+    return &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs;
   }
 
   inputs_const_range inputs() const {
     return inputs_const_range(begin_inputs(), end_inputs());
   }
 
   // Output expr iterators.
 
   using outputs_iterator = ExprIterator;
   using const_outputs_iterator = ConstExprIterator;
   using outputs_range = llvm::iterator_range<outputs_iterator>;
   using outputs_const_range = llvm::iterator_range<const_outputs_iterator>;
 
   outputs_iterator begin_outputs() {
     return &Exprs[0];
   }
 
-  outputs_iterator end_outputs() {
-    return &Exprs[0] + NumOutputs;
-  }
+  outputs_iterator end_outputs() { return &Exprs[0] + AsmStmtBits.NumOutputs; }
 
   outputs_range outputs() {
     return outputs_range(begin_outputs(), end_outputs());
   }
 
   const_outputs_iterator begin_outputs() const {
     return &Exprs[0];
   }
 
   const_outputs_iterator end_outputs() const {
-    return &Exprs[0] + NumOutputs;
+    return &Exprs[0] + AsmStmtBits.NumOutputs;
   }
 
   outputs_const_range outputs() const {
     return outputs_const_range(begin_outputs(), end_outputs());
   }
 
   child_range children() {
-    return child_range(&Exprs[0], &Exprs[0] + NumOutputs + NumInputs);
+    return child_range(&Exprs[0],
+                       &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs);
   }
 
   const_child_range children() const {
-    return const_child_range(&Exprs[0], &Exprs[0] + NumOutputs + NumInputs);
+    return const_child_range(&Exprs[0],
+                             &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs);
   }
 };
 
 /// This represents a GCC inline-assembly statement extension.
 class GCCAsmStmt : public AsmStmt {
   friend class ASTStmtReader;
 
   SourceLocation RParenLoc;
public:
 
   const Expr *getOutputExpr(unsigned i) const {
     return const_cast<GCCAsmStmt*>(this)->getOutputExpr(i);
   }
 
   //===--- Input operands ---===//
 
   IdentifierInfo *getInputIdentifier(unsigned i) const {
-    return Names[i + NumOutputs];
+    return Names[i + AsmStmtBits.NumOutputs];
   }
 
   StringRef getInputName(unsigned i) const {
     if (IdentifierInfo *II = getInputIdentifier(i))
       return II->getName();
 
     return {};
   }
 
   StringRef getInputConstraint(unsigned i) const;
 
   const StringLiteral *getInputConstraintLiteral(unsigned i) const {
-    return Constraints[i + NumOutputs];
+    return Constraints[i + AsmStmtBits.NumOutputs];
   }
   StringLiteral *getInputConstraintLiteral(unsigned i) {
-    return Constraints[i + NumOutputs];
+    return Constraints[i + AsmStmtBits.NumOutputs];
   }
 
   Expr *getInputExpr(unsigned i);
   void setInputExpr(unsigned i, Expr *E);
 
   const Expr *getInputExpr(unsigned i) const {
     return const_cast<GCCAsmStmt*>(this)->getInputExpr(i);
   }
 
   //===--- Labels ---===//
 
   bool isAsmGoto() const {
     return NumLabels > 0;
   }
 
   unsigned getNumLabels() const {
     return NumLabels;
   }
 
   IdentifierInfo *getLabelIdentifier(unsigned i) const {
-    return Names[i + NumOutputs + NumInputs];
+    return Names[i + AsmStmtBits.NumOutputs + NumInputs];
   }
 
   AddrLabelExpr *getLabelExpr(unsigned i) const;
   StringRef getLabelName(unsigned i) const;
   using labels_iterator = CastIterator<AddrLabelExpr>;
   using const_labels_iterator = ConstCastIterator<AddrLabelExpr>;
   using labels_range = llvm::iterator_range<labels_iterator>;
   using labels_const_range = llvm::iterator_range<const_labels_iterator>;
 
   labels_iterator begin_labels() {
-    return &Exprs[0] + NumOutputs + NumInputs;
+    return &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs;
   }
 
   labels_iterator end_labels() {
-    return &Exprs[0] + NumOutputs + NumInputs + NumLabels;
+    return &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs + NumLabels;
   }
 
   labels_range labels() {
     return labels_range(begin_labels(), end_labels());
   }
 
   const_labels_iterator begin_labels() const {
-    return &Exprs[0] + NumOutputs + NumInputs;
+    return &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs;
   }
 
   const_labels_iterator end_labels() const {
-    return &Exprs[0] + NumOutputs + NumInputs + NumLabels;
+    return &Exprs[0] + AsmStmtBits.NumOutputs + NumInputs + NumLabels;
   }
 
   labels_const_range labels() const {
     return labels_const_range(begin_labels(), end_labels());
   }
 
 private:
   void setOutputsAndInputsAndClobbers(const ASTContext &C,
public:
 
   StringRef getClobber(unsigned i) const;
 
   StringLiteral *getClobberStringLiteral(unsigned i) { return Clobbers[i]; }
   const StringLiteral *getClobberStringLiteral(unsigned i) const {
     return Clobbers[i];
   }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AsmLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return AsmStmtBits.AsmLoc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GCCAsmStmtClass;
   }
 };
 
 /// This represents a Microsoft inline-assembly statement extension.
public:
   StringRef getAsmString() const { return AsmStr; }
 
   /// Assemble final IR asm string.
   std::string generateAsmString(const ASTContext &C) const;
 
   //===--- Output operands ---===//
 
   StringRef getOutputConstraint(unsigned i) const {
-    assert(i < NumOutputs);
+    assert(i < AsmStmtBits.NumOutputs);
     return Constraints[i];
   }
 
   Expr *getOutputExpr(unsigned i);
 
   const Expr *getOutputExpr(unsigned i) const {
     return const_cast<MSAsmStmt*>(this)->getOutputExpr(i);
   }
 
   //===--- Input operands ---===//
 
   StringRef getInputConstraint(unsigned i) const {
     assert(i < NumInputs);
-    return Constraints[i + NumOutputs];
+    return Constraints[i + AsmStmtBits.NumOutputs];
   }
 
   Expr *getInputExpr(unsigned i);
   void setInputExpr(unsigned i, Expr *E);
 
   const Expr *getInputExpr(unsigned i) const {
     return const_cast<MSAsmStmt*>(this)->getInputExpr(i);
   }
 
   //===--- Other ---===//
 
   ArrayRef<StringRef> getAllConstraints() const {
-    return llvm::makeArrayRef(Constraints, NumInputs + NumOutputs);
+    return llvm::makeArrayRef(Constraints, NumInputs + AsmStmtBits.NumOutputs);
   }
 
   ArrayRef<StringRef> getClobbers() const {
     return llvm::makeArrayRef(Clobbers, NumClobbers);
   }
 
   ArrayRef<Expr*> getAllExprs() const {
-    return llvm::makeArrayRef(reinterpret_cast<Expr**>(Exprs),
-                              NumInputs + NumOutputs);
+    return llvm::makeArrayRef(reinterpret_cast<Expr **>(Exprs),
+                              NumInputs + AsmStmtBits.NumOutputs);
   }
 
   StringRef getClobber(unsigned i) const { return getClobbers()[i]; }
 
 private:
   void initialize(const ASTContext &C, StringRef AsmString,
                   ArrayRef<Token> AsmToks, ArrayRef<StringRef> Constraints,
                   ArrayRef<Expr*> Exprs, ArrayRef<StringRef> Clobbers);
 
 public:
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AsmLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return AsmStmtBits.AsmLoc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MSAsmStmtClass;
   }
 
   child_range children() {
-    return child_range(&Exprs[0], &Exprs[NumInputs + NumOutputs]);
+    return child_range(&Exprs[0], &Exprs[NumInputs + AsmStmtBits.NumOutputs]);
   }
 
   const_child_range children() const {
-    return const_child_range(&Exprs[0], &Exprs[NumInputs + NumOutputs]);
+    return const_child_range(&Exprs[0],
+                             &Exprs[NumInputs + AsmStmtBits.NumOutputs]);
   }
 };
 
 class SEHExceptStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
 
-  SourceLocation  Loc;
   Stmt *Children[2];
 
   enum { FILTER_EXPR, BLOCK };
 
   SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block);
   explicit SEHExceptStmt(EmptyShell E) : Stmt(SEHExceptStmtClass, E) {}
 
 public:
   static SEHExceptStmt* Create(const ASTContext &C,
                                SourceLocation ExceptLoc,
                                Expr *FilterExpr,
                                Stmt *Block);
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return getExceptLoc(); }
 
-  SourceLocation getExceptLoc() const { return Loc; }
+  SourceLocation getExceptLoc() const { return StmtWithSourceLocBits.Loc; }
   SourceLocation getEndLoc() const { return getBlock()->getEndLoc(); }
 
   Expr *getFilterExpr() const {
     return reinterpret_cast<Expr*>(Children[FILTER_EXPR]);
   }
 
   CompoundStmt *getBlock() const {
     return cast<CompoundStmt>(Children[BLOCK]);
static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHExceptStmtClass;
   }
 };
 
 class SEHFinallyStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
 
-  SourceLocation  Loc;
   Stmt *Block;
 
   SEHFinallyStmt(SourceLocation Loc, Stmt *Block);
   explicit SEHFinallyStmt(EmptyShell E) : Stmt(SEHFinallyStmtClass, E) {}
 
 public:
   static SEHFinallyStmt* Create(const ASTContext &C,
                                 SourceLocation FinallyLoc,
                                 Stmt *Block);
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return getFinallyLoc(); }
 
-  SourceLocation getFinallyLoc() const { return Loc; }
+  SourceLocation getFinallyLoc() const { return StmtWithSourceLocBits.Loc; }
   SourceLocation getEndLoc() const { return Block->getEndLoc(); }
 
   CompoundStmt *getBlock() const { return cast<CompoundStmt>(Block); }
 
   child_range children() {
     return child_range(&Block,&Block+1);
   }
 
   const_child_range children() const {
     return const_child_range(&Block, &Block + 1);
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHFinallyStmtClass;
   }
 };
 
 class SEHTryStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
 
-  bool IsCXXTry;
-  SourceLocation  TryLoc;
   Stmt *Children[2];
 
   enum { TRY = 0, HANDLER = 1 };
 
   SEHTryStmt(bool isCXXTry, // true if 'try' otherwise '__try'
              SourceLocation TryLoc,
              Stmt *TryBlock,
              Stmt *Handler);
 
   explicit SEHTryStmt(EmptyShell E) : Stmt(SEHTryStmtClass, E) {}
 
 public:
   static SEHTryStmt* Create(const ASTContext &C, bool isCXXTry,
                             SourceLocation TryLoc, Stmt *TryBlock,
                             Stmt *Handler);
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return getTryLoc(); }
 
-  SourceLocation getTryLoc() const { return TryLoc; }
+  SourceLocation getTryLoc() const { return SEHTryStmtBits.TryLoc; }
   SourceLocation getEndLoc() const { return Children[HANDLER]->getEndLoc(); }
 
-  bool getIsCXXTry() const { return IsCXXTry; }
+  bool getIsCXXTry() const { return SEHTryStmtBits.IsCXXTry; }
 
   CompoundStmt* getTryBlock() const {
     return cast<CompoundStmt>(Children[TRY]);
   }
 
   Stmt *getHandler() const { return Children[HANDLER]; }
 
   /// Returns 0 if not defined
public:
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHTryStmtClass;
   }
 };
 
 /// Represents a __leave statement.
 class SEHLeaveStmt : public Stmt {
-  SourceLocation LeaveLoc;
-
 public:
-  explicit SEHLeaveStmt(SourceLocation LL)
-      : Stmt(SEHLeaveStmtClass), LeaveLoc(LL) {}
+  explicit SEHLeaveStmt(SourceLocation LL) : Stmt(SEHLeaveStmtClass) {
+    StmtWithSourceLocBits.Loc = LL;
+  }
 
   /// Build an empty __leave statement.
   explicit SEHLeaveStmt(EmptyShell Empty) : Stmt(SEHLeaveStmtClass, Empty) {}
 
-  SourceLocation getLeaveLoc() const { return LeaveLoc; }
-  void setLeaveLoc(SourceLocation L) { LeaveLoc = L; }
+  SourceLocation getLeaveLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setLeaveLoc(SourceLocation L) { StmtWithSourceLocBits.Loc = L; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return LeaveLoc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return LeaveLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHLeaveStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
public:
 
     /// Retrieve the declaration of the variable being captured.
     ///
     /// This operation is only valid if this capture captures a variable.
     VarDecl *getCapturedVar() const;
   };
 
 private:
-  /// The number of variable captured, including 'this'.
-  unsigned NumCaptures;
-
   /// The pointer part is the implicit the outlined function and the
   /// int part is the captured region kind, 'CR_Default' etc.
   llvm::PointerIntPair<CapturedDecl *, 2, CapturedRegionKind> CapDeclAndKind;
 
   /// The record for captured variables, a RecordDecl or CXXRecordDecl.
   RecordDecl *TheRecordDecl = nullptr;
 
   /// Construct a captured statement.
   CapturedStmt(Stmt *S, CapturedRegionKind Kind, ArrayRef<Capture> Captures,
                ArrayRef<Expr *> CaptureInits, CapturedDecl *CD, RecordDecl *RD);
 
   /// Construct an empty captured statement.
   CapturedStmt(EmptyShell Empty, unsigned NumCaptures);
 
   Stmt **getStoredStmts() { return reinterpret_cast<Stmt **>(this + 1); }
 
   Stmt *const *getStoredStmts() const {
     return reinterpret_cast<Stmt *const *>(this + 1);
   }
 
   Capture *getStoredCaptures() const;
 
-  void setCapturedStmt(Stmt *S) { getStoredStmts()[NumCaptures] = S; }
+  void setCapturedStmt(Stmt *S) {
+    getStoredStmts()[CapturedStmtBits.NumCaptures] = S;
+  }
 
 public:
   friend class ASTStmtReader;
 
   static CapturedStmt *Create(const ASTContext &Context, Stmt *S,
                               CapturedRegionKind Kind,
                               ArrayRef<Capture> Captures,
                               ArrayRef<Expr *> CaptureInits,
                               CapturedDecl *CD, RecordDecl *RD);
 
   static CapturedStmt *CreateDeserialized(const ASTContext &Context,
                                           unsigned NumCaptures);
 
   /// Retrieve the statement being captured.
-  Stmt *getCapturedStmt() { return getStoredStmts()[NumCaptures]; }
-  const Stmt *getCapturedStmt() const { return getStoredStmts()[NumCaptures]; }
+  Stmt *getCapturedStmt() {
+    return getStoredStmts()[CapturedStmtBits.NumCaptures];
+  }
+  const Stmt *getCapturedStmt() const {
+    return getStoredStmts()[CapturedStmtBits.NumCaptures];
+  }
 
   /// Retrieve the outlined function declaration.
   CapturedDecl *getCapturedDecl();
   const CapturedDecl *getCapturedDecl() const;
 
   /// Set the outlined function declaration.
   void setCapturedDecl(CapturedDecl *D);
 
public:
 
   /// Retrieve an iterator pointing to the first capture.
   capture_iterator capture_begin() { return getStoredCaptures(); }
   const_capture_iterator capture_begin() const { return getStoredCaptures(); }
 
   /// Retrieve an iterator pointing past the end of the sequence of
   /// captures.
   capture_iterator capture_end() const {
-    return getStoredCaptures() + NumCaptures;
+    return getStoredCaptures() + CapturedStmtBits.NumCaptures;
   }
 
   /// Retrieve the number of captures, including 'this'.
-  unsigned capture_size() const { return NumCaptures; }
+  unsigned capture_size() const { return CapturedStmtBits.NumCaptures; }
 
   /// Iterator that walks over the capture initialization arguments.
   using capture_init_iterator = Expr **;
   using capture_init_range = llvm::iterator_range<capture_init_iterator>;
 
   /// Const iterator that walks over the capture initialization
   /// arguments.
   using const_capture_init_iterator = Expr *const *;
public:
 
   const_capture_init_iterator capture_init_begin() const {
     return reinterpret_cast<Expr *const *>(getStoredStmts());
   }
 
   /// Retrieve the iterator pointing one past the last initialization
   /// argument.
   capture_init_iterator capture_init_end() {
-    return capture_init_begin() + NumCaptures;
+    return capture_init_begin() + CapturedStmtBits.NumCaptures;
   }
 
   const_capture_init_iterator capture_init_end() const {
-    return capture_init_begin() + NumCaptures;
+    return capture_init_begin() + CapturedStmtBits.NumCaptures;
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getCapturedStmt()->getBeginLoc();
   }
 
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getCapturedStmt()->getEndLoc();

clang/include/clang/AST/StmtCXX.h

 
 namespace clang {
 
 class VarDecl;
 
 /// CXXCatchStmt - This represents a C++ catch block.
 ///
 class CXXCatchStmt : public Stmt {
-  SourceLocation CatchLoc;
   /// The exception-declaration of the type.
   VarDecl *ExceptionDecl;
   /// The handler block.
   Stmt *HandlerBlock;
 
 public:
   CXXCatchStmt(SourceLocation catchLoc, VarDecl *exDecl, Stmt *handlerBlock)
-  : Stmt(CXXCatchStmtClass), CatchLoc(catchLoc), ExceptionDecl(exDecl),
-    HandlerBlock(handlerBlock) {}
+      : Stmt(CXXCatchStmtClass), ExceptionDecl(exDecl),
+        HandlerBlock(handlerBlock) {
+    StmtWithSourceLocBits.Loc = catchLoc;
+  }
 
   CXXCatchStmt(EmptyShell Empty)
   : Stmt(CXXCatchStmtClass), ExceptionDecl(nullptr), HandlerBlock(nullptr) {}
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return CatchLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return HandlerBlock->getEndLoc();
   }
 
-  SourceLocation getCatchLoc() const { return CatchLoc; }
+  SourceLocation getCatchLoc() const { return StmtWithSourceLocBits.Loc; }
   VarDecl *getExceptionDecl() const { return ExceptionDecl; }
   QualType getCaughtType() const;
   Stmt *getHandlerBlock() const { return HandlerBlock; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXCatchStmtClass;
   }
 

 /// CXXTryStmt - A C++ try block, including all handlers.
 ///
 class CXXTryStmt final : public Stmt,
                          private llvm::TrailingObjects<CXXTryStmt, Stmt *> {
 
   friend TrailingObjects;
   friend class ASTStmtReader;
 
-  SourceLocation TryLoc;
-  unsigned NumHandlers;
-  size_t numTrailingObjects(OverloadToken<Stmt *>) const { return NumHandlers; }
+  size_t numTrailingObjects(OverloadToken<Stmt *>) const {
+    return CXXTryStmtBits.NumHandlers;
+  }
 
   CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock, ArrayRef<Stmt*> handlers);
-  CXXTryStmt(EmptyShell Empty, unsigned numHandlers)
-    : Stmt(CXXTryStmtClass), NumHandlers(numHandlers) { }
+  CXXTryStmt(EmptyShell Empty, unsigned numHandlers) : Stmt(CXXTryStmtClass) {
+    CXXTryStmtBits.NumHandlers = numHandlers;
+  }
 
   Stmt *const *getStmts() const { return getTrailingObjects<Stmt *>(); }
   Stmt **getStmts() { return getTrailingObjects<Stmt *>(); }
 
 public:
   static CXXTryStmt *Create(const ASTContext &C, SourceLocation tryLoc,
                             Stmt *tryBlock, ArrayRef<Stmt*> handlers);
 
   static CXXTryStmt *Create(const ASTContext &C, EmptyShell Empty,
                             unsigned numHandlers);
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return getTryLoc(); }
 
-  SourceLocation getTryLoc() const { return TryLoc; }
+  SourceLocation getTryLoc() const { return CXXTryStmtBits.TryLoc; }
   SourceLocation getEndLoc() const {
-    return getStmts()[NumHandlers]->getEndLoc();
+    return getStmts()[CXXTryStmtBits.NumHandlers]->getEndLoc();
   }
 
   CompoundStmt *getTryBlock() {
     return cast<CompoundStmt>(getStmts()[0]);
   }
   const CompoundStmt *getTryBlock() const {
     return cast<CompoundStmt>(getStmts()[0]);
   }
 
-  unsigned getNumHandlers() const { return NumHandlers; }
+  unsigned getNumHandlers() const { return CXXTryStmtBits.NumHandlers; }
   CXXCatchStmt *getHandler(unsigned i) {
     return cast<CXXCatchStmt>(getStmts()[i + 1]);
   }
   const CXXCatchStmt *getHandler(unsigned i) const {
     return cast<CXXCatchStmt>(getStmts()[i + 1]);
   }
 
   static bool classof(const Stmt *T) {

 /// CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for
 /// statement, represented as 'for (range-declarator : range-expression)'
 /// or 'for (init-statement range-declarator : range-expression)'.
 ///
 /// This is stored in a partially-desugared form to allow full semantic
 /// analysis of the constituent components. The original syntactic components
 /// can be extracted using getLoopVariable and getRangeInit.
 class CXXForRangeStmt : public Stmt {
-  SourceLocation ForLoc;
   enum { INIT, RANGE, BEGINSTMT, ENDSTMT, COND, INC, LOOPVAR, BODY, END };
   // SubExprs[RANGE] is an expression or declstmt.
   // SubExprs[COND] and SubExprs[INC] are expressions.
   Stmt *SubExprs[END];
   SourceLocation CoawaitLoc;
   SourceLocation ColonLoc;
   SourceLocation RParenLoc;
 
public:
   void setRangeStmt(Stmt *S) { SubExprs[RANGE] = S; }
   void setBeginStmt(Stmt *S) { SubExprs[BEGINSTMT] = S; }
   void setEndStmt(Stmt *S) { SubExprs[ENDSTMT] = S; }
   void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); }
   void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); }
   void setLoopVarStmt(Stmt *S) { SubExprs[LOOPVAR] = S; }
   void setBody(Stmt *S) { SubExprs[BODY] = S; }
 
-  SourceLocation getForLoc() const { return ForLoc; }
+  SourceLocation getForLoc() const { return StmtWithSourceLocBits.Loc; }
   SourceLocation getCoawaitLoc() const { return CoawaitLoc; }
   SourceLocation getColonLoc() const { return ColonLoc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return ForLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return SubExprs[BODY]->getEndLoc();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXForRangeStmtClass;
   }
 

 /// statements whose name is dependent. All non-dependent cases are handled
 /// directly in the parser, so that they don't introduce a new scope. Clang
 /// introduces scopes in the dependent case to keep names inside the compound
 /// statement from leaking out into the surround statements, which would
 /// compromise the template instantiation model. This behavior differs from
 /// Visual C++ (which never introduces a scope), but is a fairly reasonable
 /// approximation of the VC++ behavior.
 class MSDependentExistsStmt : public Stmt {
-  SourceLocation KeywordLoc;
-  bool IsIfExists;
+
   NestedNameSpecifierLoc QualifierLoc;
   DeclarationNameInfo NameInfo;
   Stmt *SubStmt;
 
   friend class ASTReader;
   friend class ASTStmtReader;
 
 public:
   MSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists,
                         NestedNameSpecifierLoc QualifierLoc,
-                        DeclarationNameInfo NameInfo,
-                        CompoundStmt *SubStmt)
-  : Stmt(MSDependentExistsStmtClass),
-    KeywordLoc(KeywordLoc), IsIfExists(IsIfExists),
-    QualifierLoc(QualifierLoc), NameInfo(NameInfo),
-    SubStmt(reinterpret_cast<Stmt *>(SubStmt)) { }
+                        DeclarationNameInfo NameInfo, CompoundStmt *SubStmt)
+      : Stmt(MSDependentExistsStmtClass), QualifierLoc(QualifierLoc),
+        NameInfo(NameInfo), SubStmt(reinterpret_cast<Stmt *>(SubStmt)) {
+    MSDependentExistsStmtBits.KeywordLoc = KeywordLoc;
+    MSDependentExistsStmtBits.IsIfExists = IsIfExists;
+  }
 
   /// Retrieve the location of the __if_exists or __if_not_exists
   /// keyword.
-  SourceLocation getKeywordLoc() const { return KeywordLoc; }
+  SourceLocation getKeywordLoc() const {
+    return MSDependentExistsStmtBits.KeywordLoc;
+  }
 
   /// Determine whether this is an __if_exists statement.
-  bool isIfExists() const { return IsIfExists; }
+  bool isIfExists() const { return MSDependentExistsStmtBits.IsIfExists; }
 
   /// Determine whether this is an __if_exists statement.
-  bool isIfNotExists() const { return !IsIfExists; }
+  bool isIfNotExists() const { return !MSDependentExistsStmtBits.IsIfExists; }
 
   /// Retrieve the nested-name-specifier that qualifies this name, if
   /// any.
   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
 
   /// Retrieve the name of the entity we're testing for, along with
   /// location information
   DeclarationNameInfo getNameInfo() const { return NameInfo; }
 
   /// Retrieve the compound statement that will be included in the
   /// program only if the existence of the symbol matches the initial keyword.
   CompoundStmt *getSubStmt() const {
     return reinterpret_cast<CompoundStmt *>(SubStmt);
   }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return MSDependentExistsStmtBits.KeywordLoc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return SubStmt->getEndLoc();
   }
 
   child_range children() {
     return child_range(&SubStmt, &SubStmt+1);
   }
 
enum SubStmt {
     OnFallthrough, ///< Handler for control flow falling off the body.
     Allocate,      ///< Coroutine frame memory allocation.
     Deallocate,    ///< Coroutine frame memory deallocation.
     ReturnValue,   ///< Return value for thunk function: p.get_return_object().
     ReturnStmt,    ///< Return statement for the thunk function.
     ReturnStmtOnAllocFailure, ///< Return statement if allocation failed.
     FirstParamMove ///< First offset for move construction of parameter copies.
   };
-  unsigned NumParams;
 
   friend class ASTStmtReader;
   friend class ASTReader;
   friend TrailingObjects;
 
   Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
 
   Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
Expr *getReturnValue() const {
     auto *RS = cast<clang::ReturnStmt>(getReturnStmt());
     return RS->getRetValue();
   }
   Stmt *getReturnStmt() const { return getStoredStmts()[SubStmt::ReturnStmt]; }
   Stmt *getReturnStmtOnAllocFailure() const {
     return getStoredStmts()[SubStmt::ReturnStmtOnAllocFailure];
   }
   ArrayRef<Stmt const *> getParamMoves() const {
-    return {getStoredStmts() + SubStmt::FirstParamMove, NumParams};
+    return {getStoredStmts() + SubStmt::FirstParamMove,
+            CoroutineBodyStmtBits.NumParams};
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getBody() ? getBody()->getBeginLoc()
                      : getPromiseDecl()->getBeginLoc();
   }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getBody() ? getBody()->getEndLoc() : getPromiseDecl()->getEndLoc();
   }
 
   child_range children() {
-    return child_range(getStoredStmts(),
-                       getStoredStmts() + SubStmt::FirstParamMove + NumParams);
+    return child_range(getStoredStmts(), getStoredStmts() +
+                                             SubStmt::FirstParamMove +
+                                             CoroutineBodyStmtBits.NumParams);
   }
 
   const_child_range children() const {
-    return const_child_range(getStoredStmts(), getStoredStmts() +
-                                                   SubStmt::FirstParamMove +
-                                                   NumParams);
+    return const_child_range(getStoredStmts(),
+                             getStoredStmts() + SubStmt::FirstParamMove +
+                                 CoroutineBodyStmtBits.NumParams);
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CoroutineBodyStmtClass;
   }
 };
 
 /// Represents a 'co_return' statement in the C++ Coroutines TS.
 ///
 /// This statament models the initialization of the coroutine promise
 /// (encapsulating the eventual notional return value) from an expression
 /// (or braced-init-list), followed by termination of the coroutine.
 ///
 /// This initialization is modeled by the evaluation of the operand
 /// followed by a call to one of:
 ///   <promise>.return_value(<operand>)
 ///   <promise>.return_void()
 /// which we name the "promise call".
 class CoreturnStmt : public Stmt {
-  SourceLocation CoreturnLoc;
 
   enum SubStmt { Operand, PromiseCall, Count };
   Stmt *SubStmts[SubStmt::Count];
 
-  bool IsImplicit : 1;
-
   friend class ASTStmtReader;
 public:
   CoreturnStmt(SourceLocation CoreturnLoc, Stmt *Operand, Stmt *PromiseCall,
                bool IsImplicit = false)
-      : Stmt(CoreturnStmtClass), CoreturnLoc(CoreturnLoc),
-        IsImplicit(IsImplicit) {
+      : Stmt(CoreturnStmtClass) {
+    CoreturnStmtBits.CoreturnLoc = CoreturnLoc;
+    CoreturnStmtBits.IsImplicit = IsImplicit;
     SubStmts[SubStmt::Operand] = Operand;
     SubStmts[SubStmt::PromiseCall] = PromiseCall;
   }
 
   CoreturnStmt(EmptyShell) : CoreturnStmt({}, {}, {}) {}
 
-  SourceLocation getKeywordLoc() const { return CoreturnLoc; }
+  SourceLocation getKeywordLoc() const { return CoreturnStmtBits.CoreturnLoc; }
 
   /// Retrieve the operand of the 'co_return' statement. Will be nullptr
   /// if none was specified.
   Expr *getOperand() const { return static_cast<Expr*>(SubStmts[Operand]); }
 
   /// Retrieve the promise call that results from this 'co_return'
   /// statement. Will be nullptr if either the coroutine has not yet been
   /// finalized or the coroutine has no eventual return type.
   Expr *getPromiseCall() const {
     return static_cast<Expr*>(SubStmts[PromiseCall]);
   }
 
-  bool isImplicit() const { return IsImplicit; }
-  void setIsImplicit(bool value = true) { IsImplicit = value; }
+  bool isImplicit() const { return CoreturnStmtBits.IsImplicit; }
+  void setIsImplicit(bool value = true) { CoreturnStmtBits.IsImplicit = value; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return CoreturnLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return CoreturnStmtBits.CoreturnLoc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getOperand() ? getOperand()->getEndLoc() : getBeginLoc();
   }
 
   child_range children() {
     if (!getOperand())
       return child_range(SubStmts + SubStmt::PromiseCall,
                          SubStmts + SubStmt::Count);

clang/include/clang/AST/StmtObjC.h

public:
 
   const_child_range children() const {
     return const_child_range(&Body, &Body + 1);
   }
 };
 
 /// Represents Objective-C's \@finally statement
 class ObjCAtFinallyStmt : public Stmt {
-  SourceLocation AtFinallyLoc;
   Stmt *AtFinallyStmt;
 
 public:
   ObjCAtFinallyStmt(SourceLocation atFinallyLoc, Stmt *atFinallyStmt)
-      : Stmt(ObjCAtFinallyStmtClass), AtFinallyLoc(atFinallyLoc),
-        AtFinallyStmt(atFinallyStmt) {}
+      : Stmt(ObjCAtFinallyStmtClass), AtFinallyStmt(atFinallyStmt) {
+    StmtWithSourceLocBits.Loc = atFinallyLoc;
+  }
 
   explicit ObjCAtFinallyStmt(EmptyShell Empty) :
     Stmt(ObjCAtFinallyStmtClass, Empty) { }
 
   const Stmt *getFinallyBody() const { return AtFinallyStmt; }
   Stmt *getFinallyBody() { return AtFinallyStmt; }
   void setFinallyBody(Stmt *S) { AtFinallyStmt = S; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AtFinallyLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return AtFinallyStmt->getEndLoc();
   }
 
-  SourceLocation getAtFinallyLoc() const { return AtFinallyLoc; }
-  void setAtFinallyLoc(SourceLocation Loc) { AtFinallyLoc = Loc; }
+  SourceLocation getAtFinallyLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setAtFinallyLoc(SourceLocation Loc) { StmtWithSourceLocBits.Loc = Loc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCAtFinallyStmtClass;
   }
 
   child_range children() {
     return child_range(&AtFinallyStmt, &AtFinallyStmt+1);
   }
 
   const_child_range children() const {
     return const_child_range(&AtFinallyStmt, &AtFinallyStmt + 1);
   }
 };
 
 /// Represents Objective-C's \@try ... \@catch ... \@finally statement.
 class ObjCAtTryStmt final
     : public Stmt,
       private llvm::TrailingObjects<ObjCAtTryStmt, Stmt *> {
   friend TrailingObjects;
   size_t numTrailingObjects(OverloadToken<Stmt *>) const {
-    return 1 + NumCatchStmts + HasFinally;
+    return 1 + ObjCAtTryStmtBits.NumCatchStmts + ObjCAtTryStmtBits.HasFinally;
   }
 
-  // The location of the @ in the \@try.
-  SourceLocation AtTryLoc;
-
-  // The number of catch blocks in this statement.
-  unsigned NumCatchStmts : 16;
-
-  // Whether this statement has a \@finally statement.
-  bool HasFinally : 1;
-
   /// Retrieve the statements that are stored after this \@try statement.
   ///
   /// The order of the statements in memory follows the order in the source,
   /// with the \@try body first, followed by the \@catch statements (if any)
   /// and, finally, the \@finally (if it exists).
   Stmt **getStmts() { return getTrailingObjects<Stmt *>(); }
   Stmt *const *getStmts() const { return getTrailingObjects<Stmt *>(); }
 
   ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
                 Stmt **CatchStmts, unsigned NumCatchStmts,
                 Stmt *atFinallyStmt);
 
   explicit ObjCAtTryStmt(EmptyShell Empty, unsigned NumCatchStmts,
                          bool HasFinally)
-    : Stmt(ObjCAtTryStmtClass, Empty), NumCatchStmts(NumCatchStmts),
-      HasFinally(HasFinally) { }
+      : Stmt(ObjCAtTryStmtClass, Empty) {
+    ObjCAtTryStmtBits.NumCatchStmts = NumCatchStmts;
+    ObjCAtTryStmtBits.HasFinally = HasFinally;
+  }
 
 public:
   static ObjCAtTryStmt *Create(const ASTContext &Context,
                                SourceLocation atTryLoc, Stmt *atTryStmt,
                                Stmt **CatchStmts, unsigned NumCatchStmts,
                                Stmt *atFinallyStmt);
   static ObjCAtTryStmt *CreateEmpty(const ASTContext &Context,
                                     unsigned NumCatchStmts, bool HasFinally);
 
   /// Retrieve the location of the @ in the \@try.
-  SourceLocation getAtTryLoc() const { return AtTryLoc; }
-  void setAtTryLoc(SourceLocation Loc) { AtTryLoc = Loc; }
+  SourceLocation getAtTryLoc() const { return ObjCAtTryStmtBits.AtTryLoc; }
+  void setAtTryLoc(SourceLocation Loc) { ObjCAtTryStmtBits.AtTryLoc = Loc; }
 
   /// Retrieve the \@try body.
   const Stmt *getTryBody() const { return getStmts()[0]; }
   Stmt *getTryBody() { return getStmts()[0]; }
   void setTryBody(Stmt *S) { getStmts()[0] = S; }
 
   /// Retrieve the number of \@catch statements in this try-catch-finally
   /// block.
-  unsigned getNumCatchStmts() const { return NumCatchStmts; }
+  unsigned getNumCatchStmts() const { return ObjCAtTryStmtBits.NumCatchStmts; }
 
   /// Retrieve a \@catch statement.
   const ObjCAtCatchStmt *getCatchStmt(unsigned I) const {
-    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
+    assert(I < ObjCAtTryStmtBits.NumCatchStmts && "Out-of-bounds @catch index");
     return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]);
   }
 
   /// Retrieve a \@catch statement.
   ObjCAtCatchStmt *getCatchStmt(unsigned I) {
-    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
+    assert(I < ObjCAtTryStmtBits.NumCatchStmts && "Out-of-bounds @catch index");
     return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]);
   }
 
   /// Set a particular catch statement.
   void setCatchStmt(unsigned I, ObjCAtCatchStmt *S) {
-    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
+    assert(I < ObjCAtTryStmtBits.NumCatchStmts && "Out-of-bounds @catch index");
     getStmts()[I + 1] = S;
   }
 
   /// Retrieve the \@finally statement, if any.
   const ObjCAtFinallyStmt *getFinallyStmt() const {
-    if (!HasFinally)
+    if (!ObjCAtTryStmtBits.HasFinally)
       return nullptr;
 
-    return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
+    return cast_or_null<ObjCAtFinallyStmt>(
+        getStmts()[1 + ObjCAtTryStmtBits.NumCatchStmts]);
   }
   ObjCAtFinallyStmt *getFinallyStmt() {
-    if (!HasFinally)
+    if (!ObjCAtTryStmtBits.HasFinally)
       return nullptr;
 
-    return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
+    return cast_or_null<ObjCAtFinallyStmt>(
+        getStmts()[1 + ObjCAtTryStmtBits.NumCatchStmts]);
   }
   void setFinallyStmt(Stmt *S) {
-    assert(HasFinally && "@try does not have a @finally slot!");
-    getStmts()[1 + NumCatchStmts] = S;
+    assert(ObjCAtTryStmtBits.HasFinally &&
+           "@try does not have a @finally slot!");
+    getStmts()[1 + ObjCAtTryStmtBits.NumCatchStmts] = S;
   }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AtTryLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return ObjCAtTryStmtBits.AtTryLoc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY;
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCAtTryStmtClass;
   }
 
   child_range children() {
     return child_range(
         getStmts(), getStmts() + numTrailingObjects(OverloadToken<Stmt *>()));
   }
 
   const_child_range children() const {
     return const_child_range(const_cast<ObjCAtTryStmt *>(this)->children());
   }
 
   using catch_stmt_iterator = CastIterator<ObjCAtCatchStmt>;
   using const_catch_stmt_iterator = ConstCastIterator<ObjCAtCatchStmt>;
   using catch_range = llvm::iterator_range<catch_stmt_iterator>;
   using catch_const_range = llvm::iterator_range<const_catch_stmt_iterator>;
 
   catch_stmt_iterator catch_stmts_begin() { return getStmts() + 1; }
   catch_stmt_iterator catch_stmts_end() {
-    return catch_stmts_begin() + NumCatchStmts;
+    return catch_stmts_begin() + ObjCAtTryStmtBits.NumCatchStmts;
   }
   catch_range catch_stmts() {
     return catch_range(catch_stmts_begin(), catch_stmts_end());
   }
 
   const_catch_stmt_iterator catch_stmts_begin() const { return getStmts() + 1; }
   const_catch_stmt_iterator catch_stmts_end() const {
-    return catch_stmts_begin() + NumCatchStmts;
+    return catch_stmts_begin() + ObjCAtTryStmtBits.NumCatchStmts;
   }
   catch_const_range catch_stmts() const {
     return catch_const_range(catch_stmts_begin(), catch_stmts_end());
   }
 };
 
 /// Represents Objective-C's \@synchronized statement.
 ///
 /// Example:
 /// \code
 ///   @synchronized (sem) {
 ///     do-something;
 ///   }
 /// \endcode
 class ObjCAtSynchronizedStmt : public Stmt {
 private:
-  SourceLocation AtSynchronizedLoc;
   enum { SYNC_EXPR, SYNC_BODY, END_EXPR };
   Stmt* SubStmts[END_EXPR];
 
 public:
   ObjCAtSynchronizedStmt(SourceLocation atSynchronizedLoc, Stmt *synchExpr,
                          Stmt *synchBody)
   : Stmt(ObjCAtSynchronizedStmtClass) {
     SubStmts[SYNC_EXPR] = synchExpr;
     SubStmts[SYNC_BODY] = synchBody;
-    AtSynchronizedLoc = atSynchronizedLoc;
+    StmtWithSourceLocBits.Loc = atSynchronizedLoc;
   }
   explicit ObjCAtSynchronizedStmt(EmptyShell Empty) :
     Stmt(ObjCAtSynchronizedStmtClass, Empty) { }
 
-  SourceLocation getAtSynchronizedLoc() const { return AtSynchronizedLoc; }
-  void setAtSynchronizedLoc(SourceLocation Loc) { AtSynchronizedLoc = Loc; }
+  SourceLocation getAtSynchronizedLoc() const {
+    return StmtWithSourceLocBits.Loc;
+  }
+  void setAtSynchronizedLoc(SourceLocation Loc) {
+    StmtWithSourceLocBits.Loc = Loc;
+  }
 
   const CompoundStmt *getSynchBody() const {
     return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
   }
   CompoundStmt *getSynchBody() {
     return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
   }
   void setSynchBody(Stmt *S) { SubStmts[SYNC_BODY] = S; }
 
   const Expr *getSynchExpr() const {
     return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
   }
   Expr *getSynchExpr() {
     return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
   }
   void setSynchExpr(Stmt *S) { SubStmts[SYNC_EXPR] = S; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AtSynchronizedLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getSynchBody()->getEndLoc();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCAtSynchronizedStmtClass;
   }
 
   child_range children() {
     return child_range(&SubStmts[0], &SubStmts[0]+END_EXPR);
   }
 
   const_child_range children() const {
     return const_child_range(&SubStmts[0], &SubStmts[0] + END_EXPR);
   }
 };
 
 /// Represents Objective-C's \@throw statement.
 class ObjCAtThrowStmt : public Stmt {
-  SourceLocation AtThrowLoc;
   Stmt *Throw;
 
 public:
   ObjCAtThrowStmt(SourceLocation atThrowLoc, Stmt *throwExpr)
   : Stmt(ObjCAtThrowStmtClass), Throw(throwExpr) {
-    AtThrowLoc = atThrowLoc;
+    StmtWithSourceLocBits.Loc = atThrowLoc;
   }
   explicit ObjCAtThrowStmt(EmptyShell Empty) :
     Stmt(ObjCAtThrowStmtClass, Empty) { }
 
   const Expr *getThrowExpr() const { return reinterpret_cast<Expr*>(Throw); }
   Expr *getThrowExpr() { return reinterpret_cast<Expr*>(Throw); }
   void setThrowExpr(Stmt *S) { Throw = S; }
 
-  SourceLocation getThrowLoc() const LLVM_READONLY { return AtThrowLoc; }
-  void setThrowLoc(SourceLocation Loc) { AtThrowLoc = Loc; }
+  SourceLocation getThrowLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
+  void setThrowLoc(SourceLocation Loc) { StmtWithSourceLocBits.Loc = Loc; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AtThrowLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
-    return Throw ? Throw->getEndLoc() : AtThrowLoc;
+    return Throw ? Throw->getEndLoc() : StmtWithSourceLocBits.Loc;
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCAtThrowStmtClass;
   }
 
   child_range children() { return child_range(&Throw, &Throw+1); }
 
   const_child_range children() const {
     return const_child_range(&Throw, &Throw + 1);
   }
 };
 
 /// Represents Objective-C's \@autoreleasepool Statement
 class ObjCAutoreleasePoolStmt : public Stmt {
-  SourceLocation AtLoc;
   Stmt *SubStmt;
 
 public:
   ObjCAutoreleasePoolStmt(SourceLocation atLoc, Stmt *subStmt)
-      : Stmt(ObjCAutoreleasePoolStmtClass), AtLoc(atLoc), SubStmt(subStmt) {}
+      : Stmt(ObjCAutoreleasePoolStmtClass), SubStmt(subStmt) {
+    StmtWithSourceLocBits.Loc = atLoc;
+  }
 
   explicit ObjCAutoreleasePoolStmt(EmptyShell Empty) :
     Stmt(ObjCAutoreleasePoolStmtClass, Empty) { }
 
   const Stmt *getSubStmt() const { return SubStmt; }
   Stmt *getSubStmt() { return SubStmt; }
   void setSubStmt(Stmt *S) { SubStmt = S; }
 
-  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return StmtWithSourceLocBits.Loc;
+  }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return SubStmt->getEndLoc();
   }
 
-  SourceLocation getAtLoc() const { return AtLoc; }
-  void setAtLoc(SourceLocation Loc) { AtLoc = Loc; }
+  SourceLocation getAtLoc() const { return StmtWithSourceLocBits.Loc; }
+  void setAtLoc(SourceLocation Loc) { StmtWithSourceLocBits.Loc = Loc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCAutoreleasePoolStmtClass;
   }
 
   child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
 
   const_child_range children() const {
     return const_child_range(&SubStmt, &SubStmt + 1);
   }
 };
 
 }  // end namespace clang
 
 #endif

clang/lib/AST/Expr.cpp

 }
 
 SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(SourceLocation OpLoc,
                                                    SourceLocation LParen,
                                                    SourceLocation RParen,
                                                    QualType ResultTy,
                                                    TypeSourceInfo *TSI)
     : Expr(SYCLUniqueStableNameExprClass, ResultTy, VK_PRValue, OK_Ordinary),
-      OpLoc(OpLoc), LParen(LParen), RParen(RParen) {
+      LParen(LParen), RParen(RParen) {
+  ExprWithSourceLocBits.Loc = OpLoc;
   setTypeSourceInfo(TSI);
   setDependence(computeDependence(this));
 }
 
 SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(EmptyShell Empty,
                                                    QualType ResultTy)
     : Expr(SYCLUniqueStableNameExprClass, ResultTy, VK_PRValue, OK_Ordinary) {}
 

 IntegerLiteral *
 IntegerLiteral::Create(const ASTContext &C, EmptyShell Empty) {
   return new (C) IntegerLiteral(Empty);
 }
 
 FixedPointLiteral::FixedPointLiteral(const ASTContext &C, const llvm::APInt &V,
                                      QualType type, SourceLocation l,
                                      unsigned Scale)
-    : Expr(FixedPointLiteralClass, type, VK_PRValue, OK_Ordinary), Loc(l),
-      Scale(Scale) {
+    : Expr(FixedPointLiteralClass, type, VK_PRValue, OK_Ordinary) {
   assert(type->isFixedPointType() && "Illegal type in FixedPointLiteral");
   assert(V.getBitWidth() == C.getTypeInfo(type).Width &&
          "Fixed point type is not the correct size for constant.");
+  FixedPointLiteralBits.Loc = l;
+  FixedPointLiteralBits.Scale = Scale;
   setValue(C, V);
   setDependence(ExprDependence::None);
 }
 
 FixedPointLiteral *FixedPointLiteral::CreateFromRawInt(const ASTContext &C,
                                                        const llvm::APInt &V,
                                                        QualType type,
                                                        SourceLocation l,
                                                        unsigned Scale) {
   return new (C) FixedPointLiteral(C, V, type, l, Scale);
 }
 
 FixedPointLiteral *FixedPointLiteral::Create(const ASTContext &C,
                                              EmptyShell Empty) {
   return new (C) FixedPointLiteral(Empty);
 }
 
 std::string FixedPointLiteral::getValueAsString(unsigned Radix) const {
   // Currently the longest decimal number that can be printed is the max for an
   // unsigned long _Accum: 4294967295.99999999976716935634613037109375
   // which is 43 characters.
   SmallString<64> S;
-  FixedPointValueToString(
-      S, llvm::APSInt::getUnsigned(getValue().getZExtValue()), Scale);
+  FixedPointValueToString(S,
+                          llvm::APSInt::getUnsigned(getValue().getZExtValue()),
+                          FixedPointLiteralBits.Scale);
   return std::string(S.str());
 }
 
 void CharacterLiteral::print(unsigned Val, CharacterKind Kind,
                              raw_ostream &OS) {
   switch (Kind) {
   case CharacterLiteral::Ascii:
     break; // no prefix.
else if (Val <= 0xFFFF)
       OS << "'\\u" << llvm::format("%04x", Val) << "'";
     else
       OS << "'\\U" << llvm::format("%08x", Val) << "'";
   }
 }
 
 FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V,
                                  bool isexact, QualType Type, SourceLocation L)
-    : Expr(FloatingLiteralClass, Type, VK_PRValue, OK_Ordinary), Loc(L) {
+    : Expr(FloatingLiteralClass, Type, VK_PRValue, OK_Ordinary) {
   setSemantics(V.getSemantics());
   FloatingLiteralBits.IsExact = isexact;
+  FloatingLiteralBits.Loc = L;
   setValue(C, V);
   setDependence(ExprDependence::None);
 }
 
 FloatingLiteral::FloatingLiteral(const ASTContext &C, EmptyShell Empty)
   : Expr(FloatingLiteralClass, Empty) {
   setRawSemantics(llvm::APFloatBase::S_IEEEhalf);
   FloatingLiteralBits.IsExact = false;
OffsetOfExpr *OffsetOfExpr::CreateEmpty(const ASTContext &C,
   return new (Mem) OffsetOfExpr(numComps, numExprs);
 }
 
 OffsetOfExpr::OffsetOfExpr(const ASTContext &C, QualType type,
                            SourceLocation OperatorLoc, TypeSourceInfo *tsi,
                            ArrayRef<OffsetOfNode> comps, ArrayRef<Expr *> exprs,
                            SourceLocation RParenLoc)
     : Expr(OffsetOfExprClass, type, VK_PRValue, OK_Ordinary),
-      OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
-      NumComps(comps.size()), NumExprs(exprs.size()) {
+      OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi) {
+  OffsetOfExprBits.NumComps = comps.size();
+  OffsetOfExprBits.NumExprs = exprs.size();
   for (unsigned i = 0; i != comps.size(); ++i)
     setComponent(i, comps[i]);
   for (unsigned i = 0; i != exprs.size(); ++i)
     setIndexExpr(i, exprs[i]);
 
   setDependence(computeDependence(this));
 }
 
 IdentifierInfo *OffsetOfNode::getFieldName() const {
   assert(getKind() == Field || getKind() == Identifier);
   if (getKind() == Field)
     return getField()->getIdentifier();
 
   return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
 }
 
 UnaryExprOrTypeTraitExpr::UnaryExprOrTypeTraitExpr(
     UnaryExprOrTypeTrait ExprKind, Expr *E, QualType resultType,
     SourceLocation op, SourceLocation rp)
     : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_PRValue, OK_Ordinary),
-      OpLoc(op), RParenLoc(rp) {
+      RParenLoc(rp) {
   assert(ExprKind <= UETT_Last && "invalid enum value!");
   UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
+  UnaryExprOrTypeTraitExprBits.OpLoc = op;
   assert(static_cast<unsigned>(ExprKind) == UnaryExprOrTypeTraitExprBits.Kind &&
          "UnaryExprOrTypeTraitExprBits.Kind overflow!");
   UnaryExprOrTypeTraitExprBits.IsType = false;
   Argument.Ex = E;
   setDependence(computeDependence(this));
 }
 
 MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
bool BinaryOperator::isNullPointerArithmeticExtension(ASTContext &Ctx,
   return true;
 }
 
 SourceLocExpr::SourceLocExpr(const ASTContext &Ctx, IdentKind Kind,
                              QualType ResultTy, SourceLocation BLoc,
                              SourceLocation RParenLoc,
                              DeclContext *ParentContext)
     : Expr(SourceLocExprClass, ResultTy, VK_PRValue, OK_Ordinary),
-      BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {
+      RParenLoc(RParenLoc), ParentContext(ParentContext) {
   SourceLocExprBits.Kind = Kind;
+  SourceLocExprBits.BuiltinLoc = BLoc;
   setDependence(ExprDependence::None);
 }
 
 StringRef SourceLocExpr::getBuiltinStr() const {
   switch (getIdentKind()) {
   case File:
     return "__builtin_FILE";
   case Function:
APValue SourceLocExpr::EvaluateInContext(const ASTContext &Ctx,
   }
   }
   llvm_unreachable("unhandled case");
 }
 
 InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
                            ArrayRef<Expr *> initExprs, SourceLocation rbraceloc)
     : Expr(InitListExprClass, QualType(), VK_PRValue, OK_Ordinary),
-      InitExprs(C, initExprs.size()), LBraceLoc(lbraceloc),
-      RBraceLoc(rbraceloc), AltForm(nullptr, true) {
+      InitExprs(C, initExprs.size()), RBraceLoc(rbraceloc),
+      AltForm(nullptr, true) {
+  InitListExprBits.LBraceLoc = lbraceloc;
   sawArrayRangeDesignator(false);
   InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end());
 
   setDependence(computeDependence(this));
 }
 
 void InitListExpr::reserveInits(const ASTContext &C, unsigned NumInits) {
   if (NumInits > InitExprs.size())
bool InitListExpr::isIdiomaticZeroInitializer(const LangOptions &LangOpts) const {
 
   const IntegerLiteral *Lit = dyn_cast<IntegerLiteral>(getInit(0)->IgnoreImplicit());
   return Lit && Lit->getValue() == 0;
 }
 
 SourceLocation InitListExpr::getBeginLoc() const {
   if (InitListExpr *SyntacticForm = getSyntacticForm())
     return SyntacticForm->getBeginLoc();
-  SourceLocation Beg = LBraceLoc;
+  SourceLocation Beg = InitListExprBits.LBraceLoc;
   if (Beg.isInvalid()) {
     // Find the first non-null initializer.
     for (InitExprsTy::const_iterator I = InitExprs.begin(),
                                      E = InitExprs.end();
       I != E; ++I) {
       if (Stmt *S = *I) {
         Beg = S->getBeginLoc();
         break;
for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
     Elts.push_back(Index);
   }
 }
 
 ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr *> args,
                                      QualType Type, SourceLocation BLoc,
                                      SourceLocation RP)
     : Expr(ShuffleVectorExprClass, Type, VK_PRValue, OK_Ordinary),
-      BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
+      BuiltinLoc(BLoc), RParenLoc(RP) {
+  ShuffleVectorExprBits.NumExprs = args.size();
   SubExprs = new (C) Stmt*[args.size()];
   for (unsigned i = 0; i != args.size(); i++)
     SubExprs[i] = args[i];
 
   setDependence(computeDependence(this));
 }
 
 void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) {
   if (SubExprs) C.Deallocate(SubExprs);
 
-  this->NumExprs = Exprs.size();
-  SubExprs = new (C) Stmt*[NumExprs];
+  ShuffleVectorExprBits.NumExprs = Exprs.size();
+  SubExprs = new (C) Stmt *[ShuffleVectorExprBits.NumExprs];
   memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size());
 }
 
 GenericSelectionExpr::GenericSelectionExpr(
     const ASTContext &, SourceLocation GenericLoc, Expr *ControllingExpr,
     ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
     SourceLocation DefaultLoc, SourceLocation RParenLoc,
     bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
     : Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
            AssocExprs[ResultIndex]->getValueKind(),
            AssocExprs[ResultIndex]->getObjectKind()),
       NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
       DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
   assert(AssocTypes.size() == AssocExprs.size() &&
          "Must have the same number of association expressions"
          " and TypeSourceInfo!");
   assert(ResultIndex < NumAssocs && "ResultIndex is out-of-bounds!");
 
-  GenericSelectionExprBits.GenericLoc = GenericLoc;
+  ExprWithSourceLocBits.Loc = GenericLoc;
   getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
   std::copy(AssocExprs.begin(), AssocExprs.end(),
             getTrailingObjects<Stmt *>() + AssocExprStartIndex);
   std::copy(AssocTypes.begin(), AssocTypes.end(),
             getTrailingObjects<TypeSourceInfo *>());
 
   setDependence(computeDependence(this, ContainsUnexpandedParameterPack));
 }
 
 GenericSelectionExpr::GenericSelectionExpr(
     const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
     ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
     SourceLocation DefaultLoc, SourceLocation RParenLoc,
     bool ContainsUnexpandedParameterPack)
     : Expr(GenericSelectionExprClass, Context.DependentTy, VK_PRValue,
            OK_Ordinary),
       NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
       DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
   assert(AssocTypes.size() == AssocExprs.size() &&
          "Must have the same number of association expressions"
          " and TypeSourceInfo!");
 
-  GenericSelectionExprBits.GenericLoc = GenericLoc;
+  ExprWithSourceLocBits.Loc = GenericLoc;
   getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
   std::copy(AssocExprs.begin(), AssocExprs.end(),
             getTrailingObjects<Stmt *>() + AssocExprStartIndex);
   std::copy(AssocTypes.begin(), AssocTypes.end(),
             getTrailingObjects<TypeSourceInfo *>());
 
   setDependence(computeDependence(this, ContainsUnexpandedParameterPack));
 }

 
 DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty,
                                        llvm::ArrayRef<Designator> Designators,
                                        SourceLocation EqualOrColonLoc,
                                        bool GNUSyntax,
                                        ArrayRef<Expr *> IndexExprs, Expr *Init)
     : Expr(DesignatedInitExprClass, Ty, Init->getValueKind(),
            Init->getObjectKind()),
-      EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
-      NumDesignators(Designators.size()), NumSubExprs(IndexExprs.size() + 1) {
-  this->Designators = new (C) Designator[NumDesignators];
+      EqualOrColonLoc(EqualOrColonLoc) {
+  DesignatedInitExprBits.GNUSyntax = GNUSyntax;
+  DesignatedInitExprBits.NumDesignators = Designators.size();
+  DesignatedInitExprBits.NumSubExprs = IndexExprs.size() + 1;
+  this->Designators = new (C) Designator[DesignatedInitExprBits.NumDesignators];
 
   // Record the initializer itself.
   child_iterator Child = child_begin();
   *Child++ = Init;
 
   // Copy the designators and their subexpressions, computing
   // value-dependence along the way.
   unsigned IndexIdx = 0;
-  for (unsigned I = 0; I != NumDesignators; ++I) {
+  for (unsigned I = 0; I != DesignatedInitExprBits.NumDesignators; ++I) {
     this->Designators[I] = Designators[I];
     if (this->Designators[I].isArrayDesignator()) {
       // Copy the index expressions into permanent storage.
       *Child++ = IndexExprs[IndexIdx++];
     } else if (this->Designators[I].isArrayRangeDesignator()) {
       // Copy the start/end expressions into permanent storage.
       *Child++ = IndexExprs[IndexIdx++];
       *Child++ = IndexExprs[IndexIdx++];
void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
                          alignof(DesignatedInitExpr));
   return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
 }
 
 void DesignatedInitExpr::setDesignators(const ASTContext &C,
                                         const Designator *Desigs,
                                         unsigned NumDesigs) {
   Designators = new (C) Designator[NumDesigs];
-  NumDesignators = NumDesigs;
+  DesignatedInitExprBits.NumDesignators = NumDesigs;
   for (unsigned I = 0; I != NumDesigs; ++I)
     Designators[I] = Desigs[I];
 }
 
 SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
   DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
   if (size() == 1)
     return DIE->getDesignator(0)->getSourceRange();
   return SourceRange(DIE->getDesignator(0)->getBeginLoc(),
                      DIE->getDesignator(size() - 1)->getEndLoc());
 }
 
 SourceLocation DesignatedInitExpr::getBeginLoc() const {
   SourceLocation StartLoc;
   auto *DIE = const_cast<DesignatedInitExpr *>(this);
   Designator &First = *DIE->getDesignator(0);
   if (First.isFieldDesignator())
-    StartLoc = GNUSyntax ? First.Field.FieldLoc : First.Field.DotLoc;
+    StartLoc = DesignatedInitExprBits.GNUSyntax ? First.Field.FieldLoc
+                                                : First.Field.DotLoc;
   else
     StartLoc = First.ArrayOrRange.LBracketLoc;
   return StartLoc;
 }
 
 SourceLocation DesignatedInitExpr::getEndLoc() const {
   return getInit()->getEndLoc();
 }

 /// Replaces the designator at index @p Idx with the series
 /// of designators in [First, Last).
 void DesignatedInitExpr::ExpandDesignator(const ASTContext &C, unsigned Idx,
                                           const Designator *First,
                                           const Designator *Last) {
   unsigned NumNewDesignators = Last - First;
   if (NumNewDesignators == 0) {
     std::copy_backward(Designators + Idx + 1,
-                       Designators + NumDesignators,
+                       Designators + DesignatedInitExprBits.NumDesignators,
                        Designators + Idx);
     --NumNewDesignators;
     return;
   }
   if (NumNewDesignators == 1) {
     Designators[Idx] = *First;
     return;
   }
 
-  Designator *NewDesignators
-    = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
+  Designator *NewDesignators = new (C)
+      Designator[DesignatedInitExprBits.NumDesignators - 1 + NumNewDesignators];
   std::copy(Designators, Designators + Idx, NewDesignators);
   std::copy(First, Last, NewDesignators + Idx);
-  std::copy(Designators + Idx + 1, Designators + NumDesignators,
+  std::copy(Designators + Idx + 1,
+            Designators + DesignatedInitExprBits.NumDesignators,
             NewDesignators + Idx + NumNewDesignators);
   Designators = NewDesignators;
-  NumDesignators = NumDesignators - 1 + NumNewDesignators;
+  DesignatedInitExprBits.NumDesignators =
+      DesignatedInitExprBits.NumDesignators - 1 + NumNewDesignators;
 }
 
 DesignatedInitUpdateExpr::DesignatedInitUpdateExpr(const ASTContext &C,
                                                    SourceLocation lBraceLoc,
                                                    Expr *baseExpr,
                                                    SourceLocation rBraceLoc)
     : Expr(DesignatedInitUpdateExprClass, baseExpr->getType(), VK_PRValue,
            OK_Ordinary) {
if (const VariableArrayType *T =
       return const_child_range(const_child_iterator(T), const_child_iterator());
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
   return const_child_range(&Argument.Ex, &Argument.Ex + 1);
 }
 
 AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr *> args, QualType t,
                        AtomicOp op, SourceLocation RP)
-    : Expr(AtomicExprClass, t, VK_PRValue, OK_Ordinary),
-      NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
+    : Expr(AtomicExprClass, t, VK_PRValue, OK_Ordinary), BuiltinLoc(BLoc),
+      RParenLoc(RP) {
+  AtomicExprBits.NumSubExprs = args.size();
+  AtomicExprBits.Op = op;
   assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
   for (unsigned i = 0; i != args.size(); i++)
     SubExprs[i] = args[i];
   setDependence(computeDependence(this));
 }
 
 unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) {
   switch (Op) {
QualType OMPArraySectionExpr::getBaseOriginalType(const Expr *Base) {
   return OriginalTy;
 }
 
 RecoveryExpr::RecoveryExpr(ASTContext &Ctx, QualType T, SourceLocation BeginLoc,
                            SourceLocation EndLoc, ArrayRef<Expr *> SubExprs)
     : Expr(RecoveryExprClass, T.getNonReferenceType(),
            T->isDependentType() ? VK_LValue : getValueKindForType(T),
            OK_Ordinary),
-      BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {
+      EndLoc(EndLoc) {
+  RecoveryExprBits.NumExprs = SubExprs.size();
+  RecoveryExprBits.BeginLoc = BeginLoc;
   assert(!T.isNull());
   assert(llvm::all_of(SubExprs, [](Expr* E) { return E != nullptr; }));
 
   llvm::copy(SubExprs, getTrailingObjects<Expr *>());
   setDependence(computeDependence(this));
 }
 
 RecoveryExpr *RecoveryExpr::Create(ASTContext &Ctx, QualType T,

clang/lib/AST/ExprCXX.cpp

 
 CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(
     const ASTContext &Context, Expr *Base, bool isArrow,
     SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
     TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc,
     SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
     : Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy, VK_PRValue,
            OK_Ordinary),
-      Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
-      OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
+      Base(static_cast<Stmt *>(Base)), QualifierLoc(QualifierLoc),
       ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
       DestroyedType(DestroyedType) {
+  CXXPseudoDestructorExprBits.IsArrow = isArrow;
+  CXXPseudoDestructorExprBits.OperatorLoc = OperatorLoc;
   setDependence(computeDependence(this));
 }
 
 QualType CXXPseudoDestructorExpr::getDestroyedType() const {
   if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
     return TInfo->getType();
 
   return QualType();
CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,
                                        SourceLocation Loc, FieldDecl *Field,
                                        QualType Ty, DeclContext *UsedContext)
     : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
            Ty->isLValueReferenceType()   ? VK_LValue
            : Ty->isRValueReferenceType() ? VK_XValue
                                          : VK_PRValue,
            /*FIXME*/ OK_Ordinary),
       Field(Field), UsedContext(UsedContext) {
-  CXXDefaultInitExprBits.Loc = Loc;
+  ExprWithSourceLocBits.Loc = Loc;
   assert(Field->hasInClassInitializer());
 
   setDependence(computeDependence(this));
 }
 
 CXXTemporary *CXXTemporary::Create(const ASTContext &C,
                                    const CXXDestructorDecl *Destructor) {
   return new (C) CXXTemporary(Destructor);

clang/lib/AST/ExprObjC.cpp

 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 
 using namespace clang;
 
 ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, QualType T,
                                    ObjCMethodDecl *Method, SourceRange SR)
-    : Expr(ObjCArrayLiteralClass, T, VK_PRValue, OK_Ordinary),
-      NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) {
+    : Expr(ObjCArrayLiteralClass, T, VK_PRValue, OK_Ordinary), Range(SR),
+      ArrayWithObjectsMethod(Method) {
+  ObjCArrayLiteralBits.NumElements = Elements.size();
   Expr **SaveElements = getElements();
   for (unsigned I = 0, N = Elements.size(); I != N; ++I)
     SaveElements[I] = Elements[I];
 
   setDependence(computeDependence(this));
 }
 
 ObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C,
ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(const ASTContext &C,
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumElements));
   return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements);
 }
 
 ObjCDictionaryLiteral::ObjCDictionaryLiteral(ArrayRef<ObjCDictionaryElement> VK,
                                              bool HasPackExpansions, QualType T,
                                              ObjCMethodDecl *method,
                                              SourceRange SR)
-    : Expr(ObjCDictionaryLiteralClass, T, VK_PRValue, OK_Ordinary),
-      NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR),
+    : Expr(ObjCDictionaryLiteralClass, T, VK_PRValue, OK_Ordinary), Range(SR),
       DictWithObjectsMethod(method) {
+  ObjCDictionaryLiteralBits.HasPackExpansions = HasPackExpansions;
+  ObjCDictionaryLiteralBits.NumElements = VK.size();
   KeyValuePair *KeyValues = getTrailingObjects<KeyValuePair>();
   ExpansionData *Expansions =
       HasPackExpansions ? getTrailingObjects<ExpansionData>() : nullptr;
-  for (unsigned I = 0; I < NumElements; I++) {
+  for (unsigned I = 0; I < ObjCDictionaryLiteralBits.NumElements; I++) {
     KeyValues[I].Key = VK[I].Key;
     KeyValues[I].Value = VK[I].Value;
     if (Expansions) {
       Expansions[I].EllipsisLoc = VK[I].EllipsisLoc;
       if (VK[I].NumExpansions)
         Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1;
       else
         Expansions[I].NumExpansionsPlusOne = 0;

clang/lib/AST/Stmt.cpp

 /// getOutputConstraint - Return the constraint string for the specified
 /// output operand.  All output constraints are known to be non-empty (either
 /// '=' or '+').
 StringRef GCCAsmStmt::getOutputConstraint(unsigned i) const {
   return getOutputConstraintLiteral(i)->getString();
 }
 
 Expr *GCCAsmStmt::getInputExpr(unsigned i) {
-  return cast<Expr>(Exprs[i + NumOutputs]);
+  return cast<Expr>(Exprs[i + AsmStmtBits.NumOutputs]);
 }
 
 void GCCAsmStmt::setInputExpr(unsigned i, Expr *E) {
-  Exprs[i + NumOutputs] = E;
+  Exprs[i + AsmStmtBits.NumOutputs] = E;
 }
 
 AddrLabelExpr *GCCAsmStmt::getLabelExpr(unsigned i) const {
-  return cast<AddrLabelExpr>(Exprs[i + NumOutputs + NumInputs]);
+  return cast<AddrLabelExpr>(Exprs[i + AsmStmtBits.NumOutputs + NumInputs]);
 }
 
 StringRef GCCAsmStmt::getLabelName(unsigned i) const {
   return getLabelExpr(i)->getLabel()->getName();
 }
 
 /// getInputConstraint - Return the specified input constraint.  Unlike output
 /// constraints, these can be empty.
 StringRef GCCAsmStmt::getInputConstraint(unsigned i) const {
   return getInputConstraintLiteral(i)->getString();
 }
 
 void GCCAsmStmt::setOutputsAndInputsAndClobbers(const ASTContext &C,
                                                 IdentifierInfo **Names,
                                                 StringLiteral **Constraints,
                                                 Stmt **Exprs,
                                                 unsigned NumOutputs,
                                                 unsigned NumInputs,
                                                 unsigned NumLabels,
                                                 StringLiteral **Clobbers,
                                                 unsigned NumClobbers) {
-  this->NumOutputs = NumOutputs;
+  this->AsmStmtBits.NumOutputs = NumOutputs;
   this->NumInputs = NumInputs;
   this->NumClobbers = NumClobbers;
   this->NumLabels = NumLabels;
 
   unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
 
   C.Deallocate(this->Names);
   this->Names = new (C) IdentifierInfo*[NumExprs];
std::string MSAsmStmt::generateAsmString(const ASTContext &C) const {
   return MSAsmString;
 }
 
 Expr *MSAsmStmt::getOutputExpr(unsigned i) {
   return cast<Expr>(Exprs[i]);
 }
 
 Expr *MSAsmStmt::getInputExpr(unsigned i) {
-  return cast<Expr>(Exprs[i + NumOutputs]);
+  return cast<Expr>(Exprs[i + AsmStmtBits.NumOutputs]);
 }
 
 void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
-  Exprs[i + NumOutputs] = E;
+  Exprs[i + AsmStmtBits.NumOutputs] = E;
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors
 //===----------------------------------------------------------------------===//
 
 GCCAsmStmt::GCCAsmStmt(const ASTContext &C, SourceLocation asmloc,
                        bool issimple, bool isvolatile, unsigned numoutputs,
                        unsigned numinputs, IdentifierInfo **names,
                        StringLiteral **constraints, Expr **exprs,
                        StringLiteral *asmstr, unsigned numclobbers,
                        StringLiteral **clobbers, unsigned numlabels,
                        SourceLocation rparenloc)
     : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
               numinputs, numclobbers),
               RParenLoc(rparenloc), AsmStr(asmstr), NumLabels(numlabels) {
-  unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
+  unsigned NumExprs = AsmStmtBits.NumOutputs + NumInputs + NumLabels;
 
   Names = new (C) IdentifierInfo*[NumExprs];
   std::copy(names, names + NumExprs, Names);
 
   Exprs = new (C) Stmt*[NumExprs];
   std::copy(exprs, exprs + NumExprs, Exprs);
 
-  unsigned NumConstraints = NumOutputs + NumInputs;
+  unsigned NumConstraints = AsmStmtBits.NumOutputs + NumInputs;
   Constraints = new (C) StringLiteral*[NumConstraints];
   std::copy(constraints, constraints + NumConstraints, Constraints);
 
   Clobbers = new (C) StringLiteral*[NumClobbers];
   std::copy(clobbers, clobbers + NumClobbers, Clobbers);
 }
 
 MSAsmStmt::MSAsmStmt(const ASTContext &C, SourceLocation asmloc,

 void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr,
                            ArrayRef<Token> asmtoks,
                            ArrayRef<StringRef> constraints,
                            ArrayRef<Expr*> exprs,
                            ArrayRef<StringRef> clobbers) {
   assert(NumAsmToks == asmtoks.size());
   assert(NumClobbers == clobbers.size());
 
-  assert(exprs.size() == NumOutputs + NumInputs);
+  assert(exprs.size() == AsmStmtBits.NumOutputs + NumInputs);
   assert(exprs.size() == constraints.size());
 
   AsmStr = copyIntoContext(C, asmstr);
 
   Exprs = new (C) Stmt*[exprs.size()];
   std::copy(exprs.begin(), exprs.end(), Exprs);
 
   AsmToks = new (C) Token[asmtoks.size()];
ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
                  SourceLocation RP)
   : Stmt(ForStmtClass), LParenLoc(LP), RParenLoc(RP)
 {
   SubExprs[INIT] = Init;
   setConditionVariable(C, condVar);
   SubExprs[COND] = Cond;
   SubExprs[INC] = Inc;
   SubExprs[BODY] = Body;
-  ForStmtBits.ForLoc = FL;
+  StmtWithSourceLocBits.Loc = FL;
 }
 
 VarDecl *ForStmt::getConditionVariable() const {
   if (!SubExprs[CONDVAR])
     return nullptr;
 
   auto *DS = cast<DeclStmt>(SubExprs[CONDVAR]);
   return cast<VarDecl>(DS->getSingleDecl());
void *Mem = Ctx.Allocate(
       totalSizeToAlloc<Stmt *, SourceLocation>(
           NumMandatoryStmtPtr + CaseStmtIsGNURange, CaseStmtIsGNURange),
       alignof(CaseStmt));
   return new (Mem) CaseStmt(EmptyShell(), CaseStmtIsGNURange);
 }
 
 SEHTryStmt::SEHTryStmt(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock,
                        Stmt *Handler)
-    : Stmt(SEHTryStmtClass), IsCXXTry(IsCXXTry), TryLoc(TryLoc) {
+    : Stmt(SEHTryStmtClass) {
+  SEHTryStmtBits.IsCXXTry = IsCXXTry;
+  SEHTryStmtBits.TryLoc = TryLoc;
   Children[TRY]     = TryBlock;
   Children[HANDLER] = Handler;
 }
 
 SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry,
                                SourceLocation TryLoc, Stmt *TryBlock,
                                Stmt *Handler) {
   return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
 }
 
 SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
   return dyn_cast<SEHExceptStmt>(getHandler());
 }
 
 SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
   return dyn_cast<SEHFinallyStmt>(getHandler());
 }
 
 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
-    : Stmt(SEHExceptStmtClass), Loc(Loc) {
+    : Stmt(SEHExceptStmtClass) {
+  StmtWithSourceLocBits.Loc = Loc;
   Children[FILTER_EXPR] = FilterExpr;
   Children[BLOCK]       = Block;
 }
 
 SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc,
                                      Expr *FilterExpr, Stmt *Block) {
   return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
 }
 
 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc, Stmt *Block)
-    : Stmt(SEHFinallyStmtClass), Loc(Loc), Block(Block) {}
+    : Stmt(SEHFinallyStmtClass), Block(Block) {
+  StmtWithSourceLocBits.Loc = Loc;
+}
 
 SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc,
                                        Stmt *Block) {
   return new(C)SEHFinallyStmt(Loc,Block);
 }
 
 CapturedStmt::Capture::Capture(SourceLocation Loc, VariableCaptureKind Kind,
                                VarDecl *Var)

 
 VarDecl *CapturedStmt::Capture::getCapturedVar() const {
   assert((capturesVariable() || capturesVariableByCopy()) &&
          "No variable available for 'this' or VAT capture");
   return VarAndKind.getPointer();
 }
 
 CapturedStmt::Capture *CapturedStmt::getStoredCaptures() const {
-  unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
+  unsigned Size = sizeof(CapturedStmt) +
+                  sizeof(Stmt *) * (CapturedStmtBits.NumCaptures + 1);
 
   // Offset of the first Capture object.
   unsigned FirstCaptureOffset = llvm::alignTo(Size, alignof(Capture));
 
   return reinterpret_cast<Capture *>(
       reinterpret_cast<char *>(const_cast<CapturedStmt *>(this))
       + FirstCaptureOffset);
 }
 
 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
                            ArrayRef<Capture> Captures,
-                           ArrayRef<Expr *> CaptureInits,
-                           CapturedDecl *CD,
+                           ArrayRef<Expr *> CaptureInits, CapturedDecl *CD,
                            RecordDecl *RD)
-  : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
-    CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
+    : Stmt(CapturedStmtClass), CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
   assert( S && "null captured statement");
   assert(CD && "null captured declaration for captured statement");
   assert(RD && "null record declaration for captured statement");
+  CapturedStmtBits.NumCaptures = Captures.size();
 
   // Copy initialization expressions.
   Stmt **Stored = getStoredStmts();
-  for (unsigned I = 0, N = NumCaptures; I != N; ++I)
+  for (unsigned I = 0, N = CapturedStmtBits.NumCaptures; I != N; ++I)
     *Stored++ = CaptureInits[I];
 
   // Copy the statement being captured.
   *Stored = S;
 
   // Copy all Capture objects.
   Capture *Buffer = getStoredCaptures();
   std::copy(Captures.begin(), Captures.end(), Buffer);
 }
 
 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures)
-  : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures),
-    CapDeclAndKind(nullptr, CR_Default) {
+    : Stmt(CapturedStmtClass, Empty), CapDeclAndKind(nullptr, CR_Default) {
+  CapturedStmtBits.NumCaptures = NumCaptures;
   getStoredStmts()[NumCaptures] = nullptr;
 }
 
 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S,
                                    CapturedRegionKind Kind,
                                    ArrayRef<Capture> Captures,
                                    ArrayRef<Expr *> CaptureInits,
                                    CapturedDecl *CD,
CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context,
   }
 
   void *Mem = Context.Allocate(Size);
   return new (Mem) CapturedStmt(EmptyShell(), NumCaptures);
 }
 
 Stmt::child_range CapturedStmt::children() {
   // Children are captured field initializers.
-  return child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
+  return child_range(getStoredStmts(),
+                     getStoredStmts() + CapturedStmtBits.NumCaptures);
 }
 
 Stmt::const_child_range CapturedStmt::children() const {
-  return const_child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
+  return const_child_range(getStoredStmts(),
+                           getStoredStmts() + CapturedStmtBits.NumCaptures);
 }
 
 CapturedDecl *CapturedStmt::getCapturedDecl() {
   return CapDeclAndKind.getPointer();
 }
 
 const CapturedDecl *CapturedStmt::getCapturedDecl() const {
   return CapDeclAndKind.getPointer();

clang/lib/AST/StmtCXX.cpp

CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, EmptyShell Empty,
                                unsigned numHandlers) {
   const size_t Size = totalSizeToAlloc<Stmt *>(numHandlers + 1);
   void *Mem = C.Allocate(Size, alignof(CXXTryStmt));
   return new (Mem) CXXTryStmt(Empty, numHandlers);
 }
 
 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
                        ArrayRef<Stmt *> handlers)
-    : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
+    : Stmt(CXXTryStmtClass) {
+  CXXTryStmtBits.TryLoc = tryLoc;
+  CXXTryStmtBits.NumHandlers = handlers.size();
   Stmt **Stmts = getStmts();
   Stmts[0] = tryBlock;
   std::copy(handlers.begin(), handlers.end(), Stmts + 1);
 }
 
 CXXForRangeStmt::CXXForRangeStmt(Stmt *Init, DeclStmt *Range,
                                  DeclStmt *BeginStmt, DeclStmt *EndStmt,
                                  Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
                                  Stmt *Body, SourceLocation FL,
                                  SourceLocation CAL, SourceLocation CL,
                                  SourceLocation RPL)
-    : Stmt(CXXForRangeStmtClass), ForLoc(FL), CoawaitLoc(CAL), ColonLoc(CL),
+    : Stmt(CXXForRangeStmtClass), CoawaitLoc(CAL), ColonLoc(CL),
       RParenLoc(RPL) {
+  StmtWithSourceLocBits.Loc = FL;
   SubExprs[INIT] = Init;
   SubExprs[RANGE] = Range;
   SubExprs[BEGINSTMT] = BeginStmt;
   SubExprs[ENDSTMT] = EndStmt;
   SubExprs[COND] = Cond;
   SubExprs[INC] = Inc;
   SubExprs[LOOPVAR] = LoopVar;
   SubExprs[BODY] = Body;

 
 CoroutineBodyStmt *CoroutineBodyStmt::Create(const ASTContext &C, EmptyShell,
                                              unsigned NumParams) {
   std::size_t Size = totalSizeToAlloc<Stmt *>(
       CoroutineBodyStmt::FirstParamMove + NumParams);
 
   void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt));
   auto *Result = new (Mem) CoroutineBodyStmt(CtorArgs());
-  Result->NumParams = NumParams;
+  Result->CoroutineBodyStmtBits.NumParams = NumParams;
   auto *ParamBegin = Result->getStoredStmts() + SubStmt::FirstParamMove;
   std::uninitialized_fill(ParamBegin, ParamBegin + NumParams,
                           static_cast<Stmt *>(nullptr));
   return Result;
 }
 
 CoroutineBodyStmt::CoroutineBodyStmt(CoroutineBodyStmt::CtorArgs const &Args)
-    : Stmt(CoroutineBodyStmtClass), NumParams(Args.ParamMoves.size()) {
+    : Stmt(CoroutineBodyStmtClass) {
+  CoroutineBodyStmtBits.NumParams = Args.ParamMoves.size();
   Stmt **SubStmts = getStoredStmts();
   SubStmts[CoroutineBodyStmt::Body] = Args.Body;
   SubStmts[CoroutineBodyStmt::Promise] = Args.Promise;
   SubStmts[CoroutineBodyStmt::InitSuspend] = Args.InitialSuspend;
   SubStmts[CoroutineBodyStmt::FinalSuspend] = Args.FinalSuspend;
   SubStmts[CoroutineBodyStmt::OnException] = Args.OnException;
   SubStmts[CoroutineBodyStmt::OnFallthrough] = Args.OnFallthrough;
   SubStmts[CoroutineBodyStmt::Allocate] = Args.Allocate;
   SubStmts[CoroutineBodyStmt::Deallocate] = Args.Deallocate;
   SubStmts[CoroutineBodyStmt::ReturnValue] = Args.ReturnValue;
   SubStmts[CoroutineBodyStmt::ReturnStmt] = Args.ReturnStmt;
   SubStmts[CoroutineBodyStmt::ReturnStmtOnAllocFailure] =
       Args.ReturnStmtOnAllocFailure;
   std::copy(Args.ParamMoves.begin(), Args.ParamMoves.end(),
             const_cast<Stmt **>(getParamMoves().data()));
 }

clang/lib/AST/StmtObjC.cpp

ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
   SubExprs[BODY] = Body;
   ForLoc = FCL;
   RParenLoc = RPL;
 }
 
 ObjCAtTryStmt::ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
                              Stmt **CatchStmts, unsigned NumCatchStmts,
                              Stmt *atFinallyStmt)
-    : Stmt(ObjCAtTryStmtClass), AtTryLoc(atTryLoc),
-      NumCatchStmts(NumCatchStmts), HasFinally(atFinallyStmt != nullptr) {
+    : Stmt(ObjCAtTryStmtClass) {
+  ObjCAtTryStmtBits.AtTryLoc = atTryLoc;
+  ObjCAtTryStmtBits.NumCatchStmts = NumCatchStmts;
+  ObjCAtTryStmtBits.HasFinally = atFinallyStmt != nullptr;
+
   Stmt **Stmts = getStmts();
   Stmts[0] = atTryStmt;
   for (unsigned I = 0; I != NumCatchStmts; ++I)
     Stmts[I + 1] = CatchStmts[I];
 
-  if (HasFinally)
+  if (ObjCAtTryStmtBits.HasFinally)
     Stmts[NumCatchStmts + 1] = atFinallyStmt;
 }
 
 ObjCAtTryStmt *ObjCAtTryStmt::Create(const ASTContext &Context,
                                      SourceLocation atTryLoc, Stmt *atTryStmt,
                                      Stmt **CatchStmts, unsigned NumCatchStmts,
                                      Stmt *atFinallyStmt) {
   size_t Size =
       totalSizeToAlloc<Stmt *>(1 + NumCatchStmts + (atFinallyStmt != nullptr));
   void *Mem = Context.Allocate(Size, alignof(ObjCAtTryStmt));
   return new (Mem) ObjCAtTryStmt(atTryLoc, atTryStmt, CatchStmts, NumCatchStmts,
                                  atFinallyStmt);
 }
 
 ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(const ASTContext &Context,
                                           unsigned NumCatchStmts,
                                           bool HasFinally) {
   size_t Size = totalSizeToAlloc<Stmt *>(1 + NumCatchStmts + HasFinally);
   void *Mem = Context.Allocate(Size, alignof(ObjCAtTryStmt));
   return new (Mem) ObjCAtTryStmt(EmptyShell(), NumCatchStmts, HasFinally);
 }
 
 SourceLocation ObjCAtTryStmt::getEndLoc() const {
-  if (HasFinally)
+  if (ObjCAtTryStmtBits.HasFinally)
     return getFinallyStmt()->getEndLoc();
-  if (NumCatchStmts)
-    return getCatchStmt(NumCatchStmts - 1)->getEndLoc();
+  if (ObjCAtTryStmtBits.NumCatchStmts)
+    return getCatchStmt(ObjCAtTryStmtBits.NumCatchStmts - 1)->getEndLoc();
   return getTryBody()->getEndLoc();
 }

clang/lib/Serialization/ASTReaderStmt.cpp

if (Record.size() - Record.getIdx() == 1) {
     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
                                                    Decls.data(),
                                                    Decls.size())));
   }
 }
 
 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
   VisitStmt(S);
-  S->NumOutputs = Record.readInt();
+  S->AsmStmtBits.NumOutputs = Record.readInt();
   S->NumInputs = Record.readInt();
   S->NumClobbers = Record.readInt();
   S->setAsmLoc(readSourceLocation());
   S->setVolatile(Record.readInt());
   S->setSimple(Record.readInt());
 }
 
 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
   ClobbersData.reserve(S->NumClobbers);
   Clobbers.reserve(S->NumClobbers);
   for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
     ClobbersData.push_back(readString());
     Clobbers.push_back(ClobbersData.back());
   }
 
   // Read the operands.
-  unsigned NumOperands = S->NumOutputs + S->NumInputs;
+  unsigned NumOperands = S->AsmStmtBits.NumOutputs + S->NumInputs;
   SmallVector<Expr*, 16> Exprs;
   SmallVector<std::string, 16> ConstraintsData;
   SmallVector<StringRef, 16> Constraints;
   Exprs.reserve(NumOperands);
   ConstraintsData.reserve(NumOperands);
   Constraints.reserve(NumOperands);
   for (unsigned i = 0; i != NumOperands; ++i) {
     Exprs.push_back(cast<Expr>(Record.readSubStmt()));
     ConstraintsData.push_back(readString());
     Constraints.push_back(ConstraintsData.back());
   }
 
   S->initialize(Record.getContext(), AsmStr, AsmToks,
                 Constraints, Exprs, Clobbers);
 }
 
 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
   VisitStmt(S);
-  assert(Record.peekInt() == S->NumParams);
+  assert(Record.peekInt() == S->CoroutineBodyStmtBits.NumParams);
   Record.skipInts(1);
   auto *StoredStmts = S->getStoredStmts();
-  for (unsigned i = 0;
-       i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
+  for (unsigned i = 0; i < CoroutineBodyStmt::SubStmt::FirstParamMove +
+                               S->CoroutineBodyStmtBits.NumParams;
+       ++i)
     StoredStmts[i] = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
   VisitStmt(S);
-  S->CoreturnLoc = Record.readSourceLocation();
+  S->CoreturnStmtBits.CoreturnLoc = Record.readSourceLocation();
   for (auto &SubStmt: S->SubStmts)
     SubStmt = Record.readSubStmt();
-  S->IsImplicit = Record.readInt() != 0;
+  S->CoreturnStmtBits.IsImplicit = Record.readInt() != 0;
 }
 
-void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
+void ASTStmtReader::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) {
   VisitExpr(E);
-  E->KeywordLoc = readSourceLocation();
-  for (auto &SubExpr: E->SubExprs)
+  E->CoroutineSuspendExprBits.KeywordLoc = readSourceLocation();
+  for (auto &SubExpr : E->SubExprs)
     SubExpr = Record.readSubStmt();
   E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
+}
+
+void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
+  VisitCoroutineSuspendExpr(E);
   E->setIsImplicit(Record.readInt() != 0);
 }
 
 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
-  VisitExpr(E);
-  E->KeywordLoc = readSourceLocation();
-  for (auto &SubExpr: E->SubExprs)
-    SubExpr = Record.readSubStmt();
-  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
+  VisitCoroutineSuspendExpr(E);
 }
 
 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
   VisitExpr(E);
-  E->KeywordLoc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
   for (auto &SubExpr: E->SubExprs)
     SubExpr = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);
   Record.skipInts(1);
   S->setCapturedDecl(readDeclAs<CapturedDecl>());
VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
   E->Operand = Record.readSubExpr();
   E->setShouldCopy(Record.readInt());
 }
 
 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
   VisitExplicitCastExpr(E);
   E->LParenLoc = readSourceLocation();
   E->BridgeKeywordLoc = readSourceLocation();
-  E->Kind = Record.readInt();
+  E->ObjCBridgedCastExprBits.Kind = Record.readInt();
 }
 
 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
   VisitExpr(E);
   unsigned NumBaseSpecs = Record.readInt();
   assert(NumBaseSpecs == E->path_size());
   unsigned HasFPFeatures = Record.readInt();
   assert(E->hasStoredFPFeatures() == HasFPFeatures);
void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
   E->setComputationResultType(Record.readType());
 }
 
 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
   VisitExpr(E);
   E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
   E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
   E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
-  E->QuestionLoc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
   E->ColonLoc = readSourceLocation();
 }
 
 void
 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
   VisitExpr(E);
   E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
   E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
   E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
   E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
   E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
-  E->QuestionLoc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
   E->ColonLoc = readSourceLocation();
 }
 
 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
   VisitCastExpr(E);
   E->setIsPartOfExplicitCast(Record.readInt());
 }
 
void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
   E->setBuiltinLoc(readSourceLocation());
   E->setRParenLoc(readSourceLocation());
   E->setIsMicrosoftABI(Record.readInt());
 }
 
 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
   VisitExpr(E);
   E->ParentContext = readDeclAs<DeclContext>();
-  E->BuiltinLoc = readSourceLocation();
+  E->SourceLocExprBits.BuiltinLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
   E->SourceLocExprBits.Kind =
       static_cast<SourceLocExpr::IdentKind>(Record.readInt());
 }
 
 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
   VisitExpr(E);
   E->setAmpAmpLoc(readSourceLocation());

 }
 
 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
   VisitExpr(E);
 
   unsigned NumAssocs = Record.readInt();
   assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
   E->ResultIndex = Record.readInt();
-  E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
   E->DefaultLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
 
   Stmt **Stmts = E->getTrailingObjects<Stmt *>();
   // Add 1 to account for the controlling expression which is the first
   // expression in the trailing array of Stmt *. This is not needed for
   // the trailing array of TypeSourceInfo *.
   for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
   for (unsigned i = 0; i != numSemanticExprs; ++i) {
     Expr *subExpr = Record.readSubExpr();
     E->getSubExprsBuffer()[i+1] = subExpr;
   }
 }
 
 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
   VisitExpr(E);
-  E->Op = AtomicExpr::AtomicOp(Record.readInt());
-  E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
-  for (unsigned I = 0; I != E->NumSubExprs; ++I)
+  E->AtomicExprBits.Op = Record.readInt();
+  E->AtomicExprBits.NumSubExprs =
+      AtomicExpr::getNumSubExprs(AtomicExpr::AtomicOp(E->AtomicExprBits.Op));
+  for (unsigned I = 0; I != E->AtomicExprBits.NumSubExprs; ++I)
     E->SubExprs[I] = Record.readSubExpr();
   E->BuiltinLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
 }
 
 //===----------------------------------------------------------------------===//
 // Objective-C Expressions and Statements
 
void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
   E->Range = readSourceRange();
 }
 
 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
   VisitExpr(E);
   unsigned NumElements = Record.readInt();
   assert(NumElements == E->getNumElements() && "Wrong number of elements");
   bool HasPackExpansions = Record.readInt();
-  assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
+  assert(HasPackExpansions == E->ObjCDictionaryLiteralBits.HasPackExpansions &&
+         "Pack expansion mismatch");
   auto *KeyValues =
       E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
   auto *Expansions =
       E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
   for (unsigned I = 0; I != NumElements; ++I) {
     KeyValues[I].Key = Record.readSubExpr();
     KeyValues[I].Value = Record.readSubExpr();
     if (HasPackExpansions) {

 }
 
 //===----------------------------------------------------------------------===//
 // C++ Expressions and Statements
 //===----------------------------------------------------------------------===//
 
 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
   VisitStmt(S);
-  S->CatchLoc = readSourceLocation();
+  S->StmtWithSourceLocBits.Loc = readSourceLocation();
   S->ExceptionDecl = readDeclAs<VarDecl>();
   S->HandlerBlock = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
   VisitStmt(S);
   assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
   Record.skipInts(1);
-  S->TryLoc = readSourceLocation();
+  S->CXXTryStmtBits.TryLoc = readSourceLocation();
   S->getStmts()[0] = Record.readSubStmt();
   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
     S->getStmts()[i + 1] = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
   VisitStmt(S);
-  S->ForLoc = readSourceLocation();
+  S->StmtWithSourceLocBits.Loc = readSourceLocation();
   S->CoawaitLoc = readSourceLocation();
   S->ColonLoc = readSourceLocation();
   S->RParenLoc = readSourceLocation();
   S->setInit(Record.readSubStmt());
   S->setRangeStmt(Record.readSubStmt());
   S->setBeginStmt(Record.readSubStmt());
   S->setEndStmt(Record.readSubStmt());
   S->setCond(Record.readSubExpr());
   S->setInc(Record.readSubExpr());
   S->setLoopVarStmt(Record.readSubStmt());
   S->setBody(Record.readSubStmt());
 }
 
 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
   VisitStmt(S);
-  S->KeywordLoc = readSourceLocation();
-  S->IsIfExists = Record.readInt();
+  S->MSDependentExistsStmtBits.KeywordLoc = readSourceLocation();
+  S->MSDependentExistsStmtBits.IsIfExists = Record.readInt();
   S->QualifierLoc = Record.readNestedNameSpecifierLoc();
   S->NameInfo = Record.readDeclarationNameInfo();
   S->SubStmt = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
   VisitCallExpr(E);
   E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
 
   for (unsigned I = 0; I != NumArgs; ++I)
     E->setArg(I, Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
   VisitExpr(E);
   E->Constructor = readDeclAs<CXXConstructorDecl>();
-  E->Loc = readSourceLocation();
-  E->ConstructsVirtualBase = Record.readInt();
-  E->InheritedFromVirtualBase = Record.readInt();
+  E->CXXInheritedCtorInitExprBits.Loc = readSourceLocation();
+  E->CXXInheritedCtorInitExprBits.ConstructsVirtualBase = Record.readInt();
+  E->CXXInheritedCtorInitExprBits.InheritedFromVirtualBase = Record.readInt();
 }
 
 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
   VisitCXXConstructExpr(E);
   E->TSI = readTypeSourceInfo();
 }
 
 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
   E->Operand = Record.readSubExpr();
   E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
 }
 
 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   VisitExpr(E);
   E->Param = readDeclAs<ParmVarDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
-  E->CXXDefaultArgExprBits.Loc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   VisitExpr(E);
   E->Field = readDeclAs<FieldDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
-  E->CXXDefaultInitExprBits.Loc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   VisitExpr(E);
   E->setTemporary(Record.readCXXTemporary());
   E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
   VisitExpr(E);
   E->TypeInfo = readTypeSourceInfo();
-  E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
   VisitExpr(E);
 
   bool IsArray = Record.readInt();
   bool HasInit = Record.readInt();
   unsigned NumPlacementArgs = Record.readInt();
void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   E->Argument = Record.readSubExpr();
   E->CXXDeleteExprBits.Loc = readSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
   VisitExpr(E);
 
   E->Base = Record.readSubExpr();
-  E->IsArrow = Record.readInt();
-  E->OperatorLoc = readSourceLocation();
+  E->CXXPseudoDestructorExprBits.IsArrow = Record.readInt();
+  E->CXXPseudoDestructorExprBits.OperatorLoc = readSourceLocation();
   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
   E->ScopeType = readTypeSourceInfo();
   E->ColonColonLoc = readSourceLocation();
   E->TildeLoc = readSourceLocation();
 
   IdentifierInfo *II = Record.readIdentifier();
   if (II)
     E->setDestroyedType(II, readSourceLocation());
void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
 
   auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
     Args[I] = readTypeSourceInfo();
 }
 
 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
   VisitExpr(E);
-  E->ATT = (ArrayTypeTrait)Record.readInt();
+  E->ArrayTypeTraitExprBits.ATT = (ArrayTypeTrait)Record.readInt();
   E->Value = (unsigned int)Record.readInt();
   SourceRange Range = readSourceRange();
-  E->Loc = Range.getBegin();
+  E->ArrayTypeTraitExprBits.Loc = Range.getBegin();
   E->RParen = Range.getEnd();
   E->QueriedType = readTypeSourceInfo();
   E->Dimension = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
   VisitExpr(E);
   E->ET = (ExpressionTrait)Record.readInt();
-  E->Value = (bool)Record.readInt();
+  E->ExpressionTraitExprBits.Value = (bool)Record.readInt();
   SourceRange Range = readSourceRange();
   E->QueriedExpression = Record.readSubExpr();
-  E->Loc = Range.getBegin();
+  E->ExpressionTraitExprBits.Loc = Range.getBegin();
   E->RParen = Range.getEnd();
 }
 
 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
   VisitExpr(E);
   E->CXXNoexceptExprBits.Value = Record.readInt();
-  E->Range = readSourceRange();
+  SourceRange R = readSourceRange();
+  E->CXXNoexceptExprBits.KeywordLoc = R.getBegin();
+  E->RParenLoc = R.getEnd();
   E->Operand = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
   VisitExpr(E);
   E->EllipsisLoc = readSourceLocation();
   E->NumExpansions = Record.readInt();
   E->Pattern = Record.readSubExpr();
void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
   }
 }
 
 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
                                               SubstNonTypeTemplateParmExpr *E) {
   VisitExpr(E);
   E->ParamAndRef.setPointer(readDeclAs<NonTypeTemplateParmDecl>());
   E->ParamAndRef.setInt(Record.readInt());
-  E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
+  E->ExprWithSourceLocBits.Loc = readSourceLocation();
   E->Replacement = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
                                           SubstNonTypeTemplateParmPackExpr *E) {
   VisitExpr(E);
   E->Param = readDeclAs<NonTypeTemplateParmDecl>();
   TemplateArgument ArgPack = Record.readTemplateArgument();
void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
   if (HasMaterialzedDecl)
     E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
   else
     E->State = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
   VisitExpr(E);
-  E->LParenLoc = readSourceLocation();
+  E->CXXFoldExprBits.LParenLoc = readSourceLocation();
   E->EllipsisLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
   E->NumExpansions = Record.readInt();
   E->SubExprs[0] = Record.readSubExpr();
   E->SubExprs[1] = Record.readSubExpr();
   E->SubExprs[2] = Record.readSubExpr();
-  E->Opcode = (BinaryOperatorKind)Record.readInt();
+  E->CXXFoldExprBits.Opcode = Record.readInt();
 }
 
 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
   VisitExpr(E);
   E->SourceExpr = Record.readSubExpr();
   E->OpaqueValueExprBits.Loc = readSourceLocation();
   E->setIsUnique(Record.readInt());
 }
 
 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
   llvm_unreachable("Cannot read TypoExpr nodes");
 }
 
 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
   VisitExpr(E);
   unsigned NumArgs = Record.readInt();
-  E->BeginLoc = readSourceLocation();
+  E->RecoveryExprBits.BeginLoc = readSourceLocation();
   E->EndLoc = readSourceLocation();
   assert((NumArgs + 0LL ==
           std::distance(E->children().begin(), E->children().end())) &&
          "Wrong NumArgs!");
   (void)NumArgs;
   for (Stmt *&Child : E->children())
     Child = Record.readSubStmt();
 }
 
 //===----------------------------------------------------------------------===//
 // Microsoft Expressions and Statements
 //===----------------------------------------------------------------------===//
 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
   VisitExpr(E);
-  E->IsArrow = (Record.readInt() != 0);
+  E->MSPropertyRefExprBits.IsArrow = (Record.readInt() != 0);
   E->BaseExpr = Record.readSubExpr();
   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
-  E->MemberLoc = readSourceLocation();
+  E->MSPropertyRefExprBits.MemberLoc = readSourceLocation();
   E->TheDecl = readDeclAs<MSPropertyDecl>();
 }
 
 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
   VisitExpr(E);
   E->setBase(Record.readSubExpr());
   E->setIdx(Record.readSubExpr());
   E->setRBracketLoc(readSourceLocation());

 
 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
   VisitStmt(S);
   S->setLeaveLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
   VisitStmt(S);
-  S->Loc = readSourceLocation();
+  S->StmtWithSourceLocBits.Loc = readSourceLocation();
   S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
   S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
   VisitStmt(S);
-  S->Loc = readSourceLocation();
+  S->StmtWithSourceLocBits.Loc = readSourceLocation();
   S->Block = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
   VisitStmt(S);
-  S->IsCXXTry = Record.readInt();
-  S->TryLoc = readSourceLocation();
+  S->SEHTryStmtBits.IsCXXTry = Record.readInt();
+  S->SEHTryStmtBits.TryLoc = readSourceLocation();
   S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
   S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
 }
 
 //===----------------------------------------------------------------------===//
 // CUDA Expressions and Statements
 //===----------------------------------------------------------------------===//
 

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
   Record.AddDeclRef(E->getArrayWithObjectsMethod());
   Record.AddSourceRange(E->getSourceRange());
   Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
 }
 
 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
   VisitExpr(E);
   Record.push_back(E->getNumElements());
-  Record.push_back(E->HasPackExpansions);
+  Record.push_back(E->ObjCDictionaryLiteralBits.HasPackExpansions);
   for (unsigned i = 0; i < E->getNumElements(); i++) {
     ObjCDictionaryElement Element = E->getKeyValueElement(i);
     Record.AddStmt(Element.Key);
     Record.AddStmt(Element.Value);
-    if (E->HasPackExpansions) {
+    if (E->ObjCDictionaryLiteralBits.HasPackExpansions) {
       Record.AddSourceLocation(Element.EllipsisLoc);
       unsigned NumExpansions = 0;
       if (Element.NumExpansions)
         NumExpansions = *Element.NumExpansions + 1;
       Record.push_back(NumExpansions);
     }
   }
 
if (E->getLifetimeExtendedTemporaryDecl())
     Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl());
   else
     Record.AddStmt(E->getSubExpr());
   Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
 }
 
 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
   VisitExpr(E);
-  Record.AddSourceLocation(E->LParenLoc);
+  Record.AddSourceLocation(E->getLParenLoc());
   Record.AddSourceLocation(E->EllipsisLoc);
   Record.AddSourceLocation(E->RParenLoc);
   Record.push_back(E->NumExpansions);
   Record.AddStmt(E->SubExprs[0]);
   Record.AddStmt(E->SubExprs[1]);
   Record.AddStmt(E->SubExprs[2]);
-  Record.push_back(E->Opcode);
+  Record.push_back(E->getOperator());
   Code = serialization::EXPR_CXX_FOLD;
 }
 
 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
   VisitExpr(E);
   Record.AddStmt(E->getSourceExpr());
   Record.AddSourceLocation(E->getLocation());
   Record.push_back(E->isUnique());