#ifndef SHARE_VM_INTERPRETER_ABSTRACTINTERPRETER_HPP

#define SHARE_VM_INTERPRETER_ABSTRACTINTERPRETER_HPP

#include "code/stubs.hpp"

#include "interpreter/bytecodes.hpp"

#include "runtime/vmThread.hpp"

#include "utilities/top.hpp"

#ifdef TARGET_ARCH_MODEL_x86_32

# include "interp_masm_x86_32.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_x86_64

# include "interp_masm_x86_64.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_sparc

# include "interp_masm_sparc.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_zero

# include "interp_masm_zero.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_arm

# include "interp_masm_arm.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_ppc

# include "interp_masm_ppc.hpp"

#endif

#ifdef TARGET_OS_FAMILY_linux

# include "thread_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "thread_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "thread_windows.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "thread_bsd.inline.hpp"

#endif

class AbstractInterpreter: AllStatic {

friend class VMStructs;

friend class Interpreter;

friend class CppInterpreterGenerator;

public:

enum MethodKind {

zerolocals, // method needs locals initialization

zerolocals_synchronized, // method needs locals initialization & is synchronized

native, // native method

native_synchronized, // native method & is synchronized

empty, // empty method (code: _return)

accessor, // accessor method (code: _aload_0, _getfield, _(a|i)return)

abstract, // abstract method (throws an AbstractMethodException)

method_handle_invoke_FIRST, // java.lang.invoke.MethodHandles::invokeExact, etc.

method_handle_invoke_LAST = (method_handle_invoke_FIRST

+ (vmIntrinsics::LAST_MH_SIG_POLY

- vmIntrinsics::FIRST_MH_SIG_POLY)),

java_lang_math_sin, // implementation of java.lang.Math.sin (x)

java_lang_math_cos, // implementation of java.lang.Math.cos (x)

java_lang_math_tan, // implementation of java.lang.Math.tan (x)

java_lang_math_abs, // implementation of java.lang.Math.abs (x)

java_lang_math_sqrt, // implementation of java.lang.Math.sqrt (x)

java_lang_math_log, // implementation of java.lang.Math.log (x)

java_lang_math_log10, // implementation of java.lang.Math.log10 (x)

java_lang_math_pow, // implementation of java.lang.Math.pow (x,y)

java_lang_math_exp, // implementation of java.lang.Math.exp (x)

java_lang_ref_reference_get, // implementation of java.lang.ref.Reference.get()

number_of_method_entries,

invalid = -1

};

// Conversion from the part of the above enum to vmIntrinsics::_invokeExact, etc.

static vmIntrinsics::ID method_handle_intrinsic(MethodKind kind) {

if (kind >= method_handle_invoke_FIRST && kind <= method_handle_invoke_LAST)

return (vmIntrinsics::ID)( vmIntrinsics::FIRST_MH_SIG_POLY + (kind - method_handle_invoke_FIRST) );

else

return vmIntrinsics::_none;

}

enum SomeConstants {

number_of_result_handlers = 10 // number of result handlers for native calls

};

protected:

static StubQueue* _code; // the interpreter code (codelets)

static bool _notice_safepoints; // true if safepoints are activated

static address _native_entry_begin; // Region for native entry code

static address _native_entry_end;

// method entry points

static address _entry_table[number_of_method_entries]; // entry points for a given method

static address _native_abi_to_tosca[number_of_result_handlers]; // for native method result handlers

static address _slow_signature_handler; // the native method generic (slow) signature handler

static address _rethrow_exception_entry; // rethrows an activation in previous frame

friend class AbstractInterpreterGenerator;

friend class InterpreterGenerator;

friend class InterpreterMacroAssembler;

public:

// Initialization/debugging

static void initialize();

static StubQueue* code() { return _code; }

// Method activation

static MethodKind method_kind(methodHandle m);

static address entry_for_kind(MethodKind k) { assert(0 <= k && k < number_of_method_entries, "illegal kind"); return _entry_table[k]; }

static address entry_for_method(methodHandle m) { return entry_for_kind(method_kind(m)); }

// used for bootstrapping method handles:

static void set_entry_for_kind(MethodKind k, address e);

static void print_method_kind(MethodKind kind) PRODUCT_RETURN;

static bool can_be_compiled(methodHandle m);

// Runtime support

// length = invoke bytecode length (to advance to next bytecode)

static address deopt_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; }

static address return_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; }

static address rethrow_exception_entry() { return _rethrow_exception_entry; }

// Activation size in words for a method that is just being called.

// Parameters haven't been pushed so count them too.

static int size_top_interpreter_activation(methodOop method);

// Deoptimization support

// Compute the entry address for continuation after

static address deopt_continue_after_entry(methodOop method,

address bcp,

int callee_parameters,

bool is_top_frame);

// Compute the entry address for reexecution

static address deopt_reexecute_entry(methodOop method, address bcp);

// Deoptimization should reexecute this bytecode

static bool bytecode_should_reexecute(Bytecodes::Code code);

// share implementation of size_activation and layout_activation:

static int size_activation(methodOop method,

int temps,

int popframe_args,

int monitors,

int caller_actual_parameters,

int callee_params,

int callee_locals,

bool is_top_frame,

bool is_bottom_frame) {

return layout_activation(method,

temps,

popframe_args,

monitors,

caller_actual_parameters,

callee_params,

callee_locals,

(frame*)NULL,

(frame*)NULL,

is_top_frame,

is_bottom_frame);

}

static int layout_activation(methodOop method,

int temps,

int popframe_args,

int monitors,

int caller_actual_parameters,

int callee_params,

int callee_locals,

frame* caller,

frame* interpreter_frame,

bool is_top_frame,

bool is_bottom_frame);

// Runtime support

static bool is_not_reached( methodHandle method, int bci);

// Safepoint support

static void notice_safepoints() { ShouldNotReachHere(); } // stops the thread when reaching a safepoint

static void ignore_safepoints() { ShouldNotReachHere(); } // ignores safepoints

// Support for native calls

static address slow_signature_handler() { return _slow_signature_handler; }

static address result_handler(BasicType type) { return _native_abi_to_tosca[BasicType_as_index(type)]; }

static int BasicType_as_index(BasicType type); // computes index into result_handler_by_index table

static bool in_native_entry(address pc) { return _native_entry_begin <= pc && pc < _native_entry_end; }

// Debugging/printing

static void print(); // prints the interpreter code

public:

// Interpreter helpers

const static int stackElementWords = 1;

const static int stackElementSize = stackElementWords * wordSize;

const static int logStackElementSize = LogBytesPerWord;

// Local values relative to locals[n]

static int local_offset_in_bytes(int n) {

return ((frame::interpreter_frame_expression_stack_direction() * n) * stackElementSize);

}

// access to stacked values according to type:

static oop* oop_addr_in_slot(intptr_t* slot_addr) {

return (oop*) slot_addr;

}

static jint* int_addr_in_slot(intptr_t* slot_addr) {

if ((int) sizeof(jint) < wordSize && !Bytes::is_Java_byte_ordering_different())

// big-endian LP64

return (jint*)(slot_addr + 1) - 1;

else

return (jint*) slot_addr;

}

static jlong long_in_slot(intptr_t* slot_addr) {

if (sizeof(intptr_t) >= sizeof(jlong)) {

return *(jlong*) slot_addr;

} else {

return Bytes::get_native_u8((address)slot_addr);

}

}

static void set_long_in_slot(intptr_t* slot_addr, jlong value) {

if (sizeof(intptr_t) >= sizeof(jlong)) {

*(jlong*) slot_addr = value;

} else {

Bytes::put_native_u8((address)slot_addr, value);

}

}

static void get_jvalue_in_slot(intptr_t* slot_addr, BasicType type, jvalue* value) {

switch (type) {

case T_BOOLEAN: value->z = *int_addr_in_slot(slot_addr); break;

case T_CHAR: value->c = *int_addr_in_slot(slot_addr); break;

case T_BYTE: value->b = *int_addr_in_slot(slot_addr); break;

case T_SHORT: value->s = *int_addr_in_slot(slot_addr); break;

case T_INT: value->i = *int_addr_in_slot(slot_addr); break;

case T_LONG: value->j = long_in_slot(slot_addr); break;

case T_FLOAT: value->f = *(jfloat*)int_addr_in_slot(slot_addr); break;

case T_DOUBLE: value->d = jdouble_cast(long_in_slot(slot_addr)); break;

case T_OBJECT: value->l = (jobject)*oop_addr_in_slot(slot_addr); break;

default: ShouldNotReachHere();

}

}

static void set_jvalue_in_slot(intptr_t* slot_addr, BasicType type, jvalue* value) {

switch (type) {

case T_BOOLEAN: *int_addr_in_slot(slot_addr) = (value->z != 0); break;

case T_CHAR: *int_addr_in_slot(slot_addr) = value->c; break;

case T_BYTE: *int_addr_in_slot(slot_addr) = value->b; break;

case T_SHORT: *int_addr_in_slot(slot_addr) = value->s; break;

case T_INT: *int_addr_in_slot(slot_addr) = value->i; break;

case T_LONG: set_long_in_slot(slot_addr, value->j); break;

case T_FLOAT: *(jfloat*)int_addr_in_slot(slot_addr) = value->f; break;

case T_DOUBLE: set_long_in_slot(slot_addr, jlong_cast(value->d)); break;

case T_OBJECT: *oop_addr_in_slot(slot_addr) = (oop) value->l; break;

default: ShouldNotReachHere();

}

}

};

class Template;

class AbstractInterpreterGenerator: public StackObj {

protected:

InterpreterMacroAssembler* _masm;

// shared code sequences

// Converter for native abi result to tosca result

address generate_result_handler_for(BasicType type);

address generate_slow_signature_handler();

// entry point generator

address generate_method_entry(AbstractInterpreter::MethodKind kind);

void bang_stack_shadow_pages(bool native_call);

void generate_all();

void initialize_method_handle_entries();

public:

AbstractInterpreterGenerator(StubQueue* _code);

};

#endif // SHARE_VM_INTERPRETER_ABSTRACTINTERPRETER_HPP