/*
 * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
 * Copyright 2010-xxx Lemote, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 *
 */

#include "incls/_precompiled.incl"
#include "incls/_cppInterpreter_mips.cpp.incl"

#ifdef CC_INTERP

// Routine exists to make tracebacks look decent in debugger
// while "shadow" interpreter frames are on stack. It is also
// used to distinguish interpreter frames.

extern "C" void RecursiveInterpreterActivation(interpreterState istate) {
  ShouldNotReachHere();
}

bool CppInterpreter::contains(address pc) {
  Unimplemented();
}

#define STATE(field_name) Lstate, in_bytes(byte_offset_of(BytecodeInterpreter, field_name))
#define __ _masm->

Label frame_manager_entry;
Label fast_accessor_slow_entry_path;  // fast accessor methods need to be able to jmp to unsynchronized
                                      // c++ interpreter entry point this holds that entry point label.

static address unctrap_frame_manager_entry  = NULL;

static address interpreter_return_address  = NULL;
static address deopt_frame_manager_return_atos  = NULL;
static address deopt_frame_manager_return_btos  = NULL;
static address deopt_frame_manager_return_itos  = NULL;
static address deopt_frame_manager_return_ltos  = NULL;
static address deopt_frame_manager_return_ftos  = NULL;
static address deopt_frame_manager_return_dtos  = NULL;
static address deopt_frame_manager_return_vtos  = NULL;

const Register prevState = G1_scratch;

void InterpreterGenerator::save_native_result(void) {
  Unimplemented();
}

void InterpreterGenerator::restore_native_result(void) {
  Unimplemented();
}

// A result handler converts/unboxes a native call result into
// a java interpreter/compiler result. The current frame is an
// interpreter frame. The activation frame unwind code must be
// consistent with that of TemplateTable::_return(...). In the
// case of native methods, the caller's SP was not modified.
address CppInterpreterGenerator::generate_result_handler_for(BasicType type) {
  Unimplemented();
}

address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) {
  Unimplemented();
}

address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {
  Unimplemented();
}

address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {
  Unimplemented();
}

address CppInterpreter::return_entry(TosState state, int length) {
  Unimplemented();
}

address CppInterpreter::deopt_entry(TosState state, int length) {
  Unimplemented();
}

void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {
  Unimplemented();
}

address InterpreterGenerator::generate_empty_entry(void) {
  Unimplemented();
}

address InterpreterGenerator::generate_accessor_entry(void) {
  Unimplemented();
}

address InterpreterGenerator::generate_native_entry(bool synchronized) {
  Unimplemented();
}

void CppInterpreterGenerator::generate_compute_interpreter_state(const Register state,
                                                              const Register prev_state,
                                                              bool native) {
  Unimplemented();
}

void InterpreterGenerator::lock_method(void) {
  Unimplemented();
}

void CppInterpreterGenerator::generate_deopt_handling() {
  Unimplemented();
}

void CppInterpreterGenerator::generate_more_monitors() {
  Unimplemented();
}


static address interpreter_frame_manager = NULL;

void CppInterpreterGenerator::adjust_callers_stack(Register args) {
  Unimplemented();
}

address InterpreterGenerator::generate_normal_entry(bool synchronized) {
  Unimplemented();
}

InterpreterGenerator::InterpreterGenerator(StubQueue* code)
 : CppInterpreterGenerator(code) {
  Unimplemented();
}


static int size_activation_helper(int callee_extra_locals, int max_stack, int monitor_size) {
  Unimplemented();
}

int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
  Unimplemented();
}

void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill,
                                           frame* caller,
                                           frame* current,
                                           methodOop method,
                                           intptr_t* locals,
                                           intptr_t* stack,
                                           intptr_t* stack_base,
                                           intptr_t* monitor_base,
                                           intptr_t* frame_bottom,
                                           bool is_top_frame
                                           )
{
  Unimplemented();
}

void BytecodeInterpreter::pd_layout_interpreterState(interpreterState istate, address last_Java_pc, intptr_t* last_Java_fp) {
  Unimplemented();
}


int AbstractInterpreter::layout_activation(methodOop method,
                                           int tempcount, // Number of slots on java expression stack in use
                                           int popframe_extra_args,
                                           int moncount,  // Number of active monitors
                                           int callee_param_size,
                                           int callee_locals_size,
                                           frame* caller,
                                           frame* interpreter_frame,
                                           bool is_top_frame) {
  Unimplemented();
}

#endif // CC_INTERP