4402 adrp(rscratch1, src2, offset);
4403 ldr(rscratch1, Address(rscratch1, offset));
4404 cmp(src1, rscratch1);
4405 }
4406
4407 void MacroAssembler::cmpoop(Register obj1, Register obj2) {
4408 cmp(obj1, obj2);
4409 }
4410
4411 void MacroAssembler::load_method_holder_cld(Register rresult, Register rmethod) {
4412 load_method_holder(rresult, rmethod);
4413 ldr(rresult, Address(rresult, InstanceKlass::class_loader_data_offset()));
4414 }
4415
4416 void MacroAssembler::load_method_holder(Register holder, Register method) {
4417 ldr(holder, Address(method, Method::const_offset())); // ConstMethod*
4418 ldr(holder, Address(holder, ConstMethod::constants_offset())); // ConstantPool*
4419 ldr(holder, Address(holder, ConstantPool::pool_holder_offset())); // InstanceKlass*
4420 }
4421
4422 void MacroAssembler::load_klass(Register dst, Register src) {
4423 if (UseCompressedClassPointers) {
4424 ldrw(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4425 decode_klass_not_null(dst);
4426 } else {
4427 ldr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4428 }
4429 }
4430
4431 // ((OopHandle)result).resolve();
4432 void MacroAssembler::resolve_oop_handle(Register result, Register tmp1, Register tmp2) {
4433 // OopHandle::resolve is an indirection.
4434 access_load_at(T_OBJECT, IN_NATIVE, result, Address(result, 0), tmp1, tmp2);
4435 }
4436
4437 // ((WeakHandle)result).resolve();
4438 void MacroAssembler::resolve_weak_handle(Register result, Register tmp1, Register tmp2) {
4439 assert_different_registers(result, tmp1, tmp2);
4440 Label resolved;
4441
4442 // A null weak handle resolves to null.
4443 cbz(result, resolved);
4444
4445 // Only 64 bit platforms support GCs that require a tmp register
4446 // WeakHandle::resolve is an indirection like jweak.
4447 access_load_at(T_OBJECT, IN_NATIVE | ON_PHANTOM_OOP_REF,
4448 result, Address(result), tmp1, tmp2);
4449 bind(resolved);
4450 }
4451
4452 void MacroAssembler::load_mirror(Register dst, Register method, Register tmp1, Register tmp2) {
4453 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
4454 ldr(dst, Address(rmethod, Method::const_offset()));
4455 ldr(dst, Address(dst, ConstMethod::constants_offset()));
4456 ldr(dst, Address(dst, ConstantPool::pool_holder_offset()));
4457 ldr(dst, Address(dst, mirror_offset));
4458 resolve_oop_handle(dst, tmp1, tmp2);
4459 }
4460
4461 void MacroAssembler::cmp_klass(Register oop, Register trial_klass, Register tmp) {
4462 if (UseCompressedClassPointers) {
4463 ldrw(tmp, Address(oop, oopDesc::klass_offset_in_bytes()));
4464 if (CompressedKlassPointers::base() == nullptr) {
4465 cmp(trial_klass, tmp, LSL, CompressedKlassPointers::shift());
4466 return;
4467 } else if (((uint64_t)CompressedKlassPointers::base() & 0xffffffff) == 0
4468 && CompressedKlassPointers::shift() == 0) {
4469 // Only the bottom 32 bits matter
4470 cmpw(trial_klass, tmp);
4471 return;
4472 }
4473 decode_klass_not_null(tmp);
4474 } else {
4475 ldr(tmp, Address(oop, oopDesc::klass_offset_in_bytes()));
4476 }
4477 cmp(trial_klass, tmp);
4478 }
4479
4480 void MacroAssembler::store_klass(Register dst, Register src) {
4481 // FIXME: Should this be a store release? concurrent gcs assumes
4482 // klass length is valid if klass field is not null.
4483 if (UseCompressedClassPointers) {
4484 encode_klass_not_null(src);
4485 strw(src, Address(dst, oopDesc::klass_offset_in_bytes()));
4486 } else {
4487 str(src, Address(dst, oopDesc::klass_offset_in_bytes()));
4488 }
4489 }
4490
4491 void MacroAssembler::store_klass_gap(Register dst, Register src) {
4492 if (UseCompressedClassPointers) {
4493 // Store to klass gap in destination
4494 strw(src, Address(dst, oopDesc::klass_gap_offset_in_bytes()));
4495 }
4496 }
4497
4498 // Algorithm must match CompressedOops::encode.
4499 void MacroAssembler::encode_heap_oop(Register d, Register s) {
4500 #ifdef ASSERT
4501 verify_heapbase("MacroAssembler::encode_heap_oop: heap base corrupted?");
4502 #endif
4503 verify_oop_msg(s, "broken oop in encode_heap_oop");
4504 if (CompressedOops::base() == nullptr) {
4505 if (CompressedOops::shift() != 0) {
4506 assert (LogMinObjAlignmentInBytes == CompressedOops::shift(), "decode alg wrong");
4507 lsr(d, s, LogMinObjAlignmentInBytes);
4508 } else {
4509 mov(d, s);
4510 }
4511 } else {
|
4402 adrp(rscratch1, src2, offset);
4403 ldr(rscratch1, Address(rscratch1, offset));
4404 cmp(src1, rscratch1);
4405 }
4406
4407 void MacroAssembler::cmpoop(Register obj1, Register obj2) {
4408 cmp(obj1, obj2);
4409 }
4410
4411 void MacroAssembler::load_method_holder_cld(Register rresult, Register rmethod) {
4412 load_method_holder(rresult, rmethod);
4413 ldr(rresult, Address(rresult, InstanceKlass::class_loader_data_offset()));
4414 }
4415
4416 void MacroAssembler::load_method_holder(Register holder, Register method) {
4417 ldr(holder, Address(method, Method::const_offset())); // ConstMethod*
4418 ldr(holder, Address(holder, ConstMethod::constants_offset())); // ConstantPool*
4419 ldr(holder, Address(holder, ConstantPool::pool_holder_offset())); // InstanceKlass*
4420 }
4421
4422 // Loads the obj's Klass* into dst.
4423 // Preserves all registers (incl src, rscratch1 and rscratch2).
4424 void MacroAssembler::load_nklass(Register dst, Register src) {
4425 assert(UseCompactObjectHeaders, "expects UseCompactObjectHeaders");
4426
4427 Label fast;
4428
4429 // Check if we can take the (common) fast path, if obj is unlocked.
4430 ldr(dst, Address(src, oopDesc::mark_offset_in_bytes()));
4431 tbz(dst, exact_log2(markWord::monitor_value), fast);
4432
4433 // Fetch displaced header
4434 ldr(dst, Address(dst, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
4435
4436 // Fast-path: shift and decode Klass*.
4437 bind(fast);
4438 lsr(dst, dst, markWord::klass_shift);
4439 }
4440
4441 void MacroAssembler::load_klass(Register dst, Register src) {
4442 if (UseCompactObjectHeaders) {
4443 load_nklass(dst, src);
4444 decode_klass_not_null(dst);
4445 } else if (UseCompressedClassPointers) {
4446 ldrw(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4447 decode_klass_not_null(dst);
4448 } else {
4449 ldr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4450 }
4451 }
4452
4453 // ((OopHandle)result).resolve();
4454 void MacroAssembler::resolve_oop_handle(Register result, Register tmp1, Register tmp2) {
4455 // OopHandle::resolve is an indirection.
4456 access_load_at(T_OBJECT, IN_NATIVE, result, Address(result, 0), tmp1, tmp2);
4457 }
4458
4459 // ((WeakHandle)result).resolve();
4460 void MacroAssembler::resolve_weak_handle(Register result, Register tmp1, Register tmp2) {
4461 assert_different_registers(result, tmp1, tmp2);
4462 Label resolved;
4463
4464 // A null weak handle resolves to null.
4465 cbz(result, resolved);
4466
4467 // Only 64 bit platforms support GCs that require a tmp register
4468 // WeakHandle::resolve is an indirection like jweak.
4469 access_load_at(T_OBJECT, IN_NATIVE | ON_PHANTOM_OOP_REF,
4470 result, Address(result), tmp1, tmp2);
4471 bind(resolved);
4472 }
4473
4474 void MacroAssembler::load_mirror(Register dst, Register method, Register tmp1, Register tmp2) {
4475 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
4476 ldr(dst, Address(rmethod, Method::const_offset()));
4477 ldr(dst, Address(dst, ConstMethod::constants_offset()));
4478 ldr(dst, Address(dst, ConstantPool::pool_holder_offset()));
4479 ldr(dst, Address(dst, mirror_offset));
4480 resolve_oop_handle(dst, tmp1, tmp2);
4481 }
4482
4483 void MacroAssembler::cmp_klass(Register oop, Register trial_klass, Register tmp) {
4484 assert_different_registers(oop, trial_klass, tmp);
4485 if (UseCompressedClassPointers) {
4486 if (UseCompactObjectHeaders) {
4487 load_nklass(tmp, oop);
4488 } else {
4489 ldrw(tmp, Address(oop, oopDesc::klass_offset_in_bytes()));
4490 }
4491 if (CompressedKlassPointers::base() == nullptr) {
4492 cmp(trial_klass, tmp, LSL, CompressedKlassPointers::shift());
4493 return;
4494 } else if (((uint64_t)CompressedKlassPointers::base() & 0xffffffff) == 0
4495 && CompressedKlassPointers::shift() == 0) {
4496 // Only the bottom 32 bits matter
4497 cmpw(trial_klass, tmp);
4498 return;
4499 }
4500 decode_klass_not_null(tmp);
4501 } else {
4502 ldr(tmp, Address(oop, oopDesc::klass_offset_in_bytes()));
4503 }
4504 cmp(trial_klass, tmp);
4505 }
4506
4507 void MacroAssembler::cmp_klass(Register src, Register dst, Register tmp1, Register tmp2) {
4508 if (UseCompactObjectHeaders) {
4509 load_nklass(tmp1, src);
4510 load_nklass(tmp2, dst);
4511 cmpw(tmp1, tmp2);
4512 } else if (UseCompressedClassPointers) {
4513 ldrw(tmp1, Address(src, oopDesc::klass_offset_in_bytes()));
4514 ldrw(tmp2, Address(dst, oopDesc::klass_offset_in_bytes()));
4515 cmpw(tmp1, tmp2);
4516 } else {
4517 ldr(tmp1, Address(src, oopDesc::klass_offset_in_bytes()));
4518 ldr(tmp2, Address(dst, oopDesc::klass_offset_in_bytes()));
4519 cmp(tmp1, tmp2);
4520 }
4521 }
4522
4523 void MacroAssembler::store_klass(Register dst, Register src) {
4524 // FIXME: Should this be a store release? concurrent gcs assumes
4525 // klass length is valid if klass field is not null.
4526 assert(!UseCompactObjectHeaders, "not with compact headers");
4527 if (UseCompressedClassPointers) {
4528 encode_klass_not_null(src);
4529 strw(src, Address(dst, oopDesc::klass_offset_in_bytes()));
4530 } else {
4531 str(src, Address(dst, oopDesc::klass_offset_in_bytes()));
4532 }
4533 }
4534
4535 void MacroAssembler::store_klass_gap(Register dst, Register src) {
4536 assert(!UseCompactObjectHeaders, "not with compact headers");
4537 if (UseCompressedClassPointers) {
4538 // Store to klass gap in destination
4539 strw(src, Address(dst, oopDesc::klass_gap_offset_in_bytes()));
4540 }
4541 }
4542
4543 // Algorithm must match CompressedOops::encode.
4544 void MacroAssembler::encode_heap_oop(Register d, Register s) {
4545 #ifdef ASSERT
4546 verify_heapbase("MacroAssembler::encode_heap_oop: heap base corrupted?");
4547 #endif
4548 verify_oop_msg(s, "broken oop in encode_heap_oop");
4549 if (CompressedOops::base() == nullptr) {
4550 if (CompressedOops::shift() != 0) {
4551 assert (LogMinObjAlignmentInBytes == CompressedOops::shift(), "decode alg wrong");
4552 lsr(d, s, LogMinObjAlignmentInBytes);
4553 } else {
4554 mov(d, s);
4555 }
4556 } else {
|