commit f4917d435a8086f13525d29b14f52d1e5b45093e Author: lax1dude Date: Wed Apr 10 19:57:21 2024 -0700 upload source diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..5dd8ade --- /dev/null +++ b/LICENSE @@ -0,0 +1,24 @@ + +Copyright (c) 2024 lax1dude + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..6c84d07 --- /dev/null +++ b/README.md @@ -0,0 +1,7 @@ +### Unsafe Memcpy for Java + +Fast JNI library to copy arbitrary data from native code into and out of primitive arrays in Java. + +You probably don't need this. + +Compiling instructions coming later. \ No newline at end of file diff --git a/UnsafeMemcpy.dll b/UnsafeMemcpy.dll new file mode 100644 index 0000000..0746243 Binary files /dev/null and b/UnsafeMemcpy.dll differ diff --git a/UnsafeMemcpy.jar b/UnsafeMemcpy.jar new file mode 100644 index 0000000..9298c39 Binary files /dev/null and b/UnsafeMemcpy.jar differ diff --git a/java/net/lax1dude/unsafememcpy/UnsafeMalloc.java b/java/net/lax1dude/unsafememcpy/UnsafeMalloc.java new file mode 100644 index 0000000..d39f523 --- /dev/null +++ b/java/net/lax1dude/unsafememcpy/UnsafeMalloc.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package net.lax1dude.unsafememcpy; + +import java.nio.Buffer; +import java.nio.ByteBuffer; + +public class UnsafeMalloc { + + static { + UnsafeUtils.loadNatives(); + } + + public static native long malloc(int size); + + public static native long malloc(long size); + + public static native long calloc(int num, int size); + + public static native long calloc(long num, long size); + + public static native long realloc(long oldPtr, int size); + + public static native long realloc(long oldPtr, long size); + + public static native void free(long ptr); + + public static native ByteBuffer mallocBuffer(int size); + + public static native ByteBuffer mallocBuffer(long size); + + public static native ByteBuffer callocBuffer(int num, int size); + + public static native ByteBuffer callocBuffer(long num, long size); + + public static native ByteBuffer reallocBuffer(long oldPtr, int size); + + public static native ByteBuffer reallocBuffer(long oldPtr, long size); + + public static native ByteBuffer reallocBuffer(Buffer oldBuffer, int size); + + public static native ByteBuffer reallocBuffer(Buffer oldBuffer, long size); + + public static native void freeBuffer(Buffer buffer); + +} diff --git a/java/net/lax1dude/unsafememcpy/UnsafeMemcpy.java b/java/net/lax1dude/unsafememcpy/UnsafeMemcpy.java new file mode 100644 index 0000000..a3bed39 --- /dev/null +++ b/java/net/lax1dude/unsafememcpy/UnsafeMemcpy.java @@ -0,0 +1,361 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package net.lax1dude.unsafememcpy; + +import java.nio.Buffer; + +public class UnsafeMemcpy { + + static { + UnsafeUtils.loadNatives(); + } + + public static native void memcpy(long dstAddress, long srcAddress, int byteLength); + + public static native void memcpy(long dstAddress, long srcAddress, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, long srcAddress, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, long srcAddress, long byteLength); + + public static native void memcpy(long dstAddress, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, Buffer srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, Buffer srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long dstAddress, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, byte[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, byte[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long dstAddress, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, short[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, short[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long dstAddress, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, char[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, char[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long dstAddress, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, int[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, int[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long dstAddress, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, long[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, long[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long dstAddress, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, double[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, double[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long dstAddress, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long dstAddress, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(Buffer dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(Buffer dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(byte[] dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(byte[] dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(short[] dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(short[] dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(char[] dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(char[] dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(int[] dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(int[] dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(long[] dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(long[] dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(double[] dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(double[] dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + + public static native void memcpy(float[] dstAddress, int dstOffset, float[] srcAddress, int srcOffset, int byteLength); + + public static native void memcpy(float[] dstAddress, long dstOffset, float[] srcAddress, long srcOffset, long byteLength); + +} diff --git a/java/net/lax1dude/unsafememcpy/UnsafeMemset.java b/java/net/lax1dude/unsafememcpy/UnsafeMemset.java new file mode 100644 index 0000000..0a8026c --- /dev/null +++ b/java/net/lax1dude/unsafememcpy/UnsafeMemset.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package net.lax1dude.unsafememcpy; + +import java.nio.Buffer; + +public class UnsafeMemset { + + static { + UnsafeUtils.loadNatives(); + } + + public static native void memset(long address, int value, int byteLength); + + public static native void memset(long address, int value, long byteLength); + + public static native void memset(Buffer address, int offset, int value, int byteLength); + + public static native void memset(Buffer address, long offset, int value, long byteLength); + + public static native void memset(byte[] address, int offset, int value, int byteLength); + + public static native void memset(byte[] address, long offset, int value, long byteLength); + + public static native void memset(short[] address, int offset, int value, int byteLength); + + public static native void memset(short[] address, long offset, int value, long byteLength); + + public static native void memset(char[] address, int offset, int value, int byteLength); + + public static native void memset(char[] address, long offset, int value, long byteLength); + + public static native void memset(int[] address, int offset, int value, int byteLength); + + public static native void memset(int[] address, long offset, int value, long byteLength); + + public static native void memset(long[] address, int offset, int value, int byteLength); + + public static native void memset(long[] address, long offset, int value, long byteLength); + + public static native void memset(double[] address, int offset, int value, int byteLength); + + public static native void memset(double[] address, long offset, int value, long byteLength); + + public static native void memset(float[] address, int offset, int value, int byteLength); + + public static native void memset(float[] address, long offset, int value, long byteLength); + +} diff --git a/java/net/lax1dude/unsafememcpy/UnsafeUtils.java b/java/net/lax1dude/unsafememcpy/UnsafeUtils.java new file mode 100644 index 0000000..df366e0 --- /dev/null +++ b/java/net/lax1dude/unsafememcpy/UnsafeUtils.java @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package net.lax1dude.unsafememcpy; + +import java.nio.Buffer; +import java.nio.ByteBuffer; + +public class UnsafeUtils { + + private static boolean hasLoadedNatives = false; + + static { + loadNatives(); + } + + public static void loadNatives() { + if(!hasLoadedNatives) { + hasLoadedNatives = true; + System.loadLibrary("UnsafeMemcpy"); + } + } + + public static native int getVersionMajor(); + + public static native int getVersionMinor(); + + public static native ByteBuffer makeDirectBuffer(long address, int size); + + public static native ByteBuffer makeDirectBuffer(long address, long size); + + public static native long getAddress(Buffer buffer); + + public static native byte getMemByte(long address); + + public static native short getMemShort(long address); + + public static native char getMemChar(long address); + + public static native int getMemInt(long address); + + public static native long getMemLong(long address); + + public static native double getMemDouble(long address); + + public static native float getMemFloat(long address); + + public static native void setMemByte(long address, byte value); + + public static native void setMemShort(long address, short value); + + public static native void setMemChar(long address, char value); + + public static native void setMemInt(long address, int value); + + public static native void setMemLong(long address, long value); + + public static native void setMemDouble(long address, double value); + + public static native void setMemFloat(long address, float value); + +} diff --git a/native/UnsafeMalloc.c b/native/UnsafeMalloc.c new file mode 100644 index 0000000..745397f --- /dev/null +++ b/native/UnsafeMalloc.c @@ -0,0 +1,234 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "UnsafeMallocImpl.h" + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: malloc + * Signature: (I)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_malloc__I + (JNIEnv * jniHandle, jclass jniClass, jint size) { + return (jlong)UNSAFE_MALLOC_IMPL(size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: malloc + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_malloc__J + (JNIEnv * jniHandle, jclass jniClass, jlong size) { + return (jlong)UNSAFE_MALLOC_IMPL(size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: calloc + * Signature: (II)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_calloc__II + (JNIEnv * jniHandle, jclass jniClass, jint num, jint size) { + return (jlong)UNSAFE_CALLOC_IMPL(num, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: calloc + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_calloc__JJ + (JNIEnv * jniHandle, jclass jniClass, jlong num, jlong size) { + return (jlong)UNSAFE_CALLOC_IMPL(num, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: realloc + * Signature: (JI)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_realloc__JI + (JNIEnv * jniHandle, jclass jniClass, jlong address, jint size) { + return (jlong)UNSAFE_REALLOC_IMPL(address, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: realloc + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_realloc__JJ + (JNIEnv * jniHandle, jclass jniClass, jlong address, jlong size) { + return (jlong)UNSAFE_REALLOC_IMPL(address, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: free + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_free + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + UNSAFE_FREE_IMPL(address); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: mallocBuffer + * Signature: (I)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_mallocBuffer__I + (JNIEnv * jniHandle, jclass jniClass, jint size) { + void* ret = UNSAFE_MALLOC_IMPL(size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: mallocBuffer + * Signature: (J)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_mallocBuffer__J + (JNIEnv * jniHandle, jclass jniClass, jlong size) { + void* ret = UNSAFE_MALLOC_IMPL(size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: callocBuffer + * Signature: (II)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_callocBuffer__II + (JNIEnv * jniHandle, jclass jniClass, jint num, jint size) { + void* ret = UNSAFE_CALLOC_IMPL(num, size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, num * size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: callocBuffer + * Signature: (JJ)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_callocBuffer__JJ + (JNIEnv * jniHandle, jclass jniClass, jlong num, jlong size) { + void* ret = UNSAFE_CALLOC_IMPL(num, size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, num * size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: reallocBuffer + * Signature: (JI)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_reallocBuffer__JI + (JNIEnv * jniHandle, jclass jniClass, jlong address, jint size) { + void* ret = UNSAFE_REALLOC_IMPL(address, size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: reallocBuffer + * Signature: (JJ)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_reallocBuffer__JJ + (JNIEnv * jniHandle, jclass jniClass, jlong address, jlong size) { + void* ret = UNSAFE_REALLOC_IMPL(address, size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: reallocBuffer + * Signature: (Ljava/nio/Buffer;I)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_reallocBuffer__Ljava_nio_Buffer_2I + (JNIEnv * jniHandle, jclass jniClass, jobject buffer, jint size) { + void* srcBuffer = (*jniHandle)->GetDirectBufferAddress(jniHandle, buffer); + if(srcBuffer == NULL) { + unsafeThrowNotDirectBuffer(jniHandle); + return NULL; + } + void* ret = UNSAFE_REALLOC_IMPL(srcBuffer, size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: reallocBuffer + * Signature: (Ljava/nio/Buffer;J)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_reallocBuffer__Ljava_nio_Buffer_2J + (JNIEnv * jniHandle, jclass jniClass, jobject buffer, jlong size) { + void* srcBuffer = (*jniHandle)->GetDirectBufferAddress(jniHandle, buffer); + if(srcBuffer == NULL) { + unsafeThrowNotDirectBuffer(jniHandle); + return NULL; + } + void* ret = UNSAFE_REALLOC_IMPL(srcBuffer, size); + if(!ret) { + return NULL; + } + return (*jniHandle)->NewDirectByteBuffer(jniHandle, ret, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMalloc + * Method: freeBuffer + * Signature: (Ljava/nio/Buffer;)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMalloc_freeBuffer + (JNIEnv * jniHandle, jclass jniClass, jobject buffer) { + void* srcBuffer = (*jniHandle)->GetDirectBufferAddress(jniHandle, buffer); + if(srcBuffer == NULL) { + unsafeThrowNotDirectBuffer(jniHandle); + return; + } + UNSAFE_FREE_IMPL(srcBuffer); +} diff --git a/native/UnsafeMemcpy.c b/native/UnsafeMemcpy.c new file mode 100644 index 0000000..4cb688e --- /dev/null +++ b/native/UnsafeMemcpy.c @@ -0,0 +1,1648 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "UnsafeMemcpyImpl.h" + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (JJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__JJI + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_IMPL(dstAddress, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__JJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_IMPL(dstAddress, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;IJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2IJI + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2JJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BIJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BIJI + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SIJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SIJI + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CIJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CIJI + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IIJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IIJI + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JIJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JIJI + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DIJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DIJI + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FIJI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FIJI + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jlong srcAddress, jint byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jlong srcAddress, jlong byteLength) { + UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (JLjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__JLjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (JLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__JLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;ILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2ILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;JLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2JLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FILjava/nio/Buffer;II)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FILjava_nio_Buffer_2II + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jobject srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJLjava/nio/Buffer;JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJLjava_nio_Buffer_2JJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jobject srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3BII + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;I[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2I_3BII + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;J[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2J_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BI[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BI_3BII + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJ[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJ_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SI[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SI_3BII + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJ[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJ_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CI[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CI_3BII + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJ[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJ_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([II[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3II_3BII + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJ[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJ_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JI[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JI_3BII + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJ[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJ_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DI[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DI_3BII + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJ[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJ_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FI[BII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FI_3BII + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jbyteArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJ[BJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJ_3BJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jbyteArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3SII + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;I[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2I_3SII + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;J[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2J_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BI[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BI_3SII + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJ[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJ_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SI[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SI_3SII + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJ[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJ_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CI[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CI_3SII + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJ[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJ_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([II[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3II_3SII + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJ[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJ_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JI[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JI_3SII + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJ[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJ_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DI[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DI_3SII + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJ[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJ_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FI[SII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FI_3SII + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jshortArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJ[SJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJ_3SJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jshortArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3CII + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;I[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2I_3CII + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;J[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2J_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BI[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BI_3CII + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJ[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJ_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SI[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SI_3CII + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJ[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJ_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CI[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CI_3CII + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJ[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJ_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([II[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3II_3CII + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJ[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJ_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JI[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JI_3CII + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJ[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJ_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DI[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DI_3CII + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJ[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJ_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FI[CII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FI_3CII + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jcharArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJ[CJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJ_3CJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jcharArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3III + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;I[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2I_3III + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;J[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2J_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BI[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BI_3III + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJ[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJ_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SI[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SI_3III + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJ[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJ_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CI[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CI_3III + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJ[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJ_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([II[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3II_3III + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJ[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJ_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JI[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JI_3III + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJ[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJ_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DI[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DI_3III + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJ[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJ_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FI[III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FI_3III + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jintArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJ[IJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJ_3IJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jintArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3JII + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;I[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2I_3JII + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;J[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2J_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BI[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BI_3JII + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJ[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJ_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SI[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SI_3JII + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJ[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJ_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CI[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CI_3JII + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJ[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJ_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([II[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3II_3JII + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJ[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJ_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JI[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JI_3JII + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJ[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJ_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DI[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DI_3JII + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJ[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJ_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FI[JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FI_3JII + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jlongArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJ[JJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJ_3JJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jlongArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3DII + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;I[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2I_3DII + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;J[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2J_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BI[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BI_3DII + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJ[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJ_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SI[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SI_3DII + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJ[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJ_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CI[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CI_3DII + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJ[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJ_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([II[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3II_3DII + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJ[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJ_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JI[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JI_3DII + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJ[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJ_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DI[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DI_3DII + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJ[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJ_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FI[DII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FI_3DII + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jdoubleArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJ[DJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJ_3DJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jdoubleArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3FII + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (J[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__J_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jlong dstAddress, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;I[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2I_3FII + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: (Ljava/nio/Buffer;J[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy__Ljava_nio_Buffer_2J_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jobject dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BI[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BI_3FII + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([BJ[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3BJ_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SI[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SI_3FII + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([SJ[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3SJ_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CI[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CI_3FII + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([CJ[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3CJ_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([II[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3II_3FII + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([IJ[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3IJ_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jintArray dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JI[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JI_3FII + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([JJ[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3JJ_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DI[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DI_3FII + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([DJ[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3DJ_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FI[FII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FI_3FII + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jint dstOffset, jfloatArray srcAddress, jint srcOffset, jint byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemcpy + * Method: memcpy + * Signature: ([FJ[FJJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemcpy_memcpy___3FJ_3FJJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray dstAddress, jlong dstOffset, jfloatArray srcAddress, jlong srcOffset, jlong byteLength) { + UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength); +} + diff --git a/native/UnsafeMemcpyImpl.h b/native/UnsafeMemcpyImpl.h new file mode 100644 index 0000000..c50db91 --- /dev/null +++ b/native/UnsafeMemcpyImpl.h @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include +#include +#include + +#include "utils.h" + +#define UNSAFE_MEMCPY_IMPL(dst, src, len) memcpy((void*)(dst), (const void*)(src), (size_t)(len)) + +#define UNSAFE_MEMCPY_ARRAY_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength)\ + uint64_t srcArray = (uint64_t)(*jniHandle)->GetPrimitiveArrayCritical(jniHandle, srcAddress, NULL);\ + if(!srcArray) {\ + unsafeThrowOutOfMemory(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstAddress, srcArray + srcOffset, byteLength);\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, srcAddress, (void*)srcArray, JNI_ABORT); + +#define UNSAFE_MEMCPY_BUFFER_TO_NATIVE_IMPL(jniHandle, dstAddress, srcAddress, srcOffset, byteLength)\ + uint64_t srcBuffer = (uint64_t)(*jniHandle)->GetDirectBufferAddress(jniHandle, srcAddress);\ + if(!srcBuffer) {\ + unsafeThrowNotDirectBuffer(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstAddress, srcBuffer + srcOffset, byteLength); + +#define UNSAFE_MEMCPY_NATIVE_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength)\ + uint64_t dstBuffer = (uint64_t)(*jniHandle)->GetDirectBufferAddress(jniHandle, dstAddress);\ + if(!dstBuffer) {\ + unsafeThrowNotDirectBuffer(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstBuffer + dstOffset, srcAddress, byteLength); + +#define UNSAFE_MEMCPY_BUFFER_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength)\ + uint64_t dstBuffer = (uint64_t)(*jniHandle)->GetDirectBufferAddress(jniHandle, dstAddress);\ + if(!dstBuffer) {\ + unsafeThrowNotDirectBuffer(jniHandle);\ + return;\ + }\ + uint64_t srcBuffer = (uint64_t)(*jniHandle)->GetDirectBufferAddress(jniHandle, srcAddress);\ + if(!srcBuffer) {\ + unsafeThrowNotDirectBuffer(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstBuffer + dstOffset, srcBuffer + srcOffset, byteLength); + +#define UNSAFE_MEMCPY_ARRAY_TO_BUFFER_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength)\ + uint64_t dstBuffer = (uint64_t)(*jniHandle)->GetDirectBufferAddress(jniHandle, dstAddress);\ + if(!dstBuffer) {\ + unsafeThrowNotDirectBuffer(jniHandle);\ + return;\ + }\ + uint64_t srcArray = (uint64_t)(*jniHandle)->GetPrimitiveArrayCritical(jniHandle, srcAddress, NULL);\ + if(!srcArray) {\ + unsafeThrowOutOfMemory(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstBuffer + dstOffset, srcArray + srcOffset, byteLength);\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, srcAddress, (void*)srcArray, JNI_ABORT); + +#define UNSAFE_MEMCPY_NATIVE_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, byteLength)\ + uint64_t dstArray = (uint64_t)(*jniHandle)->GetPrimitiveArrayCritical(jniHandle, dstAddress, NULL);\ + if(!dstArray) {\ + unsafeThrowOutOfMemory(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstArray + dstOffset, srcAddress, byteLength);\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, dstAddress, (void*)dstArray, JNI_COMMIT); + +#define UNSAFE_MEMCPY_BUFFER_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength)\ + uint64_t srcBuffer = (uint64_t)(*jniHandle)->GetDirectBufferAddress(jniHandle, srcAddress);\ + if(!srcBuffer) {\ + unsafeThrowNotDirectBuffer(jniHandle);\ + return;\ + }\ + uint64_t dstArray = (uint64_t)(*jniHandle)->GetPrimitiveArrayCritical(jniHandle, dstAddress, NULL);\ + if(!dstArray) {\ + unsafeThrowOutOfMemory(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstArray + dstOffset, srcBuffer + srcOffset, byteLength);\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, dstAddress, (void*)dstArray, JNI_COMMIT); + +#define UNSAFE_MEMCPY_ARRAY_TO_ARRAY_IMPL(jniHandle, dstAddress, dstOffset, srcAddress, srcOffset, byteLength)\ + uint64_t srcArray = (uint64_t)(*jniHandle)->GetPrimitiveArrayCritical(jniHandle, srcAddress, NULL);\ + if(!srcArray) {\ + unsafeThrowOutOfMemory(jniHandle);\ + return;\ + }\ + uint64_t dstArray = (uint64_t)(*jniHandle)->GetPrimitiveArrayCritical(jniHandle, dstAddress, NULL);\ + if(!dstArray) {\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, srcAddress, (void*)srcArray, JNI_ABORT);\ + unsafeThrowOutOfMemory(jniHandle);\ + return;\ + }\ + UNSAFE_MEMCPY_IMPL(dstArray + dstOffset, srcArray + srcOffset, byteLength);\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, dstAddress, (void*)dstArray, JNI_COMMIT);\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, srcAddress, (void*)srcArray, JNI_ABORT); diff --git a/native/UnsafeMemset.c b/native/UnsafeMemset.c new file mode 100644 index 0000000..64286ed --- /dev/null +++ b/native/UnsafeMemset.c @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "UnsafeMemsetImpl.h" + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: (JII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset__JII + (JNIEnv * jniHandle, jclass jniClass, jlong address, jint value, jint byteLength) { + UNSAFE_MEMSET_IMPL(address, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: (JIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset__JIJ + (JNIEnv * jniHandle, jclass jniClass, jlong address, jint value, jlong byteLength) { + UNSAFE_MEMSET_IMPL(address, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: (Ljava/nio/Buffer;III)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset__Ljava_nio_Buffer_2III + (JNIEnv * jniHandle, jclass jniClass, jobject address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_BUFFER_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: (Ljava/nio/Buffer;JIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset__Ljava_nio_Buffer_2JIJ + (JNIEnv * jniHandle, jclass jniClass, jobject address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_BUFFER_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([BIII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3BIII + (JNIEnv * jniHandle, jclass jniClass, jbyteArray address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([BJIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3BJIJ + (JNIEnv * jniHandle, jclass jniClass, jbyteArray address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([SIII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3SIII + (JNIEnv * jniHandle, jclass jniClass, jshortArray address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([SJIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3SJIJ + (JNIEnv * jniHandle, jclass jniClass, jshortArray address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([CIII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3CIII + (JNIEnv * jniHandle, jclass jniClass, jcharArray address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([CJIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3CJIJ + (JNIEnv * jniHandle, jclass jniClass, jcharArray address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([IIII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3IIII + (JNIEnv * jniHandle, jclass jniClass, jintArray address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([IJIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3IJIJ + (JNIEnv * jniHandle, jclass jniClass, jintArray address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([JIII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3JIII + (JNIEnv * jniHandle, jclass jniClass, jlongArray address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([JJIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3JJIJ + (JNIEnv * jniHandle, jclass jniClass, jlongArray address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([DIII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3DIII + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([DJIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3DJIJ + (JNIEnv * jniHandle, jclass jniClass, jdoubleArray address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([FIII)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3FIII + (JNIEnv * jniHandle, jclass jniClass, jfloatArray address, jint offset, jint value, jint byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeMemset + * Method: memset + * Signature: ([FJIJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeMemset_memset___3FJIJ + (JNIEnv * jniHandle, jclass jniClass, jfloatArray address, jlong offset, jint value, jlong byteLength) { + UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength); +} + diff --git a/native/UnsafeMemsetImpl.h b/native/UnsafeMemsetImpl.h new file mode 100644 index 0000000..c279367 --- /dev/null +++ b/native/UnsafeMemsetImpl.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include +#include +#include + +#include "utils.h" + +#define UNSAFE_MEMSET_IMPL(address, value, byteLength)\ + memset((void*)(address), (int)(value), (size_t)(byteLength)); + +#define UNSAFE_MEMSET_BUFFER_IMPL(jniHandle, address, offset, value, byteLength)\ + uint64_t dstBuffer = (uint64_t)(*jniHandle)->GetDirectBufferAddress(jniHandle, address);\ + if(!dstBuffer) {\ + unsafeThrowNotDirectBuffer(jniHandle);\ + return;\ + }\ + UNSAFE_MEMSET_IMPL(dstBuffer + offset, value, byteLength); + +#define UNSAFE_MEMSET_ARRAY_IMPL(jniHandle, address, offset, value, byteLength)\ + uint64_t dstArray = (uint64_t)(*jniHandle)->GetPrimitiveArrayCritical(jniHandle, address, NULL);\ + if(!dstArray) {\ + unsafeThrowOutOfMemory(jniHandle);\ + return;\ + }\ + UNSAFE_MEMSET_IMPL(dstArray + offset, value, byteLength);\ + (*jniHandle)->ReleasePrimitiveArrayCritical(jniHandle, address, (void*)dstArray, JNI_COMMIT); diff --git a/native/UnsafeUtils.c b/native/UnsafeUtils.c new file mode 100644 index 0000000..1a92b7c --- /dev/null +++ b/native/UnsafeUtils.c @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include "utils.h" + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getVersionMajor + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getVersionMajor + (JNIEnv * jniHandle, jclass jniClass) { + return NATIVE_LIBRARY_VERSION_MAJOR; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getVersionMinor + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getVersionMinor + (JNIEnv * jniHandle, jclass jniClass) { + return NATIVE_LIBRARY_VERSION_MINOR; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: makeDirectBuffer + * Signature: (JI)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_makeDirectBuffer__JI + (JNIEnv * jniHandle, jclass jniClass, jlong address, jint size) { + return (*jniHandle)->NewDirectByteBuffer(jniHandle, (void*)address, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: makeDirectBuffer + * Signature: (JJ)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_makeDirectBuffer__JJ + (JNIEnv * jniHandle, jclass jniClass, jlong address, jlong size) { + return (*jniHandle)->NewDirectByteBuffer(jniHandle, (void*)address, size); +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getAddress + * Signature: (Ljava/nio/Buffer;)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getAddress + (JNIEnv * jniHandle, jclass jniClass, jobject buffer) { + void* srcBuffer = (*jniHandle)->GetDirectBufferAddress(jniHandle, buffer); + if(srcBuffer == NULL) { + unsafeThrowNotDirectBuffer(jniHandle); + return 0; + } + return (jlong)srcBuffer; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getMemByte + * Signature: (J)B + */ +JNIEXPORT jbyte JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getMemByte + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + return *(jbyte*)address; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getMemShort + * Signature: (J)S + */ +JNIEXPORT jshort JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getMemShort + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + return *(jshort*)address; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getMemChar + * Signature: (J)C + */ +JNIEXPORT jchar JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getMemChar + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + return *(jchar*)address; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getMemInt + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getMemInt + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + return *(jint*)address; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getMemLong + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getMemLong + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + return *(jlong*)address; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getMemDouble + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getMemDouble + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + return *(jdouble*)address; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: getMemFloat + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_getMemFloat + (JNIEnv * jniHandle, jclass jniClass, jlong address) { + return *(jfloat*)address; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: setMemByte + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_setMemByte + (JNIEnv * jniHandle, jclass jniClass, jlong address, jbyte value) { + *(jbyte*)address = value; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: setMemShort + * Signature: (JS)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_setMemShort + (JNIEnv * jniHandle, jclass jniClass, jlong address, jshort value) { + *(jshort*)address = value; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: setMemChar + * Signature: (JC)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_setMemChar + (JNIEnv * jniHandle, jclass jniClass, jlong address, jchar value) { + *(jchar*)address = value; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: setMemInt + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_setMemInt + (JNIEnv * jniHandle, jclass jniClass, jlong address, jint value) { + *(jint*)address = value; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: setMemLong + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_setMemLong + (JNIEnv * jniHandle, jclass jniClass, jlong address, jlong value) { + *(jlong*)address = value; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: setMemDouble + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_setMemDouble + (JNIEnv * jniHandle, jclass jniClass, jlong address, jdouble value) { + *(jdouble*)address = value; +} + +/* + * Class: net_lax1dude_unsafememcpy_UnsafeUtils + * Method: setMemFloat + * Signature: (JF)V + */ +JNIEXPORT void JNICALL Java_net_lax1dude_unsafememcpy_UnsafeUtils_setMemFloat + (JNIEnv * jniHandle, jclass jniClass, jlong address, jfloat value) { + *(jfloat*)address = value; +} diff --git a/native/utils.c b/native/utils.c new file mode 100644 index 0000000..eaeccb2 --- /dev/null +++ b/native/utils.c @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "utils.h" + +void unsafeThrowNotDirectBuffer(JNIEnv* jniHandle) { + jclass exceptionClass = (*jniHandle)->FindClass(jniHandle, "java/lang/IllegalArgumentException"); + if (!exceptionClass) { + return; // should not happen ever + } + (*jniHandle)->ThrowNew(jniHandle, exceptionClass, "NIO Buffer object is not direct!"); +} + +void unsafeThrowOutOfMemory(JNIEnv* jniHandle) { + jclass exceptionClass = (*jniHandle)->FindClass(jniHandle, "java/lang/OutOfMemoryError"); + if (!exceptionClass) { + return; + } + (*jniHandle)->ThrowNew(jniHandle, exceptionClass, "Not enough memory available to access the array!"); +} diff --git a/native/utils.h b/native/utils.h new file mode 100644 index 0000000..bc2391d --- /dev/null +++ b/native/utils.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2024 lax1dude + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include + +#define NATIVE_LIBRARY_VERSION_MAJOR 1 +#define NATIVE_LIBRARY_VERSION_MINOR 0 + +void unsafeThrowNotDirectBuffer(JNIEnv* jniHandle); +void unsafeThrowOutOfMemory(JNIEnv* jniHandle);