jdk8-mips64-public/hotspot: src/cpu/sparc/vm/interpreter

src/cpu/sparc/vm/interpreter_sparc.cpp@e1162778c1c8 (annotated)

src/cpu/sparc/vm/interpreter_sparc.cpp

Thu, 07 Apr 2011 09:53:20 -0700

author: johnc
date: Thu, 07 Apr 2011 09:53:20 -0700
changeset 2781: e1162778c1c8
parent 2639: 8033953d67ff
child 2784: 92add02409c9
permissions: -rw-r--r--

7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes

 /*
  * Copyright (c) 1997, 2011, 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.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "asm/assembler.hpp"
 #include "interpreter/bytecodeHistogram.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/interpreterGenerator.hpp"
 #include "interpreter/interpreterRuntime.hpp"
 #include "interpreter/templateTable.hpp"
 #include "oops/arrayOop.hpp"
 #include "oops/methodDataOop.hpp"
 #include "oops/methodOop.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "prims/methodHandles.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/deoptimization.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/synchronizer.hpp"
 #include "runtime/timer.hpp"
 #include "runtime/vframeArray.hpp"
 #include "utilities/debug.hpp"
 #ifdef COMPILER1
 #include "c1/c1_Runtime1.hpp"
 #endif
 // Generation of Interpreter
 //
 // The InterpreterGenerator generates the interpreter into Interpreter::_code.
 #define __ _masm->
 //----------------------------------------------------------------------------------------------------
 int AbstractInterpreter::BasicType_as_index(BasicType type) {
   int i = 0;
   switch (type) {
     case T_BOOLEAN: i = 0; break;
     case T_CHAR   : i = 1; break;
     case T_BYTE   : i = 2; break;
     case T_SHORT  : i = 3; break;
     case T_INT    : i = 4; break;
     case T_LONG   : i = 5; break;
     case T_VOID   : i = 6; break;
     case T_FLOAT  : i = 7; break;
     case T_DOUBLE : i = 8; break;
     case T_OBJECT : i = 9; break;
     case T_ARRAY  : i = 9; break;
     default       : ShouldNotReachHere();
   }
   assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, "index out of bounds");
   return i;
 }
 #ifndef _LP64
 address AbstractInterpreterGenerator::generate_slow_signature_handler() {
   address entry = __ pc();
   Argument argv(0, true);
   // We are in the jni transition frame. Save the last_java_frame corresponding to the
   // outer interpreter frame
   //
   __ set_last_Java_frame(FP, noreg);
   // make sure the interpreter frame we've pushed has a valid return pc
   __ mov(O7, I7);
   __ mov(Lmethod, G3_scratch);
   __ mov(Llocals, G4_scratch);
   __ save_frame(0);
   __ mov(G2_thread, L7_thread_cache);
   __ add(argv.address_in_frame(), O3);
   __ mov(G2_thread, O0);
   __ mov(G3_scratch, O1);
   __ call(CAST_FROM_FN_PTR(address, InterpreterRuntime::slow_signature_handler), relocInfo::runtime_call_type);
   __ delayed()->mov(G4_scratch, O2);
   __ mov(L7_thread_cache, G2_thread);
   __ reset_last_Java_frame();
   // load the register arguments (the C code packed them as varargs)
   for (Argument ldarg = argv.successor(); ldarg.is_register(); ldarg = ldarg.successor()) {
       __ ld_ptr(ldarg.address_in_frame(), ldarg.as_register());
   }
   __ ret();
   __ delayed()->
      restore(O0, 0, Lscratch);  // caller's Lscratch gets the result handler
   return entry;
 }
 #else
 // LP64 passes floating point arguments in F1, F3, F5, etc. instead of
 // O0, O1, O2 etc..
 // Doubles are passed in D0, D2, D4
 // We store the signature of the first 16 arguments in the first argument
 // slot because it will be overwritten prior to calling the native
 // function, with the pointer to the JNIEnv.
 // If LP64 there can be up to 16 floating point arguments in registers
 // or 6 integer registers.
 address AbstractInterpreterGenerator::generate_slow_signature_handler() {
   enum {
     non_float  = 0,
     float_sig  = 1,
     double_sig = 2,
     sig_mask   = 3
   };
   address entry = __ pc();
   Argument argv(0, true);
   // We are in the jni transition frame. Save the last_java_frame corresponding to the
   // outer interpreter frame
   //
   __ set_last_Java_frame(FP, noreg);
   // make sure the interpreter frame we've pushed has a valid return pc
   __ mov(O7, I7);
   __ mov(Lmethod, G3_scratch);
   __ mov(Llocals, G4_scratch);
   __ save_frame(0);
   __ mov(G2_thread, L7_thread_cache);
   __ add(argv.address_in_frame(), O3);
   __ mov(G2_thread, O0);
   __ mov(G3_scratch, O1);
   __ call(CAST_FROM_FN_PTR(address, InterpreterRuntime::slow_signature_handler), relocInfo::runtime_call_type);
   __ delayed()->mov(G4_scratch, O2);
   __ mov(L7_thread_cache, G2_thread);
   __ reset_last_Java_frame();
   // load the register arguments (the C code packed them as varargs)
   Address Sig = argv.address_in_frame();        // Argument 0 holds the signature
   __ ld_ptr( Sig, G3_scratch );                   // Get register argument signature word into G3_scratch
   __ mov( G3_scratch, G4_scratch);
   __ srl( G4_scratch, 2, G4_scratch);             // Skip Arg 0
   Label done;
   for (Argument ldarg = argv.successor(); ldarg.is_float_register(); ldarg = ldarg.successor()) {
     Label NonFloatArg;
     Label LoadFloatArg;
     Label LoadDoubleArg;
     Label NextArg;
     Address a = ldarg.address_in_frame();
     __ andcc(G4_scratch, sig_mask, G3_scratch);
     __ br(Assembler::zero, false, Assembler::pt, NonFloatArg);
     __ delayed()->nop();
     __ cmp(G3_scratch, float_sig );
     __ br(Assembler::equal, false, Assembler::pt, LoadFloatArg);
     __ delayed()->nop();
     __ cmp(G3_scratch, double_sig );
     __ br(Assembler::equal, false, Assembler::pt, LoadDoubleArg);
     __ delayed()->nop();
     __ bind(NonFloatArg);
     // There are only 6 integer register arguments!
     if ( ldarg.is_register() )
       __ ld_ptr(ldarg.address_in_frame(), ldarg.as_register());
     else {
     // Optimization, see if there are any more args and get out prior to checking
     // all 16 float registers.  My guess is that this is rare.
     // If is_register is false, then we are done the first six integer args.
       __ tst(G4_scratch);
       __ brx(Assembler::zero, false, Assembler::pt, done);
       __ delayed()->nop();
     }
     __ ba(false, NextArg);
     __ delayed()->srl( G4_scratch, 2, G4_scratch );
     __ bind(LoadFloatArg);
     __ ldf( FloatRegisterImpl::S, a, ldarg.as_float_register(), 4);
     __ ba(false, NextArg);
     __ delayed()->srl( G4_scratch, 2, G4_scratch );
     __ bind(LoadDoubleArg);
     __ ldf( FloatRegisterImpl::D, a, ldarg.as_double_register() );
     __ ba(false, NextArg);
     __ delayed()->srl( G4_scratch, 2, G4_scratch );
     __ bind(NextArg);
   }
   __ bind(done);
   __ ret();
   __ delayed()->
      restore(O0, 0, Lscratch);  // caller's Lscratch gets the result handler
   return entry;
 }
 #endif
 void InterpreterGenerator::generate_counter_overflow(Label& Lcontinue) {
   // Generate code to initiate compilation on the counter overflow.
   // InterpreterRuntime::frequency_counter_overflow takes two arguments,
   // the first indicates if the counter overflow occurs at a backwards branch (NULL bcp)
   // and the second is only used when the first is true.  We pass zero for both.
   // The call returns the address of the verified entry point for the method or NULL
   // if the compilation did not complete (either went background or bailed out).
   __ set((int)false, O2);
   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), O2, O2, true);
   // returns verified_entry_point or NULL
   // we ignore it in any case
   __ ba(false, Lcontinue);
   __ delayed()->nop();
 }
 // End of helpers
 // Various method entries
 // Abstract method entry
 // Attempt to execute abstract method. Throw exception
 //
 address InterpreterGenerator::generate_abstract_entry(void) {
   address entry = __ pc();
   // abstract method entry
   // throw exception
   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError));
   // the call_VM checks for exception, so we should never return here.
   __ should_not_reach_here();
   return entry;
 }
 // Method handle invoker
 // Dispatch a method of the form java.lang.invoke.MethodHandles::invoke(...)
 address InterpreterGenerator::generate_method_handle_entry(void) {
   if (!EnableMethodHandles) {
     return generate_abstract_entry();
   }
   return MethodHandles::generate_method_handle_interpreter_entry(_masm);
 }
 //----------------------------------------------------------------------------------------------------
 // Entry points & stack frame layout
 //
 // Here we generate the various kind of entries into the interpreter.
 // The two main entry type are generic bytecode methods and native call method.
 // These both come in synchronized and non-synchronized versions but the
 // frame layout they create is very similar. The other method entry
 // types are really just special purpose entries that are really entry
 // and interpretation all in one. These are for trivial methods like
 // accessor, empty, or special math methods.
 //
 // When control flow reaches any of the entry types for the interpreter
 // the following holds ->
 //
 // C2 Calling Conventions:
 //
 // The entry code below assumes that the following registers are set
 // when coming in:
 //    G5_method: holds the methodOop of the method to call
 //    Lesp:    points to the TOS of the callers expression stack
 //             after having pushed all the parameters
 //
 // The entry code does the following to setup an interpreter frame
 //   pop parameters from the callers stack by adjusting Lesp
 //   set O0 to Lesp
 //   compute X = (max_locals - num_parameters)
 //   bump SP up by X to accomadate the extra locals
 //   compute X = max_expression_stack
 //               + vm_local_words
 //               + 16 words of register save area
 //   save frame doing a save sp, -X, sp growing towards lower addresses
 //   set Lbcp, Lmethod, LcpoolCache
 //   set Llocals to i0
 //   set Lmonitors to FP - rounded_vm_local_words
 //   set Lesp to Lmonitors - 4
 //
 //  The frame has now been setup to do the rest of the entry code
 // Try this optimization:  Most method entries could live in a
 // "one size fits all" stack frame without all the dynamic size
 // calculations.  It might be profitable to do all this calculation
 // statically and approximately for "small enough" methods.
 //-----------------------------------------------------------------------------------------------
 // C1 Calling conventions
 //
 // Upon method entry, the following registers are setup:
 //
 // g2 G2_thread: current thread
 // g5 G5_method: method to activate
 // g4 Gargs  : pointer to last argument
 //
 //
 // Stack:
 //
 // +---------------+ <--- sp
 // |               |
 // : reg save area :
 // |               |
 // +---------------+ <--- sp + 0x40
 // |               |
 // : extra 7 slots :      note: these slots are not really needed for the interpreter (fix later)
 // |               |
 // +---------------+ <--- sp + 0x5c
 // |               |
 // :     free      :
 // |               |
 // +---------------+ <--- Gargs
 // |               |
 // :   arguments   :
 // |               |
 // +---------------+
 // |               |
 //
 //
 //
 // AFTER FRAME HAS BEEN SETUP for method interpretation the stack looks like:
 //
 // +---------------+ <--- sp
 // |               |
 // : reg save area :
 // |               |
 // +---------------+ <--- sp + 0x40
 // |               |
 // : extra 7 slots :      note: these slots are not really needed for the interpreter (fix later)
 // |               |
 // +---------------+ <--- sp + 0x5c
 // |               |
 // :               :
 // |               | <--- Lesp
 // +---------------+ <--- Lmonitors (fp - 0x18)
 // |   VM locals   |
 // +---------------+ <--- fp
 // |               |
 // : reg save area :
 // |               |
 // +---------------+ <--- fp + 0x40
 // |               |
 // : extra 7 slots :      note: these slots are not really needed for the interpreter (fix later)
 // |               |
 // +---------------+ <--- fp + 0x5c
 // |               |
 // :     free      :
 // |               |
 // +---------------+
 // |               |
 // : nonarg locals :
 // |               |
 // +---------------+
 // |               |
 // :   arguments   :
 // |               | <--- Llocals
 // +---------------+ <--- Gargs
 // |               |
 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
   // determine code generation flags
   bool synchronized = false;
   address entry_point = NULL;
   switch (kind) {
     case Interpreter::zerolocals             :                                                                             break;
     case Interpreter::zerolocals_synchronized: synchronized = true;                                                        break;
     case Interpreter::native                 : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false);  break;
     case Interpreter::native_synchronized    : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true);   break;
     case Interpreter::empty                  : entry_point = ((InterpreterGenerator*)this)->generate_empty_entry();        break;
     case Interpreter::accessor               : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry();     break;
     case Interpreter::abstract               : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry();     break;
     case Interpreter::method_handle          : entry_point = ((InterpreterGenerator*)this)->generate_method_handle_entry(); break;
     case Interpreter::java_lang_math_sin     :                                                                             break;
     case Interpreter::java_lang_math_cos     :                                                                             break;
     case Interpreter::java_lang_math_tan     :                                                                             break;
     case Interpreter::java_lang_math_sqrt    :                                                                             break;
     case Interpreter::java_lang_math_abs     :                                                                             break;
     case Interpreter::java_lang_math_log     :                                                                             break;
     case Interpreter::java_lang_math_log10   :                                                                             break;
     case Interpreter::java_lang_ref_reference_get
                                              : entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break;
     default                                  : ShouldNotReachHere();                                                       break;
   }
   if (entry_point) return entry_point;
   return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
 }
 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
   // No special entry points that preclude compilation
   return true;
 }
 // This method tells the deoptimizer how big an interpreted frame must be:
 int AbstractInterpreter::size_activation(methodOop method,
                                          int tempcount,
                                          int popframe_extra_args,
                                          int moncount,
                                          int callee_param_count,
                                          int callee_locals,
                                          bool is_top_frame) {
   return layout_activation(method,
                            tempcount,
                            popframe_extra_args,
                            moncount,
                            callee_param_count,
                            callee_locals,
                            (frame*)NULL,
                            (frame*)NULL,
                            is_top_frame);
 }
 void Deoptimization::unwind_callee_save_values(frame* f, vframeArray* vframe_array) {
   // This code is sort of the equivalent of C2IAdapter::setup_stack_frame back in
   // the days we had adapter frames. When we deoptimize a situation where a
   // compiled caller calls a compiled caller will have registers it expects
   // to survive the call to the callee. If we deoptimize the callee the only
   // way we can restore these registers is to have the oldest interpreter
   // frame that we create restore these values. That is what this routine
   // will accomplish.
   // At the moment we have modified c2 to not have any callee save registers
   // so this problem does not exist and this routine is just a place holder.
   assert(f->is_interpreted_frame(), "must be interpreted");
 }
 //----------------------------------------------------------------------------------------------------
 // Exceptions

Mercurial > jdk8-mips64-public > hotspot / annotate

src/cpu/sparc/vm/interpreter_sparc.cpp@e1162778c1c8 (annotated)

src/cpu/sparc/vm/interpreter_sparc.cpp