--- a/hotspot/src/cpu/sparc/vm/assembler_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/assembler_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -3152,7 +3152,7 @@
RegisterOrConstant MacroAssembler::argument_offset(RegisterOrConstant arg_slot,
int extra_slot_offset) {
// cf. TemplateTable::prepare_invoke(), if (load_receiver).
- int stackElementSize = Interpreter::stackElementSize();
+ int stackElementSize = Interpreter::stackElementSize;
int offset = extra_slot_offset * stackElementSize;
if (arg_slot.is_constant()) {
offset += arg_slot.as_constant() * stackElementSize;
--- a/hotspot/src/cpu/sparc/vm/cppInterpreter_sparc.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/cppInterpreter_sparc.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 2002 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2002-2010 Sun Microsystems, Inc. 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
@@ -26,7 +26,7 @@
// fail with a guarantee ("not enough space for interpreter generation");
// if too small.
// Run with +PrintInterpreter to get the VM to print out the size.
- // Max size with JVMTI and TaggedStackInterpreter
+ // Max size with JVMTI
// QQQ this is proably way too large for c++ interpreter
--- a/hotspot/src/cpu/sparc/vm/frame_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/frame_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -620,7 +620,7 @@
// stack frames shouldn't be much larger than max_stack elements
- if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize()) {
+ if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize) {
return false;
}
--- a/hotspot/src/cpu/sparc/vm/interp_masm_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/interp_masm_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -50,7 +50,6 @@
// Any changes should also be applied to CodeEmitter::emit_osr_entry().
assert_different_registers(args_size, locals_size);
// max_locals*2 for TAGS. Assumes that args_size has already been adjusted.
- if (TaggedStackInterpreter) sll(locals_size, 1, locals_size);
subcc(locals_size, args_size, delta);// extra space for non-arguments locals in words
// Use br/mov combination because it works on both V8 and V9 and is
// faster.
@@ -319,7 +318,7 @@
ldf(FloatRegisterImpl::D, r1, offset, d);
#else
ldf(FloatRegisterImpl::S, r1, offset, d);
- ldf(FloatRegisterImpl::S, r1, offset + Interpreter::stackElementSize(), d->successor());
+ ldf(FloatRegisterImpl::S, r1, offset + Interpreter::stackElementSize, d->successor());
#endif
}
@@ -330,10 +329,10 @@
#ifdef _LP64
stf(FloatRegisterImpl::D, d, r1, offset);
// store something more useful here
- debug_only(stx(G0, r1, offset+Interpreter::stackElementSize());)
+ debug_only(stx(G0, r1, offset+Interpreter::stackElementSize);)
#else
stf(FloatRegisterImpl::S, d, r1, offset);
- stf(FloatRegisterImpl::S, d->successor(), r1, offset + Interpreter::stackElementSize());
+ stf(FloatRegisterImpl::S, d->successor(), r1, offset + Interpreter::stackElementSize);
#endif
}
@@ -345,7 +344,7 @@
ldx(r1, offset, rd);
#else
ld(r1, offset, rd);
- ld(r1, offset + Interpreter::stackElementSize(), rd->successor());
+ ld(r1, offset + Interpreter::stackElementSize, rd->successor());
#endif
}
@@ -356,138 +355,62 @@
#ifdef _LP64
stx(l, r1, offset);
// store something more useful here
- debug_only(stx(G0, r1, offset+Interpreter::stackElementSize());)
+ debug_only(stx(G0, r1, offset+Interpreter::stackElementSize);)
#else
st(l, r1, offset);
- st(l->successor(), r1, offset + Interpreter::stackElementSize());
+ st(l->successor(), r1, offset + Interpreter::stackElementSize);
#endif
}
-#ifdef ASSERT
-void InterpreterMacroAssembler::verify_stack_tag(frame::Tag t,
- Register r,
- Register scratch) {
- if (TaggedStackInterpreter) {
- Label ok, long_ok;
- ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(0), r);
- if (t == frame::TagCategory2) {
- cmp(r, G0);
- brx(Assembler::equal, false, Assembler::pt, long_ok);
- delayed()->ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(1), r);
- stop("stack long/double tag value bad");
- bind(long_ok);
- cmp(r, G0);
- } else if (t == frame::TagValue) {
- cmp(r, G0);
- } else {
- assert_different_registers(r, scratch);
- mov(t, scratch);
- cmp(r, scratch);
- }
- brx(Assembler::equal, false, Assembler::pt, ok);
- delayed()->nop();
- // Also compare if the stack value is zero, then the tag might
- // not have been set coming from deopt.
- ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), r);
- cmp(r, G0);
- brx(Assembler::equal, false, Assembler::pt, ok);
- delayed()->nop();
- stop("Stack tag value is bad");
- bind(ok);
- }
-}
-#endif // ASSERT
-
void InterpreterMacroAssembler::pop_i(Register r) {
assert_not_delayed();
- // Uses destination register r for scratch
- debug_only(verify_stack_tag(frame::TagValue, r));
ld(Lesp, Interpreter::expr_offset_in_bytes(0), r);
- inc(Lesp, Interpreter::stackElementSize());
+ inc(Lesp, Interpreter::stackElementSize);
debug_only(verify_esp(Lesp));
}
void InterpreterMacroAssembler::pop_ptr(Register r, Register scratch) {
assert_not_delayed();
- // Uses destination register r for scratch
- debug_only(verify_stack_tag(frame::TagReference, r, scratch));
ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), r);
- inc(Lesp, Interpreter::stackElementSize());
+ inc(Lesp, Interpreter::stackElementSize);
debug_only(verify_esp(Lesp));
}
void InterpreterMacroAssembler::pop_l(Register r) {
assert_not_delayed();
- // Uses destination register r for scratch
- debug_only(verify_stack_tag(frame::TagCategory2, r));
load_unaligned_long(Lesp, Interpreter::expr_offset_in_bytes(0), r);
- inc(Lesp, 2*Interpreter::stackElementSize());
+ inc(Lesp, 2*Interpreter::stackElementSize);
debug_only(verify_esp(Lesp));
}
void InterpreterMacroAssembler::pop_f(FloatRegister f, Register scratch) {
assert_not_delayed();
- debug_only(verify_stack_tag(frame::TagValue, scratch));
ldf(FloatRegisterImpl::S, Lesp, Interpreter::expr_offset_in_bytes(0), f);
- inc(Lesp, Interpreter::stackElementSize());
+ inc(Lesp, Interpreter::stackElementSize);
debug_only(verify_esp(Lesp));
}
void InterpreterMacroAssembler::pop_d(FloatRegister f, Register scratch) {
assert_not_delayed();
- debug_only(verify_stack_tag(frame::TagCategory2, scratch));
load_unaligned_double(Lesp, Interpreter::expr_offset_in_bytes(0), f);
- inc(Lesp, 2*Interpreter::stackElementSize());
+ inc(Lesp, 2*Interpreter::stackElementSize);
debug_only(verify_esp(Lesp));
}
-// (Note use register first, then decrement so dec can be done during store stall)
-void InterpreterMacroAssembler::tag_stack(Register r) {
- if (TaggedStackInterpreter) {
- st_ptr(r, Lesp, Interpreter::tag_offset_in_bytes());
- }
-}
-
-void InterpreterMacroAssembler::tag_stack(frame::Tag t, Register r) {
- if (TaggedStackInterpreter) {
- assert (frame::TagValue == 0, "TagValue must be zero");
- if (t == frame::TagValue) {
- st_ptr(G0, Lesp, Interpreter::tag_offset_in_bytes());
- } else if (t == frame::TagCategory2) {
- st_ptr(G0, Lesp, Interpreter::tag_offset_in_bytes());
- // Tag next slot down too
- st_ptr(G0, Lesp, -Interpreter::stackElementSize() + Interpreter::tag_offset_in_bytes());
- } else {
- assert_different_registers(r, O3);
- mov(t, O3);
- st_ptr(O3, Lesp, Interpreter::tag_offset_in_bytes());
- }
- }
-}
-
void InterpreterMacroAssembler::push_i(Register r) {
assert_not_delayed();
debug_only(verify_esp(Lesp));
- tag_stack(frame::TagValue, r);
- st( r, Lesp, Interpreter::value_offset_in_bytes());
- dec( Lesp, Interpreter::stackElementSize());
+ st(r, Lesp, 0);
+ dec(Lesp, Interpreter::stackElementSize);
}
void InterpreterMacroAssembler::push_ptr(Register r) {
assert_not_delayed();
- tag_stack(frame::TagReference, r);
- st_ptr( r, Lesp, Interpreter::value_offset_in_bytes());
- dec( Lesp, Interpreter::stackElementSize());
-}
-
-void InterpreterMacroAssembler::push_ptr(Register r, Register tag) {
- assert_not_delayed();
- tag_stack(tag);
- st_ptr(r, Lesp, Interpreter::value_offset_in_bytes());
- dec( Lesp, Interpreter::stackElementSize());
+ st_ptr(r, Lesp, 0);
+ dec(Lesp, Interpreter::stackElementSize);
}
// remember: our convention for longs in SPARC is:
@@ -497,33 +420,28 @@
void InterpreterMacroAssembler::push_l(Register r) {
assert_not_delayed();
debug_only(verify_esp(Lesp));
- tag_stack(frame::TagCategory2, r);
- // Longs are in stored in memory-correct order, even if unaligned.
- // and may be separated by stack tags.
- int offset = -Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();
+ // Longs are stored in memory-correct order, even if unaligned.
+ int offset = -Interpreter::stackElementSize;
store_unaligned_long(r, Lesp, offset);
- dec(Lesp, 2 * Interpreter::stackElementSize());
+ dec(Lesp, 2 * Interpreter::stackElementSize);
}
void InterpreterMacroAssembler::push_f(FloatRegister f) {
assert_not_delayed();
debug_only(verify_esp(Lesp));
- tag_stack(frame::TagValue, Otos_i);
- stf(FloatRegisterImpl::S, f, Lesp, Interpreter::value_offset_in_bytes());
- dec(Lesp, Interpreter::stackElementSize());
+ stf(FloatRegisterImpl::S, f, Lesp, 0);
+ dec(Lesp, Interpreter::stackElementSize);
}
void InterpreterMacroAssembler::push_d(FloatRegister d) {
assert_not_delayed();
debug_only(verify_esp(Lesp));
- tag_stack(frame::TagCategory2, Otos_i);
- // Longs are in stored in memory-correct order, even if unaligned.
- // and may be separated by stack tags.
- int offset = -Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();
+ // Longs are stored in memory-correct order, even if unaligned.
+ int offset = -Interpreter::stackElementSize;
store_unaligned_double(d, Lesp, offset);
- dec(Lesp, 2 * Interpreter::stackElementSize());
+ dec(Lesp, 2 * Interpreter::stackElementSize);
}
@@ -561,30 +479,18 @@
}
-// Tagged stack helpers for swap and dup
-void InterpreterMacroAssembler::load_ptr_and_tag(int n, Register val,
- Register tag) {
+// Helpers for swap and dup
+void InterpreterMacroAssembler::load_ptr(int n, Register val) {
ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(n), val);
- if (TaggedStackInterpreter) {
- ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(n), tag);
- }
}
-void InterpreterMacroAssembler::store_ptr_and_tag(int n, Register val,
- Register tag) {
+void InterpreterMacroAssembler::store_ptr(int n, Register val) {
st_ptr(val, Lesp, Interpreter::expr_offset_in_bytes(n));
- if (TaggedStackInterpreter) {
- st_ptr(tag, Lesp, Interpreter::expr_tag_offset_in_bytes(n));
- }
}
void InterpreterMacroAssembler::load_receiver(Register param_count,
Register recv) {
-
- sll(param_count, Interpreter::logStackElementSize(), param_count);
- if (TaggedStackInterpreter) {
- add(param_count, Interpreter::value_offset_in_bytes(), param_count); // get obj address
- }
+ sll(param_count, Interpreter::logStackElementSize, param_count);
ld_ptr(Lesp, param_count, recv); // gets receiver Oop
}
@@ -605,7 +511,6 @@
// Compute max expression stack+register save area
lduh(Lmethod, in_bytes(methodOopDesc::max_stack_offset()), Gframe_size); // Load max stack.
- if (TaggedStackInterpreter) sll ( Gframe_size, 1, Gframe_size); // max_stack * 2 for TAGS
add( Gframe_size, frame::memory_parameter_word_sp_offset, Gframe_size );
//
@@ -2018,51 +1923,11 @@
}
// Locals
-#ifdef ASSERT
-void InterpreterMacroAssembler::verify_local_tag(frame::Tag t,
- Register base,
- Register scratch,
- int n) {
- if (TaggedStackInterpreter) {
- Label ok, long_ok;
- // Use dst for scratch
- assert_different_registers(base, scratch);
- ld_ptr(base, Interpreter::local_tag_offset_in_bytes(n), scratch);
- if (t == frame::TagCategory2) {
- cmp(scratch, G0);
- brx(Assembler::equal, false, Assembler::pt, long_ok);
- delayed()->ld_ptr(base, Interpreter::local_tag_offset_in_bytes(n+1), scratch);
- stop("local long/double tag value bad");
- bind(long_ok);
- // compare second half tag
- cmp(scratch, G0);
- } else if (t == frame::TagValue) {
- cmp(scratch, G0);
- } else {
- assert_different_registers(O3, base, scratch);
- mov(t, O3);
- cmp(scratch, O3);
- }
- brx(Assembler::equal, false, Assembler::pt, ok);
- delayed()->nop();
- // Also compare if the local value is zero, then the tag might
- // not have been set coming from deopt.
- ld_ptr(base, Interpreter::local_offset_in_bytes(n), scratch);
- cmp(scratch, G0);
- brx(Assembler::equal, false, Assembler::pt, ok);
- delayed()->nop();
- stop("Local tag value is bad");
- bind(ok);
- }
-}
-#endif // ASSERT
-
void InterpreterMacroAssembler::access_local_ptr( Register index, Register dst ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- debug_only(verify_local_tag(frame::TagReference, index, dst));
- ld_ptr(index, Interpreter::value_offset_in_bytes(), dst);
+ ld_ptr(index, 0, dst);
// Note: index must hold the effective address--the iinc template uses it
}
@@ -2070,27 +1935,24 @@
void InterpreterMacroAssembler::access_local_returnAddress(Register index,
Register dst ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- debug_only(verify_local_tag(frame::TagValue, index, dst));
- ld_ptr(index, Interpreter::value_offset_in_bytes(), dst);
+ ld_ptr(index, 0, dst);
}
void InterpreterMacroAssembler::access_local_int( Register index, Register dst ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- debug_only(verify_local_tag(frame::TagValue, index, dst));
- ld(index, Interpreter::value_offset_in_bytes(), dst);
+ ld(index, 0, dst);
// Note: index must hold the effective address--the iinc template uses it
}
void InterpreterMacroAssembler::access_local_long( Register index, Register dst ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- debug_only(verify_local_tag(frame::TagCategory2, index, dst));
// First half stored at index n+1 (which grows down from Llocals[n])
load_unaligned_long(index, Interpreter::local_offset_in_bytes(1), dst);
}
@@ -2098,18 +1960,16 @@
void InterpreterMacroAssembler::access_local_float( Register index, FloatRegister dst ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- debug_only(verify_local_tag(frame::TagValue, index, G1_scratch));
- ldf(FloatRegisterImpl::S, index, Interpreter::value_offset_in_bytes(), dst);
+ ldf(FloatRegisterImpl::S, index, 0, dst);
}
void InterpreterMacroAssembler::access_local_double( Register index, FloatRegister dst ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- debug_only(verify_local_tag(frame::TagCategory2, index, G1_scratch));
load_unaligned_double(index, Interpreter::local_offset_in_bytes(1), dst);
}
@@ -2135,94 +1995,60 @@
}
#endif // ASSERT
-void InterpreterMacroAssembler::tag_local(frame::Tag t,
- Register base,
- Register src,
- int n) {
- if (TaggedStackInterpreter) {
- // have to store zero because local slots can be reused (rats!)
- if (t == frame::TagValue) {
- st_ptr(G0, base, Interpreter::local_tag_offset_in_bytes(n));
- } else if (t == frame::TagCategory2) {
- st_ptr(G0, base, Interpreter::local_tag_offset_in_bytes(n));
- st_ptr(G0, base, Interpreter::local_tag_offset_in_bytes(n+1));
- } else {
- // assert that we don't stomp the value in 'src'
- // O3 is arbitrary because it's not used.
- assert_different_registers(src, base, O3);
- mov( t, O3);
- st_ptr(O3, base, Interpreter::local_tag_offset_in_bytes(n));
- }
- }
-}
-
void InterpreterMacroAssembler::store_local_int( Register index, Register src ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- debug_only(check_for_regarea_stomp(index, Interpreter::value_offset_in_bytes(), FP, G1_scratch, G4_scratch);)
- tag_local(frame::TagValue, index, src);
- st(src, index, Interpreter::value_offset_in_bytes());
+ debug_only(check_for_regarea_stomp(index, 0, FP, G1_scratch, G4_scratch);)
+ st(src, index, 0);
}
-void InterpreterMacroAssembler::store_local_ptr( Register index, Register src,
- Register tag ) {
+void InterpreterMacroAssembler::store_local_ptr( Register index, Register src ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- #ifdef ASSERT
- check_for_regarea_stomp(index, Interpreter::value_offset_in_bytes(), FP, G1_scratch, G4_scratch);
- #endif
- st_ptr(src, index, Interpreter::value_offset_in_bytes());
- // Store tag register directly
- if (TaggedStackInterpreter) {
- st_ptr(tag, index, Interpreter::tag_offset_in_bytes());
- }
+#ifdef ASSERT
+ check_for_regarea_stomp(index, 0, FP, G1_scratch, G4_scratch);
+#endif
+ st_ptr(src, index, 0);
}
-void InterpreterMacroAssembler::store_local_ptr( int n, Register src,
- Register tag ) {
- st_ptr(src, Llocals, Interpreter::local_offset_in_bytes(n));
- if (TaggedStackInterpreter) {
- st_ptr(tag, Llocals, Interpreter::local_tag_offset_in_bytes(n));
- }
+void InterpreterMacroAssembler::store_local_ptr( int n, Register src ) {
+ st_ptr(src, Llocals, Interpreter::local_offset_in_bytes(n));
}
void InterpreterMacroAssembler::store_local_long( Register index, Register src ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- #ifdef ASSERT
+#ifdef ASSERT
check_for_regarea_stomp(index, Interpreter::local_offset_in_bytes(1), FP, G1_scratch, G4_scratch);
- #endif
- tag_local(frame::TagCategory2, index, src);
+#endif
store_unaligned_long(src, index, Interpreter::local_offset_in_bytes(1)); // which is n+1
}
void InterpreterMacroAssembler::store_local_float( Register index, FloatRegister src ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- #ifdef ASSERT
- check_for_regarea_stomp(index, Interpreter::value_offset_in_bytes(), FP, G1_scratch, G4_scratch);
- #endif
- tag_local(frame::TagValue, index, G1_scratch);
- stf(FloatRegisterImpl::S, src, index, Interpreter::value_offset_in_bytes());
+#ifdef ASSERT
+ check_for_regarea_stomp(index, 0, FP, G1_scratch, G4_scratch);
+#endif
+ stf(FloatRegisterImpl::S, src, index, 0);
}
void InterpreterMacroAssembler::store_local_double( Register index, FloatRegister src ) {
assert_not_delayed();
- sll(index, Interpreter::logStackElementSize(), index);
+ sll(index, Interpreter::logStackElementSize, index);
sub(Llocals, index, index);
- #ifdef ASSERT
+#ifdef ASSERT
check_for_regarea_stomp(index, Interpreter::local_offset_in_bytes(1), FP, G1_scratch, G4_scratch);
- #endif
- tag_local(frame::TagCategory2, index, G1_scratch);
+#endif
store_unaligned_double(src, index, Interpreter::local_offset_in_bytes(1));
}
--- a/hotspot/src/cpu/sparc/vm/interp_masm_sparc.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/interp_masm_sparc.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -149,7 +149,6 @@
void push_i( Register r = Otos_i);
void push_ptr( Register r = Otos_i);
- void push_ptr( Register r, Register tag);
void push_l( Register r = Otos_l1);
void push_f(FloatRegister f = Ftos_f);
void push_d(FloatRegister f = Ftos_d1);
@@ -159,17 +158,9 @@
void push(TosState state); // transition state -> vtos
void empty_expression_stack(); // resets both Lesp and SP
- // Support for Tagged Stacks
- void tag_stack(frame::Tag t, Register r);
- void tag_stack(Register tag);
- void tag_local(frame::Tag t, Register src, Register base, int n = 0);
-
#ifdef ASSERT
void verify_sp(Register Rsp, Register Rtemp);
void verify_esp(Register Resp); // verify that Lesp points to a word in the temp stack
-
- void verify_stack_tag(frame::Tag t, Register r, Register scratch = G0);
- void verify_local_tag(frame::Tag t, Register base, Register scr, int n = 0);
#endif // ASSERT
public:
@@ -242,17 +233,17 @@
void check_for_regarea_stomp( Register Rindex, int offset, Register Rlimit, Register Rscratch, Register Rscratch1);
#endif // ASSERT
void store_local_int( Register index, Register src );
- void store_local_ptr( Register index, Register src, Register tag = Otos_l2 );
- void store_local_ptr( int n, Register src, Register tag = Otos_l2 );
+ void store_local_ptr( Register index, Register src );
+ void store_local_ptr( int n, Register src );
void store_local_long( Register index, Register src );
void store_local_float( Register index, FloatRegister src );
void store_local_double( Register index, FloatRegister src );
- // Tagged stack helpers for swap and dup
- void load_ptr_and_tag(int n, Register val, Register tag);
- void store_ptr_and_tag(int n, Register val, Register tag);
+ // Helpers for swap and dup
+ void load_ptr(int n, Register val);
+ void store_ptr(int n, Register val);
- // Tagged stack helper for getting receiver in register.
+ // Helper for getting receiver in register.
void load_receiver(Register param_count, Register recv);
static int top_most_monitor_byte_offset(); // offset in bytes to top of monitor block
--- a/hotspot/src/cpu/sparc/vm/interpreterRT_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/interpreterRT_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1998-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1998-2010 Sun Microsystems, Inc. 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
@@ -43,19 +43,6 @@
Argument jni_arg(jni_offset(), false);
Register Rtmp = O0;
-#ifdef ASSERT
- if (TaggedStackInterpreter) {
- // check at least one tag is okay
- Label ok;
- __ ld_ptr(Llocals, Interpreter::local_tag_offset_in_bytes(offset() + 1), Rtmp);
- __ cmp(Rtmp, G0);
- __ brx(Assembler::equal, false, Assembler::pt, ok);
- __ delayed()->nop();
- __ stop("Native object has bad tag value");
- __ bind(ok);
- }
-#endif // ASSERT
-
#ifdef _LP64
__ ldx(Llocals, Interpreter::local_offset_in_bytes(offset() + 1), Rtmp);
__ store_long_argument(Rtmp, jni_arg);
@@ -107,18 +94,6 @@
Address h_arg = Address(Llocals, Interpreter::local_offset_in_bytes(offset()));
__ ld_ptr(h_arg, Rtmp1);
-#ifdef ASSERT
- if (TaggedStackInterpreter) {
- // check we have the obj and not the tag
- Label ok;
- __ mov(frame::TagReference, Rtmp3);
- __ cmp(Rtmp1, Rtmp3);
- __ brx(Assembler::notEqual, true, Assembler::pt, ok);
- __ delayed()->nop();
- __ stop("Native object passed tag by mistake");
- __ bind(ok);
- }
-#endif // ASSERT
if (!do_NULL_check) {
__ add(h_arg.base(), h_arg.disp(), Rtmp2);
} else {
@@ -168,17 +143,9 @@
long_sig = 3
};
-#ifdef ASSERT
- void verify_tag(frame::Tag t) {
- assert(!TaggedStackInterpreter ||
- *(intptr_t*)(_from+Interpreter::local_tag_offset_in_bytes(0)) == t, "wrong tag");
- }
-#endif // ASSERT
-
virtual void pass_int() {
*_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
add_signature( non_float );
}
@@ -186,31 +153,27 @@
// pass address of from
intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
*_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
- debug_only(verify_tag(frame::TagReference));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
add_signature( non_float );
}
#ifdef _LP64
virtual void pass_float() {
*_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
add_signature( float_sig );
}
virtual void pass_double() {
*_to++ = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
- debug_only(verify_tag(frame::TagValue));
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
add_signature( double_sig );
}
virtual void pass_long() {
_to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
- debug_only(verify_tag(frame::TagValue));
_to += 1;
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
add_signature( long_sig );
}
#else
@@ -218,9 +181,8 @@
virtual void pass_long() {
_to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
_to[1] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
_to += 2;
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
add_signature( non_float );
}
#endif // _LP64
--- a/hotspot/src/cpu/sparc/vm/interpreter_sparc.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/interpreter_sparc.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -24,33 +24,13 @@
public:
- // Support for Tagged Stacks
+ static int expr_offset_in_bytes(int i) { return stackElementSize * i + wordSize; }
// Stack index relative to tos (which points at value)
- static int expr_index_at(int i) {
- return stackElementWords() * i;
- }
-
- static int expr_tag_index_at(int i) {
- assert(TaggedStackInterpreter, "should not call this");
- // tag is one word above java stack element
- return stackElementWords() * i + 1;
- }
-
- static int expr_offset_in_bytes(int i) { return stackElementSize()*i + wordSize; }
- static int expr_tag_offset_in_bytes (int i) {
- assert(TaggedStackInterpreter, "should not call this");
- return expr_offset_in_bytes(i) + wordSize;
- }
+ static int expr_index_at(int i) { return stackElementWords * i; }
// Already negated by c++ interpreter
- static int local_index_at(int i) {
- assert(i<=0, "local direction already negated");
- return stackElementWords() * i + (value_offset_in_bytes()/wordSize);
+ static int local_index_at(int i) {
+ assert(i <= 0, "local direction already negated");
+ return stackElementWords * i;
}
-
- static int local_tag_index_at(int i) {
- assert(i<=0, "local direction already negated");
- assert(TaggedStackInterpreter, "should not call this");
- return stackElementWords() * i + (tag_offset_in_bytes()/wordSize);
- }
--- a/hotspot/src/cpu/sparc/vm/methodHandles_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/methodHandles_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -358,7 +358,7 @@
// Push arguments as if coming from the interpreter.
Register O0_scratch = O0_argslot;
- int stackElementSize = Interpreter::stackElementSize();
+ int stackElementSize = Interpreter::stackElementSize;
// Make space on the stack for the arguments.
__ sub(SP, 4*stackElementSize, SP);
@@ -679,7 +679,7 @@
insert_arg_slots(_masm, stack_move_unit(), _INSERT_INT_MASK, O0_argslot, O1_scratch, O2_scratch, G5_index);
Address arg_lsw(O0_argslot, 0);
- Address arg_msw(O0_argslot, -Interpreter::stackElementSize());
+ Address arg_msw(O0_argslot, -Interpreter::stackElementSize);
switch (ek) {
case _adapter_opt_i2l:
--- a/hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -547,17 +547,11 @@
void set_Rdisp(Register r) { Rdisp = r; }
void patch_callers_callsite();
- void tag_c2i_arg(frame::Tag t, Register base, int st_off, Register scratch);
// base+st_off points to top of argument
- int arg_offset(const int st_off) { return st_off + Interpreter::value_offset_in_bytes(); }
+ int arg_offset(const int st_off) { return st_off; }
int next_arg_offset(const int st_off) {
- return st_off - Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();
- }
-
- int tag_offset(const int st_off) { return st_off + Interpreter::tag_offset_in_bytes(); }
- int next_tag_offset(const int st_off) {
- return st_off - Interpreter::stackElementSize() + Interpreter::tag_offset_in_bytes();
+ return st_off - Interpreter::stackElementSize;
}
// Argument slot values may be loaded first into a register because
@@ -565,9 +559,6 @@
RegisterOrConstant arg_slot(const int st_off);
RegisterOrConstant next_arg_slot(const int st_off);
- RegisterOrConstant tag_slot(const int st_off);
- RegisterOrConstant next_tag_slot(const int st_off);
-
// Stores long into offset pointed to by base
void store_c2i_long(Register r, Register base,
const int st_off, bool is_stack);
@@ -653,23 +644,6 @@
__ bind(L);
}
-void AdapterGenerator::tag_c2i_arg(frame::Tag t, Register base, int st_off,
- Register scratch) {
- if (TaggedStackInterpreter) {
- RegisterOrConstant slot = tag_slot(st_off);
- // have to store zero because local slots can be reused (rats!)
- if (t == frame::TagValue) {
- __ st_ptr(G0, base, slot);
- } else if (t == frame::TagCategory2) {
- __ st_ptr(G0, base, slot);
- __ st_ptr(G0, base, next_tag_slot(st_off));
- } else {
- __ mov(t, scratch);
- __ st_ptr(scratch, base, slot);
- }
- }
-}
-
RegisterOrConstant AdapterGenerator::arg_slot(const int st_off) {
RegisterOrConstant roc(arg_offset(st_off));
@@ -682,17 +656,6 @@
}
-RegisterOrConstant AdapterGenerator::tag_slot(const int st_off) {
- RegisterOrConstant roc(tag_offset(st_off));
- return __ ensure_simm13_or_reg(roc, Rdisp);
-}
-
-RegisterOrConstant AdapterGenerator::next_tag_slot(const int st_off) {
- RegisterOrConstant roc(next_tag_offset(st_off));
- return __ ensure_simm13_or_reg(roc, Rdisp);
-}
-
-
// Stores long into offset pointed to by base
void AdapterGenerator::store_c2i_long(Register r, Register base,
const int st_off, bool is_stack) {
@@ -718,19 +681,16 @@
}
#endif // COMPILER2
#endif // _LP64
- tag_c2i_arg(frame::TagCategory2, base, st_off, r);
}
void AdapterGenerator::store_c2i_object(Register r, Register base,
const int st_off) {
__ st_ptr (r, base, arg_slot(st_off));
- tag_c2i_arg(frame::TagReference, base, st_off, r);
}
void AdapterGenerator::store_c2i_int(Register r, Register base,
const int st_off) {
__ st (r, base, arg_slot(st_off));
- tag_c2i_arg(frame::TagValue, base, st_off, r);
}
// Stores into offset pointed to by base
@@ -745,13 +705,11 @@
__ stf(FloatRegisterImpl::S, r_1->as_FloatRegister(), base, next_arg_slot(st_off));
__ stf(FloatRegisterImpl::S, r_2->as_FloatRegister(), base, arg_slot(st_off) );
#endif
- tag_c2i_arg(frame::TagCategory2, base, st_off, G1_scratch);
}
void AdapterGenerator::store_c2i_float(FloatRegister f, Register base,
const int st_off) {
__ stf(FloatRegisterImpl::S, f, base, arg_slot(st_off));
- tag_c2i_arg(frame::TagValue, base, st_off, G1_scratch);
}
void AdapterGenerator::gen_c2i_adapter(
@@ -786,14 +744,14 @@
// Since all args are passed on the stack, total_args_passed*wordSize is the
// space we need. Add in varargs area needed by the interpreter. Round up
// to stack alignment.
- const int arg_size = total_args_passed * Interpreter::stackElementSize();
+ const int arg_size = total_args_passed * Interpreter::stackElementSize;
const int varargs_area =
(frame::varargs_offset - frame::register_save_words)*wordSize;
const int extraspace = round_to(arg_size + varargs_area, 2*wordSize);
int bias = STACK_BIAS;
const int interp_arg_offset = frame::varargs_offset*wordSize +
- (total_args_passed-1)*Interpreter::stackElementSize();
+ (total_args_passed-1)*Interpreter::stackElementSize;
Register base = SP;
@@ -814,7 +772,7 @@
// First write G1 (if used) to where ever it must go
for (int i=0; i<total_args_passed; i++) {
- const int st_off = interp_arg_offset - (i*Interpreter::stackElementSize()) + bias;
+ const int st_off = interp_arg_offset - (i*Interpreter::stackElementSize) + bias;
VMReg r_1 = regs[i].first();
VMReg r_2 = regs[i].second();
if (r_1 == G1_scratch->as_VMReg()) {
@@ -831,7 +789,7 @@
// Now write the args into the outgoing interpreter space
for (int i=0; i<total_args_passed; i++) {
- const int st_off = interp_arg_offset - (i*Interpreter::stackElementSize()) + bias;
+ const int st_off = interp_arg_offset - (i*Interpreter::stackElementSize) + bias;
VMReg r_1 = regs[i].first();
VMReg r_2 = regs[i].second();
if (!r_1->is_valid()) {
@@ -900,7 +858,7 @@
#endif // _LP64
__ mov((frame::varargs_offset)*wordSize -
- 1*Interpreter::stackElementSize()+bias+BytesPerWord, G1);
+ 1*Interpreter::stackElementSize+bias+BytesPerWord, G1);
// Jump to the interpreter just as if interpreter was doing it.
__ jmpl(G3_scratch, 0, G0);
// Setup Lesp for the call. Cannot actually set Lesp as the current Lesp
@@ -1051,7 +1009,7 @@
// ldx/lddf optimizations.
// Load in argument order going down.
- const int ld_off = (total_args_passed-i)*Interpreter::stackElementSize();
+ const int ld_off = (total_args_passed-i)*Interpreter::stackElementSize;
set_Rdisp(G1_scratch);
VMReg r_1 = regs[i].first();
@@ -1120,7 +1078,7 @@
for (int i=0; i<total_args_passed; i++) {
if (regs[i].first()->is_Register() && regs[i].second()->is_valid()) {
// Load in argument order going down
- int ld_off = (total_args_passed-i)*Interpreter::stackElementSize();
+ int ld_off = (total_args_passed-i)*Interpreter::stackElementSize;
// Need to marshal 64-bit value from misaligned Lesp loads
Register r = regs[i].first()->as_Register()->after_restore();
if (r == G1 || r == G4) {
@@ -3062,7 +3020,7 @@
"test and remove; got more parms than locals");
if (callee_locals < callee_parameters)
return 0; // No adjustment for negative locals
- int diff = (callee_locals - callee_parameters) * Interpreter::stackElementWords();
+ int diff = (callee_locals - callee_parameters) * Interpreter::stackElementWords;
return round_to(diff, WordsPerLong);
}
--- a/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -139,7 +139,7 @@
__ ld_ptr(parameter_size.as_address(), t); // get parameter size (in words)
__ add(t, frame::memory_parameter_word_sp_offset, t); // add space for save area (in words)
__ round_to(t, WordsPerLong); // make sure it is multiple of 2 (in words)
- __ sll(t, Interpreter::logStackElementSize(), t); // compute number of bytes
+ __ sll(t, Interpreter::logStackElementSize, t); // compute number of bytes
__ neg(t); // negate so it can be used with save
__ save(SP, t, SP); // setup new frame
}
@@ -191,19 +191,13 @@
// copy parameters if any
Label loop;
__ BIND(loop);
- // Store tag first.
- if (TaggedStackInterpreter) {
- __ ld_ptr(src, 0, tmp);
- __ add(src, BytesPerWord, src); // get next
- __ st_ptr(tmp, dst, Interpreter::tag_offset_in_bytes());
- }
// Store parameter value
__ ld_ptr(src, 0, tmp);
__ add(src, BytesPerWord, src);
- __ st_ptr(tmp, dst, Interpreter::value_offset_in_bytes());
+ __ st_ptr(tmp, dst, 0);
__ deccc(cnt);
__ br(Assembler::greater, false, Assembler::pt, loop);
- __ delayed()->sub(dst, Interpreter::stackElementSize(), dst);
+ __ delayed()->sub(dst, Interpreter::stackElementSize, dst);
// done
__ BIND(exit);
@@ -220,7 +214,7 @@
// setup parameters
const Register t = G3_scratch;
__ ld_ptr(parameter_size.as_in().as_address(), t); // get parameter size (in words)
- __ sll(t, Interpreter::logStackElementSize(), t); // compute number of bytes
+ __ sll(t, Interpreter::logStackElementSize, t); // compute number of bytes
__ sub(FP, t, Gargs); // setup parameter pointer
#ifdef _LP64
__ add( Gargs, STACK_BIAS, Gargs ); // Account for LP64 stack bias
--- a/hotspot/src/cpu/sparc/vm/templateInterpreter_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/templateInterpreter_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -197,7 +197,7 @@
__ ld_ptr(cache, constantPoolCacheOopDesc::base_offset() +
ConstantPoolCacheEntry::flags_offset(), size);
__ and3(size, 0xFF, size); // argument size in words
- __ sll(size, Interpreter::logStackElementSize(), size); // each argument size in bytes
+ __ sll(size, Interpreter::logStackElementSize, size); // each argument size in bytes
__ add(Lesp, size, Lesp); // pop arguments
__ dispatch_next(state, step);
@@ -495,7 +495,7 @@
// Set the saved SP after the register window save
//
assert_different_registers(Gargs, Glocals_size, Gframe_size, O5_savedSP);
- __ sll(Glocals_size, Interpreter::logStackElementSize(), Otmp1);
+ __ sll(Glocals_size, Interpreter::logStackElementSize, Otmp1);
__ add(Gargs, Otmp1, Gargs);
if (native_call) {
@@ -511,7 +511,7 @@
__ lduh( size_of_locals, Otmp1 );
__ sub( Otmp1, Glocals_size, Glocals_size );
__ round_to( Glocals_size, WordsPerLong );
- __ sll( Glocals_size, Interpreter::logStackElementSize(), Glocals_size );
+ __ sll( Glocals_size, Interpreter::logStackElementSize, Glocals_size );
// see if the frame is greater than one page in size. If so,
// then we need to verify there is enough stack space remaining
@@ -519,7 +519,7 @@
__ lduh( max_stack, Gframe_size );
__ add( Gframe_size, extra_space, Gframe_size );
__ round_to( Gframe_size, WordsPerLong );
- __ sll( Gframe_size, Interpreter::logStackElementSize(), Gframe_size);
+ __ sll( Gframe_size, Interpreter::logStackElementSize, Gframe_size);
// Add in java locals size for stack overflow check only
__ add( Gframe_size, Glocals_size, Gframe_size );
@@ -1234,8 +1234,8 @@
// be updated!
__ lduh( size_of_locals, O2 );
__ lduh( size_of_parameters, O1 );
- __ sll( O2, Interpreter::logStackElementSize(), O2);
- __ sll( O1, Interpreter::logStackElementSize(), O1 );
+ __ sll( O2, Interpreter::logStackElementSize, O2);
+ __ sll( O1, Interpreter::logStackElementSize, O1 );
__ sub( Llocals, O2, O2 );
__ sub( Llocals, O1, O1 );
@@ -1470,8 +1470,8 @@
round_to(frame::interpreter_frame_vm_local_words,WordsPerLong);
// callee_locals and max_stack are counts, not the size in frame.
const int locals_size =
- round_to(callee_extra_locals * Interpreter::stackElementWords(), WordsPerLong);
- const int max_stack_words = max_stack * Interpreter::stackElementWords();
+ round_to(callee_extra_locals * Interpreter::stackElementWords, WordsPerLong);
+ const int max_stack_words = max_stack * Interpreter::stackElementWords;
return (round_to((max_stack_words
//6815692//+ methodOopDesc::extra_stack_words()
+ rounded_vm_local_words
@@ -1570,11 +1570,11 @@
// preallocate stack space
intptr_t* esp = monitors - 1 -
- (tempcount * Interpreter::stackElementWords()) -
+ (tempcount * Interpreter::stackElementWords) -
popframe_extra_args;
- int local_words = method->max_locals() * Interpreter::stackElementWords();
- int parm_words = method->size_of_parameters() * Interpreter::stackElementWords();
+ int local_words = method->max_locals() * Interpreter::stackElementWords;
+ int parm_words = method->size_of_parameters() * Interpreter::stackElementWords;
NEEDS_CLEANUP;
intptr_t* locals;
if (caller->is_interpreted_frame()) {
@@ -1662,7 +1662,7 @@
BasicObjectLock* mp = (BasicObjectLock*)monitors;
assert(interpreter_frame->interpreter_frame_method() == method, "method matches");
- assert(interpreter_frame->interpreter_frame_local_at(9) == (intptr_t *)((intptr_t)locals - (9 * Interpreter::stackElementSize())+Interpreter::value_offset_in_bytes()), "locals match");
+ assert(interpreter_frame->interpreter_frame_local_at(9) == (intptr_t *)((intptr_t)locals - (9 * Interpreter::stackElementSize)), "locals match");
assert(interpreter_frame->interpreter_frame_monitor_end() == mp, "monitor_end matches");
assert(((intptr_t *)interpreter_frame->interpreter_frame_monitor_begin()) == ((intptr_t *)mp)+monitor_size, "monitor_begin matches");
assert(interpreter_frame->interpreter_frame_tos_address()-1 == esp, "esp matches");
@@ -1758,7 +1758,7 @@
// Compute size of arguments for saving when returning to deoptimized caller
__ lduh(Lmethod, in_bytes(methodOopDesc::size_of_parameters_offset()), Gtmp1);
- __ sll(Gtmp1, Interpreter::logStackElementSize(), Gtmp1);
+ __ sll(Gtmp1, Interpreter::logStackElementSize, Gtmp1);
__ sub(Llocals, Gtmp1, Gtmp2);
__ add(Gtmp2, wordSize, Gtmp2);
// Save these arguments
--- a/hotspot/src/cpu/sparc/vm/templateInterpreter_sparc.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/templateInterpreter_sparc.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -29,7 +29,8 @@
// fail with a guarantee ("not enough space for interpreter generation");
// if too small.
// Run with +PrintInterpreter to get the VM to print out the size.
- // Max size with JVMTI and TaggedStackInterpreter
+ // Max size with JVMTI
+
#ifdef _LP64
// The sethi() instruction generates lots more instructions when shell
// stack limit is unlimited, so that's why this is much bigger.
--- a/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -580,7 +580,6 @@
void TemplateTable::iload(int n) {
transition(vtos, itos);
- debug_only(__ verify_local_tag(frame::TagValue, Llocals, Otos_i, n));
__ ld( Llocals, Interpreter::local_offset_in_bytes(n), Otos_i );
}
@@ -588,7 +587,6 @@
void TemplateTable::lload(int n) {
transition(vtos, ltos);
assert(n+1 < Argument::n_register_parameters, "would need more code");
- debug_only(__ verify_local_tag(frame::TagCategory2, Llocals, Otos_l, n));
__ load_unaligned_long(Llocals, Interpreter::local_offset_in_bytes(n+1), Otos_l);
}
@@ -596,7 +594,6 @@
void TemplateTable::fload(int n) {
transition(vtos, ftos);
assert(n < Argument::n_register_parameters, "would need more code");
- debug_only(__ verify_local_tag(frame::TagValue, Llocals, G3_scratch, n));
__ ldf( FloatRegisterImpl::S, Llocals, Interpreter::local_offset_in_bytes(n), Ftos_f );
}
@@ -604,14 +601,12 @@
void TemplateTable::dload(int n) {
transition(vtos, dtos);
FloatRegister dst = Ftos_d;
- debug_only(__ verify_local_tag(frame::TagCategory2, Llocals, G3_scratch, n));
__ load_unaligned_double(Llocals, Interpreter::local_offset_in_bytes(n+1), dst);
}
void TemplateTable::aload(int n) {
transition(vtos, atos);
- debug_only(__ verify_local_tag(frame::TagReference, Llocals, Otos_i, n));
__ ld_ptr( Llocals, Interpreter::local_offset_in_bytes(n), Otos_i );
}
@@ -707,12 +702,11 @@
void TemplateTable::astore() {
transition(vtos, vtos);
- // astore tos can also be a returnAddress, so load and store the tag too
- __ load_ptr_and_tag(0, Otos_i, Otos_l2);
- __ inc(Lesp, Interpreter::stackElementSize());
+ __ load_ptr(0, Otos_i);
+ __ inc(Lesp, Interpreter::stackElementSize);
__ verify_oop_or_return_address(Otos_i, G3_scratch);
locals_index(G3_scratch);
- __ store_local_ptr( G3_scratch, Otos_i, Otos_l2 );
+ __ store_local_ptr(G3_scratch, Otos_i);
}
@@ -750,12 +744,11 @@
void TemplateTable::wide_astore() {
transition(vtos, vtos);
- // astore tos can also be a returnAddress, so load and store the tag too
- __ load_ptr_and_tag(0, Otos_i, Otos_l2);
- __ inc(Lesp, Interpreter::stackElementSize());
+ __ load_ptr(0, Otos_i);
+ __ inc(Lesp, Interpreter::stackElementSize);
__ verify_oop_or_return_address(Otos_i, G3_scratch);
locals_index_wide(G3_scratch);
- __ store_local_ptr( G3_scratch, Otos_i, Otos_l2 );
+ __ store_local_ptr(G3_scratch, Otos_i);
}
@@ -845,13 +838,13 @@
do_oop_store(_masm, O1, noreg, arrayOopDesc::base_offset_in_bytes(T_OBJECT), Otos_i, G3_scratch, _bs->kind(), true);
__ ba(false,done);
- __ delayed()->inc(Lesp, 3* Interpreter::stackElementSize()); // adj sp (pops array, index and value)
+ __ delayed()->inc(Lesp, 3* Interpreter::stackElementSize); // adj sp (pops array, index and value)
__ bind(is_null);
do_oop_store(_masm, O1, noreg, arrayOopDesc::base_offset_in_bytes(T_OBJECT), G0, G4_scratch, _bs->kind(), true);
__ profile_null_seen(G3_scratch);
- __ inc(Lesp, 3* Interpreter::stackElementSize()); // adj sp (pops array, index and value)
+ __ inc(Lesp, 3* Interpreter::stackElementSize); // adj sp (pops array, index and value)
__ bind(done);
}
@@ -884,7 +877,6 @@
void TemplateTable::istore(int n) {
transition(itos, vtos);
- __ tag_local(frame::TagValue, Llocals, Otos_i, n);
__ st(Otos_i, Llocals, Interpreter::local_offset_in_bytes(n));
}
@@ -892,7 +884,6 @@
void TemplateTable::lstore(int n) {
transition(ltos, vtos);
assert(n+1 < Argument::n_register_parameters, "only handle register cases");
- __ tag_local(frame::TagCategory2, Llocals, Otos_l, n);
__ store_unaligned_long(Otos_l, Llocals, Interpreter::local_offset_in_bytes(n+1));
}
@@ -901,7 +892,6 @@
void TemplateTable::fstore(int n) {
transition(ftos, vtos);
assert(n < Argument::n_register_parameters, "only handle register cases");
- __ tag_local(frame::TagValue, Llocals, Otos_l, n);
__ stf(FloatRegisterImpl::S, Ftos_f, Llocals, Interpreter::local_offset_in_bytes(n));
}
@@ -909,30 +899,28 @@
void TemplateTable::dstore(int n) {
transition(dtos, vtos);
FloatRegister src = Ftos_d;
- __ tag_local(frame::TagCategory2, Llocals, Otos_l, n);
__ store_unaligned_double(src, Llocals, Interpreter::local_offset_in_bytes(n+1));
}
void TemplateTable::astore(int n) {
transition(vtos, vtos);
- // astore tos can also be a returnAddress, so load and store the tag too
- __ load_ptr_and_tag(0, Otos_i, Otos_l2);
- __ inc(Lesp, Interpreter::stackElementSize());
+ __ load_ptr(0, Otos_i);
+ __ inc(Lesp, Interpreter::stackElementSize);
__ verify_oop_or_return_address(Otos_i, G3_scratch);
- __ store_local_ptr( n, Otos_i, Otos_l2 );
+ __ store_local_ptr(n, Otos_i);
}
void TemplateTable::pop() {
transition(vtos, vtos);
- __ inc(Lesp, Interpreter::stackElementSize());
+ __ inc(Lesp, Interpreter::stackElementSize);
}
void TemplateTable::pop2() {
transition(vtos, vtos);
- __ inc(Lesp, 2 * Interpreter::stackElementSize());
+ __ inc(Lesp, 2 * Interpreter::stackElementSize);
}
@@ -940,8 +928,8 @@
transition(vtos, vtos);
// stack: ..., a
// load a and tag
- __ load_ptr_and_tag(0, Otos_i, Otos_l2);
- __ push_ptr(Otos_i, Otos_l2);
+ __ load_ptr(0, Otos_i);
+ __ push_ptr(Otos_i);
// stack: ..., a, a
}
@@ -949,11 +937,11 @@
void TemplateTable::dup_x1() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(1, G3_scratch, G4_scratch); // get a
- __ load_ptr_and_tag(0, Otos_l1, Otos_l2); // get b
- __ store_ptr_and_tag(1, Otos_l1, Otos_l2); // put b
- __ store_ptr_and_tag(0, G3_scratch, G4_scratch); // put a - like swap
- __ push_ptr(Otos_l1, Otos_l2); // push b
+ __ load_ptr( 1, G3_scratch); // get a
+ __ load_ptr( 0, Otos_l1); // get b
+ __ store_ptr(1, Otos_l1); // put b
+ __ store_ptr(0, G3_scratch); // put a - like swap
+ __ push_ptr(Otos_l1); // push b
// stack: ..., b, a, b
}
@@ -962,27 +950,27 @@
transition(vtos, vtos);
// stack: ..., a, b, c
// get c and push on stack, reuse registers
- __ load_ptr_and_tag(0, G3_scratch, G4_scratch); // get c
- __ push_ptr(G3_scratch, G4_scratch); // push c with tag
+ __ load_ptr( 0, G3_scratch); // get c
+ __ push_ptr(G3_scratch); // push c with tag
// stack: ..., a, b, c, c (c in reg) (Lesp - 4)
// (stack offsets n+1 now)
- __ load_ptr_and_tag(3, Otos_l1, Otos_l2); // get a
- __ store_ptr_and_tag(3, G3_scratch, G4_scratch); // put c at 3
+ __ load_ptr( 3, Otos_l1); // get a
+ __ store_ptr(3, G3_scratch); // put c at 3
// stack: ..., c, b, c, c (a in reg)
- __ load_ptr_and_tag(2, G3_scratch, G4_scratch); // get b
- __ store_ptr_and_tag(2, Otos_l1, Otos_l2); // put a at 2
+ __ load_ptr( 2, G3_scratch); // get b
+ __ store_ptr(2, Otos_l1); // put a at 2
// stack: ..., c, a, c, c (b in reg)
- __ store_ptr_and_tag(1, G3_scratch, G4_scratch); // put b at 1
+ __ store_ptr(1, G3_scratch); // put b at 1
// stack: ..., c, a, b, c
}
void TemplateTable::dup2() {
transition(vtos, vtos);
- __ load_ptr_and_tag(1, G3_scratch, G4_scratch); // get a
- __ load_ptr_and_tag(0, Otos_l1, Otos_l2); // get b
- __ push_ptr(G3_scratch, G4_scratch); // push a
- __ push_ptr(Otos_l1, Otos_l2); // push b
+ __ load_ptr(1, G3_scratch); // get a
+ __ load_ptr(0, Otos_l1); // get b
+ __ push_ptr(G3_scratch); // push a
+ __ push_ptr(Otos_l1); // push b
// stack: ..., a, b, a, b
}
@@ -990,17 +978,17 @@
void TemplateTable::dup2_x1() {
transition(vtos, vtos);
// stack: ..., a, b, c
- __ load_ptr_and_tag(1, Lscratch, G1_scratch); // get b
- __ load_ptr_and_tag(2, Otos_l1, Otos_l2); // get a
- __ store_ptr_and_tag(2, Lscratch, G1_scratch); // put b at a
+ __ load_ptr( 1, Lscratch); // get b
+ __ load_ptr( 2, Otos_l1); // get a
+ __ store_ptr(2, Lscratch); // put b at a
// stack: ..., b, b, c
- __ load_ptr_and_tag(0, G3_scratch, G4_scratch); // get c
- __ store_ptr_and_tag(1, G3_scratch, G4_scratch); // put c at b
+ __ load_ptr( 0, G3_scratch); // get c
+ __ store_ptr(1, G3_scratch); // put c at b
// stack: ..., b, c, c
- __ store_ptr_and_tag(0, Otos_l1, Otos_l2); // put a at c
+ __ store_ptr(0, Otos_l1); // put a at c
// stack: ..., b, c, a
- __ push_ptr(Lscratch, G1_scratch); // push b
- __ push_ptr(G3_scratch, G4_scratch); // push c
+ __ push_ptr(Lscratch); // push b
+ __ push_ptr(G3_scratch); // push c
// stack: ..., b, c, a, b, c
}
@@ -1010,18 +998,18 @@
void TemplateTable::dup2_x2() {
transition(vtos, vtos);
// stack: ..., a, b, c, d
- __ load_ptr_and_tag(1, Lscratch, G1_scratch); // get c
- __ load_ptr_and_tag(3, Otos_l1, Otos_l2); // get a
- __ store_ptr_and_tag(3, Lscratch, G1_scratch); // put c at 3
- __ store_ptr_and_tag(1, Otos_l1, Otos_l2); // put a at 1
+ __ load_ptr( 1, Lscratch); // get c
+ __ load_ptr( 3, Otos_l1); // get a
+ __ store_ptr(3, Lscratch); // put c at 3
+ __ store_ptr(1, Otos_l1); // put a at 1
// stack: ..., c, b, a, d
- __ load_ptr_and_tag(2, G3_scratch, G4_scratch); // get b
- __ load_ptr_and_tag(0, Otos_l1, Otos_l2); // get d
- __ store_ptr_and_tag(0, G3_scratch, G4_scratch); // put b at 0
- __ store_ptr_and_tag(2, Otos_l1, Otos_l2); // put d at 2
+ __ load_ptr( 2, G3_scratch); // get b
+ __ load_ptr( 0, Otos_l1); // get d
+ __ store_ptr(0, G3_scratch); // put b at 0
+ __ store_ptr(2, Otos_l1); // put d at 2
// stack: ..., c, d, a, b
- __ push_ptr(Lscratch, G1_scratch); // push c
- __ push_ptr(Otos_l1, Otos_l2); // push d
+ __ push_ptr(Lscratch); // push c
+ __ push_ptr(Otos_l1); // push d
// stack: ..., c, d, a, b, c, d
}
@@ -1029,10 +1017,10 @@
void TemplateTable::swap() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(1, G3_scratch, G4_scratch); // get a
- __ load_ptr_and_tag(0, Otos_l1, Otos_l2); // get b
- __ store_ptr_and_tag(0, G3_scratch, G4_scratch); // put b
- __ store_ptr_and_tag(1, Otos_l1, Otos_l2); // put a
+ __ load_ptr( 1, G3_scratch); // get a
+ __ load_ptr( 0, Otos_l1); // get b
+ __ store_ptr(0, G3_scratch); // put b
+ __ store_ptr(1, Otos_l1); // put a
// stack: ..., b, a
}
@@ -1045,9 +1033,9 @@
case sub: __ sub(O1, Otos_i, Otos_i); break;
// %%%%% Mul may not exist: better to call .mul?
case mul: __ smul(O1, Otos_i, Otos_i); break;
- case _and: __ and3(O1, Otos_i, Otos_i); break;
- case _or: __ or3(O1, Otos_i, Otos_i); break;
- case _xor: __ xor3(O1, Otos_i, Otos_i); break;
+ case _and: __ and3(O1, Otos_i, Otos_i); break;
+ case _or: __ or3(O1, Otos_i, Otos_i); break;
+ case _xor: __ xor3(O1, Otos_i, Otos_i); break;
case shl: __ sll(O1, Otos_i, Otos_i); break;
case shr: __ sra(O1, Otos_i, Otos_i); break;
case ushr: __ srl(O1, Otos_i, Otos_i); break;
@@ -1061,17 +1049,17 @@
__ pop_l(O2);
switch (op) {
#ifdef _LP64
- case add: __ add(O2, Otos_l, Otos_l); break;
- case sub: __ sub(O2, Otos_l, Otos_l); break;
- case _and: __ and3( O2, Otos_l, Otos_l); break;
- case _or: __ or3( O2, Otos_l, Otos_l); break;
- case _xor: __ xor3( O2, Otos_l, Otos_l); break;
+ case add: __ add(O2, Otos_l, Otos_l); break;
+ case sub: __ sub(O2, Otos_l, Otos_l); break;
+ case _and: __ and3(O2, Otos_l, Otos_l); break;
+ case _or: __ or3(O2, Otos_l, Otos_l); break;
+ case _xor: __ xor3(O2, Otos_l, Otos_l); break;
#else
case add: __ addcc(O3, Otos_l2, Otos_l2); __ addc(O2, Otos_l1, Otos_l1); break;
case sub: __ subcc(O3, Otos_l2, Otos_l2); __ subc(O2, Otos_l1, Otos_l1); break;
- case _and: __ and3( O3, Otos_l2, Otos_l2); __ and3( O2, Otos_l1, Otos_l1); break;
- case _or: __ or3( O3, Otos_l2, Otos_l2); __ or3( O2, Otos_l1, Otos_l1); break;
- case _xor: __ xor3( O3, Otos_l2, Otos_l2); __ xor3( O2, Otos_l1, Otos_l1); break;
+ case _and: __ and3(O3, Otos_l2, Otos_l2); __ and3(O2, Otos_l1, Otos_l1); break;
+ case _or: __ or3(O3, Otos_l2, Otos_l2); __ or3(O2, Otos_l1, Otos_l1); break;
+ case _xor: __ xor3(O3, Otos_l2, Otos_l2); __ xor3(O2, Otos_l1, Otos_l1); break;
#endif
default: ShouldNotReachHere();
}
@@ -1307,7 +1295,7 @@
__ ldsb(Lbcp, 2, O2); // load constant
__ access_local_int(G3_scratch, Otos_i);
__ add(Otos_i, O2, Otos_i);
- __ st(Otos_i, G3_scratch, Interpreter::value_offset_in_bytes()); // access_local_int puts E.A. in G3_scratch
+ __ st(Otos_i, G3_scratch, 0); // access_local_int puts E.A. in G3_scratch
}
@@ -1317,7 +1305,7 @@
__ get_2_byte_integer_at_bcp( 4, O2, O3, InterpreterMacroAssembler::Signed);
__ access_local_int(G3_scratch, Otos_i);
__ add(Otos_i, O3, Otos_i);
- __ st(Otos_i, G3_scratch, Interpreter::value_offset_in_bytes()); // access_local_int puts E.A. in G3_scratch
+ __ st(Otos_i, G3_scratch, 0); // access_local_int puts E.A. in G3_scratch
}
@@ -1555,7 +1543,7 @@
// Bump Lbcp to target of JSR
__ add(Lbcp, O1_disp, Lbcp);
// Push returnAddress for "ret" on stack
- __ push_ptr(Otos_i, G0); // push ptr sized thing plus 0 for tag.
+ __ push_ptr(Otos_i);
// And away we go!
__ dispatch_next(vtos);
return;
@@ -2754,7 +2742,7 @@
Register Rflags = G4_scratch;
Register Rreceiver = Lscratch;
- __ ld_ptr(Llocals, Interpreter::value_offset_in_bytes(), Rreceiver);
+ __ ld_ptr(Llocals, 0, Rreceiver);
// access constant pool cache (is resolved)
__ get_cache_and_index_at_bcp(Rcache, G4_scratch, 2);
@@ -3696,7 +3684,7 @@
transition(vtos, atos);
// put ndims * wordSize into Lscratch
__ ldub( Lbcp, 3, Lscratch);
- __ sll( Lscratch, Interpreter::logStackElementSize(), Lscratch);
+ __ sll( Lscratch, Interpreter::logStackElementSize, Lscratch);
// Lesp points past last_dim, so set to O1 to first_dim address
__ add( Lesp, Lscratch, O1);
call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray), O1);
--- a/hotspot/src/cpu/x86/vm/assembler_x86.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/assembler_x86.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -7740,7 +7740,7 @@
Address MacroAssembler::argument_address(RegisterOrConstant arg_slot,
int extra_slot_offset) {
// cf. TemplateTable::prepare_invoke(), if (load_receiver).
- int stackElementSize = Interpreter::stackElementSize();
+ int stackElementSize = Interpreter::stackElementSize;
int offset = Interpreter::expr_offset_in_bytes(extra_slot_offset+0);
#ifdef ASSERT
int offset1 = Interpreter::expr_offset_in_bytes(extra_slot_offset+1);
--- a/hotspot/src/cpu/x86/vm/cppInterpreter_x86.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/cppInterpreter_x86.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -28,6 +28,6 @@
// Size of interpreter code. Increase if too small. Interpreter will
// fail with a guarantee ("not enough space for interpreter generation");
// if too small.
- // Run with +PrintInterpreterSize to get the VM to print out the size.
- // Max size with JVMTI and TaggedStackInterpreter
+ // Run with +PrintInterpreter to get the VM to print out the size.
+ // Max size with JVMTI
const static int InterpreterCodeSize = 168 * 1024;
--- a/hotspot/src/cpu/x86/vm/frame_x86.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/frame_x86.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -502,7 +502,7 @@
// When unpacking an optimized frame the frame pointer is
// adjusted with:
int diff = (method->max_locals() - method->size_of_parameters()) *
- Interpreter::stackElementWords();
+ Interpreter::stackElementWords;
return _fp == (fp - diff);
}
@@ -542,7 +542,7 @@
// stack frames shouldn't be much larger than max_stack elements
- if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize()) {
+ if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize) {
return false;
}
@@ -594,7 +594,7 @@
#ifdef AMD64
// This is times two because we do a push(ltos) after pushing XMM0
// and that takes two interpreter stack slots.
- tos_addr += 2 * Interpreter::stackElementWords();
+ tos_addr += 2 * Interpreter::stackElementWords;
#else
tos_addr += 2;
#endif // AMD64
--- a/hotspot/src/cpu/x86/vm/interp_masm_x86_32.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interp_masm_x86_32.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -265,89 +265,30 @@
// Java Expression Stack
-#ifdef ASSERT
-void InterpreterMacroAssembler::verify_stack_tag(frame::Tag t) {
- if (TaggedStackInterpreter) {
- Label okay;
- cmpptr(Address(rsp, wordSize), (int32_t)t);
- jcc(Assembler::equal, okay);
- // Also compare if the stack value is zero, then the tag might
- // not have been set coming from deopt.
- cmpptr(Address(rsp, 0), 0);
- jcc(Assembler::equal, okay);
- stop("Java Expression stack tag value is bad");
- bind(okay);
- }
-}
-#endif // ASSERT
-
void InterpreterMacroAssembler::pop_ptr(Register r) {
- debug_only(verify_stack_tag(frame::TagReference));
pop(r);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
-}
-
-void InterpreterMacroAssembler::pop_ptr(Register r, Register tag) {
- pop(r);
- // Tag may not be reference for jsr, can be returnAddress
- if (TaggedStackInterpreter) pop(tag);
}
void InterpreterMacroAssembler::pop_i(Register r) {
- debug_only(verify_stack_tag(frame::TagValue));
pop(r);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
}
void InterpreterMacroAssembler::pop_l(Register lo, Register hi) {
- debug_only(verify_stack_tag(frame::TagValue));
pop(lo);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
- debug_only(verify_stack_tag(frame::TagValue));
pop(hi);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
}
void InterpreterMacroAssembler::pop_f() {
- debug_only(verify_stack_tag(frame::TagValue));
fld_s(Address(rsp, 0));
addptr(rsp, 1 * wordSize);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
}
void InterpreterMacroAssembler::pop_d() {
- // Write double to stack contiguously and load into ST0
- pop_dtos_to_rsp();
fld_d(Address(rsp, 0));
addptr(rsp, 2 * wordSize);
}
-// Pop the top of the java expression stack to execution stack (which
-// happens to be the same place).
-void InterpreterMacroAssembler::pop_dtos_to_rsp() {
- if (TaggedStackInterpreter) {
- // Pop double value into scratch registers
- debug_only(verify_stack_tag(frame::TagValue));
- pop(rax);
- addptr(rsp, 1* wordSize);
- debug_only(verify_stack_tag(frame::TagValue));
- pop(rdx);
- addptr(rsp, 1* wordSize);
- push(rdx);
- push(rax);
- }
-}
-
-void InterpreterMacroAssembler::pop_ftos_to_rsp() {
- if (TaggedStackInterpreter) {
- debug_only(verify_stack_tag(frame::TagValue));
- pop(rax);
- addptr(rsp, 1 * wordSize);
- push(rax); // ftos is at rsp
- }
-}
-
void InterpreterMacroAssembler::pop(TosState state) {
switch (state) {
case atos: pop_ptr(rax); break;
@@ -365,54 +306,28 @@
}
void InterpreterMacroAssembler::push_ptr(Register r) {
- if (TaggedStackInterpreter) push(frame::TagReference);
- push(r);
-}
-
-void InterpreterMacroAssembler::push_ptr(Register r, Register tag) {
- if (TaggedStackInterpreter) push(tag); // tag first
push(r);
}
void InterpreterMacroAssembler::push_i(Register r) {
- if (TaggedStackInterpreter) push(frame::TagValue);
push(r);
}
void InterpreterMacroAssembler::push_l(Register lo, Register hi) {
- if (TaggedStackInterpreter) push(frame::TagValue);
push(hi);
- if (TaggedStackInterpreter) push(frame::TagValue);
push(lo);
}
void InterpreterMacroAssembler::push_f() {
- if (TaggedStackInterpreter) push(frame::TagValue);
// Do not schedule for no AGI! Never write beyond rsp!
subptr(rsp, 1 * wordSize);
fstp_s(Address(rsp, 0));
}
void InterpreterMacroAssembler::push_d(Register r) {
- if (TaggedStackInterpreter) {
- // Double values are stored as:
- // tag
- // high
- // tag
- // low
- push(frame::TagValue);
- subptr(rsp, 3 * wordSize);
- fstp_d(Address(rsp, 0));
- // move high word up to slot n-1
- movl(r, Address(rsp, 1*wordSize));
- movl(Address(rsp, 2*wordSize), r);
- // move tag
- movl(Address(rsp, 1*wordSize), frame::TagValue);
- } else {
- // Do not schedule for no AGI! Never write beyond rsp!
- subptr(rsp, 2 * wordSize);
- fstp_d(Address(rsp, 0));
- }
+ // Do not schedule for no AGI! Never write beyond rsp!
+ subptr(rsp, 2 * wordSize);
+ fstp_d(Address(rsp, 0));
}
@@ -433,118 +348,15 @@
}
-// Tagged stack helpers for swap and dup
-void InterpreterMacroAssembler::load_ptr_and_tag(int n, Register val,
- Register tag) {
+// Helpers for swap and dup
+void InterpreterMacroAssembler::load_ptr(int n, Register val) {
movptr(val, Address(rsp, Interpreter::expr_offset_in_bytes(n)));
- if (TaggedStackInterpreter) {
- movptr(tag, Address(rsp, Interpreter::expr_tag_offset_in_bytes(n)));
- }
-}
-
-void InterpreterMacroAssembler::store_ptr_and_tag(int n, Register val,
- Register tag) {
- movptr(Address(rsp, Interpreter::expr_offset_in_bytes(n)), val);
- if (TaggedStackInterpreter) {
- movptr(Address(rsp, Interpreter::expr_tag_offset_in_bytes(n)), tag);
- }
-}
-
-
-// Tagged local support
-void InterpreterMacroAssembler::tag_local(frame::Tag tag, int n) {
- if (TaggedStackInterpreter) {
- if (tag == frame::TagCategory2) {
- movptr(Address(rdi, Interpreter::local_tag_offset_in_bytes(n+1)), (int32_t)frame::TagValue);
- movptr(Address(rdi, Interpreter::local_tag_offset_in_bytes(n)), (int32_t)frame::TagValue);
- } else {
- movptr(Address(rdi, Interpreter::local_tag_offset_in_bytes(n)), (int32_t)tag);
- }
- }
-}
-
-void InterpreterMacroAssembler::tag_local(frame::Tag tag, Register idx) {
- if (TaggedStackInterpreter) {
- if (tag == frame::TagCategory2) {
- movptr(Address(rdi, idx, Interpreter::stackElementScale(),
- Interpreter::local_tag_offset_in_bytes(1)), (int32_t)frame::TagValue);
- movptr(Address(rdi, idx, Interpreter::stackElementScale(),
- Interpreter::local_tag_offset_in_bytes(0)), (int32_t)frame::TagValue);
- } else {
- movptr(Address(rdi, idx, Interpreter::stackElementScale(),
- Interpreter::local_tag_offset_in_bytes(0)), (int32_t)tag);
- }
- }
-}
-
-void InterpreterMacroAssembler::tag_local(Register tag, Register idx) {
- if (TaggedStackInterpreter) {
- // can only be TagValue or TagReference
- movptr(Address(rdi, idx, Interpreter::stackElementScale(),
- Interpreter::local_tag_offset_in_bytes(0)), tag);
- }
}
-
-void InterpreterMacroAssembler::tag_local(Register tag, int n) {
- if (TaggedStackInterpreter) {
- // can only be TagValue or TagReference
- movptr(Address(rdi, Interpreter::local_tag_offset_in_bytes(n)), tag);
- }
+void InterpreterMacroAssembler::store_ptr(int n, Register val) {
+ movptr(Address(rsp, Interpreter::expr_offset_in_bytes(n)), val);
}
-#ifdef ASSERT
-void InterpreterMacroAssembler::verify_local_tag(frame::Tag tag, int n) {
- if (TaggedStackInterpreter) {
- frame::Tag t = tag;
- if (tag == frame::TagCategory2) {
- Label nbl;
- t = frame::TagValue; // change to what is stored in locals
- cmpptr(Address(rdi, Interpreter::local_tag_offset_in_bytes(n+1)), (int32_t)t);
- jcc(Assembler::equal, nbl);
- stop("Local tag is bad for long/double");
- bind(nbl);
- }
- Label notBad;
- cmpptr(Address(rdi, Interpreter::local_tag_offset_in_bytes(n)), (int32_t)t);
- jcc(Assembler::equal, notBad);
- // Also compare if the local value is zero, then the tag might
- // not have been set coming from deopt.
- cmpptr(Address(rdi, Interpreter::local_offset_in_bytes(n)), 0);
- jcc(Assembler::equal, notBad);
- stop("Local tag is bad");
- bind(notBad);
- }
-}
-
-void InterpreterMacroAssembler::verify_local_tag(frame::Tag tag, Register idx) {
- if (TaggedStackInterpreter) {
- frame::Tag t = tag;
- if (tag == frame::TagCategory2) {
- Label nbl;
- t = frame::TagValue; // change to what is stored in locals
- cmpptr(Address(rdi, idx, Interpreter::stackElementScale(),
- Interpreter::local_tag_offset_in_bytes(1)), (int32_t)t);
- jcc(Assembler::equal, nbl);
- stop("Local tag is bad for long/double");
- bind(nbl);
- }
- Label notBad;
- cmpl(Address(rdi, idx, Interpreter::stackElementScale(),
- Interpreter::local_tag_offset_in_bytes(0)), (int32_t)t);
- jcc(Assembler::equal, notBad);
- // Also compare if the local value is zero, then the tag might
- // not have been set coming from deopt.
- cmpptr(Address(rdi, idx, Interpreter::stackElementScale(),
- Interpreter::local_offset_in_bytes(0)), 0);
- jcc(Assembler::equal, notBad);
- stop("Local tag is bad");
- bind(notBad);
-
- }
-}
-#endif // ASSERT
-
void InterpreterMacroAssembler::super_call_VM_leaf(address entry_point) {
MacroAssembler::call_VM_leaf_base(entry_point, 0);
}
--- a/hotspot/src/cpu/x86/vm/interp_masm_x86_32.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interp_masm_x86_32.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -85,16 +85,12 @@
void d2ieee(); // truncate dtos to 64bits
void pop_ptr(Register r = rax);
- void pop_ptr(Register r, Register tag);
void pop_i(Register r = rax);
void pop_l(Register lo = rax, Register hi = rdx);
void pop_f();
void pop_d();
- void pop_ftos_to_rsp();
- void pop_dtos_to_rsp();
void push_ptr(Register r = rax);
- void push_ptr(Register r, Register tag);
void push_i(Register r = rax);
void push_l(Register lo = rax, Register hi = rdx);
void push_d(Register r = rax);
@@ -112,33 +108,15 @@
void pop(void* v ); // Add unimplemented ambiguous method
void push(void* v ); // Add unimplemented ambiguous method
- DEBUG_ONLY(void verify_stack_tag(frame::Tag t);)
-
-#endif // CC_INTERP
-
-#ifndef CC_INTERP
-
- void empty_expression_stack() {
- movptr(rsp, Address(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize));
- // NULL last_sp until next java call
- movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
+ void empty_expression_stack() {
+ movptr(rsp, Address(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize));
+ // NULL last_sp until next java call
+ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
}
- // Tagged stack helpers for swap and dup
- void load_ptr_and_tag(int n, Register val, Register tag);
- void store_ptr_and_tag(int n, Register val, Register tag);
-
- // Tagged Local support
-
- void tag_local(frame::Tag tag, int n);
- void tag_local(Register tag, int n);
- void tag_local(frame::Tag tag, Register idx);
- void tag_local(Register tag, Register idx);
-
-#ifdef ASSERT
- void verify_local_tag(frame::Tag tag, int n);
- void verify_local_tag(frame::Tag tag, Register idx);
-#endif // ASSERT
+ // Helpers for swap and dup
+ void load_ptr(int n, Register val);
+ void store_ptr(int n, Register val);
// Super call_VM calls - correspond to MacroAssembler::call_VM(_leaf) calls
void super_call_VM_leaf(address entry_point);
--- a/hotspot/src/cpu/x86/vm/interp_masm_x86_64.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interp_masm_x86_64.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -264,113 +264,51 @@
// Java Expression Stack
-#ifdef ASSERT
-// Verifies that the stack tag matches. Must be called before the stack
-// value is popped off the stack.
-void InterpreterMacroAssembler::verify_stack_tag(frame::Tag t) {
- if (TaggedStackInterpreter) {
- frame::Tag tag = t;
- if (t == frame::TagCategory2) {
- tag = frame::TagValue;
- Label hokay;
- cmpptr(Address(rsp, 3*wordSize), (int32_t)tag);
- jcc(Assembler::equal, hokay);
- stop("Java Expression stack tag high value is bad");
- bind(hokay);
- }
- Label okay;
- cmpptr(Address(rsp, wordSize), (int32_t)tag);
- jcc(Assembler::equal, okay);
- // Also compare if the stack value is zero, then the tag might
- // not have been set coming from deopt.
- cmpptr(Address(rsp, 0), 0);
- jcc(Assembler::equal, okay);
- stop("Java Expression stack tag value is bad");
- bind(okay);
- }
-}
-#endif // ASSERT
-
void InterpreterMacroAssembler::pop_ptr(Register r) {
- debug_only(verify_stack_tag(frame::TagReference));
pop(r);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
-}
-
-void InterpreterMacroAssembler::pop_ptr(Register r, Register tag) {
- pop(r);
- if (TaggedStackInterpreter) pop(tag);
}
void InterpreterMacroAssembler::pop_i(Register r) {
// XXX can't use pop currently, upper half non clean
- debug_only(verify_stack_tag(frame::TagValue));
movl(r, Address(rsp, 0));
addptr(rsp, wordSize);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
}
void InterpreterMacroAssembler::pop_l(Register r) {
- debug_only(verify_stack_tag(frame::TagCategory2));
movq(r, Address(rsp, 0));
- addptr(rsp, 2 * Interpreter::stackElementSize());
+ addptr(rsp, 2 * Interpreter::stackElementSize);
}
void InterpreterMacroAssembler::pop_f(XMMRegister r) {
- debug_only(verify_stack_tag(frame::TagValue));
movflt(r, Address(rsp, 0));
addptr(rsp, wordSize);
- if (TaggedStackInterpreter) addptr(rsp, 1 * wordSize);
}
void InterpreterMacroAssembler::pop_d(XMMRegister r) {
- debug_only(verify_stack_tag(frame::TagCategory2));
movdbl(r, Address(rsp, 0));
- addptr(rsp, 2 * Interpreter::stackElementSize());
+ addptr(rsp, 2 * Interpreter::stackElementSize);
}
void InterpreterMacroAssembler::push_ptr(Register r) {
- if (TaggedStackInterpreter) push(frame::TagReference);
- push(r);
-}
-
-void InterpreterMacroAssembler::push_ptr(Register r, Register tag) {
- if (TaggedStackInterpreter) push(tag);
push(r);
}
void InterpreterMacroAssembler::push_i(Register r) {
- if (TaggedStackInterpreter) push(frame::TagValue);
push(r);
}
void InterpreterMacroAssembler::push_l(Register r) {
- if (TaggedStackInterpreter) {
- push(frame::TagValue);
- subptr(rsp, 1 * wordSize);
- push(frame::TagValue);
- subptr(rsp, 1 * wordSize);
- } else {
- subptr(rsp, 2 * wordSize);
- }
+ subptr(rsp, 2 * wordSize);
movq(Address(rsp, 0), r);
}
void InterpreterMacroAssembler::push_f(XMMRegister r) {
- if (TaggedStackInterpreter) push(frame::TagValue);
subptr(rsp, wordSize);
movflt(Address(rsp, 0), r);
}
void InterpreterMacroAssembler::push_d(XMMRegister r) {
- if (TaggedStackInterpreter) {
- push(frame::TagValue);
- subptr(rsp, 1 * wordSize);
- push(frame::TagValue);
- subptr(rsp, 1 * wordSize);
- } else {
- subptr(rsp, 2 * wordSize);
- }
+ subptr(rsp, 2 * wordSize);
movdbl(Address(rsp, 0), r);
}
@@ -407,117 +345,15 @@
}
-
-
-// Tagged stack helpers for swap and dup
-void InterpreterMacroAssembler::load_ptr_and_tag(int n, Register val,
- Register tag) {
+// Helpers for swap and dup
+void InterpreterMacroAssembler::load_ptr(int n, Register val) {
movptr(val, Address(rsp, Interpreter::expr_offset_in_bytes(n)));
- if (TaggedStackInterpreter) {
- movptr(tag, Address(rsp, Interpreter::expr_tag_offset_in_bytes(n)));
- }
-}
-
-void InterpreterMacroAssembler::store_ptr_and_tag(int n, Register val,
- Register tag) {
- movptr(Address(rsp, Interpreter::expr_offset_in_bytes(n)), val);
- if (TaggedStackInterpreter) {
- movptr(Address(rsp, Interpreter::expr_tag_offset_in_bytes(n)), tag);
- }
-}
-
-
-// Tagged local support
-void InterpreterMacroAssembler::tag_local(frame::Tag tag, int n) {
- if (TaggedStackInterpreter) {
- if (tag == frame::TagCategory2) {
- movptr(Address(r14, Interpreter::local_tag_offset_in_bytes(n+1)),
- (int32_t)frame::TagValue);
- movptr(Address(r14, Interpreter::local_tag_offset_in_bytes(n)),
- (int32_t)frame::TagValue);
- } else {
- movptr(Address(r14, Interpreter::local_tag_offset_in_bytes(n)), (int32_t)tag);
- }
- }
-}
-
-void InterpreterMacroAssembler::tag_local(frame::Tag tag, Register idx) {
- if (TaggedStackInterpreter) {
- if (tag == frame::TagCategory2) {
- movptr(Address(r14, idx, Address::times_8,
- Interpreter::local_tag_offset_in_bytes(1)), (int32_t)frame::TagValue);
- movptr(Address(r14, idx, Address::times_8,
- Interpreter::local_tag_offset_in_bytes(0)), (int32_t)frame::TagValue);
- } else {
- movptr(Address(r14, idx, Address::times_8, Interpreter::local_tag_offset_in_bytes(0)),
- (int32_t)tag);
- }
- }
-}
-
-void InterpreterMacroAssembler::tag_local(Register tag, Register idx) {
- if (TaggedStackInterpreter) {
- // can only be TagValue or TagReference
- movptr(Address(r14, idx, Address::times_8, Interpreter::local_tag_offset_in_bytes(0)), tag);
- }
}
-
-void InterpreterMacroAssembler::tag_local(Register tag, int n) {
- if (TaggedStackInterpreter) {
- // can only be TagValue or TagReference
- movptr(Address(r14, Interpreter::local_tag_offset_in_bytes(n)), tag);
- }
+void InterpreterMacroAssembler::store_ptr(int n, Register val) {
+ movptr(Address(rsp, Interpreter::expr_offset_in_bytes(n)), val);
}
-#ifdef ASSERT
-void InterpreterMacroAssembler::verify_local_tag(frame::Tag tag, int n) {
- if (TaggedStackInterpreter) {
- frame::Tag t = tag;
- if (tag == frame::TagCategory2) {
- Label nbl;
- t = frame::TagValue; // change to what is stored in locals
- cmpptr(Address(r14, Interpreter::local_tag_offset_in_bytes(n+1)), (int32_t)t);
- jcc(Assembler::equal, nbl);
- stop("Local tag is bad for long/double");
- bind(nbl);
- }
- Label notBad;
- cmpq(Address(r14, Interpreter::local_tag_offset_in_bytes(n)), (int32_t)t);
- jcc(Assembler::equal, notBad);
- // Also compare if the local value is zero, then the tag might
- // not have been set coming from deopt.
- cmpptr(Address(r14, Interpreter::local_offset_in_bytes(n)), 0);
- jcc(Assembler::equal, notBad);
- stop("Local tag is bad");
- bind(notBad);
- }
-}
-
-void InterpreterMacroAssembler::verify_local_tag(frame::Tag tag, Register idx) {
- if (TaggedStackInterpreter) {
- frame::Tag t = tag;
- if (tag == frame::TagCategory2) {
- Label nbl;
- t = frame::TagValue; // change to what is stored in locals
- cmpptr(Address(r14, idx, Address::times_8, Interpreter::local_tag_offset_in_bytes(1)), (int32_t)t);
- jcc(Assembler::equal, nbl);
- stop("Local tag is bad for long/double");
- bind(nbl);
- }
- Label notBad;
- cmpptr(Address(r14, idx, Address::times_8, Interpreter::local_tag_offset_in_bytes(0)), (int32_t)t);
- jcc(Assembler::equal, notBad);
- // Also compare if the local value is zero, then the tag might
- // not have been set coming from deopt.
- cmpptr(Address(r14, idx, Address::times_8, Interpreter::local_offset_in_bytes(0)), 0);
- jcc(Assembler::equal, notBad);
- stop("Local tag is bad");
- bind(notBad);
- }
-}
-#endif // ASSERT
-
void InterpreterMacroAssembler::super_call_VM_leaf(address entry_point) {
MacroAssembler::call_VM_leaf_base(entry_point, 0);
--- a/hotspot/src/cpu/x86/vm/interp_masm_x86_64.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interp_masm_x86_64.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 2003-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2003-2010 Sun Microsystems, Inc. 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
@@ -120,38 +120,16 @@
void pop(TosState state); // transition vtos -> state
void push(TosState state); // transition state -> vtos
- // Tagged stack support, pop and push both tag and value.
- void pop_ptr(Register r, Register tag);
- void push_ptr(Register r, Register tag);
-#endif // CC_INTERP
-
- DEBUG_ONLY(void verify_stack_tag(frame::Tag t);)
-
-#ifndef CC_INTERP
-
- // Tagged stack helpers for swap and dup
- void load_ptr_and_tag(int n, Register val, Register tag);
- void store_ptr_and_tag(int n, Register val, Register tag);
-
- // Tagged Local support
- void tag_local(frame::Tag tag, int n);
- void tag_local(Register tag, int n);
- void tag_local(frame::Tag tag, Register idx);
- void tag_local(Register tag, Register idx);
-
-#ifdef ASSERT
- void verify_local_tag(frame::Tag tag, int n);
- void verify_local_tag(frame::Tag tag, Register idx);
-#endif // ASSERT
-
-
- void empty_expression_stack()
- {
+ void empty_expression_stack() {
movptr(rsp, Address(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize));
// NULL last_sp until next java call
movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
}
+ // Helpers for swap and dup
+ void load_ptr(int n, Register val);
+ void store_ptr(int n, Register val);
+
// Super call_VM calls - correspond to MacroAssembler::call_VM(_leaf) calls
void super_call_VM_leaf(address entry_point);
void super_call_VM_leaf(address entry_point, Register arg_1);
--- a/hotspot/src/cpu/x86/vm/interpreterRT_x86_32.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interpreterRT_x86_32.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1998-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1998-2010 Sun Microsystems, Inc. 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
@@ -86,33 +86,23 @@
address _from;
intptr_t* _to;
-#ifdef ASSERT
- void verify_tag(frame::Tag t) {
- assert(!TaggedStackInterpreter ||
- *(intptr_t*)(_from+Interpreter::local_tag_offset_in_bytes(0)) == t, "wrong tag");
- }
-#endif // ASSERT
-
virtual void pass_int() {
*_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
}
virtual void pass_long() {
_to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
_to[1] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
_to += 2;
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
}
virtual void pass_object() {
// pass address of from
intptr_t from_addr = (intptr_t)(_from + Interpreter::local_offset_in_bytes(0));
*_to++ = (*(intptr_t*)from_addr == 0) ? NULL_WORD : from_addr;
- debug_only(verify_tag(frame::TagReference));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
}
public:
--- a/hotspot/src/cpu/x86/vm/interpreterRT_x86_64.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interpreterRT_x86_64.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 2003-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2003-2010 Sun Microsystems, Inc. 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
@@ -293,18 +293,10 @@
intptr_t* _fp_identifiers;
unsigned int _num_args;
-#ifdef ASSERT
- void verify_tag(frame::Tag t) {
- assert(!TaggedStackInterpreter ||
- *(intptr_t*)(_from+Interpreter::local_tag_offset_in_bytes(0)) == t, "wrong tag");
- }
-#endif // ASSERT
-
virtual void pass_int()
{
jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
if (_num_args < Argument::n_int_register_parameters_c-1) {
*_reg_args++ = from_obj;
@@ -317,8 +309,7 @@
virtual void pass_long()
{
intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
- debug_only(verify_tag(frame::TagValue));
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
if (_num_args < Argument::n_int_register_parameters_c-1) {
*_reg_args++ = from_obj;
@@ -331,8 +322,7 @@
virtual void pass_object()
{
intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagReference));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
if (_num_args < Argument::n_int_register_parameters_c-1) {
*_reg_args++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
_num_args++;
@@ -344,8 +334,7 @@
virtual void pass_float()
{
jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
if (_num_args < Argument::n_float_register_parameters_c-1) {
*_reg_args++ = from_obj;
@@ -359,8 +348,7 @@
virtual void pass_double()
{
intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
- debug_only(verify_tag(frame::TagValue));
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
if (_num_args < Argument::n_float_register_parameters_c-1) {
*_reg_args++ = from_obj;
@@ -397,18 +385,10 @@
unsigned int _num_int_args;
unsigned int _num_fp_args;
-#ifdef ASSERT
- void verify_tag(frame::Tag t) {
- assert(!TaggedStackInterpreter ||
- *(intptr_t*)(_from+Interpreter::local_tag_offset_in_bytes(0)) == t, "wrong tag");
- }
-#endif // ASSERT
-
virtual void pass_int()
{
jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
if (_num_int_args < Argument::n_int_register_parameters_c-1) {
*_int_args++ = from_obj;
@@ -421,8 +401,7 @@
virtual void pass_long()
{
intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
- debug_only(verify_tag(frame::TagValue));
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
if (_num_int_args < Argument::n_int_register_parameters_c-1) {
*_int_args++ = from_obj;
@@ -435,8 +414,7 @@
virtual void pass_object()
{
intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagReference));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
if (_num_int_args < Argument::n_int_register_parameters_c-1) {
*_int_args++ = (*from_addr == 0) ? NULL : (intptr_t)from_addr;
@@ -449,8 +427,7 @@
virtual void pass_float()
{
jint from_obj = *(jint*)(_from+Interpreter::local_offset_in_bytes(0));
- debug_only(verify_tag(frame::TagValue));
- _from -= Interpreter::stackElementSize();
+ _from -= Interpreter::stackElementSize;
if (_num_fp_args < Argument::n_float_register_parameters_c) {
*_fp_args++ = from_obj;
@@ -463,7 +440,7 @@
virtual void pass_double()
{
intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
- _from -= 2*Interpreter::stackElementSize();
+ _from -= 2*Interpreter::stackElementSize;
if (_num_fp_args < Argument::n_float_register_parameters_c) {
*_fp_args++ = from_obj;
--- a/hotspot/src/cpu/x86/vm/interpreter_x86.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interpreter_x86.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -31,39 +31,16 @@
// the fpu stack.
static const int return_sentinel;
-
- static Address::ScaleFactor stackElementScale() {
- return TaggedStackInterpreter? Address::times_8 : Address::times_4;
- }
+ static Address::ScaleFactor stackElementScale() { return Address::times_4; }
// Offset from rsp (which points to the last stack element)
- static int expr_offset_in_bytes(int i) { return stackElementSize()*i ; }
- static int expr_tag_offset_in_bytes(int i) {
- assert(TaggedStackInterpreter, "should not call this");
- return expr_offset_in_bytes(i) + wordSize;
- }
-
- // Support for Tagged Stacks
+ static int expr_offset_in_bytes(int i) { return stackElementSize * i; }
// Stack index relative to tos (which points at value)
- static int expr_index_at(int i) {
- return stackElementWords() * i;
- }
-
- static int expr_tag_index_at(int i) {
- assert(TaggedStackInterpreter, "should not call this");
- // tag is one word above java stack element
- return stackElementWords() * i + 1;
- }
+ static int expr_index_at(int i) { return stackElementWords * i; }
// Already negated by c++ interpreter
- static int local_index_at(int i) {
- assert(i<=0, "local direction already negated");
- return stackElementWords() * i + (value_offset_in_bytes()/wordSize);
+ static int local_index_at(int i) {
+ assert(i <= 0, "local direction already negated");
+ return stackElementWords * i;
}
-
- static int local_tag_index_at(int i) {
- assert(i<=0, "local direction already negated");
- assert(TaggedStackInterpreter, "should not call this");
- return stackElementWords() * i + (tag_offset_in_bytes()/wordSize);
- }
--- a/hotspot/src/cpu/x86/vm/interpreter_x86_32.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/interpreter_x86_32.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -131,14 +131,7 @@
// java methods. Interpreter::method_kind(...) will select
// this entry point for the corresponding methods in JDK 1.3.
// get argument
- if (TaggedStackInterpreter) {
- __ pushl(Address(rsp, 3*wordSize)); // push hi (and note rsp -= wordSize)
- __ pushl(Address(rsp, 2*wordSize)); // push lo
- __ fld_d(Address(rsp, 0)); // get double in ST0
- __ addptr(rsp, 2*wordSize);
- } else {
- __ fld_d(Address(rsp, 1*wordSize));
- }
+ __ fld_d(Address(rsp, 1*wordSize));
switch (kind) {
case Interpreter::java_lang_math_sin :
__ trigfunc('s');
--- a/hotspot/src/cpu/x86/vm/methodHandles_x86.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/methodHandles_x86.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -500,7 +500,7 @@
#ifndef _LP64
if (arg_slots == 2) {
__ movl(rdx_temp, prim_value_addr.plus_disp(wordSize));
- __ movl(Address(rax_argslot, Interpreter::stackElementSize()), rdx_temp);
+ __ movl(Address(rax_argslot, Interpreter::stackElementSize), rdx_temp);
}
#endif //_LP64
}
@@ -596,7 +596,7 @@
__ lea(rax_argslot, __ argument_address(rax_argslot, 1));
remove_arg_slots(_masm, -stack_move_unit(),
rax_argslot, rbx_temp, rdx_temp);
- vmarg = Address(rax_argslot, -Interpreter::stackElementSize());
+ vmarg = Address(rax_argslot, -Interpreter::stackElementSize);
__ movl(rdx_temp, vmarg);
}
break;
@@ -665,8 +665,8 @@
__ lea(rax_argslot, __ argument_address(rax_argslot, 1));
insert_arg_slots(_masm, stack_move_unit(), _INSERT_INT_MASK,
rax_argslot, rbx_temp, rdx_temp);
- Address vmarg1(rax_argslot, -Interpreter::stackElementSize());
- Address vmarg2 = vmarg1.plus_disp(Interpreter::stackElementSize());
+ Address vmarg1(rax_argslot, -Interpreter::stackElementSize);
+ Address vmarg2 = vmarg1.plus_disp(Interpreter::stackElementSize);
switch (ek) {
case _adapter_opt_i2l:
@@ -718,7 +718,7 @@
insert_arg_slots(_masm, stack_move_unit(), _INSERT_INT_MASK,
rax_argslot, rbx_temp, rdx_temp);
}
- Address vmarg(rax_argslot, -Interpreter::stackElementSize());
+ Address vmarg(rax_argslot, -Interpreter::stackElementSize);
#ifdef _LP64
if (ek == _adapter_opt_f2d) {
@@ -1016,7 +1016,7 @@
// Array length checks out. Now insert any required stack slots.
if (length_constant == -1) {
// Form a pointer to the end of the affected region.
- __ lea(rdx_argslot_limit, Address(rax_argslot, Interpreter::stackElementSize()));
+ __ lea(rdx_argslot_limit, Address(rax_argslot, Interpreter::stackElementSize));
// 'stack_move' is negative number of words to insert
Register rdi_stack_move = rdi;
__ movl2ptr(rdi_stack_move, rcx_amh_conversion);
@@ -1054,7 +1054,7 @@
__ movptr(rbx_temp, Address(rsi_source, 0));
__ movptr(Address(rax_argslot, 0), rbx_temp);
__ addptr(rsi_source, type2aelembytes(elem_type));
- __ addptr(rax_argslot, Interpreter::stackElementSize());
+ __ addptr(rax_argslot, Interpreter::stackElementSize);
__ cmpptr(rax_argslot, rdx_argslot_limit);
__ jccb(Assembler::less, loop);
} else if (length_constant == 0) {
@@ -1067,7 +1067,7 @@
__ movptr(rbx_temp, Address(rsi_array, elem_offset));
__ movptr(Address(rax_argslot, slot_offset), rbx_temp);
elem_offset += type2aelembytes(elem_type);
- slot_offset += Interpreter::stackElementSize();
+ slot_offset += Interpreter::stackElementSize;
}
}
--- a/hotspot/src/cpu/x86/vm/sharedRuntime_x86_32.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/sharedRuntime_x86_32.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -503,34 +503,9 @@
}
-// Helper function to put tags in interpreter stack.
-static void tag_stack(MacroAssembler *masm, const BasicType sig, int st_off) {
- if (TaggedStackInterpreter) {
- int tag_offset = st_off + Interpreter::expr_tag_offset_in_bytes(0);
- if (sig == T_OBJECT || sig == T_ARRAY) {
- __ movptr(Address(rsp, tag_offset), frame::TagReference);
- } else if (sig == T_LONG || sig == T_DOUBLE) {
- int next_tag_offset = st_off + Interpreter::expr_tag_offset_in_bytes(1);
- __ movptr(Address(rsp, next_tag_offset), frame::TagValue);
- __ movptr(Address(rsp, tag_offset), frame::TagValue);
- } else {
- __ movptr(Address(rsp, tag_offset), frame::TagValue);
- }
- }
-}
-
-// Double and long values with Tagged stacks are not contiguous.
static void move_c2i_double(MacroAssembler *masm, XMMRegister r, int st_off) {
- int next_off = st_off - Interpreter::stackElementSize();
- if (TaggedStackInterpreter) {
- __ movdbl(Address(rsp, next_off), r);
- // Move top half up and put tag in the middle.
- __ movl(rdi, Address(rsp, next_off+wordSize));
- __ movl(Address(rsp, st_off), rdi);
- tag_stack(masm, T_DOUBLE, next_off);
- } else {
- __ movdbl(Address(rsp, next_off), r);
- }
+ int next_off = st_off - Interpreter::stackElementSize;
+ __ movdbl(Address(rsp, next_off), r);
}
static void gen_c2i_adapter(MacroAssembler *masm,
@@ -560,7 +535,7 @@
// Since all args are passed on the stack, total_args_passed * interpreter_
// stack_element_size is the
// space we need.
- int extraspace = total_args_passed * Interpreter::stackElementSize();
+ int extraspace = total_args_passed * Interpreter::stackElementSize;
// Get return address
__ pop(rax);
@@ -578,8 +553,8 @@
}
// st_off points to lowest address on stack.
- int st_off = ((total_args_passed - 1) - i) * Interpreter::stackElementSize();
- int next_off = st_off - Interpreter::stackElementSize();
+ int st_off = ((total_args_passed - 1) - i) * Interpreter::stackElementSize;
+ int next_off = st_off - Interpreter::stackElementSize;
// Say 4 args:
// i st_off
@@ -601,7 +576,6 @@
if (!r_2->is_valid()) {
__ movl(rdi, Address(rsp, ld_off));
__ movptr(Address(rsp, st_off), rdi);
- tag_stack(masm, sig_bt[i], st_off);
} else {
// ld_off == LSW, ld_off+VMRegImpl::stack_slot_size == MSW
@@ -619,13 +593,11 @@
__ movptr(Address(rsp, st_off), rax);
#endif /* ASSERT */
#endif // _LP64
- tag_stack(masm, sig_bt[i], next_off);
}
} else if (r_1->is_Register()) {
Register r = r_1->as_Register();
if (!r_2->is_valid()) {
__ movl(Address(rsp, st_off), r);
- tag_stack(masm, sig_bt[i], st_off);
} else {
// long/double in gpr
NOT_LP64(ShouldNotReachHere());
@@ -639,17 +611,14 @@
__ movptr(Address(rsp, st_off), rax);
#endif /* ASSERT */
__ movptr(Address(rsp, next_off), r);
- tag_stack(masm, sig_bt[i], next_off);
} else {
__ movptr(Address(rsp, st_off), r);
- tag_stack(masm, sig_bt[i], st_off);
}
}
} else {
assert(r_1->is_XMMRegister(), "");
if (!r_2->is_valid()) {
__ movflt(Address(rsp, st_off), r_1->as_XMMRegister());
- tag_stack(masm, sig_bt[i], st_off);
} else {
assert(sig_bt[i] == T_DOUBLE || sig_bt[i] == T_LONG, "wrong type");
move_c2i_double(masm, r_1->as_XMMRegister(), st_off);
@@ -665,20 +634,9 @@
}
-// For tagged stacks, double or long value aren't contiguous on the stack
-// so get them contiguous for the xmm load
static void move_i2c_double(MacroAssembler *masm, XMMRegister r, Register saved_sp, int ld_off) {
- int next_val_off = ld_off - Interpreter::stackElementSize();
- if (TaggedStackInterpreter) {
- // use tag slot temporarily for MSW
- __ movptr(rsi, Address(saved_sp, ld_off));
- __ movptr(Address(saved_sp, next_val_off+wordSize), rsi);
- __ movdbl(r, Address(saved_sp, next_val_off));
- // restore tag
- __ movptr(Address(saved_sp, next_val_off+wordSize), frame::TagValue);
- } else {
- __ movdbl(r, Address(saved_sp, next_val_off));
- }
+ int next_val_off = ld_off - Interpreter::stackElementSize;
+ __ movdbl(r, Address(saved_sp, next_val_off));
}
static void gen_i2c_adapter(MacroAssembler *masm,
@@ -797,9 +755,9 @@
assert(!regs[i].second()->is_valid() || regs[i].first()->next() == regs[i].second(),
"scrambled load targets?");
// Load in argument order going down.
- int ld_off = (total_args_passed - i)*Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();
+ int ld_off = (total_args_passed - i) * Interpreter::stackElementSize;
// Point to interpreter value (vs. tag)
- int next_off = ld_off - Interpreter::stackElementSize();
+ int next_off = ld_off - Interpreter::stackElementSize;
//
//
//
@@ -2322,7 +2280,7 @@
// this function returns the adjust size (in number of words) to a c2i adapter
// activation for use during deoptimization
int Deoptimization::last_frame_adjust(int callee_parameters, int callee_locals ) {
- return (callee_locals - callee_parameters) * Interpreter::stackElementWords();
+ return (callee_locals - callee_parameters) * Interpreter::stackElementWords;
}
--- a/hotspot/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -452,22 +452,6 @@
__ bind(L);
}
-// Helper function to put tags in interpreter stack.
-static void tag_stack(MacroAssembler *masm, const BasicType sig, int st_off) {
- if (TaggedStackInterpreter) {
- int tag_offset = st_off + Interpreter::expr_tag_offset_in_bytes(0);
- if (sig == T_OBJECT || sig == T_ARRAY) {
- __ movptr(Address(rsp, tag_offset), (int32_t) frame::TagReference);
- } else if (sig == T_LONG || sig == T_DOUBLE) {
- int next_tag_offset = st_off + Interpreter::expr_tag_offset_in_bytes(1);
- __ movptr(Address(rsp, next_tag_offset), (int32_t) frame::TagValue);
- __ movptr(Address(rsp, tag_offset), (int32_t) frame::TagValue);
- } else {
- __ movptr(Address(rsp, tag_offset), (int32_t) frame::TagValue);
- }
- }
-}
-
static void gen_c2i_adapter(MacroAssembler *masm,
int total_args_passed,
@@ -489,7 +473,7 @@
// we also account for the return address location since
// we store it first rather than hold it in rax across all the shuffling
- int extraspace = (total_args_passed * Interpreter::stackElementSize()) + wordSize;
+ int extraspace = (total_args_passed * Interpreter::stackElementSize) + wordSize;
// stack is aligned, keep it that way
extraspace = round_to(extraspace, 2*wordSize);
@@ -513,9 +497,8 @@
}
// offset to start parameters
- int st_off = (total_args_passed - i) * Interpreter::stackElementSize() +
- Interpreter::value_offset_in_bytes();
- int next_off = st_off - Interpreter::stackElementSize();
+ int st_off = (total_args_passed - i) * Interpreter::stackElementSize;
+ int next_off = st_off - Interpreter::stackElementSize;
// Say 4 args:
// i st_off
@@ -543,7 +526,6 @@
// sign extend??
__ movl(rax, Address(rsp, ld_off));
__ movptr(Address(rsp, st_off), rax);
- tag_stack(masm, sig_bt[i], st_off);
} else {
@@ -560,10 +542,8 @@
__ mov64(rax, CONST64(0xdeadffffdeadaaaa));
__ movptr(Address(rsp, st_off), rax);
#endif /* ASSERT */
- tag_stack(masm, sig_bt[i], next_off);
} else {
__ movq(Address(rsp, st_off), rax);
- tag_stack(masm, sig_bt[i], st_off);
}
}
} else if (r_1->is_Register()) {
@@ -572,7 +552,6 @@
// must be only an int (or less ) so move only 32bits to slot
// why not sign extend??
__ movl(Address(rsp, st_off), r);
- tag_stack(masm, sig_bt[i], st_off);
} else {
// Two VMREgs|OptoRegs can be T_OBJECT, T_ADDRESS, T_DOUBLE, T_LONG
// T_DOUBLE and T_LONG use two slots in the interpreter
@@ -584,10 +563,8 @@
__ movptr(Address(rsp, st_off), rax);
#endif /* ASSERT */
__ movq(Address(rsp, next_off), r);
- tag_stack(masm, sig_bt[i], next_off);
} else {
__ movptr(Address(rsp, st_off), r);
- tag_stack(masm, sig_bt[i], st_off);
}
}
} else {
@@ -595,7 +572,6 @@
if (!r_2->is_valid()) {
// only a float use just part of the slot
__ movflt(Address(rsp, st_off), r_1->as_XMMRegister());
- tag_stack(masm, sig_bt[i], st_off);
} else {
#ifdef ASSERT
// Overwrite the unused slot with known junk
@@ -603,7 +579,6 @@
__ movptr(Address(rsp, st_off), rax);
#endif /* ASSERT */
__ movdbl(Address(rsp, next_off), r_1->as_XMMRegister());
- tag_stack(masm, sig_bt[i], next_off);
}
}
}
@@ -688,9 +663,9 @@
assert(!regs[i].second()->is_valid() || regs[i].first()->next() == regs[i].second(),
"scrambled load targets?");
// Load in argument order going down.
- int ld_off = (total_args_passed - i)*Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();
+ int ld_off = (total_args_passed - i)*Interpreter::stackElementSize;
// Point to interpreter value (vs. tag)
- int next_off = ld_off - Interpreter::stackElementSize();
+ int next_off = ld_off - Interpreter::stackElementSize;
//
//
//
@@ -2535,7 +2510,7 @@
// this function returns the adjust size (in number of words) to a c2i adapter
// activation for use during deoptimization
int Deoptimization::last_frame_adjust(int callee_parameters, int callee_locals ) {
- return (callee_locals - callee_parameters) * Interpreter::stackElementWords();
+ return (callee_locals - callee_parameters) * Interpreter::stackElementWords;
}
--- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -139,7 +139,7 @@
// stub code
__ enter();
__ movptr(rcx, parameter_size); // parameter counter
- __ shlptr(rcx, Interpreter::logStackElementSize()); // convert parameter count to bytes
+ __ shlptr(rcx, Interpreter::logStackElementSize); // convert parameter count to bytes
__ addptr(rcx, locals_count_in_bytes); // reserve space for register saves
__ subptr(rsp, rcx);
__ andptr(rsp, -(StackAlignmentInBytes)); // Align stack
@@ -194,12 +194,6 @@
__ xorptr(rbx, rbx);
__ BIND(loop);
- if (TaggedStackInterpreter) {
- __ movptr(rax, Address(rdx, rcx, Interpreter::stackElementScale(),
- -2*wordSize)); // get tag
- __ movptr(Address(rsp, rbx, Interpreter::stackElementScale(),
- Interpreter::expr_tag_offset_in_bytes(0)), rax); // store tag
- }
// get parameter
__ movptr(rax, Address(rdx, rcx, Interpreter::stackElementScale(), -wordSize));
--- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -278,11 +278,6 @@
__ movptr(c_rarg2, parameters); // parameter pointer
__ movl(c_rarg1, c_rarg3); // parameter counter is in c_rarg1
__ BIND(loop);
- if (TaggedStackInterpreter) {
- __ movl(rax, Address(c_rarg2, 0)); // get tag
- __ addptr(c_rarg2, wordSize); // advance to next tag
- __ push(rax); // pass tag
- }
__ movptr(rax, Address(c_rarg2, 0));// get parameter
__ addptr(c_rarg2, wordSize); // advance to next parameter
__ decrementl(c_rarg1); // decrement counter
--- a/hotspot/src/cpu/x86/vm/templateInterpreter_x86.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/templateInterpreter_x86.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -28,8 +28,8 @@
// Size of interpreter code. Increase if too small. Interpreter will
// fail with a guarantee ("not enough space for interpreter generation");
// if too small.
- // Run with +PrintInterpreterSize to get the VM to print out the size.
- // Max size with JVMTI and TaggedStackInterpreter
+ // Run with +PrintInterpreter to get the VM to print out the size.
+ // Max size with JVMTI
#ifdef AMD64
const static int InterpreterCodeSize = 200 * 1024;
#else
--- a/hotspot/src/cpu/x86/vm/templateInterpreter_x86_32.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/templateInterpreter_x86_32.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -305,7 +305,6 @@
case T_FLOAT :
{ const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();
__ pop(t); // remove return address first
- __ pop_dtos_to_rsp();
// Must return a result for interpreter or compiler. In SSE
// mode, results are returned in xmm0 and the FPU stack must
// be empty.
@@ -468,7 +467,7 @@
// see if the frame is greater than one page in size. If so,
// then we need to verify there is enough stack space remaining
// for the additional locals.
- __ cmpl(rdx, (page_size - overhead_size)/Interpreter::stackElementSize());
+ __ cmpl(rdx, (page_size - overhead_size)/Interpreter::stackElementSize);
__ jcc(Assembler::belowEqual, after_frame_check);
// compute rsp as if this were going to be the last frame on
@@ -882,7 +881,7 @@
__ get_method(method);
__ verify_oop(method);
__ load_unsigned_short(t, Address(method, methodOopDesc::size_of_parameters_offset()));
- __ shlptr(t, Interpreter::logStackElementSize());
+ __ shlptr(t, Interpreter::logStackElementSize);
__ addptr(t, 2*wordSize); // allocate two more slots for JNIEnv and possible mirror
__ subptr(rsp, t);
__ andptr(rsp, -(StackAlignmentInBytes)); // gcc needs 16 byte aligned stacks to do XMM intrinsics
@@ -1225,9 +1224,6 @@
__ testl(rdx, rdx);
__ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0
__ bind(loop);
- if (TaggedStackInterpreter) {
- __ push((int32_t)NULL_WORD); // push tag
- }
__ push((int32_t)NULL_WORD); // initialize local variables
__ decrement(rdx); // until everything initialized
__ jcc(Assembler::greater, loop);
@@ -1463,7 +1459,7 @@
const int extra_stack = methodOopDesc::extra_stack_entries();
const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) *
- Interpreter::stackElementWords();
+ Interpreter::stackElementWords;
return overhead_size + method_stack + stub_code;
}
@@ -1487,9 +1483,9 @@
// NOTE: return size is in words not bytes
// fixed size of an interpreter frame:
- int max_locals = method->max_locals() * Interpreter::stackElementWords();
+ int max_locals = method->max_locals() * Interpreter::stackElementWords;
int extra_locals = (method->max_locals() - method->size_of_parameters()) *
- Interpreter::stackElementWords();
+ Interpreter::stackElementWords;
int overhead = frame::sender_sp_offset - frame::interpreter_frame_initial_sp_offset;
@@ -1499,9 +1495,9 @@
int size = overhead +
- ((callee_locals - callee_param_count)*Interpreter::stackElementWords()) +
+ ((callee_locals - callee_param_count)*Interpreter::stackElementWords) +
(moncount*frame::interpreter_frame_monitor_size()) +
- tempcount*Interpreter::stackElementWords() + popframe_extra_args;
+ tempcount*Interpreter::stackElementWords + popframe_extra_args;
if (interpreter_frame != NULL) {
#ifdef ASSERT
@@ -1525,7 +1521,7 @@
// Set last_sp
intptr_t* rsp = (intptr_t*) monbot -
- tempcount*Interpreter::stackElementWords() -
+ tempcount*Interpreter::stackElementWords -
popframe_extra_args;
interpreter_frame->interpreter_frame_set_last_sp(rsp);
@@ -1625,7 +1621,7 @@
__ get_method(rax);
__ verify_oop(rax);
__ load_unsigned_short(rax, Address(rax, in_bytes(methodOopDesc::size_of_parameters_offset())));
- __ shlptr(rax, Interpreter::logStackElementSize());
+ __ shlptr(rax, Interpreter::logStackElementSize);
__ restore_locals();
__ subptr(rdi, rax);
__ addptr(rdi, wordSize);
--- a/hotspot/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -199,7 +199,6 @@
in_bytes(constantPoolCacheOopDesc::base_offset()) +
3 * wordSize));
__ andl(rbx, 0xFF);
- if (TaggedStackInterpreter) __ shll(rbx, 1); // 2 slots per parameter.
__ lea(rsp, Address(rsp, rbx, Address::times_8));
__ dispatch_next(state, step);
@@ -417,7 +416,7 @@
// see if the frame is greater than one page in size. If so,
// then we need to verify there is enough stack space remaining
// for the additional locals.
- __ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize());
+ __ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize);
__ jcc(Assembler::belowEqual, after_frame_check);
// compute rsp as if this were going to be the last frame on
@@ -428,7 +427,7 @@
// locals + overhead, in bytes
__ mov(rax, rdx);
- __ shlptr(rax, Interpreter::logStackElementSize()); // 2 slots per parameter.
+ __ shlptr(rax, Interpreter::logStackElementSize); // 2 slots per parameter.
__ addptr(rax, overhead_size);
#ifdef ASSERT
@@ -759,7 +758,6 @@
// for natives the size of locals is zero
// compute beginning of parameters (r14)
- if (TaggedStackInterpreter) __ shll(rcx, 1); // 2 slots per parameter.
__ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize));
// add 2 zero-initialized slots for native calls
@@ -865,7 +863,7 @@
__ load_unsigned_short(t,
Address(method,
methodOopDesc::size_of_parameters_offset()));
- __ shll(t, Interpreter::logStackElementSize());
+ __ shll(t, Interpreter::logStackElementSize);
__ subptr(rsp, t);
__ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
@@ -1228,7 +1226,6 @@
__ pop(rax);
// compute beginning of parameters (r14)
- if (TaggedStackInterpreter) __ shll(rcx, 1); // 2 slots per parameter.
__ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize));
// rdx - # of additional locals
@@ -1239,7 +1236,6 @@
__ testl(rdx, rdx);
__ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0
__ bind(loop);
- if (TaggedStackInterpreter) __ push((int) NULL_WORD); // push tag
__ push((int) NULL_WORD); // initialize local variables
__ decrementl(rdx); // until everything initialized
__ jcc(Assembler::greater, loop);
@@ -1486,7 +1482,7 @@
const int stub_code = frame::entry_frame_after_call_words;
const int extra_stack = methodOopDesc::extra_stack_entries();
const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) *
- Interpreter::stackElementWords();
+ Interpreter::stackElementWords;
return (overhead_size + method_stack + stub_code);
}
@@ -1507,9 +1503,9 @@
// It is also guaranteed to be walkable even though it is in a skeletal state
// fixed size of an interpreter frame:
- int max_locals = method->max_locals() * Interpreter::stackElementWords();
+ int max_locals = method->max_locals() * Interpreter::stackElementWords;
int extra_locals = (method->max_locals() - method->size_of_parameters()) *
- Interpreter::stackElementWords();
+ Interpreter::stackElementWords;
int overhead = frame::sender_sp_offset -
frame::interpreter_frame_initial_sp_offset;
@@ -1518,9 +1514,9 @@
// for the callee's params we only need to account for the extra
// locals.
int size = overhead +
- (callee_locals - callee_param_count)*Interpreter::stackElementWords() +
+ (callee_locals - callee_param_count)*Interpreter::stackElementWords +
moncount * frame::interpreter_frame_monitor_size() +
- tempcount* Interpreter::stackElementWords() + popframe_extra_args;
+ tempcount* Interpreter::stackElementWords + popframe_extra_args;
if (interpreter_frame != NULL) {
#ifdef ASSERT
if (!EnableMethodHandles)
@@ -1544,7 +1540,7 @@
// Set last_sp
intptr_t* esp = (intptr_t*) monbot -
- tempcount*Interpreter::stackElementWords() -
+ tempcount*Interpreter::stackElementWords -
popframe_extra_args;
interpreter_frame->interpreter_frame_set_last_sp(esp);
@@ -1650,7 +1646,7 @@
__ get_method(rax);
__ load_unsigned_short(rax, Address(rax, in_bytes(methodOopDesc::
size_of_parameters_offset())));
- __ shll(rax, Interpreter::logStackElementSize());
+ __ shll(rax, Interpreter::logStackElementSize);
__ restore_locals(); // XXX do we need this?
__ subptr(r14, rax);
__ addptr(r14, wordSize);
--- a/hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -50,7 +50,7 @@
static inline Address aaddress(int n) { return iaddress(n); }
static inline Address iaddress(Register r) {
- return Address(rdi, r, Interpreter::stackElementScale(), Interpreter::value_offset_in_bytes());
+ return Address(rdi, r, Interpreter::stackElementScale());
}
static inline Address laddress(Register r) {
return Address(rdi, r, Interpreter::stackElementScale(), Interpreter::local_offset_in_bytes(1));
@@ -59,12 +59,9 @@
return Address(rdi, r, Interpreter::stackElementScale(), Interpreter::local_offset_in_bytes(0));
}
-static inline Address faddress(Register r) { return iaddress(r); };
-static inline Address daddress(Register r) {
- assert(!TaggedStackInterpreter, "This doesn't work");
- return laddress(r);
-};
-static inline Address aaddress(Register r) { return iaddress(r); };
+static inline Address faddress(Register r) { return iaddress(r); }
+static inline Address daddress(Register r) { return laddress(r); }
+static inline Address aaddress(Register r) { return iaddress(r); }
// expression stack
// (Note: Must not use symmetric equivalents at_rsp_m1/2 since they store
@@ -448,7 +445,6 @@
// Get the local value into tos
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
@@ -456,18 +452,15 @@
transition(vtos, itos);
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
__ push(itos);
locals_index(rbx, 3);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::fast_iload() {
transition(vtos, itos);
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
@@ -476,7 +469,6 @@
locals_index(rbx);
__ movptr(rax, laddress(rbx));
NOT_LP64(__ movl(rdx, haddress(rbx)));
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
}
@@ -484,26 +476,13 @@
transition(vtos, ftos);
locals_index(rbx);
__ fld_s(faddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::dload() {
transition(vtos, dtos);
locals_index(rbx);
- if (TaggedStackInterpreter) {
- // Get double out of locals array, onto temp stack and load with
- // float instruction into ST0
- __ movl(rax, laddress(rbx));
- __ movl(rdx, haddress(rbx));
- __ push(rdx); // push hi first
- __ push(rax);
- __ fld_d(Address(rsp, 0));
- __ addptr(rsp, 2*wordSize);
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
- } else {
- __ fld_d(daddress(rbx));
- }
+ __ fld_d(daddress(rbx));
}
@@ -511,7 +490,6 @@
transition(vtos, atos);
locals_index(rbx);
__ movptr(rax, aaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagReference, rbx));
}
@@ -527,7 +505,6 @@
transition(vtos, itos);
locals_index_wide(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
@@ -536,7 +513,6 @@
locals_index_wide(rbx);
__ movptr(rax, laddress(rbx));
NOT_LP64(__ movl(rdx, haddress(rbx)));
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
}
@@ -544,26 +520,13 @@
transition(vtos, ftos);
locals_index_wide(rbx);
__ fld_s(faddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::wide_dload() {
transition(vtos, dtos);
locals_index_wide(rbx);
- if (TaggedStackInterpreter) {
- // Get double out of locals array, onto temp stack and load with
- // float instruction into ST0
- __ movl(rax, laddress(rbx));
- __ movl(rdx, haddress(rbx));
- __ push(rdx); // push hi first
- __ push(rax);
- __ fld_d(Address(rsp, 0));
- __ addl(rsp, 2*wordSize);
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
- } else {
- __ fld_d(daddress(rbx));
- }
+ __ fld_d(daddress(rbx));
}
@@ -571,7 +534,6 @@
transition(vtos, atos);
locals_index_wide(rbx);
__ movptr(rax, aaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagReference, rbx));
}
void TemplateTable::index_check(Register array, Register index) {
@@ -672,7 +634,6 @@
// load index out of locals
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
// rdx: array
index_check(rdx, rax);
@@ -695,7 +656,6 @@
void TemplateTable::iload(int n) {
transition(vtos, itos);
__ movl(rax, iaddress(n));
- debug_only(__ verify_local_tag(frame::TagValue, n));
}
@@ -703,39 +663,24 @@
transition(vtos, ltos);
__ movptr(rax, laddress(n));
NOT_LP64(__ movptr(rdx, haddress(n)));
- debug_only(__ verify_local_tag(frame::TagCategory2, n));
}
void TemplateTable::fload(int n) {
transition(vtos, ftos);
__ fld_s(faddress(n));
- debug_only(__ verify_local_tag(frame::TagValue, n));
}
void TemplateTable::dload(int n) {
transition(vtos, dtos);
- if (TaggedStackInterpreter) {
- // Get double out of locals array, onto temp stack and load with
- // float instruction into ST0
- __ movl(rax, laddress(n));
- __ movl(rdx, haddress(n));
- __ push(rdx); // push hi first
- __ push(rax);
- __ fld_d(Address(rsp, 0));
- __ addptr(rsp, 2*wordSize); // reset rsp
- debug_only(__ verify_local_tag(frame::TagCategory2, n));
- } else {
- __ fld_d(daddress(n));
- }
+ __ fld_d(daddress(n));
}
void TemplateTable::aload(int n) {
transition(vtos, atos);
__ movptr(rax, aaddress(n));
- debug_only(__ verify_local_tag(frame::TagReference, n));
}
@@ -809,7 +754,6 @@
transition(itos, vtos);
locals_index(rbx);
__ movl(iaddress(rbx), rax);
- __ tag_local(frame::TagValue, rbx);
}
@@ -818,7 +762,6 @@
locals_index(rbx);
__ movptr(laddress(rbx), rax);
NOT_LP64(__ movptr(haddress(rbx), rdx));
- __ tag_local(frame::TagCategory2, rbx);
}
@@ -826,34 +769,21 @@
transition(ftos, vtos);
locals_index(rbx);
__ fstp_s(faddress(rbx));
- __ tag_local(frame::TagValue, rbx);
}
void TemplateTable::dstore() {
transition(dtos, vtos);
locals_index(rbx);
- if (TaggedStackInterpreter) {
- // Store double on stack and reload into locals nonadjacently
- __ subptr(rsp, 2 * wordSize);
- __ fstp_d(Address(rsp, 0));
- __ pop(rax);
- __ pop(rdx);
- __ movptr(laddress(rbx), rax);
- __ movptr(haddress(rbx), rdx);
- __ tag_local(frame::TagCategory2, rbx);
- } else {
- __ fstp_d(daddress(rbx));
- }
+ __ fstp_d(daddress(rbx));
}
void TemplateTable::astore() {
transition(vtos, vtos);
- __ pop_ptr(rax, rdx); // will need to pop tag too
+ __ pop_ptr(rax);
locals_index(rbx);
__ movptr(aaddress(rbx), rax);
- __ tag_local(rdx, rbx); // need to store same tag in local may be returnAddr
}
@@ -862,7 +792,6 @@
__ pop_i(rax);
locals_index_wide(rbx);
__ movl(iaddress(rbx), rax);
- __ tag_local(frame::TagValue, rbx);
}
@@ -872,7 +801,6 @@
locals_index_wide(rbx);
__ movptr(laddress(rbx), rax);
NOT_LP64(__ movl(haddress(rbx), rdx));
- __ tag_local(frame::TagCategory2, rbx);
}
@@ -888,10 +816,9 @@
void TemplateTable::wide_astore() {
transition(vtos, vtos);
- __ pop_ptr(rax, rdx);
+ __ pop_ptr(rax);
locals_index_wide(rbx);
__ movptr(aaddress(rbx), rax);
- __ tag_local(rdx, rbx);
}
@@ -990,7 +917,7 @@
// Pop stack arguments
__ bind(done);
- __ addptr(rsp, 3 * Interpreter::stackElementSize());
+ __ addptr(rsp, 3 * Interpreter::stackElementSize);
}
@@ -1024,7 +951,6 @@
void TemplateTable::istore(int n) {
transition(itos, vtos);
__ movl(iaddress(n), rax);
- __ tag_local(frame::TagValue, n);
}
@@ -1032,58 +958,45 @@
transition(ltos, vtos);
__ movptr(laddress(n), rax);
NOT_LP64(__ movptr(haddress(n), rdx));
- __ tag_local(frame::TagCategory2, n);
}
void TemplateTable::fstore(int n) {
transition(ftos, vtos);
__ fstp_s(faddress(n));
- __ tag_local(frame::TagValue, n);
}
void TemplateTable::dstore(int n) {
transition(dtos, vtos);
- if (TaggedStackInterpreter) {
- __ subptr(rsp, 2 * wordSize);
- __ fstp_d(Address(rsp, 0));
- __ pop(rax);
- __ pop(rdx);
- __ movl(laddress(n), rax);
- __ movl(haddress(n), rdx);
- __ tag_local(frame::TagCategory2, n);
- } else {
- __ fstp_d(daddress(n));
- }
+ __ fstp_d(daddress(n));
}
void TemplateTable::astore(int n) {
transition(vtos, vtos);
- __ pop_ptr(rax, rdx);
+ __ pop_ptr(rax);
__ movptr(aaddress(n), rax);
- __ tag_local(rdx, n);
}
void TemplateTable::pop() {
transition(vtos, vtos);
- __ addptr(rsp, Interpreter::stackElementSize());
+ __ addptr(rsp, Interpreter::stackElementSize);
}
void TemplateTable::pop2() {
transition(vtos, vtos);
- __ addptr(rsp, 2*Interpreter::stackElementSize());
+ __ addptr(rsp, 2*Interpreter::stackElementSize);
}
void TemplateTable::dup() {
transition(vtos, vtos);
// stack: ..., a
- __ load_ptr_and_tag(0, rax, rdx);
- __ push_ptr(rax, rdx);
+ __ load_ptr(0, rax);
+ __ push_ptr(rax);
// stack: ..., a, a
}
@@ -1091,11 +1004,11 @@
void TemplateTable::dup_x1() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(0, rax, rdx); // load b
- __ load_ptr_and_tag(1, rcx, rbx); // load a
- __ store_ptr_and_tag(1, rax, rdx); // store b
- __ store_ptr_and_tag(0, rcx, rbx); // store a
- __ push_ptr(rax, rdx); // push b
+ __ load_ptr( 0, rax); // load b
+ __ load_ptr( 1, rcx); // load a
+ __ store_ptr(1, rax); // store b
+ __ store_ptr(0, rcx); // store a
+ __ push_ptr(rax); // push b
// stack: ..., b, a, b
}
@@ -1103,15 +1016,15 @@
void TemplateTable::dup_x2() {
transition(vtos, vtos);
// stack: ..., a, b, c
- __ load_ptr_and_tag(0, rax, rdx); // load c
- __ load_ptr_and_tag(2, rcx, rbx); // load a
- __ store_ptr_and_tag(2, rax, rdx); // store c in a
- __ push_ptr(rax, rdx); // push c
+ __ load_ptr( 0, rax); // load c
+ __ load_ptr( 2, rcx); // load a
+ __ store_ptr(2, rax); // store c in a
+ __ push_ptr(rax); // push c
// stack: ..., c, b, c, c
- __ load_ptr_and_tag(2, rax, rdx); // load b
- __ store_ptr_and_tag(2, rcx, rbx); // store a in b
+ __ load_ptr( 2, rax); // load b
+ __ store_ptr(2, rcx); // store a in b
// stack: ..., c, a, c, c
- __ store_ptr_and_tag(1, rax, rdx); // store b in c
+ __ store_ptr(1, rax); // store b in c
// stack: ..., c, a, b, c
}
@@ -1119,10 +1032,10 @@
void TemplateTable::dup2() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(1, rax, rdx); // load a
- __ push_ptr(rax, rdx); // push a
- __ load_ptr_and_tag(1, rax, rdx); // load b
- __ push_ptr(rax, rdx); // push b
+ __ load_ptr(1, rax); // load a
+ __ push_ptr(rax); // push a
+ __ load_ptr(1, rax); // load b
+ __ push_ptr(rax); // push b
// stack: ..., a, b, a, b
}
@@ -1130,17 +1043,17 @@
void TemplateTable::dup2_x1() {
transition(vtos, vtos);
// stack: ..., a, b, c
- __ load_ptr_and_tag(0, rcx, rbx); // load c
- __ load_ptr_and_tag(1, rax, rdx); // load b
- __ push_ptr(rax, rdx); // push b
- __ push_ptr(rcx, rbx); // push c
+ __ load_ptr( 0, rcx); // load c
+ __ load_ptr( 1, rax); // load b
+ __ push_ptr(rax); // push b
+ __ push_ptr(rcx); // push c
// stack: ..., a, b, c, b, c
- __ store_ptr_and_tag(3, rcx, rbx); // store c in b
+ __ store_ptr(3, rcx); // store c in b
// stack: ..., a, c, c, b, c
- __ load_ptr_and_tag(4, rcx, rbx); // load a
- __ store_ptr_and_tag(2, rcx, rbx); // store a in 2nd c
+ __ load_ptr( 4, rcx); // load a
+ __ store_ptr(2, rcx); // store a in 2nd c
// stack: ..., a, c, a, b, c
- __ store_ptr_and_tag(4, rax, rdx); // store b in a
+ __ store_ptr(4, rax); // store b in a
// stack: ..., b, c, a, b, c
// stack: ..., b, c, a, b, c
}
@@ -1149,19 +1062,19 @@
void TemplateTable::dup2_x2() {
transition(vtos, vtos);
// stack: ..., a, b, c, d
- __ load_ptr_and_tag(0, rcx, rbx); // load d
- __ load_ptr_and_tag(1, rax, rdx); // load c
- __ push_ptr(rax, rdx); // push c
- __ push_ptr(rcx, rbx); // push d
+ __ load_ptr( 0, rcx); // load d
+ __ load_ptr( 1, rax); // load c
+ __ push_ptr(rax); // push c
+ __ push_ptr(rcx); // push d
// stack: ..., a, b, c, d, c, d
- __ load_ptr_and_tag(4, rax, rdx); // load b
- __ store_ptr_and_tag(2, rax, rdx); // store b in d
- __ store_ptr_and_tag(4, rcx, rbx); // store d in b
+ __ load_ptr( 4, rax); // load b
+ __ store_ptr(2, rax); // store b in d
+ __ store_ptr(4, rcx); // store d in b
// stack: ..., a, d, c, b, c, d
- __ load_ptr_and_tag(5, rcx, rbx); // load a
- __ load_ptr_and_tag(3, rax, rdx); // load c
- __ store_ptr_and_tag(3, rcx, rbx); // store a in c
- __ store_ptr_and_tag(5, rax, rdx); // store c in a
+ __ load_ptr( 5, rcx); // load a
+ __ load_ptr( 3, rax); // load c
+ __ store_ptr(3, rcx); // store a in c
+ __ store_ptr(5, rax); // store c in a
// stack: ..., c, d, a, b, c, d
// stack: ..., c, d, a, b, c, d
}
@@ -1170,10 +1083,10 @@
void TemplateTable::swap() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(1, rcx, rbx); // load a
- __ load_ptr_and_tag(0, rax, rdx); // load b
- __ store_ptr_and_tag(0, rcx, rbx); // store a in b
- __ store_ptr_and_tag(1, rax, rdx); // store b in a
+ __ load_ptr( 1, rcx); // load a
+ __ load_ptr( 0, rax); // load b
+ __ store_ptr(0, rcx); // store a in b
+ __ store_ptr(1, rax); // store b in a
// stack: ..., b, a
}
@@ -1181,12 +1094,12 @@
void TemplateTable::iop2(Operation op) {
transition(itos, itos);
switch (op) {
- case add : __ pop_i(rdx); __ addl (rax, rdx); break;
+ case add : __ pop_i(rdx); __ addl (rax, rdx); break;
case sub : __ mov(rdx, rax); __ pop_i(rax); __ subl (rax, rdx); break;
- case mul : __ pop_i(rdx); __ imull(rax, rdx); break;
- case _and : __ pop_i(rdx); __ andl (rax, rdx); break;
- case _or : __ pop_i(rdx); __ orl (rax, rdx); break;
- case _xor : __ pop_i(rdx); __ xorl (rax, rdx); break;
+ case mul : __ pop_i(rdx); __ imull(rax, rdx); break;
+ case _and : __ pop_i(rdx); __ andl (rax, rdx); break;
+ case _or : __ pop_i(rdx); __ orl (rax, rdx); break;
+ case _xor : __ pop_i(rdx); __ xorl (rax, rdx); break;
case shl : __ mov(rcx, rax); __ pop_i(rax); __ shll (rax); break; // implicit masking of lower 5 bits by Intel shift instr.
case shr : __ mov(rcx, rax); __ pop_i(rax); __ sarl (rax); break; // implicit masking of lower 5 bits by Intel shift instr.
case ushr : __ mov(rcx, rax); __ pop_i(rax); __ shrl (rax); break; // implicit masking of lower 5 bits by Intel shift instr.
@@ -1199,13 +1112,13 @@
transition(ltos, ltos);
__ pop_l(rbx, rcx);
switch (op) {
- case add : __ addl(rax, rbx); __ adcl(rdx, rcx); break;
- case sub : __ subl(rbx, rax); __ sbbl(rcx, rdx);
- __ mov(rax, rbx); __ mov(rdx, rcx); break;
- case _and: __ andl(rax, rbx); __ andl(rdx, rcx); break;
- case _or : __ orl (rax, rbx); __ orl (rdx, rcx); break;
- case _xor: __ xorl(rax, rbx); __ xorl(rdx, rcx); break;
- default : ShouldNotReachHere();
+ case add : __ addl(rax, rbx); __ adcl(rdx, rcx); break;
+ case sub : __ subl(rbx, rax); __ sbbl(rcx, rdx);
+ __ mov (rax, rbx); __ mov (rdx, rcx); break;
+ case _and : __ andl(rax, rbx); __ andl(rdx, rcx); break;
+ case _or : __ orl (rax, rbx); __ orl (rdx, rcx); break;
+ case _xor : __ xorl(rax, rbx); __ xorl(rdx, rcx); break;
+ default : ShouldNotReachHere();
}
}
@@ -1299,7 +1212,6 @@
void TemplateTable::fop2(Operation op) {
transition(ftos, ftos);
- __ pop_ftos_to_rsp(); // pop ftos into rsp
switch (op) {
case add: __ fadd_s (at_rsp()); break;
case sub: __ fsubr_s(at_rsp()); break;
@@ -1315,7 +1227,6 @@
void TemplateTable::dop2(Operation op) {
transition(dtos, dtos);
- __ pop_dtos_to_rsp(); // pop dtos into rsp
switch (op) {
case add: __ fadd_d (at_rsp()); break;
@@ -1557,10 +1468,8 @@
void TemplateTable::float_cmp(bool is_float, int unordered_result) {
if (is_float) {
- __ pop_ftos_to_rsp();
__ fld_s(at_rsp());
} else {
- __ pop_dtos_to_rsp();
__ fld_d(at_rsp());
__ pop(rdx);
}
@@ -2854,7 +2763,6 @@
transition(vtos, state);
// get receiver
__ movptr(rax, aaddress(0));
- debug_only(__ verify_local_tag(frame::TagReference, 0));
// access constant pool cache
__ get_cache_and_index_at_bcp(rcx, rdx, 2);
__ movptr(rbx, Address(rcx,
--- a/hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -58,7 +58,7 @@
}
static inline Address iaddress(Register r) {
- return Address(r14, r, Address::times_8, Interpreter::value_offset_in_bytes());
+ return Address(r14, r, Address::times_8);
}
static inline Address laddress(Register r) {
@@ -418,7 +418,6 @@
void TemplateTable::locals_index(Register reg, int offset) {
__ load_unsigned_byte(reg, at_bcp(offset));
__ negptr(reg);
- if (TaggedStackInterpreter) __ shlptr(reg, 1); // index = index*2
}
void TemplateTable::iload() {
@@ -460,53 +459,45 @@
// Get the local value into tos
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::fast_iload2() {
transition(vtos, itos);
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
__ push(itos);
locals_index(rbx, 3);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::fast_iload() {
transition(vtos, itos);
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::lload() {
transition(vtos, ltos);
locals_index(rbx);
__ movq(rax, laddress(rbx));
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
}
void TemplateTable::fload() {
transition(vtos, ftos);
locals_index(rbx);
__ movflt(xmm0, faddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::dload() {
transition(vtos, dtos);
locals_index(rbx);
__ movdbl(xmm0, daddress(rbx));
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
}
void TemplateTable::aload() {
transition(vtos, atos);
locals_index(rbx);
__ movptr(rax, aaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagReference, rbx));
}
void TemplateTable::locals_index_wide(Register reg) {
@@ -514,42 +505,36 @@
__ bswapl(reg);
__ shrl(reg, 16);
__ negptr(reg);
- if (TaggedStackInterpreter) __ shlptr(reg, 1); // index = index*2
}
void TemplateTable::wide_iload() {
transition(vtos, itos);
locals_index_wide(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::wide_lload() {
transition(vtos, ltos);
locals_index_wide(rbx);
__ movq(rax, laddress(rbx));
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
}
void TemplateTable::wide_fload() {
transition(vtos, ftos);
locals_index_wide(rbx);
__ movflt(xmm0, faddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
}
void TemplateTable::wide_dload() {
transition(vtos, dtos);
locals_index_wide(rbx);
__ movdbl(xmm0, daddress(rbx));
- debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
}
void TemplateTable::wide_aload() {
transition(vtos, atos);
locals_index_wide(rbx);
__ movptr(rax, aaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagReference, rbx));
}
void TemplateTable::index_check(Register array, Register index) {
@@ -654,7 +639,6 @@
// load index out of locals
locals_index(rbx);
__ movl(rax, iaddress(rbx));
- debug_only(__ verify_local_tag(frame::TagValue, rbx));
// eax: index
// rdx: array
@@ -681,31 +665,26 @@
void TemplateTable::iload(int n) {
transition(vtos, itos);
__ movl(rax, iaddress(n));
- debug_only(__ verify_local_tag(frame::TagValue, n));
}
void TemplateTable::lload(int n) {
transition(vtos, ltos);
__ movq(rax, laddress(n));
- debug_only(__ verify_local_tag(frame::TagCategory2, n));
}
void TemplateTable::fload(int n) {
transition(vtos, ftos);
__ movflt(xmm0, faddress(n));
- debug_only(__ verify_local_tag(frame::TagValue, n));
}
void TemplateTable::dload(int n) {
transition(vtos, dtos);
__ movdbl(xmm0, daddress(n));
- debug_only(__ verify_local_tag(frame::TagCategory2, n));
}
void TemplateTable::aload(int n) {
transition(vtos, atos);
__ movptr(rax, aaddress(n));
- debug_only(__ verify_local_tag(frame::TagReference, n));
}
void TemplateTable::aload_0() {
@@ -791,36 +770,31 @@
transition(itos, vtos);
locals_index(rbx);
__ movl(iaddress(rbx), rax);
- __ tag_local(frame::TagValue, rbx);
}
void TemplateTable::lstore() {
transition(ltos, vtos);
locals_index(rbx);
__ movq(laddress(rbx), rax);
- __ tag_local(frame::TagCategory2, rbx);
}
void TemplateTable::fstore() {
transition(ftos, vtos);
locals_index(rbx);
__ movflt(faddress(rbx), xmm0);
- __ tag_local(frame::TagValue, rbx);
}
void TemplateTable::dstore() {
transition(dtos, vtos);
locals_index(rbx);
__ movdbl(daddress(rbx), xmm0);
- __ tag_local(frame::TagCategory2, rbx);
}
void TemplateTable::astore() {
transition(vtos, vtos);
- __ pop_ptr(rax, rdx); // will need to pop tag too
+ __ pop_ptr(rax);
locals_index(rbx);
__ movptr(aaddress(rbx), rax);
- __ tag_local(rdx, rbx); // store tag from stack, might be returnAddr
}
void TemplateTable::wide_istore() {
@@ -828,7 +802,6 @@
__ pop_i();
locals_index_wide(rbx);
__ movl(iaddress(rbx), rax);
- __ tag_local(frame::TagValue, rbx);
}
void TemplateTable::wide_lstore() {
@@ -836,7 +809,6 @@
__ pop_l();
locals_index_wide(rbx);
__ movq(laddress(rbx), rax);
- __ tag_local(frame::TagCategory2, rbx);
}
void TemplateTable::wide_fstore() {
@@ -844,7 +816,6 @@
__ pop_f();
locals_index_wide(rbx);
__ movflt(faddress(rbx), xmm0);
- __ tag_local(frame::TagValue, rbx);
}
void TemplateTable::wide_dstore() {
@@ -852,15 +823,13 @@
__ pop_d();
locals_index_wide(rbx);
__ movdbl(daddress(rbx), xmm0);
- __ tag_local(frame::TagCategory2, rbx);
}
void TemplateTable::wide_astore() {
transition(vtos, vtos);
- __ pop_ptr(rax, rdx); // will need to pop tag too
+ __ pop_ptr(rax);
locals_index_wide(rbx);
__ movptr(aaddress(rbx), rax);
- __ tag_local(rdx, rbx); // store tag from stack, might be returnAddr
}
void TemplateTable::iastore() {
@@ -972,7 +941,7 @@
// Pop stack arguments
__ bind(done);
- __ addptr(rsp, 3 * Interpreter::stackElementSize());
+ __ addptr(rsp, 3 * Interpreter::stackElementSize);
}
void TemplateTable::bastore() {
@@ -1010,130 +979,125 @@
void TemplateTable::istore(int n) {
transition(itos, vtos);
__ movl(iaddress(n), rax);
- __ tag_local(frame::TagValue, n);
}
void TemplateTable::lstore(int n) {
transition(ltos, vtos);
__ movq(laddress(n), rax);
- __ tag_local(frame::TagCategory2, n);
}
void TemplateTable::fstore(int n) {
transition(ftos, vtos);
__ movflt(faddress(n), xmm0);
- __ tag_local(frame::TagValue, n);
}
void TemplateTable::dstore(int n) {
transition(dtos, vtos);
__ movdbl(daddress(n), xmm0);
- __ tag_local(frame::TagCategory2, n);
}
void TemplateTable::astore(int n) {
transition(vtos, vtos);
- __ pop_ptr(rax, rdx);
+ __ pop_ptr(rax);
__ movptr(aaddress(n), rax);
- __ tag_local(rdx, n);
}
void TemplateTable::pop() {
transition(vtos, vtos);
- __ addptr(rsp, Interpreter::stackElementSize());
+ __ addptr(rsp, Interpreter::stackElementSize);
}
void TemplateTable::pop2() {
transition(vtos, vtos);
- __ addptr(rsp, 2 * Interpreter::stackElementSize());
+ __ addptr(rsp, 2 * Interpreter::stackElementSize);
}
void TemplateTable::dup() {
transition(vtos, vtos);
- __ load_ptr_and_tag(0, rax, rdx);
- __ push_ptr(rax, rdx);
+ __ load_ptr(0, rax);
+ __ push_ptr(rax);
// stack: ..., a, a
}
void TemplateTable::dup_x1() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(0, rax, rdx); // load b
- __ load_ptr_and_tag(1, rcx, rbx); // load a
- __ store_ptr_and_tag(1, rax, rdx); // store b
- __ store_ptr_and_tag(0, rcx, rbx); // store a
- __ push_ptr(rax, rdx); // push b
+ __ load_ptr( 0, rax); // load b
+ __ load_ptr( 1, rcx); // load a
+ __ store_ptr(1, rax); // store b
+ __ store_ptr(0, rcx); // store a
+ __ push_ptr(rax); // push b
// stack: ..., b, a, b
}
void TemplateTable::dup_x2() {
transition(vtos, vtos);
// stack: ..., a, b, c
- __ load_ptr_and_tag(0, rax, rdx); // load c
- __ load_ptr_and_tag(2, rcx, rbx); // load a
- __ store_ptr_and_tag(2, rax, rdx); // store c in a
- __ push_ptr(rax, rdx); // push c
+ __ load_ptr( 0, rax); // load c
+ __ load_ptr( 2, rcx); // load a
+ __ store_ptr(2, rax); // store c in a
+ __ push_ptr(rax); // push c
// stack: ..., c, b, c, c
- __ load_ptr_and_tag(2, rax, rdx); // load b
- __ store_ptr_and_tag(2, rcx, rbx); // store a in b
+ __ load_ptr( 2, rax); // load b
+ __ store_ptr(2, rcx); // store a in b
// stack: ..., c, a, c, c
- __ store_ptr_and_tag(1, rax, rdx); // store b in c
+ __ store_ptr(1, rax); // store b in c
// stack: ..., c, a, b, c
}
void TemplateTable::dup2() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(1, rax, rdx); // load a
- __ push_ptr(rax, rdx); // push a
- __ load_ptr_and_tag(1, rax, rdx); // load b
- __ push_ptr(rax, rdx); // push b
+ __ load_ptr(1, rax); // load a
+ __ push_ptr(rax); // push a
+ __ load_ptr(1, rax); // load b
+ __ push_ptr(rax); // push b
// stack: ..., a, b, a, b
}
void TemplateTable::dup2_x1() {
transition(vtos, vtos);
// stack: ..., a, b, c
- __ load_ptr_and_tag(0, rcx, rbx); // load c
- __ load_ptr_and_tag(1, rax, rdx); // load b
- __ push_ptr(rax, rdx); // push b
- __ push_ptr(rcx, rbx); // push c
+ __ load_ptr( 0, rcx); // load c
+ __ load_ptr( 1, rax); // load b
+ __ push_ptr(rax); // push b
+ __ push_ptr(rcx); // push c
// stack: ..., a, b, c, b, c
- __ store_ptr_and_tag(3, rcx, rbx); // store c in b
+ __ store_ptr(3, rcx); // store c in b
// stack: ..., a, c, c, b, c
- __ load_ptr_and_tag(4, rcx, rbx); // load a
- __ store_ptr_and_tag(2, rcx, rbx); // store a in 2nd c
+ __ load_ptr( 4, rcx); // load a
+ __ store_ptr(2, rcx); // store a in 2nd c
// stack: ..., a, c, a, b, c
- __ store_ptr_and_tag(4, rax, rdx); // store b in a
+ __ store_ptr(4, rax); // store b in a
// stack: ..., b, c, a, b, c
}
void TemplateTable::dup2_x2() {
transition(vtos, vtos);
// stack: ..., a, b, c, d
- __ load_ptr_and_tag(0, rcx, rbx); // load d
- __ load_ptr_and_tag(1, rax, rdx); // load c
- __ push_ptr(rax, rdx); // push c
- __ push_ptr(rcx, rbx); // push d
+ __ load_ptr( 0, rcx); // load d
+ __ load_ptr( 1, rax); // load c
+ __ push_ptr(rax); // push c
+ __ push_ptr(rcx); // push d
// stack: ..., a, b, c, d, c, d
- __ load_ptr_and_tag(4, rax, rdx); // load b
- __ store_ptr_and_tag(2, rax, rdx); // store b in d
- __ store_ptr_and_tag(4, rcx, rbx); // store d in b
+ __ load_ptr( 4, rax); // load b
+ __ store_ptr(2, rax); // store b in d
+ __ store_ptr(4, rcx); // store d in b
// stack: ..., a, d, c, b, c, d
- __ load_ptr_and_tag(5, rcx, rbx); // load a
- __ load_ptr_and_tag(3, rax, rdx); // load c
- __ store_ptr_and_tag(3, rcx, rbx); // store a in c
- __ store_ptr_and_tag(5, rax, rdx); // store c in a
+ __ load_ptr( 5, rcx); // load a
+ __ load_ptr( 3, rax); // load c
+ __ store_ptr(3, rcx); // store a in c
+ __ store_ptr(5, rax); // store c in a
// stack: ..., c, d, a, b, c, d
}
void TemplateTable::swap() {
transition(vtos, vtos);
// stack: ..., a, b
- __ load_ptr_and_tag(1, rcx, rbx); // load a
- __ load_ptr_and_tag(0, rax, rdx); // load b
- __ store_ptr_and_tag(0, rcx, rbx); // store a in b
- __ store_ptr_and_tag(1, rax, rdx); // store b in a
+ __ load_ptr( 1, rcx); // load a
+ __ load_ptr( 0, rax); // load b
+ __ store_ptr(0, rcx); // store a in b
+ __ store_ptr(1, rax); // store b in a
// stack: ..., b, a
}
@@ -1156,12 +1120,12 @@
void TemplateTable::lop2(Operation op) {
transition(ltos, ltos);
switch (op) {
- case add : __ pop_l(rdx); __ addptr (rax, rdx); break;
- case sub : __ mov(rdx, rax); __ pop_l(rax); __ subptr (rax, rdx); break;
- case _and : __ pop_l(rdx); __ andptr (rax, rdx); break;
- case _or : __ pop_l(rdx); __ orptr (rax, rdx); break;
- case _xor : __ pop_l(rdx); __ xorptr (rax, rdx); break;
- default : ShouldNotReachHere();
+ case add : __ pop_l(rdx); __ addptr(rax, rdx); break;
+ case sub : __ mov(rdx, rax); __ pop_l(rax); __ subptr(rax, rdx); break;
+ case _and : __ pop_l(rdx); __ andptr(rax, rdx); break;
+ case _or : __ pop_l(rdx); __ orptr (rax, rdx); break;
+ case _xor : __ pop_l(rdx); __ xorptr(rax, rdx); break;
+ default : ShouldNotReachHere();
}
}
@@ -1250,7 +1214,7 @@
switch (op) {
case add:
__ addss(xmm0, at_rsp());
- __ addptr(rsp, Interpreter::stackElementSize());
+ __ addptr(rsp, Interpreter::stackElementSize);
break;
case sub:
__ movflt(xmm1, xmm0);
@@ -1259,7 +1223,7 @@
break;
case mul:
__ mulss(xmm0, at_rsp());
- __ addptr(rsp, Interpreter::stackElementSize());
+ __ addptr(rsp, Interpreter::stackElementSize);
break;
case div:
__ movflt(xmm1, xmm0);
@@ -1282,7 +1246,7 @@
switch (op) {
case add:
__ addsd(xmm0, at_rsp());
- __ addptr(rsp, 2 * Interpreter::stackElementSize());
+ __ addptr(rsp, 2 * Interpreter::stackElementSize);
break;
case sub:
__ movdbl(xmm1, xmm0);
@@ -1291,7 +1255,7 @@
break;
case mul:
__ mulsd(xmm0, at_rsp());
- __ addptr(rsp, 2 * Interpreter::stackElementSize());
+ __ addptr(rsp, 2 * Interpreter::stackElementSize);
break;
case div:
__ movdbl(xmm1, xmm0);
@@ -2782,7 +2746,6 @@
// get receiver
__ movptr(rax, aaddress(0));
- debug_only(__ verify_local_tag(frame::TagReference, 0));
// access constant pool cache
__ get_cache_and_index_at_bcp(rcx, rdx, 2);
__ movptr(rbx,
@@ -2858,7 +2821,6 @@
if (load_receiver) {
__ movl(recv, flags);
__ andl(recv, 0xFF);
- if (TaggedStackInterpreter) __ shll(recv, 1); // index*2
Address recv_addr(rsp, recv, Address::times_8, -Interpreter::expr_offset_in_bytes(1));
__ movptr(recv, recv_addr);
__ verify_oop(recv);
@@ -3610,13 +3572,11 @@
__ load_unsigned_byte(rax, at_bcp(3)); // get number of dimensions
// last dim is on top of stack; we want address of first one:
// first_addr = last_addr + (ndims - 1) * wordSize
- if (TaggedStackInterpreter) __ shll(rax, 1); // index*2
__ lea(c_rarg1, Address(rsp, rax, Address::times_8, -wordSize));
call_VM(rax,
CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray),
c_rarg1);
__ load_unsigned_byte(rbx, at_bcp(3));
- if (TaggedStackInterpreter) __ shll(rbx, 1); // index*2
__ lea(rsp, Address(rsp, rbx, Address::times_8));
}
#endif // !CC_INTERP
--- a/hotspot/src/cpu/zero/vm/interpreter_zero.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/cpu/zero/vm/interpreter_zero.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 2003-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2003-2010 Sun Microsystems, Inc. All Rights Reserved.
* Copyright 2007, 2008 Red Hat, Inc.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@@ -38,24 +38,12 @@
static int expr_index_at(int i) {
return stackElementWords() * i;
}
- static int expr_tag_index_at(int i) {
- assert(TaggedStackInterpreter, "should not call this");
- Unimplemented();
- }
static int expr_offset_in_bytes(int i) {
return stackElementSize() * i;
}
- static int expr_tag_offset_in_bytes(int i) {
- assert(TaggedStackInterpreter, "should not call this");
- Unimplemented();
- }
static int local_index_at(int i) {
assert(i <= 0, "local direction already negated");
- return stackElementWords() * i + (value_offset_in_bytes() / wordSize);
+ return stackElementWords() * i;
}
- static int local_tag_index_at(int i) {
- assert(TaggedStackInterpreter, "should not call this");
- Unimplemented();
- }
--- a/hotspot/src/os_cpu/linux_x86/vm/globals_linux_x86.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/os_cpu/linux_x86/vm/globals_linux_x86.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2000-2010 Sun Microsystems, Inc. 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
@@ -30,9 +30,9 @@
define_pd_global(intx, ThreadStackSize, 1024); // 0 => use system default
define_pd_global(intx, VMThreadStackSize, 1024);
#else
-// ThreadStackSize 320 allows TaggedStackInterpreter and a couple of test cases
-// to run while keeping the number of threads that can be created high.
-// System default ThreadStackSize appears to be 512 which is too big.
+// ThreadStackSize 320 allows a couple of test cases to run while
+// keeping the number of threads that can be created high. System
+// default ThreadStackSize appears to be 512 which is too big.
define_pd_global(intx, ThreadStackSize, 320);
define_pd_global(intx, VMThreadStackSize, 512);
#endif // AMD64
--- a/hotspot/src/os_cpu/solaris_x86/vm/globals_solaris_x86.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/os_cpu/solaris_x86/vm/globals_solaris_x86.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2000-2010 Sun Microsystems, Inc. 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
@@ -31,8 +31,8 @@
define_pd_global(intx, VMThreadStackSize, 1024);
define_pd_global(uintx,JVMInvokeMethodSlack, 8*K);
#else
-// ThreadStackSize 320 allows TaggedStackInterpreter and a couple of test cases
-// to run while keeping the number of threads that can be created high.
+// ThreadStackSize 320 allows a couple of test cases to run while
+// keeping the number of threads that can be created high.
define_pd_global(intx, ThreadStackSize, 320);
define_pd_global(intx, VMThreadStackSize, 512);
define_pd_global(uintx,JVMInvokeMethodSlack, 10*K);
--- a/hotspot/src/share/vm/interpreter/abstractInterpreter.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/interpreter/abstractInterpreter.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -167,60 +167,15 @@
// Debugging/printing
static void print(); // prints the interpreter code
- // Support for Tagged Stacks
- //
- // Tags are stored on the Java Expression stack above the value:
- //
- // tag
- // value
- //
- // For double values:
- //
- // tag2
- // high word
- // tag1
- // low word
-
public:
- static int stackElementWords() { return TaggedStackInterpreter ? 2 : 1; }
- static int stackElementSize() { return stackElementWords()*wordSize; }
- static int logStackElementSize() { return
- TaggedStackInterpreter? LogBytesPerWord+1 : LogBytesPerWord; }
-
- // Tag is at pointer, value is one below for a stack growing down
- // (or above for stack growing up)
- static int value_offset_in_bytes() {
- return TaggedStackInterpreter ?
- frame::interpreter_frame_expression_stack_direction() * wordSize : 0;
- }
- static int tag_offset_in_bytes() {
- assert(TaggedStackInterpreter, "should not call this");
- return 0;
- }
-
- // Tagged Locals
- // Locals are stored relative to Llocals:
- //
- // tag <- Llocals[n]
- // value
- //
- // Category 2 types are indexed as:
- //
- // tag <- Llocals[-n]
- // high word
- // tag <- Llocals[-n+1]
- // low word
- //
+ // Interpreter helpers
+ const static int stackElementWords = 1;
+ const static int stackElementSize = stackElementWords * wordSize;
+ const static int logStackElementSize = LogBytesPerWord;
// Local values relative to locals[n]
static int local_offset_in_bytes(int n) {
- return ((frame::interpreter_frame_expression_stack_direction() * n) *
- stackElementSize()) + value_offset_in_bytes();
- }
- static int local_tag_offset_in_bytes(int n) {
- assert(TaggedStackInterpreter, "should not call this");
- return ((frame::interpreter_frame_expression_stack_direction() * n) *
- stackElementSize()) + tag_offset_in_bytes();
+ return ((frame::interpreter_frame_expression_stack_direction() * n) * stackElementSize);
}
// access to stacked values according to type:
@@ -237,29 +192,15 @@
static jlong long_in_slot(intptr_t* slot_addr) {
if (sizeof(intptr_t) >= sizeof(jlong)) {
return *(jlong*) slot_addr;
- } else if (!TaggedStackInterpreter) {
+ } else {
return Bytes::get_native_u8((address)slot_addr);
- } else {
- assert(sizeof(intptr_t) * 2 == sizeof(jlong), "ILP32");
- // assemble the long in memory order (not arithmetic order)
- union { jlong j; jint i[2]; } u;
- u.i[0] = (jint) slot_addr[0*stackElementSize()];
- u.i[1] = (jint) slot_addr[1*stackElementSize()];
- return u.j;
}
}
static void set_long_in_slot(intptr_t* slot_addr, jlong value) {
if (sizeof(intptr_t) >= sizeof(jlong)) {
*(jlong*) slot_addr = value;
- } else if (!TaggedStackInterpreter) {
+ } else {
Bytes::put_native_u8((address)slot_addr, value);
- } else {
- assert(sizeof(intptr_t) * 2 == sizeof(jlong), "ILP32");
- // assemble the long in memory order (not arithmetic order)
- union { jlong j; jint i[2]; } u;
- u.j = value;
- slot_addr[0*stackElementSize()] = (intptr_t) u.i[0];
- slot_addr[1*stackElementSize()] = (intptr_t) u.i[1];
}
}
static void get_jvalue_in_slot(intptr_t* slot_addr, BasicType type, jvalue* value) {
--- a/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 2002-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 2002-2010 Sun Microsystems, Inc. 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
@@ -2692,219 +2692,141 @@
// The implementations are platform dependent. We have to worry about alignment
// issues on some machines which can change on the same platform depending on
// whether it is an LP64 machine also.
-#ifdef ASSERT
-void BytecodeInterpreter::verify_stack_tag(intptr_t *tos, frame::Tag tag, int offset) {
- if (TaggedStackInterpreter) {
- frame::Tag t = (frame::Tag)tos[Interpreter::expr_tag_index_at(-offset)];
- assert(t == tag, "stack tag mismatch");
- }
-}
-#endif // ASSERT
-
address BytecodeInterpreter::stack_slot(intptr_t *tos, int offset) {
- debug_only(verify_stack_tag(tos, frame::TagValue, offset));
return (address) tos[Interpreter::expr_index_at(-offset)];
}
jint BytecodeInterpreter::stack_int(intptr_t *tos, int offset) {
- debug_only(verify_stack_tag(tos, frame::TagValue, offset));
return *((jint*) &tos[Interpreter::expr_index_at(-offset)]);
}
jfloat BytecodeInterpreter::stack_float(intptr_t *tos, int offset) {
- debug_only(verify_stack_tag(tos, frame::TagValue, offset));
return *((jfloat *) &tos[Interpreter::expr_index_at(-offset)]);
}
oop BytecodeInterpreter::stack_object(intptr_t *tos, int offset) {
- debug_only(verify_stack_tag(tos, frame::TagReference, offset));
return (oop)tos [Interpreter::expr_index_at(-offset)];
}
jdouble BytecodeInterpreter::stack_double(intptr_t *tos, int offset) {
- debug_only(verify_stack_tag(tos, frame::TagValue, offset));
- debug_only(verify_stack_tag(tos, frame::TagValue, offset-1));
return ((VMJavaVal64*) &tos[Interpreter::expr_index_at(-offset)])->d;
}
jlong BytecodeInterpreter::stack_long(intptr_t *tos, int offset) {
- debug_only(verify_stack_tag(tos, frame::TagValue, offset));
- debug_only(verify_stack_tag(tos, frame::TagValue, offset-1));
return ((VMJavaVal64 *) &tos[Interpreter::expr_index_at(-offset)])->l;
}
-void BytecodeInterpreter::tag_stack(intptr_t *tos, frame::Tag tag, int offset) {
- if (TaggedStackInterpreter)
- tos[Interpreter::expr_tag_index_at(-offset)] = (intptr_t)tag;
-}
-
// only used for value types
void BytecodeInterpreter::set_stack_slot(intptr_t *tos, address value,
int offset) {
- tag_stack(tos, frame::TagValue, offset);
*((address *)&tos[Interpreter::expr_index_at(-offset)]) = value;
}
void BytecodeInterpreter::set_stack_int(intptr_t *tos, int value,
int offset) {
- tag_stack(tos, frame::TagValue, offset);
*((jint *)&tos[Interpreter::expr_index_at(-offset)]) = value;
}
void BytecodeInterpreter::set_stack_float(intptr_t *tos, jfloat value,
int offset) {
- tag_stack(tos, frame::TagValue, offset);
*((jfloat *)&tos[Interpreter::expr_index_at(-offset)]) = value;
}
void BytecodeInterpreter::set_stack_object(intptr_t *tos, oop value,
int offset) {
- tag_stack(tos, frame::TagReference, offset);
*((oop *)&tos[Interpreter::expr_index_at(-offset)]) = value;
}
// needs to be platform dep for the 32 bit platforms.
void BytecodeInterpreter::set_stack_double(intptr_t *tos, jdouble value,
int offset) {
- tag_stack(tos, frame::TagValue, offset);
- tag_stack(tos, frame::TagValue, offset-1);
((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->d = value;
}
void BytecodeInterpreter::set_stack_double_from_addr(intptr_t *tos,
address addr, int offset) {
- tag_stack(tos, frame::TagValue, offset);
- tag_stack(tos, frame::TagValue, offset-1);
(((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->d =
((VMJavaVal64*)addr)->d);
}
void BytecodeInterpreter::set_stack_long(intptr_t *tos, jlong value,
int offset) {
- tag_stack(tos, frame::TagValue, offset);
((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset+1)])->l = 0xdeedbeeb;
- tag_stack(tos, frame::TagValue, offset-1);
((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->l = value;
}
void BytecodeInterpreter::set_stack_long_from_addr(intptr_t *tos,
address addr, int offset) {
- tag_stack(tos, frame::TagValue, offset);
((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset+1)])->l = 0xdeedbeeb;
- tag_stack(tos, frame::TagValue, offset-1);
((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->l =
((VMJavaVal64*)addr)->l;
}
// Locals
-#ifdef ASSERT
-void BytecodeInterpreter::verify_locals_tag(intptr_t *locals, frame::Tag tag,
- int offset) {
- if (TaggedStackInterpreter) {
- frame::Tag t = (frame::Tag)locals[Interpreter::local_tag_index_at(-offset)];
- assert(t == tag, "locals tag mismatch");
- }
-}
-#endif // ASSERT
address BytecodeInterpreter::locals_slot(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
return (address)locals[Interpreter::local_index_at(-offset)];
}
jint BytecodeInterpreter::locals_int(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
return (jint)locals[Interpreter::local_index_at(-offset)];
}
jfloat BytecodeInterpreter::locals_float(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
return (jfloat)locals[Interpreter::local_index_at(-offset)];
}
oop BytecodeInterpreter::locals_object(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagReference, offset));
return (oop)locals[Interpreter::local_index_at(-offset)];
}
jdouble BytecodeInterpreter::locals_double(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
return ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->d;
}
jlong BytecodeInterpreter::locals_long(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
- debug_only(verify_locals_tag(locals, frame::TagValue, offset+1));
return ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->l;
}
// Returns the address of locals value.
address BytecodeInterpreter::locals_long_at(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
- debug_only(verify_locals_tag(locals, frame::TagValue, offset+1));
return ((address)&locals[Interpreter::local_index_at(-(offset+1))]);
}
address BytecodeInterpreter::locals_double_at(intptr_t* locals, int offset) {
- debug_only(verify_locals_tag(locals, frame::TagValue, offset));
- debug_only(verify_locals_tag(locals, frame::TagValue, offset+1));
return ((address)&locals[Interpreter::local_index_at(-(offset+1))]);
}
-void BytecodeInterpreter::tag_locals(intptr_t *locals, frame::Tag tag, int offset) {
- if (TaggedStackInterpreter)
- locals[Interpreter::local_tag_index_at(-offset)] = (intptr_t)tag;
-}
-
// Used for local value or returnAddress
void BytecodeInterpreter::set_locals_slot(intptr_t *locals,
address value, int offset) {
- tag_locals(locals, frame::TagValue, offset);
*((address*)&locals[Interpreter::local_index_at(-offset)]) = value;
}
void BytecodeInterpreter::set_locals_int(intptr_t *locals,
jint value, int offset) {
- tag_locals(locals, frame::TagValue, offset);
*((jint *)&locals[Interpreter::local_index_at(-offset)]) = value;
}
void BytecodeInterpreter::set_locals_float(intptr_t *locals,
jfloat value, int offset) {
- tag_locals(locals, frame::TagValue, offset);
*((jfloat *)&locals[Interpreter::local_index_at(-offset)]) = value;
}
void BytecodeInterpreter::set_locals_object(intptr_t *locals,
oop value, int offset) {
- tag_locals(locals, frame::TagReference, offset);
*((oop *)&locals[Interpreter::local_index_at(-offset)]) = value;
}
void BytecodeInterpreter::set_locals_double(intptr_t *locals,
jdouble value, int offset) {
- tag_locals(locals, frame::TagValue, offset);
- tag_locals(locals, frame::TagValue, offset+1);
((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->d = value;
}
void BytecodeInterpreter::set_locals_long(intptr_t *locals,
jlong value, int offset) {
- tag_locals(locals, frame::TagValue, offset);
- tag_locals(locals, frame::TagValue, offset+1);
((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->l = value;
}
void BytecodeInterpreter::set_locals_double_from_addr(intptr_t *locals,
address addr, int offset) {
- tag_locals(locals, frame::TagValue, offset);
- tag_locals(locals, frame::TagValue, offset+1);
((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->d = ((VMJavaVal64*)addr)->d;
}
void BytecodeInterpreter::set_locals_long_from_addr(intptr_t *locals,
address addr, int offset) {
- tag_locals(locals, frame::TagValue, offset);
- tag_locals(locals, frame::TagValue, offset+1);
((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->l = ((VMJavaVal64*)addr)->l;
}
void BytecodeInterpreter::astore(intptr_t* tos, int stack_offset,
intptr_t* locals, int locals_offset) {
- // Copy tag from stack to locals. astore's operand can be returnAddress
- // and may not be TagReference
- if (TaggedStackInterpreter) {
- frame::Tag t = (frame::Tag) tos[Interpreter::expr_tag_index_at(-stack_offset)];
- locals[Interpreter::local_tag_index_at(-locals_offset)] = (intptr_t)t;
- }
intptr_t value = tos[Interpreter::expr_index_at(-stack_offset)];
locals[Interpreter::local_index_at(-locals_offset)] = value;
}
@@ -2912,10 +2834,6 @@
void BytecodeInterpreter::copy_stack_slot(intptr_t *tos, int from_offset,
int to_offset) {
- if (TaggedStackInterpreter) {
- tos[Interpreter::expr_tag_index_at(-to_offset)] =
- (intptr_t)tos[Interpreter::expr_tag_index_at(-from_offset)];
- }
tos[Interpreter::expr_index_at(-to_offset)] =
(intptr_t)tos[Interpreter::expr_index_at(-from_offset)];
}
@@ -2964,16 +2882,9 @@
void BytecodeInterpreter::swap(intptr_t *tos) {
// swap top two elements
intptr_t val = tos[Interpreter::expr_index_at(1)];
- frame::Tag t;
- if (TaggedStackInterpreter) {
- t = (frame::Tag) tos[Interpreter::expr_tag_index_at(1)];
- }
// Copy -2 entry to -1
copy_stack_slot(tos, -2, -1);
// Store saved -1 entry into -2
- if (TaggedStackInterpreter) {
- tos[Interpreter::expr_tag_index_at(2)] = (intptr_t)t;
- }
tos[Interpreter::expr_index_at(2)] = val;
}
// --------------------------------------------------------------------------------
--- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1067,7 +1067,7 @@
jlong_accessor u;
jint* newval = (jint*)value;
u.words[0] = newval[0];
- u.words[1] = newval[Interpreter::stackElementWords()]; // skip if tag
+ u.words[1] = newval[Interpreter::stackElementWords]; // skip if tag
fvalue.j = u.long_value;
#endif // _LP64
@@ -1252,6 +1252,6 @@
ArgumentSizeComputer asc(invoke->signature());
int size_of_arguments = (asc.size() + (invoke->has_receiver() ? 1 : 0)); // receiver
Copy::conjoint_bytes(src_address, dest_address,
- size_of_arguments * Interpreter::stackElementSize());
+ size_of_arguments * Interpreter::stackElementSize);
IRT_END
#endif
--- a/hotspot/src/share/vm/oops/methodOop.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/oops/methodOop.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -306,7 +306,7 @@
int methodOopDesc::extra_stack_words() {
// not an inline function, to avoid a header dependency on Interpreter
- return extra_stack_entries() * Interpreter::stackElementSize();
+ return extra_stack_entries() * Interpreter::stackElementSize;
}
--- a/hotspot/src/share/vm/prims/methodHandles.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/prims/methodHandles.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -163,7 +163,7 @@
default: ShouldNotReachHere();
}
// Return the size of the stack slots to move in bytes.
- swap_bytes = swap_slots * Interpreter::stackElementSize();
+ swap_bytes = swap_slots * Interpreter::stackElementSize;
}
static int get_ek_adapter_opt_spread_info(EntryKind ek) {
@@ -219,7 +219,7 @@
// Offset in words that the interpreter stack pointer moves when an argument is pushed.
// The stack_move value must always be a multiple of this.
static int stack_move_unit() {
- return frame::interpreter_frame_expression_stack_direction() * Interpreter::stackElementWords();
+ return frame::interpreter_frame_expression_stack_direction() * Interpreter::stackElementWords;
}
enum { CONV_VMINFO_SIGN_FLAG = 0x80 };
--- a/hotspot/src/share/vm/runtime/arguments.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -2867,12 +2867,6 @@
}
#endif // _LP64
- // MethodHandles code does not support TaggedStackInterpreter.
- if (EnableMethodHandles && TaggedStackInterpreter) {
- warning("TaggedStackInterpreter is not supported by MethodHandles code. Disabling TaggedStackInterpreter.");
- TaggedStackInterpreter = false;
- }
-
// Check the GC selections again.
if (!check_gc_consistency()) {
return JNI_EINVAL;
@@ -2915,11 +2909,6 @@
LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false));
#endif // CC_INTERP
-#ifdef ZERO
- // Clear flags not supported by Zero
- FLAG_SET_DEFAULT(TaggedStackInterpreter, false);
-#endif // ZERO
-
#ifdef COMPILER2
if (!UseBiasedLocking || EmitSync != 0) {
UseOptoBiasInlining = false;
--- a/hotspot/src/share/vm/runtime/frame.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/frame.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -468,42 +468,16 @@
return &((*interpreter_frame_locals_addr())[n]);
}
-frame::Tag frame::interpreter_frame_local_tag(int index) const {
- const int n = Interpreter::local_tag_offset_in_bytes(index)/wordSize;
- return (Tag)(*interpreter_frame_locals_addr()) [n];
-}
-
-void frame::interpreter_frame_set_local_tag(int index, Tag tag) const {
- const int n = Interpreter::local_tag_offset_in_bytes(index)/wordSize;
- (*interpreter_frame_locals_addr())[n] = (intptr_t)tag;
-}
-
intptr_t* frame::interpreter_frame_expression_stack_at(jint offset) const {
const int i = offset * interpreter_frame_expression_stack_direction();
- const int n = ((i * Interpreter::stackElementSize()) +
- Interpreter::value_offset_in_bytes())/wordSize;
+ const int n = i * Interpreter::stackElementWords;
return &(interpreter_frame_expression_stack()[n]);
}
-frame::Tag frame::interpreter_frame_expression_stack_tag(jint offset) const {
- const int i = offset * interpreter_frame_expression_stack_direction();
- const int n = ((i * Interpreter::stackElementSize()) +
- Interpreter::tag_offset_in_bytes())/wordSize;
- return (Tag)(interpreter_frame_expression_stack()[n]);
-}
-
-void frame::interpreter_frame_set_expression_stack_tag(jint offset,
- Tag tag) const {
- const int i = offset * interpreter_frame_expression_stack_direction();
- const int n = ((i * Interpreter::stackElementSize()) +
- Interpreter::tag_offset_in_bytes())/wordSize;
- interpreter_frame_expression_stack()[n] = (intptr_t)tag;
-}
-
jint frame::interpreter_frame_expression_stack_size() const {
// Number of elements on the interpreter expression stack
// Callers should span by stackElementWords
- int element_size = Interpreter::stackElementWords();
+ int element_size = Interpreter::stackElementWords;
if (frame::interpreter_frame_expression_stack_direction() < 0) {
return (interpreter_frame_expression_stack() -
interpreter_frame_tos_address() + 1)/element_size;
@@ -585,20 +559,12 @@
for (i = 0; i < interpreter_frame_method()->max_locals(); i++ ) {
intptr_t x = *interpreter_frame_local_at(i);
st->print(" - local [" INTPTR_FORMAT "]", x);
- if (TaggedStackInterpreter) {
- Tag x = interpreter_frame_local_tag(i);
- st->print(" - local tag [" INTPTR_FORMAT "]", x);
- }
st->fill_to(23);
st->print_cr("; #%d", i);
}
for (i = interpreter_frame_expression_stack_size() - 1; i >= 0; --i ) {
intptr_t x = *interpreter_frame_expression_stack_at(i);
st->print(" - stack [" INTPTR_FORMAT "]", x);
- if (TaggedStackInterpreter) {
- Tag x = interpreter_frame_expression_stack_tag(i);
- st->print(" - stack tag [" INTPTR_FORMAT "]", x);
- }
st->fill_to(23);
st->print_cr("; #%d", i);
}
@@ -950,103 +916,19 @@
}
}
- if (TaggedStackInterpreter) {
- // process locals & expression stack
- InterpreterOopMap *mask = NULL;
-#ifdef ASSERT
- InterpreterOopMap oopmap_mask;
- OopMapCache::compute_one_oop_map(m, bci, &oopmap_mask);
- mask = &oopmap_mask;
-#endif // ASSERT
- oops_interpreted_locals_do(f, max_locals, mask);
- oops_interpreted_expressions_do(f, signature, has_receiver,
- m->max_stack(),
- max_locals, mask);
+ InterpreterFrameClosure blk(this, max_locals, m->max_stack(), f);
+
+ // process locals & expression stack
+ InterpreterOopMap mask;
+ if (query_oop_map_cache) {
+ m->mask_for(bci, &mask);
} else {
- InterpreterFrameClosure blk(this, max_locals, m->max_stack(), f);
-
- // process locals & expression stack
- InterpreterOopMap mask;
- if (query_oop_map_cache) {
- m->mask_for(bci, &mask);
- } else {
- OopMapCache::compute_one_oop_map(m, bci, &mask);
- }
- mask.iterate_oop(&blk);
+ OopMapCache::compute_one_oop_map(m, bci, &mask);
}
+ mask.iterate_oop(&blk);
}
-void frame::oops_interpreted_locals_do(OopClosure *f,
- int max_locals,
- InterpreterOopMap *mask) {
- // Process locals then interpreter expression stack
- for (int i = 0; i < max_locals; i++ ) {
- Tag tag = interpreter_frame_local_tag(i);
- if (tag == TagReference) {
- oop* addr = (oop*) interpreter_frame_local_at(i);
- assert((intptr_t*)addr >= sp(), "must be inside the frame");
- f->do_oop(addr);
-#ifdef ASSERT
- } else {
- assert(tag == TagValue, "bad tag value for locals");
- oop* p = (oop*) interpreter_frame_local_at(i);
- // Not always true - too bad. May have dead oops without tags in locals.
- // assert(*p == NULL || !(*p)->is_oop(), "oop not tagged on interpreter locals");
- assert(*p == NULL || !mask->is_oop(i), "local oop map mismatch");
-#endif // ASSERT
- }
- }
-}
-
-void frame::oops_interpreted_expressions_do(OopClosure *f,
- symbolHandle signature,
- bool has_receiver,
- int max_stack,
- int max_locals,
- InterpreterOopMap *mask) {
- // There is no stack no matter what the esp is pointing to (native methods
- // might look like expression stack is nonempty).
- if (max_stack == 0) return;
-
- // Point the top of the expression stack above arguments to a call so
- // arguments aren't gc'ed as both stack values for callee and callee
- // arguments in callee's locals.
- int args_size = 0;
- if (!signature.is_null()) {
- args_size = ArgumentSizeComputer(signature).size() + (has_receiver ? 1 : 0);
- }
-
- intptr_t *tos_addr = interpreter_frame_tos_at(args_size);
- assert(args_size != 0 || tos_addr == interpreter_frame_tos_address(), "these are same");
- intptr_t *frst_expr = interpreter_frame_expression_stack_at(0);
- // In case of exceptions, the expression stack is invalid and the esp
- // will be reset to express this condition. Therefore, we call f only
- // if addr is 'inside' the stack (i.e., addr >= esp for Intel).
- bool in_stack;
- if (interpreter_frame_expression_stack_direction() > 0) {
- in_stack = (intptr_t*)frst_expr <= tos_addr;
- } else {
- in_stack = (intptr_t*)frst_expr >= tos_addr;
- }
- if (!in_stack) return;
-
- jint stack_size = interpreter_frame_expression_stack_size() - args_size;
- for (int j = 0; j < stack_size; j++) {
- Tag tag = interpreter_frame_expression_stack_tag(j);
- if (tag == TagReference) {
- oop *addr = (oop*) interpreter_frame_expression_stack_at(j);
- f->do_oop(addr);
-#ifdef ASSERT
- } else {
- assert(tag == TagValue, "bad tag value for stack element");
- oop *p = (oop*) interpreter_frame_expression_stack_at((j));
- assert(*p == NULL || !mask->is_oop(j+max_locals), "stack oop map mismatch");
-#endif // ASSERT
- }
- }
-}
-
void frame::oops_interpreted_arguments_do(symbolHandle signature, bool has_receiver, OopClosure* f) {
InterpretedArgumentOopFinder finder(signature, has_receiver, this, f);
finder.oops_do();
@@ -1306,29 +1188,18 @@
int max_locals = m->is_native() ? m->size_of_parameters() : m->max_locals();
- if (TaggedStackInterpreter) {
- InterpreterOopMap *mask = NULL;
-#ifdef ASSERT
- InterpreterOopMap oopmap_mask;
- methodHandle method(thread, m);
- OopMapCache::compute_one_oop_map(method, bci, &oopmap_mask);
- mask = &oopmap_mask;
-#endif // ASSERT
- oops_interpreted_locals_do(&_check_oop, max_locals, mask);
- } else {
- // process dynamic part
- InterpreterFrameClosure value_blk(this, max_locals, m->max_stack(),
- &_check_value);
- InterpreterFrameClosure oop_blk(this, max_locals, m->max_stack(),
- &_check_oop );
- InterpreterFrameClosure dead_blk(this, max_locals, m->max_stack(),
- &_zap_dead );
+ // process dynamic part
+ InterpreterFrameClosure value_blk(this, max_locals, m->max_stack(),
+ &_check_value);
+ InterpreterFrameClosure oop_blk(this, max_locals, m->max_stack(),
+ &_check_oop );
+ InterpreterFrameClosure dead_blk(this, max_locals, m->max_stack(),
+ &_zap_dead );
- // get frame map
- InterpreterOopMap mask;
- m->mask_for(bci, &mask);
- mask.iterate_all( &oop_blk, &value_blk, &dead_blk);
- }
+ // get frame map
+ InterpreterOopMap mask;
+ m->mask_for(bci, &mask);
+ mask.iterate_all( &oop_blk, &value_blk, &dead_blk);
}
--- a/hotspot/src/share/vm/runtime/frame.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/frame.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -191,26 +191,10 @@
intptr_t* interpreter_frame_mdx_addr() const;
public:
- // Tags for TaggedStackInterpreter
- enum Tag {
- TagValue = 0, // Important: must be zero to use G0 on sparc.
- TagReference = 0x555, // Reference type - is an oop that needs gc.
- TagCategory2 = 0x666 // Only used internally by interpreter
- // and not written to the java stack.
- // The values above are chosen so that misuse causes a crash
- // with a recognizable value.
- };
-
- static Tag tag_for_basic_type(BasicType typ) {
- return (typ == T_OBJECT ? TagReference : TagValue);
- }
-
// Locals
// The _at version returns a pointer because the address is used for GC.
intptr_t* interpreter_frame_local_at(int index) const;
- Tag interpreter_frame_local_tag(int index) const;
- void interpreter_frame_set_local_tag(int index, Tag tag) const;
void interpreter_frame_set_locals(intptr_t* locs);
@@ -260,8 +244,6 @@
// The _at version returns a pointer because the address is used for GC.
intptr_t* interpreter_frame_expression_stack_at(jint offset) const;
- Tag interpreter_frame_expression_stack_tag(jint offset) const;
- void interpreter_frame_set_expression_stack_tag(jint offset, Tag tag) const;
// top of expression stack
intptr_t* interpreter_frame_tos_at(jint offset) const;
@@ -375,12 +357,6 @@
void oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache = true);
private:
- void oops_interpreted_locals_do(OopClosure *f,
- int max_locals,
- InterpreterOopMap *mask);
- void oops_interpreted_expressions_do(OopClosure *f, symbolHandle signature,
- bool has_receiver, int max_stack, int max_locals,
- InterpreterOopMap *mask);
void oops_interpreted_arguments_do(symbolHandle signature, bool has_receiver, OopClosure* f);
// Iteration of oops
--- a/hotspot/src/share/vm/runtime/globals.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/globals.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -3497,9 +3497,6 @@
develop(bool, TraceInvokeDynamic, false, \
"trace internal invoke dynamic operations") \
\
- product(bool, TaggedStackInterpreter, false, \
- "Insert tags in interpreter execution stack for oopmap generaion")\
- \
diagnostic(bool, PauseAtStartup, false, \
"Causes the VM to pause at startup time and wait for the pause " \
"file to be removed (default: ./vm.paused.<pid>)") \
--- a/hotspot/src/share/vm/runtime/javaCalls.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/javaCalls.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2010 Sun Microsystems, Inc. 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
@@ -417,17 +417,9 @@
// Handle conversion
_value[i] = (intptr_t)Handle::raw_resolve((oop *)_value[i]);
}
- // The parameters are moved to the parameters array to include the tags.
- if (TaggedStackInterpreter) {
- // Tags are interspersed with arguments. Tags are first.
- int tagged_index = i*2;
- _parameters[tagged_index] = _is_oop[i] ? frame::TagReference :
- frame::TagValue;
- _parameters[tagged_index+1] = _value[i];
- }
}
// Return argument vector
- return TaggedStackInterpreter ? _parameters : _value;
+ return _value;
}
--- a/hotspot/src/share/vm/runtime/javaCalls.hpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/javaCalls.hpp Fri Apr 30 08:37:24 2010 -0700
@@ -66,11 +66,9 @@
};
intptr_t _value_buffer [_default_size + 1];
- intptr_t _parameter_buffer [_default_size*2 + 1];
bool _is_oop_buffer[_default_size + 1];
intptr_t* _value;
- intptr_t* _parameters;
bool* _is_oop;
int _size;
int _max_size;
@@ -81,7 +79,6 @@
_value = &_value_buffer[1];
_is_oop = &_is_oop_buffer[1];
- _parameters = &_parameter_buffer[0];
_max_size = _default_size;
_size = 0;
_start_at_zero = false;
@@ -99,11 +96,10 @@
if (max_size > _default_size) {
_value = NEW_RESOURCE_ARRAY(intptr_t, max_size + 1);
_is_oop = NEW_RESOURCE_ARRAY(bool, max_size + 1);
- if (TaggedStackInterpreter) {
- _parameters = NEW_RESOURCE_ARRAY(intptr_t, max_size*2 + 1);
- }
+
// Reserve room for potential receiver in value and is_oop
_value++; _is_oop++;
+
_max_size = max_size;
_size = 0;
_start_at_zero = false;
--- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -1842,14 +1842,11 @@
case T_OBJECT:
case T_ARRAY:
- if (!TaggedStackInterpreter) {
#ifdef _LP64
- return T_LONG;
+ return T_LONG;
#else
- return T_INT;
+ return T_INT;
#endif
- }
- return T_OBJECT;
case T_INT:
case T_LONG:
@@ -2595,17 +2592,9 @@
// Copy the locals. Order is preserved so that loading of longs works.
// Since there's no GC I can copy the oops blindly.
assert( sizeof(HeapWord)==sizeof(intptr_t), "fix this code");
- if (TaggedStackInterpreter) {
- for (int i = 0; i < max_locals; i++) {
- // copy only each local separately to the buffer avoiding the tag
- buf[i] = *fr.interpreter_frame_local_at(max_locals-i-1);
- }
- } else {
- Copy::disjoint_words(
- (HeapWord*)fr.interpreter_frame_local_at(max_locals-1),
+ Copy::disjoint_words((HeapWord*)fr.interpreter_frame_local_at(max_locals-1),
(HeapWord*)&buf[0],
max_locals);
- }
// Inflate locks. Copy the displaced headers. Be careful, there can be holes.
int i = max_locals;
--- a/hotspot/src/share/vm/runtime/vframe.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/vframe.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -244,51 +244,30 @@
StackValueCollection* result = new StackValueCollection(length);
// Get oopmap describing oops and int for current bci
- if (TaggedStackInterpreter) {
- for(int i=0; i < length; i++) {
- // Find stack location
- intptr_t *addr = locals_addr_at(i);
-
- // Depending on oop/int put it in the right package
- StackValue *sv;
- frame::Tag tag = fr().interpreter_frame_local_tag(i);
- if (tag == frame::TagReference) {
- // oop value
- Handle h(*(oop *)addr);
- sv = new StackValue(h);
- } else {
- // integer
- sv = new StackValue(*addr);
- }
- assert(sv != NULL, "sanity check");
- result->add(sv);
- }
+ InterpreterOopMap oop_mask;
+ if (TraceDeoptimization && Verbose) {
+ methodHandle m_h(thread(), method());
+ OopMapCache::compute_one_oop_map(m_h, bci(), &oop_mask);
} else {
- InterpreterOopMap oop_mask;
- if (TraceDeoptimization && Verbose) {
- methodHandle m_h(thread(), method());
- OopMapCache::compute_one_oop_map(m_h, bci(), &oop_mask);
- } else {
- method()->mask_for(bci(), &oop_mask);
- }
- // handle locals
- for(int i=0; i < length; i++) {
- // Find stack location
- intptr_t *addr = locals_addr_at(i);
+ method()->mask_for(bci(), &oop_mask);
+ }
+ // handle locals
+ for(int i=0; i < length; i++) {
+ // Find stack location
+ intptr_t *addr = locals_addr_at(i);
- // Depending on oop/int put it in the right package
- StackValue *sv;
- if (oop_mask.is_oop(i)) {
- // oop value
- Handle h(*(oop *)addr);
- sv = new StackValue(h);
- } else {
- // integer
- sv = new StackValue(*addr);
- }
- assert(sv != NULL, "sanity check");
- result->add(sv);
+ // Depending on oop/int put it in the right package
+ StackValue *sv;
+ if (oop_mask.is_oop(i)) {
+ // oop value
+ Handle h(*(oop *)addr);
+ sv = new StackValue(h);
+ } else {
+ // integer
+ sv = new StackValue(*addr);
}
+ assert(sv != NULL, "sanity check");
+ result->add(sv);
}
return result;
}
@@ -331,53 +310,31 @@
int nof_locals = method()->max_locals();
StackValueCollection* result = new StackValueCollection(length);
- if (TaggedStackInterpreter) {
- // handle expressions
- for(int i=0; i < length; i++) {
- // Find stack location
- intptr_t *addr = fr().interpreter_frame_expression_stack_at(i);
- frame::Tag tag = fr().interpreter_frame_expression_stack_tag(i);
-
- // Depending on oop/int put it in the right package
- StackValue *sv;
- if (tag == frame::TagReference) {
- // oop value
- Handle h(*(oop *)addr);
- sv = new StackValue(h);
- } else {
- // otherwise
- sv = new StackValue(*addr);
- }
- assert(sv != NULL, "sanity check");
- result->add(sv);
- }
+ InterpreterOopMap oop_mask;
+ // Get oopmap describing oops and int for current bci
+ if (TraceDeoptimization && Verbose) {
+ methodHandle m_h(method());
+ OopMapCache::compute_one_oop_map(m_h, bci(), &oop_mask);
} else {
- InterpreterOopMap oop_mask;
- // Get oopmap describing oops and int for current bci
- if (TraceDeoptimization && Verbose) {
- methodHandle m_h(method());
- OopMapCache::compute_one_oop_map(m_h, bci(), &oop_mask);
- } else {
- method()->mask_for(bci(), &oop_mask);
- }
- // handle expressions
- for(int i=0; i < length; i++) {
- // Find stack location
- intptr_t *addr = fr().interpreter_frame_expression_stack_at(i);
+ method()->mask_for(bci(), &oop_mask);
+ }
+ // handle expressions
+ for(int i=0; i < length; i++) {
+ // Find stack location
+ intptr_t *addr = fr().interpreter_frame_expression_stack_at(i);
- // Depending on oop/int put it in the right package
- StackValue *sv;
- if (oop_mask.is_oop(i + nof_locals)) {
- // oop value
- Handle h(*(oop *)addr);
- sv = new StackValue(h);
- } else {
- // integer
- sv = new StackValue(*addr);
- }
- assert(sv != NULL, "sanity check");
- result->add(sv);
+ // Depending on oop/int put it in the right package
+ StackValue *sv;
+ if (oop_mask.is_oop(i + nof_locals)) {
+ // oop value
+ Handle h(*(oop *)addr);
+ sv = new StackValue(h);
+ } else {
+ // integer
+ sv = new StackValue(*addr);
}
+ assert(sv != NULL, "sanity check");
+ result->add(sv);
}
return result;
}
--- a/hotspot/src/share/vm/runtime/vframeArray.cpp Fri Apr 30 04:27:25 2010 -0700
+++ b/hotspot/src/share/vm/runtime/vframeArray.cpp Fri Apr 30 08:37:24 2010 -0700
@@ -309,11 +309,6 @@
default:
ShouldNotReachHere();
}
- if (TaggedStackInterpreter) {
- // Write tag to the stack
- iframe()->interpreter_frame_set_expression_stack_tag(i,
- frame::tag_for_basic_type(value->type()));
- }
}
@@ -335,11 +330,6 @@
default:
ShouldNotReachHere();
}
- if (TaggedStackInterpreter) {
- // Write tag to stack
- iframe()->interpreter_frame_set_local_tag(i,
- frame::tag_for_basic_type(value->type()));
- }
}
if (is_top_frame && JvmtiExport::can_pop_frame() && thread->popframe_forcing_deopt_reexecution()) {
@@ -354,9 +344,8 @@
void* saved_args = thread->popframe_preserved_args();
assert(saved_args != NULL, "must have been saved by interpreter");
#ifdef ASSERT
- int stack_words = Interpreter::stackElementWords();
assert(popframe_preserved_args_size_in_words <=
- iframe()->interpreter_frame_expression_stack_size()*stack_words,
+ iframe()->interpreter_frame_expression_stack_size()*Interpreter::stackElementWords,
"expression stack size should have been extended");
#endif // ASSERT
int top_element = iframe()->interpreter_frame_expression_stack_size()-1;