5308
5309 void MacroAssembler::load_mirror(Register mirror, Register method, Register tmp) {
5310 // get mirror
5311 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
5312 load_method_holder(mirror, method);
5313 movptr(mirror, Address(mirror, mirror_offset));
5314 resolve_oop_handle(mirror, tmp);
5315 }
5316
5317 void MacroAssembler::load_method_holder_cld(Register rresult, Register rmethod) {
5318 load_method_holder(rresult, rmethod);
5319 movptr(rresult, Address(rresult, InstanceKlass::class_loader_data_offset()));
5320 }
5321
5322 void MacroAssembler::load_method_holder(Register holder, Register method) {
5323 movptr(holder, Address(method, Method::const_offset())); // ConstMethod*
5324 movptr(holder, Address(holder, ConstMethod::constants_offset())); // ConstantPool*
5325 movptr(holder, Address(holder, ConstantPool::pool_holder_offset())); // InstanceKlass*
5326 }
5327
5328 void MacroAssembler::load_klass(Register dst, Register src, Register tmp) {
5329 assert_different_registers(src, tmp);
5330 assert_different_registers(dst, tmp);
5331 #ifdef _LP64
5332 if (UseCompressedClassPointers) {
5333 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5334 decode_klass_not_null(dst, tmp);
5335 } else
5336 #endif
5337 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5338 }
5339
5340 void MacroAssembler::store_klass(Register dst, Register src, Register tmp) {
5341 assert_different_registers(src, tmp);
5342 assert_different_registers(dst, tmp);
5343 #ifdef _LP64
5344 if (UseCompressedClassPointers) {
5345 encode_klass_not_null(src, tmp);
5346 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5347 } else
5348 #endif
5349 movptr(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5350 }
5351
5352 void MacroAssembler::access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
5353 Register tmp1, Register thread_tmp) {
5354 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5355 decorators = AccessInternal::decorator_fixup(decorators, type);
5356 bool as_raw = (decorators & AS_RAW) != 0;
5357 if (as_raw) {
5358 bs->BarrierSetAssembler::load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5359 } else {
5360 bs->load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5361 }
5362 }
5363
5364 void MacroAssembler::access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register val,
5365 Register tmp1, Register tmp2, Register tmp3) {
5366 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5367 decorators = AccessInternal::decorator_fixup(decorators, type);
5368 bool as_raw = (decorators & AS_RAW) != 0;
5369 if (as_raw) {
5370 bs->BarrierSetAssembler::store_at(this, decorators, type, dst, val, tmp1, tmp2, tmp3);
5371 } else {
5379 }
5380
5381 // Doesn't do verification, generates fixed size code
5382 void MacroAssembler::load_heap_oop_not_null(Register dst, Address src, Register tmp1,
5383 Register thread_tmp, DecoratorSet decorators) {
5384 access_load_at(T_OBJECT, IN_HEAP | IS_NOT_NULL | decorators, dst, src, tmp1, thread_tmp);
5385 }
5386
5387 void MacroAssembler::store_heap_oop(Address dst, Register val, Register tmp1,
5388 Register tmp2, Register tmp3, DecoratorSet decorators) {
5389 access_store_at(T_OBJECT, IN_HEAP | decorators, dst, val, tmp1, tmp2, tmp3);
5390 }
5391
5392 // Used for storing nulls.
5393 void MacroAssembler::store_heap_oop_null(Address dst) {
5394 access_store_at(T_OBJECT, IN_HEAP, dst, noreg, noreg, noreg, noreg);
5395 }
5396
5397 #ifdef _LP64
5398 void MacroAssembler::store_klass_gap(Register dst, Register src) {
5399 if (UseCompressedClassPointers) {
5400 // Store to klass gap in destination
5401 movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
5402 }
5403 }
5404
5405 #ifdef ASSERT
5406 void MacroAssembler::verify_heapbase(const char* msg) {
5407 assert (UseCompressedOops, "should be compressed");
5408 assert (Universe::heap() != nullptr, "java heap should be initialized");
5409 if (CheckCompressedOops) {
5410 Label ok;
5411 ExternalAddress src2(CompressedOops::ptrs_base_addr());
5412 const bool is_src2_reachable = reachable(src2);
5413 if (!is_src2_reachable) {
5414 push(rscratch1); // cmpptr trashes rscratch1
5415 }
5416 cmpptr(r12_heapbase, src2, rscratch1);
5417 jcc(Assembler::equal, ok);
5418 STOP(msg);
|
5308
5309 void MacroAssembler::load_mirror(Register mirror, Register method, Register tmp) {
5310 // get mirror
5311 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
5312 load_method_holder(mirror, method);
5313 movptr(mirror, Address(mirror, mirror_offset));
5314 resolve_oop_handle(mirror, tmp);
5315 }
5316
5317 void MacroAssembler::load_method_holder_cld(Register rresult, Register rmethod) {
5318 load_method_holder(rresult, rmethod);
5319 movptr(rresult, Address(rresult, InstanceKlass::class_loader_data_offset()));
5320 }
5321
5322 void MacroAssembler::load_method_holder(Register holder, Register method) {
5323 movptr(holder, Address(method, Method::const_offset())); // ConstMethod*
5324 movptr(holder, Address(holder, ConstMethod::constants_offset())); // ConstantPool*
5325 movptr(holder, Address(holder, ConstantPool::pool_holder_offset())); // InstanceKlass*
5326 }
5327
5328 #ifdef _LP64
5329 void MacroAssembler::load_nklass_compact(Register dst, Register src) {
5330 assert(UseCompactObjectHeaders, "expect compact object headers");
5331
5332 Label fast;
5333 movq(dst, Address(src, oopDesc::mark_offset_in_bytes()));
5334 testb(dst, markWord::monitor_value);
5335 jccb(Assembler::zero, fast);
5336
5337 // Fetch displaced header
5338 movq(dst, Address(dst, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
5339
5340 bind(fast);
5341 shrq(dst, markWord::klass_shift);
5342 }
5343 #endif
5344
5345 void MacroAssembler::load_klass(Register dst, Register src, Register tmp) {
5346 assert_different_registers(src, tmp);
5347 assert_different_registers(dst, tmp);
5348 #ifdef _LP64
5349 if (UseCompactObjectHeaders) {
5350 load_nklass_compact(dst, src);
5351 decode_klass_not_null(dst, tmp);
5352 } else if (UseCompressedClassPointers) {
5353 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5354 decode_klass_not_null(dst, tmp);
5355 } else
5356 #endif
5357 {
5358 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5359 }
5360 }
5361
5362 void MacroAssembler::store_klass(Register dst, Register src, Register tmp) {
5363 assert(!UseCompactObjectHeaders, "not with compact headers");
5364 assert_different_registers(src, tmp);
5365 assert_different_registers(dst, tmp);
5366 #ifdef _LP64
5367 if (UseCompressedClassPointers) {
5368 encode_klass_not_null(src, tmp);
5369 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5370 } else
5371 #endif
5372 movptr(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5373 }
5374
5375 void MacroAssembler::cmp_klass(Register klass, Register obj, Register tmp) {
5376 #ifdef _LP64
5377 if (UseCompactObjectHeaders) {
5378 load_nklass_compact(tmp, obj);
5379 cmpl(klass, tmp);
5380 } else if (UseCompressedClassPointers) {
5381 cmpl(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
5382 } else
5383 #endif
5384 {
5385 cmpptr(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
5386 }
5387 }
5388
5389 void MacroAssembler::cmp_klass(Register src, Register dst, Register tmp1, Register tmp2) {
5390 #ifdef _LP64
5391 if (UseCompactObjectHeaders) {
5392 assert(tmp2 != noreg, "need tmp2");
5393 assert_different_registers(src, dst, tmp1, tmp2);
5394 load_nklass_compact(tmp1, src);
5395 load_nklass_compact(tmp2, dst);
5396 cmpl(tmp1, tmp2);
5397 } else if (UseCompressedClassPointers) {
5398 movl(tmp1, Address(src, oopDesc::klass_offset_in_bytes()));
5399 cmpl(tmp1, Address(dst, oopDesc::klass_offset_in_bytes()));
5400 } else
5401 #endif
5402 {
5403 movptr(tmp1, Address(src, oopDesc::klass_offset_in_bytes()));
5404 cmpptr(tmp1, Address(dst, oopDesc::klass_offset_in_bytes()));
5405 }
5406 }
5407
5408 void MacroAssembler::access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
5409 Register tmp1, Register thread_tmp) {
5410 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5411 decorators = AccessInternal::decorator_fixup(decorators, type);
5412 bool as_raw = (decorators & AS_RAW) != 0;
5413 if (as_raw) {
5414 bs->BarrierSetAssembler::load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5415 } else {
5416 bs->load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5417 }
5418 }
5419
5420 void MacroAssembler::access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register val,
5421 Register tmp1, Register tmp2, Register tmp3) {
5422 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5423 decorators = AccessInternal::decorator_fixup(decorators, type);
5424 bool as_raw = (decorators & AS_RAW) != 0;
5425 if (as_raw) {
5426 bs->BarrierSetAssembler::store_at(this, decorators, type, dst, val, tmp1, tmp2, tmp3);
5427 } else {
5435 }
5436
5437 // Doesn't do verification, generates fixed size code
5438 void MacroAssembler::load_heap_oop_not_null(Register dst, Address src, Register tmp1,
5439 Register thread_tmp, DecoratorSet decorators) {
5440 access_load_at(T_OBJECT, IN_HEAP | IS_NOT_NULL | decorators, dst, src, tmp1, thread_tmp);
5441 }
5442
5443 void MacroAssembler::store_heap_oop(Address dst, Register val, Register tmp1,
5444 Register tmp2, Register tmp3, DecoratorSet decorators) {
5445 access_store_at(T_OBJECT, IN_HEAP | decorators, dst, val, tmp1, tmp2, tmp3);
5446 }
5447
5448 // Used for storing nulls.
5449 void MacroAssembler::store_heap_oop_null(Address dst) {
5450 access_store_at(T_OBJECT, IN_HEAP, dst, noreg, noreg, noreg, noreg);
5451 }
5452
5453 #ifdef _LP64
5454 void MacroAssembler::store_klass_gap(Register dst, Register src) {
5455 assert(!UseCompactObjectHeaders, "Don't use with compact headers");
5456 if (UseCompressedClassPointers) {
5457 // Store to klass gap in destination
5458 movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
5459 }
5460 }
5461
5462 #ifdef ASSERT
5463 void MacroAssembler::verify_heapbase(const char* msg) {
5464 assert (UseCompressedOops, "should be compressed");
5465 assert (Universe::heap() != nullptr, "java heap should be initialized");
5466 if (CheckCompressedOops) {
5467 Label ok;
5468 ExternalAddress src2(CompressedOops::ptrs_base_addr());
5469 const bool is_src2_reachable = reachable(src2);
5470 if (!is_src2_reachable) {
5471 push(rscratch1); // cmpptr trashes rscratch1
5472 }
5473 cmpptr(r12_heapbase, src2, rscratch1);
5474 jcc(Assembler::equal, ok);
5475 STOP(msg);
|