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

comparison src/share/vm/interpreter/rewriter.cpp @ 3464:be4ca325525a

Merge.

author	Thomas Wuerthinger <thomas@wuerthinger.net>
date	Wed, 27 Jul 2011 17:32:44 -0700
parents	75a99b4f1c98 2d4b2b833d29
children	04b9a2566eec

comparison

equal deleted inserted replaced

-:7c4b4daac19b
+:be4ca325525a
 "all cp cache indexes fit in a u2");
 _have_invoke_dynamic = ((tag_mask & (1 << JVM_CONSTANT_InvokeDynamic)) != 0);
 }
+// Unrewrite the bytecodes if an error occurs.
+void Rewriter::restore_bytecodes() {
+int len = _methods->length();
+for (int i = len-1; i >= 0; i--) {
+methodOop method = (methodOop)_methods->obj_at(i);
+scan_method(method, true);
+}
+}
 // Creates a constant pool cache given a CPC map
 void Rewriter::make_constant_pool_cache(TRAPS) {
 const int length = _cp_cache_map.length();
 constantPoolCacheOop cache =
 }
 }
 // Rewrite a classfile-order CP index into a native-order CPC index.
-void Rewriter::rewrite_member_reference(address bcp, int offset) {
+void Rewriter::rewrite_member_reference(address bcp, int offset, bool reverse) {
 address p = bcp + offset;
-int  cp_index    = Bytes::get_Java_u2(p);
+if (!reverse) {
-int  cache_index = cp_entry_to_cp_cache(cp_index);
+int  cp_index    = Bytes::get_Java_u2(p);
-Bytes::put_native_u2(p, cache_index);
+int  cache_index = cp_entry_to_cp_cache(cp_index);
-}
+Bytes::put_native_u2(p, cache_index);
+} else {
+int cache_index = Bytes::get_native_u2(p);
-void Rewriter::rewrite_invokedynamic(address bcp, int offset) {
+int pool_index = cp_cache_entry_pool_index(cache_index);
+Bytes::put_Java_u2(p, pool_index);
+}
+}
+void Rewriter::rewrite_invokedynamic(address bcp, int offset, bool reverse) {
 address p = bcp + offset;
-assert(p[-1] == Bytecodes::_invokedynamic, "");
+assert(p[-1] == Bytecodes::_invokedynamic, "not invokedynamic bytecode");
-int cp_index = Bytes::get_Java_u2(p);
+if (!reverse) {
-int cpc  = maybe_add_cp_cache_entry(cp_index);  // add lazily
+int cp_index = Bytes::get_Java_u2(p);
-int cpc2 = add_secondary_cp_cache_entry(cpc);
+int cpc  = maybe_add_cp_cache_entry(cp_index);  // add lazily
+int cpc2 = add_secondary_cp_cache_entry(cpc);
-// Replace the trailing four bytes with a CPC index for the dynamic
-// call site.  Unlike other CPC entries, there is one per bytecode,
+// Replace the trailing four bytes with a CPC index for the dynamic
-// not just one per distinct CP entry.  In other words, the
+// call site.  Unlike other CPC entries, there is one per bytecode,
-// CPC-to-CP relation is many-to-one for invokedynamic entries.
+// not just one per distinct CP entry.  In other words, the
-// This means we must use a larger index size than u2 to address
+// CPC-to-CP relation is many-to-one for invokedynamic entries.
-// all these entries.  That is the main reason invokedynamic
+// This means we must use a larger index size than u2 to address
-// must have a five-byte instruction format.  (Of course, other JVM
+// all these entries.  That is the main reason invokedynamic
-// implementations can use the bytes for other purposes.)
+// must have a five-byte instruction format.  (Of course, other JVM
-Bytes::put_native_u4(p, constantPoolCacheOopDesc::encode_secondary_index(cpc2));
+// implementations can use the bytes for other purposes.)
-// Note: We use native_u4 format exclusively for 4-byte indexes.
+Bytes::put_native_u4(p, constantPoolCacheOopDesc::encode_secondary_index(cpc2));
+// Note: We use native_u4 format exclusively for 4-byte indexes.
+} else {
+int cache_index = constantPoolCacheOopDesc::decode_secondary_index(
+Bytes::get_native_u4(p));
+int secondary_index = cp_cache_secondary_entry_main_index(cache_index);
+int pool_index = cp_cache_entry_pool_index(secondary_index);
+assert(_pool->tag_at(pool_index).is_invoke_dynamic(), "wrong index");
+// zero out 4 bytes
+Bytes::put_Java_u4(p, 0);
+Bytes::put_Java_u2(p, pool_index);
+}
 }
 // Rewrite some ldc bytecodes to _fast_aldc
-void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide) {
+void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide,
-assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "");
+bool reverse) {
-address p = bcp + offset;
+if (!reverse) {
-int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p);
+assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "not ldc bytecode");
-constantTag tag = _pool->tag_at(cp_index).value();
+address p = bcp + offset;
-if (tag.is_method_handle() || tag.is_method_type()) {
+int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p);
-int cache_index = cp_entry_to_cp_cache(cp_index);
+constantTag tag = _pool->tag_at(cp_index).value();
-if (is_wide) {
+if (tag.is_method_handle() || tag.is_method_type()) {
-(*bcp) = Bytecodes::_fast_aldc_w;
+int cache_index = cp_entry_to_cp_cache(cp_index);
-assert(cache_index == (u2)cache_index, "");
+if (is_wide) {
-Bytes::put_native_u2(p, cache_index);
+(*bcp) = Bytecodes::_fast_aldc_w;
-} else {
+assert(cache_index == (u2)cache_index, "index overflow");
-(*bcp) = Bytecodes::_fast_aldc;
+Bytes::put_native_u2(p, cache_index);
-assert(cache_index == (u1)cache_index, "");
+} else {
-(*p) = (u1)cache_index;
+(*bcp) = Bytecodes::_fast_aldc;
+assert(cache_index == (u1)cache_index, "index overflow");
+(*p) = (u1)cache_index;
+}
+}
+} else {
+Bytecodes::Code rewritten_bc =
+(is_wide ? Bytecodes::_fast_aldc_w : Bytecodes::_fast_aldc);
+if ((*bcp) == rewritten_bc) {
+address p = bcp + offset;
+int cache_index = is_wide ? Bytes::get_native_u2(p) : (u1)(*p);
+int pool_index = cp_cache_entry_pool_index(cache_index);
+if (is_wide) {
+(*bcp) = Bytecodes::_ldc_w;
+assert(pool_index == (u2)pool_index, "index overflow");
+Bytes::put_Java_u2(p, pool_index);
+} else {
+(*bcp) = Bytecodes::_ldc;
+assert(pool_index == (u1)pool_index, "index overflow");
+(*p) = (u1)pool_index;
+}
 }
 }
 }
 // Rewrites a method given the index_map information
-void Rewriter::scan_method(methodOop method) {
+void Rewriter::scan_method(methodOop method, bool reverse) {
 int nof_jsrs = 0;
 bool has_monitor_bytecodes = false;
 {
 );
 }
 #endif
 break;
 }
+case Bytecodes::_fast_linearswitch:
+case Bytecodes::_fast_binaryswitch: {
+#ifndef CC_INTERP
+(*bcp) = Bytecodes::_lookupswitch;
+#endif
+break;
+}
 case Bytecodes::_getstatic      : // fall through
 case Bytecodes::_putstatic      : // fall through
 case Bytecodes::_getfield       : // fall through
 case Bytecodes::_putfield       : // fall through
 case Bytecodes::_invokevirtual  : // fall through
 case Bytecodes::_invokespecial  : // fall through
 case Bytecodes::_invokestatic   :
 case Bytecodes::_invokeinterface:
-rewrite_member_reference(bcp, prefix_length+1);
+rewrite_member_reference(bcp, prefix_length+1, reverse);
 break;
 case Bytecodes::_invokedynamic:
-rewrite_invokedynamic(bcp, prefix_length+1);
+rewrite_invokedynamic(bcp, prefix_length+1, reverse);
 break;
 case Bytecodes::_ldc:
-maybe_rewrite_ldc(bcp, prefix_length+1, false);
+case Bytecodes::_fast_aldc:
+maybe_rewrite_ldc(bcp, prefix_length+1, false, reverse);
 break;
 case Bytecodes::_ldc_w:
-maybe_rewrite_ldc(bcp, prefix_length+1, true);
+case Bytecodes::_fast_aldc_w:
+maybe_rewrite_ldc(bcp, prefix_length+1, true, reverse);
 break;
 case Bytecodes::_jsr            : // fall through
 case Bytecodes::_jsr_w          : nof_jsrs++;                   break;
 case Bytecodes::_monitorenter   : // fall through
 case Bytecodes::_monitorexit    : has_monitor_bytecodes = true; break;
 // The present of a jsr bytecode implies that the method might potentially
 // have to be rewritten, so we run the oopMapGenerator on the method
 if (nof_jsrs > 0) {
 method->set_has_jsrs();
 // Second pass will revisit this method.
-assert(method->has_jsrs(), "");
+assert(method->has_jsrs(), "didn't we just set this?");
 }
 }
 // After constant pool is created, revisit methods containing jsrs.
 methodHandle Rewriter::rewrite_jsrs(methodHandle method, TRAPS) {
+ResourceMark rm(THREAD);
 ResolveOopMapConflicts romc(method);
 methodHandle original_method = method;
 method = romc.do_potential_rewrite(CHECK_(methodHandle()));
 if (method() != original_method()) {
 // Insert invalid bytecode into original methodOop and set
 method->set_guaranteed_monitor_matching();
 }
 return method;
 }
 void Rewriter::rewrite(instanceKlassHandle klass, TRAPS) {
 ResourceMark rm(THREAD);
 Rewriter     rw(klass, klass->constants(), klass->methods(), CHECK);
 // (That's all, folks.)
 }
 assert(did_rewrite, "must find Object::<init> to rewrite it");
 }
 // rewrite methods, in two passes
-int i, len = _methods->length();
+int len = _methods->length();
-for (i = len; --i >= 0; ) {
+for (int i = len-1; i >= 0; i--) {
 methodOop method = (methodOop)_methods->obj_at(i);
 scan_method(method);
 }
 // allocate constant pool cache, now that we've seen all the bytecodes
-make_constant_pool_cache(CHECK);
+make_constant_pool_cache(THREAD);
-for (i = len; --i >= 0; ) {
+// Restore bytecodes to their unrewritten state if there are exceptions
-methodHandle m(THREAD, (methodOop)_methods->obj_at(i));
+// rewriting bytecodes or allocating the cpCache
+if (HAS_PENDING_EXCEPTION) {
+restore_bytecodes();
+return;
+}
+}
+// Relocate jsr/rets in a method.  This can't be done with the rewriter
+// stage because it can throw other exceptions, leaving the bytecodes
+// pointing at constant pool cache entries.
+// Link and check jvmti dependencies while we're iterating over the methods.
+// JSR292 code calls with a different set of methods, so two entry points.
+void Rewriter::relocate_and_link(instanceKlassHandle this_oop, TRAPS) {
+objArrayHandle methods(THREAD, this_oop->methods());
+relocate_and_link(this_oop, methods, THREAD);
+}
+void Rewriter::relocate_and_link(instanceKlassHandle this_oop,
+objArrayHandle methods, TRAPS) {
+int len = methods->length();
+for (int i = len-1; i >= 0; i--) {
+methodHandle m(THREAD, (methodOop)methods->obj_at(i));
 if (m->has_jsrs()) {
 m = rewrite_jsrs(m, CHECK);
 // Method might have gotten rewritten.
-_methods->obj_at_put(i, m());
+methods->obj_at_put(i, m());
 }
-// Set up method entry points for compiler and interpreter.
+// Set up method entry points for compiler and interpreter    .
 m->link_method(m, CHECK);
+// This is for JVMTI and unrelated to relocator but the last thing we do
 #ifdef ASSERT
 if (StressMethodComparator) {
 static int nmc = 0;
 for (int j = i; j >= 0 && j >= i-4; j--) {
 if ((++nmc % 1000) == 0)  tty->print_cr("Have run MethodComparator %d times...", nmc);
-bool z = MethodComparator::methods_EMCP(m(), (methodOop)_methods->obj_at(j));
+bool z = MethodComparator::methods_EMCP(m(),
+(methodOop)methods->obj_at(j));
 if (j == i && !z) {
 tty->print("MethodComparator FAIL: "); m->print(); m->print_codes();
 assert(z, "method must compare equal to itself");
 }
 }

Mercurial > hg > truffle

comparison src/share/vm/interpreter/rewriter.cpp @ 3464:be4ca325525a