[refactor] Separate generated builtins and C++ builtins into separate files

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/ast/ast.h"
 #include "src/builtins/builtins-constructor.h"
-#include "src/ast/ast.h"
-#include "src/builtins/builtins-utils.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"
 
 namespace v8 {
 namespace internal {
 
 typedef compiler::Node Node;
 
 Node* ConstructorBuiltinsAssembler::EmitFastNewClosure(Node* shared_info,
                                                        Node* feedback_vector,
                                                        Node* slot,
                                                        Node* context) {
-  typedef compiler::CodeAssembler::Label Label;
-  typedef compiler::CodeAssembler::Variable Variable;
-
   Isolate* isolate = this->isolate();
   Factory* factory = isolate->factory();
   IncrementCounter(isolate->counters()->fast_new_closure_total(), 1);
 
   // Create a new closure from the given function info in new space
   Node* result = Allocate(JSFunction::kSize);
 
   // Calculate the index of the map we should install on the function based on
   // the FunctionKind and LanguageMode of the function.
   // Note: Must be kept in sync with Context::FunctionMapIndex
@@ skipping 167 matching lines @@
   Goto(&end);
 
   Bind(&call_runtime);
   var_obj.Bind(CallRuntime(Runtime::kNewObject, context, target, new_target));
   Goto(&end);
 
   Bind(&end);
   return var_obj.value();
 }
 
-Node* ConstructorBuiltinsAssembler::EmitFastNewObject(
-    Node* context, Node* target, Node* new_target,
-    CodeAssemblerLabel* call_runtime) {
+Node* ConstructorBuiltinsAssembler::EmitFastNewObject(Node* context,
+                                                      Node* target,
+                                                      Node* new_target,
+                                                      Label* call_runtime) {
   CSA_ASSERT(this, HasInstanceType(target, JS_FUNCTION_TYPE));
   CSA_ASSERT(this, IsJSReceiver(new_target));
 
   // Verify that the new target is a JSFunction.
   Label fast(this), end(this);
   GotoIf(HasInstanceType(new_target, JS_FUNCTION_TYPE), &fast);
   Goto(call_runtime);
 
   Bind(&fast);
 
@@ skipping 169 matching lines @@
 }
 
 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));
 }
 
-Handle<Code> Builtins::NewFunctionContext(ScopeType scope_type) {
-  switch (scope_type) {
-    case ScopeType::EVAL_SCOPE:
-      return FastNewFunctionContextEval();
-    case ScopeType::FUNCTION_SCOPE:
-      return FastNewFunctionContextFunction();
-    default:
-      UNREACHABLE();
-  }
-  return Handle<Code>::null();
-}
-
 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);
@@ skipping 66 matching lines @@
 
   Comment("copy boilerplate elements");
   CopyFixedArrayElements(kind, boilerplate_elements, elements, length,
                          SKIP_WRITE_BARRIER, param_mode);
   IncrementCounter(isolate()->counters()->inlined_copied_elements(), 1);
 
   return array;
 }
 
 Node* ConstructorBuiltinsAssembler::EmitFastCloneShallowArray(
-    Node* closure, Node* literal_index, Node* context,
-    CodeAssemblerLabel* call_runtime, AllocationSiteMode allocation_site_mode) {
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
-  typedef compiler::Node Node;
-
+    Node* closure, Node* literal_index, Node* context, Label* call_runtime,
+    AllocationSiteMode allocation_site_mode) {
   Label zero_capacity(this), cow_elements(this), fast_elements(this),
       return_result(this);
   Variable result(this, MachineRepresentation::kTagged);
 
   Node* cell = LoadObjectField(closure, JSFunction::kFeedbackVectorOffset);
   Node* feedback_vector = LoadObjectField(cell, Cell::kValueOffset);
   Node* allocation_site = LoadFixedArrayElement(
       feedback_vector, literal_index, 0, CodeStubAssembler::SMI_PARAMETERS);
 
   GotoIf(IsUndefined(allocation_site), call_runtime);
@@ skipping 114 matching lines @@
 }
 
 TF_BUILTIN(FastCloneShallowArrayTrack, ConstructorBuiltinsAssembler) {
   CreateFastCloneShallowArrayBuiltin(TRACK_ALLOCATION_SITE);
 }
 
 TF_BUILTIN(FastCloneShallowArrayDontTrack, ConstructorBuiltinsAssembler) {
   CreateFastCloneShallowArrayBuiltin(DONT_TRACK_ALLOCATION_SITE);
 }
 
-Handle<Code> Builtins::NewCloneShallowArray(
-    AllocationSiteMode allocation_mode) {
-  switch (allocation_mode) {
-    case TRACK_ALLOCATION_SITE:
-      return FastCloneShallowArrayTrack();
-    case DONT_TRACK_ALLOCATION_SITE:
-      return FastCloneShallowArrayDontTrack();
-    default:
-      UNREACHABLE();
-  }
-  return Handle<Code>::null();
-}
-
 // 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(
-    CodeAssemblerLabel* call_runtime, Node* closure, Node* literals_index,
+    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.
   Node* object_size = IntPtrAdd(WordShl(properties_count, kPointerSizeLog2),
                                 IntPtrConstant(JSObject::kHeaderSize));
@@ skipping 80 matching lines @@
   }
 
 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);
 
-Handle<Code> Builtins::NewCloneShallowObject(int length) {
-  switch (length) {
-    case 0:
-      return FastCloneShallowObject0();
-    case 1:
-      return FastCloneShallowObject1();
-    case 2:
-      return FastCloneShallowObject2();
-    case 3:
-      return FastCloneShallowObject3();
-    case 4:
-      return FastCloneShallowObject4();
-    case 5:
-      return FastCloneShallowObject5();
-    case 6:
-      return FastCloneShallowObject6();
-    default:
-      UNREACHABLE();
-  }
-  return Handle<Code>::null();
-}
-
 }  // namespace internal
 }  // namespace v8