Merge "Implement sun.misc.Unsafe and fix the jfieldID/jmethodID leak." into dalvik-dev
diff --git a/build/Android.common.mk b/build/Android.common.mk
index 933fdf5..94b0fbc 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -119,6 +119,7 @@
src/stringprintf.cc \
src/stub_arm.cc \
src/stub_x86.cc \
+ src/sun_misc_Unsafe.cc \
src/thread.cc \
src/thread_list.cc \
src/utf.cc \
diff --git a/src/check_jni.cc b/src/check_jni.cc
index 38f47dc..ce4c2d0 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -359,7 +359,7 @@
}
ScopedJniThreadState ts(mEnv);
- Field* f = DecodeField(ts, fid);
+ Field* f = DecodeField(fid);
Class* field_type = f->GetType();
if (!field_type->IsPrimitive()) {
if (java_object != NULL) {
@@ -418,7 +418,7 @@
return;
}
- Field* f = DecodeField(ts, fid);
+ Field* f = DecodeField(fid);
Class* f_type = f->GetType();
// check invariant that all jfieldIDs have resovled types
DCHECK(f_type != NULL);
@@ -445,7 +445,7 @@
*/
void checkSig(jmethodID mid, const char* expectedType, bool isStatic) {
ScopedJniThreadState ts(mEnv);
- const Method* m = DecodeMethod(ts, mid);
+ const Method* m = DecodeMethod(mid);
if (*expectedType != m->GetShorty()->CharAt(0)) {
LOG(ERROR) << "JNI ERROR: expected return type '" << *expectedType << "' calling " << PrettyMethod(m);
JniAbort();
@@ -467,7 +467,7 @@
void checkStaticFieldID(jclass java_class, jfieldID fid) {
ScopedJniThreadState ts(mEnv);
Class* c = Decode<Class*>(ts, java_class);
- const Field* f = DecodeField(ts, fid);
+ const Field* f = DecodeField(fid);
if (f->GetDeclaringClass() != c) {
LOG(ERROR) << "JNI ERROR: static jfieldID " << fid << " not valid for class " << PrettyDescriptor(c->GetDescriptor());
JniAbort();
@@ -486,7 +486,7 @@
void checkStaticMethod(jclass java_class, jmethodID mid) {
ScopedJniThreadState ts(mEnv);
Class* c = Decode<Class*>(ts, java_class);
- const Method* m = DecodeMethod(ts, mid);
+ const Method* m = DecodeMethod(mid);
if (!c->IsAssignableFrom(m->GetDeclaringClass())) {
LOG(ERROR) << "JNI ERROR: can't call static " << PrettyMethod(m) << " on class " << PrettyDescriptor(c->GetDescriptor());
JniAbort();
@@ -503,7 +503,7 @@
void checkVirtualMethod(jobject java_object, jmethodID mid) {
ScopedJniThreadState ts(mEnv);
Object* o = Decode<Object*>(ts, java_object);
- const Method* m = DecodeMethod(ts, mid);
+ const Method* m = DecodeMethod(mid);
if (!o->InstanceOf(m->GetDeclaringClass())) {
LOG(ERROR) << "JNI ERROR: can't call " << PrettyMethod(m) << " on instance of " << PrettyType(o);
JniAbort();
@@ -620,7 +620,7 @@
}
} else if (ch == 'f') { // jfieldID
jfieldID fid = va_arg(ap, jfieldID);
- Field* f = reinterpret_cast<Field*>(Thread::Current()->DecodeJObject(reinterpret_cast<jweak>(fid)));
+ Field* f = reinterpret_cast<Field*>(fid);
msg += PrettyField(f);
if (!entry) {
StringAppendF(&msg, " (%p)", fid);
@@ -633,7 +633,7 @@
StringAppendF(&msg, "%d", i);
} else if (ch == 'm') { // jmethodID
jmethodID mid = va_arg(ap, jmethodID);
- Method* m = reinterpret_cast<Method*>(Thread::Current()->DecodeJObject(reinterpret_cast<jweak>(mid)));
+ Method* m = reinterpret_cast<Method*>(mid);
msg += PrettyMethod(m);
if (!entry) {
StringAppendF(&msg, " (%p)", mid);
@@ -730,14 +730,6 @@
}
private:
- Field* DecodeField(ScopedJniThreadState& ts, jfieldID fid) {
- return Decode<Field*>(ts, reinterpret_cast<jweak>(fid));
- }
-
- Method* DecodeMethod(ScopedJniThreadState& ts, jmethodID mid) {
- return Decode<Method*>(ts, reinterpret_cast<jweak>(mid));
- }
-
void init(JNIEnv* env, JavaVM* vm, int flags, const char* functionName, bool hasMethod) {
mEnv = reinterpret_cast<JNIEnvExt*>(env);
mVm = reinterpret_cast<JavaVMExt*>(vm);
diff --git a/src/compiler/codegen/arm/Thumb2/Gen.cc b/src/compiler/codegen/arm/Thumb2/Gen.cc
index a763d6e..cd3a64a 100644
--- a/src/compiler/codegen/arm/Thumb2/Gen.cc
+++ b/src/compiler/codegen/arm/Thumb2/Gen.cc
@@ -393,7 +393,7 @@
*/
static void markGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
{
-#if 0
+#ifdef CONCURRENT_GARBAGE_COLLECTOR
// TODO: re-enable when concurrent collector is active
int regCardBase = oatAllocTemp(cUnit);
int regCardNo = oatAllocTemp(cUnit);
diff --git a/src/heap.h b/src/heap.h
index 1c2b7c9..8ffb558 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -140,7 +140,10 @@
// Must be called if a field of an Object in the heap changes, and before any GC safe-point.
// The call is not needed if NULL is stored in the field.
static void WriteBarrier(const Object* object) {
- // TODO: re-enable card marking when concurrent collector is active.
+#ifdef CONCURRENT_GARBAGE_COLLECTOR
+ // TODO: we need card marking for a concurrent collector.
+ UNIMPLEMENTED(FATAL);
+#endif
}
private:
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 3b8eeff..9aa54ef 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -111,8 +111,7 @@
template ClassLoader* Decode<ClassLoader*>(JNIEnv*, jobject);
template Object* Decode<Object*>(JNIEnv*, jobject);
template String* Decode<String*>(JNIEnv*, jobject);
-template ObjectArray<StackTraceElement>*
- Decode<ObjectArray<StackTraceElement>*>(JNIEnv*, jobject);
+template ObjectArray<StackTraceElement>* Decode<ObjectArray<StackTraceElement>*>(JNIEnv*, jobject);
namespace {
@@ -133,14 +132,6 @@
return reinterpret_cast<T>(ts.Self()->DecodeJObject(obj));
}
-Field* DecodeField(ScopedJniThreadState& ts, jfieldID fid) {
- return Decode<Field*>(ts, reinterpret_cast<jweak>(fid));
-}
-
-Method* DecodeMethod(ScopedJniThreadState& ts, jmethodID mid) {
- return Decode<Method*>(ts, reinterpret_cast<jweak>(mid));
-}
-
byte* CreateArgArray(ScopedJniThreadState& ts, Method* method, va_list ap) {
size_t num_bytes = method->NumArgArrayBytes();
UniquePtr<byte[]> arg_array(new byte[num_bytes]);
@@ -222,18 +213,16 @@
return result;
}
-JValue InvokeWithJValues(ScopedJniThreadState& ts, jobject obj,
- jmethodID mid, jvalue* args) {
+JValue InvokeWithJValues(ScopedJniThreadState& ts, jobject obj, jmethodID mid, jvalue* args) {
Object* receiver = Decode<Object*>(ts, obj);
- Method* method = DecodeMethod(ts, mid);
+ Method* method = DecodeMethod(mid);
UniquePtr<byte[]> arg_array(CreateArgArray(ts, method, args));
return InvokeWithArgArray(ts, receiver, method, arg_array.get());
}
-JValue InvokeWithVarArgs(ScopedJniThreadState& ts, jobject obj,
- jmethodID mid, va_list args) {
+JValue InvokeWithVarArgs(ScopedJniThreadState& ts, jobject obj, jmethodID mid, va_list args) {
Object* receiver = Decode<Object*>(ts, obj);
- Method* method = DecodeMethod(ts, mid);
+ Method* method = DecodeMethod(mid);
UniquePtr<byte[]> arg_array(CreateArgArray(ts, method, args));
return InvokeWithArgArray(ts, receiver, method, arg_array.get());
}
@@ -244,14 +233,14 @@
JValue InvokeVirtualOrInterfaceWithJValues(ScopedJniThreadState& ts, jobject obj, jmethodID mid, jvalue* args) {
Object* receiver = Decode<Object*>(ts, obj);
- Method* method = FindVirtualMethod(receiver, DecodeMethod(ts, mid));
+ Method* method = FindVirtualMethod(receiver, DecodeMethod(mid));
UniquePtr<byte[]> arg_array(CreateArgArray(ts, method, args));
return InvokeWithArgArray(ts, receiver, method, arg_array.get());
}
JValue InvokeVirtualOrInterfaceWithVarArgs(ScopedJniThreadState& ts, jobject obj, jmethodID mid, va_list args) {
Object* receiver = Decode<Object*>(ts, obj);
- Method* method = FindVirtualMethod(receiver, DecodeMethod(ts, mid));
+ Method* method = FindVirtualMethod(receiver, DecodeMethod(mid));
UniquePtr<byte[]> arg_array(CreateArgArray(ts, method, args));
return InvokeWithArgArray(ts, receiver, method, arg_array.get());
}
@@ -309,7 +298,7 @@
return NULL;
}
- return reinterpret_cast<jmethodID>(AddWeakGlobalReference(ts, method));
+ return reinterpret_cast<jmethodID>(method);
}
jfieldID FindFieldID(ScopedJniThreadState& ts, jclass jni_class, const char* name, const char* sig, bool is_static) {
@@ -353,8 +342,7 @@
// Check invariant that all jfieldIDs have resolved types (how else would
// the type equality in Find...Field hold?)
DCHECK(field->GetType() != NULL);
- jweak fid = AddWeakGlobalReference(ts, field);
- return reinterpret_cast<jfieldID>(fid);
+ return reinterpret_cast<jfieldID>(field);
}
void PinPrimitiveArray(ScopedJniThreadState& ts, const Array* array) {
@@ -654,24 +642,24 @@
static jmethodID FromReflectedMethod(JNIEnv* env, jobject java_method) {
ScopedJniThreadState ts(env);
Method* method = Decode<Method*>(ts, java_method);
- return reinterpret_cast<jmethodID>(AddWeakGlobalReference(ts, method));
+ return reinterpret_cast<jmethodID>(method);
}
static jfieldID FromReflectedField(JNIEnv* env, jobject java_field) {
ScopedJniThreadState ts(env);
Field* field = Decode<Field*>(ts, java_field);
- return reinterpret_cast<jfieldID>(AddWeakGlobalReference(ts, field));
+ return reinterpret_cast<jfieldID>(field);
}
static jobject ToReflectedMethod(JNIEnv* env, jclass, jmethodID mid, jboolean) {
ScopedJniThreadState ts(env);
- Method* method = DecodeMethod(ts, mid);
+ Method* method = DecodeMethod(mid);
return AddLocalReference<jobject>(env, method);
}
static jobject ToReflectedField(JNIEnv* env, jclass, jfieldID fid, jboolean) {
ScopedJniThreadState ts(env);
- Field* field = DecodeField(ts, fid);
+ Field* field = DecodeField(fid);
return AddLocalReference<jobject>(env, field);
}
@@ -1376,15 +1364,13 @@
InvokeWithJValues(ts, obj, mid, args);
}
- static jfieldID GetFieldID(JNIEnv* env,
- jclass c, const char* name, const char* sig) {
+ static jfieldID GetFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
ScopedJniThreadState ts(env);
return FindFieldID(ts, c, name, sig, false);
}
- static jfieldID GetStaticFieldID(JNIEnv* env,
- jclass c, const char* name, const char* sig) {
+ static jfieldID GetStaticFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
ScopedJniThreadState ts(env);
return FindFieldID(ts, c, name, sig, true);
}
@@ -1392,13 +1378,13 @@
static jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fid) {
ScopedJniThreadState ts(env);
Object* o = Decode<Object*>(ts, obj);
- Field* f = DecodeField(ts, fid);
+ Field* f = DecodeField(fid);
return AddLocalReference<jobject>(env, f->GetObject(o));
}
static jobject GetStaticObjectField(JNIEnv* env, jclass, jfieldID fid) {
ScopedJniThreadState ts(env);
- Field* f = DecodeField(ts, fid);
+ Field* f = DecodeField(fid);
return AddLocalReference<jobject>(env, f->GetObject(NULL));
}
@@ -1406,27 +1392,27 @@
ScopedJniThreadState ts(env);
Object* o = Decode<Object*>(ts, java_object);
Object* v = Decode<Object*>(ts, java_value);
- Field* f = DecodeField(ts, fid);
+ Field* f = DecodeField(fid);
f->SetObject(o, v);
}
static void SetStaticObjectField(JNIEnv* env, jclass, jfieldID fid, jobject java_value) {
ScopedJniThreadState ts(env);
Object* v = Decode<Object*>(ts, java_value);
- Field* f = DecodeField(ts, fid);
+ Field* f = DecodeField(fid);
f->SetObject(NULL, v);
}
#define GET_PRIMITIVE_FIELD(fn, instance) \
ScopedJniThreadState ts(env); \
Object* o = Decode<Object*>(ts, instance); \
- Field* f = DecodeField(ts, fid); \
+ Field* f = DecodeField(fid); \
return f->fn(o)
#define SET_PRIMITIVE_FIELD(fn, instance, value) \
ScopedJniThreadState ts(env); \
Object* o = Decode<Object*>(ts, instance); \
- Field* f = DecodeField(ts, fid); \
+ Field* f = DecodeField(fid); \
f->fn(o, value)
static jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fid) {
diff --git a/src/jni_internal.h b/src/jni_internal.h
index 20aa716..a0602e5 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -17,6 +17,7 @@
namespace art {
class ClassLoader;
+class Field;
class Libraries;
class Method;
class Thread;
@@ -27,6 +28,22 @@
template<typename T> T Decode(JNIEnv*, jobject);
template<typename T> T AddLocalReference(JNIEnv*, const Object*);
+inline Field* DecodeField(jfieldID fid) {
+#ifdef MOVING_GARBAGE_COLLECTOR
+ // TODO: we should make these unique weak globals if Field instances can ever move.
+ UNIMPLEMENTED(WARNING);
+#endif
+ return reinterpret_cast<Field*>(fid);
+}
+
+inline Method* DecodeMethod(jmethodID mid) {
+#ifdef MOVING_GARBAGE_COLLECTOR
+ // TODO: we should make these unique weak globals if Method instances can ever move.
+ UNIMPLEMENTED(WARNING);
+#endif
+ return reinterpret_cast<Method*>(mid);
+}
+
struct JavaVMExt : public JavaVM {
JavaVMExt(Runtime* runtime, Runtime::ParsedOptions* options);
~JavaVMExt();
diff --git a/src/runtime.cc b/src/runtime.cc
index 706d793..8b3838f 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -432,7 +432,7 @@
REGISTER(register_java_util_concurrent_atomic_AtomicLong);
//REGISTER(register_org_apache_harmony_dalvik_ddmc_DdmServer);
//REGISTER(register_org_apache_harmony_dalvik_ddmc_DdmVmInternal);
- //REGISTER(register_sun_misc_Unsafe);
+ REGISTER(register_sun_misc_Unsafe);
#undef REGISTER
}
diff --git a/src/sun_misc_Unsafe.cc b/src/sun_misc_Unsafe.cc
new file mode 100644
index 0000000..4c23f7a
--- /dev/null
+++ b/src/sun_misc_Unsafe.cc
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "jni_internal.h"
+#include "object.h"
+
+#include "JniConstants.h" // Last to avoid problems with LOG redefinition.
+
+namespace art {
+
+namespace {
+
+jlong Unsafe_objectFieldOffset0(JNIEnv* env, jclass, jobject javaField) {
+ jfieldID fid = env->FromReflectedField(javaField);
+ Field* field = DecodeField(fid);
+ return field->GetOffset().Int32Value();
+}
+
+jint Unsafe_arrayBaseOffset0(JNIEnv*, jclass, jclass) {
+ return Array::DataOffset().Int32Value();
+}
+
+jint Unsafe_arrayIndexScale0(JNIEnv* env, jclass, jclass javaClass) {
+ Class* c = Decode<Class*>(env, javaClass);
+ return c->GetComponentSize();
+}
+
+jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint expectedValue, jint newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
+ // Note: android_atomic_release_cas() returns 0 on success, not failure.
+ int result = android_atomic_release_cas(expectedValue, newValue, address);
+ return (result == 0);
+}
+
+jboolean Unsafe_compareAndSwapLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong expectedValue, jlong newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int64_t* address = reinterpret_cast<volatile int64_t*>(raw_addr);
+ // Note: android_atomic_cmpxchg() returns 0 on success, not failure.
+ int result = QuasiAtomicCas64(expectedValue, newValue, address);
+ return (result == 0);
+}
+
+jboolean Unsafe_compareAndSwapObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaExpectedValue, jobject javaNewValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ Object* expectedValue = Decode<Object*>(env, javaExpectedValue);
+ Object* newValue = Decode<Object*>(env, javaNewValue);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ int32_t* address = reinterpret_cast<int32_t*>(raw_addr);
+ // Note: android_atomic_cmpxchg() returns 0 on success, not failure.
+ int result = android_atomic_release_cas(reinterpret_cast<int32_t>(expectedValue),
+ reinterpret_cast<int32_t>(newValue), address);
+ Heap::WriteBarrier(obj);
+ return (result == 0);
+}
+
+jint Unsafe_getIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
+ return android_atomic_acquire_load(address);
+}
+
+void Unsafe_putIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
+ android_atomic_release_store(newValue, address);
+}
+
+jlong Unsafe_getLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int64_t* address = reinterpret_cast<volatile int64_t*>(raw_addr);
+ DCHECK_EQ(offset & 7, 0);
+ return QuasiAtomicRead64(address);
+}
+
+void Unsafe_putLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int64_t* address = reinterpret_cast<volatile int64_t*>(raw_addr);
+ DCHECK_EQ(offset & 7, 0);
+ QuasiAtomicSwap64(newValue, address);
+}
+
+jobject Unsafe_getObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
+ Object* value = reinterpret_cast<Object*>(android_atomic_acquire_load(address));
+ return AddLocalReference<jobject>(env, value);
+}
+
+void Unsafe_putObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ Object* newValue = Decode<Object*>(env, javaNewValue);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
+ android_atomic_release_store(reinterpret_cast<int32_t>(newValue), address);
+ Heap::WriteBarrier(obj);
+}
+
+jint Unsafe_getInt(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ int32_t* address = reinterpret_cast<int32_t*>(raw_addr);
+ return *address;
+}
+
+void Unsafe_putInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ int32_t* address = reinterpret_cast<int32_t*>(raw_addr);
+ *address = newValue;
+}
+
+void Unsafe_putOrderedInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ int32_t* address = reinterpret_cast<int32_t*>(raw_addr);
+ ANDROID_MEMBAR_STORE();
+ *address = newValue;
+}
+
+jlong Unsafe_getLong(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ int64_t* address = reinterpret_cast<int64_t*>(raw_addr);
+ return *address;
+}
+
+void Unsafe_putLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ int64_t* address = reinterpret_cast<int64_t*>(raw_addr);
+ *address = newValue;
+}
+
+void Unsafe_putOrderedLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ int64_t* address = reinterpret_cast<int64_t*>(raw_addr);
+ ANDROID_MEMBAR_STORE();
+ *address = newValue;
+}
+
+jobject Unsafe_getObject(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ Object** address = reinterpret_cast<Object**>(raw_addr);
+ return AddLocalReference<jobject>(env, *address);
+}
+
+void Unsafe_putObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ Object* newValue = Decode<Object*>(env, javaNewValue);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ Object** address = reinterpret_cast<Object**>(raw_addr);
+ *address = newValue;
+ Heap::WriteBarrier(obj);
+}
+
+void Unsafe_putOrderedObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
+ Object* obj = Decode<Object*>(env, javaObj);
+ Object* newValue = Decode<Object*>(env, javaNewValue);
+ byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
+ Object** address = reinterpret_cast<Object**>(raw_addr);
+ ANDROID_MEMBAR_STORE();
+ *address = newValue;
+ Heap::WriteBarrier(obj);
+}
+
+JNINativeMethod gMethods[] = {
+ NATIVE_METHOD(Unsafe, objectFieldOffset0, "(Ljava/lang/reflect/Field;)J"),
+ NATIVE_METHOD(Unsafe, arrayBaseOffset0, "(Ljava/lang/Class;)I"),
+ NATIVE_METHOD(Unsafe, arrayIndexScale0, "(Ljava/lang/Class;)I"),
+ NATIVE_METHOD(Unsafe, compareAndSwapInt, "(Ljava/lang/Object;JII)Z"),
+ NATIVE_METHOD(Unsafe, compareAndSwapLong, "(Ljava/lang/Object;JJJ)Z"),
+ NATIVE_METHOD(Unsafe, compareAndSwapObject, "(Ljava/lang/Object;JLjava/lang/Object;Ljava/lang/Object;)Z"),
+ NATIVE_METHOD(Unsafe, getIntVolatile, "(Ljava/lang/Object;J)I"),
+ NATIVE_METHOD(Unsafe, putIntVolatile, "(Ljava/lang/Object;JI)V"),
+ NATIVE_METHOD(Unsafe, getLongVolatile, "(Ljava/lang/Object;J)J"),
+ NATIVE_METHOD(Unsafe, putLongVolatile, "(Ljava/lang/Object;JJ)V"),
+ NATIVE_METHOD(Unsafe, getObjectVolatile, "(Ljava/lang/Object;J)Ljava/lang/Object;"),
+ NATIVE_METHOD(Unsafe, putObjectVolatile, "(Ljava/lang/Object;JLjava/lang/Object;)V"),
+ NATIVE_METHOD(Unsafe, getInt, "(Ljava/lang/Object;J)I"),
+ NATIVE_METHOD(Unsafe, putInt, "(Ljava/lang/Object;JI)V"),
+ NATIVE_METHOD(Unsafe, putOrderedInt, "(Ljava/lang/Object;JI)V"),
+ NATIVE_METHOD(Unsafe, getLong, "(Ljava/lang/Object;J)J"),
+ NATIVE_METHOD(Unsafe, putLong, "(Ljava/lang/Object;JJ)V"),
+ NATIVE_METHOD(Unsafe, putOrderedLong, "(Ljava/lang/Object;JJ)V"),
+ NATIVE_METHOD(Unsafe, getObject, "(Ljava/lang/Object;J)Ljava/lang/Object;"),
+ NATIVE_METHOD(Unsafe, putObject, "(Ljava/lang/Object;JLjava/lang/Object;)V"),
+ NATIVE_METHOD(Unsafe, putOrderedObject, "(Ljava/lang/Object;JLjava/lang/Object;)V"),
+};
+
+} // namespace
+
+void register_sun_misc_Unsafe(JNIEnv* env) {
+ jniRegisterNativeMethods(env, "sun/misc/Unsafe", gMethods, NELEM(gMethods));
+}
+
+} // namespace art