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 "code/codeCacheExtensions.hpp"
27 #include "interpreter/interpreter.hpp"
28 #include "interpreter/interpreterRuntime.hpp"
29 #include "interpreter/interp_masm.hpp"
30 #include "interpreter/templateInterpreter.hpp"
31 #include "interpreter/templateInterpreterGenerator.hpp"
32 #include "interpreter/templateTable.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "runtime/logTimer.hpp"
35
36 #ifndef CC_INTERP
37
38 # define __ _masm->
39
40 void TemplateInterpreter::initialize() {
41 if (_code != NULL) return;
42 // assertions
43 assert((int)Bytecodes::number_of_codes <= (int)DispatchTable::length,
44 "dispatch table too small");
45
46 AbstractInterpreter::initialize();
47
48 TemplateTable::initialize();
49
50 // generate interpreter
51 { ResourceMark rm;
52 TraceStartupTime timer("Interpreter generation");
53 int code_size = InterpreterCodeSize;
54 NOT_PRODUCT(code_size *= 4;) // debug uses extra interpreter code space
55 #if INCLUDE_JVMTI
56 if (CodeCacheExtensions::saving_generated_interpreter()) {
57 // May requires several versions of the codelets.
58 // Final size will automatically be optimized.
59 code_size *= 2;
60 }
61 #endif
62 _code = new StubQueue(new InterpreterCodeletInterface, code_size, NULL,
63 "Interpreter");
64 TemplateInterpreterGenerator g(_code);
65 }
66 if (PrintInterpreter) {
67 if (CodeCacheExtensions::saving_generated_interpreter() &&
68 CodeCacheExtensions::use_pregenerated_interpreter()) {
69 ResourceMark rm;
70 tty->print("Printing the newly generated interpreter first");
71 print();
72 tty->print("Printing the pregenerated interpreter next");
73 }
74 }
75
76 // Install the pregenerated interpreter code before printing it
77 CodeCacheExtensions::complete_step(CodeCacheExtensionsSteps::TemplateInterpreter);
78
79 if (PrintInterpreter) {
80 ResourceMark rm;
81 print();
82 }
83
84 // initialize dispatch table
85 _active_table = _normal_table;
86 }
87
88 //------------------------------------------------------------------------------------------------------------------------
89 // Implementation of EntryPoint
90
91 EntryPoint::EntryPoint() {
92 assert(number_of_states == 10, "check the code below");
93 _entry[btos] = NULL;
94 _entry[ctos] = NULL;
95 _entry[stos] = NULL;
96 _entry[atos] = NULL;
97 _entry[itos] = NULL;
98 _entry[ltos] = NULL;
99 _entry[ftos] = NULL;
100 _entry[dtos] = NULL;
101 _entry[qtos] = NULL;
102 _entry[vtos] = NULL;
103 }
207 address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
208 address TemplateInterpreter::_throw_exception_entry = NULL;
209
210 #ifndef PRODUCT
211 EntryPoint TemplateInterpreter::_trace_code;
212 #endif // !PRODUCT
213 EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
214 EntryPoint TemplateInterpreter::_earlyret_entry;
215 EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
216 EntryPoint TemplateInterpreter::_continuation_entry;
217 EntryPoint TemplateInterpreter::_safept_entry;
218
219 address TemplateInterpreter::_invoke_return_entry[TemplateInterpreter::number_of_return_addrs];
220 address TemplateInterpreter::_invokeinterface_return_entry[TemplateInterpreter::number_of_return_addrs];
221 address TemplateInterpreter::_invokedynamic_return_entry[TemplateInterpreter::number_of_return_addrs];
222
223 DispatchTable TemplateInterpreter::_active_table;
224 DispatchTable TemplateInterpreter::_normal_table;
225 DispatchTable TemplateInterpreter::_safept_table;
226 address TemplateInterpreter::_wentry_point[DispatchTable::length];
227
228
229 //------------------------------------------------------------------------------------------------------------------------
230 // Entry points
231
232 /**
233 * Returns the return entry table for the given invoke bytecode.
234 */
235 address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) {
236 switch (code) {
237 case Bytecodes::_invokestatic:
238 case Bytecodes::_invokespecial:
239 case Bytecodes::_invokevirtual:
240 case Bytecodes::_invokedirect:
241 case Bytecodes::_invokehandle:
242 return Interpreter::invoke_return_entry_table();
243 case Bytecodes::_invokeinterface:
244 return Interpreter::invokeinterface_return_entry_table();
245 case Bytecodes::_invokedynamic:
246 return Interpreter::invokedynamic_return_entry_table();
|
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 "code/codeCacheExtensions.hpp"
27 #include "interpreter/interpreter.hpp"
28 #include "interpreter/interpreterRuntime.hpp"
29 #include "interpreter/interp_masm.hpp"
30 #include "interpreter/templateInterpreter.hpp"
31 #include "interpreter/templateInterpreterGenerator.hpp"
32 #include "interpreter/templateTable.hpp"
33 #include "interpreter/extendedBytecodes.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "runtime/logTimer.hpp"
36
37 #ifndef CC_INTERP
38
39 # define __ _masm->
40
41 void TemplateInterpreter::initialize() {
42 if (_code != NULL) return;
43 // assertions
44 assert((int)Bytecodes::number_of_codes <= (int)DispatchTable::length,
45 "dispatch table too small");
46
47 AbstractInterpreter::initialize();
48
49 TemplateTable::initialize();
50
51 BCSetTemplate::initialize();
52
53 // generate interpreter
54 { ResourceMark rm;
55 TraceStartupTime timer("Interpreter generation");
56 int code_size = InterpreterCodeSize;
57 NOT_PRODUCT(code_size *= 4;) // debug uses extra interpreter code space
58 #if INCLUDE_JVMTI
59 if (CodeCacheExtensions::saving_generated_interpreter()) {
60 // May requires several versions of the codelets.
61 // Final size will automatically be optimized.
62 code_size *= 2;
63 }
64 #endif
65 _code = new StubQueue(new InterpreterCodeletInterface, code_size, NULL,
66 "Interpreter");
67 TemplateInterpreterGenerator g(_code);
68 }
69 if (PrintInterpreter) {
70 if (CodeCacheExtensions::saving_generated_interpreter() &&
71 CodeCacheExtensions::use_pregenerated_interpreter()) {
72 ResourceMark rm;
73 tty->print("Printing the newly generated interpreter first");
74 print();
75 tty->print("Printing the pregenerated interpreter next");
76 }
77 }
78
79 // Install the pregenerated interpreter code before printing it
80 CodeCacheExtensions::complete_step(CodeCacheExtensionsSteps::TemplateInterpreter);
81
82 if (PrintInterpreter) {
83 ResourceMark rm;
84 print();
85 }
86
87 TemplateTable::cleanup();
88
89 // initialize dispatch table
90 _active_table = _normal_table;
91 }
92
93 //------------------------------------------------------------------------------------------------------------------------
94 // Implementation of EntryPoint
95
96 EntryPoint::EntryPoint() {
97 assert(number_of_states == 10, "check the code below");
98 _entry[btos] = NULL;
99 _entry[ctos] = NULL;
100 _entry[stos] = NULL;
101 _entry[atos] = NULL;
102 _entry[itos] = NULL;
103 _entry[ltos] = NULL;
104 _entry[ftos] = NULL;
105 _entry[dtos] = NULL;
106 _entry[qtos] = NULL;
107 _entry[vtos] = NULL;
108 }
212 address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
213 address TemplateInterpreter::_throw_exception_entry = NULL;
214
215 #ifndef PRODUCT
216 EntryPoint TemplateInterpreter::_trace_code;
217 #endif // !PRODUCT
218 EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
219 EntryPoint TemplateInterpreter::_earlyret_entry;
220 EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
221 EntryPoint TemplateInterpreter::_continuation_entry;
222 EntryPoint TemplateInterpreter::_safept_entry;
223
224 address TemplateInterpreter::_invoke_return_entry[TemplateInterpreter::number_of_return_addrs];
225 address TemplateInterpreter::_invokeinterface_return_entry[TemplateInterpreter::number_of_return_addrs];
226 address TemplateInterpreter::_invokedynamic_return_entry[TemplateInterpreter::number_of_return_addrs];
227
228 DispatchTable TemplateInterpreter::_active_table;
229 DispatchTable TemplateInterpreter::_normal_table;
230 DispatchTable TemplateInterpreter::_safept_table;
231 address TemplateInterpreter::_wentry_point[DispatchTable::length];
232 address TemplateInterpreter::_typed_entry_point[Bytecodes::number_of_bcset][DispatchTable::length];
233 address TemplateInterpreter::_typed_wentry_point[Bytecodes::number_of_bcset][DispatchTable::length];
234
235
236 //------------------------------------------------------------------------------------------------------------------------
237 // Entry points
238
239 /**
240 * Returns the return entry table for the given invoke bytecode.
241 */
242 address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) {
243 switch (code) {
244 case Bytecodes::_invokestatic:
245 case Bytecodes::_invokespecial:
246 case Bytecodes::_invokevirtual:
247 case Bytecodes::_invokedirect:
248 case Bytecodes::_invokehandle:
249 return Interpreter::invoke_return_entry_table();
250 case Bytecodes::_invokeinterface:
251 return Interpreter::invokeinterface_return_entry_table();
252 case Bytecodes::_invokedynamic:
253 return Interpreter::invokedynamic_return_entry_table();
|