Make some functions that are hit during renderer startup available for inlining

src/ast/variables.h

 // Copyright 2011 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_VARIABLES_H_
 #define V8_AST_VARIABLES_H_
 
 #include "src/ast/ast-value-factory.h"
 #include "src/globals.h"
 #include "src/zone/zone.h"
 
 namespace v8 {
 namespace internal {
 
 // The AST refers to variables via VariableProxies - placeholders for the actual
 // variables. Variables themselves are never directly referred to from the AST,
 // they are maintained by scopes, and referred to from VariableProxies and Slots
 // after binding and variable allocation.
 class Variable final : public ZoneObject {
  public:
   Variable(Scope* scope, const AstRawString* name, VariableMode mode,
            VariableKind kind, InitializationFlag initialization_flag,
-           MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
+           MaybeAssignedFlag maybe_assigned_flag = kNotAssigned)
+      : scope_(scope),
+        name_(name),
+        local_if_not_shadowed_(nullptr),
+        next_(nullptr),
+        index_(-1),
+        initializer_position_(kNoSourcePosition),
+        bit_field_(MaybeAssignedFlagField::encode(maybe_assigned_flag) |
+                   InitializationFlagField::encode(initialization_flag) |
+                   VariableModeField::encode(mode) |
+                   IsUsedField::encode(false) |
+                   ForceContextAllocationField::encode(false) |
+                   ForceHoleInitializationField::encode(false) |
+                   LocationField::encode(VariableLocation::UNALLOCATED) |
+                   VariableKindField::encode(kind)) {
+    // Var declared variables never need initialization.
+    DCHECK(!(mode == VAR && initialization_flag == kNeedsInitialization));
+  }
 
   // The source code for an eval() call may refer to a variable that is
   // in an outer scope about which we don't know anything (it may not
   // be the script scope). scope() is NULL in that case. Currently the
   // scope is only used to follow the context chain length.
   Scope* scope() const { return scope_; }
 
   // This is for adjusting the scope of temporaries used when desugaring
   // parameter initializers.
   void set_scope(Scope* scope) { scope_ = scope; }
@@ skipping 157 matching lines @@
   class MaybeAssignedFlagField
       : public BitField16<MaybeAssignedFlag,
                           ForceHoleInitializationField::kNext, 1> {};
   Variable** next() { return &next_; }
   friend List;
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_VARIABLES_H_