Print this page
rev 2162 : [mq]: code-review-comments-vladimir
| Split |
Close |
| Expand all |
| Collapse all |
--- old/src/cpu/x86/vm/templateTable_x86_64.cpp
+++ new/src/cpu/x86/vm/templateTable_x86_64.cpp
1 1 /*
2 2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
3 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 4 *
5 5 * This code is free software; you can redistribute it and/or modify it
6 6 * under the terms of the GNU General Public License version 2 only, as
7 7 * published by the Free Software Foundation.
8 8 *
9 9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 12 * version 2 for more details (a copy is included in the LICENSE file that
13 13 * accompanied this code).
14 14 *
15 15 * You should have received a copy of the GNU General Public License version
16 16 * 2 along with this work; if not, write to the Free Software Foundation,
17 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 18 *
19 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 20 * or visit www.oracle.com if you need additional information or have any
21 21 * questions.
22 22 *
23 23 */
24 24
25 25 #include "precompiled.hpp"
26 26 #include "interpreter/interpreter.hpp"
27 27 #include "interpreter/interpreterRuntime.hpp"
28 28 #include "interpreter/templateTable.hpp"
29 29 #include "memory/universe.inline.hpp"
30 30 #include "oops/methodDataOop.hpp"
31 31 #include "oops/objArrayKlass.hpp"
32 32 #include "oops/oop.inline.hpp"
33 33 #include "prims/methodHandles.hpp"
34 34 #include "runtime/sharedRuntime.hpp"
35 35 #include "runtime/stubRoutines.hpp"
36 36 #include "runtime/synchronizer.hpp"
37 37
38 38 #ifndef CC_INTERP
39 39
40 40 #define __ _masm->
41 41
42 42 // Platform-dependent initialization
43 43
44 44 void TemplateTable::pd_initialize() {
45 45 // No amd64 specific initialization
46 46 }
47 47
48 48 // Address computation: local variables
49 49
50 50 static inline Address iaddress(int n) {
51 51 return Address(r14, Interpreter::local_offset_in_bytes(n));
52 52 }
53 53
54 54 static inline Address laddress(int n) {
55 55 return iaddress(n + 1);
56 56 }
57 57
58 58 static inline Address faddress(int n) {
59 59 return iaddress(n);
60 60 }
61 61
62 62 static inline Address daddress(int n) {
63 63 return laddress(n);
64 64 }
65 65
66 66 static inline Address aaddress(int n) {
67 67 return iaddress(n);
68 68 }
69 69
70 70 static inline Address iaddress(Register r) {
71 71 return Address(r14, r, Address::times_8);
72 72 }
73 73
74 74 static inline Address laddress(Register r) {
75 75 return Address(r14, r, Address::times_8, Interpreter::local_offset_in_bytes(1));
76 76 }
77 77
78 78 static inline Address faddress(Register r) {
79 79 return iaddress(r);
80 80 }
81 81
82 82 static inline Address daddress(Register r) {
83 83 return laddress(r);
84 84 }
85 85
86 86 static inline Address aaddress(Register r) {
87 87 return iaddress(r);
88 88 }
89 89
90 90 static inline Address at_rsp() {
91 91 return Address(rsp, 0);
92 92 }
93 93
94 94 // At top of Java expression stack which may be different than esp(). It
95 95 // isn't for category 1 objects.
96 96 static inline Address at_tos () {
97 97 return Address(rsp, Interpreter::expr_offset_in_bytes(0));
98 98 }
99 99
100 100 static inline Address at_tos_p1() {
101 101 return Address(rsp, Interpreter::expr_offset_in_bytes(1));
102 102 }
103 103
104 104 static inline Address at_tos_p2() {
105 105 return Address(rsp, Interpreter::expr_offset_in_bytes(2));
106 106 }
107 107
108 108 static inline Address at_tos_p3() {
109 109 return Address(rsp, Interpreter::expr_offset_in_bytes(3));
110 110 }
111 111
112 112 // Condition conversion
113 113 static Assembler::Condition j_not(TemplateTable::Condition cc) {
114 114 switch (cc) {
115 115 case TemplateTable::equal : return Assembler::notEqual;
116 116 case TemplateTable::not_equal : return Assembler::equal;
117 117 case TemplateTable::less : return Assembler::greaterEqual;
118 118 case TemplateTable::less_equal : return Assembler::greater;
119 119 case TemplateTable::greater : return Assembler::lessEqual;
120 120 case TemplateTable::greater_equal: return Assembler::less;
121 121 }
122 122 ShouldNotReachHere();
123 123 return Assembler::zero;
124 124 }
125 125
126 126
127 127 // Miscelaneous helper routines
128 128 // Store an oop (or NULL) at the address described by obj.
129 129 // If val == noreg this means store a NULL
130 130
131 131 static void do_oop_store(InterpreterMacroAssembler* _masm,
132 132 Address obj,
133 133 Register val,
134 134 BarrierSet::Name barrier,
135 135 bool precise) {
136 136 assert(val == noreg || val == rax, "parameter is just for looks");
137 137 switch (barrier) {
138 138 #ifndef SERIALGC
139 139 case BarrierSet::G1SATBCT:
|
↓ open down ↓ |
139 lines elided |
↑ open up ↑ |
140 140 case BarrierSet::G1SATBCTLogging:
141 141 {
142 142 // flatten object address if needed
143 143 if (obj.index() == noreg && obj.disp() == 0) {
144 144 if (obj.base() != rdx) {
145 145 __ movq(rdx, obj.base());
146 146 }
147 147 } else {
148 148 __ leaq(rdx, obj);
149 149 }
150 - __ g1_write_barrier_pre(rdx, r8, rbx, val != noreg);
150 + __ g1_write_barrier_pre(rdx /* obj */,
151 + rbx /* pre_val */,
152 + r15_thread /* thread */,
153 + r8 /* tmp */,
154 + val != noreg /* tosca_live */,
155 + false /* expand_call */);
151 156 if (val == noreg) {
152 157 __ store_heap_oop_null(Address(rdx, 0));
153 158 } else {
154 159 __ store_heap_oop(Address(rdx, 0), val);
155 - __ g1_write_barrier_post(rdx, val, r8, rbx);
160 + __ g1_write_barrier_post(rdx /* store_adr */,
161 + val /* new_val */,
162 + r15_thread /* thread */,
163 + r8 /* tmp */,
164 + rbx /* tmp2 */);
156 165 }
157 166
158 167 }
159 168 break;
160 169 #endif // SERIALGC
161 170 case BarrierSet::CardTableModRef:
162 171 case BarrierSet::CardTableExtension:
163 172 {
164 173 if (val == noreg) {
165 174 __ store_heap_oop_null(obj);
166 175 } else {
167 176 __ store_heap_oop(obj, val);
168 177 // flatten object address if needed
169 178 if (!precise || (obj.index() == noreg && obj.disp() == 0)) {
170 179 __ store_check(obj.base());
171 180 } else {
172 181 __ leaq(rdx, obj);
173 182 __ store_check(rdx);
174 183 }
175 184 }
176 185 }
177 186 break;
178 187 case BarrierSet::ModRef:
179 188 case BarrierSet::Other:
180 189 if (val == noreg) {
181 190 __ store_heap_oop_null(obj);
182 191 } else {
183 192 __ store_heap_oop(obj, val);
184 193 }
185 194 break;
186 195 default :
187 196 ShouldNotReachHere();
188 197
189 198 }
190 199 }
191 200
192 201 Address TemplateTable::at_bcp(int offset) {
193 202 assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
194 203 return Address(r13, offset);
195 204 }
196 205
197 206 void TemplateTable::patch_bytecode(Bytecodes::Code bytecode, Register bc,
198 207 Register scratch,
199 208 bool load_bc_into_scratch/*=true*/) {
200 209 if (!RewriteBytecodes) {
201 210 return;
202 211 }
203 212 // the pair bytecodes have already done the load.
204 213 if (load_bc_into_scratch) {
205 214 __ movl(bc, bytecode);
206 215 }
207 216 Label patch_done;
208 217 if (JvmtiExport::can_post_breakpoint()) {
209 218 Label fast_patch;
210 219 // if a breakpoint is present we can't rewrite the stream directly
211 220 __ movzbl(scratch, at_bcp(0));
212 221 __ cmpl(scratch, Bytecodes::_breakpoint);
213 222 __ jcc(Assembler::notEqual, fast_patch);
214 223 __ get_method(scratch);
215 224 // Let breakpoint table handling rewrite to quicker bytecode
216 225 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), scratch, r13, bc);
217 226 #ifndef ASSERT
218 227 __ jmpb(patch_done);
219 228 #else
220 229 __ jmp(patch_done);
221 230 #endif
222 231 __ bind(fast_patch);
223 232 }
224 233 #ifdef ASSERT
225 234 Label okay;
226 235 __ load_unsigned_byte(scratch, at_bcp(0));
227 236 __ cmpl(scratch, (int) Bytecodes::java_code(bytecode));
228 237 __ jcc(Assembler::equal, okay);
229 238 __ cmpl(scratch, bc);
230 239 __ jcc(Assembler::equal, okay);
231 240 __ stop("patching the wrong bytecode");
232 241 __ bind(okay);
233 242 #endif
234 243 // patch bytecode
235 244 __ movb(at_bcp(0), bc);
236 245 __ bind(patch_done);
237 246 }
238 247
239 248
240 249 // Individual instructions
241 250
242 251 void TemplateTable::nop() {
243 252 transition(vtos, vtos);
244 253 // nothing to do
245 254 }
246 255
247 256 void TemplateTable::shouldnotreachhere() {
248 257 transition(vtos, vtos);
249 258 __ stop("shouldnotreachhere bytecode");
250 259 }
251 260
252 261 void TemplateTable::aconst_null() {
253 262 transition(vtos, atos);
254 263 __ xorl(rax, rax);
255 264 }
256 265
257 266 void TemplateTable::iconst(int value) {
258 267 transition(vtos, itos);
259 268 if (value == 0) {
260 269 __ xorl(rax, rax);
261 270 } else {
262 271 __ movl(rax, value);
263 272 }
264 273 }
265 274
266 275 void TemplateTable::lconst(int value) {
267 276 transition(vtos, ltos);
268 277 if (value == 0) {
269 278 __ xorl(rax, rax);
270 279 } else {
271 280 __ movl(rax, value);
272 281 }
273 282 }
274 283
275 284 void TemplateTable::fconst(int value) {
276 285 transition(vtos, ftos);
277 286 static float one = 1.0f, two = 2.0f;
278 287 switch (value) {
279 288 case 0:
280 289 __ xorps(xmm0, xmm0);
281 290 break;
282 291 case 1:
283 292 __ movflt(xmm0, ExternalAddress((address) &one));
284 293 break;
285 294 case 2:
286 295 __ movflt(xmm0, ExternalAddress((address) &two));
287 296 break;
288 297 default:
289 298 ShouldNotReachHere();
290 299 break;
291 300 }
292 301 }
293 302
294 303 void TemplateTable::dconst(int value) {
295 304 transition(vtos, dtos);
296 305 static double one = 1.0;
297 306 switch (value) {
298 307 case 0:
299 308 __ xorpd(xmm0, xmm0);
300 309 break;
301 310 case 1:
302 311 __ movdbl(xmm0, ExternalAddress((address) &one));
303 312 break;
304 313 default:
305 314 ShouldNotReachHere();
306 315 break;
307 316 }
308 317 }
309 318
310 319 void TemplateTable::bipush() {
311 320 transition(vtos, itos);
312 321 __ load_signed_byte(rax, at_bcp(1));
313 322 }
314 323
315 324 void TemplateTable::sipush() {
316 325 transition(vtos, itos);
317 326 __ load_unsigned_short(rax, at_bcp(1));
318 327 __ bswapl(rax);
319 328 __ sarl(rax, 16);
320 329 }
321 330
322 331 void TemplateTable::ldc(bool wide) {
323 332 transition(vtos, vtos);
324 333 Label call_ldc, notFloat, notClass, Done;
325 334
326 335 if (wide) {
327 336 __ get_unsigned_2_byte_index_at_bcp(rbx, 1);
328 337 } else {
329 338 __ load_unsigned_byte(rbx, at_bcp(1));
330 339 }
331 340
332 341 __ get_cpool_and_tags(rcx, rax);
333 342 const int base_offset = constantPoolOopDesc::header_size() * wordSize;
334 343 const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
335 344
336 345 // get type
337 346 __ movzbl(rdx, Address(rax, rbx, Address::times_1, tags_offset));
338 347
339 348 // unresolved string - get the resolved string
340 349 __ cmpl(rdx, JVM_CONSTANT_UnresolvedString);
341 350 __ jccb(Assembler::equal, call_ldc);
342 351
343 352 // unresolved class - get the resolved class
344 353 __ cmpl(rdx, JVM_CONSTANT_UnresolvedClass);
345 354 __ jccb(Assembler::equal, call_ldc);
346 355
347 356 // unresolved class in error state - call into runtime to throw the error
348 357 // from the first resolution attempt
349 358 __ cmpl(rdx, JVM_CONSTANT_UnresolvedClassInError);
350 359 __ jccb(Assembler::equal, call_ldc);
351 360
352 361 // resolved class - need to call vm to get java mirror of the class
353 362 __ cmpl(rdx, JVM_CONSTANT_Class);
354 363 __ jcc(Assembler::notEqual, notClass);
355 364
356 365 __ bind(call_ldc);
357 366 __ movl(c_rarg1, wide);
358 367 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);
359 368 __ push_ptr(rax);
360 369 __ verify_oop(rax);
361 370 __ jmp(Done);
362 371
363 372 __ bind(notClass);
364 373 __ cmpl(rdx, JVM_CONSTANT_Float);
365 374 __ jccb(Assembler::notEqual, notFloat);
366 375 // ftos
367 376 __ movflt(xmm0, Address(rcx, rbx, Address::times_8, base_offset));
368 377 __ push_f();
369 378 __ jmp(Done);
370 379
371 380 __ bind(notFloat);
372 381 #ifdef ASSERT
373 382 {
374 383 Label L;
375 384 __ cmpl(rdx, JVM_CONSTANT_Integer);
376 385 __ jcc(Assembler::equal, L);
377 386 __ cmpl(rdx, JVM_CONSTANT_String);
378 387 __ jcc(Assembler::equal, L);
379 388 __ stop("unexpected tag type in ldc");
380 389 __ bind(L);
381 390 }
382 391 #endif
383 392 // atos and itos
384 393 Label isOop;
385 394 __ cmpl(rdx, JVM_CONSTANT_Integer);
386 395 __ jcc(Assembler::notEqual, isOop);
387 396 __ movl(rax, Address(rcx, rbx, Address::times_8, base_offset));
388 397 __ push_i(rax);
389 398 __ jmp(Done);
390 399
391 400 __ bind(isOop);
392 401 __ movptr(rax, Address(rcx, rbx, Address::times_8, base_offset));
393 402 __ push_ptr(rax);
394 403
395 404 if (VerifyOops) {
396 405 __ verify_oop(rax);
397 406 }
398 407
399 408 __ bind(Done);
400 409 }
401 410
402 411 // Fast path for caching oop constants.
403 412 // %%% We should use this to handle Class and String constants also.
404 413 // %%% It will simplify the ldc/primitive path considerably.
405 414 void TemplateTable::fast_aldc(bool wide) {
406 415 transition(vtos, atos);
407 416
408 417 if (!EnableMethodHandles) {
409 418 // We should not encounter this bytecode if !EnableMethodHandles.
410 419 // The verifier will stop it. However, if we get past the verifier,
411 420 // this will stop the thread in a reasonable way, without crashing the JVM.
412 421 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
413 422 InterpreterRuntime::throw_IncompatibleClassChangeError));
414 423 // the call_VM checks for exception, so we should never return here.
415 424 __ should_not_reach_here();
416 425 return;
417 426 }
418 427
419 428 const Register cache = rcx;
420 429 const Register index = rdx;
421 430
422 431 resolve_cache_and_index(f1_oop, rax, cache, index, wide ? sizeof(u2) : sizeof(u1));
423 432 if (VerifyOops) {
424 433 __ verify_oop(rax);
425 434 }
426 435
427 436 Label L_done, L_throw_exception;
428 437 const Register con_klass_temp = rcx; // same as cache
429 438 const Register array_klass_temp = rdx; // same as index
430 439 __ movptr(con_klass_temp, Address(rax, oopDesc::klass_offset_in_bytes()));
431 440 __ lea(array_klass_temp, ExternalAddress((address)Universe::systemObjArrayKlassObj_addr()));
432 441 __ cmpptr(con_klass_temp, Address(array_klass_temp, 0));
433 442 __ jcc(Assembler::notEqual, L_done);
434 443 __ cmpl(Address(rax, arrayOopDesc::length_offset_in_bytes()), 0);
435 444 __ jcc(Assembler::notEqual, L_throw_exception);
436 445 __ xorptr(rax, rax);
437 446 __ jmp(L_done);
438 447
439 448 // Load the exception from the system-array which wraps it:
440 449 __ bind(L_throw_exception);
441 450 __ movptr(rax, Address(rax, arrayOopDesc::base_offset_in_bytes(T_OBJECT)));
442 451 __ jump(ExternalAddress(Interpreter::throw_exception_entry()));
443 452
444 453 __ bind(L_done);
445 454 }
446 455
447 456 void TemplateTable::ldc2_w() {
448 457 transition(vtos, vtos);
449 458 Label Long, Done;
450 459 __ get_unsigned_2_byte_index_at_bcp(rbx, 1);
451 460
452 461 __ get_cpool_and_tags(rcx, rax);
453 462 const int base_offset = constantPoolOopDesc::header_size() * wordSize;
454 463 const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
455 464
456 465 // get type
457 466 __ cmpb(Address(rax, rbx, Address::times_1, tags_offset),
458 467 JVM_CONSTANT_Double);
459 468 __ jccb(Assembler::notEqual, Long);
460 469 // dtos
461 470 __ movdbl(xmm0, Address(rcx, rbx, Address::times_8, base_offset));
462 471 __ push_d();
463 472 __ jmpb(Done);
464 473
465 474 __ bind(Long);
466 475 // ltos
467 476 __ movq(rax, Address(rcx, rbx, Address::times_8, base_offset));
468 477 __ push_l();
469 478
470 479 __ bind(Done);
471 480 }
472 481
473 482 void TemplateTable::locals_index(Register reg, int offset) {
474 483 __ load_unsigned_byte(reg, at_bcp(offset));
475 484 __ negptr(reg);
476 485 }
477 486
478 487 void TemplateTable::iload() {
479 488 transition(vtos, itos);
480 489 if (RewriteFrequentPairs) {
481 490 Label rewrite, done;
482 491 const Register bc = c_rarg3;
483 492 assert(rbx != bc, "register damaged");
484 493
485 494 // get next byte
486 495 __ load_unsigned_byte(rbx,
487 496 at_bcp(Bytecodes::length_for(Bytecodes::_iload)));
488 497 // if _iload, wait to rewrite to iload2. We only want to rewrite the
489 498 // last two iloads in a pair. Comparing against fast_iload means that
490 499 // the next bytecode is neither an iload or a caload, and therefore
491 500 // an iload pair.
492 501 __ cmpl(rbx, Bytecodes::_iload);
493 502 __ jcc(Assembler::equal, done);
494 503
495 504 __ cmpl(rbx, Bytecodes::_fast_iload);
496 505 __ movl(bc, Bytecodes::_fast_iload2);
497 506 __ jccb(Assembler::equal, rewrite);
498 507
499 508 // if _caload, rewrite to fast_icaload
500 509 __ cmpl(rbx, Bytecodes::_caload);
501 510 __ movl(bc, Bytecodes::_fast_icaload);
502 511 __ jccb(Assembler::equal, rewrite);
503 512
504 513 // rewrite so iload doesn't check again.
505 514 __ movl(bc, Bytecodes::_fast_iload);
506 515
507 516 // rewrite
508 517 // bc: fast bytecode
509 518 __ bind(rewrite);
510 519 patch_bytecode(Bytecodes::_iload, bc, rbx, false);
511 520 __ bind(done);
512 521 }
513 522
514 523 // Get the local value into tos
515 524 locals_index(rbx);
516 525 __ movl(rax, iaddress(rbx));
517 526 }
518 527
519 528 void TemplateTable::fast_iload2() {
520 529 transition(vtos, itos);
521 530 locals_index(rbx);
522 531 __ movl(rax, iaddress(rbx));
523 532 __ push(itos);
524 533 locals_index(rbx, 3);
525 534 __ movl(rax, iaddress(rbx));
526 535 }
527 536
528 537 void TemplateTable::fast_iload() {
529 538 transition(vtos, itos);
530 539 locals_index(rbx);
531 540 __ movl(rax, iaddress(rbx));
532 541 }
533 542
534 543 void TemplateTable::lload() {
535 544 transition(vtos, ltos);
536 545 locals_index(rbx);
537 546 __ movq(rax, laddress(rbx));
538 547 }
539 548
540 549 void TemplateTable::fload() {
541 550 transition(vtos, ftos);
542 551 locals_index(rbx);
543 552 __ movflt(xmm0, faddress(rbx));
544 553 }
545 554
546 555 void TemplateTable::dload() {
547 556 transition(vtos, dtos);
548 557 locals_index(rbx);
549 558 __ movdbl(xmm0, daddress(rbx));
550 559 }
551 560
552 561 void TemplateTable::aload() {
553 562 transition(vtos, atos);
554 563 locals_index(rbx);
555 564 __ movptr(rax, aaddress(rbx));
556 565 }
557 566
558 567 void TemplateTable::locals_index_wide(Register reg) {
559 568 __ movl(reg, at_bcp(2));
560 569 __ bswapl(reg);
561 570 __ shrl(reg, 16);
562 571 __ negptr(reg);
563 572 }
564 573
565 574 void TemplateTable::wide_iload() {
566 575 transition(vtos, itos);
567 576 locals_index_wide(rbx);
568 577 __ movl(rax, iaddress(rbx));
569 578 }
570 579
571 580 void TemplateTable::wide_lload() {
572 581 transition(vtos, ltos);
573 582 locals_index_wide(rbx);
574 583 __ movq(rax, laddress(rbx));
575 584 }
576 585
577 586 void TemplateTable::wide_fload() {
578 587 transition(vtos, ftos);
579 588 locals_index_wide(rbx);
580 589 __ movflt(xmm0, faddress(rbx));
581 590 }
582 591
583 592 void TemplateTable::wide_dload() {
584 593 transition(vtos, dtos);
585 594 locals_index_wide(rbx);
586 595 __ movdbl(xmm0, daddress(rbx));
587 596 }
588 597
589 598 void TemplateTable::wide_aload() {
590 599 transition(vtos, atos);
591 600 locals_index_wide(rbx);
592 601 __ movptr(rax, aaddress(rbx));
593 602 }
594 603
595 604 void TemplateTable::index_check(Register array, Register index) {
596 605 // destroys rbx
597 606 // check array
598 607 __ null_check(array, arrayOopDesc::length_offset_in_bytes());
599 608 // sign extend index for use by indexed load
600 609 __ movl2ptr(index, index);
601 610 // check index
602 611 __ cmpl(index, Address(array, arrayOopDesc::length_offset_in_bytes()));
603 612 if (index != rbx) {
604 613 // ??? convention: move aberrant index into ebx for exception message
605 614 assert(rbx != array, "different registers");
606 615 __ movl(rbx, index);
607 616 }
608 617 __ jump_cc(Assembler::aboveEqual,
609 618 ExternalAddress(Interpreter::_throw_ArrayIndexOutOfBoundsException_entry));
610 619 }
611 620
612 621 void TemplateTable::iaload() {
613 622 transition(itos, itos);
614 623 __ pop_ptr(rdx);
615 624 // eax: index
616 625 // rdx: array
617 626 index_check(rdx, rax); // kills rbx
618 627 __ movl(rax, Address(rdx, rax,
619 628 Address::times_4,
620 629 arrayOopDesc::base_offset_in_bytes(T_INT)));
621 630 }
622 631
623 632 void TemplateTable::laload() {
624 633 transition(itos, ltos);
625 634 __ pop_ptr(rdx);
626 635 // eax: index
627 636 // rdx: array
628 637 index_check(rdx, rax); // kills rbx
629 638 __ movq(rax, Address(rdx, rbx,
630 639 Address::times_8,
631 640 arrayOopDesc::base_offset_in_bytes(T_LONG)));
632 641 }
633 642
634 643 void TemplateTable::faload() {
635 644 transition(itos, ftos);
636 645 __ pop_ptr(rdx);
637 646 // eax: index
638 647 // rdx: array
639 648 index_check(rdx, rax); // kills rbx
640 649 __ movflt(xmm0, Address(rdx, rax,
641 650 Address::times_4,
642 651 arrayOopDesc::base_offset_in_bytes(T_FLOAT)));
643 652 }
644 653
645 654 void TemplateTable::daload() {
646 655 transition(itos, dtos);
647 656 __ pop_ptr(rdx);
648 657 // eax: index
649 658 // rdx: array
650 659 index_check(rdx, rax); // kills rbx
651 660 __ movdbl(xmm0, Address(rdx, rax,
652 661 Address::times_8,
653 662 arrayOopDesc::base_offset_in_bytes(T_DOUBLE)));
654 663 }
655 664
656 665 void TemplateTable::aaload() {
657 666 transition(itos, atos);
658 667 __ pop_ptr(rdx);
659 668 // eax: index
660 669 // rdx: array
661 670 index_check(rdx, rax); // kills rbx
662 671 __ load_heap_oop(rax, Address(rdx, rax,
663 672 UseCompressedOops ? Address::times_4 : Address::times_8,
664 673 arrayOopDesc::base_offset_in_bytes(T_OBJECT)));
665 674 }
666 675
667 676 void TemplateTable::baload() {
668 677 transition(itos, itos);
669 678 __ pop_ptr(rdx);
670 679 // eax: index
671 680 // rdx: array
672 681 index_check(rdx, rax); // kills rbx
673 682 __ load_signed_byte(rax,
674 683 Address(rdx, rax,
675 684 Address::times_1,
676 685 arrayOopDesc::base_offset_in_bytes(T_BYTE)));
677 686 }
678 687
679 688 void TemplateTable::caload() {
680 689 transition(itos, itos);
681 690 __ pop_ptr(rdx);
682 691 // eax: index
683 692 // rdx: array
684 693 index_check(rdx, rax); // kills rbx
685 694 __ load_unsigned_short(rax,
686 695 Address(rdx, rax,
687 696 Address::times_2,
688 697 arrayOopDesc::base_offset_in_bytes(T_CHAR)));
689 698 }
690 699
691 700 // iload followed by caload frequent pair
692 701 void TemplateTable::fast_icaload() {
693 702 transition(vtos, itos);
694 703 // load index out of locals
695 704 locals_index(rbx);
696 705 __ movl(rax, iaddress(rbx));
697 706
698 707 // eax: index
699 708 // rdx: array
700 709 __ pop_ptr(rdx);
701 710 index_check(rdx, rax); // kills rbx
702 711 __ load_unsigned_short(rax,
703 712 Address(rdx, rax,
704 713 Address::times_2,
705 714 arrayOopDesc::base_offset_in_bytes(T_CHAR)));
706 715 }
707 716
708 717 void TemplateTable::saload() {
709 718 transition(itos, itos);
710 719 __ pop_ptr(rdx);
711 720 // eax: index
712 721 // rdx: array
713 722 index_check(rdx, rax); // kills rbx
714 723 __ load_signed_short(rax,
715 724 Address(rdx, rax,
716 725 Address::times_2,
717 726 arrayOopDesc::base_offset_in_bytes(T_SHORT)));
718 727 }
719 728
720 729 void TemplateTable::iload(int n) {
721 730 transition(vtos, itos);
722 731 __ movl(rax, iaddress(n));
723 732 }
724 733
725 734 void TemplateTable::lload(int n) {
726 735 transition(vtos, ltos);
727 736 __ movq(rax, laddress(n));
728 737 }
729 738
730 739 void TemplateTable::fload(int n) {
731 740 transition(vtos, ftos);
732 741 __ movflt(xmm0, faddress(n));
733 742 }
734 743
735 744 void TemplateTable::dload(int n) {
736 745 transition(vtos, dtos);
737 746 __ movdbl(xmm0, daddress(n));
738 747 }
739 748
740 749 void TemplateTable::aload(int n) {
741 750 transition(vtos, atos);
742 751 __ movptr(rax, aaddress(n));
743 752 }
744 753
745 754 void TemplateTable::aload_0() {
746 755 transition(vtos, atos);
747 756 // According to bytecode histograms, the pairs:
748 757 //
749 758 // _aload_0, _fast_igetfield
750 759 // _aload_0, _fast_agetfield
751 760 // _aload_0, _fast_fgetfield
752 761 //
753 762 // occur frequently. If RewriteFrequentPairs is set, the (slow)
754 763 // _aload_0 bytecode checks if the next bytecode is either
755 764 // _fast_igetfield, _fast_agetfield or _fast_fgetfield and then
756 765 // rewrites the current bytecode into a pair bytecode; otherwise it
757 766 // rewrites the current bytecode into _fast_aload_0 that doesn't do
758 767 // the pair check anymore.
759 768 //
760 769 // Note: If the next bytecode is _getfield, the rewrite must be
761 770 // delayed, otherwise we may miss an opportunity for a pair.
762 771 //
763 772 // Also rewrite frequent pairs
764 773 // aload_0, aload_1
765 774 // aload_0, iload_1
766 775 // These bytecodes with a small amount of code are most profitable
767 776 // to rewrite
768 777 if (RewriteFrequentPairs) {
769 778 Label rewrite, done;
770 779 const Register bc = c_rarg3;
771 780 assert(rbx != bc, "register damaged");
772 781 // get next byte
773 782 __ load_unsigned_byte(rbx,
774 783 at_bcp(Bytecodes::length_for(Bytecodes::_aload_0)));
775 784
776 785 // do actual aload_0
777 786 aload(0);
778 787
779 788 // if _getfield then wait with rewrite
780 789 __ cmpl(rbx, Bytecodes::_getfield);
781 790 __ jcc(Assembler::equal, done);
782 791
783 792 // if _igetfield then reqrite to _fast_iaccess_0
784 793 assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) ==
785 794 Bytecodes::_aload_0,
786 795 "fix bytecode definition");
787 796 __ cmpl(rbx, Bytecodes::_fast_igetfield);
788 797 __ movl(bc, Bytecodes::_fast_iaccess_0);
789 798 __ jccb(Assembler::equal, rewrite);
790 799
791 800 // if _agetfield then reqrite to _fast_aaccess_0
792 801 assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) ==
793 802 Bytecodes::_aload_0,
794 803 "fix bytecode definition");
795 804 __ cmpl(rbx, Bytecodes::_fast_agetfield);
796 805 __ movl(bc, Bytecodes::_fast_aaccess_0);
797 806 __ jccb(Assembler::equal, rewrite);
798 807
799 808 // if _fgetfield then reqrite to _fast_faccess_0
800 809 assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) ==
801 810 Bytecodes::_aload_0,
802 811 "fix bytecode definition");
803 812 __ cmpl(rbx, Bytecodes::_fast_fgetfield);
804 813 __ movl(bc, Bytecodes::_fast_faccess_0);
805 814 __ jccb(Assembler::equal, rewrite);
806 815
807 816 // else rewrite to _fast_aload0
808 817 assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) ==
809 818 Bytecodes::_aload_0,
810 819 "fix bytecode definition");
811 820 __ movl(bc, Bytecodes::_fast_aload_0);
812 821
813 822 // rewrite
814 823 // bc: fast bytecode
815 824 __ bind(rewrite);
816 825 patch_bytecode(Bytecodes::_aload_0, bc, rbx, false);
817 826
818 827 __ bind(done);
819 828 } else {
820 829 aload(0);
821 830 }
822 831 }
823 832
824 833 void TemplateTable::istore() {
825 834 transition(itos, vtos);
826 835 locals_index(rbx);
827 836 __ movl(iaddress(rbx), rax);
828 837 }
829 838
830 839 void TemplateTable::lstore() {
831 840 transition(ltos, vtos);
832 841 locals_index(rbx);
833 842 __ movq(laddress(rbx), rax);
834 843 }
835 844
836 845 void TemplateTable::fstore() {
837 846 transition(ftos, vtos);
838 847 locals_index(rbx);
839 848 __ movflt(faddress(rbx), xmm0);
840 849 }
841 850
842 851 void TemplateTable::dstore() {
843 852 transition(dtos, vtos);
844 853 locals_index(rbx);
845 854 __ movdbl(daddress(rbx), xmm0);
846 855 }
847 856
848 857 void TemplateTable::astore() {
849 858 transition(vtos, vtos);
850 859 __ pop_ptr(rax);
851 860 locals_index(rbx);
852 861 __ movptr(aaddress(rbx), rax);
853 862 }
854 863
855 864 void TemplateTable::wide_istore() {
856 865 transition(vtos, vtos);
857 866 __ pop_i();
858 867 locals_index_wide(rbx);
859 868 __ movl(iaddress(rbx), rax);
860 869 }
861 870
862 871 void TemplateTable::wide_lstore() {
863 872 transition(vtos, vtos);
864 873 __ pop_l();
865 874 locals_index_wide(rbx);
866 875 __ movq(laddress(rbx), rax);
867 876 }
868 877
869 878 void TemplateTable::wide_fstore() {
870 879 transition(vtos, vtos);
871 880 __ pop_f();
872 881 locals_index_wide(rbx);
873 882 __ movflt(faddress(rbx), xmm0);
874 883 }
875 884
876 885 void TemplateTable::wide_dstore() {
877 886 transition(vtos, vtos);
878 887 __ pop_d();
879 888 locals_index_wide(rbx);
880 889 __ movdbl(daddress(rbx), xmm0);
881 890 }
882 891
883 892 void TemplateTable::wide_astore() {
884 893 transition(vtos, vtos);
885 894 __ pop_ptr(rax);
886 895 locals_index_wide(rbx);
887 896 __ movptr(aaddress(rbx), rax);
888 897 }
889 898
890 899 void TemplateTable::iastore() {
891 900 transition(itos, vtos);
892 901 __ pop_i(rbx);
893 902 __ pop_ptr(rdx);
894 903 // eax: value
895 904 // ebx: index
896 905 // rdx: array
897 906 index_check(rdx, rbx); // prefer index in ebx
898 907 __ movl(Address(rdx, rbx,
899 908 Address::times_4,
900 909 arrayOopDesc::base_offset_in_bytes(T_INT)),
901 910 rax);
902 911 }
903 912
904 913 void TemplateTable::lastore() {
905 914 transition(ltos, vtos);
906 915 __ pop_i(rbx);
907 916 __ pop_ptr(rdx);
908 917 // rax: value
909 918 // ebx: index
910 919 // rdx: array
911 920 index_check(rdx, rbx); // prefer index in ebx
912 921 __ movq(Address(rdx, rbx,
913 922 Address::times_8,
914 923 arrayOopDesc::base_offset_in_bytes(T_LONG)),
915 924 rax);
916 925 }
917 926
918 927 void TemplateTable::fastore() {
919 928 transition(ftos, vtos);
920 929 __ pop_i(rbx);
921 930 __ pop_ptr(rdx);
922 931 // xmm0: value
923 932 // ebx: index
924 933 // rdx: array
925 934 index_check(rdx, rbx); // prefer index in ebx
926 935 __ movflt(Address(rdx, rbx,
927 936 Address::times_4,
928 937 arrayOopDesc::base_offset_in_bytes(T_FLOAT)),
929 938 xmm0);
930 939 }
931 940
932 941 void TemplateTable::dastore() {
933 942 transition(dtos, vtos);
934 943 __ pop_i(rbx);
935 944 __ pop_ptr(rdx);
936 945 // xmm0: value
937 946 // ebx: index
938 947 // rdx: array
939 948 index_check(rdx, rbx); // prefer index in ebx
940 949 __ movdbl(Address(rdx, rbx,
941 950 Address::times_8,
942 951 arrayOopDesc::base_offset_in_bytes(T_DOUBLE)),
943 952 xmm0);
944 953 }
945 954
946 955 void TemplateTable::aastore() {
947 956 Label is_null, ok_is_subtype, done;
948 957 transition(vtos, vtos);
949 958 // stack: ..., array, index, value
950 959 __ movptr(rax, at_tos()); // value
951 960 __ movl(rcx, at_tos_p1()); // index
952 961 __ movptr(rdx, at_tos_p2()); // array
953 962
954 963 Address element_address(rdx, rcx,
955 964 UseCompressedOops? Address::times_4 : Address::times_8,
956 965 arrayOopDesc::base_offset_in_bytes(T_OBJECT));
957 966
958 967 index_check(rdx, rcx); // kills rbx
959 968 // do array store check - check for NULL value first
960 969 __ testptr(rax, rax);
961 970 __ jcc(Assembler::zero, is_null);
962 971
963 972 // Move subklass into rbx
964 973 __ load_klass(rbx, rax);
965 974 // Move superklass into rax
966 975 __ load_klass(rax, rdx);
967 976 __ movptr(rax, Address(rax,
968 977 sizeof(oopDesc) +
969 978 objArrayKlass::element_klass_offset_in_bytes()));
970 979 // Compress array + index*oopSize + 12 into a single register. Frees rcx.
971 980 __ lea(rdx, element_address);
972 981
973 982 // Generate subtype check. Blows rcx, rdi
974 983 // Superklass in rax. Subklass in rbx.
975 984 __ gen_subtype_check(rbx, ok_is_subtype);
976 985
977 986 // Come here on failure
978 987 // object is at TOS
979 988 __ jump(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry));
980 989
981 990 // Come here on success
982 991 __ bind(ok_is_subtype);
983 992
984 993 // Get the value we will store
985 994 __ movptr(rax, at_tos());
986 995 // Now store using the appropriate barrier
987 996 do_oop_store(_masm, Address(rdx, 0), rax, _bs->kind(), true);
988 997 __ jmp(done);
989 998
990 999 // Have a NULL in rax, rdx=array, ecx=index. Store NULL at ary[idx]
991 1000 __ bind(is_null);
992 1001 __ profile_null_seen(rbx);
993 1002
994 1003 // Store a NULL
995 1004 do_oop_store(_masm, element_address, noreg, _bs->kind(), true);
996 1005
997 1006 // Pop stack arguments
998 1007 __ bind(done);
999 1008 __ addptr(rsp, 3 * Interpreter::stackElementSize);
1000 1009 }
1001 1010
1002 1011 void TemplateTable::bastore() {
1003 1012 transition(itos, vtos);
1004 1013 __ pop_i(rbx);
1005 1014 __ pop_ptr(rdx);
1006 1015 // eax: value
1007 1016 // ebx: index
1008 1017 // rdx: array
1009 1018 index_check(rdx, rbx); // prefer index in ebx
1010 1019 __ movb(Address(rdx, rbx,
1011 1020 Address::times_1,
1012 1021 arrayOopDesc::base_offset_in_bytes(T_BYTE)),
1013 1022 rax);
1014 1023 }
1015 1024
1016 1025 void TemplateTable::castore() {
1017 1026 transition(itos, vtos);
1018 1027 __ pop_i(rbx);
1019 1028 __ pop_ptr(rdx);
1020 1029 // eax: value
1021 1030 // ebx: index
1022 1031 // rdx: array
1023 1032 index_check(rdx, rbx); // prefer index in ebx
1024 1033 __ movw(Address(rdx, rbx,
1025 1034 Address::times_2,
1026 1035 arrayOopDesc::base_offset_in_bytes(T_CHAR)),
1027 1036 rax);
1028 1037 }
1029 1038
1030 1039 void TemplateTable::sastore() {
1031 1040 castore();
1032 1041 }
1033 1042
1034 1043 void TemplateTable::istore(int n) {
1035 1044 transition(itos, vtos);
1036 1045 __ movl(iaddress(n), rax);
1037 1046 }
1038 1047
1039 1048 void TemplateTable::lstore(int n) {
1040 1049 transition(ltos, vtos);
1041 1050 __ movq(laddress(n), rax);
1042 1051 }
1043 1052
1044 1053 void TemplateTable::fstore(int n) {
1045 1054 transition(ftos, vtos);
1046 1055 __ movflt(faddress(n), xmm0);
1047 1056 }
1048 1057
1049 1058 void TemplateTable::dstore(int n) {
1050 1059 transition(dtos, vtos);
1051 1060 __ movdbl(daddress(n), xmm0);
1052 1061 }
1053 1062
1054 1063 void TemplateTable::astore(int n) {
1055 1064 transition(vtos, vtos);
1056 1065 __ pop_ptr(rax);
1057 1066 __ movptr(aaddress(n), rax);
1058 1067 }
1059 1068
1060 1069 void TemplateTable::pop() {
1061 1070 transition(vtos, vtos);
1062 1071 __ addptr(rsp, Interpreter::stackElementSize);
1063 1072 }
1064 1073
1065 1074 void TemplateTable::pop2() {
1066 1075 transition(vtos, vtos);
1067 1076 __ addptr(rsp, 2 * Interpreter::stackElementSize);
1068 1077 }
1069 1078
1070 1079 void TemplateTable::dup() {
1071 1080 transition(vtos, vtos);
1072 1081 __ load_ptr(0, rax);
1073 1082 __ push_ptr(rax);
1074 1083 // stack: ..., a, a
1075 1084 }
1076 1085
1077 1086 void TemplateTable::dup_x1() {
1078 1087 transition(vtos, vtos);
1079 1088 // stack: ..., a, b
1080 1089 __ load_ptr( 0, rax); // load b
1081 1090 __ load_ptr( 1, rcx); // load a
1082 1091 __ store_ptr(1, rax); // store b
1083 1092 __ store_ptr(0, rcx); // store a
1084 1093 __ push_ptr(rax); // push b
1085 1094 // stack: ..., b, a, b
1086 1095 }
1087 1096
1088 1097 void TemplateTable::dup_x2() {
1089 1098 transition(vtos, vtos);
1090 1099 // stack: ..., a, b, c
1091 1100 __ load_ptr( 0, rax); // load c
1092 1101 __ load_ptr( 2, rcx); // load a
1093 1102 __ store_ptr(2, rax); // store c in a
1094 1103 __ push_ptr(rax); // push c
1095 1104 // stack: ..., c, b, c, c
1096 1105 __ load_ptr( 2, rax); // load b
1097 1106 __ store_ptr(2, rcx); // store a in b
1098 1107 // stack: ..., c, a, c, c
1099 1108 __ store_ptr(1, rax); // store b in c
1100 1109 // stack: ..., c, a, b, c
1101 1110 }
1102 1111
1103 1112 void TemplateTable::dup2() {
1104 1113 transition(vtos, vtos);
1105 1114 // stack: ..., a, b
1106 1115 __ load_ptr(1, rax); // load a
1107 1116 __ push_ptr(rax); // push a
1108 1117 __ load_ptr(1, rax); // load b
1109 1118 __ push_ptr(rax); // push b
1110 1119 // stack: ..., a, b, a, b
1111 1120 }
1112 1121
1113 1122 void TemplateTable::dup2_x1() {
1114 1123 transition(vtos, vtos);
1115 1124 // stack: ..., a, b, c
1116 1125 __ load_ptr( 0, rcx); // load c
1117 1126 __ load_ptr( 1, rax); // load b
1118 1127 __ push_ptr(rax); // push b
1119 1128 __ push_ptr(rcx); // push c
1120 1129 // stack: ..., a, b, c, b, c
1121 1130 __ store_ptr(3, rcx); // store c in b
1122 1131 // stack: ..., a, c, c, b, c
1123 1132 __ load_ptr( 4, rcx); // load a
1124 1133 __ store_ptr(2, rcx); // store a in 2nd c
1125 1134 // stack: ..., a, c, a, b, c
1126 1135 __ store_ptr(4, rax); // store b in a
1127 1136 // stack: ..., b, c, a, b, c
1128 1137 }
1129 1138
1130 1139 void TemplateTable::dup2_x2() {
1131 1140 transition(vtos, vtos);
1132 1141 // stack: ..., a, b, c, d
1133 1142 __ load_ptr( 0, rcx); // load d
1134 1143 __ load_ptr( 1, rax); // load c
1135 1144 __ push_ptr(rax); // push c
1136 1145 __ push_ptr(rcx); // push d
1137 1146 // stack: ..., a, b, c, d, c, d
1138 1147 __ load_ptr( 4, rax); // load b
1139 1148 __ store_ptr(2, rax); // store b in d
1140 1149 __ store_ptr(4, rcx); // store d in b
1141 1150 // stack: ..., a, d, c, b, c, d
1142 1151 __ load_ptr( 5, rcx); // load a
1143 1152 __ load_ptr( 3, rax); // load c
1144 1153 __ store_ptr(3, rcx); // store a in c
1145 1154 __ store_ptr(5, rax); // store c in a
1146 1155 // stack: ..., c, d, a, b, c, d
1147 1156 }
1148 1157
1149 1158 void TemplateTable::swap() {
1150 1159 transition(vtos, vtos);
1151 1160 // stack: ..., a, b
1152 1161 __ load_ptr( 1, rcx); // load a
1153 1162 __ load_ptr( 0, rax); // load b
1154 1163 __ store_ptr(0, rcx); // store a in b
1155 1164 __ store_ptr(1, rax); // store b in a
1156 1165 // stack: ..., b, a
1157 1166 }
1158 1167
1159 1168 void TemplateTable::iop2(Operation op) {
1160 1169 transition(itos, itos);
1161 1170 switch (op) {
1162 1171 case add : __ pop_i(rdx); __ addl (rax, rdx); break;
1163 1172 case sub : __ movl(rdx, rax); __ pop_i(rax); __ subl (rax, rdx); break;
1164 1173 case mul : __ pop_i(rdx); __ imull(rax, rdx); break;
1165 1174 case _and : __ pop_i(rdx); __ andl (rax, rdx); break;
1166 1175 case _or : __ pop_i(rdx); __ orl (rax, rdx); break;
1167 1176 case _xor : __ pop_i(rdx); __ xorl (rax, rdx); break;
1168 1177 case shl : __ movl(rcx, rax); __ pop_i(rax); __ shll (rax); break;
1169 1178 case shr : __ movl(rcx, rax); __ pop_i(rax); __ sarl (rax); break;
1170 1179 case ushr : __ movl(rcx, rax); __ pop_i(rax); __ shrl (rax); break;
1171 1180 default : ShouldNotReachHere();
1172 1181 }
1173 1182 }
1174 1183
1175 1184 void TemplateTable::lop2(Operation op) {
1176 1185 transition(ltos, ltos);
1177 1186 switch (op) {
1178 1187 case add : __ pop_l(rdx); __ addptr(rax, rdx); break;
1179 1188 case sub : __ mov(rdx, rax); __ pop_l(rax); __ subptr(rax, rdx); break;
1180 1189 case _and : __ pop_l(rdx); __ andptr(rax, rdx); break;
1181 1190 case _or : __ pop_l(rdx); __ orptr (rax, rdx); break;
1182 1191 case _xor : __ pop_l(rdx); __ xorptr(rax, rdx); break;
1183 1192 default : ShouldNotReachHere();
1184 1193 }
1185 1194 }
1186 1195
1187 1196 void TemplateTable::idiv() {
1188 1197 transition(itos, itos);
1189 1198 __ movl(rcx, rax);
1190 1199 __ pop_i(rax);
1191 1200 // Note: could xor eax and ecx and compare with (-1 ^ min_int). If
1192 1201 // they are not equal, one could do a normal division (no correction
1193 1202 // needed), which may speed up this implementation for the common case.
1194 1203 // (see also JVM spec., p.243 & p.271)
1195 1204 __ corrected_idivl(rcx);
1196 1205 }
1197 1206
1198 1207 void TemplateTable::irem() {
1199 1208 transition(itos, itos);
1200 1209 __ movl(rcx, rax);
1201 1210 __ pop_i(rax);
1202 1211 // Note: could xor eax and ecx and compare with (-1 ^ min_int). If
1203 1212 // they are not equal, one could do a normal division (no correction
1204 1213 // needed), which may speed up this implementation for the common case.
1205 1214 // (see also JVM spec., p.243 & p.271)
1206 1215 __ corrected_idivl(rcx);
1207 1216 __ movl(rax, rdx);
1208 1217 }
1209 1218
1210 1219 void TemplateTable::lmul() {
1211 1220 transition(ltos, ltos);
1212 1221 __ pop_l(rdx);
1213 1222 __ imulq(rax, rdx);
1214 1223 }
1215 1224
1216 1225 void TemplateTable::ldiv() {
1217 1226 transition(ltos, ltos);
1218 1227 __ mov(rcx, rax);
1219 1228 __ pop_l(rax);
1220 1229 // generate explicit div0 check
1221 1230 __ testq(rcx, rcx);
1222 1231 __ jump_cc(Assembler::zero,
1223 1232 ExternalAddress(Interpreter::_throw_ArithmeticException_entry));
1224 1233 // Note: could xor rax and rcx and compare with (-1 ^ min_int). If
1225 1234 // they are not equal, one could do a normal division (no correction
1226 1235 // needed), which may speed up this implementation for the common case.
1227 1236 // (see also JVM spec., p.243 & p.271)
1228 1237 __ corrected_idivq(rcx); // kills rbx
1229 1238 }
1230 1239
1231 1240 void TemplateTable::lrem() {
1232 1241 transition(ltos, ltos);
1233 1242 __ mov(rcx, rax);
1234 1243 __ pop_l(rax);
1235 1244 __ testq(rcx, rcx);
1236 1245 __ jump_cc(Assembler::zero,
1237 1246 ExternalAddress(Interpreter::_throw_ArithmeticException_entry));
1238 1247 // Note: could xor rax and rcx and compare with (-1 ^ min_int). If
1239 1248 // they are not equal, one could do a normal division (no correction
1240 1249 // needed), which may speed up this implementation for the common case.
1241 1250 // (see also JVM spec., p.243 & p.271)
1242 1251 __ corrected_idivq(rcx); // kills rbx
1243 1252 __ mov(rax, rdx);
1244 1253 }
1245 1254
1246 1255 void TemplateTable::lshl() {
1247 1256 transition(itos, ltos);
1248 1257 __ movl(rcx, rax); // get shift count
1249 1258 __ pop_l(rax); // get shift value
1250 1259 __ shlq(rax);
1251 1260 }
1252 1261
1253 1262 void TemplateTable::lshr() {
1254 1263 transition(itos, ltos);
1255 1264 __ movl(rcx, rax); // get shift count
1256 1265 __ pop_l(rax); // get shift value
1257 1266 __ sarq(rax);
1258 1267 }
1259 1268
1260 1269 void TemplateTable::lushr() {
1261 1270 transition(itos, ltos);
1262 1271 __ movl(rcx, rax); // get shift count
1263 1272 __ pop_l(rax); // get shift value
1264 1273 __ shrq(rax);
1265 1274 }
1266 1275
1267 1276 void TemplateTable::fop2(Operation op) {
1268 1277 transition(ftos, ftos);
1269 1278 switch (op) {
1270 1279 case add:
1271 1280 __ addss(xmm0, at_rsp());
1272 1281 __ addptr(rsp, Interpreter::stackElementSize);
1273 1282 break;
1274 1283 case sub:
1275 1284 __ movflt(xmm1, xmm0);
1276 1285 __ pop_f(xmm0);
1277 1286 __ subss(xmm0, xmm1);
1278 1287 break;
1279 1288 case mul:
1280 1289 __ mulss(xmm0, at_rsp());
1281 1290 __ addptr(rsp, Interpreter::stackElementSize);
1282 1291 break;
1283 1292 case div:
1284 1293 __ movflt(xmm1, xmm0);
1285 1294 __ pop_f(xmm0);
1286 1295 __ divss(xmm0, xmm1);
1287 1296 break;
1288 1297 case rem:
1289 1298 __ movflt(xmm1, xmm0);
1290 1299 __ pop_f(xmm0);
1291 1300 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::frem), 2);
1292 1301 break;
1293 1302 default:
1294 1303 ShouldNotReachHere();
1295 1304 break;
1296 1305 }
1297 1306 }
1298 1307
1299 1308 void TemplateTable::dop2(Operation op) {
1300 1309 transition(dtos, dtos);
1301 1310 switch (op) {
1302 1311 case add:
1303 1312 __ addsd(xmm0, at_rsp());
1304 1313 __ addptr(rsp, 2 * Interpreter::stackElementSize);
1305 1314 break;
1306 1315 case sub:
1307 1316 __ movdbl(xmm1, xmm0);
1308 1317 __ pop_d(xmm0);
1309 1318 __ subsd(xmm0, xmm1);
1310 1319 break;
1311 1320 case mul:
1312 1321 __ mulsd(xmm0, at_rsp());
1313 1322 __ addptr(rsp, 2 * Interpreter::stackElementSize);
1314 1323 break;
1315 1324 case div:
1316 1325 __ movdbl(xmm1, xmm0);
1317 1326 __ pop_d(xmm0);
1318 1327 __ divsd(xmm0, xmm1);
1319 1328 break;
1320 1329 case rem:
1321 1330 __ movdbl(xmm1, xmm0);
1322 1331 __ pop_d(xmm0);
1323 1332 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::drem), 2);
1324 1333 break;
1325 1334 default:
1326 1335 ShouldNotReachHere();
1327 1336 break;
1328 1337 }
1329 1338 }
1330 1339
1331 1340 void TemplateTable::ineg() {
1332 1341 transition(itos, itos);
1333 1342 __ negl(rax);
1334 1343 }
1335 1344
1336 1345 void TemplateTable::lneg() {
1337 1346 transition(ltos, ltos);
1338 1347 __ negq(rax);
1339 1348 }
1340 1349
1341 1350 // Note: 'double' and 'long long' have 32-bits alignment on x86.
1342 1351 static jlong* double_quadword(jlong *adr, jlong lo, jlong hi) {
1343 1352 // Use the expression (adr)&(~0xF) to provide 128-bits aligned address
1344 1353 // of 128-bits operands for SSE instructions.
1345 1354 jlong *operand = (jlong*)(((intptr_t)adr)&((intptr_t)(~0xF)));
1346 1355 // Store the value to a 128-bits operand.
1347 1356 operand[0] = lo;
1348 1357 operand[1] = hi;
1349 1358 return operand;
1350 1359 }
1351 1360
1352 1361 // Buffer for 128-bits masks used by SSE instructions.
1353 1362 static jlong float_signflip_pool[2*2];
1354 1363 static jlong double_signflip_pool[2*2];
1355 1364
1356 1365 void TemplateTable::fneg() {
1357 1366 transition(ftos, ftos);
1358 1367 static jlong *float_signflip = double_quadword(&float_signflip_pool[1], 0x8000000080000000, 0x8000000080000000);
1359 1368 __ xorps(xmm0, ExternalAddress((address) float_signflip));
1360 1369 }
1361 1370
1362 1371 void TemplateTable::dneg() {
1363 1372 transition(dtos, dtos);
1364 1373 static jlong *double_signflip = double_quadword(&double_signflip_pool[1], 0x8000000000000000, 0x8000000000000000);
1365 1374 __ xorpd(xmm0, ExternalAddress((address) double_signflip));
1366 1375 }
1367 1376
1368 1377 void TemplateTable::iinc() {
1369 1378 transition(vtos, vtos);
1370 1379 __ load_signed_byte(rdx, at_bcp(2)); // get constant
1371 1380 locals_index(rbx);
1372 1381 __ addl(iaddress(rbx), rdx);
1373 1382 }
1374 1383
1375 1384 void TemplateTable::wide_iinc() {
1376 1385 transition(vtos, vtos);
1377 1386 __ movl(rdx, at_bcp(4)); // get constant
1378 1387 locals_index_wide(rbx);
1379 1388 __ bswapl(rdx); // swap bytes & sign-extend constant
1380 1389 __ sarl(rdx, 16);
1381 1390 __ addl(iaddress(rbx), rdx);
1382 1391 // Note: should probably use only one movl to get both
1383 1392 // the index and the constant -> fix this
1384 1393 }
1385 1394
1386 1395 void TemplateTable::convert() {
1387 1396 // Checking
1388 1397 #ifdef ASSERT
1389 1398 {
1390 1399 TosState tos_in = ilgl;
1391 1400 TosState tos_out = ilgl;
1392 1401 switch (bytecode()) {
1393 1402 case Bytecodes::_i2l: // fall through
1394 1403 case Bytecodes::_i2f: // fall through
1395 1404 case Bytecodes::_i2d: // fall through
1396 1405 case Bytecodes::_i2b: // fall through
1397 1406 case Bytecodes::_i2c: // fall through
1398 1407 case Bytecodes::_i2s: tos_in = itos; break;
1399 1408 case Bytecodes::_l2i: // fall through
1400 1409 case Bytecodes::_l2f: // fall through
1401 1410 case Bytecodes::_l2d: tos_in = ltos; break;
1402 1411 case Bytecodes::_f2i: // fall through
1403 1412 case Bytecodes::_f2l: // fall through
1404 1413 case Bytecodes::_f2d: tos_in = ftos; break;
1405 1414 case Bytecodes::_d2i: // fall through
1406 1415 case Bytecodes::_d2l: // fall through
1407 1416 case Bytecodes::_d2f: tos_in = dtos; break;
1408 1417 default : ShouldNotReachHere();
1409 1418 }
1410 1419 switch (bytecode()) {
1411 1420 case Bytecodes::_l2i: // fall through
1412 1421 case Bytecodes::_f2i: // fall through
1413 1422 case Bytecodes::_d2i: // fall through
1414 1423 case Bytecodes::_i2b: // fall through
1415 1424 case Bytecodes::_i2c: // fall through
1416 1425 case Bytecodes::_i2s: tos_out = itos; break;
1417 1426 case Bytecodes::_i2l: // fall through
1418 1427 case Bytecodes::_f2l: // fall through
1419 1428 case Bytecodes::_d2l: tos_out = ltos; break;
1420 1429 case Bytecodes::_i2f: // fall through
1421 1430 case Bytecodes::_l2f: // fall through
1422 1431 case Bytecodes::_d2f: tos_out = ftos; break;
1423 1432 case Bytecodes::_i2d: // fall through
1424 1433 case Bytecodes::_l2d: // fall through
1425 1434 case Bytecodes::_f2d: tos_out = dtos; break;
1426 1435 default : ShouldNotReachHere();
1427 1436 }
1428 1437 transition(tos_in, tos_out);
1429 1438 }
1430 1439 #endif // ASSERT
1431 1440
1432 1441 static const int64_t is_nan = 0x8000000000000000L;
1433 1442
1434 1443 // Conversion
1435 1444 switch (bytecode()) {
1436 1445 case Bytecodes::_i2l:
1437 1446 __ movslq(rax, rax);
1438 1447 break;
1439 1448 case Bytecodes::_i2f:
1440 1449 __ cvtsi2ssl(xmm0, rax);
1441 1450 break;
1442 1451 case Bytecodes::_i2d:
1443 1452 __ cvtsi2sdl(xmm0, rax);
1444 1453 break;
1445 1454 case Bytecodes::_i2b:
1446 1455 __ movsbl(rax, rax);
1447 1456 break;
1448 1457 case Bytecodes::_i2c:
1449 1458 __ movzwl(rax, rax);
1450 1459 break;
1451 1460 case Bytecodes::_i2s:
1452 1461 __ movswl(rax, rax);
1453 1462 break;
1454 1463 case Bytecodes::_l2i:
1455 1464 __ movl(rax, rax);
1456 1465 break;
1457 1466 case Bytecodes::_l2f:
1458 1467 __ cvtsi2ssq(xmm0, rax);
1459 1468 break;
1460 1469 case Bytecodes::_l2d:
1461 1470 __ cvtsi2sdq(xmm0, rax);
1462 1471 break;
1463 1472 case Bytecodes::_f2i:
1464 1473 {
1465 1474 Label L;
1466 1475 __ cvttss2sil(rax, xmm0);
1467 1476 __ cmpl(rax, 0x80000000); // NaN or overflow/underflow?
1468 1477 __ jcc(Assembler::notEqual, L);
1469 1478 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2i), 1);
1470 1479 __ bind(L);
1471 1480 }
1472 1481 break;
1473 1482 case Bytecodes::_f2l:
1474 1483 {
1475 1484 Label L;
1476 1485 __ cvttss2siq(rax, xmm0);
1477 1486 // NaN or overflow/underflow?
1478 1487 __ cmp64(rax, ExternalAddress((address) &is_nan));
1479 1488 __ jcc(Assembler::notEqual, L);
1480 1489 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2l), 1);
1481 1490 __ bind(L);
1482 1491 }
1483 1492 break;
1484 1493 case Bytecodes::_f2d:
1485 1494 __ cvtss2sd(xmm0, xmm0);
1486 1495 break;
1487 1496 case Bytecodes::_d2i:
1488 1497 {
1489 1498 Label L;
1490 1499 __ cvttsd2sil(rax, xmm0);
1491 1500 __ cmpl(rax, 0x80000000); // NaN or overflow/underflow?
1492 1501 __ jcc(Assembler::notEqual, L);
1493 1502 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2i), 1);
1494 1503 __ bind(L);
1495 1504 }
1496 1505 break;
1497 1506 case Bytecodes::_d2l:
1498 1507 {
1499 1508 Label L;
1500 1509 __ cvttsd2siq(rax, xmm0);
1501 1510 // NaN or overflow/underflow?
1502 1511 __ cmp64(rax, ExternalAddress((address) &is_nan));
1503 1512 __ jcc(Assembler::notEqual, L);
1504 1513 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2l), 1);
1505 1514 __ bind(L);
1506 1515 }
1507 1516 break;
1508 1517 case Bytecodes::_d2f:
1509 1518 __ cvtsd2ss(xmm0, xmm0);
1510 1519 break;
1511 1520 default:
1512 1521 ShouldNotReachHere();
1513 1522 }
1514 1523 }
1515 1524
1516 1525 void TemplateTable::lcmp() {
1517 1526 transition(ltos, itos);
1518 1527 Label done;
1519 1528 __ pop_l(rdx);
1520 1529 __ cmpq(rdx, rax);
1521 1530 __ movl(rax, -1);
1522 1531 __ jccb(Assembler::less, done);
1523 1532 __ setb(Assembler::notEqual, rax);
1524 1533 __ movzbl(rax, rax);
1525 1534 __ bind(done);
1526 1535 }
1527 1536
1528 1537 void TemplateTable::float_cmp(bool is_float, int unordered_result) {
1529 1538 Label done;
1530 1539 if (is_float) {
1531 1540 // XXX get rid of pop here, use ... reg, mem32
1532 1541 __ pop_f(xmm1);
1533 1542 __ ucomiss(xmm1, xmm0);
1534 1543 } else {
1535 1544 // XXX get rid of pop here, use ... reg, mem64
1536 1545 __ pop_d(xmm1);
1537 1546 __ ucomisd(xmm1, xmm0);
1538 1547 }
1539 1548 if (unordered_result < 0) {
1540 1549 __ movl(rax, -1);
1541 1550 __ jccb(Assembler::parity, done);
1542 1551 __ jccb(Assembler::below, done);
1543 1552 __ setb(Assembler::notEqual, rdx);
1544 1553 __ movzbl(rax, rdx);
1545 1554 } else {
1546 1555 __ movl(rax, 1);
1547 1556 __ jccb(Assembler::parity, done);
1548 1557 __ jccb(Assembler::above, done);
1549 1558 __ movl(rax, 0);
1550 1559 __ jccb(Assembler::equal, done);
1551 1560 __ decrementl(rax);
1552 1561 }
1553 1562 __ bind(done);
1554 1563 }
1555 1564
1556 1565 void TemplateTable::branch(bool is_jsr, bool is_wide) {
1557 1566 __ get_method(rcx); // rcx holds method
1558 1567 __ profile_taken_branch(rax, rbx); // rax holds updated MDP, rbx
1559 1568 // holds bumped taken count
1560 1569
1561 1570 const ByteSize be_offset = methodOopDesc::backedge_counter_offset() +
1562 1571 InvocationCounter::counter_offset();
1563 1572 const ByteSize inv_offset = methodOopDesc::invocation_counter_offset() +
1564 1573 InvocationCounter::counter_offset();
1565 1574 const int method_offset = frame::interpreter_frame_method_offset * wordSize;
1566 1575
1567 1576 // Load up edx with the branch displacement
1568 1577 __ movl(rdx, at_bcp(1));
1569 1578 __ bswapl(rdx);
1570 1579
1571 1580 if (!is_wide) {
1572 1581 __ sarl(rdx, 16);
1573 1582 }
1574 1583 __ movl2ptr(rdx, rdx);
1575 1584
1576 1585 // Handle all the JSR stuff here, then exit.
1577 1586 // It's much shorter and cleaner than intermingling with the non-JSR
1578 1587 // normal-branch stuff occurring below.
1579 1588 if (is_jsr) {
1580 1589 // Pre-load the next target bytecode into rbx
1581 1590 __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1, 0));
1582 1591
1583 1592 // compute return address as bci in rax
1584 1593 __ lea(rax, at_bcp((is_wide ? 5 : 3) -
1585 1594 in_bytes(constMethodOopDesc::codes_offset())));
1586 1595 __ subptr(rax, Address(rcx, methodOopDesc::const_offset()));
1587 1596 // Adjust the bcp in r13 by the displacement in rdx
1588 1597 __ addptr(r13, rdx);
1589 1598 // jsr returns atos that is not an oop
1590 1599 __ push_i(rax);
1591 1600 __ dispatch_only(vtos);
1592 1601 return;
1593 1602 }
1594 1603
1595 1604 // Normal (non-jsr) branch handling
1596 1605
1597 1606 // Adjust the bcp in r13 by the displacement in rdx
1598 1607 __ addptr(r13, rdx);
1599 1608
1600 1609 assert(UseLoopCounter || !UseOnStackReplacement,
1601 1610 "on-stack-replacement requires loop counters");
1602 1611 Label backedge_counter_overflow;
1603 1612 Label profile_method;
1604 1613 Label dispatch;
1605 1614 if (UseLoopCounter) {
1606 1615 // increment backedge counter for backward branches
1607 1616 // rax: MDO
1608 1617 // ebx: MDO bumped taken-count
1609 1618 // rcx: method
1610 1619 // rdx: target offset
1611 1620 // r13: target bcp
1612 1621 // r14: locals pointer
1613 1622 __ testl(rdx, rdx); // check if forward or backward branch
1614 1623 __ jcc(Assembler::positive, dispatch); // count only if backward branch
1615 1624 if (TieredCompilation) {
1616 1625 Label no_mdo;
1617 1626 int increment = InvocationCounter::count_increment;
1618 1627 int mask = ((1 << Tier0BackedgeNotifyFreqLog) - 1) << InvocationCounter::count_shift;
1619 1628 if (ProfileInterpreter) {
1620 1629 // Are we profiling?
1621 1630 __ movptr(rbx, Address(rcx, in_bytes(methodOopDesc::method_data_offset())));
1622 1631 __ testptr(rbx, rbx);
1623 1632 __ jccb(Assembler::zero, no_mdo);
1624 1633 // Increment the MDO backedge counter
1625 1634 const Address mdo_backedge_counter(rbx, in_bytes(methodDataOopDesc::backedge_counter_offset()) +
1626 1635 in_bytes(InvocationCounter::counter_offset()));
1627 1636 __ increment_mask_and_jump(mdo_backedge_counter, increment, mask,
1628 1637 rax, false, Assembler::zero, &backedge_counter_overflow);
1629 1638 __ jmp(dispatch);
1630 1639 }
1631 1640 __ bind(no_mdo);
1632 1641 // Increment backedge counter in methodOop
1633 1642 __ increment_mask_and_jump(Address(rcx, be_offset), increment, mask,
1634 1643 rax, false, Assembler::zero, &backedge_counter_overflow);
1635 1644 } else {
1636 1645 // increment counter
1637 1646 __ movl(rax, Address(rcx, be_offset)); // load backedge counter
1638 1647 __ incrementl(rax, InvocationCounter::count_increment); // increment counter
1639 1648 __ movl(Address(rcx, be_offset), rax); // store counter
1640 1649
1641 1650 __ movl(rax, Address(rcx, inv_offset)); // load invocation counter
1642 1651 __ andl(rax, InvocationCounter::count_mask_value); // and the status bits
1643 1652 __ addl(rax, Address(rcx, be_offset)); // add both counters
1644 1653
1645 1654 if (ProfileInterpreter) {
1646 1655 // Test to see if we should create a method data oop
1647 1656 __ cmp32(rax,
1648 1657 ExternalAddress((address) &InvocationCounter::InterpreterProfileLimit));
1649 1658 __ jcc(Assembler::less, dispatch);
1650 1659
1651 1660 // if no method data exists, go to profile method
1652 1661 __ test_method_data_pointer(rax, profile_method);
1653 1662
1654 1663 if (UseOnStackReplacement) {
1655 1664 // check for overflow against ebx which is the MDO taken count
1656 1665 __ cmp32(rbx,
1657 1666 ExternalAddress((address) &InvocationCounter::InterpreterBackwardBranchLimit));
1658 1667 __ jcc(Assembler::below, dispatch);
1659 1668
1660 1669 // When ProfileInterpreter is on, the backedge_count comes
1661 1670 // from the methodDataOop, which value does not get reset on
1662 1671 // the call to frequency_counter_overflow(). To avoid
1663 1672 // excessive calls to the overflow routine while the method is
1664 1673 // being compiled, add a second test to make sure the overflow
1665 1674 // function is called only once every overflow_frequency.
1666 1675 const int overflow_frequency = 1024;
1667 1676 __ andl(rbx, overflow_frequency - 1);
1668 1677 __ jcc(Assembler::zero, backedge_counter_overflow);
1669 1678
1670 1679 }
1671 1680 } else {
1672 1681 if (UseOnStackReplacement) {
1673 1682 // check for overflow against eax, which is the sum of the
1674 1683 // counters
1675 1684 __ cmp32(rax,
1676 1685 ExternalAddress((address) &InvocationCounter::InterpreterBackwardBranchLimit));
1677 1686 __ jcc(Assembler::aboveEqual, backedge_counter_overflow);
1678 1687
1679 1688 }
1680 1689 }
1681 1690 }
1682 1691 __ bind(dispatch);
1683 1692 }
1684 1693
1685 1694 // Pre-load the next target bytecode into rbx
1686 1695 __ load_unsigned_byte(rbx, Address(r13, 0));
1687 1696
1688 1697 // continue with the bytecode @ target
1689 1698 // eax: return bci for jsr's, unused otherwise
1690 1699 // ebx: target bytecode
1691 1700 // r13: target bcp
1692 1701 __ dispatch_only(vtos);
1693 1702
1694 1703 if (UseLoopCounter) {
1695 1704 if (ProfileInterpreter) {
1696 1705 // Out-of-line code to allocate method data oop.
1697 1706 __ bind(profile_method);
1698 1707 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method));
1699 1708 __ load_unsigned_byte(rbx, Address(r13, 0)); // restore target bytecode
1700 1709 __ set_method_data_pointer_for_bcp();
1701 1710 __ jmp(dispatch);
1702 1711 }
1703 1712
1704 1713 if (UseOnStackReplacement) {
1705 1714 // invocation counter overflow
1706 1715 __ bind(backedge_counter_overflow);
1707 1716 __ negptr(rdx);
1708 1717 __ addptr(rdx, r13); // branch bcp
1709 1718 // IcoResult frequency_counter_overflow([JavaThread*], address branch_bcp)
1710 1719 __ call_VM(noreg,
1711 1720 CAST_FROM_FN_PTR(address,
1712 1721 InterpreterRuntime::frequency_counter_overflow),
1713 1722 rdx);
1714 1723 __ load_unsigned_byte(rbx, Address(r13, 0)); // restore target bytecode
1715 1724
1716 1725 // rax: osr nmethod (osr ok) or NULL (osr not possible)
1717 1726 // ebx: target bytecode
1718 1727 // rdx: scratch
1719 1728 // r14: locals pointer
1720 1729 // r13: bcp
1721 1730 __ testptr(rax, rax); // test result
1722 1731 __ jcc(Assembler::zero, dispatch); // no osr if null
1723 1732 // nmethod may have been invalidated (VM may block upon call_VM return)
1724 1733 __ movl(rcx, Address(rax, nmethod::entry_bci_offset()));
1725 1734 __ cmpl(rcx, InvalidOSREntryBci);
1726 1735 __ jcc(Assembler::equal, dispatch);
1727 1736
1728 1737 // We have the address of an on stack replacement routine in eax
1729 1738 // We need to prepare to execute the OSR method. First we must
1730 1739 // migrate the locals and monitors off of the stack.
1731 1740
1732 1741 __ mov(r13, rax); // save the nmethod
1733 1742
1734 1743 call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin));
1735 1744
1736 1745 // eax is OSR buffer, move it to expected parameter location
1737 1746 __ mov(j_rarg0, rax);
1738 1747
1739 1748 // We use j_rarg definitions here so that registers don't conflict as parameter
1740 1749 // registers change across platforms as we are in the midst of a calling
1741 1750 // sequence to the OSR nmethod and we don't want collision. These are NOT parameters.
1742 1751
1743 1752 const Register retaddr = j_rarg2;
1744 1753 const Register sender_sp = j_rarg1;
1745 1754
1746 1755 // pop the interpreter frame
1747 1756 __ movptr(sender_sp, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp
1748 1757 __ leave(); // remove frame anchor
1749 1758 __ pop(retaddr); // get return address
1750 1759 __ mov(rsp, sender_sp); // set sp to sender sp
1751 1760 // Ensure compiled code always sees stack at proper alignment
1752 1761 __ andptr(rsp, -(StackAlignmentInBytes));
1753 1762
1754 1763 // unlike x86 we need no specialized return from compiled code
1755 1764 // to the interpreter or the call stub.
1756 1765
1757 1766 // push the return address
1758 1767 __ push(retaddr);
1759 1768
1760 1769 // and begin the OSR nmethod
1761 1770 __ jmp(Address(r13, nmethod::osr_entry_point_offset()));
1762 1771 }
1763 1772 }
1764 1773 }
1765 1774
1766 1775
1767 1776 void TemplateTable::if_0cmp(Condition cc) {
1768 1777 transition(itos, vtos);
1769 1778 // assume branch is more often taken than not (loops use backward branches)
1770 1779 Label not_taken;
1771 1780 __ testl(rax, rax);
1772 1781 __ jcc(j_not(cc), not_taken);
1773 1782 branch(false, false);
1774 1783 __ bind(not_taken);
1775 1784 __ profile_not_taken_branch(rax);
1776 1785 }
1777 1786
1778 1787 void TemplateTable::if_icmp(Condition cc) {
1779 1788 transition(itos, vtos);
1780 1789 // assume branch is more often taken than not (loops use backward branches)
1781 1790 Label not_taken;
1782 1791 __ pop_i(rdx);
1783 1792 __ cmpl(rdx, rax);
1784 1793 __ jcc(j_not(cc), not_taken);
1785 1794 branch(false, false);
1786 1795 __ bind(not_taken);
1787 1796 __ profile_not_taken_branch(rax);
1788 1797 }
1789 1798
1790 1799 void TemplateTable::if_nullcmp(Condition cc) {
1791 1800 transition(atos, vtos);
1792 1801 // assume branch is more often taken than not (loops use backward branches)
1793 1802 Label not_taken;
1794 1803 __ testptr(rax, rax);
1795 1804 __ jcc(j_not(cc), not_taken);
1796 1805 branch(false, false);
1797 1806 __ bind(not_taken);
1798 1807 __ profile_not_taken_branch(rax);
1799 1808 }
1800 1809
1801 1810 void TemplateTable::if_acmp(Condition cc) {
1802 1811 transition(atos, vtos);
1803 1812 // assume branch is more often taken than not (loops use backward branches)
1804 1813 Label not_taken;
1805 1814 __ pop_ptr(rdx);
1806 1815 __ cmpptr(rdx, rax);
1807 1816 __ jcc(j_not(cc), not_taken);
1808 1817 branch(false, false);
1809 1818 __ bind(not_taken);
1810 1819 __ profile_not_taken_branch(rax);
1811 1820 }
1812 1821
1813 1822 void TemplateTable::ret() {
1814 1823 transition(vtos, vtos);
1815 1824 locals_index(rbx);
1816 1825 __ movslq(rbx, iaddress(rbx)); // get return bci, compute return bcp
1817 1826 __ profile_ret(rbx, rcx);
1818 1827 __ get_method(rax);
1819 1828 __ movptr(r13, Address(rax, methodOopDesc::const_offset()));
1820 1829 __ lea(r13, Address(r13, rbx, Address::times_1,
1821 1830 constMethodOopDesc::codes_offset()));
1822 1831 __ dispatch_next(vtos);
1823 1832 }
1824 1833
1825 1834 void TemplateTable::wide_ret() {
1826 1835 transition(vtos, vtos);
1827 1836 locals_index_wide(rbx);
1828 1837 __ movptr(rbx, aaddress(rbx)); // get return bci, compute return bcp
1829 1838 __ profile_ret(rbx, rcx);
1830 1839 __ get_method(rax);
1831 1840 __ movptr(r13, Address(rax, methodOopDesc::const_offset()));
1832 1841 __ lea(r13, Address(r13, rbx, Address::times_1, constMethodOopDesc::codes_offset()));
1833 1842 __ dispatch_next(vtos);
1834 1843 }
1835 1844
1836 1845 void TemplateTable::tableswitch() {
1837 1846 Label default_case, continue_execution;
1838 1847 transition(itos, vtos);
1839 1848 // align r13
1840 1849 __ lea(rbx, at_bcp(BytesPerInt));
1841 1850 __ andptr(rbx, -BytesPerInt);
1842 1851 // load lo & hi
1843 1852 __ movl(rcx, Address(rbx, BytesPerInt));
1844 1853 __ movl(rdx, Address(rbx, 2 * BytesPerInt));
1845 1854 __ bswapl(rcx);
1846 1855 __ bswapl(rdx);
1847 1856 // check against lo & hi
1848 1857 __ cmpl(rax, rcx);
1849 1858 __ jcc(Assembler::less, default_case);
1850 1859 __ cmpl(rax, rdx);
1851 1860 __ jcc(Assembler::greater, default_case);
1852 1861 // lookup dispatch offset
1853 1862 __ subl(rax, rcx);
1854 1863 __ movl(rdx, Address(rbx, rax, Address::times_4, 3 * BytesPerInt));
1855 1864 __ profile_switch_case(rax, rbx, rcx);
1856 1865 // continue execution
1857 1866 __ bind(continue_execution);
1858 1867 __ bswapl(rdx);
1859 1868 __ movl2ptr(rdx, rdx);
1860 1869 __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1));
1861 1870 __ addptr(r13, rdx);
1862 1871 __ dispatch_only(vtos);
1863 1872 // handle default
1864 1873 __ bind(default_case);
1865 1874 __ profile_switch_default(rax);
1866 1875 __ movl(rdx, Address(rbx, 0));
1867 1876 __ jmp(continue_execution);
1868 1877 }
1869 1878
1870 1879 void TemplateTable::lookupswitch() {
1871 1880 transition(itos, itos);
1872 1881 __ stop("lookupswitch bytecode should have been rewritten");
1873 1882 }
1874 1883
1875 1884 void TemplateTable::fast_linearswitch() {
1876 1885 transition(itos, vtos);
1877 1886 Label loop_entry, loop, found, continue_execution;
1878 1887 // bswap rax so we can avoid bswapping the table entries
1879 1888 __ bswapl(rax);
1880 1889 // align r13
1881 1890 __ lea(rbx, at_bcp(BytesPerInt)); // btw: should be able to get rid of
1882 1891 // this instruction (change offsets
1883 1892 // below)
1884 1893 __ andptr(rbx, -BytesPerInt);
1885 1894 // set counter
1886 1895 __ movl(rcx, Address(rbx, BytesPerInt));
1887 1896 __ bswapl(rcx);
1888 1897 __ jmpb(loop_entry);
1889 1898 // table search
1890 1899 __ bind(loop);
1891 1900 __ cmpl(rax, Address(rbx, rcx, Address::times_8, 2 * BytesPerInt));
1892 1901 __ jcc(Assembler::equal, found);
1893 1902 __ bind(loop_entry);
1894 1903 __ decrementl(rcx);
1895 1904 __ jcc(Assembler::greaterEqual, loop);
1896 1905 // default case
1897 1906 __ profile_switch_default(rax);
1898 1907 __ movl(rdx, Address(rbx, 0));
1899 1908 __ jmp(continue_execution);
1900 1909 // entry found -> get offset
1901 1910 __ bind(found);
1902 1911 __ movl(rdx, Address(rbx, rcx, Address::times_8, 3 * BytesPerInt));
1903 1912 __ profile_switch_case(rcx, rax, rbx);
1904 1913 // continue execution
1905 1914 __ bind(continue_execution);
1906 1915 __ bswapl(rdx);
1907 1916 __ movl2ptr(rdx, rdx);
1908 1917 __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1));
1909 1918 __ addptr(r13, rdx);
1910 1919 __ dispatch_only(vtos);
1911 1920 }
1912 1921
1913 1922 void TemplateTable::fast_binaryswitch() {
1914 1923 transition(itos, vtos);
1915 1924 // Implementation using the following core algorithm:
1916 1925 //
1917 1926 // int binary_search(int key, LookupswitchPair* array, int n) {
1918 1927 // // Binary search according to "Methodik des Programmierens" by
1919 1928 // // Edsger W. Dijkstra and W.H.J. Feijen, Addison Wesley Germany 1985.
1920 1929 // int i = 0;
1921 1930 // int j = n;
1922 1931 // while (i+1 < j) {
1923 1932 // // invariant P: 0 <= i < j <= n and (a[i] <= key < a[j] or Q)
1924 1933 // // with Q: for all i: 0 <= i < n: key < a[i]
1925 1934 // // where a stands for the array and assuming that the (inexisting)
1926 1935 // // element a[n] is infinitely big.
1927 1936 // int h = (i + j) >> 1;
1928 1937 // // i < h < j
1929 1938 // if (key < array[h].fast_match()) {
1930 1939 // j = h;
1931 1940 // } else {
1932 1941 // i = h;
1933 1942 // }
1934 1943 // }
1935 1944 // // R: a[i] <= key < a[i+1] or Q
1936 1945 // // (i.e., if key is within array, i is the correct index)
1937 1946 // return i;
1938 1947 // }
1939 1948
1940 1949 // Register allocation
1941 1950 const Register key = rax; // already set (tosca)
1942 1951 const Register array = rbx;
1943 1952 const Register i = rcx;
1944 1953 const Register j = rdx;
1945 1954 const Register h = rdi;
1946 1955 const Register temp = rsi;
1947 1956
1948 1957 // Find array start
1949 1958 __ lea(array, at_bcp(3 * BytesPerInt)); // btw: should be able to
1950 1959 // get rid of this
1951 1960 // instruction (change
1952 1961 // offsets below)
1953 1962 __ andptr(array, -BytesPerInt);
1954 1963
1955 1964 // Initialize i & j
1956 1965 __ xorl(i, i); // i = 0;
1957 1966 __ movl(j, Address(array, -BytesPerInt)); // j = length(array);
1958 1967
1959 1968 // Convert j into native byteordering
1960 1969 __ bswapl(j);
1961 1970
1962 1971 // And start
1963 1972 Label entry;
1964 1973 __ jmp(entry);
1965 1974
1966 1975 // binary search loop
1967 1976 {
1968 1977 Label loop;
1969 1978 __ bind(loop);
1970 1979 // int h = (i + j) >> 1;
1971 1980 __ leal(h, Address(i, j, Address::times_1)); // h = i + j;
1972 1981 __ sarl(h, 1); // h = (i + j) >> 1;
1973 1982 // if (key < array[h].fast_match()) {
1974 1983 // j = h;
1975 1984 // } else {
1976 1985 // i = h;
1977 1986 // }
1978 1987 // Convert array[h].match to native byte-ordering before compare
1979 1988 __ movl(temp, Address(array, h, Address::times_8));
1980 1989 __ bswapl(temp);
1981 1990 __ cmpl(key, temp);
1982 1991 // j = h if (key < array[h].fast_match())
1983 1992 __ cmovl(Assembler::less, j, h);
1984 1993 // i = h if (key >= array[h].fast_match())
1985 1994 __ cmovl(Assembler::greaterEqual, i, h);
1986 1995 // while (i+1 < j)
1987 1996 __ bind(entry);
1988 1997 __ leal(h, Address(i, 1)); // i+1
1989 1998 __ cmpl(h, j); // i+1 < j
1990 1999 __ jcc(Assembler::less, loop);
1991 2000 }
1992 2001
1993 2002 // end of binary search, result index is i (must check again!)
1994 2003 Label default_case;
1995 2004 // Convert array[i].match to native byte-ordering before compare
1996 2005 __ movl(temp, Address(array, i, Address::times_8));
1997 2006 __ bswapl(temp);
1998 2007 __ cmpl(key, temp);
1999 2008 __ jcc(Assembler::notEqual, default_case);
2000 2009
2001 2010 // entry found -> j = offset
2002 2011 __ movl(j , Address(array, i, Address::times_8, BytesPerInt));
2003 2012 __ profile_switch_case(i, key, array);
2004 2013 __ bswapl(j);
2005 2014 __ movl2ptr(j, j);
2006 2015 __ load_unsigned_byte(rbx, Address(r13, j, Address::times_1));
2007 2016 __ addptr(r13, j);
2008 2017 __ dispatch_only(vtos);
2009 2018
2010 2019 // default case -> j = default offset
2011 2020 __ bind(default_case);
2012 2021 __ profile_switch_default(i);
2013 2022 __ movl(j, Address(array, -2 * BytesPerInt));
2014 2023 __ bswapl(j);
2015 2024 __ movl2ptr(j, j);
2016 2025 __ load_unsigned_byte(rbx, Address(r13, j, Address::times_1));
2017 2026 __ addptr(r13, j);
2018 2027 __ dispatch_only(vtos);
2019 2028 }
2020 2029
2021 2030
2022 2031 void TemplateTable::_return(TosState state) {
2023 2032 transition(state, state);
2024 2033 assert(_desc->calls_vm(),
2025 2034 "inconsistent calls_vm information"); // call in remove_activation
2026 2035
2027 2036 if (_desc->bytecode() == Bytecodes::_return_register_finalizer) {
2028 2037 assert(state == vtos, "only valid state");
2029 2038 __ movptr(c_rarg1, aaddress(0));
2030 2039 __ load_klass(rdi, c_rarg1);
2031 2040 __ movl(rdi, Address(rdi, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc)));
2032 2041 __ testl(rdi, JVM_ACC_HAS_FINALIZER);
2033 2042 Label skip_register_finalizer;
2034 2043 __ jcc(Assembler::zero, skip_register_finalizer);
2035 2044
2036 2045 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), c_rarg1);
2037 2046
2038 2047 __ bind(skip_register_finalizer);
2039 2048 }
2040 2049
2041 2050 __ remove_activation(state, r13);
2042 2051 __ jmp(r13);
2043 2052 }
2044 2053
2045 2054 // ----------------------------------------------------------------------------
2046 2055 // Volatile variables demand their effects be made known to all CPU's
2047 2056 // in order. Store buffers on most chips allow reads & writes to
2048 2057 // reorder; the JMM's ReadAfterWrite.java test fails in -Xint mode
2049 2058 // without some kind of memory barrier (i.e., it's not sufficient that
2050 2059 // the interpreter does not reorder volatile references, the hardware
2051 2060 // also must not reorder them).
2052 2061 //
2053 2062 // According to the new Java Memory Model (JMM):
2054 2063 // (1) All volatiles are serialized wrt to each other. ALSO reads &
2055 2064 // writes act as aquire & release, so:
2056 2065 // (2) A read cannot let unrelated NON-volatile memory refs that
2057 2066 // happen after the read float up to before the read. It's OK for
2058 2067 // non-volatile memory refs that happen before the volatile read to
2059 2068 // float down below it.
2060 2069 // (3) Similar a volatile write cannot let unrelated NON-volatile
2061 2070 // memory refs that happen BEFORE the write float down to after the
2062 2071 // write. It's OK for non-volatile memory refs that happen after the
2063 2072 // volatile write to float up before it.
2064 2073 //
2065 2074 // We only put in barriers around volatile refs (they are expensive),
2066 2075 // not _between_ memory refs (that would require us to track the
2067 2076 // flavor of the previous memory refs). Requirements (2) and (3)
2068 2077 // require some barriers before volatile stores and after volatile
2069 2078 // loads. These nearly cover requirement (1) but miss the
2070 2079 // volatile-store-volatile-load case. This final case is placed after
2071 2080 // volatile-stores although it could just as well go before
2072 2081 // volatile-loads.
2073 2082 void TemplateTable::volatile_barrier(Assembler::Membar_mask_bits
2074 2083 order_constraint) {
2075 2084 // Helper function to insert a is-volatile test and memory barrier
2076 2085 if (os::is_MP()) { // Not needed on single CPU
2077 2086 __ membar(order_constraint);
2078 2087 }
2079 2088 }
2080 2089
2081 2090 void TemplateTable::resolve_cache_and_index(int byte_no,
2082 2091 Register result,
2083 2092 Register Rcache,
2084 2093 Register index,
2085 2094 size_t index_size) {
2086 2095 const Register temp = rbx;
2087 2096 assert_different_registers(result, Rcache, index, temp);
2088 2097
2089 2098 Label resolved;
2090 2099 __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
2091 2100 if (byte_no == f1_oop) {
2092 2101 // We are resolved if the f1 field contains a non-null object (CallSite, etc.)
2093 2102 // This kind of CP cache entry does not need to match the flags byte, because
2094 2103 // there is a 1-1 relation between bytecode type and CP entry type.
2095 2104 assert(result != noreg, ""); //else do cmpptr(Address(...), (int32_t) NULL_WORD)
2096 2105 __ movptr(result, Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f1_offset()));
2097 2106 __ testptr(result, result);
2098 2107 __ jcc(Assembler::notEqual, resolved);
2099 2108 } else {
2100 2109 assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
2101 2110 assert(result == noreg, ""); //else change code for setting result
2102 2111 const int shift_count = (1 + byte_no) * BitsPerByte;
2103 2112 __ movl(temp, Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::indices_offset()));
2104 2113 __ shrl(temp, shift_count);
2105 2114 // have we resolved this bytecode?
2106 2115 __ andl(temp, 0xFF);
2107 2116 __ cmpl(temp, (int) bytecode());
2108 2117 __ jcc(Assembler::equal, resolved);
2109 2118 }
2110 2119
2111 2120 // resolve first time through
2112 2121 address entry;
2113 2122 switch (bytecode()) {
2114 2123 case Bytecodes::_getstatic:
2115 2124 case Bytecodes::_putstatic:
2116 2125 case Bytecodes::_getfield:
2117 2126 case Bytecodes::_putfield:
2118 2127 entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put);
2119 2128 break;
2120 2129 case Bytecodes::_invokevirtual:
2121 2130 case Bytecodes::_invokespecial:
2122 2131 case Bytecodes::_invokestatic:
2123 2132 case Bytecodes::_invokeinterface:
2124 2133 entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke);
2125 2134 break;
2126 2135 case Bytecodes::_invokedynamic:
2127 2136 entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokedynamic);
2128 2137 break;
2129 2138 case Bytecodes::_fast_aldc:
2130 2139 entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
2131 2140 break;
2132 2141 case Bytecodes::_fast_aldc_w:
2133 2142 entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
2134 2143 break;
2135 2144 default:
2136 2145 ShouldNotReachHere();
2137 2146 break;
2138 2147 }
2139 2148 __ movl(temp, (int) bytecode());
2140 2149 __ call_VM(noreg, entry, temp);
2141 2150
2142 2151 // Update registers with resolved info
2143 2152 __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
2144 2153 if (result != noreg)
2145 2154 __ movptr(result, Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f1_offset()));
2146 2155 __ bind(resolved);
2147 2156 }
2148 2157
2149 2158 // The Rcache and index registers must be set before call
2150 2159 void TemplateTable::load_field_cp_cache_entry(Register obj,
2151 2160 Register cache,
2152 2161 Register index,
2153 2162 Register off,
2154 2163 Register flags,
2155 2164 bool is_static = false) {
2156 2165 assert_different_registers(cache, index, flags, off);
2157 2166
2158 2167 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
2159 2168 // Field offset
2160 2169 __ movptr(off, Address(cache, index, Address::times_8,
2161 2170 in_bytes(cp_base_offset +
2162 2171 ConstantPoolCacheEntry::f2_offset())));
2163 2172 // Flags
2164 2173 __ movl(flags, Address(cache, index, Address::times_8,
2165 2174 in_bytes(cp_base_offset +
2166 2175 ConstantPoolCacheEntry::flags_offset())));
2167 2176
2168 2177 // klass overwrite register
2169 2178 if (is_static) {
2170 2179 __ movptr(obj, Address(cache, index, Address::times_8,
2171 2180 in_bytes(cp_base_offset +
2172 2181 ConstantPoolCacheEntry::f1_offset())));
2173 2182 }
2174 2183 }
2175 2184
2176 2185 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
2177 2186 Register method,
2178 2187 Register itable_index,
2179 2188 Register flags,
2180 2189 bool is_invokevirtual,
2181 2190 bool is_invokevfinal, /*unused*/
2182 2191 bool is_invokedynamic) {
2183 2192 // setup registers
2184 2193 const Register cache = rcx;
2185 2194 const Register index = rdx;
2186 2195 assert_different_registers(method, flags);
2187 2196 assert_different_registers(method, cache, index);
2188 2197 assert_different_registers(itable_index, flags);
2189 2198 assert_different_registers(itable_index, cache, index);
2190 2199 // determine constant pool cache field offsets
2191 2200 const int method_offset = in_bytes(
2192 2201 constantPoolCacheOopDesc::base_offset() +
2193 2202 (is_invokevirtual
2194 2203 ? ConstantPoolCacheEntry::f2_offset()
2195 2204 : ConstantPoolCacheEntry::f1_offset()));
2196 2205 const int flags_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
2197 2206 ConstantPoolCacheEntry::flags_offset());
2198 2207 // access constant pool cache fields
2199 2208 const int index_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
2200 2209 ConstantPoolCacheEntry::f2_offset());
2201 2210
2202 2211 if (byte_no == f1_oop) {
2203 2212 // Resolved f1_oop goes directly into 'method' register.
2204 2213 assert(is_invokedynamic, "");
2205 2214 resolve_cache_and_index(byte_no, method, cache, index, sizeof(u4));
2206 2215 } else {
2207 2216 resolve_cache_and_index(byte_no, noreg, cache, index, sizeof(u2));
2208 2217 __ movptr(method, Address(cache, index, Address::times_ptr, method_offset));
2209 2218 }
2210 2219 if (itable_index != noreg) {
2211 2220 __ movptr(itable_index, Address(cache, index, Address::times_ptr, index_offset));
2212 2221 }
2213 2222 __ movl(flags, Address(cache, index, Address::times_ptr, flags_offset));
2214 2223 }
2215 2224
2216 2225
2217 2226 // The registers cache and index expected to be set before call.
2218 2227 // Correct values of the cache and index registers are preserved.
2219 2228 void TemplateTable::jvmti_post_field_access(Register cache, Register index,
2220 2229 bool is_static, bool has_tos) {
2221 2230 // do the JVMTI work here to avoid disturbing the register state below
2222 2231 // We use c_rarg registers here because we want to use the register used in
2223 2232 // the call to the VM
2224 2233 if (JvmtiExport::can_post_field_access()) {
2225 2234 // Check to see if a field access watch has been set before we
2226 2235 // take the time to call into the VM.
2227 2236 Label L1;
2228 2237 assert_different_registers(cache, index, rax);
2229 2238 __ mov32(rax, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
2230 2239 __ testl(rax, rax);
2231 2240 __ jcc(Assembler::zero, L1);
2232 2241
2233 2242 __ get_cache_and_index_at_bcp(c_rarg2, c_rarg3, 1);
2234 2243
2235 2244 // cache entry pointer
2236 2245 __ addptr(c_rarg2, in_bytes(constantPoolCacheOopDesc::base_offset()));
2237 2246 __ shll(c_rarg3, LogBytesPerWord);
2238 2247 __ addptr(c_rarg2, c_rarg3);
2239 2248 if (is_static) {
2240 2249 __ xorl(c_rarg1, c_rarg1); // NULL object reference
2241 2250 } else {
2242 2251 __ movptr(c_rarg1, at_tos()); // get object pointer without popping it
2243 2252 __ verify_oop(c_rarg1);
2244 2253 }
2245 2254 // c_rarg1: object pointer or NULL
2246 2255 // c_rarg2: cache entry pointer
2247 2256 // c_rarg3: jvalue object on the stack
2248 2257 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2249 2258 InterpreterRuntime::post_field_access),
2250 2259 c_rarg1, c_rarg2, c_rarg3);
2251 2260 __ get_cache_and_index_at_bcp(cache, index, 1);
2252 2261 __ bind(L1);
2253 2262 }
2254 2263 }
2255 2264
2256 2265 void TemplateTable::pop_and_check_object(Register r) {
2257 2266 __ pop_ptr(r);
2258 2267 __ null_check(r); // for field access must check obj.
2259 2268 __ verify_oop(r);
2260 2269 }
2261 2270
2262 2271 void TemplateTable::getfield_or_static(int byte_no, bool is_static) {
2263 2272 transition(vtos, vtos);
2264 2273
2265 2274 const Register cache = rcx;
2266 2275 const Register index = rdx;
2267 2276 const Register obj = c_rarg3;
2268 2277 const Register off = rbx;
2269 2278 const Register flags = rax;
2270 2279 const Register bc = c_rarg3; // uses same reg as obj, so don't mix them
2271 2280
2272 2281 resolve_cache_and_index(byte_no, noreg, cache, index, sizeof(u2));
2273 2282 jvmti_post_field_access(cache, index, is_static, false);
2274 2283 load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
2275 2284
2276 2285 if (!is_static) {
2277 2286 // obj is on the stack
2278 2287 pop_and_check_object(obj);
2279 2288 }
2280 2289
2281 2290 const Address field(obj, off, Address::times_1);
2282 2291
2283 2292 Label Done, notByte, notInt, notShort, notChar,
2284 2293 notLong, notFloat, notObj, notDouble;
2285 2294
2286 2295 __ shrl(flags, ConstantPoolCacheEntry::tosBits);
2287 2296 assert(btos == 0, "change code, btos != 0");
2288 2297
2289 2298 __ andl(flags, 0x0F);
2290 2299 __ jcc(Assembler::notZero, notByte);
2291 2300 // btos
2292 2301 __ load_signed_byte(rax, field);
2293 2302 __ push(btos);
2294 2303 // Rewrite bytecode to be faster
2295 2304 if (!is_static) {
2296 2305 patch_bytecode(Bytecodes::_fast_bgetfield, bc, rbx);
2297 2306 }
2298 2307 __ jmp(Done);
2299 2308
2300 2309 __ bind(notByte);
2301 2310 __ cmpl(flags, atos);
2302 2311 __ jcc(Assembler::notEqual, notObj);
2303 2312 // atos
2304 2313 __ load_heap_oop(rax, field);
2305 2314 __ push(atos);
2306 2315 if (!is_static) {
2307 2316 patch_bytecode(Bytecodes::_fast_agetfield, bc, rbx);
2308 2317 }
2309 2318 __ jmp(Done);
2310 2319
2311 2320 __ bind(notObj);
2312 2321 __ cmpl(flags, itos);
2313 2322 __ jcc(Assembler::notEqual, notInt);
2314 2323 // itos
2315 2324 __ movl(rax, field);
2316 2325 __ push(itos);
2317 2326 // Rewrite bytecode to be faster
2318 2327 if (!is_static) {
2319 2328 patch_bytecode(Bytecodes::_fast_igetfield, bc, rbx);
2320 2329 }
2321 2330 __ jmp(Done);
2322 2331
2323 2332 __ bind(notInt);
2324 2333 __ cmpl(flags, ctos);
2325 2334 __ jcc(Assembler::notEqual, notChar);
2326 2335 // ctos
2327 2336 __ load_unsigned_short(rax, field);
2328 2337 __ push(ctos);
2329 2338 // Rewrite bytecode to be faster
2330 2339 if (!is_static) {
2331 2340 patch_bytecode(Bytecodes::_fast_cgetfield, bc, rbx);
2332 2341 }
2333 2342 __ jmp(Done);
2334 2343
2335 2344 __ bind(notChar);
2336 2345 __ cmpl(flags, stos);
2337 2346 __ jcc(Assembler::notEqual, notShort);
2338 2347 // stos
2339 2348 __ load_signed_short(rax, field);
2340 2349 __ push(stos);
2341 2350 // Rewrite bytecode to be faster
2342 2351 if (!is_static) {
2343 2352 patch_bytecode(Bytecodes::_fast_sgetfield, bc, rbx);
2344 2353 }
2345 2354 __ jmp(Done);
2346 2355
2347 2356 __ bind(notShort);
2348 2357 __ cmpl(flags, ltos);
2349 2358 __ jcc(Assembler::notEqual, notLong);
2350 2359 // ltos
2351 2360 __ movq(rax, field);
2352 2361 __ push(ltos);
2353 2362 // Rewrite bytecode to be faster
2354 2363 if (!is_static) {
2355 2364 patch_bytecode(Bytecodes::_fast_lgetfield, bc, rbx);
2356 2365 }
2357 2366 __ jmp(Done);
2358 2367
2359 2368 __ bind(notLong);
2360 2369 __ cmpl(flags, ftos);
2361 2370 __ jcc(Assembler::notEqual, notFloat);
2362 2371 // ftos
2363 2372 __ movflt(xmm0, field);
2364 2373 __ push(ftos);
2365 2374 // Rewrite bytecode to be faster
2366 2375 if (!is_static) {
2367 2376 patch_bytecode(Bytecodes::_fast_fgetfield, bc, rbx);
2368 2377 }
2369 2378 __ jmp(Done);
2370 2379
2371 2380 __ bind(notFloat);
2372 2381 #ifdef ASSERT
2373 2382 __ cmpl(flags, dtos);
2374 2383 __ jcc(Assembler::notEqual, notDouble);
2375 2384 #endif
2376 2385 // dtos
2377 2386 __ movdbl(xmm0, field);
2378 2387 __ push(dtos);
2379 2388 // Rewrite bytecode to be faster
2380 2389 if (!is_static) {
2381 2390 patch_bytecode(Bytecodes::_fast_dgetfield, bc, rbx);
2382 2391 }
2383 2392 #ifdef ASSERT
2384 2393 __ jmp(Done);
2385 2394
2386 2395 __ bind(notDouble);
2387 2396 __ stop("Bad state");
2388 2397 #endif
2389 2398
2390 2399 __ bind(Done);
2391 2400 // [jk] not needed currently
2392 2401 // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadLoad |
2393 2402 // Assembler::LoadStore));
2394 2403 }
2395 2404
2396 2405
2397 2406 void TemplateTable::getfield(int byte_no) {
2398 2407 getfield_or_static(byte_no, false);
2399 2408 }
2400 2409
2401 2410 void TemplateTable::getstatic(int byte_no) {
2402 2411 getfield_or_static(byte_no, true);
2403 2412 }
2404 2413
2405 2414 // The registers cache and index expected to be set before call.
2406 2415 // The function may destroy various registers, just not the cache and index registers.
2407 2416 void TemplateTable::jvmti_post_field_mod(Register cache, Register index, bool is_static) {
2408 2417 transition(vtos, vtos);
2409 2418
2410 2419 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
2411 2420
2412 2421 if (JvmtiExport::can_post_field_modification()) {
2413 2422 // Check to see if a field modification watch has been set before
2414 2423 // we take the time to call into the VM.
2415 2424 Label L1;
2416 2425 assert_different_registers(cache, index, rax);
2417 2426 __ mov32(rax, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
2418 2427 __ testl(rax, rax);
2419 2428 __ jcc(Assembler::zero, L1);
2420 2429
2421 2430 __ get_cache_and_index_at_bcp(c_rarg2, rscratch1, 1);
2422 2431
2423 2432 if (is_static) {
2424 2433 // Life is simple. Null out the object pointer.
2425 2434 __ xorl(c_rarg1, c_rarg1);
2426 2435 } else {
2427 2436 // Life is harder. The stack holds the value on top, followed by
2428 2437 // the object. We don't know the size of the value, though; it
2429 2438 // could be one or two words depending on its type. As a result,
2430 2439 // we must find the type to determine where the object is.
2431 2440 __ movl(c_rarg3, Address(c_rarg2, rscratch1,
2432 2441 Address::times_8,
2433 2442 in_bytes(cp_base_offset +
2434 2443 ConstantPoolCacheEntry::flags_offset())));
2435 2444 __ shrl(c_rarg3, ConstantPoolCacheEntry::tosBits);
2436 2445 // Make sure we don't need to mask rcx for tosBits after the
2437 2446 // above shift
2438 2447 ConstantPoolCacheEntry::verify_tosBits();
2439 2448 __ movptr(c_rarg1, at_tos_p1()); // initially assume a one word jvalue
2440 2449 __ cmpl(c_rarg3, ltos);
2441 2450 __ cmovptr(Assembler::equal,
2442 2451 c_rarg1, at_tos_p2()); // ltos (two word jvalue)
2443 2452 __ cmpl(c_rarg3, dtos);
2444 2453 __ cmovptr(Assembler::equal,
2445 2454 c_rarg1, at_tos_p2()); // dtos (two word jvalue)
2446 2455 }
2447 2456 // cache entry pointer
2448 2457 __ addptr(c_rarg2, in_bytes(cp_base_offset));
2449 2458 __ shll(rscratch1, LogBytesPerWord);
2450 2459 __ addptr(c_rarg2, rscratch1);
2451 2460 // object (tos)
2452 2461 __ mov(c_rarg3, rsp);
2453 2462 // c_rarg1: object pointer set up above (NULL if static)
2454 2463 // c_rarg2: cache entry pointer
2455 2464 // c_rarg3: jvalue object on the stack
2456 2465 __ call_VM(noreg,
2457 2466 CAST_FROM_FN_PTR(address,
2458 2467 InterpreterRuntime::post_field_modification),
2459 2468 c_rarg1, c_rarg2, c_rarg3);
2460 2469 __ get_cache_and_index_at_bcp(cache, index, 1);
2461 2470 __ bind(L1);
2462 2471 }
2463 2472 }
2464 2473
2465 2474 void TemplateTable::putfield_or_static(int byte_no, bool is_static) {
2466 2475 transition(vtos, vtos);
2467 2476
2468 2477 const Register cache = rcx;
2469 2478 const Register index = rdx;
2470 2479 const Register obj = rcx;
2471 2480 const Register off = rbx;
2472 2481 const Register flags = rax;
2473 2482 const Register bc = c_rarg3;
2474 2483
2475 2484 resolve_cache_and_index(byte_no, noreg, cache, index, sizeof(u2));
2476 2485 jvmti_post_field_mod(cache, index, is_static);
2477 2486 load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
2478 2487
2479 2488 // [jk] not needed currently
2480 2489 // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadStore |
2481 2490 // Assembler::StoreStore));
2482 2491
2483 2492 Label notVolatile, Done;
2484 2493 __ movl(rdx, flags);
2485 2494 __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
2486 2495 __ andl(rdx, 0x1);
2487 2496
2488 2497 // field address
2489 2498 const Address field(obj, off, Address::times_1);
2490 2499
2491 2500 Label notByte, notInt, notShort, notChar,
2492 2501 notLong, notFloat, notObj, notDouble;
2493 2502
2494 2503 __ shrl(flags, ConstantPoolCacheEntry::tosBits);
2495 2504
2496 2505 assert(btos == 0, "change code, btos != 0");
2497 2506 __ andl(flags, 0x0f);
2498 2507 __ jcc(Assembler::notZero, notByte);
2499 2508 // btos
2500 2509 __ pop(btos);
2501 2510 if (!is_static) pop_and_check_object(obj);
2502 2511 __ movb(field, rax);
2503 2512 if (!is_static) {
2504 2513 patch_bytecode(Bytecodes::_fast_bputfield, bc, rbx);
2505 2514 }
2506 2515 __ jmp(Done);
2507 2516
2508 2517 __ bind(notByte);
2509 2518 __ cmpl(flags, atos);
2510 2519 __ jcc(Assembler::notEqual, notObj);
2511 2520 // atos
2512 2521 __ pop(atos);
2513 2522 if (!is_static) pop_and_check_object(obj);
2514 2523
2515 2524 // Store into the field
2516 2525 do_oop_store(_masm, field, rax, _bs->kind(), false);
2517 2526
2518 2527 if (!is_static) {
2519 2528 patch_bytecode(Bytecodes::_fast_aputfield, bc, rbx);
2520 2529 }
2521 2530 __ jmp(Done);
2522 2531
2523 2532 __ bind(notObj);
2524 2533 __ cmpl(flags, itos);
2525 2534 __ jcc(Assembler::notEqual, notInt);
2526 2535 // itos
2527 2536 __ pop(itos);
2528 2537 if (!is_static) pop_and_check_object(obj);
2529 2538 __ movl(field, rax);
2530 2539 if (!is_static) {
2531 2540 patch_bytecode(Bytecodes::_fast_iputfield, bc, rbx);
2532 2541 }
2533 2542 __ jmp(Done);
2534 2543
2535 2544 __ bind(notInt);
2536 2545 __ cmpl(flags, ctos);
2537 2546 __ jcc(Assembler::notEqual, notChar);
2538 2547 // ctos
2539 2548 __ pop(ctos);
2540 2549 if (!is_static) pop_and_check_object(obj);
2541 2550 __ movw(field, rax);
2542 2551 if (!is_static) {
2543 2552 patch_bytecode(Bytecodes::_fast_cputfield, bc, rbx);
2544 2553 }
2545 2554 __ jmp(Done);
2546 2555
2547 2556 __ bind(notChar);
2548 2557 __ cmpl(flags, stos);
2549 2558 __ jcc(Assembler::notEqual, notShort);
2550 2559 // stos
2551 2560 __ pop(stos);
2552 2561 if (!is_static) pop_and_check_object(obj);
2553 2562 __ movw(field, rax);
2554 2563 if (!is_static) {
2555 2564 patch_bytecode(Bytecodes::_fast_sputfield, bc, rbx);
2556 2565 }
2557 2566 __ jmp(Done);
2558 2567
2559 2568 __ bind(notShort);
2560 2569 __ cmpl(flags, ltos);
2561 2570 __ jcc(Assembler::notEqual, notLong);
2562 2571 // ltos
2563 2572 __ pop(ltos);
2564 2573 if (!is_static) pop_and_check_object(obj);
2565 2574 __ movq(field, rax);
2566 2575 if (!is_static) {
2567 2576 patch_bytecode(Bytecodes::_fast_lputfield, bc, rbx);
2568 2577 }
2569 2578 __ jmp(Done);
2570 2579
2571 2580 __ bind(notLong);
2572 2581 __ cmpl(flags, ftos);
2573 2582 __ jcc(Assembler::notEqual, notFloat);
2574 2583 // ftos
2575 2584 __ pop(ftos);
2576 2585 if (!is_static) pop_and_check_object(obj);
2577 2586 __ movflt(field, xmm0);
2578 2587 if (!is_static) {
2579 2588 patch_bytecode(Bytecodes::_fast_fputfield, bc, rbx);
2580 2589 }
2581 2590 __ jmp(Done);
2582 2591
2583 2592 __ bind(notFloat);
2584 2593 #ifdef ASSERT
2585 2594 __ cmpl(flags, dtos);
2586 2595 __ jcc(Assembler::notEqual, notDouble);
2587 2596 #endif
2588 2597 // dtos
2589 2598 __ pop(dtos);
2590 2599 if (!is_static) pop_and_check_object(obj);
2591 2600 __ movdbl(field, xmm0);
2592 2601 if (!is_static) {
2593 2602 patch_bytecode(Bytecodes::_fast_dputfield, bc, rbx);
2594 2603 }
2595 2604
2596 2605 #ifdef ASSERT
2597 2606 __ jmp(Done);
2598 2607
2599 2608 __ bind(notDouble);
2600 2609 __ stop("Bad state");
2601 2610 #endif
2602 2611
2603 2612 __ bind(Done);
2604 2613 // Check for volatile store
2605 2614 __ testl(rdx, rdx);
2606 2615 __ jcc(Assembler::zero, notVolatile);
2607 2616 volatile_barrier(Assembler::Membar_mask_bits(Assembler::StoreLoad |
2608 2617 Assembler::StoreStore));
2609 2618
2610 2619 __ bind(notVolatile);
2611 2620 }
2612 2621
2613 2622 void TemplateTable::putfield(int byte_no) {
2614 2623 putfield_or_static(byte_no, false);
2615 2624 }
2616 2625
2617 2626 void TemplateTable::putstatic(int byte_no) {
2618 2627 putfield_or_static(byte_no, true);
2619 2628 }
2620 2629
2621 2630 void TemplateTable::jvmti_post_fast_field_mod() {
2622 2631 if (JvmtiExport::can_post_field_modification()) {
2623 2632 // Check to see if a field modification watch has been set before
2624 2633 // we take the time to call into the VM.
2625 2634 Label L2;
2626 2635 __ mov32(c_rarg3, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
2627 2636 __ testl(c_rarg3, c_rarg3);
2628 2637 __ jcc(Assembler::zero, L2);
2629 2638 __ pop_ptr(rbx); // copy the object pointer from tos
2630 2639 __ verify_oop(rbx);
2631 2640 __ push_ptr(rbx); // put the object pointer back on tos
2632 2641 __ subptr(rsp, sizeof(jvalue)); // add space for a jvalue object
2633 2642 __ mov(c_rarg3, rsp);
2634 2643 const Address field(c_rarg3, 0);
2635 2644
2636 2645 switch (bytecode()) { // load values into the jvalue object
2637 2646 case Bytecodes::_fast_aputfield: __ movq(field, rax); break;
2638 2647 case Bytecodes::_fast_lputfield: __ movq(field, rax); break;
2639 2648 case Bytecodes::_fast_iputfield: __ movl(field, rax); break;
2640 2649 case Bytecodes::_fast_bputfield: __ movb(field, rax); break;
2641 2650 case Bytecodes::_fast_sputfield: // fall through
2642 2651 case Bytecodes::_fast_cputfield: __ movw(field, rax); break;
2643 2652 case Bytecodes::_fast_fputfield: __ movflt(field, xmm0); break;
2644 2653 case Bytecodes::_fast_dputfield: __ movdbl(field, xmm0); break;
2645 2654 default:
2646 2655 ShouldNotReachHere();
2647 2656 }
2648 2657
2649 2658 // Save rax because call_VM() will clobber it, then use it for
2650 2659 // JVMTI purposes
2651 2660 __ push(rax);
2652 2661 // access constant pool cache entry
2653 2662 __ get_cache_entry_pointer_at_bcp(c_rarg2, rax, 1);
2654 2663 __ verify_oop(rbx);
2655 2664 // rbx: object pointer copied above
2656 2665 // c_rarg2: cache entry pointer
2657 2666 // c_rarg3: jvalue object on the stack
2658 2667 __ call_VM(noreg,
2659 2668 CAST_FROM_FN_PTR(address,
2660 2669 InterpreterRuntime::post_field_modification),
2661 2670 rbx, c_rarg2, c_rarg3);
2662 2671 __ pop(rax); // restore lower value
2663 2672 __ addptr(rsp, sizeof(jvalue)); // release jvalue object space
2664 2673 __ bind(L2);
2665 2674 }
2666 2675 }
2667 2676
2668 2677 void TemplateTable::fast_storefield(TosState state) {
2669 2678 transition(state, vtos);
2670 2679
2671 2680 ByteSize base = constantPoolCacheOopDesc::base_offset();
2672 2681
2673 2682 jvmti_post_fast_field_mod();
2674 2683
2675 2684 // access constant pool cache
2676 2685 __ get_cache_and_index_at_bcp(rcx, rbx, 1);
2677 2686
2678 2687 // test for volatile with rdx
2679 2688 __ movl(rdx, Address(rcx, rbx, Address::times_8,
2680 2689 in_bytes(base +
2681 2690 ConstantPoolCacheEntry::flags_offset())));
2682 2691
2683 2692 // replace index with field offset from cache entry
2684 2693 __ movptr(rbx, Address(rcx, rbx, Address::times_8,
2685 2694 in_bytes(base + ConstantPoolCacheEntry::f2_offset())));
2686 2695
2687 2696 // [jk] not needed currently
2688 2697 // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadStore |
2689 2698 // Assembler::StoreStore));
2690 2699
2691 2700 Label notVolatile;
2692 2701 __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
2693 2702 __ andl(rdx, 0x1);
2694 2703
2695 2704 // Get object from stack
2696 2705 pop_and_check_object(rcx);
2697 2706
2698 2707 // field address
2699 2708 const Address field(rcx, rbx, Address::times_1);
2700 2709
2701 2710 // access field
2702 2711 switch (bytecode()) {
2703 2712 case Bytecodes::_fast_aputfield:
2704 2713 do_oop_store(_masm, field, rax, _bs->kind(), false);
2705 2714 break;
2706 2715 case Bytecodes::_fast_lputfield:
2707 2716 __ movq(field, rax);
2708 2717 break;
2709 2718 case Bytecodes::_fast_iputfield:
2710 2719 __ movl(field, rax);
2711 2720 break;
2712 2721 case Bytecodes::_fast_bputfield:
2713 2722 __ movb(field, rax);
2714 2723 break;
2715 2724 case Bytecodes::_fast_sputfield:
2716 2725 // fall through
2717 2726 case Bytecodes::_fast_cputfield:
2718 2727 __ movw(field, rax);
2719 2728 break;
2720 2729 case Bytecodes::_fast_fputfield:
2721 2730 __ movflt(field, xmm0);
2722 2731 break;
2723 2732 case Bytecodes::_fast_dputfield:
2724 2733 __ movdbl(field, xmm0);
2725 2734 break;
2726 2735 default:
2727 2736 ShouldNotReachHere();
2728 2737 }
2729 2738
2730 2739 // Check for volatile store
2731 2740 __ testl(rdx, rdx);
2732 2741 __ jcc(Assembler::zero, notVolatile);
2733 2742 volatile_barrier(Assembler::Membar_mask_bits(Assembler::StoreLoad |
2734 2743 Assembler::StoreStore));
2735 2744 __ bind(notVolatile);
2736 2745 }
2737 2746
2738 2747
2739 2748 void TemplateTable::fast_accessfield(TosState state) {
2740 2749 transition(atos, state);
2741 2750
2742 2751 // Do the JVMTI work here to avoid disturbing the register state below
2743 2752 if (JvmtiExport::can_post_field_access()) {
2744 2753 // Check to see if a field access watch has been set before we
2745 2754 // take the time to call into the VM.
2746 2755 Label L1;
2747 2756 __ mov32(rcx, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
2748 2757 __ testl(rcx, rcx);
2749 2758 __ jcc(Assembler::zero, L1);
2750 2759 // access constant pool cache entry
2751 2760 __ get_cache_entry_pointer_at_bcp(c_rarg2, rcx, 1);
2752 2761 __ verify_oop(rax);
2753 2762 __ push_ptr(rax); // save object pointer before call_VM() clobbers it
2754 2763 __ mov(c_rarg1, rax);
2755 2764 // c_rarg1: object pointer copied above
2756 2765 // c_rarg2: cache entry pointer
2757 2766 __ call_VM(noreg,
2758 2767 CAST_FROM_FN_PTR(address,
2759 2768 InterpreterRuntime::post_field_access),
2760 2769 c_rarg1, c_rarg2);
2761 2770 __ pop_ptr(rax); // restore object pointer
2762 2771 __ bind(L1);
2763 2772 }
2764 2773
2765 2774 // access constant pool cache
2766 2775 __ get_cache_and_index_at_bcp(rcx, rbx, 1);
2767 2776 // replace index with field offset from cache entry
2768 2777 // [jk] not needed currently
2769 2778 // if (os::is_MP()) {
2770 2779 // __ movl(rdx, Address(rcx, rbx, Address::times_8,
2771 2780 // in_bytes(constantPoolCacheOopDesc::base_offset() +
2772 2781 // ConstantPoolCacheEntry::flags_offset())));
2773 2782 // __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
2774 2783 // __ andl(rdx, 0x1);
2775 2784 // }
2776 2785 __ movptr(rbx, Address(rcx, rbx, Address::times_8,
2777 2786 in_bytes(constantPoolCacheOopDesc::base_offset() +
2778 2787 ConstantPoolCacheEntry::f2_offset())));
2779 2788
2780 2789 // rax: object
2781 2790 __ verify_oop(rax);
2782 2791 __ null_check(rax);
2783 2792 Address field(rax, rbx, Address::times_1);
2784 2793
2785 2794 // access field
2786 2795 switch (bytecode()) {
2787 2796 case Bytecodes::_fast_agetfield:
2788 2797 __ load_heap_oop(rax, field);
2789 2798 __ verify_oop(rax);
2790 2799 break;
2791 2800 case Bytecodes::_fast_lgetfield:
2792 2801 __ movq(rax, field);
2793 2802 break;
2794 2803 case Bytecodes::_fast_igetfield:
2795 2804 __ movl(rax, field);
2796 2805 break;
2797 2806 case Bytecodes::_fast_bgetfield:
2798 2807 __ movsbl(rax, field);
2799 2808 break;
2800 2809 case Bytecodes::_fast_sgetfield:
2801 2810 __ load_signed_short(rax, field);
2802 2811 break;
2803 2812 case Bytecodes::_fast_cgetfield:
2804 2813 __ load_unsigned_short(rax, field);
2805 2814 break;
2806 2815 case Bytecodes::_fast_fgetfield:
2807 2816 __ movflt(xmm0, field);
2808 2817 break;
2809 2818 case Bytecodes::_fast_dgetfield:
2810 2819 __ movdbl(xmm0, field);
2811 2820 break;
2812 2821 default:
2813 2822 ShouldNotReachHere();
2814 2823 }
2815 2824 // [jk] not needed currently
2816 2825 // if (os::is_MP()) {
2817 2826 // Label notVolatile;
2818 2827 // __ testl(rdx, rdx);
2819 2828 // __ jcc(Assembler::zero, notVolatile);
2820 2829 // __ membar(Assembler::LoadLoad);
2821 2830 // __ bind(notVolatile);
2822 2831 //};
2823 2832 }
2824 2833
2825 2834 void TemplateTable::fast_xaccess(TosState state) {
2826 2835 transition(vtos, state);
2827 2836
2828 2837 // get receiver
2829 2838 __ movptr(rax, aaddress(0));
2830 2839 // access constant pool cache
2831 2840 __ get_cache_and_index_at_bcp(rcx, rdx, 2);
2832 2841 __ movptr(rbx,
2833 2842 Address(rcx, rdx, Address::times_8,
2834 2843 in_bytes(constantPoolCacheOopDesc::base_offset() +
2835 2844 ConstantPoolCacheEntry::f2_offset())));
2836 2845 // make sure exception is reported in correct bcp range (getfield is
2837 2846 // next instruction)
2838 2847 __ increment(r13);
2839 2848 __ null_check(rax);
2840 2849 switch (state) {
2841 2850 case itos:
2842 2851 __ movl(rax, Address(rax, rbx, Address::times_1));
2843 2852 break;
2844 2853 case atos:
2845 2854 __ load_heap_oop(rax, Address(rax, rbx, Address::times_1));
2846 2855 __ verify_oop(rax);
2847 2856 break;
2848 2857 case ftos:
2849 2858 __ movflt(xmm0, Address(rax, rbx, Address::times_1));
2850 2859 break;
2851 2860 default:
2852 2861 ShouldNotReachHere();
2853 2862 }
2854 2863
2855 2864 // [jk] not needed currently
2856 2865 // if (os::is_MP()) {
2857 2866 // Label notVolatile;
2858 2867 // __ movl(rdx, Address(rcx, rdx, Address::times_8,
2859 2868 // in_bytes(constantPoolCacheOopDesc::base_offset() +
2860 2869 // ConstantPoolCacheEntry::flags_offset())));
2861 2870 // __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
2862 2871 // __ testl(rdx, 0x1);
2863 2872 // __ jcc(Assembler::zero, notVolatile);
2864 2873 // __ membar(Assembler::LoadLoad);
2865 2874 // __ bind(notVolatile);
2866 2875 // }
2867 2876
2868 2877 __ decrement(r13);
2869 2878 }
2870 2879
2871 2880
2872 2881
2873 2882 //-----------------------------------------------------------------------------
2874 2883 // Calls
2875 2884
2876 2885 void TemplateTable::count_calls(Register method, Register temp) {
2877 2886 // implemented elsewhere
2878 2887 ShouldNotReachHere();
2879 2888 }
2880 2889
2881 2890 void TemplateTable::prepare_invoke(Register method, Register index, int byte_no) {
2882 2891 // determine flags
2883 2892 Bytecodes::Code code = bytecode();
2884 2893 const bool is_invokeinterface = code == Bytecodes::_invokeinterface;
2885 2894 const bool is_invokedynamic = code == Bytecodes::_invokedynamic;
2886 2895 const bool is_invokevirtual = code == Bytecodes::_invokevirtual;
2887 2896 const bool is_invokespecial = code == Bytecodes::_invokespecial;
2888 2897 const bool load_receiver = (code != Bytecodes::_invokestatic && code != Bytecodes::_invokedynamic);
2889 2898 const bool receiver_null_check = is_invokespecial;
2890 2899 const bool save_flags = is_invokeinterface || is_invokevirtual;
2891 2900 // setup registers & access constant pool cache
2892 2901 const Register recv = rcx;
2893 2902 const Register flags = rdx;
2894 2903 assert_different_registers(method, index, recv, flags);
2895 2904
2896 2905 // save 'interpreter return address'
2897 2906 __ save_bcp();
2898 2907
2899 2908 load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic);
2900 2909
2901 2910 // load receiver if needed (note: no return address pushed yet)
2902 2911 if (load_receiver) {
2903 2912 assert(!is_invokedynamic, "");
2904 2913 __ movl(recv, flags);
2905 2914 __ andl(recv, 0xFF);
2906 2915 Address recv_addr(rsp, recv, Address::times_8, -Interpreter::expr_offset_in_bytes(1));
2907 2916 __ movptr(recv, recv_addr);
2908 2917 __ verify_oop(recv);
2909 2918 }
2910 2919
2911 2920 // do null check if needed
2912 2921 if (receiver_null_check) {
2913 2922 __ null_check(recv);
2914 2923 }
2915 2924
2916 2925 if (save_flags) {
2917 2926 __ movl(r13, flags);
2918 2927 }
2919 2928
2920 2929 // compute return type
2921 2930 __ shrl(flags, ConstantPoolCacheEntry::tosBits);
2922 2931 // Make sure we don't need to mask flags for tosBits after the above shift
2923 2932 ConstantPoolCacheEntry::verify_tosBits();
2924 2933 // load return address
2925 2934 {
2926 2935 address table_addr;
2927 2936 if (is_invokeinterface || is_invokedynamic)
2928 2937 table_addr = (address)Interpreter::return_5_addrs_by_index_table();
2929 2938 else
2930 2939 table_addr = (address)Interpreter::return_3_addrs_by_index_table();
2931 2940 ExternalAddress table(table_addr);
2932 2941 __ lea(rscratch1, table);
2933 2942 __ movptr(flags, Address(rscratch1, flags, Address::times_ptr));
2934 2943 }
2935 2944
2936 2945 // push return address
2937 2946 __ push(flags);
2938 2947
2939 2948 // Restore flag field from the constant pool cache, and restore esi
2940 2949 // for later null checks. r13 is the bytecode pointer
2941 2950 if (save_flags) {
2942 2951 __ movl(flags, r13);
2943 2952 __ restore_bcp();
2944 2953 }
2945 2954 }
2946 2955
2947 2956
2948 2957 void TemplateTable::invokevirtual_helper(Register index,
2949 2958 Register recv,
2950 2959 Register flags) {
2951 2960 // Uses temporary registers rax, rdx
2952 2961 assert_different_registers(index, recv, rax, rdx);
2953 2962
2954 2963 // Test for an invoke of a final method
2955 2964 Label notFinal;
2956 2965 __ movl(rax, flags);
2957 2966 __ andl(rax, (1 << ConstantPoolCacheEntry::vfinalMethod));
2958 2967 __ jcc(Assembler::zero, notFinal);
2959 2968
2960 2969 const Register method = index; // method must be rbx
2961 2970 assert(method == rbx,
2962 2971 "methodOop must be rbx for interpreter calling convention");
2963 2972
2964 2973 // do the call - the index is actually the method to call
2965 2974 __ verify_oop(method);
2966 2975
2967 2976 // It's final, need a null check here!
2968 2977 __ null_check(recv);
2969 2978
2970 2979 // profile this call
2971 2980 __ profile_final_call(rax);
2972 2981
2973 2982 __ jump_from_interpreted(method, rax);
2974 2983
2975 2984 __ bind(notFinal);
2976 2985
2977 2986 // get receiver klass
2978 2987 __ null_check(recv, oopDesc::klass_offset_in_bytes());
2979 2988 __ load_klass(rax, recv);
2980 2989
2981 2990 __ verify_oop(rax);
2982 2991
2983 2992 // profile this call
2984 2993 __ profile_virtual_call(rax, r14, rdx);
2985 2994
2986 2995 // get target methodOop & entry point
2987 2996 const int base = instanceKlass::vtable_start_offset() * wordSize;
2988 2997 assert(vtableEntry::size() * wordSize == 8,
2989 2998 "adjust the scaling in the code below");
2990 2999 __ movptr(method, Address(rax, index,
2991 3000 Address::times_8,
2992 3001 base + vtableEntry::method_offset_in_bytes()));
2993 3002 __ movptr(rdx, Address(method, methodOopDesc::interpreter_entry_offset()));
2994 3003 __ jump_from_interpreted(method, rdx);
2995 3004 }
2996 3005
2997 3006
2998 3007 void TemplateTable::invokevirtual(int byte_no) {
2999 3008 transition(vtos, vtos);
3000 3009 assert(byte_no == f2_byte, "use this argument");
3001 3010 prepare_invoke(rbx, noreg, byte_no);
3002 3011
3003 3012 // rbx: index
3004 3013 // rcx: receiver
3005 3014 // rdx: flags
3006 3015
3007 3016 invokevirtual_helper(rbx, rcx, rdx);
3008 3017 }
3009 3018
3010 3019
3011 3020 void TemplateTable::invokespecial(int byte_no) {
3012 3021 transition(vtos, vtos);
3013 3022 assert(byte_no == f1_byte, "use this argument");
3014 3023 prepare_invoke(rbx, noreg, byte_no);
3015 3024 // do the call
3016 3025 __ verify_oop(rbx);
3017 3026 __ profile_call(rax);
3018 3027 __ jump_from_interpreted(rbx, rax);
3019 3028 }
3020 3029
3021 3030
3022 3031 void TemplateTable::invokestatic(int byte_no) {
3023 3032 transition(vtos, vtos);
3024 3033 assert(byte_no == f1_byte, "use this argument");
3025 3034 prepare_invoke(rbx, noreg, byte_no);
3026 3035 // do the call
3027 3036 __ verify_oop(rbx);
3028 3037 __ profile_call(rax);
3029 3038 __ jump_from_interpreted(rbx, rax);
3030 3039 }
3031 3040
3032 3041 void TemplateTable::fast_invokevfinal(int byte_no) {
3033 3042 transition(vtos, vtos);
3034 3043 assert(byte_no == f2_byte, "use this argument");
3035 3044 __ stop("fast_invokevfinal not used on amd64");
3036 3045 }
3037 3046
3038 3047 void TemplateTable::invokeinterface(int byte_no) {
3039 3048 transition(vtos, vtos);
3040 3049 assert(byte_no == f1_byte, "use this argument");
3041 3050 prepare_invoke(rax, rbx, byte_no);
3042 3051
3043 3052 // rax: Interface
3044 3053 // rbx: index
3045 3054 // rcx: receiver
3046 3055 // rdx: flags
3047 3056
3048 3057 // Special case of invokeinterface called for virtual method of
3049 3058 // java.lang.Object. See cpCacheOop.cpp for details.
3050 3059 // This code isn't produced by javac, but could be produced by
3051 3060 // another compliant java compiler.
3052 3061 Label notMethod;
3053 3062 __ movl(r14, rdx);
3054 3063 __ andl(r14, (1 << ConstantPoolCacheEntry::methodInterface));
3055 3064 __ jcc(Assembler::zero, notMethod);
3056 3065
3057 3066 invokevirtual_helper(rbx, rcx, rdx);
3058 3067 __ bind(notMethod);
3059 3068
3060 3069 // Get receiver klass into rdx - also a null check
3061 3070 __ restore_locals(); // restore r14
3062 3071 __ load_klass(rdx, rcx);
3063 3072 __ verify_oop(rdx);
3064 3073
3065 3074 // profile this call
3066 3075 __ profile_virtual_call(rdx, r13, r14);
3067 3076
3068 3077 Label no_such_interface, no_such_method;
3069 3078
3070 3079 __ lookup_interface_method(// inputs: rec. class, interface, itable index
3071 3080 rdx, rax, rbx,
3072 3081 // outputs: method, scan temp. reg
3073 3082 rbx, r13,
3074 3083 no_such_interface);
3075 3084
3076 3085 // rbx,: methodOop to call
3077 3086 // rcx: receiver
3078 3087 // Check for abstract method error
3079 3088 // Note: This should be done more efficiently via a throw_abstract_method_error
3080 3089 // interpreter entry point and a conditional jump to it in case of a null
3081 3090 // method.
3082 3091 __ testptr(rbx, rbx);
3083 3092 __ jcc(Assembler::zero, no_such_method);
3084 3093
3085 3094 // do the call
3086 3095 // rcx: receiver
3087 3096 // rbx,: methodOop
3088 3097 __ jump_from_interpreted(rbx, rdx);
3089 3098 __ should_not_reach_here();
3090 3099
3091 3100 // exception handling code follows...
3092 3101 // note: must restore interpreter registers to canonical
3093 3102 // state for exception handling to work correctly!
3094 3103
3095 3104 __ bind(no_such_method);
3096 3105 // throw exception
3097 3106 __ pop(rbx); // pop return address (pushed by prepare_invoke)
3098 3107 __ restore_bcp(); // r13 must be correct for exception handler (was destroyed)
3099 3108 __ restore_locals(); // make sure locals pointer is correct as well (was destroyed)
3100 3109 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError));
3101 3110 // the call_VM checks for exception, so we should never return here.
3102 3111 __ should_not_reach_here();
3103 3112
3104 3113 __ bind(no_such_interface);
3105 3114 // throw exception
3106 3115 __ pop(rbx); // pop return address (pushed by prepare_invoke)
3107 3116 __ restore_bcp(); // r13 must be correct for exception handler (was destroyed)
3108 3117 __ restore_locals(); // make sure locals pointer is correct as well (was destroyed)
3109 3118 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
3110 3119 InterpreterRuntime::throw_IncompatibleClassChangeError));
3111 3120 // the call_VM checks for exception, so we should never return here.
3112 3121 __ should_not_reach_here();
3113 3122 return;
3114 3123 }
3115 3124
3116 3125 void TemplateTable::invokedynamic(int byte_no) {
3117 3126 transition(vtos, vtos);
3118 3127 assert(byte_no == f1_oop, "use this argument");
3119 3128
3120 3129 if (!EnableInvokeDynamic) {
3121 3130 // We should not encounter this bytecode if !EnableInvokeDynamic.
3122 3131 // The verifier will stop it. However, if we get past the verifier,
3123 3132 // this will stop the thread in a reasonable way, without crashing the JVM.
3124 3133 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
3125 3134 InterpreterRuntime::throw_IncompatibleClassChangeError));
3126 3135 // the call_VM checks for exception, so we should never return here.
3127 3136 __ should_not_reach_here();
3128 3137 return;
3129 3138 }
3130 3139
3131 3140 assert(byte_no == f1_oop, "use this argument");
3132 3141 prepare_invoke(rax, rbx, byte_no);
3133 3142
3134 3143 // rax: CallSite object (f1)
3135 3144 // rbx: unused (f2)
3136 3145 // rcx: receiver address
3137 3146 // rdx: flags (unused)
3138 3147
3139 3148 Register rax_callsite = rax;
3140 3149 Register rcx_method_handle = rcx;
3141 3150
3142 3151 if (ProfileInterpreter) {
3143 3152 // %%% should make a type profile for any invokedynamic that takes a ref argument
3144 3153 // profile this call
3145 3154 __ profile_call(r13);
3146 3155 }
3147 3156
3148 3157 __ load_heap_oop(rcx_method_handle, Address(rax_callsite, __ delayed_value(java_dyn_CallSite::target_offset_in_bytes, rcx)));
3149 3158 __ null_check(rcx_method_handle);
3150 3159 __ prepare_to_jump_from_interpreted();
3151 3160 __ jump_to_method_handle_entry(rcx_method_handle, rdx);
3152 3161 }
3153 3162
3154 3163
3155 3164 //-----------------------------------------------------------------------------
3156 3165 // Allocation
3157 3166
3158 3167 void TemplateTable::_new() {
3159 3168 transition(vtos, atos);
3160 3169 __ get_unsigned_2_byte_index_at_bcp(rdx, 1);
3161 3170 Label slow_case;
3162 3171 Label done;
3163 3172 Label initialize_header;
3164 3173 Label initialize_object; // including clearing the fields
3165 3174 Label allocate_shared;
3166 3175
3167 3176 __ get_cpool_and_tags(rsi, rax);
3168 3177 // Make sure the class we're about to instantiate has been resolved.
3169 3178 // This is done before loading instanceKlass to be consistent with the order
3170 3179 // how Constant Pool is updated (see constantPoolOopDesc::klass_at_put)
3171 3180 const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
3172 3181 __ cmpb(Address(rax, rdx, Address::times_1, tags_offset),
3173 3182 JVM_CONSTANT_Class);
3174 3183 __ jcc(Assembler::notEqual, slow_case);
3175 3184
3176 3185 // get instanceKlass
3177 3186 __ movptr(rsi, Address(rsi, rdx,
3178 3187 Address::times_8, sizeof(constantPoolOopDesc)));
3179 3188
3180 3189 // make sure klass is initialized & doesn't have finalizer
3181 3190 // make sure klass is fully initialized
3182 3191 __ cmpl(Address(rsi,
3183 3192 instanceKlass::init_state_offset_in_bytes() +
3184 3193 sizeof(oopDesc)),
3185 3194 instanceKlass::fully_initialized);
3186 3195 __ jcc(Assembler::notEqual, slow_case);
3187 3196
3188 3197 // get instance_size in instanceKlass (scaled to a count of bytes)
3189 3198 __ movl(rdx,
3190 3199 Address(rsi,
3191 3200 Klass::layout_helper_offset_in_bytes() + sizeof(oopDesc)));
3192 3201 // test to see if it has a finalizer or is malformed in some way
3193 3202 __ testl(rdx, Klass::_lh_instance_slow_path_bit);
3194 3203 __ jcc(Assembler::notZero, slow_case);
3195 3204
3196 3205 // Allocate the instance
3197 3206 // 1) Try to allocate in the TLAB
3198 3207 // 2) if fail and the object is large allocate in the shared Eden
3199 3208 // 3) if the above fails (or is not applicable), go to a slow case
3200 3209 // (creates a new TLAB, etc.)
3201 3210
3202 3211 const bool allow_shared_alloc =
3203 3212 Universe::heap()->supports_inline_contig_alloc() && !CMSIncrementalMode;
3204 3213
3205 3214 if (UseTLAB) {
3206 3215 __ movptr(rax, Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())));
3207 3216 __ lea(rbx, Address(rax, rdx, Address::times_1));
3208 3217 __ cmpptr(rbx, Address(r15_thread, in_bytes(JavaThread::tlab_end_offset())));
3209 3218 __ jcc(Assembler::above, allow_shared_alloc ? allocate_shared : slow_case);
3210 3219 __ movptr(Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())), rbx);
3211 3220 if (ZeroTLAB) {
3212 3221 // the fields have been already cleared
3213 3222 __ jmp(initialize_header);
3214 3223 } else {
3215 3224 // initialize both the header and fields
3216 3225 __ jmp(initialize_object);
3217 3226 }
3218 3227 }
3219 3228
3220 3229 // Allocation in the shared Eden, if allowed.
3221 3230 //
3222 3231 // rdx: instance size in bytes
3223 3232 if (allow_shared_alloc) {
3224 3233 __ bind(allocate_shared);
3225 3234
3226 3235 ExternalAddress top((address)Universe::heap()->top_addr());
3227 3236 ExternalAddress end((address)Universe::heap()->end_addr());
3228 3237
3229 3238 const Register RtopAddr = rscratch1;
3230 3239 const Register RendAddr = rscratch2;
3231 3240
3232 3241 __ lea(RtopAddr, top);
3233 3242 __ lea(RendAddr, end);
3234 3243 __ movptr(rax, Address(RtopAddr, 0));
3235 3244
3236 3245 // For retries rax gets set by cmpxchgq
3237 3246 Label retry;
3238 3247 __ bind(retry);
3239 3248 __ lea(rbx, Address(rax, rdx, Address::times_1));
3240 3249 __ cmpptr(rbx, Address(RendAddr, 0));
3241 3250 __ jcc(Assembler::above, slow_case);
3242 3251
3243 3252 // Compare rax with the top addr, and if still equal, store the new
3244 3253 // top addr in rbx at the address of the top addr pointer. Sets ZF if was
3245 3254 // equal, and clears it otherwise. Use lock prefix for atomicity on MPs.
3246 3255 //
3247 3256 // rax: object begin
3248 3257 // rbx: object end
3249 3258 // rdx: instance size in bytes
3250 3259 if (os::is_MP()) {
3251 3260 __ lock();
3252 3261 }
3253 3262 __ cmpxchgptr(rbx, Address(RtopAddr, 0));
3254 3263
3255 3264 // if someone beat us on the allocation, try again, otherwise continue
3256 3265 __ jcc(Assembler::notEqual, retry);
3257 3266
3258 3267 __ incr_allocated_bytes(r15_thread, rdx, 0);
3259 3268 }
3260 3269
3261 3270 if (UseTLAB || Universe::heap()->supports_inline_contig_alloc()) {
3262 3271 // The object is initialized before the header. If the object size is
3263 3272 // zero, go directly to the header initialization.
3264 3273 __ bind(initialize_object);
3265 3274 __ decrementl(rdx, sizeof(oopDesc));
3266 3275 __ jcc(Assembler::zero, initialize_header);
3267 3276
3268 3277 // Initialize object fields
3269 3278 __ xorl(rcx, rcx); // use zero reg to clear memory (shorter code)
3270 3279 __ shrl(rdx, LogBytesPerLong); // divide by oopSize to simplify the loop
3271 3280 {
3272 3281 Label loop;
3273 3282 __ bind(loop);
3274 3283 __ movq(Address(rax, rdx, Address::times_8,
3275 3284 sizeof(oopDesc) - oopSize),
3276 3285 rcx);
3277 3286 __ decrementl(rdx);
3278 3287 __ jcc(Assembler::notZero, loop);
3279 3288 }
3280 3289
3281 3290 // initialize object header only.
3282 3291 __ bind(initialize_header);
3283 3292 if (UseBiasedLocking) {
3284 3293 __ movptr(rscratch1, Address(rsi, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
3285 3294 __ movptr(Address(rax, oopDesc::mark_offset_in_bytes()), rscratch1);
3286 3295 } else {
3287 3296 __ movptr(Address(rax, oopDesc::mark_offset_in_bytes()),
3288 3297 (intptr_t) markOopDesc::prototype()); // header (address 0x1)
3289 3298 }
3290 3299 __ xorl(rcx, rcx); // use zero reg to clear memory (shorter code)
3291 3300 __ store_klass_gap(rax, rcx); // zero klass gap for compressed oops
3292 3301 __ store_klass(rax, rsi); // store klass last
3293 3302
3294 3303 {
3295 3304 SkipIfEqual skip(_masm, &DTraceAllocProbes, false);
3296 3305 // Trigger dtrace event for fastpath
3297 3306 __ push(atos); // save the return value
3298 3307 __ call_VM_leaf(
3299 3308 CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc), rax);
3300 3309 __ pop(atos); // restore the return value
3301 3310
3302 3311 }
3303 3312 __ jmp(done);
3304 3313 }
3305 3314
3306 3315
3307 3316 // slow case
3308 3317 __ bind(slow_case);
3309 3318 __ get_constant_pool(c_rarg1);
3310 3319 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3311 3320 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
3312 3321 __ verify_oop(rax);
3313 3322
3314 3323 // continue
3315 3324 __ bind(done);
3316 3325 }
3317 3326
3318 3327 void TemplateTable::newarray() {
3319 3328 transition(itos, atos);
3320 3329 __ load_unsigned_byte(c_rarg1, at_bcp(1));
3321 3330 __ movl(c_rarg2, rax);
3322 3331 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
3323 3332 c_rarg1, c_rarg2);
3324 3333 }
3325 3334
3326 3335 void TemplateTable::anewarray() {
3327 3336 transition(itos, atos);
3328 3337 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3329 3338 __ get_constant_pool(c_rarg1);
3330 3339 __ movl(c_rarg3, rax);
3331 3340 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::anewarray),
3332 3341 c_rarg1, c_rarg2, c_rarg3);
3333 3342 }
3334 3343
3335 3344 void TemplateTable::arraylength() {
3336 3345 transition(atos, itos);
3337 3346 __ null_check(rax, arrayOopDesc::length_offset_in_bytes());
3338 3347 __ movl(rax, Address(rax, arrayOopDesc::length_offset_in_bytes()));
3339 3348 }
3340 3349
3341 3350 void TemplateTable::checkcast() {
3342 3351 transition(atos, atos);
3343 3352 Label done, is_null, ok_is_subtype, quicked, resolved;
3344 3353 __ testptr(rax, rax); // object is in rax
3345 3354 __ jcc(Assembler::zero, is_null);
3346 3355
3347 3356 // Get cpool & tags index
3348 3357 __ get_cpool_and_tags(rcx, rdx); // rcx=cpool, rdx=tags array
3349 3358 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // rbx=index
3350 3359 // See if bytecode has already been quicked
3351 3360 __ cmpb(Address(rdx, rbx,
3352 3361 Address::times_1,
3353 3362 typeArrayOopDesc::header_size(T_BYTE) * wordSize),
3354 3363 JVM_CONSTANT_Class);
3355 3364 __ jcc(Assembler::equal, quicked);
3356 3365 __ push(atos); // save receiver for result, and for GC
3357 3366 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
3358 3367 __ pop_ptr(rdx); // restore receiver
3359 3368 __ jmpb(resolved);
3360 3369
3361 3370 // Get superklass in rax and subklass in rbx
3362 3371 __ bind(quicked);
3363 3372 __ mov(rdx, rax); // Save object in rdx; rax needed for subtype check
3364 3373 __ movptr(rax, Address(rcx, rbx,
3365 3374 Address::times_8, sizeof(constantPoolOopDesc)));
3366 3375
3367 3376 __ bind(resolved);
3368 3377 __ load_klass(rbx, rdx);
3369 3378
3370 3379 // Generate subtype check. Blows rcx, rdi. Object in rdx.
3371 3380 // Superklass in rax. Subklass in rbx.
3372 3381 __ gen_subtype_check(rbx, ok_is_subtype);
3373 3382
3374 3383 // Come here on failure
3375 3384 __ push_ptr(rdx);
3376 3385 // object is at TOS
3377 3386 __ jump(ExternalAddress(Interpreter::_throw_ClassCastException_entry));
3378 3387
3379 3388 // Come here on success
3380 3389 __ bind(ok_is_subtype);
3381 3390 __ mov(rax, rdx); // Restore object in rdx
3382 3391
3383 3392 // Collect counts on whether this check-cast sees NULLs a lot or not.
3384 3393 if (ProfileInterpreter) {
3385 3394 __ jmp(done);
3386 3395 __ bind(is_null);
3387 3396 __ profile_null_seen(rcx);
3388 3397 } else {
3389 3398 __ bind(is_null); // same as 'done'
3390 3399 }
3391 3400 __ bind(done);
3392 3401 }
3393 3402
3394 3403 void TemplateTable::instanceof() {
3395 3404 transition(atos, itos);
3396 3405 Label done, is_null, ok_is_subtype, quicked, resolved;
3397 3406 __ testptr(rax, rax);
3398 3407 __ jcc(Assembler::zero, is_null);
3399 3408
3400 3409 // Get cpool & tags index
3401 3410 __ get_cpool_and_tags(rcx, rdx); // rcx=cpool, rdx=tags array
3402 3411 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // rbx=index
3403 3412 // See if bytecode has already been quicked
3404 3413 __ cmpb(Address(rdx, rbx,
3405 3414 Address::times_1,
3406 3415 typeArrayOopDesc::header_size(T_BYTE) * wordSize),
3407 3416 JVM_CONSTANT_Class);
3408 3417 __ jcc(Assembler::equal, quicked);
3409 3418
3410 3419 __ push(atos); // save receiver for result, and for GC
3411 3420 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
3412 3421 __ pop_ptr(rdx); // restore receiver
3413 3422 __ verify_oop(rdx);
3414 3423 __ load_klass(rdx, rdx);
3415 3424 __ jmpb(resolved);
3416 3425
3417 3426 // Get superklass in rax and subklass in rdx
3418 3427 __ bind(quicked);
3419 3428 __ load_klass(rdx, rax);
3420 3429 __ movptr(rax, Address(rcx, rbx,
3421 3430 Address::times_8, sizeof(constantPoolOopDesc)));
3422 3431
3423 3432 __ bind(resolved);
3424 3433
3425 3434 // Generate subtype check. Blows rcx, rdi
3426 3435 // Superklass in rax. Subklass in rdx.
3427 3436 __ gen_subtype_check(rdx, ok_is_subtype);
3428 3437
3429 3438 // Come here on failure
3430 3439 __ xorl(rax, rax);
3431 3440 __ jmpb(done);
3432 3441 // Come here on success
3433 3442 __ bind(ok_is_subtype);
3434 3443 __ movl(rax, 1);
3435 3444
3436 3445 // Collect counts on whether this test sees NULLs a lot or not.
3437 3446 if (ProfileInterpreter) {
3438 3447 __ jmp(done);
3439 3448 __ bind(is_null);
3440 3449 __ profile_null_seen(rcx);
3441 3450 } else {
3442 3451 __ bind(is_null); // same as 'done'
3443 3452 }
3444 3453 __ bind(done);
3445 3454 // rax = 0: obj == NULL or obj is not an instanceof the specified klass
3446 3455 // rax = 1: obj != NULL and obj is an instanceof the specified klass
3447 3456 }
3448 3457
3449 3458 //-----------------------------------------------------------------------------
3450 3459 // Breakpoints
3451 3460 void TemplateTable::_breakpoint() {
3452 3461 // Note: We get here even if we are single stepping..
3453 3462 // jbug inists on setting breakpoints at every bytecode
3454 3463 // even if we are in single step mode.
3455 3464
3456 3465 transition(vtos, vtos);
3457 3466
3458 3467 // get the unpatched byte code
3459 3468 __ get_method(c_rarg1);
3460 3469 __ call_VM(noreg,
3461 3470 CAST_FROM_FN_PTR(address,
3462 3471 InterpreterRuntime::get_original_bytecode_at),
3463 3472 c_rarg1, r13);
3464 3473 __ mov(rbx, rax);
3465 3474
3466 3475 // post the breakpoint event
3467 3476 __ get_method(c_rarg1);
3468 3477 __ call_VM(noreg,
3469 3478 CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint),
3470 3479 c_rarg1, r13);
3471 3480
3472 3481 // complete the execution of original bytecode
3473 3482 __ dispatch_only_normal(vtos);
3474 3483 }
3475 3484
3476 3485 //-----------------------------------------------------------------------------
3477 3486 // Exceptions
3478 3487
3479 3488 void TemplateTable::athrow() {
3480 3489 transition(atos, vtos);
3481 3490 __ null_check(rax);
3482 3491 __ jump(ExternalAddress(Interpreter::throw_exception_entry()));
3483 3492 }
3484 3493
3485 3494 //-----------------------------------------------------------------------------
3486 3495 // Synchronization
3487 3496 //
3488 3497 // Note: monitorenter & exit are symmetric routines; which is reflected
3489 3498 // in the assembly code structure as well
3490 3499 //
3491 3500 // Stack layout:
3492 3501 //
3493 3502 // [expressions ] <--- rsp = expression stack top
3494 3503 // ..
3495 3504 // [expressions ]
3496 3505 // [monitor entry] <--- monitor block top = expression stack bot
3497 3506 // ..
3498 3507 // [monitor entry]
3499 3508 // [frame data ] <--- monitor block bot
3500 3509 // ...
3501 3510 // [saved rbp ] <--- rbp
3502 3511 void TemplateTable::monitorenter() {
3503 3512 transition(atos, vtos);
3504 3513
3505 3514 // check for NULL object
3506 3515 __ null_check(rax);
3507 3516
3508 3517 const Address monitor_block_top(
3509 3518 rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
3510 3519 const Address monitor_block_bot(
3511 3520 rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
3512 3521 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
3513 3522
3514 3523 Label allocated;
3515 3524
3516 3525 // initialize entry pointer
3517 3526 __ xorl(c_rarg1, c_rarg1); // points to free slot or NULL
3518 3527
3519 3528 // find a free slot in the monitor block (result in c_rarg1)
3520 3529 {
3521 3530 Label entry, loop, exit;
3522 3531 __ movptr(c_rarg3, monitor_block_top); // points to current entry,
3523 3532 // starting with top-most entry
3524 3533 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
3525 3534 // of monitor block
3526 3535 __ jmpb(entry);
3527 3536
3528 3537 __ bind(loop);
3529 3538 // check if current entry is used
3530 3539 __ cmpptr(Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()), (int32_t) NULL_WORD);
3531 3540 // if not used then remember entry in c_rarg1
3532 3541 __ cmov(Assembler::equal, c_rarg1, c_rarg3);
3533 3542 // check if current entry is for same object
3534 3543 __ cmpptr(rax, Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()));
3535 3544 // if same object then stop searching
3536 3545 __ jccb(Assembler::equal, exit);
3537 3546 // otherwise advance to next entry
3538 3547 __ addptr(c_rarg3, entry_size);
3539 3548 __ bind(entry);
3540 3549 // check if bottom reached
3541 3550 __ cmpptr(c_rarg3, c_rarg2);
3542 3551 // if not at bottom then check this entry
3543 3552 __ jcc(Assembler::notEqual, loop);
3544 3553 __ bind(exit);
3545 3554 }
3546 3555
3547 3556 __ testptr(c_rarg1, c_rarg1); // check if a slot has been found
3548 3557 __ jcc(Assembler::notZero, allocated); // if found, continue with that one
3549 3558
3550 3559 // allocate one if there's no free slot
3551 3560 {
3552 3561 Label entry, loop;
3553 3562 // 1. compute new pointers // rsp: old expression stack top
3554 3563 __ movptr(c_rarg1, monitor_block_bot); // c_rarg1: old expression stack bottom
3555 3564 __ subptr(rsp, entry_size); // move expression stack top
3556 3565 __ subptr(c_rarg1, entry_size); // move expression stack bottom
3557 3566 __ mov(c_rarg3, rsp); // set start value for copy loop
3558 3567 __ movptr(monitor_block_bot, c_rarg1); // set new monitor block bottom
3559 3568 __ jmp(entry);
3560 3569 // 2. move expression stack contents
3561 3570 __ bind(loop);
3562 3571 __ movptr(c_rarg2, Address(c_rarg3, entry_size)); // load expression stack
3563 3572 // word from old location
3564 3573 __ movptr(Address(c_rarg3, 0), c_rarg2); // and store it at new location
3565 3574 __ addptr(c_rarg3, wordSize); // advance to next word
3566 3575 __ bind(entry);
3567 3576 __ cmpptr(c_rarg3, c_rarg1); // check if bottom reached
3568 3577 __ jcc(Assembler::notEqual, loop); // if not at bottom then
3569 3578 // copy next word
3570 3579 }
3571 3580
3572 3581 // call run-time routine
3573 3582 // c_rarg1: points to monitor entry
3574 3583 __ bind(allocated);
3575 3584
3576 3585 // Increment bcp to point to the next bytecode, so exception
3577 3586 // handling for async. exceptions work correctly.
3578 3587 // The object has already been poped from the stack, so the
3579 3588 // expression stack looks correct.
3580 3589 __ increment(r13);
3581 3590
3582 3591 // store object
3583 3592 __ movptr(Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()), rax);
3584 3593 __ lock_object(c_rarg1);
3585 3594
3586 3595 // check to make sure this monitor doesn't cause stack overflow after locking
3587 3596 __ save_bcp(); // in case of exception
3588 3597 __ generate_stack_overflow_check(0);
3589 3598
3590 3599 // The bcp has already been incremented. Just need to dispatch to
3591 3600 // next instruction.
3592 3601 __ dispatch_next(vtos);
3593 3602 }
3594 3603
3595 3604
3596 3605 void TemplateTable::monitorexit() {
3597 3606 transition(atos, vtos);
3598 3607
3599 3608 // check for NULL object
3600 3609 __ null_check(rax);
3601 3610
3602 3611 const Address monitor_block_top(
3603 3612 rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
3604 3613 const Address monitor_block_bot(
3605 3614 rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
3606 3615 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
3607 3616
3608 3617 Label found;
3609 3618
3610 3619 // find matching slot
3611 3620 {
3612 3621 Label entry, loop;
3613 3622 __ movptr(c_rarg1, monitor_block_top); // points to current entry,
3614 3623 // starting with top-most entry
3615 3624 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
3616 3625 // of monitor block
3617 3626 __ jmpb(entry);
3618 3627
3619 3628 __ bind(loop);
3620 3629 // check if current entry is for same object
3621 3630 __ cmpptr(rax, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
3622 3631 // if same object then stop searching
3623 3632 __ jcc(Assembler::equal, found);
3624 3633 // otherwise advance to next entry
3625 3634 __ addptr(c_rarg1, entry_size);
3626 3635 __ bind(entry);
3627 3636 // check if bottom reached
3628 3637 __ cmpptr(c_rarg1, c_rarg2);
3629 3638 // if not at bottom then check this entry
3630 3639 __ jcc(Assembler::notEqual, loop);
3631 3640 }
3632 3641
3633 3642 // error handling. Unlocking was not block-structured
3634 3643 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
3635 3644 InterpreterRuntime::throw_illegal_monitor_state_exception));
3636 3645 __ should_not_reach_here();
3637 3646
3638 3647 // call run-time routine
3639 3648 // rsi: points to monitor entry
3640 3649 __ bind(found);
3641 3650 __ push_ptr(rax); // make sure object is on stack (contract with oopMaps)
3642 3651 __ unlock_object(c_rarg1);
3643 3652 __ pop_ptr(rax); // discard object
3644 3653 }
3645 3654
3646 3655
3647 3656 // Wide instructions
3648 3657 void TemplateTable::wide() {
3649 3658 transition(vtos, vtos);
3650 3659 __ load_unsigned_byte(rbx, at_bcp(1));
3651 3660 __ lea(rscratch1, ExternalAddress((address)Interpreter::_wentry_point));
3652 3661 __ jmp(Address(rscratch1, rbx, Address::times_8));
3653 3662 // Note: the r13 increment step is part of the individual wide
3654 3663 // bytecode implementations
3655 3664 }
3656 3665
3657 3666
3658 3667 // Multi arrays
3659 3668 void TemplateTable::multianewarray() {
3660 3669 transition(vtos, atos);
3661 3670 __ load_unsigned_byte(rax, at_bcp(3)); // get number of dimensions
3662 3671 // last dim is on top of stack; we want address of first one:
3663 3672 // first_addr = last_addr + (ndims - 1) * wordSize
3664 3673 __ lea(c_rarg1, Address(rsp, rax, Address::times_8, -wordSize));
3665 3674 call_VM(rax,
3666 3675 CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray),
3667 3676 c_rarg1);
3668 3677 __ load_unsigned_byte(rbx, at_bcp(3));
3669 3678 __ lea(rsp, Address(rsp, rbx, Address::times_8));
3670 3679 }
3671 3680 #endif // !CC_INTERP
|
↓ open down ↓ |
3506 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX