--- a/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp Fri Apr 02 15:55:04 2010 -0700
@@ -206,7 +206,6 @@
// Update the invocation counter
if ((UseCompiler || CountCompiledCalls) && !method->is_synchronized()) {
- thread->set_do_not_unlock();
InvocationCounter *counter = method->invocation_counter();
counter->increment();
if (counter->reached_InvocationLimit()) {
@@ -215,7 +214,6 @@
if (HAS_PENDING_EXCEPTION)
goto unwind_and_return;
}
- thread->clr_do_not_unlock();
}
// Lock if necessary
--- a/hotspot/src/cpu/zero/vm/methodHandles_zero.cpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/cpu/zero/vm/methodHandles_zero.cpp Fri Apr 02 15:55:04 2010 -0700
@@ -1,6 +1,6 @@
/*
* Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * Copyright 2009, 2010 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
@@ -23,4 +23,10 @@
*
*/
-// This file is intentionally empty
+#include "incls/_precompiled.incl"
+#include "incls/_methodHandles_zero.cpp.incl"
+
+void MethodHandles::generate_method_handle_stub(MacroAssembler* masm,
+ MethodHandles::EntryKind ek) {
+ ShouldNotCallThis();
+}
--- a/hotspot/src/cpu/zero/vm/stubRoutines_zero.hpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/cpu/zero/vm/stubRoutines_zero.hpp Fri Apr 02 15:55:04 2010 -0700
@@ -1,6 +1,6 @@
/*
* Copyright 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
- * Copyright 2007, 2008, 2009 Red Hat, Inc.
+ * Copyright 2007, 2008, 2009, 2010 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
@@ -41,6 +41,10 @@
code_size2 = 0 // if these are too small. Simply increase
}; // them if that happens.
+ enum method_handles_platform_dependent_constants {
+ method_handles_adapters_code_size = 0
+ };
+
#ifdef IA32
class x86 {
friend class VMStructs;
--- a/hotspot/src/share/vm/ci/ciConstant.cpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/share/vm/ci/ciConstant.cpp Fri Apr 02 15:55:04 2010 -0700
@@ -36,7 +36,7 @@
basictype_to_str(basic_type()));
switch (basic_type()) {
case T_BOOLEAN:
- tty->print("%s", bool_to_str(_value._int == 0));
+ tty->print("%s", bool_to_str(_value._int != 0));
break;
case T_CHAR:
case T_BYTE:
--- a/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Fri Apr 02 15:55:04 2010 -0700
@@ -2328,6 +2328,17 @@
}
DEFAULT:
+#ifdef ZERO
+ // Some zero configurations use the C++ interpreter as a
+ // fallback interpreter and have support for platform
+ // specific fast bytecodes which aren't supported here, so
+ // redispatch to the equivalent non-fast bytecode when they
+ // are encountered.
+ if (Bytecodes::is_defined((Bytecodes::Code)opcode)) {
+ opcode = (jubyte)Bytecodes::java_code((Bytecodes::Code)opcode);
+ goto opcode_switch;
+ }
+#endif
fatal2("\t*** Unimplemented opcode: %d = %s\n",
opcode, Bytecodes::name((Bytecodes::Code)opcode));
goto finish;
--- a/hotspot/src/share/vm/opto/doCall.cpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/share/vm/opto/doCall.cpp Fri Apr 02 15:55:04 2010 -0700
@@ -714,8 +714,6 @@
// iterate through all entries sequentially
for (;!handlers.is_done(); handlers.next()) {
- // Do nothing if turned off
- if( !DeutschShiffmanExceptions ) break;
ciExceptionHandler* handler = handlers.handler();
if (handler->is_rethrow()) {
@@ -741,46 +739,26 @@
return; // No more handling to be done here!
}
- // %%% The following logic replicates make_from_klass_unique.
- // TO DO: Replace by a subroutine call. Then generalize
- // the type check, as noted in the next "%%%" comment.
-
+ // Get the handler's klass
ciInstanceKlass* klass = handler->catch_klass();
- if (UseUniqueSubclasses) {
- // (We use make_from_klass because it respects UseUniqueSubclasses.)
- const TypeOopPtr* tp = TypeOopPtr::make_from_klass(klass);
- klass = tp->klass()->as_instance_klass();
+
+ if (!klass->is_loaded()) { // klass is not loaded?
+ // fall through into catch_call_exceptions which will emit a
+ // handler with an uncommon trap.
+ break;
}
- // Get the handler's klass
- if (!klass->is_loaded()) // klass is not loaded?
- break; // Must call Rethrow!
if (klass->is_interface()) // should not happen, but...
break; // bail out
- // See if the loaded exception klass has no subtypes
- if (klass->has_subklass())
- break; // Cannot easily do precise test ==> Rethrow
- // %%% Now that subclass checking is very fast, we need to rewrite
- // this section and remove the option "DeutschShiffmanExceptions".
- // The exception processing chain should be a normal typecase pattern,
- // with a bailout to the interpreter only in the case of unloaded
- // classes. (The bailout should mark the method non-entrant.)
- // This rewrite should be placed in GraphKit::, not Parse::.
-
- // Add a dependence; if any subclass added we need to recompile
- // %%% should use stronger assert_unique_concrete_subtype instead
- if (!klass->is_final()) {
- C->dependencies()->assert_leaf_type(klass);
- }
-
- // Implement precise test
+ // Check the type of the exception against the catch type
const TypeKlassPtr *tk = TypeKlassPtr::make(klass);
Node* con = _gvn.makecon(tk);
- Node* cmp = _gvn.transform( new (C, 3) CmpPNode(ex_klass_node, con) );
- Node* bol = _gvn.transform( new (C, 2) BoolNode(cmp, BoolTest::ne) );
- { BuildCutout unless(this, bol, PROB_LIKELY(0.7f));
- const TypeInstPtr* tinst = TypeInstPtr::make_exact(TypePtr::NotNull, klass);
+ Node* not_subtype_ctrl = gen_subtype_check(ex_klass_node, con);
+ if (!stopped()) {
+ PreserveJVMState pjvms(this);
+ const TypeInstPtr* tinst = TypeOopPtr::make_from_klass_unique(klass)->cast_to_ptr_type(TypePtr::NotNull)->is_instptr();
+ assert(klass->has_subklass() || tinst->klass_is_exact(), "lost exactness");
Node* ex_oop = _gvn.transform(new (C, 2) CheckCastPPNode(control(), ex_node, tinst));
push_ex_oop(ex_oop); // Push exception oop for handler
#ifndef PRODUCT
@@ -792,6 +770,7 @@
#endif
merge_exception(handler_bci);
}
+ set_control(not_subtype_ctrl);
// Come here if exception does not match handler.
// Carry on with more handler checks.
@@ -800,21 +779,6 @@
assert(!stopped(), "you should return if you finish the chain");
- if (remaining == 1) {
- // Further checks do not matter.
- }
-
- if (can_rerun_bytecode()) {
- // Do not push_ex_oop here!
- // Re-executing the bytecode will reproduce the throwing condition.
- bool must_throw = true;
- uncommon_trap(Deoptimization::Reason_unhandled,
- Deoptimization::Action_none,
- (ciKlass*)NULL, (const char*)NULL, // default args
- must_throw);
- return;
- }
-
// Oops, need to call into the VM to resolve the klasses at runtime.
// Note: This call must not deoptimize, since it is not a real at this bci!
kill_dead_locals();
--- a/hotspot/src/share/vm/opto/parse.hpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/share/vm/opto/parse.hpp Fri Apr 02 15:55:04 2010 -0700
@@ -551,9 +551,6 @@
// Also handles exceptions for individual bytecodes.
void catch_inline_exceptions(SafePointNode* ex_map);
- // Bytecode classifier, helps decide to use uncommon_trap vs. rethrow_C.
- bool can_rerun_bytecode();
-
// Merge the given map into correct exceptional exit state.
// Assumes that there is no applicable local handler.
void throw_to_exit(SafePointNode* ex_map);
--- a/hotspot/src/share/vm/opto/parse1.cpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/share/vm/opto/parse1.cpp Fri Apr 02 15:55:04 2010 -0700
@@ -798,67 +798,6 @@
initial_gvn()->transform_no_reclaim(exit);
}
-bool Parse::can_rerun_bytecode() {
- switch (bc()) {
- case Bytecodes::_ldc:
- case Bytecodes::_ldc_w:
- case Bytecodes::_ldc2_w:
- case Bytecodes::_getfield:
- case Bytecodes::_putfield:
- case Bytecodes::_getstatic:
- case Bytecodes::_putstatic:
- case Bytecodes::_arraylength:
- case Bytecodes::_baload:
- case Bytecodes::_caload:
- case Bytecodes::_iaload:
- case Bytecodes::_saload:
- case Bytecodes::_faload:
- case Bytecodes::_aaload:
- case Bytecodes::_laload:
- case Bytecodes::_daload:
- case Bytecodes::_bastore:
- case Bytecodes::_castore:
- case Bytecodes::_iastore:
- case Bytecodes::_sastore:
- case Bytecodes::_fastore:
- case Bytecodes::_aastore:
- case Bytecodes::_lastore:
- case Bytecodes::_dastore:
- case Bytecodes::_irem:
- case Bytecodes::_idiv:
- case Bytecodes::_lrem:
- case Bytecodes::_ldiv:
- case Bytecodes::_frem:
- case Bytecodes::_fdiv:
- case Bytecodes::_drem:
- case Bytecodes::_ddiv:
- case Bytecodes::_checkcast:
- case Bytecodes::_instanceof:
- case Bytecodes::_anewarray:
- case Bytecodes::_newarray:
- case Bytecodes::_multianewarray:
- case Bytecodes::_new:
- case Bytecodes::_monitorenter: // can re-run initial null check, only
- case Bytecodes::_return:
- return true;
- break;
-
- // Don't rerun athrow since it's part of the exception path.
- case Bytecodes::_athrow:
- case Bytecodes::_invokestatic:
- case Bytecodes::_invokedynamic:
- case Bytecodes::_invokespecial:
- case Bytecodes::_invokevirtual:
- case Bytecodes::_invokeinterface:
- return false;
- break;
-
- default:
- assert(false, "unexpected bytecode produced an exception");
- return true;
- }
-}
-
//---------------------------do_exceptions-------------------------------------
// Process exceptions arising from the current bytecode.
// Send caught exceptions to the proper handler within this method.
@@ -872,9 +811,6 @@
return;
}
- // Make sure we can classify this bytecode if we need to.
- debug_only(can_rerun_bytecode());
-
PreserveJVMState pjvms(this, false);
SafePointNode* ex_map;
--- a/hotspot/src/share/vm/prims/forte.cpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/share/vm/prims/forte.cpp Fri Apr 02 15:55:04 2010 -0700
@@ -55,12 +55,11 @@
};
-static void is_decipherable_compiled_frame(frame* fr, RegisterMap* map,
- bool* is_compiled_p, bool* is_walkable_p);
+static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm);
static bool is_decipherable_interpreted_frame(JavaThread* thread,
- frame* fr,
- methodOop* method_p,
- int* bci_p);
+ frame* fr,
+ methodOop* method_p,
+ int* bci_p);
@@ -122,41 +121,43 @@
// Determine if 'fr' is a decipherable compiled frame. We are already
// assured that fr is for a java nmethod.
-static bool is_decipherable_compiled_frame(frame* fr) {
-
- assert(fr->cb() != NULL && fr->cb()->is_nmethod(), "invariant");
- nmethod* nm = (nmethod*) fr->cb();
+static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm) {
assert(nm->is_java_method(), "invariant");
- // First try and find an exact PcDesc
-
- PcDesc* pc_desc = nm->pc_desc_at(fr->pc());
-
- // Did we find a useful PcDesc?
- if (pc_desc != NULL &&
- pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
-
- address probe_pc = fr->pc() + 1;
- pc_desc = nm->pc_desc_near(probe_pc);
+ if (thread->has_last_Java_frame() && thread->last_Java_pc() == fr->pc()) {
+ // We're stopped at a call into the JVM so look for a PcDesc with
+ // the actual pc reported by the frame.
+ PcDesc* pc_desc = nm->pc_desc_at(fr->pc());
- // Now do we have a useful PcDesc?
-
+ // Did we find a useful PcDesc?
if (pc_desc != NULL &&
- pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
- // No debug information available for this pc
- // vframeStream would explode if we try and walk the frames.
- return false;
+ pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) {
+ return true;
}
-
- // This PcDesc is useful however we must adjust the frame's pc
- // so that the vframeStream lookups will use this same pc
-
- fr->set_pc(pc_desc->real_pc(nm));
}
+ // We're at some random pc in the nmethod so search for the PcDesc
+ // whose pc is greater than the current PC. It's done this way
+ // because the extra PcDescs that are recorded for improved debug
+ // info record the end of the region covered by the ScopeDesc
+ // instead of the beginning.
+ PcDesc* pc_desc = nm->pc_desc_near(fr->pc() + 1);
+
+ // Now do we have a useful PcDesc?
+ if (pc_desc == NULL ||
+ pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
+ // No debug information available for this pc
+ // vframeStream would explode if we try and walk the frames.
+ return false;
+ }
+
+ // This PcDesc is useful however we must adjust the frame's pc
+ // so that the vframeStream lookups will use this same pc
+ fr->set_pc(pc_desc->real_pc(nm));
return true;
}
+
// Determine if 'fr' is a walkable interpreted frame. Returns false
// if it is not. *method_p, and *bci_p are not set when false is
// returned. *method_p is non-NULL if frame was executing a Java
@@ -166,9 +167,9 @@
// even if a valid BCI cannot be found.
static bool is_decipherable_interpreted_frame(JavaThread* thread,
- frame* fr,
- methodOop* method_p,
- int* bci_p) {
+ frame* fr,
+ methodOop* method_p,
+ int* bci_p) {
assert(fr->is_interpreted_frame(), "just checking");
// top frame is an interpreted frame
@@ -323,13 +324,15 @@
// have a PCDesc that can get us a bci however we did find
// a method
- if (!is_decipherable_compiled_frame(&candidate)) {
+ if (!is_decipherable_compiled_frame(thread, &candidate, nm)) {
return false;
}
// is_decipherable_compiled_frame may modify candidate's pc
*initial_frame_p = candidate;
+ assert(nm->pc_desc_at(candidate.pc()) != NULL, "if it's decipherable then pc must be valid");
+
return true;
}
--- a/hotspot/src/share/vm/runtime/globals.hpp Wed Jul 05 17:09:16 2017 +0200
+++ b/hotspot/src/share/vm/runtime/globals.hpp Fri Apr 02 15:55:04 2010 -0700
@@ -2502,10 +2502,6 @@
notproduct(bool, TraceSpilling, false, \
"Trace spilling") \
\
- develop(bool, DeutschShiffmanExceptions, true, \
- "Fast check to find exception handler for precisely typed " \
- "exceptions") \
- \
product(bool, SplitIfBlocks, true, \
"Clone compares and control flow through merge points to fold " \
"some branches") \