1 /*
  2  * Copyright (c) 2003, 2021, Oracle and/or its affiliates. All rights reserved.
  3  * Copyright (c) 2014, 2020, Red Hat Inc. All rights reserved.
  4  * Copyright (c) 2021, Azul Systems, Inc. All rights reserved.
  5  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  6  *
  7  * This code is free software; you can redistribute it and/or modify it
  8  * under the terms of the GNU General Public License version 2 only, as
  9  * published by the Free Software Foundation.
 10  *
 11  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  * version 2 for more details (a copy is included in the LICENSE file that
 15  * accompanied this code).
 16  *
 17  * You should have received a copy of the GNU General Public License version
 18  * 2 along with this work; if not, write to the Free Software Foundation,
 19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  *
 21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  *
 25  */
 26 
 27 #include "precompiled.hpp"
 28 #include "asm/macroAssembler.inline.hpp"
 29 #include "interpreter/interp_masm.hpp"
 30 #include "interpreter/interpreter.hpp"
 31 #include "interpreter/interpreterRuntime.hpp"
 32 #include "memory/allocation.inline.hpp"
 33 #include "oops/method.hpp"
 34 #include "oops/oop.inline.hpp"
 35 #include "runtime/handles.inline.hpp"
 36 #include "runtime/icache.hpp"
 37 #include "runtime/interfaceSupport.inline.hpp"
 38 #include "runtime/signature.hpp"
 39 
 40 #define __ _masm->
 41 
 42 // Implementation of SignatureHandlerGenerator
 43 Register InterpreterRuntime::SignatureHandlerGenerator::from() { return rlocals; }
 44 Register InterpreterRuntime::SignatureHandlerGenerator::to()   { return sp; }
 45 Register InterpreterRuntime::SignatureHandlerGenerator::temp() { return rscratch1; }
 46 
 47 Register InterpreterRuntime::SignatureHandlerGenerator::next_gpr() {
 48   if (_num_reg_int_args < Argument::n_int_register_parameters_c-1) {
 49     return as_Register(_num_reg_int_args++ + c_rarg1->encoding());
 50   }
 51   return noreg;
 52 }
 53 
 54 FloatRegister InterpreterRuntime::SignatureHandlerGenerator::next_fpr() {
 55   if (_num_reg_fp_args < Argument::n_float_register_parameters_c) {
 56     return as_FloatRegister(_num_reg_fp_args++);
 57   }
 58   return fnoreg;
 59 }
 60 
 61 // On macos/aarch64 native stack is packed, int/float are using only 4 bytes
 62 // on stack. Natural alignment for types are still in place,
 63 // for example double/long should be 8 bytes aligned.
 64 
 65 int InterpreterRuntime::SignatureHandlerGenerator::next_stack_offset(unsigned elem_size) {
 66   MACOS_ONLY(_stack_offset = align_up(_stack_offset, elem_size));
 67   int ret = _stack_offset;
 68   _stack_offset += NOT_MACOS(wordSize) MACOS_ONLY(elem_size);
 69   return ret;
 70 }
 71 
 72 InterpreterRuntime::SignatureHandlerGenerator::SignatureHandlerGenerator(
 73       const methodHandle& method, CodeBuffer* buffer) : NativeSignatureIterator(method) {
 74   _masm = new MacroAssembler(buffer);
 75   _num_reg_int_args = (method->is_static() ? 1 : 0);
 76   _num_reg_fp_args = 0;
 77   _stack_offset = 0;
 78 }
 79 
 80 void InterpreterRuntime::SignatureHandlerGenerator::pass_byte() {
 81   const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
 82 
 83   Register reg = next_gpr();
 84   if (reg != noreg) {
 85     __ ldr(reg, src);
 86   } else {
 87     __ ldrb(r0, src);
 88     __ strb(r0, Address(to(), next_stack_offset(sizeof(jbyte))));
 89   }
 90 }
 91 
 92 void InterpreterRuntime::SignatureHandlerGenerator::pass_short() {
 93   const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
 94 
 95   Register reg = next_gpr();
 96   if (reg != noreg) {
 97     __ ldr(reg, src);
 98   } else {
 99     __ ldrh(r0, src);
100     __ strh(r0, Address(to(), next_stack_offset(sizeof(jshort))));
101   }
102 }
103 
104 void InterpreterRuntime::SignatureHandlerGenerator::pass_int() {
105   const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
106 
107   Register reg = next_gpr();
108   if (reg != noreg) {
109     __ ldr(reg, src);
110   } else {
111     __ ldrw(r0, src);
112     __ strw(r0, Address(to(), next_stack_offset(sizeof(jint))));
113   }
114 }
115 
116 void InterpreterRuntime::SignatureHandlerGenerator::pass_long() {
117   const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
118 
119   Register reg = next_gpr();
120   if (reg != noreg) {
121     __ ldr(reg, src);
122   } else {
123     __ ldr(r0, src);
124     __ str(r0, Address(to(), next_stack_offset(sizeof(jlong))));
125   }
126 }
127 
128 void InterpreterRuntime::SignatureHandlerGenerator::pass_float() {
129   const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
130 
131   FloatRegister reg = next_fpr();
132   if (reg != fnoreg) {
133     __ ldrs(reg, src);
134   } else {
135     __ ldrw(r0, src);
136     __ strw(r0, Address(to(), next_stack_offset(sizeof(jfloat))));
137   }
138 }
139 
140 void InterpreterRuntime::SignatureHandlerGenerator::pass_double() {
141   const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
142 
143   FloatRegister reg = next_fpr();
144   if (reg != fnoreg) {
145     __ ldrd(reg, src);
146   } else {
147     __ ldr(r0, src);
148     __ str(r0, Address(to(), next_stack_offset(sizeof(jdouble))));
149   }
150 }
151 
152 void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
153   Register reg = next_gpr();
154   if (reg == c_rarg1) {
155     assert(offset() == 0, "argument register 1 can only be (non-null) receiver");
156     __ add(c_rarg1, from(), Interpreter::local_offset_in_bytes(offset()));
157   } else if (reg != noreg) {
158     __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
159     __ mov(reg, 0);
160     __ ldr(temp(), r0);
161     Label L;
162     __ cbz(temp(), L);
163     __ mov(reg, r0);
164     __ bind(L);
165   } else {
166     __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
167     __ ldr(temp(), r0);
168     Label L;
169     __ cbnz(temp(), L);
170     __ mov(r0, zr);
171     __ bind(L);
172     static_assert(sizeof(jobject) == wordSize, "");
173     __ str(r0, Address(to(), next_stack_offset(sizeof(jobject))));
174   }
175 }
176 
177 void InterpreterRuntime::SignatureHandlerGenerator::pass_valuetype() {
178    pass_object();
179 }
180 
181 void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
182   // generate code to handle arguments
183   iterate(fingerprint);
184 
185   // return result handler
186   __ lea(r0, ExternalAddress(Interpreter::result_handler(method()->result_type())));
187   __ ret(lr);
188 
189   __ flush();
190 }
191 
192 
193 // Implementation of SignatureHandlerLibrary
194 
195 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
196 
197 
198 class SlowSignatureHandler
199   : public NativeSignatureIterator {
200  private:
201   address   _from;
202   char*     _to;
203   intptr_t* _int_args;
204   intptr_t* _fp_args;
205   intptr_t* _fp_identifiers;
206   unsigned int _num_reg_int_args;
207   unsigned int _num_reg_fp_args;
208 
209   intptr_t* single_slot_addr() {
210     intptr_t* from_addr = (intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
211     _from -= Interpreter::stackElementSize;
212     return from_addr;
213   }
214 
215   intptr_t* double_slot_addr() {
216     intptr_t* from_addr = (intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
217     _from -= 2*Interpreter::stackElementSize;
218     return from_addr;
219   }
220 
221   int pass_gpr(intptr_t value) {
222     if (_num_reg_int_args < Argument::n_int_register_parameters_c-1) {
223       *_int_args++ = value;
224       return _num_reg_int_args++;
225     }
226     return -1;
227   }
228 
229   int pass_fpr(intptr_t value) {
230     if (_num_reg_fp_args < Argument::n_float_register_parameters_c) {
231       *_fp_args++ = value;
232       return _num_reg_fp_args++;
233     }
234     return -1;
235   }
236 
237   template<typename T>
238   void pass_stack(T value) {
239     MACOS_ONLY(_to = align_up(_to, sizeof(value)));
240     *(T *)_to = value;
241     _to += NOT_MACOS(wordSize) MACOS_ONLY(sizeof(value));
242   }
243 
244   virtual void pass_byte() {
245     jbyte value = *(jbyte*)single_slot_addr();
246     if (pass_gpr(value) < 0) {
247       pass_stack<>(value);
248     }
249   }
250 
251   virtual void pass_short() {
252     jshort value = *(jshort*)single_slot_addr();
253     if (pass_gpr(value) < 0) {
254       pass_stack<>(value);
255     }
256   }
257 
258   virtual void pass_int() {
259     jint value = *(jint*)single_slot_addr();
260     if (pass_gpr(value) < 0) {
261       pass_stack<>(value);
262     }
263   }
264 
265   virtual void pass_valuetype() {
266     // values are handled with oops, like objects
267     pass_object();
268   }
269 
270   virtual void pass_long() {
271     intptr_t value = *double_slot_addr();
272     if (pass_gpr(value) < 0) {
273       pass_stack<>(value);
274     }
275   }
276 
277   virtual void pass_object() {
278     intptr_t* addr = single_slot_addr();
279     intptr_t value = *addr == 0 ? NULL : (intptr_t)addr;
280     if (pass_gpr(value) < 0) {
281       pass_stack<>(value);
282     }
283   }
284 
285   virtual void pass_float() {
286     jint value = *(jint*)single_slot_addr();
287     if (pass_fpr(value) < 0) {
288       pass_stack<>(value);
289     }
290   }
291 
292   virtual void pass_double() {
293     intptr_t value = *double_slot_addr();
294     int arg = pass_fpr(value);
295     if (0 <= arg) {
296       *_fp_identifiers |= (1ull << arg); // mark as double
297     } else {
298       pass_stack<>(value);
299     }
300   }
301 
302  public:
303   SlowSignatureHandler(const methodHandle& method, address from, intptr_t* to)
304     : NativeSignatureIterator(method)
305   {
306     _from = from;
307     _to   = (char *)to;
308 
309     _int_args = to - (method->is_static() ? 16 : 17);
310     _fp_args =  to - 8;
311     _fp_identifiers = to - 9;
312     *(int*) _fp_identifiers = 0;
313     _num_reg_int_args = (method->is_static() ? 1 : 0);
314     _num_reg_fp_args = 0;
315   }
316 
317 };
318 
319 
320 JRT_ENTRY(address,
321           InterpreterRuntime::slow_signature_handler(JavaThread* current,
322                                                      Method* method,
323                                                      intptr_t* from,
324                                                      intptr_t* to))
325   methodHandle m(current, (Method*)method);
326   assert(m->is_native(), "sanity check");
327 
328   // handle arguments
329   SlowSignatureHandler ssh(m, (address)from, to);
330   ssh.iterate((uint64_t)CONST64(-1));
331 
332   // return result handler
333   return Interpreter::result_handler(m->result_type());
334 JRT_END