1 /*
  2  * Copyright (c) 1999, 2021, 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   MacroAssembler::null_check(receiver, oopDesc::klass_offset_in_bytes(), &Lmiss);
 49   load_klass(temp_reg, receiver);
 50 
 51   if (TrapBasedICMissChecks && TrapBasedNullChecks) {
 52     trap_ic_miss_check(temp_reg, iCache);
 53   } else {
 54     Label Lok;
 55     cmpd(CCR0, temp_reg, iCache);
 56     beq(CCR0, Lok);
 57     bind(Lmiss);
 58     //load_const_optimized(temp_reg, SharedRuntime::get_ic_miss_stub(), R0);
 59     calculate_address_from_global_toc(temp_reg, SharedRuntime::get_ic_miss_stub(), true, true, false);
 60     mtctr(temp_reg);
 61     bctr();
 62     align(32, 12);
 63     bind(Lok);
 64   }
 65 }
 66 
 67 
 68 void C1_MacroAssembler::explicit_null_check(Register base) {
 69   Unimplemented();
 70 }
 71 
 72 
 73 void C1_MacroAssembler::build_frame(int frame_size_in_bytes, int bang_size_in_bytes) {
 74   // Avoid stack bang as first instruction. It may get overwritten by patch_verified_entry.
 75   const Register return_pc = R20;
 76   mflr(return_pc);
 77 
 78   // Make sure there is enough stack space for this method's activation.
 79   assert(bang_size_in_bytes >= frame_size_in_bytes, "stack bang size incorrect");
 80   generate_stack_overflow_check(bang_size_in_bytes);
 81 
 82   std(return_pc, _abi0(lr), R1_SP);     // SP->lr = return_pc
 83   push_frame(frame_size_in_bytes, R0); // SP -= frame_size_in_bytes
 84 
 85   BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
 86   bs->nmethod_entry_barrier(this, R20);
 87 }
 88 
 89 
 90 void C1_MacroAssembler::verified_entry(bool breakAtEntry) {
 91   if (breakAtEntry) illtrap();
 92   // build frame
 93 }
 94 
 95 void C1_MacroAssembler::try_allocate(
 96   Register obj,                        // result: pointer to object after successful allocation
 97   Register var_size_in_bytes,          // object size in bytes if unknown at compile time; invalid otherwise
 98   int      con_size_in_bytes,          // object size in bytes if   known at compile time
 99   Register t1,                         // temp register, must be global register for incr_allocated_bytes
100   Register t2,                         // temp register
101   Label&   slow_case                   // continuation point if fast allocation fails
102 ) {
103   if (UseTLAB) {
104     tlab_allocate(obj, var_size_in_bytes, con_size_in_bytes, t1, slow_case);
105   } else {
106     b(slow_case);
107   }
108 }
109 
110 
111 void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register len, Register t1, Register t2) {
112   assert_different_registers(obj, klass, len, t1, t2);
113   load_const_optimized(t1, (intx)markWord::prototype().value());
114   std(t1, oopDesc::mark_offset_in_bytes(), obj);
115   store_klass(obj, klass);
116   if (len->is_valid()) {
117     stw(len, arrayOopDesc::length_offset_in_bytes(), obj);
118   } else if (UseCompressedClassPointers) {
119     // Otherwise length is in the class gap.
120     store_klass_gap(obj);
121   }
122 }
123 
124 
125 void C1_MacroAssembler::initialize_body(Register base, Register index) {
126   assert_different_registers(base, index);
127   srdi(index, index, LogBytesPerWord);
128   clear_memory_doubleword(base, index);
129 }
130 
131 void C1_MacroAssembler::initialize_body(Register obj, Register tmp1, Register tmp2,
132                                         int obj_size_in_bytes, int hdr_size_in_bytes) {
133   const int index = (obj_size_in_bytes - hdr_size_in_bytes) / HeapWordSize;
134 
135   // 2x unrolled loop is shorter with more than 9 HeapWords.
136   if (index <= 9) {
137     clear_memory_unrolled(obj, index, R0, hdr_size_in_bytes);
138   } else {
139     const Register base_ptr = tmp1,
140                    cnt_dwords = tmp2;
141 
142     addi(base_ptr, obj, hdr_size_in_bytes); // Compute address of first element.
143     clear_memory_doubleword(base_ptr, cnt_dwords, R0, index);
144   }
145 }
146 
147 void C1_MacroAssembler::allocate_object(
148   Register obj,                        // result: pointer to object after successful allocation
149   Register t1,                         // temp register
150   Register t2,                         // temp register
151   Register t3,                         // temp register
152   int      hdr_size,                   // object header size in words
153   int      obj_size,                   // object size in words
154   Register klass,                      // object klass
155   Label&   slow_case                   // continuation point if fast allocation fails
156 ) {
157   assert_different_registers(obj, t1, t2, t3, klass);
158 
159   // allocate space & initialize header
160   if (!is_simm16(obj_size * wordSize)) {
161     // Would need to use extra register to load
162     // object size => go the slow case for now.
163     b(slow_case);
164     return;
165   }
166   try_allocate(obj, noreg, obj_size * wordSize, t2, t3, slow_case);
167 
168   initialize_object(obj, klass, noreg, obj_size * HeapWordSize, t1, t2);
169 }
170 
171 void C1_MacroAssembler::initialize_object(
172   Register obj,                        // result: pointer to object after successful allocation
173   Register klass,                      // object klass
174   Register var_size_in_bytes,          // object size in bytes if unknown at compile time; invalid otherwise
175   int      con_size_in_bytes,          // object size in bytes if   known at compile time
176   Register t1,                         // temp register
177   Register t2                          // temp register
178   ) {
179   const int hdr_size_in_bytes = instanceOopDesc::header_size() * HeapWordSize;
180 
181   initialize_header(obj, klass, noreg, t1, t2);
182 
183 #ifdef ASSERT
184   {
185     lwz(t1, in_bytes(Klass::layout_helper_offset()), klass);
186     if (var_size_in_bytes != noreg) {
187       cmpw(CCR0, t1, var_size_in_bytes);
188     } else {
189       cmpwi(CCR0, t1, con_size_in_bytes);
190     }
191     asm_assert_eq("bad size in initialize_object");
192   }
193 #endif
194 
195   // Initialize body.
196   if (var_size_in_bytes != noreg) {
197     // Use a loop.
198     addi(t1, obj, hdr_size_in_bytes);                // Compute address of first element.
199     addi(t2, var_size_in_bytes, -hdr_size_in_bytes); // Compute size of body.
200     initialize_body(t1, t2);
201   } else if (con_size_in_bytes > hdr_size_in_bytes) {
202     // Use a loop.
203     initialize_body(obj, t1, t2, con_size_in_bytes, hdr_size_in_bytes);
204   }
205 
206   if (CURRENT_ENV->dtrace_alloc_probes()) {
207     Unimplemented();
208 //    assert(obj == O0, "must be");
209 //    call(CAST_FROM_FN_PTR(address, Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)),
210 //         relocInfo::runtime_call_type);
211   }
212 
213   verify_oop(obj, FILE_AND_LINE);
214 }
215 
216 
217 void C1_MacroAssembler::allocate_array(
218   Register obj,                        // result: pointer to array after successful allocation
219   Register len,                        // array length
220   Register t1,                         // temp register
221   Register t2,                         // temp register
222   Register t3,                         // temp register
223   int      hdr_size,                   // object header size in words
224   int      elt_size,                   // element size in bytes
225   Register klass,                      // object klass
226   Label&   slow_case                   // continuation point if fast allocation fails
227 ) {
228   assert_different_registers(obj, len, t1, t2, t3, klass);
229 
230   // Determine alignment mask.
231   assert(!(BytesPerWord & 1), "must be a multiple of 2 for masking code to work");
232   int log2_elt_size = exact_log2(elt_size);
233 
234   // Check for negative or excessive length.
235   size_t max_length = max_array_allocation_length >> log2_elt_size;
236   if (UseTLAB) {
237     size_t max_tlab = align_up(ThreadLocalAllocBuffer::max_size() >> log2_elt_size, 64*K);
238     if (max_tlab < max_length) { max_length = max_tlab; }
239   }
240   load_const_optimized(t1, max_length);
241   cmpld(CCR0, len, t1);
242   bc_far_optimized(Assembler::bcondCRbiIs1, bi0(CCR0, Assembler::greater), slow_case);
243 
244   // compute array size
245   // note: If 0 <= len <= max_length, len*elt_size + header + alignment is
246   //       smaller or equal to the largest integer; also, since top is always
247   //       aligned, we can do the alignment here instead of at the end address
248   //       computation.
249   const Register arr_size = t1;
250   Register arr_len_in_bytes = len;
251   if (elt_size != 1) {
252     sldi(t1, len, log2_elt_size);
253     arr_len_in_bytes = t1;
254   }
255   addi(arr_size, arr_len_in_bytes, hdr_size * wordSize + MinObjAlignmentInBytesMask); // Add space for header & alignment.
256   clrrdi(arr_size, arr_size, LogMinObjAlignmentInBytes);                              // Align array size.
257 
258   // Allocate space & initialize header.
259   try_allocate(obj, arr_size, 0, t2, t3, slow_case);
260   initialize_header(obj, klass, len, t2, t3);
261 
262   // Initialize body.
263   const Register base  = t2;
264   const Register index = t3;
265   addi(base, obj, hdr_size * wordSize);               // compute address of first element
266   addi(index, arr_size, -(hdr_size * wordSize));      // compute index = number of bytes to clear
267   initialize_body(base, index);
268 
269   if (CURRENT_ENV->dtrace_alloc_probes()) {
270     Unimplemented();
271     //assert(obj == O0, "must be");
272     //call(CAST_FROM_FN_PTR(address, Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)),
273     //     relocInfo::runtime_call_type);
274   }
275 
276   verify_oop(obj, FILE_AND_LINE);
277 }
278 
279 
280 #ifndef PRODUCT
281 
282 void C1_MacroAssembler::verify_stack_oop(int stack_offset) {
283   verify_oop_addr((RegisterOrConstant)stack_offset, R1_SP, "broken oop in stack slot");
284 }
285 
286 void C1_MacroAssembler::verify_not_null_oop(Register r) {
287   Label not_null;
288   cmpdi(CCR0, r, 0);
289   bne(CCR0, not_null);
290   stop("non-null oop required");
291   bind(not_null);
292   verify_oop(r, FILE_AND_LINE);
293 }
294 
295 #endif // PRODUCT
296 
297 void C1_MacroAssembler::null_check(Register r, Label* Lnull) {
298   if (TrapBasedNullChecks) { // SIGTRAP based
299     trap_null_check(r);
300   } else { // explicit
301     //const address exception_entry = Runtime1::entry_for(Runtime1::throw_null_pointer_exception_id);
302     assert(Lnull != NULL, "must have Label for explicit check");
303     cmpdi(CCR0, r, 0);
304     bc_far_optimized(Assembler::bcondCRbiIs1, bi0(CCR0, Assembler::equal), *Lnull);
305   }
306 }
307 
308 address C1_MacroAssembler::call_c_with_frame_resize(address dest, int frame_resize) {
309   if (frame_resize) { resize_frame(-frame_resize, R0); }
310 #if defined(ABI_ELFv2)
311   address return_pc = call_c(dest, relocInfo::runtime_call_type);
312 #else
313   address return_pc = call_c(CAST_FROM_FN_PTR(FunctionDescriptor*, dest), relocInfo::runtime_call_type);
314 #endif
315   if (frame_resize) { resize_frame(frame_resize, R0); }
316   return return_pc;
317 }