1 /*
  2  * Copyright (c) 1998, 2021, 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 "oops/method.hpp"
 31 #include "oops/oop.inline.hpp"
 32 #include "runtime/handles.inline.hpp"
 33 #include "runtime/icache.hpp"
 34 #include "runtime/interfaceSupport.inline.hpp"
 35 #include "runtime/signature.hpp"
 36 
 37 
 38 #define __ _masm->
 39 
 40 
 41 // Implementation of SignatureHandlerGenerator
 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 void InterpreterRuntime::SignatureHandlerGenerator::pass_int() {
 58   move(offset(), jni_offset() + 1);
 59 }
 60 
 61 void InterpreterRuntime::SignatureHandlerGenerator::pass_float() {
 62   move(offset(), jni_offset() + 1);
 63 }
 64 
 65 void InterpreterRuntime::SignatureHandlerGenerator::pass_long() {
 66    move(offset(), jni_offset() + 2);
 67    move(offset() + 1, jni_offset() + 1);
 68 }
 69 
 70 void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
 71   box (offset(), jni_offset() + 1);
 72 }
 73 
 74 void InterpreterRuntime::SignatureHandlerGenerator::move(int from_offset, int to_offset) {
 75   __ movl(temp(), Address(from(), Interpreter::local_offset_in_bytes(from_offset)));
 76   __ movl(Address(to(), to_offset * wordSize), temp());
 77 }
 78 
 79 
 80 void InterpreterRuntime::SignatureHandlerGenerator::box(int from_offset, int to_offset) {
 81   __ lea(temp(), Address(from(), Interpreter::local_offset_in_bytes(from_offset)));
 82   __ cmpptr(Address(from(), Interpreter::local_offset_in_bytes(from_offset)), (int32_t)NULL_WORD); // do not use temp() to avoid AGI
 83   Label L;
 84   __ jcc(Assembler::notZero, L);
 85   __ movptr(temp(), NULL_WORD);
 86   __ bind(L);
 87   __ movptr(Address(to(), to_offset * wordSize), temp());
 88 }
 89 
 90 
 91 void InterpreterRuntime::SignatureHandlerGenerator::generate( uint64_t fingerprint) {
 92   // generate code to handle arguments
 93   iterate(fingerprint);
 94   // return result handler
 95   __ lea(rax,
 96          ExternalAddress((address)Interpreter::result_handler(method()->result_type())));
 97   // return
 98   __ ret(0);
 99   __ flush();
100 }
101 
102 
103 Register InterpreterRuntime::SignatureHandlerGenerator::from()       { return rdi; }
104 Register InterpreterRuntime::SignatureHandlerGenerator::to()         { return rsp; }
105 Register InterpreterRuntime::SignatureHandlerGenerator::temp()       { return rcx; }
106 
107 
108 // Implementation of SignatureHandlerLibrary
109 
110 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
111 
112 class SlowSignatureHandler: public NativeSignatureIterator {
113  private:
114   address   _from;
115   intptr_t* _to;
116 
117   virtual void pass_int() {
118     *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
119     _from -= Interpreter::stackElementSize;
120   }
121 
122   virtual void pass_float() {
123     *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
124     _from -= Interpreter::stackElementSize;
125   }
126 
127   virtual void pass_long() {
128     _to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
129     _to[1] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
130     _to += 2;
131     _from -= 2*Interpreter::stackElementSize;
132   }
133 
134   virtual void pass_object() {
135     // pass address of from
136     intptr_t from_addr = (intptr_t)(_from + Interpreter::local_offset_in_bytes(0));
137     *_to++ = (*(intptr_t*)from_addr == 0) ? NULL_WORD : from_addr;
138     _from -= Interpreter::stackElementSize;
139    }
140 
141  public:
142   SlowSignatureHandler(const methodHandle& method, address from, intptr_t* to) :
143     NativeSignatureIterator(method) {
144     _from = from;
145     _to   = to + (is_static() ? 2 : 1);
146   }
147 };
148 
149 JRT_ENTRY(address, InterpreterRuntime::slow_signature_handler(JavaThread* current, Method* method, intptr_t* from, intptr_t* to))
150   methodHandle m(current, (Method*)method);
151   assert(m->is_native(), "sanity check");
152   // handle arguments
153   SlowSignatureHandler(m, (address)from, to + 1).iterate((uint64_t)CONST64(-1));
154   // return result handler
155   return Interpreter::result_handler(m->result_type());
156 JRT_END