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 <memory>
18 #include <type_traits>
19
20 #include <math.h>
21
22 #include "art_method-inl.h"
23 #include "base/bit_utils.h"
24 #include "base/casts.h"
25 #include "base/macros.h"
26 #include "base/mem_map.h"
27 #include "class_linker.h"
28 #include "common_compiler_test.h"
29 #include "compiler.h"
30 #include "dex/dex_file.h"
31 #include "driver/compiler_options.h"
32 #include "entrypoints/entrypoint_utils-inl.h"
33 #include "gtest/gtest.h"
34 #include "indirect_reference_table.h"
35 #include "java_frame_root_info.h"
36 #include "jni/java_vm_ext.h"
37 #include "jni/jni_internal.h"
38 #include "mirror/class-inl.h"
39 #include "mirror/class_loader.h"
40 #include "mirror/object-inl.h"
41 #include "mirror/object_array-inl.h"
42 #include "mirror/stack_trace_element-inl.h"
43 #include "nativehelper/ScopedLocalRef.h"
44 #include "nativeloader/native_loader.h"
45 #include "oat_quick_method_header.h"
46 #include "runtime.h"
47 #include "scoped_thread_state_change-inl.h"
48 #include "thread-inl.h"
49
Java_MyClassNatives_bar(JNIEnv *,jobject,jint count)50 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_bar(JNIEnv*, jobject, jint count) {
51 return count + 1;
52 }
53
54 // Note: JNI name mangling "_" -> "_1".
Java_MyClassNatives_bar_1Fast(JNIEnv *,jobject,jint count)55 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_bar_1Fast(JNIEnv*, jobject, jint count) {
56 return count + 1;
57 }
58
Java_MyClassNatives_sbar(JNIEnv *,jclass,jint count)59 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_sbar(JNIEnv*, jclass, jint count) {
60 return count + 1;
61 }
62
63 // Note: JNI name mangling "_" -> "_1".
Java_MyClassNatives_sbar_1Fast(JNIEnv *,jclass,jint count)64 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_sbar_1Fast(JNIEnv*, jclass, jint count) {
65 return count + 1;
66 }
67
68 // Note: JNI name mangling "_" -> "_1".
Java_MyClassNatives_sbar_1Critical(jint count)69 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_sbar_1Critical(jint count) {
70 return count + 1;
71 }
72
73 // TODO: In the Baker read barrier configuration, add checks to ensure
74 // the Marking Register's value is correct.
75
76 namespace art HIDDEN {
77
78 enum class JniKind {
79 kNormal, // Regular kind of un-annotated natives.
80 kFast, // Native method annotated with @FastNative.
81 kCritical, // Native method annotated with @CriticalNative.
82 kCount // How many different types of JNIs we can have.
83 };
84
85 // Used to initialize array sizes that want to have different state per current jni.
86 static constexpr size_t kJniKindCount = static_cast<size_t>(JniKind::kCount);
87 // Do not use directly, use the helpers instead.
88 uint32_t gCurrentJni = static_cast<uint32_t>(JniKind::kNormal);
89
90 // Is the current native method under test @CriticalNative?
IsCurrentJniCritical()91 static bool IsCurrentJniCritical() {
92 return gCurrentJni == static_cast<uint32_t>(JniKind::kCritical);
93 }
94
95 // Is the current native method under test @FastNative?
IsCurrentJniFast()96 static bool IsCurrentJniFast() {
97 return gCurrentJni == static_cast<uint32_t>(JniKind::kFast);
98 }
99
100 // Is the current native method a plain-old non-annotated native?
IsCurrentJniNormal()101 static bool IsCurrentJniNormal() {
102 return gCurrentJni == static_cast<uint32_t>(JniKind::kNormal);
103 }
104
105 // Signify that a different kind of JNI is about to be tested.
UpdateCurrentJni(JniKind kind)106 static void UpdateCurrentJni(JniKind kind) {
107 gCurrentJni = static_cast<uint32_t>(kind);
108 }
109
110 // (Match the name suffixes of native methods in MyClassNatives.java)
CurrentJniStringSuffix()111 static std::string CurrentJniStringSuffix() {
112 switch (gCurrentJni) {
113 case static_cast<uint32_t>(JniKind::kNormal): {
114 return "";
115 }
116 case static_cast<uint32_t>(JniKind::kFast): {
117 return "_Fast";
118 }
119 case static_cast<uint32_t>(JniKind::kCritical): {
120 return "_Critical";
121 }
122 default:
123 LOG(FATAL) << "Invalid current JNI value: " << gCurrentJni;
124 UNREACHABLE();
125 }
126 }
127
128 // Fake values passed to our JNI handlers when we enter @CriticalNative.
129 // Normally @CriticalNative calling convention strips out the "JNIEnv*, jclass" parameters.
130 // However to avoid duplicating every single test method we have a templated handler
131 // that inserts fake parameters (0,1) to make it compatible with a regular JNI handler.
132 static JNIEnv* const kCriticalFakeJniEnv = reinterpret_cast<JNIEnv*>(0xDEADFEAD);
133 static jclass const kCriticalFakeJniClass = reinterpret_cast<jclass>(0xBEAFBEEF);
134
135 // Type trait. Returns true if "T" is the same type as one of the types in Args...
136 //
137 // Logically equal to OR(std::same_type<T, U> for all U in Args).
138 template <typename T, typename ... Args>
139 struct is_any_of;
140
141 template <typename T, typename U, typename ... Args>
142 struct is_any_of<T, U, Args ...> {
143 using value_type = bool;
144 static constexpr const bool value = std::is_same<T, U>::value || is_any_of<T, Args ...>::value;
145 };
146
147 template <typename T, typename U>
148 struct is_any_of<T, U> {
149 using value_type = bool;
150 static constexpr const bool value = std::is_same<T, U>::value;
151 };
152
153 // Type traits for JNI types.
154 template <typename T>
155 struct jni_type_traits {
156 // True if type T ends up holding an object reference. False otherwise.
157 // (Non-JNI types will also be false).
158 static constexpr const bool is_ref =
159 is_any_of<T, jclass, jobject, jstring, jobjectArray, jintArray,
160 jcharArray, jfloatArray, jshortArray, jdoubleArray, jlongArray>::value;
161 };
162
163 // Base case: No parameters = 0 refs.
count_nonnull_refs_helper()164 size_t count_nonnull_refs_helper() {
165 return 0;
166 }
167
168 // SFINAE for ref types. 1 if non-null, 0 otherwise.
169 template <typename T>
count_nonnull_refs_single_helper(T arg,typename std::enable_if<jni_type_traits<T>::is_ref>::type * =nullptr)170 size_t count_nonnull_refs_single_helper(T arg,
171 typename std::enable_if<jni_type_traits<T>::is_ref>::type*
172 = nullptr) {
173 return ((arg == NULL) ? 0 : 1);
174 }
175
176 // SFINAE for non-ref-types. Always 0.
177 template <typename T>
count_nonnull_refs_single_helper(T arg ATTRIBUTE_UNUSED,typename std::enable_if<!jni_type_traits<T>::is_ref>::type * =nullptr)178 size_t count_nonnull_refs_single_helper(T arg ATTRIBUTE_UNUSED,
179 typename std::enable_if<!jni_type_traits<T>::is_ref>::type*
180 = nullptr) {
181 return 0;
182 }
183
184 // Recursive case.
185 template <typename T, typename ... Args>
count_nonnull_refs_helper(T arg,Args...args)186 size_t count_nonnull_refs_helper(T arg, Args ... args) {
187 return count_nonnull_refs_single_helper(arg) + count_nonnull_refs_helper(args...);
188 }
189
190 // Given any list of parameters, check how many object refs there are and only count
191 // them if their runtime value is non-null.
192 //
193 // For example given (jobject, jint, jclass) we can get (2) if both #0/#2 are non-null,
194 // (1) if either #0/#2 are null but not both, and (0) if all parameters are null.
195 // Primitive parameters (including JNIEnv*, if present) are ignored.
196 template <typename ... Args>
count_nonnull_refs(Args...args)197 size_t count_nonnull_refs(Args ... args) {
198 return count_nonnull_refs_helper(args...);
199 }
200
201 template <typename T, T* fn>
202 struct remove_extra_parameters_helper;
203
204 template <typename R, typename Arg1, typename Arg2, typename ... Args, R (*fn)(Arg1, Arg2, Args...)>
205 struct remove_extra_parameters_helper<R(Arg1, Arg2, Args...), fn> {
206 // Note: Do not use Args&& here to maintain C-style parameter types.
applyart::remove_extra_parameters_helper207 static R apply(Args... args) {
208 JNIEnv* env = kCriticalFakeJniEnv;
209 jclass kls = kCriticalFakeJniClass;
210 return fn(env, kls, args...);
211 }
212 };
213
214 // Given a function 'fn' create a function 'apply' which will omit the JNIEnv/jklass parameters
215 //
216 // i.e. if fn(JNIEnv*,jklass,a,b,c,d,e...) then apply(a,b,c,d,e,...)
217 template <typename T, T* fn>
218 struct jni_remove_extra_parameters : public remove_extra_parameters_helper<T, fn> {};
219
220 class JniCompilerTest : public CommonCompilerTest {
221 protected:
SetUp()222 void SetUp() override {
223 CommonCompilerTest::SetUp();
224 check_generic_jni_ = false;
225 }
226
TearDown()227 void TearDown() override {
228 android::ResetNativeLoader();
229 CommonCompilerTest::TearDown();
230 }
231
SetCheckGenericJni(bool generic)232 void SetCheckGenericJni(bool generic) {
233 check_generic_jni_ = generic;
234 }
235
236 private:
CompileForTest(jobject class_loader,bool direct,const char * method_name,const char * method_sig)237 void CompileForTest(jobject class_loader,
238 bool direct,
239 const char* method_name,
240 const char* method_sig) {
241 Thread* self = Thread::Current();
242 ScopedObjectAccess soa(self);
243 StackHandleScope<2> hs(self);
244 Handle<mirror::ClassLoader> loader(
245 hs.NewHandle(soa.Decode<mirror::ClassLoader>(class_loader)));
246 // Compile the native method before starting the runtime
247 Handle<mirror::Class> c =
248 hs.NewHandle(class_linker_->FindClass(self, "LMyClassNatives;", loader));
249 const auto pointer_size = class_linker_->GetImagePointerSize();
250 ArtMethod* method = c->FindClassMethod(method_name, method_sig, pointer_size);
251 ASSERT_TRUE(method != nullptr) << method_name << " " << method_sig;
252 ASSERT_EQ(direct, method->IsDirect()) << method_name << " " << method_sig;
253 if (direct) {
254 // Class initialization could replace the entrypoint, so force
255 // the initialization before we set up the entrypoint below.
256 class_linker_->EnsureInitialized(
257 self, c, /*can_init_fields=*/ true, /*can_init_parents=*/ true);
258 {
259 ScopedThreadSuspension sts(self, ThreadState::kNative);
260 class_linker_->MakeInitializedClassesVisiblyInitialized(self, /*wait=*/ true);
261 }
262 }
263 if (check_generic_jni_) {
264 method->SetEntryPointFromQuickCompiledCode(class_linker_->GetRuntimeQuickGenericJniStub());
265 } else {
266 const void* code = method->GetEntryPointFromQuickCompiledCode();
267 if (code == nullptr || class_linker_->IsQuickGenericJniStub(code)) {
268 CompileMethod(method);
269 ASSERT_TRUE(method->GetEntryPointFromQuickCompiledCode() != nullptr)
270 << method_name << " " << method_sig;
271 }
272 }
273 }
274
275 protected:
CompileForTestWithCurrentJni(jobject class_loader,bool direct,const char * method_name_orig,const char * method_sig)276 void CompileForTestWithCurrentJni(jobject class_loader,
277 bool direct,
278 const char* method_name_orig,
279 const char* method_sig) {
280 // Append the JNI kind to the method name, so that we automatically get the
281 // fast or critical versions of the same method.
282 std::string method_name_str = std::string(method_name_orig) + CurrentJniStringSuffix();
283 const char* method_name = method_name_str.c_str();
284
285 CompileForTest(class_loader, direct, method_name, method_sig);
286 }
287
SetUpForTest(bool direct,const char * method_name_orig,const char * method_sig,void * native_fnptr)288 void SetUpForTest(bool direct,
289 const char* method_name_orig,
290 const char* method_sig,
291 void* native_fnptr) {
292 // Append the JNI kind to the method name, so that we automatically get the
293 // fast or critical versions of the same method.
294 std::string method_name_str = std::string(method_name_orig) + CurrentJniStringSuffix();
295 const char* method_name = method_name_str.c_str();
296
297 // Initialize class loader and compile method when runtime not started.
298 if (!runtime_->IsStarted()) {
299 {
300 ScopedObjectAccess soa(Thread::Current());
301 class_loader_ = LoadDex("MyClassNatives");
302 }
303 CompileForTest(class_loader_, direct, method_name, method_sig);
304 // Start runtime.
305 Thread::Current()->TransitionFromSuspendedToRunnable();
306 android::InitializeNativeLoader();
307 bool started = runtime_->Start();
308 CHECK(started);
309 }
310 // JNI operations after runtime start.
311 env_ = Thread::Current()->GetJniEnv();
312 jklass_ = env_->FindClass("MyClassNatives");
313 ASSERT_TRUE(jklass_ != nullptr) << method_name << " " << method_sig;
314
315 if (direct) {
316 jmethod_ = env_->GetStaticMethodID(jklass_, method_name, method_sig);
317 } else {
318 jmethod_ = env_->GetMethodID(jklass_, method_name, method_sig);
319 }
320 ASSERT_TRUE(jmethod_ != nullptr) << method_name << " " << method_sig;
321
322 // Make sure the test class is visibly initialized so that the RegisterNatives() below
323 // sets the JNI entrypoint rather than leaving it as null (this test pretends to be an
324 // AOT compiler and therefore the ClassLinker skips entrypoint initialization). Even
325 // if the ClassLinker initialized it with a stub, we would not want to test that here.
326 class_linker_->MakeInitializedClassesVisiblyInitialized(Thread::Current(), /*wait=*/ true);
327
328 if (native_fnptr != nullptr) {
329 JNINativeMethod methods[] = { { method_name, method_sig, native_fnptr } };
330 ASSERT_EQ(JNI_OK, env_->RegisterNatives(jklass_, methods, 1))
331 << method_name << " " << method_sig;
332 } else {
333 env_->UnregisterNatives(jklass_);
334 }
335
336 jmethodID constructor = env_->GetMethodID(jklass_, "<init>", "()V");
337 jobj_ = env_->NewObject(jklass_, constructor);
338 ASSERT_TRUE(jobj_ != nullptr) << method_name << " " << method_sig;
339 }
340
341 public:
342 // Available as statics so our JNI handlers can access these.
343 static jclass jklass_;
344 static jobject jobj_;
345 static jobject class_loader_;
346
347 static void AssertCallerObjectLocked(JNIEnv* env);
348
349 static LockWord GetLockWord(jobject obj);
350
351 protected:
352 // We have to list the methods here so we can share them between default and generic JNI.
353 void CompileAndRunNoArgMethodImpl();
354 void CompileAndRunIntMethodThroughStubImpl();
355 void CompileAndRunStaticIntMethodThroughStubImpl();
356 void CompileAndRunIntMethodImpl();
357 void CompileAndRunIntIntMethodImpl();
358 void CompileAndRunLongLongMethodImpl();
359 void CompileAndRunDoubleDoubleMethodImpl();
360 void CompileAndRun_fooJJ_synchronizedImpl();
361 void CompileAndRunIntObjectObjectMethodImpl();
362 void CompileAndRunStaticIntIntMethodImpl();
363 void CompileAndRunStaticDoubleDoubleMethodImpl();
364 void RunStaticLogDoubleMethodImpl();
365 void RunStaticLogFloatMethodImpl();
366 void RunStaticReturnTrueImpl();
367 void RunStaticReturnFalseImpl();
368 void RunGenericStaticReturnIntImpl();
369 void RunGenericStaticReturnDoubleImpl();
370 void RunGenericStaticReturnLongImpl();
371 void CompileAndRunStaticIntObjectObjectMethodImpl();
372 void CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl();
373 void ExceptionHandlingImpl();
374 void NativeStackTraceElementImpl();
375 void ReturnGlobalRefImpl();
376 void LocalReferenceTableClearingTestImpl();
377 void JavaLangSystemArrayCopyImpl();
378 void CompareAndSwapIntImpl();
379 void GetTextImpl();
380 void GetSinkPropertiesNativeImpl();
381 void UpcallReturnTypeChecking_InstanceImpl();
382 void UpcallReturnTypeChecking_StaticImpl();
383 void UpcallArgumentTypeChecking_InstanceImpl();
384 void UpcallArgumentTypeChecking_StaticImpl();
385 void CompileAndRunFloatFloatMethodImpl();
386 void CheckParameterAlignImpl();
387 void MaxParamNumberImpl();
388 void WithoutImplementationImpl();
389 void WithoutImplementationRefReturnImpl();
390 void StaticWithoutImplementationImpl();
391 void StackArgsIntsFirstImpl();
392 void StackArgsFloatsFirstImpl();
393 void StackArgsMixedImpl();
394
395 void NormalNativeImpl();
396 void FastNativeImpl();
397 void CriticalNativeImpl();
398
399 JNIEnv* env_;
400 jmethodID jmethod_;
401
402 private:
403 bool check_generic_jni_;
404 };
405
406 jclass JniCompilerTest::jklass_;
407 jobject JniCompilerTest::jobj_;
408 jobject JniCompilerTest::class_loader_;
409
AssertCallerObjectLocked(JNIEnv * env)410 void JniCompilerTest::AssertCallerObjectLocked(JNIEnv* env) {
411 Thread* self = Thread::ForEnv(env);
412 CHECK_EQ(self, Thread::Current());
413 ScopedObjectAccess soa(self);
414 ArtMethod** caller_frame = self->GetManagedStack()->GetTopQuickFrame();
415 CHECK(caller_frame != nullptr);
416 ArtMethod* caller = *caller_frame;
417 CHECK(caller != nullptr);
418 CHECK(caller->IsNative());
419 CHECK(!caller->IsFastNative());
420 CHECK(!caller->IsCriticalNative());
421 CHECK(caller->IsSynchronized());
422 ObjPtr<mirror::Object> lock;
423 if (self->GetManagedStack()->GetTopQuickFrameGenericJniTag()) {
424 // Generic JNI.
425 lock = GetGenericJniSynchronizationObject(self, caller);
426 } else if (caller->IsStatic()) {
427 lock = caller->GetDeclaringClass();
428 } else {
429 uint8_t* sp = reinterpret_cast<uint8_t*>(caller_frame);
430 const void* code_ptr = EntryPointToCodePointer(caller->GetEntryPointFromQuickCompiledCode());
431 OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromCodePointer(code_ptr);
432 size_t frame_size = method_header->GetFrameSizeInBytes();
433 StackReference<mirror::Object>* this_ref = reinterpret_cast<StackReference<mirror::Object>*>(
434 sp + frame_size + static_cast<size_t>(kRuntimePointerSize));
435 lock = this_ref->AsMirrorPtr();
436 }
437 CHECK_EQ(Monitor::GetLockOwnerThreadId(lock), self->GetThreadId());
438 }
439
GetLockWord(jobject obj)440 LockWord JniCompilerTest::GetLockWord(jobject obj) {
441 ScopedObjectAccess soa(Thread::Current());
442 return soa.Decode<mirror::Object>(obj)->GetLockWord(/*as_volatile=*/ false);
443 }
444
445 // Test the normal compiler and normal generic JNI only.
446 // The following features are unsupported in @FastNative:
447 // 1) synchronized keyword
448 # define JNI_TEST_NORMAL_ONLY(TestName) \
449 TEST_F(JniCompilerTest, TestName ## NormalCompiler) { \
450 ScopedCheckHandleScope top_handle_scope_check; \
451 SCOPED_TRACE("Normal JNI with compiler"); \
452 gCurrentJni = static_cast<uint32_t>(JniKind::kNormal); \
453 TestName ## Impl(); \
454 } \
455 TEST_F(JniCompilerTest, TestName ## NormalGeneric) { \
456 ScopedCheckHandleScope top_handle_scope_check; \
457 SCOPED_TRACE("Normal JNI with generic"); \
458 gCurrentJni = static_cast<uint32_t>(JniKind::kNormal); \
459 SetCheckGenericJni(true); \
460 TestName ## Impl(); \
461 }
462
463 // Test (normal, @FastNative) x (compiler, generic).
464 #define JNI_TEST(TestName) \
465 JNI_TEST_NORMAL_ONLY(TestName) \
466 TEST_F(JniCompilerTest, TestName ## FastCompiler) { \
467 ScopedCheckHandleScope top_handle_scope_check; \
468 SCOPED_TRACE("@FastNative JNI with compiler"); \
469 gCurrentJni = static_cast<uint32_t>(JniKind::kFast); \
470 TestName ## Impl(); \
471 } \
472 \
473 TEST_F(JniCompilerTest, TestName ## FastGeneric) { \
474 ScopedCheckHandleScope top_handle_scope_check; \
475 SCOPED_TRACE("@FastNative JNI with generic"); \
476 gCurrentJni = static_cast<uint32_t>(JniKind::kFast); \
477 SetCheckGenericJni(true); \
478 TestName ## Impl(); \
479 }
480
481 // Test (@CriticalNative) x (compiler, generic) only.
482 #define JNI_TEST_CRITICAL_ONLY(TestName) \
483 TEST_F(JniCompilerTest, TestName ## CriticalCompiler) { \
484 ScopedCheckHandleScope top_handle_scope_check; \
485 SCOPED_TRACE("@CriticalNative JNI with compiler"); \
486 gCurrentJni = static_cast<uint32_t>(JniKind::kCritical); \
487 TestName ## Impl(); \
488 } \
489 TEST_F(JniCompilerTest, TestName ## CriticalGeneric) { \
490 ScopedCheckHandleScope top_handle_scope_check; \
491 SCOPED_TRACE("@CriticalNative JNI with generic"); \
492 gCurrentJni = static_cast<uint32_t>(JniKind::kCritical); \
493 SetCheckGenericJni(true); \
494 TestName ## Impl(); \
495 }
496
497 // Test everything: (normal, @FastNative, @CriticalNative) x (compiler, generic).
498 #define JNI_TEST_CRITICAL(TestName) \
499 JNI_TEST(TestName) \
500 JNI_TEST_CRITICAL_ONLY(TestName) \
501
expectValidThreadState()502 static void expectValidThreadState() {
503 // Normal JNI always transitions to "Native". Other JNIs stay in the "Runnable" state.
504 if (IsCurrentJniNormal()) {
505 EXPECT_EQ(ThreadState::kNative, Thread::Current()->GetState());
506 } else {
507 EXPECT_EQ(ThreadState::kRunnable, Thread::Current()->GetState());
508 }
509 }
510
511 #define EXPECT_THREAD_STATE_FOR_CURRENT_JNI() expectValidThreadState()
512
expectValidMutatorLockHeld()513 static void expectValidMutatorLockHeld() {
514 if (IsCurrentJniNormal()) {
515 Locks::mutator_lock_->AssertNotHeld(Thread::Current());
516 } else {
517 Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
518 }
519 }
520
521 #define EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI() expectValidMutatorLockHeld()
522
expectValidJniEnvAndObject(JNIEnv * env,jobject thisObj)523 static void expectValidJniEnvAndObject(JNIEnv* env, jobject thisObj) {
524 if (!IsCurrentJniCritical()) {
525 EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
526 ASSERT_TRUE(thisObj != nullptr);
527 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
528 } else {
529 LOG(FATAL) << "Objects are not supported for @CriticalNative, why is this being tested?";
530 UNREACHABLE();
531 }
532 }
533
534 // Validates the JNIEnv to be the same as the current thread's JNIEnv, and makes sure
535 // that the object here is an instance of the class we registered the method with.
536 //
537 // Hard-fails if this somehow gets invoked for @CriticalNative since objects are unsupported.
538 #define EXPECT_JNI_ENV_AND_OBJECT_FOR_CURRENT_JNI(env, thisObj) \
539 expectValidJniEnvAndObject(env, thisObj)
540
expectValidJniEnvAndClass(JNIEnv * env,jclass kls)541 static void expectValidJniEnvAndClass(JNIEnv* env, jclass kls) {
542 if (!IsCurrentJniCritical()) {
543 EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
544 ASSERT_TRUE(kls != nullptr);
545 EXPECT_TRUE(env->IsSameObject(static_cast<jobject>(JniCompilerTest::jklass_),
546 static_cast<jobject>(kls)));
547 } else {
548 // This is pretty much vacuously true but catch any testing setup mistakes.
549 EXPECT_EQ(env, kCriticalFakeJniEnv);
550 EXPECT_EQ(kls, kCriticalFakeJniClass);
551 }
552 }
553
554 // Validates the JNIEnv is the same as the current thread's JNIenv, and makes sure
555 // that the jclass we got in the JNI handler is the same one as the class the method was looked
556 // up for.
557 //
558 // (Checks are skipped for @CriticalNative since the two values are fake).
559 #define EXPECT_JNI_ENV_AND_CLASS_FOR_CURRENT_JNI(env, kls) expectValidJniEnvAndClass(env, kls)
560
561 // Temporarily disable the EXPECT_NUM_STACK_REFERENCES check (for a single test).
562 struct ScopedDisableCheckNumStackReferences {
ScopedDisableCheckNumStackReferencesart::ScopedDisableCheckNumStackReferences563 ScopedDisableCheckNumStackReferences() {
564 CHECK(sCheckNumStackReferences); // No nested support.
565 sCheckNumStackReferences = false;
566 }
567
~ScopedDisableCheckNumStackReferencesart::ScopedDisableCheckNumStackReferences568 ~ScopedDisableCheckNumStackReferences() {
569 sCheckNumStackReferences = true;
570 }
571
572 static bool sCheckNumStackReferences;
573 };
574
575 bool ScopedDisableCheckNumStackReferences::sCheckNumStackReferences = true;
576
577 // Check that the handle scope at the start of this block is the same
578 // as the handle scope at the end of the block.
579 struct ScopedCheckHandleScope {
ScopedCheckHandleScopeart::ScopedCheckHandleScope580 ScopedCheckHandleScope() : handle_scope_(Thread::Current()->GetTopHandleScope()) {
581 }
582
~ScopedCheckHandleScopeart::ScopedCheckHandleScope583 ~ScopedCheckHandleScope() {
584 EXPECT_EQ(handle_scope_, Thread::Current()->GetTopHandleScope())
585 << "Top-most handle scope must be the same after all the JNI "
586 << "invocations have finished (as before they were invoked).";
587 }
588
589 BaseHandleScope* const handle_scope_;
590 };
591
592 class CountReferencesVisitor : public RootVisitor {
593 public:
VisitRoots(mirror::Object *** roots ATTRIBUTE_UNUSED,size_t count,const RootInfo & info)594 void VisitRoots(mirror::Object*** roots ATTRIBUTE_UNUSED,
595 size_t count,
596 const RootInfo& info) override
597 REQUIRES_SHARED(Locks::mutator_lock_) {
598 if (info.GetType() == art::RootType::kRootJavaFrame) {
599 const JavaFrameRootInfo& jrfi = static_cast<const JavaFrameRootInfo&>(info);
600 if (jrfi.GetVReg() == JavaFrameRootInfo::kNativeReferenceArgument) {
601 DCHECK_EQ(count, 1u);
602 num_references_ += count;
603 }
604 }
605 }
606
VisitRoots(mirror::CompressedReference<mirror::Object> ** roots ATTRIBUTE_UNUSED,size_t count ATTRIBUTE_UNUSED,const RootInfo & info)607 void VisitRoots(mirror::CompressedReference<mirror::Object>** roots ATTRIBUTE_UNUSED,
608 size_t count ATTRIBUTE_UNUSED,
609 const RootInfo& info) override
610 REQUIRES_SHARED(Locks::mutator_lock_) {
611 CHECK_NE(info.GetType(), art::RootType::kRootJavaFrame);
612 }
613
NumReferences() const614 size_t NumReferences() const {
615 return num_references_;
616 }
617
618 private:
619 size_t num_references_ = 0u;
620 };
621
622 // Number of references allocated in handle scopes & JNI shadow frames on this thread.
NumStackReferences(Thread * self)623 static size_t NumStackReferences(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) {
624 CountReferencesVisitor visitor;
625 self->VisitRoots(&visitor, kVisitRootFlagAllRoots);
626 return visitor.NumReferences();
627 }
628
expectNumStackReferences(size_t expected)629 static void expectNumStackReferences(size_t expected) {
630 // In rare cases when JNI functions call themselves recursively,
631 // disable this test because it will have a false negative.
632 if (!IsCurrentJniCritical() && ScopedDisableCheckNumStackReferences::sCheckNumStackReferences) {
633 /* @CriticalNative doesn't build a HandleScope, so this test is meaningless then. */
634 ScopedObjectAccess soa(Thread::Current());
635
636 size_t num_references = NumStackReferences(Thread::Current());
637 EXPECT_EQ(expected, num_references);
638 }
639 }
640
641 #define EXPECT_NUM_STACK_REFERENCES(expected) expectNumStackReferences(expected)
642
643 template <typename T, T* fn>
644 struct make_jni_test_decorator;
645
646 // Decorator for "static" JNI callbacks.
647 template <typename R, typename ... Args, R (*fn)(JNIEnv*, jclass, Args...)>
648 struct make_jni_test_decorator<R(JNIEnv*, jclass kls, Args...), fn> {
applyart::make_jni_test_decorator649 static R apply(JNIEnv* env, jclass kls, Args ... args) {
650 EXPECT_THREAD_STATE_FOR_CURRENT_JNI();
651 EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI();
652 EXPECT_JNI_ENV_AND_CLASS_FOR_CURRENT_JNI(env, kls);
653 // All incoming parameters get spilled into the JNI transition frame.
654 // The `jclass` is just a reference to the method's declaring class field.
655 EXPECT_NUM_STACK_REFERENCES(count_nonnull_refs(args...));
656
657 return fn(env, kls, args...);
658 }
659 };
660
661 // Decorator for instance JNI callbacks.
662 template <typename R, typename ... Args, R (*fn)(JNIEnv*, jobject, Args...)>
663 struct make_jni_test_decorator<R(JNIEnv*, jobject, Args...), fn> {
applyart::make_jni_test_decorator664 static R apply(JNIEnv* env, jobject thisObj, Args ... args) {
665 EXPECT_THREAD_STATE_FOR_CURRENT_JNI();
666 EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI();
667 EXPECT_JNI_ENV_AND_OBJECT_FOR_CURRENT_JNI(env, thisObj);
668 // All incoming parameters + the implicit 'this' get spilled into the JNI transition frame.
669 EXPECT_NUM_STACK_REFERENCES(count_nonnull_refs(thisObj, args...));
670
671 return fn(env, thisObj, args...);
672 }
673 };
674
675 // Decorate the regular JNI callee with the extra gtest checks.
676 // This way we can have common test logic for everything generic like checking if a lock is held,
677 // checking handle scope state, etc.
678 #define MAKE_JNI_TEST_DECORATOR(fn) make_jni_test_decorator<decltype(fn), (fn)>::apply
679
680 // Convert function f(JNIEnv*,jclass,a,b,c,d...) into f2(a,b,c,d...)
681 // -- This way we don't have to write out each implementation twice for @CriticalNative.
682 #define JNI_CRITICAL_WRAPPER(func) jni_remove_extra_parameters<decltype(func), (func)>::apply
683 // Get a function pointer whose calling convention either matches a regular native
684 // or a critical native depending on which kind of jni is currently under test.
685 // -- This also has the benefit of genering a compile time error if the 'func' doesn't properly
686 // have JNIEnv and jclass parameters first.
687 #define CURRENT_JNI_WRAPPER(func) \
688 (IsCurrentJniCritical() \
689 ? reinterpret_cast<void*>(&JNI_CRITICAL_WRAPPER(MAKE_JNI_TEST_DECORATOR(func))) \
690 : reinterpret_cast<void*>(&MAKE_JNI_TEST_DECORATOR(func)))
691
692 // Do the opposite of the above. Do *not* wrap the function, instead just cast it to a void*.
693 // Only for "TEST_JNI_NORMAL_ONLY" configs, and it inserts a test assert to ensure this is the case.
694 #define NORMAL_JNI_ONLY_NOWRAP(func) \
695 ({ ASSERT_TRUE(IsCurrentJniNormal()); reinterpret_cast<void*>(&(func)); })
696 // Same as above, but with nullptr. When we want to test the stub functionality.
697 #define NORMAL_OR_FAST_JNI_ONLY_NULLPTR \
698 ({ ASSERT_TRUE(IsCurrentJniNormal() || IsCurrentJniFast()); nullptr; })
699
700
701 int gJava_MyClassNatives_foo_calls[kJniKindCount] = {};
Java_MyClassNatives_foo(JNIEnv *,jobject)702 void Java_MyClassNatives_foo(JNIEnv*, jobject) {
703 gJava_MyClassNatives_foo_calls[gCurrentJni]++;
704 }
705
CompileAndRunNoArgMethodImpl()706 void JniCompilerTest::CompileAndRunNoArgMethodImpl() {
707 SetUpForTest(false, "foo", "()V", CURRENT_JNI_WRAPPER(Java_MyClassNatives_foo));
708
709 EXPECT_EQ(0, gJava_MyClassNatives_foo_calls[gCurrentJni]);
710 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
711 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
712 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
713 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
714
715 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
716 }
717
JNI_TEST(CompileAndRunNoArgMethod)718 JNI_TEST(CompileAndRunNoArgMethod)
719
720 void JniCompilerTest::CompileAndRunIntMethodThroughStubImpl() {
721 SetUpForTest(false, "bar", "(I)I", NORMAL_OR_FAST_JNI_ONLY_NULLPTR);
722 // calling through stub will link with &Java_MyClassNatives_bar{,_1Fast}
723
724 std::string reason;
725 ASSERT_TRUE(Runtime::Current()->GetJavaVM()->
726 LoadNativeLibrary(env_, "", class_loader_, nullptr, &reason))
727 << reason;
728
729 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 24);
730 EXPECT_EQ(25, result);
731 }
732
733 // Note: @CriticalNative is only for static methods.
JNI_TEST(CompileAndRunIntMethodThroughStub)734 JNI_TEST(CompileAndRunIntMethodThroughStub)
735
736 void JniCompilerTest::CompileAndRunStaticIntMethodThroughStubImpl() {
737 SetUpForTest(true, "sbar", "(I)I", nullptr);
738 // calling through stub will link with &Java_MyClassNatives_sbar{,_1Fast,_1Critical}
739
740 std::string reason;
741 ASSERT_TRUE(Runtime::Current()->GetJavaVM()->
742 LoadNativeLibrary(env_, "", class_loader_, nullptr, &reason))
743 << reason;
744
745 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 42);
746 EXPECT_EQ(43, result);
747 }
748
749 JNI_TEST_CRITICAL(CompileAndRunStaticIntMethodThroughStub)
750
751 int gJava_MyClassNatives_fooI_calls[kJniKindCount] = {};
Java_MyClassNatives_fooI(JNIEnv *,jobject,jint x)752 jint Java_MyClassNatives_fooI(JNIEnv*, jobject, jint x) {
753 gJava_MyClassNatives_fooI_calls[gCurrentJni]++;
754 return x;
755 }
756
CompileAndRunIntMethodImpl()757 void JniCompilerTest::CompileAndRunIntMethodImpl() {
758 SetUpForTest(false, "fooI", "(I)I",
759 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooI));
760
761 EXPECT_EQ(0, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
762 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 42);
763 EXPECT_EQ(42, result);
764 EXPECT_EQ(1, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
765 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFED00D);
766 EXPECT_EQ(static_cast<jint>(0xCAFED00D), result);
767 EXPECT_EQ(2, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
768
769 gJava_MyClassNatives_fooI_calls[gCurrentJni] = 0;
770 }
771
772 JNI_TEST(CompileAndRunIntMethod)
773
774 int gJava_MyClassNatives_fooII_calls[kJniKindCount] = {};
Java_MyClassNatives_fooII(JNIEnv *,jobject,jint x,jint y)775 jint Java_MyClassNatives_fooII(JNIEnv*, jobject, jint x, jint y) {
776 gJava_MyClassNatives_fooII_calls[gCurrentJni]++;
777 return x - y; // non-commutative operator
778 }
779
CompileAndRunIntIntMethodImpl()780 void JniCompilerTest::CompileAndRunIntIntMethodImpl() {
781 SetUpForTest(false, "fooII", "(II)I",
782 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooII));
783
784 EXPECT_EQ(0, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
785 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 99, 10);
786 EXPECT_EQ(99 - 10, result);
787 EXPECT_EQ(1, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
788 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFEBABE,
789 0xCAFED00D);
790 EXPECT_EQ(static_cast<jint>(0xCAFEBABE - 0xCAFED00D), result);
791 EXPECT_EQ(2, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
792
793 gJava_MyClassNatives_fooII_calls[gCurrentJni] = 0;
794 }
795
796 JNI_TEST(CompileAndRunIntIntMethod)
797
798 int gJava_MyClassNatives_fooJJ_calls[kJniKindCount] = {};
Java_MyClassNatives_fooJJ(JNIEnv *,jobject,jlong x,jlong y)799 jlong Java_MyClassNatives_fooJJ(JNIEnv*, jobject, jlong x, jlong y) {
800 gJava_MyClassNatives_fooJJ_calls[gCurrentJni]++;
801 return x - y; // non-commutative operator
802 }
803
CompileAndRunLongLongMethodImpl()804 void JniCompilerTest::CompileAndRunLongLongMethodImpl() {
805 SetUpForTest(false, "fooJJ", "(JJ)J",
806 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooJJ));
807
808 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
809 jlong a = INT64_C(0x1234567890ABCDEF);
810 jlong b = INT64_C(0xFEDCBA0987654321);
811 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
812 EXPECT_EQ(a - b, result);
813 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
814 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, b, a);
815 EXPECT_EQ(b - a, result);
816 EXPECT_EQ(2, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
817
818 gJava_MyClassNatives_fooJJ_calls[gCurrentJni] = 0;
819 }
820
821 JNI_TEST(CompileAndRunLongLongMethod)
822
823 int gJava_MyClassNatives_fooDD_calls[kJniKindCount] = {};
Java_MyClassNatives_fooDD(JNIEnv *,jobject,jdouble x,jdouble y)824 jdouble Java_MyClassNatives_fooDD(JNIEnv*, jobject, jdouble x, jdouble y) {
825 gJava_MyClassNatives_fooDD_calls[gCurrentJni]++;
826 return x - y; // non-commutative operator
827 }
828
CompileAndRunDoubleDoubleMethodImpl()829 void JniCompilerTest::CompileAndRunDoubleDoubleMethodImpl() {
830 SetUpForTest(false, "fooDD", "(DD)D",
831 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooDD));
832
833 EXPECT_EQ(0, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
834 jdouble result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_,
835 99.0, 10.0);
836 EXPECT_DOUBLE_EQ(99.0 - 10.0, result);
837 EXPECT_EQ(1, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
838 jdouble a = 3.14159265358979323846;
839 jdouble b = 0.69314718055994530942;
840 result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_, a, b);
841 EXPECT_DOUBLE_EQ(a - b, result);
842 EXPECT_EQ(2, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
843
844 gJava_MyClassNatives_fooDD_calls[gCurrentJni] = 0;
845 }
846
847 int gJava_MyClassNatives_fooJJ_synchronized_calls[kJniKindCount] = {};
Java_MyClassNatives_fooJJ_synchronized(JNIEnv * env,jobject,jlong x,jlong y)848 jlong Java_MyClassNatives_fooJJ_synchronized(JNIEnv* env, jobject, jlong x, jlong y) {
849 JniCompilerTest::AssertCallerObjectLocked(env);
850 gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]++;
851 return x | y;
852 }
853
854 EXPORT // Defined in `libart.so`.
855 void InitEntryPoints(JniEntryPoints* jpoints,
856 QuickEntryPoints* qpoints,
857 bool monitor_jni_entry_exit);
858
CompileAndRun_fooJJ_synchronizedImpl()859 void JniCompilerTest::CompileAndRun_fooJJ_synchronizedImpl() {
860 SetUpForTest(false, "fooJJ_synchronized", "(JJ)J",
861 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooJJ_synchronized));
862
863 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
864 jlong a = 0x1000000020000000ULL;
865 jlong b = 0x00ff000000aa0000ULL;
866 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
867 EXPECT_EQ(a | b, result);
868 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
869
870 // Exercise recursive thin locking/unlocking.
871 // Note: Thin lock count 0 means locked once.
872 env_->MonitorEnter(jobj_);
873 LockWord lock_word = GetLockWord(jobj_);
874 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
875 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
876 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
877 EXPECT_EQ(a | b, result);
878 EXPECT_EQ(2, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
879 lock_word = GetLockWord(jobj_);
880 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
881 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
882 env_->MonitorExit(jobj_);
883 lock_word = GetLockWord(jobj_);
884 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
885
886 // Exercise lock inflation due to thin lock count overflow.
887 constexpr uint32_t kMaxThinLockRecursiveLocks = 1u << LockWord::kThinLockCountSize;
888 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
889 env_->MonitorEnter(jobj_);
890 lock_word = GetLockWord(jobj_);
891 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
892 ASSERT_EQ(lock_word.ThinLockCount(), i);
893 }
894 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
895 EXPECT_EQ(a | b, result);
896 EXPECT_EQ(3, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
897 lock_word = GetLockWord(jobj_);
898 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
899 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
900 env_->MonitorExit(jobj_); // Remains "fat-locked" even if actually unlocked.
901 }
902
903 // Exercise locking for "fat-locked".
904 lock_word = GetLockWord(jobj_);
905 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
906 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
907 EXPECT_EQ(a | b, result);
908 EXPECT_EQ(4, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
909 lock_word = GetLockWord(jobj_);
910 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
911
912 // Exercise locking/unocking for "fat-locked" through the "no_inline" path.
913 // These entrypoints are selected with verbose "systrace_lock_logging".
914 Thread* self = Thread::Current();
915 ASSERT_FALSE(gLogVerbosity.systrace_lock_logging);
916 gLogVerbosity.systrace_lock_logging = true;
917 InitEntryPoints(&self->tlsPtr_.jni_entrypoints,
918 &self->tlsPtr_.quick_entrypoints,
919 self->ReadFlag(ThreadFlag::kMonitorJniEntryExit));
920 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
921 EXPECT_EQ(a | b, result);
922 EXPECT_EQ(5, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
923 gLogVerbosity.systrace_lock_logging = false;
924 InitEntryPoints(&self->tlsPtr_.jni_entrypoints,
925 &self->tlsPtr_.quick_entrypoints,
926 self->ReadFlag(ThreadFlag::kMonitorJniEntryExit));
927
928 gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni] = 0;
929 }
930
931 JNI_TEST_NORMAL_ONLY(CompileAndRun_fooJJ_synchronized)
932
933 int gJava_MyClassNatives_fooIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooIOO(JNIEnv *,jobject thisObj,jint x,jobject y,jobject z)934 jobject Java_MyClassNatives_fooIOO(JNIEnv*, jobject thisObj, jint x, jobject y,
935 jobject z) {
936 gJava_MyClassNatives_fooIOO_calls[gCurrentJni]++;
937 switch (x) {
938 case 1:
939 return y;
940 case 2:
941 return z;
942 default:
943 return thisObj;
944 }
945 }
946
CompileAndRunIntObjectObjectMethodImpl()947 void JniCompilerTest::CompileAndRunIntObjectObjectMethodImpl() {
948 SetUpForTest(false, "fooIOO",
949 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
950 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooIOO));
951
952 EXPECT_EQ(0, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
953 jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, nullptr);
954 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
955 EXPECT_EQ(1, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
956
957 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, jklass_);
958 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
959 EXPECT_EQ(2, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
960 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, nullptr, jklass_);
961 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
962 EXPECT_EQ(3, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
963 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, nullptr, jklass_);
964 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
965 EXPECT_EQ(4, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
966
967 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, jklass_, nullptr);
968 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
969 EXPECT_EQ(5, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
970 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, jklass_, nullptr);
971 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
972 EXPECT_EQ(6, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
973 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, jklass_, nullptr);
974 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
975 EXPECT_EQ(7, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
976
977 gJava_MyClassNatives_fooIOO_calls[gCurrentJni] = 0;
978 }
979
980 JNI_TEST(CompileAndRunIntObjectObjectMethod)
981
982 int gJava_MyClassNatives_fooSII_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSII(JNIEnv * env ATTRIBUTE_UNUSED,jclass klass ATTRIBUTE_UNUSED,jint x,jint y)983 jint Java_MyClassNatives_fooSII(JNIEnv* env ATTRIBUTE_UNUSED,
984 jclass klass ATTRIBUTE_UNUSED,
985 jint x,
986 jint y) {
987 gJava_MyClassNatives_fooSII_calls[gCurrentJni]++;
988 return x + y;
989 }
990
CompileAndRunStaticIntIntMethodImpl()991 void JniCompilerTest::CompileAndRunStaticIntIntMethodImpl() {
992 SetUpForTest(true, "fooSII", "(II)I",
993 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSII));
994
995 EXPECT_EQ(0, gJava_MyClassNatives_fooSII_calls[gCurrentJni]);
996 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 20, 30);
997 EXPECT_EQ(50, result);
998 EXPECT_EQ(1, gJava_MyClassNatives_fooSII_calls[gCurrentJni]);
999
1000 gJava_MyClassNatives_fooSII_calls[gCurrentJni] = 0;
1001 }
1002
1003 JNI_TEST_CRITICAL(CompileAndRunStaticIntIntMethod)
1004
1005 int gJava_MyClassNatives_fooSDD_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSDD(JNIEnv * env ATTRIBUTE_UNUSED,jclass klass ATTRIBUTE_UNUSED,jdouble x,jdouble y)1006 jdouble Java_MyClassNatives_fooSDD(JNIEnv* env ATTRIBUTE_UNUSED,
1007 jclass klass ATTRIBUTE_UNUSED,
1008 jdouble x,
1009 jdouble y) {
1010 gJava_MyClassNatives_fooSDD_calls[gCurrentJni]++;
1011 return x - y; // non-commutative operator
1012 }
1013
CompileAndRunStaticDoubleDoubleMethodImpl()1014 void JniCompilerTest::CompileAndRunStaticDoubleDoubleMethodImpl() {
1015 SetUpForTest(true, "fooSDD", "(DD)D",
1016 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSDD));
1017
1018 EXPECT_EQ(0, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1019 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 99.0, 10.0);
1020 EXPECT_DOUBLE_EQ(99.0 - 10.0, result);
1021 EXPECT_EQ(1, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1022 jdouble a = 3.14159265358979323846;
1023 jdouble b = 0.69314718055994530942;
1024 result = env_->CallStaticDoubleMethod(jklass_, jmethod_, a, b);
1025 EXPECT_DOUBLE_EQ(a - b, result);
1026 EXPECT_DOUBLE_EQ(2, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1027
1028 gJava_MyClassNatives_fooSDD_calls[gCurrentJni] = 0;
1029 }
1030
JNI_TEST_CRITICAL(CompileAndRunStaticDoubleDoubleMethod)1031 JNI_TEST_CRITICAL(CompileAndRunStaticDoubleDoubleMethod)
1032
1033 // The x86 generic JNI code had a bug where it assumed a floating
1034 // point return value would be in xmm0. We use log, to somehow ensure
1035 // the compiler will use the floating point stack.
1036
1037 jdouble Java_MyClassNatives_logD(JNIEnv*, jclass, jdouble x) {
1038 return log(x);
1039 }
1040
Java_MyClassNatives_logD_notNormal(JNIEnv *,jclass,jdouble x)1041 jdouble Java_MyClassNatives_logD_notNormal(JNIEnv*, jclass, jdouble x) {
1042 EXPECT_DOUBLE_EQ(2.0, x);
1043 return log(x);
1044 }
1045
RunStaticLogDoubleMethodImpl()1046 void JniCompilerTest::RunStaticLogDoubleMethodImpl() {
1047 void* jni_handler;
1048 if (IsCurrentJniNormal()) {
1049 // This test seems a bit special, don't use a JNI wrapper here.
1050 jni_handler = NORMAL_JNI_ONLY_NOWRAP(Java_MyClassNatives_logD);
1051 } else {
1052 jni_handler = CURRENT_JNI_WRAPPER(Java_MyClassNatives_logD_notNormal);
1053 }
1054 SetUpForTest(true, "logD", "(D)D", jni_handler);
1055
1056 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 2.0);
1057 EXPECT_DOUBLE_EQ(log(2.0), result);
1058 }
1059
JNI_TEST_CRITICAL(RunStaticLogDoubleMethod)1060 JNI_TEST_CRITICAL(RunStaticLogDoubleMethod)
1061
1062 jfloat Java_MyClassNatives_logF(JNIEnv*, jclass, jfloat x) {
1063 return logf(x);
1064 }
1065
RunStaticLogFloatMethodImpl()1066 void JniCompilerTest::RunStaticLogFloatMethodImpl() {
1067 void* jni_handler;
1068 if (IsCurrentJniNormal()) {
1069 // This test seems a bit special, don't use a JNI wrapper here.
1070 jni_handler = NORMAL_JNI_ONLY_NOWRAP(Java_MyClassNatives_logF);
1071 } else {
1072 jni_handler = CURRENT_JNI_WRAPPER(Java_MyClassNatives_logF);
1073 }
1074
1075 SetUpForTest(true, "logF", "(F)F", jni_handler);
1076
1077 jfloat result = env_->CallStaticFloatMethod(jklass_, jmethod_, 2.0);
1078 EXPECT_FLOAT_EQ(logf(2.0), result);
1079 }
1080
JNI_TEST_CRITICAL(RunStaticLogFloatMethod)1081 JNI_TEST_CRITICAL(RunStaticLogFloatMethod)
1082
1083 jboolean Java_MyClassNatives_returnTrue(JNIEnv*, jclass) {
1084 return JNI_TRUE;
1085 }
1086
Java_MyClassNatives_returnFalse(JNIEnv *,jclass)1087 jboolean Java_MyClassNatives_returnFalse(JNIEnv*, jclass) {
1088 return JNI_FALSE;
1089 }
1090
Java_MyClassNatives_returnInt(JNIEnv *,jclass)1091 jint Java_MyClassNatives_returnInt(JNIEnv*, jclass) {
1092 return 42;
1093 }
1094
RunStaticReturnTrueImpl()1095 void JniCompilerTest::RunStaticReturnTrueImpl() {
1096 SetUpForTest(true, "returnTrue", "()Z", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnTrue));
1097
1098 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_);
1099 EXPECT_TRUE(result);
1100 }
1101
JNI_TEST_CRITICAL(RunStaticReturnTrue)1102 JNI_TEST_CRITICAL(RunStaticReturnTrue)
1103
1104 void JniCompilerTest::RunStaticReturnFalseImpl() {
1105 SetUpForTest(true, "returnFalse", "()Z",
1106 CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnFalse));
1107
1108 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_);
1109 EXPECT_FALSE(result);
1110 }
1111
JNI_TEST_CRITICAL(RunStaticReturnFalse)1112 JNI_TEST_CRITICAL(RunStaticReturnFalse)
1113
1114 void JniCompilerTest::RunGenericStaticReturnIntImpl() {
1115 SetUpForTest(true, "returnInt", "()I", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnInt));
1116
1117 jint result = env_->CallStaticIntMethod(jklass_, jmethod_);
1118 EXPECT_EQ(42, result);
1119 }
1120
1121 JNI_TEST_CRITICAL(RunGenericStaticReturnInt)
1122
1123 int gJava_MyClassNatives_returnDouble_calls[kJniKindCount] = {};
Java_MyClassNatives_returnDouble(JNIEnv *,jclass)1124 jdouble Java_MyClassNatives_returnDouble(JNIEnv*, jclass) {
1125 gJava_MyClassNatives_returnDouble_calls[gCurrentJni]++;
1126 return 4.0;
1127 }
1128
RunGenericStaticReturnDoubleImpl()1129 void JniCompilerTest::RunGenericStaticReturnDoubleImpl() {
1130 SetUpForTest(true, "returnDouble", "()D", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnDouble));
1131
1132 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_);
1133 EXPECT_DOUBLE_EQ(4.0, result);
1134 EXPECT_EQ(1, gJava_MyClassNatives_returnDouble_calls[gCurrentJni]);
1135
1136 gJava_MyClassNatives_returnDouble_calls[gCurrentJni] = 0;
1137 }
1138
JNI_TEST_CRITICAL(RunGenericStaticReturnDouble)1139 JNI_TEST_CRITICAL(RunGenericStaticReturnDouble)
1140
1141 jlong Java_MyClassNatives_returnLong(JNIEnv*, jclass) {
1142 return 0xFEEDDEADFEEDL;
1143 }
1144
RunGenericStaticReturnLongImpl()1145 void JniCompilerTest::RunGenericStaticReturnLongImpl() {
1146 SetUpForTest(true, "returnLong", "()J", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnLong));
1147
1148 jlong result = env_->CallStaticLongMethod(jklass_, jmethod_);
1149 EXPECT_EQ(0xFEEDDEADFEEDL, result);
1150 }
1151
1152 JNI_TEST_CRITICAL(RunGenericStaticReturnLong)
1153
1154 int gJava_MyClassNatives_fooSIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSIOO(JNIEnv *,jclass klass,jint x,jobject y,jobject z)1155 jobject Java_MyClassNatives_fooSIOO(JNIEnv*, jclass klass, jint x, jobject y, jobject z) {
1156 gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]++;
1157 switch (x) {
1158 case 1:
1159 return y;
1160 case 2:
1161 return z;
1162 default:
1163 return klass;
1164 }
1165 }
1166
CompileAndRunStaticIntObjectObjectMethodImpl()1167 void JniCompilerTest::CompileAndRunStaticIntObjectObjectMethodImpl() {
1168 SetUpForTest(true, "fooSIOO",
1169 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
1170 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSIOO));
1171
1172 EXPECT_EQ(0, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1173 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr);
1174 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1175 EXPECT_EQ(1, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1176
1177 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_);
1178 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1179 EXPECT_EQ(2, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1180 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_);
1181 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1182 EXPECT_EQ(3, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1183 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_);
1184 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1185 EXPECT_EQ(4, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1186
1187 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr);
1188 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1189 EXPECT_EQ(5, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1190 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr);
1191 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1192 EXPECT_EQ(6, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1193 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1194 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1195 EXPECT_EQ(7, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1196
1197 gJava_MyClassNatives_fooSIOO_calls[gCurrentJni] = 0;
1198 }
1199
1200 JNI_TEST(CompileAndRunStaticIntObjectObjectMethod)
1201
1202 int gJava_MyClassNatives_fooSSIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSSIOO(JNIEnv * env,jclass klass,jint x,jobject y,jobject z)1203 jobject Java_MyClassNatives_fooSSIOO(JNIEnv* env, jclass klass, jint x, jobject y, jobject z) {
1204 JniCompilerTest::AssertCallerObjectLocked(env);
1205 gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]++;
1206 switch (x) {
1207 case 1:
1208 return y;
1209 case 2:
1210 return z;
1211 default:
1212 return klass;
1213 }
1214 }
1215
CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl()1216 void JniCompilerTest::CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl() {
1217 SetUpForTest(true, "fooSSIOO",
1218 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
1219 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSSIOO));
1220
1221 EXPECT_EQ(0, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1222 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr);
1223 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1224 EXPECT_EQ(1, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1225
1226 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_);
1227 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1228 EXPECT_EQ(2, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1229 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_);
1230 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1231 EXPECT_EQ(3, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1232 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_);
1233 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1234 EXPECT_EQ(4, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1235
1236 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr);
1237 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1238 EXPECT_EQ(5, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1239 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr);
1240 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1241 EXPECT_EQ(6, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1242 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1243 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1244 EXPECT_EQ(7, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1245
1246 // Exercise recursive thin locking/unlocking.
1247 // Note: Thin lock count 0 means locked once.
1248 env_->MonitorEnter(jklass_);
1249 LockWord lock_word = GetLockWord(jklass_);
1250 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1251 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
1252 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1253 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1254 EXPECT_EQ(8, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1255 lock_word = GetLockWord(jklass_);
1256 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1257 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
1258 env_->MonitorExit(jklass_);
1259 lock_word = GetLockWord(jklass_);
1260 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1261
1262 // Exercise lock inflation due to thin lock count overflow.
1263 constexpr uint32_t kMaxThinLockRecursiveLocks = 1u << LockWord::kThinLockCountSize;
1264 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
1265 env_->MonitorEnter(jklass_);
1266 lock_word = GetLockWord(jklass_);
1267 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1268 ASSERT_EQ(lock_word.ThinLockCount(), i);
1269 }
1270 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1271 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1272 EXPECT_EQ(9, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1273 lock_word = GetLockWord(jklass_);
1274 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
1275 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
1276 env_->MonitorExit(jklass_); // Remains "fat-locked" even if actually unlocked.
1277 }
1278
1279 // Exercise locking for "fat-locked".
1280 lock_word = GetLockWord(jklass_);
1281 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1282 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1283 EXPECT_EQ(10, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1284 lock_word = GetLockWord(jklass_);
1285 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
1286
1287 gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni] = 0;
1288 }
1289
1290 // TODO: Maybe. @FastNative support for returning Objects?
JNI_TEST_NORMAL_ONLY(CompileAndRunStaticSynchronizedIntObjectObjectMethod)1291 JNI_TEST_NORMAL_ONLY(CompileAndRunStaticSynchronizedIntObjectObjectMethod)
1292
1293 void Java_MyClassNatives_throwException(JNIEnv* env, jobject) {
1294 jclass c = env->FindClass("java/lang/RuntimeException");
1295 env->ThrowNew(c, "hello");
1296 }
1297
Java_MyClassNatives_synchronizedThrowException(JNIEnv * env,jobject)1298 void Java_MyClassNatives_synchronizedThrowException(JNIEnv* env, jobject) {
1299 JniCompilerTest::AssertCallerObjectLocked(env);
1300 jclass c = env->FindClass("java/lang/RuntimeException");
1301 env->ThrowNew(c, "hello");
1302 }
1303
ExceptionHandlingImpl()1304 void JniCompilerTest::ExceptionHandlingImpl() {
1305 {
1306 ASSERT_FALSE(runtime_->IsStarted());
1307 ScopedObjectAccess soa(Thread::Current());
1308 class_loader_ = LoadDex("MyClassNatives");
1309
1310 // all compilation needs to happen before Runtime::Start
1311 CompileForTestWithCurrentJni(class_loader_, false, "foo", "()V");
1312 CompileForTestWithCurrentJni(class_loader_, false, "throwException", "()V");
1313 if (gCurrentJni == enum_cast<uint32_t>(JniKind::kNormal)) {
1314 CompileForTestWithCurrentJni(class_loader_, false, "synchronizedThrowException", "()V");
1315 }
1316 }
1317 // Start runtime to avoid re-initialization in SetUpForTest.
1318 Thread::Current()->TransitionFromSuspendedToRunnable();
1319 bool started = runtime_->Start();
1320 CHECK(started);
1321
1322 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
1323
1324 // Check a single call of a JNI method is ok
1325 SetUpForTest(false, "foo", "()V", CURRENT_JNI_WRAPPER(Java_MyClassNatives_foo));
1326 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1327 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1328 EXPECT_FALSE(Thread::Current()->IsExceptionPending());
1329
1330 // Get class for exception we expect to be thrown
1331 ScopedLocalRef<jclass> jlre(env_, env_->FindClass("java/lang/RuntimeException"));
1332 SetUpForTest(false, "throwException", "()V",
1333 CURRENT_JNI_WRAPPER(Java_MyClassNatives_throwException));
1334 // Call Java_MyClassNatives_throwException (JNI method that throws exception)
1335 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1336 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
1337 ScopedLocalRef<jthrowable> exception(env_, env_->ExceptionOccurred());
1338 env_->ExceptionClear();
1339 EXPECT_TRUE(env_->IsInstanceOf(exception.get(), jlre.get()));
1340
1341 // Check a single call of a JNI method is ok
1342 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1343 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
1344 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1345 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1346
1347 if (gCurrentJni == enum_cast<uint32_t>(JniKind::kNormal)) {
1348 SetUpForTest(false, "synchronizedThrowException", "()V",
1349 CURRENT_JNI_WRAPPER(Java_MyClassNatives_synchronizedThrowException));
1350 LockWord lock_word = GetLockWord(jobj_);
1351 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1352 // Call Java_MyClassNatives_synchronizedThrowException (synchronized JNI method
1353 // that throws exception) to check that we correctly unlock the object.
1354 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1355 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
1356 ScopedLocalRef<jthrowable> exception2(env_, env_->ExceptionOccurred());
1357 env_->ExceptionClear();
1358 EXPECT_TRUE(env_->IsInstanceOf(exception2.get(), jlre.get()));
1359 lock_word = GetLockWord(jobj_);
1360 EXPECT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1361
1362 // Check a single call of a JNI method is ok
1363 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1364 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
1365 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1366 EXPECT_EQ(3, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1367 }
1368
1369 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
1370 }
1371
JNI_TEST(ExceptionHandling)1372 JNI_TEST(ExceptionHandling)
1373
1374 jint Java_MyClassNatives_nativeUpCall(JNIEnv* env, jobject thisObj, jint i) {
1375 if (i <= 0) {
1376 // We want to check raw Object* / Array* below
1377 ScopedObjectAccess soa(env);
1378
1379 // Build stack trace
1380 jobject internal = Thread::Current()->CreateInternalStackTrace(soa);
1381 jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(soa, internal);
1382 ObjPtr<mirror::ObjectArray<mirror::StackTraceElement>> trace_array =
1383 soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>>(ste_array);
1384 EXPECT_TRUE(trace_array != nullptr);
1385 EXPECT_EQ(11, trace_array->GetLength());
1386
1387 // Check stack trace entries have expected values
1388 for (int32_t j = 0; j < trace_array->GetLength(); ++j) {
1389 EXPECT_EQ(-2, trace_array->Get(j)->GetLineNumber());
1390 ObjPtr<mirror::StackTraceElement> ste = trace_array->Get(j);
1391 EXPECT_STREQ("MyClassNatives.java", ste->GetFileName()->ToModifiedUtf8().c_str());
1392 EXPECT_STREQ("MyClassNatives", ste->GetDeclaringClass()->ToModifiedUtf8().c_str());
1393 EXPECT_EQ(("fooI" + CurrentJniStringSuffix()), ste->GetMethodName()->ToModifiedUtf8());
1394 }
1395
1396 // end recursion
1397 return 0;
1398 } else {
1399 jclass jklass = env->FindClass("MyClassNatives");
1400 EXPECT_TRUE(jklass != nullptr);
1401 jmethodID jmethod = env->GetMethodID(jklass,
1402 ("fooI" + CurrentJniStringSuffix()).c_str(),
1403 "(I)I");
1404 EXPECT_TRUE(jmethod != nullptr);
1405
1406 // Recurse with i - 1
1407 jint result = env->CallNonvirtualIntMethod(thisObj, jklass, jmethod, i - 1);
1408
1409 // Return sum of all depths
1410 return i + result;
1411 }
1412 }
1413
NativeStackTraceElementImpl()1414 void JniCompilerTest::NativeStackTraceElementImpl() {
1415 SetUpForTest(false, "fooI", "(I)I",
1416 CURRENT_JNI_WRAPPER(Java_MyClassNatives_nativeUpCall));
1417
1418 // Usual # local references on stack check fails because nativeUpCall calls itself recursively,
1419 // each time the # of local references will therefore go up.
1420 ScopedDisableCheckNumStackReferences disable_num_stack_check;
1421 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 10);
1422
1423 EXPECT_EQ(10+9+8+7+6+5+4+3+2+1, result);
1424 }
1425
JNI_TEST(NativeStackTraceElement)1426 JNI_TEST(NativeStackTraceElement)
1427
1428 jobject Java_MyClassNatives_fooO(JNIEnv* env, jobject, jobject x) {
1429 return env->NewGlobalRef(x);
1430 }
1431
ReturnGlobalRefImpl()1432 void JniCompilerTest::ReturnGlobalRefImpl() {
1433 SetUpForTest(false, "fooO", "(Ljava/lang/Object;)Ljava/lang/Object;",
1434 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooO));
1435 jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, jobj_);
1436 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(result));
1437 EXPECT_TRUE(env_->IsSameObject(result, jobj_));
1438 }
1439
JNI_TEST(ReturnGlobalRef)1440 JNI_TEST(ReturnGlobalRef)
1441
1442 jint local_ref_test(JNIEnv* env, jobject thisObj, jint x) {
1443 // Add 10 local references
1444 ScopedObjectAccess soa(env);
1445 for (int i = 0; i < 10; i++) {
1446 soa.AddLocalReference<jobject>(soa.Decode<mirror::Object>(thisObj));
1447 }
1448 return x+1;
1449 }
1450
LocalReferenceTableClearingTestImpl()1451 void JniCompilerTest::LocalReferenceTableClearingTestImpl() {
1452 SetUpForTest(false, "fooI", "(I)I", CURRENT_JNI_WRAPPER(local_ref_test));
1453 // 1000 invocations of a method that adds 10 local references
1454 for (int i = 0; i < 1000; i++) {
1455 jint result = env_->CallIntMethod(jobj_, jmethod_, i);
1456 EXPECT_TRUE(result == i + 1);
1457 }
1458 }
1459
JNI_TEST(LocalReferenceTableClearingTest)1460 JNI_TEST(LocalReferenceTableClearingTest)
1461
1462 void my_arraycopy(JNIEnv* env, jclass klass, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length) {
1463 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jklass_, klass));
1464 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jklass_, dst));
1465 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, src));
1466 EXPECT_EQ(1234, src_pos);
1467 EXPECT_EQ(5678, dst_pos);
1468 EXPECT_EQ(9876, length);
1469 }
1470
JavaLangSystemArrayCopyImpl()1471 void JniCompilerTest::JavaLangSystemArrayCopyImpl() {
1472 SetUpForTest(true, "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V",
1473 CURRENT_JNI_WRAPPER(my_arraycopy));
1474 env_->CallStaticVoidMethod(jklass_, jmethod_, jobj_, 1234, jklass_, 5678, 9876);
1475 }
1476
JNI_TEST(JavaLangSystemArrayCopy)1477 JNI_TEST(JavaLangSystemArrayCopy)
1478
1479 jboolean my_casi(JNIEnv* env, jobject unsafe, jobject obj, jlong offset, jint expected, jint newval) {
1480 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, unsafe));
1481 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj));
1482 EXPECT_EQ(INT64_C(0x12345678ABCDEF88), offset);
1483 EXPECT_EQ(static_cast<jint>(0xCAFEF00D), expected);
1484 EXPECT_EQ(static_cast<jint>(0xEBADF00D), newval);
1485 return JNI_TRUE;
1486 }
1487
CompareAndSwapIntImpl()1488 void JniCompilerTest::CompareAndSwapIntImpl() {
1489 SetUpForTest(false, "compareAndSwapInt", "(Ljava/lang/Object;JII)Z",
1490 CURRENT_JNI_WRAPPER(my_casi));
1491 jboolean result = env_->CallBooleanMethod(jobj_, jmethod_, jobj_, INT64_C(0x12345678ABCDEF88),
1492 0xCAFEF00D, 0xEBADF00D);
1493 EXPECT_EQ(result, JNI_TRUE);
1494 }
1495
JNI_TEST(CompareAndSwapInt)1496 JNI_TEST(CompareAndSwapInt)
1497
1498 jint my_gettext(JNIEnv* env, jclass klass, jlong val1, jobject obj1, jlong val2, jobject obj2) {
1499 EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
1500 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj1));
1501 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj2));
1502 EXPECT_EQ(0x12345678ABCDEF88LL, val1);
1503 EXPECT_EQ(0x7FEDCBA987654321LL, val2);
1504 return 42;
1505 }
1506
GetTextImpl()1507 void JniCompilerTest::GetTextImpl() {
1508 SetUpForTest(true, "getText", "(JLjava/lang/Object;JLjava/lang/Object;)I",
1509 CURRENT_JNI_WRAPPER(my_gettext));
1510 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 0x12345678ABCDEF88LL, jobj_,
1511 INT64_C(0x7FEDCBA987654321), jobj_);
1512 EXPECT_EQ(result, 42);
1513 }
1514
1515 JNI_TEST(GetText)
1516
1517 int gJava_MyClassNatives_GetSinkProperties_calls[kJniKindCount] = {};
Java_MyClassNatives_GetSinkProperties(JNIEnv * env,jobject thisObj,jstring s)1518 jarray Java_MyClassNatives_GetSinkProperties(JNIEnv* env, jobject thisObj, jstring s) {
1519 JniCompilerTest::AssertCallerObjectLocked(env);
1520 EXPECT_EQ(s, nullptr);
1521 gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni]++;
1522
1523 Thread* self = Thread::Current();
1524 ScopedObjectAccess soa(self);
1525 EXPECT_TRUE(self->HoldsLock(soa.Decode<mirror::Object>(thisObj)));
1526 return nullptr;
1527 }
1528
GetSinkPropertiesNativeImpl()1529 void JniCompilerTest::GetSinkPropertiesNativeImpl() {
1530 SetUpForTest(false, "getSinkPropertiesNative", "(Ljava/lang/String;)[Ljava/lang/Object;",
1531 CURRENT_JNI_WRAPPER(Java_MyClassNatives_GetSinkProperties));
1532
1533 EXPECT_EQ(0, gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni]);
1534 jarray result = down_cast<jarray>(
1535 env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, nullptr));
1536 EXPECT_EQ(nullptr, result);
1537 EXPECT_EQ(1, gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni]);
1538
1539 gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni] = 0;
1540 }
1541
1542 // @FastNative doesn't support 'synchronized' keyword and
1543 // never will -- locking functions aren't fast.
JNI_TEST_NORMAL_ONLY(GetSinkPropertiesNative)1544 JNI_TEST_NORMAL_ONLY(GetSinkPropertiesNative)
1545
1546 // This should return jclass, but we're imitating a bug pattern.
1547 jobject Java_MyClassNatives_instanceMethodThatShouldReturnClass(JNIEnv* env, jobject) {
1548 return env->NewStringUTF("not a class!");
1549 }
1550
1551 // This should return jclass, but we're imitating a bug pattern.
Java_MyClassNatives_staticMethodThatShouldReturnClass(JNIEnv * env,jclass)1552 jobject Java_MyClassNatives_staticMethodThatShouldReturnClass(JNIEnv* env, jclass) {
1553 return env->NewStringUTF("not a class!");
1554 }
1555
UpcallReturnTypeChecking_InstanceImpl()1556 void JniCompilerTest::UpcallReturnTypeChecking_InstanceImpl() {
1557 // Set debuggable so that the JNI compiler does not emit a fast-path that would skip the
1558 // runtime call where we do these checks. Note that while normal gtests use the debug build
1559 // which disables the fast path, `art_standalone_compiler_tests` run in the release build.
1560 compiler_options_->SetDebuggable(true);
1561 SetUpForTest(false, "instanceMethodThatShouldReturnClass", "()Ljava/lang/Class;",
1562 CURRENT_JNI_WRAPPER(Java_MyClassNatives_instanceMethodThatShouldReturnClass));
1563
1564 CheckJniAbortCatcher check_jni_abort_catcher;
1565 // This native method is bad, and tries to return a jstring as a jclass.
1566 env_->CallObjectMethod(jobj_, jmethod_);
1567 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1568 "of java.lang.String from java.lang.Class " +
1569 "MyClassNatives.instanceMethodThatShouldReturnClass" +
1570 CurrentJniStringSuffix() + "()");
1571
1572 // Here, we just call the method incorrectly; we should catch that too.
1573 env_->CallObjectMethod(jobj_, jmethod_);
1574 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1575 "of java.lang.String from java.lang.Class " +
1576 "MyClassNatives.instanceMethodThatShouldReturnClass" +
1577 CurrentJniStringSuffix() + "()");
1578 env_->CallStaticObjectMethod(jklass_, jmethod_);
1579 check_jni_abort_catcher.Check(std::string() + "calling non-static method " +
1580 "java.lang.Class " +
1581 "MyClassNatives.instanceMethodThatShouldReturnClass" +
1582 CurrentJniStringSuffix() + "() with CallStaticObjectMethodV");
1583 }
1584
JNI_TEST(UpcallReturnTypeChecking_Instance)1585 JNI_TEST(UpcallReturnTypeChecking_Instance)
1586
1587 void JniCompilerTest::UpcallReturnTypeChecking_StaticImpl() {
1588 // Set debuggable so that the JNI compiler does not emit a fast-path that would skip the
1589 // runtime call where we do these checks. Note that while normal gtests use the debug build
1590 // which disables the fast path, `art_standalone_compiler_tests` run in the release build.
1591 compiler_options_->SetDebuggable(true);
1592 SetUpForTest(true, "staticMethodThatShouldReturnClass", "()Ljava/lang/Class;",
1593 CURRENT_JNI_WRAPPER(Java_MyClassNatives_staticMethodThatShouldReturnClass));
1594
1595 CheckJniAbortCatcher check_jni_abort_catcher;
1596 // This native method is bad, and tries to return a jstring as a jclass.
1597 env_->CallStaticObjectMethod(jklass_, jmethod_);
1598 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1599 "of java.lang.String from java.lang.Class " +
1600 "MyClassNatives.staticMethodThatShouldReturnClass" +
1601 CurrentJniStringSuffix() + "()");
1602
1603 // Here, we just call the method incorrectly; we should catch that too.
1604 env_->CallStaticObjectMethod(jklass_, jmethod_);
1605 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1606 "of java.lang.String from java.lang.Class " +
1607 "MyClassNatives.staticMethodThatShouldReturnClass" +
1608 CurrentJniStringSuffix() + "()");
1609 env_->CallObjectMethod(jobj_, jmethod_);
1610 check_jni_abort_catcher.Check(std::string() + "calling static method " +
1611 "java.lang.Class " +
1612 "MyClassNatives.staticMethodThatShouldReturnClass" +
1613 CurrentJniStringSuffix() + "() with CallObjectMethodV");
1614 }
1615
JNI_TEST(UpcallReturnTypeChecking_Static)1616 JNI_TEST(UpcallReturnTypeChecking_Static)
1617
1618 // This should take jclass, but we're imitating a bug pattern.
1619 void Java_MyClassNatives_instanceMethodThatShouldTakeClass(JNIEnv*, jobject, jclass) {
1620 }
1621
1622 // This should take jclass, but we're imitating a bug pattern.
Java_MyClassNatives_staticMethodThatShouldTakeClass(JNIEnv *,jclass,jclass)1623 void Java_MyClassNatives_staticMethodThatShouldTakeClass(JNIEnv*, jclass, jclass) {
1624 }
1625
UpcallArgumentTypeChecking_InstanceImpl()1626 void JniCompilerTest::UpcallArgumentTypeChecking_InstanceImpl() {
1627 // This will lead to error messages in the log.
1628 ScopedLogSeverity sls(LogSeverity::FATAL);
1629
1630 SetUpForTest(false, "instanceMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
1631 CURRENT_JNI_WRAPPER(Java_MyClassNatives_instanceMethodThatShouldTakeClass));
1632
1633 CheckJniAbortCatcher check_jni_abort_catcher;
1634 // We deliberately pass a bad second argument here.
1635 env_->CallVoidMethod(jobj_, jmethod_, 123, env_->NewStringUTF("not a class!"));
1636 check_jni_abort_catcher.Check(std::string() + "bad arguments passed to void " +
1637 "MyClassNatives.instanceMethodThatShouldTakeClass" +
1638 CurrentJniStringSuffix() + "(int, java.lang.Class)");
1639 }
1640
JNI_TEST(UpcallArgumentTypeChecking_Instance)1641 JNI_TEST(UpcallArgumentTypeChecking_Instance)
1642
1643 void JniCompilerTest::UpcallArgumentTypeChecking_StaticImpl() {
1644 // This will lead to error messages in the log.
1645 ScopedLogSeverity sls(LogSeverity::FATAL);
1646
1647 SetUpForTest(true, "staticMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
1648 CURRENT_JNI_WRAPPER(Java_MyClassNatives_staticMethodThatShouldTakeClass));
1649
1650 CheckJniAbortCatcher check_jni_abort_catcher;
1651 // We deliberately pass a bad second argument here.
1652 env_->CallStaticVoidMethod(jklass_, jmethod_, 123, env_->NewStringUTF("not a class!"));
1653 check_jni_abort_catcher.Check(std::string() + "bad arguments passed to void " +
1654 "MyClassNatives.staticMethodThatShouldTakeClass" +
1655 CurrentJniStringSuffix() + "(int, java.lang.Class)");
1656 }
1657
JNI_TEST(UpcallArgumentTypeChecking_Static)1658 JNI_TEST(UpcallArgumentTypeChecking_Static)
1659
1660 jfloat Java_MyClassNatives_checkFloats(JNIEnv*, jobject, jfloat f1, jfloat f2) {
1661 return f1 - f2; // non-commutative operator
1662 }
1663
CompileAndRunFloatFloatMethodImpl()1664 void JniCompilerTest::CompileAndRunFloatFloatMethodImpl() {
1665 SetUpForTest(false, "checkFloats", "(FF)F",
1666 CURRENT_JNI_WRAPPER(Java_MyClassNatives_checkFloats));
1667
1668 jfloat result = env_->CallNonvirtualFloatMethod(jobj_, jklass_, jmethod_,
1669 99.0F, 10.0F);
1670 EXPECT_FLOAT_EQ(99.0F - 10.0F, result);
1671 jfloat a = 3.14159F;
1672 jfloat b = 0.69314F;
1673 result = env_->CallNonvirtualFloatMethod(jobj_, jklass_, jmethod_, a, b);
1674 EXPECT_FLOAT_EQ(a - b, result);
1675 }
1676
JNI_TEST(CompileAndRunFloatFloatMethod)1677 JNI_TEST(CompileAndRunFloatFloatMethod)
1678
1679 void Java_MyClassNatives_checkParameterAlign(JNIEnv* env ATTRIBUTE_UNUSED,
1680 jobject thisObj ATTRIBUTE_UNUSED,
1681 jint i1,
1682 jlong l1) {
1683 EXPECT_EQ(i1, 1234);
1684 EXPECT_EQ(l1, INT64_C(0x12345678ABCDEF0));
1685 }
1686
CheckParameterAlignImpl()1687 void JniCompilerTest::CheckParameterAlignImpl() {
1688 SetUpForTest(false, "checkParameterAlign", "(IJ)V",
1689 CURRENT_JNI_WRAPPER(Java_MyClassNatives_checkParameterAlign));
1690
1691 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_, 1234, INT64_C(0x12345678ABCDEF0));
1692 }
1693
JNI_TEST(CheckParameterAlign)1694 JNI_TEST(CheckParameterAlign)
1695
1696 void Java_MyClassNatives_maxParamNumber(JNIEnv* env, jobject,
1697 jobject o0, jobject o1, jobject o2, jobject o3, jobject o4, jobject o5, jobject o6, jobject o7,
1698 jobject o8, jobject o9, jobject o10, jobject o11, jobject o12, jobject o13, jobject o14, jobject o15,
1699 jobject o16, jobject o17, jobject o18, jobject o19, jobject o20, jobject o21, jobject o22, jobject o23,
1700 jobject o24, jobject o25, jobject o26, jobject o27, jobject o28, jobject o29, jobject o30, jobject o31,
1701 jobject o32, jobject o33, jobject o34, jobject o35, jobject o36, jobject o37, jobject o38, jobject o39,
1702 jobject o40, jobject o41, jobject o42, jobject o43, jobject o44, jobject o45, jobject o46, jobject o47,
1703 jobject o48, jobject o49, jobject o50, jobject o51, jobject o52, jobject o53, jobject o54, jobject o55,
1704 jobject o56, jobject o57, jobject o58, jobject o59, jobject o60, jobject o61, jobject o62, jobject o63,
1705 jobject o64, jobject o65, jobject o66, jobject o67, jobject o68, jobject o69, jobject o70, jobject o71,
1706 jobject o72, jobject o73, jobject o74, jobject o75, jobject o76, jobject o77, jobject o78, jobject o79,
1707 jobject o80, jobject o81, jobject o82, jobject o83, jobject o84, jobject o85, jobject o86, jobject o87,
1708 jobject o88, jobject o89, jobject o90, jobject o91, jobject o92, jobject o93, jobject o94, jobject o95,
1709 jobject o96, jobject o97, jobject o98, jobject o99, jobject o100, jobject o101, jobject o102, jobject o103,
1710 jobject o104, jobject o105, jobject o106, jobject o107, jobject o108, jobject o109, jobject o110, jobject o111,
1711 jobject o112, jobject o113, jobject o114, jobject o115, jobject o116, jobject o117, jobject o118, jobject o119,
1712 jobject o120, jobject o121, jobject o122, jobject o123, jobject o124, jobject o125, jobject o126, jobject o127,
1713 jobject o128, jobject o129, jobject o130, jobject o131, jobject o132, jobject o133, jobject o134, jobject o135,
1714 jobject o136, jobject o137, jobject o138, jobject o139, jobject o140, jobject o141, jobject o142, jobject o143,
1715 jobject o144, jobject o145, jobject o146, jobject o147, jobject o148, jobject o149, jobject o150, jobject o151,
1716 jobject o152, jobject o153, jobject o154, jobject o155, jobject o156, jobject o157, jobject o158, jobject o159,
1717 jobject o160, jobject o161, jobject o162, jobject o163, jobject o164, jobject o165, jobject o166, jobject o167,
1718 jobject o168, jobject o169, jobject o170, jobject o171, jobject o172, jobject o173, jobject o174, jobject o175,
1719 jobject o176, jobject o177, jobject o178, jobject o179, jobject o180, jobject o181, jobject o182, jobject o183,
1720 jobject o184, jobject o185, jobject o186, jobject o187, jobject o188, jobject o189, jobject o190, jobject o191,
1721 jobject o192, jobject o193, jobject o194, jobject o195, jobject o196, jobject o197, jobject o198, jobject o199,
1722 jobject o200, jobject o201, jobject o202, jobject o203, jobject o204, jobject o205, jobject o206, jobject o207,
1723 jobject o208, jobject o209, jobject o210, jobject o211, jobject o212, jobject o213, jobject o214, jobject o215,
1724 jobject o216, jobject o217, jobject o218, jobject o219, jobject o220, jobject o221, jobject o222, jobject o223,
1725 jobject o224, jobject o225, jobject o226, jobject o227, jobject o228, jobject o229, jobject o230, jobject o231,
1726 jobject o232, jobject o233, jobject o234, jobject o235, jobject o236, jobject o237, jobject o238, jobject o239,
1727 jobject o240, jobject o241, jobject o242, jobject o243, jobject o244, jobject o245, jobject o246, jobject o247,
1728 jobject o248, jobject o249, jobject o250, jobject o251, jobject o252, jobject o253) {
1729 // two tests possible
1730 if (o0 == nullptr) {
1731 // 1) everything is null
1732 EXPECT_TRUE(o0 == nullptr && o1 == nullptr && o2 == nullptr && o3 == nullptr && o4 == nullptr
1733 && o5 == nullptr && o6 == nullptr && o7 == nullptr && o8 == nullptr && o9 == nullptr
1734 && o10 == nullptr && o11 == nullptr && o12 == nullptr && o13 == nullptr && o14 == nullptr
1735 && o15 == nullptr && o16 == nullptr && o17 == nullptr && o18 == nullptr && o19 == nullptr
1736 && o20 == nullptr && o21 == nullptr && o22 == nullptr && o23 == nullptr && o24 == nullptr
1737 && o25 == nullptr && o26 == nullptr && o27 == nullptr && o28 == nullptr && o29 == nullptr
1738 && o30 == nullptr && o31 == nullptr && o32 == nullptr && o33 == nullptr && o34 == nullptr
1739 && o35 == nullptr && o36 == nullptr && o37 == nullptr && o38 == nullptr && o39 == nullptr
1740 && o40 == nullptr && o41 == nullptr && o42 == nullptr && o43 == nullptr && o44 == nullptr
1741 && o45 == nullptr && o46 == nullptr && o47 == nullptr && o48 == nullptr && o49 == nullptr
1742 && o50 == nullptr && o51 == nullptr && o52 == nullptr && o53 == nullptr && o54 == nullptr
1743 && o55 == nullptr && o56 == nullptr && o57 == nullptr && o58 == nullptr && o59 == nullptr
1744 && o60 == nullptr && o61 == nullptr && o62 == nullptr && o63 == nullptr && o64 == nullptr
1745 && o65 == nullptr && o66 == nullptr && o67 == nullptr && o68 == nullptr && o69 == nullptr
1746 && o70 == nullptr && o71 == nullptr && o72 == nullptr && o73 == nullptr && o74 == nullptr
1747 && o75 == nullptr && o76 == nullptr && o77 == nullptr && o78 == nullptr && o79 == nullptr
1748 && o80 == nullptr && o81 == nullptr && o82 == nullptr && o83 == nullptr && o84 == nullptr
1749 && o85 == nullptr && o86 == nullptr && o87 == nullptr && o88 == nullptr && o89 == nullptr
1750 && o90 == nullptr && o91 == nullptr && o92 == nullptr && o93 == nullptr && o94 == nullptr
1751 && o95 == nullptr && o96 == nullptr && o97 == nullptr && o98 == nullptr && o99 == nullptr
1752 && o100 == nullptr && o101 == nullptr && o102 == nullptr && o103 == nullptr && o104 == nullptr
1753 && o105 == nullptr && o106 == nullptr && o107 == nullptr && o108 == nullptr && o109 == nullptr
1754 && o110 == nullptr && o111 == nullptr && o112 == nullptr && o113 == nullptr && o114 == nullptr
1755 && o115 == nullptr && o116 == nullptr && o117 == nullptr && o118 == nullptr && o119 == nullptr
1756 && o120 == nullptr && o121 == nullptr && o122 == nullptr && o123 == nullptr && o124 == nullptr
1757 && o125 == nullptr && o126 == nullptr && o127 == nullptr && o128 == nullptr && o129 == nullptr
1758 && o130 == nullptr && o131 == nullptr && o132 == nullptr && o133 == nullptr && o134 == nullptr
1759 && o135 == nullptr && o136 == nullptr && o137 == nullptr && o138 == nullptr && o139 == nullptr
1760 && o140 == nullptr && o141 == nullptr && o142 == nullptr && o143 == nullptr && o144 == nullptr
1761 && o145 == nullptr && o146 == nullptr && o147 == nullptr && o148 == nullptr && o149 == nullptr
1762 && o150 == nullptr && o151 == nullptr && o152 == nullptr && o153 == nullptr && o154 == nullptr
1763 && o155 == nullptr && o156 == nullptr && o157 == nullptr && o158 == nullptr && o159 == nullptr
1764 && o160 == nullptr && o161 == nullptr && o162 == nullptr && o163 == nullptr && o164 == nullptr
1765 && o165 == nullptr && o166 == nullptr && o167 == nullptr && o168 == nullptr && o169 == nullptr
1766 && o170 == nullptr && o171 == nullptr && o172 == nullptr && o173 == nullptr && o174 == nullptr
1767 && o175 == nullptr && o176 == nullptr && o177 == nullptr && o178 == nullptr && o179 == nullptr
1768 && o180 == nullptr && o181 == nullptr && o182 == nullptr && o183 == nullptr && o184 == nullptr
1769 && o185 == nullptr && o186 == nullptr && o187 == nullptr && o188 == nullptr && o189 == nullptr
1770 && o190 == nullptr && o191 == nullptr && o192 == nullptr && o193 == nullptr && o194 == nullptr
1771 && o195 == nullptr && o196 == nullptr && o197 == nullptr && o198 == nullptr && o199 == nullptr
1772 && o200 == nullptr && o201 == nullptr && o202 == nullptr && o203 == nullptr && o204 == nullptr
1773 && o205 == nullptr && o206 == nullptr && o207 == nullptr && o208 == nullptr && o209 == nullptr
1774 && o210 == nullptr && o211 == nullptr && o212 == nullptr && o213 == nullptr && o214 == nullptr
1775 && o215 == nullptr && o216 == nullptr && o217 == nullptr && o218 == nullptr && o219 == nullptr
1776 && o220 == nullptr && o221 == nullptr && o222 == nullptr && o223 == nullptr && o224 == nullptr
1777 && o225 == nullptr && o226 == nullptr && o227 == nullptr && o228 == nullptr && o229 == nullptr
1778 && o230 == nullptr && o231 == nullptr && o232 == nullptr && o233 == nullptr && o234 == nullptr
1779 && o235 == nullptr && o236 == nullptr && o237 == nullptr && o238 == nullptr && o239 == nullptr
1780 && o240 == nullptr && o241 == nullptr && o242 == nullptr && o243 == nullptr && o244 == nullptr
1781 && o245 == nullptr && o246 == nullptr && o247 == nullptr && o248 == nullptr && o249 == nullptr
1782 && o250 == nullptr && o251 == nullptr && o252 == nullptr && o253 == nullptr);
1783 } else {
1784 EXPECT_EQ(0, env->GetArrayLength(reinterpret_cast<jarray>(o0)));
1785 EXPECT_EQ(1, env->GetArrayLength(reinterpret_cast<jarray>(o1)));
1786 EXPECT_EQ(2, env->GetArrayLength(reinterpret_cast<jarray>(o2)));
1787 EXPECT_EQ(3, env->GetArrayLength(reinterpret_cast<jarray>(o3)));
1788 EXPECT_EQ(4, env->GetArrayLength(reinterpret_cast<jarray>(o4)));
1789 EXPECT_EQ(5, env->GetArrayLength(reinterpret_cast<jarray>(o5)));
1790 EXPECT_EQ(6, env->GetArrayLength(reinterpret_cast<jarray>(o6)));
1791 EXPECT_EQ(7, env->GetArrayLength(reinterpret_cast<jarray>(o7)));
1792 EXPECT_EQ(8, env->GetArrayLength(reinterpret_cast<jarray>(o8)));
1793 EXPECT_EQ(9, env->GetArrayLength(reinterpret_cast<jarray>(o9)));
1794 EXPECT_EQ(10, env->GetArrayLength(reinterpret_cast<jarray>(o10)));
1795 EXPECT_EQ(11, env->GetArrayLength(reinterpret_cast<jarray>(o11)));
1796 EXPECT_EQ(12, env->GetArrayLength(reinterpret_cast<jarray>(o12)));
1797 EXPECT_EQ(13, env->GetArrayLength(reinterpret_cast<jarray>(o13)));
1798 EXPECT_EQ(14, env->GetArrayLength(reinterpret_cast<jarray>(o14)));
1799 EXPECT_EQ(15, env->GetArrayLength(reinterpret_cast<jarray>(o15)));
1800 EXPECT_EQ(16, env->GetArrayLength(reinterpret_cast<jarray>(o16)));
1801 EXPECT_EQ(17, env->GetArrayLength(reinterpret_cast<jarray>(o17)));
1802 EXPECT_EQ(18, env->GetArrayLength(reinterpret_cast<jarray>(o18)));
1803 EXPECT_EQ(19, env->GetArrayLength(reinterpret_cast<jarray>(o19)));
1804 EXPECT_EQ(20, env->GetArrayLength(reinterpret_cast<jarray>(o20)));
1805 EXPECT_EQ(21, env->GetArrayLength(reinterpret_cast<jarray>(o21)));
1806 EXPECT_EQ(22, env->GetArrayLength(reinterpret_cast<jarray>(o22)));
1807 EXPECT_EQ(23, env->GetArrayLength(reinterpret_cast<jarray>(o23)));
1808 EXPECT_EQ(24, env->GetArrayLength(reinterpret_cast<jarray>(o24)));
1809 EXPECT_EQ(25, env->GetArrayLength(reinterpret_cast<jarray>(o25)));
1810 EXPECT_EQ(26, env->GetArrayLength(reinterpret_cast<jarray>(o26)));
1811 EXPECT_EQ(27, env->GetArrayLength(reinterpret_cast<jarray>(o27)));
1812 EXPECT_EQ(28, env->GetArrayLength(reinterpret_cast<jarray>(o28)));
1813 EXPECT_EQ(29, env->GetArrayLength(reinterpret_cast<jarray>(o29)));
1814 EXPECT_EQ(30, env->GetArrayLength(reinterpret_cast<jarray>(o30)));
1815 EXPECT_EQ(31, env->GetArrayLength(reinterpret_cast<jarray>(o31)));
1816 EXPECT_EQ(32, env->GetArrayLength(reinterpret_cast<jarray>(o32)));
1817 EXPECT_EQ(33, env->GetArrayLength(reinterpret_cast<jarray>(o33)));
1818 EXPECT_EQ(34, env->GetArrayLength(reinterpret_cast<jarray>(o34)));
1819 EXPECT_EQ(35, env->GetArrayLength(reinterpret_cast<jarray>(o35)));
1820 EXPECT_EQ(36, env->GetArrayLength(reinterpret_cast<jarray>(o36)));
1821 EXPECT_EQ(37, env->GetArrayLength(reinterpret_cast<jarray>(o37)));
1822 EXPECT_EQ(38, env->GetArrayLength(reinterpret_cast<jarray>(o38)));
1823 EXPECT_EQ(39, env->GetArrayLength(reinterpret_cast<jarray>(o39)));
1824 EXPECT_EQ(40, env->GetArrayLength(reinterpret_cast<jarray>(o40)));
1825 EXPECT_EQ(41, env->GetArrayLength(reinterpret_cast<jarray>(o41)));
1826 EXPECT_EQ(42, env->GetArrayLength(reinterpret_cast<jarray>(o42)));
1827 EXPECT_EQ(43, env->GetArrayLength(reinterpret_cast<jarray>(o43)));
1828 EXPECT_EQ(44, env->GetArrayLength(reinterpret_cast<jarray>(o44)));
1829 EXPECT_EQ(45, env->GetArrayLength(reinterpret_cast<jarray>(o45)));
1830 EXPECT_EQ(46, env->GetArrayLength(reinterpret_cast<jarray>(o46)));
1831 EXPECT_EQ(47, env->GetArrayLength(reinterpret_cast<jarray>(o47)));
1832 EXPECT_EQ(48, env->GetArrayLength(reinterpret_cast<jarray>(o48)));
1833 EXPECT_EQ(49, env->GetArrayLength(reinterpret_cast<jarray>(o49)));
1834 EXPECT_EQ(50, env->GetArrayLength(reinterpret_cast<jarray>(o50)));
1835 EXPECT_EQ(51, env->GetArrayLength(reinterpret_cast<jarray>(o51)));
1836 EXPECT_EQ(52, env->GetArrayLength(reinterpret_cast<jarray>(o52)));
1837 EXPECT_EQ(53, env->GetArrayLength(reinterpret_cast<jarray>(o53)));
1838 EXPECT_EQ(54, env->GetArrayLength(reinterpret_cast<jarray>(o54)));
1839 EXPECT_EQ(55, env->GetArrayLength(reinterpret_cast<jarray>(o55)));
1840 EXPECT_EQ(56, env->GetArrayLength(reinterpret_cast<jarray>(o56)));
1841 EXPECT_EQ(57, env->GetArrayLength(reinterpret_cast<jarray>(o57)));
1842 EXPECT_EQ(58, env->GetArrayLength(reinterpret_cast<jarray>(o58)));
1843 EXPECT_EQ(59, env->GetArrayLength(reinterpret_cast<jarray>(o59)));
1844 EXPECT_EQ(60, env->GetArrayLength(reinterpret_cast<jarray>(o60)));
1845 EXPECT_EQ(61, env->GetArrayLength(reinterpret_cast<jarray>(o61)));
1846 EXPECT_EQ(62, env->GetArrayLength(reinterpret_cast<jarray>(o62)));
1847 EXPECT_EQ(63, env->GetArrayLength(reinterpret_cast<jarray>(o63)));
1848 EXPECT_EQ(64, env->GetArrayLength(reinterpret_cast<jarray>(o64)));
1849 EXPECT_EQ(65, env->GetArrayLength(reinterpret_cast<jarray>(o65)));
1850 EXPECT_EQ(66, env->GetArrayLength(reinterpret_cast<jarray>(o66)));
1851 EXPECT_EQ(67, env->GetArrayLength(reinterpret_cast<jarray>(o67)));
1852 EXPECT_EQ(68, env->GetArrayLength(reinterpret_cast<jarray>(o68)));
1853 EXPECT_EQ(69, env->GetArrayLength(reinterpret_cast<jarray>(o69)));
1854 EXPECT_EQ(70, env->GetArrayLength(reinterpret_cast<jarray>(o70)));
1855 EXPECT_EQ(71, env->GetArrayLength(reinterpret_cast<jarray>(o71)));
1856 EXPECT_EQ(72, env->GetArrayLength(reinterpret_cast<jarray>(o72)));
1857 EXPECT_EQ(73, env->GetArrayLength(reinterpret_cast<jarray>(o73)));
1858 EXPECT_EQ(74, env->GetArrayLength(reinterpret_cast<jarray>(o74)));
1859 EXPECT_EQ(75, env->GetArrayLength(reinterpret_cast<jarray>(o75)));
1860 EXPECT_EQ(76, env->GetArrayLength(reinterpret_cast<jarray>(o76)));
1861 EXPECT_EQ(77, env->GetArrayLength(reinterpret_cast<jarray>(o77)));
1862 EXPECT_EQ(78, env->GetArrayLength(reinterpret_cast<jarray>(o78)));
1863 EXPECT_EQ(79, env->GetArrayLength(reinterpret_cast<jarray>(o79)));
1864 EXPECT_EQ(80, env->GetArrayLength(reinterpret_cast<jarray>(o80)));
1865 EXPECT_EQ(81, env->GetArrayLength(reinterpret_cast<jarray>(o81)));
1866 EXPECT_EQ(82, env->GetArrayLength(reinterpret_cast<jarray>(o82)));
1867 EXPECT_EQ(83, env->GetArrayLength(reinterpret_cast<jarray>(o83)));
1868 EXPECT_EQ(84, env->GetArrayLength(reinterpret_cast<jarray>(o84)));
1869 EXPECT_EQ(85, env->GetArrayLength(reinterpret_cast<jarray>(o85)));
1870 EXPECT_EQ(86, env->GetArrayLength(reinterpret_cast<jarray>(o86)));
1871 EXPECT_EQ(87, env->GetArrayLength(reinterpret_cast<jarray>(o87)));
1872 EXPECT_EQ(88, env->GetArrayLength(reinterpret_cast<jarray>(o88)));
1873 EXPECT_EQ(89, env->GetArrayLength(reinterpret_cast<jarray>(o89)));
1874 EXPECT_EQ(90, env->GetArrayLength(reinterpret_cast<jarray>(o90)));
1875 EXPECT_EQ(91, env->GetArrayLength(reinterpret_cast<jarray>(o91)));
1876 EXPECT_EQ(92, env->GetArrayLength(reinterpret_cast<jarray>(o92)));
1877 EXPECT_EQ(93, env->GetArrayLength(reinterpret_cast<jarray>(o93)));
1878 EXPECT_EQ(94, env->GetArrayLength(reinterpret_cast<jarray>(o94)));
1879 EXPECT_EQ(95, env->GetArrayLength(reinterpret_cast<jarray>(o95)));
1880 EXPECT_EQ(96, env->GetArrayLength(reinterpret_cast<jarray>(o96)));
1881 EXPECT_EQ(97, env->GetArrayLength(reinterpret_cast<jarray>(o97)));
1882 EXPECT_EQ(98, env->GetArrayLength(reinterpret_cast<jarray>(o98)));
1883 EXPECT_EQ(99, env->GetArrayLength(reinterpret_cast<jarray>(o99)));
1884 EXPECT_EQ(100, env->GetArrayLength(reinterpret_cast<jarray>(o100)));
1885 EXPECT_EQ(101, env->GetArrayLength(reinterpret_cast<jarray>(o101)));
1886 EXPECT_EQ(102, env->GetArrayLength(reinterpret_cast<jarray>(o102)));
1887 EXPECT_EQ(103, env->GetArrayLength(reinterpret_cast<jarray>(o103)));
1888 EXPECT_EQ(104, env->GetArrayLength(reinterpret_cast<jarray>(o104)));
1889 EXPECT_EQ(105, env->GetArrayLength(reinterpret_cast<jarray>(o105)));
1890 EXPECT_EQ(106, env->GetArrayLength(reinterpret_cast<jarray>(o106)));
1891 EXPECT_EQ(107, env->GetArrayLength(reinterpret_cast<jarray>(o107)));
1892 EXPECT_EQ(108, env->GetArrayLength(reinterpret_cast<jarray>(o108)));
1893 EXPECT_EQ(109, env->GetArrayLength(reinterpret_cast<jarray>(o109)));
1894 EXPECT_EQ(110, env->GetArrayLength(reinterpret_cast<jarray>(o110)));
1895 EXPECT_EQ(111, env->GetArrayLength(reinterpret_cast<jarray>(o111)));
1896 EXPECT_EQ(112, env->GetArrayLength(reinterpret_cast<jarray>(o112)));
1897 EXPECT_EQ(113, env->GetArrayLength(reinterpret_cast<jarray>(o113)));
1898 EXPECT_EQ(114, env->GetArrayLength(reinterpret_cast<jarray>(o114)));
1899 EXPECT_EQ(115, env->GetArrayLength(reinterpret_cast<jarray>(o115)));
1900 EXPECT_EQ(116, env->GetArrayLength(reinterpret_cast<jarray>(o116)));
1901 EXPECT_EQ(117, env->GetArrayLength(reinterpret_cast<jarray>(o117)));
1902 EXPECT_EQ(118, env->GetArrayLength(reinterpret_cast<jarray>(o118)));
1903 EXPECT_EQ(119, env->GetArrayLength(reinterpret_cast<jarray>(o119)));
1904 EXPECT_EQ(120, env->GetArrayLength(reinterpret_cast<jarray>(o120)));
1905 EXPECT_EQ(121, env->GetArrayLength(reinterpret_cast<jarray>(o121)));
1906 EXPECT_EQ(122, env->GetArrayLength(reinterpret_cast<jarray>(o122)));
1907 EXPECT_EQ(123, env->GetArrayLength(reinterpret_cast<jarray>(o123)));
1908 EXPECT_EQ(124, env->GetArrayLength(reinterpret_cast<jarray>(o124)));
1909 EXPECT_EQ(125, env->GetArrayLength(reinterpret_cast<jarray>(o125)));
1910 EXPECT_EQ(126, env->GetArrayLength(reinterpret_cast<jarray>(o126)));
1911 EXPECT_EQ(127, env->GetArrayLength(reinterpret_cast<jarray>(o127)));
1912 EXPECT_EQ(128, env->GetArrayLength(reinterpret_cast<jarray>(o128)));
1913 EXPECT_EQ(129, env->GetArrayLength(reinterpret_cast<jarray>(o129)));
1914 EXPECT_EQ(130, env->GetArrayLength(reinterpret_cast<jarray>(o130)));
1915 EXPECT_EQ(131, env->GetArrayLength(reinterpret_cast<jarray>(o131)));
1916 EXPECT_EQ(132, env->GetArrayLength(reinterpret_cast<jarray>(o132)));
1917 EXPECT_EQ(133, env->GetArrayLength(reinterpret_cast<jarray>(o133)));
1918 EXPECT_EQ(134, env->GetArrayLength(reinterpret_cast<jarray>(o134)));
1919 EXPECT_EQ(135, env->GetArrayLength(reinterpret_cast<jarray>(o135)));
1920 EXPECT_EQ(136, env->GetArrayLength(reinterpret_cast<jarray>(o136)));
1921 EXPECT_EQ(137, env->GetArrayLength(reinterpret_cast<jarray>(o137)));
1922 EXPECT_EQ(138, env->GetArrayLength(reinterpret_cast<jarray>(o138)));
1923 EXPECT_EQ(139, env->GetArrayLength(reinterpret_cast<jarray>(o139)));
1924 EXPECT_EQ(140, env->GetArrayLength(reinterpret_cast<jarray>(o140)));
1925 EXPECT_EQ(141, env->GetArrayLength(reinterpret_cast<jarray>(o141)));
1926 EXPECT_EQ(142, env->GetArrayLength(reinterpret_cast<jarray>(o142)));
1927 EXPECT_EQ(143, env->GetArrayLength(reinterpret_cast<jarray>(o143)));
1928 EXPECT_EQ(144, env->GetArrayLength(reinterpret_cast<jarray>(o144)));
1929 EXPECT_EQ(145, env->GetArrayLength(reinterpret_cast<jarray>(o145)));
1930 EXPECT_EQ(146, env->GetArrayLength(reinterpret_cast<jarray>(o146)));
1931 EXPECT_EQ(147, env->GetArrayLength(reinterpret_cast<jarray>(o147)));
1932 EXPECT_EQ(148, env->GetArrayLength(reinterpret_cast<jarray>(o148)));
1933 EXPECT_EQ(149, env->GetArrayLength(reinterpret_cast<jarray>(o149)));
1934 EXPECT_EQ(150, env->GetArrayLength(reinterpret_cast<jarray>(o150)));
1935 EXPECT_EQ(151, env->GetArrayLength(reinterpret_cast<jarray>(o151)));
1936 EXPECT_EQ(152, env->GetArrayLength(reinterpret_cast<jarray>(o152)));
1937 EXPECT_EQ(153, env->GetArrayLength(reinterpret_cast<jarray>(o153)));
1938 EXPECT_EQ(154, env->GetArrayLength(reinterpret_cast<jarray>(o154)));
1939 EXPECT_EQ(155, env->GetArrayLength(reinterpret_cast<jarray>(o155)));
1940 EXPECT_EQ(156, env->GetArrayLength(reinterpret_cast<jarray>(o156)));
1941 EXPECT_EQ(157, env->GetArrayLength(reinterpret_cast<jarray>(o157)));
1942 EXPECT_EQ(158, env->GetArrayLength(reinterpret_cast<jarray>(o158)));
1943 EXPECT_EQ(159, env->GetArrayLength(reinterpret_cast<jarray>(o159)));
1944 EXPECT_EQ(160, env->GetArrayLength(reinterpret_cast<jarray>(o160)));
1945 EXPECT_EQ(161, env->GetArrayLength(reinterpret_cast<jarray>(o161)));
1946 EXPECT_EQ(162, env->GetArrayLength(reinterpret_cast<jarray>(o162)));
1947 EXPECT_EQ(163, env->GetArrayLength(reinterpret_cast<jarray>(o163)));
1948 EXPECT_EQ(164, env->GetArrayLength(reinterpret_cast<jarray>(o164)));
1949 EXPECT_EQ(165, env->GetArrayLength(reinterpret_cast<jarray>(o165)));
1950 EXPECT_EQ(166, env->GetArrayLength(reinterpret_cast<jarray>(o166)));
1951 EXPECT_EQ(167, env->GetArrayLength(reinterpret_cast<jarray>(o167)));
1952 EXPECT_EQ(168, env->GetArrayLength(reinterpret_cast<jarray>(o168)));
1953 EXPECT_EQ(169, env->GetArrayLength(reinterpret_cast<jarray>(o169)));
1954 EXPECT_EQ(170, env->GetArrayLength(reinterpret_cast<jarray>(o170)));
1955 EXPECT_EQ(171, env->GetArrayLength(reinterpret_cast<jarray>(o171)));
1956 EXPECT_EQ(172, env->GetArrayLength(reinterpret_cast<jarray>(o172)));
1957 EXPECT_EQ(173, env->GetArrayLength(reinterpret_cast<jarray>(o173)));
1958 EXPECT_EQ(174, env->GetArrayLength(reinterpret_cast<jarray>(o174)));
1959 EXPECT_EQ(175, env->GetArrayLength(reinterpret_cast<jarray>(o175)));
1960 EXPECT_EQ(176, env->GetArrayLength(reinterpret_cast<jarray>(o176)));
1961 EXPECT_EQ(177, env->GetArrayLength(reinterpret_cast<jarray>(o177)));
1962 EXPECT_EQ(178, env->GetArrayLength(reinterpret_cast<jarray>(o178)));
1963 EXPECT_EQ(179, env->GetArrayLength(reinterpret_cast<jarray>(o179)));
1964 EXPECT_EQ(180, env->GetArrayLength(reinterpret_cast<jarray>(o180)));
1965 EXPECT_EQ(181, env->GetArrayLength(reinterpret_cast<jarray>(o181)));
1966 EXPECT_EQ(182, env->GetArrayLength(reinterpret_cast<jarray>(o182)));
1967 EXPECT_EQ(183, env->GetArrayLength(reinterpret_cast<jarray>(o183)));
1968 EXPECT_EQ(184, env->GetArrayLength(reinterpret_cast<jarray>(o184)));
1969 EXPECT_EQ(185, env->GetArrayLength(reinterpret_cast<jarray>(o185)));
1970 EXPECT_EQ(186, env->GetArrayLength(reinterpret_cast<jarray>(o186)));
1971 EXPECT_EQ(187, env->GetArrayLength(reinterpret_cast<jarray>(o187)));
1972 EXPECT_EQ(188, env->GetArrayLength(reinterpret_cast<jarray>(o188)));
1973 EXPECT_EQ(189, env->GetArrayLength(reinterpret_cast<jarray>(o189)));
1974 EXPECT_EQ(190, env->GetArrayLength(reinterpret_cast<jarray>(o190)));
1975 EXPECT_EQ(191, env->GetArrayLength(reinterpret_cast<jarray>(o191)));
1976 EXPECT_EQ(192, env->GetArrayLength(reinterpret_cast<jarray>(o192)));
1977 EXPECT_EQ(193, env->GetArrayLength(reinterpret_cast<jarray>(o193)));
1978 EXPECT_EQ(194, env->GetArrayLength(reinterpret_cast<jarray>(o194)));
1979 EXPECT_EQ(195, env->GetArrayLength(reinterpret_cast<jarray>(o195)));
1980 EXPECT_EQ(196, env->GetArrayLength(reinterpret_cast<jarray>(o196)));
1981 EXPECT_EQ(197, env->GetArrayLength(reinterpret_cast<jarray>(o197)));
1982 EXPECT_EQ(198, env->GetArrayLength(reinterpret_cast<jarray>(o198)));
1983 EXPECT_EQ(199, env->GetArrayLength(reinterpret_cast<jarray>(o199)));
1984 EXPECT_EQ(200, env->GetArrayLength(reinterpret_cast<jarray>(o200)));
1985 EXPECT_EQ(201, env->GetArrayLength(reinterpret_cast<jarray>(o201)));
1986 EXPECT_EQ(202, env->GetArrayLength(reinterpret_cast<jarray>(o202)));
1987 EXPECT_EQ(203, env->GetArrayLength(reinterpret_cast<jarray>(o203)));
1988 EXPECT_EQ(204, env->GetArrayLength(reinterpret_cast<jarray>(o204)));
1989 EXPECT_EQ(205, env->GetArrayLength(reinterpret_cast<jarray>(o205)));
1990 EXPECT_EQ(206, env->GetArrayLength(reinterpret_cast<jarray>(o206)));
1991 EXPECT_EQ(207, env->GetArrayLength(reinterpret_cast<jarray>(o207)));
1992 EXPECT_EQ(208, env->GetArrayLength(reinterpret_cast<jarray>(o208)));
1993 EXPECT_EQ(209, env->GetArrayLength(reinterpret_cast<jarray>(o209)));
1994 EXPECT_EQ(210, env->GetArrayLength(reinterpret_cast<jarray>(o210)));
1995 EXPECT_EQ(211, env->GetArrayLength(reinterpret_cast<jarray>(o211)));
1996 EXPECT_EQ(212, env->GetArrayLength(reinterpret_cast<jarray>(o212)));
1997 EXPECT_EQ(213, env->GetArrayLength(reinterpret_cast<jarray>(o213)));
1998 EXPECT_EQ(214, env->GetArrayLength(reinterpret_cast<jarray>(o214)));
1999 EXPECT_EQ(215, env->GetArrayLength(reinterpret_cast<jarray>(o215)));
2000 EXPECT_EQ(216, env->GetArrayLength(reinterpret_cast<jarray>(o216)));
2001 EXPECT_EQ(217, env->GetArrayLength(reinterpret_cast<jarray>(o217)));
2002 EXPECT_EQ(218, env->GetArrayLength(reinterpret_cast<jarray>(o218)));
2003 EXPECT_EQ(219, env->GetArrayLength(reinterpret_cast<jarray>(o219)));
2004 EXPECT_EQ(220, env->GetArrayLength(reinterpret_cast<jarray>(o220)));
2005 EXPECT_EQ(221, env->GetArrayLength(reinterpret_cast<jarray>(o221)));
2006 EXPECT_EQ(222, env->GetArrayLength(reinterpret_cast<jarray>(o222)));
2007 EXPECT_EQ(223, env->GetArrayLength(reinterpret_cast<jarray>(o223)));
2008 EXPECT_EQ(224, env->GetArrayLength(reinterpret_cast<jarray>(o224)));
2009 EXPECT_EQ(225, env->GetArrayLength(reinterpret_cast<jarray>(o225)));
2010 EXPECT_EQ(226, env->GetArrayLength(reinterpret_cast<jarray>(o226)));
2011 EXPECT_EQ(227, env->GetArrayLength(reinterpret_cast<jarray>(o227)));
2012 EXPECT_EQ(228, env->GetArrayLength(reinterpret_cast<jarray>(o228)));
2013 EXPECT_EQ(229, env->GetArrayLength(reinterpret_cast<jarray>(o229)));
2014 EXPECT_EQ(230, env->GetArrayLength(reinterpret_cast<jarray>(o230)));
2015 EXPECT_EQ(231, env->GetArrayLength(reinterpret_cast<jarray>(o231)));
2016 EXPECT_EQ(232, env->GetArrayLength(reinterpret_cast<jarray>(o232)));
2017 EXPECT_EQ(233, env->GetArrayLength(reinterpret_cast<jarray>(o233)));
2018 EXPECT_EQ(234, env->GetArrayLength(reinterpret_cast<jarray>(o234)));
2019 EXPECT_EQ(235, env->GetArrayLength(reinterpret_cast<jarray>(o235)));
2020 EXPECT_EQ(236, env->GetArrayLength(reinterpret_cast<jarray>(o236)));
2021 EXPECT_EQ(237, env->GetArrayLength(reinterpret_cast<jarray>(o237)));
2022 EXPECT_EQ(238, env->GetArrayLength(reinterpret_cast<jarray>(o238)));
2023 EXPECT_EQ(239, env->GetArrayLength(reinterpret_cast<jarray>(o239)));
2024 EXPECT_EQ(240, env->GetArrayLength(reinterpret_cast<jarray>(o240)));
2025 EXPECT_EQ(241, env->GetArrayLength(reinterpret_cast<jarray>(o241)));
2026 EXPECT_EQ(242, env->GetArrayLength(reinterpret_cast<jarray>(o242)));
2027 EXPECT_EQ(243, env->GetArrayLength(reinterpret_cast<jarray>(o243)));
2028 EXPECT_EQ(244, env->GetArrayLength(reinterpret_cast<jarray>(o244)));
2029 EXPECT_EQ(245, env->GetArrayLength(reinterpret_cast<jarray>(o245)));
2030 EXPECT_EQ(246, env->GetArrayLength(reinterpret_cast<jarray>(o246)));
2031 EXPECT_EQ(247, env->GetArrayLength(reinterpret_cast<jarray>(o247)));
2032 EXPECT_EQ(248, env->GetArrayLength(reinterpret_cast<jarray>(o248)));
2033 EXPECT_EQ(249, env->GetArrayLength(reinterpret_cast<jarray>(o249)));
2034 EXPECT_EQ(250, env->GetArrayLength(reinterpret_cast<jarray>(o250)));
2035 EXPECT_EQ(251, env->GetArrayLength(reinterpret_cast<jarray>(o251)));
2036 EXPECT_EQ(252, env->GetArrayLength(reinterpret_cast<jarray>(o252)));
2037 EXPECT_EQ(253, env->GetArrayLength(reinterpret_cast<jarray>(o253)));
2038 }
2039 }
2040
2041 const char* longSig =
2042 "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2043 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2044 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2045 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2046 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2047 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2048 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2049 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2050 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2051 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2052 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2053 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2054 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2055 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2056 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2057 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2058 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2059 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2060 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2061 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2062 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2063 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2064 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2065 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2066 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2067 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2068 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2069 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2070 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2071 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2072 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2073 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2074 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2075 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2076 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2077 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2078 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2079 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2080 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2081 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2082 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2083 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2084 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2085 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2086 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2087 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2088 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2089 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2090 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2091 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2092 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V";
2093
MaxParamNumberImpl()2094 void JniCompilerTest::MaxParamNumberImpl() {
2095 SetUpForTest(false, "maxParamNumber", longSig,
2096 CURRENT_JNI_WRAPPER(Java_MyClassNatives_maxParamNumber));
2097
2098 jvalue args[254];
2099
2100 // First test: test with all arguments null.
2101 for (int i = 0; i < 254; ++i) {
2102 args[i].l = nullptr;
2103 }
2104
2105 env_->CallNonvirtualVoidMethodA(jobj_, jklass_, jmethod_, args);
2106
2107 // Second test: test with int[] objects with increasing lengths
2108 for (int i = 0; i < 254; ++i) {
2109 jintArray tmp = env_->NewIntArray(i);
2110 args[i].l = tmp;
2111 EXPECT_NE(args[i].l, nullptr);
2112 }
2113
2114 env_->CallNonvirtualVoidMethodA(jobj_, jklass_, jmethod_, args);
2115 }
2116
JNI_TEST(MaxParamNumber)2117 JNI_TEST(MaxParamNumber)
2118
2119 void JniCompilerTest::WithoutImplementationImpl() {
2120 // This will lead to error messages in the log.
2121 ScopedLogSeverity sls(LogSeverity::FATAL);
2122
2123 SetUpForTest(false, "withoutImplementation", "()V", NORMAL_OR_FAST_JNI_ONLY_NULLPTR);
2124
2125 env_->CallVoidMethod(jobj_, jmethod_);
2126
2127 EXPECT_TRUE(Thread::Current()->IsExceptionPending());
2128 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
2129 }
2130
JNI_TEST(WithoutImplementation)2131 JNI_TEST(WithoutImplementation)
2132
2133 void JniCompilerTest::WithoutImplementationRefReturnImpl() {
2134 // This will lead to error messages in the log.
2135 ScopedLogSeverity sls(LogSeverity::FATAL);
2136
2137 SetUpForTest(false,
2138 "withoutImplementationRefReturn",
2139 "()Ljava/lang/Object;",
2140 NORMAL_OR_FAST_JNI_ONLY_NULLPTR);
2141
2142 env_->CallObjectMethod(jobj_, jmethod_);
2143
2144 EXPECT_TRUE(Thread::Current()->IsExceptionPending());
2145 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
2146 }
2147
JNI_TEST(WithoutImplementationRefReturn)2148 JNI_TEST(WithoutImplementationRefReturn)
2149
2150 void JniCompilerTest::StaticWithoutImplementationImpl() {
2151 // This will lead to error messages in the log.
2152 ScopedLogSeverity sls(LogSeverity::FATAL);
2153
2154 SetUpForTest(true, "staticWithoutImplementation", "()V", nullptr);
2155
2156 env_->CallStaticVoidMethod(jklass_, jmethod_);
2157
2158 EXPECT_TRUE(Thread::Current()->IsExceptionPending());
2159 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
2160 }
2161
JNI_TEST_CRITICAL(StaticWithoutImplementation)2162 JNI_TEST_CRITICAL(StaticWithoutImplementation)
2163
2164 void Java_MyClassNatives_stackArgsIntsFirst(JNIEnv*, jclass, jint i1, jint i2, jint i3,
2165 jint i4, jint i5, jint i6, jint i7, jint i8, jint i9,
2166 jint i10, jfloat f1, jfloat f2, jfloat f3, jfloat f4,
2167 jfloat f5, jfloat f6, jfloat f7, jfloat f8, jfloat f9,
2168 jfloat f10) {
2169 EXPECT_EQ(i1, 1);
2170 EXPECT_EQ(i2, 2);
2171 EXPECT_EQ(i3, 3);
2172 EXPECT_EQ(i4, 4);
2173 EXPECT_EQ(i5, 5);
2174 EXPECT_EQ(i6, 6);
2175 EXPECT_EQ(i7, 7);
2176 EXPECT_EQ(i8, 8);
2177 EXPECT_EQ(i9, 9);
2178 EXPECT_EQ(i10, 10);
2179
2180 jint i11 = bit_cast<jint, jfloat>(f1);
2181 EXPECT_EQ(i11, 11);
2182 jint i12 = bit_cast<jint, jfloat>(f2);
2183 EXPECT_EQ(i12, 12);
2184 jint i13 = bit_cast<jint, jfloat>(f3);
2185 EXPECT_EQ(i13, 13);
2186 jint i14 = bit_cast<jint, jfloat>(f4);
2187 EXPECT_EQ(i14, 14);
2188 jint i15 = bit_cast<jint, jfloat>(f5);
2189 EXPECT_EQ(i15, 15);
2190 jint i16 = bit_cast<jint, jfloat>(f6);
2191 EXPECT_EQ(i16, 16);
2192 jint i17 = bit_cast<jint, jfloat>(f7);
2193 EXPECT_EQ(i17, 17);
2194 jint i18 = bit_cast<jint, jfloat>(f8);
2195 EXPECT_EQ(i18, 18);
2196 jint i19 = bit_cast<jint, jfloat>(f9);
2197 EXPECT_EQ(i19, 19);
2198 jint i20 = bit_cast<jint, jfloat>(f10);
2199 EXPECT_EQ(i20, 20);
2200 }
2201
StackArgsIntsFirstImpl()2202 void JniCompilerTest::StackArgsIntsFirstImpl() {
2203 SetUpForTest(true, "stackArgsIntsFirst", "(IIIIIIIIIIFFFFFFFFFF)V",
2204 CURRENT_JNI_WRAPPER(Java_MyClassNatives_stackArgsIntsFirst));
2205
2206 jint i1 = 1;
2207 jint i2 = 2;
2208 jint i3 = 3;
2209 jint i4 = 4;
2210 jint i5 = 5;
2211 jint i6 = 6;
2212 jint i7 = 7;
2213 jint i8 = 8;
2214 jint i9 = 9;
2215 jint i10 = 10;
2216
2217 jfloat f1 = bit_cast<jfloat, jint>(11);
2218 jfloat f2 = bit_cast<jfloat, jint>(12);
2219 jfloat f3 = bit_cast<jfloat, jint>(13);
2220 jfloat f4 = bit_cast<jfloat, jint>(14);
2221 jfloat f5 = bit_cast<jfloat, jint>(15);
2222 jfloat f6 = bit_cast<jfloat, jint>(16);
2223 jfloat f7 = bit_cast<jfloat, jint>(17);
2224 jfloat f8 = bit_cast<jfloat, jint>(18);
2225 jfloat f9 = bit_cast<jfloat, jint>(19);
2226 jfloat f10 = bit_cast<jfloat, jint>(20);
2227
2228 env_->CallStaticVoidMethod(jklass_, jmethod_, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, f1, f2,
2229 f3, f4, f5, f6, f7, f8, f9, f10);
2230 }
2231
JNI_TEST_CRITICAL(StackArgsIntsFirst)2232 JNI_TEST_CRITICAL(StackArgsIntsFirst)
2233
2234 void Java_MyClassNatives_stackArgsFloatsFirst(JNIEnv*, jclass, jfloat f1, jfloat f2,
2235 jfloat f3, jfloat f4, jfloat f5, jfloat f6, jfloat f7,
2236 jfloat f8, jfloat f9, jfloat f10, jint i1, jint i2,
2237 jint i3, jint i4, jint i5, jint i6, jint i7, jint i8,
2238 jint i9, jint i10) {
2239 EXPECT_EQ(i1, 1);
2240 EXPECT_EQ(i2, 2);
2241 EXPECT_EQ(i3, 3);
2242 EXPECT_EQ(i4, 4);
2243 EXPECT_EQ(i5, 5);
2244 EXPECT_EQ(i6, 6);
2245 EXPECT_EQ(i7, 7);
2246 EXPECT_EQ(i8, 8);
2247 EXPECT_EQ(i9, 9);
2248 EXPECT_EQ(i10, 10);
2249
2250 jint i11 = bit_cast<jint, jfloat>(f1);
2251 EXPECT_EQ(i11, 11);
2252 jint i12 = bit_cast<jint, jfloat>(f2);
2253 EXPECT_EQ(i12, 12);
2254 jint i13 = bit_cast<jint, jfloat>(f3);
2255 EXPECT_EQ(i13, 13);
2256 jint i14 = bit_cast<jint, jfloat>(f4);
2257 EXPECT_EQ(i14, 14);
2258 jint i15 = bit_cast<jint, jfloat>(f5);
2259 EXPECT_EQ(i15, 15);
2260 jint i16 = bit_cast<jint, jfloat>(f6);
2261 EXPECT_EQ(i16, 16);
2262 jint i17 = bit_cast<jint, jfloat>(f7);
2263 EXPECT_EQ(i17, 17);
2264 jint i18 = bit_cast<jint, jfloat>(f8);
2265 EXPECT_EQ(i18, 18);
2266 jint i19 = bit_cast<jint, jfloat>(f9);
2267 EXPECT_EQ(i19, 19);
2268 jint i20 = bit_cast<jint, jfloat>(f10);
2269 EXPECT_EQ(i20, 20);
2270 }
2271
StackArgsFloatsFirstImpl()2272 void JniCompilerTest::StackArgsFloatsFirstImpl() {
2273 SetUpForTest(true, "stackArgsFloatsFirst", "(FFFFFFFFFFIIIIIIIIII)V",
2274 CURRENT_JNI_WRAPPER(Java_MyClassNatives_stackArgsFloatsFirst));
2275
2276 jint i1 = 1;
2277 jint i2 = 2;
2278 jint i3 = 3;
2279 jint i4 = 4;
2280 jint i5 = 5;
2281 jint i6 = 6;
2282 jint i7 = 7;
2283 jint i8 = 8;
2284 jint i9 = 9;
2285 jint i10 = 10;
2286
2287 jfloat f1 = bit_cast<jfloat, jint>(11);
2288 jfloat f2 = bit_cast<jfloat, jint>(12);
2289 jfloat f3 = bit_cast<jfloat, jint>(13);
2290 jfloat f4 = bit_cast<jfloat, jint>(14);
2291 jfloat f5 = bit_cast<jfloat, jint>(15);
2292 jfloat f6 = bit_cast<jfloat, jint>(16);
2293 jfloat f7 = bit_cast<jfloat, jint>(17);
2294 jfloat f8 = bit_cast<jfloat, jint>(18);
2295 jfloat f9 = bit_cast<jfloat, jint>(19);
2296 jfloat f10 = bit_cast<jfloat, jint>(20);
2297
2298 env_->CallStaticVoidMethod(jklass_, jmethod_, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, i1, i2, i3,
2299 i4, i5, i6, i7, i8, i9, i10);
2300 }
2301
JNI_TEST_CRITICAL(StackArgsFloatsFirst)2302 JNI_TEST_CRITICAL(StackArgsFloatsFirst)
2303
2304 void Java_MyClassNatives_stackArgsMixed(JNIEnv*, jclass, jint i1, jfloat f1, jint i2,
2305 jfloat f2, jint i3, jfloat f3, jint i4, jfloat f4, jint i5,
2306 jfloat f5, jint i6, jfloat f6, jint i7, jfloat f7, jint i8,
2307 jfloat f8, jint i9, jfloat f9, jint i10, jfloat f10) {
2308 EXPECT_EQ(i1, 1);
2309 EXPECT_EQ(i2, 2);
2310 EXPECT_EQ(i3, 3);
2311 EXPECT_EQ(i4, 4);
2312 EXPECT_EQ(i5, 5);
2313 EXPECT_EQ(i6, 6);
2314 EXPECT_EQ(i7, 7);
2315 EXPECT_EQ(i8, 8);
2316 EXPECT_EQ(i9, 9);
2317 EXPECT_EQ(i10, 10);
2318
2319 jint i11 = bit_cast<jint, jfloat>(f1);
2320 EXPECT_EQ(i11, 11);
2321 jint i12 = bit_cast<jint, jfloat>(f2);
2322 EXPECT_EQ(i12, 12);
2323 jint i13 = bit_cast<jint, jfloat>(f3);
2324 EXPECT_EQ(i13, 13);
2325 jint i14 = bit_cast<jint, jfloat>(f4);
2326 EXPECT_EQ(i14, 14);
2327 jint i15 = bit_cast<jint, jfloat>(f5);
2328 EXPECT_EQ(i15, 15);
2329 jint i16 = bit_cast<jint, jfloat>(f6);
2330 EXPECT_EQ(i16, 16);
2331 jint i17 = bit_cast<jint, jfloat>(f7);
2332 EXPECT_EQ(i17, 17);
2333 jint i18 = bit_cast<jint, jfloat>(f8);
2334 EXPECT_EQ(i18, 18);
2335 jint i19 = bit_cast<jint, jfloat>(f9);
2336 EXPECT_EQ(i19, 19);
2337 jint i20 = bit_cast<jint, jfloat>(f10);
2338 EXPECT_EQ(i20, 20);
2339 }
2340
StackArgsMixedImpl()2341 void JniCompilerTest::StackArgsMixedImpl() {
2342 SetUpForTest(true, "stackArgsMixed", "(IFIFIFIFIFIFIFIFIFIF)V",
2343 CURRENT_JNI_WRAPPER(Java_MyClassNatives_stackArgsMixed));
2344
2345 jint i1 = 1;
2346 jint i2 = 2;
2347 jint i3 = 3;
2348 jint i4 = 4;
2349 jint i5 = 5;
2350 jint i6 = 6;
2351 jint i7 = 7;
2352 jint i8 = 8;
2353 jint i9 = 9;
2354 jint i10 = 10;
2355
2356 jfloat f1 = bit_cast<jfloat, jint>(11);
2357 jfloat f2 = bit_cast<jfloat, jint>(12);
2358 jfloat f3 = bit_cast<jfloat, jint>(13);
2359 jfloat f4 = bit_cast<jfloat, jint>(14);
2360 jfloat f5 = bit_cast<jfloat, jint>(15);
2361 jfloat f6 = bit_cast<jfloat, jint>(16);
2362 jfloat f7 = bit_cast<jfloat, jint>(17);
2363 jfloat f8 = bit_cast<jfloat, jint>(18);
2364 jfloat f9 = bit_cast<jfloat, jint>(19);
2365 jfloat f10 = bit_cast<jfloat, jint>(20);
2366
2367 env_->CallStaticVoidMethod(jklass_, jmethod_, i1, f1, i2, f2, i3, f3, i4, f4, i5, f5, i6, f6, i7,
2368 f7, i8, f8, i9, f9, i10, f10);
2369 }
2370
JNI_TEST_CRITICAL(StackArgsMixed)2371 JNI_TEST_CRITICAL(StackArgsMixed)
2372
2373 void Java_MyClassNatives_normalNative(JNIEnv*, jclass) {
2374 // Intentionally left empty.
2375 }
2376
2377 // Methods not annotated with anything are not considered "fast native"
2378 // -- Check that the annotation lookup does not find it.
NormalNativeImpl()2379 void JniCompilerTest::NormalNativeImpl() {
2380 SetUpForTest(/* direct= */ true,
2381 "normalNative",
2382 "()V",
2383 CURRENT_JNI_WRAPPER(Java_MyClassNatives_normalNative));
2384
2385 ArtMethod* method = jni::DecodeArtMethod(jmethod_);
2386 ASSERT_TRUE(method != nullptr);
2387
2388 EXPECT_FALSE(method->IsCriticalNative());
2389 EXPECT_FALSE(method->IsFastNative());
2390 }
2391
2392 // TODO: just rename the java functions to the standard convention and remove duplicated tests
JNI_TEST_NORMAL_ONLY(NormalNative)2393 JNI_TEST_NORMAL_ONLY(NormalNative)
2394
2395 // Methods annotated with @FastNative are considered "fast native"
2396 // -- Check that the annotation lookup succeeds.
2397 void Java_MyClassNatives_fastNative(JNIEnv*, jclass) {
2398 // Intentionally left empty.
2399 }
2400
FastNativeImpl()2401 void JniCompilerTest::FastNativeImpl() {
2402 SetUpForTest(/* direct= */ true,
2403 "fastNative",
2404 "()V",
2405 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fastNative));
2406
2407 ArtMethod* method = jni::DecodeArtMethod(jmethod_);
2408 ASSERT_TRUE(method != nullptr);
2409
2410 EXPECT_FALSE(method->IsCriticalNative());
2411 EXPECT_TRUE(method->IsFastNative());
2412 }
2413
2414 // TODO: just rename the java functions to the standard convention and remove duplicated tests
2415 JNI_TEST_NORMAL_ONLY(FastNative)
2416
2417 int gJava_myClassNatives_criticalNative_calls[kJniKindCount] = {};
2418 // Methods annotated with @CriticalNative are considered "critical native"
2419 // -- Check that the annotation lookup succeeds.
Java_MyClassNatives_criticalNative()2420 void Java_MyClassNatives_criticalNative() {
2421 gJava_myClassNatives_criticalNative_calls[gCurrentJni]++;
2422 }
2423
CriticalNativeImpl()2424 void JniCompilerTest::CriticalNativeImpl() {
2425 SetUpForTest(/* direct= */ true,
2426 // Important: Don't change the "current jni" yet to avoid a method name suffix.
2427 "criticalNative",
2428 "()V",
2429 // TODO: Use CURRENT_JNI_WRAPPER instead which is more generic.
2430 reinterpret_cast<void*>(&Java_MyClassNatives_criticalNative));
2431
2432 // TODO: remove this manual updating of the current JNI. Merge with the other tests.
2433 UpdateCurrentJni(JniKind::kCritical);
2434 ASSERT_TRUE(IsCurrentJniCritical());
2435
2436 ArtMethod* method = jni::DecodeArtMethod(jmethod_);
2437 ASSERT_TRUE(method != nullptr);
2438
2439 EXPECT_TRUE(method->IsCriticalNative());
2440 EXPECT_FALSE(method->IsFastNative());
2441
2442 EXPECT_EQ(0, gJava_myClassNatives_criticalNative_calls[gCurrentJni]);
2443 env_->CallStaticVoidMethod(jklass_, jmethod_);
2444 EXPECT_EQ(1, gJava_myClassNatives_criticalNative_calls[gCurrentJni]);
2445
2446 gJava_myClassNatives_criticalNative_calls[gCurrentJni] = 0;
2447 }
2448
2449 // TODO: just rename the java functions to the standard convention and remove duplicated tests
2450 JNI_TEST_NORMAL_ONLY(CriticalNative)
2451
2452 } // namespace art
2453