Reorder fields of AstNode subclasses for better packing

src/ast/ast.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
@@ skipping 212 matching lines @@
 
  private:
   // Hidden to prevent accidental usage. It would have to load the
   // current zone from the TLS.
   void* operator new(size_t size);
 
   friend class CaseClause;  // Generates AST IDs.
 
   int position_;
   NodeType node_type_;
+  // Ends with NodeType which is uint8_t sized. Deriving classes in turn begin
+  // sub-int32_t-sized fields for optimum packing efficiency.
 };
 
 
 class Statement : public AstNode {
  public:
   bool IsEmpty() { return AsEmptyStatement() != NULL; }
   bool IsJump() const;
 
  protected:
   Statement(Zone* zone, int position, NodeType type)
@@ skipping 108 matching lines @@
   IcCheckType GetKeyType() const;
   bool IsMonomorphic() const;
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId id() const { return BailoutId(local_id(0)); }
   TypeFeedbackId test_id() const { return TypeFeedbackId(local_id(1)); }
 
  protected:
   Expression(Zone* zone, int pos, NodeType type)
-      : AstNode(pos, type),
-        base_id_(BailoutId::None().ToInt()),
-        bit_field_(0) {}
+      : AstNode(pos, type), base_id_(BailoutId::None().ToInt()) {}
   static int parent_num_ids() { return 0; }
   void set_to_boolean_types(uint16_t types) {
     bit_field_ = ToBooleanTypesField::update(bit_field_, types);
   }
 
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  uint16_t bit_field_ = 0;

[Michael Starzinger, 2016/07/18 08:20:52]

nit: Why use implicit initialization here and explicit everywhere else? Can we
make this one explicit as well (just for symmetry and readability)?

   int base_id_;
   class ToBooleanTypesField : public BitField16<uint16_t, 0, 9> {};
-  uint16_t bit_field_;
-  // Ends with 16-bit field; deriving classes in turn begin with
-  // 16-bit fields for optimum packing efficiency.
 };
 
 
 class BreakableStatement : public Statement {
  public:
   enum BreakableType {
     TARGET_FOR_ANONYMOUS,
     TARGET_FOR_NAMED_ONLY
   };
 
@@ skipping 11 matching lines @@
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId EntryId() const { return BailoutId(local_id(0)); }
   BailoutId ExitId() const { return BailoutId(local_id(1)); }
 
  protected:
   BreakableStatement(Zone* zone, ZoneList<const AstRawString*>* labels,
                      BreakableType breakable_type, int position, NodeType type)
       : Statement(zone, position, type),
-        labels_(labels),
         breakable_type_(breakable_type),
-        base_id_(BailoutId::None().ToInt()) {
+        base_id_(BailoutId::None().ToInt()),
+        labels_(labels) {
     DCHECK(labels == NULL || labels->length() > 0);
   }
   static int parent_num_ids() { return 0; }
 
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  BreakableType breakable_type_;
+  int base_id_;
+  Label break_target_;
   ZoneList<const AstRawString*>* labels_;
-  BreakableType breakable_type_;
-  Label break_target_;
-  int base_id_;
 };
 
 
 class Block final : public BreakableStatement {
  public:
   DECLARE_NODE_TYPE(Block)
 
   ZoneList<Statement*>* statements() { return &statements_; }
   bool ignore_completion_value() const { return ignore_completion_value_; }
 
@@ skipping 534 matching lines @@
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ToObjectId() const { return BailoutId(local_id(0)); }
   BailoutId EntryId() const { return BailoutId(local_id(1)); }
 
  protected:
   WithStatement(Zone* zone, Scope* scope, Expression* expression,
                 Statement* statement, int pos)
       : Statement(zone, pos, kWithStatement),
+        base_id_(BailoutId::None().ToInt()),
         scope_(scope),
         expression_(expression),
-        statement_(statement),
-        base_id_(BailoutId::None().ToInt()) {}
+        statement_(statement) {}
   static int parent_num_ids() { return 0; }
 
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  int base_id_;
   Scope* scope_;
   Expression* expression_;
   Statement* statement_;
-  int base_id_;
 };
 
 
 class CaseClause final : public Expression {
  public:
   DECLARE_NODE_TYPE(CaseClause)
 
   bool is_default() const { return label_ == NULL; }
   Expression* label() const {
     CHECK(!is_default());
@@ skipping 80 matching lines @@
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 3; }
   BailoutId IfId() const { return BailoutId(local_id(0)); }
   BailoutId ThenId() const { return BailoutId(local_id(1)); }
   BailoutId ElseId() const { return BailoutId(local_id(2)); }
 
  protected:
   IfStatement(Zone* zone, Expression* condition, Statement* then_statement,
               Statement* else_statement, int pos)
       : Statement(zone, pos, kIfStatement),
+        base_id_(BailoutId::None().ToInt()),
         condition_(condition),
         then_statement_(then_statement),
-        else_statement_(else_statement),
-        base_id_(BailoutId::None().ToInt()) {}
+        else_statement_(else_statement) {}
   static int parent_num_ids() { return 0; }
 
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  int base_id_;
   Expression* condition_;
   Statement* then_statement_;
   Statement* else_statement_;
-  int base_id_;
 };
 
 
 class TryStatement : public Statement {
  public:
   Block* try_block() const { return try_block_; }
   void set_try_block(Block* b) { try_block_ = b; }
 
   // Prediction of whether exceptions thrown into the handler for this try block
   // will be caught.
   //
   // This is set in ast-numbering and later compiled into the code's handler
   // table.  The runtime uses this information to implement a feature that
   // notifies the debugger when an uncaught exception is thrown, _before_ the
   // exception propagates to the top.
   //
   // Since it's generally undecidable whether an exception will be caught, our
   // prediction is only an approximation.
   bool catch_predicted() const { return catch_predicted_; }
   void set_catch_predicted(bool b) { catch_predicted_ = b; }
 
  protected:
   TryStatement(Zone* zone, Block* try_block, int pos, NodeType type)
       : Statement(zone, pos, type),
-        try_block_(try_block),
-        catch_predicted_(false) {}
+        catch_predicted_(false),
+        try_block_(try_block) {}
 
  private:
+  bool catch_predicted_;
   Block* try_block_;
-  bool catch_predicted_;
 };
 
 
 class TryCatchStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryCatchStatement)
 
   Scope* scope() { return scope_; }
   Variable* variable() { return variable_; }
   Block* catch_block() const { return catch_block_; }
   void set_catch_block(Block* b) { catch_block_ = b; }
 
   // The clear_pending_message flag indicates whether or not to clear the
   // isolate's pending exception message before executing the catch_block.  In
   // the normal use case, this flag is always on because the message object
   // is not needed anymore when entering the catch block and should not be kept
   // alive.
   // The use case where the flag is off is when the catch block is guaranteed to
   // rethrow the caught exception (using %ReThrow), which reuses the pending
   // message instead of generating a new one.
   // (When the catch block doesn't rethrow but is guaranteed to perform an
   // ordinary throw, not clearing the old message is safe but not very useful.)
   bool clear_pending_message() { return clear_pending_message_; }
 
  protected:
   TryCatchStatement(Zone* zone, Block* try_block, Scope* scope,
                     Variable* variable, Block* catch_block,
                     bool clear_pending_message, int pos)
       : TryStatement(zone, try_block, pos, kTryCatchStatement),
+        clear_pending_message_(clear_pending_message),
         scope_(scope),
         variable_(variable),
-        catch_block_(catch_block),
-        clear_pending_message_(clear_pending_message) {}
+        catch_block_(catch_block) {}
 
  private:
+  bool clear_pending_message_;
   Scope* scope_;
   Variable* variable_;
   Block* catch_block_;
-  bool clear_pending_message_;
 };
 
 
 class TryFinallyStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryFinallyStatement)
 
   Block* finally_block() const { return finally_block_; }
   void set_finally_block(Block* b) { finally_block_ = b; }
 
@@ skipping 119 matching lines @@
 
   int depth() const {
     // only callable after initialization.
     DCHECK(depth_ >= 1);
     return depth_;
   }
 
  protected:
   MaterializedLiteral(Zone* zone, int literal_index, int pos, NodeType type)
       : Expression(zone, pos, type),
-        literal_index_(literal_index),
         is_simple_(false),
-        depth_(0) {}
+        depth_(0),
+        literal_index_(literal_index) {}
 
   // A materialized literal is simple if the values consist of only
   // constants and simple object and array literals.
   bool is_simple() const { return is_simple_; }
   void set_is_simple(bool is_simple) { is_simple_ = is_simple; }
   friend class CompileTimeValue;
 
   void set_depth(int depth) {
-    DCHECK(depth >= 1);
+    DCHECK_LE(1, depth);
     depth_ = depth;
   }
 
   // Populate the constant properties/elements fixed array.
   void BuildConstants(Isolate* isolate);
   friend class ArrayLiteral;
   friend class ObjectLiteral;
 
   // If the expression is a literal, return the literal value;
   // if the expression is a materialized literal and is simple return a
   // compile time value as encoded by CompileTimeValue::GetValue().
   // Otherwise, return undefined literal as the placeholder
   // in the object literal boilerplate.
   Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
 
  private:
+  bool is_simple_ : 1;
+  int depth_ : 31;
   int literal_index_;
-  bool is_simple_;
-  int depth_;
 
   friend class AstLiteralReindexer;
 };
 
 
 // Property is used for passing information
 // about an object literal's properties from the parser
 // to the code generator.
 class ObjectLiteralProperty final : public ZoneObject {
  public:
-  enum Kind {
+  enum Kind : uint8_t {
     CONSTANT,              // Property with constant value (compile time).
     COMPUTED,              // Property with computed value (execution time).
     MATERIALIZED_LITERAL,  // Property value is a materialized literal.
-    GETTER, SETTER,        // Property is an accessor function.
-    PROTOTYPE              // Property is __proto__.
+    GETTER,
+    SETTER,    // Property is an accessor function.
+    PROTOTYPE  // Property is __proto__.
   };
 
   Expression* key() { return key_; }
   Expression* value() { return value_; }
   Kind kind() { return kind_; }
 
   void set_key(Expression* e) { key_ = e; }
   void set_value(Expression* e) { value_ = e; }
 
   // Type feedback information.
@@ skipping 114 matching lines @@
     return parent_num_ids() + 1 + 2 * properties()->length();
   }
 
   // Object literals need one feedback slot for each non-trivial value, as well
   // as some slots for home objects.
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
 
  protected:
   ObjectLiteral(Zone* zone, ZoneList<Property*>* properties, int literal_index,
-                int boilerplate_properties, int pos)
+                uint32_t boilerplate_properties, int pos)
       : MaterializedLiteral(zone, literal_index, pos, kObjectLiteral),
-        properties_(properties),
         boilerplate_properties_(boilerplate_properties),
         fast_elements_(false),
         has_elements_(false),
-        may_store_doubles_(false) {}
+        may_store_doubles_(false),
+        properties_(properties) {}
   static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+  uint32_t boilerplate_properties_ : 29;
+  bool fast_elements_ : 1;
+  bool has_elements_ : 1;
+  bool may_store_doubles_ : 1;
+  FeedbackVectorSlot slot_;
   Handle<FixedArray> constant_properties_;
   ZoneList<Property*>* properties_;
-  int boilerplate_properties_;
-  bool fast_elements_;
-  bool has_elements_;
-  bool may_store_doubles_;
-  FeedbackVectorSlot slot_;
 };
 
 
 // A map from property names to getter/setter pairs allocated in the zone.
 class AccessorTable
     : public base::TemplateHashMap<Literal, ObjectLiteral::Accessors,
                                    ZoneAllocationPolicy> {
  public:
   explicit AccessorTable(Zone* zone)
       : base::TemplateHashMap<Literal, ObjectLiteral::Accessors,
@@ skipping 17 matching lines @@
  public:
   DECLARE_NODE_TYPE(RegExpLiteral)
 
   Handle<String> pattern() const { return pattern_->string(); }
   int flags() const { return flags_; }
 
  protected:
   RegExpLiteral(Zone* zone, const AstRawString* pattern, int flags,
                 int literal_index, int pos)
       : MaterializedLiteral(zone, literal_index, pos, kRegExpLiteral),
-        pattern_(pattern),
-        flags_(flags) {
+        flags_(flags),
+        pattern_(pattern) {
     set_depth(1);
   }
 
  private:
+  int const flags_;
   const AstRawString* const pattern_;
-  int const flags_;
 };
 
 
 // An array literal has a literals object that is used
 // for minimizing the work when constructing it at runtime.
 class ArrayLiteral final : public MaterializedLiteral {
  public:
   DECLARE_NODE_TYPE(ArrayLiteral)
 
   Handle<FixedArray> constant_elements() const { return constant_elements_; }
@@ skipping 46 matching lines @@
   };
 
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot LiteralFeedbackSlot() const { return literal_slot_; }
 
  protected:
   ArrayLiteral(Zone* zone, ZoneList<Expression*>* values,
                int first_spread_index, int literal_index, int pos)
       : MaterializedLiteral(zone, literal_index, pos, kArrayLiteral),
-        values_(values),
-        first_spread_index_(first_spread_index) {}
+        first_spread_index_(first_spread_index),
+        values_(values) {}
   static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  int first_spread_index_;
+  FeedbackVectorSlot literal_slot_;
   Handle<FixedArray> constant_elements_;
   ZoneList<Expression*>* values_;
-  int first_spread_index_;
-  FeedbackVectorSlot literal_slot_;
 };
 
 
 class VariableProxy final : public Expression {
  public:
   DECLARE_NODE_TYPE(VariableProxy)
 
   bool IsValidReferenceExpression() const {
     return !is_this() && !is_new_target();
   }
@@ skipping 60 matching lines @@
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsThisField : public BitField8<bool, 0, 1> {};
   class IsAssignedField : public BitField8<bool, 1, 1> {};
   class IsResolvedField : public BitField8<bool, 2, 1> {};
   class IsNewTargetField : public BitField8<bool, 3, 1> {};
 
   // Start with 16-bit (or smaller) field, which should get packed together
   // with Expression's trailing 16-bit field.
   uint8_t bit_field_;
+  // Position is stored in the AstNode superclass, but VariableProxy needs to
+  // know its end position too (for error messages). It cannot be inferred from
+  // the variable name length because it can contain escapes.
+  int end_position_;
   FeedbackVectorSlot variable_feedback_slot_;
   union {
     const AstRawString* raw_name_;  // if !is_resolved_
     Variable* var_;                 // if is_resolved_
   };
-  // Position is stored in the AstNode superclass, but VariableProxy needs to
-  // know its end position too (for error messages). It cannot be inferred from
-  // the variable name length because it can contain escapes.
-  int end_position_;
 };
 
 
 // Left-hand side can only be a property, a global or a (parameter or local)
 // slot.
 enum LhsKind {
   VARIABLE,
   NAMED_PROPERTY,
   KEYED_PROPERTY,
   NAMED_SUPER_PROPERTY,
@@ skipping 186 matching lines @@
 
 #ifdef DEBUG
   // Used to assert that the FullCodeGenerator records the return site.
   bool return_is_recorded_;
 #endif
 
  protected:
   Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
        int pos)
       : Expression(zone, pos, kCall),
+        bit_field_(IsUninitializedField::encode(false)),
         expression_(expression),
-        arguments_(arguments),
-        bit_field_(IsUninitializedField::encode(false)) {
+        arguments_(arguments) {
     if (expression->IsProperty()) {
       expression->AsProperty()->mark_for_call();
     }
   }
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  class IsUninitializedField : public BitField8<bool, 0, 1> {};
+  class IsTailField : public BitField8<bool, 1, 1> {};
+  uint8_t bit_field_;
   FeedbackVectorSlot ic_slot_;
   FeedbackVectorSlot stub_slot_;
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   Handle<JSFunction> target_;
   Handle<AllocationSite> allocation_site_;
-  class IsUninitializedField : public BitField8<bool, 0, 1> {};
-  class IsTailField : public BitField8<bool, 1, 1> {};
-  uint8_t bit_field_;
 };
 
 
 class CallNew final : public Expression {
  public:
   DECLARE_NODE_TYPE(CallNew)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
@@ skipping 30 matching lines @@
   void set_target(Handle<JSFunction> target) { target_ = target; }
   void SetKnownGlobalTarget(Handle<JSFunction> target) {
     target_ = target;
     is_monomorphic_ = true;
   }
 
  protected:
   CallNew(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
           int pos)
       : Expression(zone, pos, kCallNew),
+        is_monomorphic_(false),
         expression_(expression),
-        arguments_(arguments),
-        is_monomorphic_(false) {}
+        arguments_(arguments) {}
 
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  bool is_monomorphic_;
+  FeedbackVectorSlot callnew_feedback_slot_;
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
-  bool is_monomorphic_;
   Handle<JSFunction> target_;
   Handle<AllocationSite> allocation_site_;
-  FeedbackVectorSlot callnew_feedback_slot_;
 };
 
 
 // The CallRuntime class does not represent any official JavaScript
 // language construct. Instead it is used to call a C or JS function
 // with a set of arguments. This is used from the builtins that are
 // implemented in JavaScript (see "v8natives.js").
 class CallRuntime final : public Expression {
  public:
   DECLARE_NODE_TYPE(CallRuntime)
@@ skipping 20 matching lines @@
  protected:
   CallRuntime(Zone* zone, const Runtime::Function* function,
               ZoneList<Expression*>* arguments, int pos)
       : Expression(zone, pos, kCallRuntime),
         function_(function),
         arguments_(arguments) {}
 
   CallRuntime(Zone* zone, int context_index, ZoneList<Expression*>* arguments,
               int pos)
       : Expression(zone, pos, kCallRuntime),
+        context_index_(context_index),
         function_(NULL),
-        context_index_(context_index),
         arguments_(arguments) {}
 
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  int context_index_;
   const Runtime::Function* function_;
-  int context_index_;
   ZoneList<Expression*>* arguments_;
 };
 
 
 class UnaryOperation final : public Expression {
  public:
   DECLARE_NODE_TYPE(UnaryOperation)
 
   Token::Value op() const { return op_; }
   Expression* expression() const { return expression_; }
@@ skipping 153 matching lines @@
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsPrefixField : public BitField16<bool, 0, 1> {};
   class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
   class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 3> {};
   class TokenField : public BitField16<Token::Value, 5, 8> {};
 
   // Starts with 16-bit field, which should get packed together with
   // Expression's trailing 16-bit field.
   uint16_t bit_field_;
+  FeedbackVectorSlot slot_;
   Type* type_;
   Expression* expression_;
   SmallMapList receiver_types_;
-  FeedbackVectorSlot slot_;
 };
 
 
 class CompareOperation final : public Expression {
  public:
   DECLARE_NODE_TYPE(CompareOperation)
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
@@ skipping 44 matching lines @@
   Expression* expression() const { return expression_; }
   void set_expression(Expression* e) { expression_ = e; }
 
   int expression_position() const { return expr_pos_; }
 
   static int num_ids() { return parent_num_ids(); }
 
  protected:
   Spread(Zone* zone, Expression* expression, int pos, int expr_pos)
       : Expression(zone, pos, kSpread),
-        expression_(expression),
-        expr_pos_(expr_pos) {}
+        expr_pos_(expr_pos),
+        expression_(expression) {}
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  int expr_pos_;
   Expression* expression_;
-  int expr_pos_;
 };
 
 
 class Conditional final : public Expression {
  public:
   DECLARE_NODE_TYPE(Conditional)
 
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
   Expression* else_expression() const { return else_expression_; }
@@ skipping 92 matching lines @@
   class KeyTypeField
       : public BitField16<IcCheckType, IsUninitializedField::kNext, 1> {};
   class StoreModeField
       : public BitField16<KeyedAccessStoreMode, KeyTypeField::kNext, 3> {};
   class TokenField : public BitField16<Token::Value, StoreModeField::kNext, 8> {
   };
 
   // Starts with 16-bit field, which should get packed together with
   // Expression's trailing 16-bit field.
   uint16_t bit_field_;
+  FeedbackVectorSlot slot_;
   Expression* target_;
   Expression* value_;
   BinaryOperation* binary_operation_;
   SmallMapList receiver_types_;
-  FeedbackVectorSlot slot_;
 };
 
 
 // The RewritableExpression class is a wrapper for AST nodes that wait
 // for some potential rewriting.  However, even if such nodes are indeed
 // rewritten, the RewritableExpression wrapper nodes will survive in the
 // final AST and should be just ignored, i.e., they should be treated as
 // equivalent to the wrapped nodes.  For this reason and to simplify later
 // phases, RewritableExpressions are considered as exceptions of AST nodes
 // in the following sense:
@@ skipping 54 matching lines @@
   int yield_id() const { return yield_id_; }
 
   void set_generator_object(Expression* e) { generator_object_ = e; }
   void set_expression(Expression* e) { expression_ = e; }
   void set_yield_id(int yield_id) { yield_id_ = yield_id; }
 
  protected:
   Yield(Zone* zone, Expression* generator_object, Expression* expression,
         int pos, OnException on_exception)
       : Expression(zone, pos, kYield),
+        on_exception_(on_exception),
+        yield_id_(-1),
         generator_object_(generator_object),
-        expression_(expression),
-        on_exception_(on_exception),
-        yield_id_(-1) {}
+        expression_(expression) {}
 
  private:
+  OnException on_exception_;
+  int yield_id_;
   Expression* generator_object_;
   Expression* expression_;
-  OnException on_exception_;
-  int yield_id_;
 };
 
 
 class Throw final : public Expression {
  public:
   DECLARE_NODE_TYPE(Throw)
 
   Expression* exception() const { return exception_; }
   void set_exception(Expression* e) { exception_ = e; }
 
@@ skipping 142 matching lines @@
  protected:
   FunctionLiteral(Zone* zone, const AstString* name,
                   AstValueFactory* ast_value_factory, Scope* scope,
                   ZoneList<Statement*>* body, int materialized_literal_count,
                   int expected_property_count, int parameter_count,
                   FunctionType function_type,
                   ParameterFlag has_duplicate_parameters,
                   EagerCompileHint eager_compile_hint, FunctionKind kind,
                   int position, bool is_function)
       : Expression(zone, position, kFunctionLiteral),
-        raw_name_(name),
-        scope_(scope),
-        body_(body),
-        raw_inferred_name_(ast_value_factory->empty_string()),
-        ast_properties_(zone),
         dont_optimize_reason_(kNoReason),
         materialized_literal_count_(materialized_literal_count),
         expected_property_count_(expected_property_count),
         parameter_count_(parameter_count),
         function_token_position_(kNoSourcePosition),
-        yield_count_(0) {
+        yield_count_(0),
+        raw_name_(name),
+        scope_(scope),
+        body_(body),
+        raw_inferred_name_(ast_value_factory->empty_string()),
+        ast_properties_(zone) {
     bitfield_ =
         FunctionTypeBits::encode(function_type) | Pretenure::encode(false) |
         HasDuplicateParameters::encode(has_duplicate_parameters ==
                                        kHasDuplicateParameters) |
         IsFunction::encode(is_function) |
         ShouldEagerCompile::encode(eager_compile_hint == kShouldEagerCompile) |
         FunctionKindBits::encode(kind) | ShouldBeUsedOnceHint::encode(false);
     DCHECK(IsValidFunctionKind(kind));
   }
 
  private:
   class FunctionTypeBits : public BitField16<FunctionType, 0, 2> {};
   class Pretenure : public BitField16<bool, 2, 1> {};
   class HasDuplicateParameters : public BitField16<bool, 3, 1> {};
   class IsFunction : public BitField16<bool, 4, 1> {};
   class ShouldEagerCompile : public BitField16<bool, 5, 1> {};
   class ShouldBeUsedOnceHint : public BitField16<bool, 6, 1> {};
   class FunctionKindBits : public BitField16<FunctionKind, 7, 9> {};
 
   // Start with 16-bit field, which should get packed together
   // with Expression's trailing 16-bit field.
   uint16_t bitfield_;
 
-  const AstString* raw_name_;
-  Scope* scope_;
-  ZoneList<Statement*>* body_;
-  const AstString* raw_inferred_name_;
-  Handle<String> inferred_name_;
-  AstProperties ast_properties_;
   BailoutReason dont_optimize_reason_;
 
   int materialized_literal_count_;
   int expected_property_count_;
   int parameter_count_;
   int function_token_position_;
   int yield_count_;
+
+  const AstString* raw_name_;
+  Scope* scope_;
+  ZoneList<Statement*>* body_;
+  const AstString* raw_inferred_name_;
+  Handle<String> inferred_name_;
+  AstProperties ast_properties_;
 };
 
 
 class ClassLiteral final : public Expression {
  public:
   typedef ObjectLiteralProperty Property;
 
   DECLARE_NODE_TYPE(ClassLiteral)
 
   Scope* scope() const { return scope_; }
@@ skipping 35 matching lines @@
   bool IsAnonymousFunctionDefinition() const {
     return constructor()->raw_name()->length() == 0;
   }
 
  protected:
   ClassLiteral(Zone* zone, Scope* scope, VariableProxy* class_variable_proxy,
                Expression* extends, FunctionLiteral* constructor,
                ZoneList<Property*>* properties, int start_position,
                int end_position)
       : Expression(zone, start_position, kClassLiteral),
+        end_position_(end_position),
         scope_(scope),
         class_variable_proxy_(class_variable_proxy),
         extends_(extends),
         constructor_(constructor),
-        properties_(properties),
-        end_position_(end_position) {}
+        properties_(properties) {}
 
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  int end_position_;
+  FeedbackVectorSlot prototype_slot_;
+  FeedbackVectorSlot proxy_slot_;
   Scope* scope_;
   VariableProxy* class_variable_proxy_;
   Expression* extends_;
   FunctionLiteral* constructor_;
   ZoneList<Property*>* properties_;
-  int end_position_;
-  FeedbackVectorSlot prototype_slot_;
-  FeedbackVectorSlot proxy_slot_;
 };
 
 
 class NativeFunctionLiteral final : public Expression {
  public:
   DECLARE_NODE_TYPE(NativeFunctionLiteral)
 
   Handle<String> name() const { return name_->string(); }
   v8::Extension* extension() const { return extension_; }
 
@@ skipping 450 matching lines @@
     return new (local_zone_)
         Literal(local_zone_, ast_value_factory_->NewUndefined(), pos);
   }
 
   Literal* NewTheHoleLiteral(int pos) {
     return new (local_zone_)
         Literal(local_zone_, ast_value_factory_->NewTheHole(), pos);
   }
 
   ObjectLiteral* NewObjectLiteral(
-      ZoneList<ObjectLiteral::Property*>* properties,
-      int literal_index,
-      int boilerplate_properties,
-      int pos) {
+      ZoneList<ObjectLiteral::Property*>* properties, int literal_index,
+      uint32_t boilerplate_properties, int pos) {
     return new (local_zone_) ObjectLiteral(
         local_zone_, properties, literal_index, boilerplate_properties, pos);
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(
       Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
       bool is_static, bool is_computed_name) {
     return new (local_zone_)
         ObjectLiteral::Property(key, value, kind, is_static, is_computed_name);
   }
@@ skipping 291 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_