< prev index next >

src/hotspot/cpu/riscv/c1_MacroAssembler_riscv.cpp

Print this page

164   } else {
165     j(slow_case);
166   }
167 }
168 
169 void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register len, Register tmp1, Register tmp2) {
170   assert_different_registers(obj, klass, len, tmp1, tmp2);
171   // This assumes that all prototype bits fitr in an int32_t
172   mv(tmp1, (int32_t)(intptr_t)markWord::prototype().value());
173   sd(tmp1, Address(obj, oopDesc::mark_offset_in_bytes()));
174 
175   if (UseCompressedClassPointers) { // Take care not to kill klass
176     encode_klass_not_null(tmp1, klass, tmp2);
177     sw(tmp1, Address(obj, oopDesc::klass_offset_in_bytes()));
178   } else {
179     sd(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
180   }
181 
182   if (len->is_valid()) {
183     sw(len, Address(obj, arrayOopDesc::length_offset_in_bytes()));




184   } else if (UseCompressedClassPointers) {
185     store_klass_gap(obj, zr);
186   }
187 }
188 
189 // preserves obj, destroys len_in_bytes
190 void C1_MacroAssembler::initialize_body(Register obj, Register len_in_bytes, int hdr_size_in_bytes, Register tmp) {
191   assert(hdr_size_in_bytes >= 0, "header size must be positive or 0");
192   Label done;
193 
194   // len_in_bytes is positive and ptr sized
195   sub(len_in_bytes, len_in_bytes, hdr_size_in_bytes);
196   beqz(len_in_bytes, done);
197 
198   // Preserve obj
199   if (hdr_size_in_bytes) {
200     add(obj, obj, hdr_size_in_bytes);
201   }
202   zero_memory(obj, len_in_bytes, tmp);
203   if (hdr_size_in_bytes) {

263         sd(zr, Address(t0, i * wordSize));
264       }
265       if (remainder == 0) {
266         bind(entry_point);
267       }
268       add(t0, t0, unroll * wordSize);
269       bnez(index, loop);
270     }
271   }
272 
273   membar(MacroAssembler::StoreStore);
274 
275   if (CURRENT_ENV->dtrace_alloc_probes()) {
276     assert(obj == x10, "must be");
277     far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)));
278   }
279 
280   verify_oop(obj);
281 }
282 
283 void C1_MacroAssembler::allocate_array(Register obj, Register len, Register tmp1, Register tmp2, int header_size, int f, Register klass, Label& slow_case) {
284   assert_different_registers(obj, len, tmp1, tmp2, klass);
285 
286   // determine alignment mask
287   assert(!(BytesPerWord & 1), "must be multiple of 2 for masking code to work");
288 
289   // check for negative or excessive length
290   mv(t0, (int32_t)max_array_allocation_length);
291   bgeu(len, t0, slow_case, /* is_far */ true);
292 
293   const Register arr_size = tmp2; // okay to be the same
294   // align object end
295   mv(arr_size, (int32_t)header_size * BytesPerWord + MinObjAlignmentInBytesMask);
296   shadd(arr_size, len, arr_size, t0, f);
297   andi(arr_size, arr_size, ~(uint)MinObjAlignmentInBytesMask);
298 
299   try_allocate(obj, arr_size, 0, tmp1, tmp2, slow_case);
300 
301   initialize_header(obj, klass, len, tmp1, tmp2);
302 
303   // clear rest of allocated space
304   const Register len_zero = len;
305   initialize_body(obj, arr_size, header_size * BytesPerWord, len_zero);



306 
307   membar(MacroAssembler::StoreStore);
308 
309   if (CURRENT_ENV->dtrace_alloc_probes()) {
310     assert(obj == x10, "must be");
311     far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)));
312   }
313 
314   verify_oop(obj);
315 }
316 
317 void C1_MacroAssembler::inline_cache_check(Register receiver, Register iCache, Label &L) {
318   verify_oop(receiver);
319   // explicit null check not needed since load from [klass_offset] causes a trap
320   // check against inline cache
321   assert(!MacroAssembler::needs_explicit_null_check(oopDesc::klass_offset_in_bytes()), "must add explicit null check");
322   assert_different_registers(receiver, iCache, t0, t2);
323   cmp_klass(receiver, iCache, t0, t2 /* call-clobbered t2 as a tmp */, L);
324 }
325 

164   } else {
165     j(slow_case);
166   }
167 }
168 
169 void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register len, Register tmp1, Register tmp2) {
170   assert_different_registers(obj, klass, len, tmp1, tmp2);
171   // This assumes that all prototype bits fitr in an int32_t
172   mv(tmp1, (int32_t)(intptr_t)markWord::prototype().value());
173   sd(tmp1, Address(obj, oopDesc::mark_offset_in_bytes()));
174 
175   if (UseCompressedClassPointers) { // Take care not to kill klass
176     encode_klass_not_null(tmp1, klass, tmp2);
177     sw(tmp1, Address(obj, oopDesc::klass_offset_in_bytes()));
178   } else {
179     sd(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
180   }
181 
182   if (len->is_valid()) {
183     sw(len, Address(obj, arrayOopDesc::length_offset_in_bytes()));
184     if (!is_aligned(arrayOopDesc::header_size_in_bytes(), BytesPerWord)) {
185       assert(is_aligned(arrayOopDesc::header_size_in_bytes(), BytesPerInt), "must be 4-byte aligned");
186       sw(zr, Address(obj, arrayOopDesc::header_size_in_bytes()));
187     }
188   } else if (UseCompressedClassPointers) {
189     store_klass_gap(obj, zr);
190   }
191 }
192 
193 // preserves obj, destroys len_in_bytes
194 void C1_MacroAssembler::initialize_body(Register obj, Register len_in_bytes, int hdr_size_in_bytes, Register tmp) {
195   assert(hdr_size_in_bytes >= 0, "header size must be positive or 0");
196   Label done;
197 
198   // len_in_bytes is positive and ptr sized
199   sub(len_in_bytes, len_in_bytes, hdr_size_in_bytes);
200   beqz(len_in_bytes, done);
201 
202   // Preserve obj
203   if (hdr_size_in_bytes) {
204     add(obj, obj, hdr_size_in_bytes);
205   }
206   zero_memory(obj, len_in_bytes, tmp);
207   if (hdr_size_in_bytes) {

267         sd(zr, Address(t0, i * wordSize));
268       }
269       if (remainder == 0) {
270         bind(entry_point);
271       }
272       add(t0, t0, unroll * wordSize);
273       bnez(index, loop);
274     }
275   }
276 
277   membar(MacroAssembler::StoreStore);
278 
279   if (CURRENT_ENV->dtrace_alloc_probes()) {
280     assert(obj == x10, "must be");
281     far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)));
282   }
283 
284   verify_oop(obj);
285 }
286 
287 void C1_MacroAssembler::allocate_array(Register obj, Register len, Register tmp1, Register tmp2, int base_offset_in_bytes, int f, Register klass, Label& slow_case) {
288   assert_different_registers(obj, len, tmp1, tmp2, klass);
289 
290   // determine alignment mask
291   assert(!(BytesPerWord & 1), "must be multiple of 2 for masking code to work");
292 
293   // check for negative or excessive length
294   mv(t0, (int32_t)max_array_allocation_length);
295   bgeu(len, t0, slow_case, /* is_far */ true);
296 
297   const Register arr_size = tmp2; // okay to be the same
298   // align object end
299   mv(arr_size, (int32_t)base_offset_in_bytes + MinObjAlignmentInBytesMask);
300   shadd(arr_size, len, arr_size, t0, f);
301   andi(arr_size, arr_size, ~(uint)MinObjAlignmentInBytesMask);
302 
303   try_allocate(obj, arr_size, 0, tmp1, tmp2, slow_case);
304 
305   initialize_header(obj, klass, len, tmp1, tmp2);
306 
307   // clear rest of allocated space
308   const Register len_zero = len;
309   // We align-up the header size to word-size, because we clear the
310   // possible alignment gap in initialize_header().
311   int hdr_size = align_up(base_offset_in_bytes, BytesPerWord);
312   initialize_body(obj, arr_size, hdr_size, len_zero);
313 
314   membar(MacroAssembler::StoreStore);
315 
316   if (CURRENT_ENV->dtrace_alloc_probes()) {
317     assert(obj == x10, "must be");
318     far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)));
319   }
320 
321   verify_oop(obj);
322 }
323 
324 void C1_MacroAssembler::inline_cache_check(Register receiver, Register iCache, Label &L) {
325   verify_oop(receiver);
326   // explicit null check not needed since load from [klass_offset] causes a trap
327   // check against inline cache
328   assert(!MacroAssembler::needs_explicit_null_check(oopDesc::klass_offset_in_bytes()), "must add explicit null check");
329   assert_different_registers(receiver, iCache, t0, t2);
330   cmp_klass(receiver, iCache, t0, t2 /* call-clobbered t2 as a tmp */, L);
331 }
332 
< prev index next >