851 true /* expand_call */);
852
853 // _areturn
854 __ pop(rsi); // get sender sp
855 __ pop(rdi); // get return address
856 __ mov(rsp, rsi); // set sp to sender sp
857 __ jmp(rdi);
858
859 __ bind(slow_path);
860 (void) generate_normal_entry(false);
861
862 return entry;
863 }
864 #endif // INCLUDE_ALL_GCS
865
866 // If G1 is not enabled then attempt to go through the accessor entry point
867 // Reference.get is an accessor
868 return generate_accessor_entry();
869 }
870
871 //
872 // Interpreter stub for calling a native method. (asm interpreter)
873 // This sets up a somewhat different looking stack for calling the native method
874 // than the typical interpreter frame setup.
875 //
876
877 address InterpreterGenerator::generate_native_entry(bool synchronized) {
878 // determine code generation flags
879 bool inc_counter = UseCompiler || CountCompiledCalls;
880
881 // rbx,: Method*
882 // rsi: sender sp
883 // rsi: previous interpreter state (C++ interpreter) must preserve
884 address entry_point = __ pc();
885
886 const Address constMethod (rbx, Method::const_offset());
887 const Address access_flags (rbx, Method::access_flags_offset());
888 const Address size_of_parameters(rcx, ConstMethod::size_of_parameters_offset());
889
890 // get parameter size (always needed)
1484 // [ monitor entry ] <--- rsp
1485 // ...
1486 // [ monitor entry ]
1487 // [ expr. stack bottom ]
1488 // [ saved rsi ]
1489 // [ current rdi ]
1490 // [ Method* ]
1491 // [ saved rbp, ] <--- rbp,
1492 // [ return address ]
1493 // [ local variable m ]
1494 // ...
1495 // [ local variable 1 ]
1496 // [ parameter n ]
1497 // ...
1498 // [ parameter 1 ] <--- rdi
1499
1500 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
1501 // determine code generation flags
1502 bool synchronized = false;
1503 address entry_point = NULL;
1504
1505 switch (kind) {
1506 case Interpreter::zerolocals : break;
1507 case Interpreter::zerolocals_synchronized: synchronized = true; break;
1508 case Interpreter::native : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false); break;
1509 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true); break;
1510 case Interpreter::empty : entry_point = ((InterpreterGenerator*)this)->generate_empty_entry(); break;
1511 case Interpreter::accessor : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry(); break;
1512 case Interpreter::abstract : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry(); break;
1513
1514 case Interpreter::java_lang_math_sin : // fall thru
1515 case Interpreter::java_lang_math_cos : // fall thru
1516 case Interpreter::java_lang_math_tan : // fall thru
1517 case Interpreter::java_lang_math_abs : // fall thru
1518 case Interpreter::java_lang_math_log : // fall thru
1519 case Interpreter::java_lang_math_log10 : // fall thru
1520 case Interpreter::java_lang_math_sqrt : // fall thru
1521 case Interpreter::java_lang_math_pow : // fall thru
1522 case Interpreter::java_lang_math_exp : entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break;
1523 case Interpreter::java_lang_ref_reference_get
1524 : entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break;
1525 default:
1526 fatal(err_msg("unexpected method kind: %d", kind));
1527 break;
1528 }
1529
1530 if (entry_point) return entry_point;
1531
1532 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
1533
1534 }
1535
1536 // These should never be compiled since the interpreter will prefer
1537 // the compiled version to the intrinsic version.
1538 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
1539 switch (method_kind(m)) {
1540 case Interpreter::java_lang_math_sin : // fall thru
1541 case Interpreter::java_lang_math_cos : // fall thru
1542 case Interpreter::java_lang_math_tan : // fall thru
1543 case Interpreter::java_lang_math_abs : // fall thru
1544 case Interpreter::java_lang_math_log : // fall thru
1545 case Interpreter::java_lang_math_log10 : // fall thru
1546 case Interpreter::java_lang_math_sqrt : // fall thru
1547 case Interpreter::java_lang_math_pow : // fall thru
1548 case Interpreter::java_lang_math_exp :
1549 return false;
1550 default:
1551 return true;
1552 }
|
851 true /* expand_call */);
852
853 // _areturn
854 __ pop(rsi); // get sender sp
855 __ pop(rdi); // get return address
856 __ mov(rsp, rsi); // set sp to sender sp
857 __ jmp(rdi);
858
859 __ bind(slow_path);
860 (void) generate_normal_entry(false);
861
862 return entry;
863 }
864 #endif // INCLUDE_ALL_GCS
865
866 // If G1 is not enabled then attempt to go through the accessor entry point
867 // Reference.get is an accessor
868 return generate_accessor_entry();
869 }
870
871 /**
872 * Method entry for static native methods:
873 * int java.util.zip.CRC32.update(int crc, int b)
874 */
875 address InterpreterGenerator::generate_CRC32_update_entry() {
876 if (UseCRC32Intrinsics) {
877 address entry = __ pc();
878
879 // rbx,: Method*
880 // rsi: senderSP must preserved for slow path, set SP to it on fast path
881 // rdx: scratch
882 // rdi: scratch
883
884 Label slow_path;
885 // If we need a safepoint check, generate full interpreter entry.
886 ExternalAddress state(SafepointSynchronize::address_of_state());
887 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
888 SafepointSynchronize::_not_synchronized);
889 __ jcc(Assembler::notEqual, slow_path);
890
891 // We don't generate local frame and don't align stack because
892 // we call stub code and there is no safepoint on this path.
893
894 // Load parameters
895 const Register crc = rax; // crc
896 const Register val = rdx; // source java byte value
897 const Register tbl = rdi; // scratch
898
899 // Arguments are reversed on java expression stack
900 __ movl(val, Address(rsp, wordSize)); // byte value
901 __ movl(crc, Address(rsp, 2*wordSize)); // Initial CRC
902
903 __ lea(tbl, ExternalAddress(StubRoutines::crc_table_addr()));
904 __ notl(crc); // ~crc
905 __ update_byte_crc32(crc, val, tbl);
906 __ notl(crc); // ~crc
907 // result in rax
908
909 // _areturn
910 __ pop(rdi); // get return address
911 __ mov(rsp, rsi); // set sp to sender sp
912 __ jmp(rdi);
913
914 // generate a vanilla native entry as the slow path
915 __ bind(slow_path);
916
917 (void) generate_native_entry(false);
918
919 return entry;
920 }
921 return generate_native_entry(false);
922 }
923
924 /**
925 * Method entry for static native methods:
926 * int java.util.zip.CRC32.updateBytes(int crc, byte[] b, int off, int len)
927 * int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len)
928 */
929 address InterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
930 if (UseCRC32Intrinsics) {
931 address entry = __ pc();
932
933 // rbx,: Method*
934 // rsi: senderSP must preserved for slow path, set SP to it on fast path
935 // rdx: scratch
936 // rdi: scratch
937
938 Label slow_path;
939 // If we need a safepoint check, generate full interpreter entry.
940 ExternalAddress state(SafepointSynchronize::address_of_state());
941 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
942 SafepointSynchronize::_not_synchronized);
943 __ jcc(Assembler::notEqual, slow_path);
944
945 // We don't generate local frame and don't align stack because
946 // we call stub code and there is no safepoint on this path.
947
948 // Load parameters
949 const Register crc = rax; // crc
950 const Register buf = rdx; // source java byte array address
951 const Register len = rdi; // length
952
953 // Arguments are reversed on java expression stack
954 __ movl(len, Address(rsp, wordSize)); // Length
955 // Calculate address of start element
956 if (kind == Interpreter::java_util_zip_CRC32_updateByteBuffer) {
957 __ movptr(buf, Address(rsp, 3*wordSize)); // long buf
958 __ addptr(buf, Address(rsp, 2*wordSize)); // + offset
959 __ movl(crc, Address(rsp, 5*wordSize)); // Initial CRC
960 } else {
961 __ movptr(buf, Address(rsp, 3*wordSize)); // byte[] array
962 __ addptr(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE)); // + header size
963 __ addptr(buf, Address(rsp, 2*wordSize)); // + offset
964 __ movl(crc, Address(rsp, 4*wordSize)); // Initial CRC
965 }
966
967 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, StubRoutines::updateBytesCRC32()), crc, buf, len);
968 // result in rax
969
970 // _areturn
971 __ pop(rdi); // get return address
972 __ mov(rsp, rsi); // set sp to sender sp
973 __ jmp(rdi);
974
975 // generate a vanilla native entry as the slow path
976 __ bind(slow_path);
977
978 (void) generate_native_entry(false);
979
980 return entry;
981 }
982 return generate_native_entry(false);
983 }
984
985 //
986 // Interpreter stub for calling a native method. (asm interpreter)
987 // This sets up a somewhat different looking stack for calling the native method
988 // than the typical interpreter frame setup.
989 //
990
991 address InterpreterGenerator::generate_native_entry(bool synchronized) {
992 // determine code generation flags
993 bool inc_counter = UseCompiler || CountCompiledCalls;
994
995 // rbx,: Method*
996 // rsi: sender sp
997 // rsi: previous interpreter state (C++ interpreter) must preserve
998 address entry_point = __ pc();
999
1000 const Address constMethod (rbx, Method::const_offset());
1001 const Address access_flags (rbx, Method::access_flags_offset());
1002 const Address size_of_parameters(rcx, ConstMethod::size_of_parameters_offset());
1003
1004 // get parameter size (always needed)
1598 // [ monitor entry ] <--- rsp
1599 // ...
1600 // [ monitor entry ]
1601 // [ expr. stack bottom ]
1602 // [ saved rsi ]
1603 // [ current rdi ]
1604 // [ Method* ]
1605 // [ saved rbp, ] <--- rbp,
1606 // [ return address ]
1607 // [ local variable m ]
1608 // ...
1609 // [ local variable 1 ]
1610 // [ parameter n ]
1611 // ...
1612 // [ parameter 1 ] <--- rdi
1613
1614 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
1615 // determine code generation flags
1616 bool synchronized = false;
1617 address entry_point = NULL;
1618 InterpreterGenerator* ig_this = (InterpreterGenerator*)this;
1619
1620 switch (kind) {
1621 case Interpreter::zerolocals : break;
1622 case Interpreter::zerolocals_synchronized: synchronized = true; break;
1623 case Interpreter::native : entry_point = ig_this->generate_native_entry(false); break;
1624 case Interpreter::native_synchronized : entry_point = ig_this->generate_native_entry(true); break;
1625 case Interpreter::empty : entry_point = ig_this->generate_empty_entry(); break;
1626 case Interpreter::accessor : entry_point = ig_this->generate_accessor_entry(); break;
1627 case Interpreter::abstract : entry_point = ig_this->generate_abstract_entry(); break;
1628
1629 case Interpreter::java_lang_math_sin : // fall thru
1630 case Interpreter::java_lang_math_cos : // fall thru
1631 case Interpreter::java_lang_math_tan : // fall thru
1632 case Interpreter::java_lang_math_abs : // fall thru
1633 case Interpreter::java_lang_math_log : // fall thru
1634 case Interpreter::java_lang_math_log10 : // fall thru
1635 case Interpreter::java_lang_math_sqrt : // fall thru
1636 case Interpreter::java_lang_math_pow : // fall thru
1637 case Interpreter::java_lang_math_exp : entry_point = ig_this->generate_math_entry(kind); break;
1638 case Interpreter::java_lang_ref_reference_get
1639 : entry_point = ig_this->generate_Reference_get_entry(); break;
1640 case Interpreter::java_util_zip_CRC32_update
1641 : entry_point = ig_this->generate_CRC32_update_entry(); break;
1642 case Interpreter::java_util_zip_CRC32_updateBytes
1643 : // fall thru
1644 case Interpreter::java_util_zip_CRC32_updateByteBuffer
1645 : entry_point = ig_this->generate_CRC32_updateBytes_entry(kind); break;
1646 default:
1647 fatal(err_msg("unexpected method kind: %d", kind));
1648 break;
1649 }
1650
1651 if (entry_point) return entry_point;
1652
1653 return ig_this->generate_normal_entry(synchronized);
1654
1655 }
1656
1657 // These should never be compiled since the interpreter will prefer
1658 // the compiled version to the intrinsic version.
1659 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
1660 switch (method_kind(m)) {
1661 case Interpreter::java_lang_math_sin : // fall thru
1662 case Interpreter::java_lang_math_cos : // fall thru
1663 case Interpreter::java_lang_math_tan : // fall thru
1664 case Interpreter::java_lang_math_abs : // fall thru
1665 case Interpreter::java_lang_math_log : // fall thru
1666 case Interpreter::java_lang_math_log10 : // fall thru
1667 case Interpreter::java_lang_math_sqrt : // fall thru
1668 case Interpreter::java_lang_math_pow : // fall thru
1669 case Interpreter::java_lang_math_exp :
1670 return false;
1671 default:
1672 return true;
1673 }
|