[builtins] move conversions, debugger, handlers, interpreter builtins.

BUG=v8:5197

Review-Url: https://codereview.chromium.org/2168273004
Cr-Commit-Position: refs/heads/master@{#38012}

BUILD.gn

@@ -876,12 +876,16 @@ v8_source_set("v8_base") {
     "src/builtins/builtins-arraybuffer.cc",
     "src/builtins/builtins-boolean.cc",
     "src/builtins/builtins-callsite.cc",
+    "src/builtins/builtins-conversion.cc",
     "src/builtins/builtins-dataview.cc",
     "src/builtins/builtins-date.cc",
+    "src/builtins/builtins-debug.cc",
     "src/builtins/builtins-error.cc",
     "src/builtins/builtins-function.cc",
     "src/builtins/builtins-global.cc",
+    "src/builtins/builtins-handler.cc",
     "src/builtins/builtins-internal.cc",
+    "src/builtins/builtins-interpreter.cc",
     "src/builtins/builtins-json.cc",
     "src/builtins/builtins-math.cc",
     "src/builtins/builtins-number.cc",

src/builtins/builtins-debug.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.h"
+#include "src/builtins/builtins-utils.h"
+#include "src/debug/debug.h"
+
+namespace v8 {
+namespace internal {
+
+void Builtins::Generate_Return_DebugBreak(MacroAssembler* masm) {
+  DebugCodegen::GenerateDebugBreakStub(masm,
+                                       DebugCodegen::SAVE_RESULT_REGISTER);
+}
+
+void Builtins::Generate_Slot_DebugBreak(MacroAssembler* masm) {
+  DebugCodegen::GenerateDebugBreakStub(masm,
+                                       DebugCodegen::IGNORE_RESULT_REGISTER);
+}
+
+void Builtins::Generate_FrameDropper_LiveEdit(MacroAssembler* masm) {
+  DebugCodegen::GenerateFrameDropperLiveEdit(masm);
+}
+
+}  // namespace internal
+}  // namespace v8

src/builtins/builtins-handler.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.h"
+#include "src/builtins/builtins-utils.h"
+#include "src/ic/handler-compiler.h"
+#include "src/ic/ic.h"
+
+namespace v8 {
+namespace internal {
+
+void Builtins::Generate_KeyedLoadIC_Megamorphic(MacroAssembler* masm) {
+  KeyedLoadIC::GenerateMegamorphic(masm);
+}
+
+void Builtins::Generate_KeyedLoadIC_Miss(MacroAssembler* masm) {
+  KeyedLoadIC::GenerateMiss(masm);
+}
+void Builtins::Generate_KeyedLoadIC_Slow(MacroAssembler* masm) {
+  KeyedLoadIC::GenerateRuntimeGetProperty(masm);
+}
+
+void Builtins::Generate_KeyedStoreIC_Megamorphic(MacroAssembler* masm) {
+  KeyedStoreIC::GenerateMegamorphic(masm, SLOPPY);
+}
+
+void Builtins::Generate_KeyedStoreIC_Megamorphic_Strict(MacroAssembler* masm) {
+  KeyedStoreIC::GenerateMegamorphic(masm, STRICT);
+}
+
+void Builtins::Generate_KeyedStoreIC_Miss(MacroAssembler* masm) {
+  KeyedStoreIC::GenerateMiss(masm);
+}
+
+void Builtins::Generate_KeyedStoreIC_Slow(MacroAssembler* masm) {
+  ElementHandlerCompiler::GenerateStoreSlow(masm);
+}
+
+void Builtins::Generate_LoadGlobalIC_Miss(CodeStubAssembler* assembler) {
+  typedef compiler::Node Node;
+
+  Node* slot = assembler->Parameter(0);
+  Node* vector = assembler->Parameter(1);
+  Node* context = assembler->Parameter(2);
+
+  assembler->TailCallRuntime(Runtime::kLoadGlobalIC_Miss, context, slot,
+                             vector);
+}
+
+namespace {
+void Generate_LoadGlobalIC_Slow(CodeStubAssembler* assembler, TypeofMode mode) {
+  typedef compiler::Node Node;
+
+  Node* slot = assembler->Parameter(0);
+  Node* vector = assembler->Parameter(1);
+  Node* context = assembler->Parameter(2);
+  Node* typeof_mode = assembler->SmiConstant(Smi::FromInt(mode));
+
+  assembler->TailCallRuntime(Runtime::kGetGlobal, context, slot, vector,
+                             typeof_mode);
+}
+}  // anonymous namespace
+
+void Builtins::Generate_LoadGlobalIC_SlowInsideTypeof(
+    CodeStubAssembler* assembler) {
+  Generate_LoadGlobalIC_Slow(assembler, INSIDE_TYPEOF);
+}
+
+void Builtins::Generate_LoadGlobalIC_SlowNotInsideTypeof(
+    CodeStubAssembler* assembler) {
+  Generate_LoadGlobalIC_Slow(assembler, NOT_INSIDE_TYPEOF);
+}
+
+void Builtins::Generate_LoadIC_Getter_ForDeopt(MacroAssembler* masm) {
+  NamedLoadHandlerCompiler::GenerateLoadViaGetterForDeopt(masm);
+}
+
+void Builtins::Generate_LoadIC_Miss(CodeStubAssembler* assembler) {
+  typedef compiler::Node Node;
+
+  Node* receiver = assembler->Parameter(0);
+  Node* name = assembler->Parameter(1);
+  Node* slot = assembler->Parameter(2);
+  Node* vector = assembler->Parameter(3);
+  Node* context = assembler->Parameter(4);
+
+  assembler->TailCallRuntime(Runtime::kLoadIC_Miss, context, receiver, name,
+                             slot, vector);
+}
+
+void Builtins::Generate_LoadIC_Normal(MacroAssembler* masm) {
+  LoadIC::GenerateNormal(masm);
+}
+
+void Builtins::Generate_LoadIC_Slow(CodeStubAssembler* assembler) {
+  typedef compiler::Node Node;
+
+  Node* receiver = assembler->Parameter(0);
+  Node* name = assembler->Parameter(1);
+  // Node* slot = assembler->Parameter(2);
+  // Node* vector = assembler->Parameter(3);
+  Node* context = assembler->Parameter(4);
+
+  assembler->TailCallRuntime(Runtime::kGetProperty, context, receiver, name);
+}
+
+void Builtins::Generate_StoreIC_Miss(CodeStubAssembler* assembler) {
+  typedef compiler::Node Node;
+
+  Node* receiver = assembler->Parameter(0);
+  Node* name = assembler->Parameter(1);
+  Node* value = assembler->Parameter(2);
+  Node* slot = assembler->Parameter(3);
+  Node* vector = assembler->Parameter(4);
+  Node* context = assembler->Parameter(5);
+
+  assembler->TailCallRuntime(Runtime::kStoreIC_Miss, context, receiver, name,
+                             value, slot, vector);
+}
+
+void Builtins::Generate_StoreIC_Normal(MacroAssembler* masm) {
+  StoreIC::GenerateNormal(masm);
+}
+
+void Builtins::Generate_StoreIC_Setter_ForDeopt(MacroAssembler* masm) {
+  NamedStoreHandlerCompiler::GenerateStoreViaSetterForDeopt(masm);
+}
+
+namespace {
+void Generate_StoreIC_Slow(CodeStubAssembler* assembler,
+                           LanguageMode language_mode) {
+  typedef compiler::Node Node;
+
+  Node* receiver = assembler->Parameter(0);
+  Node* name = assembler->Parameter(1);
+  Node* value = assembler->Parameter(2);
+  // Node* slot = assembler->Parameter(3);
+  // Node* vector = assembler->Parameter(4);
+  Node* context = assembler->Parameter(5);
+  Node* lang_mode = assembler->SmiConstant(Smi::FromInt(language_mode));
+
+  // The slow case calls into the runtime to complete the store without causing
+  // an IC miss that would otherwise cause a transition to the generic stub.
+  assembler->TailCallRuntime(Runtime::kSetProperty, context, receiver, name,
+                             value, lang_mode);
+}
+}  // anonymous namespace
+
+void Builtins::Generate_StoreIC_SlowSloppy(CodeStubAssembler* assembler) {
+  Generate_StoreIC_Slow(assembler, SLOPPY);
+}
+
+void Builtins::Generate_StoreIC_SlowStrict(CodeStubAssembler* assembler) {
+  Generate_StoreIC_Slow(assembler, STRICT);
+}
+
+}  // namespace internal
+}  // namespace v8

src/builtins/builtins-interpreter.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.h"
+#include "src/builtins/builtins-utils.h"
+
+namespace v8 {
+namespace internal {
+
+Handle<Code> Builtins::InterpreterPushArgsAndCall(TailCallMode tail_call_mode,
+                                                  CallableType function_type) {
+  switch (tail_call_mode) {
+    case TailCallMode::kDisallow:
+      if (function_type == CallableType::kJSFunction) {
+        return InterpreterPushArgsAndCallFunction();
+      } else {
+        return InterpreterPushArgsAndCall();
+      }
+    case TailCallMode::kAllow:
+      if (function_type == CallableType::kJSFunction) {
+        return InterpreterPushArgsAndTailCallFunction();
+      } else {
+        return InterpreterPushArgsAndTailCall();
+      }
+  }
+  UNREACHABLE();
+  return Handle<Code>::null();
+}
+
+void Builtins::Generate_InterpreterPushArgsAndCall(MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kDisallow,
+                                                 CallableType::kAny);
+}
+
+void Builtins::Generate_InterpreterPushArgsAndCallFunction(
+    MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kDisallow,
+                                                 CallableType::kJSFunction);
+}
+
+void Builtins::Generate_InterpreterPushArgsAndTailCall(MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kAllow,
+                                                 CallableType::kAny);
+}
+
+void Builtins::Generate_InterpreterPushArgsAndTailCallFunction(
+    MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kAllow,
+                                                 CallableType::kJSFunction);
+}
+
+}  // namespace internal
+}  // namespace v8

src/builtins/builtins.h

@@ -50,26 +50,26 @@ namespace internal {
 #define BUILTIN_LIST(CPP, API, TFJ, TFS, ASM, ASH, DBG)                      \
   ASM(Abort)                                                                 \
   /* Handlers */                                                             \
-  ASM(KeyedLoadIC_Miss)                                                      \
-  ASM(KeyedStoreIC_Miss)                                                     \
-  ASH(LoadIC_Getter_ForDeopt, LOAD_IC, kNoExtraICState)                      \
   ASH(KeyedLoadIC_Megamorphic, KEYED_LOAD_IC, kNoExtraICState)               \
-  ASH(StoreIC_Setter_ForDeopt, STORE_IC, StoreICState::kStrictModeState)     \
+  ASM(KeyedLoadIC_Miss)                                                      \
+  ASH(KeyedLoadIC_Slow, HANDLER, Code::KEYED_LOAD_IC)                        \
   ASH(KeyedStoreIC_Megamorphic, KEYED_STORE_IC, kNoExtraICState)             \
   ASH(KeyedStoreIC_Megamorphic_Strict, KEYED_STORE_IC,                       \
       StoreICState::kStrictModeState)                                        \
-  ASH(KeyedLoadIC_Slow, HANDLER, Code::KEYED_LOAD_IC)                        \
+  ASM(KeyedStoreIC_Miss)                                                     \
   ASH(KeyedStoreIC_Slow, HANDLER, Code::KEYED_STORE_IC)                      \
-  ASH(LoadIC_Normal, HANDLER, Code::LOAD_IC)                                 \
-  ASH(StoreIC_Normal, HANDLER, Code::STORE_IC)                               \
   TFS(LoadGlobalIC_Miss, BUILTIN, kNoExtraICState, LoadGlobalWithVector)     \
-  TFS(LoadGlobalIC_SlowNotInsideTypeof, HANDLER, Code::LOAD_GLOBAL_IC,       \
-      LoadGlobalWithVector)                                                  \
   TFS(LoadGlobalIC_SlowInsideTypeof, HANDLER, Code::LOAD_GLOBAL_IC,          \
       LoadGlobalWithVector)                                                  \
+  TFS(LoadGlobalIC_SlowNotInsideTypeof, HANDLER, Code::LOAD_GLOBAL_IC,       \
+      LoadGlobalWithVector)                                                  \
+  ASH(LoadIC_Getter_ForDeopt, LOAD_IC, kNoExtraICState)                      \
   TFS(LoadIC_Miss, BUILTIN, kNoExtraICState, LoadWithVector)                 \
+  ASH(LoadIC_Normal, HANDLER, Code::LOAD_IC)                                 \
   TFS(LoadIC_Slow, HANDLER, Code::LOAD_IC, LoadWithVector)                   \
   TFS(StoreIC_Miss, BUILTIN, kNoExtraICState, StoreWithVector)               \
+  ASH(StoreIC_Normal, HANDLER, Code::STORE_IC)                               \
+  ASH(StoreIC_Setter_ForDeopt, STORE_IC, StoreICState::kStrictModeState)     \
   TFS(StoreIC_SlowSloppy, HANDLER, Code::STORE_IC, StoreWithVector)          \
   TFS(StoreIC_SlowStrict, HANDLER, Code::STORE_IC, StoreWithVector)          \
                                                                              \
@@ -124,11 +124,11 @@ namespace internal {
   /* Interpreter */                                                          \
   ASM(InterpreterEntryTrampoline)                                            \
   ASM(InterpreterMarkBaselineOnReturn)                                       \
-  ASM(InterpreterPushArgsAndCallFunction)                                    \
-  ASM(InterpreterPushArgsAndTailCallFunction)                                \
   ASM(InterpreterPushArgsAndCall)                                            \
-  ASM(InterpreterPushArgsAndTailCall)                                        \
+  ASM(InterpreterPushArgsAndCallFunction)                                    \
   ASM(InterpreterPushArgsAndConstruct)                                       \
+  ASM(InterpreterPushArgsAndTailCall)                                        \
+  ASM(InterpreterPushArgsAndTailCallFunction)                                \
   ASM(InterpreterEnterBytecodeDispatch)                                      \
                                                                              \
   /* Code life-cycle */                                                      \
@@ -159,9 +159,9 @@ namespace internal {
   ASM(AllocateInOldSpace)                                                    \
                                                                              \
   /* Debugger */                                                             \
+  DBG(FrameDropper_LiveEdit)                                                 \
   DBG(Return_DebugBreak)                                                     \
   DBG(Slot_DebugBreak)                                                       \
-  DBG(FrameDropper_LiveEdit)                                                 \
                                                                              \
   /* Type conversions */                                                     \
   TFS(ToBoolean, BUILTIN, kNoExtraICState, TypeConversion)                   \

src/v8.gyp

@@ -489,12 +489,16 @@
         'builtins/builtins-array.cc',
         'builtins/builtins-boolean.cc',
         'builtins/builtins-callsite.cc',
+        'builtins/builtins-conversion.cc',
         'builtins/builtins-dataview.cc',
         'builtins/builtins-date.cc',
+        'builtins/builtins-debug.cc',
         'builtins/builtins-error.cc',
         'builtins/builtins-function.cc',
         'builtins/builtins-global.cc',
+        'builtins/builtins-handler.cc',
         'builtins/builtins-internal.cc',
+        'builtins/builtins-interpreter.cc',
         'builtins/builtins-json.cc',
         'builtins/builtins-math.cc',
         'builtins/builtins-number.cc',