jdk8-mips64-public/hotspot: comparison src/share/vm/interpreter/bytecodeInterpreter.cpp

-:a64438a2b7e8
+:126ea7725993
 */
 #undef CHECK_NULL
 #define CHECK_NULL(obj_)                                                 \
 if ((obj_) == NULL) {                                                \
 VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), "");  \
-}
+}                                                                    \
+VERIFY_OOP(obj_)
 #define VMdoubleConstZero() 0.0
 #define VMdoubleConstOne() 1.0
 #define VMlongConstZero() (max_jlong-max_jlong)
 #define VMlongConstOne() ((max_jlong-max_jlong)+1)
 /* 0xA8 */ &&opc_jsr,      &&opc_ret,      &&opc_tableswitch,&&opc_lookupswitch,
 /* 0xAC */ &&opc_ireturn,  &&opc_lreturn,  &&opc_freturn,    &&opc_dreturn,
 /* 0xB0 */ &&opc_areturn,     &&opc_return,         &&opc_getstatic,    &&opc_putstatic,
 /* 0xB4 */ &&opc_getfield,    &&opc_putfield,       &&opc_invokevirtual,&&opc_invokespecial,
-/* 0xB8 */ &&opc_invokestatic,&&opc_invokeinterface,NULL,               &&opc_new,
+/* 0xB8 */ &&opc_invokestatic,&&opc_invokeinterface,&&opc_default,      &&opc_new,
 /* 0xBC */ &&opc_newarray,    &&opc_anewarray,      &&opc_arraylength,  &&opc_athrow,
 /* 0xC0 */ &&opc_checkcast,   &&opc_instanceof,     &&opc_monitorenter, &&opc_monitorexit,
 /* 0xC4 */ &&opc_wide,        &&opc_multianewarray, &&opc_ifnull,       &&opc_ifnonnull,
 /* 0xC8 */ &&opc_goto_w,      &&opc_jsr_w,          &&opc_breakpoint,   &&opc_default,
 #ifdef ASSERT
 // this will trigger a VERIFY_OOP on entry
 if (istate->msg() != initialize && ! METHOD->is_static()) {
 oop rcvr = LOCALS_OBJECT(0);
+VERIFY_OOP(rcvr);
 }
 #endif
 // #define HACK
 #ifdef HACK
 bool interesting = false;
 #endif // HACK
 /* QQQ this should be a stack method so we don't know actual direction */
-assert(istate->msg() == initialize ||
+guarantee(istate->msg() == initialize ||
 topOfStack >= istate->stack_limit() &&
 topOfStack < istate->stack_base(),
 "Stack top out of range");
 switch (istate->msg()) {
 oop rcvr;
 if (METHOD->is_static()) {
 rcvr = METHOD->constants()->pool_holder()->klass_part()->java_mirror();
 } else {
 rcvr = LOCALS_OBJECT(0);
+VERIFY_OOP(rcvr);
 }
 // The initial monitor is ours for the taking
 BasicObjectLock* mon = &istate->monitor_base()[-1];
 oop monobj = mon->obj();
 assert(mon->obj() == rcvr, "method monitor mis-initialized");
 }
 case popping_frame: {
 // returned from a java call to pop the frame, restart the call
 // clear the message so we don't confuse ourselves later
+ShouldNotReachHere();  // we don't return this.
 assert(THREAD->pop_frame_in_process(), "wrong frame pop state");
 istate->set_msg(no_request);
 THREAD->clr_pop_frame_in_process();
 goto run;
 }
 }
 case got_monitors: {
 // continue locking now that we have a monitor to use
 // we expect to find newly allocated monitor at the "top" of the monitor stack.
 oop lockee = STACK_OBJECT(-1);
+VERIFY_OOP(lockee);
 // derefing's lockee ought to provoke implicit null check
 // find a free monitor
 BasicObjectLock* entry = (BasicObjectLock*) istate->stack_base();
 assert(entry->obj() == NULL, "Frame manager didn't allocate the monitor");
 entry->set_obj(lockee);
 UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
 /* load from local variable */
 CASE(_aload):
+VERIFY_OOP(LOCALS_OBJECT(pc[1]));
 SET_STACK_OBJECT(LOCALS_OBJECT(pc[1]), 0);
 UPDATE_PC_AND_TOS_AND_CONTINUE(2, 1);
 CASE(_iload):
 CASE(_fload):
 UPDATE_PC_AND_TOS_AND_CONTINUE(2, 2);
 #undef  OPC_LOAD_n
 #define OPC_LOAD_n(num)                                                 \
 CASE(_aload_##num):                                               \
+VERIFY_OOP(LOCALS_OBJECT(num));                               \
 SET_STACK_OBJECT(LOCALS_OBJECT(num), 0);                      \
 UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);                         \
 \
 CASE(_iload_##num):                                               \
 CASE(_fload_##num):                                               \
 uint16_t reg = Bytes::get_Java_u2(pc + 2);
 opcode = pc[1];
 switch(opcode) {
 case Bytecodes::_aload:
+VERIFY_OOP(LOCALS_OBJECT(reg));
 SET_STACK_OBJECT(LOCALS_OBJECT(reg), 0);
 UPDATE_PC_AND_TOS_AND_CONTINUE(4, 1);
 case Bytecodes::_iload:
 case Bytecodes::_fload:
 #undef  OPC_INT_BINARY
 #define OPC_INT_BINARY(opcname, opname, test)                           \
 CASE(_i##opcname):                                                \
 if (test && (STACK_INT(-1) == 0)) {                           \
 VM_JAVA_ERROR(vmSymbols::java_lang_ArithmeticException(), \
-"/ by int zero");                           \
+"/ by zero");                               \
 }                                                             \
 SET_STACK_INT(VMint##opname(STACK_INT(-2),                    \
 STACK_INT(-1)),                   \
 -2);                              \
 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                        \
 CASE(_f2d):  /* convert top of stack float to double */
 {
 jfloat f;
 jdouble r;
 f = STACK_FLOAT(-1);
+#ifdef IA64
+// IA64 gcc bug
+r = ( f == 0.0f ) ? (jdouble) f : (jdouble) f + ia64_double_zero;
+#else
 r = (jdouble) f;
+#endif
 MORE_STACK(-1); // POP
 SET_STACK_DOUBLE(r, 1);
 UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
 }
 }
 CASE(_return_register_finalizer): {
 oop rcvr = LOCALS_OBJECT(0);
+VERIFY_OOP(rcvr);
 if (rcvr->klass()->klass_part()->has_finalizer()) {
 CALL_VM(InterpreterRuntime::register_finalizer(THREAD, rcvr), handle_exception);
 }
 goto handle_return;
 }
 /*
 * This one looks different because of the assignability check
 */
 CASE(_aastore): {
 oop rhsObject = STACK_OBJECT(-1);
+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)
 if ( *count_addr > 0 ) {
 if ((Bytecodes::Code)opcode == Bytecodes::_getstatic) {
 obj = (oop)NULL;
 } else {
 obj = (oop) STACK_OBJECT(-1);
+VERIFY_OOP(obj);
 }
 CALL_VM(InterpreterRuntime::post_field_access(THREAD,
 obj,
 cache),
 handle_exception);
 //
 TosState tos_type = cache->flag_state();
 int field_offset = cache->f2();
 if (cache->is_volatile()) {
 if (tos_type == atos) {
+VERIFY_OOP(obj->obj_field_acquire(field_offset));
 SET_STACK_OBJECT(obj->obj_field_acquire(field_offset), -1);
 } else if (tos_type == itos) {
 SET_STACK_INT(obj->int_field_acquire(field_offset), -1);
 } else if (tos_type == ltos) {
 SET_STACK_LONG(obj->long_field_acquire(field_offset), 0);
 SET_STACK_DOUBLE(obj->double_field_acquire(field_offset), 0);
 MORE_STACK(1);
 }
 } else {
 if (tos_type == atos) {
+VERIFY_OOP(obj->obj_field(field_offset));
 SET_STACK_OBJECT(obj->obj_field(field_offset), -1);
 } else if (tos_type == itos) {
 SET_STACK_INT(obj->int_field(field_offset), -1);
 } else if (tos_type == ltos) {
 SET_STACK_LONG(obj->long_field(field_offset), 0);
 if (cache->is_long() || cache->is_double()) {
 obj = (oop) STACK_OBJECT(-3);
 } else {
 obj = (oop) STACK_OBJECT(-2);
 }
+VERIFY_OOP(obj);
 }
 CALL_VM(InterpreterRuntime::post_field_modification(THREAD,
 obj,
 cache,
 int field_offset = cache->f2();
 if (cache->is_volatile()) {
 if (tos_type == itos) {
 obj->release_int_field_put(field_offset, STACK_INT(-1));
 } else if (tos_type == atos) {
+VERIFY_OOP(STACK_OBJECT(-1));
 obj->release_obj_field_put(field_offset, STACK_OBJECT(-1));
 OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)obj >> CardTableModRefBS::card_shift], 0);
 } else if (tos_type == btos) {
 obj->release_byte_field_put(field_offset, STACK_INT(-1));
 } else if (tos_type == ltos) {
 OrderAccess::storeload();
 } else {
 if (tos_type == itos) {
 obj->int_field_put(field_offset, STACK_INT(-1));
 } else if (tos_type == atos) {
+VERIFY_OOP(STACK_OBJECT(-1));
 obj->obj_field_put(field_offset, STACK_OBJECT(-1));
 OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)obj >> CardTableModRefBS::card_shift], 0);
 } else if (tos_type == btos) {
 obj->byte_field_put(field_offset, STACK_INT(-1));
 } else if (tos_type == ltos) {
 THREAD->set_vm_result(NULL);
 UPDATE_PC_AND_TOS_AND_CONTINUE(4, -(dims-1));
 }
 CASE(_checkcast):
 if (STACK_OBJECT(-1) != NULL) {
+VERIFY_OOP(STACK_OBJECT(-1));
 u2 index = Bytes::get_Java_u2(pc+1);
 if (ProfileInterpreter) {
 // needs Profile_checkcast QQQ
 ShouldNotReachHere();
 }
 CASE(_instanceof):
 if (STACK_OBJECT(-1) == NULL) {
 SET_STACK_INT(0, -1);
 } else {
+VERIFY_OOP(STACK_OBJECT(-1));
 u2 index = Bytes::get_Java_u2(pc+1);
 // 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);
 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);
 break;
 case JVM_CONSTANT_Class:
+VERIFY_OOP(constants->resolved_klass_at(index)->klass_part()->java_mirror());
 SET_STACK_OBJECT(constants->resolved_klass_at(index)->klass_part()->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);
 break;
-#if 0
-CASE(_fast_igetfield):
-CASE(_fastagetfield):
-CASE(_fast_aload_0):
-CASE(_fast_iaccess_0):
-CASE(__fast_aaccess_0):
-CASE(_fast_linearswitch):
-CASE(_fast_binaryswitch):
-fatal("unsupported fast bytecode");
-#endif
 default:  ShouldNotReachHere();
 }
 UPDATE_PC_AND_TOS_AND_CONTINUE(incr, 1);
 }
 callee = (methodOop) cache->f2();
 } else {
 // get receiver
 int parms = cache->parameter_size();
 // Same comments as invokevirtual apply here
+VERIFY_OOP(STACK_OBJECT(-parms));
 instanceKlass* rcvrKlass = (instanceKlass*)
 STACK_OBJECT(-parms)->klass()->klass_part();
 callee = (methodOop) rcvrKlass->start_of_vtable()[ cache->f2()];
 }
 istate->set_callee(callee);
 // methodOop callee = rcvr->klass()->klass_part()->vtable()->method_at(cache->f2());
 //
 // this fails with an assert
 // 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();
 /*
 Executing this code in java.lang.String:
 public String(char value[]) {
 this.count = value.length;
 //
 THREAD->popframe_preserve_args(in_ByteSize(METHOD->size_of_parameters() * wordSize),
 LOCALS_SLOT(METHOD->size_of_parameters() - 1));
 THREAD->set_popframe_condition_bit(JavaThread::popframe_force_deopt_reexecution_bit);
 }
-UPDATE_PC_AND_RETURN(1);
+THREAD->clr_pop_frame_in_process();
-} else {
-// Normal return
-// Advance the pc and return to frame manager
-istate->set_msg(return_from_method);
-istate->set_return_kind((Bytecodes::Code)opcode);
-UPDATE_PC_AND_RETURN(1);
 }
+// Normal return
+// Advance the pc and return to frame manager
+istate->set_msg(return_from_method);
+istate->set_return_kind((Bytecodes::Code)opcode);
+UPDATE_PC_AND_RETURN(1);
 } /* handle_return: */
 // This is really a fatal error return
 finish:

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

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

src/share/vm/interpreter/bytecodeInterpreter.cpp