stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8199424: consider removing ObjectInputStream and ObjectOutputStream native methods

Browse Source 
Reviewed-by: bpb, rriggs, redestad
This commit is contained in:
Joe Darcy 2019-09-20 09:32:45 -07:00
parent b770e9a6b4
commit f3208bfcd0
4 changed files with 26 additions and 408 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/java.base/share/classes/java/io/ObjectInputStream.java
View File

@ -2413,22 +2413,6 @@ public class ObjectInputStream
clear();
}
/**
* Converts specified span of bytes into float values.
*/
// REMIND: remove once hotspot inlines Float.intBitsToFloat
private static native void bytesToFloats(byte[] src, int srcpos,
float[] dst, int dstpos,
int nfloats);
/**
* Converts specified span of bytes into double values.
*/
// REMIND: remove once hotspot inlines Double.longBitsToDouble
private static native void bytesToDoubles(byte[] src, int srcpos,
double[] dst, int dstpos,
int ndoubles);
/**
* Returns the first non-null and non-platform class loader (not counting
* class loaders of generated reflection implementation classes) up the
@ -3433,22 +3417,24 @@ public class ObjectInputStream
}
void readFloats(float[] v, int off, int len) throws IOException {
int span, endoff = off + len;
int stop, endoff = off + len;
while (off < endoff) {
if (!blkmode) {
span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2);
int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2);
in.readFully(buf, 0, span << 2);
stop = off + span;
pos = 0;
} else if (end - pos < 4) {
v[off++] = din.readFloat();
continue;
} else {
span = Math.min(endoff - off, ((end - pos) >> 2));
stop = Math.min(endoff, ((end - pos) >> 2));
}
bytesToFloats(buf, pos, v, off, span);
off += span;
pos += span << 2;
while (off < stop) {
v[off++] = Bits.getFloat(buf, pos);
pos += 4;
}
}
}
@ -3475,22 +3461,24 @@ public class ObjectInputStream
}
void readDoubles(double[] v, int off, int len) throws IOException {
int span, endoff = off + len;
int stop, endoff = off + len;
while (off < endoff) {
if (!blkmode) {
span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
in.readFully(buf, 0, span << 3);
stop = off + span;
pos = 0;
} else if (end - pos < 8) {
v[off++] = din.readDouble();
continue;
} else {
span = Math.min(endoff - off, ((end - pos) >> 3));
stop = Math.min(endoff - off, ((end - pos) >> 3));
}
bytesToDoubles(buf, pos, v, off, span);
off += span;
pos += span << 3;
while (off < stop) {
v[off++] = Bits.getDouble(buf, pos);
pos += 8;
}
}
}

34
src/java.base/share/classes/java/io/ObjectOutputStream.java
View File

@ -1591,22 +1591,6 @@ public class ObjectOutputStream
}
}
/**
* Converts specified span of float values into byte values.
*/
// REMIND: remove once hotspot inlines Float.floatToIntBits
private static native void floatsToBytes(float[] src, int srcpos,
byte[] dst, int dstpos,
int nfloats);
/**
* Converts specified span of double values into byte values.
*/
// REMIND: remove once hotspot inlines Double.doubleToLongBits
private static native void doublesToBytes(double[] src, int srcpos,
byte[] dst, int dstpos,
int ndoubles);
/**
* Default PutField implementation.
*/
@ -2096,10 +2080,11 @@ public class ObjectOutputStream
while (off < endoff) {
if (pos <= limit) {
int avail = (MAX_BLOCK_SIZE - pos) >> 2;
int chunklen = Math.min(endoff - off, avail);
floatsToBytes(v, off, buf, pos, chunklen);
off += chunklen;
pos += chunklen << 2;
int stop = Math.min(endoff, off + avail);
while (off < stop) {
Bits.putFloat(buf, pos, v[off++]);
pos += 4;
}
} else {
dout.writeFloat(v[off++]);
}
@ -2129,10 +2114,11 @@ public class ObjectOutputStream
while (off < endoff) {
if (pos <= limit) {
int avail = (MAX_BLOCK_SIZE - pos) >> 3;
int chunklen = Math.min(endoff - off, avail);
doublesToBytes(v, off, buf, pos, chunklen);
off += chunklen;
pos += chunklen << 3;
int stop = Math.min(endoff, off + avail);
while (off < stop) {
Bits.putDouble(buf, pos, v[off++]);
pos += 8;
}
} else {
dout.writeDouble(v[off++]);
}

175
src/java.base/share/native/libjava/ObjectInputStream.c
View File

@ -1,175 +0,0 @@
/*
* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include "jni.h"
#include "jvm.h"
#include "jni_util.h"
#include "jlong.h"
#include "java_lang_Float.h"
#include "java_lang_Double.h"
#include "java_io_ObjectInputStream.h"
/*
* Class: java_io_ObjectInputStream
* Method: bytesToFloats
* Signature: ([BI[FII)V
*
* Reconstitutes nfloats float values from their byte representations. Byte
* values are read from array src starting at offset srcpos; the resulting
* float values are written to array dst starting at dstpos.
*/
JNIEXPORT void JNICALL
Java_java_io_ObjectInputStream_bytesToFloats(JNIEnv *env,
jclass this,
jbyteArray src,
jint srcpos,
jfloatArray dst,
jint dstpos,
jint nfloats)
{
union {
int i;
float f;
} u;
jfloat *floats;
jbyte *bytes;
jsize dstend;
jint ival;
if (nfloats == 0)
return;
/* fetch source array */
if (src == NULL) {
JNU_ThrowNullPointerException(env, NULL);
return;
}
bytes = (*env)->GetPrimitiveArrayCritical(env, src, NULL);
if (bytes == NULL) /* exception thrown */
return;
/* fetch dest array */
if (dst == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, src, bytes, JNI_ABORT);
JNU_ThrowNullPointerException(env, NULL);
return;
}
floats = (*env)->GetPrimitiveArrayCritical(env, dst, NULL);
if (floats == NULL) { /* exception thrown */
(*env)->ReleasePrimitiveArrayCritical(env, src, bytes, JNI_ABORT);
return;
}
/* do conversion */
dstend = dstpos + nfloats;
for ( ; dstpos < dstend; dstpos++) {
ival = ((bytes[srcpos + 0] & 0xFF) << 24) +
((bytes[srcpos + 1] & 0xFF) << 16) +
((bytes[srcpos + 2] & 0xFF) << 8) +
((bytes[srcpos + 3] & 0xFF) << 0);
u.i = (long) ival;
floats[dstpos] = (jfloat) u.f;
srcpos += 4;
}
(*env)->ReleasePrimitiveArrayCritical(env, src, bytes, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, dst, floats, 0);
}
/*
* Class: java_io_ObjectInputStream
* Method: bytesToDoubles
* Signature: ([BI[DII)V
*
* Reconstitutes ndoubles double values from their byte representations.
* Byte values are read from array src starting at offset srcpos; the
* resulting double values are written to array dst starting at dstpos.
*/
JNIEXPORT void JNICALL
Java_java_io_ObjectInputStream_bytesToDoubles(JNIEnv *env,
jclass this,
jbyteArray src,
jint srcpos,
jdoubleArray dst,
jint dstpos,
jint ndoubles)
{
union {
jlong l;
double d;
} u;
jdouble *doubles;
jbyte *bytes;
jsize dstend;
jlong lval;
if (ndoubles == 0)
return;
/* fetch source array */
if (src == NULL) {
JNU_ThrowNullPointerException(env, NULL);
return;
}
bytes = (*env)->GetPrimitiveArrayCritical(env, src, NULL);
if (bytes == NULL) /* exception thrown */
return;
/* fetch dest array */
if (dst == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, src, bytes, JNI_ABORT);
JNU_ThrowNullPointerException(env, NULL);
return;
}
doubles = (*env)->GetPrimitiveArrayCritical(env, dst, NULL);
if (doubles == NULL) { /* exception thrown */
(*env)->ReleasePrimitiveArrayCritical(env, src, bytes, JNI_ABORT);
return;
}
/* do conversion */
dstend = dstpos + ndoubles;
for ( ; dstpos < dstend; dstpos++) {
lval = (((jlong) bytes[srcpos + 0] & 0xFF) << 56) +
(((jlong) bytes[srcpos + 1] & 0xFF) << 48) +
(((jlong) bytes[srcpos + 2] & 0xFF) << 40) +
(((jlong) bytes[srcpos + 3] & 0xFF) << 32) +
(((jlong) bytes[srcpos + 4] & 0xFF) << 24) +
(((jlong) bytes[srcpos + 5] & 0xFF) << 16) +
(((jlong) bytes[srcpos + 6] & 0xFF) << 8) +
(((jlong) bytes[srcpos + 7] & 0xFF) << 0);
jlong_to_jdouble_bits(&lval);
u.l = lval;
doubles[dstpos] = (jdouble) u.d;
srcpos += 8;
}
(*env)->ReleasePrimitiveArrayCritical(env, src, bytes, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, dst, doubles, 0);
}

181
src/java.base/share/native/libjava/ObjectOutputStream.c
View File

@ -1,181 +0,0 @@
/*
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include "jni_util.h"
#include "jdk_util.h"
#include "java_lang_Float.h"
#include "java_lang_Double.h"
#include "java_io_ObjectOutputStream.h"
/*
* Class: java_io_ObjectOutputStream
* Method: floatsToBytes
* Signature: ([FI[BII)V
*
* Convert nfloats float values to their byte representations. Float values
* are read from array src starting at offset srcpos and written to array
* dst starting at offset dstpos.
*/
JNIEXPORT void JNICALL
Java_java_io_ObjectOutputStream_floatsToBytes(JNIEnv *env,
jclass this,
jfloatArray src,
jint srcpos,
jbyteArray dst,
jint dstpos,
jint nfloats)
{
union {
int i;
float f;
} u;
jfloat *floats;
jbyte *bytes;
jsize srcend;
jint ival;
float fval;
if (nfloats == 0)
return;
/* fetch source array */
if (src == NULL) {
JNU_ThrowNullPointerException(env, NULL);
return;
}
floats = (*env)->GetPrimitiveArrayCritical(env, src, NULL);
if (floats == NULL) /* exception thrown */
return;
/* fetch dest array */
if (dst == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, src, floats, JNI_ABORT);
JNU_ThrowNullPointerException(env, NULL);
return;
}
bytes = (*env)->GetPrimitiveArrayCritical(env, dst, NULL);
if (bytes == NULL) { /* exception thrown */
(*env)->ReleasePrimitiveArrayCritical(env, src, floats, JNI_ABORT);
return;
}
/* do conversion */
srcend = srcpos + nfloats;
for ( ; srcpos < srcend; srcpos++) {
fval = (float) floats[srcpos];
if (ISNANF(fval)) { /* collapse NaNs */
ival = 0x7fc00000;
} else {
u.f = fval;
ival = (jint) u.i;
}
bytes[dstpos++] = (ival >> 24) & 0xFF;
bytes[dstpos++] = (ival >> 16) & 0xFF;
bytes[dstpos++] = (ival >> 8) & 0xFF;
bytes[dstpos++] = (ival >> 0) & 0xFF;
}
(*env)->ReleasePrimitiveArrayCritical(env, src, floats, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, dst, bytes, 0);
}
/*
* Class: java_io_ObjectOutputStream
* Method: doublesToBytes
* Signature: ([DI[BII)V
*
* Convert ndoubles double values to their byte representations. Double
* values are read from array src starting at offset srcpos and written to
* array dst starting at offset dstpos.
*/
JNIEXPORT void JNICALL
Java_java_io_ObjectOutputStream_doublesToBytes(JNIEnv *env,
jclass this,
jdoubleArray src,
jint srcpos,
jbyteArray dst,
jint dstpos,
jint ndoubles)
{
union {
jlong l;
double d;
} u;
jdouble *doubles;
jbyte *bytes;
jsize srcend;
jdouble dval;
jlong lval;
if (ndoubles == 0)
return;
/* fetch source array */
if (src == NULL) {
JNU_ThrowNullPointerException(env, NULL);
return;
}
doubles = (*env)->GetPrimitiveArrayCritical(env, src, NULL);
if (doubles == NULL) /* exception thrown */
return;
/* fetch dest array */
if (dst == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, src, doubles, JNI_ABORT);
JNU_ThrowNullPointerException(env, NULL);
return;
}
bytes = (*env)->GetPrimitiveArrayCritical(env, dst, NULL);
if (bytes == NULL) { /* exception thrown */
(*env)->ReleasePrimitiveArrayCritical(env, src, doubles, JNI_ABORT);
return;
}
/* do conversion */
srcend = srcpos + ndoubles;
for ( ; srcpos < srcend; srcpos++) {
dval = doubles[srcpos];
if (ISNAND((double) dval)) { /* collapse NaNs */
lval = jint_to_jlong(0x7ff80000);
lval = jlong_shl(lval, 32);
} else {
jdouble_to_jlong_bits(&dval);
u.d = (double) dval;
lval = u.l;
}
bytes[dstpos++] = (lval >> 56) & 0xFF;
bytes[dstpos++] = (lval >> 48) & 0xFF;
bytes[dstpos++] = (lval >> 40) & 0xFF;
bytes[dstpos++] = (lval >> 32) & 0xFF;
bytes[dstpos++] = (lval >> 24) & 0xFF;
bytes[dstpos++] = (lval >> 16) & 0xFF;
bytes[dstpos++] = (lval >> 8) & 0xFF;
bytes[dstpos++] = (lval >> 0) & 0xFF;
}
(*env)->ReleasePrimitiveArrayCritical(env, src, doubles, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, dst, bytes, 0);
}