Cross Reference: /openjdk7/jdk/src/share/classes/sun/security/provider/ByteArrayAccess.java

Lines Matching defs:in
9  * by Oracle in the LICENSE file that accompanied this code.
11  * This code is distributed in the hope that it will be useful, but WITHOUT
14  * version 2 for more details (a copy is included in the LICENSE file that
49  * checks before calling methods in this class.
51  * This class may also be helpful in improving the performance of the
52  * crypto code in the SunJCE provider. However, for now it is only accessible by
53  * the message digest implementation in the SUN provider.
105     static void b2iLittle(byte[] in, int inOfs, int[] out, int outOfs, int len) {
110                 out[outOfs++] = unsafe.getInt(in, (long)inOfs);
117                 out[outOfs++] = reverseBytes(unsafe.getInt(in, (long)inOfs));
123                 out[outOfs++] = ((in[inOfs    ] & 0xff)      )
124                               | ((in[inOfs + 1] & 0xff) <<  8)
125                               | ((in[inOfs + 2] & 0xff) << 16)
126                               | ((in[inOfs + 3]       ) << 24);
132     // Special optimization of b2iLittle(in, inOfs, out, 0, 64)
133     static void b2iLittle64(byte[] in, int inOfs, int[] out) {
136             out[ 0] = unsafe.getInt(in, (long)(inOfs     ));
137             out[ 1] = unsafe.getInt(in, (long)(inOfs +  4));
138             out[ 2] = unsafe.getInt(in, (long)(inOfs +  8));
139             out[ 3] = unsafe.getInt(in, (long)(inOfs + 12));
140             out[ 4] = unsafe.getInt(in, (long)(inOfs + 16));
141             out[ 5] = unsafe.getInt(in, (long)(inOfs + 20));
142             out[ 6] = unsafe.getInt(in, (long)(inOfs + 24));
143             out[ 7] = unsafe.getInt(in, (long)(inOfs + 28));
144             out[ 8] = unsafe.getInt(in, (long)(inOfs + 32));
145             out[ 9] = unsafe.getInt(in, (long)(inOfs + 36));
146             out[10] = unsafe.getInt(in, (long)(inOfs + 40));
147             out[11] = unsafe.getInt(in, (long)(inOfs + 44));
148             out[12] = unsafe.getInt(in, (long)(inOfs + 48));
149             out[13] = unsafe.getInt(in, (long)(inOfs + 52));
150             out[14] = unsafe.getInt(in, (long)(inOfs + 56));
151             out[15] = unsafe.getInt(in, (long)(inOfs + 60));
154             out[ 0] = reverseBytes(unsafe.getInt(in, (long)(inOfs     )));
155             out[ 1] = reverseBytes(unsafe.getInt(in, (long)(inOfs +  4)));
156             out[ 2] = reverseBytes(unsafe.getInt(in, (long)(inOfs +  8)));
157             out[ 3] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 12)));
158             out[ 4] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 16)));
159             out[ 5] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 20)));
160             out[ 6] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 24)));
161             out[ 7] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 28)));
162             out[ 8] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 32)));
163             out[ 9] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 36)));
164             out[10] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 40)));
165             out[11] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 44)));
166             out[12] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 48)));
167             out[13] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 52)));
168             out[14] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 56)));
169             out[15] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 60)));
171             b2iLittle(in, inOfs, out, 0, 64);
178     static void i2bLittle(int[] in, int inOfs, byte[] out, int outOfs, int len) {
183                 unsafe.putInt(out, (long)outOfs, in[inOfs++]);
190                 unsafe.putInt(out, (long)outOfs, reverseBytes(in[inOfs++]));
196                 int i = in[inOfs++];
205     // Store one 32-bit value into out[outOfs..outOfs+3] in little endian order.
222     static void b2iBig(byte[] in, int inOfs, int[] out, int outOfs, int len) {
227                 out[outOfs++] = reverseBytes(unsafe.getInt(in, (long)inOfs));
234                 out[outOfs++] = unsafe.getInt(in, (long)inOfs);
240                 out[outOfs++] = ((in[inOfs + 3] & 0xff)      )
241                               | ((in[inOfs + 2] & 0xff) <<  8)
242                               | ((in[inOfs + 1] & 0xff) << 16)
243                               | ((in[inOfs    ]       ) << 24);
249     // Special optimization of b2iBig(in, inOfs, out, 0, 64)
250     static void b2iBig64(byte[] in, int inOfs, int[] out) {
253             out[ 0] = reverseBytes(unsafe.getInt(in, (long)(inOfs     )));
254             out[ 1] = reverseBytes(unsafe.getInt(in, (long)(inOfs +  4)));
255             out[ 2] = reverseBytes(unsafe.getInt(in, (long)(inOfs +  8)));
256             out[ 3] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 12)));
257             out[ 4] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 16)));
258             out[ 5] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 20)));
259             out[ 6] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 24)));
260             out[ 7] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 28)));
261             out[ 8] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 32)));
262             out[ 9] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 36)));
263             out[10] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 40)));
264             out[11] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 44)));
265             out[12] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 48)));
266             out[13] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 52)));
267             out[14] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 56)));
268             out[15] = reverseBytes(unsafe.getInt(in, (long)(inOfs + 60)));
271             out[ 0] = unsafe.getInt(in, (long)(inOfs     ));
272             out[ 1] = unsafe.getInt(in, (long)(inOfs +  4));
273             out[ 2] = unsafe.getInt(in, (long)(inOfs +  8));
274             out[ 3] = unsafe.getInt(in, (long)(inOfs + 12));
275             out[ 4] = unsafe.getInt(in, (long)(inOfs + 16));
276             out[ 5] = unsafe.getInt(in, (long)(inOfs + 20));
277             out[ 6] = unsafe.getInt(in, (long)(inOfs + 24));
278             out[ 7] = unsafe.getInt(in, (long)(inOfs + 28));
279             out[ 8] = unsafe.getInt(in, (long)(inOfs + 32));
280             out[ 9] = unsafe.getInt(in, (long)(inOfs + 36));
281             out[10] = unsafe.getInt(in, (long)(inOfs + 40));
282             out[11] = unsafe.getInt(in, (long)(inOfs + 44));
283             out[12] = unsafe.getInt(in, (long)(inOfs + 48));
284             out[13] = unsafe.getInt(in, (long)(inOfs + 52));
285             out[14] = unsafe.getInt(in, (long)(inOfs + 56));
286             out[15] = unsafe.getInt(in, (long)(inOfs + 60));
288             b2iBig(in, inOfs, out, 0, 64);
295     static void i2bBig(int[] in, int inOfs, byte[] out, int outOfs, int len) {
300                 unsafe.putInt(out, (long)outOfs, reverseBytes(in[inOfs++]));
307                 unsafe.putInt(out, (long)outOfs, in[inOfs++]);
313                 int i = in[inOfs++];
322     // Store one 32-bit value into out[outOfs..outOfs+3] in big endian order.
339     static void b2lBig(byte[] in, int inOfs, long[] out, int outOfs, int len) {
344                 out[outOfs++] = reverseBytes(unsafe.getLong(in, (long)inOfs));
351             // which would rarely occur in practice. Instead, we use an
357                       ((long)unsafe.getInt(in, (long)inOfs) << 32)
358                           | (unsafe.getInt(in, (long)(inOfs + 4)) & 0xffffffffL);
364                 int i1 = ((in[inOfs + 3] & 0xff)      )
365                        | ((in[inOfs + 2] & 0xff) <<  8)
366                        | ((in[inOfs + 1] & 0xff) << 16)
367                        | ((in[inOfs    ]       ) << 24);
369                 int i2 = ((in[inOfs + 3] & 0xff)      )
370                        | ((in[inOfs + 2] & 0xff) <<  8)
371                        | ((in[inOfs + 1] & 0xff) << 16)
372                        | ((in[inOfs    ]       ) << 24);
379     // Special optimization of b2lBig(in, inOfs, out, 0, 128)
380     static void b2lBig128(byte[] in, int inOfs, long[] out) {
383             out[ 0] = reverseBytes(unsafe.getLong(in, (long)(inOfs      )));
384             out[ 1] = reverseBytes(unsafe.getLong(in, (long)(inOfs +   8)));
385             out[ 2] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  16)));
386             out[ 3] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  24)));
387             out[ 4] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  32)));
388             out[ 5] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  40)));
389             out[ 6] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  48)));
390             out[ 7] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  56)));
391             out[ 8] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  64)));
392             out[ 9] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  72)));
393             out[10] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  80)));
394             out[11] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  88)));
395             out[12] = reverseBytes(unsafe.getLong(in, (long)(inOfs +  96)));
396             out[13] = reverseBytes(unsafe.getLong(in, (long)(inOfs + 104)));
397             out[14] = reverseBytes(unsafe.getLong(in, (long)(inOfs + 112)));
398             out[15] = reverseBytes(unsafe.getLong(in, (long)(inOfs + 120)));
400             // no optimization for big endian, see comments in b2lBig
401             b2lBig(in, inOfs, out, 0, 128);
408     static void l2bBig(long[] in, int inOfs, byte[] out, int outOfs, int len) {
411             long i = in[inOfs++];