sun_misc_Unsafe.cc revision 5abc6f913bc77aa3b9c05ad07905d4c1c28b2661
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, size_t size) 297 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 298 const T* src = reinterpret_cast<T*>(srcAddr); 299 size_t sz = size / sizeof(T); 300 for (size_t i = 0; i < sz; ++i) { 301 array->Set(i, *(src + i)); 302 } 303} 304 305template<typename T> 306static void copyFromArray(jlong dstAddr, mirror::PrimitiveArray<T>* array, size_t size) 307 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){ 308 T* dst = reinterpret_cast<T*>(dstAddr); 309 size_t sz = size / sizeof(T); 310 for (size_t i = 0; i < sz; ++i) { 311 *(dst + i) = array->Get(i); 312 } 313} 314 315static void Unsafe_copyMemoryToPrimitiveArray(JNIEnv *env, 316 jobject unsafe, 317 jlong srcAddr, 318 jobject dstObj, 319 jlong dstOffset, 320 jlong size) { 321 ScopedObjectAccess soa(env); 322 if (size == 0) { 323 return; 324 } 325 // size is nonnegative and fits into size_t 326 if (size < 0 || size != (jlong)(size_t) size) { 327 ThrowIllegalAccessException(nullptr, "wrong number of bytes"); 328 } 329 size_t sz = (size_t)size; 330 mirror::Object* dst = soa.Decode<mirror::Object*>(dstObj); 331 mirror::Class* component_type = dst->GetClass()->GetComponentType(); 332 if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) { 333 copyToArray(srcAddr, dst->AsByteSizedArray(), sz); 334 } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) { 335 copyToArray(srcAddr, dst->AsShortSizedArray(), sz); 336 } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) { 337 copyToArray(srcAddr, dst->AsIntArray(), sz); 338 } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) { 339 copyToArray(srcAddr, dst->AsLongArray(), sz); 340 } else { 341 ThrowIllegalAccessException(nullptr, "not a primitive array"); 342 } 343} 344 345static void Unsafe_copyMemoryFromPrimitiveArray(JNIEnv *env, 346 jobject unsafe, 347 jobject srcObj, 348 jlong srcOffset, 349 jlong dstAddr, 350 jlong size) { 351 ScopedObjectAccess soa(env); 352 if (size == 0) { 353 return; 354 } 355 // size is nonnegative and fits into size_t 356 if (size < 0 || size != (jlong)(size_t) size) { 357 ThrowIllegalAccessException(nullptr, "wrong number of bytes"); 358 } 359 size_t sz = (size_t)size; 360 mirror::Object* src = soa.Decode<mirror::Object*>(srcObj); 361 mirror::Class* component_type = src->GetClass()->GetComponentType(); 362 if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) { 363 copyFromArray(dstAddr, src->AsByteSizedArray(), sz); 364 } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) { 365 copyFromArray(dstAddr, src->AsShortSizedArray(), sz); 366 } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) { 367 copyFromArray(dstAddr, src->AsIntArray(), sz); 368 } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) { 369 copyFromArray(dstAddr, src->AsLongArray(), sz); 370 } else { 371 ThrowIllegalAccessException(nullptr, "not a primitive array"); 372 } 373} 374static jboolean Unsafe_getBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset) { 375 ScopedFastNativeObjectAccess soa(env); 376 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 377 return obj->GetField8(MemberOffset(offset)); 378} 379 380static void Unsafe_putBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset, jboolean newValue) { 381 ScopedFastNativeObjectAccess soa(env); 382 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 383 // JNI must use non transactional mode (SetField8 is non-transactional). 384 obj->SetField8(MemberOffset(offset), newValue); 385} 386 387static jbyte Unsafe_getByte(JNIEnv* env, jobject, jobject javaObj, jlong offset) { 388 ScopedFastNativeObjectAccess soa(env); 389 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 390 return obj->GetField8(MemberOffset(offset)); 391} 392 393static void Unsafe_putByte(JNIEnv* env, jobject, jobject javaObj, jlong offset, jbyte newValue) { 394 ScopedFastNativeObjectAccess soa(env); 395 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 396 // JNI must use non transactional mode. 397 obj->SetField8(MemberOffset(offset), newValue); 398} 399 400static jchar Unsafe_getChar(JNIEnv* env, jobject, jobject javaObj, jlong offset) { 401 ScopedFastNativeObjectAccess soa(env); 402 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 403 return obj->GetField16(MemberOffset(offset)); 404} 405 406static void Unsafe_putChar(JNIEnv* env, jobject, jobject javaObj, jlong offset, jchar newValue) { 407 ScopedFastNativeObjectAccess soa(env); 408 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 409 // JNI must use non transactional mode. 410 obj->SetField16(MemberOffset(offset), newValue); 411} 412 413static jshort Unsafe_getShort(JNIEnv* env, jobject, jobject javaObj, jlong offset) { 414 ScopedFastNativeObjectAccess soa(env); 415 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 416 return obj->GetField16(MemberOffset(offset)); 417} 418 419static void Unsafe_putShort(JNIEnv* env, jobject, jobject javaObj, jlong offset, jshort newValue) { 420 ScopedFastNativeObjectAccess soa(env); 421 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 422 // JNI must use non transactional mode. 423 obj->SetField16<false>(MemberOffset(offset), newValue); 424} 425 426static jfloat Unsafe_getFloat(JNIEnv* env, jobject, jobject javaObj, jlong offset) { 427 ScopedFastNativeObjectAccess soa(env); 428 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 429 return obj->GetField32(MemberOffset(offset)); 430} 431 432static void Unsafe_putFloat(JNIEnv* env, jobject, jobject javaObj, jlong offset, jfloat newValue) { 433 ScopedFastNativeObjectAccess soa(env); 434 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 435 // JNI must use non transactional mode. 436 obj->SetField32<false>(MemberOffset(offset), newValue); 437} 438 439static jdouble Unsafe_getDouble(JNIEnv* env, jobject, jobject javaObj, jlong offset) { 440 ScopedFastNativeObjectAccess soa(env); 441 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 442 return obj->GetField64(MemberOffset(offset)); 443} 444 445static void Unsafe_putDouble(JNIEnv* env, jobject, jobject javaObj, jlong offset, jdouble newValue) { 446 ScopedFastNativeObjectAccess soa(env); 447 mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); 448 // JNI must use non transactional mode. 449 obj->SetField64<false>(MemberOffset(offset), newValue); 450} 451 452static JNINativeMethod gMethods[] = { 453 NATIVE_METHOD(Unsafe, compareAndSwapInt, "!(Ljava/lang/Object;JII)Z"), 454 NATIVE_METHOD(Unsafe, compareAndSwapLong, "!(Ljava/lang/Object;JJJ)Z"), 455 NATIVE_METHOD(Unsafe, compareAndSwapObject, "!(Ljava/lang/Object;JLjava/lang/Object;Ljava/lang/Object;)Z"), 456 NATIVE_METHOD(Unsafe, getIntVolatile, "!(Ljava/lang/Object;J)I"), 457 NATIVE_METHOD(Unsafe, putIntVolatile, "!(Ljava/lang/Object;JI)V"), 458 NATIVE_METHOD(Unsafe, getLongVolatile, "!(Ljava/lang/Object;J)J"), 459 NATIVE_METHOD(Unsafe, putLongVolatile, "!(Ljava/lang/Object;JJ)V"), 460 NATIVE_METHOD(Unsafe, getObjectVolatile, "!(Ljava/lang/Object;J)Ljava/lang/Object;"), 461 NATIVE_METHOD(Unsafe, putObjectVolatile, "!(Ljava/lang/Object;JLjava/lang/Object;)V"), 462 NATIVE_METHOD(Unsafe, getInt, "!(Ljava/lang/Object;J)I"), 463 NATIVE_METHOD(Unsafe, putInt, "!(Ljava/lang/Object;JI)V"), 464 NATIVE_METHOD(Unsafe, putOrderedInt, "!(Ljava/lang/Object;JI)V"), 465 NATIVE_METHOD(Unsafe, getLong, "!(Ljava/lang/Object;J)J"), 466 NATIVE_METHOD(Unsafe, putLong, "!(Ljava/lang/Object;JJ)V"), 467 NATIVE_METHOD(Unsafe, putOrderedLong, "!(Ljava/lang/Object;JJ)V"), 468 NATIVE_METHOD(Unsafe, getObject, "!(Ljava/lang/Object;J)Ljava/lang/Object;"), 469 NATIVE_METHOD(Unsafe, putObject, "!(Ljava/lang/Object;JLjava/lang/Object;)V"), 470 NATIVE_METHOD(Unsafe, putOrderedObject, "!(Ljava/lang/Object;JLjava/lang/Object;)V"), 471 NATIVE_METHOD(Unsafe, getArrayBaseOffsetForComponentType, "!(Ljava/lang/Class;)I"), 472 NATIVE_METHOD(Unsafe, getArrayIndexScaleForComponentType, "!(Ljava/lang/Class;)I"), 473 NATIVE_METHOD(Unsafe, addressSize, "!()I"), 474 NATIVE_METHOD(Unsafe, pageSize, "!()I"), 475 NATIVE_METHOD(Unsafe, allocateMemory, "!(J)J"), 476 NATIVE_METHOD(Unsafe, freeMemory, "!(J)V"), 477 NATIVE_METHOD(Unsafe, setMemory, "!(JJB)V"), 478 NATIVE_METHOD(Unsafe, getByte$, "!(J)B"), 479 NATIVE_METHOD(Unsafe, putByte$, "!(JB)V"), 480 NATIVE_METHOD(Unsafe, getShort$, "!(J)S"), 481 NATIVE_METHOD(Unsafe, putShort$, "!(JS)V"), 482 NATIVE_METHOD(Unsafe, getChar$, "!(J)C"), 483 NATIVE_METHOD(Unsafe, putChar$, "!(JC)V"), 484 NATIVE_METHOD(Unsafe, getInt$, "!(J)I"), 485 NATIVE_METHOD(Unsafe, putInt$, "!(JI)V"), 486 NATIVE_METHOD(Unsafe, getLong$, "!(J)J"), 487 NATIVE_METHOD(Unsafe, putLong$, "!(JJ)V"), 488 NATIVE_METHOD(Unsafe, getFloat$, "!(J)F"), 489 NATIVE_METHOD(Unsafe, putFloat$, "!(JF)V"), 490 NATIVE_METHOD(Unsafe, getDouble$, "!(J)D"), 491 NATIVE_METHOD(Unsafe, putDouble$, "!(JD)V"), 492 NATIVE_METHOD(Unsafe, getAddress, "!(J)J"), 493 NATIVE_METHOD(Unsafe, copyMemory, "!(JJJ)V"), 494 NATIVE_METHOD(Unsafe, copyMemoryToPrimitiveArray, "!(JLjava/lang/Object;JJ)V"), 495 NATIVE_METHOD(Unsafe, copyMemoryFromPrimitiveArray, "!(Ljava/lang/Object;JJJ)V"), 496 NATIVE_METHOD(Unsafe, getBoolean, "!(Ljava/lang/Object;J)Z"), 497 NATIVE_METHOD(Unsafe, getByte, "!(Ljava/lang/Object;J)B"), 498 NATIVE_METHOD(Unsafe, getChar, "!(Ljava/lang/Object;J)C"), 499 NATIVE_METHOD(Unsafe, getShort, "!(Ljava/lang/Object;J)S"), 500 NATIVE_METHOD(Unsafe, getFloat, "!(Ljava/lang/Object;J)F"), 501 NATIVE_METHOD(Unsafe, getDouble, "!(Ljava/lang/Object;J)D"), 502 NATIVE_METHOD(Unsafe, putBoolean, "!(Ljava/lang/Object;JZ)V"), 503 NATIVE_METHOD(Unsafe, putByte, "!(Ljava/lang/Object;JB)V"), 504 NATIVE_METHOD(Unsafe, putChar, "!(Ljava/lang/Object;JC)V"), 505 NATIVE_METHOD(Unsafe, putShort, "!(Ljava/lang/Object;JS)V"), 506 NATIVE_METHOD(Unsafe, putFloat, "!(Ljava/lang/Object;JF)V"), 507 NATIVE_METHOD(Unsafe, putDouble, "!(Ljava/lang/Object;JD)V"), 508}; 509 510void register_sun_misc_Unsafe(JNIEnv* env) { 511 REGISTER_NATIVE_METHODS("sun/misc/Unsafe"); 512} 513 514} // namespace art 515