graal-jvmci-8: src/cpu/x86/vm/templateInterpreter_x86

comparison src/cpu/x86/vm/templateInterpreter_x86_64.cpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	c6a1ffc707ff 603ca7e51354
children	3489047ffea2

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 /*
-* Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2013, 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.
 //
 #ifdef GRAAL
 void graal_initialize_time(JavaThread* thread) {
+assert(ProfileInterpreter, "must be profiling interpreter");
 frame fr = thread->last_frame();
 assert(fr.is_interpreted_frame(), "must come from interpreter");
-fr.interpreter_frame_method()->set_graal_invocation_time(os::javaTimeNanos());
+assert(fr.interpreter_frame_method()->method_counters() != NULL, "need to initialize method counters");
+fr.interpreter_frame_method()->method_counters()->set_graal_invocation_time(os::javaTimeNanos());
 }
 #endif // GRAAL
 // increment invocation count & check for overflow
 //
 void InterpreterGenerator::generate_counter_incr(
 Label* overflow,
 Label* profile_method,
 Label* profile_method_continue) {
-const Address invocation_counter(rbx, in_bytes(Method::invocation_counter_offset()) +
+Label done;
-in_bytes(InvocationCounter::counter_offset()));
 // Note: In tiered we increment either counters in Method* or in MDO depending if we're profiling or not.
 if (TieredCompilation) {
 int increment = InvocationCounter::count_increment;
 int mask = ((1 << Tier0InvokeNotifyFreqLog)  - 1) << InvocationCounter::count_shift;
-Label no_mdo, done;
+Label no_mdo;
 if (ProfileInterpreter) {
 // Are we profiling?
 __ movptr(rax, Address(rbx, Method::method_data_offset()));
 __ testptr(rax, rax);
 __ jccb(Assembler::zero, no_mdo);
 // Increment counter in the MDO
 const Address mdo_invocation_counter(rax, in_bytes(MethodData::invocation_counter_offset()) +
 in_bytes(InvocationCounter::counter_offset()));
 __ increment_mask_and_jump(mdo_invocation_counter, increment, mask, rcx, false, Assembler::zero, overflow);
-__ jmpb(done);
+__ jmp(done);
 }
 __ bind(no_mdo);
-// Increment counter in Method* (we don't need to load it, it's in ecx).
+// Increment counter in MethodCounters
-__ increment_mask_and_jump(invocation_counter, increment, mask, rcx, true, Assembler::zero, overflow);
+const Address invocation_counter(rax,
+MethodCounters::invocation_counter_offset() +
+InvocationCounter::counter_offset());
+__ get_method_counters(rbx, rax, done);
+__ increment_mask_and_jump(invocation_counter, increment, mask, rcx,
+false, Assembler::zero, overflow);
 __ bind(done);
 } else {
-const Address backedge_counter(rbx,
+const Address backedge_counter(rax,
-Method::backedge_counter_offset() +
+MethodCounters::backedge_counter_offset() +
 InvocationCounter::counter_offset());
+const Address invocation_counter(rax,
-if (ProfileInterpreter) { // %%% Merge this into MethodData*
+MethodCounters::invocation_counter_offset() +
-__ incrementl(Address(rbx,
+InvocationCounter::counter_offset());
-Method::interpreter_invocation_counter_offset()));
+__ get_method_counters(rbx, rax, done);
+if (ProfileInterpreter) {
+__ incrementl(Address(rax,
+MethodCounters::interpreter_invocation_counter_offset()));
 }
 #ifdef GRAAL
 if (CompilationPolicyChoice == 4) {
 Label not_zero;
 __ bind(not_zero);
 }
 #endif // GRAAL
 // Update standard invocation counters
+__ movl(rcx, invocation_counter);
+__ incrementl(rcx, InvocationCounter::count_increment);
+__ movl(invocation_counter, rcx); // save invocation count
 __ movl(rax, backedge_counter);   // load backedge counter
-__ incrementl(rcx, InvocationCounter::count_increment);
 __ andl(rax, InvocationCounter::count_mask_value); // mask out the status bits
-__ movl(invocation_counter, rcx); // save invocation count
 __ addl(rcx, rax);                // add both counters
 // profile_method is non-null only for interpreted method so
 // profile_method != NULL == !native_call
 __ test_method_data_pointer(rax, *profile_method);
 }
 __ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterInvocationLimit));
 __ jcc(Assembler::aboveEqual, *overflow);
+__ bind(done);
 }
 }
 void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {
 // r13: sender sp
 address entry_point = __ pc();
 const Address constMethod       (rbx, Method::const_offset());
-const Address invocation_counter(rbx, Method::
-invocation_counter_offset() +
-InvocationCounter::counter_offset());
 const Address access_flags      (rbx, Method::access_flags_offset());
 const Address size_of_parameters(rcx, ConstMethod::
 size_of_parameters_offset());
 // initialize result_handler slot
 __ push((int) NULL_WORD);
 // slot for oop temp
 // (static native method holder mirror/jni oop result)
 __ push((int) NULL_WORD);
-if (inc_counter) {
-__ movl(rcx, invocation_counter);  // (pre-)fetch invocation count
-}
 // initialize fixed part of activation frame
 generate_fixed_frame(true);
 // make sure method is native & not abstract
 // ebx: Method*
 // r13: sender sp
 address entry_point = __ pc();
 const Address constMethod(rbx, Method::const_offset());
-const Address invocation_counter(rbx,
-Method::invocation_counter_offset() +
-InvocationCounter::counter_offset());
 const Address access_flags(rbx, Method::access_flags_offset());
 const Address size_of_parameters(rdx,
 ConstMethod::size_of_parameters_offset());
 const Address size_of_locals(rdx, ConstMethod::size_of_locals_offset());
 __ decrementl(rdx); // until everything initialized
 __ jcc(Assembler::greater, loop);
 __ bind(exit);
 }
-// (pre-)fetch invocation count
-if (inc_counter) {
-__ movl(rcx, invocation_counter);
-}
 // initialize fixed part of activation frame
 generate_fixed_frame(false);
 // make sure method is not native & not abstract
 #ifdef ASSERT
 // to/from the overhead area
 const int overhead_size =
 -(frame::interpreter_frame_initial_sp_offset) + entry_size;
 const int stub_code = frame::entry_frame_after_call_words;
-const int extra_stack = Method::extra_stack_entries();
+const int method_stack = (method->max_locals() + method->max_stack()) *
-const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) *
 Interpreter::stackElementWords;
 return (overhead_size + method_stack + stub_code);
 }
 int AbstractInterpreter::layout_activation(Method* method,

Mercurial > hg > graal-jvmci-8

comparison src/cpu/x86/vm/templateInterpreter_x86_64.cpp @ 10408:836a62f43af9