< prev index next >

src/hotspot/cpu/x86/macroAssembler_x86.cpp

Print this page

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);
< prev index next >