1 /*
2 * Copyright (C) 2011 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 "jni_internal.h"
18
19 #include <cstdarg>
20 #include <log/log.h>
21 #include <memory>
22 #include <utility>
23
24 #include "art_field-inl.h"
25 #include "art_method-alloc-inl.h"
26 #include "base/allocator.h"
27 #include "base/atomic.h"
28 #include "base/casts.h"
29 #include "base/enums.h"
30 #include "base/file_utils.h"
31 #include "base/logging.h" // For VLOG.
32 #include "base/mutex.h"
33 #include "base/safe_map.h"
34 #include "base/stl_util.h"
35 #include "class_linker-inl.h"
36 #include "class_root-inl.h"
37 #include "dex/dex_file-inl.h"
38 #include "dex/utf-inl.h"
39 #include "fault_handler.h"
40 #include "handle_scope.h"
41 #include "hidden_api.h"
42 #include "gc/accounting/card_table-inl.h"
43 #include "gc_root.h"
44 #include "indirect_reference_table-inl.h"
45 #include "interpreter/interpreter.h"
46 #include "java_vm_ext.h"
47 #include "jni_env_ext.h"
48 #include "jvalue-inl.h"
49 #include "mirror/class-alloc-inl.h"
50 #include "mirror/class-inl.h"
51 #include "mirror/class_loader.h"
52 #include "mirror/dex_cache-inl.h"
53 #include "mirror/field.h"
54 #include "mirror/method.h"
55 #include "mirror/object-inl.h"
56 #include "mirror/object_array-alloc-inl.h"
57 #include "mirror/object_array-inl.h"
58 #include "mirror/string-alloc-inl.h"
59 #include "mirror/string-inl.h"
60 #include "mirror/throwable.h"
61 #include "nativehelper/scoped_local_ref.h"
62 #include "parsed_options.h"
63 #include "reflection.h"
64 #include "runtime.h"
65 #include "scoped_thread_state_change-inl.h"
66 #include "thread.h"
67 #include "well_known_classes-inl.h"
68
69 namespace art {
70
71 namespace {
72
73 // Frees the given va_list upon destruction.
74 // This also guards the returns from inside of the CHECK_NON_NULL_ARGUMENTs.
75 struct ScopedVAArgs {
ScopedVAArgsart::__anon9de519ce0111::ScopedVAArgs76 explicit ScopedVAArgs(va_list* args): args(args) {}
77 ScopedVAArgs(const ScopedVAArgs&) = delete;
78 ScopedVAArgs(ScopedVAArgs&&) = delete;
~ScopedVAArgsart::__anon9de519ce0111::ScopedVAArgs79 ~ScopedVAArgs() { va_end(*args); }
80
81 private:
82 va_list* args;
83 };
84
85 constexpr char kBadUtf8ReplacementChar = '?';
86
87 // This is a modified version of `CountModifiedUtf8Chars()` from utf.cc,
88 // with extra checks and different output options.
89 //
90 // The `good` functor can process valid characters.
91 // The `bad` functor is called when we find an invalid character.
92 //
93 // Returns the number of UTF-16 characters.
94 template <typename GoodFunc, typename BadFunc>
VisitUtf8Chars(const char * utf8,size_t byte_count,GoodFunc good,BadFunc bad)95 size_t VisitUtf8Chars(const char* utf8, size_t byte_count, GoodFunc good, BadFunc bad) {
96 DCHECK_LE(byte_count, strlen(utf8));
97 size_t len = 0;
98 const char* end = utf8 + byte_count;
99 while (utf8 != end) {
100 int ic = *utf8;
101 if (LIKELY((ic & 0x80) == 0)) {
102 // One-byte encoding.
103 good(utf8, 1u);
104 utf8 += 1u;
105 len += 1u;
106 continue;
107 }
108 // Note: We do not check whether the bit 0x40 is correctly set in the leading byte of
109 // a multi-byte sequence. Nor do we verify the top two bits of continuation characters.
110 if ((ic & 0x20) == 0) {
111 // Two-byte encoding.
112 if (static_cast<size_t>(end - utf8) < 2u) {
113 bad();
114 return len + 1u; // Reached end of sequence.
115 }
116 good(utf8, 2u);
117 utf8 += 2u;
118 len += 1u;
119 continue;
120 }
121 if ((ic & 0x10) == 0) {
122 // Three-byte encoding.
123 if (static_cast<size_t>(end - utf8) < 3u) {
124 bad();
125 return len + 1u; // Reached end of sequence
126 }
127 good(utf8, 3u);
128 utf8 += 3u;
129 len += 1u;
130 continue;
131 }
132
133 // Four-byte encoding: needs to be converted into a surrogate pair.
134 if (static_cast<size_t>(end - utf8) < 4u) {
135 bad();
136 return len + 1u; // Reached end of sequence.
137 }
138 good(utf8, 4u);
139 utf8 += 4u;
140 len += 2u;
141 }
142 return len;
143 }
144
145 ALWAYS_INLINE
DecodeModifiedUtf8Character(const char * ptr,size_t length)146 static inline uint16_t DecodeModifiedUtf8Character(const char* ptr, size_t length) {
147 switch (length) {
148 case 1:
149 return ptr[0];
150 case 2:
151 return ((ptr[0] & 0x1fu) << 6) | (ptr[1] & 0x3fu);
152 case 3:
153 return ((ptr[0] & 0x0fu) << 12) | ((ptr[1] & 0x3fu) << 6) | (ptr[2] & 0x3fu);
154 default:
155 LOG(FATAL) << "UNREACHABLE"; // 4-byte sequences are not valid Modified UTF-8.
156 UNREACHABLE();
157 }
158 }
159
160 class NewStringUTFVisitor {
161 public:
NewStringUTFVisitor(const char * utf,size_t utf8_length,int32_t count,bool has_bad_char)162 NewStringUTFVisitor(const char* utf, size_t utf8_length, int32_t count, bool has_bad_char)
163 : utf_(utf), utf8_length_(utf8_length), count_(count), has_bad_char_(has_bad_char) {}
164
operator ()(ObjPtr<mirror::Object> obj,size_t usable_size ATTRIBUTE_UNUSED) const165 void operator()(ObjPtr<mirror::Object> obj, size_t usable_size ATTRIBUTE_UNUSED) const
166 REQUIRES_SHARED(Locks::mutator_lock_) {
167 // Avoid AsString as object is not yet in live bitmap or allocation stack.
168 ObjPtr<mirror::String> string = ObjPtr<mirror::String>::DownCast(obj);
169 string->SetCount(count_);
170 DCHECK_IMPLIES(string->IsCompressed(), mirror::kUseStringCompression);
171 if (string->IsCompressed()) {
172 uint8_t* value_compressed = string->GetValueCompressed();
173 auto good = [&](const char* ptr, size_t length) {
174 uint16_t c = DecodeModifiedUtf8Character(ptr, length);
175 DCHECK(mirror::String::IsASCII(c));
176 *value_compressed++ = dchecked_integral_cast<uint8_t>(c);
177 };
178 auto bad = [&]() {
179 DCHECK(has_bad_char_);
180 *value_compressed++ = kBadUtf8ReplacementChar;
181 };
182 VisitUtf8Chars(utf_, utf8_length_, good, bad);
183 } else {
184 // Uncompressed.
185 uint16_t* value = string->GetValue();
186 auto good = [&](const char* ptr, size_t length) {
187 if (length != 4u) {
188 *value++ = DecodeModifiedUtf8Character(ptr, length);
189 } else {
190 const uint32_t code_point = ((ptr[0] & 0x0fu) << 18) |
191 ((ptr[1] & 0x3fu) << 12) |
192 ((ptr[2] & 0x3fu) << 6) |
193 (ptr[3] & 0x3fu);
194 // TODO: What do we do about values outside the range [U+10000, U+10FFFF]?
195 // The spec says they're invalid but nobody appears to check for them.
196 const uint32_t code_point_bits = code_point - 0x10000u;
197 *value++ = 0xd800u | ((code_point_bits >> 10) & 0x3ffu);
198 *value++ = 0xdc00u | (code_point_bits & 0x3ffu);
199 }
200 };
201 auto bad = [&]() {
202 DCHECK(has_bad_char_);
203 *value++ = kBadUtf8ReplacementChar;
204 };
205 VisitUtf8Chars(utf_, utf8_length_, good, bad);
206 DCHECK_IMPLIES(mirror::kUseStringCompression,
207 !mirror::String::AllASCII(string->GetValue(), string->GetLength()));
208 }
209 }
210
211 private:
212 const char* utf_;
213 size_t utf8_length_;
214 const int32_t count_;
215 bool has_bad_char_;
216 };
217
218 // The JNI specification says that `GetStringUTFLength()`, `GetStringUTFChars()`
219 // and `GetStringUTFRegion()` should emit the Modified UTF-8 encoding.
220 // However, we have been emitting 4-byte UTF-8 sequences for several years now
221 // and changing that would risk breaking a lot of binary interfaces.
222 constexpr bool kUtfUseShortZero = false;
223 constexpr bool kUtfUse4ByteSequence = true; // This is against the JNI spec.
224 constexpr bool kUtfReplaceBadSurrogates = false;
225
GetUncompressedStringUTFLength(const uint16_t * chars,size_t length)226 jsize GetUncompressedStringUTFLength(const uint16_t* chars, size_t length) {
227 jsize byte_count = 0;
228 ConvertUtf16ToUtf8<kUtfUseShortZero, kUtfUse4ByteSequence, kUtfReplaceBadSurrogates>(
229 chars, length, [&](char c ATTRIBUTE_UNUSED) { ++byte_count; });
230 return byte_count;
231 }
232
GetUncompressedStringUTFChars(const uint16_t * chars,size_t length,char * dest)233 char* GetUncompressedStringUTFChars(const uint16_t* chars, size_t length, char* dest) {
234 ConvertUtf16ToUtf8<kUtfUseShortZero, kUtfUse4ByteSequence, kUtfReplaceBadSurrogates>(
235 chars, length, [&](char c) { *dest++ = c; });
236 return dest;
237 }
238
239 } // namespace
240
241 // Consider turning this on when there is errors which could be related to JNI array copies such as
242 // things not rendering correctly. E.g. b/16858794
243 static constexpr bool kWarnJniAbort = false;
244
GetJniAccessContext(Thread * self)245 static hiddenapi::AccessContext GetJniAccessContext(Thread* self)
246 REQUIRES_SHARED(Locks::mutator_lock_) {
247 // Construct AccessContext from the first calling class on stack.
248 // If the calling class cannot be determined, e.g. unattached threads,
249 // we conservatively assume the caller is trusted.
250 ObjPtr<mirror::Class> caller = GetCallingClass(self, /* num_frames= */ 1);
251 return caller.IsNull() ? hiddenapi::AccessContext(/* is_trusted= */ true)
252 : hiddenapi::AccessContext(caller);
253 }
254
255 template<typename T>
ShouldDenyAccessToMember(T * member,Thread * self,hiddenapi::AccessMethod access_kind=hiddenapi::AccessMethod::kJNI)256 ALWAYS_INLINE static bool ShouldDenyAccessToMember(
257 T* member,
258 Thread* self,
259 hiddenapi::AccessMethod access_kind = hiddenapi::AccessMethod::kJNI)
260 REQUIRES_SHARED(Locks::mutator_lock_) {
261 return hiddenapi::ShouldDenyAccessToMember(
262 member,
263 [self]() REQUIRES_SHARED(Locks::mutator_lock_) { return GetJniAccessContext(self); },
264 access_kind);
265 }
266
267 // Helpers to call instrumentation functions for fields. These take jobjects so we don't need to set
268 // up handles for the rare case where these actually do something. Once these functions return it is
269 // possible there will be a pending exception if the instrumentation happens to throw one.
NotifySetObjectField(ArtField * field,jobject obj,jobject jval)270 static void NotifySetObjectField(ArtField* field, jobject obj, jobject jval)
271 REQUIRES_SHARED(Locks::mutator_lock_) {
272 DCHECK_EQ(field->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
273 instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
274 if (UNLIKELY(instrumentation->HasFieldWriteListeners())) {
275 Thread* self = Thread::Current();
276 ArtMethod* cur_method = self->GetCurrentMethod(/*dex_pc=*/ nullptr,
277 /*check_suspended=*/ true,
278 /*abort_on_error=*/ false);
279
280 if (cur_method == nullptr) {
281 // Set/Get Fields can be issued without a method during runtime startup/teardown. Ignore all
282 // of these changes.
283 return;
284 }
285 DCHECK(cur_method->IsNative());
286 JValue val;
287 val.SetL(self->DecodeJObject(jval));
288 instrumentation->FieldWriteEvent(self,
289 self->DecodeJObject(obj),
290 cur_method,
291 0, // dex_pc is always 0 since this is a native method.
292 field,
293 val);
294 }
295 }
296
NotifySetPrimitiveField(ArtField * field,jobject obj,JValue val)297 static void NotifySetPrimitiveField(ArtField* field, jobject obj, JValue val)
298 REQUIRES_SHARED(Locks::mutator_lock_) {
299 DCHECK_NE(field->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
300 instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
301 if (UNLIKELY(instrumentation->HasFieldWriteListeners())) {
302 Thread* self = Thread::Current();
303 ArtMethod* cur_method = self->GetCurrentMethod(/*dex_pc=*/ nullptr,
304 /*check_suspended=*/ true,
305 /*abort_on_error=*/ false);
306
307 if (cur_method == nullptr) {
308 // Set/Get Fields can be issued without a method during runtime startup/teardown. Ignore all
309 // of these changes.
310 return;
311 }
312 DCHECK(cur_method->IsNative());
313 instrumentation->FieldWriteEvent(self,
314 self->DecodeJObject(obj),
315 cur_method,
316 0, // dex_pc is always 0 since this is a native method.
317 field,
318 val);
319 }
320 }
321
NotifyGetField(ArtField * field,jobject obj)322 static void NotifyGetField(ArtField* field, jobject obj)
323 REQUIRES_SHARED(Locks::mutator_lock_) {
324 instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
325 if (UNLIKELY(instrumentation->HasFieldReadListeners())) {
326 Thread* self = Thread::Current();
327 ArtMethod* cur_method = self->GetCurrentMethod(/*dex_pc=*/ nullptr,
328 /*check_suspended=*/ true,
329 /*abort_on_error=*/ false);
330
331 if (cur_method == nullptr) {
332 // Set/Get Fields can be issued without a method during runtime startup/teardown. Ignore all
333 // of these changes.
334 return;
335 }
336 DCHECK(cur_method->IsNative());
337 instrumentation->FieldReadEvent(self,
338 self->DecodeJObject(obj),
339 cur_method,
340 0, // dex_pc is always 0 since this is a native method.
341 field);
342 }
343 }
344
345 // Section 12.3.2 of the JNI spec describes JNI class descriptors. They're
346 // separated with slashes but aren't wrapped with "L;" like regular descriptors
347 // (i.e. "a/b/C" rather than "La/b/C;"). Arrays of reference types are an
348 // exception; there the "L;" must be present ("[La/b/C;"). Historically we've
349 // supported names with dots too (such as "a.b.C").
NormalizeJniClassDescriptor(const char * name)350 static std::string NormalizeJniClassDescriptor(const char* name) {
351 std::string result;
352 // Add the missing "L;" if necessary.
353 if (name[0] == '[') {
354 result = name;
355 } else {
356 result += 'L';
357 result += name;
358 result += ';';
359 }
360 // Rewrite '.' as '/' for backwards compatibility.
361 if (result.find('.') != std::string::npos) {
362 LOG(WARNING) << "Call to JNI FindClass with dots in name: "
363 << "\"" << name << "\"";
364 std::replace(result.begin(), result.end(), '.', '/');
365 }
366 return result;
367 }
368
ReportInvalidJNINativeMethod(const ScopedObjectAccess & soa,ObjPtr<mirror::Class> c,const char * kind,jint idx)369 static void ReportInvalidJNINativeMethod(const ScopedObjectAccess& soa,
370 ObjPtr<mirror::Class> c,
371 const char* kind,
372 jint idx)
373 REQUIRES_SHARED(Locks::mutator_lock_) {
374 LOG(ERROR)
375 << "Failed to register native method in " << c->PrettyDescriptor()
376 << " in " << c->GetDexCache()->GetLocation()->ToModifiedUtf8()
377 << ": " << kind << " is null at index " << idx;
378 soa.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchMethodError;",
379 "%s is null at index %d",
380 kind,
381 idx);
382 }
383
384 template<bool kEnableIndexIds>
FindMethodID(ScopedObjectAccess & soa,jclass jni_class,const char * name,const char * sig,bool is_static)385 static jmethodID FindMethodID(ScopedObjectAccess& soa, jclass jni_class,
386 const char* name, const char* sig, bool is_static)
387 REQUIRES_SHARED(Locks::mutator_lock_) {
388 return jni::EncodeArtMethod<kEnableIndexIds>(FindMethodJNI(soa, jni_class, name, sig, is_static));
389 }
390
391 template<bool kEnableIndexIds>
GetClassLoader(const ScopedObjectAccess & soa)392 static ObjPtr<mirror::ClassLoader> GetClassLoader(const ScopedObjectAccess& soa)
393 REQUIRES_SHARED(Locks::mutator_lock_) {
394 ArtMethod* method = soa.Self()->GetCurrentMethod(nullptr);
395 // If we are running Runtime.nativeLoad, use the overriding ClassLoader it set.
396 if (method == WellKnownClasses::java_lang_Runtime_nativeLoad) {
397 return soa.Decode<mirror::ClassLoader>(soa.Self()->GetClassLoaderOverride());
398 }
399 // If we have a method, use its ClassLoader for context.
400 if (method != nullptr) {
401 return method->GetDeclaringClass()->GetClassLoader();
402 }
403 // We don't have a method, so try to use the system ClassLoader.
404 ObjPtr<mirror::ClassLoader> class_loader =
405 soa.Decode<mirror::ClassLoader>(Runtime::Current()->GetSystemClassLoader());
406 if (class_loader != nullptr) {
407 return class_loader;
408 }
409 // See if the override ClassLoader is set for gtests.
410 class_loader = soa.Decode<mirror::ClassLoader>(soa.Self()->GetClassLoaderOverride());
411 if (class_loader != nullptr) {
412 // If so, CommonCompilerTest should have marked the runtime as a compiler not compiling an
413 // image.
414 CHECK(Runtime::Current()->IsAotCompiler());
415 CHECK(!Runtime::Current()->IsCompilingBootImage());
416 return class_loader;
417 }
418 // Use the BOOTCLASSPATH.
419 return nullptr;
420 }
421
422 template<bool kEnableIndexIds>
FindFieldID(const ScopedObjectAccess & soa,jclass jni_class,const char * name,const char * sig,bool is_static)423 static jfieldID FindFieldID(const ScopedObjectAccess& soa, jclass jni_class, const char* name,
424 const char* sig, bool is_static)
425 REQUIRES_SHARED(Locks::mutator_lock_) {
426 return jni::EncodeArtField<kEnableIndexIds>(FindFieldJNI(soa, jni_class, name, sig, is_static));
427 }
428
ThrowAIOOBE(ScopedObjectAccess & soa,ObjPtr<mirror::Array> array,jsize start,jsize length,const char * identifier)429 static void ThrowAIOOBE(ScopedObjectAccess& soa,
430 ObjPtr<mirror::Array> array,
431 jsize start,
432 jsize length,
433 const char* identifier)
434 REQUIRES_SHARED(Locks::mutator_lock_) {
435 std::string type(array->PrettyTypeOf());
436 soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
437 "%s offset=%d length=%d %s.length=%d",
438 type.c_str(), start, length, identifier, array->GetLength());
439 }
440
ThrowSIOOBE(ScopedObjectAccess & soa,jsize start,jsize length,jsize array_length)441 static void ThrowSIOOBE(ScopedObjectAccess& soa, jsize start, jsize length,
442 jsize array_length)
443 REQUIRES_SHARED(Locks::mutator_lock_) {
444 soa.Self()->ThrowNewExceptionF("Ljava/lang/StringIndexOutOfBoundsException;",
445 "offset=%d length=%d string.length()=%d", start, length,
446 array_length);
447 }
448
ThrowNoSuchMethodError(const ScopedObjectAccess & soa,ObjPtr<mirror::Class> c,const char * name,const char * sig,const char * kind)449 static void ThrowNoSuchMethodError(const ScopedObjectAccess& soa,
450 ObjPtr<mirror::Class> c,
451 const char* name,
452 const char* sig,
453 const char* kind)
454 REQUIRES_SHARED(Locks::mutator_lock_) {
455 std::string temp;
456 soa.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchMethodError;",
457 "no %s method \"%s.%s%s\"",
458 kind,
459 c->GetDescriptor(&temp),
460 name,
461 sig);
462 }
463
EnsureInitialized(Thread * self,ObjPtr<mirror::Class> klass)464 static ObjPtr<mirror::Class> EnsureInitialized(Thread* self, ObjPtr<mirror::Class> klass)
465 REQUIRES_SHARED(Locks::mutator_lock_) {
466 if (LIKELY(klass->IsInitialized())) {
467 return klass;
468 }
469 StackHandleScope<1> hs(self);
470 Handle<mirror::Class> h_klass(hs.NewHandle(klass));
471 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(self, h_klass, true, true)) {
472 return nullptr;
473 }
474 return h_klass.Get();
475 }
476
FindMethodJNI(const ScopedObjectAccess & soa,jclass jni_class,const char * name,const char * sig,bool is_static)477 ArtMethod* FindMethodJNI(const ScopedObjectAccess& soa,
478 jclass jni_class,
479 const char* name,
480 const char* sig,
481 bool is_static) {
482 ObjPtr<mirror::Class> c = EnsureInitialized(soa.Self(), soa.Decode<mirror::Class>(jni_class));
483 if (c == nullptr) {
484 return nullptr;
485 }
486 ArtMethod* method = nullptr;
487 auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
488 if (c->IsInterface()) {
489 method = c->FindInterfaceMethod(name, sig, pointer_size);
490 } else {
491 method = c->FindClassMethod(name, sig, pointer_size);
492 }
493 if (method != nullptr &&
494 ShouldDenyAccessToMember(method, soa.Self(), hiddenapi::AccessMethod::kNone)) {
495 // The resolved method that we have found cannot be accessed due to
496 // hiddenapi (typically it is declared up the hierarchy and is not an SDK
497 // method). Try to find an interface method from the implemented interfaces which is
498 // accessible.
499 ArtMethod* itf_method = c->FindAccessibleInterfaceMethod(method, pointer_size);
500 if (itf_method == nullptr) {
501 // No interface method. Call ShouldDenyAccessToMember again but this time
502 // with AccessMethod::kJNI to ensure that an appropriate warning is
503 // logged.
504 ShouldDenyAccessToMember(method, soa.Self(), hiddenapi::AccessMethod::kJNI);
505 method = nullptr;
506 } else {
507 // We found an interface method that is accessible, continue with the resolved method.
508 }
509 }
510 if (method == nullptr || method->IsStatic() != is_static) {
511 ThrowNoSuchMethodError(soa, c, name, sig, is_static ? "static" : "non-static");
512 return nullptr;
513 }
514 return method;
515 }
516
FindFieldJNI(const ScopedObjectAccess & soa,jclass jni_class,const char * name,const char * sig,bool is_static)517 ArtField* FindFieldJNI(const ScopedObjectAccess& soa,
518 jclass jni_class,
519 const char* name,
520 const char* sig,
521 bool is_static) {
522 StackHandleScope<2> hs(soa.Self());
523 Handle<mirror::Class> c(
524 hs.NewHandle(EnsureInitialized(soa.Self(), soa.Decode<mirror::Class>(jni_class))));
525 if (c == nullptr) {
526 return nullptr;
527 }
528 ArtField* field = nullptr;
529 ObjPtr<mirror::Class> field_type;
530 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
531 if (UNLIKELY(sig[0] == '\0')) {
532 DCHECK(field == nullptr);
533 } else if (sig[1] != '\0') {
534 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(c->GetClassLoader()));
535 field_type = class_linker->FindClass(soa.Self(), sig, class_loader);
536 } else {
537 field_type = class_linker->FindPrimitiveClass(*sig);
538 }
539 if (field_type == nullptr) {
540 // Failed to find type from the signature of the field.
541 DCHECK(sig[0] == '\0' || soa.Self()->IsExceptionPending());
542 StackHandleScope<1> hs2(soa.Self());
543 Handle<mirror::Throwable> cause(hs2.NewHandle(soa.Self()->GetException()));
544 soa.Self()->ClearException();
545 std::string temp;
546 soa.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
547 "no type \"%s\" found and so no field \"%s\" "
548 "could be found in class \"%s\" or its superclasses", sig, name,
549 c->GetDescriptor(&temp));
550 if (cause != nullptr) {
551 soa.Self()->GetException()->SetCause(cause.Get());
552 }
553 return nullptr;
554 }
555 std::string temp;
556 if (is_static) {
557 field = c->FindStaticField(name, field_type->GetDescriptor(&temp));
558 } else {
559 field = c->FindInstanceField(name, field_type->GetDescriptor(&temp));
560 }
561 if (field != nullptr && ShouldDenyAccessToMember(field, soa.Self())) {
562 field = nullptr;
563 }
564 if (field == nullptr) {
565 soa.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
566 "no \"%s\" field \"%s\" in class \"%s\" or its superclasses",
567 sig, name, c->GetDescriptor(&temp));
568 return nullptr;
569 }
570 return field;
571 }
572
ThrowNewException(JNIEnv * env,jclass exception_class,const char * msg,jobject cause)573 int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause)
574 REQUIRES(!Locks::mutator_lock_) {
575 // Turn the const char* into a java.lang.String.
576 ScopedLocalRef<jstring> s(env, env->NewStringUTF(msg));
577 if (msg != nullptr && s.get() == nullptr) {
578 return JNI_ERR;
579 }
580
581 // Choose an appropriate constructor and set up the arguments.
582 jvalue args[2];
583 const char* signature;
584 if (msg == nullptr && cause == nullptr) {
585 signature = "()V";
586 } else if (msg != nullptr && cause == nullptr) {
587 signature = "(Ljava/lang/String;)V";
588 args[0].l = s.get();
589 } else if (msg == nullptr && cause != nullptr) {
590 signature = "(Ljava/lang/Throwable;)V";
591 args[0].l = cause;
592 } else {
593 signature = "(Ljava/lang/String;Ljava/lang/Throwable;)V";
594 args[0].l = s.get();
595 args[1].l = cause;
596 }
597 jmethodID mid = env->GetMethodID(exception_class, "<init>", signature);
598 if (mid == nullptr) {
599 ScopedObjectAccess soa(env);
600 LOG(ERROR) << "No <init>" << signature << " in "
601 << mirror::Class::PrettyClass(soa.Decode<mirror::Class>(exception_class));
602 return JNI_ERR;
603 }
604
605 ScopedLocalRef<jthrowable> exception(
606 env, reinterpret_cast<jthrowable>(env->NewObjectA(exception_class, mid, args)));
607 if (exception.get() == nullptr) {
608 return JNI_ERR;
609 }
610 ScopedObjectAccess soa(env);
611 soa.Self()->SetException(soa.Decode<mirror::Throwable>(exception.get()));
612 return JNI_OK;
613 }
614
JavaVmExtFromEnv(JNIEnv * env)615 static JavaVMExt* JavaVmExtFromEnv(JNIEnv* env) {
616 return reinterpret_cast<JNIEnvExt*>(env)->GetVm();
617 }
618
619 #define CHECK_NON_NULL_ARGUMENT(value) \
620 CHECK_NON_NULL_ARGUMENT_FN_NAME(__FUNCTION__, value, nullptr)
621
622 #define CHECK_NON_NULL_ARGUMENT_RETURN_VOID(value) \
623 CHECK_NON_NULL_ARGUMENT_FN_NAME(__FUNCTION__, value, )
624
625 #define CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(value) \
626 CHECK_NON_NULL_ARGUMENT_FN_NAME(__FUNCTION__, value, 0)
627
628 #define CHECK_NON_NULL_ARGUMENT_RETURN(value, return_val) \
629 CHECK_NON_NULL_ARGUMENT_FN_NAME(__FUNCTION__, value, return_val)
630
631 #define CHECK_NON_NULL_ARGUMENT_FN_NAME(name, value, return_val) \
632 if (UNLIKELY((value) == nullptr)) { \
633 JavaVmExtFromEnv(env)->JniAbort(name, #value " == null"); \
634 return return_val; \
635 }
636
637 #define CHECK_NON_NULL_MEMCPY_ARGUMENT(length, value) \
638 if (UNLIKELY((length) != 0 && (value) == nullptr)) { \
639 JavaVmExtFromEnv(env)->JniAbort(__FUNCTION__, #value " == null"); \
640 return; \
641 }
642
643 template <bool kNative>
FindMethod(ObjPtr<mirror::Class> c,std::string_view name,std::string_view sig)644 static ArtMethod* FindMethod(ObjPtr<mirror::Class> c,
645 std::string_view name,
646 std::string_view sig)
647 REQUIRES_SHARED(Locks::mutator_lock_) {
648 auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
649 for (auto& method : c->GetMethods(pointer_size)) {
650 if (kNative == method.IsNative() && name == method.GetName() && method.GetSignature() == sig) {
651 return &method;
652 }
653 }
654 return nullptr;
655 }
656
657 template <bool kEnableIndexIds>
658 class JNI {
659 public:
GetVersion(JNIEnv *)660 static jint GetVersion(JNIEnv*) {
661 return JNI_VERSION_1_6;
662 }
663
DefineClass(JNIEnv *,const char *,jobject,const jbyte *,jsize)664 static jclass DefineClass(JNIEnv*, const char*, jobject, const jbyte*, jsize) {
665 LOG(WARNING) << "JNI DefineClass is not supported";
666 return nullptr;
667 }
668
FindClass(JNIEnv * env,const char * name)669 static jclass FindClass(JNIEnv* env, const char* name) {
670 CHECK_NON_NULL_ARGUMENT(name);
671 Runtime* runtime = Runtime::Current();
672 ClassLinker* class_linker = runtime->GetClassLinker();
673 std::string descriptor(NormalizeJniClassDescriptor(name));
674 ScopedObjectAccess soa(env);
675 ObjPtr<mirror::Class> c = nullptr;
676 if (runtime->IsStarted()) {
677 StackHandleScope<1> hs(soa.Self());
678 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(GetClassLoader<kEnableIndexIds>(soa)));
679 c = class_linker->FindClass(soa.Self(), descriptor.c_str(), class_loader);
680 } else {
681 c = class_linker->FindSystemClass(soa.Self(), descriptor.c_str());
682 }
683 return soa.AddLocalReference<jclass>(c);
684 }
685
FromReflectedMethod(JNIEnv * env,jobject jlr_method)686 static jmethodID FromReflectedMethod(JNIEnv* env, jobject jlr_method) {
687 CHECK_NON_NULL_ARGUMENT(jlr_method);
688 ScopedObjectAccess soa(env);
689 return jni::EncodeArtMethod<kEnableIndexIds>(ArtMethod::FromReflectedMethod(soa, jlr_method));
690 }
691
FromReflectedField(JNIEnv * env,jobject jlr_field)692 static jfieldID FromReflectedField(JNIEnv* env, jobject jlr_field) {
693 CHECK_NON_NULL_ARGUMENT(jlr_field);
694 ScopedObjectAccess soa(env);
695 ObjPtr<mirror::Object> obj_field = soa.Decode<mirror::Object>(jlr_field);
696 if (obj_field->GetClass() != GetClassRoot<mirror::Field>()) {
697 // Not even a java.lang.reflect.Field, return null. TODO, is this check necessary?
698 return nullptr;
699 }
700 ObjPtr<mirror::Field> field = ObjPtr<mirror::Field>::DownCast(obj_field);
701 return jni::EncodeArtField<kEnableIndexIds>(field->GetArtField());
702 }
703
ToReflectedMethod(JNIEnv * env,jclass,jmethodID mid,jboolean)704 static jobject ToReflectedMethod(JNIEnv* env, jclass, jmethodID mid, jboolean) {
705 CHECK_NON_NULL_ARGUMENT(mid);
706 ScopedObjectAccess soa(env);
707 ArtMethod* m = jni::DecodeArtMethod(mid);
708 ObjPtr<mirror::Executable> method;
709 DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
710 if (m->IsConstructor()) {
711 method = mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), m);
712 } else {
713 method = mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), m);
714 }
715 return soa.AddLocalReference<jobject>(method);
716 }
717
ToReflectedField(JNIEnv * env,jclass,jfieldID fid,jboolean)718 static jobject ToReflectedField(JNIEnv* env, jclass, jfieldID fid, jboolean) {
719 CHECK_NON_NULL_ARGUMENT(fid);
720 ScopedObjectAccess soa(env);
721 ArtField* f = jni::DecodeArtField(fid);
722 return soa.AddLocalReference<jobject>(
723 mirror::Field::CreateFromArtField(soa.Self(), f, true));
724 }
725
GetObjectClass(JNIEnv * env,jobject java_object)726 static jclass GetObjectClass(JNIEnv* env, jobject java_object) {
727 CHECK_NON_NULL_ARGUMENT(java_object);
728 ScopedObjectAccess soa(env);
729 ObjPtr<mirror::Object> o = soa.Decode<mirror::Object>(java_object);
730 return soa.AddLocalReference<jclass>(o->GetClass());
731 }
732
GetSuperclass(JNIEnv * env,jclass java_class)733 static jclass GetSuperclass(JNIEnv* env, jclass java_class) {
734 CHECK_NON_NULL_ARGUMENT(java_class);
735 ScopedObjectAccess soa(env);
736 ObjPtr<mirror::Class> c = soa.Decode<mirror::Class>(java_class);
737 return soa.AddLocalReference<jclass>(c->IsInterface() ? nullptr : c->GetSuperClass());
738 }
739
740 // Note: java_class1 should be safely castable to java_class2, and
741 // not the other way around.
IsAssignableFrom(JNIEnv * env,jclass java_class1,jclass java_class2)742 static jboolean IsAssignableFrom(JNIEnv* env, jclass java_class1, jclass java_class2) {
743 CHECK_NON_NULL_ARGUMENT_RETURN(java_class1, JNI_FALSE);
744 CHECK_NON_NULL_ARGUMENT_RETURN(java_class2, JNI_FALSE);
745 ScopedObjectAccess soa(env);
746 ObjPtr<mirror::Class> c1 = soa.Decode<mirror::Class>(java_class1);
747 ObjPtr<mirror::Class> c2 = soa.Decode<mirror::Class>(java_class2);
748 return c2->IsAssignableFrom(c1) ? JNI_TRUE : JNI_FALSE;
749 }
750
IsInstanceOf(JNIEnv * env,jobject jobj,jclass java_class)751 static jboolean IsInstanceOf(JNIEnv* env, jobject jobj, jclass java_class) {
752 CHECK_NON_NULL_ARGUMENT_RETURN(java_class, JNI_FALSE);
753 if (jobj == nullptr) {
754 // Note: JNI is different from regular Java instanceof in this respect
755 return JNI_TRUE;
756 } else {
757 ScopedObjectAccess soa(env);
758 ObjPtr<mirror::Object> obj = soa.Decode<mirror::Object>(jobj);
759 ObjPtr<mirror::Class> c = soa.Decode<mirror::Class>(java_class);
760 return obj->InstanceOf(c) ? JNI_TRUE : JNI_FALSE;
761 }
762 }
763
Throw(JNIEnv * env,jthrowable java_exception)764 static jint Throw(JNIEnv* env, jthrowable java_exception) {
765 ScopedObjectAccess soa(env);
766 ObjPtr<mirror::Throwable> exception = soa.Decode<mirror::Throwable>(java_exception);
767 if (exception == nullptr) {
768 return JNI_ERR;
769 }
770 soa.Self()->SetException(exception);
771 return JNI_OK;
772 }
773
ThrowNew(JNIEnv * env,jclass c,const char * msg)774 static jint ThrowNew(JNIEnv* env, jclass c, const char* msg) {
775 CHECK_NON_NULL_ARGUMENT_RETURN(c, JNI_ERR);
776 return ThrowNewException(env, c, msg, nullptr);
777 }
778
ExceptionCheck(JNIEnv * env)779 static jboolean ExceptionCheck(JNIEnv* env) {
780 return static_cast<JNIEnvExt*>(env)->self_->IsExceptionPending() ? JNI_TRUE : JNI_FALSE;
781 }
782
ExceptionClear(JNIEnv * env)783 static void ExceptionClear(JNIEnv* env) {
784 ScopedObjectAccess soa(env);
785 soa.Self()->ClearException();
786 }
787
ExceptionDescribe(JNIEnv * env)788 static void ExceptionDescribe(JNIEnv* env) {
789 ScopedObjectAccess soa(env);
790
791 // If we have no exception to describe, pass through.
792 if (!soa.Self()->GetException()) {
793 return;
794 }
795
796 StackHandleScope<1> hs(soa.Self());
797 Handle<mirror::Throwable> old_exception(
798 hs.NewHandle<mirror::Throwable>(soa.Self()->GetException()));
799 soa.Self()->ClearException();
800 ScopedLocalRef<jthrowable> exception(env,
801 soa.AddLocalReference<jthrowable>(old_exception.Get()));
802 ScopedLocalRef<jclass> exception_class(env, env->GetObjectClass(exception.get()));
803 jmethodID mid = env->GetMethodID(exception_class.get(), "printStackTrace", "()V");
804 if (mid == nullptr) {
805 LOG(WARNING) << "JNI WARNING: no printStackTrace()V in "
806 << mirror::Object::PrettyTypeOf(old_exception.Get());
807 } else {
808 env->CallVoidMethod(exception.get(), mid);
809 if (soa.Self()->IsExceptionPending()) {
810 LOG(WARNING) << "JNI WARNING: " << mirror::Object::PrettyTypeOf(soa.Self()->GetException())
811 << " thrown while calling printStackTrace";
812 soa.Self()->ClearException();
813 }
814 }
815 soa.Self()->SetException(old_exception.Get());
816 }
817
ExceptionOccurred(JNIEnv * env)818 static jthrowable ExceptionOccurred(JNIEnv* env) {
819 ScopedObjectAccess soa(env);
820 ObjPtr<mirror::Object> exception = soa.Self()->GetException();
821 return soa.AddLocalReference<jthrowable>(exception);
822 }
823
FatalError(JNIEnv *,const char * msg)824 static void FatalError(JNIEnv*, const char* msg) {
825 LOG(FATAL) << "JNI FatalError called: " << msg;
826 }
827
PushLocalFrame(JNIEnv * env,jint capacity)828 static jint PushLocalFrame(JNIEnv* env, jint capacity) {
829 // TODO: SOA may not be necessary but I do it to please lock annotations.
830 ScopedObjectAccess soa(env);
831 if (EnsureLocalCapacityInternal(soa, capacity, "PushLocalFrame") != JNI_OK) {
832 return JNI_ERR;
833 }
834 down_cast<JNIEnvExt*>(env)->PushFrame(capacity);
835 return JNI_OK;
836 }
837
PopLocalFrame(JNIEnv * env,jobject java_survivor)838 static jobject PopLocalFrame(JNIEnv* env, jobject java_survivor) {
839 ScopedObjectAccess soa(env);
840 ObjPtr<mirror::Object> survivor = soa.Decode<mirror::Object>(java_survivor);
841 soa.Env()->PopFrame();
842 return soa.AddLocalReference<jobject>(survivor);
843 }
844
EnsureLocalCapacity(JNIEnv * env,jint desired_capacity)845 static jint EnsureLocalCapacity(JNIEnv* env, jint desired_capacity) {
846 // TODO: SOA may not be necessary but I do it to please lock annotations.
847 ScopedObjectAccess soa(env);
848 return EnsureLocalCapacityInternal(soa, desired_capacity, "EnsureLocalCapacity");
849 }
850
NewGlobalRef(JNIEnv * env,jobject obj)851 static jobject NewGlobalRef(JNIEnv* env, jobject obj) {
852 ScopedObjectAccess soa(env);
853 ObjPtr<mirror::Object> decoded_obj = soa.Decode<mirror::Object>(obj);
854 return soa.Vm()->AddGlobalRef(soa.Self(), decoded_obj);
855 }
856
DeleteGlobalRef(JNIEnv * env,jobject obj)857 static void DeleteGlobalRef(JNIEnv* env, jobject obj) {
858 JavaVMExt* vm = down_cast<JNIEnvExt*>(env)->GetVm();
859 Thread* self = down_cast<JNIEnvExt*>(env)->self_;
860 vm->DeleteGlobalRef(self, obj);
861 }
862
NewWeakGlobalRef(JNIEnv * env,jobject obj)863 static jweak NewWeakGlobalRef(JNIEnv* env, jobject obj) {
864 ScopedObjectAccess soa(env);
865 ObjPtr<mirror::Object> decoded_obj = soa.Decode<mirror::Object>(obj);
866 return soa.Vm()->AddWeakGlobalRef(soa.Self(), decoded_obj);
867 }
868
DeleteWeakGlobalRef(JNIEnv * env,jweak obj)869 static void DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
870 JavaVMExt* vm = down_cast<JNIEnvExt*>(env)->GetVm();
871 Thread* self = down_cast<JNIEnvExt*>(env)->self_;
872 vm->DeleteWeakGlobalRef(self, obj);
873 }
874
NewLocalRef(JNIEnv * env,jobject obj)875 static jobject NewLocalRef(JNIEnv* env, jobject obj) {
876 ScopedObjectAccess soa(env);
877 ObjPtr<mirror::Object> decoded_obj = soa.Decode<mirror::Object>(obj);
878 // Check for null after decoding the object to handle cleared weak globals.
879 if (decoded_obj == nullptr) {
880 return nullptr;
881 }
882 return soa.AddLocalReference<jobject>(decoded_obj);
883 }
884
DeleteLocalRef(JNIEnv * env,jobject obj)885 static void DeleteLocalRef(JNIEnv* env, jobject obj) {
886 if (obj == nullptr) {
887 return;
888 }
889 // SOA is only necessary to have exclusion between GC root marking and removing.
890 // We don't want to have the GC attempt to mark a null root if we just removed
891 // it. b/22119403
892 ScopedObjectAccess soa(env);
893 auto* ext_env = down_cast<JNIEnvExt*>(env);
894 if (!ext_env->locals_.Remove(ext_env->local_ref_cookie_, obj)) {
895 // Attempting to delete a local reference that is not in the
896 // topmost local reference frame is a no-op. DeleteLocalRef returns
897 // void and doesn't throw any exceptions, but we should probably
898 // complain about it so the user will notice that things aren't
899 // going quite the way they expect.
900 LOG(WARNING) << "JNI WARNING: DeleteLocalRef(" << obj << ") "
901 << "failed to find entry";
902 // Investigating b/228295454: Scudo ERROR: internal map failure (NO MEMORY).
903 soa.Self()->DumpJavaStack(LOG_STREAM(WARNING));
904 }
905 }
906
IsSameObject(JNIEnv * env,jobject obj1,jobject obj2)907 static jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2) {
908 if (obj1 == obj2) {
909 return JNI_TRUE;
910 } else {
911 ScopedObjectAccess soa(env);
912 return (soa.Decode<mirror::Object>(obj1) == soa.Decode<mirror::Object>(obj2))
913 ? JNI_TRUE : JNI_FALSE;
914 }
915 }
916
AllocObject(JNIEnv * env,jclass java_class)917 static jobject AllocObject(JNIEnv* env, jclass java_class) {
918 CHECK_NON_NULL_ARGUMENT(java_class);
919 ScopedObjectAccess soa(env);
920 ObjPtr<mirror::Class> c = EnsureInitialized(soa.Self(), soa.Decode<mirror::Class>(java_class));
921 if (c == nullptr) {
922 return nullptr;
923 }
924 if (c->IsStringClass()) {
925 gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator();
926 return soa.AddLocalReference<jobject>(
927 mirror::String::AllocEmptyString(soa.Self(), allocator_type));
928 }
929 return soa.AddLocalReference<jobject>(c->AllocObject(soa.Self()));
930 }
931
NewObject(JNIEnv * env,jclass java_class,jmethodID mid,...)932 static jobject NewObject(JNIEnv* env, jclass java_class, jmethodID mid, ...) {
933 va_list args;
934 va_start(args, mid);
935 ScopedVAArgs free_args_later(&args);
936 CHECK_NON_NULL_ARGUMENT(java_class);
937 CHECK_NON_NULL_ARGUMENT(mid);
938 jobject result = NewObjectV(env, java_class, mid, args);
939 return result;
940 }
941
NewObjectV(JNIEnv * env,jclass java_class,jmethodID mid,va_list args)942 static jobject NewObjectV(JNIEnv* env, jclass java_class, jmethodID mid, va_list args) {
943 CHECK_NON_NULL_ARGUMENT(java_class);
944 CHECK_NON_NULL_ARGUMENT(mid);
945 ScopedObjectAccess soa(env);
946 ObjPtr<mirror::Class> c = EnsureInitialized(soa.Self(),
947 soa.Decode<mirror::Class>(java_class));
948 if (c == nullptr) {
949 return nullptr;
950 }
951 if (c->IsStringClass()) {
952 // Replace calls to String.<init> with equivalent StringFactory call.
953 jmethodID sf_mid = jni::EncodeArtMethod<kEnableIndexIds>(
954 WellKnownClasses::StringInitToStringFactory(jni::DecodeArtMethod(mid)));
955 return CallStaticObjectMethodV(env, WellKnownClasses::java_lang_StringFactory, sf_mid, args);
956 }
957 ScopedLocalRef<jobject> result(env, soa.AddLocalReference<jobject>(c->AllocObject(soa.Self())));
958 if (result == nullptr) {
959 return nullptr;
960 }
961 CallNonvirtualVoidMethodV(env, result.get(), java_class, mid, args);
962 if (soa.Self()->IsExceptionPending()) {
963 return nullptr;
964 }
965 return result.release();
966 }
967
NewObjectA(JNIEnv * env,jclass java_class,jmethodID mid,const jvalue * args)968 static jobject NewObjectA(JNIEnv* env, jclass java_class, jmethodID mid, const jvalue* args) {
969 CHECK_NON_NULL_ARGUMENT(java_class);
970 CHECK_NON_NULL_ARGUMENT(mid);
971 ScopedObjectAccess soa(env);
972 ObjPtr<mirror::Class> c = EnsureInitialized(soa.Self(),
973 soa.Decode<mirror::Class>(java_class));
974 if (c == nullptr) {
975 return nullptr;
976 }
977 if (c->IsStringClass()) {
978 // Replace calls to String.<init> with equivalent StringFactory call.
979 jmethodID sf_mid = jni::EncodeArtMethod<kEnableIndexIds>(
980 WellKnownClasses::StringInitToStringFactory(jni::DecodeArtMethod(mid)));
981 return CallStaticObjectMethodA(env, WellKnownClasses::java_lang_StringFactory, sf_mid, args);
982 }
983 ScopedLocalRef<jobject> result(env, soa.AddLocalReference<jobject>(c->AllocObject(soa.Self())));
984 if (result == nullptr) {
985 return nullptr;
986 }
987 CallNonvirtualVoidMethodA(env, result.get(), java_class, mid, args);
988 if (soa.Self()->IsExceptionPending()) {
989 return nullptr;
990 }
991 return result.release();
992 }
993
GetMethodID(JNIEnv * env,jclass java_class,const char * name,const char * sig)994 static jmethodID GetMethodID(JNIEnv* env, jclass java_class, const char* name, const char* sig) {
995 CHECK_NON_NULL_ARGUMENT(java_class);
996 CHECK_NON_NULL_ARGUMENT(name);
997 CHECK_NON_NULL_ARGUMENT(sig);
998 ScopedObjectAccess soa(env);
999 return FindMethodID<kEnableIndexIds>(soa, java_class, name, sig, false);
1000 }
1001
GetStaticMethodID(JNIEnv * env,jclass java_class,const char * name,const char * sig)1002 static jmethodID GetStaticMethodID(JNIEnv* env, jclass java_class, const char* name,
1003 const char* sig) {
1004 CHECK_NON_NULL_ARGUMENT(java_class);
1005 CHECK_NON_NULL_ARGUMENT(name);
1006 CHECK_NON_NULL_ARGUMENT(sig);
1007 ScopedObjectAccess soa(env);
1008 return FindMethodID<kEnableIndexIds>(soa, java_class, name, sig, true);
1009 }
1010
CallObjectMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1011 static jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1012 va_list ap;
1013 va_start(ap, mid);
1014 ScopedVAArgs free_args_later(&ap);
1015 CHECK_NON_NULL_ARGUMENT(obj);
1016 CHECK_NON_NULL_ARGUMENT(mid);
1017 ScopedObjectAccess soa(env);
1018 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1019 return soa.AddLocalReference<jobject>(result.GetL());
1020 }
1021
CallObjectMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1022 static jobject CallObjectMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1023 CHECK_NON_NULL_ARGUMENT(obj);
1024 CHECK_NON_NULL_ARGUMENT(mid);
1025 ScopedObjectAccess soa(env);
1026 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args));
1027 return soa.AddLocalReference<jobject>(result.GetL());
1028 }
1029
CallObjectMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1030 static jobject CallObjectMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1031 CHECK_NON_NULL_ARGUMENT(obj);
1032 CHECK_NON_NULL_ARGUMENT(mid);
1033 ScopedObjectAccess soa(env);
1034 JValue result(InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args));
1035 return soa.AddLocalReference<jobject>(result.GetL());
1036 }
1037
CallBooleanMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1038 static jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1039 va_list ap;
1040 va_start(ap, mid);
1041 ScopedVAArgs free_args_later(&ap);
1042 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1043 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1044 ScopedObjectAccess soa(env);
1045 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1046 return result.GetZ();
1047 }
1048
CallBooleanMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1049 static jboolean CallBooleanMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1050 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1051 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1052 ScopedObjectAccess soa(env);
1053 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetZ();
1054 }
1055
CallBooleanMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1056 static jboolean CallBooleanMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1057 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1058 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1059 ScopedObjectAccess soa(env);
1060 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetZ();
1061 }
1062
CallByteMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1063 static jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1064 va_list ap;
1065 va_start(ap, mid);
1066 ScopedVAArgs free_args_later(&ap);
1067 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1068 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1069 ScopedObjectAccess soa(env);
1070 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1071 return result.GetB();
1072 }
1073
CallByteMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1074 static jbyte CallByteMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1075 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1076 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1077 ScopedObjectAccess soa(env);
1078 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetB();
1079 }
1080
CallByteMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1081 static jbyte CallByteMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1082 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1083 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1084 ScopedObjectAccess soa(env);
1085 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetB();
1086 }
1087
CallCharMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1088 static jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1089 va_list ap;
1090 va_start(ap, mid);
1091 ScopedVAArgs free_args_later(&ap);
1092 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1093 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1094 ScopedObjectAccess soa(env);
1095 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1096 return result.GetC();
1097 }
1098
CallCharMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1099 static jchar CallCharMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1100 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1101 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1102 ScopedObjectAccess soa(env);
1103 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetC();
1104 }
1105
CallCharMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1106 static jchar CallCharMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1107 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1108 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1109 ScopedObjectAccess soa(env);
1110 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetC();
1111 }
1112
CallDoubleMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1113 static jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1114 va_list ap;
1115 va_start(ap, mid);
1116 ScopedVAArgs free_args_later(&ap);
1117 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1118 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1119 ScopedObjectAccess soa(env);
1120 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1121 return result.GetD();
1122 }
1123
CallDoubleMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1124 static jdouble CallDoubleMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1125 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1126 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1127 ScopedObjectAccess soa(env);
1128 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetD();
1129 }
1130
CallDoubleMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1131 static jdouble CallDoubleMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1132 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1133 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1134 ScopedObjectAccess soa(env);
1135 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetD();
1136 }
1137
CallFloatMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1138 static jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1139 va_list ap;
1140 va_start(ap, mid);
1141 ScopedVAArgs free_args_later(&ap);
1142 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1143 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1144 ScopedObjectAccess soa(env);
1145 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1146 return result.GetF();
1147 }
1148
CallFloatMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1149 static jfloat CallFloatMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1150 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1151 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1152 ScopedObjectAccess soa(env);
1153 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetF();
1154 }
1155
CallFloatMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1156 static jfloat CallFloatMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1157 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1158 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1159 ScopedObjectAccess soa(env);
1160 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetF();
1161 }
1162
CallIntMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1163 static jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1164 va_list ap;
1165 va_start(ap, mid);
1166 ScopedVAArgs free_args_later(&ap);
1167 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1168 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1169 ScopedObjectAccess soa(env);
1170 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1171 return result.GetI();
1172 }
1173
CallIntMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1174 static jint CallIntMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1175 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1176 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1177 ScopedObjectAccess soa(env);
1178 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetI();
1179 }
1180
CallIntMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1181 static jint CallIntMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1182 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1183 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1184 ScopedObjectAccess soa(env);
1185 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetI();
1186 }
1187
CallLongMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1188 static jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1189 va_list ap;
1190 va_start(ap, mid);
1191 ScopedVAArgs free_args_later(&ap);
1192 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1193 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1194 ScopedObjectAccess soa(env);
1195 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1196 return result.GetJ();
1197 }
1198
CallLongMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1199 static jlong CallLongMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1200 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1201 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1202 ScopedObjectAccess soa(env);
1203 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetJ();
1204 }
1205
CallLongMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1206 static jlong CallLongMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1207 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1208 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1209 ScopedObjectAccess soa(env);
1210 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetJ();
1211 }
1212
CallShortMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1213 static jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1214 va_list ap;
1215 va_start(ap, mid);
1216 ScopedVAArgs free_args_later(&ap);
1217 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1218 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1219 ScopedObjectAccess soa(env);
1220 JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
1221 return result.GetS();
1222 }
1223
CallShortMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1224 static jshort CallShortMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1225 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1226 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1227 ScopedObjectAccess soa(env);
1228 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetS();
1229 }
1230
CallShortMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1231 static jshort CallShortMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1232 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1233 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1234 ScopedObjectAccess soa(env);
1235 return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetS();
1236 }
1237
CallVoidMethod(JNIEnv * env,jobject obj,jmethodID mid,...)1238 static void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
1239 va_list ap;
1240 va_start(ap, mid);
1241 ScopedVAArgs free_args_later(&ap);
1242 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(obj);
1243 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1244 ScopedObjectAccess soa(env);
1245 InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap);
1246 }
1247
CallVoidMethodV(JNIEnv * env,jobject obj,jmethodID mid,va_list args)1248 static void CallVoidMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
1249 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(obj);
1250 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1251 ScopedObjectAccess soa(env);
1252 InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args);
1253 }
1254
CallVoidMethodA(JNIEnv * env,jobject obj,jmethodID mid,const jvalue * args)1255 static void CallVoidMethodA(JNIEnv* env, jobject obj, jmethodID mid, const jvalue* args) {
1256 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(obj);
1257 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1258 ScopedObjectAccess soa(env);
1259 InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args);
1260 }
1261
CallNonvirtualObjectMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1262 static jobject CallNonvirtualObjectMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1263 va_list ap;
1264 va_start(ap, mid);
1265 ScopedVAArgs free_args_later(&ap);
1266 CHECK_NON_NULL_ARGUMENT(obj);
1267 CHECK_NON_NULL_ARGUMENT(mid);
1268 ScopedObjectAccess soa(env);
1269 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1270 return soa.AddLocalReference<jobject>(result.GetL());
1271 }
1272
CallNonvirtualObjectMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1273 static jobject CallNonvirtualObjectMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1274 va_list args) {
1275 CHECK_NON_NULL_ARGUMENT(obj);
1276 CHECK_NON_NULL_ARGUMENT(mid);
1277 ScopedObjectAccess soa(env);
1278 JValue result(InvokeWithVarArgs(soa, obj, mid, args));
1279 return soa.AddLocalReference<jobject>(result.GetL());
1280 }
1281
CallNonvirtualObjectMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1282 static jobject CallNonvirtualObjectMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1283 const jvalue* args) {
1284 CHECK_NON_NULL_ARGUMENT(obj);
1285 CHECK_NON_NULL_ARGUMENT(mid);
1286 ScopedObjectAccess soa(env);
1287 JValue result(InvokeWithJValues(soa, obj, mid, args));
1288 return soa.AddLocalReference<jobject>(result.GetL());
1289 }
1290
CallNonvirtualBooleanMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1291 static jboolean CallNonvirtualBooleanMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1292 ...) {
1293 va_list ap;
1294 va_start(ap, mid);
1295 ScopedVAArgs free_args_later(&ap);
1296 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1297 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1298 ScopedObjectAccess soa(env);
1299 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1300 return result.GetZ();
1301 }
1302
CallNonvirtualBooleanMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1303 static jboolean CallNonvirtualBooleanMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1304 va_list args) {
1305 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1306 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1307 ScopedObjectAccess soa(env);
1308 return InvokeWithVarArgs(soa, obj, mid, args).GetZ();
1309 }
1310
CallNonvirtualBooleanMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1311 static jboolean CallNonvirtualBooleanMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1312 const jvalue* args) {
1313 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1314 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1315 ScopedObjectAccess soa(env);
1316 return InvokeWithJValues(soa, obj, mid, args).GetZ();
1317 }
1318
CallNonvirtualByteMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1319 static jbyte CallNonvirtualByteMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1320 va_list ap;
1321 va_start(ap, mid);
1322 ScopedVAArgs free_args_later(&ap);
1323 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1324 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1325 ScopedObjectAccess soa(env);
1326 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1327 return result.GetB();
1328 }
1329
CallNonvirtualByteMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1330 static jbyte CallNonvirtualByteMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1331 va_list args) {
1332 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1333 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1334 ScopedObjectAccess soa(env);
1335 return InvokeWithVarArgs(soa, obj, mid, args).GetB();
1336 }
1337
CallNonvirtualByteMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1338 static jbyte CallNonvirtualByteMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1339 const jvalue* args) {
1340 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1341 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1342 ScopedObjectAccess soa(env);
1343 return InvokeWithJValues(soa, obj, mid, args).GetB();
1344 }
1345
CallNonvirtualCharMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1346 static jchar CallNonvirtualCharMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1347 va_list ap;
1348 va_start(ap, mid);
1349 ScopedVAArgs free_args_later(&ap);
1350 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1351 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1352 ScopedObjectAccess soa(env);
1353 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1354 return result.GetC();
1355 }
1356
CallNonvirtualCharMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1357 static jchar CallNonvirtualCharMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1358 va_list args) {
1359 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1360 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1361 ScopedObjectAccess soa(env);
1362 return InvokeWithVarArgs(soa, obj, mid, args).GetC();
1363 }
1364
CallNonvirtualCharMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1365 static jchar CallNonvirtualCharMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1366 const jvalue* args) {
1367 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1368 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1369 ScopedObjectAccess soa(env);
1370 return InvokeWithJValues(soa, obj, mid, args).GetC();
1371 }
1372
CallNonvirtualShortMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1373 static jshort CallNonvirtualShortMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1374 va_list ap;
1375 va_start(ap, mid);
1376 ScopedVAArgs free_args_later(&ap);
1377 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1378 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1379 ScopedObjectAccess soa(env);
1380 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1381 return result.GetS();
1382 }
1383
CallNonvirtualShortMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1384 static jshort CallNonvirtualShortMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1385 va_list args) {
1386 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1387 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1388 ScopedObjectAccess soa(env);
1389 return InvokeWithVarArgs(soa, obj, mid, args).GetS();
1390 }
1391
CallNonvirtualShortMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1392 static jshort CallNonvirtualShortMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1393 const jvalue* args) {
1394 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1395 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1396 ScopedObjectAccess soa(env);
1397 return InvokeWithJValues(soa, obj, mid, args).GetS();
1398 }
1399
CallNonvirtualIntMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1400 static jint CallNonvirtualIntMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1401 va_list ap;
1402 va_start(ap, mid);
1403 ScopedVAArgs free_args_later(&ap);
1404 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1405 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1406 ScopedObjectAccess soa(env);
1407 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1408 return result.GetI();
1409 }
1410
CallNonvirtualIntMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1411 static jint CallNonvirtualIntMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1412 va_list args) {
1413 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1414 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1415 ScopedObjectAccess soa(env);
1416 return InvokeWithVarArgs(soa, obj, mid, args).GetI();
1417 }
1418
CallNonvirtualIntMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1419 static jint CallNonvirtualIntMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1420 const jvalue* args) {
1421 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1422 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1423 ScopedObjectAccess soa(env);
1424 return InvokeWithJValues(soa, obj, mid, args).GetI();
1425 }
1426
CallNonvirtualLongMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1427 static jlong CallNonvirtualLongMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1428 va_list ap;
1429 va_start(ap, mid);
1430 ScopedVAArgs free_args_later(&ap);
1431 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1432 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1433 ScopedObjectAccess soa(env);
1434 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1435 return result.GetJ();
1436 }
1437
CallNonvirtualLongMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1438 static jlong CallNonvirtualLongMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1439 va_list args) {
1440 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1441 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1442 ScopedObjectAccess soa(env);
1443 return InvokeWithVarArgs(soa, obj, mid, args).GetJ();
1444 }
1445
CallNonvirtualLongMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1446 static jlong CallNonvirtualLongMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1447 const jvalue* args) {
1448 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1449 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1450 ScopedObjectAccess soa(env);
1451 return InvokeWithJValues(soa, obj, mid, args).GetJ();
1452 }
1453
CallNonvirtualFloatMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1454 static jfloat CallNonvirtualFloatMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1455 va_list ap;
1456 va_start(ap, mid);
1457 ScopedVAArgs free_args_later(&ap);
1458 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1459 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1460 ScopedObjectAccess soa(env);
1461 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1462 return result.GetF();
1463 }
1464
CallNonvirtualFloatMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1465 static jfloat CallNonvirtualFloatMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1466 va_list args) {
1467 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1468 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1469 ScopedObjectAccess soa(env);
1470 return InvokeWithVarArgs(soa, obj, mid, args).GetF();
1471 }
1472
CallNonvirtualFloatMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1473 static jfloat CallNonvirtualFloatMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1474 const jvalue* args) {
1475 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1476 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1477 ScopedObjectAccess soa(env);
1478 return InvokeWithJValues(soa, obj, mid, args).GetF();
1479 }
1480
CallNonvirtualDoubleMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1481 static jdouble CallNonvirtualDoubleMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1482 va_list ap;
1483 va_start(ap, mid);
1484 ScopedVAArgs free_args_later(&ap);
1485 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1486 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1487 ScopedObjectAccess soa(env);
1488 JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
1489 return result.GetD();
1490 }
1491
CallNonvirtualDoubleMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1492 static jdouble CallNonvirtualDoubleMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1493 va_list args) {
1494 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1495 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1496 ScopedObjectAccess soa(env);
1497 return InvokeWithVarArgs(soa, obj, mid, args).GetD();
1498 }
1499
CallNonvirtualDoubleMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1500 static jdouble CallNonvirtualDoubleMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1501 const jvalue* args) {
1502 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
1503 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1504 ScopedObjectAccess soa(env);
1505 return InvokeWithJValues(soa, obj, mid, args).GetD();
1506 }
1507
CallNonvirtualVoidMethod(JNIEnv * env,jobject obj,jclass,jmethodID mid,...)1508 static void CallNonvirtualVoidMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
1509 va_list ap;
1510 va_start(ap, mid);
1511 ScopedVAArgs free_args_later(&ap);
1512 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(obj);
1513 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1514 ScopedObjectAccess soa(env);
1515 InvokeWithVarArgs(soa, obj, mid, ap);
1516 }
1517
CallNonvirtualVoidMethodV(JNIEnv * env,jobject obj,jclass,jmethodID mid,va_list args)1518 static void CallNonvirtualVoidMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1519 va_list args) {
1520 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(obj);
1521 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1522 ScopedObjectAccess soa(env);
1523 InvokeWithVarArgs(soa, obj, mid, args);
1524 }
1525
CallNonvirtualVoidMethodA(JNIEnv * env,jobject obj,jclass,jmethodID mid,const jvalue * args)1526 static void CallNonvirtualVoidMethodA(JNIEnv* env, jobject obj, jclass, jmethodID mid,
1527 const jvalue* args) {
1528 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(obj);
1529 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1530 ScopedObjectAccess soa(env);
1531 InvokeWithJValues(soa, obj, mid, args);
1532 }
1533
GetFieldID(JNIEnv * env,jclass java_class,const char * name,const char * sig)1534 static jfieldID GetFieldID(JNIEnv* env, jclass java_class, const char* name, const char* sig) {
1535 CHECK_NON_NULL_ARGUMENT(java_class);
1536 CHECK_NON_NULL_ARGUMENT(name);
1537 CHECK_NON_NULL_ARGUMENT(sig);
1538 ScopedObjectAccess soa(env);
1539 return FindFieldID<kEnableIndexIds>(soa, java_class, name, sig, false);
1540 }
1541
GetStaticFieldID(JNIEnv * env,jclass java_class,const char * name,const char * sig)1542 static jfieldID GetStaticFieldID(JNIEnv* env, jclass java_class, const char* name,
1543 const char* sig) {
1544 CHECK_NON_NULL_ARGUMENT(java_class);
1545 CHECK_NON_NULL_ARGUMENT(name);
1546 CHECK_NON_NULL_ARGUMENT(sig);
1547 ScopedObjectAccess soa(env);
1548 return FindFieldID<kEnableIndexIds>(soa, java_class, name, sig, true);
1549 }
1550
GetObjectField(JNIEnv * env,jobject obj,jfieldID fid)1551 static jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fid) {
1552 CHECK_NON_NULL_ARGUMENT(obj);
1553 CHECK_NON_NULL_ARGUMENT(fid);
1554 ScopedObjectAccess soa(env);
1555 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid);
1556 NotifyGetField(f, obj);
1557 ObjPtr<mirror::Object> o = soa.Decode<mirror::Object>(obj);
1558 return soa.AddLocalReference<jobject>(f->GetObject(o));
1559 }
1560
GetStaticObjectField(JNIEnv * env,jclass,jfieldID fid)1561 static jobject GetStaticObjectField(JNIEnv* env, jclass, jfieldID fid) {
1562 CHECK_NON_NULL_ARGUMENT(fid);
1563 ScopedObjectAccess soa(env);
1564 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid);
1565 NotifyGetField(f, nullptr);
1566 return soa.AddLocalReference<jobject>(f->GetObject(f->GetDeclaringClass()));
1567 }
1568
SetObjectField(JNIEnv * env,jobject java_object,jfieldID fid,jobject java_value)1569 static void SetObjectField(JNIEnv* env, jobject java_object, jfieldID fid, jobject java_value) {
1570 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_object);
1571 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(fid);
1572 ScopedObjectAccess soa(env);
1573 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid);
1574 NotifySetObjectField(f, java_object, java_value);
1575 ObjPtr<mirror::Object> o = soa.Decode<mirror::Object>(java_object);
1576 ObjPtr<mirror::Object> v = soa.Decode<mirror::Object>(java_value);
1577 f->SetObject<false>(o, v);
1578 }
1579
SetStaticObjectField(JNIEnv * env,jclass,jfieldID fid,jobject java_value)1580 static void SetStaticObjectField(JNIEnv* env, jclass, jfieldID fid, jobject java_value) {
1581 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(fid);
1582 ScopedObjectAccess soa(env);
1583 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid);
1584 NotifySetObjectField(f, nullptr, java_value);
1585 ObjPtr<mirror::Object> v = soa.Decode<mirror::Object>(java_value);
1586 f->SetObject<false>(f->GetDeclaringClass(), v);
1587 }
1588
1589 #define GET_PRIMITIVE_FIELD(fn, instance) \
1590 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(instance); \
1591 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(fid); \
1592 ScopedObjectAccess soa(env); \
1593 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid); \
1594 NotifyGetField(f, instance); \
1595 ObjPtr<mirror::Object> o = soa.Decode<mirror::Object>(instance); \
1596 return f->Get ##fn (o)
1597
1598 #define GET_STATIC_PRIMITIVE_FIELD(fn) \
1599 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(fid); \
1600 ScopedObjectAccess soa(env); \
1601 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid); \
1602 NotifyGetField(f, nullptr); \
1603 return f->Get ##fn (f->GetDeclaringClass())
1604
1605 #define SET_PRIMITIVE_FIELD(fn, instance, value) \
1606 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(instance); \
1607 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(fid); \
1608 ScopedObjectAccess soa(env); \
1609 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid); \
1610 NotifySetPrimitiveField(f, instance, JValue::FromPrimitive<decltype(value)>(value)); \
1611 ObjPtr<mirror::Object> o = soa.Decode<mirror::Object>(instance); \
1612 f->Set ##fn <false>(o, value)
1613
1614 #define SET_STATIC_PRIMITIVE_FIELD(fn, value) \
1615 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(fid); \
1616 ScopedObjectAccess soa(env); \
1617 ArtField* f = jni::DecodeArtField<kEnableIndexIds>(fid); \
1618 NotifySetPrimitiveField(f, nullptr, JValue::FromPrimitive<decltype(value)>(value)); \
1619 f->Set ##fn <false>(f->GetDeclaringClass(), value)
1620
GetBooleanField(JNIEnv * env,jobject obj,jfieldID fid)1621 static jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fid) {
1622 GET_PRIMITIVE_FIELD(Boolean, obj);
1623 }
1624
GetByteField(JNIEnv * env,jobject obj,jfieldID fid)1625 static jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fid) {
1626 GET_PRIMITIVE_FIELD(Byte, obj);
1627 }
1628
GetCharField(JNIEnv * env,jobject obj,jfieldID fid)1629 static jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fid) {
1630 GET_PRIMITIVE_FIELD(Char, obj);
1631 }
1632
GetShortField(JNIEnv * env,jobject obj,jfieldID fid)1633 static jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fid) {
1634 GET_PRIMITIVE_FIELD(Short, obj);
1635 }
1636
GetIntField(JNIEnv * env,jobject obj,jfieldID fid)1637 static jint GetIntField(JNIEnv* env, jobject obj, jfieldID fid) {
1638 GET_PRIMITIVE_FIELD(Int, obj);
1639 }
1640
GetLongField(JNIEnv * env,jobject obj,jfieldID fid)1641 static jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fid) {
1642 GET_PRIMITIVE_FIELD(Long, obj);
1643 }
1644
GetFloatField(JNIEnv * env,jobject obj,jfieldID fid)1645 static jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fid) {
1646 GET_PRIMITIVE_FIELD(Float, obj);
1647 }
1648
GetDoubleField(JNIEnv * env,jobject obj,jfieldID fid)1649 static jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fid) {
1650 GET_PRIMITIVE_FIELD(Double, obj);
1651 }
1652
GetStaticBooleanField(JNIEnv * env,jclass,jfieldID fid)1653 static jboolean GetStaticBooleanField(JNIEnv* env, jclass, jfieldID fid) {
1654 GET_STATIC_PRIMITIVE_FIELD(Boolean);
1655 }
1656
GetStaticByteField(JNIEnv * env,jclass,jfieldID fid)1657 static jbyte GetStaticByteField(JNIEnv* env, jclass, jfieldID fid) {
1658 GET_STATIC_PRIMITIVE_FIELD(Byte);
1659 }
1660
GetStaticCharField(JNIEnv * env,jclass,jfieldID fid)1661 static jchar GetStaticCharField(JNIEnv* env, jclass, jfieldID fid) {
1662 GET_STATIC_PRIMITIVE_FIELD(Char);
1663 }
1664
GetStaticShortField(JNIEnv * env,jclass,jfieldID fid)1665 static jshort GetStaticShortField(JNIEnv* env, jclass, jfieldID fid) {
1666 GET_STATIC_PRIMITIVE_FIELD(Short);
1667 }
1668
GetStaticIntField(JNIEnv * env,jclass,jfieldID fid)1669 static jint GetStaticIntField(JNIEnv* env, jclass, jfieldID fid) {
1670 GET_STATIC_PRIMITIVE_FIELD(Int);
1671 }
1672
GetStaticLongField(JNIEnv * env,jclass,jfieldID fid)1673 static jlong GetStaticLongField(JNIEnv* env, jclass, jfieldID fid) {
1674 GET_STATIC_PRIMITIVE_FIELD(Long);
1675 }
1676
GetStaticFloatField(JNIEnv * env,jclass,jfieldID fid)1677 static jfloat GetStaticFloatField(JNIEnv* env, jclass, jfieldID fid) {
1678 GET_STATIC_PRIMITIVE_FIELD(Float);
1679 }
1680
GetStaticDoubleField(JNIEnv * env,jclass,jfieldID fid)1681 static jdouble GetStaticDoubleField(JNIEnv* env, jclass, jfieldID fid) {
1682 GET_STATIC_PRIMITIVE_FIELD(Double);
1683 }
1684
SetBooleanField(JNIEnv * env,jobject obj,jfieldID fid,jboolean v)1685 static void SetBooleanField(JNIEnv* env, jobject obj, jfieldID fid, jboolean v) {
1686 SET_PRIMITIVE_FIELD(Boolean, obj, v);
1687 }
1688
SetByteField(JNIEnv * env,jobject obj,jfieldID fid,jbyte v)1689 static void SetByteField(JNIEnv* env, jobject obj, jfieldID fid, jbyte v) {
1690 SET_PRIMITIVE_FIELD(Byte, obj, v);
1691 }
1692
SetCharField(JNIEnv * env,jobject obj,jfieldID fid,jchar v)1693 static void SetCharField(JNIEnv* env, jobject obj, jfieldID fid, jchar v) {
1694 SET_PRIMITIVE_FIELD(Char, obj, v);
1695 }
1696
SetFloatField(JNIEnv * env,jobject obj,jfieldID fid,jfloat v)1697 static void SetFloatField(JNIEnv* env, jobject obj, jfieldID fid, jfloat v) {
1698 SET_PRIMITIVE_FIELD(Float, obj, v);
1699 }
1700
SetDoubleField(JNIEnv * env,jobject obj,jfieldID fid,jdouble v)1701 static void SetDoubleField(JNIEnv* env, jobject obj, jfieldID fid, jdouble v) {
1702 SET_PRIMITIVE_FIELD(Double, obj, v);
1703 }
1704
SetIntField(JNIEnv * env,jobject obj,jfieldID fid,jint v)1705 static void SetIntField(JNIEnv* env, jobject obj, jfieldID fid, jint v) {
1706 SET_PRIMITIVE_FIELD(Int, obj, v);
1707 }
1708
SetLongField(JNIEnv * env,jobject obj,jfieldID fid,jlong v)1709 static void SetLongField(JNIEnv* env, jobject obj, jfieldID fid, jlong v) {
1710 SET_PRIMITIVE_FIELD(Long, obj, v);
1711 }
1712
SetShortField(JNIEnv * env,jobject obj,jfieldID fid,jshort v)1713 static void SetShortField(JNIEnv* env, jobject obj, jfieldID fid, jshort v) {
1714 SET_PRIMITIVE_FIELD(Short, obj, v);
1715 }
1716
SetStaticBooleanField(JNIEnv * env,jclass,jfieldID fid,jboolean v)1717 static void SetStaticBooleanField(JNIEnv* env, jclass, jfieldID fid, jboolean v) {
1718 SET_STATIC_PRIMITIVE_FIELD(Boolean, v);
1719 }
1720
SetStaticByteField(JNIEnv * env,jclass,jfieldID fid,jbyte v)1721 static void SetStaticByteField(JNIEnv* env, jclass, jfieldID fid, jbyte v) {
1722 SET_STATIC_PRIMITIVE_FIELD(Byte, v);
1723 }
1724
SetStaticCharField(JNIEnv * env,jclass,jfieldID fid,jchar v)1725 static void SetStaticCharField(JNIEnv* env, jclass, jfieldID fid, jchar v) {
1726 SET_STATIC_PRIMITIVE_FIELD(Char, v);
1727 }
1728
SetStaticFloatField(JNIEnv * env,jclass,jfieldID fid,jfloat v)1729 static void SetStaticFloatField(JNIEnv* env, jclass, jfieldID fid, jfloat v) {
1730 SET_STATIC_PRIMITIVE_FIELD(Float, v);
1731 }
1732
SetStaticDoubleField(JNIEnv * env,jclass,jfieldID fid,jdouble v)1733 static void SetStaticDoubleField(JNIEnv* env, jclass, jfieldID fid, jdouble v) {
1734 SET_STATIC_PRIMITIVE_FIELD(Double, v);
1735 }
1736
SetStaticIntField(JNIEnv * env,jclass,jfieldID fid,jint v)1737 static void SetStaticIntField(JNIEnv* env, jclass, jfieldID fid, jint v) {
1738 SET_STATIC_PRIMITIVE_FIELD(Int, v);
1739 }
1740
SetStaticLongField(JNIEnv * env,jclass,jfieldID fid,jlong v)1741 static void SetStaticLongField(JNIEnv* env, jclass, jfieldID fid, jlong v) {
1742 SET_STATIC_PRIMITIVE_FIELD(Long, v);
1743 }
1744
SetStaticShortField(JNIEnv * env,jclass,jfieldID fid,jshort v)1745 static void SetStaticShortField(JNIEnv* env, jclass, jfieldID fid, jshort v) {
1746 SET_STATIC_PRIMITIVE_FIELD(Short, v);
1747 }
1748
CallStaticObjectMethod(JNIEnv * env,jclass,jmethodID mid,...)1749 static jobject CallStaticObjectMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1750 va_list ap;
1751 va_start(ap, mid);
1752 ScopedVAArgs free_args_later(&ap);
1753 CHECK_NON_NULL_ARGUMENT(mid);
1754 ScopedObjectAccess soa(env);
1755 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1756 return soa.AddLocalReference<jobject>(result.GetL());
1757 }
1758
CallStaticObjectMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1759 static jobject CallStaticObjectMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1760 CHECK_NON_NULL_ARGUMENT(mid);
1761 ScopedObjectAccess soa(env);
1762 JValue result(InvokeWithVarArgs(soa, nullptr, mid, args));
1763 return soa.AddLocalReference<jobject>(result.GetL());
1764 }
1765
CallStaticObjectMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1766 static jobject CallStaticObjectMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1767 CHECK_NON_NULL_ARGUMENT(mid);
1768 ScopedObjectAccess soa(env);
1769 JValue result(InvokeWithJValues(soa, nullptr, mid, args));
1770 return soa.AddLocalReference<jobject>(result.GetL());
1771 }
1772
CallStaticBooleanMethod(JNIEnv * env,jclass,jmethodID mid,...)1773 static jboolean CallStaticBooleanMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1774 va_list ap;
1775 va_start(ap, mid);
1776 ScopedVAArgs free_args_later(&ap);
1777 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1778 ScopedObjectAccess soa(env);
1779 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1780 return result.GetZ();
1781 }
1782
CallStaticBooleanMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1783 static jboolean CallStaticBooleanMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1784 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1785 ScopedObjectAccess soa(env);
1786 return InvokeWithVarArgs(soa, nullptr, mid, args).GetZ();
1787 }
1788
CallStaticBooleanMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1789 static jboolean CallStaticBooleanMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1790 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1791 ScopedObjectAccess soa(env);
1792 return InvokeWithJValues(soa, nullptr, mid, args).GetZ();
1793 }
1794
CallStaticByteMethod(JNIEnv * env,jclass,jmethodID mid,...)1795 static jbyte CallStaticByteMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1796 va_list ap;
1797 va_start(ap, mid);
1798 ScopedVAArgs free_args_later(&ap);
1799 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1800 ScopedObjectAccess soa(env);
1801 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1802 return result.GetB();
1803 }
1804
CallStaticByteMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1805 static jbyte CallStaticByteMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1806 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1807 ScopedObjectAccess soa(env);
1808 return InvokeWithVarArgs(soa, nullptr, mid, args).GetB();
1809 }
1810
CallStaticByteMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1811 static jbyte CallStaticByteMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1812 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1813 ScopedObjectAccess soa(env);
1814 return InvokeWithJValues(soa, nullptr, mid, args).GetB();
1815 }
1816
CallStaticCharMethod(JNIEnv * env,jclass,jmethodID mid,...)1817 static jchar CallStaticCharMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1818 va_list ap;
1819 va_start(ap, mid);
1820 ScopedVAArgs free_args_later(&ap);
1821 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1822 ScopedObjectAccess soa(env);
1823 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1824 return result.GetC();
1825 }
1826
CallStaticCharMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1827 static jchar CallStaticCharMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1828 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1829 ScopedObjectAccess soa(env);
1830 return InvokeWithVarArgs(soa, nullptr, mid, args).GetC();
1831 }
1832
CallStaticCharMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1833 static jchar CallStaticCharMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1834 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1835 ScopedObjectAccess soa(env);
1836 return InvokeWithJValues(soa, nullptr, mid, args).GetC();
1837 }
1838
CallStaticShortMethod(JNIEnv * env,jclass,jmethodID mid,...)1839 static jshort CallStaticShortMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1840 va_list ap;
1841 va_start(ap, mid);
1842 ScopedVAArgs free_args_later(&ap);
1843 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1844 ScopedObjectAccess soa(env);
1845 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1846 return result.GetS();
1847 }
1848
CallStaticShortMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1849 static jshort CallStaticShortMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1850 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1851 ScopedObjectAccess soa(env);
1852 return InvokeWithVarArgs(soa, nullptr, mid, args).GetS();
1853 }
1854
CallStaticShortMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1855 static jshort CallStaticShortMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1856 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1857 ScopedObjectAccess soa(env);
1858 return InvokeWithJValues(soa, nullptr, mid, args).GetS();
1859 }
1860
CallStaticIntMethod(JNIEnv * env,jclass,jmethodID mid,...)1861 static jint CallStaticIntMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1862 va_list ap;
1863 va_start(ap, mid);
1864 ScopedVAArgs free_args_later(&ap);
1865 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1866 ScopedObjectAccess soa(env);
1867 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1868 return result.GetI();
1869 }
1870
CallStaticIntMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1871 static jint CallStaticIntMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1872 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1873 ScopedObjectAccess soa(env);
1874 return InvokeWithVarArgs(soa, nullptr, mid, args).GetI();
1875 }
1876
CallStaticIntMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1877 static jint CallStaticIntMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1878 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1879 ScopedObjectAccess soa(env);
1880 return InvokeWithJValues(soa, nullptr, mid, args).GetI();
1881 }
1882
CallStaticLongMethod(JNIEnv * env,jclass,jmethodID mid,...)1883 static jlong CallStaticLongMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1884 va_list ap;
1885 va_start(ap, mid);
1886 ScopedVAArgs free_args_later(&ap);
1887 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1888 ScopedObjectAccess soa(env);
1889 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1890 return result.GetJ();
1891 }
1892
CallStaticLongMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1893 static jlong CallStaticLongMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1894 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1895 ScopedObjectAccess soa(env);
1896 return InvokeWithVarArgs(soa, nullptr, mid, args).GetJ();
1897 }
1898
CallStaticLongMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1899 static jlong CallStaticLongMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1900 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1901 ScopedObjectAccess soa(env);
1902 return InvokeWithJValues(soa, nullptr, mid, args).GetJ();
1903 }
1904
CallStaticFloatMethod(JNIEnv * env,jclass,jmethodID mid,...)1905 static jfloat CallStaticFloatMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1906 va_list ap;
1907 va_start(ap, mid);
1908 ScopedVAArgs free_args_later(&ap);
1909 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1910 ScopedObjectAccess soa(env);
1911 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1912 return result.GetF();
1913 }
1914
CallStaticFloatMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1915 static jfloat CallStaticFloatMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1916 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1917 ScopedObjectAccess soa(env);
1918 return InvokeWithVarArgs(soa, nullptr, mid, args).GetF();
1919 }
1920
CallStaticFloatMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1921 static jfloat CallStaticFloatMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1922 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1923 ScopedObjectAccess soa(env);
1924 return InvokeWithJValues(soa, nullptr, mid, args).GetF();
1925 }
1926
CallStaticDoubleMethod(JNIEnv * env,jclass,jmethodID mid,...)1927 static jdouble CallStaticDoubleMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1928 va_list ap;
1929 va_start(ap, mid);
1930 ScopedVAArgs free_args_later(&ap);
1931 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1932 ScopedObjectAccess soa(env);
1933 JValue result(InvokeWithVarArgs(soa, nullptr, mid, ap));
1934 return result.GetD();
1935 }
1936
CallStaticDoubleMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1937 static jdouble CallStaticDoubleMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1938 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1939 ScopedObjectAccess soa(env);
1940 return InvokeWithVarArgs(soa, nullptr, mid, args).GetD();
1941 }
1942
CallStaticDoubleMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1943 static jdouble CallStaticDoubleMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1944 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
1945 ScopedObjectAccess soa(env);
1946 return InvokeWithJValues(soa, nullptr, mid, args).GetD();
1947 }
1948
1949 NO_STACK_PROTECTOR
CallStaticVoidMethod(JNIEnv * env,jclass,jmethodID mid,...)1950 static void CallStaticVoidMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
1951 va_list ap;
1952 va_start(ap, mid);
1953 ScopedVAArgs free_args_later(&ap);
1954 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1955 ScopedObjectAccess soa(env);
1956 InvokeWithVarArgs(soa, nullptr, mid, ap);
1957 }
1958
1959 NO_STACK_PROTECTOR
CallStaticVoidMethodV(JNIEnv * env,jclass,jmethodID mid,va_list args)1960 static void CallStaticVoidMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
1961 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1962 ScopedObjectAccess soa(env);
1963 InvokeWithVarArgs(soa, nullptr, mid, args);
1964 }
1965
CallStaticVoidMethodA(JNIEnv * env,jclass,jmethodID mid,const jvalue * args)1966 static void CallStaticVoidMethodA(JNIEnv* env, jclass, jmethodID mid, const jvalue* args) {
1967 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(mid);
1968 ScopedObjectAccess soa(env);
1969 InvokeWithJValues(soa, nullptr, mid, args);
1970 }
1971
NewString(JNIEnv * env,const jchar * chars,jsize char_count)1972 static jstring NewString(JNIEnv* env, const jchar* chars, jsize char_count) {
1973 if (UNLIKELY(char_count < 0)) {
1974 JavaVmExtFromEnv(env)->JniAbortF("NewString", "char_count < 0: %d", char_count);
1975 return nullptr;
1976 }
1977 if (UNLIKELY(chars == nullptr && char_count > 0)) {
1978 JavaVmExtFromEnv(env)->JniAbortF("NewString", "chars == null && char_count > 0");
1979 return nullptr;
1980 }
1981 ScopedObjectAccess soa(env);
1982 ObjPtr<mirror::String> result = mirror::String::AllocFromUtf16(soa.Self(), char_count, chars);
1983 return soa.AddLocalReference<jstring>(result);
1984 }
1985
1986 // For historical reasons, NewStringUTF() accepts 4-byte UTF-8
1987 // sequences which are not valid Modified UTF-8. This can be
1988 // considered an extension of the JNI specification.
NewStringUTF(JNIEnv * env,const char * utf)1989 static jstring NewStringUTF(JNIEnv* env, const char* utf) {
1990 if (utf == nullptr) {
1991 return nullptr;
1992 }
1993
1994 // The input may come from an untrusted source, so we need to validate it.
1995 // We do not perform full validation, only as much as necessary to avoid reading
1996 // beyond the terminating null character. CheckJNI performs stronger validation.
1997 size_t utf8_length = strlen(utf);
1998 bool compressible = mirror::kUseStringCompression;
1999 bool has_bad_char = false;
2000 size_t utf16_length = VisitUtf8Chars(
2001 utf,
2002 utf8_length,
2003 /*good=*/ [&compressible](const char* ptr, size_t length) {
2004 if (mirror::kUseStringCompression) {
2005 switch (length) {
2006 case 1:
2007 DCHECK(mirror::String::IsASCII(*ptr));
2008 break;
2009 case 2:
2010 case 3:
2011 if (!mirror::String::IsASCII(DecodeModifiedUtf8Character(ptr, length))) {
2012 compressible = false;
2013 }
2014 break;
2015 default:
2016 // 4-byte sequences lead to uncompressible surroate pairs.
2017 DCHECK_EQ(length, 4u);
2018 compressible = false;
2019 break;
2020 }
2021 }
2022 },
2023 /*bad=*/ [&has_bad_char]() {
2024 static_assert(mirror::String::IsASCII(kBadUtf8ReplacementChar)); // Compressible.
2025 has_bad_char = true;
2026 });
2027 if (UNLIKELY(utf16_length > static_cast<uint32_t>(std::numeric_limits<int32_t>::max()))) {
2028 // Converting the utf16_length to int32_t would overflow. Explicitly throw an OOME.
2029 std::string error =
2030 android::base::StringPrintf("NewStringUTF input has 2^31 or more characters: %zu",
2031 utf16_length);
2032 ScopedObjectAccess soa(env);
2033 soa.Self()->ThrowOutOfMemoryError(error.c_str());
2034 return nullptr;
2035 }
2036 if (UNLIKELY(has_bad_char)) {
2037 // VisitUtf8Chars() found a bad character.
2038 android_errorWriteLog(0x534e4554, "172655291"); // Report to SafetyNet.
2039 // Report the error to logcat but avoid too much spam.
2040 static const uint64_t kMinDelay = UINT64_C(10000000000); // 10s
2041 static std::atomic<uint64_t> prev_bad_input_time(UINT64_C(0));
2042 uint64_t prev_time = prev_bad_input_time.load(std::memory_order_relaxed);
2043 uint64_t now = NanoTime();
2044 if ((prev_time == 0u || now - prev_time >= kMinDelay) &&
2045 prev_bad_input_time.compare_exchange_strong(prev_time, now, std::memory_order_relaxed)) {
2046 LOG(ERROR) << "Invalid UTF-8 input to JNI::NewStringUTF()";
2047 }
2048 }
2049 const int32_t length_with_flag = mirror::String::GetFlaggedCount(utf16_length, compressible);
2050 NewStringUTFVisitor visitor(utf, utf8_length, length_with_flag, has_bad_char);
2051
2052 ScopedObjectAccess soa(env);
2053 gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator();
2054 ObjPtr<mirror::String> result =
2055 mirror::String::Alloc(soa.Self(), length_with_flag, allocator_type, visitor);
2056 return soa.AddLocalReference<jstring>(result);
2057 }
2058
GetStringLength(JNIEnv * env,jstring java_string)2059 static jsize GetStringLength(JNIEnv* env, jstring java_string) {
2060 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(java_string);
2061 ScopedObjectAccess soa(env);
2062 return soa.Decode<mirror::String>(java_string)->GetLength();
2063 }
2064
GetStringUTFLength(JNIEnv * env,jstring java_string)2065 static jsize GetStringUTFLength(JNIEnv* env, jstring java_string) {
2066 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(java_string);
2067 ScopedObjectAccess soa(env);
2068 ObjPtr<mirror::String> str = soa.Decode<mirror::String>(java_string);
2069 return str->IsCompressed()
2070 ? str->GetLength()
2071 : GetUncompressedStringUTFLength(str->GetValue(), str->GetLength());
2072 }
2073
GetStringRegion(JNIEnv * env,jstring java_string,jsize start,jsize length,jchar * buf)2074 static void GetStringRegion(JNIEnv* env, jstring java_string, jsize start, jsize length,
2075 jchar* buf) {
2076 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_string);
2077 ScopedObjectAccess soa(env);
2078 ObjPtr<mirror::String> s = soa.Decode<mirror::String>(java_string);
2079 if (start < 0 || length < 0 || length > s->GetLength() - start) {
2080 ThrowSIOOBE(soa, start, length, s->GetLength());
2081 } else {
2082 CHECK_NON_NULL_MEMCPY_ARGUMENT(length, buf);
2083 if (s->IsCompressed()) {
2084 const uint8_t* src = s->GetValueCompressed() + start;
2085 for (int i = 0; i < length; ++i) {
2086 buf[i] = static_cast<jchar>(src[i]);
2087 }
2088 } else {
2089 const jchar* chars = static_cast<jchar*>(s->GetValue());
2090 memcpy(buf, chars + start, length * sizeof(jchar));
2091 }
2092 }
2093 }
2094
GetStringUTFRegion(JNIEnv * env,jstring java_string,jsize start,jsize length,char * buf)2095 static void GetStringUTFRegion(JNIEnv* env, jstring java_string, jsize start, jsize length,
2096 char* buf) {
2097 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_string);
2098 ScopedObjectAccess soa(env);
2099 ObjPtr<mirror::String> s = soa.Decode<mirror::String>(java_string);
2100 if (start < 0 || length < 0 || length > s->GetLength() - start) {
2101 ThrowSIOOBE(soa, start, length, s->GetLength());
2102 } else {
2103 CHECK_NON_NULL_MEMCPY_ARGUMENT(length, buf);
2104 if (length == 0 && buf == nullptr) {
2105 // Don't touch anything when length is 0 and null buffer.
2106 return;
2107 }
2108 if (s->IsCompressed()) {
2109 const uint8_t* src = s->GetValueCompressed() + start;
2110 for (int i = 0; i < length; ++i) {
2111 buf[i] = static_cast<jchar>(src[i]);
2112 }
2113 buf[length] = '\0';
2114 } else {
2115 char* end = GetUncompressedStringUTFChars(s->GetValue() + start, length, buf);
2116 *end = '\0';
2117 }
2118 }
2119 }
2120
GetStringChars(JNIEnv * env,jstring java_string,jboolean * is_copy)2121 static const jchar* GetStringChars(JNIEnv* env, jstring java_string, jboolean* is_copy) {
2122 CHECK_NON_NULL_ARGUMENT(java_string);
2123 ScopedObjectAccess soa(env);
2124 ObjPtr<mirror::String> s = soa.Decode<mirror::String>(java_string);
2125 gc::Heap* heap = Runtime::Current()->GetHeap();
2126 if (heap->IsMovableObject(s) || s->IsCompressed()) {
2127 jchar* chars = new jchar[s->GetLength()];
2128 if (s->IsCompressed()) {
2129 int32_t length = s->GetLength();
2130 const uint8_t* src = s->GetValueCompressed();
2131 for (int i = 0; i < length; ++i) {
2132 chars[i] = static_cast<jchar>(src[i]);
2133 }
2134 } else {
2135 memcpy(chars, s->GetValue(), sizeof(jchar) * s->GetLength());
2136 }
2137 if (is_copy != nullptr) {
2138 *is_copy = JNI_TRUE;
2139 }
2140 return chars;
2141 }
2142 if (is_copy != nullptr) {
2143 *is_copy = JNI_FALSE;
2144 }
2145 return static_cast<jchar*>(s->GetValue());
2146 }
2147
ReleaseStringChars(JNIEnv * env,jstring java_string,const jchar * chars)2148 static void ReleaseStringChars(JNIEnv* env, jstring java_string, const jchar* chars) {
2149 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_string);
2150 ScopedObjectAccess soa(env);
2151 ObjPtr<mirror::String> s = soa.Decode<mirror::String>(java_string);
2152 if (s->IsCompressed() || (s->IsCompressed() == false && chars != s->GetValue())) {
2153 delete[] chars;
2154 }
2155 }
2156
GetStringCritical(JNIEnv * env,jstring java_string,jboolean * is_copy)2157 static const jchar* GetStringCritical(JNIEnv* env, jstring java_string, jboolean* is_copy) {
2158 CHECK_NON_NULL_ARGUMENT(java_string);
2159 ScopedObjectAccess soa(env);
2160 ObjPtr<mirror::String> s = soa.Decode<mirror::String>(java_string);
2161 gc::Heap* heap = Runtime::Current()->GetHeap();
2162 if (s->IsCompressed()) {
2163 if (is_copy != nullptr) {
2164 *is_copy = JNI_TRUE;
2165 }
2166 int32_t length = s->GetLength();
2167 const uint8_t* src = s->GetValueCompressed();
2168 jchar* chars = new jchar[length];
2169 for (int i = 0; i < length; ++i) {
2170 chars[i] = static_cast<jchar>(src[i]);
2171 }
2172 return chars;
2173 } else {
2174 if (heap->IsMovableObject(s)) {
2175 StackHandleScope<1> hs(soa.Self());
2176 HandleWrapperObjPtr<mirror::String> h(hs.NewHandleWrapper(&s));
2177 if (!gUseReadBarrier && !gUseUserfaultfd) {
2178 heap->IncrementDisableMovingGC(soa.Self());
2179 } else {
2180 // For the CC and CMC collector, we only need to wait for the thread flip rather
2181 // than the whole GC to occur thanks to the to-space invariant.
2182 heap->IncrementDisableThreadFlip(soa.Self());
2183 }
2184 }
2185 // Ensure that the string doesn't cause userfaults in case passed on to
2186 // the kernel.
2187 heap->EnsureObjectUserfaulted(s);
2188 if (is_copy != nullptr) {
2189 *is_copy = JNI_FALSE;
2190 }
2191 return static_cast<jchar*>(s->GetValue());
2192 }
2193 }
2194
ReleaseStringCritical(JNIEnv * env,jstring java_string,const jchar * chars)2195 static void ReleaseStringCritical(JNIEnv* env,
2196 jstring java_string,
2197 const jchar* chars) {
2198 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_string);
2199 ScopedObjectAccess soa(env);
2200 gc::Heap* heap = Runtime::Current()->GetHeap();
2201 ObjPtr<mirror::String> s = soa.Decode<mirror::String>(java_string);
2202 if (!s->IsCompressed() && heap->IsMovableObject(s)) {
2203 if (!gUseReadBarrier && !gUseUserfaultfd) {
2204 heap->DecrementDisableMovingGC(soa.Self());
2205 } else {
2206 heap->DecrementDisableThreadFlip(soa.Self());
2207 }
2208 }
2209 // TODO: For uncompressed strings GetStringCritical() always returns `s->GetValue()`.
2210 // Should we report an error if the user passes a different `chars`?
2211 if (s->IsCompressed() || (!s->IsCompressed() && s->GetValue() != chars)) {
2212 delete[] chars;
2213 }
2214 }
2215
GetStringUTFChars(JNIEnv * env,jstring java_string,jboolean * is_copy)2216 static const char* GetStringUTFChars(JNIEnv* env, jstring java_string, jboolean* is_copy) {
2217 if (java_string == nullptr) {
2218 return nullptr;
2219 }
2220 if (is_copy != nullptr) {
2221 *is_copy = JNI_TRUE;
2222 }
2223
2224 ScopedObjectAccess soa(env);
2225 ObjPtr<mirror::String> s = soa.Decode<mirror::String>(java_string);
2226 size_t length = s->GetLength();
2227 size_t byte_count =
2228 s->IsCompressed() ? length : GetUncompressedStringUTFLength(s->GetValue(), length);
2229 char* bytes = new char[byte_count + 1];
2230 CHECK(bytes != nullptr); // bionic aborts anyway.
2231 if (s->IsCompressed()) {
2232 const uint8_t* src = s->GetValueCompressed();
2233 for (size_t i = 0; i < byte_count; ++i) {
2234 bytes[i] = src[i];
2235 }
2236 } else {
2237 char* end = GetUncompressedStringUTFChars(s->GetValue(), length, bytes);
2238 DCHECK_EQ(byte_count, static_cast<size_t>(end - bytes));
2239 }
2240 bytes[byte_count] = '\0';
2241 return bytes;
2242 }
2243
ReleaseStringUTFChars(JNIEnv *,jstring,const char * chars)2244 static void ReleaseStringUTFChars(JNIEnv*, jstring, const char* chars) {
2245 delete[] chars;
2246 }
2247
GetArrayLength(JNIEnv * env,jarray java_array)2248 static jsize GetArrayLength(JNIEnv* env, jarray java_array) {
2249 CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(java_array);
2250 ScopedObjectAccess soa(env);
2251 ObjPtr<mirror::Object> obj = soa.Decode<mirror::Object>(java_array);
2252 if (UNLIKELY(!obj->IsArrayInstance())) {
2253 soa.Vm()->JniAbortF("GetArrayLength", "not an array: %s", obj->PrettyTypeOf().c_str());
2254 return 0;
2255 }
2256 ObjPtr<mirror::Array> array = obj->AsArray();
2257 return array->GetLength();
2258 }
2259
GetObjectArrayElement(JNIEnv * env,jobjectArray java_array,jsize index)2260 static jobject GetObjectArrayElement(JNIEnv* env, jobjectArray java_array, jsize index) {
2261 CHECK_NON_NULL_ARGUMENT(java_array);
2262 ScopedObjectAccess soa(env);
2263 ObjPtr<mirror::ObjectArray<mirror::Object>> array =
2264 soa.Decode<mirror::ObjectArray<mirror::Object>>(java_array);
2265 return soa.AddLocalReference<jobject>(array->Get(index));
2266 }
2267
SetObjectArrayElement(JNIEnv * env,jobjectArray java_array,jsize index,jobject java_value)2268 static void SetObjectArrayElement(JNIEnv* env, jobjectArray java_array, jsize index,
2269 jobject java_value) {
2270 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_array);
2271 ScopedObjectAccess soa(env);
2272 ObjPtr<mirror::ObjectArray<mirror::Object>> array =
2273 soa.Decode<mirror::ObjectArray<mirror::Object>>(java_array);
2274 ObjPtr<mirror::Object> value = soa.Decode<mirror::Object>(java_value);
2275 array->Set<false>(index, value);
2276 }
2277
NewBooleanArray(JNIEnv * env,jsize length)2278 static jbooleanArray NewBooleanArray(JNIEnv* env, jsize length) {
2279 return NewPrimitiveArray<jbooleanArray, mirror::BooleanArray>(env, length);
2280 }
2281
NewByteArray(JNIEnv * env,jsize length)2282 static jbyteArray NewByteArray(JNIEnv* env, jsize length) {
2283 return NewPrimitiveArray<jbyteArray, mirror::ByteArray>(env, length);
2284 }
2285
NewCharArray(JNIEnv * env,jsize length)2286 static jcharArray NewCharArray(JNIEnv* env, jsize length) {
2287 return NewPrimitiveArray<jcharArray, mirror::CharArray>(env, length);
2288 }
2289
NewDoubleArray(JNIEnv * env,jsize length)2290 static jdoubleArray NewDoubleArray(JNIEnv* env, jsize length) {
2291 return NewPrimitiveArray<jdoubleArray, mirror::DoubleArray>(env, length);
2292 }
2293
NewFloatArray(JNIEnv * env,jsize length)2294 static jfloatArray NewFloatArray(JNIEnv* env, jsize length) {
2295 return NewPrimitiveArray<jfloatArray, mirror::FloatArray>(env, length);
2296 }
2297
NewIntArray(JNIEnv * env,jsize length)2298 static jintArray NewIntArray(JNIEnv* env, jsize length) {
2299 return NewPrimitiveArray<jintArray, mirror::IntArray>(env, length);
2300 }
2301
NewLongArray(JNIEnv * env,jsize length)2302 static jlongArray NewLongArray(JNIEnv* env, jsize length) {
2303 return NewPrimitiveArray<jlongArray, mirror::LongArray>(env, length);
2304 }
2305
NewObjectArray(JNIEnv * env,jsize length,jclass element_jclass,jobject initial_element)2306 static jobjectArray NewObjectArray(JNIEnv* env, jsize length, jclass element_jclass,
2307 jobject initial_element) {
2308 if (UNLIKELY(length < 0)) {
2309 JavaVmExtFromEnv(env)->JniAbortF("NewObjectArray", "negative array length: %d", length);
2310 return nullptr;
2311 }
2312 CHECK_NON_NULL_ARGUMENT(element_jclass);
2313
2314 // Compute the array class corresponding to the given element class.
2315 ScopedObjectAccess soa(env);
2316 ObjPtr<mirror::Class> array_class;
2317 {
2318 ObjPtr<mirror::Class> element_class = soa.Decode<mirror::Class>(element_jclass);
2319 if (UNLIKELY(element_class->IsPrimitive())) {
2320 soa.Vm()->JniAbortF("NewObjectArray",
2321 "not an object type: %s",
2322 element_class->PrettyDescriptor().c_str());
2323 return nullptr;
2324 }
2325 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2326 array_class = class_linker->FindArrayClass(soa.Self(), element_class);
2327 if (UNLIKELY(array_class == nullptr)) {
2328 return nullptr;
2329 }
2330 }
2331
2332 // Allocate and initialize if necessary.
2333 ObjPtr<mirror::ObjectArray<mirror::Object>> result =
2334 mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), array_class, length);
2335 if (result != nullptr && initial_element != nullptr) {
2336 ObjPtr<mirror::Object> initial_object = soa.Decode<mirror::Object>(initial_element);
2337 if (initial_object != nullptr) {
2338 ObjPtr<mirror::Class> element_class = result->GetClass()->GetComponentType();
2339 if (UNLIKELY(!element_class->IsAssignableFrom(initial_object->GetClass()))) {
2340 soa.Vm()->JniAbortF("NewObjectArray", "cannot assign object of type '%s' to array with "
2341 "element type of '%s'",
2342 mirror::Class::PrettyDescriptor(initial_object->GetClass()).c_str(),
2343 element_class->PrettyDescriptor().c_str());
2344 return nullptr;
2345 } else {
2346 for (jsize i = 0; i < length; ++i) {
2347 result->SetWithoutChecks<false>(i, initial_object);
2348 }
2349 }
2350 }
2351 }
2352 return soa.AddLocalReference<jobjectArray>(result);
2353 }
2354
NewShortArray(JNIEnv * env,jsize length)2355 static jshortArray NewShortArray(JNIEnv* env, jsize length) {
2356 return NewPrimitiveArray<jshortArray, mirror::ShortArray>(env, length);
2357 }
2358
GetPrimitiveArrayCritical(JNIEnv * env,jarray java_array,jboolean * is_copy)2359 static void* GetPrimitiveArrayCritical(JNIEnv* env, jarray java_array, jboolean* is_copy) {
2360 CHECK_NON_NULL_ARGUMENT(java_array);
2361 ScopedObjectAccess soa(env);
2362 ObjPtr<mirror::Array> array = soa.Decode<mirror::Array>(java_array);
2363 if (UNLIKELY(!array->GetClass()->IsPrimitiveArray())) {
2364 soa.Vm()->JniAbortF("GetPrimitiveArrayCritical", "expected primitive array, given %s",
2365 array->GetClass()->PrettyDescriptor().c_str());
2366 return nullptr;
2367 }
2368 gc::Heap* heap = Runtime::Current()->GetHeap();
2369 if (heap->IsMovableObject(array)) {
2370 if (!gUseReadBarrier && !gUseUserfaultfd) {
2371 heap->IncrementDisableMovingGC(soa.Self());
2372 } else {
2373 // For the CC and CMC collector, we only need to wait for the thread flip rather
2374 // than the whole GC to occur thanks to the to-space invariant.
2375 heap->IncrementDisableThreadFlip(soa.Self());
2376 }
2377 // Re-decode in case the object moved since IncrementDisableGC waits for GC to complete.
2378 array = soa.Decode<mirror::Array>(java_array);
2379 }
2380 // Ensure that the array doesn't cause userfaults in case passed on to the kernel.
2381 heap->EnsureObjectUserfaulted(array);
2382 if (is_copy != nullptr) {
2383 *is_copy = JNI_FALSE;
2384 }
2385 return array->GetRawData(array->GetClass()->GetComponentSize(), 0);
2386 }
2387
ReleasePrimitiveArrayCritical(JNIEnv * env,jarray java_array,void * elements,jint mode)2388 static void ReleasePrimitiveArrayCritical(JNIEnv* env, jarray java_array, void* elements,
2389 jint mode) {
2390 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_array);
2391 ScopedObjectAccess soa(env);
2392 ObjPtr<mirror::Array> array = soa.Decode<mirror::Array>(java_array);
2393 if (UNLIKELY(!array->GetClass()->IsPrimitiveArray())) {
2394 soa.Vm()->JniAbortF("ReleasePrimitiveArrayCritical", "expected primitive array, given %s",
2395 array->GetClass()->PrettyDescriptor().c_str());
2396 return;
2397 }
2398 const size_t component_size = array->GetClass()->GetComponentSize();
2399 ReleasePrimitiveArray(soa, array, component_size, elements, mode);
2400 }
2401
GetBooleanArrayElements(JNIEnv * env,jbooleanArray array,jboolean * is_copy)2402 static jboolean* GetBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* is_copy) {
2403 return GetPrimitiveArray<jbooleanArray, jboolean, mirror::BooleanArray>(env, array, is_copy);
2404 }
2405
GetByteArrayElements(JNIEnv * env,jbyteArray array,jboolean * is_copy)2406 static jbyte* GetByteArrayElements(JNIEnv* env, jbyteArray array, jboolean* is_copy) {
2407 return GetPrimitiveArray<jbyteArray, jbyte, mirror::ByteArray>(env, array, is_copy);
2408 }
2409
GetCharArrayElements(JNIEnv * env,jcharArray array,jboolean * is_copy)2410 static jchar* GetCharArrayElements(JNIEnv* env, jcharArray array, jboolean* is_copy) {
2411 return GetPrimitiveArray<jcharArray, jchar, mirror::CharArray>(env, array, is_copy);
2412 }
2413
GetDoubleArrayElements(JNIEnv * env,jdoubleArray array,jboolean * is_copy)2414 static jdouble* GetDoubleArrayElements(JNIEnv* env, jdoubleArray array, jboolean* is_copy) {
2415 return GetPrimitiveArray<jdoubleArray, jdouble, mirror::DoubleArray>(env, array, is_copy);
2416 }
2417
GetFloatArrayElements(JNIEnv * env,jfloatArray array,jboolean * is_copy)2418 static jfloat* GetFloatArrayElements(JNIEnv* env, jfloatArray array, jboolean* is_copy) {
2419 return GetPrimitiveArray<jfloatArray, jfloat, mirror::FloatArray>(env, array, is_copy);
2420 }
2421
GetIntArrayElements(JNIEnv * env,jintArray array,jboolean * is_copy)2422 static jint* GetIntArrayElements(JNIEnv* env, jintArray array, jboolean* is_copy) {
2423 return GetPrimitiveArray<jintArray, jint, mirror::IntArray>(env, array, is_copy);
2424 }
2425
GetLongArrayElements(JNIEnv * env,jlongArray array,jboolean * is_copy)2426 static jlong* GetLongArrayElements(JNIEnv* env, jlongArray array, jboolean* is_copy) {
2427 return GetPrimitiveArray<jlongArray, jlong, mirror::LongArray>(env, array, is_copy);
2428 }
2429
GetShortArrayElements(JNIEnv * env,jshortArray array,jboolean * is_copy)2430 static jshort* GetShortArrayElements(JNIEnv* env, jshortArray array, jboolean* is_copy) {
2431 return GetPrimitiveArray<jshortArray, jshort, mirror::ShortArray>(env, array, is_copy);
2432 }
2433
ReleaseBooleanArrayElements(JNIEnv * env,jbooleanArray array,jboolean * elements,jint mode)2434 static void ReleaseBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* elements,
2435 jint mode) {
2436 ReleasePrimitiveArray<jbooleanArray, jboolean, mirror::BooleanArray>(env, array, elements,
2437 mode);
2438 }
2439
ReleaseByteArrayElements(JNIEnv * env,jbyteArray array,jbyte * elements,jint mode)2440 static void ReleaseByteArrayElements(JNIEnv* env, jbyteArray array, jbyte* elements, jint mode) {
2441 ReleasePrimitiveArray<jbyteArray, jbyte, mirror::ByteArray>(env, array, elements, mode);
2442 }
2443
ReleaseCharArrayElements(JNIEnv * env,jcharArray array,jchar * elements,jint mode)2444 static void ReleaseCharArrayElements(JNIEnv* env, jcharArray array, jchar* elements, jint mode) {
2445 ReleasePrimitiveArray<jcharArray, jchar, mirror::CharArray>(env, array, elements, mode);
2446 }
2447
ReleaseDoubleArrayElements(JNIEnv * env,jdoubleArray array,jdouble * elements,jint mode)2448 static void ReleaseDoubleArrayElements(JNIEnv* env, jdoubleArray array, jdouble* elements,
2449 jint mode) {
2450 ReleasePrimitiveArray<jdoubleArray, jdouble, mirror::DoubleArray>(env, array, elements, mode);
2451 }
2452
ReleaseFloatArrayElements(JNIEnv * env,jfloatArray array,jfloat * elements,jint mode)2453 static void ReleaseFloatArrayElements(JNIEnv* env, jfloatArray array, jfloat* elements,
2454 jint mode) {
2455 ReleasePrimitiveArray<jfloatArray, jfloat, mirror::FloatArray>(env, array, elements, mode);
2456 }
2457
ReleaseIntArrayElements(JNIEnv * env,jintArray array,jint * elements,jint mode)2458 static void ReleaseIntArrayElements(JNIEnv* env, jintArray array, jint* elements, jint mode) {
2459 ReleasePrimitiveArray<jintArray, jint, mirror::IntArray>(env, array, elements, mode);
2460 }
2461
ReleaseLongArrayElements(JNIEnv * env,jlongArray array,jlong * elements,jint mode)2462 static void ReleaseLongArrayElements(JNIEnv* env, jlongArray array, jlong* elements, jint mode) {
2463 ReleasePrimitiveArray<jlongArray, jlong, mirror::LongArray>(env, array, elements, mode);
2464 }
2465
ReleaseShortArrayElements(JNIEnv * env,jshortArray array,jshort * elements,jint mode)2466 static void ReleaseShortArrayElements(JNIEnv* env, jshortArray array, jshort* elements,
2467 jint mode) {
2468 ReleasePrimitiveArray<jshortArray, jshort, mirror::ShortArray>(env, array, elements, mode);
2469 }
2470
GetBooleanArrayRegion(JNIEnv * env,jbooleanArray array,jsize start,jsize length,jboolean * buf)2471 static void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize length,
2472 jboolean* buf) {
2473 GetPrimitiveArrayRegion<jbooleanArray, jboolean, mirror::BooleanArray>(env, array, start,
2474 length, buf);
2475 }
2476
GetByteArrayRegion(JNIEnv * env,jbyteArray array,jsize start,jsize length,jbyte * buf)2477 static void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize length,
2478 jbyte* buf) {
2479 GetPrimitiveArrayRegion<jbyteArray, jbyte, mirror::ByteArray>(env, array, start, length, buf);
2480 }
2481
GetCharArrayRegion(JNIEnv * env,jcharArray array,jsize start,jsize length,jchar * buf)2482 static void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize length,
2483 jchar* buf) {
2484 GetPrimitiveArrayRegion<jcharArray, jchar, mirror::CharArray>(env, array, start, length, buf);
2485 }
2486
GetDoubleArrayRegion(JNIEnv * env,jdoubleArray array,jsize start,jsize length,jdouble * buf)2487 static void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize length,
2488 jdouble* buf) {
2489 GetPrimitiveArrayRegion<jdoubleArray, jdouble, mirror::DoubleArray>(env, array, start, length,
2490 buf);
2491 }
2492
GetFloatArrayRegion(JNIEnv * env,jfloatArray array,jsize start,jsize length,jfloat * buf)2493 static void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize length,
2494 jfloat* buf) {
2495 GetPrimitiveArrayRegion<jfloatArray, jfloat, mirror::FloatArray>(env, array, start, length,
2496 buf);
2497 }
2498
GetIntArrayRegion(JNIEnv * env,jintArray array,jsize start,jsize length,jint * buf)2499 static void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize length,
2500 jint* buf) {
2501 GetPrimitiveArrayRegion<jintArray, jint, mirror::IntArray>(env, array, start, length, buf);
2502 }
2503
GetLongArrayRegion(JNIEnv * env,jlongArray array,jsize start,jsize length,jlong * buf)2504 static void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize length,
2505 jlong* buf) {
2506 GetPrimitiveArrayRegion<jlongArray, jlong, mirror::LongArray>(env, array, start, length, buf);
2507 }
2508
GetShortArrayRegion(JNIEnv * env,jshortArray array,jsize start,jsize length,jshort * buf)2509 static void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize length,
2510 jshort* buf) {
2511 GetPrimitiveArrayRegion<jshortArray, jshort, mirror::ShortArray>(env, array, start, length,
2512 buf);
2513 }
2514
SetBooleanArrayRegion(JNIEnv * env,jbooleanArray array,jsize start,jsize length,const jboolean * buf)2515 static void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize length,
2516 const jboolean* buf) {
2517 SetPrimitiveArrayRegion<jbooleanArray, jboolean, mirror::BooleanArray>(env, array, start,
2518 length, buf);
2519 }
2520
SetByteArrayRegion(JNIEnv * env,jbyteArray array,jsize start,jsize length,const jbyte * buf)2521 static void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize length,
2522 const jbyte* buf) {
2523 SetPrimitiveArrayRegion<jbyteArray, jbyte, mirror::ByteArray>(env, array, start, length, buf);
2524 }
2525
SetCharArrayRegion(JNIEnv * env,jcharArray array,jsize start,jsize length,const jchar * buf)2526 static void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize length,
2527 const jchar* buf) {
2528 SetPrimitiveArrayRegion<jcharArray, jchar, mirror::CharArray>(env, array, start, length, buf);
2529 }
2530
SetDoubleArrayRegion(JNIEnv * env,jdoubleArray array,jsize start,jsize length,const jdouble * buf)2531 static void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize length,
2532 const jdouble* buf) {
2533 SetPrimitiveArrayRegion<jdoubleArray, jdouble, mirror::DoubleArray>(env, array, start, length,
2534 buf);
2535 }
2536
SetFloatArrayRegion(JNIEnv * env,jfloatArray array,jsize start,jsize length,const jfloat * buf)2537 static void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize length,
2538 const jfloat* buf) {
2539 SetPrimitiveArrayRegion<jfloatArray, jfloat, mirror::FloatArray>(env, array, start, length,
2540 buf);
2541 }
2542
SetIntArrayRegion(JNIEnv * env,jintArray array,jsize start,jsize length,const jint * buf)2543 static void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize length,
2544 const jint* buf) {
2545 SetPrimitiveArrayRegion<jintArray, jint, mirror::IntArray>(env, array, start, length, buf);
2546 }
2547
SetLongArrayRegion(JNIEnv * env,jlongArray array,jsize start,jsize length,const jlong * buf)2548 static void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize length,
2549 const jlong* buf) {
2550 SetPrimitiveArrayRegion<jlongArray, jlong, mirror::LongArray>(env, array, start, length, buf);
2551 }
2552
SetShortArrayRegion(JNIEnv * env,jshortArray array,jsize start,jsize length,const jshort * buf)2553 static void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize length,
2554 const jshort* buf) {
2555 SetPrimitiveArrayRegion<jshortArray, jshort, mirror::ShortArray>(env, array, start, length,
2556 buf);
2557 }
2558
RegisterNatives(JNIEnv * env,jclass java_class,const JNINativeMethod * methods,jint method_count)2559 static jint RegisterNatives(JNIEnv* env,
2560 jclass java_class,
2561 const JNINativeMethod* methods,
2562 jint method_count) {
2563 if (UNLIKELY(method_count < 0)) {
2564 JavaVmExtFromEnv(env)->JniAbortF("RegisterNatives", "negative method count: %d",
2565 method_count);
2566 return JNI_ERR; // Not reached except in unit tests.
2567 }
2568 CHECK_NON_NULL_ARGUMENT_FN_NAME("RegisterNatives", java_class, JNI_ERR);
2569 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2570 ScopedObjectAccess soa(env);
2571 StackHandleScope<1> hs(soa.Self());
2572 Handle<mirror::Class> c = hs.NewHandle(soa.Decode<mirror::Class>(java_class));
2573 if (UNLIKELY(method_count == 0)) {
2574 LOG(WARNING) << "JNI RegisterNativeMethods: attempt to register 0 native methods for "
2575 << c->PrettyDescriptor();
2576 return JNI_OK;
2577 }
2578 CHECK_NON_NULL_ARGUMENT_FN_NAME("RegisterNatives", methods, JNI_ERR);
2579 for (jint i = 0; i < method_count; ++i) {
2580 const char* name = methods[i].name;
2581 const char* sig = methods[i].signature;
2582 const void* fnPtr = methods[i].fnPtr;
2583 if (UNLIKELY(name == nullptr)) {
2584 ReportInvalidJNINativeMethod(soa, c.Get(), "method name", i);
2585 return JNI_ERR;
2586 } else if (UNLIKELY(sig == nullptr)) {
2587 ReportInvalidJNINativeMethod(soa, c.Get(), "method signature", i);
2588 return JNI_ERR;
2589 } else if (UNLIKELY(fnPtr == nullptr)) {
2590 ReportInvalidJNINativeMethod(soa, c.Get(), "native function", i);
2591 return JNI_ERR;
2592 }
2593 bool is_fast = false;
2594 // Notes about fast JNI calls:
2595 //
2596 // On a normal JNI call, the calling thread usually transitions
2597 // from the kRunnable state to the kNative state. But if the
2598 // called native function needs to access any Java object, it
2599 // will have to transition back to the kRunnable state.
2600 //
2601 // There is a cost to this double transition. For a JNI call
2602 // that should be quick, this cost may dominate the call cost.
2603 //
2604 // On a fast JNI call, the calling thread avoids this double
2605 // transition by not transitioning from kRunnable to kNative and
2606 // stays in the kRunnable state.
2607 //
2608 // There are risks to using a fast JNI call because it can delay
2609 // a response to a thread suspension request which is typically
2610 // used for a GC root scanning, etc. If a fast JNI call takes a
2611 // long time, it could cause longer thread suspension latency
2612 // and GC pauses.
2613 //
2614 // Thus, fast JNI should be used with care. It should be used
2615 // for a JNI call that takes a short amount of time (eg. no
2616 // long-running loop) and does not block (eg. no locks, I/O,
2617 // etc.)
2618 //
2619 // A '!' prefix in the signature in the JNINativeMethod
2620 // indicates that it's a fast JNI call and the runtime omits the
2621 // thread state transition from kRunnable to kNative at the
2622 // entry.
2623 if (*sig == '!') {
2624 is_fast = true;
2625 ++sig;
2626 }
2627
2628 // Note: the right order is to try to find the method locally
2629 // first, either as a direct or a virtual method. Then move to
2630 // the parent.
2631 ArtMethod* m = nullptr;
2632 bool warn_on_going_to_parent = down_cast<JNIEnvExt*>(env)->GetVm()->IsCheckJniEnabled();
2633 for (ObjPtr<mirror::Class> current_class = c.Get();
2634 current_class != nullptr;
2635 current_class = current_class->GetSuperClass()) {
2636 // Search first only comparing methods which are native.
2637 m = FindMethod<true>(current_class, name, sig);
2638 if (m != nullptr) {
2639 break;
2640 }
2641
2642 // Search again comparing to all methods, to find non-native methods that match.
2643 m = FindMethod<false>(current_class, name, sig);
2644 if (m != nullptr) {
2645 break;
2646 }
2647
2648 if (warn_on_going_to_parent) {
2649 LOG(WARNING) << "CheckJNI: method to register \"" << name << "\" not in the given class. "
2650 << "This is slow, consider changing your RegisterNatives calls.";
2651 warn_on_going_to_parent = false;
2652 }
2653 }
2654
2655 if (m == nullptr) {
2656 c->DumpClass(LOG_STREAM(ERROR), mirror::Class::kDumpClassFullDetail);
2657 LOG(ERROR)
2658 << "Failed to register native method "
2659 << c->PrettyDescriptor() << "." << name << sig << " in "
2660 << c->GetDexCache()->GetLocation()->ToModifiedUtf8();
2661 ThrowNoSuchMethodError(soa, c.Get(), name, sig, "static or non-static");
2662 return JNI_ERR;
2663 } else if (!m->IsNative()) {
2664 LOG(ERROR)
2665 << "Failed to register non-native method "
2666 << c->PrettyDescriptor() << "." << name << sig
2667 << " as native";
2668 ThrowNoSuchMethodError(soa, c.Get(), name, sig, "native");
2669 return JNI_ERR;
2670 }
2671
2672 VLOG(jni) << "[Registering JNI native method " << m->PrettyMethod() << "]";
2673
2674 if (UNLIKELY(is_fast)) {
2675 // There are a few reasons to switch:
2676 // 1) We don't support !bang JNI anymore, it will turn to a hard error later.
2677 // 2) @FastNative is actually faster. At least 1.5x faster than !bang JNI.
2678 // and switching is super easy, remove ! in C code, add annotation in .java code.
2679 // 3) Good chance of hitting DCHECK failures in ScopedFastNativeObjectAccess
2680 // since that checks for presence of @FastNative and not for ! in the descriptor.
2681 LOG(WARNING) << "!bang JNI is deprecated. Switch to @FastNative for " << m->PrettyMethod();
2682 is_fast = false;
2683 // TODO: make this a hard register error in the future.
2684 }
2685
2686 const void* final_function_ptr = class_linker->RegisterNative(soa.Self(), m, fnPtr);
2687 UNUSED(final_function_ptr);
2688 }
2689 return JNI_OK;
2690 }
2691
UnregisterNatives(JNIEnv * env,jclass java_class)2692 static jint UnregisterNatives(JNIEnv* env, jclass java_class) {
2693 CHECK_NON_NULL_ARGUMENT_RETURN(java_class, JNI_ERR);
2694 ScopedObjectAccess soa(env);
2695 ObjPtr<mirror::Class> c = soa.Decode<mirror::Class>(java_class);
2696
2697 VLOG(jni) << "[Unregistering JNI native methods for " << mirror::Class::PrettyClass(c) << "]";
2698
2699 size_t unregistered_count = 0;
2700 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2701 auto pointer_size = class_linker->GetImagePointerSize();
2702 for (auto& m : c->GetMethods(pointer_size)) {
2703 if (m.IsNative()) {
2704 class_linker->UnregisterNative(soa.Self(), &m);
2705 unregistered_count++;
2706 }
2707 }
2708
2709 if (unregistered_count == 0) {
2710 LOG(WARNING) << "JNI UnregisterNatives: attempt to unregister native methods of class '"
2711 << mirror::Class::PrettyDescriptor(c) << "' that contains no native methods";
2712 }
2713 return JNI_OK;
2714 }
2715
MonitorEnter(JNIEnv * env,jobject java_object)2716 static jint MonitorEnter(JNIEnv* env, jobject java_object) NO_THREAD_SAFETY_ANALYSIS {
2717 CHECK_NON_NULL_ARGUMENT_RETURN(java_object, JNI_ERR);
2718 ScopedObjectAccess soa(env);
2719 ObjPtr<mirror::Object> o = soa.Decode<mirror::Object>(java_object);
2720 o = o->MonitorEnter(soa.Self());
2721 if (soa.Self()->HoldsLock(o)) {
2722 soa.Env()->monitors_.Add(o);
2723 }
2724 if (soa.Self()->IsExceptionPending()) {
2725 return JNI_ERR;
2726 }
2727 return JNI_OK;
2728 }
2729
MonitorExit(JNIEnv * env,jobject java_object)2730 static jint MonitorExit(JNIEnv* env, jobject java_object) NO_THREAD_SAFETY_ANALYSIS {
2731 CHECK_NON_NULL_ARGUMENT_RETURN(java_object, JNI_ERR);
2732 ScopedObjectAccess soa(env);
2733 ObjPtr<mirror::Object> o = soa.Decode<mirror::Object>(java_object);
2734 bool remove_mon = soa.Self()->HoldsLock(o);
2735 o->MonitorExit(soa.Self());
2736 if (remove_mon) {
2737 soa.Env()->monitors_.Remove(o);
2738 }
2739 if (soa.Self()->IsExceptionPending()) {
2740 return JNI_ERR;
2741 }
2742 return JNI_OK;
2743 }
2744
GetJavaVM(JNIEnv * env,JavaVM ** vm)2745 static jint GetJavaVM(JNIEnv* env, JavaVM** vm) {
2746 CHECK_NON_NULL_ARGUMENT_RETURN(vm, JNI_ERR);
2747 Runtime* runtime = Runtime::Current();
2748 if (runtime != nullptr) {
2749 *vm = runtime->GetJavaVM();
2750 } else {
2751 *vm = nullptr;
2752 }
2753 return (*vm != nullptr) ? JNI_OK : JNI_ERR;
2754 }
2755
NewDirectByteBuffer(JNIEnv * env,void * address,jlong capacity)2756 static jobject NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) {
2757 if (capacity < 0) {
2758 JavaVmExtFromEnv(env)->JniAbortF("NewDirectByteBuffer", "negative buffer capacity: %" PRId64,
2759 capacity);
2760 return nullptr;
2761 }
2762 if (address == nullptr && capacity != 0) {
2763 JavaVmExtFromEnv(env)->JniAbortF("NewDirectByteBuffer",
2764 "non-zero capacity for nullptr pointer: %" PRId64, capacity);
2765 return nullptr;
2766 }
2767
2768 // At the moment, the capacity of DirectByteBuffer is limited to a signed int.
2769 if (capacity > INT_MAX) {
2770 JavaVmExtFromEnv(env)->JniAbortF("NewDirectByteBuffer",
2771 "buffer capacity greater than maximum jint: %" PRId64,
2772 capacity);
2773 return nullptr;
2774 }
2775 jlong address_arg = reinterpret_cast<jlong>(address);
2776 jint capacity_arg = static_cast<jint>(capacity);
2777
2778 ScopedObjectAccess soa(env);
2779 return soa.AddLocalReference<jobject>(
2780 WellKnownClasses::java_nio_DirectByteBuffer_init->NewObject<'J', 'I'>(
2781 soa.Self(), address_arg, capacity_arg));
2782 }
2783
GetDirectBufferAddress(JNIEnv * env,jobject java_buffer)2784 static void* GetDirectBufferAddress(JNIEnv* env, jobject java_buffer) {
2785 // Return null if |java_buffer| is not defined.
2786 if (java_buffer == nullptr) {
2787 return nullptr;
2788 }
2789
2790 ScopedObjectAccess soa(env);
2791 ObjPtr<mirror::Object> buffer = soa.Decode<mirror::Object>(java_buffer);
2792
2793 // Return null if |java_buffer| is not a java.nio.Buffer instance.
2794 if (!buffer->InstanceOf(WellKnownClasses::java_nio_Buffer.Get())) {
2795 return nullptr;
2796 }
2797
2798 // Buffer.address is non-null when the |java_buffer| is direct.
2799 return reinterpret_cast<void*>(WellKnownClasses::java_nio_Buffer_address->GetLong(buffer));
2800 }
2801
GetDirectBufferCapacity(JNIEnv * env,jobject java_buffer)2802 static jlong GetDirectBufferCapacity(JNIEnv* env, jobject java_buffer) {
2803 if (java_buffer == nullptr) {
2804 return -1;
2805 }
2806
2807 ScopedObjectAccess soa(env);
2808 StackHandleScope<1u> hs(soa.Self());
2809 Handle<mirror::Object> buffer = hs.NewHandle(soa.Decode<mirror::Object>(java_buffer));
2810 if (!buffer->InstanceOf(WellKnownClasses::java_nio_Buffer.Get())) {
2811 return -1;
2812 }
2813
2814 // When checking the buffer capacity, it's important to note that a zero-sized direct buffer
2815 // may have a null address field which means we can't tell whether it is direct or not.
2816 // We therefore call Buffer.isDirect(). One path that creates such a buffer is
2817 // FileChannel.map() if the file size is zero.
2818 //
2819 // NB GetDirectBufferAddress() does not need to call `Buffer.isDirect()` since it is only
2820 // able return a valid address if the Buffer address field is not-null.
2821 //
2822 // Note: We can hit a `StackOverflowError` during the invocation but `Buffer.isDirect()`
2823 // implementations should not otherwise throw any exceptions.
2824 bool direct = WellKnownClasses::java_nio_Buffer_isDirect->InvokeVirtual<'Z'>(
2825 soa.Self(), buffer.Get());
2826 if (UNLIKELY(soa.Self()->IsExceptionPending()) || !direct) {
2827 return -1;
2828 }
2829
2830 return static_cast<jlong>(WellKnownClasses::java_nio_Buffer_capacity->GetInt(buffer.Get()));
2831 }
2832
GetObjectRefType(JNIEnv * env ATTRIBUTE_UNUSED,jobject java_object)2833 static jobjectRefType GetObjectRefType(JNIEnv* env ATTRIBUTE_UNUSED, jobject java_object) {
2834 if (java_object == nullptr) {
2835 return JNIInvalidRefType;
2836 }
2837
2838 // Do we definitely know what kind of reference this is?
2839 IndirectRef ref = reinterpret_cast<IndirectRef>(java_object);
2840 IndirectRefKind kind = IndirectReferenceTable::GetIndirectRefKind(ref);
2841 switch (kind) {
2842 case kLocal:
2843 return JNILocalRefType;
2844 case kGlobal:
2845 return JNIGlobalRefType;
2846 case kWeakGlobal:
2847 return JNIWeakGlobalRefType;
2848 case kJniTransition:
2849 // Assume value is in a JNI transition frame.
2850 return JNILocalRefType;
2851 }
2852 LOG(FATAL) << "IndirectRefKind[" << kind << "]";
2853 UNREACHABLE();
2854 }
2855
2856 private:
EnsureLocalCapacityInternal(ScopedObjectAccess & soa,jint desired_capacity,const char * caller)2857 static jint EnsureLocalCapacityInternal(ScopedObjectAccess& soa, jint desired_capacity,
2858 const char* caller)
2859 REQUIRES_SHARED(Locks::mutator_lock_) {
2860 if (desired_capacity > 0) {
2861 std::string error_msg;
2862 if (!soa.Env()->locals_.EnsureFreeCapacity(static_cast<size_t>(desired_capacity),
2863 &error_msg)) {
2864 std::string caller_error = android::base::StringPrintf("%s: %s", caller,
2865 error_msg.c_str());
2866 soa.Self()->ThrowOutOfMemoryError(caller_error.c_str());
2867 return JNI_ERR;
2868 }
2869 } else if (desired_capacity < 0) {
2870 LOG(ERROR) << "Invalid capacity given to " << caller << ": " << desired_capacity;
2871 return JNI_ERR;
2872 } // The zero case is a no-op.
2873 return JNI_OK;
2874 }
2875
2876 template<typename JniT, typename ArtT>
NewPrimitiveArray(JNIEnv * env,jsize length)2877 static JniT NewPrimitiveArray(JNIEnv* env, jsize length) {
2878 ScopedObjectAccess soa(env);
2879 if (UNLIKELY(length < 0)) {
2880 soa.Vm()->JniAbortF("NewPrimitiveArray", "negative array length: %d", length);
2881 return nullptr;
2882 }
2883 ObjPtr<ArtT> result = ArtT::Alloc(soa.Self(), length);
2884 return soa.AddLocalReference<JniT>(result);
2885 }
2886
2887 template <typename JArrayT, typename ElementT, typename ArtArrayT>
DecodeAndCheckArrayType(ScopedObjectAccess & soa,JArrayT java_array,const char * fn_name,const char * operation)2888 static ObjPtr<ArtArrayT> DecodeAndCheckArrayType(ScopedObjectAccess& soa,
2889 JArrayT java_array,
2890 const char* fn_name,
2891 const char* operation)
2892 REQUIRES_SHARED(Locks::mutator_lock_) {
2893 ObjPtr<ArtArrayT> array = soa.Decode<ArtArrayT>(java_array);
2894 ObjPtr<mirror::Class> expected_array_class = GetClassRoot<ArtArrayT>();
2895 if (UNLIKELY(expected_array_class != array->GetClass())) {
2896 soa.Vm()->JniAbortF(fn_name,
2897 "attempt to %s %s primitive array elements with an object of type %s",
2898 operation,
2899 mirror::Class::PrettyDescriptor(
2900 expected_array_class->GetComponentType()).c_str(),
2901 mirror::Class::PrettyDescriptor(array->GetClass()).c_str());
2902 return nullptr;
2903 }
2904 DCHECK_EQ(sizeof(ElementT), array->GetClass()->GetComponentSize());
2905 return array;
2906 }
2907
2908 template <typename ArrayT, typename ElementT, typename ArtArrayT>
GetPrimitiveArray(JNIEnv * env,ArrayT java_array,jboolean * is_copy)2909 static ElementT* GetPrimitiveArray(JNIEnv* env, ArrayT java_array, jboolean* is_copy) {
2910 CHECK_NON_NULL_ARGUMENT(java_array);
2911 ScopedObjectAccess soa(env);
2912 ObjPtr<ArtArrayT> array = DecodeAndCheckArrayType<ArrayT, ElementT, ArtArrayT>(
2913 soa, java_array, "GetArrayElements", "get");
2914 if (UNLIKELY(array == nullptr)) {
2915 return nullptr;
2916 }
2917 // Only make a copy if necessary.
2918 if (Runtime::Current()->GetHeap()->IsMovableObject(array)) {
2919 if (is_copy != nullptr) {
2920 *is_copy = JNI_TRUE;
2921 }
2922 const size_t component_size = sizeof(ElementT);
2923 size_t size = array->GetLength() * component_size;
2924 void* data = new uint64_t[RoundUp(size, 8) / 8];
2925 memcpy(data, array->GetData(), size);
2926 return reinterpret_cast<ElementT*>(data);
2927 } else {
2928 if (is_copy != nullptr) {
2929 *is_copy = JNI_FALSE;
2930 }
2931 return reinterpret_cast<ElementT*>(array->GetData());
2932 }
2933 }
2934
2935 template <typename ArrayT, typename ElementT, typename ArtArrayT>
ReleasePrimitiveArray(JNIEnv * env,ArrayT java_array,ElementT * elements,jint mode)2936 static void ReleasePrimitiveArray(JNIEnv* env, ArrayT java_array, ElementT* elements, jint mode) {
2937 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_array);
2938 ScopedObjectAccess soa(env);
2939 ObjPtr<ArtArrayT> array = DecodeAndCheckArrayType<ArrayT, ElementT, ArtArrayT>(
2940 soa, java_array, "ReleaseArrayElements", "release");
2941 if (array == nullptr) {
2942 return;
2943 }
2944 ReleasePrimitiveArray(soa, array, sizeof(ElementT), elements, mode);
2945 }
2946
ReleasePrimitiveArray(ScopedObjectAccess & soa,ObjPtr<mirror::Array> array,size_t component_size,void * elements,jint mode)2947 static void ReleasePrimitiveArray(ScopedObjectAccess& soa,
2948 ObjPtr<mirror::Array> array,
2949 size_t component_size,
2950 void* elements,
2951 jint mode)
2952 REQUIRES_SHARED(Locks::mutator_lock_) {
2953 void* array_data = array->GetRawData(component_size, 0);
2954 gc::Heap* heap = Runtime::Current()->GetHeap();
2955 bool is_copy = array_data != elements;
2956 size_t bytes = array->GetLength() * component_size;
2957 if (is_copy) {
2958 // Integrity check: If elements is not the same as the java array's data, it better not be a
2959 // heap address. TODO: This might be slow to check, may be worth keeping track of which
2960 // copies we make?
2961 if (heap->IsNonDiscontinuousSpaceHeapAddress(elements)) {
2962 soa.Vm()->JniAbortF("ReleaseArrayElements",
2963 "invalid element pointer %p, array elements are %p",
2964 reinterpret_cast<void*>(elements), array_data);
2965 return;
2966 }
2967 if (mode != JNI_ABORT) {
2968 memcpy(array_data, elements, bytes);
2969 } else if (kWarnJniAbort && memcmp(array_data, elements, bytes) != 0) {
2970 // Warn if we have JNI_ABORT and the arrays don't match since this is usually an error.
2971 LOG(WARNING) << "Possible incorrect JNI_ABORT in Release*ArrayElements";
2972 soa.Self()->DumpJavaStack(LOG_STREAM(WARNING));
2973 }
2974 }
2975 if (mode != JNI_COMMIT) {
2976 if (is_copy) {
2977 delete[] reinterpret_cast<uint64_t*>(elements);
2978 } else if (heap->IsMovableObject(array)) {
2979 // Non copy to a movable object must means that we had disabled the moving GC.
2980 if (!gUseReadBarrier && !gUseUserfaultfd) {
2981 heap->DecrementDisableMovingGC(soa.Self());
2982 } else {
2983 heap->DecrementDisableThreadFlip(soa.Self());
2984 }
2985 }
2986 }
2987 }
2988
2989 template <typename JArrayT, typename ElementT, typename ArtArrayT>
GetPrimitiveArrayRegion(JNIEnv * env,JArrayT java_array,jsize start,jsize length,ElementT * buf)2990 static void GetPrimitiveArrayRegion(JNIEnv* env, JArrayT java_array,
2991 jsize start, jsize length, ElementT* buf) {
2992 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_array);
2993 ScopedObjectAccess soa(env);
2994 ObjPtr<ArtArrayT> array = DecodeAndCheckArrayType<JArrayT, ElementT, ArtArrayT>(
2995 soa, java_array, "GetPrimitiveArrayRegion", "get region of");
2996 if (array != nullptr) {
2997 if (start < 0 || length < 0 || length > array->GetLength() - start) {
2998 ThrowAIOOBE(soa, array, start, length, "src");
2999 } else {
3000 CHECK_NON_NULL_MEMCPY_ARGUMENT(length, buf);
3001 ElementT* data = array->GetData();
3002 memcpy(buf, data + start, length * sizeof(ElementT));
3003 }
3004 }
3005 }
3006
3007 template <typename JArrayT, typename ElementT, typename ArtArrayT>
SetPrimitiveArrayRegion(JNIEnv * env,JArrayT java_array,jsize start,jsize length,const ElementT * buf)3008 static void SetPrimitiveArrayRegion(JNIEnv* env, JArrayT java_array,
3009 jsize start, jsize length, const ElementT* buf) {
3010 CHECK_NON_NULL_ARGUMENT_RETURN_VOID(java_array);
3011 ScopedObjectAccess soa(env);
3012 ObjPtr<ArtArrayT> array = DecodeAndCheckArrayType<JArrayT, ElementT, ArtArrayT>(
3013 soa, java_array, "SetPrimitiveArrayRegion", "set region of");
3014 if (array != nullptr) {
3015 if (start < 0 || length < 0 || length > array->GetLength() - start) {
3016 ThrowAIOOBE(soa, array, start, length, "dst");
3017 } else {
3018 CHECK_NON_NULL_MEMCPY_ARGUMENT(length, buf);
3019 ElementT* data = array->GetData();
3020 memcpy(data + start, buf, length * sizeof(ElementT));
3021 }
3022 }
3023 }
3024 };
3025
3026 template<bool kEnableIndexIds>
3027 struct JniNativeInterfaceFunctions {
3028 using JNIImpl = JNI<kEnableIndexIds>;
3029 static constexpr JNINativeInterface gJniNativeInterface = {
3030 nullptr, // reserved0.
3031 nullptr, // reserved1.
3032 nullptr, // reserved2.
3033 nullptr, // reserved3.
3034 JNIImpl::GetVersion,
3035 JNIImpl::DefineClass,
3036 JNIImpl::FindClass,
3037 JNIImpl::FromReflectedMethod,
3038 JNIImpl::FromReflectedField,
3039 JNIImpl::ToReflectedMethod,
3040 JNIImpl::GetSuperclass,
3041 JNIImpl::IsAssignableFrom,
3042 JNIImpl::ToReflectedField,
3043 JNIImpl::Throw,
3044 JNIImpl::ThrowNew,
3045 JNIImpl::ExceptionOccurred,
3046 JNIImpl::ExceptionDescribe,
3047 JNIImpl::ExceptionClear,
3048 JNIImpl::FatalError,
3049 JNIImpl::PushLocalFrame,
3050 JNIImpl::PopLocalFrame,
3051 JNIImpl::NewGlobalRef,
3052 JNIImpl::DeleteGlobalRef,
3053 JNIImpl::DeleteLocalRef,
3054 JNIImpl::IsSameObject,
3055 JNIImpl::NewLocalRef,
3056 JNIImpl::EnsureLocalCapacity,
3057 JNIImpl::AllocObject,
3058 JNIImpl::NewObject,
3059 JNIImpl::NewObjectV,
3060 JNIImpl::NewObjectA,
3061 JNIImpl::GetObjectClass,
3062 JNIImpl::IsInstanceOf,
3063 JNIImpl::GetMethodID,
3064 JNIImpl::CallObjectMethod,
3065 JNIImpl::CallObjectMethodV,
3066 JNIImpl::CallObjectMethodA,
3067 JNIImpl::CallBooleanMethod,
3068 JNIImpl::CallBooleanMethodV,
3069 JNIImpl::CallBooleanMethodA,
3070 JNIImpl::CallByteMethod,
3071 JNIImpl::CallByteMethodV,
3072 JNIImpl::CallByteMethodA,
3073 JNIImpl::CallCharMethod,
3074 JNIImpl::CallCharMethodV,
3075 JNIImpl::CallCharMethodA,
3076 JNIImpl::CallShortMethod,
3077 JNIImpl::CallShortMethodV,
3078 JNIImpl::CallShortMethodA,
3079 JNIImpl::CallIntMethod,
3080 JNIImpl::CallIntMethodV,
3081 JNIImpl::CallIntMethodA,
3082 JNIImpl::CallLongMethod,
3083 JNIImpl::CallLongMethodV,
3084 JNIImpl::CallLongMethodA,
3085 JNIImpl::CallFloatMethod,
3086 JNIImpl::CallFloatMethodV,
3087 JNIImpl::CallFloatMethodA,
3088 JNIImpl::CallDoubleMethod,
3089 JNIImpl::CallDoubleMethodV,
3090 JNIImpl::CallDoubleMethodA,
3091 JNIImpl::CallVoidMethod,
3092 JNIImpl::CallVoidMethodV,
3093 JNIImpl::CallVoidMethodA,
3094 JNIImpl::CallNonvirtualObjectMethod,
3095 JNIImpl::CallNonvirtualObjectMethodV,
3096 JNIImpl::CallNonvirtualObjectMethodA,
3097 JNIImpl::CallNonvirtualBooleanMethod,
3098 JNIImpl::CallNonvirtualBooleanMethodV,
3099 JNIImpl::CallNonvirtualBooleanMethodA,
3100 JNIImpl::CallNonvirtualByteMethod,
3101 JNIImpl::CallNonvirtualByteMethodV,
3102 JNIImpl::CallNonvirtualByteMethodA,
3103 JNIImpl::CallNonvirtualCharMethod,
3104 JNIImpl::CallNonvirtualCharMethodV,
3105 JNIImpl::CallNonvirtualCharMethodA,
3106 JNIImpl::CallNonvirtualShortMethod,
3107 JNIImpl::CallNonvirtualShortMethodV,
3108 JNIImpl::CallNonvirtualShortMethodA,
3109 JNIImpl::CallNonvirtualIntMethod,
3110 JNIImpl::CallNonvirtualIntMethodV,
3111 JNIImpl::CallNonvirtualIntMethodA,
3112 JNIImpl::CallNonvirtualLongMethod,
3113 JNIImpl::CallNonvirtualLongMethodV,
3114 JNIImpl::CallNonvirtualLongMethodA,
3115 JNIImpl::CallNonvirtualFloatMethod,
3116 JNIImpl::CallNonvirtualFloatMethodV,
3117 JNIImpl::CallNonvirtualFloatMethodA,
3118 JNIImpl::CallNonvirtualDoubleMethod,
3119 JNIImpl::CallNonvirtualDoubleMethodV,
3120 JNIImpl::CallNonvirtualDoubleMethodA,
3121 JNIImpl::CallNonvirtualVoidMethod,
3122 JNIImpl::CallNonvirtualVoidMethodV,
3123 JNIImpl::CallNonvirtualVoidMethodA,
3124 JNIImpl::GetFieldID,
3125 JNIImpl::GetObjectField,
3126 JNIImpl::GetBooleanField,
3127 JNIImpl::GetByteField,
3128 JNIImpl::GetCharField,
3129 JNIImpl::GetShortField,
3130 JNIImpl::GetIntField,
3131 JNIImpl::GetLongField,
3132 JNIImpl::GetFloatField,
3133 JNIImpl::GetDoubleField,
3134 JNIImpl::SetObjectField,
3135 JNIImpl::SetBooleanField,
3136 JNIImpl::SetByteField,
3137 JNIImpl::SetCharField,
3138 JNIImpl::SetShortField,
3139 JNIImpl::SetIntField,
3140 JNIImpl::SetLongField,
3141 JNIImpl::SetFloatField,
3142 JNIImpl::SetDoubleField,
3143 JNIImpl::GetStaticMethodID,
3144 JNIImpl::CallStaticObjectMethod,
3145 JNIImpl::CallStaticObjectMethodV,
3146 JNIImpl::CallStaticObjectMethodA,
3147 JNIImpl::CallStaticBooleanMethod,
3148 JNIImpl::CallStaticBooleanMethodV,
3149 JNIImpl::CallStaticBooleanMethodA,
3150 JNIImpl::CallStaticByteMethod,
3151 JNIImpl::CallStaticByteMethodV,
3152 JNIImpl::CallStaticByteMethodA,
3153 JNIImpl::CallStaticCharMethod,
3154 JNIImpl::CallStaticCharMethodV,
3155 JNIImpl::CallStaticCharMethodA,
3156 JNIImpl::CallStaticShortMethod,
3157 JNIImpl::CallStaticShortMethodV,
3158 JNIImpl::CallStaticShortMethodA,
3159 JNIImpl::CallStaticIntMethod,
3160 JNIImpl::CallStaticIntMethodV,
3161 JNIImpl::CallStaticIntMethodA,
3162 JNIImpl::CallStaticLongMethod,
3163 JNIImpl::CallStaticLongMethodV,
3164 JNIImpl::CallStaticLongMethodA,
3165 JNIImpl::CallStaticFloatMethod,
3166 JNIImpl::CallStaticFloatMethodV,
3167 JNIImpl::CallStaticFloatMethodA,
3168 JNIImpl::CallStaticDoubleMethod,
3169 JNIImpl::CallStaticDoubleMethodV,
3170 JNIImpl::CallStaticDoubleMethodA,
3171 JNIImpl::CallStaticVoidMethod,
3172 JNIImpl::CallStaticVoidMethodV,
3173 JNIImpl::CallStaticVoidMethodA,
3174 JNIImpl::GetStaticFieldID,
3175 JNIImpl::GetStaticObjectField,
3176 JNIImpl::GetStaticBooleanField,
3177 JNIImpl::GetStaticByteField,
3178 JNIImpl::GetStaticCharField,
3179 JNIImpl::GetStaticShortField,
3180 JNIImpl::GetStaticIntField,
3181 JNIImpl::GetStaticLongField,
3182 JNIImpl::GetStaticFloatField,
3183 JNIImpl::GetStaticDoubleField,
3184 JNIImpl::SetStaticObjectField,
3185 JNIImpl::SetStaticBooleanField,
3186 JNIImpl::SetStaticByteField,
3187 JNIImpl::SetStaticCharField,
3188 JNIImpl::SetStaticShortField,
3189 JNIImpl::SetStaticIntField,
3190 JNIImpl::SetStaticLongField,
3191 JNIImpl::SetStaticFloatField,
3192 JNIImpl::SetStaticDoubleField,
3193 JNIImpl::NewString,
3194 JNIImpl::GetStringLength,
3195 JNIImpl::GetStringChars,
3196 JNIImpl::ReleaseStringChars,
3197 JNIImpl::NewStringUTF,
3198 JNIImpl::GetStringUTFLength,
3199 JNIImpl::GetStringUTFChars,
3200 JNIImpl::ReleaseStringUTFChars,
3201 JNIImpl::GetArrayLength,
3202 JNIImpl::NewObjectArray,
3203 JNIImpl::GetObjectArrayElement,
3204 JNIImpl::SetObjectArrayElement,
3205 JNIImpl::NewBooleanArray,
3206 JNIImpl::NewByteArray,
3207 JNIImpl::NewCharArray,
3208 JNIImpl::NewShortArray,
3209 JNIImpl::NewIntArray,
3210 JNIImpl::NewLongArray,
3211 JNIImpl::NewFloatArray,
3212 JNIImpl::NewDoubleArray,
3213 JNIImpl::GetBooleanArrayElements,
3214 JNIImpl::GetByteArrayElements,
3215 JNIImpl::GetCharArrayElements,
3216 JNIImpl::GetShortArrayElements,
3217 JNIImpl::GetIntArrayElements,
3218 JNIImpl::GetLongArrayElements,
3219 JNIImpl::GetFloatArrayElements,
3220 JNIImpl::GetDoubleArrayElements,
3221 JNIImpl::ReleaseBooleanArrayElements,
3222 JNIImpl::ReleaseByteArrayElements,
3223 JNIImpl::ReleaseCharArrayElements,
3224 JNIImpl::ReleaseShortArrayElements,
3225 JNIImpl::ReleaseIntArrayElements,
3226 JNIImpl::ReleaseLongArrayElements,
3227 JNIImpl::ReleaseFloatArrayElements,
3228 JNIImpl::ReleaseDoubleArrayElements,
3229 JNIImpl::GetBooleanArrayRegion,
3230 JNIImpl::GetByteArrayRegion,
3231 JNIImpl::GetCharArrayRegion,
3232 JNIImpl::GetShortArrayRegion,
3233 JNIImpl::GetIntArrayRegion,
3234 JNIImpl::GetLongArrayRegion,
3235 JNIImpl::GetFloatArrayRegion,
3236 JNIImpl::GetDoubleArrayRegion,
3237 JNIImpl::SetBooleanArrayRegion,
3238 JNIImpl::SetByteArrayRegion,
3239 JNIImpl::SetCharArrayRegion,
3240 JNIImpl::SetShortArrayRegion,
3241 JNIImpl::SetIntArrayRegion,
3242 JNIImpl::SetLongArrayRegion,
3243 JNIImpl::SetFloatArrayRegion,
3244 JNIImpl::SetDoubleArrayRegion,
3245 JNIImpl::RegisterNatives,
3246 JNIImpl::UnregisterNatives,
3247 JNIImpl::MonitorEnter,
3248 JNIImpl::MonitorExit,
3249 JNIImpl::GetJavaVM,
3250 JNIImpl::GetStringRegion,
3251 JNIImpl::GetStringUTFRegion,
3252 JNIImpl::GetPrimitiveArrayCritical,
3253 JNIImpl::ReleasePrimitiveArrayCritical,
3254 JNIImpl::GetStringCritical,
3255 JNIImpl::ReleaseStringCritical,
3256 JNIImpl::NewWeakGlobalRef,
3257 JNIImpl::DeleteWeakGlobalRef,
3258 JNIImpl::ExceptionCheck,
3259 JNIImpl::NewDirectByteBuffer,
3260 JNIImpl::GetDirectBufferAddress,
3261 JNIImpl::GetDirectBufferCapacity,
3262 JNIImpl::GetObjectRefType,
3263 };
3264 };
3265
GetJniNativeInterface()3266 const JNINativeInterface* GetJniNativeInterface() {
3267 // The template argument is passed down through the Encode/DecodeArtMethod/Field calls so if
3268 // JniIdType is kPointer the calls will be a simple cast with no branches. This ensures that
3269 // the normal case is still fast.
3270 return Runtime::Current()->GetJniIdType() == JniIdType::kPointer
3271 ? &JniNativeInterfaceFunctions<false>::gJniNativeInterface
3272 : &JniNativeInterfaceFunctions<true>::gJniNativeInterface;
3273 }
3274
3275 JNINativeInterface gJniSleepForeverStub = {
3276 nullptr, // reserved0.
3277 nullptr, // reserved1.
3278 nullptr, // reserved2.
3279 nullptr, // reserved3.
3280 reinterpret_cast<jint (*)(JNIEnv*)>(SleepForever),
3281 reinterpret_cast<jclass (*)(JNIEnv*, const char*, jobject, const jbyte*, jsize)>(SleepForever),
3282 reinterpret_cast<jclass (*)(JNIEnv*, const char*)>(SleepForever),
3283 reinterpret_cast<jmethodID (*)(JNIEnv*, jobject)>(SleepForever),
3284 reinterpret_cast<jfieldID (*)(JNIEnv*, jobject)>(SleepForever),
3285 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jmethodID, jboolean)>(SleepForever),
3286 reinterpret_cast<jclass (*)(JNIEnv*, jclass)>(SleepForever),
3287 reinterpret_cast<jboolean (*)(JNIEnv*, jclass, jclass)>(SleepForever),
3288 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jfieldID, jboolean)>(SleepForever),
3289 reinterpret_cast<jint (*)(JNIEnv*, jthrowable)>(SleepForever),
3290 reinterpret_cast<jint (*)(JNIEnv*, jclass, const char*)>(SleepForever),
3291 reinterpret_cast<jthrowable (*)(JNIEnv*)>(SleepForever),
3292 reinterpret_cast<void (*)(JNIEnv*)>(SleepForever),
3293 reinterpret_cast<void (*)(JNIEnv*)>(SleepForever),
3294 reinterpret_cast<void (*)(JNIEnv*, const char*)>(SleepForever),
3295 reinterpret_cast<jint (*)(JNIEnv*, jint)>(SleepForever),
3296 reinterpret_cast<jobject (*)(JNIEnv*, jobject)>(SleepForever),
3297 reinterpret_cast<jobject (*)(JNIEnv*, jobject)>(SleepForever),
3298 reinterpret_cast<void (*)(JNIEnv*, jobject)>(SleepForever),
3299 reinterpret_cast<void (*)(JNIEnv*, jobject)>(SleepForever),
3300 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jobject)>(SleepForever),
3301 reinterpret_cast<jobject (*)(JNIEnv*, jobject)>(SleepForever),
3302 reinterpret_cast<jint (*)(JNIEnv*, jint)>(SleepForever),
3303 reinterpret_cast<jobject (*)(JNIEnv*, jclass)>(SleepForever),
3304 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3305 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3306 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3307 reinterpret_cast<jclass (*)(JNIEnv*, jobject)>(SleepForever),
3308 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jclass)>(SleepForever),
3309 reinterpret_cast<jmethodID (*)(JNIEnv*, jclass, const char*, const char*)>(SleepForever),
3310 reinterpret_cast<jobject (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3311 reinterpret_cast<jobject (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3312 reinterpret_cast<jobject (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3313 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3314 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3315 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3316 reinterpret_cast<jbyte (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3317 reinterpret_cast<jbyte (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3318 reinterpret_cast<jbyte (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3319 reinterpret_cast<jchar (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3320 reinterpret_cast<jchar (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3321 reinterpret_cast<jchar (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3322 reinterpret_cast<jshort (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3323 reinterpret_cast<jshort (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3324 reinterpret_cast<jshort (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3325 reinterpret_cast<jint (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3326 reinterpret_cast<jint (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3327 reinterpret_cast<jint (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3328 reinterpret_cast<jlong (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3329 reinterpret_cast<jlong (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3330 reinterpret_cast<jlong (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3331 reinterpret_cast<jfloat (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3332 reinterpret_cast<jfloat (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3333 reinterpret_cast<jfloat (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3334 reinterpret_cast<jdouble (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3335 reinterpret_cast<jdouble (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3336 reinterpret_cast<jdouble (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3337 reinterpret_cast<void (*)(JNIEnv*, jobject, jmethodID, ...)>(SleepForever),
3338 reinterpret_cast<void (*)(JNIEnv*, jobject, jmethodID, va_list)>(SleepForever),
3339 reinterpret_cast<void (*)(JNIEnv*, jobject, jmethodID, const jvalue*)>(SleepForever),
3340 reinterpret_cast<jobject (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3341 reinterpret_cast<jobject (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3342 reinterpret_cast<jobject (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3343 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3344 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3345 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(
3346 SleepForever),
3347 reinterpret_cast<jbyte (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3348 reinterpret_cast<jbyte (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3349 reinterpret_cast<jbyte (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3350 reinterpret_cast<jchar (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3351 reinterpret_cast<jchar (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3352 reinterpret_cast<jchar (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3353 reinterpret_cast<jshort (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3354 reinterpret_cast<jshort (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3355 reinterpret_cast<jshort (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3356 reinterpret_cast<jint (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3357 reinterpret_cast<jint (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3358 reinterpret_cast<jint (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3359 reinterpret_cast<jlong (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3360 reinterpret_cast<jlong (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3361 reinterpret_cast<jlong (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3362 reinterpret_cast<jfloat (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3363 reinterpret_cast<jfloat (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3364 reinterpret_cast<jfloat (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3365 reinterpret_cast<jdouble (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3366 reinterpret_cast<jdouble (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3367 reinterpret_cast<jdouble (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3368 reinterpret_cast<void (*)(JNIEnv*, jobject, jclass, jmethodID, ...)>(SleepForever),
3369 reinterpret_cast<void (*)(JNIEnv*, jobject, jclass, jmethodID, va_list)>(SleepForever),
3370 reinterpret_cast<void (*)(JNIEnv*, jobject, jclass, jmethodID, const jvalue*)>(SleepForever),
3371 reinterpret_cast<jfieldID (*)(JNIEnv*, jclass, const char*, const char*)>(SleepForever),
3372 reinterpret_cast<jobject (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3373 reinterpret_cast<jboolean (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3374 reinterpret_cast<jbyte (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3375 reinterpret_cast<jchar (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3376 reinterpret_cast<jshort (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3377 reinterpret_cast<jint (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3378 reinterpret_cast<jlong (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3379 reinterpret_cast<jfloat (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3380 reinterpret_cast<jdouble (*)(JNIEnv*, jobject, jfieldID)>(SleepForever),
3381 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jobject)>(SleepForever),
3382 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jboolean)>(SleepForever),
3383 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jbyte)>(SleepForever),
3384 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jchar)>(SleepForever),
3385 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jshort)>(SleepForever),
3386 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jint)>(SleepForever),
3387 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jlong)>(SleepForever),
3388 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jfloat)>(SleepForever),
3389 reinterpret_cast<void (*)(JNIEnv*, jobject, jfieldID, jdouble)>(SleepForever),
3390 reinterpret_cast<jmethodID (*)(JNIEnv*, jclass, const char*, const char*)>(SleepForever),
3391 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3392 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3393 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3394 reinterpret_cast<jboolean (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3395 reinterpret_cast<jboolean (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3396 reinterpret_cast<jboolean (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3397 reinterpret_cast<jbyte (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3398 reinterpret_cast<jbyte (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3399 reinterpret_cast<jbyte (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3400 reinterpret_cast<jchar (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3401 reinterpret_cast<jchar (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3402 reinterpret_cast<jchar (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3403 reinterpret_cast<jshort (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3404 reinterpret_cast<jshort (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3405 reinterpret_cast<jshort (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3406 reinterpret_cast<jint (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3407 reinterpret_cast<jint (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3408 reinterpret_cast<jint (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3409 reinterpret_cast<jlong (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3410 reinterpret_cast<jlong (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3411 reinterpret_cast<jlong (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3412 reinterpret_cast<jfloat (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3413 reinterpret_cast<jfloat (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3414 reinterpret_cast<jfloat (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3415 reinterpret_cast<jdouble (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3416 reinterpret_cast<jdouble (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3417 reinterpret_cast<jdouble (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3418 reinterpret_cast<void (*)(JNIEnv*, jclass, jmethodID, ...)>(SleepForever),
3419 reinterpret_cast<void (*)(JNIEnv*, jclass, jmethodID, va_list)>(SleepForever),
3420 reinterpret_cast<void (*)(JNIEnv*, jclass, jmethodID, const jvalue*)>(SleepForever),
3421 reinterpret_cast<jfieldID (*)(JNIEnv*, jclass, const char*, const char*)>(SleepForever),
3422 reinterpret_cast<jobject (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3423 reinterpret_cast<jboolean (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3424 reinterpret_cast<jbyte (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3425 reinterpret_cast<jchar (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3426 reinterpret_cast<jshort (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3427 reinterpret_cast<jint (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3428 reinterpret_cast<jlong (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3429 reinterpret_cast<jfloat (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3430 reinterpret_cast<jdouble (*)(JNIEnv*, jclass, jfieldID)>(SleepForever),
3431 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jobject)>(SleepForever),
3432 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jboolean)>(SleepForever),
3433 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jbyte)>(SleepForever),
3434 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jchar)>(SleepForever),
3435 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jshort)>(SleepForever),
3436 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jint)>(SleepForever),
3437 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jlong)>(SleepForever),
3438 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jfloat)>(SleepForever),
3439 reinterpret_cast<void (*)(JNIEnv*, jclass, jfieldID, jdouble)>(SleepForever),
3440 reinterpret_cast<jstring (*)(JNIEnv*, const jchar*, jsize)>(SleepForever),
3441 reinterpret_cast<jsize (*)(JNIEnv*, jstring)>(SleepForever),
3442 reinterpret_cast<const jchar* (*)(JNIEnv*, jstring, jboolean*)>(SleepForever),
3443 reinterpret_cast<void (*)(JNIEnv*, jstring, const jchar*)>(SleepForever),
3444 reinterpret_cast<jstring (*)(JNIEnv*, const char*)>(SleepForever),
3445 reinterpret_cast<jsize (*)(JNIEnv*, jstring)>(SleepForever),
3446 reinterpret_cast<const char* (*)(JNIEnv*, jstring, jboolean*)>(SleepForever),
3447 reinterpret_cast<void (*)(JNIEnv*, jstring, const char*)>(SleepForever),
3448 reinterpret_cast<jsize (*)(JNIEnv*, jarray)>(SleepForever),
3449 reinterpret_cast<jobjectArray (*)(JNIEnv*, jsize, jclass, jobject)>(SleepForever),
3450 reinterpret_cast<jobject (*)(JNIEnv*, jobjectArray, jsize)>(SleepForever),
3451 reinterpret_cast<void (*)(JNIEnv*, jobjectArray, jsize, jobject)>(SleepForever),
3452 reinterpret_cast<jbooleanArray (*)(JNIEnv*, jsize)>(SleepForever),
3453 reinterpret_cast<jbyteArray (*)(JNIEnv*, jsize)>(SleepForever),
3454 reinterpret_cast<jcharArray (*)(JNIEnv*, jsize)>(SleepForever),
3455 reinterpret_cast<jshortArray (*)(JNIEnv*, jsize)>(SleepForever),
3456 reinterpret_cast<jintArray (*)(JNIEnv*, jsize)>(SleepForever),
3457 reinterpret_cast<jlongArray (*)(JNIEnv*, jsize)>(SleepForever),
3458 reinterpret_cast<jfloatArray (*)(JNIEnv*, jsize)>(SleepForever),
3459 reinterpret_cast<jdoubleArray (*)(JNIEnv*, jsize)>(SleepForever),
3460 reinterpret_cast<jboolean* (*)(JNIEnv*, jbooleanArray, jboolean*)>(SleepForever),
3461 reinterpret_cast<jbyte* (*)(JNIEnv*, jbyteArray, jboolean*)>(SleepForever),
3462 reinterpret_cast<jchar* (*)(JNIEnv*, jcharArray, jboolean*)>(SleepForever),
3463 reinterpret_cast<jshort* (*)(JNIEnv*, jshortArray, jboolean*)>(SleepForever),
3464 reinterpret_cast<jint* (*)(JNIEnv*, jintArray, jboolean*)>(SleepForever),
3465 reinterpret_cast<jlong* (*)(JNIEnv*, jlongArray, jboolean*)>(SleepForever),
3466 reinterpret_cast<jfloat* (*)(JNIEnv*, jfloatArray, jboolean*)>(SleepForever),
3467 reinterpret_cast<jdouble* (*)(JNIEnv*, jdoubleArray, jboolean*)>(SleepForever),
3468 reinterpret_cast<void (*)(JNIEnv*, jbooleanArray, jboolean*, jint)>(SleepForever),
3469 reinterpret_cast<void (*)(JNIEnv*, jbyteArray, jbyte*, jint)>(SleepForever),
3470 reinterpret_cast<void (*)(JNIEnv*, jcharArray, jchar*, jint)>(SleepForever),
3471 reinterpret_cast<void (*)(JNIEnv*, jshortArray, jshort*, jint)>(SleepForever),
3472 reinterpret_cast<void (*)(JNIEnv*, jintArray, jint*, jint)>(SleepForever),
3473 reinterpret_cast<void (*)(JNIEnv*, jlongArray, jlong*, jint)>(SleepForever),
3474 reinterpret_cast<void (*)(JNIEnv*, jfloatArray, jfloat*, jint)>(SleepForever),
3475 reinterpret_cast<void (*)(JNIEnv*, jdoubleArray, jdouble*, jint)>(SleepForever),
3476 reinterpret_cast<void (*)(JNIEnv*, jbooleanArray, jsize, jsize, jboolean*)>(SleepForever),
3477 reinterpret_cast<void (*)(JNIEnv*, jbyteArray, jsize, jsize, jbyte*)>(SleepForever),
3478 reinterpret_cast<void (*)(JNIEnv*, jcharArray, jsize, jsize, jchar*)>(SleepForever),
3479 reinterpret_cast<void (*)(JNIEnv*, jshortArray, jsize, jsize, jshort*)>(SleepForever),
3480 reinterpret_cast<void (*)(JNIEnv*, jintArray, jsize, jsize, jint*)>(SleepForever),
3481 reinterpret_cast<void (*)(JNIEnv*, jlongArray, jsize, jsize, jlong*)>(SleepForever),
3482 reinterpret_cast<void (*)(JNIEnv*, jfloatArray, jsize, jsize, jfloat*)>(SleepForever),
3483 reinterpret_cast<void (*)(JNIEnv*, jdoubleArray, jsize, jsize, jdouble*)>(SleepForever),
3484 reinterpret_cast<void (*)(JNIEnv*, jbooleanArray, jsize, jsize, const jboolean*)>(SleepForever),
3485 reinterpret_cast<void (*)(JNIEnv*, jbyteArray, jsize, jsize, const jbyte*)>(SleepForever),
3486 reinterpret_cast<void (*)(JNIEnv*, jcharArray, jsize, jsize, const jchar*)>(SleepForever),
3487 reinterpret_cast<void (*)(JNIEnv*, jshortArray, jsize, jsize, const jshort*)>(SleepForever),
3488 reinterpret_cast<void (*)(JNIEnv*, jintArray, jsize, jsize, const jint*)>(SleepForever),
3489 reinterpret_cast<void (*)(JNIEnv*, jlongArray, jsize, jsize, const jlong*)>(SleepForever),
3490 reinterpret_cast<void (*)(JNIEnv*, jfloatArray, jsize, jsize, const jfloat*)>(SleepForever),
3491 reinterpret_cast<void (*)(JNIEnv*, jdoubleArray, jsize, jsize, const jdouble*)>(SleepForever),
3492 reinterpret_cast<jint (*)(JNIEnv*, jclass, const JNINativeMethod*, jint)>(SleepForever),
3493 reinterpret_cast<jint (*)(JNIEnv*, jclass)>(SleepForever),
3494 reinterpret_cast<jint (*)(JNIEnv*, jobject)>(SleepForever),
3495 reinterpret_cast<jint (*)(JNIEnv*, jobject)>(SleepForever),
3496 reinterpret_cast<jint (*)(JNIEnv*, JavaVM**)>(SleepForever),
3497 reinterpret_cast<void (*)(JNIEnv*, jstring, jsize, jsize, jchar*)>(SleepForever),
3498 reinterpret_cast<void (*)(JNIEnv*, jstring, jsize, jsize, char*)>(SleepForever),
3499 reinterpret_cast<void* (*)(JNIEnv*, jarray, jboolean*)>(SleepForever),
3500 reinterpret_cast<void (*)(JNIEnv*, jarray, void*, jint)>(SleepForever),
3501 reinterpret_cast<const jchar* (*)(JNIEnv*, jstring, jboolean*)>(SleepForever),
3502 reinterpret_cast<void (*)(JNIEnv*, jstring, const jchar*)>(SleepForever),
3503 reinterpret_cast<jweak (*)(JNIEnv*, jobject)>(SleepForever),
3504 reinterpret_cast<void (*)(JNIEnv*, jweak)>(SleepForever),
3505 reinterpret_cast<jboolean (*)(JNIEnv*)>(SleepForever),
3506 reinterpret_cast<jobject (*)(JNIEnv*, void*, jlong)>(SleepForever),
3507 reinterpret_cast<void* (*)(JNIEnv*, jobject)>(SleepForever),
3508 reinterpret_cast<jlong (*)(JNIEnv*, jobject)>(SleepForever),
3509 reinterpret_cast<jobjectRefType (*)(JNIEnv*, jobject)>(SleepForever),
3510 };
3511
GetRuntimeShutdownNativeInterface()3512 const JNINativeInterface* GetRuntimeShutdownNativeInterface() {
3513 return &gJniSleepForeverStub;
3514 }
3515
3516 } // namespace art
3517
operator <<(std::ostream & os,const jobjectRefType & rhs)3518 std::ostream& operator<<(std::ostream& os, const jobjectRefType& rhs) {
3519 switch (rhs) {
3520 case JNIInvalidRefType:
3521 os << "JNIInvalidRefType";
3522 return os;
3523 case JNILocalRefType:
3524 os << "JNILocalRefType";
3525 return os;
3526 case JNIGlobalRefType:
3527 os << "JNIGlobalRefType";
3528 return os;
3529 case JNIWeakGlobalRefType:
3530 os << "JNIWeakGlobalRefType";
3531 return os;
3532 default:
3533 LOG(FATAL) << "jobjectRefType[" << static_cast<int>(rhs) << "]";
3534 UNREACHABLE();
3535 }
3536 }
3537