< prev index next >

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

Print this page

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 {
< prev index next >