1berry/openjdk
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

8221477: Inject os/cpu-specific constants into Unsafe from JVM

Browse Source 
Initialize Unsafe os/cpu-specific constants using injection instead of native callouts

Reviewed-by: stuefe, coleenp, dholmes, plevart
This commit is contained in:
Andrew Dinn 2019-04-05 10:01:09 +01:00
parent 7a093bcf50
commit 71164a973b
9 changed files with 190 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/hotspot/share/classfile/javaClasses.cpp
View File

@ -218,7 +218,7 @@ public:
void java_lang_String::set_compact_strings(bool value) {
CompactStringsFixup fix(value);
InstanceKlass::cast(SystemDictionary::String_klass())->do_local_static_fields(&fix);
SystemDictionary::String_klass()->do_local_static_fields(&fix);
}
Handle java_lang_String::basic_create(int length, bool is_latin1, TRAPS) {
@ -3991,6 +3991,48 @@ int java_lang_System::in_offset_in_bytes() { return static_in_offset; }
int java_lang_System::out_offset_in_bytes() { return static_out_offset; }
int java_lang_System::err_offset_in_bytes() { return static_err_offset; }
// Support for jdk_internal_misc_UnsafeConstants
//
class UnsafeConstantsFixup : public FieldClosure {
private:
int _address_size;
int _page_size;
bool _big_endian;
bool _use_unaligned_access;
public:
UnsafeConstantsFixup() {
// round up values for all static final fields
_address_size = sizeof(void*);
_page_size = os::vm_page_size();
_big_endian = LITTLE_ENDIAN_ONLY(false) BIG_ENDIAN_ONLY(true);
_use_unaligned_access = UseUnalignedAccesses;
}
void do_field(fieldDescriptor* fd) {
oop mirror = fd->field_holder()->java_mirror();
assert(mirror != NULL, "UnsafeConstants must have mirror already");
assert(fd->field_holder() == SystemDictionary::UnsafeConstants_klass(), "Should be UnsafeConstants");
assert(fd->is_final(), "fields of UnsafeConstants must be final");
assert(fd->is_static(), "fields of UnsafeConstants must be static");
if (fd->name() == vmSymbols::address_size_name()) {
mirror->int_field_put(fd->offset(), _address_size);
} else if (fd->name() == vmSymbols::page_size_name()) {
mirror->int_field_put(fd->offset(), _page_size);
} else if (fd->name() == vmSymbols::big_endian_name()) {
mirror->bool_field_put(fd->offset(), _big_endian);
} else if (fd->name() == vmSymbols::use_unaligned_access_name()) {
mirror->bool_field_put(fd->offset(), _use_unaligned_access);
} else {
assert(false, "unexpected UnsafeConstants field");
}
}
};
void jdk_internal_misc_UnsafeConstants::set_unsafe_constants() {
UnsafeConstantsFixup fixup;
SystemDictionary::UnsafeConstants_klass()->do_local_static_fields(&fixup);
}
int java_lang_Class::_klass_offset;
int java_lang_Class::_array_klass_offset;
int java_lang_Class::_oop_size_offset;

10
src/hotspot/share/classfile/javaClasses.hpp
View File

@ -81,6 +81,7 @@
f(java_lang_StackFrameInfo) \
f(java_lang_LiveStackFrameInfo) \
f(java_util_concurrent_locks_AbstractOwnableSynchronizer) \
f(jdk_internal_misc_UnsafeConstants) \
//end
#define BASIC_JAVA_CLASSES_DO(f) \
@ -1483,6 +1484,15 @@ class java_util_concurrent_locks_AbstractOwnableSynchronizer : AllStatic {
static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
};
// Interface to jdk.internal.misc.UnsafeConsants
class jdk_internal_misc_UnsafeConstants : AllStatic {
public:
static void set_unsafe_constants();
static void compute_offsets() { }
static void serialize_offsets(SerializeClosure* f) { }
};
// Use to declare fields that need to be injected into Java classes
// for the JVM to use. The name_index and signature_index are
// declared in vmSymbols. The may_be_java flag is used to declare

1
src/hotspot/share/classfile/systemDictionary.hpp
View File

@ -177,6 +177,7 @@ class OopStorage;
do_klass(AssertionStatusDirectives_klass, java_lang_AssertionStatusDirectives ) \
do_klass(StringBuffer_klass, java_lang_StringBuffer ) \
do_klass(StringBuilder_klass, java_lang_StringBuilder ) \
do_klass(UnsafeConstants_klass, jdk_internal_misc_UnsafeConstants ) \
do_klass(internal_Unsafe_klass, jdk_internal_misc_Unsafe ) \
do_klass(module_Modules_klass, jdk_internal_module_Modules ) \
\

7
src/hotspot/share/classfile/vmSymbols.hpp
View File

@ -446,6 +446,10 @@
template(module_entry_name, "module_entry") \
template(resolved_references_name, "<resolved_references>") \
template(init_lock_name, "<init_lock>") \
template(address_size_name, "ADDRESS_SIZE0") \
template(page_size_name, "PAGE_SIZE") \
template(big_endian_name, "BIG_ENDIAN") \
template(use_unaligned_access_name, "UNALIGNED_ACCESS") \
\
/* name symbols needed by intrinsics */ \
VM_INTRINSICS_DO(VM_INTRINSIC_IGNORE, VM_SYMBOL_IGNORE, template, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE) \
@ -1070,6 +1074,9 @@
do_intrinsic(_updateByteBufferAdler32, java_util_zip_Adler32, updateByteBuffer_A_name, updateByteBuffer_signature, F_SN) \
do_name( updateByteBuffer_A_name, "updateByteBuffer") \
\
/* support for UnsafeConstants */ \
do_class(jdk_internal_misc_UnsafeConstants, "jdk/internal/misc/UnsafeConstants") \
\
/* support for Unsafe */ \
do_class(jdk_internal_misc_Unsafe, "jdk/internal/misc/Unsafe") \
\

25
src/hotspot/share/prims/unsafe.cpp
View File

@ -292,18 +292,6 @@ UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe,
return JNIHandles::make_local(env, v);
} UNSAFE_END
UNSAFE_LEAF(jboolean, Unsafe_isBigEndian0(JNIEnv *env, jobject unsafe)) {
#ifdef VM_LITTLE_ENDIAN
return false;
#else
return true;
#endif
} UNSAFE_END
UNSAFE_LEAF(jint, Unsafe_unalignedAccess0(JNIEnv *env, jobject unsafe)) {
return UseUnalignedAccesses;
} UNSAFE_END
#define DEFINE_GETSETOOP(java_type, Type) \
\
UNSAFE_ENTRY(java_type, Unsafe_Get##Type(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) { \
@ -446,14 +434,6 @@ UNSAFE_LEAF(void, Unsafe_CopySwapMemory0(JNIEnv *env, jobject unsafe, jobject sr
////// Random queries
UNSAFE_LEAF(jint, Unsafe_AddressSize0(JNIEnv *env, jobject unsafe)) {
return sizeof(void*);
} UNSAFE_END
UNSAFE_LEAF(jint, Unsafe_PageSize()) {
return os::vm_page_size();
} UNSAFE_END
static jlong find_field_offset(jclass clazz, jstring name, TRAPS) {
assert(clazz != NULL, "clazz must not be NULL");
assert(name != NULL, "name must not be NULL");
@ -1073,8 +1053,6 @@ static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
{CC "ensureClassInitialized0", CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized0)},
{CC "arrayBaseOffset0", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset0)},
{CC "arrayIndexScale0", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale0)},
{CC "addressSize0", CC "()I", FN_PTR(Unsafe_AddressSize0)},
{CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
{CC "defineClass0", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)},
{CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
@ -1102,9 +1080,6 @@ static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
{CC "loadFence", CC "()V", FN_PTR(Unsafe_LoadFence)},
{CC "storeFence", CC "()V", FN_PTR(Unsafe_StoreFence)},
{CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
{CC "isBigEndian0", CC "()Z", FN_PTR(Unsafe_isBigEndian0)},
{CC "unalignedAccess0", CC "()Z", FN_PTR(Unsafe_unalignedAccess0)}
};
#undef CC

10
src/hotspot/share/runtime/thread.cpp
View File

@ -3628,6 +3628,7 @@ void Threads::initialize_java_lang_classes(JavaThread* main_thread, TRAPS) {
initialize_class(vmSymbols::java_lang_Thread(), CHECK);
oop thread_object = create_initial_thread(thread_group, main_thread, CHECK);
main_thread->set_threadObj(thread_object);
// Set thread status to running since main thread has
// been started and running.
java_lang_Thread::set_thread_status(thread_object,
@ -3636,6 +3637,15 @@ void Threads::initialize_java_lang_classes(JavaThread* main_thread, TRAPS) {
// The VM creates objects of this class.
initialize_class(vmSymbols::java_lang_Module(), CHECK);
#ifdef ASSERT
InstanceKlass *k = SystemDictionary::UnsafeConstants_klass();
assert(k->is_not_initialized(), "UnsafeConstants should not already be initialized");
#endif
// initialize the hardware-specific constants needed by Unsafe
initialize_class(vmSymbols::jdk_internal_misc_UnsafeConstants(), CHECK);
jdk_internal_misc_UnsafeConstants::set_unsafe_constants();
// The VM preresolves methods to these classes. Make sure that they get initialized
initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK);
initialize_class(vmSymbols::java_lang_ref_Finalizer(), CHECK);

40
src/java.base/share/classes/jdk/internal/misc/Unsafe.java
View File

@ -33,6 +33,7 @@ import sun.nio.ch.DirectBuffer;
import java.lang.reflect.Field;
import java.security.ProtectionDomain;
import static jdk.internal.misc.UnsafeConstants.*;
/**
* A collection of methods for performing low-level, unsafe operations.
@ -1166,14 +1167,13 @@ public final class Unsafe {
}
/** The value of {@code addressSize()} */
public static final int ADDRESS_SIZE = theUnsafe.addressSize0();
public static final int ADDRESS_SIZE = ADDRESS_SIZE0;
/**
* Reports the size in bytes of a native memory page (whatever that is).
* This value will always be a power of two.
*/
public native int pageSize();
public int pageSize() { return PAGE_SIZE; }
/// random trusted operations from JNI:
@ -1417,7 +1417,7 @@ public final class Unsafe {
byte x) {
long wordOffset = offset & ~3;
int shift = (int) (offset & 3) << 3;
if (BE) {
if (BIG_ENDIAN) {
shift = 24 - shift;
}
int mask = 0xFF << shift;
@ -1491,7 +1491,7 @@ public final class Unsafe {
}
long wordOffset = offset & ~3;
int shift = (int) (offset & 3) << 3;
if (BE) {
if (BIG_ENDIAN) {
shift = 16 - shift;
}
int mask = 0xFFFF << shift;
@ -3354,14 +3354,14 @@ public final class Unsafe {
* @return Returns true if the native byte ordering of this
* platform is big-endian, false if it is little-endian.
*/
public final boolean isBigEndian() { return BE; }
public final boolean isBigEndian() { return BIG_ENDIAN; }
/**
* @return Returns true if this platform is capable of performing
* accesses at addresses which are not aligned for the type of the
* primitive type being accessed, false otherwise.
*/
public final boolean unalignedAccess() { return unalignedAccess; }
public final boolean unalignedAccess() { return UNALIGNED_ACCESS; }
/**
* Fetches a value at some byte offset into a given Java object.
@ -3603,14 +3603,7 @@ public final class Unsafe {
putCharUnaligned(o, offset, convEndian(bigEndian, x));
}
// JVM interface methods
// BE is true iff the native endianness of this platform is big.
private static final boolean BE = theUnsafe.isBigEndian0();
// unalignedAccess is true iff this platform can perform unaligned accesses.
private static final boolean unalignedAccess = theUnsafe.unalignedAccess0();
private static int pickPos(int top, int pos) { return BE ? top - pos : pos; }
private static int pickPos(int top, int pos) { return BIG_ENDIAN ? top - pos : pos; }
// These methods construct integers from bytes. The byte ordering
// is the native endianness of this platform.
@ -3649,9 +3642,9 @@ public final class Unsafe {
| (toUnsignedInt(i1) << pickPos(8, 8)));
}
private static byte pick(byte le, byte be) { return BE ? be : le; }
private static short pick(short le, short be) { return BE ? be : le; }
private static int pick(int le, int be) { return BE ? be : le; }
private static byte pick(byte le, byte be) { return BIG_ENDIAN ? be : le; }
private static short pick(short le, short be) { return BIG_ENDIAN ? be : le; }
private static int pick(int le, int be) { return BIG_ENDIAN ? be : le; }
// These methods write integers to memory from smaller parts
// provided by their caller. The ordering in which these parts
@ -3699,10 +3692,10 @@ public final class Unsafe {
private static long toUnsignedLong(int n) { return n & 0xffffffffl; }
// Maybe byte-reverse an integer
private static char convEndian(boolean big, char n) { return big == BE ? n : Character.reverseBytes(n); }
private static short convEndian(boolean big, short n) { return big == BE ? n : Short.reverseBytes(n) ; }
private static int convEndian(boolean big, int n) { return big == BE ? n : Integer.reverseBytes(n) ; }
private static long convEndian(boolean big, long n) { return big == BE ? n : Long.reverseBytes(n) ; }
private static char convEndian(boolean big, char n) { return big == BIG_ENDIAN ? n : Character.reverseBytes(n); }
private static short convEndian(boolean big, short n) { return big == BIG_ENDIAN ? n : Short.reverseBytes(n) ; }
private static int convEndian(boolean big, int n) { return big == BIG_ENDIAN ? n : Integer.reverseBytes(n) ; }
private static long convEndian(boolean big, long n) { return big == BIG_ENDIAN ? n : Long.reverseBytes(n) ; }
@ -3721,11 +3714,8 @@ public final class Unsafe {
private native void ensureClassInitialized0(Class<?> c);
private native int arrayBaseOffset0(Class<?> arrayClass);
private native int arrayIndexScale0(Class<?> arrayClass);
private native int addressSize0();
private native Class<?> defineAnonymousClass0(Class<?> hostClass, byte[] data, Object[] cpPatches);
private native int getLoadAverage0(double[] loadavg, int nelems);
private native boolean unalignedAccess0();
private native boolean isBigEndian0();
/**

103
src/java.base/share/classes/jdk/internal/misc/UnsafeConstants.java Normal file
View File

@ -0,0 +1,103 @@
/*
* Copyright (c) 2019, Red Hat Inc. 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.
*/
package jdk.internal.misc;
/**
* A class used to expose details of the underlying hardware that
* configure the operation of class Unsafe. This class is
* package-private as the only intended client is class Unsafe.
* All fields in this class must be static final constants.
*
* @since 13
*
* @implNote
*
* The JVM injects hardware-specific values into all the static fields
* of this class during JVM initialization. The static initialization
* block is executed when the class is initialized then JVM injection
* updates the fields with the correct constants. The static block
* is required to prevent the fields from being considered constant
* variables, so the field values will be not be compiled directly into
* any class that uses them.
*/
final class UnsafeConstants {
/**
* This constructor is private because the class is not meant to
* be instantiated.
*/
private UnsafeConstants() {}
/**
* The size in bytes of a native pointer, as stored via {@link
* #putAddress}. This value will be either 4 or 8. Note that the
* sizes of other primitive types (as stored in native memory
* blocks) is determined fully by their information content.
*
* @implNote
* The actual value for this field is injected by the JVM.
*/
static final int ADDRESS_SIZE0;
/**
* The size in bytes of a native memory page (whatever that is).
* This value will always be a power of two.
*
* @implNote
* The actual value for this field is injected by the JVM.
*/
static final int PAGE_SIZE;
/**
* Flag whose value is true if and only if the native endianness
* of this platform is big.
*
* @implNote
* The actual value for this field is injected by the JVM.
*/
static final boolean BIG_ENDIAN;
/**
* Flag whose value is true if and only if the platform can
* perform unaligned accesses
*
* @implNote
* The actual value for this field is injected by the JVM.
*/
static final boolean UNALIGNED_ACCESS;
static {
ADDRESS_SIZE0 = 0;
PAGE_SIZE = 0;
BIG_ENDIAN = false;
UNALIGNED_ACCESS = false;
}
}

2
test/jdk/java/lang/reflect/AccessibleObject/CanAccessTest.java
View File

@ -94,7 +94,7 @@ public class CanAccessTest {
* for instance members
*/
public void testInstanceMethod() throws Exception {
Method m = Unsafe.class.getDeclaredMethod("addressSize0");
Method m = Unsafe.class.getDeclaredMethod("allocateMemory0", long.class);
assertFalse(m.canAccess(INSTANCE));
try {