|
1 /* |
|
2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. |
|
8 * |
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
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 "interpreter/interpreter.hpp" |
|
28 #include "interpreter/interpreterGenerator.hpp" |
|
29 #include "runtime/arguments.hpp" |
|
30 |
|
31 #define __ _masm-> |
|
32 |
|
33 #ifndef CC_INTERP |
|
34 |
|
35 /** |
|
36 * Method entry for static native methods: |
|
37 * int java.util.zip.CRC32.update(int crc, int b) |
|
38 */ |
|
39 address InterpreterGenerator::generate_CRC32_update_entry() { |
|
40 if (UseCRC32Intrinsics) { |
|
41 address entry = __ pc(); |
|
42 |
|
43 // rbx,: Method* |
|
44 // r13: senderSP must preserved for slow path, set SP to it on fast path |
|
45 // c_rarg0: scratch (rdi on non-Win64, rcx on Win64) |
|
46 // c_rarg1: scratch (rsi on non-Win64, rdx on Win64) |
|
47 |
|
48 Label slow_path; |
|
49 // If we need a safepoint check, generate full interpreter entry. |
|
50 ExternalAddress state(SafepointSynchronize::address_of_state()); |
|
51 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), |
|
52 SafepointSynchronize::_not_synchronized); |
|
53 __ jcc(Assembler::notEqual, slow_path); |
|
54 |
|
55 // We don't generate local frame and don't align stack because |
|
56 // we call stub code and there is no safepoint on this path. |
|
57 |
|
58 // Load parameters |
|
59 const Register crc = rax; // crc |
|
60 const Register val = c_rarg0; // source java byte value |
|
61 const Register tbl = c_rarg1; // scratch |
|
62 |
|
63 // Arguments are reversed on java expression stack |
|
64 __ movl(val, Address(rsp, wordSize)); // byte value |
|
65 __ movl(crc, Address(rsp, 2*wordSize)); // Initial CRC |
|
66 |
|
67 __ lea(tbl, ExternalAddress(StubRoutines::crc_table_addr())); |
|
68 __ notl(crc); // ~crc |
|
69 __ update_byte_crc32(crc, val, tbl); |
|
70 __ notl(crc); // ~crc |
|
71 // result in rax |
|
72 |
|
73 // _areturn |
|
74 __ pop(rdi); // get return address |
|
75 __ mov(rsp, r13); // set sp to sender sp |
|
76 __ jmp(rdi); |
|
77 |
|
78 // generate a vanilla native entry as the slow path |
|
79 __ bind(slow_path); |
|
80 __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native)); |
|
81 return entry; |
|
82 } |
|
83 return NULL; |
|
84 } |
|
85 |
|
86 /** |
|
87 * Method entry for static native methods: |
|
88 * int java.util.zip.CRC32.updateBytes(int crc, byte[] b, int off, int len) |
|
89 * int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len) |
|
90 */ |
|
91 address InterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) { |
|
92 if (UseCRC32Intrinsics) { |
|
93 address entry = __ pc(); |
|
94 |
|
95 // rbx,: Method* |
|
96 // r13: senderSP must preserved for slow path, set SP to it on fast path |
|
97 |
|
98 Label slow_path; |
|
99 // If we need a safepoint check, generate full interpreter entry. |
|
100 ExternalAddress state(SafepointSynchronize::address_of_state()); |
|
101 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), |
|
102 SafepointSynchronize::_not_synchronized); |
|
103 __ jcc(Assembler::notEqual, slow_path); |
|
104 |
|
105 // We don't generate local frame and don't align stack because |
|
106 // we call stub code and there is no safepoint on this path. |
|
107 |
|
108 // Load parameters |
|
109 const Register crc = c_rarg0; // crc |
|
110 const Register buf = c_rarg1; // source java byte array address |
|
111 const Register len = c_rarg2; // length |
|
112 const Register off = len; // offset (never overlaps with 'len') |
|
113 |
|
114 // Arguments are reversed on java expression stack |
|
115 // Calculate address of start element |
|
116 if (kind == Interpreter::java_util_zip_CRC32_updateByteBuffer) { |
|
117 __ movptr(buf, Address(rsp, 3*wordSize)); // long buf |
|
118 __ movl2ptr(off, Address(rsp, 2*wordSize)); // offset |
|
119 __ addq(buf, off); // + offset |
|
120 __ movl(crc, Address(rsp, 5*wordSize)); // Initial CRC |
|
121 } else { |
|
122 __ movptr(buf, Address(rsp, 3*wordSize)); // byte[] array |
|
123 __ addptr(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE)); // + header size |
|
124 __ movl2ptr(off, Address(rsp, 2*wordSize)); // offset |
|
125 __ addq(buf, off); // + offset |
|
126 __ movl(crc, Address(rsp, 4*wordSize)); // Initial CRC |
|
127 } |
|
128 // Can now load 'len' since we're finished with 'off' |
|
129 __ movl(len, Address(rsp, wordSize)); // Length |
|
130 |
|
131 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, StubRoutines::updateBytesCRC32()), crc, buf, len); |
|
132 // result in rax |
|
133 |
|
134 // _areturn |
|
135 __ pop(rdi); // get return address |
|
136 __ mov(rsp, r13); // set sp to sender sp |
|
137 __ jmp(rdi); |
|
138 |
|
139 // generate a vanilla native entry as the slow path |
|
140 __ bind(slow_path); |
|
141 __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native)); |
|
142 return entry; |
|
143 } |
|
144 return NULL; |
|
145 } |
|
146 |
|
147 /** |
|
148 * Method entry for static native methods: |
|
149 * int java.util.zip.CRC32C.updateBytes(int crc, byte[] b, int off, int end) |
|
150 * int java.util.zip.CRC32C.updateByteBuffer(int crc, long address, int off, int end) |
|
151 */ |
|
152 address InterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) { |
|
153 if (UseCRC32CIntrinsics) { |
|
154 address entry = __ pc(); |
|
155 // Load parameters |
|
156 const Register crc = c_rarg0; // crc |
|
157 const Register buf = c_rarg1; // source java byte array address |
|
158 const Register len = c_rarg2; |
|
159 const Register off = c_rarg3; // offset |
|
160 const Register end = len; |
|
161 |
|
162 // Arguments are reversed on java expression stack |
|
163 // Calculate address of start element |
|
164 if (kind == Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer) { |
|
165 __ movptr(buf, Address(rsp, 3 * wordSize)); // long buf |
|
166 __ movl2ptr(off, Address(rsp, 2 * wordSize)); // offset |
|
167 __ addq(buf, off); // + offset |
|
168 __ movl(crc, Address(rsp, 5 * wordSize)); // Initial CRC |
|
169 // Note on 5 * wordSize vs. 4 * wordSize: |
|
170 // * int java.util.zip.CRC32C.updateByteBuffer(int crc, long address, int off, int end) |
|
171 // 4 2,3 1 0 |
|
172 // end starts at SP + 8 |
|
173 // The Java(R) Virtual Machine Specification Java SE 7 Edition |
|
174 // 4.10.2.3. Values of Types long and double |
|
175 // "When calculating operand stack length, values of type long and double have length two." |
|
176 } else { |
|
177 __ movptr(buf, Address(rsp, 3 * wordSize)); // byte[] array |
|
178 __ addptr(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE)); // + header size |
|
179 __ movl2ptr(off, Address(rsp, 2 * wordSize)); // offset |
|
180 __ addq(buf, off); // + offset |
|
181 __ movl(crc, Address(rsp, 4 * wordSize)); // Initial CRC |
|
182 } |
|
183 __ movl(end, Address(rsp, wordSize)); // end |
|
184 __ subl(end, off); // end - off |
|
185 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, StubRoutines::updateBytesCRC32C()), crc, buf, len); |
|
186 // result in rax |
|
187 // _areturn |
|
188 __ pop(rdi); // get return address |
|
189 __ mov(rsp, r13); // set sp to sender sp |
|
190 __ jmp(rdi); |
|
191 |
|
192 return entry; |
|
193 } |
|
194 |
|
195 return NULL; |
|
196 } |
|
197 #endif // ! CC_INTERP |