1 /*
2  * Copyright (c) 2003, 2020, Oracle and/or its affiliates. All rights reserved.
3  * Copyright 2007, 2008, 2009, 2010, 2011 Red Hat, Inc.
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 "asm/assembler.hpp"
28 #include "interpreter/bytecodeHistogram.hpp"
29 #include "interpreter/interpreter.hpp"
30 #include "interpreter/interpreterRuntime.hpp"
31 #include "interpreter/zero/bytecodeInterpreter.hpp"
32 #include "interpreter/zero/zeroInterpreter.hpp"
33 #include "oops/method.hpp"
34 #include "runtime/arguments.hpp"
35 #include "zeroInterpreterGenerator.hpp"
36 
ZeroInterpreterGenerator(StubQueue * _code)37 ZeroInterpreterGenerator::ZeroInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
38   generate_all();
39 }
40 
generate_all()41 void ZeroInterpreterGenerator::generate_all() {
42   { CodeletMark cm(_masm, "slow signature handler");
43     AbstractInterpreter::_slow_signature_handler = generate_slow_signature_handler();
44   }
45 
46 #define method_entry(kind) Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind)
47 
48   { CodeletMark cm(_masm, "(kind = frame_manager)");
49     // all non-native method kinds
50     method_entry(zerolocals);
51     method_entry(zerolocals_synchronized);
52     method_entry(empty);
53     method_entry(getter);
54     method_entry(setter);
55     method_entry(abstract);
56     method_entry(java_lang_math_sin   );
57     method_entry(java_lang_math_cos   );
58     method_entry(java_lang_math_tan   );
59     method_entry(java_lang_math_abs   );
60     method_entry(java_lang_math_sqrt  );
61     method_entry(java_lang_math_log   );
62     method_entry(java_lang_math_log10 );
63     method_entry(java_lang_math_pow );
64     method_entry(java_lang_math_exp );
65     method_entry(java_lang_math_fmaD );
66     method_entry(java_lang_math_fmaF );
67     method_entry(java_lang_ref_reference_get);
68 
69     AbstractInterpreter::initialize_method_handle_entries();
70 
71     Interpreter::_native_entry_begin = Interpreter::code()->code_end();
72     method_entry(native);
73     method_entry(native_synchronized);
74     Interpreter::_native_entry_end = Interpreter::code()->code_end();
75   }
76 
77 #undef method_entry
78 }
79 
80 // Generate method entries
generate_method_entry(AbstractInterpreter::MethodKind kind)81 address ZeroInterpreterGenerator::generate_method_entry(
82                                         AbstractInterpreter::MethodKind kind) {
83   // determine code generation flags
84   bool native = false;
85   bool synchronized = false;
86   address entry_point = NULL;
87 
88   switch (kind) {
89   case Interpreter::zerolocals             :                                          break;
90   case Interpreter::zerolocals_synchronized:                synchronized = true;      break;
91   case Interpreter::native                 : native = true;                           break;
92   case Interpreter::native_synchronized    : native = true; synchronized = true;      break;
93   case Interpreter::empty                  : entry_point = generate_empty_entry();    break;
94   case Interpreter::getter                 : entry_point = generate_getter_entry();   break;
95   case Interpreter::setter                 : entry_point = generate_setter_entry();   break;
96   case Interpreter::abstract               : entry_point = generate_abstract_entry(); break;
97 
98   case Interpreter::java_lang_math_sin     : // fall thru
99   case Interpreter::java_lang_math_cos     : // fall thru
100   case Interpreter::java_lang_math_tan     : // fall thru
101   case Interpreter::java_lang_math_abs     : // fall thru
102   case Interpreter::java_lang_math_log     : // fall thru
103   case Interpreter::java_lang_math_log10   : // fall thru
104   case Interpreter::java_lang_math_sqrt    : // fall thru
105   case Interpreter::java_lang_math_pow     : // fall thru
106   case Interpreter::java_lang_math_exp     : // fall thru
107   case Interpreter::java_lang_math_fmaD    : // fall thru
108   case Interpreter::java_lang_math_fmaF    : entry_point = generate_math_entry(kind);      break;
109   case Interpreter::java_lang_ref_reference_get
110                                            : entry_point = generate_Reference_get_entry(); break;
111   default:
112     fatal("unexpected method kind: %d", kind);
113     break;
114   }
115 
116   if (entry_point) {
117     return entry_point;
118   }
119 
120   // We expect the normal and native entry points to be generated first so we can reuse them.
121   if (native) {
122     entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
123     if (entry_point == NULL) {
124       entry_point = generate_native_entry(synchronized);
125     }
126   } else {
127     entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);
128     if (entry_point == NULL) {
129       entry_point = generate_normal_entry(synchronized);
130     }
131   }
132 
133   return entry_point;
134 }
135 
generate_slow_signature_handler()136 address ZeroInterpreterGenerator::generate_slow_signature_handler() {
137   _masm->advance(1);
138   return (address) InterpreterRuntime::slow_signature_handler;
139 }
140 
generate_math_entry(AbstractInterpreter::MethodKind kind)141 address ZeroInterpreterGenerator::generate_math_entry(
142     AbstractInterpreter::MethodKind kind) {
143   if (!InlineIntrinsics)
144     return NULL;
145 
146   Unimplemented();
147   return NULL;
148 }
149 
generate_abstract_entry()150 address ZeroInterpreterGenerator::generate_abstract_entry() {
151   return generate_entry((address) ShouldNotCallThisEntry());
152 }
153 
generate_empty_entry()154 address ZeroInterpreterGenerator::generate_empty_entry() {
155   if (!UseFastEmptyMethods)
156     return NULL;
157 
158   return generate_entry((address) ZeroInterpreter::empty_entry);
159 }
160 
generate_getter_entry()161 address ZeroInterpreterGenerator::generate_getter_entry() {
162   if (!UseFastAccessorMethods)
163     return NULL;
164 
165   return generate_entry((address) ZeroInterpreter::getter_entry);
166 }
167 
generate_setter_entry()168 address ZeroInterpreterGenerator::generate_setter_entry() {
169   if (!UseFastAccessorMethods)
170     return NULL;
171 
172   return generate_entry((address) ZeroInterpreter::setter_entry);
173 }
174 
generate_Reference_get_entry(void)175 address ZeroInterpreterGenerator::generate_Reference_get_entry(void) {
176   return generate_entry((address) ZeroInterpreter::Reference_get_entry);
177 }
178 
generate_native_entry(bool synchronized)179 address ZeroInterpreterGenerator::generate_native_entry(bool synchronized) {
180   return generate_entry((address) ZeroInterpreter::native_entry);
181 }
182 
generate_normal_entry(bool synchronized)183 address ZeroInterpreterGenerator::generate_normal_entry(bool synchronized) {
184   return generate_entry((address) ZeroInterpreter::normal_entry);
185 }
186