1 /*
  2  * Copyright (c) 1999, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * Copyright (c) 2012, 2018 SAP SE. All rights reserved.
  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  6  * This code is free software; you can redistribute it and/or modify it
  7  * under the terms of the GNU General Public License version 2 only, as
  8  * published by the Free Software Foundation.
  9  *
 10  * This code is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 13  * version 2 for more details (a copy is included in the LICENSE file that
 14  * accompanied this code).
 15  *
 16  * You should have received a copy of the GNU General Public License version
 17  * 2 along with this work; if not, write to the Free Software Foundation,
 18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 19  *
 20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 21  * or visit www.oracle.com if you need additional information or have any
 22  * questions.
 23  *
 24  */
 25 
 26 #include "precompiled.hpp"
 27 #include "asm/macroAssembler.inline.hpp"
 28 #include "c1/c1_MacroAssembler.hpp"
 29 #include "c1/c1_Runtime1.hpp"
 30 #include "gc/shared/collectedHeap.hpp"
 31 #include "gc/shared/tlab_globals.hpp"
 32 #include "interpreter/interpreter.hpp"
 33 #include "oops/arrayOop.hpp"
 34 #include "oops/markWord.hpp"
 35 #include "runtime/basicLock.hpp"
 36 #include "runtime/os.hpp"
 37 #include "runtime/sharedRuntime.hpp"
 38 #include "runtime/stubRoutines.hpp"
 39 #include "utilities/align.hpp"
 40 #include "utilities/macros.hpp"
 41 #include "utilities/powerOfTwo.hpp"
 42 
 43 void C1_MacroAssembler::inline_cache_check(Register receiver, Register iCache) {
 44   const Register temp_reg = R12_scratch2;
 45   Label Lmiss;
 46 
 47   verify_oop(receiver, FILE_AND_LINE);
 48   load_klass_check_null(temp_reg, receiver, &Lmiss);
 49 
 50   if (TrapBasedICMissChecks && TrapBasedNullChecks) {
 51     trap_ic_miss_check(temp_reg, iCache);
 52   } else {
 53     Label Lok;
 54     cmpd(CCR0, temp_reg, iCache);
 55     beq(CCR0, Lok);
 56     bind(Lmiss);
 57     //load_const_optimized(temp_reg, SharedRuntime::get_ic_miss_stub(), R0);
 58     calculate_address_from_global_toc(temp_reg, SharedRuntime::get_ic_miss_stub(), true, true, false);
 59     mtctr(temp_reg);
 60     bctr();
 61     align(32, 12);
 62     bind(Lok);
 63   }
 64 }
 65 
 66 
 67 void C1_MacroAssembler::explicit_null_check(Register base) {
 68   Unimplemented();
 69 }
 70 
 71 
 72 void C1_MacroAssembler::build_frame(int frame_size_in_bytes, int bang_size_in_bytes) {
 73   // Avoid stack bang as first instruction. It may get overwritten by patch_verified_entry.
 74   const Register return_pc = R20;
 75   mflr(return_pc);
 76 
 77   // Make sure there is enough stack space for this method's activation.
 78   assert(bang_size_in_bytes >= frame_size_in_bytes, "stack bang size incorrect");
 79   generate_stack_overflow_check(bang_size_in_bytes);
 80 
 81   std(return_pc, _abi0(lr), R1_SP);     // SP->lr = return_pc
 82   push_frame(frame_size_in_bytes, R0); // SP -= frame_size_in_bytes
 83 
 84   BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
 85   bs->nmethod_entry_barrier(this, R20);
 86 }
 87 
 88 
 89 void C1_MacroAssembler::verified_entry(bool breakAtEntry) {
 90   if (breakAtEntry) illtrap();
 91   // build frame
 92 }
 93 
 94 
 95 void C1_MacroAssembler::lock_object(Register Rmark, Register Roop, Register Rbox, Register Rscratch, Label& slow_case) {
 96   assert_different_registers(Rmark, Roop, Rbox, Rscratch);
 97 
 98   Label done, cas_failed, slow_int;
 99 
100   // The following move must be the first instruction of emitted since debug
101   // information may be generated for it.
102   // Load object header.
103   ld(Rmark, oopDesc::mark_offset_in_bytes(), Roop);
104 
105   verify_oop(Roop, FILE_AND_LINE);
106 
107   // Save object being locked into the BasicObjectLock...
108   std(Roop, in_bytes(BasicObjectLock::obj_offset()), Rbox);
109 
110   if (DiagnoseSyncOnValueBasedClasses != 0) {
111     load_klass(Rscratch, Roop);
112     lwz(Rscratch, in_bytes(Klass::access_flags_offset()), Rscratch);
113     testbitdi(CCR0, R0, Rscratch, exact_log2(JVM_ACC_IS_VALUE_BASED_CLASS));
114     bne(CCR0, slow_int);
115   }
116 
117   if (LockingMode == LM_LIGHTWEIGHT) {
118     lightweight_lock(Roop, Rmark, Rscratch, slow_int);
119   } else if (LockingMode == LM_LEGACY) {
120     // ... and mark it unlocked.
121     ori(Rmark, Rmark, markWord::unlocked_value);
122 
123     // Save unlocked object header into the displaced header location on the stack.
124     std(Rmark, BasicLock::displaced_header_offset_in_bytes(), Rbox);
125 
126     // Compare object markWord with Rmark and if equal exchange Rscratch with object markWord.
127     assert(oopDesc::mark_offset_in_bytes() == 0, "cas must take a zero displacement");
128     cmpxchgd(/*flag=*/CCR0,
129              /*current_value=*/Rscratch,
130              /*compare_value=*/Rmark,
131              /*exchange_value=*/Rbox,
132              /*where=*/Roop/*+0==mark_offset_in_bytes*/,
133              MacroAssembler::MemBarRel | MacroAssembler::MemBarAcq,
134              MacroAssembler::cmpxchgx_hint_acquire_lock(),
135              noreg,
136              &cas_failed,
137              /*check without membar and ldarx first*/true);
138     // If compare/exchange succeeded we found an unlocked object and we now have locked it
139     // hence we are done.
140   }
141   b(done);
142 
143   bind(slow_int);
144   b(slow_case); // far
145 
146   if (LockingMode == LM_LEGACY) {
147     bind(cas_failed);
148     // We did not find an unlocked object so see if this is a recursive case.
149     sub(Rscratch, Rscratch, R1_SP);
150     load_const_optimized(R0, (~(os::vm_page_size()-1) | markWord::lock_mask_in_place));
151     and_(R0/*==0?*/, Rscratch, R0);
152     std(R0/*==0, perhaps*/, BasicLock::displaced_header_offset_in_bytes(), Rbox);
153     bne(CCR0, slow_int);
154   }
155 
156   bind(done);
157   inc_held_monitor_count(Rmark /*tmp*/);
158 }
159 
160 
161 void C1_MacroAssembler::unlock_object(Register Rmark, Register Roop, Register Rbox, Label& slow_case) {
162   assert_different_registers(Rmark, Roop, Rbox);
163 
164   Label slow_int, done;
165 
166   Address mark_addr(Roop, oopDesc::mark_offset_in_bytes());
167   assert(mark_addr.disp() == 0, "cas must take a zero displacement");
168 
169   if (LockingMode != LM_LIGHTWEIGHT) {
170     // Test first if it is a fast recursive unlock.
171     ld(Rmark, BasicLock::displaced_header_offset_in_bytes(), Rbox);
172     cmpdi(CCR0, Rmark, 0);
173     beq(CCR0, done);
174   }
175 
176   // Load object.
177   ld(Roop, in_bytes(BasicObjectLock::obj_offset()), Rbox);
178   verify_oop(Roop, FILE_AND_LINE);
179 
180   if (LockingMode == LM_LIGHTWEIGHT) {
181     ld(Rmark, oopDesc::mark_offset_in_bytes(), Roop);
182     andi_(R0, Rmark, markWord::monitor_value);
183     bne(CCR0, slow_int);
184     lightweight_unlock(Roop, Rmark, slow_int);
185   } else if (LockingMode == LM_LEGACY) {
186     // Check if it is still a light weight lock, this is is true if we see
187     // the stack address of the basicLock in the markWord of the object.
188     cmpxchgd(/*flag=*/CCR0,
189              /*current_value=*/R0,
190              /*compare_value=*/Rbox,
191              /*exchange_value=*/Rmark,
192              /*where=*/Roop,
193              MacroAssembler::MemBarRel,
194              MacroAssembler::cmpxchgx_hint_release_lock(),
195              noreg,
196              &slow_int);
197   }
198   b(done);
199   bind(slow_int);
200   b(slow_case); // far
201 
202   // Done
203   bind(done);
204   dec_held_monitor_count(Rmark /*tmp*/);
205 }
206 
207 
208 void C1_MacroAssembler::try_allocate(
209   Register obj,                        // result: pointer to object after successful allocation
210   Register var_size_in_bytes,          // object size in bytes if unknown at compile time; invalid otherwise
211   int      con_size_in_bytes,          // object size in bytes if   known at compile time
212   Register t1,                         // temp register, must be global register for incr_allocated_bytes
213   Register t2,                         // temp register
214   Label&   slow_case                   // continuation point if fast allocation fails
215 ) {
216   if (UseTLAB) {
217     tlab_allocate(obj, var_size_in_bytes, con_size_in_bytes, t1, slow_case);
218   } else {
219     b(slow_case);
220   }
221 }
222 
223 
224 void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register len, Register t1, Register t2) {
225   assert_different_registers(obj, klass, len, t1, t2);
226   load_const_optimized(t1, (intx)markWord::prototype().value());
227   std(t1, oopDesc::mark_offset_in_bytes(), obj);
228   store_klass(obj, klass);
229   if (len->is_valid()) {
230     stw(len, arrayOopDesc::length_offset_in_bytes(), obj);
231   } else if (UseCompressedClassPointers) {
232     // Otherwise length is in the class gap.
233     store_klass_gap(obj);
234   }
235 }
236 
237 
238 void C1_MacroAssembler::initialize_body(Register base, Register index) {
239   assert_different_registers(base, index);
240   srdi(index, index, LogBytesPerWord);
241   clear_memory_doubleword(base, index);
242 }
243 
244 void C1_MacroAssembler::initialize_body(Register obj, Register tmp1, Register tmp2,
245                                         int obj_size_in_bytes, int hdr_size_in_bytes) {
246   const int index = (obj_size_in_bytes - hdr_size_in_bytes) / HeapWordSize;
247 
248   // 2x unrolled loop is shorter with more than 9 HeapWords.
249   if (index <= 9) {
250     clear_memory_unrolled(obj, index, R0, hdr_size_in_bytes);
251   } else {
252     const Register base_ptr = tmp1,
253                    cnt_dwords = tmp2;
254 
255     addi(base_ptr, obj, hdr_size_in_bytes); // Compute address of first element.
256     clear_memory_doubleword(base_ptr, cnt_dwords, R0, index);
257   }
258 }
259 
260 void C1_MacroAssembler::allocate_object(
261   Register obj,                        // result: pointer to object after successful allocation
262   Register t1,                         // temp register
263   Register t2,                         // temp register
264   Register t3,                         // temp register
265   int      hdr_size,                   // object header size in words
266   int      obj_size,                   // object size in words
267   Register klass,                      // object klass
268   Label&   slow_case                   // continuation point if fast allocation fails
269 ) {
270   assert_different_registers(obj, t1, t2, t3, klass);
271 
272   // allocate space & initialize header
273   if (!is_simm16(obj_size * wordSize)) {
274     // Would need to use extra register to load
275     // object size => go the slow case for now.
276     b(slow_case);
277     return;
278   }
279   try_allocate(obj, noreg, obj_size * wordSize, t2, t3, slow_case);
280 
281   initialize_object(obj, klass, noreg, obj_size * HeapWordSize, t1, t2);
282 }
283 
284 void C1_MacroAssembler::initialize_object(
285   Register obj,                        // result: pointer to object after successful allocation
286   Register klass,                      // object klass
287   Register var_size_in_bytes,          // object size in bytes if unknown at compile time; invalid otherwise
288   int      con_size_in_bytes,          // object size in bytes if   known at compile time
289   Register t1,                         // temp register
290   Register t2                          // temp register
291   ) {
292   const int hdr_size_in_bytes = instanceOopDesc::header_size() * HeapWordSize;
293 
294   initialize_header(obj, klass, noreg, t1, t2);
295 
296 #ifdef ASSERT
297   {
298     lwz(t1, in_bytes(Klass::layout_helper_offset()), klass);
299     if (var_size_in_bytes != noreg) {
300       cmpw(CCR0, t1, var_size_in_bytes);
301     } else {
302       cmpwi(CCR0, t1, con_size_in_bytes);
303     }
304     asm_assert_eq("bad size in initialize_object");
305   }
306 #endif
307 
308   // Initialize body.
309   if (var_size_in_bytes != noreg) {
310     // Use a loop.
311     addi(t1, obj, hdr_size_in_bytes);                // Compute address of first element.
312     addi(t2, var_size_in_bytes, -hdr_size_in_bytes); // Compute size of body.
313     initialize_body(t1, t2);
314   } else if (con_size_in_bytes > hdr_size_in_bytes) {
315     // Use a loop.
316     initialize_body(obj, t1, t2, con_size_in_bytes, hdr_size_in_bytes);
317   }
318 
319   if (CURRENT_ENV->dtrace_alloc_probes()) {
320     Unimplemented();
321 //    assert(obj == O0, "must be");
322 //    call(CAST_FROM_FN_PTR(address, Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)),
323 //         relocInfo::runtime_call_type);
324   }
325 
326   verify_oop(obj, FILE_AND_LINE);
327 }
328 
329 
330 void C1_MacroAssembler::allocate_array(
331   Register obj,                        // result: pointer to array after successful allocation
332   Register len,                        // array length
333   Register t1,                         // temp register
334   Register t2,                         // temp register
335   Register t3,                         // temp register
336   int      hdr_size,                   // object header size in words
337   int      elt_size,                   // element size in bytes
338   Register klass,                      // object klass
339   Label&   slow_case                   // continuation point if fast allocation fails
340 ) {
341   assert_different_registers(obj, len, t1, t2, t3, klass);
342 
343   // Determine alignment mask.
344   assert(!(BytesPerWord & 1), "must be a multiple of 2 for masking code to work");
345   int log2_elt_size = exact_log2(elt_size);
346 
347   // Check for negative or excessive length.
348   size_t max_length = max_array_allocation_length >> log2_elt_size;
349   if (UseTLAB) {
350     size_t max_tlab = align_up(ThreadLocalAllocBuffer::max_size() >> log2_elt_size, 64*K);
351     if (max_tlab < max_length) { max_length = max_tlab; }
352   }
353   load_const_optimized(t1, max_length);
354   cmpld(CCR0, len, t1);
355   bc_far_optimized(Assembler::bcondCRbiIs1, bi0(CCR0, Assembler::greater), slow_case);
356 
357   // compute array size
358   // note: If 0 <= len <= max_length, len*elt_size + header + alignment is
359   //       smaller or equal to the largest integer; also, since top is always
360   //       aligned, we can do the alignment here instead of at the end address
361   //       computation.
362   const Register arr_size = t1;
363   Register arr_len_in_bytes = len;
364   if (elt_size != 1) {
365     sldi(t1, len, log2_elt_size);
366     arr_len_in_bytes = t1;
367   }
368   addi(arr_size, arr_len_in_bytes, hdr_size * wordSize + MinObjAlignmentInBytesMask); // Add space for header & alignment.
369   clrrdi(arr_size, arr_size, LogMinObjAlignmentInBytes);                              // Align array size.
370 
371   // Allocate space & initialize header.
372   try_allocate(obj, arr_size, 0, t2, t3, slow_case);
373   initialize_header(obj, klass, len, t2, t3);
374 
375   // Initialize body.
376   const Register base  = t2;
377   const Register index = t3;
378   addi(base, obj, hdr_size * wordSize);               // compute address of first element
379   addi(index, arr_size, -(hdr_size * wordSize));      // compute index = number of bytes to clear










380   initialize_body(base, index);
381 
382   if (CURRENT_ENV->dtrace_alloc_probes()) {
383     Unimplemented();
384     //assert(obj == O0, "must be");
385     //call(CAST_FROM_FN_PTR(address, Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)),
386     //     relocInfo::runtime_call_type);
387   }
388 
389   verify_oop(obj, FILE_AND_LINE);
390 }
391 
392 
393 #ifndef PRODUCT
394 
395 void C1_MacroAssembler::verify_stack_oop(int stack_offset) {
396   verify_oop_addr((RegisterOrConstant)stack_offset, R1_SP, "broken oop in stack slot");
397 }
398 
399 void C1_MacroAssembler::verify_not_null_oop(Register r) {
400   Label not_null;
401   cmpdi(CCR0, r, 0);
402   bne(CCR0, not_null);
403   stop("non-null oop required");
404   bind(not_null);
405   verify_oop(r, FILE_AND_LINE);
406 }
407 
408 #endif // PRODUCT
409 
410 void C1_MacroAssembler::null_check(Register r, Label* Lnull) {
411   if (TrapBasedNullChecks) { // SIGTRAP based
412     trap_null_check(r);
413   } else { // explicit
414     //const address exception_entry = Runtime1::entry_for(Runtime1::throw_null_pointer_exception_id);
415     assert(Lnull != nullptr, "must have Label for explicit check");
416     cmpdi(CCR0, r, 0);
417     bc_far_optimized(Assembler::bcondCRbiIs1, bi0(CCR0, Assembler::equal), *Lnull);
418   }
419 }
420 
421 address C1_MacroAssembler::call_c_with_frame_resize(address dest, int frame_resize) {
422   if (frame_resize) { resize_frame(-frame_resize, R0); }
423 #if defined(ABI_ELFv2)
424   address return_pc = call_c(dest, relocInfo::runtime_call_type);
425 #else
426   address return_pc = call_c(CAST_FROM_FN_PTR(FunctionDescriptor*, dest), relocInfo::runtime_call_type);
427 #endif
428   if (frame_resize) { resize_frame(frame_resize, R0); }
429   return return_pc;
430 }
--- EOF ---