jdk-sandbox: comparison hotspot/src/cpu/ppc/vm/interpreter

equal deleted inserted replaced

-:fc827339dc37
+:b70675ece1ce
 /*
-* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
-* Copyright 2012, 2013 SAP AG. All rights reserved.
+* Copyright 2012, 2014 SAP AG. 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.
 #include "utilities/debug.hpp"
 #ifdef COMPILER1
 #include "c1/c1_Runtime1.hpp"
 #endif
-#ifndef CC_INTERP
-#error "CC_INTERP must be defined on PPC"
-#endif
 #define __ _masm->
 #ifdef PRODUCT
 #define BLOCK_COMMENT(str) // nothing
 #else
 // Reload method, it may have moved.
 #ifdef CC_INTERP
 __ ld(R19_method, state_(_method));
 #else
-__ unimplemented("slow signature handler 1");
+__ ld(R19_method, 0, target_sp);
+__ ld(R19_method, _ijava_state_neg(method), R19_method);
 #endif
 // Get the result handler.
 __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::get_result_handler), R16_thread, R19_method);
 // Reload method, it may have moved.
 #ifdef CC_INTERP
 __ ld(R19_method, state_(_method));
 #else
-__ unimplemented("slow signature handler 2");
+__ ld(R19_method, 0, target_sp);
+__ ld(R19_method, _ijava_state_neg(method), R19_method);
 #endif
 {
 Label L;
 // test if static
 address entry = __ pc();
 //
 // Registers alive
 //   R16_thread     - JavaThread*
-//   R19_method     - callee's methodOop (method to be invoked)
+//   R19_method     - callee's method (method to be invoked)
 //   R1_SP          - SP prepared such that caller's outgoing args are near top
 //   LR             - return address to caller
 //
 // Stack layout at this point:
 //
 #ifdef CC_INTERP
 // Return to frame manager, it will handle the pending exception.
 __ blr();
 #else
-Unimplemented();
+// We don't know our caller, so jump to the general forward exception stub,
+// which will also pop our full frame off. Satisfy the interface of
+// SharedRuntime::generate_forward_exception()
+__ load_const_optimized(R11_scratch1, StubRoutines::forward_exception_entry(), R0);
+__ mtctr(R11_scratch1);
+__ bctr();
 #endif
 return entry;
 }
 // Call an accessor method (assuming it is resolved, otherwise drop into
 // vanilla (slow path) entry.
 address InterpreterGenerator::generate_accessor_entry(void) {
-if(!UseFastAccessorMethods && (!FLAG_IS_ERGO(UseFastAccessorMethods)))
+if (!UseFastAccessorMethods && (!FLAG_IS_ERGO(UseFastAccessorMethods))) {
 return NULL;
+}
 Label Lslow_path, Lacquire;
 const Register
 Rclass_or_obj = R3_ARG1,
 __ mr(R1_SP, R21_sender_SP); // Cut the stack back to where the caller started.
 // Load from branch table and dispatch (volatile case: one instruction ahead)
 __ sldi(Rflags, Rflags, LogBytesPerWord);
 __ cmpwi(CCR6, Rscratch, 1); // volatile?
-__ sldi(Rscratch, Rscratch, exact_log2(BytesPerInstWord)); // volatile ? size of 1 instruction : 0
+if (support_IRIW_for_not_multiple_copy_atomic_cpu) {
+__ sldi(Rscratch, Rscratch, exact_log2(BytesPerInstWord)); // volatile ? size of 1 instruction : 0
+}
 __ ldx(Rbtable, Rbtable, Rflags);
-__ subf(Rbtable, Rscratch, Rbtable); // point to volatile/non-volatile entry point
+if (support_IRIW_for_not_multiple_copy_atomic_cpu) {
+__ subf(Rbtable, Rscratch, Rbtable); // point to volatile/non-volatile entry point
+}
 __ mtctr(Rbtable);
 __ bctr();
 #ifdef ASSERT
 __ bind(LFlagInvalid);
 all_uninitialized = all_uninitialized && (branch_table[i] == NULL);
 all_initialized   = all_initialized   && (branch_table[i] != NULL);
 }
 assert(all_uninitialized != all_initialized, "consistency"); // either or
-__ sync(); // volatile entry point (one instruction before non-volatile_entry point)
+__ fence(); // volatile entry point (one instruction before non-volatile_entry point)
 if (branch_table[vtos] == 0) branch_table[vtos] = __ pc(); // non-volatile_entry point
 if (branch_table[dtos] == 0) branch_table[dtos] = __ pc(); // non-volatile_entry point
 if (branch_table[ftos] == 0) branch_table[ftos] = __ pc(); // non-volatile_entry point
 __ stop("unexpected type", 0x6551);
 #endif
 if (branch_table[itos] == 0) { // generate only once
 __ align(32, 28, 28); // align load
-__ sync(); // volatile entry point (one instruction before non-volatile_entry point)
+__ fence(); // volatile entry point (one instruction before non-volatile_entry point)
 branch_table[itos] = __ pc(); // non-volatile_entry point
 __ lwax(R3_RET, Rclass_or_obj, Roffset);
 __ beq(CCR6, Lacquire);
 __ blr();
 }
 if (branch_table[ltos] == 0) { // generate only once
 __ align(32, 28, 28); // align load
-__ sync(); // volatile entry point (one instruction before non-volatile_entry point)
+__ fence(); // volatile entry point (one instruction before non-volatile_entry point)
 branch_table[ltos] = __ pc(); // non-volatile_entry point
 __ ldx(R3_RET, Rclass_or_obj, Roffset);
 __ beq(CCR6, Lacquire);
 __ blr();
 }
 if (branch_table[btos] == 0) { // generate only once
 __ align(32, 28, 28); // align load
-__ sync(); // volatile entry point (one instruction before non-volatile_entry point)
+__ fence(); // volatile entry point (one instruction before non-volatile_entry point)
 branch_table[btos] = __ pc(); // non-volatile_entry point
 __ lbzx(R3_RET, Rclass_or_obj, Roffset);
 __ extsb(R3_RET, R3_RET);
 __ beq(CCR6, Lacquire);
 __ blr();
 }
 if (branch_table[ctos] == 0) { // generate only once
 __ align(32, 28, 28); // align load
-__ sync(); // volatile entry point (one instruction before non-volatile_entry point)
+__ fence(); // volatile entry point (one instruction before non-volatile_entry point)
 branch_table[ctos] = __ pc(); // non-volatile_entry point
 __ lhzx(R3_RET, Rclass_or_obj, Roffset);
 __ beq(CCR6, Lacquire);
 __ blr();
 }
 if (branch_table[stos] == 0) { // generate only once
 __ align(32, 28, 28); // align load
-__ sync(); // volatile entry point (one instruction before non-volatile_entry point)
+__ fence(); // volatile entry point (one instruction before non-volatile_entry point)
 branch_table[stos] = __ pc(); // non-volatile_entry point
 __ lhax(R3_RET, Rclass_or_obj, Roffset);
 __ beq(CCR6, Lacquire);
 __ blr();
 }
 if (branch_table[atos] == 0) { // generate only once
 __ align(32, 28, 28); // align load
-__ sync(); // volatile entry point (one instruction before non-volatile_entry point)
+__ fence(); // volatile entry point (one instruction before non-volatile_entry point)
 branch_table[atos] = __ pc(); // non-volatile_entry point
 __ load_heap_oop(R3_RET, (RegisterOrConstant)Roffset, Rclass_or_obj);
 __ verify_oop(R3_RET);
 //__ dcbt(R3_RET); // prefetch
 __ beq(CCR6, Lacquire);
 //tty->print_cr("accessor_entry: branch_table[%d] = 0x%llx (opcode 0x%llx)", i, branch_table[i], *((unsigned int*)branch_table[i]));
 }
 #endif
 __ bind(Lslow_path);
-assert(Interpreter::entry_for_kind(Interpreter::zerolocals), "Normal entry must have been generated by now");
+__ branch_to_entry(Interpreter::entry_for_kind(Interpreter::zerolocals), Rscratch);
-__ load_const_optimized(Rscratch, Interpreter::entry_for_kind(Interpreter::zerolocals), R0);
-__ mtctr(Rscratch);
-__ bctr();
 __ flush();
 return entry;
 }
 __ blr();
 // Generate regular method entry.
 __ bind(slow_path);
-assert(Interpreter::entry_for_kind(Interpreter::zerolocals), "Normal entry must have been generated by now");
+__ branch_to_entry(Interpreter::entry_for_kind(Interpreter::zerolocals), R11_scratch1);
-__ load_const_optimized(R11_scratch1, Interpreter::entry_for_kind(Interpreter::zerolocals), R0);
-__ mtctr(R11_scratch1);
-__ bctr();
 __ flush();
 return entry;
 } else {
 return generate_accessor_entry();

changeset 23221	b70675ece1ce
parent 23211	954e3a81da29
child 24349	d8f40e5b392d