1 /*

     2  * Copyright (c) 2002, 2010, 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.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 /*

    27  */

    28 

    29 #include "jni.h"

    30 #include "jni_util.h"

    31 #include "jlong.h"

    32 #include <string.h>

    33 

    34 #define MBYTE 1048576

    35 

    36 #define GETCRITICAL_OR_RETURN(bytes, env, obj) { \

    37     bytes = (*env)->GetPrimitiveArrayCritical(env, obj, NULL); \

    38     if (bytes == NULL)  { \

    39         if ((*env)->ExceptionOccurred(env) == NULL) \

    40             JNU_ThrowInternalError(env, "Unable to get array"); \

    41         return; \

    42     } \

    43 }

    44 

    45 #define RELEASECRITICAL(bytes, env, obj, mode) { \

    46     (*env)->ReleasePrimitiveArrayCritical(env, obj, bytes, mode); \

    47 }

    48 

    49 #define SWAPSHORT(x) ((jshort)(((x) << 8) | (((x) >> 8) & 0xff)))

    50 #define SWAPINT(x)   ((jint)((SWAPSHORT((jshort)(x)) << 16) | \

    51                             (SWAPSHORT((jshort)((x) >> 16)) & 0xffff)))

    52 #define SWAPLONG(x)  ((jlong)(((jlong)SWAPINT((jint)(x)) << 32) | \

    53                               ((jlong)SWAPINT((jint)((x) >> 32)) & 0xffffffff)))

    54 

    55 JNIEXPORT void JNICALL

    56 Java_java_nio_Bits_copyFromShortArray(JNIEnv *env, jclass clazz, jobject src,

    57                                       jlong srcPos, jlong dstAddr, jlong length)

    58 {

    59     jbyte *bytes;

    60     size_t size;

    61     jshort *srcShort, *dstShort, *endShort;

    62     jshort tmpShort;

    63 

    64     dstShort = (jshort *)jlong_to_ptr(dstAddr);

    65 

    66     while (length > 0) {

    67         size = (length < MBYTE) ? (size_t)length : (size_t)MBYTE;

    68 

    69         GETCRITICAL_OR_RETURN(bytes, env, src);

    70 

    71         srcShort = (jshort *)(bytes + srcPos);

    72         endShort = srcShort + (size / sizeof(jshort));

    73         while (srcShort < endShort) {

    74           tmpShort = *srcShort++;

    75           *dstShort++ = SWAPSHORT(tmpShort);

    76         }

    77 

    78         RELEASECRITICAL(bytes, env, src, JNI_ABORT);

    79 

    80         length -= size;

    81         srcPos += size;

    82     }

    83 }

    84 

    85 JNIEXPORT void JNICALL

    86 Java_java_nio_Bits_copyToShortArray(JNIEnv *env, jclass clazz, jlong srcAddr,

    87                                     jobject dst, jlong dstPos, jlong length)

    88 {

    89     jbyte *bytes;

    90     size_t size;

    91     jshort *srcShort, *dstShort, *endShort;

    92     jshort tmpShort;

    93 

    94     srcShort = (jshort *)jlong_to_ptr(srcAddr);

    95 

    96     while (length > 0) {

    97         size = (length < MBYTE) ? (size_t)length : (size_t)MBYTE;

    98 

    99         GETCRITICAL_OR_RETURN(bytes, env, dst);

   100 

   101         dstShort = (jshort *)(bytes + dstPos);

   102         endShort = srcShort + (size / sizeof(jshort));

   103         while (srcShort < endShort) {

   104             tmpShort = *srcShort++;

   105             *dstShort++ = SWAPSHORT(tmpShort);

   106         }

   107 

   108         RELEASECRITICAL(bytes, env, dst, 0);

   109 

   110         length -= size;

   111         dstPos += size;

   112     }

   113 }

   114 

   115 JNIEXPORT void JNICALL

   116 Java_java_nio_Bits_copyFromIntArray(JNIEnv *env, jclass clazz, jobject src,

   117                                     jlong srcPos, jlong dstAddr, jlong length)

   118 {

   119     jbyte *bytes;

   120     size_t size;

   121     jint *srcInt, *dstInt, *endInt;

   122     jint tmpInt;

   123 

   124     dstInt = (jint *)jlong_to_ptr(dstAddr);

   125 

   126     while (length > 0) {

   127         size = (length < MBYTE) ? (size_t)length : (size_t)MBYTE;

   128 

   129         GETCRITICAL_OR_RETURN(bytes, env, src);

   130 

   131         srcInt = (jint *)(bytes + srcPos);

   132         endInt = srcInt + (size / sizeof(jint));

   133         while (srcInt < endInt) {

   134             tmpInt = *srcInt++;

   135             *dstInt++ = SWAPINT(tmpInt);

   136         }

   137 

   138         RELEASECRITICAL(bytes, env, src, JNI_ABORT);

   139 

   140         length -= size;

   141         srcPos += size;

   142     }

   143 }

   144 

   145 JNIEXPORT void JNICALL

   146 Java_java_nio_Bits_copyToIntArray(JNIEnv *env, jclass clazz, jlong srcAddr,

   147                                   jobject dst, jlong dstPos, jlong length)

   148 {

   149     jbyte *bytes;

   150     size_t size;

   151     jint *srcInt, *dstInt, *endInt;

   152     jint tmpInt;

   153 

   154     srcInt = (jint *)jlong_to_ptr(srcAddr);

   155 

   156     while (length > 0) {

   157         size = (length < MBYTE) ? (size_t)length : (size_t)MBYTE;

   158 

   159         GETCRITICAL_OR_RETURN(bytes, env, dst);

   160 

   161         dstInt = (jint *)(bytes + dstPos);

   162         endInt = srcInt + (size / sizeof(jint));

   163         while (srcInt < endInt) {

   164             tmpInt = *srcInt++;

   165             *dstInt++ = SWAPINT(tmpInt);

   166         }

   167 

   168         RELEASECRITICAL(bytes, env, dst, 0);

   169 

   170         length -= size;

   171         dstPos += size;

   172     }

   173 }

   174 

   175 JNIEXPORT void JNICALL

   176 Java_java_nio_Bits_copyFromLongArray(JNIEnv *env, jclass clazz, jobject src,

   177                                      jlong srcPos, jlong dstAddr, jlong length)

   178 {

   179     jbyte *bytes;

   180     size_t size;

   181     jlong *srcLong, *dstLong, *endLong;

   182     jlong tmpLong;

   183 

   184     dstLong = (jlong *)jlong_to_ptr(dstAddr);

   185 

   186     while (length > 0) {

   187         size = (length < MBYTE) ? (size_t)length : (size_t)MBYTE;

   188 

   189         GETCRITICAL_OR_RETURN(bytes, env, src);

   190 

   191         srcLong = (jlong *)(bytes + srcPos);

   192         endLong = srcLong + (size / sizeof(jlong));

   193         while (srcLong < endLong) {

   194             tmpLong = *srcLong++;

   195             *dstLong++ = SWAPLONG(tmpLong);

   196         }

   197 

   198         RELEASECRITICAL(bytes, env, src, JNI_ABORT);

   199 

   200         length -= size;

   201         srcPos += size;

   202     }

   203 }

   204 

   205 JNIEXPORT void JNICALL

   206 Java_java_nio_Bits_copyToLongArray(JNIEnv *env, jclass clazz, jlong srcAddr,

   207                                    jobject dst, jlong dstPos, jlong length)

   208 {

   209     jbyte *bytes;

   210     size_t size;

   211     jlong *srcLong, *dstLong, *endLong;

   212     jlong tmpLong;

   213 

   214     srcLong = (jlong *)jlong_to_ptr(srcAddr);

   215 

   216     while (length > 0) {

   217         size = (length < MBYTE) ? (size_t)length : (size_t)MBYTE;

   218 

   219         GETCRITICAL_OR_RETURN(bytes, env, dst);

   220 

   221         dstLong = (jlong *)(bytes + dstPos);

   222         endLong = srcLong + (size / sizeof(jlong));

   223         while (srcLong < endLong) {

   224             tmpLong = *srcLong++;

   225             *dstLong++ = SWAPLONG(tmpLong);

   226         }

   227 

   228         RELEASECRITICAL(bytes, env, dst, 0);

   229 

   230         length -= size;

   231         dstPos += size;

   232     }

   233 }