Mercurial > people > rkennke > hotspot-comp-zero > hotspot > .hg > patches
changeset 4:df468965b6f6 default tip
Merged zero with upstream changes, fixes jtreg tests.
| author | Roman Kennke <rkennke@redhat.com> |
|---|---|
| date | Wed, 10 Oct 2012 12:14:29 +0200 |
| parents | 9b527bc96254 |
| children | |
| files | hotspot-zero.patch hotspot.patch mergejdk8.patch series zero-makefile.patch zero-meth.patch zero-new-math.patch zero-segfault.patch |
| diffstat | 8 files changed, 1420 insertions(+), 2516 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hotspot-zero.patch Wed Oct 10 12:14:29 2012 +0200 @@ -0,0 +1,1419 @@ +# HG changeset patch +# Parent 7482c7f6081469eedf7d27de17aa5385a4a5006c + +diff --git a/make/Makefile b/make/Makefile +--- a/make/Makefile ++++ b/make/Makefile +@@ -402,14 +402,30 @@ + ifeq ($(JVM_VARIANT_ZEROSHARK), true) + $(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_DIR)/%.$(LIBRARY_SUFFIX) + $(install-file) ++ $(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo): $(SHARK_DIR)/%.debuginfo ++ $(install-file) ++ $(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(SHARK_DIR)/%.diz ++ $(install-file) + $(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_DIR)/%.$(LIBRARY_SUFFIX) + $(install-file) ++ $(EXPORT_SERVER_DIR)/%.debuginfo: $(SHARK_DIR)/%.debuginfo ++ $(install-file) ++ $(EXPORT_SERVER_DIR)/%.diz: $(SHARK_DIR)/%.diz ++ $(install-file) + endif + ifeq ($(JVM_VARIANT_ZERO), true) + $(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_DIR)/%.$(LIBRARY_SUFFIX) + $(install-file) ++ $(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(ZERO_DIR)/%.debuginfo ++ $(install-file) ++ $(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(ZERO_DIR)/%.diz ++ $(install-file) + $(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_DIR)/%.$(LIBRARY_SUFFIX) + $(install-file) ++ $(EXPORT_SERVER_DIR)/%.debuginfo: $(ZERO_DIR)/%.debuginfo ++ $(install-file) ++ $(EXPORT_SERVER_DIR)/%.diz: $(ZERO_DIR)/%.diz ++ $(install-file) + endif + endif + +diff --git a/src/cpu/zero/vm/copy_zero.hpp b/src/cpu/zero/vm/copy_zero.hpp +--- a/src/cpu/zero/vm/copy_zero.hpp ++++ b/src/cpu/zero/vm/copy_zero.hpp +@@ -169,7 +169,7 @@ + } + + static void pd_fill_to_bytes(void* to, size_t count, jubyte value) { +- memset(to, value, count); ++ if ( count > 0 ) memset(to, value, count); + } + + static void pd_zero_to_words(HeapWord* tohw, size_t count) { +@@ -177,7 +177,7 @@ + } + + static void pd_zero_to_bytes(void* to, size_t count) { +- memset(to, 0, count); ++ if ( count > 0 ) memset(to, 0, count); + } + + #endif // CPU_ZERO_VM_COPY_ZERO_HPP +diff --git a/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp b/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp +--- a/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp ++++ b/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp +@@ -31,12 +31,17 @@ + return _masm; + } + +- protected: +- address generate_entry(address entry_point) { +- ZeroEntry *entry = (ZeroEntry *) assembler()->pc(); +- assembler()->advance(sizeof(ZeroEntry)); ++ public: ++ static address generate_entry_impl(MacroAssembler* masm, address entry_point) { ++ ZeroEntry *entry = (ZeroEntry *) masm->pc(); ++ masm->advance(sizeof(ZeroEntry)); + entry->set_entry_point(entry_point); + return (address) entry; + } + ++ protected: ++ address generate_entry(address entry_point) { ++ return generate_entry_impl(assembler(), entry_point); ++ } ++ + #endif // CPU_ZERO_VM_CPPINTERPRETERGENERATOR_ZERO_HPP +diff --git a/src/cpu/zero/vm/cppInterpreter_zero.cpp b/src/cpu/zero/vm/cppInterpreter_zero.cpp +--- a/src/cpu/zero/vm/cppInterpreter_zero.cpp ++++ b/src/cpu/zero/vm/cppInterpreter_zero.cpp +@@ -36,6 +36,7 @@ + #include "oops/oop.inline.hpp" + #include "prims/jvmtiExport.hpp" + #include "prims/jvmtiThreadState.hpp" ++#include "prims/methodHandles.hpp" + #include "runtime/arguments.hpp" + #include "runtime/deoptimization.hpp" + #include "runtime/frame.inline.hpp" +@@ -180,25 +181,6 @@ + method, istate->osr_entry(), istate->osr_buf(), THREAD); + return; + } +- else if (istate->msg() == BytecodeInterpreter::call_method_handle) { +- oop method_handle = istate->callee(); +- +- // Trim back the stack to put the parameters at the top +- stack->set_sp(istate->stack() + 1); +- +- // Make the call +- process_method_handle(method_handle, THREAD); +- fixup_after_potential_safepoint(); +- +- // Convert the result +- istate->set_stack(stack->sp() - 1); +- +- // Restore the stack +- stack->set_sp(istate->stack_limit() + 1); +- +- // Resume the interpreter +- istate->set_msg(BytecodeInterpreter::method_resume); +- } + else { + ShouldNotReachHere(); + } +@@ -535,35 +517,35 @@ + if (entry->is_volatile()) { + switch (entry->flag_state()) { + case ctos: +- SET_LOCALS_INT(object->char_field_acquire(entry->f2()), 0); ++ SET_LOCALS_INT(object->char_field_acquire(entry->f2_as_index()), 0); + break; + + case btos: +- SET_LOCALS_INT(object->byte_field_acquire(entry->f2()), 0); ++ SET_LOCALS_INT(object->byte_field_acquire(entry->f2_as_index()), 0); + break; + + case stos: +- SET_LOCALS_INT(object->short_field_acquire(entry->f2()), 0); ++ SET_LOCALS_INT(object->short_field_acquire(entry->f2_as_index()), 0); + break; + + case itos: +- SET_LOCALS_INT(object->int_field_acquire(entry->f2()), 0); ++ SET_LOCALS_INT(object->int_field_acquire(entry->f2_as_index()), 0); + break; + + case ltos: +- SET_LOCALS_LONG(object->long_field_acquire(entry->f2()), 0); ++ SET_LOCALS_LONG(object->long_field_acquire(entry->f2_as_index()), 0); + break; + + case ftos: +- SET_LOCALS_FLOAT(object->float_field_acquire(entry->f2()), 0); ++ SET_LOCALS_FLOAT(object->float_field_acquire(entry->f2_as_index()), 0); + break; + + case dtos: +- SET_LOCALS_DOUBLE(object->double_field_acquire(entry->f2()), 0); ++ SET_LOCALS_DOUBLE(object->double_field_acquire(entry->f2_as_index()), 0); + break; + + case atos: +- SET_LOCALS_OBJECT(object->obj_field_acquire(entry->f2()), 0); ++ SET_LOCALS_OBJECT(object->obj_field_acquire(entry->f2_as_index()), 0); + break; + + default: +@@ -573,35 +555,35 @@ + else { + switch (entry->flag_state()) { + case ctos: +- SET_LOCALS_INT(object->char_field(entry->f2()), 0); ++ SET_LOCALS_INT(object->char_field(entry->f2_as_index()), 0); + break; + + case btos: +- SET_LOCALS_INT(object->byte_field(entry->f2()), 0); ++ SET_LOCALS_INT(object->byte_field(entry->f2_as_index()), 0); + break; + + case stos: +- SET_LOCALS_INT(object->short_field(entry->f2()), 0); ++ SET_LOCALS_INT(object->short_field(entry->f2_as_index()), 0); + break; + + case itos: +- SET_LOCALS_INT(object->int_field(entry->f2()), 0); ++ SET_LOCALS_INT(object->int_field(entry->f2_as_index()), 0); + break; + + case ltos: +- SET_LOCALS_LONG(object->long_field(entry->f2()), 0); ++ SET_LOCALS_LONG(object->long_field(entry->f2_as_index()), 0); + break; + + case ftos: +- SET_LOCALS_FLOAT(object->float_field(entry->f2()), 0); ++ SET_LOCALS_FLOAT(object->float_field(entry->f2_as_index()), 0); + break; + + case dtos: +- SET_LOCALS_DOUBLE(object->double_field(entry->f2()), 0); ++ SET_LOCALS_DOUBLE(object->double_field(entry->f2_as_index()), 0); + break; + + case atos: +- SET_LOCALS_OBJECT(object->obj_field(entry->f2()), 0); ++ SET_LOCALS_OBJECT(object->obj_field(entry->f2_as_index()), 0); + break; + + default: +@@ -629,516 +611,6 @@ + return 0; + } + +-int CppInterpreter::method_handle_entry(Method* method, +- intptr_t UNUSED, TRAPS) { +- JavaThread *thread = (JavaThread *) THREAD; +- ZeroStack *stack = thread->zero_stack(); +- int argument_slots = method->size_of_parameters(); +- int result_slots = type2size[result_type_of(method)]; +- intptr_t *vmslots = stack->sp(); +- intptr_t *unwind_sp = vmslots + argument_slots; +- +- // Find the MethodType +- address p = (address) method; +- for (jint* pc = method->method_type_offsets_chain(); (*pc) != -1; pc++) { +- p = *(address*)(p + (*pc)); +- } +- oop method_type = (oop) p; +- +- // The MethodHandle is in the slot after the arguments +- int num_vmslots = argument_slots - 1; +- oop method_handle = VMSLOTS_OBJECT(num_vmslots); +- +- // InvokeGeneric requires some extra shuffling +- oop mhtype = java_lang_invoke_MethodHandle::type(method_handle); +- bool is_exact = mhtype == method_type; +- if (!is_exact) { +- if (true || // FIXME +- method->intrinsic_id() == vmIntrinsics::_invokeExact) { +- CALL_VM_NOCHECK_NOFIX( +- SharedRuntime::throw_WrongMethodTypeException( +- thread, method_type, mhtype)); +- // NB all oops trashed! +- assert(HAS_PENDING_EXCEPTION, "should do"); +- stack->set_sp(unwind_sp); +- return 0; +- } +- assert(method->intrinsic_id() == vmIntrinsics::_invokeGeneric, "should be"); +- +- // Load up an adapter from the calling type +- // NB the x86 code for this (in methodHandles_x86.cpp, search for +- // "genericInvoker") is really really odd. I'm hoping it's trying +- // to accomodate odd VM/class library combinations I can ignore. +- oop adapter = NULL; //FIXME: load the adapter from the CP cache +- IF (adapter == NULL) { +- CALL_VM_NOCHECK_NOFIX( +- SharedRuntime::throw_WrongMethodTypeException( +- thread, method_type, mhtype)); +- // NB all oops trashed! +- assert(HAS_PENDING_EXCEPTION, "should do"); +- stack->set_sp(unwind_sp); +- return 0; +- } +- +- // Adapters are shared among form-families of method-type. The +- // type being called is passed as a trusted first argument so that +- // the adapter knows the actual types of its arguments and return +- // values. +- insert_vmslots(num_vmslots + 1, 1, THREAD); +- if (HAS_PENDING_EXCEPTION) { +- // NB all oops trashed! +- stack->set_sp(unwind_sp); +- return 0; +- } +- +- vmslots = stack->sp(); +- num_vmslots++; +- SET_VMSLOTS_OBJECT(method_type, num_vmslots); +- +- method_handle = adapter; +- } +- +- // Start processing +- process_method_handle(method_handle, THREAD); +- if (HAS_PENDING_EXCEPTION) +- result_slots = 0; +- +- // If this is an invokeExact then the eventual callee will not +- // have unwound the method handle argument so we have to do it. +- // If a result is being returned the it will be above the method +- // handle argument we're unwinding. +- if (is_exact) { +- intptr_t result[2]; +- for (int i = 0; i < result_slots; i++) +- result[i] = stack->pop(); +- stack->pop(); +- for (int i = result_slots - 1; i >= 0; i--) +- stack->push(result[i]); +- } +- +- // Check +- assert(stack->sp() == unwind_sp - result_slots, "should be"); +- +- // No deoptimized frames on the stack +- return 0; +-} +- +-void CppInterpreter::process_method_handle(oop method_handle, TRAPS) { +- JavaThread *thread = (JavaThread *) THREAD; +- ZeroStack *stack = thread->zero_stack(); +- intptr_t *vmslots = stack->sp(); +- +- bool direct_to_method = false; +- BasicType src_rtype = T_ILLEGAL; +- BasicType dst_rtype = T_ILLEGAL; +- +- MethodHandleEntry *entry = +- java_lang_invoke_MethodHandle::vmentry(method_handle); +- MethodHandles::EntryKind entry_kind = +- (MethodHandles::EntryKind) (((intptr_t) entry) & 0xffffffff); +- +- Method* method = NULL; +- switch (entry_kind) { +- case MethodHandles::_invokestatic_mh: +- direct_to_method = true; +- break; +- +- case MethodHandles::_invokespecial_mh: +- case MethodHandles::_invokevirtual_mh: +- case MethodHandles::_invokeinterface_mh: +- { +- oop receiver = +- VMSLOTS_OBJECT( +- java_lang_invoke_MethodHandle::vmslots(method_handle) - 1); +- if (receiver == NULL) { +- stack->set_sp(calculate_unwind_sp(stack, method_handle)); +- CALL_VM_NOCHECK_NOFIX( +- throw_exception( +- thread, vmSymbols::java_lang_NullPointerException())); +- // NB all oops trashed! +- assert(HAS_PENDING_EXCEPTION, "should do"); +- return; +- } +- if (entry_kind != MethodHandles::_invokespecial_mh) { +- intptr_t index = java_lang_invoke_DirectMethodHandle::vmindex(method_handle); +- InstanceKlass* rcvrKlass = +- (InstanceKlass *) receiver->klass(); +- if (entry_kind == MethodHandles::_invokevirtual_mh) { +- method = (Method*) rcvrKlass->start_of_vtable()[index]; +- } +- else { +- oop iclass = java_lang_invoke_MethodHandle::next_target(method_handle); +- itableOffsetEntry* ki = +- (itableOffsetEntry *) rcvrKlass->start_of_itable(); +- int i, length = rcvrKlass->itable_length(); +- for (i = 0; i < length; i++, ki++ ) { +- if (ki->interface_klass() == iclass) +- break; +- } +- if (i == length) { +- stack->set_sp(calculate_unwind_sp(stack, method_handle)); +- CALL_VM_NOCHECK_NOFIX( +- throw_exception( +- thread, vmSymbols::java_lang_IncompatibleClassChangeError())); +- // NB all oops trashed! +- assert(HAS_PENDING_EXCEPTION, "should do"); +- return; +- } +- itableMethodEntry* im = ki->first_method_entry(receiver->klass()); +- method = im[index].method(); +- if (method == NULL) { +- stack->set_sp(calculate_unwind_sp(stack, method_handle)); +- CALL_VM_NOCHECK_NOFIX( +- throw_exception( +- thread, vmSymbols::java_lang_AbstractMethodError())); +- // NB all oops trashed! +- assert(HAS_PENDING_EXCEPTION, "should do"); +- return; +- } +- } +- } +- } +- direct_to_method = true; +- break; +- +- case MethodHandles::_bound_ref_direct_mh: +- case MethodHandles::_bound_int_direct_mh: +- case MethodHandles::_bound_long_direct_mh: +- direct_to_method = true; +- // fall through +- case MethodHandles::_bound_ref_mh: +- case MethodHandles::_bound_int_mh: +- case MethodHandles::_bound_long_mh: +- { +- BasicType arg_type = T_ILLEGAL; +- int arg_mask = -1; +- int arg_slots = -1; +- MethodHandles::get_ek_bound_mh_info( +- entry_kind, arg_type, arg_mask, arg_slots); +- int arg_slot = +- java_lang_invoke_BoundMethodHandle::vmargslot(method_handle); +- +- // Create the new slot(s) +- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); +- insert_vmslots(arg_slot, arg_slots, THREAD); +- if (HAS_PENDING_EXCEPTION) { +- // all oops trashed +- stack->set_sp(unwind_sp); +- return; +- } +- vmslots = stack->sp(); +- +- // Store bound argument into new stack slot +- oop arg = java_lang_invoke_BoundMethodHandle::argument(method_handle); +- if (arg_type == T_OBJECT) { +- assert(arg_slots == 1, "should be"); +- SET_VMSLOTS_OBJECT(arg, arg_slot); +- } +- else { +- jvalue arg_value; +- arg_type = java_lang_boxing_object::get_value(arg, &arg_value); +- switch (arg_type) { +- case T_BOOLEAN: +- SET_VMSLOTS_INT(arg_value.z, arg_slot); +- break; +- case T_CHAR: +- SET_VMSLOTS_INT(arg_value.c, arg_slot); +- break; +- case T_BYTE: +- SET_VMSLOTS_INT(arg_value.b, arg_slot); +- break; +- case T_SHORT: +- SET_VMSLOTS_INT(arg_value.s, arg_slot); +- break; +- case T_INT: +- SET_VMSLOTS_INT(arg_value.i, arg_slot); +- break; +- case T_FLOAT: +- SET_VMSLOTS_FLOAT(arg_value.f, arg_slot); +- break; +- case T_LONG: +- SET_VMSLOTS_LONG(arg_value.j, arg_slot + 1); +- break; +- case T_DOUBLE: +- SET_VMSLOTS_DOUBLE(arg_value.d, arg_slot + 1); +- break; +- default: +- tty->print_cr("unhandled type %s", type2name(arg_type)); +- ShouldNotReachHere(); +- } +- } +- } +- break; +- +- case MethodHandles::_adapter_retype_only: +- case MethodHandles::_adapter_retype_raw: +- src_rtype = result_type_of_handle( +- java_lang_invoke_MethodHandle::next_target(method_handle)); +- dst_rtype = result_type_of_handle(method_handle); +- break; +- +- case MethodHandles::_adapter_check_cast: +- { +- int arg_slot = +- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); +- oop arg = VMSLOTS_OBJECT(arg_slot); +- if (arg != NULL) { +- Klass* objKlassOop = arg->klass(); +- Klass* klassOf = java_lang_Class::as_Klass( +- java_lang_invoke_AdapterMethodHandle::argument(method_handle)); +- +- if (objKlassOop != klassOf && +- !objKlassOop->is_subtype_of(klassOf)) { +- ResourceMark rm(THREAD); +- const char* objName = Klass::cast(objKlassOop)->external_name(); +- const char* klassName = Klass::cast(klassOf)->external_name(); +- char* message = SharedRuntime::generate_class_cast_message( +- objName, klassName); +- +- stack->set_sp(calculate_unwind_sp(stack, method_handle)); +- CALL_VM_NOCHECK_NOFIX( +- throw_exception( +- thread, vmSymbols::java_lang_ClassCastException(), message)); +- // NB all oops trashed! +- assert(HAS_PENDING_EXCEPTION, "should do"); +- return; +- } +- } +- } +- break; +- +- case MethodHandles::_adapter_dup_args: +- { +- int arg_slot = +- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); +- int conv = +- java_lang_invoke_AdapterMethodHandle::conversion(method_handle); +- int num_slots = -MethodHandles::adapter_conversion_stack_move(conv); +- assert(num_slots > 0, "should be"); +- +- // Create the new slot(s) +- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); +- stack->overflow_check(num_slots, THREAD); +- if (HAS_PENDING_EXCEPTION) { +- // all oops trashed +- stack->set_sp(unwind_sp); +- return; +- } +- +- // Duplicate the arguments +- for (int i = num_slots - 1; i >= 0; i--) +- stack->push(*VMSLOTS_SLOT(arg_slot + i)); +- +- vmslots = stack->sp(); // unused, but let the compiler figure that out +- } +- break; +- +- case MethodHandles::_adapter_drop_args: +- { +- int arg_slot = +- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); +- int conv = +- java_lang_invoke_AdapterMethodHandle::conversion(method_handle); +- int num_slots = MethodHandles::adapter_conversion_stack_move(conv); +- assert(num_slots > 0, "should be"); +- +- remove_vmslots(arg_slot, num_slots, THREAD); // doesn't trap +- vmslots = stack->sp(); // unused, but let the compiler figure that out +- } +- break; +- +- case MethodHandles::_adapter_opt_swap_1: +- case MethodHandles::_adapter_opt_swap_2: +- case MethodHandles::_adapter_opt_rot_1_up: +- case MethodHandles::_adapter_opt_rot_1_down: +- case MethodHandles::_adapter_opt_rot_2_up: +- case MethodHandles::_adapter_opt_rot_2_down: +- { +- int arg1 = +- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); +- int conv = +- java_lang_invoke_AdapterMethodHandle::conversion(method_handle); +- int arg2 = MethodHandles::adapter_conversion_vminfo(conv); +- +- int swap_bytes = 0, rotate = 0; +- MethodHandles::get_ek_adapter_opt_swap_rot_info( +- entry_kind, swap_bytes, rotate); +- int swap_slots = swap_bytes >> LogBytesPerWord; +- +- intptr_t tmp; +- switch (rotate) { +- case 0: // swap +- for (int i = 0; i < swap_slots; i++) { +- tmp = *VMSLOTS_SLOT(arg1 + i); +- SET_VMSLOTS_SLOT(VMSLOTS_SLOT(arg2 + i), arg1 + i); +- SET_VMSLOTS_SLOT(&tmp, arg2 + i); +- } +- break; +- +- case 1: // up +- assert(arg1 - swap_slots > arg2, "should be"); +- +- tmp = *VMSLOTS_SLOT(arg1); +- for (int i = arg1 - swap_slots; i >= arg2; i--) +- SET_VMSLOTS_SLOT(VMSLOTS_SLOT(i), i + swap_slots); +- SET_VMSLOTS_SLOT(&tmp, arg2); +- +- break; +- +- case -1: // down +- assert(arg2 - swap_slots > arg1, "should be"); +- +- tmp = *VMSLOTS_SLOT(arg1); +- for (int i = arg1 + swap_slots; i <= arg2; i++) +- SET_VMSLOTS_SLOT(VMSLOTS_SLOT(i), i - swap_slots); +- SET_VMSLOTS_SLOT(&tmp, arg2); +- break; +- +- default: +- ShouldNotReachHere(); +- } +- } +- break; +- +- case MethodHandles::_adapter_opt_i2l: +- { +- int arg_slot = +- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); +- int arg = VMSLOTS_INT(arg_slot); +- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); +- insert_vmslots(arg_slot, 1, THREAD); +- if (HAS_PENDING_EXCEPTION) { +- // all oops trashed +- stack->set_sp(unwind_sp); +- return; +- } +- vmslots = stack->sp(); +- arg_slot++; +- SET_VMSLOTS_LONG(arg, arg_slot); +- } +- break; +- +- case MethodHandles::_adapter_opt_unboxi: +- case MethodHandles::_adapter_opt_unboxl: +- { +- int arg_slot = +- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); +- oop arg = VMSLOTS_OBJECT(arg_slot); +- jvalue arg_value; +- if (arg == NULL) { +- // queue a nullpointer exception for the caller +- stack->set_sp(calculate_unwind_sp(stack, method_handle)); +- CALL_VM_NOCHECK_NOFIX( +- throw_exception( +- thread, vmSymbols::java_lang_NullPointerException())); +- // NB all oops trashed! +- assert(HAS_PENDING_EXCEPTION, "should do"); +- return; +- } +- BasicType arg_type = java_lang_boxing_object::get_value(arg, &arg_value); +- if (arg_type == T_LONG || arg_type == T_DOUBLE) { +- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); +- insert_vmslots(arg_slot, 1, THREAD); +- if (HAS_PENDING_EXCEPTION) { +- // all oops trashed +- stack->set_sp(unwind_sp); +- return; +- } +- vmslots = stack->sp(); +- arg_slot++; +- } +- switch (arg_type) { +- case T_BOOLEAN: +- SET_VMSLOTS_INT(arg_value.z, arg_slot); +- break; +- case T_CHAR: +- SET_VMSLOTS_INT(arg_value.c, arg_slot); +- break; +- case T_BYTE: +- SET_VMSLOTS_INT(arg_value.b, arg_slot); +- break; +- case T_SHORT: +- SET_VMSLOTS_INT(arg_value.s, arg_slot); +- break; +- case T_INT: +- SET_VMSLOTS_INT(arg_value.i, arg_slot); +- break; +- case T_FLOAT: +- SET_VMSLOTS_FLOAT(arg_value.f, arg_slot); +- break; +- case T_LONG: +- SET_VMSLOTS_LONG(arg_value.j, arg_slot); +- break; +- case T_DOUBLE: +- SET_VMSLOTS_DOUBLE(arg_value.d, arg_slot); +- break; +- default: +- tty->print_cr("unhandled type %s", type2name(arg_type)); +- ShouldNotReachHere(); +- } +- } +- break; +- +- default: +- tty->print_cr("unhandled entry_kind %s", +- MethodHandles::entry_name(entry_kind)); +- ShouldNotReachHere(); +- } +- +- // Continue along the chain +- if (direct_to_method) { +- if (method == NULL) { +- method = +- (Method*) java_lang_invoke_MethodHandle::vmtarget(method_handle); +- } +- address entry_point = method->from_interpreted_entry(); +- Interpreter::invoke_method(method, entry_point, THREAD); +- } +- else { +- process_method_handle( +- java_lang_invoke_MethodHandle::next_target(method_handle), THREAD); +- } +- // NB all oops now trashed +- +- // Adapt the result type, if necessary +- if (src_rtype != dst_rtype && !HAS_PENDING_EXCEPTION) { +- switch (dst_rtype) { +- case T_VOID: +- for (int i = 0; i < type2size[src_rtype]; i++) +- stack->pop(); +- return; +- +- case T_INT: +- switch (src_rtype) { +- case T_VOID: +- stack->overflow_check(1, CHECK); +- stack->push(0); +- return; +- +- case T_BOOLEAN: +- case T_CHAR: +- case T_BYTE: +- case T_SHORT: +- return; +- } +- // INT results sometimes need narrowing +- case T_BOOLEAN: +- case T_CHAR: +- case T_BYTE: +- case T_SHORT: +- switch (src_rtype) { +- case T_INT: +- return; +- } +- } +- +- tty->print_cr("unhandled conversion:"); +- tty->print_cr("src_rtype = %s", type2name(src_rtype)); +- tty->print_cr("dst_rtype = %s", type2name(dst_rtype)); +- ShouldNotReachHere(); +- } +-} +- + // The new slots will be inserted before slot insert_before. + // Slots < insert_before will have the same slot number after the insert. + // Slots >= insert_before will become old_slot + num_slots. +@@ -1380,10 +852,6 @@ + entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry(); + break; + +- case Interpreter::method_handle: +- entry_point = ((InterpreterGenerator*) this)->generate_method_handle_entry(); +- break; +- + case Interpreter::java_lang_math_sin: + case Interpreter::java_lang_math_cos: + case Interpreter::java_lang_math_tan: +@@ -1391,6 +859,8 @@ + case Interpreter::java_lang_math_log: + case Interpreter::java_lang_math_log10: + case Interpreter::java_lang_math_sqrt: ++ case Interpreter::java_lang_math_pow: ++ case Interpreter::java_lang_math_exp: + entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); + break; + +diff --git a/src/cpu/zero/vm/cppInterpreter_zero.hpp b/src/cpu/zero/vm/cppInterpreter_zero.hpp +--- a/src/cpu/zero/vm/cppInterpreter_zero.hpp ++++ b/src/cpu/zero/vm/cppInterpreter_zero.hpp +@@ -36,7 +36,6 @@ + static int native_entry(Method* method, intptr_t UNUSED, TRAPS); + static int accessor_entry(Method* method, intptr_t UNUSED, TRAPS); + static int empty_entry(Method* method, intptr_t UNUSED, TRAPS); +- static int method_handle_entry(Method* method, intptr_t UNUSED, TRAPS); + + public: + // Main loop of normal_entry +@@ -44,7 +43,6 @@ + + private: + // Helpers for method_handle_entry +- static void process_method_handle(oop method_handle, TRAPS); + static void insert_vmslots(int insert_before, int num_slots, TRAPS); + static void remove_vmslots(int first_slot, int num_slots, TRAPS); + static BasicType result_type_of_handle(oop method_handle); +diff --git a/src/cpu/zero/vm/frame_zero.cpp b/src/cpu/zero/vm/frame_zero.cpp +--- a/src/cpu/zero/vm/frame_zero.cpp ++++ b/src/cpu/zero/vm/frame_zero.cpp +@@ -351,7 +351,7 @@ + switch (offset) { + case pc_off: + strncpy(fieldbuf, "pc", buflen); +- if (method()->is_oop()) { ++ if (method()->is_method()) { + nmethod *code = method()->code(); + if (code && code->pc_desc_at(pc())) { + SimpleScopeDesc ssd(code, pc()); +@@ -367,7 +367,7 @@ + + case method_off: + strncpy(fieldbuf, "method", buflen); +- if (method()->is_oop()) { ++ if (method()->is_method()) { + method()->name_and_sig_as_C_string(valuebuf, buflen); + } + return; +@@ -378,7 +378,7 @@ + } + + // Variable part +- if (method()->is_oop()) { ++ if (method()->is_method()) { + identify_vp_word(frame_index, addr_of_word(offset), + addr_of_word(header_words + 1), + unextended_sp() + method()->max_stack(), +diff --git a/src/cpu/zero/vm/frame_zero.inline.hpp b/src/cpu/zero/vm/frame_zero.inline.hpp +--- a/src/cpu/zero/vm/frame_zero.inline.hpp ++++ b/src/cpu/zero/vm/frame_zero.inline.hpp +@@ -36,6 +36,8 @@ + _deopt_state = unknown; + } + ++inline address frame::sender_pc() const { ShouldNotCallThis(); } ++ + inline frame::frame(ZeroFrame* zf, intptr_t* sp) { + _zeroframe = zf; + _sp = sp; +diff --git a/src/cpu/zero/vm/icBuffer_zero.cpp b/src/cpu/zero/vm/icBuffer_zero.cpp +--- a/src/cpu/zero/vm/icBuffer_zero.cpp ++++ b/src/cpu/zero/vm/icBuffer_zero.cpp +@@ -40,7 +40,7 @@ + } + + void InlineCacheBuffer::assemble_ic_buffer_code(address code_begin, +- Metadata* cached_oop, ++ void* cached_oop, + address entry_point) { + // NB ic_stub_code_size() must return the size of the code we generate + ShouldNotCallThis(); +@@ -51,7 +51,6 @@ + ShouldNotCallThis(); + } + +-Metadata* InlineCacheBuffer::ic_buffer_cached_oop(address code_begin) { +- // NB ic_stub_code_size() must return the size of the code we generate ++void* InlineCacheBuffer::ic_buffer_cached_value(address code_begin) { + ShouldNotCallThis(); + } +diff --git a/src/cpu/zero/vm/methodHandles_zero.cpp b/src/cpu/zero/vm/methodHandles_zero.cpp +--- a/src/cpu/zero/vm/methodHandles_zero.cpp ++++ b/src/cpu/zero/vm/methodHandles_zero.cpp +@@ -24,26 +24,159 @@ + */ + + #include "precompiled.hpp" ++#include "interpreter/interpreterGenerator.hpp" + #include "interpreter/interpreter.hpp" + #include "memory/allocation.inline.hpp" + #include "prims/methodHandles.hpp" + +-int MethodHandles::adapter_conversion_ops_supported_mask() { +- return ((1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS) +- |(1<<java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS) +- //|(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) //BUG! +- ); +- // FIXME: MethodHandlesTest gets a crash if we enable OP_SPREAD_ARGS. ++void MethodHandles::invoke_target(Method* method, TRAPS) { ++ ++ JavaThread *thread = (JavaThread *) THREAD; ++ ZeroStack *stack = thread->zero_stack(); ++ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); ++ interpreterState istate = frame->interpreter_state(); ++ ++ // Trim back the stack to put the parameters at the top ++ stack->set_sp(istate->stack() + 1); ++ ++ Interpreter::invoke_method(method, method->from_interpreted_entry(), THREAD); ++ ++ // Convert the result ++ istate->set_stack(stack->sp() - 1); ++ + } + +-void MethodHandles::generate_method_handle_stub(MacroAssembler* masm, +- MethodHandles::EntryKind ek) { +- init_entry(ek, (MethodHandleEntry *) ek); ++oop MethodHandles::popFromStack(TRAPS) { ++ ++ JavaThread *thread = (JavaThread *) THREAD; ++ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); ++ interpreterState istate = frame->interpreter_state(); ++ intptr_t* topOfStack = istate->stack(); ++ ++ oop top = STACK_OBJECT(-1); ++ MORE_STACK(-1); ++ istate->set_stack(topOfStack); ++ ++ return top; ++ + } ++ ++int MethodHandles::method_handle_entry_invokeBasic(Method* method, intptr_t UNUSED, TRAPS) { ++ ++ JavaThread *thread = (JavaThread *) THREAD; ++ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); ++ interpreterState istate = frame->interpreter_state(); ++ intptr_t* topOfStack = istate->stack(); ++ ++ // 'this' is a MethodHandle. We resolve the target method by accessing this.form.vmentry.vmtarget. ++ int numArgs = method->size_of_parameters(); ++ oop lform1 = java_lang_invoke_MethodHandle::form(STACK_OBJECT(-numArgs)); // this.form ++ oop vmEntry1 = java_lang_invoke_LambdaForm::vmentry(lform1); ++ Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmEntry1); ++ ++ invoke_target(vmtarget, THREAD); ++ ++ // No deoptimized frames on the stack ++ return 0; ++} ++ ++int MethodHandles::method_handle_entry_linkToStaticOrSpecial(Method* method, intptr_t UNUSED, TRAPS) { ++ ++ // Pop appendix argument from stack. This is a MemberName which we resolve to the ++ // target method. ++ oop vmentry = popFromStack(THREAD); ++ ++ Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); ++ ++ invoke_target(vmtarget, THREAD); ++ ++ return 0; ++} ++ ++int MethodHandles::method_handle_entry_linkToInterface(Method* method, intptr_t UNUSED, TRAPS) { ++ JavaThread *thread = (JavaThread *) THREAD; ++ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); ++ interpreterState istate = frame->interpreter_state(); ++ ++ // Pop appendix argument from stack. This is a MemberName which we resolve to the ++ // target method. ++ oop vmentry = popFromStack(THREAD); ++ intptr_t* topOfStack = istate->stack(); ++ ++ // Resolve target method by looking up in the receiver object's itable. ++ Klass* clazz = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(vmentry)); ++ intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); ++ Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); ++ ++ int numArgs = target->size_of_parameters(); ++ oop recv = STACK_OBJECT(-numArgs); ++ ++ InstanceKlass* klass_part = InstanceKlass::cast(recv->klass()); ++ itableOffsetEntry* ki = (itableOffsetEntry*) klass_part->start_of_itable(); ++ int i; ++ for ( i = 0 ; i < klass_part->itable_length() ; i++, ki++ ) { ++ if (ki->interface_klass() == clazz) break; ++ } ++ ++ itableMethodEntry* im = ki->first_method_entry(recv->klass()); ++ Method* vmtarget = im[vmindex].method(); ++ ++ invoke_target(vmtarget, THREAD); ++ ++ return 0; ++} ++ ++int MethodHandles::method_handle_entry_linkToVirtual(Method* method, intptr_t UNUSED, TRAPS) { ++ JavaThread *thread = (JavaThread *) THREAD; ++ ++ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); ++ interpreterState istate = frame->interpreter_state(); ++ ++ // Pop appendix argument from stack. This is a MemberName which we resolve to the ++ // target method. ++ oop vmentry = popFromStack(THREAD); ++ intptr_t* topOfStack = istate->stack(); ++ ++ // Resolve target method by looking up in the receiver object's vtable. ++ intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); ++ Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); ++ int numArgs = target->size_of_parameters(); ++ oop recv = STACK_OBJECT(-numArgs); ++ Klass* clazz = recv->klass(); ++ Klass* klass_part = InstanceKlass::cast(clazz); ++ klassVtable* vtable = klass_part->vtable(); ++ Method* vmtarget = vtable->method_at(vmindex); ++ ++ invoke_target(vmtarget, THREAD); ++ ++ return 0; ++} ++ ++int MethodHandles::method_handle_entry_invalid(Method* method, intptr_t UNUSED, TRAPS) { ++ ShouldNotReachHere(); ++ return 0; ++} ++ ++address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* masm, ++ vmIntrinsics::ID iid) { ++ switch (iid) { ++ case vmIntrinsics::_invokeGeneric: ++ case vmIntrinsics::_compiledLambdaForm: ++ // Perhaps surprisingly, the symbolic references visible to Java are not directly used. ++ // They are linked to Java-generated adapters via MethodHandleNatives.linkMethod. ++ // They all allow an appendix argument. ++ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invalid); ++ case vmIntrinsics::_invokeBasic: ++ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invokeBasic); ++ case vmIntrinsics::_linkToStatic: ++ case vmIntrinsics::_linkToSpecial: ++ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToStaticOrSpecial); ++ case vmIntrinsics::_linkToInterface: ++ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToInterface); ++ case vmIntrinsics::_linkToVirtual: ++ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToVirtual); ++ default: ++ ShouldNotReachHere(); ++ return NULL; ++ } ++} +diff --git a/src/cpu/zero/vm/methodHandles_zero.hpp b/src/cpu/zero/vm/methodHandles_zero.hpp +--- a/src/cpu/zero/vm/methodHandles_zero.hpp ++++ b/src/cpu/zero/vm/methodHandles_zero.hpp +@@ -26,6 +26,14 @@ + + // Adapters + enum /* platform_dependent_constants */ { +- adapter_code_size = 0 ++ adapter_code_size = sizeof(ZeroEntry) * (Interpreter::method_handle_invoke_LAST - Interpreter::method_handle_invoke_FIRST + 1) + }; + ++private: ++ static oop popFromStack(TRAPS); ++ static void invoke_target(Method* method, TRAPS); ++ static int method_handle_entry_invokeBasic(Method* method, intptr_t UNUSED, TRAPS); ++ static int method_handle_entry_linkToStaticOrSpecial(Method* method, intptr_t UNUSED, TRAPS); ++ static int method_handle_entry_linkToVirtual(Method* method, intptr_t UNUSED, TRAPS); ++ static int method_handle_entry_linkToInterface(Method* method, intptr_t UNUSED, TRAPS); ++ static int method_handle_entry_invalid(Method* method, intptr_t UNUSED, TRAPS); +diff --git a/src/cpu/zero/vm/register_zero.hpp b/src/cpu/zero/vm/register_zero.hpp +--- a/src/cpu/zero/vm/register_zero.hpp ++++ b/src/cpu/zero/vm/register_zero.hpp +@@ -114,5 +114,8 @@ + }; + + CONSTANT_REGISTER_DECLARATION(Register, noreg, (-1)); ++#ifndef DONT_USE_REGISTER_DEFINES ++#define noreg ((Register)(noreg_RegisterEnumValue)) ++#endif + + #endif // CPU_ZERO_VM_REGISTER_ZERO_HPP +diff --git a/src/cpu/zero/vm/relocInfo_zero.cpp b/src/cpu/zero/vm/relocInfo_zero.cpp +--- a/src/cpu/zero/vm/relocInfo_zero.cpp ++++ b/src/cpu/zero/vm/relocInfo_zero.cpp +@@ -77,3 +77,7 @@ + CodeBuffer* dst) { + ShouldNotCallThis(); + } ++ ++void metadata_Relocation::pd_fix_value(address x) { ++ ShouldNotCallThis(); ++} +diff --git a/src/cpu/zero/vm/sharedRuntime_zero.cpp b/src/cpu/zero/vm/sharedRuntime_zero.cpp +--- a/src/cpu/zero/vm/sharedRuntime_zero.cpp ++++ b/src/cpu/zero/vm/sharedRuntime_zero.cpp +@@ -35,6 +35,7 @@ + #include "runtime/sharedRuntime.hpp" + #include "runtime/vframeArray.hpp" + #include "vmreg_zero.inline.hpp" ++ + #ifdef COMPILER1 + #include "c1/c1_Runtime1.hpp" + #endif +@@ -47,6 +48,12 @@ + #endif + + ++ ++static address zero_null_code_stub() { ++ address start = ShouldNotCallThisStub(); ++ return start; ++} ++ + int SharedRuntime::java_calling_convention(const BasicType *sig_bt, + VMRegPair *regs, + int total_args_passed, +@@ -63,16 +70,14 @@ + AdapterFingerPrint *fingerprint) { + return AdapterHandlerLibrary::new_entry( + fingerprint, +- ShouldNotCallThisStub(), +- ShouldNotCallThisStub(), +- ShouldNotCallThisStub()); ++ CAST_FROM_FN_PTR(address,zero_null_code_stub), ++ CAST_FROM_FN_PTR(address,zero_null_code_stub), ++ CAST_FROM_FN_PTR(address,zero_null_code_stub)); + } + + nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm, + methodHandle method, + int compile_id, +- int total_args_passed, +- int max_arg, + BasicType *sig_bt, + VMRegPair *regs, + BasicType ret_type) { +@@ -96,19 +101,20 @@ + ShouldNotCallThis(); + } + ++JRT_LEAF(void, zero_stub()) ++ ShouldNotCallThis(); ++JRT_END ++ + static RuntimeStub* generate_empty_runtime_stub(const char* name) { +- CodeBuffer buffer(name, 0, 0); +- return RuntimeStub::new_runtime_stub(name, &buffer, 0, 0, NULL, false); ++ return CAST_FROM_FN_PTR(RuntimeStub*,zero_stub); + } + + static SafepointBlob* generate_empty_safepoint_blob() { +- CodeBuffer buffer("handler_blob", 0, 0); +- return SafepointBlob::create(&buffer, NULL, 0); ++ return CAST_FROM_FN_PTR(SafepointBlob*,zero_stub); + } + + static DeoptimizationBlob* generate_empty_deopt_blob() { +- CodeBuffer buffer("handler_blob", 0, 0); +- return DeoptimizationBlob::create(&buffer, NULL, 0, 0, 0, 0); ++ return CAST_FROM_FN_PTR(DeoptimizationBlob*,zero_stub); + } + + +@@ -116,7 +122,7 @@ + _deopt_blob = generate_empty_deopt_blob(); + } + +-SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, bool cause_return) { ++SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { + return generate_empty_safepoint_blob(); + } + +@@ -124,6 +130,7 @@ + return generate_empty_runtime_stub("resolve_blob"); + } + ++ + int SharedRuntime::c_calling_convention(const BasicType *sig_bt, + VMRegPair *regs, + int total_args_passed) { +diff --git a/src/cpu/zero/vm/stubRoutines_zero.hpp b/src/cpu/zero/vm/stubRoutines_zero.hpp +--- a/src/cpu/zero/vm/stubRoutines_zero.hpp ++++ b/src/cpu/zero/vm/stubRoutines_zero.hpp +@@ -40,8 +40,8 @@ + } + + enum platform_dependent_constants { +- code_size1 = 0, // The assembler will fail with a guarantee +- code_size2 = 0 // if these are too small. Simply increase ++ code_size1 = 1, // The assembler will fail with a guarantee ++ code_size2 = 1 // if these are too small. Simply increase + }; // them if that happens. + + enum method_handles_platform_dependent_constants { +diff --git a/src/share/vm/asm/assembler.cpp b/src/share/vm/asm/assembler.cpp +--- a/src/share/vm/asm/assembler.cpp ++++ b/src/share/vm/asm/assembler.cpp +@@ -59,6 +59,7 @@ + _code_section = cs; + _code_begin = cs->start(); + _code_limit = cs->limit(); ++ assert(_code_limit > _code_begin, "no empty code buffer"); + _code_pos = cs->end(); + _oop_recorder= code->oop_recorder(); + DEBUG_ONLY( _short_branch_delta = 0; ) +diff --git a/src/share/vm/asm/codeBuffer.cpp b/src/share/vm/asm/codeBuffer.cpp +--- a/src/share/vm/asm/codeBuffer.cpp ++++ b/src/share/vm/asm/codeBuffer.cpp +@@ -758,7 +758,7 @@ + } + } + +- if (dest->blob() == NULL) { ++ if (dest->blob() == NULL && dest_filled != 0x0) { + // Destination is a final resting place, not just another buffer. + // Normalize uninitialized bytes in the final padding. + Copy::fill_to_bytes(dest_filled, dest_end - dest_filled, +diff --git a/src/share/vm/interpreter/bytecodeInterpreter.cpp b/src/share/vm/interpreter/bytecodeInterpreter.cpp +--- a/src/share/vm/interpreter/bytecodeInterpreter.cpp ++++ b/src/share/vm/interpreter/bytecodeInterpreter.cpp +@@ -235,10 +235,6 @@ + #endif + #endif + +-// JavaStack Implementation +-#define MORE_STACK(count) \ +- (topOfStack -= ((count) * Interpreter::stackElementWords)) +- + + #define UPDATE_PC(opsize) {pc += opsize; } + /* +@@ -575,7 +571,7 @@ + + /* 0xE0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, + /* 0xE4 */ &&opc_default, &&opc_fast_aldc, &&opc_fast_aldc_w, &&opc_return_register_finalizer, +-/* 0xE8 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, ++/* 0xE8 */ &&opc_invokehandle,&&opc_default, &&opc_default, &&opc_default, + /* 0xEC */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, + + /* 0xF0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, +@@ -1773,7 +1769,7 @@ + + oop obj; + if ((Bytecodes::Code)opcode == Bytecodes::_getstatic) { +- Klass* k = (Klass*) cache->f1(); ++ Klass* k = cache->f1_as_klass(); + obj = k->java_mirror(); + MORE_STACK(1); // Assume single slot push + } else { +@@ -1885,7 +1881,7 @@ + --count; + } + if ((Bytecodes::Code)opcode == Bytecodes::_putstatic) { +- Klass* k = (Klass*) cache->f1(); ++ Klass* k = cache->f1_as_klass(); + obj = k->java_mirror(); + } else { + --count; +@@ -2190,6 +2186,7 @@ + } + + CASE(_invokedynamic): { ++ + if (!EnableInvokeDynamic) { + // We should not encounter this bytecode if !EnableInvokeDynamic. + // The verifier will stop it. However, if we get past the verifier, +@@ -2199,30 +2196,69 @@ + ShouldNotReachHere(); + } + +- int index = Bytes::get_native_u4(pc+1); ++ u4 index = Bytes::get_native_u4(pc+1); ++ ConstantPoolCacheEntry* cache = cp->constant_pool()->invokedynamic_cp_cache_entry_at(index); + + // We are resolved if the resolved_references field contains a non-null object (CallSite, etc.) + // This kind of CP cache entry does not need to match the flags byte, because + // there is a 1-1 relation between bytecode type and CP entry type. +- ConstantPool* constants = METHOD->constants(); +- oop result = constants->resolved_references()->obj_at(index); +- if (result == NULL) { ++ if (! cache->is_resolved((Bytecodes::Code) opcode)) { + CALL_VM(InterpreterRuntime::resolve_invokedynamic(THREAD), + handle_exception); +- result = THREAD->vm_result(); ++ cache = cp->constant_pool()->invokedynamic_cp_cache_entry_at(index); + } + +- VERIFY_OOP(result); +- oop method_handle = java_lang_invoke_CallSite::target(result); +- CHECK_NULL(method_handle); +- +- istate->set_msg(call_method_handle); +- istate->set_callee((Method*) method_handle); ++ Method* method = cache->f1_as_method(); ++ VERIFY_OOP(method); ++ ++ if (cache->has_appendix()) { ++ ConstantPool* constants = METHOD->constants(); ++ SET_STACK_OBJECT(cache->appendix_if_resolved(constants), 0); ++ MORE_STACK(1); ++ } ++ ++ istate->set_msg(call_method); ++ istate->set_callee(method); ++ istate->set_callee_entry_point(method->from_interpreted_entry()); + istate->set_bcp_advance(5); + + UPDATE_PC_AND_RETURN(0); // I'll be back... + } + ++ CASE(_invokehandle): { ++ ++ if (!EnableInvokeDynamic) { ++ ShouldNotReachHere(); ++ } ++ ++ u2 index = Bytes::get_native_u2(pc+1); ++ ConstantPoolCacheEntry* cache = cp->entry_at(index); ++ ++ if (! cache->is_resolved((Bytecodes::Code) opcode)) { ++ CALL_VM(InterpreterRuntime::resolve_invokehandle(THREAD), ++ handle_exception); ++ cache = cp->entry_at(index); ++ } ++ ++ /* ***************** */ ++ Method* method = cache->f1_as_method(); ++ ++ VERIFY_OOP(method); ++ ++ if (cache->has_appendix()) { ++ ConstantPool* constants = METHOD->constants(); ++ SET_STACK_OBJECT(cache->appendix_if_resolved(constants), 0); ++ MORE_STACK(1); ++ } ++ ++ istate->set_msg(call_method); ++ istate->set_callee(method); ++ istate->set_callee_entry_point(method->from_interpreted_entry()); ++ istate->set_bcp_advance(3); ++ ++ UPDATE_PC_AND_RETURN(0); // I'll be back... ++ } ++ + CASE(_invokeinterface): { + u2 index = Bytes::get_native_u2(pc+1); + +diff --git a/src/share/vm/interpreter/bytecodeInterpreter.hpp b/src/share/vm/interpreter/bytecodeInterpreter.hpp +--- a/src/share/vm/interpreter/bytecodeInterpreter.hpp ++++ b/src/share/vm/interpreter/bytecodeInterpreter.hpp +@@ -50,6 +50,10 @@ + + #ifdef CC_INTERP + ++// JavaStack Implementation ++#define MORE_STACK(count) \ ++ (topOfStack -= ((count) * Interpreter::stackElementWords)) ++ + // CVM definitions find hotspot equivalents... + + union VMJavaVal64 { +@@ -107,7 +111,6 @@ + rethrow_exception, // unwinding and throwing exception + // requests to frame manager from C++ interpreter + call_method, // request for new frame from interpreter, manager responds with method_entry +- call_method_handle, // like the above, except the callee is a method handle + return_from_method, // request from interpreter to unwind, manager responds with method_continue + more_monitors, // need a new monitor + throwing_exception, // unwind stack and rethrow +diff --git a/src/share/vm/interpreter/cppInterpreter.cpp b/src/share/vm/interpreter/cppInterpreter.cpp +--- a/src/share/vm/interpreter/cppInterpreter.cpp ++++ b/src/share/vm/interpreter/cppInterpreter.cpp +@@ -117,7 +117,6 @@ + method_entry(empty); + method_entry(accessor); + method_entry(abstract); +- method_entry(method_handle); + method_entry(java_lang_math_sin ); + method_entry(java_lang_math_cos ); + method_entry(java_lang_math_tan ); +@@ -125,6 +124,8 @@ + method_entry(java_lang_math_sqrt ); + method_entry(java_lang_math_log ); + method_entry(java_lang_math_log10 ); ++ method_entry(java_lang_math_pow ); ++ method_entry(java_lang_math_exp ); + method_entry(java_lang_ref_reference_get); + Interpreter::_native_entry_begin = Interpreter::code()->code_end(); + method_entry(native); +diff --git a/src/share/vm/interpreter/interpreter.cpp b/src/share/vm/interpreter/interpreter.cpp +--- a/src/share/vm/interpreter/interpreter.cpp ++++ b/src/share/vm/interpreter/interpreter.cpp +@@ -252,7 +252,7 @@ + void AbstractInterpreter::set_entry_for_kind(AbstractInterpreter::MethodKind kind, address entry) { + assert(kind >= method_handle_invoke_FIRST && + kind <= method_handle_invoke_LAST, "late initialization only for MH entry points"); +- assert(_entry_table[kind] == _entry_table[abstract], "previous value must be AME entry"); ++ assert(_entry_table[kind] == NULL || _entry_table[kind] == _entry_table[abstract], "previous value must be AME entry or NULL"); + _entry_table[kind] = entry; + } + +diff --git a/src/share/vm/interpreter/interpreterRuntime.cpp b/src/share/vm/interpreter/interpreterRuntime.cpp +--- a/src/share/vm/interpreter/interpreterRuntime.cpp ++++ b/src/share/vm/interpreter/interpreterRuntime.cpp +@@ -732,7 +732,6 @@ + LinkResolver::resolve_invoke(info, Handle(), pool, + get_index_u2_cpcache(thread, bytecode), bytecode, CHECK); + } // end JvmtiHideSingleStepping +- + cache_entry(thread)->set_method_handle( + pool, + info.resolved_method(), +diff --git a/src/share/vm/runtime/vmStructs.cpp b/src/share/vm/runtime/vmStructs.cpp +--- a/src/share/vm/runtime/vmStructs.cpp ++++ b/src/share/vm/runtime/vmStructs.cpp +@@ -2436,7 +2436,7 @@ + /* frame */ \ + /**********************/ \ + \ +- X86_ONLY(declare_constant(frame::entry_frame_call_wrapper_offset)) \ ++ NOT_ZERO(X86_ONLY(declare_constant(frame::entry_frame_call_wrapper_offset))) \ + declare_constant(frame::pc_return_offset) \ + \ + /*************/ \ +diff --git a/src/share/vm/shark/sharkCompiler.cpp b/src/share/vm/shark/sharkCompiler.cpp +--- a/src/share/vm/shark/sharkCompiler.cpp ++++ b/src/share/vm/shark/sharkCompiler.cpp +@@ -319,7 +319,8 @@ + // finish with the exception of the VM thread, so we can consider + // ourself the owner of the execution engine lock even though we + // can't actually acquire it at this time. +- assert(Thread::current()->is_VM_thread(), "must be called by VM thread"); ++ assert(JavaThread::current()->thread_state() == _thread_in_vm, "must run in vm mode"); ++//assert(Thread::current()->is_VM_thread(), "must be called by VM thread"); + assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); + + SharkEntry *entry = (SharkEntry *) code; +diff --git a/src/share/vm/utilities/macros.hpp b/src/share/vm/utilities/macros.hpp +--- a/src/share/vm/utilities/macros.hpp ++++ b/src/share/vm/utilities/macros.hpp +@@ -177,6 +177,22 @@ + #define NOT_WIN64(code) code + #endif + ++#if defined(ZERO) ++#define ZERO_ONLY(code) code ++#define NOT_ZERO(code) ++#else ++#define ZERO_ONLY(code) ++#define NOT_ZERO(code) code ++#endif ++ ++#if defined(SHARK) ++#define SHARK_ONLY(code) code ++#define NOT_SHARK(code) ++#else ++#define SHARK_ONLY(code) ++#define NOT_SHARK(code) code ++#endif ++ + #if defined(IA32) || defined(AMD64) + #define X86 + #define X86_ONLY(code) code
--- a/hotspot.patch Fri Oct 05 19:46:11 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,714 +0,0 @@ -diff --git a/make/linux/platform_zero.in b/make/linux/platform_zero.in ---- a/make/linux/platform_zero.in -+++ b/make/linux/platform_zero.in -@@ -14,4 +14,4 @@ - - gnu_dis_arch = zero - --sysdefs = -DLINUX -D_GNU_SOURCE -DCC_INTERP -DZERO -D@ZERO_ARCHDEF@ -DZERO_LIBARCH=\"@ZERO_LIBARCH@\" -+sysdefs = -DLINUX -D_GNU_SOURCE -DCC_INTERP -DZERO -DTARGET_ARCH_NYI_6939861=1 -D@ZERO_ARCHDEF@ -DZERO_LIBARCH=\"@ZERO_LIBARCH@\" -diff --git a/src/cpu/zero/vm/assembler_zero.cpp b/src/cpu/zero/vm/assembler_zero.cpp ---- a/src/cpu/zero/vm/assembler_zero.cpp -+++ b/src/cpu/zero/vm/assembler_zero.cpp -@@ -91,3 +91,11 @@ - address ShouldNotCallThisEntry() { - return (address) should_not_call; - } -+ -+static void zero_null_fn() { -+ return; -+} -+ -+address ZeroNullStubEntry(address fn) { -+ return (address) fn; -+} -diff --git a/src/cpu/zero/vm/assembler_zero.hpp b/src/cpu/zero/vm/assembler_zero.hpp ---- a/src/cpu/zero/vm/assembler_zero.hpp -+++ b/src/cpu/zero/vm/assembler_zero.hpp -@@ -65,5 +65,6 @@ - - address ShouldNotCallThisStub(); - address ShouldNotCallThisEntry(); -+address ZeroNullStubEntry(address fn); - - #endif // CPU_ZERO_VM_ASSEMBLER_ZERO_HPP -diff --git a/src/cpu/zero/vm/copy_zero.hpp b/src/cpu/zero/vm/copy_zero.hpp ---- a/src/cpu/zero/vm/copy_zero.hpp -+++ b/src/cpu/zero/vm/copy_zero.hpp -@@ -169,7 +169,7 @@ - } - - static void pd_fill_to_bytes(void* to, size_t count, jubyte value) { -- memset(to, value, count); -+ if ( count > 0 ) memset(to, value, count); - } - - static void pd_zero_to_words(HeapWord* tohw, size_t count) { -@@ -177,7 +177,7 @@ - } - - static void pd_zero_to_bytes(void* to, size_t count) { -- memset(to, 0, count); -+ if ( count > 0 ) memset(to, 0, count); - } - - #endif // CPU_ZERO_VM_COPY_ZERO_HPP -diff --git a/src/cpu/zero/vm/cppInterpreter_zero.cpp b/src/cpu/zero/vm/cppInterpreter_zero.cpp ---- a/src/cpu/zero/vm/cppInterpreter_zero.cpp -+++ b/src/cpu/zero/vm/cppInterpreter_zero.cpp -@@ -36,6 +36,7 @@ - #include "oops/oop.inline.hpp" - #include "prims/jvmtiExport.hpp" - #include "prims/jvmtiThreadState.hpp" -+#include "prims/methodHandles.hpp" - #include "runtime/arguments.hpp" - #include "runtime/deoptimization.hpp" - #include "runtime/frame.inline.hpp" -@@ -65,6 +66,7 @@ - CALL_VM_NOCHECK_NOFIX(func) \ - fixup_after_potential_safepoint() - -+ - int CppInterpreter::normal_entry(Method* method, intptr_t UNUSED, TRAPS) { - JavaThread *thread = (JavaThread *) THREAD; - -@@ -698,6 +700,9 @@ - method_handle = adapter; - } - -+ CPPINT_DEBUG( tty->print_cr( "Process method_handle sp: 0x%x unwind_sp: 0x%x result_slots: %d.", \ -+ stack->sp(), unwind_sp, result_slots ); ) -+ - // Start processing - process_method_handle(method_handle, THREAD); - if (HAS_PENDING_EXCEPTION) -@@ -717,6 +722,8 @@ - } - - // Check -+ CPPINT_DEBUG( tty->print_cr( "Exiting method_handle_entry, sp: 0x%x unwind_sp: 0x%x result_slots: %d.", \ -+ stack->sp(), unwind_sp, result_slots ); ) - assert(stack->sp() == unwind_sp - result_slots, "should be"); - - // No deoptimized frames on the stack -@@ -724,6 +731,7 @@ - } - - void CppInterpreter::process_method_handle(oop method_handle, TRAPS) { -+ - JavaThread *thread = (JavaThread *) THREAD; - ZeroStack *stack = thread->zero_stack(); - intptr_t *vmslots = stack->sp(); -@@ -810,11 +818,15 @@ - case MethodHandles::_bound_int_mh: - case MethodHandles::_bound_long_mh: - { -- BasicType arg_type = T_ILLEGAL; -- int arg_mask = -1; -- int arg_slots = -1; -- MethodHandles::get_ek_bound_mh_info( -- entry_kind, arg_type, arg_mask, arg_slots); -+ // BasicType arg_type = T_ILLEGAL; -+ // int arg_mask = -1; -+ // int arg_slots = -1; -+ // MethodHandles::get_ek_bound_mh_info( -+ // entry_kind, arg_type, arg_mask, arg_slots); -+ BasicType arg_type = MethodHandles::ek_bound_mh_arg_type(entry_kind); -+ int arg_mask = 0; -+ int arg_slots = type2size[arg_type];; -+ - int arg_slot = - java_lang_invoke_BoundMethodHandle::vmargslot(method_handle); - -@@ -960,10 +972,13 @@ - java_lang_invoke_AdapterMethodHandle::conversion(method_handle); - int arg2 = MethodHandles::adapter_conversion_vminfo(conv); - -- int swap_bytes = 0, rotate = 0; -- MethodHandles::get_ek_adapter_opt_swap_rot_info( -- entry_kind, swap_bytes, rotate); -- int swap_slots = swap_bytes >> LogBytesPerWord; -+ // int swap_bytes = 0, rotate = 0; -+ // MethodHandles::get_ek_adapter_opt_swap_rot_info( -+ // entry_kind, swap_bytes, rotate); -+ int swap_slots = MethodHandles::ek_adapter_opt_swap_slots(entry_kind); -+ int rotate = MethodHandles::ek_adapter_opt_swap_mode(entry_kind); -+ int swap_bytes = swap_slots * Interpreter::stackElementSize; -+ swap_slots = swap_bytes >> LogBytesPerWord; - - intptr_t tmp; - switch (rotate) { -@@ -1079,12 +1094,309 @@ - } - break; - -- default: -- tty->print_cr("unhandled entry_kind %s", -+ case MethodHandles::_adapter_opt_spread_0: -+ case MethodHandles::_adapter_opt_spread_1_ref: -+ case MethodHandles::_adapter_opt_spread_2_ref: -+ case MethodHandles::_adapter_opt_spread_3_ref: -+ case MethodHandles::_adapter_opt_spread_4_ref: -+ case MethodHandles::_adapter_opt_spread_5_ref: -+ case MethodHandles::_adapter_opt_spread_ref: -+ case MethodHandles::_adapter_opt_spread_byte: -+ case MethodHandles::_adapter_opt_spread_char: -+ case MethodHandles::_adapter_opt_spread_short: -+ case MethodHandles::_adapter_opt_spread_int: -+ case MethodHandles::_adapter_opt_spread_long: -+ case MethodHandles::_adapter_opt_spread_float: -+ case MethodHandles::_adapter_opt_spread_double: -+ { -+ -+ // spread an array out into a group of arguments -+ -+ int arg_slot = -+ java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -+ // Fetch the argument, which we will cast to the required array type. -+ oop arg = VMSLOTS_OBJECT(arg_slot); -+ -+ BasicType elem_type = -+ MethodHandles::ek_adapter_opt_spread_type(entry_kind); -+ int elem_slots = -+ type2size[elem_type]; // 1 or 2 -+ int array_slots = -+ 1; // array is always a T_OBJECT -+ int length_offset = -+ arrayOopDesc::length_offset_in_bytes(); -+ int elem0_offset = -+ arrayOopDesc::base_offset_in_bytes(elem_type); -+ int length_constant = -+ MethodHandles::ek_adapter_opt_spread_count(entry_kind); -+ int array_length = 0; -+ void *array_elem0 = NULL; -+ -+ CPPINT_DEBUG( tty->print_cr( \ -+ "ENTERING _adapter_opt_spread: %s %d %d 0x%x 0x%x", \ -+ type2name(elem_type), arg_slot, length_constant, (char *)arg, stack->sp() ); ) -+ -+ // If the spread count is -1, the length is "variable" ie controlled -+ // by the array length. -+ // See ek_adapter_opt_spread_count in methodHandles.hpp -+ // If array lenth is 0 or spread count is 0 , we will remove the argslot. -+ -+ bool length_can_be_zero = (length_constant == 0); -+ if (length_constant < 0) { -+ // some adapters with variable length must handle the zero case -+ if (!OptimizeMethodHandles || -+ elem_type != T_OBJECT) -+ length_can_be_zero = true; -+ } -+ -+ if (arg == NULL) { -+ CPPINT_DEBUG( tty->print_cr( \ -+ "arg NULL implies Array_length == 0, remove slot." ); ) -+ // remove arg slot -+ remove_vmslots(arg_slot, 1, THREAD); // doesn't trap -+ vmslots = stack->sp(); // unused, but let the compiler figure that out -+ CPPINT_DEBUG( tty->print_cr( \ -+ " >> Would LEAVE _adapter_opt_spread with NPE." ); ) -+#ifdef _NOT_DEF_ -+ // queue a nullpointer exception for the caller -+ stack->set_sp(calculate_unwind_sp(stack, method_handle)); -+ CALL_VM_NOCHECK_NOFIX( -+ throw_exception( -+ thread, -+ vmSymbols::java_lang_NullPointerException())); -+ // NB all oops trashed! -+ assert(HAS_PENDING_EXCEPTION, "should do"); -+ return; -+#endif -+ } else { // (arg != NULL) -+ klassOop objKlassOop = arg->klass(); -+ klassOop klassOf = java_lang_Class::as_klassOop( -+ java_lang_invoke_AdapterMethodHandle::argument(method_handle)); -+ -+ if (objKlassOop != klassOf && -+ !objKlassOop->klass_part()->is_subtype_of(klassOf)) { -+ CPPINT_DEBUG( tty->print_cr( \ -+ "CLASS CAST ERROR #1 in _adapter_opt_spread." ); ) -+ ResourceMark rm(THREAD); -+ const char* objName = Klass::cast(objKlassOop)->external_name(); -+ const char* klassName = Klass::cast(klassOf)->external_name(); -+ char* message = SharedRuntime::generate_class_cast_message( -+ objName, klassName); -+ -+ stack->set_sp(calculate_unwind_sp(stack, method_handle)); -+ CALL_VM_NOCHECK_NOFIX( -+ throw_exception( -+ thread, -+ vmSymbols::java_lang_ClassCastException(), message)); -+ // NB all oops trashed! -+ assert(HAS_PENDING_EXCEPTION, "should do"); -+ return; -+ } -+ -+ // Check the array type. -+ -+ klassOop array_klass_oop = NULL; -+ BasicType array_type = java_lang_Class::as_BasicType( -+ java_lang_invoke_AdapterMethodHandle::argument(method_handle), -+ &array_klass_oop); -+ arrayKlassHandle array_klass(THREAD, array_klass_oop); -+ -+ assert(array_type == T_OBJECT, ""); -+ assert(Klass::cast(array_klass_oop)->oop_is_array(), ""); -+ if (!(array_type == T_OBJECT) || -+ !(Klass::cast(array_klass_oop)->oop_is_array())) { -+ CPPINT_DEBUG( tty->print_cr( \ -+ "CLASS CAST ERROR #2 not an array in _adapter_opt_spread." ); ) -+ ResourceMark rm(THREAD); -+ const char* objName = Klass::cast(objKlassOop)->external_name(); -+ const char* klassName = Klass::cast(klassOf)->external_name(); -+ char* message = SharedRuntime::generate_class_cast_message( -+ objName, klassName); -+ stack->set_sp(calculate_unwind_sp(stack, method_handle)); -+ CALL_VM_NOCHECK_NOFIX( -+ throw_exception( -+ thread, -+ vmSymbols::java_lang_ClassCastException(), message)); -+ // NB all oops trashed! -+ assert(HAS_PENDING_EXCEPTION, "should do"); -+ return; -+ } -+ -+ klassOop element_klass_oop = NULL; -+ BasicType element_type = -+ java_lang_Class::as_BasicType(array_klass->component_mirror(), -+ &element_klass_oop); -+ KlassHandle element_klass(THREAD, element_klass_oop); -+ if ((elem_type != T_OBJECT) && (elem_type != element_type)) { -+ CPPINT_DEBUG( tty->print_cr( \ -+ "CLASS CAST ERROR #3 invalid type %s != %s in _adapter_opt_spread.", \ -+ type2name(elem_type), type2name(element_type) ); ) -+ ResourceMark rm(THREAD); -+ const char* objName = Klass::cast(objKlassOop)->external_name(); -+ const char* klassName = Klass::cast(klassOf)->external_name(); -+ char* message = SharedRuntime::generate_class_cast_message( -+ objName, klassName); -+ stack->set_sp(calculate_unwind_sp(stack, method_handle)); -+ CALL_VM_NOCHECK_NOFIX( -+ throw_exception( -+ thread, -+ vmSymbols::java_lang_ClassCastException(), message)); -+ // NB all oops trashed! -+ assert(HAS_PENDING_EXCEPTION, "should do"); -+ return; -+ } -+ -+ array_length = arrayOop(arg)->length(); -+ -+ // Check the required length. -+ if (length_constant > 0) { // must match ? -+ if ( array_length != length_constant ) { -+ CPPINT_DEBUG( tty->print_cr( \ -+ "ARRY INDEX ERROR #4 invalid array length in _adapter_opt_spread." ); ) -+ //fixme ArrayIndexOutOfBoundsException ? -+ ResourceMark rm(THREAD); -+ const char* objName = Klass::cast(objKlassOop)->external_name(); -+ const char* klassName = Klass::cast(klassOf)->external_name(); -+ char* message = SharedRuntime::generate_class_cast_message( -+ objName, klassName); -+ -+ stack->set_sp(calculate_unwind_sp(stack, method_handle)); -+ CALL_VM_NOCHECK_NOFIX( -+ throw_exception( -+ thread, -+ vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message)); -+ // NB all oops trashed! -+ assert(HAS_PENDING_EXCEPTION, "should do"); -+ return; -+ } -+ // use array_length ? -+ } else { // length_constant == [ -1 or 0 ] -+ if ( (array_length > 0) || length_can_be_zero ) { -+ // use array_length. -+ } else { // array_length 0 and not length_can_be_zero -+ CPPINT_DEBUG( tty->print_cr( \ -+ "ARRY INDEX ERROR #5 arry length 0 in _adapter_opt_spread." ); ) -+ //fixme ArrayIndexOutOfBoundsException ? -+ ResourceMark rm(THREAD); -+ const char* objName = Klass::cast(objKlassOop)->external_name(); -+ const char* klassName = Klass::cast(klassOf)->external_name(); -+ char* message = SharedRuntime::generate_class_cast_message( -+ objName, klassName); -+ -+ stack->set_sp(calculate_unwind_sp(stack, method_handle)); -+ CALL_VM_NOCHECK_NOFIX( -+ throw_exception( -+ thread, -+ vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message)); -+ // NB all oops trashed! -+ assert(HAS_PENDING_EXCEPTION, "should do"); -+ return; -+ } -+ } -+ -+ // Array length checked out. Now insert any required arg slots. -+ // array_length - 1 more slots if array_length > 0 -+ // otherwise if array_length == 0 remove arg_slot. -+ -+ if ( array_length > 0 ) { -+ int slots = (array_length * elem_slots) - 1; -+ CPPINT_DEBUG( tty->print_cr( \ -+ "array_length %d %d slots needed in _adapter_opt_spread.",\ -+ array_length, slots); ) -+ debug_only(if (elem_slots == 2) \ -+ assert ((slots % 2 == 1)," bad slots calc")); -+ if ( slots > 0 ) { -+ intptr_t *unwind_sp = -+ calculate_unwind_sp(stack, method_handle); -+ insert_vmslots(arg_slot, slots, THREAD); -+ if (HAS_PENDING_EXCEPTION) { -+ // all oops trashed -+ stack->set_sp(unwind_sp); -+ return; -+ } -+ } -+ vmslots = stack->sp(); -+ arg_slot += slots; -+ -+ array_elem0 = arrayOop(arg)->base(elem_type); -+ -+ // Copy from the array to the new arg slots. -+ // [from native : Beware: Arguments that are shallow -+ // on the stack are deep in the array, -+ // and vice versa. So a downward-growing stack (the usual) -+ // has to be copied elementwise in reverse order -+ // from the source array.] -+ -+ void * array_elem = array_elem0; -+ int top_slot = arg_slot; -+ -+ debug_only(if (elem_slots == 2) \ -+ assert ((((ulong)(char *)&vmslots[top_slot]) % \ -+ (u_int)type2aelembytes(elem_type) == 0), \ -+ " bad arg alignment")); -+ -+ CPPINT_DEBUG( tty->print_cr( \ -+ "BEGIN ARRY LOOP %d %d 0x%x 0x%x _adapter_opt_spread.",\ -+ array_length, top_slot, &vmslots[top_slot], array_elem ); ) -+ -+ for (int index = 0; index < array_length; index++) { -+ switch (elem_type) { -+ case T_BYTE: -+ SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -+ break; -+ case T_CHAR: -+ SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -+ break; -+ case T_SHORT: -+ SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -+ break; -+ case T_INT: -+ SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -+ break; -+ case T_FLOAT: -+ SET_VMSLOTS_FLOAT(*(jfloat*)array_elem,top_slot); -+ break; -+ case T_LONG: -+ SET_VMSLOTS_LONG(*(jlong*)array_elem, top_slot); -+ break; -+ case T_DOUBLE: -+ SET_VMSLOTS_DOUBLE(*(jdouble*)array_elem, top_slot); -+ break; -+ case T_OBJECT: -+ SET_VMSLOTS_OBJECT(*(oopDesc**)array_elem, top_slot); -+ break; -+ default: -+ tty->print_cr("unhandled type %s", type2name(elem_type)); -+ ShouldNotReachHere(); -+ } -+ array_elem = (void*)((char *)array_elem + -+ type2aelembytes(element_type)); -+ top_slot -= elem_slots; -+ } -+ arg_slot++; -+ } -+ } -+ if ((array_length == 0) && (arg != NULL)) { -+ CPPINT_DEBUG( tty->print_cr( \ -+ "Array_length == 0, will remove slot." ); ) -+ // remove arg slot -+ remove_vmslots(arg_slot, 1, THREAD); // doesn't trap -+ // unused, but let the compiler figure that out -+ vmslots = stack->sp(); -+ // -+ } -+ CPPINT_DEBUG( tty->print_cr( \ -+ "LEAVING _adapter_opt_spread: %s 0x%x 0x%x \n", \ -+ type2name(elem_type), (char *)arg, (char *)stack->sp() ); ) -+ } -+ break; -+ default: -+ tty->print_cr("unhandled entry_kind %s", - MethodHandles::entry_name(entry_kind)); -- ShouldNotReachHere(); -+ ShouldNotReachHere(); - } - -+ - // Continue along the chain - if (direct_to_method) { - if (method == NULL) { -@@ -1137,6 +1449,7 @@ - tty->print_cr("dst_rtype = %s", type2name(dst_rtype)); - ShouldNotReachHere(); - } -+ CPPINT_DEBUG( tty->print_cr( "LEAVING %s\n",MethodHandles::entry_name(entry_kind) ); ) - } - - // The new slots will be inserted before slot insert_before. -diff --git a/src/cpu/zero/vm/frame_zero.inline.hpp b/src/cpu/zero/vm/frame_zero.inline.hpp ---- a/src/cpu/zero/vm/frame_zero.inline.hpp -+++ b/src/cpu/zero/vm/frame_zero.inline.hpp -@@ -36,6 +36,8 @@ - _deopt_state = unknown; - } - -+inline address frame::sender_pc() const { ShouldNotCallThis(); } -+ - inline frame::frame(ZeroFrame* zf, intptr_t* sp) { - _zeroframe = zf; - _sp = sp; -diff --git a/src/cpu/zero/vm/methodHandles_zero.cpp b/src/cpu/zero/vm/methodHandles_zero.cpp ---- a/src/cpu/zero/vm/methodHandles_zero.cpp -+++ b/src/cpu/zero/vm/methodHandles_zero.cpp -@@ -28,6 +28,8 @@ - #include "memory/allocation.inline.hpp" - #include "prims/methodHandles.hpp" - -+#define __ _masm-> -+ - int MethodHandles::adapter_conversion_ops_supported_mask() { - return ((1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY) - |(1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW) -@@ -38,12 +40,73 @@ - |(1<<java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS) - |(1<<java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS) - |(1<<java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS) -- //|(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) //BUG! -+ |(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) - ); -- // FIXME: MethodHandlesTest gets a crash if we enable OP_SPREAD_ARGS. - } - - void MethodHandles::generate_method_handle_stub(MacroAssembler* masm, - MethodHandles::EntryKind ek) { - init_entry(ek, (MethodHandleEntry *) ek); - } -+void MethodHandles::RicochetFrame::generate_ricochet_blob(MacroAssembler* _masm, -+ // output params: -+ int* bounce_offset, -+ int* exception_offset, -+ int* frame_size_in_words) { -+ (*frame_size_in_words) = 0; -+ address start = __ pc(); -+ (*bounce_offset) = __ pc() - start; -+ (*exception_offset) = __ pc() - start; -+} -+ -+frame MethodHandles::ricochet_frame_sender(const frame& fr, RegisterMap *map) { -+ //RicochetFrame* f = RicochetFrame::from_frame(fr); -+ // Cf. is_interpreted_frame path of frame::sender -+ // intptr_t* younger_sp = fr.sp(); -+ // intptr_t* sp = fr.sender_sp(); -+ // return frame(sp, younger_sp, this_frame_adjusted_stack); -+ ShouldNotCallThis(); -+} -+ -+void MethodHandles::ricochet_frame_oops_do(const frame& fr, OopClosure* blk, const RegisterMap* reg_map) { -+ // ResourceMark rm; -+ // RicochetFrame* f = RicochetFrame::from_frame(fr); -+ -+ // pick up the argument type descriptor: -+ // Thread* thread = Thread::current(); -+ // process fixed part -+ // blk->do_oop((oop*)f->saved_target_addr()); -+ // blk->do_oop((oop*)f->saved_args_layout_addr()); -+ -+ // process variable arguments: -+ // if (cookie.is_null()) return; // no arguments to describe -+ -+ // the cookie is actually the invokeExact method for my target -+ // his argument signature is what I'm interested in -+ // assert(cookie->is_method(), ""); -+ // methodHandle invoker(thread, methodOop(cookie())); -+ // assert(invoker->name() == vmSymbols::invokeExact_name(), "must be this kind of method"); -+ // assert(!invoker->is_static(), "must have MH argument"); -+ // int slot_count = invoker->size_of_parameters(); -+ // assert(slot_count >= 1, "must include 'this'"); -+ // intptr_t* base = f->saved_args_base(); -+ // intptr_t* retval = NULL; -+ // if (f->has_return_value_slot()) -+ // retval = f->return_value_slot_addr(); -+ // int slot_num = slot_count - 1; -+ // intptr_t* loc = &base[slot_num]; -+ //blk->do_oop((oop*) loc); // original target, which is irrelevant -+ // int arg_num = 0; -+ // for (SignatureStream ss(invoker->signature()); !ss.is_done(); ss.next()) { -+ // if (ss.at_return_type()) continue; -+ // BasicType ptype = ss.type(); -+ // if (ptype == T_ARRAY) ptype = T_OBJECT; // fold all refs to T_OBJECT -+ // assert(ptype >= T_BOOLEAN && ptype <= T_OBJECT, "not array or void"); -+ // slot_num -= type2size[ptype]; -+ // loc = &base[slot_num]; -+ // bool is_oop = (ptype == T_OBJECT && loc != retval); -+ // if (is_oop) blk->do_oop((oop*)loc); -+ // arg_num += 1; -+ // } -+ // assert(slot_num == 0, "must have processed all the arguments"); -+} -diff --git a/src/cpu/zero/vm/methodHandles_zero.hpp b/src/cpu/zero/vm/methodHandles_zero.hpp ---- a/src/cpu/zero/vm/methodHandles_zero.hpp -+++ b/src/cpu/zero/vm/methodHandles_zero.hpp -@@ -29,3 +29,26 @@ - adapter_code_size = 0 - }; - -+class RicochetFrame : public ResourceObj { -+ friend class MethodHandles; -+ private: -+ /* -+ RF field x86 SPARC -+ sender_pc *(rsp+0) I7-0x8 -+ sender_link rbp I6+BIAS -+ exact_sender_sp rsi/r13 I5_savedSP -+ conversion *(rcx+&amh_conv) L5_conv -+ saved_args_base rax L4_sab (cf. Gargs = G4) -+ saved_args_layout #NULL L3_sal -+ saved_target *(rcx+&mh_vmtgt) L2_stgt -+ continuation #STUB_CON L1_cont -+ */ -+ public: -+ -+static void generate_ricochet_blob(MacroAssembler* _masm, -+ // output params: -+ int* bounce_offset, -+ int* exception_offset, -+ int* frame_size_in_words); -+ -+}; -diff --git a/src/cpu/zero/vm/sharedRuntime_zero.cpp b/src/cpu/zero/vm/sharedRuntime_zero.cpp ---- a/src/cpu/zero/vm/sharedRuntime_zero.cpp -+++ b/src/cpu/zero/vm/sharedRuntime_zero.cpp -@@ -35,6 +35,7 @@ - #include "runtime/sharedRuntime.hpp" - #include "runtime/vframeArray.hpp" - #include "vmreg_zero.inline.hpp" -+ - #ifdef COMPILER1 - #include "c1/c1_Runtime1.hpp" - #endif -@@ -47,6 +48,12 @@ - #endif - - -+ -+static address zero_null_code_stub() { -+ address start = ShouldNotCallThisStub(); -+ return start; -+} -+ - int SharedRuntime::java_calling_convention(const BasicType *sig_bt, - VMRegPair *regs, - int total_args_passed, -@@ -63,9 +70,9 @@ - AdapterFingerPrint *fingerprint) { - return AdapterHandlerLibrary::new_entry( - fingerprint, -- ShouldNotCallThisStub(), -- ShouldNotCallThisStub(), -- ShouldNotCallThisStub()); -+ ZeroNullStubEntry( CAST_FROM_FN_PTR(address,zero_null_code_stub) ), -+ ZeroNullStubEntry( CAST_FROM_FN_PTR(address,zero_null_code_stub) ), -+ ZeroNullStubEntry( CAST_FROM_FN_PTR(address,zero_null_code_stub) )); - } - - nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm, -@@ -96,19 +103,20 @@ - ShouldNotCallThis(); - } - -+JRT_LEAF(void, zero_stub()) -+ ShouldNotCallThis(); -+JRT_END -+ - static RuntimeStub* generate_empty_runtime_stub(const char* name) { -- CodeBuffer buffer(name, 0, 0); -- return RuntimeStub::new_runtime_stub(name, &buffer, 0, 0, NULL, false); -+ return CAST_FROM_FN_PTR(RuntimeStub*,zero_stub); - } - - static SafepointBlob* generate_empty_safepoint_blob() { -- CodeBuffer buffer("handler_blob", 0, 0); -- return SafepointBlob::create(&buffer, NULL, 0); -+ return CAST_FROM_FN_PTR(SafepointBlob*,zero_stub); - } - - static DeoptimizationBlob* generate_empty_deopt_blob() { -- CodeBuffer buffer("handler_blob", 0, 0); -- return DeoptimizationBlob::create(&buffer, NULL, 0, 0, 0, 0); -+ return CAST_FROM_FN_PTR(DeoptimizationBlob*,zero_stub); - } - - -@@ -124,6 +132,7 @@ - return generate_empty_runtime_stub("resolve_blob"); - } - -+ - int SharedRuntime::c_calling_convention(const BasicType *sig_bt, - VMRegPair *regs, - int total_args_passed) { -diff --git a/src/share/vm/runtime/vmStructs.cpp b/src/share/vm/runtime/vmStructs.cpp ---- a/src/share/vm/runtime/vmStructs.cpp -+++ b/src/share/vm/runtime/vmStructs.cpp -@@ -2436,7 +2436,7 @@ - /* frame */ \ - /**********************/ \ - \ -- X86_ONLY(declare_constant(frame::entry_frame_call_wrapper_offset)) \ -+ NOT_ZERO(X86_ONLY(declare_constant(frame::entry_frame_call_wrapper_offset))) \ - declare_constant(frame::pc_return_offset) \ - \ - /*************/ \ -diff --git a/src/share/vm/shark/sharkCompiler.cpp b/src/share/vm/shark/sharkCompiler.cpp ---- a/src/share/vm/shark/sharkCompiler.cpp -+++ b/src/share/vm/shark/sharkCompiler.cpp -@@ -319,7 +319,8 @@ - // finish with the exception of the VM thread, so we can consider - // ourself the owner of the execution engine lock even though we - // can't actually acquire it at this time. -- assert(Thread::current()->is_VM_thread(), "must be called by VM thread"); -+ assert(JavaThread::current()->thread_state() == _thread_in_vm, "must run in vm mode"); -+//assert(Thread::current()->is_VM_thread(), "must be called by VM thread"); - assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); - - SharkEntry *entry = (SharkEntry *) code; -diff --git a/src/share/vm/utilities/macros.hpp b/src/share/vm/utilities/macros.hpp ---- a/src/share/vm/utilities/macros.hpp -+++ b/src/share/vm/utilities/macros.hpp -@@ -177,6 +177,22 @@ - #define NOT_WIN64(code) code - #endif - -+#if defined(ZERO) -+#define ZERO_ONLY(code) code -+#define NOT_ZERO(code) -+#else -+#define ZERO_ONLY(code) -+#define NOT_ZERO(code) code -+#endif -+ -+#if defined(SHARK) -+#define SHARK_ONLY(code) code -+#define NOT_SHARK(code) -+#else -+#define SHARK_ONLY(code) -+#define NOT_SHARK(code) code -+#endif -+ - #if defined(IA32) || defined(AMD64) - #define X86 - #define X86_ONLY(code) code
--- a/mergejdk8.patch Fri Oct 05 19:46:11 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,290 +0,0 @@ -# HG changeset patch -# Parent 9fcf1fcc04b46911fe160042b7a3d6a670488777 -diff --git a/src/cpu/zero/vm/frame_zero.cpp b/src/cpu/zero/vm/frame_zero.cpp ---- a/src/cpu/zero/vm/frame_zero.cpp -+++ b/src/cpu/zero/vm/frame_zero.cpp -@@ -351,7 +351,7 @@ - switch (offset) { - case pc_off: - strncpy(fieldbuf, "pc", buflen); -- if (method()->is_oop()) { -+ if (method()->is_method()) { - nmethod *code = method()->code(); - if (code && code->pc_desc_at(pc())) { - SimpleScopeDesc ssd(code, pc()); -@@ -367,7 +367,7 @@ - - case method_off: - strncpy(fieldbuf, "method", buflen); -- if (method()->is_oop()) { -+ if (method()->is_method()) { - method()->name_and_sig_as_C_string(valuebuf, buflen); - } - return; -@@ -378,7 +378,7 @@ - } - - // Variable part -- if (method()->is_oop()) { -+ if (method()->is_method()) { - identify_vp_word(frame_index, addr_of_word(offset), - addr_of_word(header_words + 1), - unextended_sp() + method()->max_stack(), -diff --git a/src/cpu/zero/vm/icBuffer_zero.cpp b/src/cpu/zero/vm/icBuffer_zero.cpp ---- a/src/cpu/zero/vm/icBuffer_zero.cpp -+++ b/src/cpu/zero/vm/icBuffer_zero.cpp -@@ -40,7 +40,7 @@ - } - - void InlineCacheBuffer::assemble_ic_buffer_code(address code_begin, -- Metadata* cached_oop, -+ void* cached_oop, - address entry_point) { - // NB ic_stub_code_size() must return the size of the code we generate - ShouldNotCallThis(); -@@ -51,7 +51,6 @@ - ShouldNotCallThis(); - } - --Metadata* InlineCacheBuffer::ic_buffer_cached_oop(address code_begin) { -- // NB ic_stub_code_size() must return the size of the code we generate -+void* InlineCacheBuffer::ic_buffer_cached_value(address code_begin) { - ShouldNotCallThis(); - } -diff --git a/src/cpu/zero/vm/methodHandles_zero.cpp b/src/cpu/zero/vm/methodHandles_zero.cpp ---- a/src/cpu/zero/vm/methodHandles_zero.cpp -+++ b/src/cpu/zero/vm/methodHandles_zero.cpp -@@ -42,7 +42,7 @@ - (*exception_offset) = __ pc() - start; - } - --void MethodHandles::invoke_target(methodOop method, TRAPS) { -+void MethodHandles::invoke_target(Method* method, TRAPS) { - - JavaThread *thread = (JavaThread *) THREAD; - ZeroStack *stack = thread->zero_stack(); -@@ -74,7 +74,7 @@ - - } - --int MethodHandles::method_handle_entry_invokeBasic(methodOop method, intptr_t UNUSED, TRAPS) { -+int MethodHandles::method_handle_entry_invokeBasic(Method* method, intptr_t UNUSED, TRAPS) { - - JavaThread *thread = (JavaThread *) THREAD; - InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); -@@ -85,7 +85,7 @@ - int numArgs = method->size_of_parameters(); - oop lform1 = java_lang_invoke_MethodHandle::form(STACK_OBJECT(-numArgs)); // this.form - oop vmEntry1 = java_lang_invoke_LambdaForm::vmentry(lform1); -- methodOop vmtarget = (methodOop) java_lang_invoke_MemberName::vmtarget(vmEntry1); -+ Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmEntry1); - - invoke_target(vmtarget, THREAD); - -@@ -93,20 +93,20 @@ - return 0; - } - --int MethodHandles::method_handle_entry_linkToStaticOrSpecial(methodOop method, intptr_t UNUSED, TRAPS) { -+int MethodHandles::method_handle_entry_linkToStaticOrSpecial(Method* method, intptr_t UNUSED, TRAPS) { - - // Pop appendix argument from stack. This is a MemberName which we resolve to the - // target method. - oop vmentry = popFromStack(THREAD); - -- methodOop vmtarget = (methodOop) java_lang_invoke_MemberName::vmtarget(vmentry); -+ Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); - - invoke_target(vmtarget, THREAD); - - return 0; - } - --int MethodHandles::method_handle_entry_linkToInterface(methodOop method, intptr_t UNUSED, TRAPS) { -+int MethodHandles::method_handle_entry_linkToInterface(Method* method, intptr_t UNUSED, TRAPS) { - JavaThread *thread = (JavaThread *) THREAD; - InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); - interpreterState istate = frame->interpreter_state(); -@@ -117,14 +117,14 @@ - oop vmentry = popFromStack(THREAD); - - // Resolve target method by looking up in the receiver object's itable. -- klassOop clazz = java_lang_Class::as_klassOop(java_lang_invoke_MemberName::clazz(vmentry)); -+ Klass* clazz = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(vmentry)); - intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); -- methodOop target = (methodOop) java_lang_invoke_MemberName::vmtarget(vmentry); -+ Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); - - int numArgs = target->size_of_parameters(); - oop recv = STACK_OBJECT(-numArgs); - -- instanceKlass* klass_part = (instanceKlass*) recv->klass()->klass_part(); -+ InstanceKlass* klass_part = InstanceKlass::cast(recv->klass()); - itableOffsetEntry* ki = (itableOffsetEntry*) klass_part->start_of_itable(); - int i; - for ( i = 0 ; i < klass_part->itable_length() ; i++, ki++ ) { -@@ -132,14 +132,14 @@ - } - - itableMethodEntry* im = ki->first_method_entry(recv->klass()); -- methodOop vmtarget = im[vmindex].method(); -+ Method* vmtarget = im[vmindex].method(); - - invoke_target(vmtarget, THREAD); - - return 0; - } - --int MethodHandles::method_handle_entry_linkToVirtual(methodOop method, intptr_t UNUSED, TRAPS) { -+int MethodHandles::method_handle_entry_linkToVirtual(Method* method, intptr_t UNUSED, TRAPS) { - JavaThread *thread = (JavaThread *) THREAD; - - InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); -@@ -152,20 +152,20 @@ - - // Resolve target method by looking up in the receiver object's vtable. - intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); -- methodOop target = (methodOop) java_lang_invoke_MemberName::vmtarget(vmentry); -+ Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); - int numArgs = target->size_of_parameters(); - oop recv = STACK_OBJECT(-numArgs); -- klassOop clazz = recv->klass(); -- Klass* klass_part = clazz->klass_part(); -+ Klass* clazz = recv->klass(); -+ Klass* klass_part = InstanceKlass::cast(clazz); - klassVtable* vtable = klass_part->vtable(); -- methodOop vmtarget = vtable->method_at(vmindex); -+ Method* vmtarget = vtable->method_at(vmindex); - - invoke_target(vmtarget, THREAD); - - return 0; - } - --int MethodHandles::method_handle_entry_invalid(methodOop method, intptr_t UNUSED, TRAPS) { -+int MethodHandles::method_handle_entry_invalid(Method* method, intptr_t UNUSED, TRAPS) { - ShouldNotReachHere(); - return 0; - } -diff --git a/src/cpu/zero/vm/methodHandles_zero.hpp b/src/cpu/zero/vm/methodHandles_zero.hpp ---- a/src/cpu/zero/vm/methodHandles_zero.hpp -+++ b/src/cpu/zero/vm/methodHandles_zero.hpp -@@ -55,9 +55,9 @@ - - private: - static oop popFromStack(TRAPS); -- static void invoke_target(methodOop method, TRAPS); -- static int method_handle_entry_invokeBasic(methodOop method, intptr_t UNUSED, TRAPS); -- static int method_handle_entry_linkToStaticOrSpecial(methodOop method, intptr_t UNUSED, TRAPS); -- static int method_handle_entry_linkToVirtual(methodOop method, intptr_t UNUSED, TRAPS); -- static int method_handle_entry_linkToInterface(methodOop method, intptr_t UNUSED, TRAPS); -- static int method_handle_entry_invalid(methodOop method, intptr_t UNUSED, TRAPS); -+ static void invoke_target(Method* method, TRAPS); -+ static int method_handle_entry_invokeBasic(Method* method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_linkToStaticOrSpecial(Method* method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_linkToVirtual(Method* method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_linkToInterface(Method* method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_invalid(Method* method, intptr_t UNUSED, TRAPS); -diff --git a/src/cpu/zero/vm/relocInfo_zero.cpp b/src/cpu/zero/vm/relocInfo_zero.cpp ---- a/src/cpu/zero/vm/relocInfo_zero.cpp -+++ b/src/cpu/zero/vm/relocInfo_zero.cpp -@@ -77,3 +77,7 @@ - CodeBuffer* dst) { - ShouldNotCallThis(); - } -+ -+void metadata_Relocation::pd_fix_value(address x) { -+ ShouldNotCallThis(); -+} -diff --git a/src/cpu/zero/vm/sharedRuntime_zero.cpp b/src/cpu/zero/vm/sharedRuntime_zero.cpp ---- a/src/cpu/zero/vm/sharedRuntime_zero.cpp -+++ b/src/cpu/zero/vm/sharedRuntime_zero.cpp -@@ -78,8 +78,6 @@ - nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm, - methodHandle method, - int compile_id, -- int total_args_passed, -- int max_arg, - BasicType *sig_bt, - VMRegPair *regs, - BasicType ret_type) { -@@ -124,7 +122,7 @@ - _deopt_blob = generate_empty_deopt_blob(); - } - --SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, bool cause_return) { -+SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { - return generate_empty_safepoint_blob(); - } - -diff --git a/src/share/vm/interpreter/bytecodeInterpreter.cpp b/src/share/vm/interpreter/bytecodeInterpreter.cpp ---- a/src/share/vm/interpreter/bytecodeInterpreter.cpp -+++ b/src/share/vm/interpreter/bytecodeInterpreter.cpp -@@ -1769,7 +1769,7 @@ - - oop obj; - if ((Bytecodes::Code)opcode == Bytecodes::_getstatic) { -- Klass* k = (Klass*) cache->f1(); -+ Klass* k = cache->f1_as_klass(); - obj = k->java_mirror(); - MORE_STACK(1); // Assume single slot push - } else { -@@ -1881,7 +1881,7 @@ - --count; - } - if ((Bytecodes::Code)opcode == Bytecodes::_putstatic) { -- Klass* k = (Klass*) cache->f1(); -+ Klass* k = cache->f1_as_klass(); - obj = k->java_mirror(); - } else { - --count; -@@ -2197,6 +2197,7 @@ - } - - int index = Bytes::get_native_u4(pc+1); -+ ConstantPoolCacheEntry* cache = cp->entry_at(index); - - // We are resolved if the resolved_references field contains a non-null object (CallSite, etc.) - // This kind of CP cache entry does not need to match the flags byte, because -@@ -2209,16 +2210,16 @@ - result = THREAD->vm_result(); - } - -- methodOop method = cache->f2_as_vfinal_method(); -+ Method* method = cache->f2_as_vfinal_method(); - VERIFY_OOP(method); - - if (cache->has_appendix()) { -- SET_STACK_OBJECT(cache->f1_appendix(), 0); -+ SET_STACK_OBJECT(cache->appendix_if_resolved(constants), 0); - MORE_STACK(1); - } - - istate->set_msg(call_method); -- istate->set_callee((methodOop) method); -+ istate->set_callee(method); - istate->set_callee_entry_point(method->from_interpreted_entry()); - istate->set_bcp_advance(5); - -@@ -2234,18 +2235,19 @@ - u2 index = Bytes::get_native_u2(pc+1); - - ConstantPoolCacheEntry* cache = cp->entry_at(index); -+ ConstantPool* constants = METHOD->constants(); - - if (! cache->is_resolved((Bytecodes::Code) opcode)) { - CALL_VM(InterpreterRuntime::resolve_invokehandle(THREAD), - handle_exception); - cache = cp->entry_at(index); - } -- methodOop method = cache->f2_as_vfinal_method(); -+ Method* method = cache->f2_as_vfinal_method(); - - VERIFY_OOP(method); - - if (cache->has_appendix()) { -- SET_STACK_OBJECT(cache->f1_appendix(), 0); -+ SET_STACK_OBJECT(cache->appendix_if_resolved(constants), 0); - MORE_STACK(1); - } -
--- a/series Fri Oct 05 19:46:11 2012 +0200 +++ b/series Wed Oct 10 12:14:29 2012 +0200 @@ -1,8 +1,3 @@ linux_thread_name.patch -hotspot.patch -zero-makefile.patch -zero-segfault.patch -zero-new-math.patch -zero-meth.patch +hotspot-zero.patch psgc-bind-procs.patch -mergejdk8.patch
--- a/zero-makefile.patch Fri Oct 05 19:46:11 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,36 +0,0 @@ -# HG changeset patch -# Parent db2aaabd9e401399bd8e426afb67608e87d352cd -diff --git a/make/Makefile b/make/Makefile ---- a/make/Makefile -+++ b/make/Makefile -@@ -402,14 +402,30 @@ - ifeq ($(JVM_VARIANT_ZEROSHARK), true) - $(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_DIR)/%.$(LIBRARY_SUFFIX) - $(install-file) -+ $(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo): $(SHARK_DIR)/%.debuginfo -+ $(install-file) -+ $(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(SHARK_DIR)/%.diz -+ $(install-file) - $(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_DIR)/%.$(LIBRARY_SUFFIX) - $(install-file) -+ $(EXPORT_SERVER_DIR)/%.debuginfo: $(SHARK_DIR)/%.debuginfo -+ $(install-file) -+ $(EXPORT_SERVER_DIR)/%.diz: $(SHARK_DIR)/%.diz -+ $(install-file) - endif - ifeq ($(JVM_VARIANT_ZERO), true) - $(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_DIR)/%.$(LIBRARY_SUFFIX) - $(install-file) -+ $(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(ZERO_DIR)/%.debuginfo -+ $(install-file) -+ $(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(ZERO_DIR)/%.diz -+ $(install-file) - $(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_DIR)/%.$(LIBRARY_SUFFIX) - $(install-file) -+ $(EXPORT_SERVER_DIR)/%.debuginfo: $(ZERO_DIR)/%.debuginfo -+ $(install-file) -+ $(EXPORT_SERVER_DIR)/%.diz: $(ZERO_DIR)/%.diz -+ $(install-file) - endif - endif -
--- a/zero-meth.patch Fri Oct 05 19:46:11 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1430 +0,0 @@ -# HG changeset patch -# Parent fbf3e1b8b4e973d91214d98d76a1903963a93c1b - -diff --git a/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp b/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp ---- a/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp -+++ b/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp -@@ -31,12 +31,17 @@ - return _masm; - } - -- protected: -- address generate_entry(address entry_point) { -- ZeroEntry *entry = (ZeroEntry *) assembler()->pc(); -- assembler()->advance(sizeof(ZeroEntry)); -+ public: -+ static address generate_entry_impl(MacroAssembler* masm, address entry_point) { -+ ZeroEntry *entry = (ZeroEntry *) masm->pc(); -+ masm->advance(sizeof(ZeroEntry)); - entry->set_entry_point(entry_point); - return (address) entry; - } - -+ protected: -+ address generate_entry(address entry_point) { -+ return generate_entry_impl(assembler(), entry_point); -+ } -+ - #endif // CPU_ZERO_VM_CPPINTERPRETERGENERATOR_ZERO_HPP -diff --git a/src/cpu/zero/vm/cppInterpreter_zero.cpp b/src/cpu/zero/vm/cppInterpreter_zero.cpp ---- a/src/cpu/zero/vm/cppInterpreter_zero.cpp -+++ b/src/cpu/zero/vm/cppInterpreter_zero.cpp -@@ -182,25 +182,6 @@ - method, istate->osr_entry(), istate->osr_buf(), THREAD); - return; - } -- else if (istate->msg() == BytecodeInterpreter::call_method_handle) { -- oop method_handle = istate->callee(); -- -- // Trim back the stack to put the parameters at the top -- stack->set_sp(istate->stack() + 1); -- -- // Make the call -- process_method_handle(method_handle, THREAD); -- fixup_after_potential_safepoint(); -- -- // Convert the result -- istate->set_stack(stack->sp() - 1); -- -- // Restore the stack -- stack->set_sp(istate->stack_limit() + 1); -- -- // Resume the interpreter -- istate->set_msg(BytecodeInterpreter::method_resume); -- } - else { - ShouldNotReachHere(); - } -@@ -537,35 +518,35 @@ - if (entry->is_volatile()) { - switch (entry->flag_state()) { - case ctos: -- SET_LOCALS_INT(object->char_field_acquire(entry->f2()), 0); -+ SET_LOCALS_INT(object->char_field_acquire(entry->f2_as_index()), 0); - break; - - case btos: -- SET_LOCALS_INT(object->byte_field_acquire(entry->f2()), 0); -+ SET_LOCALS_INT(object->byte_field_acquire(entry->f2_as_index()), 0); - break; - - case stos: -- SET_LOCALS_INT(object->short_field_acquire(entry->f2()), 0); -+ SET_LOCALS_INT(object->short_field_acquire(entry->f2_as_index()), 0); - break; - - case itos: -- SET_LOCALS_INT(object->int_field_acquire(entry->f2()), 0); -+ SET_LOCALS_INT(object->int_field_acquire(entry->f2_as_index()), 0); - break; - - case ltos: -- SET_LOCALS_LONG(object->long_field_acquire(entry->f2()), 0); -+ SET_LOCALS_LONG(object->long_field_acquire(entry->f2_as_index()), 0); - break; - - case ftos: -- SET_LOCALS_FLOAT(object->float_field_acquire(entry->f2()), 0); -+ SET_LOCALS_FLOAT(object->float_field_acquire(entry->f2_as_index()), 0); - break; - - case dtos: -- SET_LOCALS_DOUBLE(object->double_field_acquire(entry->f2()), 0); -+ SET_LOCALS_DOUBLE(object->double_field_acquire(entry->f2_as_index()), 0); - break; - - case atos: -- SET_LOCALS_OBJECT(object->obj_field_acquire(entry->f2()), 0); -+ SET_LOCALS_OBJECT(object->obj_field_acquire(entry->f2_as_index()), 0); - break; - - default: -@@ -575,35 +556,35 @@ - else { - switch (entry->flag_state()) { - case ctos: -- SET_LOCALS_INT(object->char_field(entry->f2()), 0); -+ SET_LOCALS_INT(object->char_field(entry->f2_as_index()), 0); - break; - - case btos: -- SET_LOCALS_INT(object->byte_field(entry->f2()), 0); -+ SET_LOCALS_INT(object->byte_field(entry->f2_as_index()), 0); - break; - - case stos: -- SET_LOCALS_INT(object->short_field(entry->f2()), 0); -+ SET_LOCALS_INT(object->short_field(entry->f2_as_index()), 0); - break; - - case itos: -- SET_LOCALS_INT(object->int_field(entry->f2()), 0); -+ SET_LOCALS_INT(object->int_field(entry->f2_as_index()), 0); - break; - - case ltos: -- SET_LOCALS_LONG(object->long_field(entry->f2()), 0); -+ SET_LOCALS_LONG(object->long_field(entry->f2_as_index()), 0); - break; - - case ftos: -- SET_LOCALS_FLOAT(object->float_field(entry->f2()), 0); -+ SET_LOCALS_FLOAT(object->float_field(entry->f2_as_index()), 0); - break; - - case dtos: -- SET_LOCALS_DOUBLE(object->double_field(entry->f2()), 0); -+ SET_LOCALS_DOUBLE(object->double_field(entry->f2_as_index()), 0); - break; - - case atos: -- SET_LOCALS_OBJECT(object->obj_field(entry->f2()), 0); -+ SET_LOCALS_OBJECT(object->obj_field(entry->f2_as_index()), 0); - break; - - default: -@@ -631,827 +612,6 @@ - return 0; - } - --int CppInterpreter::method_handle_entry(Method* method, -- intptr_t UNUSED, TRAPS) { -- JavaThread *thread = (JavaThread *) THREAD; -- ZeroStack *stack = thread->zero_stack(); -- int argument_slots = method->size_of_parameters(); -- int result_slots = type2size[result_type_of(method)]; -- intptr_t *vmslots = stack->sp(); -- intptr_t *unwind_sp = vmslots + argument_slots; -- -- // Find the MethodType -- address p = (address) method; -- for (jint* pc = method->method_type_offsets_chain(); (*pc) != -1; pc++) { -- p = *(address*)(p + (*pc)); -- } -- oop method_type = (oop) p; -- -- // The MethodHandle is in the slot after the arguments -- int num_vmslots = argument_slots - 1; -- oop method_handle = VMSLOTS_OBJECT(num_vmslots); -- -- // InvokeGeneric requires some extra shuffling -- oop mhtype = java_lang_invoke_MethodHandle::type(method_handle); -- bool is_exact = mhtype == method_type; -- if (!is_exact) { -- if (true || // FIXME -- method->intrinsic_id() == vmIntrinsics::_invokeExact) { -- CALL_VM_NOCHECK_NOFIX( -- SharedRuntime::throw_WrongMethodTypeException( -- thread, method_type, mhtype)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- stack->set_sp(unwind_sp); -- return 0; -- } -- assert(method->intrinsic_id() == vmIntrinsics::_invokeGeneric, "should be"); -- -- // Load up an adapter from the calling type -- // NB the x86 code for this (in methodHandles_x86.cpp, search for -- // "genericInvoker") is really really odd. I'm hoping it's trying -- // to accomodate odd VM/class library combinations I can ignore. -- oop adapter = NULL; //FIXME: load the adapter from the CP cache -- IF (adapter == NULL) { -- CALL_VM_NOCHECK_NOFIX( -- SharedRuntime::throw_WrongMethodTypeException( -- thread, method_type, mhtype)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- stack->set_sp(unwind_sp); -- return 0; -- } -- -- // Adapters are shared among form-families of method-type. The -- // type being called is passed as a trusted first argument so that -- // the adapter knows the actual types of its arguments and return -- // values. -- insert_vmslots(num_vmslots + 1, 1, THREAD); -- if (HAS_PENDING_EXCEPTION) { -- // NB all oops trashed! -- stack->set_sp(unwind_sp); -- return 0; -- } -- -- vmslots = stack->sp(); -- num_vmslots++; -- SET_VMSLOTS_OBJECT(method_type, num_vmslots); -- -- method_handle = adapter; -- } -- -- CPPINT_DEBUG( tty->print_cr( "Process method_handle sp: 0x%x unwind_sp: 0x%x result_slots: %d.", \ -- stack->sp(), unwind_sp, result_slots ); ) -- -- // Start processing -- process_method_handle(method_handle, THREAD); -- if (HAS_PENDING_EXCEPTION) -- result_slots = 0; -- -- // If this is an invokeExact then the eventual callee will not -- // have unwound the method handle argument so we have to do it. -- // If a result is being returned the it will be above the method -- // handle argument we're unwinding. -- if (is_exact) { -- intptr_t result[2]; -- for (int i = 0; i < result_slots; i++) -- result[i] = stack->pop(); -- stack->pop(); -- for (int i = result_slots - 1; i >= 0; i--) -- stack->push(result[i]); -- } -- -- // Check -- CPPINT_DEBUG( tty->print_cr( "Exiting method_handle_entry, sp: 0x%x unwind_sp: 0x%x result_slots: %d.", \ -- stack->sp(), unwind_sp, result_slots ); ) -- assert(stack->sp() == unwind_sp - result_slots, "should be"); -- -- // No deoptimized frames on the stack -- return 0; --} -- --void CppInterpreter::process_method_handle(oop method_handle, TRAPS) { -- -- JavaThread *thread = (JavaThread *) THREAD; -- ZeroStack *stack = thread->zero_stack(); -- intptr_t *vmslots = stack->sp(); -- -- bool direct_to_method = false; -- BasicType src_rtype = T_ILLEGAL; -- BasicType dst_rtype = T_ILLEGAL; -- -- MethodHandleEntry *entry = -- java_lang_invoke_MethodHandle::vmentry(method_handle); -- MethodHandles::EntryKind entry_kind = -- (MethodHandles::EntryKind) (((intptr_t) entry) & 0xffffffff); -- -- Method* method = NULL; -- switch (entry_kind) { -- case MethodHandles::_invokestatic_mh: -- direct_to_method = true; -- break; -- -- case MethodHandles::_invokespecial_mh: -- case MethodHandles::_invokevirtual_mh: -- case MethodHandles::_invokeinterface_mh: -- { -- oop receiver = -- VMSLOTS_OBJECT( -- java_lang_invoke_MethodHandle::vmslots(method_handle) - 1); -- if (receiver == NULL) { -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, vmSymbols::java_lang_NullPointerException())); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- if (entry_kind != MethodHandles::_invokespecial_mh) { -- intptr_t index = java_lang_invoke_DirectMethodHandle::vmindex(method_handle); -- InstanceKlass* rcvrKlass = -- (InstanceKlass *) receiver->klass(); -- if (entry_kind == MethodHandles::_invokevirtual_mh) { -- method = (Method*) rcvrKlass->start_of_vtable()[index]; -- } -- else { -- oop iclass = java_lang_invoke_MethodHandle::next_target(method_handle); -- itableOffsetEntry* ki = -- (itableOffsetEntry *) rcvrKlass->start_of_itable(); -- int i, length = rcvrKlass->itable_length(); -- for (i = 0; i < length; i++, ki++ ) { -- if (ki->interface_klass() == iclass) -- break; -- } -- if (i == length) { -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, vmSymbols::java_lang_IncompatibleClassChangeError())); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- itableMethodEntry* im = ki->first_method_entry(receiver->klass()); -- method = im[index].method(); -- if (method == NULL) { -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, vmSymbols::java_lang_AbstractMethodError())); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- } -- } -- } -- direct_to_method = true; -- break; -- -- case MethodHandles::_bound_ref_direct_mh: -- case MethodHandles::_bound_int_direct_mh: -- case MethodHandles::_bound_long_direct_mh: -- direct_to_method = true; -- // fall through -- case MethodHandles::_bound_ref_mh: -- case MethodHandles::_bound_int_mh: -- case MethodHandles::_bound_long_mh: -- { -- // BasicType arg_type = T_ILLEGAL; -- // int arg_mask = -1; -- // int arg_slots = -1; -- // MethodHandles::get_ek_bound_mh_info( -- // entry_kind, arg_type, arg_mask, arg_slots); -- BasicType arg_type = MethodHandles::ek_bound_mh_arg_type(entry_kind); -- int arg_mask = 0; -- int arg_slots = type2size[arg_type];; -- -- int arg_slot = -- java_lang_invoke_BoundMethodHandle::vmargslot(method_handle); -- -- // Create the new slot(s) -- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); -- insert_vmslots(arg_slot, arg_slots, THREAD); -- if (HAS_PENDING_EXCEPTION) { -- // all oops trashed -- stack->set_sp(unwind_sp); -- return; -- } -- vmslots = stack->sp(); -- -- // Store bound argument into new stack slot -- oop arg = java_lang_invoke_BoundMethodHandle::argument(method_handle); -- if (arg_type == T_OBJECT) { -- assert(arg_slots == 1, "should be"); -- SET_VMSLOTS_OBJECT(arg, arg_slot); -- } -- else { -- jvalue arg_value; -- arg_type = java_lang_boxing_object::get_value(arg, &arg_value); -- switch (arg_type) { -- case T_BOOLEAN: -- SET_VMSLOTS_INT(arg_value.z, arg_slot); -- break; -- case T_CHAR: -- SET_VMSLOTS_INT(arg_value.c, arg_slot); -- break; -- case T_BYTE: -- SET_VMSLOTS_INT(arg_value.b, arg_slot); -- break; -- case T_SHORT: -- SET_VMSLOTS_INT(arg_value.s, arg_slot); -- break; -- case T_INT: -- SET_VMSLOTS_INT(arg_value.i, arg_slot); -- break; -- case T_FLOAT: -- SET_VMSLOTS_FLOAT(arg_value.f, arg_slot); -- break; -- case T_LONG: -- SET_VMSLOTS_LONG(arg_value.j, arg_slot + 1); -- break; -- case T_DOUBLE: -- SET_VMSLOTS_DOUBLE(arg_value.d, arg_slot + 1); -- break; -- default: -- tty->print_cr("unhandled type %s", type2name(arg_type)); -- ShouldNotReachHere(); -- } -- } -- } -- break; -- -- case MethodHandles::_adapter_retype_only: -- case MethodHandles::_adapter_retype_raw: -- src_rtype = result_type_of_handle( -- java_lang_invoke_MethodHandle::next_target(method_handle)); -- dst_rtype = result_type_of_handle(method_handle); -- break; -- -- case MethodHandles::_adapter_check_cast: -- { -- int arg_slot = -- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -- oop arg = VMSLOTS_OBJECT(arg_slot); -- if (arg != NULL) { -- Klass* objKlassOop = arg->klass(); -- Klass* klassOf = java_lang_Class::as_Klass( -- java_lang_invoke_AdapterMethodHandle::argument(method_handle)); -- -- if (objKlassOop != klassOf && -- !objKlassOop->is_subtype_of(klassOf)) { -- ResourceMark rm(THREAD); -- const char* objName = Klass::cast(objKlassOop)->external_name(); -- const char* klassName = Klass::cast(klassOf)->external_name(); -- char* message = SharedRuntime::generate_class_cast_message( -- objName, klassName); -- -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, vmSymbols::java_lang_ClassCastException(), message)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- } -- } -- break; -- -- case MethodHandles::_adapter_dup_args: -- { -- int arg_slot = -- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -- int conv = -- java_lang_invoke_AdapterMethodHandle::conversion(method_handle); -- int num_slots = -MethodHandles::adapter_conversion_stack_move(conv); -- assert(num_slots > 0, "should be"); -- -- // Create the new slot(s) -- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); -- stack->overflow_check(num_slots, THREAD); -- if (HAS_PENDING_EXCEPTION) { -- // all oops trashed -- stack->set_sp(unwind_sp); -- return; -- } -- -- // Duplicate the arguments -- for (int i = num_slots - 1; i >= 0; i--) -- stack->push(*VMSLOTS_SLOT(arg_slot + i)); -- -- vmslots = stack->sp(); // unused, but let the compiler figure that out -- } -- break; -- -- case MethodHandles::_adapter_drop_args: -- { -- int arg_slot = -- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -- int conv = -- java_lang_invoke_AdapterMethodHandle::conversion(method_handle); -- int num_slots = MethodHandles::adapter_conversion_stack_move(conv); -- assert(num_slots > 0, "should be"); -- -- remove_vmslots(arg_slot, num_slots, THREAD); // doesn't trap -- vmslots = stack->sp(); // unused, but let the compiler figure that out -- } -- break; -- -- case MethodHandles::_adapter_opt_swap_1: -- case MethodHandles::_adapter_opt_swap_2: -- case MethodHandles::_adapter_opt_rot_1_up: -- case MethodHandles::_adapter_opt_rot_1_down: -- case MethodHandles::_adapter_opt_rot_2_up: -- case MethodHandles::_adapter_opt_rot_2_down: -- { -- int arg1 = -- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -- int conv = -- java_lang_invoke_AdapterMethodHandle::conversion(method_handle); -- int arg2 = MethodHandles::adapter_conversion_vminfo(conv); -- -- // int swap_bytes = 0, rotate = 0; -- // MethodHandles::get_ek_adapter_opt_swap_rot_info( -- // entry_kind, swap_bytes, rotate); -- int swap_slots = MethodHandles::ek_adapter_opt_swap_slots(entry_kind); -- int rotate = MethodHandles::ek_adapter_opt_swap_mode(entry_kind); -- int swap_bytes = swap_slots * Interpreter::stackElementSize; -- swap_slots = swap_bytes >> LogBytesPerWord; -- -- intptr_t tmp; -- switch (rotate) { -- case 0: // swap -- for (int i = 0; i < swap_slots; i++) { -- tmp = *VMSLOTS_SLOT(arg1 + i); -- SET_VMSLOTS_SLOT(VMSLOTS_SLOT(arg2 + i), arg1 + i); -- SET_VMSLOTS_SLOT(&tmp, arg2 + i); -- } -- break; -- -- case 1: // up -- assert(arg1 - swap_slots > arg2, "should be"); -- -- tmp = *VMSLOTS_SLOT(arg1); -- for (int i = arg1 - swap_slots; i >= arg2; i--) -- SET_VMSLOTS_SLOT(VMSLOTS_SLOT(i), i + swap_slots); -- SET_VMSLOTS_SLOT(&tmp, arg2); -- -- break; -- -- case -1: // down -- assert(arg2 - swap_slots > arg1, "should be"); -- -- tmp = *VMSLOTS_SLOT(arg1); -- for (int i = arg1 + swap_slots; i <= arg2; i++) -- SET_VMSLOTS_SLOT(VMSLOTS_SLOT(i), i - swap_slots); -- SET_VMSLOTS_SLOT(&tmp, arg2); -- break; -- -- default: -- ShouldNotReachHere(); -- } -- } -- break; -- -- case MethodHandles::_adapter_opt_i2l: -- { -- int arg_slot = -- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -- int arg = VMSLOTS_INT(arg_slot); -- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); -- insert_vmslots(arg_slot, 1, THREAD); -- if (HAS_PENDING_EXCEPTION) { -- // all oops trashed -- stack->set_sp(unwind_sp); -- return; -- } -- vmslots = stack->sp(); -- arg_slot++; -- SET_VMSLOTS_LONG(arg, arg_slot); -- } -- break; -- -- case MethodHandles::_adapter_opt_unboxi: -- case MethodHandles::_adapter_opt_unboxl: -- { -- int arg_slot = -- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -- oop arg = VMSLOTS_OBJECT(arg_slot); -- jvalue arg_value; -- if (arg == NULL) { -- // queue a nullpointer exception for the caller -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, vmSymbols::java_lang_NullPointerException())); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- BasicType arg_type = java_lang_boxing_object::get_value(arg, &arg_value); -- if (arg_type == T_LONG || arg_type == T_DOUBLE) { -- intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); -- insert_vmslots(arg_slot, 1, THREAD); -- if (HAS_PENDING_EXCEPTION) { -- // all oops trashed -- stack->set_sp(unwind_sp); -- return; -- } -- vmslots = stack->sp(); -- arg_slot++; -- } -- switch (arg_type) { -- case T_BOOLEAN: -- SET_VMSLOTS_INT(arg_value.z, arg_slot); -- break; -- case T_CHAR: -- SET_VMSLOTS_INT(arg_value.c, arg_slot); -- break; -- case T_BYTE: -- SET_VMSLOTS_INT(arg_value.b, arg_slot); -- break; -- case T_SHORT: -- SET_VMSLOTS_INT(arg_value.s, arg_slot); -- break; -- case T_INT: -- SET_VMSLOTS_INT(arg_value.i, arg_slot); -- break; -- case T_FLOAT: -- SET_VMSLOTS_FLOAT(arg_value.f, arg_slot); -- break; -- case T_LONG: -- SET_VMSLOTS_LONG(arg_value.j, arg_slot); -- break; -- case T_DOUBLE: -- SET_VMSLOTS_DOUBLE(arg_value.d, arg_slot); -- break; -- default: -- tty->print_cr("unhandled type %s", type2name(arg_type)); -- ShouldNotReachHere(); -- } -- } -- break; -- -- case MethodHandles::_adapter_opt_spread_0: -- case MethodHandles::_adapter_opt_spread_1_ref: -- case MethodHandles::_adapter_opt_spread_2_ref: -- case MethodHandles::_adapter_opt_spread_3_ref: -- case MethodHandles::_adapter_opt_spread_4_ref: -- case MethodHandles::_adapter_opt_spread_5_ref: -- case MethodHandles::_adapter_opt_spread_ref: -- case MethodHandles::_adapter_opt_spread_byte: -- case MethodHandles::_adapter_opt_spread_char: -- case MethodHandles::_adapter_opt_spread_short: -- case MethodHandles::_adapter_opt_spread_int: -- case MethodHandles::_adapter_opt_spread_long: -- case MethodHandles::_adapter_opt_spread_float: -- case MethodHandles::_adapter_opt_spread_double: -- { -- -- // spread an array out into a group of arguments -- -- int arg_slot = -- java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); -- // Fetch the argument, which we will cast to the required array type. -- oop arg = VMSLOTS_OBJECT(arg_slot); -- -- BasicType elem_type = -- MethodHandles::ek_adapter_opt_spread_type(entry_kind); -- int elem_slots = -- type2size[elem_type]; // 1 or 2 -- int array_slots = -- 1; // array is always a T_OBJECT -- int length_offset = -- arrayOopDesc::length_offset_in_bytes(); -- int elem0_offset = -- arrayOopDesc::base_offset_in_bytes(elem_type); -- int length_constant = -- MethodHandles::ek_adapter_opt_spread_count(entry_kind); -- int array_length = 0; -- void *array_elem0 = NULL; -- -- CPPINT_DEBUG( tty->print_cr( \ -- "ENTERING _adapter_opt_spread: %s %d %d 0x%x 0x%x", \ -- type2name(elem_type), arg_slot, length_constant, (char *)arg, stack->sp() ); ) -- -- // If the spread count is -1, the length is "variable" ie controlled -- // by the array length. -- // See ek_adapter_opt_spread_count in methodHandles.hpp -- // If array lenth is 0 or spread count is 0 , we will remove the argslot. -- -- bool length_can_be_zero = (length_constant == 0); -- if (length_constant < 0) { -- // some adapters with variable length must handle the zero case -- if (!OptimizeMethodHandles || -- elem_type != T_OBJECT) -- length_can_be_zero = true; -- } -- -- if (arg == NULL) { -- CPPINT_DEBUG( tty->print_cr( \ -- "arg NULL implies Array_length == 0, remove slot." ); ) -- // remove arg slot -- remove_vmslots(arg_slot, 1, THREAD); // doesn't trap -- vmslots = stack->sp(); // unused, but let the compiler figure that out -- CPPINT_DEBUG( tty->print_cr( \ -- " >> Would LEAVE _adapter_opt_spread with NPE." ); ) --#ifdef _NOT_DEF_ -- // queue a nullpointer exception for the caller -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, -- vmSymbols::java_lang_NullPointerException())); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; --#endif -- } else { // (arg != NULL) -- klassOop objKlassOop = arg->klass(); -- klassOop klassOf = java_lang_Class::as_klassOop( -- java_lang_invoke_AdapterMethodHandle::argument(method_handle)); -- -- if (objKlassOop != klassOf && -- !objKlassOop->klass_part()->is_subtype_of(klassOf)) { -- CPPINT_DEBUG( tty->print_cr( \ -- "CLASS CAST ERROR #1 in _adapter_opt_spread." ); ) -- ResourceMark rm(THREAD); -- const char* objName = Klass::cast(objKlassOop)->external_name(); -- const char* klassName = Klass::cast(klassOf)->external_name(); -- char* message = SharedRuntime::generate_class_cast_message( -- objName, klassName); -- -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, -- vmSymbols::java_lang_ClassCastException(), message)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- -- // Check the array type. -- -- klassOop array_klass_oop = NULL; -- BasicType array_type = java_lang_Class::as_BasicType( -- java_lang_invoke_AdapterMethodHandle::argument(method_handle), -- &array_klass_oop); -- arrayKlassHandle array_klass(THREAD, array_klass_oop); -- -- assert(array_type == T_OBJECT, ""); -- assert(Klass::cast(array_klass_oop)->oop_is_array(), ""); -- if (!(array_type == T_OBJECT) || -- !(Klass::cast(array_klass_oop)->oop_is_array())) { -- CPPINT_DEBUG( tty->print_cr( \ -- "CLASS CAST ERROR #2 not an array in _adapter_opt_spread." ); ) -- ResourceMark rm(THREAD); -- const char* objName = Klass::cast(objKlassOop)->external_name(); -- const char* klassName = Klass::cast(klassOf)->external_name(); -- char* message = SharedRuntime::generate_class_cast_message( -- objName, klassName); -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, -- vmSymbols::java_lang_ClassCastException(), message)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- -- klassOop element_klass_oop = NULL; -- BasicType element_type = -- java_lang_Class::as_BasicType(array_klass->component_mirror(), -- &element_klass_oop); -- KlassHandle element_klass(THREAD, element_klass_oop); -- if ((elem_type != T_OBJECT) && (elem_type != element_type)) { -- CPPINT_DEBUG( tty->print_cr( \ -- "CLASS CAST ERROR #3 invalid type %s != %s in _adapter_opt_spread.", \ -- type2name(elem_type), type2name(element_type) ); ) -- ResourceMark rm(THREAD); -- const char* objName = Klass::cast(objKlassOop)->external_name(); -- const char* klassName = Klass::cast(klassOf)->external_name(); -- char* message = SharedRuntime::generate_class_cast_message( -- objName, klassName); -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, -- vmSymbols::java_lang_ClassCastException(), message)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- -- array_length = arrayOop(arg)->length(); -- -- // Check the required length. -- if (length_constant > 0) { // must match ? -- if ( array_length != length_constant ) { -- CPPINT_DEBUG( tty->print_cr( \ -- "ARRY INDEX ERROR #4 invalid array length in _adapter_opt_spread." ); ) -- //fixme ArrayIndexOutOfBoundsException ? -- ResourceMark rm(THREAD); -- const char* objName = Klass::cast(objKlassOop)->external_name(); -- const char* klassName = Klass::cast(klassOf)->external_name(); -- char* message = SharedRuntime::generate_class_cast_message( -- objName, klassName); -- -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, -- vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- // use array_length ? -- } else { // length_constant == [ -1 or 0 ] -- if ( (array_length > 0) || length_can_be_zero ) { -- // use array_length. -- } else { // array_length 0 and not length_can_be_zero -- CPPINT_DEBUG( tty->print_cr( \ -- "ARRY INDEX ERROR #5 arry length 0 in _adapter_opt_spread." ); ) -- //fixme ArrayIndexOutOfBoundsException ? -- ResourceMark rm(THREAD); -- const char* objName = Klass::cast(objKlassOop)->external_name(); -- const char* klassName = Klass::cast(klassOf)->external_name(); -- char* message = SharedRuntime::generate_class_cast_message( -- objName, klassName); -- -- stack->set_sp(calculate_unwind_sp(stack, method_handle)); -- CALL_VM_NOCHECK_NOFIX( -- throw_exception( -- thread, -- vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message)); -- // NB all oops trashed! -- assert(HAS_PENDING_EXCEPTION, "should do"); -- return; -- } -- } -- -- // Array length checked out. Now insert any required arg slots. -- // array_length - 1 more slots if array_length > 0 -- // otherwise if array_length == 0 remove arg_slot. -- -- if ( array_length > 0 ) { -- int slots = (array_length * elem_slots) - 1; -- CPPINT_DEBUG( tty->print_cr( \ -- "array_length %d %d slots needed in _adapter_opt_spread.",\ -- array_length, slots); ) -- debug_only(if (elem_slots == 2) \ -- assert ((slots % 2 == 1)," bad slots calc")); -- if ( slots > 0 ) { -- intptr_t *unwind_sp = -- calculate_unwind_sp(stack, method_handle); -- insert_vmslots(arg_slot, slots, THREAD); -- if (HAS_PENDING_EXCEPTION) { -- // all oops trashed -- stack->set_sp(unwind_sp); -- return; -- } -- } -- vmslots = stack->sp(); -- arg_slot += slots; -- -- array_elem0 = arrayOop(arg)->base(elem_type); -- -- // Copy from the array to the new arg slots. -- // [from native : Beware: Arguments that are shallow -- // on the stack are deep in the array, -- // and vice versa. So a downward-growing stack (the usual) -- // has to be copied elementwise in reverse order -- // from the source array.] -- -- void * array_elem = array_elem0; -- int top_slot = arg_slot; -- -- debug_only(if (elem_slots == 2) \ -- assert ((((ulong)(char *)&vmslots[top_slot]) % \ -- (u_int)type2aelembytes(elem_type) == 0), \ -- " bad arg alignment")); -- -- CPPINT_DEBUG( tty->print_cr( \ -- "BEGIN ARRY LOOP %d %d 0x%x 0x%x _adapter_opt_spread.",\ -- array_length, top_slot, &vmslots[top_slot], array_elem ); ) -- -- for (int index = 0; index < array_length; index++) { -- switch (elem_type) { -- case T_BYTE: -- SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -- break; -- case T_CHAR: -- SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -- break; -- case T_SHORT: -- SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -- break; -- case T_INT: -- SET_VMSLOTS_INT(*(jint*)array_elem, top_slot); -- break; -- case T_FLOAT: -- SET_VMSLOTS_FLOAT(*(jfloat*)array_elem,top_slot); -- break; -- case T_LONG: -- SET_VMSLOTS_LONG(*(jlong*)array_elem, top_slot); -- break; -- case T_DOUBLE: -- SET_VMSLOTS_DOUBLE(*(jdouble*)array_elem, top_slot); -- break; -- case T_OBJECT: -- SET_VMSLOTS_OBJECT(*(oopDesc**)array_elem, top_slot); -- break; -- default: -- tty->print_cr("unhandled type %s", type2name(elem_type)); -- ShouldNotReachHere(); -- } -- array_elem = (void*)((char *)array_elem + -- type2aelembytes(element_type)); -- top_slot -= elem_slots; -- } -- arg_slot++; -- } -- } -- if ((array_length == 0) && (arg != NULL)) { -- CPPINT_DEBUG( tty->print_cr( \ -- "Array_length == 0, will remove slot." ); ) -- // remove arg slot -- remove_vmslots(arg_slot, 1, THREAD); // doesn't trap -- // unused, but let the compiler figure that out -- vmslots = stack->sp(); -- // -- } -- CPPINT_DEBUG( tty->print_cr( \ -- "LEAVING _adapter_opt_spread: %s 0x%x 0x%x \n", \ -- type2name(elem_type), (char *)arg, (char *)stack->sp() ); ) -- } -- break; -- default: -- tty->print_cr("unhandled entry_kind %s", -- MethodHandles::entry_name(entry_kind)); -- ShouldNotReachHere(); -- } -- -- -- // Continue along the chain -- if (direct_to_method) { -- if (method == NULL) { -- method = -- (Method*) java_lang_invoke_MethodHandle::vmtarget(method_handle); -- } -- address entry_point = method->from_interpreted_entry(); -- Interpreter::invoke_method(method, entry_point, THREAD); -- } -- else { -- process_method_handle( -- java_lang_invoke_MethodHandle::next_target(method_handle), THREAD); -- } -- // NB all oops now trashed -- -- // Adapt the result type, if necessary -- if (src_rtype != dst_rtype && !HAS_PENDING_EXCEPTION) { -- switch (dst_rtype) { -- case T_VOID: -- for (int i = 0; i < type2size[src_rtype]; i++) -- stack->pop(); -- return; -- -- case T_INT: -- switch (src_rtype) { -- case T_VOID: -- stack->overflow_check(1, CHECK); -- stack->push(0); -- return; -- -- case T_BOOLEAN: -- case T_CHAR: -- case T_BYTE: -- case T_SHORT: -- return; -- } -- // INT results sometimes need narrowing -- case T_BOOLEAN: -- case T_CHAR: -- case T_BYTE: -- case T_SHORT: -- switch (src_rtype) { -- case T_INT: -- return; -- } -- } -- -- tty->print_cr("unhandled conversion:"); -- tty->print_cr("src_rtype = %s", type2name(src_rtype)); -- tty->print_cr("dst_rtype = %s", type2name(dst_rtype)); -- ShouldNotReachHere(); -- } -- CPPINT_DEBUG( tty->print_cr( "LEAVING %s\n",MethodHandles::entry_name(entry_kind) ); ) --} -- - // The new slots will be inserted before slot insert_before. - // Slots < insert_before will have the same slot number after the insert. - // Slots >= insert_before will become old_slot + num_slots. -@@ -1693,10 +853,6 @@ - entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry(); - break; - -- case Interpreter::method_handle: -- entry_point = ((InterpreterGenerator*) this)->generate_method_handle_entry(); -- break; -- - case Interpreter::java_lang_math_sin: - case Interpreter::java_lang_math_cos: - case Interpreter::java_lang_math_tan: -diff --git a/src/cpu/zero/vm/cppInterpreter_zero.hpp b/src/cpu/zero/vm/cppInterpreter_zero.hpp ---- a/src/cpu/zero/vm/cppInterpreter_zero.hpp -+++ b/src/cpu/zero/vm/cppInterpreter_zero.hpp -@@ -36,7 +36,6 @@ - static int native_entry(Method* method, intptr_t UNUSED, TRAPS); - static int accessor_entry(Method* method, intptr_t UNUSED, TRAPS); - static int empty_entry(Method* method, intptr_t UNUSED, TRAPS); -- static int method_handle_entry(Method* method, intptr_t UNUSED, TRAPS); - - public: - // Main loop of normal_entry -@@ -44,7 +43,6 @@ - - private: - // Helpers for method_handle_entry -- static void process_method_handle(oop method_handle, TRAPS); - static void insert_vmslots(int insert_before, int num_slots, TRAPS); - static void remove_vmslots(int first_slot, int num_slots, TRAPS); - static BasicType result_type_of_handle(oop method_handle); -diff --git a/src/cpu/zero/vm/interpreterGenerator_zero.hpp b/src/cpu/zero/vm/interpreterGenerator_zero.hpp ---- a/src/cpu/zero/vm/interpreterGenerator_zero.hpp -+++ b/src/cpu/zero/vm/interpreterGenerator_zero.hpp -@@ -30,6 +30,9 @@ - // - friend class AbstractInterpreterGenerator; - -+ public: -+ static address generate_method_entry_impl(AbstractInterpreter::MethodKind kind); -+ - private: - address generate_normal_entry(bool synchronized); - address generate_native_entry(bool synchronized); -diff --git a/src/cpu/zero/vm/methodHandles_zero.cpp b/src/cpu/zero/vm/methodHandles_zero.cpp ---- a/src/cpu/zero/vm/methodHandles_zero.cpp -+++ b/src/cpu/zero/vm/methodHandles_zero.cpp -@@ -24,30 +24,13 @@ - */ - - #include "precompiled.hpp" -+#include "interpreter/interpreterGenerator.hpp" - #include "interpreter/interpreter.hpp" - #include "memory/allocation.inline.hpp" - #include "prims/methodHandles.hpp" - - #define __ _masm-> - --int MethodHandles::adapter_conversion_ops_supported_mask() { -- return ((1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS) -- |(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) -- ); --} -- --void MethodHandles::generate_method_handle_stub(MacroAssembler* masm, -- MethodHandles::EntryKind ek) { -- init_entry(ek, (MethodHandleEntry *) ek); --} - void MethodHandles::RicochetFrame::generate_ricochet_blob(MacroAssembler* _masm, - // output params: - int* bounce_offset, -@@ -59,54 +42,154 @@ - (*exception_offset) = __ pc() - start; - } - --frame MethodHandles::ricochet_frame_sender(const frame& fr, RegisterMap *map) { -- //RicochetFrame* f = RicochetFrame::from_frame(fr); -- // Cf. is_interpreted_frame path of frame::sender -- // intptr_t* younger_sp = fr.sp(); -- // intptr_t* sp = fr.sender_sp(); -- // return frame(sp, younger_sp, this_frame_adjusted_stack); -- ShouldNotCallThis(); -+void MethodHandles::invoke_target(methodOop method, TRAPS) { -+ -+ JavaThread *thread = (JavaThread *) THREAD; -+ ZeroStack *stack = thread->zero_stack(); -+ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); -+ interpreterState istate = frame->interpreter_state(); -+ -+ // Trim back the stack to put the parameters at the top -+ stack->set_sp(istate->stack() + 1); -+ -+ Interpreter::invoke_method(method, method->from_interpreted_entry(), THREAD); -+ -+ // Convert the result -+ istate->set_stack(stack->sp() - 1); -+ - } - --void MethodHandles::ricochet_frame_oops_do(const frame& fr, OopClosure* blk, const RegisterMap* reg_map) { -- // ResourceMark rm; -- // RicochetFrame* f = RicochetFrame::from_frame(fr); -+oop MethodHandles::popFromStack(TRAPS) { - -- // pick up the argument type descriptor: -- // Thread* thread = Thread::current(); -- // process fixed part -- // blk->do_oop((oop*)f->saved_target_addr()); -- // blk->do_oop((oop*)f->saved_args_layout_addr()); -+ JavaThread *thread = (JavaThread *) THREAD; -+ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); -+ interpreterState istate = frame->interpreter_state(); -+ intptr_t* topOfStack = istate->stack(); - -- // process variable arguments: -- // if (cookie.is_null()) return; // no arguments to describe -+ oop top = STACK_OBJECT(-1); -+ MORE_STACK(-1); -+ istate->set_stack(topOfStack); - -- // the cookie is actually the invokeExact method for my target -- // his argument signature is what I'm interested in -- // assert(cookie->is_method(), ""); -- // methodHandle invoker(thread, methodOop(cookie())); -- // assert(invoker->name() == vmSymbols::invokeExact_name(), "must be this kind of method"); -- // assert(!invoker->is_static(), "must have MH argument"); -- // int slot_count = invoker->size_of_parameters(); -- // assert(slot_count >= 1, "must include 'this'"); -- // intptr_t* base = f->saved_args_base(); -- // intptr_t* retval = NULL; -- // if (f->has_return_value_slot()) -- // retval = f->return_value_slot_addr(); -- // int slot_num = slot_count - 1; -- // intptr_t* loc = &base[slot_num]; -- //blk->do_oop((oop*) loc); // original target, which is irrelevant -- // int arg_num = 0; -- // for (SignatureStream ss(invoker->signature()); !ss.is_done(); ss.next()) { -- // if (ss.at_return_type()) continue; -- // BasicType ptype = ss.type(); -- // if (ptype == T_ARRAY) ptype = T_OBJECT; // fold all refs to T_OBJECT -- // assert(ptype >= T_BOOLEAN && ptype <= T_OBJECT, "not array or void"); -- // slot_num -= type2size[ptype]; -- // loc = &base[slot_num]; -- // bool is_oop = (ptype == T_OBJECT && loc != retval); -- // if (is_oop) blk->do_oop((oop*)loc); -- // arg_num += 1; -- // } -- // assert(slot_num == 0, "must have processed all the arguments"); -+ return top; -+ - } -+ -+int MethodHandles::method_handle_entry_invokeBasic(methodOop method, intptr_t UNUSED, TRAPS) { -+ -+ JavaThread *thread = (JavaThread *) THREAD; -+ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); -+ interpreterState istate = frame->interpreter_state(); -+ intptr_t* topOfStack = istate->stack(); -+ -+ // 'this' is a MethodHandle. We resolve the target method by accessing this.form.vmentry.vmtarget. -+ int numArgs = method->size_of_parameters(); -+ oop lform1 = java_lang_invoke_MethodHandle::form(STACK_OBJECT(-numArgs)); // this.form -+ oop vmEntry1 = java_lang_invoke_LambdaForm::vmentry(lform1); -+ methodOop vmtarget = (methodOop) java_lang_invoke_MemberName::vmtarget(vmEntry1); -+ -+ invoke_target(vmtarget, THREAD); -+ -+ // No deoptimized frames on the stack -+ return 0; -+} -+ -+int MethodHandles::method_handle_entry_linkToStaticOrSpecial(methodOop method, intptr_t UNUSED, TRAPS) { -+ -+ // Pop appendix argument from stack. This is a MemberName which we resolve to the -+ // target method. -+ oop vmentry = popFromStack(THREAD); -+ -+ methodOop vmtarget = (methodOop) java_lang_invoke_MemberName::vmtarget(vmentry); -+ -+ invoke_target(vmtarget, THREAD); -+ -+ return 0; -+} -+ -+int MethodHandles::method_handle_entry_linkToInterface(methodOop method, intptr_t UNUSED, TRAPS) { -+ JavaThread *thread = (JavaThread *) THREAD; -+ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); -+ interpreterState istate = frame->interpreter_state(); -+ intptr_t* topOfStack = istate->stack(); -+ -+ // Pop appendix argument from stack. This is a MemberName which we resolve to the -+ // target method. -+ oop vmentry = popFromStack(THREAD); -+ -+ // Resolve target method by looking up in the receiver object's itable. -+ klassOop clazz = java_lang_Class::as_klassOop(java_lang_invoke_MemberName::clazz(vmentry)); -+ intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); -+ methodOop target = (methodOop) java_lang_invoke_MemberName::vmtarget(vmentry); -+ -+ int numArgs = target->size_of_parameters(); -+ oop recv = STACK_OBJECT(-numArgs); -+ -+ instanceKlass* klass_part = (instanceKlass*) recv->klass()->klass_part(); -+ itableOffsetEntry* ki = (itableOffsetEntry*) klass_part->start_of_itable(); -+ int i; -+ for ( i = 0 ; i < klass_part->itable_length() ; i++, ki++ ) { -+ if (ki->interface_klass() == clazz) break; -+ } -+ -+ itableMethodEntry* im = ki->first_method_entry(recv->klass()); -+ methodOop vmtarget = im[vmindex].method(); -+ -+ invoke_target(vmtarget, THREAD); -+ -+ return 0; -+} -+ -+int MethodHandles::method_handle_entry_linkToVirtual(methodOop method, intptr_t UNUSED, TRAPS) { -+ JavaThread *thread = (JavaThread *) THREAD; -+ -+ InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); -+ interpreterState istate = frame->interpreter_state(); -+ intptr_t* topOfStack = istate->stack(); -+ -+ // Pop appendix argument from stack. This is a MemberName which we resolve to the -+ // target method. -+ oop vmentry = popFromStack(THREAD); -+ -+ // Resolve target method by looking up in the receiver object's vtable. -+ intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); -+ methodOop target = (methodOop) java_lang_invoke_MemberName::vmtarget(vmentry); -+ int numArgs = target->size_of_parameters(); -+ oop recv = STACK_OBJECT(-numArgs); -+ klassOop clazz = recv->klass(); -+ Klass* klass_part = clazz->klass_part(); -+ klassVtable* vtable = klass_part->vtable(); -+ methodOop vmtarget = vtable->method_at(vmindex); -+ -+ invoke_target(vmtarget, THREAD); -+ -+ return 0; -+} -+ -+int MethodHandles::method_handle_entry_invalid(methodOop method, intptr_t UNUSED, TRAPS) { -+ ShouldNotReachHere(); -+ return 0; -+} -+ -+address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* masm, -+ vmIntrinsics::ID iid) { -+ switch (iid) { -+ case vmIntrinsics::_invokeGeneric: -+ case vmIntrinsics::_compiledLambdaForm: -+ // Perhaps surprisingly, the symbolic references visible to Java are not directly used. -+ // They are linked to Java-generated adapters via MethodHandleNatives.linkMethod. -+ // They all allow an appendix argument. -+ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invalid); -+ case vmIntrinsics::_invokeBasic: -+ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invokeBasic); -+ case vmIntrinsics::_linkToStatic: -+ case vmIntrinsics::_linkToSpecial: -+ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToStaticOrSpecial); -+ case vmIntrinsics::_linkToInterface: -+ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToInterface); -+ case vmIntrinsics::_linkToVirtual: -+ return InterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToVirtual); -+ default: -+ ShouldNotReachHere(); -+ return NULL; -+ } -+} -diff --git a/src/cpu/zero/vm/methodHandles_zero.hpp b/src/cpu/zero/vm/methodHandles_zero.hpp ---- a/src/cpu/zero/vm/methodHandles_zero.hpp -+++ b/src/cpu/zero/vm/methodHandles_zero.hpp -@@ -26,7 +26,7 @@ - - // Adapters - enum /* platform_dependent_constants */ { -- adapter_code_size = 0 -+ adapter_code_size = 20000 - }; - - class RicochetFrame : public ResourceObj { -@@ -52,3 +52,12 @@ - int* frame_size_in_words); - - }; -+ -+private: -+ static oop popFromStack(TRAPS); -+ static void invoke_target(methodOop method, TRAPS); -+ static int method_handle_entry_invokeBasic(methodOop method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_linkToStaticOrSpecial(methodOop method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_linkToVirtual(methodOop method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_linkToInterface(methodOop method, intptr_t UNUSED, TRAPS); -+ static int method_handle_entry_invalid(methodOop method, intptr_t UNUSED, TRAPS); -diff --git a/src/cpu/zero/vm/register_zero.hpp b/src/cpu/zero/vm/register_zero.hpp ---- a/src/cpu/zero/vm/register_zero.hpp -+++ b/src/cpu/zero/vm/register_zero.hpp -@@ -114,5 +114,8 @@ - }; - - CONSTANT_REGISTER_DECLARATION(Register, noreg, (-1)); -+#ifndef DONT_USE_REGISTER_DEFINES -+#define noreg ((Register)(noreg_RegisterEnumValue)) -+#endif - - #endif // CPU_ZERO_VM_REGISTER_ZERO_HPP -diff --git a/src/cpu/zero/vm/stubRoutines_zero.hpp b/src/cpu/zero/vm/stubRoutines_zero.hpp ---- a/src/cpu/zero/vm/stubRoutines_zero.hpp -+++ b/src/cpu/zero/vm/stubRoutines_zero.hpp -@@ -40,8 +40,8 @@ - } - - enum platform_dependent_constants { -- code_size1 = 0, // The assembler will fail with a guarantee -- code_size2 = 0 // if these are too small. Simply increase -+ code_size1 = 20000, // The assembler will fail with a guarantee -+ code_size2 = 20000 // if these are too small. Simply increase - }; // them if that happens. - - enum method_handles_platform_dependent_constants { -diff --git a/src/share/vm/asm/assembler.cpp b/src/share/vm/asm/assembler.cpp ---- a/src/share/vm/asm/assembler.cpp -+++ b/src/share/vm/asm/assembler.cpp -@@ -59,6 +59,7 @@ - _code_section = cs; - _code_begin = cs->start(); - _code_limit = cs->limit(); -+ assert(_code_limit > _code_begin, "no empty code buffer"); - _code_pos = cs->end(); - _oop_recorder= code->oop_recorder(); - DEBUG_ONLY( _short_branch_delta = 0; ) -diff --git a/src/share/vm/interpreter/bytecodeInterpreter.cpp b/src/share/vm/interpreter/bytecodeInterpreter.cpp ---- a/src/share/vm/interpreter/bytecodeInterpreter.cpp -+++ b/src/share/vm/interpreter/bytecodeInterpreter.cpp -@@ -235,10 +235,6 @@ - #endif - #endif - --// JavaStack Implementation --#define MORE_STACK(count) \ -- (topOfStack -= ((count) * Interpreter::stackElementWords)) -- - - #define UPDATE_PC(opsize) {pc += opsize; } - /* -@@ -575,7 +571,7 @@ - - /* 0xE0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, - /* 0xE4 */ &&opc_default, &&opc_fast_aldc, &&opc_fast_aldc_w, &&opc_return_register_finalizer, --/* 0xE8 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, -+/* 0xE8 */ &&opc_invokehandle,&&opc_default, &&opc_default, &&opc_default, - /* 0xEC */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, - - /* 0xF0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, -@@ -2190,6 +2186,7 @@ - } - - CASE(_invokedynamic): { -+ - if (!EnableInvokeDynamic) { - // We should not encounter this bytecode if !EnableInvokeDynamic. - // The verifier will stop it. However, if we get past the verifier, -@@ -2212,17 +2209,54 @@ - result = THREAD->vm_result(); - } - -- VERIFY_OOP(result); -- oop method_handle = java_lang_invoke_CallSite::target(result); -- CHECK_NULL(method_handle); -- -- istate->set_msg(call_method_handle); -- istate->set_callee((Method*) method_handle); -+ methodOop method = cache->f2_as_vfinal_method(); -+ VERIFY_OOP(method); -+ -+ if (cache->has_appendix()) { -+ SET_STACK_OBJECT(cache->f1_appendix(), 0); -+ MORE_STACK(1); -+ } -+ -+ istate->set_msg(call_method); -+ istate->set_callee((methodOop) method); -+ istate->set_callee_entry_point(method->from_interpreted_entry()); - istate->set_bcp_advance(5); - - UPDATE_PC_AND_RETURN(0); // I'll be back... - } - -+ CASE(_invokehandle): { -+ -+ if (!EnableInvokeDynamic) { -+ ShouldNotReachHere(); -+ } -+ -+ u2 index = Bytes::get_native_u2(pc+1); -+ -+ ConstantPoolCacheEntry* cache = cp->entry_at(index); -+ -+ if (! cache->is_resolved((Bytecodes::Code) opcode)) { -+ CALL_VM(InterpreterRuntime::resolve_invokehandle(THREAD), -+ handle_exception); -+ cache = cp->entry_at(index); -+ } -+ methodOop method = cache->f2_as_vfinal_method(); -+ -+ VERIFY_OOP(method); -+ -+ if (cache->has_appendix()) { -+ SET_STACK_OBJECT(cache->f1_appendix(), 0); -+ MORE_STACK(1); -+ } -+ -+ istate->set_msg(call_method); -+ istate->set_callee(method); -+ istate->set_callee_entry_point(method->from_interpreted_entry()); -+ istate->set_bcp_advance(3); -+ -+ UPDATE_PC_AND_RETURN(0); // I'll be back... -+ } -+ - CASE(_invokeinterface): { - u2 index = Bytes::get_native_u2(pc+1); - -diff --git a/src/share/vm/interpreter/bytecodeInterpreter.hpp b/src/share/vm/interpreter/bytecodeInterpreter.hpp ---- a/src/share/vm/interpreter/bytecodeInterpreter.hpp -+++ b/src/share/vm/interpreter/bytecodeInterpreter.hpp -@@ -50,6 +50,10 @@ - - #ifdef CC_INTERP - -+// JavaStack Implementation -+#define MORE_STACK(count) \ -+ (topOfStack -= ((count) * Interpreter::stackElementWords)) -+ - // CVM definitions find hotspot equivalents... - - union VMJavaVal64 { -diff --git a/src/share/vm/interpreter/cppInterpreter.cpp b/src/share/vm/interpreter/cppInterpreter.cpp ---- a/src/share/vm/interpreter/cppInterpreter.cpp -+++ b/src/share/vm/interpreter/cppInterpreter.cpp -@@ -117,7 +117,6 @@ - method_entry(empty); - method_entry(accessor); - method_entry(abstract); -- method_entry(method_handle); - method_entry(java_lang_math_sin ); - method_entry(java_lang_math_cos ); - method_entry(java_lang_math_tan );
--- a/zero-new-math.patch Fri Oct 05 19:46:11 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,26 +0,0 @@ -# HG changeset patch -# Parent dbe08e8d5dca671e570718f04b0e6f6be5afc02d -diff --git a/src/cpu/zero/vm/cppInterpreter_zero.cpp b/src/cpu/zero/vm/cppInterpreter_zero.cpp ---- a/src/cpu/zero/vm/cppInterpreter_zero.cpp -+++ b/src/cpu/zero/vm/cppInterpreter_zero.cpp -@@ -1714,6 +1714,8 @@ - case Interpreter::java_lang_math_log: - case Interpreter::java_lang_math_log10: - case Interpreter::java_lang_math_sqrt: -+ case Interpreter::java_lang_math_pow: -+ case Interpreter::java_lang_math_exp: - entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); - break; - -diff --git a/src/share/vm/interpreter/cppInterpreter.cpp b/src/share/vm/interpreter/cppInterpreter.cpp ---- a/src/share/vm/interpreter/cppInterpreter.cpp -+++ b/src/share/vm/interpreter/cppInterpreter.cpp -@@ -125,6 +125,8 @@ - method_entry(java_lang_math_sqrt ); - method_entry(java_lang_math_log ); - method_entry(java_lang_math_log10 ); -+ method_entry(java_lang_math_pow ); -+ method_entry(java_lang_math_exp ); - method_entry(java_lang_ref_reference_get); - Interpreter::_native_entry_begin = Interpreter::code()->code_end(); - method_entry(native);
--- a/zero-segfault.patch Fri Oct 05 19:46:11 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,14 +0,0 @@ -# HG changeset patch -# Parent bbe0f6e46610f23cf483e928e5d30558364e03c3 -diff --git a/src/share/vm/asm/codeBuffer.cpp b/src/share/vm/asm/codeBuffer.cpp ---- a/src/share/vm/asm/codeBuffer.cpp -+++ b/src/share/vm/asm/codeBuffer.cpp -@@ -674,7 +674,7 @@ - } - } - -- if (dest->blob() == NULL) { -+ if (dest->blob() == NULL && dest_filled != 0x0) { - // Destination is a final resting place, not just another buffer. - // Normalize uninitialized bytes in the final padding. - Copy::fill_to_bytes(dest_filled, dest_end - dest_filled,