sun_misc_Unsafe.cc revision 5c4042222fef6bca942a229a464b233d5ca89a84 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "common_throws.h"
18#include "gc/accounting/card_table-inl.h"
19#include "jni_internal.h"
20#include "mirror/array.h"
21#include "mirror/object.h"
22#include "mirror/object-inl.h"
23#include "scoped_fast_native_object_access.h"
24
25#include <unistd.h>
26#include <stdlib.h>
27#include <string.h>
28
29namespace art {
30
31static jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset,
32                                         jint expectedValue, jint newValue) {
33  ScopedFastNativeObjectAccess soa(env);
34  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
35  // JNI must use non transactional mode.
36  bool success = obj->CasFieldStrongSequentiallyConsistent32<false>(MemberOffset(offset),
37                                                                    expectedValue, newValue);
38  return success ? JNI_TRUE : JNI_FALSE;
39}
40
41static jboolean Unsafe_compareAndSwapLong(JNIEnv* env, jobject, jobject javaObj, jlong offset,
42                                          jlong expectedValue, jlong newValue) {
43  ScopedFastNativeObjectAccess soa(env);
44  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
45  // JNI must use non transactional mode.
46  bool success = obj->CasFieldStrongSequentiallyConsistent64<false>(MemberOffset(offset),
47                                                                    expectedValue, newValue);
48  return success ? JNI_TRUE : JNI_FALSE;
49}
50
51static jboolean Unsafe_compareAndSwapObject(JNIEnv* env, jobject, jobject javaObj, jlong offset,
52                                            jobject javaExpectedValue, jobject javaNewValue) {
53  ScopedFastNativeObjectAccess soa(env);
54  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
55  mirror::Object* expectedValue = soa.Decode<mirror::Object*>(javaExpectedValue);
56  mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
57  // JNI must use non transactional mode.
58  bool success = obj->CasFieldStrongSequentiallyConsistentObject<false>(MemberOffset(offset),
59                                                                        expectedValue, newValue);
60  return success ? JNI_TRUE : JNI_FALSE;
61}
62
63static jint Unsafe_getInt(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
64  ScopedFastNativeObjectAccess soa(env);
65  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
66  return obj->GetField32(MemberOffset(offset));
67}
68
69static jint Unsafe_getIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
70  ScopedFastNativeObjectAccess soa(env);
71  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
72  return obj->GetField32Volatile(MemberOffset(offset));
73}
74
75static void Unsafe_putInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
76  ScopedFastNativeObjectAccess soa(env);
77  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
78  // JNI must use non transactional mode.
79  obj->SetField32<false>(MemberOffset(offset), newValue);
80}
81
82static void Unsafe_putIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset,
83                                  jint newValue) {
84  ScopedFastNativeObjectAccess soa(env);
85  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
86  // JNI must use non transactional mode.
87  obj->SetField32Volatile<false>(MemberOffset(offset), newValue);
88}
89
90static void Unsafe_putOrderedInt(JNIEnv* env, jobject, jobject javaObj, jlong offset,
91                                 jint newValue) {
92  ScopedFastNativeObjectAccess soa(env);
93  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
94  QuasiAtomic::ThreadFenceRelease();
95  // JNI must use non transactional mode.
96  obj->SetField32<false>(MemberOffset(offset), newValue);
97}
98
99static jlong Unsafe_getLong(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
100  ScopedFastNativeObjectAccess soa(env);
101  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
102  return obj->GetField64(MemberOffset(offset));
103}
104
105static jlong Unsafe_getLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
106  ScopedFastNativeObjectAccess soa(env);
107  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
108  return obj->GetField64Volatile(MemberOffset(offset));
109}
110
111static void Unsafe_putLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
112  ScopedFastNativeObjectAccess soa(env);
113  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
114  // JNI must use non transactional mode.
115  obj->SetField64<false>(MemberOffset(offset), newValue);
116}
117
118static void Unsafe_putLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset,
119                                   jlong newValue) {
120  ScopedFastNativeObjectAccess soa(env);
121  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
122  // JNI must use non transactional mode.
123  obj->SetField64Volatile<false>(MemberOffset(offset), newValue);
124}
125
126static void Unsafe_putOrderedLong(JNIEnv* env, jobject, jobject javaObj, jlong offset,
127                                  jlong newValue) {
128  ScopedFastNativeObjectAccess soa(env);
129  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
130  QuasiAtomic::ThreadFenceRelease();
131  // JNI must use non transactional mode.
132  obj->SetField64<false>(MemberOffset(offset), newValue);
133}
134
135static jobject Unsafe_getObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
136  ScopedFastNativeObjectAccess soa(env);
137  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
138  mirror::Object* value = obj->GetFieldObjectVolatile<mirror::Object>(MemberOffset(offset));
139  return soa.AddLocalReference<jobject>(value);
140}
141
142static jobject Unsafe_getObject(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
143  ScopedFastNativeObjectAccess soa(env);
144  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
145  mirror::Object* value = obj->GetFieldObject<mirror::Object>(MemberOffset(offset));
146  return soa.AddLocalReference<jobject>(value);
147}
148
149static void Unsafe_putObject(JNIEnv* env, jobject, jobject javaObj, jlong offset,
150                             jobject javaNewValue) {
151  ScopedFastNativeObjectAccess soa(env);
152  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
153  mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
154  // JNI must use non transactional mode.
155  obj->SetFieldObject<false>(MemberOffset(offset), newValue);
156}
157
158static void Unsafe_putObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset,
159                                     jobject javaNewValue) {
160  ScopedFastNativeObjectAccess soa(env);
161  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
162  mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
163  // JNI must use non transactional mode.
164  obj->SetFieldObjectVolatile<false>(MemberOffset(offset), newValue);
165}
166
167static void Unsafe_putOrderedObject(JNIEnv* env, jobject, jobject javaObj, jlong offset,
168                                    jobject javaNewValue) {
169  ScopedFastNativeObjectAccess soa(env);
170  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
171  mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
172  QuasiAtomic::ThreadFenceRelease();
173  // JNI must use non transactional mode.
174  obj->SetFieldObject<false>(MemberOffset(offset), newValue);
175}
176
177static jint Unsafe_getArrayBaseOffsetForComponentType(JNIEnv* env, jclass, jobject component_class) {
178  ScopedFastNativeObjectAccess soa(env);
179  mirror::Class* component = soa.Decode<mirror::Class*>(component_class);
180  Primitive::Type primitive_type = component->GetPrimitiveType();
181  return mirror::Array::DataOffset(Primitive::ComponentSize(primitive_type)).Int32Value();
182}
183
184static jint Unsafe_getArrayIndexScaleForComponentType(JNIEnv* env, jclass, jobject component_class) {
185  ScopedFastNativeObjectAccess soa(env);
186  mirror::Class* component = soa.Decode<mirror::Class*>(component_class);
187  Primitive::Type primitive_type = component->GetPrimitiveType();
188  return Primitive::ComponentSize(primitive_type);
189}
190
191static jint Unsafe_addressSize(JNIEnv* env, jobject) {
192  return sizeof(void*);
193}
194
195static jint Unsafe_pageSize(JNIEnv* env, jobject) {
196  return sysconf(_SC_PAGESIZE);
197}
198
199static jlong Unsafe_allocateMemory(JNIEnv* env, jobject, jlong bytes) {
200  ScopedFastNativeObjectAccess soa(env);
201  // bytes is nonnegative and fits into size_t
202  if (bytes < 0 || bytes != (jlong)(size_t) bytes) {
203    ThrowIllegalAccessException(nullptr, "wrong number of bytes");
204    return 0;
205  }
206  void* mem = malloc(bytes);
207  if (mem == nullptr) {
208    soa.Self()->ThrowOutOfMemoryError("native alloc");
209    return 0;
210  }
211  return (uintptr_t) mem;
212}
213
214static void Unsafe_freeMemory(JNIEnv* env, jobject, jlong address) {
215  free((void*)(uintptr_t)address);
216}
217
218static void Unsafe_setMemory(JNIEnv* env, jobject, jlong address, jlong bytes, jbyte value) {
219  memset((void*)(uintptr_t)address, value, bytes);
220}
221
222static jbyte Unsafe_getByte$(JNIEnv* env, jobject, jlong address) {
223  return *reinterpret_cast<jbyte*>(address);
224}
225
226static void Unsafe_putByte$(JNIEnv* env, jobject, jlong address, jbyte value) {
227  *reinterpret_cast<jbyte*>(address) = value;
228}
229
230static jshort Unsafe_getShort$(JNIEnv* env, jobject, jlong address) {
231  return *reinterpret_cast<jshort*>(address);
232}
233
234static void Unsafe_putShort$(JNIEnv* env, jobject, jlong address, jshort value) {
235  *reinterpret_cast<jshort*>(address) = value;
236}
237
238static jchar Unsafe_getChar$(JNIEnv* env, jobject, jlong address) {
239  return *reinterpret_cast<jchar*>(address);
240}
241
242static void Unsafe_putChar$(JNIEnv* env, jobject, jlong address, jchar value) {
243  *reinterpret_cast<jchar*>(address) = value;
244}
245
246static jint Unsafe_getInt$(JNIEnv* env, jobject, jlong address) {
247  return *reinterpret_cast<jint*>(address);
248}
249
250static void Unsafe_putInt$(JNIEnv* env, jobject, jlong address, jint value) {
251  *reinterpret_cast<jint*>(address) = value;
252}
253
254static jlong Unsafe_getLong$(JNIEnv* env, jobject, jlong address) {
255  return *reinterpret_cast<jlong*>(address);
256}
257
258static void Unsafe_putLong$(JNIEnv* env, jobject, jlong address, jlong value) {
259  *reinterpret_cast<jlong*>(address) = value;
260}
261
262static jfloat Unsafe_getFloat$(JNIEnv* env, jobject, jlong address) {
263  return *reinterpret_cast<jfloat*>(address);
264}
265
266static void Unsafe_putFloat$(JNIEnv* env, jobject, jlong address, jfloat value) {
267  *reinterpret_cast<jfloat*>(address) = value;
268}
269static jdouble Unsafe_getDouble$(JNIEnv* env, jobject, jlong address) {
270  return *reinterpret_cast<jdouble*>(address);
271}
272
273static void Unsafe_putDouble$(JNIEnv* env, jobject, jlong address, jdouble value) {
274  *reinterpret_cast<jdouble*>(address) = value;
275}
276
277static jlong Unsafe_getAddress(JNIEnv* env, jobject, jlong address) {
278  void* p = (void*)(uintptr_t)address;
279  return (uintptr_t)(*(void**)p);
280}
281
282static void Unsafe_copyMemory(JNIEnv *env, jobject unsafe, jlong src, jlong dst, jlong size) {
283    if (size == 0) {
284        return;
285    }
286    // size is nonnegative and fits into size_t
287    if (size < 0 || size != (jlong)(size_t) size) {
288        ScopedFastNativeObjectAccess soa(env);
289        ThrowIllegalAccessException(nullptr, "wrong number of bytes");
290    }
291    size_t sz = (size_t)size;
292    memcpy(reinterpret_cast<void *>(dst), reinterpret_cast<void *>(src), sz);
293}
294
295template<typename T>
296static void copyToArray(jlong srcAddr, mirror::PrimitiveArray<T>* array,
297                        size_t array_offset,
298                        size_t size)
299      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
300    const T* src = reinterpret_cast<T*>(srcAddr);
301    size_t sz = size / sizeof(T);
302    size_t of = array_offset / sizeof(T);
303    for (size_t i = 0; i < sz; ++i) {
304        array->Set(i + of, *(src + i));
305    }
306}
307
308template<typename T>
309static void copyFromArray(jlong dstAddr, mirror::PrimitiveArray<T>* array,
310                          size_t array_offset,
311                          size_t size)
312        SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
313    T* dst = reinterpret_cast<T*>(dstAddr);
314    size_t sz = size / sizeof(T);
315    size_t of = array_offset / sizeof(T);
316    for (size_t i = 0; i < sz; ++i) {
317        *(dst + i) = array->Get(i + of);
318    }
319}
320
321static void Unsafe_copyMemoryToPrimitiveArray(JNIEnv *env,
322                                              jobject unsafe,
323                                              jlong srcAddr,
324                                              jobject dstObj,
325                                              jlong dstOffset,
326                                              jlong size) {
327    ScopedObjectAccess soa(env);
328    if (size == 0) {
329        return;
330    }
331    // size is nonnegative and fits into size_t
332    if (size < 0 || size != (jlong)(size_t) size) {
333        ThrowIllegalAccessException(nullptr, "wrong number of bytes");
334    }
335    size_t sz = (size_t)size;
336    size_t dst_offset = (size_t)dstOffset;
337    mirror::Object* dst = soa.Decode<mirror::Object*>(dstObj);
338    mirror::Class* component_type = dst->GetClass()->GetComponentType();
339    if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
340        copyToArray(srcAddr, dst->AsByteSizedArray(), dst_offset, sz);
341    } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) {
342        copyToArray(srcAddr, dst->AsShortSizedArray(), dst_offset, sz);
343    } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) {
344        copyToArray(srcAddr, dst->AsIntArray(), dst_offset, sz);
345    } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) {
346        copyToArray(srcAddr, dst->AsLongArray(), dst_offset, sz);
347    } else {
348        ThrowIllegalAccessException(nullptr, "not a primitive array");
349    }
350}
351
352static void Unsafe_copyMemoryFromPrimitiveArray(JNIEnv *env,
353                                                jobject unsafe,
354                                                jobject srcObj,
355                                                jlong srcOffset,
356                                                jlong dstAddr,
357                                                jlong size) {
358    ScopedObjectAccess soa(env);
359    if (size == 0) {
360        return;
361    }
362    // size is nonnegative and fits into size_t
363    if (size < 0 || size != (jlong)(size_t) size) {
364        ThrowIllegalAccessException(nullptr, "wrong number of bytes");
365    }
366    size_t sz = (size_t)size;
367    size_t src_offset = (size_t)srcOffset;
368    mirror::Object* src = soa.Decode<mirror::Object*>(srcObj);
369    mirror::Class* component_type = src->GetClass()->GetComponentType();
370    if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
371        copyFromArray(dstAddr, src->AsByteSizedArray(), src_offset, sz);
372    } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) {
373        copyFromArray(dstAddr, src->AsShortSizedArray(), src_offset, sz);
374    } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) {
375        copyFromArray(dstAddr, src->AsIntArray(), src_offset, sz);
376    } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) {
377        copyFromArray(dstAddr, src->AsLongArray(), src_offset, sz);
378    } else {
379        ThrowIllegalAccessException(nullptr, "not a primitive array");
380    }
381}
382static jboolean Unsafe_getBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
383    ScopedFastNativeObjectAccess soa(env);
384    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
385    return obj->GetField8(MemberOffset(offset));
386}
387
388static void Unsafe_putBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset, jboolean newValue) {
389    ScopedFastNativeObjectAccess soa(env);
390    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
391    // JNI must use non transactional mode (SetField8 is non-transactional).
392    obj->SetField8(MemberOffset(offset), newValue);
393}
394
395static jbyte Unsafe_getByte(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
396    ScopedFastNativeObjectAccess soa(env);
397    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
398    return obj->GetField8(MemberOffset(offset));
399}
400
401static void Unsafe_putByte(JNIEnv* env, jobject, jobject javaObj, jlong offset, jbyte newValue) {
402    ScopedFastNativeObjectAccess soa(env);
403    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
404    // JNI must use non transactional mode.
405    obj->SetField8(MemberOffset(offset), newValue);
406}
407
408static jchar Unsafe_getChar(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
409    ScopedFastNativeObjectAccess soa(env);
410    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
411    return obj->GetField16(MemberOffset(offset));
412}
413
414static void Unsafe_putChar(JNIEnv* env, jobject, jobject javaObj, jlong offset, jchar newValue) {
415    ScopedFastNativeObjectAccess soa(env);
416    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
417    // JNI must use non transactional mode.
418    obj->SetField16(MemberOffset(offset), newValue);
419}
420
421static jshort Unsafe_getShort(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
422    ScopedFastNativeObjectAccess soa(env);
423    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
424    return obj->GetField16(MemberOffset(offset));
425}
426
427static void Unsafe_putShort(JNIEnv* env, jobject, jobject javaObj, jlong offset, jshort newValue) {
428    ScopedFastNativeObjectAccess soa(env);
429    mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
430    // JNI must use non transactional mode.
431    obj->SetField16<false>(MemberOffset(offset), newValue);
432}
433
434static jfloat Unsafe_getFloat(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
435  ScopedFastNativeObjectAccess soa(env);
436  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
437  union {int32_t val; jfloat converted;} conv;
438  conv.val = obj->GetField32(MemberOffset(offset));
439  return conv.converted;
440}
441
442static void Unsafe_putFloat(JNIEnv* env, jobject, jobject javaObj, jlong offset, jfloat newValue) {
443  ScopedFastNativeObjectAccess soa(env);
444  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
445  union {int32_t converted; jfloat val;} conv;
446  conv.val = newValue;
447  // JNI must use non transactional mode.
448  obj->SetField32<false>(MemberOffset(offset), conv.converted);
449}
450
451static jdouble Unsafe_getDouble(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
452  ScopedFastNativeObjectAccess soa(env);
453  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
454  union {int64_t val; jdouble converted;} conv;
455  conv.val = obj->GetField64(MemberOffset(offset));
456  return conv.converted;
457}
458
459static void Unsafe_putDouble(JNIEnv* env, jobject, jobject javaObj, jlong offset, jdouble newValue) {
460  ScopedFastNativeObjectAccess soa(env);
461  mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
462  union {int64_t converted; jdouble val;} conv;
463  conv.val = newValue;
464  // JNI must use non transactional mode.
465  obj->SetField64<false>(MemberOffset(offset), conv.converted);
466}
467
468static JNINativeMethod gMethods[] = {
469  NATIVE_METHOD(Unsafe, compareAndSwapInt, "!(Ljava/lang/Object;JII)Z"),
470  NATIVE_METHOD(Unsafe, compareAndSwapLong, "!(Ljava/lang/Object;JJJ)Z"),
471  NATIVE_METHOD(Unsafe, compareAndSwapObject, "!(Ljava/lang/Object;JLjava/lang/Object;Ljava/lang/Object;)Z"),
472  NATIVE_METHOD(Unsafe, getIntVolatile, "!(Ljava/lang/Object;J)I"),
473  NATIVE_METHOD(Unsafe, putIntVolatile, "!(Ljava/lang/Object;JI)V"),
474  NATIVE_METHOD(Unsafe, getLongVolatile, "!(Ljava/lang/Object;J)J"),
475  NATIVE_METHOD(Unsafe, putLongVolatile, "!(Ljava/lang/Object;JJ)V"),
476  NATIVE_METHOD(Unsafe, getObjectVolatile, "!(Ljava/lang/Object;J)Ljava/lang/Object;"),
477  NATIVE_METHOD(Unsafe, putObjectVolatile, "!(Ljava/lang/Object;JLjava/lang/Object;)V"),
478  NATIVE_METHOD(Unsafe, getInt, "!(Ljava/lang/Object;J)I"),
479  NATIVE_METHOD(Unsafe, putInt, "!(Ljava/lang/Object;JI)V"),
480  NATIVE_METHOD(Unsafe, putOrderedInt, "!(Ljava/lang/Object;JI)V"),
481  NATIVE_METHOD(Unsafe, getLong, "!(Ljava/lang/Object;J)J"),
482  NATIVE_METHOD(Unsafe, putLong, "!(Ljava/lang/Object;JJ)V"),
483  NATIVE_METHOD(Unsafe, putOrderedLong, "!(Ljava/lang/Object;JJ)V"),
484  NATIVE_METHOD(Unsafe, getObject, "!(Ljava/lang/Object;J)Ljava/lang/Object;"),
485  NATIVE_METHOD(Unsafe, putObject, "!(Ljava/lang/Object;JLjava/lang/Object;)V"),
486  NATIVE_METHOD(Unsafe, putOrderedObject, "!(Ljava/lang/Object;JLjava/lang/Object;)V"),
487  NATIVE_METHOD(Unsafe, getArrayBaseOffsetForComponentType, "!(Ljava/lang/Class;)I"),
488  NATIVE_METHOD(Unsafe, getArrayIndexScaleForComponentType, "!(Ljava/lang/Class;)I"),
489  NATIVE_METHOD(Unsafe, addressSize, "!()I"),
490  NATIVE_METHOD(Unsafe, pageSize, "!()I"),
491  NATIVE_METHOD(Unsafe, allocateMemory, "!(J)J"),
492  NATIVE_METHOD(Unsafe, freeMemory, "!(J)V"),
493  NATIVE_METHOD(Unsafe, setMemory, "!(JJB)V"),
494  NATIVE_METHOD(Unsafe, getByte$, "!(J)B"),
495  NATIVE_METHOD(Unsafe, putByte$, "!(JB)V"),
496  NATIVE_METHOD(Unsafe, getShort$, "!(J)S"),
497  NATIVE_METHOD(Unsafe, putShort$, "!(JS)V"),
498  NATIVE_METHOD(Unsafe, getChar$, "!(J)C"),
499  NATIVE_METHOD(Unsafe, putChar$, "!(JC)V"),
500  NATIVE_METHOD(Unsafe, getInt$, "!(J)I"),
501  NATIVE_METHOD(Unsafe, putInt$, "!(JI)V"),
502  NATIVE_METHOD(Unsafe, getLong$, "!(J)J"),
503  NATIVE_METHOD(Unsafe, putLong$, "!(JJ)V"),
504  NATIVE_METHOD(Unsafe, getFloat$, "!(J)F"),
505  NATIVE_METHOD(Unsafe, putFloat$, "!(JF)V"),
506  NATIVE_METHOD(Unsafe, getDouble$, "!(J)D"),
507  NATIVE_METHOD(Unsafe, putDouble$, "!(JD)V"),
508  NATIVE_METHOD(Unsafe, getAddress, "!(J)J"),
509  NATIVE_METHOD(Unsafe, copyMemory, "!(JJJ)V"),
510  NATIVE_METHOD(Unsafe, copyMemoryToPrimitiveArray, "!(JLjava/lang/Object;JJ)V"),
511  NATIVE_METHOD(Unsafe, copyMemoryFromPrimitiveArray, "!(Ljava/lang/Object;JJJ)V"),
512  NATIVE_METHOD(Unsafe, getBoolean, "!(Ljava/lang/Object;J)Z"),
513  NATIVE_METHOD(Unsafe, getByte, "!(Ljava/lang/Object;J)B"),
514  NATIVE_METHOD(Unsafe, getChar, "!(Ljava/lang/Object;J)C"),
515  NATIVE_METHOD(Unsafe, getShort, "!(Ljava/lang/Object;J)S"),
516  NATIVE_METHOD(Unsafe, getFloat, "!(Ljava/lang/Object;J)F"),
517  NATIVE_METHOD(Unsafe, getDouble, "!(Ljava/lang/Object;J)D"),
518  NATIVE_METHOD(Unsafe, putBoolean, "!(Ljava/lang/Object;JZ)V"),
519  NATIVE_METHOD(Unsafe, putByte, "!(Ljava/lang/Object;JB)V"),
520  NATIVE_METHOD(Unsafe, putChar, "!(Ljava/lang/Object;JC)V"),
521  NATIVE_METHOD(Unsafe, putShort, "!(Ljava/lang/Object;JS)V"),
522  NATIVE_METHOD(Unsafe, putFloat, "!(Ljava/lang/Object;JF)V"),
523  NATIVE_METHOD(Unsafe, putDouble, "!(Ljava/lang/Object;JD)V"),
524};
525
526void register_sun_misc_Unsafe(JNIEnv* env) {
527  REGISTER_NATIVE_METHODS("sun/misc/Unsafe");
528}
529
530}  // namespace art
531