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 "asm/macroAssembler.hpp"
27 #include "asm/macroAssembler.inline.hpp"
28 #include "compiler/disassembler.hpp"
29 #include "interpreter/bytecodeHistogram.hpp"
30 #include "interpreter/bytecodeInterpreter.hpp"
31 #include "interpreter/interpreter.hpp"
32 #include "interpreter/interpreterGenerator.hpp"
33 #include "interpreter/interpreterRuntime.hpp"
34 #include "interpreter/interp_masm.hpp"
35 #include "interpreter/templateTable.hpp"
36 #include "memory/allocation.inline.hpp"
37 #include "memory/resourceArea.hpp"
38 #include "oops/arrayOop.hpp"
39 #include "oops/methodData.hpp"
40 #include "oops/method.hpp"
41 #include "oops/oop.inline.hpp"
42 #include "prims/forte.hpp"
43 #include "prims/jvmtiExport.hpp"
44 #include "prims/methodHandles.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/sharedRuntime.hpp"
47 #include "runtime/stubRoutines.hpp"
48 #include "runtime/timer.hpp"
49
50 # define __ _masm->
51
52
265 // Synchronized?
266 if (m->is_synchronized()) {
267 return zerolocals_synchronized;
268 }
269
270 if (RegisterFinalizersAtInit && m->code_size() == 1 &&
271 m->intrinsic_id() == vmIntrinsics::_Object_init) {
272 // We need to execute the special return bytecode to check for
273 // finalizer registration so create a normal frame.
274 return zerolocals;
275 }
276
277 // Empty method?
278 if (m->is_empty_method()) {
279 return empty;
280 }
281
282 // Special intrinsic method?
283 // Note: This test must come _after_ the test for native methods,
284 // otherwise we will run into problems with JDK 1.2, see also
285 // InterpreterGenerator::generate_method_entry() for
286 // for details.
287 switch (m->intrinsic_id()) {
288 case vmIntrinsics::_dsin : return java_lang_math_sin ;
289 case vmIntrinsics::_dcos : return java_lang_math_cos ;
290 case vmIntrinsics::_dtan : return java_lang_math_tan ;
291 case vmIntrinsics::_dabs : return java_lang_math_abs ;
292 case vmIntrinsics::_dsqrt : return java_lang_math_sqrt ;
293 case vmIntrinsics::_dlog : return java_lang_math_log ;
294 case vmIntrinsics::_dlog10: return java_lang_math_log10;
295 case vmIntrinsics::_dpow : return java_lang_math_pow ;
296 case vmIntrinsics::_dexp : return java_lang_math_exp ;
297
298 case vmIntrinsics::_Reference_get:
299 return java_lang_ref_reference_get;
300 }
301
302 // Accessor method?
303 if (m->is_getter()) {
304 // TODO: We should have used ::is_accessor above, but fast accessors in Zero expect only getters.
305 // See CppInterpreter::accessor_entry in cppInterpreter_zero.cpp. This should be fixed in Zero,
529 // method receiever, so do the banging after locking the receiver.)
530
531 // Bang each page in the shadow zone. We can't assume it's been done for
532 // an interpreter frame with greater than a page of locals, so each page
533 // needs to be checked. Only true for non-native.
534 if (UseStackBanging) {
535 const int start_page = native_call ? StackShadowPages : 1;
536 const int page_size = os::vm_page_size();
537 for (int pages = start_page; pages <= StackShadowPages ; pages++) {
538 __ bang_stack_with_offset(pages*page_size);
539 }
540 }
541 }
542
543 void AbstractInterpreterGenerator::initialize_method_handle_entries() {
544 // method handle entry kinds are generated later in MethodHandlesAdapterGenerator::generate:
545 for (int i = Interpreter::method_handle_invoke_FIRST; i <= Interpreter::method_handle_invoke_LAST; i++) {
546 Interpreter::MethodKind kind = (Interpreter::MethodKind) i;
547 Interpreter::_entry_table[kind] = Interpreter::_entry_table[Interpreter::abstract];
548 }
549 }
550
551 // Generate method entries
552 address InterpreterGenerator::generate_method_entry(
553 AbstractInterpreter::MethodKind kind) {
554 // determine code generation flags
555 bool native = false;
556 bool synchronized = false;
557 address entry_point = NULL;
558
559 switch (kind) {
560 case Interpreter::zerolocals : break;
561 case Interpreter::zerolocals_synchronized: synchronized = true; break;
562 case Interpreter::native : native = true; break;
563 case Interpreter::native_synchronized : native = true; synchronized = true; break;
564 case Interpreter::empty : entry_point = generate_empty_entry(); break;
565 case Interpreter::accessor : entry_point = generate_accessor_entry(); break;
566 case Interpreter::abstract : entry_point = generate_abstract_entry(); break;
567
568 case Interpreter::java_lang_math_sin : // fall thru
569 case Interpreter::java_lang_math_cos : // fall thru
570 case Interpreter::java_lang_math_tan : // fall thru
571 case Interpreter::java_lang_math_abs : // fall thru
572 case Interpreter::java_lang_math_log : // fall thru
573 case Interpreter::java_lang_math_log10 : // fall thru
574 case Interpreter::java_lang_math_sqrt : // fall thru
575 case Interpreter::java_lang_math_pow : // fall thru
576 case Interpreter::java_lang_math_exp : entry_point = generate_math_entry(kind); break;
577 case Interpreter::java_lang_ref_reference_get
578 : entry_point = generate_Reference_get_entry(); break;
579 #ifndef CC_INTERP
580 case Interpreter::java_util_zip_CRC32_update
581 : native = true; entry_point = generate_CRC32_update_entry(); break;
582 case Interpreter::java_util_zip_CRC32_updateBytes
583 : // fall thru
584 case Interpreter::java_util_zip_CRC32_updateByteBuffer
585 : native = true; entry_point = generate_CRC32_updateBytes_entry(kind); break;
586 case Interpreter::java_util_zip_CRC32C_updateBytes
587 : // fall thru
588 case Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer
589 : entry_point = generate_CRC32C_updateBytes_entry(kind); break;
590 #if defined(TARGET_ARCH_x86) && !defined(_LP64)
591 // On x86_32 platforms, a special entry is generated for the following four methods.
592 // On other platforms the normal entry is used to enter these methods.
593 case Interpreter::java_lang_Float_intBitsToFloat
594 : native = true; entry_point = generate_Float_intBitsToFloat_entry(); break;
595 case Interpreter::java_lang_Float_floatToRawIntBits
596 : native = true; entry_point = generate_Float_floatToRawIntBits_entry(); break;
597 case Interpreter::java_lang_Double_longBitsToDouble
598 : native = true; entry_point = generate_Double_longBitsToDouble_entry(); break;
599 case Interpreter::java_lang_Double_doubleToRawLongBits
600 : native = true; entry_point = generate_Double_doubleToRawLongBits_entry(); break;
601 #else
602 case Interpreter::java_lang_Float_intBitsToFloat:
603 case Interpreter::java_lang_Float_floatToRawIntBits:
604 case Interpreter::java_lang_Double_longBitsToDouble:
605 case Interpreter::java_lang_Double_doubleToRawLongBits:
606 native = true;
607 break;
608 #endif // defined(TARGET_ARCH_x86) && !defined(_LP64)
609 #endif // CC_INTERP
610 default:
611 fatal("unexpected method kind: %d", kind);
612 break;
613 }
614
615 if (entry_point) {
616 return entry_point;
617 }
618
619 // We expect the normal and native entry points to be generated first so we can reuse them.
620 if (native) {
621 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
622 if (entry_point == NULL) {
623 entry_point = generate_native_entry(synchronized);
624 }
625 } else {
626 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);
627 if (entry_point == NULL) {
628 entry_point = generate_normal_entry(synchronized);
629 }
630 }
631
632 return entry_point;
633 }
|
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 "asm/macroAssembler.hpp"
27 #include "asm/macroAssembler.inline.hpp"
28 #include "compiler/disassembler.hpp"
29 #include "interpreter/bytecodeHistogram.hpp"
30 #include "interpreter/bytecodeInterpreter.hpp"
31 #include "interpreter/interpreter.hpp"
32 #include "interpreter/interpreterRuntime.hpp"
33 #include "interpreter/interp_masm.hpp"
34 #include "interpreter/templateTable.hpp"
35 #include "memory/allocation.inline.hpp"
36 #include "memory/resourceArea.hpp"
37 #include "oops/arrayOop.hpp"
38 #include "oops/methodData.hpp"
39 #include "oops/method.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "prims/forte.hpp"
42 #include "prims/jvmtiExport.hpp"
43 #include "prims/methodHandles.hpp"
44 #include "runtime/handles.inline.hpp"
45 #include "runtime/sharedRuntime.hpp"
46 #include "runtime/stubRoutines.hpp"
47 #include "runtime/timer.hpp"
48
49 # define __ _masm->
50
51
264 // Synchronized?
265 if (m->is_synchronized()) {
266 return zerolocals_synchronized;
267 }
268
269 if (RegisterFinalizersAtInit && m->code_size() == 1 &&
270 m->intrinsic_id() == vmIntrinsics::_Object_init) {
271 // We need to execute the special return bytecode to check for
272 // finalizer registration so create a normal frame.
273 return zerolocals;
274 }
275
276 // Empty method?
277 if (m->is_empty_method()) {
278 return empty;
279 }
280
281 // Special intrinsic method?
282 // Note: This test must come _after_ the test for native methods,
283 // otherwise we will run into problems with JDK 1.2, see also
284 // TemplateInterpreterGenerator::generate_method_entry() for
285 // for details.
286 switch (m->intrinsic_id()) {
287 case vmIntrinsics::_dsin : return java_lang_math_sin ;
288 case vmIntrinsics::_dcos : return java_lang_math_cos ;
289 case vmIntrinsics::_dtan : return java_lang_math_tan ;
290 case vmIntrinsics::_dabs : return java_lang_math_abs ;
291 case vmIntrinsics::_dsqrt : return java_lang_math_sqrt ;
292 case vmIntrinsics::_dlog : return java_lang_math_log ;
293 case vmIntrinsics::_dlog10: return java_lang_math_log10;
294 case vmIntrinsics::_dpow : return java_lang_math_pow ;
295 case vmIntrinsics::_dexp : return java_lang_math_exp ;
296
297 case vmIntrinsics::_Reference_get:
298 return java_lang_ref_reference_get;
299 }
300
301 // Accessor method?
302 if (m->is_getter()) {
303 // TODO: We should have used ::is_accessor above, but fast accessors in Zero expect only getters.
304 // See CppInterpreter::accessor_entry in cppInterpreter_zero.cpp. This should be fixed in Zero,
528 // method receiever, so do the banging after locking the receiver.)
529
530 // Bang each page in the shadow zone. We can't assume it's been done for
531 // an interpreter frame with greater than a page of locals, so each page
532 // needs to be checked. Only true for non-native.
533 if (UseStackBanging) {
534 const int start_page = native_call ? StackShadowPages : 1;
535 const int page_size = os::vm_page_size();
536 for (int pages = start_page; pages <= StackShadowPages ; pages++) {
537 __ bang_stack_with_offset(pages*page_size);
538 }
539 }
540 }
541
542 void AbstractInterpreterGenerator::initialize_method_handle_entries() {
543 // method handle entry kinds are generated later in MethodHandlesAdapterGenerator::generate:
544 for (int i = Interpreter::method_handle_invoke_FIRST; i <= Interpreter::method_handle_invoke_LAST; i++) {
545 Interpreter::MethodKind kind = (Interpreter::MethodKind) i;
546 Interpreter::_entry_table[kind] = Interpreter::_entry_table[Interpreter::abstract];
547 }
548 }
|