1/*
2 * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2014, Red Hat Inc. 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 "interpreter/interpreter.hpp"
28#include "interpreter/interpreterRuntime.hpp"
29#include "memory/allocation.inline.hpp"
30#include "memory/universe.inline.hpp"
31#include "oops/method.hpp"
32#include "oops/oop.inline.hpp"
33#include "runtime/handles.inline.hpp"
34#include "runtime/icache.hpp"
35#include "runtime/interfaceSupport.hpp"
36#include "runtime/signature.hpp"
37
38#define __ _masm->
39
40// Implementation of SignatureHandlerGenerator
41Register InterpreterRuntime::SignatureHandlerGenerator::from() { return rlocals; }
42Register InterpreterRuntime::SignatureHandlerGenerator::to()   { return sp; }
43Register InterpreterRuntime::SignatureHandlerGenerator::temp() { return rscratch1; }
44
45void InterpreterRuntime::SignatureHandlerGenerator::pass_int() {
46  const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
47
48  switch (_num_int_args) {
49  case 0:
50    __ ldr(c_rarg1, src);
51    _num_int_args++;
52    break;
53  case 1:
54    __ ldr(c_rarg2, src);
55    _num_int_args++;
56    break;
57  case 2:
58    __ ldr(c_rarg3, src);
59    _num_int_args++;
60    break;
61  case 3:
62    __ ldr(c_rarg4, src);
63    _num_int_args++;
64    break;
65  case 4:
66    __ ldr(c_rarg5, src);
67    _num_int_args++;
68    break;
69  case 5:
70    __ ldr(c_rarg6, src);
71    _num_int_args++;
72    break;
73  case 6:
74    __ ldr(c_rarg7, src);
75    _num_int_args++;
76    break;
77  default:
78    __ ldr(r0, src);
79    __ str(r0, Address(to(), _stack_offset));
80    _stack_offset += wordSize;
81    _num_int_args++;
82    break;
83  }
84}
85
86void InterpreterRuntime::SignatureHandlerGenerator::pass_long() {
87  const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
88
89  switch (_num_int_args) {
90  case 0:
91    __ ldr(c_rarg1, src);
92    _num_int_args++;
93    break;
94  case 1:
95    __ ldr(c_rarg2, src);
96    _num_int_args++;
97    break;
98  case 2:
99    __ ldr(c_rarg3, src);
100    _num_int_args++;
101    break;
102  case 3:
103    __ ldr(c_rarg4, src);
104    _num_int_args++;
105    break;
106  case 4:
107    __ ldr(c_rarg5, src);
108    _num_int_args++;
109    break;
110  case 5:
111    __ ldr(c_rarg6, src);
112    _num_int_args++;
113    break;
114  case 6:
115    __ ldr(c_rarg7, src);
116    _num_int_args++;
117    break;
118  default:
119    __ ldr(r0, src);
120    __ str(r0, Address(to(), _stack_offset));
121    _stack_offset += wordSize;
122    _num_int_args++;
123    break;
124  }
125}
126
127void InterpreterRuntime::SignatureHandlerGenerator::pass_float() {
128  const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
129
130  if (_num_fp_args < Argument::n_float_register_parameters_c) {
131    __ ldrs(as_FloatRegister(_num_fp_args++), src);
132  } else {
133    __ ldrw(r0, src);
134    __ strw(r0, Address(to(), _stack_offset));
135    _stack_offset += wordSize;
136    _num_fp_args++;
137  }
138}
139
140void InterpreterRuntime::SignatureHandlerGenerator::pass_double() {
141  const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
142
143  if (_num_fp_args < Argument::n_float_register_parameters_c) {
144    __ ldrd(as_FloatRegister(_num_fp_args++), src);
145  } else {
146    __ ldr(r0, src);
147    __ str(r0, Address(to(), _stack_offset));
148    _stack_offset += wordSize;
149    _num_fp_args++;
150  }
151}
152
153void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
154
155  switch (_num_int_args) {
156  case 0:
157    assert(offset() == 0, "argument register 1 can only be (non-null) receiver");
158    __ add(c_rarg1, from(), Interpreter::local_offset_in_bytes(offset()));
159    _num_int_args++;
160    break;
161  case 1:
162    {
163      __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
164      __ mov(c_rarg2, 0);
165      __ ldr(temp(), r0);
166      Label L;
167      __ cbz(temp(), L);
168      __ mov(c_rarg2, r0);
169      __ bind(L);
170      _num_int_args++;
171      break;
172    }
173  case 2:
174    {
175      __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
176      __ mov(c_rarg3, 0);
177      __ ldr(temp(), r0);
178      Label L;
179      __ cbz(temp(), L);
180      __ mov(c_rarg3, r0);
181      __ bind(L);
182      _num_int_args++;
183      break;
184    }
185  case 3:
186    {
187      __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
188      __ mov(c_rarg4, 0);
189      __ ldr(temp(), r0);
190      Label L;
191      __ cbz(temp(), L);
192      __ mov(c_rarg4, r0);
193      __ bind(L);
194      _num_int_args++;
195      break;
196    }
197  case 4:
198    {
199      __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
200      __ mov(c_rarg5, 0);
201      __ ldr(temp(), r0);
202      Label L;
203      __ cbz(temp(), L);
204      __ mov(c_rarg5, r0);
205      __ bind(L);
206      _num_int_args++;
207      break;
208    }
209  case 5:
210    {
211      __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
212      __ mov(c_rarg6, 0);
213      __ ldr(temp(), r0);
214      Label L;
215      __ cbz(temp(), L);
216      __ mov(c_rarg6, r0);
217      __ bind(L);
218      _num_int_args++;
219      break;
220    }
221  case 6:
222    {
223      __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
224      __ mov(c_rarg7, 0);
225      __ ldr(temp(), r0);
226      Label L;
227      __ cbz(temp(), L);
228      __ mov(c_rarg7, r0);
229      __ bind(L);
230      _num_int_args++;
231      break;
232    }
233 default:
234   {
235      __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
236      __ ldr(temp(), r0);
237      Label L;
238      __ cbnz(temp(), L);
239      __ mov(r0, zr);
240      __ bind(L);
241      __ str(r0, Address(to(), _stack_offset));
242      _stack_offset += wordSize;
243      _num_int_args++;
244      break;
245   }
246  }
247}
248
249void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
250  // generate code to handle arguments
251  iterate(fingerprint);
252
253  // set the call format
254  // n.b. allow extra 1 for the JNI_Env in c_rarg0
255  unsigned int call_format = ((_num_int_args + 1) << 6) | (_num_fp_args << 2);
256
257  switch (method()->result_type()) {
258  case T_VOID:
259    call_format |= MacroAssembler::ret_type_void;
260    break;
261  case T_FLOAT:
262    call_format |= MacroAssembler::ret_type_float;
263    break;
264  case T_DOUBLE:
265    call_format |= MacroAssembler::ret_type_double;
266    break;
267  default:
268    call_format |= MacroAssembler::ret_type_integral;
269    break;
270  }
271
272  // // store the call format in the method
273  // __ movw(r0, call_format);
274  // __ str(r0, Address(rmethod, Method::call_format_offset()));
275
276  // return result handler
277  __ lea(r0, ExternalAddress(Interpreter::result_handler(method()->result_type())));
278  __ ret(lr);
279
280  __ flush();
281}
282
283
284// Implementation of SignatureHandlerLibrary
285
286void SignatureHandlerLibrary::pd_set_handler(address handler) {}
287
288
289class SlowSignatureHandler
290  : public NativeSignatureIterator {
291 private:
292  address   _from;
293  intptr_t* _to;
294  intptr_t* _int_args;
295  intptr_t* _fp_args;
296  intptr_t* _fp_identifiers;
297  unsigned int _num_int_args;
298  unsigned int _num_fp_args;
299
300  virtual void pass_int()
301  {
302    jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
303    _from -= Interpreter::stackElementSize;
304
305    if (_num_int_args < Argument::n_int_register_parameters_c-1) {
306      *_int_args++ = from_obj;
307      _num_int_args++;
308    } else {
309      *_to++ = from_obj;
310      _num_int_args++;
311    }
312  }
313
314  virtual void pass_long()
315  {
316    intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
317    _from -= 2*Interpreter::stackElementSize;
318
319    if (_num_int_args < Argument::n_int_register_parameters_c-1) {
320      *_int_args++ = from_obj;
321      _num_int_args++;
322    } else {
323      *_to++ = from_obj;
324      _num_int_args++;
325    }
326  }
327
328  virtual void pass_object()
329  {
330    intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
331    _from -= Interpreter::stackElementSize;
332
333    if (_num_int_args < Argument::n_int_register_parameters_c-1) {
334      *_int_args++ = (*from_addr == 0) ? NULL : (intptr_t)from_addr;
335      _num_int_args++;
336    } else {
337      *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
338      _num_int_args++;
339    }
340  }
341
342  virtual void pass_float()
343  {
344    jint from_obj = *(jint*)(_from+Interpreter::local_offset_in_bytes(0));
345    _from -= Interpreter::stackElementSize;
346
347    if (_num_fp_args < Argument::n_float_register_parameters_c) {
348      *_fp_args++ = from_obj;
349      _num_fp_args++;
350    } else {
351      *_to++ = from_obj;
352      _num_fp_args++;
353    }
354  }
355
356  virtual void pass_double()
357  {
358    intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
359    _from -= 2*Interpreter::stackElementSize;
360
361    if (_num_fp_args < Argument::n_float_register_parameters_c) {
362      *_fp_args++ = from_obj;
363      *_fp_identifiers |= (1 << _num_fp_args); // mark as double
364      _num_fp_args++;
365    } else {
366      *_to++ = from_obj;
367      _num_fp_args++;
368    }
369  }
370
371 public:
372  SlowSignatureHandler(const methodHandle& method, address from, intptr_t* to)
373    : NativeSignatureIterator(method)
374  {
375    _from = from;
376    _to   = to;
377
378    _int_args = to - (method->is_static() ? 16 : 17);
379    _fp_args =  to - 8;
380    _fp_identifiers = to - 9;
381    *(int*) _fp_identifiers = 0;
382    _num_int_args = (method->is_static() ? 1 : 0);
383    _num_fp_args = 0;
384  }
385
386  // n.b. allow extra 1 for the JNI_Env in c_rarg0
387  unsigned int get_call_format()
388  {
389    unsigned int call_format = ((_num_int_args + 1) << 6) | (_num_fp_args << 2);
390
391    switch (method()->result_type()) {
392    case T_VOID:
393      call_format |= MacroAssembler::ret_type_void;
394      break;
395    case T_FLOAT:
396      call_format |= MacroAssembler::ret_type_float;
397      break;
398    case T_DOUBLE:
399      call_format |= MacroAssembler::ret_type_double;
400      break;
401    default:
402      call_format |= MacroAssembler::ret_type_integral;
403      break;
404    }
405
406    return call_format;
407  }
408};
409
410
411IRT_ENTRY(address,
412          InterpreterRuntime::slow_signature_handler(JavaThread* thread,
413                                                     Method* method,
414                                                     intptr_t* from,
415                                                     intptr_t* to))
416  methodHandle m(thread, (Method*)method);
417  assert(m->is_native(), "sanity check");
418
419  // handle arguments
420  SlowSignatureHandler ssh(m, (address)from, to);
421  ssh.iterate(UCONST64(-1));
422
423  // // set the call format
424  // method->set_call_format(ssh.get_call_format());
425
426  // return result handler
427  return Interpreter::result_handler(m->result_type());
428IRT_END
429