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::pass_valuetype() {
 75   box (offset(), jni_offset() + 1);
 76 }
 77 
 78 void InterpreterRuntime::SignatureHandlerGenerator::move(int from_offset, int to_offset) {
 79   __ movl(temp(), Address(from(), Interpreter::local_offset_in_bytes(from_offset)));
 80   __ movl(Address(to(), to_offset * wordSize), temp());
 81 }
 82 
 83 
 84 void InterpreterRuntime::SignatureHandlerGenerator::box(int from_offset, int to_offset) {
 85   __ lea(temp(), Address(from(), Interpreter::local_offset_in_bytes(from_offset)));
 86   __ cmpptr(Address(from(), Interpreter::local_offset_in_bytes(from_offset)), (int32_t)NULL_WORD); // do not use temp() to avoid AGI
 87   Label L;
 88   __ jcc(Assembler::notZero, L);
 89   __ movptr(temp(), NULL_WORD);
 90   __ bind(L);
 91   __ movptr(Address(to(), to_offset * wordSize), temp());
 92 }
 93 
 94 
 95 void InterpreterRuntime::SignatureHandlerGenerator::generate( uint64_t fingerprint) {
 96   // generate code to handle arguments
 97   iterate(fingerprint);
 98   // return result handler
 99   __ lea(rax,
100          ExternalAddress((address)Interpreter::result_handler(method()->result_type())));
101   // return
102   __ ret(0);
103   __ flush();
104 }
105 
106 
107 Register InterpreterRuntime::SignatureHandlerGenerator::from()       { return rdi; }
108 Register InterpreterRuntime::SignatureHandlerGenerator::to()         { return rsp; }
109 Register InterpreterRuntime::SignatureHandlerGenerator::temp()       { return rcx; }
110 
111 
112 // Implementation of SignatureHandlerLibrary
113 
114 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
115 
116 class SlowSignatureHandler: public NativeSignatureIterator {
117  private:
118   address   _from;
119   intptr_t* _to;
120 
121   virtual void pass_int() {
122     *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
123     _from -= Interpreter::stackElementSize;
124   }
125 
126   virtual void pass_float() {
127     *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
128     _from -= Interpreter::stackElementSize;
129   }
130 
131   virtual void pass_long() {
132     _to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
133     _to[1] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
134     _to += 2;
135     _from -= 2*Interpreter::stackElementSize;
136   }
137 
138   virtual void pass_object() {
139     // pass address of from
140     intptr_t from_addr = (intptr_t)(_from + Interpreter::local_offset_in_bytes(0));
141     *_to++ = (*(intptr_t*)from_addr == 0) ? NULL_WORD : from_addr;
142     _from -= Interpreter::stackElementSize;
143    }
144 
145   virtual void pass_valuetype() {
146     // pass address of from
147     intptr_t from_addr = (intptr_t)(_from + Interpreter::local_offset_in_bytes(0));
148     *_to++ = (*(intptr_t*)from_addr == 0) ? NULL_WORD : from_addr;
149     _from -= Interpreter::stackElementSize;
150    }
151 
152  public:
153   SlowSignatureHandler(const methodHandle& method, address from, intptr_t* to) :
154     NativeSignatureIterator(method) {
155     _from = from;
156     _to   = to + (is_static() ? 2 : 1);
157   }
158 };
159 
160 JRT_ENTRY(address, InterpreterRuntime::slow_signature_handler(JavaThread* current, Method* method, intptr_t* from, intptr_t* to))
161   methodHandle m(current, (Method*)method);
162   assert(m->is_native(), "sanity check");
163   // handle arguments
164   SlowSignatureHandler(m, (address)from, to + 1).iterate((uint64_t)CONST64(-1));
165   // return result handler
166   return Interpreter::result_handler(m->result_type());
167 JRT_END