[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"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 class InterpreterCompilationJob final : public CompilationJob {
  public:
   explicit InterpreterCompilationJob(CompilationInfo* info);
@@ skipping 41 matching lines @@
   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() {

[Jakob Kummerow, 2017/03/21 16:38:00]

This moved to setup-interpreter-full.cc.

-  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);
 }
 
 // static
@@ skipping 112 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