truffle: src/cpu/x86/vm/templateInterpreter_x86

comparison src/cpu/x86/vm/templateInterpreter_x86_32.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	603ca7e51354
children	b800986664f4

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 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.
 //
 // rbx,: method
 // rcx: invocation counter
 //
 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 MethodCounters* or in MDO
-// Note: In tiered we increment either counters in Method* or in MDO depending if we're profiling or not.
+// 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 rcx).
+// 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, Method::backedge_counter_offset() +
+const Address backedge_counter  (rax,
-InvocationCounter::counter_offset());
+MethodCounters::backedge_counter_offset() +
+InvocationCounter::counter_offset());
-if (ProfileInterpreter) { // %%% Merge this into MethodData*
+const Address invocation_counter(rax,
-__ incrementl(Address(rbx,Method::interpreter_invocation_counter_offset()));
+MethodCounters::invocation_counter_offset() +
+InvocationCounter::counter_offset());
+__ get_method_counters(rbx, rax, done);
+if (ProfileInterpreter) {
+__ incrementl(Address(rax,
+MethodCounters::interpreter_invocation_counter_offset()));
 }
 // 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
 // BytecodeInterpreter only calls for native so code is elided.
 }
 __ cmp32(rcx,
 ExternalAddress((address)&InvocationCounter::InterpreterInvocationLimit));
 __ jcc(Assembler::aboveEqual, *overflow);
+__ bind(done);
 }
 }
 void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {
 // rsi: sender sp
 // rsi: previous interpreter state (C++ interpreter) must preserve
 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());
 // get parameter size (always needed)
 __ movptr(rcx, constMethod);
 // NULL result handler
 __ push((int32_t)NULL_WORD);
 // NULL oop temp (mirror or jni oop result)
 __ push((int32_t)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
 #ifdef ASSERT
 __ movl(rax, access_flags);
 // rbx,: Method*
 // rsi: 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());
 // get parameter size (always needed)
 __ decrement(rdx);                                // until everything initialized
 __ jcc(Assembler::greater, loop);
 __ bind(exit);
 }
-if (inc_counter) __ movl(rcx, invocation_counter);  // (pre-)fetch invocation count
 // initialize fixed part of activation frame
 generate_fixed_frame(false);
 // make sure method is not native & not abstract
 #ifdef ASSERT
 // total overhead size: entry_size + (saved rbp, thru expr stack bottom).
 // be sure to change this if you add/subtract anything to/from the overhead area
 const int overhead_size = -frame::interpreter_frame_initial_sp_offset;
-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;
 }
 // asm based interpreter deoptimization helpers

Mercurial > hg > truffle

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