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
|