5221
5222 void MacroAssembler::load_mirror(Register mirror, Register method, Register tmp) {
5223 // get mirror
5224 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
5225 load_method_holder(mirror, method);
5226 movptr(mirror, Address(mirror, mirror_offset));
5227 resolve_oop_handle(mirror, tmp);
5228 }
5229
5230 void MacroAssembler::load_method_holder_cld(Register rresult, Register rmethod) {
5231 load_method_holder(rresult, rmethod);
5232 movptr(rresult, Address(rresult, InstanceKlass::class_loader_data_offset()));
5233 }
5234
5235 void MacroAssembler::load_method_holder(Register holder, Register method) {
5236 movptr(holder, Address(method, Method::const_offset())); // ConstMethod*
5237 movptr(holder, Address(holder, ConstMethod::constants_offset())); // ConstantPool*
5238 movptr(holder, Address(holder, ConstantPool::pool_holder_offset())); // InstanceKlass*
5239 }
5240
5241 void MacroAssembler::load_klass(Register dst, Register src, Register tmp) {
5242 assert_different_registers(src, tmp);
5243 assert_different_registers(dst, tmp);
5244 #ifdef _LP64
5245 if (UseCompressedClassPointers) {
5246 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5247 decode_klass_not_null(dst, tmp);
5248 } else
5249 #endif
5250 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5251 }
5252
5253 void MacroAssembler::store_klass(Register dst, Register src, Register tmp) {
5254 assert_different_registers(src, tmp);
5255 assert_different_registers(dst, tmp);
5256 #ifdef _LP64
5257 if (UseCompressedClassPointers) {
5258 encode_klass_not_null(src, tmp);
5259 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5260 } else
5261 #endif
5262 movptr(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5263 }
5264
5265 void MacroAssembler::access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
5266 Register tmp1, Register thread_tmp) {
5267 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5268 decorators = AccessInternal::decorator_fixup(decorators, type);
5269 bool as_raw = (decorators & AS_RAW) != 0;
5270 if (as_raw) {
5271 bs->BarrierSetAssembler::load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5272 } else {
5273 bs->load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5274 }
5275 }
5276
5277 void MacroAssembler::access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register val,
5278 Register tmp1, Register tmp2, Register tmp3) {
5279 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5280 decorators = AccessInternal::decorator_fixup(decorators, type);
5281 bool as_raw = (decorators & AS_RAW) != 0;
5282 if (as_raw) {
5283 bs->BarrierSetAssembler::store_at(this, decorators, type, dst, val, tmp1, tmp2, tmp3);
5284 } else {
5292 }
5293
5294 // Doesn't do verification, generates fixed size code
5295 void MacroAssembler::load_heap_oop_not_null(Register dst, Address src, Register tmp1,
5296 Register thread_tmp, DecoratorSet decorators) {
5297 access_load_at(T_OBJECT, IN_HEAP | IS_NOT_NULL | decorators, dst, src, tmp1, thread_tmp);
5298 }
5299
5300 void MacroAssembler::store_heap_oop(Address dst, Register val, Register tmp1,
5301 Register tmp2, Register tmp3, DecoratorSet decorators) {
5302 access_store_at(T_OBJECT, IN_HEAP | decorators, dst, val, tmp1, tmp2, tmp3);
5303 }
5304
5305 // Used for storing nulls.
5306 void MacroAssembler::store_heap_oop_null(Address dst) {
5307 access_store_at(T_OBJECT, IN_HEAP, dst, noreg, noreg, noreg, noreg);
5308 }
5309
5310 #ifdef _LP64
5311 void MacroAssembler::store_klass_gap(Register dst, Register src) {
5312 if (UseCompressedClassPointers) {
5313 // Store to klass gap in destination
5314 movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
5315 }
5316 }
5317
5318 #ifdef ASSERT
5319 void MacroAssembler::verify_heapbase(const char* msg) {
5320 assert (UseCompressedOops, "should be compressed");
5321 assert (Universe::heap() != nullptr, "java heap should be initialized");
5322 if (CheckCompressedOops) {
5323 Label ok;
5324 ExternalAddress src2(CompressedOops::ptrs_base_addr());
5325 const bool is_src2_reachable = reachable(src2);
5326 if (!is_src2_reachable) {
5327 push(rscratch1); // cmpptr trashes rscratch1
5328 }
5329 cmpptr(r12_heapbase, src2, rscratch1);
5330 jcc(Assembler::equal, ok);
5331 STOP(msg);
|
5221
5222 void MacroAssembler::load_mirror(Register mirror, Register method, Register tmp) {
5223 // get mirror
5224 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
5225 load_method_holder(mirror, method);
5226 movptr(mirror, Address(mirror, mirror_offset));
5227 resolve_oop_handle(mirror, tmp);
5228 }
5229
5230 void MacroAssembler::load_method_holder_cld(Register rresult, Register rmethod) {
5231 load_method_holder(rresult, rmethod);
5232 movptr(rresult, Address(rresult, InstanceKlass::class_loader_data_offset()));
5233 }
5234
5235 void MacroAssembler::load_method_holder(Register holder, Register method) {
5236 movptr(holder, Address(method, Method::const_offset())); // ConstMethod*
5237 movptr(holder, Address(holder, ConstMethod::constants_offset())); // ConstantPool*
5238 movptr(holder, Address(holder, ConstantPool::pool_holder_offset())); // InstanceKlass*
5239 }
5240
5241 #ifdef _LP64
5242 void MacroAssembler::load_nklass_compact(Register dst, Register src) {
5243 assert(UseCompactObjectHeaders, "expect compact object headers");
5244
5245 Label fast;
5246 movq(dst, Address(src, oopDesc::mark_offset_in_bytes()));
5247 testb(dst, markWord::monitor_value);
5248 jccb(Assembler::zero, fast);
5249
5250 // Fetch displaced header
5251 movq(dst, Address(dst, OM_OFFSET_NO_MONITOR_VALUE_TAG(header)));
5252
5253 bind(fast);
5254 shrq(dst, markWord::klass_shift);
5255 }
5256 #endif
5257
5258 void MacroAssembler::load_klass(Register dst, Register src, Register tmp) {
5259 assert_different_registers(src, tmp);
5260 assert_different_registers(dst, tmp);
5261 #ifdef _LP64
5262 if (UseCompactObjectHeaders) {
5263 load_nklass_compact(dst, src);
5264 decode_klass_not_null(dst, tmp);
5265 } else if (UseCompressedClassPointers) {
5266 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5267 decode_klass_not_null(dst, tmp);
5268 } else
5269 #endif
5270 {
5271 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
5272 }
5273 }
5274
5275 void MacroAssembler::store_klass(Register dst, Register src, Register tmp) {
5276 assert(!UseCompactObjectHeaders, "not with compact headers");
5277 assert_different_registers(src, tmp);
5278 assert_different_registers(dst, tmp);
5279 #ifdef _LP64
5280 if (UseCompressedClassPointers) {
5281 encode_klass_not_null(src, tmp);
5282 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5283 } else
5284 #endif
5285 movptr(Address(dst, oopDesc::klass_offset_in_bytes()), src);
5286 }
5287
5288 void MacroAssembler::cmp_klass(Register klass, Register obj, Register tmp) {
5289 #ifdef _LP64
5290 if (UseCompactObjectHeaders) {
5291 load_nklass_compact(tmp, obj);
5292 cmpl(klass, tmp);
5293 } else if (UseCompressedClassPointers) {
5294 cmpl(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
5295 } else
5296 #endif
5297 {
5298 cmpptr(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
5299 }
5300 }
5301
5302 void MacroAssembler::cmp_klass(Register src, Register dst, Register tmp1, Register tmp2) {
5303 #ifdef _LP64
5304 if (UseCompactObjectHeaders) {
5305 assert(tmp2 != noreg, "need tmp2");
5306 assert_different_registers(src, dst, tmp1, tmp2);
5307 load_nklass_compact(tmp1, src);
5308 load_nklass_compact(tmp2, dst);
5309 cmpl(tmp1, tmp2);
5310 } else if (UseCompressedClassPointers) {
5311 movl(tmp1, Address(src, oopDesc::klass_offset_in_bytes()));
5312 cmpl(tmp1, Address(dst, oopDesc::klass_offset_in_bytes()));
5313 } else
5314 #endif
5315 {
5316 movptr(tmp1, Address(src, oopDesc::klass_offset_in_bytes()));
5317 cmpptr(tmp1, Address(dst, oopDesc::klass_offset_in_bytes()));
5318 }
5319 }
5320
5321 void MacroAssembler::access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
5322 Register tmp1, Register thread_tmp) {
5323 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5324 decorators = AccessInternal::decorator_fixup(decorators, type);
5325 bool as_raw = (decorators & AS_RAW) != 0;
5326 if (as_raw) {
5327 bs->BarrierSetAssembler::load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5328 } else {
5329 bs->load_at(this, decorators, type, dst, src, tmp1, thread_tmp);
5330 }
5331 }
5332
5333 void MacroAssembler::access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register val,
5334 Register tmp1, Register tmp2, Register tmp3) {
5335 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
5336 decorators = AccessInternal::decorator_fixup(decorators, type);
5337 bool as_raw = (decorators & AS_RAW) != 0;
5338 if (as_raw) {
5339 bs->BarrierSetAssembler::store_at(this, decorators, type, dst, val, tmp1, tmp2, tmp3);
5340 } else {
5348 }
5349
5350 // Doesn't do verification, generates fixed size code
5351 void MacroAssembler::load_heap_oop_not_null(Register dst, Address src, Register tmp1,
5352 Register thread_tmp, DecoratorSet decorators) {
5353 access_load_at(T_OBJECT, IN_HEAP | IS_NOT_NULL | decorators, dst, src, tmp1, thread_tmp);
5354 }
5355
5356 void MacroAssembler::store_heap_oop(Address dst, Register val, Register tmp1,
5357 Register tmp2, Register tmp3, DecoratorSet decorators) {
5358 access_store_at(T_OBJECT, IN_HEAP | decorators, dst, val, tmp1, tmp2, tmp3);
5359 }
5360
5361 // Used for storing nulls.
5362 void MacroAssembler::store_heap_oop_null(Address dst) {
5363 access_store_at(T_OBJECT, IN_HEAP, dst, noreg, noreg, noreg, noreg);
5364 }
5365
5366 #ifdef _LP64
5367 void MacroAssembler::store_klass_gap(Register dst, Register src) {
5368 assert(!UseCompactObjectHeaders, "Don't use with compact headers");
5369 if (UseCompressedClassPointers) {
5370 // Store to klass gap in destination
5371 movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
5372 }
5373 }
5374
5375 #ifdef ASSERT
5376 void MacroAssembler::verify_heapbase(const char* msg) {
5377 assert (UseCompressedOops, "should be compressed");
5378 assert (Universe::heap() != nullptr, "java heap should be initialized");
5379 if (CheckCompressedOops) {
5380 Label ok;
5381 ExternalAddress src2(CompressedOops::ptrs_base_addr());
5382 const bool is_src2_reachable = reachable(src2);
5383 if (!is_src2_reachable) {
5384 push(rscratch1); // cmpptr trashes rscratch1
5385 }
5386 cmpptr(r12_heapbase, src2, rscratch1);
5387 jcc(Assembler::equal, ok);
5388 STOP(msg);
|