jdk-sandbox: comparison hotspot/src/cpu/zero/vm/cppInterpreter

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 /*
-* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2007, 2008, 2009, 2010, 2011 Red Hat, Inc.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 #include "interpreter/cppInterpreter.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/interpreterGenerator.hpp"
 #include "interpreter/interpreterRuntime.hpp"
 #include "oops/arrayOop.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/deoptimization.hpp"
 #define CALL_VM_NOCHECK(func)                   \
 CALL_VM_NOCHECK_NOFIX(func)                   \
 fixup_after_potential_safepoint()
-int CppInterpreter::normal_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+int CppInterpreter::normal_entry(Method* method, intptr_t UNUSED, TRAPS) {
 JavaThread *thread = (JavaThread *) THREAD;
 // Allocate and initialize our frame.
 InterpreterFrame *frame = InterpreterFrame::build(method, CHECK_0);
 thread->push_zero_frame(frame);
 if (recurse)
 main_loop(recurse - 1, THREAD);
 InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
 interpreterState istate = frame->interpreter_state();
-methodOop method = istate->method();
+Method* method = istate->method();
 intptr_t *result = NULL;
 int result_slots = 0;
 while (true) {
 // Clear the frame anchor
 thread->reset_last_Java_frame();
 // Examine the message from the interpreter to decide what to do
 if (istate->msg() == BytecodeInterpreter::call_method) {
-methodOop callee = istate->callee();
+Method* callee = istate->callee();
 // Trim back the stack to put the parameters at the top
 stack->set_sp(istate->stack() + 1);
 // Make the call
 // Push our result
 for (int i = 0; i < result_slots; i++)
 stack->push(result[-i]);
 }
-int CppInterpreter::native_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+int CppInterpreter::native_entry(Method* method, intptr_t UNUSED, TRAPS) {
 // Make sure method is native and not abstract
 assert(method->is_native() && !method->is_abstract(), "should be");
 JavaThread *thread = (JavaThread *) THREAD;
 ZeroStack *stack = thread->zero_stack();
 // No deoptimized frames on the stack
 return 0;
 }
-int CppInterpreter::accessor_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+int CppInterpreter::accessor_entry(Method* method, intptr_t UNUSED, TRAPS) {
 JavaThread *thread = (JavaThread *) THREAD;
 ZeroStack *stack = thread->zero_stack();
 intptr_t *locals = stack->sp();
 // Drop into the slow path if we need a safepoint check
 code[4] == Bytecodes::_areturn), "should do");
 u2 index = Bytes::get_native_u2(&code[2]);
 // Get the entry from the constant pool cache, and drop into
 // the slow path if it has not been resolved
-constantPoolCacheOop cache = method->constants()->cache();
+ConstantPoolCache* cache = method->constants()->cache();
 ConstantPoolCacheEntry* entry = cache->entry_at(index);
 if (!entry->is_resolved(Bytecodes::_getfield)) {
 return normal_entry(method, 0, THREAD);
 }
 // No deoptimized frames on the stack
 return 0;
 }
-int CppInterpreter::empty_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+int CppInterpreter::empty_entry(Method* method, intptr_t UNUSED, TRAPS) {
 JavaThread *thread = (JavaThread *) THREAD;
 ZeroStack *stack = thread->zero_stack();
 // Drop into the slow path if we need a safepoint check
 if (SafepointSynchronize::do_call_back()) {
 // No deoptimized frames on the stack
 return 0;
 }
-int CppInterpreter::method_handle_entry(methodOop method,
+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)];
 MethodHandleEntry *entry =
 java_lang_invoke_MethodHandle::vmentry(method_handle);
 MethodHandles::EntryKind entry_kind =
 (MethodHandles::EntryKind) (((intptr_t) entry) & 0xffffffff);
-methodOop method = NULL;
+Method* method = NULL;
 switch (entry_kind) {
 case MethodHandles::_invokestatic_mh:
 direct_to_method = true;
 break;
 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* rcvrKlass =
-(instanceKlass *) receiver->klass()->klass_part();
+(InstanceKlass *) receiver->klass();
 if (entry_kind == MethodHandles::_invokevirtual_mh) {
-method = (methodOop) rcvrKlass->start_of_vtable()[index];
+method = (Method*) rcvrKlass->start_of_vtable()[index];
 }
 else {
-oop iclass = java_lang_invoke_MethodHandle::vmtarget(method_handle);
+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;
 case MethodHandles::_adapter_retype_only:
 case MethodHandles::_adapter_retype_raw:
 src_rtype = result_type_of_handle(
-java_lang_invoke_MethodHandle::vmtarget(method_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) {
-klassOop objKlassOop = arg->klass();
+Klass* objKlassOop = arg->klass();
-klassOop klassOf = java_lang_Class::as_klassOop(
+Klass* klassOf = java_lang_Class::as_Klass(
 java_lang_invoke_AdapterMethodHandle::argument(method_handle));
 if (objKlassOop != klassOf &&
-!objKlassOop->klass_part()->is_subtype_of(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);
 // Continue along the chain
 if (direct_to_method) {
 if (method == NULL) {
 method =
-(methodOop) java_lang_invoke_MethodHandle::vmtarget(method_handle);
+(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::vmtarget(method_handle), THREAD);
+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) {
 }
 BasicType CppInterpreter::result_type_of_handle(oop method_handle) {
 oop method_type = java_lang_invoke_MethodHandle::type(method_handle);
 oop return_type = java_lang_invoke_MethodType::rtype(method_type);
-return java_lang_Class::as_BasicType(return_type, (klassOop *) NULL);
+return java_lang_Class::as_BasicType(return_type, (Klass* *) NULL);
 }
 intptr_t* CppInterpreter::calculate_unwind_sp(ZeroStack* stack,
 oop method_handle) {
 oop method_type = java_lang_invoke_MethodHandle::type(method_handle);
 Symbol*     name,
 char*       message))
 THROW_MSG(name, message);
 IRT_END
-InterpreterFrame *InterpreterFrame::build(const methodOop method, TRAPS) {
+InterpreterFrame *InterpreterFrame::build(Method* const method, TRAPS) {
 JavaThread *thread = (JavaThread *) THREAD;
 ZeroStack *stack = thread->zero_stack();
 // Calculate the size of the frame we'll build, including
 // any adjustments to the caller's frame that we'll make.
 assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,
 "index out of bounds");
 return i;
 }
-BasicType CppInterpreter::result_type_of(methodOop method) {
+BasicType CppInterpreter::result_type_of(Method* method) {
 BasicType t;
 switch (method->result_index()) {
 case 0 : t = T_BOOLEAN; break;
 case 1 : t = T_CHAR;    break;
 case 2 : t = T_BYTE;    break;
 stack->alloc((size_in_words - header_words) * wordSize);
 return (InterpreterFrame *) fp;
 }
-int AbstractInterpreter::layout_activation(methodOop method,
+int AbstractInterpreter::layout_activation(Method* method,
 int       tempcount,
 int       popframe_extra_args,
 int       moncount,
 int       caller_actual_parameters,
 int       callee_param_count,
 }
 void BytecodeInterpreter::layout_interpreterState(interpreterState istate,
 frame*    caller,
 frame*    current,
-methodOop method,
+Method* method,
 intptr_t* locals,
 intptr_t* stack,
 intptr_t* stack_base,
 intptr_t* monitor_base,
 intptr_t* frame_bottom,
 return NULL;
 }
 // Helper for (runtime) stack overflow checks
-int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
+int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
 return 0;
 }
 // Helper for figuring out if frames are interpreter frames

changeset 13728	882756847a04
parent 13391	30245956af37
child 14294	130e947dfbe6