Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 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 | |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 17 | #include "sun_misc_Unsafe.h" |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 18 | #include "common_throws.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 19 | #include "gc/accounting/card_table-inl.h" |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 20 | #include "jni_internal.h" |
Hiroshi Yamauchi | 4d2efce | 2014-02-10 16:19:09 -0800 | [diff] [blame] | 21 | #include "mirror/array.h" |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 22 | #include "mirror/class-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 23 | #include "mirror/object-inl.h" |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 24 | #include "scoped_fast_native_object_access.h" |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 25 | |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 26 | #include <unistd.h> |
| 27 | #include <stdlib.h> |
| 28 | #include <string.h> |
| 29 | |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 30 | namespace art { |
| 31 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 32 | static jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 33 | jint expectedValue, jint newValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 34 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 35 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 36 | // JNI must use non transactional mode. |
Hans Boehm | d843443 | 2014-07-11 09:56:07 -0700 | [diff] [blame] | 37 | bool success = obj->CasFieldStrongSequentiallyConsistent32<false>(MemberOffset(offset), |
| 38 | expectedValue, newValue); |
Ian Rogers | 9adbff5 | 2013-01-23 18:19:03 -0800 | [diff] [blame] | 39 | return success ? JNI_TRUE : JNI_FALSE; |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 40 | } |
| 41 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 42 | static jboolean Unsafe_compareAndSwapLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 43 | jlong expectedValue, jlong newValue) { |
| 44 | ScopedFastNativeObjectAccess soa(env); |
| 45 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 46 | // JNI must use non transactional mode. |
Hans Boehm | d843443 | 2014-07-11 09:56:07 -0700 | [diff] [blame] | 47 | bool success = obj->CasFieldStrongSequentiallyConsistent64<false>(MemberOffset(offset), |
| 48 | expectedValue, newValue); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 49 | return success ? JNI_TRUE : JNI_FALSE; |
| 50 | } |
| 51 | |
| 52 | static jboolean Unsafe_compareAndSwapObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 53 | jobject javaExpectedValue, jobject javaNewValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 54 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 55 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 56 | mirror::Object* expectedValue = soa.Decode<mirror::Object*>(javaExpectedValue); |
| 57 | mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 58 | // JNI must use non transactional mode. |
Hiroshi Yamauchi | cc78f3f | 2015-12-11 15:51:04 -0800 | [diff] [blame] | 59 | if (kUseReadBarrier) { |
| 60 | // Need to make sure the reference stored in the field is a to-space one before attempting the |
| 61 | // CAS or the CAS could fail incorrectly. |
| 62 | mirror::HeapReference<mirror::Object>* field_addr = |
| 63 | reinterpret_cast<mirror::HeapReference<mirror::Object>*>( |
| 64 | reinterpret_cast<uint8_t*>(obj) + static_cast<size_t>(offset)); |
| 65 | ReadBarrier::Barrier<mirror::Object, kWithReadBarrier, /*kAlwaysUpdateField*/true>( |
| 66 | obj, |
| 67 | MemberOffset(offset), |
| 68 | field_addr); |
| 69 | } |
Hans Boehm | d843443 | 2014-07-11 09:56:07 -0700 | [diff] [blame] | 70 | bool success = obj->CasFieldStrongSequentiallyConsistentObject<false>(MemberOffset(offset), |
| 71 | expectedValue, newValue); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 72 | return success ? JNI_TRUE : JNI_FALSE; |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 73 | } |
| 74 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 75 | static jint Unsafe_getInt(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 76 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 77 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 78 | return obj->GetField32(MemberOffset(offset)); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 79 | } |
| 80 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 81 | static jint Unsafe_getIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 82 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 83 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 84 | return obj->GetField32Volatile(MemberOffset(offset)); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 85 | } |
| 86 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 87 | static void Unsafe_putInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 88 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 89 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 90 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 91 | obj->SetField32<false>(MemberOffset(offset), newValue); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 92 | } |
| 93 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 94 | static void Unsafe_putIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 95 | jint newValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 96 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 97 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 98 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 99 | obj->SetField32Volatile<false>(MemberOffset(offset), newValue); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 100 | } |
| 101 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 102 | static void Unsafe_putOrderedInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 103 | jint newValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 104 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 105 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Hans Boehm | 3035961 | 2014-05-21 17:46:23 -0700 | [diff] [blame] | 106 | QuasiAtomic::ThreadFenceRelease(); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 107 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 108 | obj->SetField32<false>(MemberOffset(offset), newValue); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 109 | } |
| 110 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 111 | static jlong Unsafe_getLong(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 112 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 113 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 114 | return obj->GetField64(MemberOffset(offset)); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 115 | } |
| 116 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 117 | static jlong Unsafe_getLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 118 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 119 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 120 | return obj->GetField64Volatile(MemberOffset(offset)); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 121 | } |
| 122 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 123 | static void Unsafe_putLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 124 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 125 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 126 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 127 | obj->SetField64<false>(MemberOffset(offset), newValue); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 128 | } |
| 129 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 130 | static void Unsafe_putLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 131 | jlong newValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 132 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 133 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 134 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 135 | obj->SetField64Volatile<false>(MemberOffset(offset), newValue); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 136 | } |
| 137 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 138 | static void Unsafe_putOrderedLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 139 | jlong newValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 140 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 141 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Hans Boehm | 3035961 | 2014-05-21 17:46:23 -0700 | [diff] [blame] | 142 | QuasiAtomic::ThreadFenceRelease(); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 143 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 144 | obj->SetField64<false>(MemberOffset(offset), newValue); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 145 | } |
| 146 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 147 | static jobject Unsafe_getObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 148 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 149 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 150 | mirror::Object* value = obj->GetFieldObjectVolatile<mirror::Object>(MemberOffset(offset)); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 151 | return soa.AddLocalReference<jobject>(value); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 152 | } |
| 153 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 154 | static jobject Unsafe_getObject(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 155 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 156 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 157 | mirror::Object* value = obj->GetFieldObject<mirror::Object>(MemberOffset(offset)); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 158 | return soa.AddLocalReference<jobject>(value); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 159 | } |
| 160 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 161 | static void Unsafe_putObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 162 | jobject javaNewValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 163 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 164 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 165 | mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 166 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 167 | obj->SetFieldObject<false>(MemberOffset(offset), newValue); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 168 | } |
| 169 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 170 | static void Unsafe_putObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 171 | jobject javaNewValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 172 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 173 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 174 | mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 175 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 176 | obj->SetFieldObjectVolatile<false>(MemberOffset(offset), newValue); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 177 | } |
| 178 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 179 | static void Unsafe_putOrderedObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, |
| 180 | jobject javaNewValue) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 181 | ScopedFastNativeObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 182 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 183 | mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue); |
Hans Boehm | 3035961 | 2014-05-21 17:46:23 -0700 | [diff] [blame] | 184 | QuasiAtomic::ThreadFenceRelease(); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 185 | // JNI must use non transactional mode. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 186 | obj->SetFieldObject<false>(MemberOffset(offset), newValue); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Hiroshi Yamauchi | 4d2efce | 2014-02-10 16:19:09 -0800 | [diff] [blame] | 189 | static jint Unsafe_getArrayBaseOffsetForComponentType(JNIEnv* env, jclass, jobject component_class) { |
| 190 | ScopedFastNativeObjectAccess soa(env); |
| 191 | mirror::Class* component = soa.Decode<mirror::Class*>(component_class); |
| 192 | Primitive::Type primitive_type = component->GetPrimitiveType(); |
| 193 | return mirror::Array::DataOffset(Primitive::ComponentSize(primitive_type)).Int32Value(); |
| 194 | } |
| 195 | |
| 196 | static jint Unsafe_getArrayIndexScaleForComponentType(JNIEnv* env, jclass, jobject component_class) { |
| 197 | ScopedFastNativeObjectAccess soa(env); |
| 198 | mirror::Class* component = soa.Decode<mirror::Class*>(component_class); |
| 199 | Primitive::Type primitive_type = component->GetPrimitiveType(); |
| 200 | return Primitive::ComponentSize(primitive_type); |
| 201 | } |
| 202 | |
Przemyslaw Szczepaniak | 6c0ea27 | 2015-09-23 08:48:00 +0100 | [diff] [blame] | 203 | static jint Unsafe_addressSize(JNIEnv* env ATTRIBUTE_UNUSED, jobject ob ATTRIBUTE_UNUSED) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 204 | return sizeof(void*); |
| 205 | } |
| 206 | |
Przemyslaw Szczepaniak | 6c0ea27 | 2015-09-23 08:48:00 +0100 | [diff] [blame] | 207 | static jint Unsafe_pageSize(JNIEnv* env ATTRIBUTE_UNUSED, jobject ob ATTRIBUTE_UNUSED) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 208 | return sysconf(_SC_PAGESIZE); |
| 209 | } |
| 210 | |
| 211 | static jlong Unsafe_allocateMemory(JNIEnv* env, jobject, jlong bytes) { |
| 212 | ScopedFastNativeObjectAccess soa(env); |
| 213 | // bytes is nonnegative and fits into size_t |
| 214 | if (bytes < 0 || bytes != (jlong)(size_t) bytes) { |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 215 | ThrowIllegalAccessException("wrong number of bytes"); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 216 | return 0; |
| 217 | } |
| 218 | void* mem = malloc(bytes); |
| 219 | if (mem == nullptr) { |
| 220 | soa.Self()->ThrowOutOfMemoryError("native alloc"); |
| 221 | return 0; |
| 222 | } |
| 223 | return (uintptr_t) mem; |
| 224 | } |
| 225 | |
Przemyslaw Szczepaniak | 6c0ea27 | 2015-09-23 08:48:00 +0100 | [diff] [blame] | 226 | static void Unsafe_freeMemory(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Narayan Kamath | a0cf5a6 | 2015-09-07 11:41:37 +0100 | [diff] [blame] | 227 | free(reinterpret_cast<void*>(static_cast<uintptr_t>(address))); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 228 | } |
| 229 | |
Przemyslaw Szczepaniak | 6c0ea27 | 2015-09-23 08:48:00 +0100 | [diff] [blame] | 230 | static void Unsafe_setMemory(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jlong bytes, jbyte value) { |
Narayan Kamath | a0cf5a6 | 2015-09-07 11:41:37 +0100 | [diff] [blame] | 231 | memset(reinterpret_cast<void*>(static_cast<uintptr_t>(address)), value, bytes); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 232 | } |
| 233 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 234 | static jbyte Unsafe_getByteJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 235 | return *reinterpret_cast<jbyte*>(address); |
| 236 | } |
| 237 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 238 | static void Unsafe_putByteJB(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jbyte value) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 239 | *reinterpret_cast<jbyte*>(address) = value; |
| 240 | } |
| 241 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 242 | static jshort Unsafe_getShortJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 243 | return *reinterpret_cast<jshort*>(address); |
| 244 | } |
| 245 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 246 | static void Unsafe_putShortJS(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jshort value) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 247 | *reinterpret_cast<jshort*>(address) = value; |
| 248 | } |
| 249 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 250 | static jchar Unsafe_getCharJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 251 | return *reinterpret_cast<jchar*>(address); |
| 252 | } |
| 253 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 254 | static void Unsafe_putCharJC(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jchar value) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 255 | *reinterpret_cast<jchar*>(address) = value; |
| 256 | } |
| 257 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 258 | static jint Unsafe_getIntJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 259 | return *reinterpret_cast<jint*>(address); |
| 260 | } |
| 261 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 262 | static void Unsafe_putIntJI(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jint value) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 263 | *reinterpret_cast<jint*>(address) = value; |
| 264 | } |
| 265 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 266 | static jlong Unsafe_getLongJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 267 | return *reinterpret_cast<jlong*>(address); |
| 268 | } |
| 269 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 270 | static void Unsafe_putLongJJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jlong value) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 271 | *reinterpret_cast<jlong*>(address) = value; |
| 272 | } |
| 273 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 274 | static jfloat Unsafe_getFloatJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 275 | return *reinterpret_cast<jfloat*>(address); |
| 276 | } |
| 277 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 278 | static void Unsafe_putFloatJF(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jfloat value) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 279 | *reinterpret_cast<jfloat*>(address) = value; |
| 280 | } |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 281 | static jdouble Unsafe_getDoubleJ(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 282 | return *reinterpret_cast<jdouble*>(address); |
| 283 | } |
| 284 | |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 285 | static void Unsafe_putDoubleJD(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address, jdouble value) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 286 | *reinterpret_cast<jdouble*>(address) = value; |
| 287 | } |
| 288 | |
Przemyslaw Szczepaniak | 6c0ea27 | 2015-09-23 08:48:00 +0100 | [diff] [blame] | 289 | static void Unsafe_copyMemory(JNIEnv *env, jobject unsafe ATTRIBUTE_UNUSED, jlong src, |
| 290 | jlong dst, jlong size) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 291 | if (size == 0) { |
| 292 | return; |
| 293 | } |
| 294 | // size is nonnegative and fits into size_t |
| 295 | if (size < 0 || size != (jlong)(size_t) size) { |
| 296 | ScopedFastNativeObjectAccess soa(env); |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 297 | ThrowIllegalAccessException("wrong number of bytes"); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 298 | } |
| 299 | size_t sz = (size_t)size; |
| 300 | memcpy(reinterpret_cast<void *>(dst), reinterpret_cast<void *>(src), sz); |
| 301 | } |
| 302 | |
| 303 | template<typename T> |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 304 | static void copyToArray(jlong srcAddr, mirror::PrimitiveArray<T>* array, |
| 305 | size_t array_offset, |
| 306 | size_t size) |
Przemyslaw Szczepaniak | 121b25e | 2015-11-20 11:24:33 +0000 | [diff] [blame] | 307 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 308 | const T* src = reinterpret_cast<T*>(srcAddr); |
| 309 | size_t sz = size / sizeof(T); |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 310 | size_t of = array_offset / sizeof(T); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 311 | for (size_t i = 0; i < sz; ++i) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 312 | array->Set(i + of, *(src + i)); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 313 | } |
| 314 | } |
| 315 | |
| 316 | template<typename T> |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 317 | static void copyFromArray(jlong dstAddr, mirror::PrimitiveArray<T>* array, |
| 318 | size_t array_offset, |
| 319 | size_t size) |
Przemyslaw Szczepaniak | 121b25e | 2015-11-20 11:24:33 +0000 | [diff] [blame] | 320 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 321 | T* dst = reinterpret_cast<T*>(dstAddr); |
| 322 | size_t sz = size / sizeof(T); |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 323 | size_t of = array_offset / sizeof(T); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 324 | for (size_t i = 0; i < sz; ++i) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 325 | *(dst + i) = array->Get(i + of); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 326 | } |
| 327 | } |
| 328 | |
| 329 | static void Unsafe_copyMemoryToPrimitiveArray(JNIEnv *env, |
Przemyslaw Szczepaniak | 6c0ea27 | 2015-09-23 08:48:00 +0100 | [diff] [blame] | 330 | jobject unsafe ATTRIBUTE_UNUSED, |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 331 | jlong srcAddr, |
| 332 | jobject dstObj, |
| 333 | jlong dstOffset, |
| 334 | jlong size) { |
| 335 | ScopedObjectAccess soa(env); |
| 336 | if (size == 0) { |
| 337 | return; |
| 338 | } |
| 339 | // size is nonnegative and fits into size_t |
| 340 | if (size < 0 || size != (jlong)(size_t) size) { |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 341 | ThrowIllegalAccessException("wrong number of bytes"); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 342 | } |
| 343 | size_t sz = (size_t)size; |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 344 | size_t dst_offset = (size_t)dstOffset; |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 345 | mirror::Object* dst = soa.Decode<mirror::Object*>(dstObj); |
| 346 | mirror::Class* component_type = dst->GetClass()->GetComponentType(); |
| 347 | if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 348 | copyToArray(srcAddr, dst->AsByteSizedArray(), dst_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 349 | } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 350 | copyToArray(srcAddr, dst->AsShortSizedArray(), dst_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 351 | } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 352 | copyToArray(srcAddr, dst->AsIntArray(), dst_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 353 | } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 354 | copyToArray(srcAddr, dst->AsLongArray(), dst_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 355 | } else { |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 356 | ThrowIllegalAccessException("not a primitive array"); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 357 | } |
| 358 | } |
| 359 | |
| 360 | static void Unsafe_copyMemoryFromPrimitiveArray(JNIEnv *env, |
Przemyslaw Szczepaniak | 6c0ea27 | 2015-09-23 08:48:00 +0100 | [diff] [blame] | 361 | jobject unsafe ATTRIBUTE_UNUSED, |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 362 | jobject srcObj, |
| 363 | jlong srcOffset, |
| 364 | jlong dstAddr, |
| 365 | jlong size) { |
| 366 | ScopedObjectAccess soa(env); |
| 367 | if (size == 0) { |
| 368 | return; |
| 369 | } |
| 370 | // size is nonnegative and fits into size_t |
| 371 | if (size < 0 || size != (jlong)(size_t) size) { |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 372 | ThrowIllegalAccessException("wrong number of bytes"); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 373 | } |
| 374 | size_t sz = (size_t)size; |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 375 | size_t src_offset = (size_t)srcOffset; |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 376 | mirror::Object* src = soa.Decode<mirror::Object*>(srcObj); |
| 377 | mirror::Class* component_type = src->GetClass()->GetComponentType(); |
| 378 | if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 379 | copyFromArray(dstAddr, src->AsByteSizedArray(), src_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 380 | } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 381 | copyFromArray(dstAddr, src->AsShortSizedArray(), src_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 382 | } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 383 | copyFromArray(dstAddr, src->AsIntArray(), src_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 384 | } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) { |
Przemyslaw Szczepaniak | 903ac27 | 2015-07-23 09:30:35 +0100 | [diff] [blame] | 385 | copyFromArray(dstAddr, src->AsLongArray(), src_offset, sz); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 386 | } else { |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 387 | ThrowIllegalAccessException("not a primitive array"); |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 388 | } |
| 389 | } |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 390 | static jboolean Unsafe_getBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 391 | ScopedFastNativeObjectAccess soa(env); |
| 392 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 393 | return obj->GetFieldBoolean(MemberOffset(offset)); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 394 | } |
| 395 | |
| 396 | static void Unsafe_putBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset, jboolean newValue) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 397 | ScopedFastNativeObjectAccess soa(env); |
| 398 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 399 | // JNI must use non transactional mode (SetField8 is non-transactional). |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 400 | obj->SetFieldBoolean<false>(MemberOffset(offset), newValue); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 401 | } |
| 402 | |
| 403 | static jbyte Unsafe_getByte(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 404 | ScopedFastNativeObjectAccess soa(env); |
| 405 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 406 | return obj->GetFieldByte(MemberOffset(offset)); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 407 | } |
| 408 | |
| 409 | static void Unsafe_putByte(JNIEnv* env, jobject, jobject javaObj, jlong offset, jbyte newValue) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 410 | ScopedFastNativeObjectAccess soa(env); |
| 411 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 412 | // JNI must use non transactional mode. |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 413 | obj->SetFieldByte<false>(MemberOffset(offset), newValue); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 414 | } |
| 415 | |
| 416 | static jchar Unsafe_getChar(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 417 | ScopedFastNativeObjectAccess soa(env); |
| 418 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 419 | return obj->GetFieldChar(MemberOffset(offset)); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 420 | } |
| 421 | |
| 422 | static void Unsafe_putChar(JNIEnv* env, jobject, jobject javaObj, jlong offset, jchar newValue) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 423 | ScopedFastNativeObjectAccess soa(env); |
| 424 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 425 | // JNI must use non transactional mode. |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 426 | obj->SetFieldChar<false>(MemberOffset(offset), newValue); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 427 | } |
| 428 | |
| 429 | static jshort Unsafe_getShort(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 430 | ScopedFastNativeObjectAccess soa(env); |
| 431 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 432 | return obj->GetFieldShort(MemberOffset(offset)); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 433 | } |
| 434 | |
| 435 | static void Unsafe_putShort(JNIEnv* env, jobject, jobject javaObj, jlong offset, jshort newValue) { |
Przemyslaw Szczepaniak | 5abc6f9 | 2015-06-30 11:05:37 +0100 | [diff] [blame] | 436 | ScopedFastNativeObjectAccess soa(env); |
| 437 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
| 438 | // JNI must use non transactional mode. |
Narayan Kamath | d1ef436 | 2015-11-12 11:49:06 +0000 | [diff] [blame] | 439 | obj->SetFieldShort<false>(MemberOffset(offset), newValue); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 440 | } |
| 441 | |
| 442 | static jfloat Unsafe_getFloat(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
| 443 | ScopedFastNativeObjectAccess soa(env); |
| 444 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Przemyslaw Szczepaniak | 5c40422 | 2015-08-04 13:19:12 +0100 | [diff] [blame] | 445 | union {int32_t val; jfloat converted;} conv; |
| 446 | conv.val = obj->GetField32(MemberOffset(offset)); |
| 447 | return conv.converted; |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 448 | } |
| 449 | |
| 450 | static void Unsafe_putFloat(JNIEnv* env, jobject, jobject javaObj, jlong offset, jfloat newValue) { |
| 451 | ScopedFastNativeObjectAccess soa(env); |
| 452 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Przemyslaw Szczepaniak | 5c40422 | 2015-08-04 13:19:12 +0100 | [diff] [blame] | 453 | union {int32_t converted; jfloat val;} conv; |
| 454 | conv.val = newValue; |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 455 | // JNI must use non transactional mode. |
Przemyslaw Szczepaniak | 5c40422 | 2015-08-04 13:19:12 +0100 | [diff] [blame] | 456 | obj->SetField32<false>(MemberOffset(offset), conv.converted); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 457 | } |
| 458 | |
| 459 | static jdouble Unsafe_getDouble(JNIEnv* env, jobject, jobject javaObj, jlong offset) { |
| 460 | ScopedFastNativeObjectAccess soa(env); |
| 461 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Przemyslaw Szczepaniak | 5c40422 | 2015-08-04 13:19:12 +0100 | [diff] [blame] | 462 | union {int64_t val; jdouble converted;} conv; |
| 463 | conv.val = obj->GetField64(MemberOffset(offset)); |
| 464 | return conv.converted; |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 465 | } |
| 466 | |
| 467 | static void Unsafe_putDouble(JNIEnv* env, jobject, jobject javaObj, jlong offset, jdouble newValue) { |
| 468 | ScopedFastNativeObjectAccess soa(env); |
| 469 | mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj); |
Przemyslaw Szczepaniak | 5c40422 | 2015-08-04 13:19:12 +0100 | [diff] [blame] | 470 | union {int64_t converted; jdouble val;} conv; |
| 471 | conv.val = newValue; |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 472 | // JNI must use non transactional mode. |
Przemyslaw Szczepaniak | 5c40422 | 2015-08-04 13:19:12 +0100 | [diff] [blame] | 473 | obj->SetField64<false>(MemberOffset(offset), conv.converted); |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 474 | } |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 475 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 476 | static JNINativeMethod gMethods[] = { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 477 | NATIVE_METHOD(Unsafe, compareAndSwapInt, "!(Ljava/lang/Object;JII)Z"), |
| 478 | NATIVE_METHOD(Unsafe, compareAndSwapLong, "!(Ljava/lang/Object;JJJ)Z"), |
| 479 | NATIVE_METHOD(Unsafe, compareAndSwapObject, "!(Ljava/lang/Object;JLjava/lang/Object;Ljava/lang/Object;)Z"), |
| 480 | NATIVE_METHOD(Unsafe, getIntVolatile, "!(Ljava/lang/Object;J)I"), |
| 481 | NATIVE_METHOD(Unsafe, putIntVolatile, "!(Ljava/lang/Object;JI)V"), |
| 482 | NATIVE_METHOD(Unsafe, getLongVolatile, "!(Ljava/lang/Object;J)J"), |
| 483 | NATIVE_METHOD(Unsafe, putLongVolatile, "!(Ljava/lang/Object;JJ)V"), |
| 484 | NATIVE_METHOD(Unsafe, getObjectVolatile, "!(Ljava/lang/Object;J)Ljava/lang/Object;"), |
| 485 | NATIVE_METHOD(Unsafe, putObjectVolatile, "!(Ljava/lang/Object;JLjava/lang/Object;)V"), |
| 486 | NATIVE_METHOD(Unsafe, getInt, "!(Ljava/lang/Object;J)I"), |
| 487 | NATIVE_METHOD(Unsafe, putInt, "!(Ljava/lang/Object;JI)V"), |
| 488 | NATIVE_METHOD(Unsafe, putOrderedInt, "!(Ljava/lang/Object;JI)V"), |
| 489 | NATIVE_METHOD(Unsafe, getLong, "!(Ljava/lang/Object;J)J"), |
| 490 | NATIVE_METHOD(Unsafe, putLong, "!(Ljava/lang/Object;JJ)V"), |
| 491 | NATIVE_METHOD(Unsafe, putOrderedLong, "!(Ljava/lang/Object;JJ)V"), |
| 492 | NATIVE_METHOD(Unsafe, getObject, "!(Ljava/lang/Object;J)Ljava/lang/Object;"), |
| 493 | NATIVE_METHOD(Unsafe, putObject, "!(Ljava/lang/Object;JLjava/lang/Object;)V"), |
| 494 | NATIVE_METHOD(Unsafe, putOrderedObject, "!(Ljava/lang/Object;JLjava/lang/Object;)V"), |
Hiroshi Yamauchi | 4d2efce | 2014-02-10 16:19:09 -0800 | [diff] [blame] | 495 | NATIVE_METHOD(Unsafe, getArrayBaseOffsetForComponentType, "!(Ljava/lang/Class;)I"), |
| 496 | NATIVE_METHOD(Unsafe, getArrayIndexScaleForComponentType, "!(Ljava/lang/Class;)I"), |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 497 | NATIVE_METHOD(Unsafe, addressSize, "!()I"), |
| 498 | NATIVE_METHOD(Unsafe, pageSize, "!()I"), |
| 499 | NATIVE_METHOD(Unsafe, allocateMemory, "!(J)J"), |
| 500 | NATIVE_METHOD(Unsafe, freeMemory, "!(J)V"), |
| 501 | NATIVE_METHOD(Unsafe, setMemory, "!(JJB)V"), |
Piotr Jastrzebski | d7fcf6e | 2015-05-05 12:54:00 +0100 | [diff] [blame] | 502 | NATIVE_METHOD(Unsafe, copyMemory, "!(JJJ)V"), |
| 503 | NATIVE_METHOD(Unsafe, copyMemoryToPrimitiveArray, "!(JLjava/lang/Object;JJ)V"), |
| 504 | NATIVE_METHOD(Unsafe, copyMemoryFromPrimitiveArray, "!(Ljava/lang/Object;JJJ)V"), |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 505 | NATIVE_METHOD(Unsafe, getBoolean, "!(Ljava/lang/Object;J)Z"), |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 506 | |
Piotr Jastrzebski | 8e73ea4 | 2015-05-07 09:41:00 +0100 | [diff] [blame] | 507 | NATIVE_METHOD(Unsafe, getByte, "!(Ljava/lang/Object;J)B"), |
| 508 | NATIVE_METHOD(Unsafe, getChar, "!(Ljava/lang/Object;J)C"), |
| 509 | NATIVE_METHOD(Unsafe, getShort, "!(Ljava/lang/Object;J)S"), |
| 510 | NATIVE_METHOD(Unsafe, getFloat, "!(Ljava/lang/Object;J)F"), |
| 511 | NATIVE_METHOD(Unsafe, getDouble, "!(Ljava/lang/Object;J)D"), |
| 512 | NATIVE_METHOD(Unsafe, putBoolean, "!(Ljava/lang/Object;JZ)V"), |
| 513 | NATIVE_METHOD(Unsafe, putByte, "!(Ljava/lang/Object;JB)V"), |
| 514 | NATIVE_METHOD(Unsafe, putChar, "!(Ljava/lang/Object;JC)V"), |
| 515 | NATIVE_METHOD(Unsafe, putShort, "!(Ljava/lang/Object;JS)V"), |
| 516 | NATIVE_METHOD(Unsafe, putFloat, "!(Ljava/lang/Object;JF)V"), |
| 517 | NATIVE_METHOD(Unsafe, putDouble, "!(Ljava/lang/Object;JD)V"), |
Narayan Kamath | 0dd8c39 | 2016-02-01 13:22:18 +0000 | [diff] [blame] | 518 | |
| 519 | // Each of the getFoo variants are overloaded with a call that operates |
| 520 | // directively on a native pointer. |
| 521 | OVERLOADED_NATIVE_METHOD(Unsafe, getByte, "!(J)B", getByteJ), |
| 522 | OVERLOADED_NATIVE_METHOD(Unsafe, getChar, "!(J)C", getCharJ), |
| 523 | OVERLOADED_NATIVE_METHOD(Unsafe, getShort, "!(J)S", getShortJ), |
| 524 | OVERLOADED_NATIVE_METHOD(Unsafe, getInt, "!(J)I", getIntJ), |
| 525 | OVERLOADED_NATIVE_METHOD(Unsafe, getLong, "!(J)J", getLongJ), |
| 526 | OVERLOADED_NATIVE_METHOD(Unsafe, getFloat, "!(J)F", getFloatJ), |
| 527 | OVERLOADED_NATIVE_METHOD(Unsafe, getDouble, "!(J)D", getDoubleJ), |
| 528 | OVERLOADED_NATIVE_METHOD(Unsafe, putByte, "!(JB)V", putByteJB), |
| 529 | OVERLOADED_NATIVE_METHOD(Unsafe, putChar, "!(JC)V", putCharJC), |
| 530 | OVERLOADED_NATIVE_METHOD(Unsafe, putShort, "!(JS)V", putShortJS), |
| 531 | OVERLOADED_NATIVE_METHOD(Unsafe, putInt, "!(JI)V", putIntJI), |
| 532 | OVERLOADED_NATIVE_METHOD(Unsafe, putLong, "!(JJ)V", putLongJJ), |
| 533 | OVERLOADED_NATIVE_METHOD(Unsafe, putFloat, "!(JF)V", putFloatJF), |
| 534 | OVERLOADED_NATIVE_METHOD(Unsafe, putDouble, "!(JD)V", putDoubleJD), |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 535 | }; |
| 536 | |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 537 | void register_sun_misc_Unsafe(JNIEnv* env) { |
Elliott Hughes | eac7667 | 2012-05-24 21:56:51 -0700 | [diff] [blame] | 538 | REGISTER_NATIVE_METHODS("sun/misc/Unsafe"); |
Elliott Hughes | 5ee7a8b | 2011-09-13 16:40:07 -0700 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | } // namespace art |