4338 // Note: monitorenter & exit are symmetric routines; which is reflected
4339 // in the assembly code structure as well
4340 //
4341 // Stack layout:
4342 //
4343 // [expressions ] <--- rsp = expression stack top
4344 // ..
4345 // [expressions ]
4346 // [monitor entry] <--- monitor block top = expression stack bot
4347 // ..
4348 // [monitor entry]
4349 // [frame data ] <--- monitor block bot
4350 // ...
4351 // [saved rbp ] <--- rbp
4352 void TemplateTable::monitorenter() {
4353 transition(atos, vtos);
4354
4355 // check for NULL object
4356 __ null_check(rax);
4357
4358 const Address monitor_block_top(
4359 rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4360 const Address monitor_block_bot(
4361 rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
4362 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4363
4364 Label allocated;
4365
4366 Register rtop = LP64_ONLY(c_rarg3) NOT_LP64(rcx);
4367 Register rbot = LP64_ONLY(c_rarg2) NOT_LP64(rbx);
4368 Register rmon = LP64_ONLY(c_rarg1) NOT_LP64(rdx);
4369
4370 // initialize entry pointer
4371 __ xorl(rmon, rmon); // points to free slot or NULL
4372
4373 // find a free slot in the monitor block (result in rmon)
4374 {
4375 Label entry, loop, exit;
4376 __ movptr(rtop, monitor_block_top); // points to current entry,
4377 // starting with top-most entry
4434 __ increment(rbcp);
4435
4436 // store object
4437 __ movptr(Address(rmon, BasicObjectLock::obj_offset_in_bytes()), rax);
4438 __ lock_object(rmon);
4439
4440 // check to make sure this monitor doesn't cause stack overflow after locking
4441 __ save_bcp(); // in case of exception
4442 __ generate_stack_overflow_check(0);
4443
4444 // The bcp has already been incremented. Just need to dispatch to
4445 // next instruction.
4446 __ dispatch_next(vtos);
4447 }
4448
4449 void TemplateTable::monitorexit() {
4450 transition(atos, vtos);
4451
4452 // check for NULL object
4453 __ null_check(rax);
4454
4455 const Address monitor_block_top(
4456 rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4457 const Address monitor_block_bot(
4458 rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
4459 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4460
4461 Register rtop = LP64_ONLY(c_rarg1) NOT_LP64(rdx);
4462 Register rbot = LP64_ONLY(c_rarg2) NOT_LP64(rbx);
4463
4464 Label found;
4465
4466 // find matching slot
4467 {
4468 Label entry, loop;
4469 __ movptr(rtop, monitor_block_top); // points to current entry,
4470 // starting with top-most entry
4471 __ lea(rbot, monitor_block_bot); // points to word before bottom
4472 // of monitor block
4473 __ jmpb(entry);
|
4338 // Note: monitorenter & exit are symmetric routines; which is reflected
4339 // in the assembly code structure as well
4340 //
4341 // Stack layout:
4342 //
4343 // [expressions ] <--- rsp = expression stack top
4344 // ..
4345 // [expressions ]
4346 // [monitor entry] <--- monitor block top = expression stack bot
4347 // ..
4348 // [monitor entry]
4349 // [frame data ] <--- monitor block bot
4350 // ...
4351 // [saved rbp ] <--- rbp
4352 void TemplateTable::monitorenter() {
4353 transition(atos, vtos);
4354
4355 // check for NULL object
4356 __ null_check(rax);
4357
4358 __ resolve(IS_NOT_NULL, rax);
4359
4360 const Address monitor_block_top(
4361 rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4362 const Address monitor_block_bot(
4363 rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
4364 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4365
4366 Label allocated;
4367
4368 Register rtop = LP64_ONLY(c_rarg3) NOT_LP64(rcx);
4369 Register rbot = LP64_ONLY(c_rarg2) NOT_LP64(rbx);
4370 Register rmon = LP64_ONLY(c_rarg1) NOT_LP64(rdx);
4371
4372 // initialize entry pointer
4373 __ xorl(rmon, rmon); // points to free slot or NULL
4374
4375 // find a free slot in the monitor block (result in rmon)
4376 {
4377 Label entry, loop, exit;
4378 __ movptr(rtop, monitor_block_top); // points to current entry,
4379 // starting with top-most entry
4436 __ increment(rbcp);
4437
4438 // store object
4439 __ movptr(Address(rmon, BasicObjectLock::obj_offset_in_bytes()), rax);
4440 __ lock_object(rmon);
4441
4442 // check to make sure this monitor doesn't cause stack overflow after locking
4443 __ save_bcp(); // in case of exception
4444 __ generate_stack_overflow_check(0);
4445
4446 // The bcp has already been incremented. Just need to dispatch to
4447 // next instruction.
4448 __ dispatch_next(vtos);
4449 }
4450
4451 void TemplateTable::monitorexit() {
4452 transition(atos, vtos);
4453
4454 // check for NULL object
4455 __ null_check(rax);
4456
4457 __ resolve(IS_NOT_NULL, rax);
4458
4459 const Address monitor_block_top(
4460 rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4461 const Address monitor_block_bot(
4462 rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
4463 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4464
4465 Register rtop = LP64_ONLY(c_rarg1) NOT_LP64(rdx);
4466 Register rbot = LP64_ONLY(c_rarg2) NOT_LP64(rbx);
4467
4468 Label found;
4469
4470 // find matching slot
4471 {
4472 Label entry, loop;
4473 __ movptr(rtop, monitor_block_top); // points to current entry,
4474 // starting with top-most entry
4475 __ lea(rbot, monitor_block_bot); // points to word before bottom
4476 // of monitor block
4477 __ jmpb(entry);
|