< prev index next >

src/hotspot/cpu/aarch64/c1_CodeStubs_aarch64.cpp

Print this page
rev 53735 : AArch64 support for ValueTypes


 158   _result = result;
 159   _info = new CodeEmitInfo(info);
 160 }
 161 
 162 
 163 void NewTypeArrayStub::emit_code(LIR_Assembler* ce) {
 164   assert(__ rsp_offset() == 0, "frame size should be fixed");
 165   __ bind(_entry);
 166   assert(_length->as_register() == r19, "length must in r19,");
 167   assert(_klass_reg->as_register() == r3, "klass_reg must in r3");
 168   __ far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::new_type_array_id)));
 169   ce->add_call_info_here(_info);
 170   ce->verify_oop_map(_info);
 171   assert(_result->as_register() == r0, "result must in r0");
 172   __ b(_continuation);
 173 }
 174 
 175 
 176 // Implementation of NewObjectArrayStub
 177 
 178 NewObjectArrayStub::NewObjectArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info) {
 179   _klass_reg = klass_reg;
 180   _result = result;
 181   _length = length;
 182   _info = new CodeEmitInfo(info);

 183 }
 184 
 185 
 186 void NewObjectArrayStub::emit_code(LIR_Assembler* ce) {
 187   assert(__ rsp_offset() == 0, "frame size should be fixed");
 188   __ bind(_entry);
 189   assert(_length->as_register() == r19, "length must in r19,");
 190   assert(_klass_reg->as_register() == r3, "klass_reg must in r3");




 191   __ far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::new_object_array_id)));


 192   ce->add_call_info_here(_info);
 193   ce->verify_oop_map(_info);
 194   assert(_result->as_register() == r0, "result must in r0");
 195   __ b(_continuation);
 196 }
 197 // Implementation of MonitorAccessStubs
 198 
 199 MonitorEnterStub::MonitorEnterStub(LIR_Opr obj_reg, LIR_Opr lock_reg, CodeEmitInfo* info)
 200 : MonitorAccessStub(obj_reg, lock_reg)
 201 {
 202   _info = new CodeEmitInfo(info);





 203 }
 204 
 205 
 206 void MonitorEnterStub::emit_code(LIR_Assembler* ce) {
 207   assert(__ rsp_offset() == 0, "frame size should be fixed");
 208   __ bind(_entry);









 209   ce->store_parameter(_obj_reg->as_register(),  1);
 210   ce->store_parameter(_lock_reg->as_register(), 0);
 211   Runtime1::StubID enter_id;
 212   if (ce->compilation()->has_fpu_code()) {
 213     enter_id = Runtime1::monitorenter_id;
 214   } else {
 215     enter_id = Runtime1::monitorenter_nofpu_id;
 216   }
 217   __ far_call(RuntimeAddress(Runtime1::entry_for(enter_id)));
 218   ce->add_call_info_here(_info);
 219   ce->verify_oop_map(_info);
 220   __ b(_continuation);
 221 }
 222 
 223 
 224 void MonitorExitStub::emit_code(LIR_Assembler* ce) {
 225   __ bind(_entry);
 226   if (_compute_lock) {
 227     // lock_reg was destroyed by fast unlocking attempt => recompute it
 228     ce->monitor_address(_monitor_ix, _lock_reg);




 158   _result = result;
 159   _info = new CodeEmitInfo(info);
 160 }
 161 
 162 
 163 void NewTypeArrayStub::emit_code(LIR_Assembler* ce) {
 164   assert(__ rsp_offset() == 0, "frame size should be fixed");
 165   __ bind(_entry);
 166   assert(_length->as_register() == r19, "length must in r19,");
 167   assert(_klass_reg->as_register() == r3, "klass_reg must in r3");
 168   __ far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::new_type_array_id)));
 169   ce->add_call_info_here(_info);
 170   ce->verify_oop_map(_info);
 171   assert(_result->as_register() == r0, "result must in r0");
 172   __ b(_continuation);
 173 }
 174 
 175 
 176 // Implementation of NewObjectArrayStub
 177 
 178 NewObjectArrayStub::NewObjectArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info, bool is_value_type) {
 179   _klass_reg = klass_reg;
 180   _result = result;
 181   _length = length;
 182   _info = new CodeEmitInfo(info);
 183   _is_value_type = is_value_type; 
 184 }
 185 
 186 
 187 void NewObjectArrayStub::emit_code(LIR_Assembler* ce) {
 188   assert(__ rsp_offset() == 0, "frame size should be fixed");
 189   __ bind(_entry);
 190   assert(_length->as_register() == r19, "length must in r19,");
 191   assert(_klass_reg->as_register() == r3, "klass_reg must in r3");
 192 
 193   if (_is_value_type) {
 194     __ far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::new_value_array_id)));
 195   } else {
 196     __ far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::new_object_array_id)));
 197   }
 198 
 199   ce->add_call_info_here(_info);
 200   ce->verify_oop_map(_info);
 201   assert(_result->as_register() == r0, "result must in r0");
 202   __ b(_continuation);
 203 }
 204 // Implementation of MonitorAccessStubs
 205 
 206 MonitorEnterStub::MonitorEnterStub(LIR_Opr obj_reg, LIR_Opr lock_reg, CodeEmitInfo* info,  CodeStub* throw_imse_stub, LIR_Opr scratch_reg)
 207 : MonitorAccessStub(obj_reg, lock_reg)
 208 {
 209   _info = new CodeEmitInfo(info);
 210   _scratch_reg = scratch_reg;
 211   _throw_imse_stub = throw_imse_stub;
 212   if (_throw_imse_stub != NULL) {
 213     assert(_scratch_reg != LIR_OprFact::illegalOpr, "must be");
 214   }
 215 }
 216 
 217 
 218 void MonitorEnterStub::emit_code(LIR_Assembler* ce) {
 219   assert(__ rsp_offset() == 0, "frame size should be fixed");
 220   __ bind(_entry);
 221   if (_throw_imse_stub != NULL) {
 222     // When we come here, _obj_reg has already been checked to be non-null.
 223     Register mark = _scratch_reg->as_register();
 224     __ ldr(mark, Address(_obj_reg->as_register(), oopDesc::mark_offset_in_bytes()));
 225     __ andr(mark, mark, (u1) markOopDesc::always_locked_pattern && 0xF);
 226     __ cmp(r2, (u1) markOopDesc::always_locked_pattern); 
 227     __ br(Assembler::NE, *_throw_imse_stub->entry());
 228   }
 229 
 230   ce->store_parameter(_obj_reg->as_register(),  1);
 231   ce->store_parameter(_lock_reg->as_register(), 0);
 232   Runtime1::StubID enter_id;
 233   if (ce->compilation()->has_fpu_code()) {
 234     enter_id = Runtime1::monitorenter_id;
 235   } else {
 236     enter_id = Runtime1::monitorenter_nofpu_id;
 237   }
 238   __ far_call(RuntimeAddress(Runtime1::entry_for(enter_id)));
 239   ce->add_call_info_here(_info);
 240   ce->verify_oop_map(_info);
 241   __ b(_continuation);
 242 }
 243 
 244 
 245 void MonitorExitStub::emit_code(LIR_Assembler* ce) {
 246   __ bind(_entry);
 247   if (_compute_lock) {
 248     // lock_reg was destroyed by fast unlocking attempt => recompute it
 249     ce->monitor_address(_monitor_ix, _lock_reg);


< prev index next >