72 if (TraceBytecodes) { |
72 if (TraceBytecodes) { |
73 CodeletMark cm(_masm, "bytecode tracing support"); |
73 CodeletMark cm(_masm, "bytecode tracing support"); |
74 Interpreter::_trace_code = |
74 Interpreter::_trace_code = |
75 EntryPoint( |
75 EntryPoint( |
76 generate_trace_code(btos), |
76 generate_trace_code(btos), |
|
77 generate_trace_code(ztos), |
77 generate_trace_code(ctos), |
78 generate_trace_code(ctos), |
78 generate_trace_code(stos), |
79 generate_trace_code(stos), |
79 generate_trace_code(atos), |
80 generate_trace_code(atos), |
80 generate_trace_code(itos), |
81 generate_trace_code(itos), |
81 generate_trace_code(ltos), |
82 generate_trace_code(ltos), |
89 { CodeletMark cm(_masm, "return entry points"); |
90 { CodeletMark cm(_masm, "return entry points"); |
90 const int index_size = sizeof(u2); |
91 const int index_size = sizeof(u2); |
91 for (int i = 0; i < Interpreter::number_of_return_entries; i++) { |
92 for (int i = 0; i < Interpreter::number_of_return_entries; i++) { |
92 Interpreter::_return_entry[i] = |
93 Interpreter::_return_entry[i] = |
93 EntryPoint( |
94 EntryPoint( |
|
95 generate_return_entry_for(itos, i, index_size), |
94 generate_return_entry_for(itos, i, index_size), |
96 generate_return_entry_for(itos, i, index_size), |
95 generate_return_entry_for(itos, i, index_size), |
97 generate_return_entry_for(itos, i, index_size), |
96 generate_return_entry_for(itos, i, index_size), |
98 generate_return_entry_for(itos, i, index_size), |
97 generate_return_entry_for(atos, i, index_size), |
99 generate_return_entry_for(atos, i, index_size), |
98 generate_return_entry_for(itos, i, index_size), |
100 generate_return_entry_for(itos, i, index_size), |
103 ); |
105 ); |
104 } |
106 } |
105 } |
107 } |
106 |
108 |
107 { CodeletMark cm(_masm, "invoke return entry points"); |
109 { CodeletMark cm(_masm, "invoke return entry points"); |
108 const TosState states[] = {itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos}; |
110 // These states are in order specified in TosState, except btos/ztos/ctos/stos are |
|
111 // really the same as itos since there is no top of stack optimization for these types |
|
112 const TosState states[] = {itos, itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos, ilgl}; |
109 const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic); |
113 const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic); |
110 const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface); |
114 const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface); |
111 const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic); |
115 const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic); |
112 |
116 |
113 for (int i = 0; i < Interpreter::number_of_return_addrs; i++) { |
117 for (int i = 0; i < Interpreter::number_of_return_addrs; i++) { |
114 TosState state = states[i]; |
118 TosState state = states[i]; |
|
119 assert(state != ilgl, "states array is wrong above"); |
115 Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2)); |
120 Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2)); |
116 Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2)); |
121 Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2)); |
117 Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4)); |
122 Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4)); |
118 } |
123 } |
119 } |
124 } |
120 |
125 |
121 { CodeletMark cm(_masm, "earlyret entry points"); |
126 { CodeletMark cm(_masm, "earlyret entry points"); |
122 Interpreter::_earlyret_entry = |
127 Interpreter::_earlyret_entry = |
123 EntryPoint( |
128 EntryPoint( |
124 generate_earlyret_entry_for(btos), |
129 generate_earlyret_entry_for(btos), |
|
130 generate_earlyret_entry_for(ztos), |
125 generate_earlyret_entry_for(ctos), |
131 generate_earlyret_entry_for(ctos), |
126 generate_earlyret_entry_for(stos), |
132 generate_earlyret_entry_for(stos), |
127 generate_earlyret_entry_for(atos), |
133 generate_earlyret_entry_for(atos), |
128 generate_earlyret_entry_for(itos), |
134 generate_earlyret_entry_for(itos), |
129 generate_earlyret_entry_for(ltos), |
135 generate_earlyret_entry_for(ltos), |
135 |
141 |
136 { CodeletMark cm(_masm, "deoptimization entry points"); |
142 { CodeletMark cm(_masm, "deoptimization entry points"); |
137 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) { |
143 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) { |
138 Interpreter::_deopt_entry[i] = |
144 Interpreter::_deopt_entry[i] = |
139 EntryPoint( |
145 EntryPoint( |
|
146 generate_deopt_entry_for(itos, i), |
140 generate_deopt_entry_for(itos, i), |
147 generate_deopt_entry_for(itos, i), |
141 generate_deopt_entry_for(itos, i), |
148 generate_deopt_entry_for(itos, i), |
142 generate_deopt_entry_for(itos, i), |
149 generate_deopt_entry_for(itos, i), |
143 generate_deopt_entry_for(atos, i), |
150 generate_deopt_entry_for(atos, i), |
144 generate_deopt_entry_for(itos, i), |
151 generate_deopt_entry_for(itos, i), |
165 |
172 |
166 { CodeletMark cm(_masm, "continuation entry points"); |
173 { CodeletMark cm(_masm, "continuation entry points"); |
167 Interpreter::_continuation_entry = |
174 Interpreter::_continuation_entry = |
168 EntryPoint( |
175 EntryPoint( |
169 generate_continuation_for(btos), |
176 generate_continuation_for(btos), |
|
177 generate_continuation_for(ztos), |
170 generate_continuation_for(ctos), |
178 generate_continuation_for(ctos), |
171 generate_continuation_for(stos), |
179 generate_continuation_for(stos), |
172 generate_continuation_for(atos), |
180 generate_continuation_for(atos), |
173 generate_continuation_for(itos), |
181 generate_continuation_for(itos), |
174 generate_continuation_for(ltos), |
182 generate_continuation_for(ltos), |
180 |
188 |
181 { CodeletMark cm(_masm, "safepoint entry points"); |
189 { CodeletMark cm(_masm, "safepoint entry points"); |
182 Interpreter::_safept_entry = |
190 Interpreter::_safept_entry = |
183 EntryPoint( |
191 EntryPoint( |
184 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
192 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
|
193 generate_safept_entry_for(ztos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
185 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
194 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
186 generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
195 generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
187 generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
196 generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
188 generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
197 generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
189 generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
198 generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), |
299 } |
308 } |
300 |
309 |
301 |
310 |
302 void TemplateInterpreterGenerator::set_unimplemented(int i) { |
311 void TemplateInterpreterGenerator::set_unimplemented(int i) { |
303 address e = _unimplemented_bytecode; |
312 address e = _unimplemented_bytecode; |
304 EntryPoint entry(e, e, e, e, e, e, e, e, e); |
313 EntryPoint entry(e, e, e, e, e, e, e, e, e, e); |
305 Interpreter::_normal_table.set_entry(i, entry); |
314 Interpreter::_normal_table.set_entry(i, entry); |
306 Interpreter::_wentry_point[i] = _unimplemented_bytecode; |
315 Interpreter::_wentry_point[i] = _unimplemented_bytecode; |
307 } |
316 } |
308 |
317 |
309 |
318 |
314 CodeletMark cm(_masm, Bytecodes::name(code), code); |
323 CodeletMark cm(_masm, Bytecodes::name(code), code); |
315 // initialize entry points |
324 // initialize entry points |
316 assert(_unimplemented_bytecode != NULL, "should have been generated before"); |
325 assert(_unimplemented_bytecode != NULL, "should have been generated before"); |
317 assert(_illegal_bytecode_sequence != NULL, "should have been generated before"); |
326 assert(_illegal_bytecode_sequence != NULL, "should have been generated before"); |
318 address bep = _illegal_bytecode_sequence; |
327 address bep = _illegal_bytecode_sequence; |
|
328 address zep = _illegal_bytecode_sequence; |
319 address cep = _illegal_bytecode_sequence; |
329 address cep = _illegal_bytecode_sequence; |
320 address sep = _illegal_bytecode_sequence; |
330 address sep = _illegal_bytecode_sequence; |
321 address aep = _illegal_bytecode_sequence; |
331 address aep = _illegal_bytecode_sequence; |
322 address iep = _illegal_bytecode_sequence; |
332 address iep = _illegal_bytecode_sequence; |
323 address lep = _illegal_bytecode_sequence; |
333 address lep = _illegal_bytecode_sequence; |
335 Template* t = TemplateTable::template_for_wide(code); |
345 Template* t = TemplateTable::template_for_wide(code); |
336 assert(t->is_valid(), "just checking"); |
346 assert(t->is_valid(), "just checking"); |
337 set_wide_entry_point(t, wep); |
347 set_wide_entry_point(t, wep); |
338 } |
348 } |
339 // set entry points |
349 // set entry points |
340 EntryPoint entry(bep, cep, sep, aep, iep, lep, fep, dep, vep); |
350 EntryPoint entry(bep, zep, cep, sep, aep, iep, lep, fep, dep, vep); |
341 Interpreter::_normal_table.set_entry(code, entry); |
351 Interpreter::_normal_table.set_entry(code, entry); |
342 Interpreter::_wentry_point[code] = wep; |
352 Interpreter::_wentry_point[code] = wep; |
343 CodeCacheExtensions::completed_template_interpreter_entries(_masm, code); |
353 CodeCacheExtensions::completed_template_interpreter_entries(_masm, code); |
344 } |
354 } |
345 |
355 |
353 |
363 |
354 void TemplateInterpreterGenerator::set_short_entry_points(Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& vep) { |
364 void TemplateInterpreterGenerator::set_short_entry_points(Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& vep) { |
355 assert(t->is_valid(), "template must exist"); |
365 assert(t->is_valid(), "template must exist"); |
356 switch (t->tos_in()) { |
366 switch (t->tos_in()) { |
357 case btos: |
367 case btos: |
|
368 case ztos: |
358 case ctos: |
369 case ctos: |
359 case stos: |
370 case stos: |
360 ShouldNotReachHere(); // btos/ctos/stos should use itos. |
371 ShouldNotReachHere(); // btos/ctos/stos should use itos. |
361 break; |
372 break; |
362 case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break; |
373 case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break; |