truffle: src/cpu/x86/vm/cppInterpreter

comparison src/cpu/x86/vm/cppInterpreter_x86.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	bd3237e0e18d

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 /*
-* Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2007, 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.
 __ subptr(rsp, wordSize);                                             // pre-push stack
 __ movptr(STATE(_stack), rsp);                                        // set current expression stack tos
 // compute full expression stack limit
-const int extra_stack = 0; //6815692//Method::extra_stack_words();
 __ movptr(rdx, Address(rbx, Method::const_offset()));
 __ load_unsigned_short(rdx, Address(rdx, ConstMethod::max_stack_offset())); // get size of expression stack in words
 __ negptr(rdx);                                                       // so we can subtract in next step
 // Allocate expression stack
-__ lea(rsp, Address(rsp, rdx, Address::times_ptr, -extra_stack));
+__ lea(rsp, Address(rsp, rdx, Address::times_ptr, -Method::extra_stack_words()));
 __ movptr(STATE(_stack_limit), rsp);
 }
 #ifdef _LP64
 // Make sure stack is properly aligned and sized for the abi
 //
 // rbx,: method
 // rcx: invocation counter
 //
 void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {
+Label done;
-const Address invocation_counter(rbx, Method::invocation_counter_offset() + InvocationCounter::counter_offset());
+const Address invocation_counter(rax,
-const Address backedge_counter  (rbx, Method::backedge_counter_offset() + InvocationCounter::counter_offset());
+MethodCounters::invocation_counter_offset() +
+InvocationCounter::counter_offset());
-if (ProfileInterpreter) { // %%% Merge this into MethodData*
+const Address backedge_counter  (rax,
-__ incrementl(Address(rbx,Method::interpreter_invocation_counter_offset()));
+MethodCounter::backedge_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);
+__ increment(rcx, InvocationCounter::count_increment);
+__ movl(invocation_counter, rcx);             // save invocation count
 __ movl(rax, backedge_counter);               // load backedge counter
-__ increment(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) {
 // C++ interpreter on entry
 // locals + overhead, in bytes
 // Always give one monitor to allow us to start interp if sync method.
 // Any additional monitors need a check when moving the expression stack
 const int one_monitor = frame::interpreter_frame_monitor_size() * wordSize;
-const int extra_stack = 0; //6815692//Method::extra_stack_entries();
 __ movptr(rax, Address(rbx, Method::const_offset()));
 __ load_unsigned_short(rax, Address(rax, ConstMethod::max_stack_offset())); // get size of expression stack in words
-__ lea(rax, Address(noreg, rax, Interpreter::stackElementScale(), extra_stack + one_monitor));
+__ lea(rax, Address(noreg, rax, Interpreter::stackElementScale(), one_monitor+Method::extra_stack_words()));
 __ lea(rax, Address(rax, rdx, Interpreter::stackElementScale(), overhead_size));
 #ifdef ASSERT
 Label stack_base_okay, stack_size_okay;
 // verify that thread stack base is non-zero
 //      in any case. If called via c1/c2/call_stub rsi/r13 is junk (to use) but harmless
 //      to save/restore.
 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());
 // rsi/r13 == state/locals rdi == prevstate
 const Register locals = rdi;
 __ jcc(Assembler::equal, L);
 __ stop("broken stack frame setup in interpreter");
 __ bind(L);
 }
 #endif
-if (inc_counter) __ movl(rcx, invocation_counter);  // (pre-)fetch invocation count
 const Register unlock_thread = LP64_ONLY(r15_thread) NOT_LP64(rax);
 NOT_LP64(__ movptr(unlock_thread, STATE(_thread));) // get thread
 // Since at this point in the method invocation the exception handler
 // would try to exit the monitor of synchronized methods which hasn't
 // address, saved rbp and 2 words for a "static long no_params() method" issue.
 const int overhead_size = sizeof(BytecodeInterpreter)/wordSize +
 ( frame::sender_sp_offset - frame::link_offset) + 2;
-const int extra_stack = 0; //6815692//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;
 }
 // returns the activation size.
 to_fill->_oop_temp = NULL;
 to_fill->_stack_base = stack_base;
 // Need +1 here because stack_base points to the word just above the first expr stack entry
 // and stack_limit is supposed to point to the word just below the last expr stack entry.
 // See generate_compute_interpreter_state.
-int extra_stack = 0; //6815692//Method::extra_stack_entries();
+to_fill->_stack_limit = stack_base - (method->max_stack() + 1);
-to_fill->_stack_limit = stack_base - (method->max_stack() + extra_stack + 1);
 to_fill->_monitor_base = (BasicObjectLock*) monitor_base;
 to_fill->_self_link = to_fill;
 assert(stack >= to_fill->_stack_limit && stack < to_fill->_stack_base,
 "Stack top out of range");
 // First calculate the frame size without any java expression stack
 int short_frame_size = size_activation_helper(extra_locals_size,
 monitor_size);
 // Now with full size expression stack
-int extra_stack = 0; //6815692//Method::extra_stack_entries();
+int full_frame_size = short_frame_size + method->max_stack() * BytesPerWord;
-int full_frame_size = short_frame_size + (method->max_stack() + extra_stack) * BytesPerWord;
 // and now with only live portion of the expression stack
 short_frame_size = short_frame_size + tempcount * BytesPerWord;
 // the size the activation is right now. Only top frame is full size

Mercurial > hg > truffle

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