// Copyright 2017 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/setup-interpreter.h"

#include "src/handles-inl.h"
#include "src/interpreter/bytecodes.h"
#include "src/interpreter/interpreter-generator.h"
#include "src/interpreter/interpreter.h"
#include "src/objects-inl.h"

namespace v8 {
namespace internal {
namespace interpreter {

namespace {
void PrintBuiltinSize(Bytecode bytecode, OperandScale operand_scale,
                      Handle<Code> code) {
  PrintF(stdout, "Ignition Handler, %s, %d\n",
         Bytecodes::ToString(bytecode, operand_scale).c_str(),
         code->InstructionSize());
}
}  // namespace

// static
void SetupInterpreter::InstallBytecodeHandlers(Interpreter* interpreter) {
  DCHECK(!interpreter->IsDispatchTableInitialized());
  HandleScope scope(interpreter->isolate_);
  // Canonicalize handles, so that we can share constant pool entries pointing
  // to code targets without dereferencing their handles.
  CanonicalHandleScope canonical(interpreter->isolate_);
  Address* dispatch_table = interpreter->dispatch_table_;

  // 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(interpreter->isolate_, dispatch_table, \
                         Bytecode::k##Name, operand_scale);
    BYTECODE_LIST(GENERATE_CODE)
#undef GENERATE_CODE
  }

  // Fill unused entries will the illegal bytecode handler.
  size_t illegal_index = Interpreter::GetDispatchTableIndex(
      Bytecode::kIllegal, OperandScale::kSingle);
  for (size_t index = 0; index < Interpreter::kDispatchTableSize; ++index) {
    if (dispatch_table[index] == kNullAddress) {
      dispatch_table[index] = dispatch_table[illegal_index];
    }
  }

  // Generate the DeserializeLazy handlers, one for each operand scale.
  Heap* heap = interpreter->isolate_->heap();
  DCHECK_EQ(Smi::kZero, heap->deserialize_lazy_handler());
  heap->SetDeserializeLazyHandler(*GenerateDeserializeLazyHandler(
      interpreter->isolate_, OperandScale::kSingle));
  DCHECK_EQ(Smi::kZero, heap->deserialize_lazy_handler_wide());
  heap->SetDeserializeLazyHandlerWide(*GenerateDeserializeLazyHandler(
      interpreter->isolate_, OperandScale::kDouble));
  DCHECK_EQ(Smi::kZero, heap->deserialize_lazy_handler_extra_wide());
  heap->SetDeserializeLazyHandlerExtraWide(*GenerateDeserializeLazyHandler(
      interpreter->isolate_, OperandScale::kQuadruple));

  // Initialization should have been successful.
  DCHECK(interpreter->IsDispatchTableInitialized());
}

// static
void SetupInterpreter::InstallBytecodeHandler(Isolate* isolate,
                                              Address* dispatch_table,
                                              Bytecode bytecode,
                                              OperandScale operand_scale) {
  if (!Bytecodes::BytecodeHasHandler(bytecode, operand_scale)) return;

  size_t index = Interpreter::GetDispatchTableIndex(bytecode, operand_scale);
  // Here we explicitly set the bytecode handler to not be a builtin with an
  // index of kNoBuiltinId.
  // TODO(delphick): Use builtins version instead.
  Handle<Code> code = GenerateBytecodeHandler(isolate, bytecode, operand_scale,
                                              Builtins::kNoBuiltinId);
  dispatch_table[index] = code->entry();

  if (FLAG_print_builtin_size) PrintBuiltinSize(bytecode, operand_scale, code);

#ifdef ENABLE_DISASSEMBLER
  if (FLAG_print_builtin_code) {
    std::string name = Bytecodes::ToString(bytecode, operand_scale);
    code->PrintBuiltinCode(isolate, name.c_str());
  }
#endif  // ENABLE_DISASSEMBLER
}

}  // namespace interpreter
}  // namespace internal
}  // namespace v8