jdk8-mips64-public/hotspot: comparison src/share/vm/prims/methodHandles.hpp

-:71fdc5052e49
+:987e948ebbc8
 // JVM support for MethodHandle, MethodType, and related types
 // in java.dyn and java.dyn.hotspot.
 // See also  javaClasses for layouts java_dyn_Method{Handle,Type,Type::Form}.
 public:
 enum EntryKind {
-_check_mtype,               // how a caller calls a MH
+_raise_exception,           // stub for error generation from other stubs
-_wrong_method_type,         // what happens when there is a type mismatch
 _invokestatic_mh,           // how a MH emulates invokestatic
 _invokespecial_mh,          // ditto for the other invokes...
 _invokevirtual_mh,
 _invokeinterface_mh,
 _bound_ref_mh,              // reference argument is bound
 _bound_int_direct_mh,
 _bound_long_direct_mh,
 _adapter_mh_first,     // adapter sequence goes here...
 _adapter_retype_only   = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_RETYPE_ONLY,
+_adapter_retype_raw    = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW,
 _adapter_check_cast    = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_CHECK_CAST,
 _adapter_prim_to_prim  = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_PRIM_TO_PRIM,
 _adapter_ref_to_prim   = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_REF_TO_PRIM,
 _adapter_prim_to_ref   = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_PRIM_TO_REF,
 _adapter_swap_args     = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_SWAP_ARGS,
 };
 static bool _enabled;
 static MethodHandleEntry* _entries[_EK_LIMIT];
 static const char*        _entry_names[_EK_LIMIT+1];
+static jobject            _raise_exception_method;
 static bool ek_valid(EntryKind ek)            { return (uint)ek < (uint)_EK_LIMIT; }
 static bool conv_op_valid(int op)             { return (uint)op < (uint)CONV_OP_LIMIT; }
 public:
 static bool    have_entry(EntryKind ek)       { return ek_valid(ek) && _entries[ek] != NULL; }
 static void init_entry(EntryKind ek, MethodHandleEntry* me) {
 assert(ek_valid(ek), "oob");
 assert(_entries[ek] == NULL, "no double initialization");
 _entries[ek] = me;
+}
+static methodOop raise_exception_method() {
+oop rem = JNIHandles::resolve(_raise_exception_method);
+assert(rem == NULL || rem->is_method(), "");
+return (methodOop) rem;
+}
+static void set_raise_exception_method(methodOop rem) {
+assert(_raise_exception_method == NULL, "");
+_raise_exception_method = JNIHandles::make_global(Handle(rem));
 }
 static jint adapter_conversion(int conv_op, BasicType src, BasicType dest,
 int stack_move = 0, int vminfo = 0) {
 assert(conv_op_valid(conv_op), "oob");
 };
 static methodOop decode_method(oop x, klassOop& receiver_limit_result, int& decode_flags_result);
 enum {
 // format of query to getConstant:
 GC_JVM_PUSH_LIMIT = 0,
-GC_JVM_STACK_MOVE_LIMIT = 1,
+GC_JVM_STACK_MOVE_UNIT = 1,
 // format of result from getTarget / encode_target:
 ETF_HANDLE_OR_METHOD_NAME = 0, // all available data (immediate MH or method)
 ETF_DIRECT_HANDLE         = 1, // ultimate method handle (will be a DMH, may be self)
 ETF_METHOD_NAME           = 2, // ultimate method as MemberName
 // These checkers operate on a pair of whole MethodTypes:
 static const char* check_method_type_change(oop src_mtype, int src_beg, int src_end,
 int insert_argnum, oop insert_type,
 int change_argnum, oop change_type,
 int delete_argnum,
-oop dst_mtype, int dst_beg, int dst_end);
+oop dst_mtype, int dst_beg, int dst_end,
+bool raw = false);
 static const char* check_method_type_insertion(oop src_mtype,
 int insert_argnum, oop insert_type,
 oop dst_mtype) {
 oop no_ref = NULL;
 return check_method_type_change(src_mtype, 0, -1,
 oop no_ref = NULL;
 return check_method_type_change(src_mtype, 0, -1, -1, no_ref,
 change_argnum, change_type,
 -1, dst_mtype, 0, -1);
 }
-static const char* check_method_type_passthrough(oop src_mtype, oop dst_mtype) {
+static const char* check_method_type_passthrough(oop src_mtype, oop dst_mtype, bool raw) {
 oop no_ref = NULL;
 return check_method_type_change(src_mtype, 0, -1,
 -1, no_ref, -1, no_ref, -1,
-dst_mtype, 0, -1);
+dst_mtype, 0, -1, raw);
 }
 // These checkers operate on pairs of argument or return types:
 static const char* check_argument_type_change(BasicType src_type, klassOop src_klass,
 BasicType dst_type, klassOop dst_klass,
-int argnum);
+int argnum, bool raw = false);
 static const char* check_argument_type_change(oop src_type, oop dst_type,
-int argnum) {
+int argnum, bool raw = false) {
 klassOop src_klass = NULL, dst_klass = NULL;
 BasicType src_bt = java_lang_Class::as_BasicType(src_type, &src_klass);
 BasicType dst_bt = java_lang_Class::as_BasicType(dst_type, &dst_klass);
 return check_argument_type_change(src_bt, src_klass,
-dst_bt, dst_klass, argnum);
+dst_bt, dst_klass, argnum, raw);
 }
-static const char* check_return_type_change(oop src_type, oop dst_type) {
+static const char* check_return_type_change(oop src_type, oop dst_type, bool raw = false) {
-return check_argument_type_change(src_type, dst_type, -1);
+return check_argument_type_change(src_type, dst_type, -1, raw);
 }
 static const char* check_return_type_change(BasicType src_type, klassOop src_klass,
 BasicType dst_type, klassOop dst_klass) {
 return check_argument_type_change(src_type, src_klass, dst_type, dst_klass, -1);
 int decode_flags,
 KlassHandle receiver_klass,
 TRAPS);
 static bool same_basic_type_for_arguments(BasicType src, BasicType dst,
+bool raw = false,
 bool for_return = false);
-static bool same_basic_type_for_returns(BasicType src, BasicType dst) {
+static bool same_basic_type_for_returns(BasicType src, BasicType dst, bool raw = false) {
-return same_basic_type_for_arguments(src, dst, true);
+return same_basic_type_for_arguments(src, dst, raw, true);
 }
 enum {                        // arg_mask values
 _INSERT_NO_MASK   = -1,
 _INSERT_REF_MASK  = 0,

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/prims/methodHandles.hpp

src/share/vm/prims/methodHandles.hpp