1 /*
   2  * Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "interpreter/interp_masm.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 
  42 InterpreterRuntime::SignatureHandlerGenerator::SignatureHandlerGenerator(const methodHandle& method, CodeBuffer* buffer) :
  43     NativeSignatureIterator(method) {
  44   _masm = new MacroAssembler(buffer);
  45 #ifdef AMD64
  46 #ifdef _WIN64
  47   _num_args = (method->is_static() ? 1 : 0);
  48   _stack_offset = (Argument::n_int_register_parameters_c+1)* wordSize; // don't overwrite return address
  49 #else
  50   _num_int_args = (method->is_static() ? 1 : 0);
  51   _num_fp_args = 0;
  52   _stack_offset = wordSize; // don't overwrite return address
  53 #endif // _WIN64
  54 #endif // AMD64
  55 }
  56 
  57 Register InterpreterRuntime::SignatureHandlerGenerator::from() { return r14; }
  58 Register InterpreterRuntime::SignatureHandlerGenerator::to()   { return rsp; }
  59 Register InterpreterRuntime::SignatureHandlerGenerator::temp() { return rscratch1; }
  60 
  61 void InterpreterRuntime::SignatureHandlerGenerator::pass_int() {
  62   const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
  63 
  64 #ifdef _WIN64
  65   switch (_num_args) {
  66   case 0:
  67     __ movl(c_rarg1, src);
  68     _num_args++;
  69     break;
  70   case 1:
  71     __ movl(c_rarg2, src);
  72     _num_args++;
  73     break;
  74   case 2:
  75     __ movl(c_rarg3, src);
  76     _num_args++;
  77     break;
  78   default:
  79     __ movl(rax, src);
  80     __ movl(Address(to(), _stack_offset), rax);
  81     _stack_offset += wordSize;
  82     break;
  83   }
  84 #else
  85   switch (_num_int_args) {
  86   case 0:
  87     __ movl(c_rarg1, src);
  88     _num_int_args++;
  89     break;
  90   case 1:
  91     __ movl(c_rarg2, src);
  92     _num_int_args++;
  93     break;
  94   case 2:
  95     __ movl(c_rarg3, src);
  96     _num_int_args++;
  97     break;
  98   case 3:
  99     __ movl(c_rarg4, src);
 100     _num_int_args++;
 101     break;
 102   case 4:
 103     __ movl(c_rarg5, src);
 104     _num_int_args++;
 105     break;
 106   default:
 107     __ movl(rax, src);
 108     __ movl(Address(to(), _stack_offset), rax);
 109     _stack_offset += wordSize;
 110     break;
 111   }
 112 #endif
 113 }
 114 
 115 void InterpreterRuntime::SignatureHandlerGenerator::pass_long() {
 116   const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
 117 
 118 #ifdef _WIN64
 119   switch (_num_args) {
 120   case 0:
 121     __ movptr(c_rarg1, src);
 122     _num_args++;
 123     break;
 124   case 1:
 125     __ movptr(c_rarg2, src);
 126     _num_args++;
 127     break;
 128   case 2:
 129     __ movptr(c_rarg3, src);
 130     _num_args++;
 131     break;
 132   case 3:
 133   default:
 134     __ movptr(rax, src);
 135     __ movptr(Address(to(), _stack_offset), rax);
 136     _stack_offset += wordSize;
 137     break;
 138   }
 139 #else
 140   switch (_num_int_args) {
 141   case 0:
 142     __ movptr(c_rarg1, src);
 143     _num_int_args++;
 144     break;
 145   case 1:
 146     __ movptr(c_rarg2, src);
 147     _num_int_args++;
 148     break;
 149   case 2:
 150     __ movptr(c_rarg3, src);
 151     _num_int_args++;
 152     break;
 153   case 3:
 154     __ movptr(c_rarg4, src);
 155     _num_int_args++;
 156     break;
 157   case 4:
 158     __ movptr(c_rarg5, src);
 159     _num_int_args++;
 160     break;
 161   default:
 162     __ movptr(rax, src);
 163     __ movptr(Address(to(), _stack_offset), rax);
 164     _stack_offset += wordSize;
 165     break;
 166   }
 167 #endif
 168 }
 169 
 170 void InterpreterRuntime::SignatureHandlerGenerator::pass_float() {
 171   const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
 172 
 173 #ifdef _WIN64
 174   if (_num_args < Argument::n_float_register_parameters_c-1) {
 175     __ movflt(as_XMMRegister(++_num_args), src);
 176   } else {
 177     __ movl(rax, src);
 178     __ movl(Address(to(), _stack_offset), rax);
 179     _stack_offset += wordSize;
 180   }
 181 #else
 182   if (_num_fp_args < Argument::n_float_register_parameters_c) {
 183     __ movflt(as_XMMRegister(_num_fp_args++), src);
 184   } else {
 185     __ movl(rax, src);
 186     __ movl(Address(to(), _stack_offset), rax);
 187     _stack_offset += wordSize;
 188   }
 189 #endif
 190 }
 191 
 192 void InterpreterRuntime::SignatureHandlerGenerator::pass_double() {
 193   const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
 194 
 195 #ifdef _WIN64
 196   if (_num_args < Argument::n_float_register_parameters_c-1) {
 197     __ movdbl(as_XMMRegister(++_num_args), src);
 198   } else {
 199     __ movptr(rax, src);
 200     __ movptr(Address(to(), _stack_offset), rax);
 201     _stack_offset += wordSize;
 202   }
 203 #else
 204   if (_num_fp_args < Argument::n_float_register_parameters_c) {
 205     __ movdbl(as_XMMRegister(_num_fp_args++), src);
 206   } else {
 207     __ movptr(rax, src);
 208     __ movptr(Address(to(), _stack_offset), rax);
 209     _stack_offset += wordSize;
 210   }
 211 #endif
 212 }
 213 
 214 void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
 215   const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
 216 
 217 #ifdef _WIN64
 218   switch (_num_args) {
 219   case 0:
 220     assert(offset() == 0, "argument register 1 can only be (non-null) receiver");
 221     __ lea(c_rarg1, src);
 222     _num_args++;
 223     break;
 224   case 1:
 225     __ lea(rax, src);
 226     __ xorl(c_rarg2, c_rarg2);
 227     __ cmpptr(src, 0);
 228     __ cmov(Assembler::notEqual, c_rarg2, rax);
 229     _num_args++;
 230     break;
 231   case 2:
 232     __ lea(rax, src);
 233     __ xorl(c_rarg3, c_rarg3);
 234     __ cmpptr(src, 0);
 235     __ cmov(Assembler::notEqual, c_rarg3, rax);
 236     _num_args++;
 237     break;
 238   default:
 239     __ lea(rax, src);
 240     __ xorl(temp(), temp());
 241     __ cmpptr(src, 0);
 242     __ cmov(Assembler::notEqual, temp(), rax);
 243     __ movptr(Address(to(), _stack_offset), temp());
 244     _stack_offset += wordSize;
 245     break;
 246   }
 247 #else
 248   switch (_num_int_args) {
 249   case 0:
 250     assert(offset() == 0, "argument register 1 can only be (non-null) receiver");
 251     __ lea(c_rarg1, src);
 252     _num_int_args++;
 253     break;
 254   case 1:
 255     __ lea(rax, src);
 256     __ xorl(c_rarg2, c_rarg2);
 257     __ cmpptr(src, 0);
 258     __ cmov(Assembler::notEqual, c_rarg2, rax);
 259     _num_int_args++;
 260     break;
 261   case 2:
 262     __ lea(rax, src);
 263     __ xorl(c_rarg3, c_rarg3);
 264     __ cmpptr(src, 0);
 265     __ cmov(Assembler::notEqual, c_rarg3, rax);
 266     _num_int_args++;
 267     break;
 268   case 3:
 269     __ lea(rax, src);
 270     __ xorl(c_rarg4, c_rarg4);
 271     __ cmpptr(src, 0);
 272     __ cmov(Assembler::notEqual, c_rarg4, rax);
 273     _num_int_args++;
 274     break;
 275   case 4:
 276     __ lea(rax, src);
 277     __ xorl(c_rarg5, c_rarg5);
 278     __ cmpptr(src, 0);
 279     __ cmov(Assembler::notEqual, c_rarg5, rax);
 280     _num_int_args++;
 281     break;
 282   default:
 283     __ lea(rax, src);
 284     __ xorl(temp(), temp());
 285     __ cmpptr(src, 0);
 286     __ cmov(Assembler::notEqual, temp(), rax);
 287     __ movptr(Address(to(), _stack_offset), temp());
 288     _stack_offset += wordSize;
 289     break;
 290   }
 291 #endif
 292 }
 293 
 294 void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
 295   // generate code to handle arguments
 296   iterate(fingerprint);
 297 
 298   // return result handler
 299   __ lea(rax, ExternalAddress(Interpreter::result_handler(method()->result_type())));
 300   __ ret(0);
 301 
 302   __ flush();
 303 }
 304 
 305 
 306 // Implementation of SignatureHandlerLibrary
 307 
 308 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
 309 
 310 
 311 #ifdef _WIN64
 312 class SlowSignatureHandler
 313   : public NativeSignatureIterator {
 314  private:
 315   address   _from;
 316   intptr_t* _to;
 317   intptr_t* _reg_args;
 318   intptr_t* _fp_identifiers;
 319   unsigned int _num_args;
 320 
 321   virtual void pass_int()
 322   {
 323     jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
 324     _from -= Interpreter::stackElementSize;
 325 
 326     if (_num_args < Argument::n_int_register_parameters_c-1) {
 327       *_reg_args++ = from_obj;
 328       _num_args++;
 329     } else {
 330       *_to++ = from_obj;
 331     }
 332   }
 333 
 334   virtual void pass_long()
 335   {
 336     intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
 337     _from -= 2*Interpreter::stackElementSize;
 338 
 339     if (_num_args < Argument::n_int_register_parameters_c-1) {
 340       *_reg_args++ = from_obj;
 341       _num_args++;
 342     } else {
 343       *_to++ = from_obj;
 344     }
 345   }
 346 
 347   virtual void pass_object()
 348   {
 349     intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
 350     _from -= Interpreter::stackElementSize;
 351     if (_num_args < Argument::n_int_register_parameters_c-1) {
 352       *_reg_args++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
 353       _num_args++;
 354     } else {
 355       *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
 356     }
 357   }
 358 
 359   virtual void pass_float()
 360   {
 361     jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
 362     _from -= Interpreter::stackElementSize;
 363 
 364     if (_num_args < Argument::n_float_register_parameters_c-1) {
 365       assert((_num_args*2) < BitsPerWord, "_num_args*2 is out of range");
 366       *_reg_args++ = from_obj;
 367       *_fp_identifiers |= ((intptr_t)0x01 << (_num_args*2)); // mark as float
 368       _num_args++;
 369     } else {
 370       *_to++ = from_obj;
 371     }
 372   }
 373 
 374   virtual void pass_double()
 375   {
 376     intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
 377     _from -= 2*Interpreter::stackElementSize;
 378 
 379     if (_num_args < Argument::n_float_register_parameters_c-1) {
 380       assert((_num_args*2) < BitsPerWord, "_num_args*2 is out of range");
 381       *_reg_args++ = from_obj;
 382       *_fp_identifiers |= ((intptr_t)0x3 << (_num_args*2)); // mark as double
 383       _num_args++;
 384     } else {
 385       *_to++ = from_obj;
 386     }
 387   }
 388 
 389  public:
 390   SlowSignatureHandler(const methodHandle& method, address from, intptr_t* to)
 391     : NativeSignatureIterator(method)
 392   {
 393     _from = from;
 394     _to   = to;
 395 
 396     _reg_args = to - (method->is_static() ? 4 : 5);
 397     _fp_identifiers = to - 2;
 398     _to = _to + 4;  // Windows reserves stack space for register arguments
 399     *(int*) _fp_identifiers = 0;
 400     _num_args = (method->is_static() ? 1 : 0);
 401   }
 402 };
 403 #else
 404 class SlowSignatureHandler
 405   : public NativeSignatureIterator {
 406  private:
 407   address   _from;
 408   intptr_t* _to;
 409   intptr_t* _int_args;
 410   intptr_t* _fp_args;
 411   intptr_t* _fp_identifiers;
 412   unsigned int _num_int_args;
 413   unsigned int _num_fp_args;
 414 
 415   virtual void pass_int()
 416   {
 417     jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
 418     _from -= Interpreter::stackElementSize;
 419 
 420     if (_num_int_args < Argument::n_int_register_parameters_c-1) {
 421       *_int_args++ = from_obj;
 422       _num_int_args++;
 423     } else {
 424       *_to++ = from_obj;
 425     }
 426   }
 427 
 428   virtual void pass_long()
 429   {
 430     intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
 431     _from -= 2*Interpreter::stackElementSize;
 432 
 433     if (_num_int_args < Argument::n_int_register_parameters_c-1) {
 434       *_int_args++ = from_obj;
 435       _num_int_args++;
 436     } else {
 437       *_to++ = from_obj;
 438     }
 439   }
 440 
 441   virtual void pass_object()
 442   {
 443     intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
 444     _from -= Interpreter::stackElementSize;
 445 
 446     if (_num_int_args < Argument::n_int_register_parameters_c-1) {
 447       *_int_args++ = (*from_addr == 0) ? NULL : (intptr_t)from_addr;
 448       _num_int_args++;
 449     } else {
 450       *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
 451     }
 452   }
 453 
 454   virtual void pass_float()
 455   {
 456     jint from_obj = *(jint*)(_from+Interpreter::local_offset_in_bytes(0));
 457     _from -= Interpreter::stackElementSize;
 458 
 459     if (_num_fp_args < Argument::n_float_register_parameters_c) {
 460       *_fp_args++ = from_obj;
 461       _num_fp_args++;
 462     } else {
 463       *_to++ = from_obj;
 464     }
 465   }
 466 
 467   virtual void pass_double()
 468   {
 469     intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
 470     _from -= 2*Interpreter::stackElementSize;
 471 
 472     if (_num_fp_args < Argument::n_float_register_parameters_c) {
 473       *_fp_args++ = from_obj;
 474       *_fp_identifiers |= (1 << _num_fp_args); // mark as double
 475       _num_fp_args++;
 476     } else {
 477       *_to++ = from_obj;
 478     }
 479   }
 480 
 481  public:
 482   SlowSignatureHandler(const methodHandle& method, address from, intptr_t* to)
 483     : NativeSignatureIterator(method)
 484   {
 485     _from = from;
 486     _to   = to;
 487 
 488     _int_args = to - (method->is_static() ? 14 : 15);
 489     _fp_args =  to - 9;
 490     _fp_identifiers = to - 10;
 491     *(int*) _fp_identifiers = 0;
 492     _num_int_args = (method->is_static() ? 1 : 0);
 493     _num_fp_args = 0;
 494   }
 495 };
 496 #endif
 497 
 498 
 499 JRT_ENTRY(address,
 500           InterpreterRuntime::slow_signature_handler(JavaThread* thread,
 501                                                      Method* method,
 502                                                      intptr_t* from,
 503                                                      intptr_t* to))
 504   methodHandle m(thread, (Method*)method);
 505   assert(m->is_native(), "sanity check");
 506 
 507   // handle arguments
 508   SlowSignatureHandler(m, (address)from, to + 1).iterate((uint64_t)CONST64(-1));
 509 
 510   // return result handler
 511   return Interpreter::result_handler(m->result_type());
 512 JRT_END