1.1 --- a/src/cpu/sparc/vm/interp_masm_sparc.cpp Fri Apr 30 04:27:25 2010 -0700
1.2 +++ b/src/cpu/sparc/vm/interp_masm_sparc.cpp Fri Apr 30 08:37:24 2010 -0700
1.3 @@ -50,7 +50,6 @@
1.4 // Any changes should also be applied to CodeEmitter::emit_osr_entry().
1.5 assert_different_registers(args_size, locals_size);
1.6 // max_locals*2 for TAGS. Assumes that args_size has already been adjusted.
1.7 - if (TaggedStackInterpreter) sll(locals_size, 1, locals_size);
1.8 subcc(locals_size, args_size, delta);// extra space for non-arguments locals in words
1.9 // Use br/mov combination because it works on both V8 and V9 and is
1.10 // faster.
1.11 @@ -319,7 +318,7 @@
1.12 ldf(FloatRegisterImpl::D, r1, offset, d);
1.13 #else
1.14 ldf(FloatRegisterImpl::S, r1, offset, d);
1.15 - ldf(FloatRegisterImpl::S, r1, offset + Interpreter::stackElementSize(), d->successor());
1.16 + ldf(FloatRegisterImpl::S, r1, offset + Interpreter::stackElementSize, d->successor());
1.17 #endif
1.18 }
1.19
1.20 @@ -330,10 +329,10 @@
1.21 #ifdef _LP64
1.22 stf(FloatRegisterImpl::D, d, r1, offset);
1.23 // store something more useful here
1.24 - debug_only(stx(G0, r1, offset+Interpreter::stackElementSize());)
1.25 + debug_only(stx(G0, r1, offset+Interpreter::stackElementSize);)
1.26 #else
1.27 stf(FloatRegisterImpl::S, d, r1, offset);
1.28 - stf(FloatRegisterImpl::S, d->successor(), r1, offset + Interpreter::stackElementSize());
1.29 + stf(FloatRegisterImpl::S, d->successor(), r1, offset + Interpreter::stackElementSize);
1.30 #endif
1.31 }
1.32
1.33 @@ -345,7 +344,7 @@
1.34 ldx(r1, offset, rd);
1.35 #else
1.36 ld(r1, offset, rd);
1.37 - ld(r1, offset + Interpreter::stackElementSize(), rd->successor());
1.38 + ld(r1, offset + Interpreter::stackElementSize, rd->successor());
1.39 #endif
1.40 }
1.41
1.42 @@ -356,138 +355,62 @@
1.43 #ifdef _LP64
1.44 stx(l, r1, offset);
1.45 // store something more useful here
1.46 - debug_only(stx(G0, r1, offset+Interpreter::stackElementSize());)
1.47 + debug_only(stx(G0, r1, offset+Interpreter::stackElementSize);)
1.48 #else
1.49 st(l, r1, offset);
1.50 - st(l->successor(), r1, offset + Interpreter::stackElementSize());
1.51 + st(l->successor(), r1, offset + Interpreter::stackElementSize);
1.52 #endif
1.53 }
1.54
1.55 -#ifdef ASSERT
1.56 -void InterpreterMacroAssembler::verify_stack_tag(frame::Tag t,
1.57 - Register r,
1.58 - Register scratch) {
1.59 - if (TaggedStackInterpreter) {
1.60 - Label ok, long_ok;
1.61 - ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(0), r);
1.62 - if (t == frame::TagCategory2) {
1.63 - cmp(r, G0);
1.64 - brx(Assembler::equal, false, Assembler::pt, long_ok);
1.65 - delayed()->ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(1), r);
1.66 - stop("stack long/double tag value bad");
1.67 - bind(long_ok);
1.68 - cmp(r, G0);
1.69 - } else if (t == frame::TagValue) {
1.70 - cmp(r, G0);
1.71 - } else {
1.72 - assert_different_registers(r, scratch);
1.73 - mov(t, scratch);
1.74 - cmp(r, scratch);
1.75 - }
1.76 - brx(Assembler::equal, false, Assembler::pt, ok);
1.77 - delayed()->nop();
1.78 - // Also compare if the stack value is zero, then the tag might
1.79 - // not have been set coming from deopt.
1.80 - ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), r);
1.81 - cmp(r, G0);
1.82 - brx(Assembler::equal, false, Assembler::pt, ok);
1.83 - delayed()->nop();
1.84 - stop("Stack tag value is bad");
1.85 - bind(ok);
1.86 - }
1.87 -}
1.88 -#endif // ASSERT
1.89 -
1.90 void InterpreterMacroAssembler::pop_i(Register r) {
1.91 assert_not_delayed();
1.92 - // Uses destination register r for scratch
1.93 - debug_only(verify_stack_tag(frame::TagValue, r));
1.94 ld(Lesp, Interpreter::expr_offset_in_bytes(0), r);
1.95 - inc(Lesp, Interpreter::stackElementSize());
1.96 + inc(Lesp, Interpreter::stackElementSize);
1.97 debug_only(verify_esp(Lesp));
1.98 }
1.99
1.100 void InterpreterMacroAssembler::pop_ptr(Register r, Register scratch) {
1.101 assert_not_delayed();
1.102 - // Uses destination register r for scratch
1.103 - debug_only(verify_stack_tag(frame::TagReference, r, scratch));
1.104 ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), r);
1.105 - inc(Lesp, Interpreter::stackElementSize());
1.106 + inc(Lesp, Interpreter::stackElementSize);
1.107 debug_only(verify_esp(Lesp));
1.108 }
1.109
1.110 void InterpreterMacroAssembler::pop_l(Register r) {
1.111 assert_not_delayed();
1.112 - // Uses destination register r for scratch
1.113 - debug_only(verify_stack_tag(frame::TagCategory2, r));
1.114 load_unaligned_long(Lesp, Interpreter::expr_offset_in_bytes(0), r);
1.115 - inc(Lesp, 2*Interpreter::stackElementSize());
1.116 + inc(Lesp, 2*Interpreter::stackElementSize);
1.117 debug_only(verify_esp(Lesp));
1.118 }
1.119
1.120
1.121 void InterpreterMacroAssembler::pop_f(FloatRegister f, Register scratch) {
1.122 assert_not_delayed();
1.123 - debug_only(verify_stack_tag(frame::TagValue, scratch));
1.124 ldf(FloatRegisterImpl::S, Lesp, Interpreter::expr_offset_in_bytes(0), f);
1.125 - inc(Lesp, Interpreter::stackElementSize());
1.126 + inc(Lesp, Interpreter::stackElementSize);
1.127 debug_only(verify_esp(Lesp));
1.128 }
1.129
1.130
1.131 void InterpreterMacroAssembler::pop_d(FloatRegister f, Register scratch) {
1.132 assert_not_delayed();
1.133 - debug_only(verify_stack_tag(frame::TagCategory2, scratch));
1.134 load_unaligned_double(Lesp, Interpreter::expr_offset_in_bytes(0), f);
1.135 - inc(Lesp, 2*Interpreter::stackElementSize());
1.136 + inc(Lesp, 2*Interpreter::stackElementSize);
1.137 debug_only(verify_esp(Lesp));
1.138 }
1.139
1.140
1.141 -// (Note use register first, then decrement so dec can be done during store stall)
1.142 -void InterpreterMacroAssembler::tag_stack(Register r) {
1.143 - if (TaggedStackInterpreter) {
1.144 - st_ptr(r, Lesp, Interpreter::tag_offset_in_bytes());
1.145 - }
1.146 -}
1.147 -
1.148 -void InterpreterMacroAssembler::tag_stack(frame::Tag t, Register r) {
1.149 - if (TaggedStackInterpreter) {
1.150 - assert (frame::TagValue == 0, "TagValue must be zero");
1.151 - if (t == frame::TagValue) {
1.152 - st_ptr(G0, Lesp, Interpreter::tag_offset_in_bytes());
1.153 - } else if (t == frame::TagCategory2) {
1.154 - st_ptr(G0, Lesp, Interpreter::tag_offset_in_bytes());
1.155 - // Tag next slot down too
1.156 - st_ptr(G0, Lesp, -Interpreter::stackElementSize() + Interpreter::tag_offset_in_bytes());
1.157 - } else {
1.158 - assert_different_registers(r, O3);
1.159 - mov(t, O3);
1.160 - st_ptr(O3, Lesp, Interpreter::tag_offset_in_bytes());
1.161 - }
1.162 - }
1.163 -}
1.164 -
1.165 void InterpreterMacroAssembler::push_i(Register r) {
1.166 assert_not_delayed();
1.167 debug_only(verify_esp(Lesp));
1.168 - tag_stack(frame::TagValue, r);
1.169 - st( r, Lesp, Interpreter::value_offset_in_bytes());
1.170 - dec( Lesp, Interpreter::stackElementSize());
1.171 + st(r, Lesp, 0);
1.172 + dec(Lesp, Interpreter::stackElementSize);
1.173 }
1.174
1.175 void InterpreterMacroAssembler::push_ptr(Register r) {
1.176 assert_not_delayed();
1.177 - tag_stack(frame::TagReference, r);
1.178 - st_ptr( r, Lesp, Interpreter::value_offset_in_bytes());
1.179 - dec( Lesp, Interpreter::stackElementSize());
1.180 -}
1.181 -
1.182 -void InterpreterMacroAssembler::push_ptr(Register r, Register tag) {
1.183 - assert_not_delayed();
1.184 - tag_stack(tag);
1.185 - st_ptr(r, Lesp, Interpreter::value_offset_in_bytes());
1.186 - dec( Lesp, Interpreter::stackElementSize());
1.187 + st_ptr(r, Lesp, 0);
1.188 + dec(Lesp, Interpreter::stackElementSize);
1.189 }
1.190
1.191 // remember: our convention for longs in SPARC is:
1.192 @@ -497,33 +420,28 @@
1.193 void InterpreterMacroAssembler::push_l(Register r) {
1.194 assert_not_delayed();
1.195 debug_only(verify_esp(Lesp));
1.196 - tag_stack(frame::TagCategory2, r);
1.197 - // Longs are in stored in memory-correct order, even if unaligned.
1.198 - // and may be separated by stack tags.
1.199 - int offset = -Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();
1.200 + // Longs are stored in memory-correct order, even if unaligned.
1.201 + int offset = -Interpreter::stackElementSize;
1.202 store_unaligned_long(r, Lesp, offset);
1.203 - dec(Lesp, 2 * Interpreter::stackElementSize());
1.204 + dec(Lesp, 2 * Interpreter::stackElementSize);
1.205 }
1.206
1.207
1.208 void InterpreterMacroAssembler::push_f(FloatRegister f) {
1.209 assert_not_delayed();
1.210 debug_only(verify_esp(Lesp));
1.211 - tag_stack(frame::TagValue, Otos_i);
1.212 - stf(FloatRegisterImpl::S, f, Lesp, Interpreter::value_offset_in_bytes());
1.213 - dec(Lesp, Interpreter::stackElementSize());
1.214 + stf(FloatRegisterImpl::S, f, Lesp, 0);
1.215 + dec(Lesp, Interpreter::stackElementSize);
1.216 }
1.217
1.218
1.219 void InterpreterMacroAssembler::push_d(FloatRegister d) {
1.220 assert_not_delayed();
1.221 debug_only(verify_esp(Lesp));
1.222 - tag_stack(frame::TagCategory2, Otos_i);
1.223 - // Longs are in stored in memory-correct order, even if unaligned.
1.224 - // and may be separated by stack tags.
1.225 - int offset = -Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();
1.226 + // Longs are stored in memory-correct order, even if unaligned.
1.227 + int offset = -Interpreter::stackElementSize;
1.228 store_unaligned_double(d, Lesp, offset);
1.229 - dec(Lesp, 2 * Interpreter::stackElementSize());
1.230 + dec(Lesp, 2 * Interpreter::stackElementSize);
1.231 }
1.232
1.233
1.234 @@ -561,30 +479,18 @@
1.235 }
1.236
1.237
1.238 -// Tagged stack helpers for swap and dup
1.239 -void InterpreterMacroAssembler::load_ptr_and_tag(int n, Register val,
1.240 - Register tag) {
1.241 +// Helpers for swap and dup
1.242 +void InterpreterMacroAssembler::load_ptr(int n, Register val) {
1.243 ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(n), val);
1.244 - if (TaggedStackInterpreter) {
1.245 - ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(n), tag);
1.246 - }
1.247 }
1.248 -void InterpreterMacroAssembler::store_ptr_and_tag(int n, Register val,
1.249 - Register tag) {
1.250 +void InterpreterMacroAssembler::store_ptr(int n, Register val) {
1.251 st_ptr(val, Lesp, Interpreter::expr_offset_in_bytes(n));
1.252 - if (TaggedStackInterpreter) {
1.253 - st_ptr(tag, Lesp, Interpreter::expr_tag_offset_in_bytes(n));
1.254 - }
1.255 }
1.256
1.257
1.258 void InterpreterMacroAssembler::load_receiver(Register param_count,
1.259 Register recv) {
1.260 -
1.261 - sll(param_count, Interpreter::logStackElementSize(), param_count);
1.262 - if (TaggedStackInterpreter) {
1.263 - add(param_count, Interpreter::value_offset_in_bytes(), param_count); // get obj address
1.264 - }
1.265 + sll(param_count, Interpreter::logStackElementSize, param_count);
1.266 ld_ptr(Lesp, param_count, recv); // gets receiver Oop
1.267 }
1.268
1.269 @@ -605,7 +511,6 @@
1.270
1.271 // Compute max expression stack+register save area
1.272 lduh(Lmethod, in_bytes(methodOopDesc::max_stack_offset()), Gframe_size); // Load max stack.
1.273 - if (TaggedStackInterpreter) sll ( Gframe_size, 1, Gframe_size); // max_stack * 2 for TAGS
1.274 add( Gframe_size, frame::memory_parameter_word_sp_offset, Gframe_size );
1.275
1.276 //
1.277 @@ -2018,51 +1923,11 @@
1.278 }
1.279
1.280 // Locals
1.281 -#ifdef ASSERT
1.282 -void InterpreterMacroAssembler::verify_local_tag(frame::Tag t,
1.283 - Register base,
1.284 - Register scratch,
1.285 - int n) {
1.286 - if (TaggedStackInterpreter) {
1.287 - Label ok, long_ok;
1.288 - // Use dst for scratch
1.289 - assert_different_registers(base, scratch);
1.290 - ld_ptr(base, Interpreter::local_tag_offset_in_bytes(n), scratch);
1.291 - if (t == frame::TagCategory2) {
1.292 - cmp(scratch, G0);
1.293 - brx(Assembler::equal, false, Assembler::pt, long_ok);
1.294 - delayed()->ld_ptr(base, Interpreter::local_tag_offset_in_bytes(n+1), scratch);
1.295 - stop("local long/double tag value bad");
1.296 - bind(long_ok);
1.297 - // compare second half tag
1.298 - cmp(scratch, G0);
1.299 - } else if (t == frame::TagValue) {
1.300 - cmp(scratch, G0);
1.301 - } else {
1.302 - assert_different_registers(O3, base, scratch);
1.303 - mov(t, O3);
1.304 - cmp(scratch, O3);
1.305 - }
1.306 - brx(Assembler::equal, false, Assembler::pt, ok);
1.307 - delayed()->nop();
1.308 - // Also compare if the local value is zero, then the tag might
1.309 - // not have been set coming from deopt.
1.310 - ld_ptr(base, Interpreter::local_offset_in_bytes(n), scratch);
1.311 - cmp(scratch, G0);
1.312 - brx(Assembler::equal, false, Assembler::pt, ok);
1.313 - delayed()->nop();
1.314 - stop("Local tag value is bad");
1.315 - bind(ok);
1.316 - }
1.317 -}
1.318 -#endif // ASSERT
1.319 -
1.320 void InterpreterMacroAssembler::access_local_ptr( Register index, Register dst ) {
1.321 assert_not_delayed();
1.322 - sll(index, Interpreter::logStackElementSize(), index);
1.323 + sll(index, Interpreter::logStackElementSize, index);
1.324 sub(Llocals, index, index);
1.325 - debug_only(verify_local_tag(frame::TagReference, index, dst));
1.326 - ld_ptr(index, Interpreter::value_offset_in_bytes(), dst);
1.327 + ld_ptr(index, 0, dst);
1.328 // Note: index must hold the effective address--the iinc template uses it
1.329 }
1.330
1.331 @@ -2070,27 +1935,24 @@
1.332 void InterpreterMacroAssembler::access_local_returnAddress(Register index,
1.333 Register dst ) {
1.334 assert_not_delayed();
1.335 - sll(index, Interpreter::logStackElementSize(), index);
1.336 + sll(index, Interpreter::logStackElementSize, index);
1.337 sub(Llocals, index, index);
1.338 - debug_only(verify_local_tag(frame::TagValue, index, dst));
1.339 - ld_ptr(index, Interpreter::value_offset_in_bytes(), dst);
1.340 + ld_ptr(index, 0, dst);
1.341 }
1.342
1.343 void InterpreterMacroAssembler::access_local_int( Register index, Register dst ) {
1.344 assert_not_delayed();
1.345 - sll(index, Interpreter::logStackElementSize(), index);
1.346 + sll(index, Interpreter::logStackElementSize, index);
1.347 sub(Llocals, index, index);
1.348 - debug_only(verify_local_tag(frame::TagValue, index, dst));
1.349 - ld(index, Interpreter::value_offset_in_bytes(), dst);
1.350 + ld(index, 0, dst);
1.351 // Note: index must hold the effective address--the iinc template uses it
1.352 }
1.353
1.354
1.355 void InterpreterMacroAssembler::access_local_long( Register index, Register dst ) {
1.356 assert_not_delayed();
1.357 - sll(index, Interpreter::logStackElementSize(), index);
1.358 + sll(index, Interpreter::logStackElementSize, index);
1.359 sub(Llocals, index, index);
1.360 - debug_only(verify_local_tag(frame::TagCategory2, index, dst));
1.361 // First half stored at index n+1 (which grows down from Llocals[n])
1.362 load_unaligned_long(index, Interpreter::local_offset_in_bytes(1), dst);
1.363 }
1.364 @@ -2098,18 +1960,16 @@
1.365
1.366 void InterpreterMacroAssembler::access_local_float( Register index, FloatRegister dst ) {
1.367 assert_not_delayed();
1.368 - sll(index, Interpreter::logStackElementSize(), index);
1.369 + sll(index, Interpreter::logStackElementSize, index);
1.370 sub(Llocals, index, index);
1.371 - debug_only(verify_local_tag(frame::TagValue, index, G1_scratch));
1.372 - ldf(FloatRegisterImpl::S, index, Interpreter::value_offset_in_bytes(), dst);
1.373 + ldf(FloatRegisterImpl::S, index, 0, dst);
1.374 }
1.375
1.376
1.377 void InterpreterMacroAssembler::access_local_double( Register index, FloatRegister dst ) {
1.378 assert_not_delayed();
1.379 - sll(index, Interpreter::logStackElementSize(), index);
1.380 + sll(index, Interpreter::logStackElementSize, index);
1.381 sub(Llocals, index, index);
1.382 - debug_only(verify_local_tag(frame::TagCategory2, index, G1_scratch));
1.383 load_unaligned_double(index, Interpreter::local_offset_in_bytes(1), dst);
1.384 }
1.385
1.386 @@ -2135,94 +1995,60 @@
1.387 }
1.388 #endif // ASSERT
1.389
1.390 -void InterpreterMacroAssembler::tag_local(frame::Tag t,
1.391 - Register base,
1.392 - Register src,
1.393 - int n) {
1.394 - if (TaggedStackInterpreter) {
1.395 - // have to store zero because local slots can be reused (rats!)
1.396 - if (t == frame::TagValue) {
1.397 - st_ptr(G0, base, Interpreter::local_tag_offset_in_bytes(n));
1.398 - } else if (t == frame::TagCategory2) {
1.399 - st_ptr(G0, base, Interpreter::local_tag_offset_in_bytes(n));
1.400 - st_ptr(G0, base, Interpreter::local_tag_offset_in_bytes(n+1));
1.401 - } else {
1.402 - // assert that we don't stomp the value in 'src'
1.403 - // O3 is arbitrary because it's not used.
1.404 - assert_different_registers(src, base, O3);
1.405 - mov( t, O3);
1.406 - st_ptr(O3, base, Interpreter::local_tag_offset_in_bytes(n));
1.407 - }
1.408 - }
1.409 -}
1.410 -
1.411
1.412 void InterpreterMacroAssembler::store_local_int( Register index, Register src ) {
1.413 assert_not_delayed();
1.414 - sll(index, Interpreter::logStackElementSize(), index);
1.415 + sll(index, Interpreter::logStackElementSize, index);
1.416 sub(Llocals, index, index);
1.417 - debug_only(check_for_regarea_stomp(index, Interpreter::value_offset_in_bytes(), FP, G1_scratch, G4_scratch);)
1.418 - tag_local(frame::TagValue, index, src);
1.419 - st(src, index, Interpreter::value_offset_in_bytes());
1.420 + debug_only(check_for_regarea_stomp(index, 0, FP, G1_scratch, G4_scratch);)
1.421 + st(src, index, 0);
1.422 }
1.423
1.424 -void InterpreterMacroAssembler::store_local_ptr( Register index, Register src,
1.425 - Register tag ) {
1.426 +void InterpreterMacroAssembler::store_local_ptr( Register index, Register src ) {
1.427 assert_not_delayed();
1.428 - sll(index, Interpreter::logStackElementSize(), index);
1.429 + sll(index, Interpreter::logStackElementSize, index);
1.430 sub(Llocals, index, index);
1.431 - #ifdef ASSERT
1.432 - check_for_regarea_stomp(index, Interpreter::value_offset_in_bytes(), FP, G1_scratch, G4_scratch);
1.433 - #endif
1.434 - st_ptr(src, index, Interpreter::value_offset_in_bytes());
1.435 - // Store tag register directly
1.436 - if (TaggedStackInterpreter) {
1.437 - st_ptr(tag, index, Interpreter::tag_offset_in_bytes());
1.438 - }
1.439 +#ifdef ASSERT
1.440 + check_for_regarea_stomp(index, 0, FP, G1_scratch, G4_scratch);
1.441 +#endif
1.442 + st_ptr(src, index, 0);
1.443 }
1.444
1.445
1.446
1.447 -void InterpreterMacroAssembler::store_local_ptr( int n, Register src,
1.448 - Register tag ) {
1.449 - st_ptr(src, Llocals, Interpreter::local_offset_in_bytes(n));
1.450 - if (TaggedStackInterpreter) {
1.451 - st_ptr(tag, Llocals, Interpreter::local_tag_offset_in_bytes(n));
1.452 - }
1.453 +void InterpreterMacroAssembler::store_local_ptr( int n, Register src ) {
1.454 + st_ptr(src, Llocals, Interpreter::local_offset_in_bytes(n));
1.455 }
1.456
1.457 void InterpreterMacroAssembler::store_local_long( Register index, Register src ) {
1.458 assert_not_delayed();
1.459 - sll(index, Interpreter::logStackElementSize(), index);
1.460 + sll(index, Interpreter::logStackElementSize, index);
1.461 sub(Llocals, index, index);
1.462 - #ifdef ASSERT
1.463 +#ifdef ASSERT
1.464 check_for_regarea_stomp(index, Interpreter::local_offset_in_bytes(1), FP, G1_scratch, G4_scratch);
1.465 - #endif
1.466 - tag_local(frame::TagCategory2, index, src);
1.467 +#endif
1.468 store_unaligned_long(src, index, Interpreter::local_offset_in_bytes(1)); // which is n+1
1.469 }
1.470
1.471
1.472 void InterpreterMacroAssembler::store_local_float( Register index, FloatRegister src ) {
1.473 assert_not_delayed();
1.474 - sll(index, Interpreter::logStackElementSize(), index);
1.475 + sll(index, Interpreter::logStackElementSize, index);
1.476 sub(Llocals, index, index);
1.477 - #ifdef ASSERT
1.478 - check_for_regarea_stomp(index, Interpreter::value_offset_in_bytes(), FP, G1_scratch, G4_scratch);
1.479 - #endif
1.480 - tag_local(frame::TagValue, index, G1_scratch);
1.481 - stf(FloatRegisterImpl::S, src, index, Interpreter::value_offset_in_bytes());
1.482 +#ifdef ASSERT
1.483 + check_for_regarea_stomp(index, 0, FP, G1_scratch, G4_scratch);
1.484 +#endif
1.485 + stf(FloatRegisterImpl::S, src, index, 0);
1.486 }
1.487
1.488
1.489 void InterpreterMacroAssembler::store_local_double( Register index, FloatRegister src ) {
1.490 assert_not_delayed();
1.491 - sll(index, Interpreter::logStackElementSize(), index);
1.492 + sll(index, Interpreter::logStackElementSize, index);
1.493 sub(Llocals, index, index);
1.494 - #ifdef ASSERT
1.495 +#ifdef ASSERT
1.496 check_for_regarea_stomp(index, Interpreter::local_offset_in_bytes(1), FP, G1_scratch, G4_scratch);
1.497 - #endif
1.498 - tag_local(frame::TagCategory2, index, G1_scratch);
1.499 +#endif
1.500 store_unaligned_double(src, index, Interpreter::local_offset_in_bytes(1));
1.501 }
1.502
