truffle: src/share/vm/interpreter/bytecodeInterpreter.cpp comparison

comparison src/share/vm/interpreter/bytecodeInterpreter.cpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	1d7922586cf6
children	d8ce2825b193

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 /*
-* Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 register intptr_t*        topOfStack = (intptr_t *)istate->stack(); /* access with STACK macros */
 register address          pc = istate->bcp();
 register jubyte opcode;
 register intptr_t*        locals = istate->locals();
-register constantPoolCacheOop  cp = istate->constants(); // method()->constants()->cache()
+register ConstantPoolCache*    cp = istate->constants(); // method()->constants()->cache()
 #ifdef LOTS_OF_REGS
 register JavaThread*      THREAD = istate->thread();
 register volatile jbyte*  BYTE_MAP_BASE = _byte_map_base;
 #else
 #undef THREAD
 markOop mark = rcvr->mark();
 if (mark->has_bias_pattern()) {
 // The bias pattern is present in the object's header. Need to check
 // whether the bias owner and the epoch are both still current.
 intptr_t xx = ((intptr_t) THREAD) ^ (intptr_t) mark;
-xx = (intptr_t) rcvr->klass()->klass_part()->prototype_header() ^ xx;
+xx = (intptr_t) rcvr->klass()->prototype_header() ^ xx;
 intptr_t yy = (xx & ~((int) markOopDesc::age_mask_in_place));
 if (yy != 0 ) {
 // At this point we know that the header has the bias pattern and
 // that we are not the bias owner in the current epoch. We need to
 // figure out more details about the state of the header in order to
 // current "bias owner", if any, is actually invalid. Under these
 // circumstances _only_, we are allowed to use the current header's
 // value as the comparison value when doing the cas to acquire the
 // bias in the current epoch. In other words, we allow transfer of
 // the bias from one thread to another directly in this situation.
-xx = (intptr_t) rcvr->klass()->klass_part()->prototype_header() | (intptr_t) THREAD;
+xx = (intptr_t) rcvr->klass()->prototype_header() | (intptr_t) THREAD;
-if (Atomic::cmpxchg_ptr((intptr_t)THREAD | (intptr_t) rcvr->klass()->klass_part()->prototype_header(),
+if (Atomic::cmpxchg_ptr((intptr_t)THREAD | (intptr_t) rcvr->klass()->prototype_header(),
 (intptr_t*) rcvr->mark_addr(),
 (intptr_t) mark) != (intptr_t) mark) {
 CALL_VM(InterpreterRuntime::monitorenter(THREAD, mon), handle_exception);
 }
 }
 // CAS-based locking scheme. Note that if our CAS fails, it means
 // that another thread raced us for the privilege of revoking the
 // bias of this particular object, so it's okay to continue in the
 // normal locking code.
 //
-xx = (intptr_t) rcvr->klass()->klass_part()->prototype_header() | (intptr_t) THREAD;
+xx = (intptr_t) rcvr->klass()->prototype_header() | (intptr_t) THREAD;
-if (Atomic::cmpxchg_ptr(rcvr->klass()->klass_part()->prototype_header(),
+if (Atomic::cmpxchg_ptr(rcvr->klass()->prototype_header(),
 (intptr_t*) rcvr->mark_addr(),
 mark) == mark) {
 // (*counters->revoked_lock_entry_count_addr())++;
 success = false;
 }
 CASE(_return_register_finalizer): {
 oop rcvr = LOCALS_OBJECT(0);
 VERIFY_OOP(rcvr);
-if (rcvr->klass()->klass_part()->has_finalizer()) {
+if (rcvr->klass()->has_finalizer()) {
 CALL_VM(InterpreterRuntime::register_finalizer(THREAD, rcvr), handle_exception);
 }
 goto handle_return;
 }
 CASE(_return): {
 VERIFY_OOP(rhsObject);
 ARRAY_INTRO( -3);
 // arrObj, index are set
 if (rhsObject != NULL) {
 /* Check assignability of rhsObject into arrObj */
-klassOop rhsKlassOop = rhsObject->klass(); // EBX (subclass)
+Klass* rhsKlassOop = rhsObject->klass(); // EBX (subclass)
-assert(arrObj->klass()->klass()->klass_part()->oop_is_objArrayKlass(), "Ack not an objArrayKlass");
+Klass* elemKlassOop = objArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
-klassOop elemKlassOop = ((objArrayKlass*) arrObj->klass()->klass_part())->element_klass(); // superklass EAX
 //
 // Check for compatibilty. This check must not GC!!
 // Seems way more expensive now that we must dispatch
 //
-if (rhsKlassOop != elemKlassOop && !rhsKlassOop->klass_part()->is_subtype_of(elemKlassOop)) { // ebx->is...
+if (rhsKlassOop != elemKlassOop && !rhsKlassOop->is_subtype_of(elemKlassOop)) { // ebx->is...
 VM_JAVA_ERROR(vmSymbols::java_lang_ArrayStoreException(), "");
 }
 }
 oop* elem_loc = (oop*)(((address) arrObj->base(T_OBJECT)) + index * sizeof(oop));
 // *(oop*)(((address) arrObj->base(T_OBJECT)) + index * sizeof(oop)) = rhsObject;
 }
 #endif /* VM_JVMTI */
 oop obj;
 if ((Bytecodes::Code)opcode == Bytecodes::_getstatic) {
-obj = (oop) cache->f1_as_instance();
+Klass* k = (Klass*) cache->f1();
+obj = k->java_mirror();
 MORE_STACK(1);  // Assume single slot push
 } else {
 obj = (oop) STACK_OBJECT(-1);
 CHECK_NULL(obj);
 }
 count = -1;
 if (tos_type == ltos || tos_type == dtos) {
 --count;
 }
 if ((Bytecodes::Code)opcode == Bytecodes::_putstatic) {
-obj = (oop) cache->f1_as_instance();
+Klass* k = (Klass*) cache->f1();
+obj = k->java_mirror();
 } else {
 --count;
 obj = (oop) STACK_OBJECT(count);
 CHECK_NULL(obj);
 }
 UPDATE_PC_AND_TOS_AND_CONTINUE(3, count);
 }
 CASE(_new): {
 u2 index = Bytes::get_Java_u2(pc+1);
-constantPoolOop constants = istate->method()->constants();
+ConstantPool* constants = istate->method()->constants();
 if (!constants->tag_at(index).is_unresolved_klass()) {
 // Make sure klass is initialized and doesn't have a finalizer
-oop entry = constants->slot_at(index).get_oop();
+Klass* entry = constants->slot_at(index).get_klass();
 assert(entry->is_klass(), "Should be resolved klass");
-klassOop k_entry = (klassOop) entry;
+Klass* k_entry = (Klass*) entry;
-assert(k_entry->klass_part()->oop_is_instance(), "Should be instanceKlass");
+assert(k_entry->oop_is_instance(), "Should be InstanceKlass");
-instanceKlass* ik = (instanceKlass*) k_entry->klass_part();
+InstanceKlass* ik = (InstanceKlass*) k_entry;
 if ( ik->is_initialized() && ik->can_be_fastpath_allocated() ) {
 size_t obj_size = ik->size_helper();
 oop result = NULL;
 // If the TLAB isn't pre-zeroed then we'll have to do it
 bool need_zero = !ZeroTLAB;
 // Constant pool may have actual klass or unresolved klass. If it is
 // unresolved we must resolve it
 if (METHOD->constants()->tag_at(index).is_unresolved_klass()) {
 CALL_VM(InterpreterRuntime::quicken_io_cc(THREAD), handle_exception);
 }
-klassOop klassOf = (klassOop) METHOD->constants()->slot_at(index).get_oop();
+Klass* klassOf = (Klass*) METHOD->constants()->slot_at(index).get_klass();
-klassOop objKlassOop = STACK_OBJECT(-1)->klass(); //ebx
+Klass* objKlassOop = STACK_OBJECT(-1)->klass(); //ebx
 //
 // Check for compatibilty. This check must not GC!!
 // Seems way more expensive now that we must dispatch
 //
 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);
 // Constant pool may have actual klass or unresolved klass. If it is
 // unresolved we must resolve it
 if (METHOD->constants()->tag_at(index).is_unresolved_klass()) {
 CALL_VM(InterpreterRuntime::quicken_io_cc(THREAD), handle_exception);
 }
-klassOop klassOf = (klassOop) METHOD->constants()->slot_at(index).get_oop();
+Klass* klassOf = (Klass*) METHOD->constants()->slot_at(index).get_klass();
-klassOop objKlassOop = STACK_OBJECT(-1)->klass();
+Klass* objKlassOop = STACK_OBJECT(-1)->klass();
 //
 // Check for compatibilty. This check must not GC!!
 // Seems way more expensive now that we must dispatch
 //
-if ( objKlassOop == klassOf || objKlassOop->klass_part()->is_subtype_of(klassOf)) {
+if ( objKlassOop == klassOf || objKlassOop->is_subtype_of(klassOf)) {
 SET_STACK_INT(1, -1);
 } else {
 SET_STACK_INT(0, -1);
 }
 }
 index = Bytes::get_Java_u2(pc+1);
 incr = 3;
 wide = true;
 }
-constantPoolOop constants = METHOD->constants();
+ConstantPool* constants = METHOD->constants();
 switch (constants->tag_at(index).value()) {
 case JVM_CONSTANT_Integer:
 SET_STACK_INT(constants->int_at(index), 0);
 break;
 case JVM_CONSTANT_Float:
 SET_STACK_FLOAT(constants->float_at(index), 0);
 break;
 case JVM_CONSTANT_String:
-VERIFY_OOP(constants->resolved_string_at(index));
+{
-SET_STACK_OBJECT(constants->resolved_string_at(index), 0);
+oop result = constants->resolved_references()->obj_at(index);
+if (result == NULL) {
+CALL_VM(InterpreterRuntime::resolve_ldc(THREAD, (Bytecodes::Code) opcode), handle_exception);
+SET_STACK_OBJECT(THREAD->vm_result(), 0);
+THREAD->set_vm_result(NULL);
+} else {
+VERIFY_OOP(result);
+SET_STACK_OBJECT(result, 0);
+}
 break;
+}
 case JVM_CONSTANT_Class:
 VERIFY_OOP(constants->resolved_klass_at(index)->java_mirror());
 SET_STACK_OBJECT(constants->resolved_klass_at(index)->java_mirror(), 0);
 break;
-case JVM_CONSTANT_UnresolvedString:
 case JVM_CONSTANT_UnresolvedClass:
 case JVM_CONSTANT_UnresolvedClassInError:
 CALL_VM(InterpreterRuntime::ldc(THREAD, wide), handle_exception);
 SET_STACK_OBJECT(THREAD->vm_result(), 0);
 THREAD->set_vm_result(NULL);
 CASE(_ldc2_w):
 {
 u2 index = Bytes::get_Java_u2(pc+1);
-constantPoolOop constants = METHOD->constants();
+ConstantPool* constants = METHOD->constants();
 switch (constants->tag_at(index).value()) {
 case JVM_CONSTANT_Long:
 SET_STACK_LONG(constants->long_at(index), 1);
 break;
 UPDATE_PC_AND_TOS_AND_CONTINUE(3, 2);
 }
 CASE(_fast_aldc_w):
 CASE(_fast_aldc): {
-if (!EnableInvokeDynamic) {
-// We should not encounter this bytecode if !EnableInvokeDynamic.
-// The verifier will stop it.  However, if we get past the verifier,
-// this will stop the thread in a reasonable way, without crashing the JVM.
-CALL_VM(InterpreterRuntime::throw_IncompatibleClassChangeError(THREAD),
-handle_exception);
-ShouldNotReachHere();
-}
 u2 index;
 int incr;
 if (opcode == Bytecodes::_fast_aldc) {
 index = pc[1];
 incr = 2;
 }
 // We are resolved if the f1 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.
-ConstantPoolCacheEntry* cache = cp->entry_at(index);
+ConstantPool* constants = METHOD->constants();
-oop result = cache->f1_as_instance();
+oop result = constants->resolved_references()->obj_at(index);
 if (result == NULL) {
 CALL_VM(InterpreterRuntime::resolve_ldc(THREAD, (Bytecodes::Code) opcode),
 handle_exception);
-result = cache->f1_as_instance();
+result = THREAD->vm_result();
 }
 VERIFY_OOP(result);
 SET_STACK_OBJECT(result, 0);
 UPDATE_PC_AND_TOS_AND_CONTINUE(incr, 1);
 ShouldNotReachHere();
 }
 int index = Bytes::get_native_u4(pc+1);
-// We are resolved if the f1 field contains a non-null object (CallSite, etc.)
+// 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.
-assert(constantPoolCacheOopDesc::is_secondary_index(index), "incorrect format");
+ConstantPool* constants = METHOD->constants();
-ConstantPoolCacheEntry* cache = cp->secondary_entry_at(index);
+oop result = constants->resolved_references()->obj_at(index);
-oop result = cache->f1_as_instance();
 if (result == NULL) {
 CALL_VM(InterpreterRuntime::resolve_invokedynamic(THREAD),
 handle_exception);
-result = cache->f1_as_instance();
+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((methodOop) method_handle);
+istate->set_callee((Method*) method_handle);
 istate->set_bcp_advance(5);
 UPDATE_PC_AND_RETURN(0); // I'll be back...
 }
 // Special case of invokeinterface called for virtual method of
 // java.lang.Object.  See cpCacheOop.cpp for details.
 // This code isn't produced by javac, but could be produced by
 // another compliant java compiler.
 if (cache->is_forced_virtual()) {
-methodOop callee;
+Method* callee;
 CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
 if (cache->is_vfinal()) {
 callee = cache->f2_as_vfinal_method();
 } else {
 // get receiver
 int parms = cache->parameter_size();
 // Same comments as invokevirtual apply here
 VERIFY_OOP(STACK_OBJECT(-parms));
-instanceKlass* rcvrKlass = (instanceKlass*)
+InstanceKlass* rcvrKlass = (InstanceKlass*)
-STACK_OBJECT(-parms)->klass()->klass_part();
+STACK_OBJECT(-parms)->klass();
-callee = (methodOop) rcvrKlass->start_of_vtable()[ cache->f2_as_index()];
+callee = (Method*) rcvrKlass->start_of_vtable()[ cache->f2_as_index()];
 }
 istate->set_callee(callee);
 istate->set_callee_entry_point(callee->from_interpreted_entry());
 #ifdef VM_JVMTI
 if (JvmtiExport::can_post_interpreter_events() && THREAD->is_interp_only_mode()) {
 istate->set_bcp_advance(5);
 UPDATE_PC_AND_RETURN(0); // I'll be back...
 }
 // this could definitely be cleaned up QQQ
-methodOop callee;
+Method* callee;
-klassOop iclass = cache->f1_as_klass();
+Klass* iclass = cache->f1_as_klass();
-// instanceKlass* interface = (instanceKlass*) iclass->klass_part();
+// InstanceKlass* interface = (InstanceKlass*) iclass;
 // get receiver
 int parms = cache->parameter_size();
 oop rcvr = STACK_OBJECT(-parms);
 CHECK_NULL(rcvr);
-instanceKlass* int2 = (instanceKlass*) rcvr->klass()->klass_part();
+InstanceKlass* int2 = (InstanceKlass*) rcvr->klass();
 itableOffsetEntry* ki = (itableOffsetEntry*) int2->start_of_itable();
 int i;
 for ( i = 0 ; i < int2->itable_length() ; i++, ki++ ) {
 if (ki->interface_klass() == iclass) break;
 }
 cache = cp->entry_at(index);
 }
 istate->set_msg(call_method);
 {
-methodOop callee;
+Method* callee;
 if ((Bytecodes::Code)opcode == Bytecodes::_invokevirtual) {
 CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
 if (cache->is_vfinal()) callee = cache->f2_as_vfinal_method();
 else {
 // get receiver
 int parms = cache->parameter_size();
 // this works but needs a resourcemark and seems to create a vtable on every call:
-// methodOop callee = rcvr->klass()->klass_part()->vtable()->method_at(cache->f2_as_index());
+// Method* callee = rcvr->klass()->vtable()->method_at(cache->f2_as_index());
 //
 // this fails with an assert
-// instanceKlass* rcvrKlass = instanceKlass::cast(STACK_OBJECT(-parms)->klass());
+// InstanceKlass* rcvrKlass = InstanceKlass::cast(STACK_OBJECT(-parms)->klass());
 // but this works
 VERIFY_OOP(STACK_OBJECT(-parms));
-instanceKlass* rcvrKlass = (instanceKlass*) STACK_OBJECT(-parms)->klass()->klass_part();
+InstanceKlass* rcvrKlass = (InstanceKlass*) STACK_OBJECT(-parms)->klass();
 /*
 Executing this code in java.lang.String:
 public String(char value[]) {
 this.count = value.length;
 this.value = (char[])value.clone();
 }
-a find on rcvr->klass()->klass_part() reports:
+a find on rcvr->klass() reports:
 {type array char}{type array class}
 - klass: {other class}
-but using instanceKlass::cast(STACK_OBJECT(-parms)->klass()) causes in assertion failure
+but using InstanceKlass::cast(STACK_OBJECT(-parms)->klass()) causes in assertion failure
-because rcvr->klass()->klass_part()->oop_is_instance() == 0
+because rcvr->klass()->oop_is_instance() == 0
 However it seems to have a vtable in the right location. Huh?
 */
-callee = (methodOop) rcvrKlass->start_of_vtable()[ cache->f2_as_index()];
+callee = (Method*) rcvrKlass->start_of_vtable()[ cache->f2_as_index()];
 }
 } else {
 if ((Bytecodes::Code)opcode == Bytecodes::_invokespecial) {
 CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
 }
 // expression stack is emptied
 topOfStack = istate->stack_base() - Interpreter::stackElementWords;
 CALL_VM(continuation_bci = (intptr_t)InterpreterRuntime::exception_handler_for_exception(THREAD, except_oop()),
 handle_exception);
-except_oop = (oop) THREAD->vm_result();
+except_oop = THREAD->vm_result();
 THREAD->set_vm_result(NULL);
 if (continuation_bci >= 0) {
 // Place exception on top of stack
 SET_STACK_OBJECT(except_oop(), 0);
 MORE_STACK(1);

Mercurial > hg > truffle

comparison src/share/vm/interpreter/bytecodeInterpreter.cpp @ 6725:da91efe96a93