1 /* 2 * Copyright (c) 2003, 2018, 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.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.inline.hpp" 36 #include "runtime/signature.hpp" 37 38 #define __ _masm-> 39 40 // Implementation of SignatureHandlerGenerator 41 Register InterpreterRuntime::SignatureHandlerGenerator::from() { return rlocals; } 42 Register InterpreterRuntime::SignatureHandlerGenerator::to() { return sp; } 43 Register InterpreterRuntime::SignatureHandlerGenerator::temp() { return rscratch1; } 44 45 void 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 86 void 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 127 void 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 140 void 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 153 void 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 249 void 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 286 void SignatureHandlerLibrary::pd_set_handler(address handler) {} 287 288 289 class 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 411 IRT_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()); 428 IRT_END