[builtins] Move more files into v8_builtins_generators source set

src/builtins/builtins-constructor-gen.cc

 // Copyright 2016 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.
 
+#include "src/builtins/builtins-constructor-gen.h"
+
 #include "src/ast/ast.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/counters.h"
 #include "src/interface-descriptors.h"
 #include "src/objects-inl.h"
 
@@ skipping 308 matching lines @@
 
   Bind(&end);
   return object;
 }
 
 Node* ConstructorBuiltinsAssembler::EmitFastNewFunctionContext(
     Node* function, Node* slots, Node* context, ScopeType scope_type) {
   slots = ChangeUint32ToWord(slots);
 
   // TODO(ishell): Use CSA::OptimalParameterMode() here.
-  CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
+  ParameterMode mode = INTPTR_PARAMETERS;
   Node* min_context_slots = IntPtrConstant(Context::MIN_CONTEXT_SLOTS);
   Node* length = IntPtrAdd(slots, min_context_slots);
   Node* size = GetFixedArrayAllocationSize(length, FAST_ELEMENTS, mode);
 
   // Create a new closure from the given function info in new space
   Node* function_context = AllocateInNewSpace(size);
 
   Heap::RootListIndex context_type;
   switch (scope_type) {
     case EVAL_SCOPE:
@@ skipping 28 matching lines @@
       function_context, FAST_ELEMENTS, min_context_slots, length,
       [this, undefined](Node* context, Node* offset) {
         StoreNoWriteBarrier(MachineRepresentation::kTagged, context, offset,
                             undefined);
       },
       mode);
 
   return function_context;
 }
 
-// static
-int ConstructorBuiltinsAssembler::MaximumFunctionContextSlots() {
-  return FLAG_test_small_max_function_context_stub_size ? kSmallMaximumSlots
-                                                        : kMaximumSlots;
-}
-
 TF_BUILTIN(FastNewFunctionContextEval, ConstructorBuiltinsAssembler) {
   Node* function = Parameter(FastNewFunctionContextDescriptor::kFunction);
   Node* slots = Parameter(FastNewFunctionContextDescriptor::kSlots);
   Node* context = Parameter(FastNewFunctionContextDescriptor::kContext);
   Return(EmitFastNewFunctionContext(function, slots, context,
                                     ScopeType::EVAL_SCOPE));
 }
 
 TF_BUILTIN(FastNewFunctionContextFunction, ConstructorBuiltinsAssembler) {
   Node* function = Parameter(FastNewFunctionContextDescriptor::kFunction);
   Node* slots = Parameter(FastNewFunctionContextDescriptor::kSlots);
   Node* context = Parameter(FastNewFunctionContextDescriptor::kContext);
   Return(EmitFastNewFunctionContext(function, slots, context,
                                     ScopeType::FUNCTION_SCOPE));
 }
 
 Node* ConstructorBuiltinsAssembler::EmitFastCloneRegExp(Node* closure,
                                                         Node* literal_index,
                                                         Node* pattern,
                                                         Node* flags,
                                                         Node* context) {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
-  typedef compiler::Node Node;
-
   Label call_runtime(this, Label::kDeferred), end(this);
 
   Variable result(this, MachineRepresentation::kTagged);
 
   Node* cell = LoadObjectField(closure, JSFunction::kFeedbackVectorOffset);
   Node* feedback_vector = LoadObjectField(cell, Cell::kValueOffset);
   Node* boilerplate = LoadFixedArrayElement(feedback_vector, literal_index, 0,
                                             CodeStubAssembler::SMI_PARAMETERS);
   GotoIf(IsUndefined(boilerplate), &call_runtime);
 
@@ skipping 25 matching lines @@
   Node* pattern = Parameter(FastCloneRegExpDescriptor::kPattern);
   Node* flags = Parameter(FastCloneRegExpDescriptor::kFlags);
   Node* context = Parameter(FastCloneRegExpDescriptor::kContext);
 
   Return(EmitFastCloneRegExp(closure, literal_index, pattern, flags, context));
 }
 
 Node* ConstructorBuiltinsAssembler::NonEmptyShallowClone(
     Node* boilerplate, Node* boilerplate_map, Node* boilerplate_elements,
     Node* allocation_site, Node* capacity, ElementsKind kind) {
-  typedef CodeStubAssembler::ParameterMode ParameterMode;
-
   ParameterMode param_mode = OptimalParameterMode();
 
   Node* length = LoadJSArrayLength(boilerplate);
   capacity = TaggedToParameter(capacity, param_mode);
 
   Node *array, *elements;
   std::tie(array, elements) = AllocateUninitializedJSArrayWithElements(
       kind, boilerplate_map, length, allocation_site, capacity, param_mode);
 
   Comment("copy elements header");
@@ skipping 112 matching lines @@
     result.Bind(array);
     Goto(&return_result);
   }
 
   Bind(&return_result);
   return result.value();
 }
 
 void ConstructorBuiltinsAssembler::CreateFastCloneShallowArrayBuiltin(
     AllocationSiteMode allocation_site_mode) {
-  typedef compiler::Node Node;
-  typedef CodeStubAssembler::Label Label;
-
   Node* closure = Parameter(FastCloneShallowArrayDescriptor::kClosure);
   Node* literal_index =
       Parameter(FastCloneShallowArrayDescriptor::kLiteralIndex);
   Node* constant_elements =
       Parameter(FastCloneShallowArrayDescriptor::kConstantElements);
   Node* context = Parameter(FastCloneShallowArrayDescriptor::kContext);
   Label call_runtime(this, Label::kDeferred);
   Return(EmitFastCloneShallowArray(closure, literal_index, context,
                                    &call_runtime, allocation_site_mode));
 
@@ skipping 11 matching lines @@
 }
 
 TF_BUILTIN(FastCloneShallowArrayTrack, ConstructorBuiltinsAssembler) {
   CreateFastCloneShallowArrayBuiltin(TRACK_ALLOCATION_SITE);
 }
 
 TF_BUILTIN(FastCloneShallowArrayDontTrack, ConstructorBuiltinsAssembler) {
   CreateFastCloneShallowArrayBuiltin(DONT_TRACK_ALLOCATION_SITE);
 }
 
-// static
-int ConstructorBuiltinsAssembler::FastCloneShallowObjectPropertiesCount(
-    int literal_length) {
-  // This heuristic of setting empty literals to have
-  // kInitialGlobalObjectUnusedPropertiesCount must remain in-sync with the
-  // runtime.
-  // TODO(verwaest): Unify this with the heuristic in the runtime.
-  return literal_length == 0
-             ? JSObject::kInitialGlobalObjectUnusedPropertiesCount
-             : literal_length;
-}
-
 Node* ConstructorBuiltinsAssembler::EmitFastCloneShallowObject(
     Label* call_runtime, Node* closure, Node* literals_index,
     Node* properties_count) {
   Node* cell = LoadObjectField(closure, JSFunction::kFeedbackVectorOffset);
   Node* feedback_vector = LoadObjectField(cell, Cell::kValueOffset);
   Node* allocation_site = LoadFixedArrayElement(
       feedback_vector, literals_index, 0, CodeStubAssembler::SMI_PARAMETERS);
   GotoIf(IsUndefined(allocation_site), call_runtime);
 
   // Calculate the object and allocation size based on the properties count.
@@ skipping 50 matching lines @@
                                    memento_create_count);
   }
 
   // TODO(verwaest): Allocate and fill in double boxes.
   return copy;
 }
 
 void ConstructorBuiltinsAssembler::CreateFastCloneShallowObjectBuiltin(
     int properties_count) {
   DCHECK_GE(properties_count, 0);
-  DCHECK_LE(properties_count, kMaximumClonedShallowObjectProperties);
+  DCHECK_LE(properties_count,
+            ConstructorBuiltins::kMaximumClonedShallowObjectProperties);
   Label call_runtime(this);
   Node* closure = Parameter(0);
   Node* literals_index = Parameter(1);
 
   Node* properties_count_node =
-      IntPtrConstant(FastCloneShallowObjectPropertiesCount(properties_count));
+      IntPtrConstant(ConstructorBuiltins::FastCloneShallowObjectPropertiesCount(
+          properties_count));
   Node* copy = EmitFastCloneShallowObject(
       &call_runtime, closure, literals_index, properties_count_node);
   Return(copy);
 
   Bind(&call_runtime);
   Node* constant_properties = Parameter(2);
   Node* flags = Parameter(3);
   Node* context = Parameter(4);
   TailCallRuntime(Runtime::kCreateObjectLiteral, context, closure,
                   literals_index, constant_properties, flags);
 }
 
 #define SHALLOW_OBJECT_BUILTIN(props)                                       \
   TF_BUILTIN(FastCloneShallowObject##props, ConstructorBuiltinsAssembler) { \
     CreateFastCloneShallowObjectBuiltin(props);                             \
   }
 
 SHALLOW_OBJECT_BUILTIN(0);
 SHALLOW_OBJECT_BUILTIN(1);
 SHALLOW_OBJECT_BUILTIN(2);
 SHALLOW_OBJECT_BUILTIN(3);
 SHALLOW_OBJECT_BUILTIN(4);
 SHALLOW_OBJECT_BUILTIN(5);
 SHALLOW_OBJECT_BUILTIN(6);
 
 }  // namespace internal
 }  // namespace v8