2955 // arrays, so just use the code we've already generated
2956 StubRoutines::_arrayof_jbyte_disjoint_arraycopy = StubRoutines::_jbyte_disjoint_arraycopy;
2957 StubRoutines::_arrayof_jbyte_arraycopy = StubRoutines::_jbyte_arraycopy;
2958
2959 StubRoutines::_arrayof_jshort_disjoint_arraycopy = StubRoutines::_jshort_disjoint_arraycopy;
2960 StubRoutines::_arrayof_jshort_arraycopy = StubRoutines::_jshort_arraycopy;
2961
2962 StubRoutines::_arrayof_jint_disjoint_arraycopy = StubRoutines::_jint_disjoint_arraycopy;
2963 StubRoutines::_arrayof_jint_arraycopy = StubRoutines::_jint_arraycopy;
2964
2965 StubRoutines::_arrayof_jlong_disjoint_arraycopy = StubRoutines::_jlong_disjoint_arraycopy;
2966 StubRoutines::_arrayof_jlong_arraycopy = StubRoutines::_jlong_arraycopy;
2967
2968 StubRoutines::_arrayof_oop_disjoint_arraycopy = StubRoutines::_oop_disjoint_arraycopy;
2969 StubRoutines::_arrayof_oop_arraycopy = StubRoutines::_oop_arraycopy;
2970
2971 StubRoutines::_arrayof_oop_disjoint_arraycopy_uninit = StubRoutines::_oop_disjoint_arraycopy_uninit;
2972 StubRoutines::_arrayof_oop_arraycopy_uninit = StubRoutines::_oop_arraycopy_uninit;
2973 }
2974
2975 void generate_math_stubs() {
2976 {
2977 StubCodeMark mark(this, "StubRoutines", "log10");
2978 StubRoutines::_intrinsic_log10 = (double (*)(double)) __ pc();
2979
2980 __ subq(rsp, 8);
2981 __ movdbl(Address(rsp, 0), xmm0);
2982 __ fld_d(Address(rsp, 0));
2983 __ flog10();
2984 __ fstp_d(Address(rsp, 0));
2985 __ movdbl(xmm0, Address(rsp, 0));
2986 __ addq(rsp, 8);
2987 __ ret(0);
2988 }
2989 {
2990 StubCodeMark mark(this, "StubRoutines", "tan");
2991 StubRoutines::_intrinsic_tan = (double (*)(double)) __ pc();
2992
2993 __ subq(rsp, 8);
2994 __ movdbl(Address(rsp, 0), xmm0);
2995 __ fld_d(Address(rsp, 0));
2996 __ trigfunc('t');
2997 __ fstp_d(Address(rsp, 0));
2998 __ movdbl(xmm0, Address(rsp, 0));
2999 __ addq(rsp, 8);
3000 __ ret(0);
3001 }
3002 }
3003
3004 // AES intrinsic stubs
3005 enum {AESBlockSize = 16};
3006
3007 address generate_key_shuffle_mask() {
3008 __ align(16);
3009 StubCodeMark mark(this, "StubRoutines", "key_shuffle_mask");
3010 address start = __ pc();
3011 __ emit_data64( 0x0405060700010203, relocInfo::none );
3012 __ emit_data64( 0x0c0d0e0f08090a0b, relocInfo::none );
3013 return start;
3014 }
3015
3016 address generate_counter_shuffle_mask() {
3017 __ align(16);
3018 StubCodeMark mark(this, "StubRoutines", "counter_shuffle_mask");
3019 address start = __ pc();
3020 __ emit_data64(0x08090a0b0c0d0e0f, relocInfo::none);
3021 __ emit_data64(0x0001020304050607, relocInfo::none);
3022 return start;
3023 }
4728 __ subptr(rsp, 4 * wordSize);
4729 __ movdqu(Address(rsp, 0), xmm6);
4730 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4731 #endif
4732 __ fast_log(x0, x1, x2, x3, x4, x5, x6, x7, rax, rcx, rdx, tmp1, tmp2);
4733
4734 #ifdef _WIN64
4735 // restore xmm regs belonging to calling function
4736 __ movdqu(xmm6, Address(rsp, 0));
4737 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4738 __ addptr(rsp, 4 * wordSize);
4739 #endif
4740
4741 __ leave(); // required for proper stackwalking of RuntimeStub frame
4742 __ ret(0);
4743
4744 return start;
4745
4746 }
4747
4748 address generate_libmPow() {
4749 address start = __ pc();
4750
4751 const XMMRegister x0 = xmm0;
4752 const XMMRegister x1 = xmm1;
4753 const XMMRegister x2 = xmm2;
4754 const XMMRegister x3 = xmm3;
4755
4756 const XMMRegister x4 = xmm4;
4757 const XMMRegister x5 = xmm5;
4758 const XMMRegister x6 = xmm6;
4759 const XMMRegister x7 = xmm7;
4760
4761 const Register tmp1 = r8;
4762 const Register tmp2 = r9;
4763 const Register tmp3 = r10;
4764 const Register tmp4 = r11;
4765
4766 BLOCK_COMMENT("Entry:");
4767 __ enter(); // required for proper stackwalking of RuntimeStub frame
4793
4794 const XMMRegister x0 = xmm0;
4795 const XMMRegister x1 = xmm1;
4796 const XMMRegister x2 = xmm2;
4797 const XMMRegister x3 = xmm3;
4798
4799 const XMMRegister x4 = xmm4;
4800 const XMMRegister x5 = xmm5;
4801 const XMMRegister x6 = xmm6;
4802 const XMMRegister x7 = xmm7;
4803
4804 const Register tmp1 = r8;
4805 const Register tmp2 = r9;
4806 const Register tmp3 = r10;
4807 const Register tmp4 = r11;
4808
4809 BLOCK_COMMENT("Entry:");
4810 __ enter(); // required for proper stackwalking of RuntimeStub frame
4811
4812 #ifdef _WIN64
4813 // save the xmm registers which must be preserved 6-7
4814 __ subptr(rsp, 4 * wordSize);
4815 __ movdqu(Address(rsp, 0), xmm6);
4816 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4817 #endif
4818 __ fast_sin(x0, x1, x2, x3, x4, x5, x6, x7, rax, rbx, rcx, rdx, tmp1, tmp2, tmp3, tmp4);
4819
4820 #ifdef _WIN64
4821 // restore xmm regs belonging to calling function
4822 __ movdqu(xmm6, Address(rsp, 0));
4823 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4824 __ addptr(rsp, 4 * wordSize);
4825 #endif
4826
4827 __ leave(); // required for proper stackwalking of RuntimeStub frame
4828 __ ret(0);
4829
4830 return start;
4831
4832 }
4833
4834 address generate_libmCos() {
4835 address start = __ pc();
4836
4837 const XMMRegister x0 = xmm0;
4838 const XMMRegister x1 = xmm1;
4839 const XMMRegister x2 = xmm2;
4840 const XMMRegister x3 = xmm3;
4841
4842 const XMMRegister x4 = xmm4;
4843 const XMMRegister x5 = xmm5;
4844 const XMMRegister x6 = xmm6;
4845 const XMMRegister x7 = xmm7;
4846
4847 const Register tmp1 = r8;
4848 const Register tmp2 = r9;
4849 const Register tmp3 = r10;
4850 const Register tmp4 = r11;
4851
4852 BLOCK_COMMENT("Entry:");
4853 __ enter(); // required for proper stackwalking of RuntimeStub frame
4854
4855 #ifdef _WIN64
4856 // save the xmm registers which must be preserved 6-7
4857 __ subptr(rsp, 4 * wordSize);
4858 __ movdqu(Address(rsp, 0), xmm6);
4859 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4860 #endif
4861 __ fast_cos(x0, x1, x2, x3, x4, x5, x6, x7, rax, rcx, rdx, tmp1, tmp2, tmp3, tmp4);
4862
4863 #ifdef _WIN64
4864 // restore xmm regs belonging to calling function
4865 __ movdqu(xmm6, Address(rsp, 0));
4866 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4867 __ addptr(rsp, 4 * wordSize);
4868 #endif
4869
4870 __ leave(); // required for proper stackwalking of RuntimeStub frame
4871 __ ret(0);
4872
4873 return start;
4874
4875 }
4876
4877 #undef __
4878 #define __ masm->
4879
4880 // Continuation point for throwing of implicit exceptions that are
4881 // not handled in the current activation. Fabricates an exception
4882 // oop and initiates normal exception dispatching in this
4883 // frame. Since we need to preserve callee-saved values (currently
4884 // only for C2, but done for C1 as well) we need a callee-saved oop
4885 // map and therefore have to make these stubs into RuntimeStubs
4886 // rather than BufferBlobs. If the compiler needs all registers to
4887 // be preserved between the fault point and the exception handler
5048 CAST_FROM_FN_PTR(address,
5049 SharedRuntime::
5050 throw_StackOverflowError));
5051 StubRoutines::_throw_delayed_StackOverflowError_entry =
5052 generate_throw_exception("delayed StackOverflowError throw_exception",
5053 CAST_FROM_FN_PTR(address,
5054 SharedRuntime::
5055 throw_delayed_StackOverflowError));
5056 if (UseCRC32Intrinsics) {
5057 // set table address before stub generation which use it
5058 StubRoutines::_crc_table_adr = (address)StubRoutines::x86::_crc_table;
5059 StubRoutines::_updateBytesCRC32 = generate_updateBytesCRC32();
5060 }
5061
5062 if (UseCRC32CIntrinsics) {
5063 bool supports_clmul = VM_Version::supports_clmul();
5064 StubRoutines::x86::generate_CRC32C_table(supports_clmul);
5065 StubRoutines::_crc32c_table_addr = (address)StubRoutines::x86::_crc32c_table;
5066 StubRoutines::_updateBytesCRC32C = generate_updateBytesCRC32C(supports_clmul);
5067 }
5068 if (VM_Version::supports_sse2()) {
5069 StubRoutines::_dexp = generate_libmExp();
5070 StubRoutines::_dlog = generate_libmLog();
5071 StubRoutines::_dpow = generate_libmPow();
5072 if (UseLibmSinIntrinsic) {
5073 StubRoutines::_dsin = generate_libmSin();
5074 }
5075 if (UseLibmCosIntrinsic) {
5076 StubRoutines::_dcos = generate_libmCos();
5077 }
5078 }
5079 }
5080
5081 void generate_all() {
5082 // Generates all stubs and initializes the entry points
5083
5084 // These entry points require SharedInfo::stack0 to be set up in
5085 // non-core builds and need to be relocatable, so they each
5086 // fabricate a RuntimeStub internally.
5087 StubRoutines::_throw_AbstractMethodError_entry =
5088 generate_throw_exception("AbstractMethodError throw_exception",
5089 CAST_FROM_FN_PTR(address,
5090 SharedRuntime::
5091 throw_AbstractMethodError));
5092
5093 StubRoutines::_throw_IncompatibleClassChangeError_entry =
5094 generate_throw_exception("IncompatibleClassChangeError throw_exception",
5095 CAST_FROM_FN_PTR(address,
5096 SharedRuntime::
5097 throw_IncompatibleClassChangeError));
5098
5099 StubRoutines::_throw_NullPointerException_at_call_entry =
5101 CAST_FROM_FN_PTR(address,
5102 SharedRuntime::
5103 throw_NullPointerException_at_call));
5104
5105 // entry points that are platform specific
5106 StubRoutines::x86::_f2i_fixup = generate_f2i_fixup();
5107 StubRoutines::x86::_f2l_fixup = generate_f2l_fixup();
5108 StubRoutines::x86::_d2i_fixup = generate_d2i_fixup();
5109 StubRoutines::x86::_d2l_fixup = generate_d2l_fixup();
5110
5111 StubRoutines::x86::_float_sign_mask = generate_fp_mask("float_sign_mask", 0x7FFFFFFF7FFFFFFF);
5112 StubRoutines::x86::_float_sign_flip = generate_fp_mask("float_sign_flip", 0x8000000080000000);
5113 StubRoutines::x86::_double_sign_mask = generate_fp_mask("double_sign_mask", 0x7FFFFFFFFFFFFFFF);
5114 StubRoutines::x86::_double_sign_flip = generate_fp_mask("double_sign_flip", 0x8000000000000000);
5115
5116 // support for verify_oop (must happen after universe_init)
5117 StubRoutines::_verify_oop_subroutine_entry = generate_verify_oop();
5118
5119 // arraycopy stubs used by compilers
5120 generate_arraycopy_stubs();
5121
5122 generate_math_stubs();
5123
5124 // don't bother generating these AES intrinsic stubs unless global flag is set
5125 if (UseAESIntrinsics) {
5126 StubRoutines::x86::_key_shuffle_mask_addr = generate_key_shuffle_mask(); // needed by the others
5127 StubRoutines::_aescrypt_encryptBlock = generate_aescrypt_encryptBlock();
5128 StubRoutines::_aescrypt_decryptBlock = generate_aescrypt_decryptBlock();
5129 StubRoutines::_cipherBlockChaining_encryptAESCrypt = generate_cipherBlockChaining_encryptAESCrypt();
5130 StubRoutines::_cipherBlockChaining_decryptAESCrypt = generate_cipherBlockChaining_decryptAESCrypt_Parallel();
5131 }
5132 if (UseAESCTRIntrinsics){
5133 StubRoutines::x86::_counter_shuffle_mask_addr = generate_counter_shuffle_mask();
5134 StubRoutines::_counterMode_AESCrypt = generate_counterMode_AESCrypt_Parallel();
5135 }
5136
5137 if (UseSHA1Intrinsics) {
5138 StubRoutines::x86::_upper_word_mask_addr = generate_upper_word_mask();
5139 StubRoutines::x86::_shuffle_byte_flip_mask_addr = generate_shuffle_byte_flip_mask();
5140 StubRoutines::_sha1_implCompress = generate_sha1_implCompress(false, "sha1_implCompress");
5141 StubRoutines::_sha1_implCompressMB = generate_sha1_implCompress(true, "sha1_implCompressMB");
5142 }
|
2955 // arrays, so just use the code we've already generated
2956 StubRoutines::_arrayof_jbyte_disjoint_arraycopy = StubRoutines::_jbyte_disjoint_arraycopy;
2957 StubRoutines::_arrayof_jbyte_arraycopy = StubRoutines::_jbyte_arraycopy;
2958
2959 StubRoutines::_arrayof_jshort_disjoint_arraycopy = StubRoutines::_jshort_disjoint_arraycopy;
2960 StubRoutines::_arrayof_jshort_arraycopy = StubRoutines::_jshort_arraycopy;
2961
2962 StubRoutines::_arrayof_jint_disjoint_arraycopy = StubRoutines::_jint_disjoint_arraycopy;
2963 StubRoutines::_arrayof_jint_arraycopy = StubRoutines::_jint_arraycopy;
2964
2965 StubRoutines::_arrayof_jlong_disjoint_arraycopy = StubRoutines::_jlong_disjoint_arraycopy;
2966 StubRoutines::_arrayof_jlong_arraycopy = StubRoutines::_jlong_arraycopy;
2967
2968 StubRoutines::_arrayof_oop_disjoint_arraycopy = StubRoutines::_oop_disjoint_arraycopy;
2969 StubRoutines::_arrayof_oop_arraycopy = StubRoutines::_oop_arraycopy;
2970
2971 StubRoutines::_arrayof_oop_disjoint_arraycopy_uninit = StubRoutines::_oop_disjoint_arraycopy_uninit;
2972 StubRoutines::_arrayof_oop_arraycopy_uninit = StubRoutines::_oop_arraycopy_uninit;
2973 }
2974
2975 // AES intrinsic stubs
2976 enum {AESBlockSize = 16};
2977
2978 address generate_key_shuffle_mask() {
2979 __ align(16);
2980 StubCodeMark mark(this, "StubRoutines", "key_shuffle_mask");
2981 address start = __ pc();
2982 __ emit_data64( 0x0405060700010203, relocInfo::none );
2983 __ emit_data64( 0x0c0d0e0f08090a0b, relocInfo::none );
2984 return start;
2985 }
2986
2987 address generate_counter_shuffle_mask() {
2988 __ align(16);
2989 StubCodeMark mark(this, "StubRoutines", "counter_shuffle_mask");
2990 address start = __ pc();
2991 __ emit_data64(0x08090a0b0c0d0e0f, relocInfo::none);
2992 __ emit_data64(0x0001020304050607, relocInfo::none);
2993 return start;
2994 }
4699 __ subptr(rsp, 4 * wordSize);
4700 __ movdqu(Address(rsp, 0), xmm6);
4701 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4702 #endif
4703 __ fast_log(x0, x1, x2, x3, x4, x5, x6, x7, rax, rcx, rdx, tmp1, tmp2);
4704
4705 #ifdef _WIN64
4706 // restore xmm regs belonging to calling function
4707 __ movdqu(xmm6, Address(rsp, 0));
4708 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4709 __ addptr(rsp, 4 * wordSize);
4710 #endif
4711
4712 __ leave(); // required for proper stackwalking of RuntimeStub frame
4713 __ ret(0);
4714
4715 return start;
4716
4717 }
4718
4719 address generate_libmLog10() {
4720 address start = __ pc();
4721
4722 const XMMRegister x0 = xmm0;
4723 const XMMRegister x1 = xmm1;
4724 const XMMRegister x2 = xmm2;
4725 const XMMRegister x3 = xmm3;
4726
4727 const XMMRegister x4 = xmm4;
4728 const XMMRegister x5 = xmm5;
4729 const XMMRegister x6 = xmm6;
4730 const XMMRegister x7 = xmm7;
4731
4732 const Register tmp = r11;
4733
4734 BLOCK_COMMENT("Entry:");
4735 __ enter(); // required for proper stackwalking of RuntimeStub frame
4736
4737 #ifdef _WIN64
4738 // save the xmm registers which must be preserved 6-7
4739 __ subptr(rsp, 4 * wordSize);
4740 __ movdqu(Address(rsp, 0), xmm6);
4741 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4742 #endif
4743 __ fast_log10(x0, x1, x2, x3, x4, x5, x6, x7, rax, rcx, rdx, tmp);
4744
4745 #ifdef _WIN64
4746 // restore xmm regs belonging to calling function
4747 __ movdqu(xmm6, Address(rsp, 0));
4748 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4749 __ addptr(rsp, 4 * wordSize);
4750 #endif
4751
4752 __ leave(); // required for proper stackwalking of RuntimeStub frame
4753 __ ret(0);
4754
4755 return start;
4756
4757 }
4758
4759 address generate_libmPow() {
4760 address start = __ pc();
4761
4762 const XMMRegister x0 = xmm0;
4763 const XMMRegister x1 = xmm1;
4764 const XMMRegister x2 = xmm2;
4765 const XMMRegister x3 = xmm3;
4766
4767 const XMMRegister x4 = xmm4;
4768 const XMMRegister x5 = xmm5;
4769 const XMMRegister x6 = xmm6;
4770 const XMMRegister x7 = xmm7;
4771
4772 const Register tmp1 = r8;
4773 const Register tmp2 = r9;
4774 const Register tmp3 = r10;
4775 const Register tmp4 = r11;
4776
4777 BLOCK_COMMENT("Entry:");
4778 __ enter(); // required for proper stackwalking of RuntimeStub frame
4804
4805 const XMMRegister x0 = xmm0;
4806 const XMMRegister x1 = xmm1;
4807 const XMMRegister x2 = xmm2;
4808 const XMMRegister x3 = xmm3;
4809
4810 const XMMRegister x4 = xmm4;
4811 const XMMRegister x5 = xmm5;
4812 const XMMRegister x6 = xmm6;
4813 const XMMRegister x7 = xmm7;
4814
4815 const Register tmp1 = r8;
4816 const Register tmp2 = r9;
4817 const Register tmp3 = r10;
4818 const Register tmp4 = r11;
4819
4820 BLOCK_COMMENT("Entry:");
4821 __ enter(); // required for proper stackwalking of RuntimeStub frame
4822
4823 #ifdef _WIN64
4824 __ push(rsi);
4825 __ push(rdi);
4826 // save the xmm registers which must be preserved 6-7
4827 __ subptr(rsp, 4 * wordSize);
4828 __ movdqu(Address(rsp, 0), xmm6);
4829 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4830 #endif
4831 __ fast_sin(x0, x1, x2, x3, x4, x5, x6, x7, rax, rbx, rcx, rdx, tmp1, tmp2, tmp3, tmp4);
4832
4833 #ifdef _WIN64
4834 // restore xmm regs belonging to calling function
4835 __ movdqu(xmm6, Address(rsp, 0));
4836 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4837 __ addptr(rsp, 4 * wordSize);
4838 __ pop(rdi);
4839 __ pop(rsi);
4840 #endif
4841
4842 __ leave(); // required for proper stackwalking of RuntimeStub frame
4843 __ ret(0);
4844
4845 return start;
4846
4847 }
4848
4849 address generate_libmCos() {
4850 address start = __ pc();
4851
4852 const XMMRegister x0 = xmm0;
4853 const XMMRegister x1 = xmm1;
4854 const XMMRegister x2 = xmm2;
4855 const XMMRegister x3 = xmm3;
4856
4857 const XMMRegister x4 = xmm4;
4858 const XMMRegister x5 = xmm5;
4859 const XMMRegister x6 = xmm6;
4860 const XMMRegister x7 = xmm7;
4861
4862 const Register tmp1 = r8;
4863 const Register tmp2 = r9;
4864 const Register tmp3 = r10;
4865 const Register tmp4 = r11;
4866
4867 BLOCK_COMMENT("Entry:");
4868 __ enter(); // required for proper stackwalking of RuntimeStub frame
4869
4870 #ifdef _WIN64
4871 __ push(rsi);
4872 __ push(rdi);
4873 // save the xmm registers which must be preserved 6-7
4874 __ subptr(rsp, 4 * wordSize);
4875 __ movdqu(Address(rsp, 0), xmm6);
4876 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4877 #endif
4878 __ fast_cos(x0, x1, x2, x3, x4, x5, x6, x7, rax, rcx, rdx, tmp1, tmp2, tmp3, tmp4);
4879
4880 #ifdef _WIN64
4881 // restore xmm regs belonging to calling function
4882 __ movdqu(xmm6, Address(rsp, 0));
4883 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4884 __ addptr(rsp, 4 * wordSize);
4885 __ pop(rdi);
4886 __ pop(rsi);
4887 #endif
4888
4889 __ leave(); // required for proper stackwalking of RuntimeStub frame
4890 __ ret(0);
4891
4892 return start;
4893
4894 }
4895
4896 address generate_libmTan() {
4897 address start = __ pc();
4898
4899 const XMMRegister x0 = xmm0;
4900 const XMMRegister x1 = xmm1;
4901 const XMMRegister x2 = xmm2;
4902 const XMMRegister x3 = xmm3;
4903
4904 const XMMRegister x4 = xmm4;
4905 const XMMRegister x5 = xmm5;
4906 const XMMRegister x6 = xmm6;
4907 const XMMRegister x7 = xmm7;
4908
4909 const Register tmp1 = r8;
4910 const Register tmp2 = r9;
4911 const Register tmp3 = r10;
4912 const Register tmp4 = r11;
4913
4914 BLOCK_COMMENT("Entry:");
4915 __ enter(); // required for proper stackwalking of RuntimeStub frame
4916
4917 #ifdef _WIN64
4918 __ push(rsi);
4919 __ push(rdi);
4920 // save the xmm registers which must be preserved 6-7
4921 __ subptr(rsp, 4 * wordSize);
4922 __ movdqu(Address(rsp, 0), xmm6);
4923 __ movdqu(Address(rsp, 2 * wordSize), xmm7);
4924 #endif
4925 __ fast_tan(x0, x1, x2, x3, x4, x5, x6, x7, rax, rcx, rdx, tmp1, tmp2, tmp3, tmp4);
4926
4927 #ifdef _WIN64
4928 // restore xmm regs belonging to calling function
4929 __ movdqu(xmm6, Address(rsp, 0));
4930 __ movdqu(xmm7, Address(rsp, 2 * wordSize));
4931 __ addptr(rsp, 4 * wordSize);
4932 __ pop(rdi);
4933 __ pop(rsi);
4934 #endif
4935
4936 __ leave(); // required for proper stackwalking of RuntimeStub frame
4937 __ ret(0);
4938
4939 return start;
4940
4941 }
4942
4943 #undef __
4944 #define __ masm->
4945
4946 // Continuation point for throwing of implicit exceptions that are
4947 // not handled in the current activation. Fabricates an exception
4948 // oop and initiates normal exception dispatching in this
4949 // frame. Since we need to preserve callee-saved values (currently
4950 // only for C2, but done for C1 as well) we need a callee-saved oop
4951 // map and therefore have to make these stubs into RuntimeStubs
4952 // rather than BufferBlobs. If the compiler needs all registers to
4953 // be preserved between the fault point and the exception handler
5114 CAST_FROM_FN_PTR(address,
5115 SharedRuntime::
5116 throw_StackOverflowError));
5117 StubRoutines::_throw_delayed_StackOverflowError_entry =
5118 generate_throw_exception("delayed StackOverflowError throw_exception",
5119 CAST_FROM_FN_PTR(address,
5120 SharedRuntime::
5121 throw_delayed_StackOverflowError));
5122 if (UseCRC32Intrinsics) {
5123 // set table address before stub generation which use it
5124 StubRoutines::_crc_table_adr = (address)StubRoutines::x86::_crc_table;
5125 StubRoutines::_updateBytesCRC32 = generate_updateBytesCRC32();
5126 }
5127
5128 if (UseCRC32CIntrinsics) {
5129 bool supports_clmul = VM_Version::supports_clmul();
5130 StubRoutines::x86::generate_CRC32C_table(supports_clmul);
5131 StubRoutines::_crc32c_table_addr = (address)StubRoutines::x86::_crc32c_table;
5132 StubRoutines::_updateBytesCRC32C = generate_updateBytesCRC32C(supports_clmul);
5133 }
5134 if (VM_Version::supports_sse2() && UseLibmIntrinsic) {
5135 StubRoutines::x86::_ONEHALF_adr = (address)StubRoutines::x86::_ONEHALF;
5136 StubRoutines::x86::_P_2_adr = (address)StubRoutines::x86::_P_2;
5137 StubRoutines::x86::_SC_4_adr = (address)StubRoutines::x86::_SC_4;
5138 StubRoutines::x86::_Ctable_adr = (address)StubRoutines::x86::_Ctable;
5139 StubRoutines::x86::_SC_2_adr = (address)StubRoutines::x86::_SC_2;
5140 StubRoutines::x86::_SC_3_adr = (address)StubRoutines::x86::_SC_3;
5141 StubRoutines::x86::_SC_1_adr = (address)StubRoutines::x86::_SC_1;
5142 StubRoutines::x86::_PI_INV_TABLE_adr = (address)StubRoutines::x86::_PI_INV_TABLE;
5143 StubRoutines::x86::_PI_4_adr = (address)StubRoutines::x86::_PI_4;
5144 StubRoutines::x86::_PI32INV_adr = (address)StubRoutines::x86::_PI32INV;
5145 StubRoutines::x86::_SIGN_MASK_adr = (address)StubRoutines::x86::_SIGN_MASK;
5146 StubRoutines::x86::_P_1_adr = (address)StubRoutines::x86::_P_1;
5147 StubRoutines::x86::_P_3_adr = (address)StubRoutines::x86::_P_3;
5148 StubRoutines::x86::_NEG_ZERO_adr = (address)StubRoutines::x86::_NEG_ZERO;
5149 StubRoutines::_dexp = generate_libmExp();
5150 StubRoutines::_dlog = generate_libmLog();
5151 StubRoutines::_dlog10 = generate_libmLog10();
5152 StubRoutines::_dpow = generate_libmPow();
5153 StubRoutines::_dtan = generate_libmTan();
5154 StubRoutines::_dsin = generate_libmSin();
5155 StubRoutines::_dcos = generate_libmCos();
5156 }
5157 }
5158
5159 void generate_all() {
5160 // Generates all stubs and initializes the entry points
5161
5162 // These entry points require SharedInfo::stack0 to be set up in
5163 // non-core builds and need to be relocatable, so they each
5164 // fabricate a RuntimeStub internally.
5165 StubRoutines::_throw_AbstractMethodError_entry =
5166 generate_throw_exception("AbstractMethodError throw_exception",
5167 CAST_FROM_FN_PTR(address,
5168 SharedRuntime::
5169 throw_AbstractMethodError));
5170
5171 StubRoutines::_throw_IncompatibleClassChangeError_entry =
5172 generate_throw_exception("IncompatibleClassChangeError throw_exception",
5173 CAST_FROM_FN_PTR(address,
5174 SharedRuntime::
5175 throw_IncompatibleClassChangeError));
5176
5177 StubRoutines::_throw_NullPointerException_at_call_entry =
5179 CAST_FROM_FN_PTR(address,
5180 SharedRuntime::
5181 throw_NullPointerException_at_call));
5182
5183 // entry points that are platform specific
5184 StubRoutines::x86::_f2i_fixup = generate_f2i_fixup();
5185 StubRoutines::x86::_f2l_fixup = generate_f2l_fixup();
5186 StubRoutines::x86::_d2i_fixup = generate_d2i_fixup();
5187 StubRoutines::x86::_d2l_fixup = generate_d2l_fixup();
5188
5189 StubRoutines::x86::_float_sign_mask = generate_fp_mask("float_sign_mask", 0x7FFFFFFF7FFFFFFF);
5190 StubRoutines::x86::_float_sign_flip = generate_fp_mask("float_sign_flip", 0x8000000080000000);
5191 StubRoutines::x86::_double_sign_mask = generate_fp_mask("double_sign_mask", 0x7FFFFFFFFFFFFFFF);
5192 StubRoutines::x86::_double_sign_flip = generate_fp_mask("double_sign_flip", 0x8000000000000000);
5193
5194 // support for verify_oop (must happen after universe_init)
5195 StubRoutines::_verify_oop_subroutine_entry = generate_verify_oop();
5196
5197 // arraycopy stubs used by compilers
5198 generate_arraycopy_stubs();
5199
5200 // don't bother generating these AES intrinsic stubs unless global flag is set
5201 if (UseAESIntrinsics) {
5202 StubRoutines::x86::_key_shuffle_mask_addr = generate_key_shuffle_mask(); // needed by the others
5203 StubRoutines::_aescrypt_encryptBlock = generate_aescrypt_encryptBlock();
5204 StubRoutines::_aescrypt_decryptBlock = generate_aescrypt_decryptBlock();
5205 StubRoutines::_cipherBlockChaining_encryptAESCrypt = generate_cipherBlockChaining_encryptAESCrypt();
5206 StubRoutines::_cipherBlockChaining_decryptAESCrypt = generate_cipherBlockChaining_decryptAESCrypt_Parallel();
5207 }
5208 if (UseAESCTRIntrinsics){
5209 StubRoutines::x86::_counter_shuffle_mask_addr = generate_counter_shuffle_mask();
5210 StubRoutines::_counterMode_AESCrypt = generate_counterMode_AESCrypt_Parallel();
5211 }
5212
5213 if (UseSHA1Intrinsics) {
5214 StubRoutines::x86::_upper_word_mask_addr = generate_upper_word_mask();
5215 StubRoutines::x86::_shuffle_byte_flip_mask_addr = generate_shuffle_byte_flip_mask();
5216 StubRoutines::_sha1_implCompress = generate_sha1_implCompress(false, "sha1_implCompress");
5217 StubRoutines::_sha1_implCompressMB = generate_sha1_implCompress(true, "sha1_implCompressMB");
5218 }
|