Revert of [snapshot] Move builtins generation into mksnapshot

src/interpreter/interpreter.cc

 // Copyright 2015 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/interpreter/interpreter.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/codegen.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/counters.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/bytecodes.h"
+#include "src/interpreter/interpreter-generator.h"
 #include "src/log.h"
 #include "src/objects.h"
-#include "src/setup-isolate.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 class InterpreterCompilationJob final : public CompilationJob {
  public:
   explicit InterpreterCompilationJob(CompilationInfo* info);
 
  protected:
@@ skipping 37 matching lines @@
   BytecodeGenerator generator_;
   RuntimeCallStats* runtime_call_stats_;
   RuntimeCallCounter background_execute_counter_;
   bool print_bytecode_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpreterCompilationJob);
 };
 
 Interpreter::Interpreter(Isolate* isolate) : isolate_(isolate) {
   memset(dispatch_table_, 0, sizeof(dispatch_table_));
+}
+
+void Interpreter::Initialize() {
+  if (!ShouldInitializeDispatchTable()) return;
+  HandleScope scope(isolate_);
 
   if (FLAG_trace_ignition_dispatches) {
     static const int kBytecodeCount = static_cast<int>(Bytecode::kLast) + 1;
     bytecode_dispatch_counters_table_.reset(
         new uintptr_t[kBytecodeCount * kBytecodeCount]);
     memset(bytecode_dispatch_counters_table_.get(), 0,
            sizeof(uintptr_t) * kBytecodeCount * kBytecodeCount);
   }
+
+  // Generate bytecode handlers for all bytecodes and scales.
+  const OperandScale kOperandScales[] = {
+#define VALUE(Name, _) OperandScale::k##Name,
+      OPERAND_SCALE_LIST(VALUE)
+#undef VALUE
+  };
+
+  for (OperandScale operand_scale : kOperandScales) {
+#define GENERATE_CODE(Name, ...) \
+  InstallBytecodeHandler(isolate_, Bytecode::k##Name, operand_scale);
+    BYTECODE_LIST(GENERATE_CODE)
+#undef GENERATE_CODE
+  }
+
+  // Fill unused entries will the illegal bytecode handler.
+  size_t illegal_index =
+      GetDispatchTableIndex(Bytecode::kIllegal, OperandScale::kSingle);
+  for (size_t index = 0; index < arraysize(dispatch_table_); ++index) {
+    if (dispatch_table_[index] == nullptr) {
+      dispatch_table_[index] = dispatch_table_[illegal_index];
+    }
+  }
+
+  // Initialization should have been successful.
+  DCHECK(IsDispatchTableInitialized());
+}
+
+bool Interpreter::ReuseExistingHandler(Bytecode bytecode,
+                                       OperandScale operand_scale) {
+  size_t index = GetDispatchTableIndex(bytecode, operand_scale);
+  switch (bytecode) {
+    case Bytecode::kCallProperty:
+    case Bytecode::kCallProperty0:
+    case Bytecode::kCallProperty1:
+    case Bytecode::kCallProperty2: {
+      const int offset = static_cast<int>(Bytecode::kCallProperty) -
+                         static_cast<int>(Bytecode::kCall);
+      STATIC_ASSERT(offset ==
+                    static_cast<int>(Bytecode::kCallProperty0) -
+                        static_cast<int>(Bytecode::kCall0));
+      STATIC_ASSERT(offset ==
+                    static_cast<int>(Bytecode::kCallProperty1) -
+                        static_cast<int>(Bytecode::kCall1));
+      STATIC_ASSERT(offset ==
+                    static_cast<int>(Bytecode::kCallProperty2) -
+                        static_cast<int>(Bytecode::kCall2));
+      CHECK_LT(offset, index);
+      dispatch_table_[index] = dispatch_table_[index - offset];
+      return true;
+      break;
+    }
+    default:
+      return false;
+  }
+}
+
+void Interpreter::InstallBytecodeHandler(Isolate* isolate, Bytecode bytecode,
+                                         OperandScale operand_scale) {
+  if (!Bytecodes::BytecodeHasHandler(bytecode, operand_scale)) return;
+  if (ReuseExistingHandler(bytecode, operand_scale)) return;
+
+  size_t index = GetDispatchTableIndex(bytecode, operand_scale);
+  Handle<Code> code = GenerateBytecodeHandler(isolate, bytecode, operand_scale);
+  dispatch_table_[index] = code->entry();
 }
 
 Code* Interpreter::GetBytecodeHandler(Bytecode bytecode,
                                       OperandScale operand_scale) {
   DCHECK(IsDispatchTableInitialized());
   DCHECK(Bytecodes::BytecodeHasHandler(bytecode, operand_scale));
   size_t index = GetDispatchTableIndex(bytecode, operand_scale);
   Address code_entry = dispatch_table_[index];
   return Code::GetCodeFromTargetAddress(code_entry);
 }
@@ skipping 114 matching lines @@
 }
 
 CompilationJob* Interpreter::NewCompilationJob(CompilationInfo* info) {
   return new InterpreterCompilationJob(info);
 }
 
 bool Interpreter::IsDispatchTableInitialized() {
   return dispatch_table_[0] != nullptr;
 }
 
+bool Interpreter::ShouldInitializeDispatchTable() {
+  if (FLAG_trace_ignition || FLAG_trace_ignition_codegen ||
+      FLAG_trace_ignition_dispatches) {
+    // Regenerate table to add bytecode tracing operations, print the assembly
+    // code generated by TurboFan or instrument handlers with dispatch counters.
+    return true;
+  }
+  return !IsDispatchTableInitialized();
+}
+
 const char* Interpreter::LookupNameOfBytecodeHandler(Code* code) {
 #ifdef ENABLE_DISASSEMBLER
 #define RETURN_NAME(Name, ...)                                 \
   if (dispatch_table_[Bytecodes::ToByte(Bytecode::k##Name)] == \
       code->entry()) {                                         \
     return #Name;                                              \
   }
   BYTECODE_LIST(RETURN_NAME)
 #undef RETURN_NAME
 #endif  // ENABLE_DISASSEMBLER
@@ skipping 55 matching lines @@
         counters_map->DefineOwnProperty(context, from_name_object, counters_row)
             .IsJust());
   }
 
   return counters_map;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8