1 /*
2  * Copyright (C) 2015 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 "unstarted_runtime.h"
18 
19 #include <limits>
20 #include <locale>
21 
22 #include "base/casts.h"
23 #include "base/enums.h"
24 #include "base/memory_tool.h"
25 #include "class_linker.h"
26 #include "class_root.h"
27 #include "common_runtime_test.h"
28 #include "dex/descriptors_names.h"
29 #include "dex/dex_instruction.h"
30 #include "handle.h"
31 #include "handle_scope-inl.h"
32 #include "interpreter/interpreter_common.h"
33 #include "mirror/array-alloc-inl.h"
34 #include "mirror/class-alloc-inl.h"
35 #include "mirror/class_loader.h"
36 #include "mirror/object-inl.h"
37 #include "mirror/object_array-alloc-inl.h"
38 #include "mirror/object_array-inl.h"
39 #include "mirror/string-inl.h"
40 #include "runtime.h"
41 #include "scoped_thread_state_change-inl.h"
42 #include "shadow_frame-inl.h"
43 #include "thread.h"
44 #include "transaction.h"
45 
46 namespace art {
47 namespace interpreter {
48 
49 // Deleter to be used with ShadowFrame::CreateDeoptimizedFrame objects.
50 struct DeoptShadowFrameDelete {
51   // NOTE: Deleting a const object is valid but free() takes a non-const pointer.
operator ()art::interpreter::DeoptShadowFrameDelete52   void operator()(ShadowFrame* ptr) const {
53     if (ptr != nullptr) {
54       ShadowFrame::DeleteDeoptimizedFrame(ptr);
55     }
56   }
57 };
58 // Alias for std::unique_ptr<> that uses the above deleter.
59 using UniqueDeoptShadowFramePtr = std::unique_ptr<ShadowFrame, DeoptShadowFrameDelete>;
60 
61 class UnstartedRuntimeTest : public CommonRuntimeTest {
62  protected:
63   // Re-expose all UnstartedRuntime implementations so we don't need to declare a million
64   // test friends.
65 
66   // Methods that intercept available libcore implementations.
67 #define UNSTARTED_DIRECT(Name, SigIgnored)                 \
68   static void Unstarted ## Name(Thread* self,              \
69                                 ShadowFrame* shadow_frame, \
70                                 JValue* result,            \
71                                 size_t arg_offset)         \
72       REQUIRES_SHARED(Locks::mutator_lock_) {        \
73     interpreter::UnstartedRuntime::Unstarted ## Name(self, shadow_frame, result, arg_offset); \
74   }
75 #include "unstarted_runtime_list.h"
76   UNSTARTED_RUNTIME_DIRECT_LIST(UNSTARTED_DIRECT)
77 #undef UNSTARTED_RUNTIME_DIRECT_LIST
78 #undef UNSTARTED_RUNTIME_JNI_LIST
79 #undef UNSTARTED_DIRECT
80 
81   // Methods that are native.
82 #define UNSTARTED_JNI(Name, SigIgnored)                       \
83   static void UnstartedJNI ## Name(Thread* self,              \
84                                    ArtMethod* method,         \
85                                    mirror::Object* receiver,  \
86                                    uint32_t* args,            \
87                                    JValue* result)            \
88       REQUIRES_SHARED(Locks::mutator_lock_) {           \
89     interpreter::UnstartedRuntime::UnstartedJNI ## Name(self, method, receiver, args, result); \
90   }
91 #include "unstarted_runtime_list.h"
UNSTARTED_RUNTIME_JNI_LIST(UNSTARTED_JNI)92   UNSTARTED_RUNTIME_JNI_LIST(UNSTARTED_JNI)
93 #undef UNSTARTED_RUNTIME_DIRECT_LIST
94 #undef UNSTARTED_RUNTIME_JNI_LIST
95 #undef UNSTARTED_JNI
96 
97   UniqueDeoptShadowFramePtr CreateShadowFrame(uint32_t num_vregs,
98                                               ShadowFrame* link,
99                                               ArtMethod* method,
100                                               uint32_t dex_pc) {
101     return UniqueDeoptShadowFramePtr(
102         ShadowFrame::CreateDeoptimizedFrame(num_vregs, link, method, dex_pc));
103   }
104 
105   // Helpers for ArrayCopy.
106   //
107   // Note: as we have to use handles, we use StackHandleScope to transfer data. Hardcode a size
108   //       of three everywhere. That is enough to test all cases.
109 
CreateObjectArray(Thread * self,ObjPtr<mirror::Class> component_type,const StackHandleScope<3> & data)110   static ObjPtr<mirror::ObjectArray<mirror::Object>> CreateObjectArray(
111       Thread* self,
112       ObjPtr<mirror::Class> component_type,
113       const StackHandleScope<3>& data)
114       REQUIRES_SHARED(Locks::mutator_lock_) {
115     Runtime* runtime = Runtime::Current();
116     ObjPtr<mirror::Class> array_type =
117         runtime->GetClassLinker()->FindArrayClass(self, component_type);
118     CHECK(array_type != nullptr);
119     ObjPtr<mirror::ObjectArray<mirror::Object>> result =
120         mirror::ObjectArray<mirror::Object>::Alloc(self, array_type, 3);
121     CHECK(result != nullptr);
122     for (size_t i = 0; i < 3; ++i) {
123       result->Set(static_cast<int32_t>(i), data.GetReference(i));
124       CHECK(!self->IsExceptionPending());
125     }
126     return result;
127   }
128 
CheckObjectArray(ObjPtr<mirror::ObjectArray<mirror::Object>> array,const StackHandleScope<3> & data)129   static void CheckObjectArray(ObjPtr<mirror::ObjectArray<mirror::Object>> array,
130                                const StackHandleScope<3>& data)
131       REQUIRES_SHARED(Locks::mutator_lock_) {
132     CHECK_EQ(array->GetLength(), 3);
133     CHECK_EQ(data.NumberOfReferences(), 3U);
134     for (size_t i = 0; i < 3; ++i) {
135       EXPECT_OBJ_PTR_EQ(data.GetReference(i), array->Get(static_cast<int32_t>(i))) << i;
136     }
137   }
138 
RunArrayCopy(Thread * self,ShadowFrame * tmp,bool expect_exception,ObjPtr<mirror::ObjectArray<mirror::Object>> src,int32_t src_pos,ObjPtr<mirror::ObjectArray<mirror::Object>> dst,int32_t dst_pos,int32_t length)139   void RunArrayCopy(Thread* self,
140                     ShadowFrame* tmp,
141                     bool expect_exception,
142                     ObjPtr<mirror::ObjectArray<mirror::Object>> src,
143                     int32_t src_pos,
144                     ObjPtr<mirror::ObjectArray<mirror::Object>> dst,
145                     int32_t dst_pos,
146                     int32_t length)
147       REQUIRES_SHARED(Locks::mutator_lock_) {
148     JValue result;
149     tmp->SetVRegReference(0, src);
150     tmp->SetVReg(1, src_pos);
151     tmp->SetVRegReference(2, dst);
152     tmp->SetVReg(3, dst_pos);
153     tmp->SetVReg(4, length);
154     UnstartedSystemArraycopy(self, tmp, &result, 0);
155     bool exception_pending = self->IsExceptionPending();
156     EXPECT_EQ(exception_pending, expect_exception);
157     if (exception_pending) {
158       self->ClearException();
159     }
160   }
161 
RunArrayCopy(Thread * self,ShadowFrame * tmp,bool expect_exception,ObjPtr<mirror::Class> src_component_class,ObjPtr<mirror::Class> dst_component_class,const StackHandleScope<3> & src_data,int32_t src_pos,const StackHandleScope<3> & dst_data,int32_t dst_pos,int32_t length,const StackHandleScope<3> & expected_result)162   void RunArrayCopy(Thread* self,
163                     ShadowFrame* tmp,
164                     bool expect_exception,
165                     ObjPtr<mirror::Class> src_component_class,
166                     ObjPtr<mirror::Class> dst_component_class,
167                     const StackHandleScope<3>& src_data,
168                     int32_t src_pos,
169                     const StackHandleScope<3>& dst_data,
170                     int32_t dst_pos,
171                     int32_t length,
172                     const StackHandleScope<3>& expected_result)
173       REQUIRES_SHARED(Locks::mutator_lock_) {
174     StackHandleScope<3> hs_misc(self);
175     Handle<mirror::Class> dst_component_handle(hs_misc.NewHandle(dst_component_class));
176 
177     Handle<mirror::ObjectArray<mirror::Object>> src_handle(
178         hs_misc.NewHandle(CreateObjectArray(self, src_component_class, src_data)));
179 
180     Handle<mirror::ObjectArray<mirror::Object>> dst_handle(
181         hs_misc.NewHandle(CreateObjectArray(self, dst_component_handle.Get(), dst_data)));
182 
183     RunArrayCopy(self,
184                  tmp,
185                  expect_exception,
186                  src_handle.Get(),
187                  src_pos,
188                  dst_handle.Get(),
189                  dst_pos,
190                  length);
191     CheckObjectArray(dst_handle.Get(), expected_result);
192   }
193 
TestCeilFloor(bool ceil,Thread * self,ShadowFrame * tmp,double const test_pairs[][2],size_t num_pairs)194   void TestCeilFloor(bool ceil,
195                      Thread* self,
196                      ShadowFrame* tmp,
197                      double const test_pairs[][2],
198                      size_t num_pairs)
199       REQUIRES_SHARED(Locks::mutator_lock_) {
200     for (size_t i = 0; i < num_pairs; ++i) {
201       tmp->SetVRegDouble(0, test_pairs[i][0]);
202 
203       JValue result;
204       if (ceil) {
205         UnstartedMathCeil(self, tmp, &result, 0);
206       } else {
207         UnstartedMathFloor(self, tmp, &result, 0);
208       }
209 
210       ASSERT_FALSE(self->IsExceptionPending());
211 
212       // We want precise results.
213       int64_t result_int64t = bit_cast<int64_t, double>(result.GetD());
214       int64_t expect_int64t = bit_cast<int64_t, double>(test_pairs[i][1]);
215       EXPECT_EQ(expect_int64t, result_int64t) << result.GetD() << " vs " << test_pairs[i][1];
216     }
217   }
218 
219   // Prepare for aborts. Aborts assume that the exception class is already resolved, as the
220   // loading code doesn't work under transactions.
PrepareForAborts()221   void PrepareForAborts() REQUIRES_SHARED(Locks::mutator_lock_) {
222     ObjPtr<mirror::Object> result = Runtime::Current()->GetClassLinker()->FindClass(
223         Thread::Current(),
224         Transaction::kAbortExceptionSignature,
225         ScopedNullHandle<mirror::ClassLoader>());
226     CHECK(result != nullptr);
227   }
228 };
229 
TEST_F(UnstartedRuntimeTest,MemoryPeekByte)230 TEST_F(UnstartedRuntimeTest, MemoryPeekByte) {
231   Thread* self = Thread::Current();
232 
233   ScopedObjectAccess soa(self);
234   constexpr const uint8_t base_array[] = "abcdefghijklmnop";
235   constexpr int32_t kBaseLen = sizeof(base_array) / sizeof(uint8_t);
236   const uint8_t* base_ptr = base_array;
237 
238   JValue result;
239   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
240 
241   for (int32_t i = 0; i < kBaseLen; ++i) {
242     tmp->SetVRegLong(0, static_cast<int64_t>(reinterpret_cast<intptr_t>(base_ptr + i)));
243 
244     UnstartedMemoryPeekByte(self, tmp.get(), &result, 0);
245 
246     EXPECT_EQ(result.GetB(), static_cast<int8_t>(base_array[i]));
247   }
248 }
249 
TEST_F(UnstartedRuntimeTest,MemoryPeekShort)250 TEST_F(UnstartedRuntimeTest, MemoryPeekShort) {
251   Thread* self = Thread::Current();
252 
253   ScopedObjectAccess soa(self);
254   constexpr const uint8_t base_array[] = "abcdefghijklmnop";
255   constexpr int32_t kBaseLen = sizeof(base_array) / sizeof(uint8_t);
256   const uint8_t* base_ptr = base_array;
257 
258   JValue result;
259   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
260 
261   int32_t adjusted_length = kBaseLen - sizeof(int16_t);
262   for (int32_t i = 0; i < adjusted_length; ++i) {
263     tmp->SetVRegLong(0, static_cast<int64_t>(reinterpret_cast<intptr_t>(base_ptr + i)));
264 
265     UnstartedMemoryPeekShort(self, tmp.get(), &result, 0);
266 
267     using unaligned_short __attribute__((__aligned__(1))) = int16_t;
268     const unaligned_short* short_ptr = reinterpret_cast<const unaligned_short*>(base_ptr + i);
269     EXPECT_EQ(result.GetS(), *short_ptr);
270   }
271 }
272 
TEST_F(UnstartedRuntimeTest,MemoryPeekInt)273 TEST_F(UnstartedRuntimeTest, MemoryPeekInt) {
274   Thread* self = Thread::Current();
275 
276   ScopedObjectAccess soa(self);
277   constexpr const uint8_t base_array[] = "abcdefghijklmnop";
278   constexpr int32_t kBaseLen = sizeof(base_array) / sizeof(uint8_t);
279   const uint8_t* base_ptr = base_array;
280 
281   JValue result;
282   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
283 
284   int32_t adjusted_length = kBaseLen - sizeof(int32_t);
285   for (int32_t i = 0; i < adjusted_length; ++i) {
286     tmp->SetVRegLong(0, static_cast<int64_t>(reinterpret_cast<intptr_t>(base_ptr + i)));
287 
288     UnstartedMemoryPeekInt(self, tmp.get(), &result, 0);
289 
290     using unaligned_int __attribute__((__aligned__(1))) = int32_t;
291     const unaligned_int* int_ptr = reinterpret_cast<const unaligned_int*>(base_ptr + i);
292     EXPECT_EQ(result.GetI(), *int_ptr);
293   }
294 }
295 
TEST_F(UnstartedRuntimeTest,MemoryPeekLong)296 TEST_F(UnstartedRuntimeTest, MemoryPeekLong) {
297   Thread* self = Thread::Current();
298 
299   ScopedObjectAccess soa(self);
300   constexpr const uint8_t base_array[] = "abcdefghijklmnop";
301   constexpr int32_t kBaseLen = sizeof(base_array) / sizeof(uint8_t);
302   const uint8_t* base_ptr = base_array;
303 
304   JValue result;
305   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
306 
307   int32_t adjusted_length = kBaseLen - sizeof(int64_t);
308   for (int32_t i = 0; i < adjusted_length; ++i) {
309     tmp->SetVRegLong(0, static_cast<int64_t>(reinterpret_cast<intptr_t>(base_ptr + i)));
310 
311     UnstartedMemoryPeekLong(self, tmp.get(), &result, 0);
312 
313     using unaligned_long __attribute__((__aligned__(1))) = int64_t;
314     const unaligned_long* long_ptr = reinterpret_cast<const unaligned_long*>(base_ptr + i);
315     EXPECT_EQ(result.GetJ(), *long_ptr);
316   }
317 }
318 
TEST_F(UnstartedRuntimeTest,StringGetCharsNoCheck)319 TEST_F(UnstartedRuntimeTest, StringGetCharsNoCheck) {
320   Thread* self = Thread::Current();
321 
322   ScopedObjectAccess soa(self);
323   StackHandleScope<2> hs(self);
324   // TODO: Actual UTF.
325   constexpr const char base_string[] = "abcdefghijklmnop";
326   Handle<mirror::String> h_test_string(hs.NewHandle(
327       mirror::String::AllocFromModifiedUtf8(self, base_string)));
328   constexpr int32_t kBaseLen = sizeof(base_string) / sizeof(char) - 1;
329   Handle<mirror::CharArray> h_char_array(hs.NewHandle(
330       mirror::CharArray::Alloc(self, kBaseLen)));
331   // A buffer so we can make sure we only modify the elements targetted.
332   uint16_t buf[kBaseLen];
333 
334   JValue result;
335   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
336 
337   for (int32_t start_index = 0; start_index < kBaseLen; ++start_index) {
338     for (int32_t count = 0; count <= kBaseLen; ++count) {
339       for (int32_t trg_offset = 0; trg_offset < kBaseLen; ++trg_offset) {
340         // Only do it when in bounds.
341         if (start_index + count <= kBaseLen && trg_offset + count <= kBaseLen) {
342           tmp->SetVRegReference(0, h_test_string.Get());
343           tmp->SetVReg(1, start_index);
344           tmp->SetVReg(2, count);
345           tmp->SetVRegReference(3, h_char_array.Get());
346           tmp->SetVReg(3, trg_offset);
347 
348           // Copy the char_array into buf.
349           memcpy(buf, h_char_array->GetData(), kBaseLen * sizeof(uint16_t));
350 
351           UnstartedStringCharAt(self, tmp.get(), &result, 0);
352 
353           uint16_t* data = h_char_array->GetData();
354 
355           bool success = true;
356 
357           // First segment should be unchanged.
358           for (int32_t i = 0; i < trg_offset; ++i) {
359             success = success && (data[i] == buf[i]);
360           }
361           // Second segment should be a copy.
362           for (int32_t i = trg_offset; i < trg_offset + count; ++i) {
363             success = success && (data[i] == buf[i - trg_offset + start_index]);
364           }
365           // Third segment should be unchanged.
366           for (int32_t i = trg_offset + count; i < kBaseLen; ++i) {
367             success = success && (data[i] == buf[i]);
368           }
369 
370           EXPECT_TRUE(success);
371         }
372       }
373     }
374   }
375 }
376 
TEST_F(UnstartedRuntimeTest,StringCharAt)377 TEST_F(UnstartedRuntimeTest, StringCharAt) {
378   Thread* self = Thread::Current();
379 
380   ScopedObjectAccess soa(self);
381   // TODO: Actual UTF.
382   constexpr const char* base_string = "abcdefghijklmnop";
383   int32_t base_len = static_cast<int32_t>(strlen(base_string));
384   ObjPtr<mirror::String> test_string = mirror::String::AllocFromModifiedUtf8(self, base_string);
385 
386   JValue result;
387   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
388 
389   for (int32_t i = 0; i < base_len; ++i) {
390     tmp->SetVRegReference(0, test_string);
391     tmp->SetVReg(1, i);
392 
393     UnstartedStringCharAt(self, tmp.get(), &result, 0);
394 
395     EXPECT_EQ(result.GetI(), base_string[i]);
396   }
397 }
398 
TEST_F(UnstartedRuntimeTest,StringInit)399 TEST_F(UnstartedRuntimeTest, StringInit) {
400   Thread* self = Thread::Current();
401   ScopedObjectAccess soa(self);
402   ObjPtr<mirror::Class> klass = GetClassRoot<mirror::String>();
403   ArtMethod* method =
404       klass->FindConstructor("(Ljava/lang/String;)V",
405                              Runtime::Current()->GetClassLinker()->GetImagePointerSize());
406   ASSERT_TRUE(method != nullptr);
407 
408   // create instruction data for invoke-direct {v0, v1} of method with fake index
409   uint16_t inst_data[3] = { 0x2070, 0x0000, 0x0010 };
410 
411   JValue result;
412   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, method, 0);
413   const char* base_string = "hello_world";
414   StackHandleScope<2> hs(self);
415   Handle<mirror::String> string_arg =
416       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(self, base_string));
417   Handle<mirror::String> reference_empty_string =
418       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(self, ""));
419   shadow_frame->SetVRegReference(0, reference_empty_string.Get());
420   shadow_frame->SetVRegReference(1, string_arg.Get());
421 
422   interpreter::DoCall<false, false>(method,
423                                     self,
424                                     *shadow_frame,
425                                     Instruction::At(inst_data),
426                                     inst_data[0],
427                                     &result);
428   ObjPtr<mirror::String> string_result = down_cast<mirror::String*>(result.GetL());
429   EXPECT_EQ(string_arg->GetLength(), string_result->GetLength());
430 
431   if (string_arg->IsCompressed() && string_result->IsCompressed()) {
432     EXPECT_EQ(memcmp(string_arg->GetValueCompressed(), string_result->GetValueCompressed(),
433                      string_arg->GetLength() * sizeof(uint8_t)), 0);
434   } else if (!string_arg->IsCompressed() && !string_result->IsCompressed()) {
435     EXPECT_EQ(memcmp(string_arg->GetValue(), string_result->GetValue(),
436                      string_arg->GetLength() * sizeof(uint16_t)), 0);
437   } else {
438     bool equal = true;
439     for (int i = 0; i < string_arg->GetLength(); ++i) {
440       if (string_arg->CharAt(i) != string_result->CharAt(i)) {
441         equal = false;
442         break;
443       }
444     }
445     EXPECT_EQ(equal, true);
446   }
447 }
448 
449 // Tests the exceptions that should be checked before modifying the destination.
450 // (Doesn't check the object vs primitive case ATM.)
TEST_F(UnstartedRuntimeTest,SystemArrayCopyObjectArrayTestExceptions)451 TEST_F(UnstartedRuntimeTest, SystemArrayCopyObjectArrayTestExceptions) {
452   Thread* self = Thread::Current();
453   ScopedObjectAccess soa(self);
454   JValue result;
455   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
456 
457   // Note: all tests are not GC safe. Assume there's no GC running here with the few objects we
458   //       allocate.
459   StackHandleScope<3> hs_misc(self);
460   Handle<mirror::Class> object_class(hs_misc.NewHandle(GetClassRoot<mirror::Object>()));
461 
462   StackHandleScope<3> hs_data(self);
463   hs_data.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "1"));
464   hs_data.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "2"));
465   hs_data.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "3"));
466 
467   Handle<mirror::ObjectArray<mirror::Object>> array(
468       hs_misc.NewHandle(CreateObjectArray(self, object_class.Get(), hs_data)));
469 
470   RunArrayCopy(self, tmp.get(), true, array.Get(), -1, array.Get(), 0, 0);
471   RunArrayCopy(self, tmp.get(), true, array.Get(), 0, array.Get(), -1, 0);
472   RunArrayCopy(self, tmp.get(), true, array.Get(), 0, array.Get(), 0, -1);
473   RunArrayCopy(self, tmp.get(), true, array.Get(), 0, array.Get(), 0, 4);
474   RunArrayCopy(self, tmp.get(), true, array.Get(), 0, array.Get(), 1, 3);
475   RunArrayCopy(self, tmp.get(), true, array.Get(), 1, array.Get(), 0, 3);
476 
477   Handle<mirror::ObjectArray<mirror::Object>> class_as_array =
478       hs_misc.NewHandle(reinterpret_cast<mirror::ObjectArray<mirror::Object>*>(object_class.Get()));
479   RunArrayCopy(self, tmp.get(), true, class_as_array.Get(), 0, array.Get(), 0, 0);
480   RunArrayCopy(self, tmp.get(), true, array.Get(), 0, class_as_array.Get(), 0, 0);
481 }
482 
TEST_F(UnstartedRuntimeTest,SystemArrayCopyObjectArrayTest)483 TEST_F(UnstartedRuntimeTest, SystemArrayCopyObjectArrayTest) {
484   Thread* self = Thread::Current();
485   ScopedObjectAccess soa(self);
486   JValue result;
487   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
488 
489   StackHandleScope<1> hs_object(self);
490   Handle<mirror::Class> object_class(hs_object.NewHandle(GetClassRoot<mirror::Object>()));
491 
492   // Simple test:
493   // [1,2,3]{1 @ 2} into [4,5,6] = [4,2,6]
494   {
495     StackHandleScope<3> hs_src(self);
496     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "1"));
497     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "2"));
498     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "3"));
499 
500     StackHandleScope<3> hs_dst(self);
501     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "4"));
502     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "5"));
503     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "6"));
504 
505     StackHandleScope<3> hs_expected(self);
506     hs_expected.NewHandle(hs_dst.GetReference(0));
507     hs_expected.NewHandle(hs_dst.GetReference(1));
508     hs_expected.NewHandle(hs_src.GetReference(1));
509 
510     RunArrayCopy(self,
511                  tmp.get(),
512                  false,
513                  object_class.Get(),
514                  object_class.Get(),
515                  hs_src,
516                  1,
517                  hs_dst,
518                  2,
519                  1,
520                  hs_expected);
521   }
522 
523   // Simple test:
524   // [1,2,3]{1 @ 1} into [4,5,6] = [4,2,6]  (with dst String[])
525   {
526     StackHandleScope<3> hs_src(self);
527     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "1"));
528     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "2"));
529     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "3"));
530 
531     StackHandleScope<3> hs_dst(self);
532     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "4"));
533     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "5"));
534     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "6"));
535 
536     StackHandleScope<3> hs_expected(self);
537     hs_expected.NewHandle(hs_dst.GetReference(0));
538     hs_expected.NewHandle(hs_src.GetReference(1));
539     hs_expected.NewHandle(hs_dst.GetReference(2));
540 
541     RunArrayCopy(self,
542                  tmp.get(),
543                  false,
544                  object_class.Get(),
545                  GetClassRoot<mirror::String>(),
546                  hs_src,
547                  1,
548                  hs_dst,
549                  1,
550                  1,
551                  hs_expected);
552   }
553 
554   // Simple test:
555   // [1,*,3] into [4,5,6] = [1,5,6] + exc
556   {
557     StackHandleScope<3> hs_src(self);
558     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "1"));
559     hs_src.NewHandle(GetClassRoot<mirror::String>());
560     hs_src.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "3"));
561 
562     StackHandleScope<3> hs_dst(self);
563     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "4"));
564     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "5"));
565     hs_dst.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "6"));
566 
567     StackHandleScope<3> hs_expected(self);
568     hs_expected.NewHandle(hs_src.GetReference(0));
569     hs_expected.NewHandle(hs_dst.GetReference(1));
570     hs_expected.NewHandle(hs_dst.GetReference(2));
571 
572     RunArrayCopy(self,
573                  tmp.get(),
574                  true,
575                  object_class.Get(),
576                  GetClassRoot<mirror::String>(),
577                  hs_src,
578                  0,
579                  hs_dst,
580                  0,
581                  3,
582                  hs_expected);
583   }
584 }
585 
TEST_F(UnstartedRuntimeTest,IntegerParseIntTest)586 TEST_F(UnstartedRuntimeTest, IntegerParseIntTest) {
587   Thread* self = Thread::Current();
588   ScopedObjectAccess soa(self);
589 
590   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
591 
592   // Test string. Should be valid, and between minimal values of LONG_MIN and LONG_MAX (for all
593   // suffixes).
594   constexpr const char* test_string = "-2147483646";
595   constexpr int32_t test_values[] = {
596                 6,
597                46,
598               646,
599              3646,
600             83646,
601            483646,
602           7483646,
603          47483646,
604         147483646,
605        2147483646,
606       -2147483646
607   };
608 
609   static_assert(arraysize(test_values) == 11U, "test_values");
610   CHECK_EQ(strlen(test_string), 11U);
611 
612   for (size_t i = 0; i <= 10; ++i) {
613     const char* test_value = &test_string[10 - i];
614 
615     StackHandleScope<1> hs_str(self);
616     Handle<mirror::String> h_str(
617         hs_str.NewHandle(mirror::String::AllocFromModifiedUtf8(self, test_value)));
618     ASSERT_NE(h_str.Get(), nullptr);
619     ASSERT_FALSE(self->IsExceptionPending());
620 
621     tmp->SetVRegReference(0, h_str.Get());
622 
623     JValue result;
624     UnstartedIntegerParseInt(self, tmp.get(), &result, 0);
625 
626     ASSERT_FALSE(self->IsExceptionPending());
627     EXPECT_EQ(result.GetI(), test_values[i]);
628   }
629 }
630 
631 // Right now the same as Integer.Parse
TEST_F(UnstartedRuntimeTest,LongParseLongTest)632 TEST_F(UnstartedRuntimeTest, LongParseLongTest) {
633   Thread* self = Thread::Current();
634   ScopedObjectAccess soa(self);
635 
636   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
637 
638   // Test string. Should be valid, and between minimal values of LONG_MIN and LONG_MAX (for all
639   // suffixes).
640   constexpr const char* test_string = "-2147483646";
641   constexpr int64_t test_values[] = {
642                 6,
643                46,
644               646,
645              3646,
646             83646,
647            483646,
648           7483646,
649          47483646,
650         147483646,
651        2147483646,
652       -2147483646
653   };
654 
655   static_assert(arraysize(test_values) == 11U, "test_values");
656   CHECK_EQ(strlen(test_string), 11U);
657 
658   for (size_t i = 0; i <= 10; ++i) {
659     const char* test_value = &test_string[10 - i];
660 
661     StackHandleScope<1> hs_str(self);
662     Handle<mirror::String> h_str(
663         hs_str.NewHandle(mirror::String::AllocFromModifiedUtf8(self, test_value)));
664     ASSERT_NE(h_str.Get(), nullptr);
665     ASSERT_FALSE(self->IsExceptionPending());
666 
667     tmp->SetVRegReference(0, h_str.Get());
668 
669     JValue result;
670     UnstartedLongParseLong(self, tmp.get(), &result, 0);
671 
672     ASSERT_FALSE(self->IsExceptionPending());
673     EXPECT_EQ(result.GetJ(), test_values[i]);
674   }
675 }
676 
TEST_F(UnstartedRuntimeTest,Ceil)677 TEST_F(UnstartedRuntimeTest, Ceil) {
678   Thread* self = Thread::Current();
679   ScopedObjectAccess soa(self);
680 
681   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
682 
683   constexpr double nan = std::numeric_limits<double>::quiet_NaN();
684   constexpr double inf = std::numeric_limits<double>::infinity();
685   constexpr double ld1 = static_cast<double>((UINT64_C(1) << 53) - 1);
686   constexpr double ld2 = static_cast<double>(UINT64_C(1) << 55);
687   constexpr double test_pairs[][2] = {
688       { -0.0, -0.0 },
689       {  0.0,  0.0 },
690       { -0.5, -0.0 },
691       { -1.0, -1.0 },
692       {  0.5,  1.0 },
693       {  1.0,  1.0 },
694       {  nan,  nan },
695       {  inf,  inf },
696       { -inf, -inf },
697       {  ld1,  ld1 },
698       {  ld2,  ld2 }
699   };
700 
701   TestCeilFloor(/* ceil= */ true, self, tmp.get(), test_pairs, arraysize(test_pairs));
702 }
703 
TEST_F(UnstartedRuntimeTest,Floor)704 TEST_F(UnstartedRuntimeTest, Floor) {
705   Thread* self = Thread::Current();
706   ScopedObjectAccess soa(self);
707 
708   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
709 
710   constexpr double nan = std::numeric_limits<double>::quiet_NaN();
711   constexpr double inf = std::numeric_limits<double>::infinity();
712   constexpr double ld1 = static_cast<double>((UINT64_C(1) << 53) - 1);
713   constexpr double ld2 = static_cast<double>(UINT64_C(1) << 55);
714   constexpr double test_pairs[][2] = {
715       { -0.0, -0.0 },
716       {  0.0,  0.0 },
717       { -0.5, -1.0 },
718       { -1.0, -1.0 },
719       {  0.5,  0.0 },
720       {  1.0,  1.0 },
721       {  nan,  nan },
722       {  inf,  inf },
723       { -inf, -inf },
724       {  ld1,  ld1 },
725       {  ld2,  ld2 }
726   };
727 
728   TestCeilFloor(/* ceil= */ false, self, tmp.get(), test_pairs, arraysize(test_pairs));
729 }
730 
TEST_F(UnstartedRuntimeTest,ToLowerUpper)731 TEST_F(UnstartedRuntimeTest, ToLowerUpper) {
732   Thread* self = Thread::Current();
733   ScopedObjectAccess soa(self);
734 
735   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
736 
737   std::locale c_locale("C");
738 
739   // Check ASCII.
740   for (uint32_t i = 0; i < 128; ++i) {
741     bool c_upper = std::isupper(static_cast<char>(i), c_locale);
742     bool c_lower = std::islower(static_cast<char>(i), c_locale);
743     EXPECT_FALSE(c_upper && c_lower) << i;
744 
745     // Check toLowerCase.
746     {
747       JValue result;
748       tmp->SetVReg(0, static_cast<int32_t>(i));
749       UnstartedCharacterToLowerCase(self, tmp.get(), &result, 0);
750       ASSERT_FALSE(self->IsExceptionPending());
751       uint32_t lower_result = static_cast<uint32_t>(result.GetI());
752       if (c_lower) {
753         EXPECT_EQ(i, lower_result);
754       } else if (c_upper) {
755         EXPECT_EQ(static_cast<uint32_t>(std::tolower(static_cast<char>(i), c_locale)),
756                   lower_result);
757       } else {
758         EXPECT_EQ(i, lower_result);
759       }
760     }
761 
762     // Check toUpperCase.
763     {
764       JValue result2;
765       tmp->SetVReg(0, static_cast<int32_t>(i));
766       UnstartedCharacterToUpperCase(self, tmp.get(), &result2, 0);
767       ASSERT_FALSE(self->IsExceptionPending());
768       uint32_t upper_result = static_cast<uint32_t>(result2.GetI());
769       if (c_upper) {
770         EXPECT_EQ(i, upper_result);
771       } else if (c_lower) {
772         EXPECT_EQ(static_cast<uint32_t>(std::toupper(static_cast<char>(i), c_locale)),
773                   upper_result);
774       } else {
775         EXPECT_EQ(i, upper_result);
776       }
777     }
778   }
779 
780   // Check abort for other things. Can't test all.
781 
782   PrepareForAborts();
783 
784   for (uint32_t i = 128; i < 256; ++i) {
785     {
786       JValue result;
787       tmp->SetVReg(0, static_cast<int32_t>(i));
788       EnterTransactionMode();
789       UnstartedCharacterToLowerCase(self, tmp.get(), &result, 0);
790       ASSERT_TRUE(IsTransactionAborted());
791       ExitTransactionMode();
792       ASSERT_TRUE(self->IsExceptionPending());
793     }
794     {
795       JValue result;
796       tmp->SetVReg(0, static_cast<int32_t>(i));
797       EnterTransactionMode();
798       UnstartedCharacterToUpperCase(self, tmp.get(), &result, 0);
799       ASSERT_TRUE(IsTransactionAborted());
800       ExitTransactionMode();
801       ASSERT_TRUE(self->IsExceptionPending());
802     }
803   }
804   for (uint64_t i = 256; i <= std::numeric_limits<uint32_t>::max(); i <<= 1) {
805     {
806       JValue result;
807       tmp->SetVReg(0, static_cast<int32_t>(i));
808       EnterTransactionMode();
809       UnstartedCharacterToLowerCase(self, tmp.get(), &result, 0);
810       ASSERT_TRUE(IsTransactionAborted());
811       ExitTransactionMode();
812       ASSERT_TRUE(self->IsExceptionPending());
813     }
814     {
815       JValue result;
816       tmp->SetVReg(0, static_cast<int32_t>(i));
817       EnterTransactionMode();
818       UnstartedCharacterToUpperCase(self, tmp.get(), &result, 0);
819       ASSERT_TRUE(IsTransactionAborted());
820       ExitTransactionMode();
821       ASSERT_TRUE(self->IsExceptionPending());
822     }
823   }
824 }
825 
TEST_F(UnstartedRuntimeTest,Sin)826 TEST_F(UnstartedRuntimeTest, Sin) {
827   Thread* self = Thread::Current();
828   ScopedObjectAccess soa(self);
829 
830   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
831 
832   // Test an important value, PI/6. That's the one we see in practice.
833   constexpr uint64_t lvalue = UINT64_C(0x3fe0c152382d7365);
834   tmp->SetVRegLong(0, static_cast<int64_t>(lvalue));
835 
836   JValue result;
837   UnstartedMathSin(self, tmp.get(), &result, 0);
838 
839   const uint64_t lresult = static_cast<uint64_t>(result.GetJ());
840   EXPECT_EQ(UINT64_C(0x3fdfffffffffffff), lresult);
841 }
842 
TEST_F(UnstartedRuntimeTest,Cos)843 TEST_F(UnstartedRuntimeTest, Cos) {
844   Thread* self = Thread::Current();
845   ScopedObjectAccess soa(self);
846 
847   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
848 
849   // Test an important value, PI/6. That's the one we see in practice.
850   constexpr uint64_t lvalue = UINT64_C(0x3fe0c152382d7365);
851   tmp->SetVRegLong(0, static_cast<int64_t>(lvalue));
852 
853   JValue result;
854   UnstartedMathCos(self, tmp.get(), &result, 0);
855 
856   const uint64_t lresult = static_cast<uint64_t>(result.GetJ());
857   EXPECT_EQ(UINT64_C(0x3febb67ae8584cab), lresult);
858 }
859 
TEST_F(UnstartedRuntimeTest,Pow)860 TEST_F(UnstartedRuntimeTest, Pow) {
861   Thread* self = Thread::Current();
862   ScopedObjectAccess soa(self);
863 
864   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
865 
866   // Test an important pair.
867   constexpr uint64_t lvalue1 = UINT64_C(0x4079000000000000);
868   constexpr uint64_t lvalue2 = UINT64_C(0xbfe6db6dc0000000);
869 
870   tmp->SetVRegLong(0, static_cast<int64_t>(lvalue1));
871   tmp->SetVRegLong(2, static_cast<int64_t>(lvalue2));
872 
873   JValue result;
874   UnstartedMathPow(self, tmp.get(), &result, 0);
875 
876   const uint64_t lresult = static_cast<uint64_t>(result.GetJ());
877   EXPECT_EQ(UINT64_C(0x3f8c5c51326aa7ee), lresult);
878 }
879 
TEST_F(UnstartedRuntimeTest,IsAnonymousClass)880 TEST_F(UnstartedRuntimeTest, IsAnonymousClass) {
881   Thread* self = Thread::Current();
882   ScopedObjectAccess soa(self);
883 
884   JValue result;
885   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, nullptr, 0);
886 
887   ObjPtr<mirror::Class> class_klass = GetClassRoot<mirror::Class>();
888   shadow_frame->SetVRegReference(0, class_klass);
889   UnstartedClassIsAnonymousClass(self, shadow_frame.get(), &result, 0);
890   EXPECT_EQ(result.GetZ(), 0);
891 
892   jobject class_loader = LoadDex("Nested");
893   StackHandleScope<1> hs(soa.Self());
894   Handle<mirror::ClassLoader> loader(
895       hs.NewHandle(soa.Decode<mirror::ClassLoader>(class_loader)));
896   ObjPtr<mirror::Class> c = class_linker_->FindClass(soa.Self(), "LNested$1;", loader);
897   ASSERT_TRUE(c != nullptr);
898   shadow_frame->SetVRegReference(0, c);
899   UnstartedClassIsAnonymousClass(self, shadow_frame.get(), &result, 0);
900   EXPECT_EQ(result.GetZ(), 1);
901 }
902 
TEST_F(UnstartedRuntimeTest,GetDeclaringClass)903 TEST_F(UnstartedRuntimeTest, GetDeclaringClass) {
904   Thread* self = Thread::Current();
905   ScopedObjectAccess soa(self);
906 
907   JValue result;
908   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, nullptr, 0);
909 
910   jobject class_loader = LoadDex("Nested");
911   StackHandleScope<4> hs(self);
912   Handle<mirror::ClassLoader> loader(
913       hs.NewHandle(soa.Decode<mirror::ClassLoader>(class_loader)));
914 
915   Handle<mirror::Class> nested_klass(hs.NewHandle(
916       class_linker_->FindClass(soa.Self(), "LNested;", loader)));
917   Handle<mirror::Class> inner_klass(hs.NewHandle(
918       class_linker_->FindClass(soa.Self(), "LNested$Inner;", loader)));
919   Handle<mirror::Class> anon_klass(hs.NewHandle(
920       class_linker_->FindClass(soa.Self(), "LNested$1;", loader)));
921 
922   shadow_frame->SetVRegReference(0, nested_klass.Get());
923   UnstartedClassGetDeclaringClass(self, shadow_frame.get(), &result, 0);
924   EXPECT_EQ(result.GetL(), nullptr);
925 
926   shadow_frame->SetVRegReference(0, inner_klass.Get());
927   UnstartedClassGetDeclaringClass(self, shadow_frame.get(), &result, 0);
928   EXPECT_EQ(result.GetL(), nested_klass.Get());
929 
930   shadow_frame->SetVRegReference(0, anon_klass.Get());
931   UnstartedClassGetDeclaringClass(self, shadow_frame.get(), &result, 0);
932   EXPECT_EQ(result.GetL(), nullptr);
933 }
934 
TEST_F(UnstartedRuntimeTest,ThreadLocalGet)935 TEST_F(UnstartedRuntimeTest, ThreadLocalGet) {
936   Thread* self = Thread::Current();
937   ScopedObjectAccess soa(self);
938 
939   JValue result;
940   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, nullptr, 0);
941 
942   StackHandleScope<1> hs(self);
943   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
944 
945   // Positive test. See that We get something for float conversion.
946   {
947     Handle<mirror::Class> floating_decimal = hs.NewHandle(
948         class_linker->FindClass(self,
949                                 "Lsun/misc/FloatingDecimal;",
950                                 ScopedNullHandle<mirror::ClassLoader>()));
951     ASSERT_TRUE(floating_decimal != nullptr);
952     ASSERT_TRUE(class_linker->EnsureInitialized(self, floating_decimal, true, true));
953 
954     ArtMethod* caller_method = floating_decimal->FindClassMethod(
955         "getBinaryToASCIIBuffer",
956         "()Lsun/misc/FloatingDecimal$BinaryToASCIIBuffer;",
957         class_linker->GetImagePointerSize());
958     // floating_decimal->DumpClass(LOG_STREAM(ERROR), mirror::Class::kDumpClassFullDetail);
959     ASSERT_TRUE(caller_method != nullptr);
960     ASSERT_TRUE(caller_method->IsDirect());
961     ASSERT_TRUE(caller_method->GetDeclaringClass() == floating_decimal.Get());
962     UniqueDeoptShadowFramePtr caller_frame = CreateShadowFrame(10, nullptr, caller_method, 0);
963     shadow_frame->SetLink(caller_frame.get());
964 
965     UnstartedThreadLocalGet(self, shadow_frame.get(), &result, 0);
966     EXPECT_TRUE(result.GetL() != nullptr);
967     EXPECT_FALSE(self->IsExceptionPending());
968 
969     shadow_frame->SetLink(nullptr);
970   }
971 
972   // Negative test.
973   PrepareForAborts();
974 
975   {
976     // Just use a method in Class.
977     ObjPtr<mirror::Class> class_class = GetClassRoot<mirror::Class>();
978     ArtMethod* caller_method =
979         &*class_class->GetDeclaredMethods(class_linker->GetImagePointerSize()).begin();
980     UniqueDeoptShadowFramePtr caller_frame = CreateShadowFrame(10, nullptr, caller_method, 0);
981     shadow_frame->SetLink(caller_frame.get());
982 
983     EnterTransactionMode();
984     UnstartedThreadLocalGet(self, shadow_frame.get(), &result, 0);
985     ASSERT_TRUE(IsTransactionAborted());
986     ExitTransactionMode();
987     ASSERT_TRUE(self->IsExceptionPending());
988     self->ClearException();
989 
990     shadow_frame->SetLink(nullptr);
991   }
992 }
993 
TEST_F(UnstartedRuntimeTest,FloatConversion)994 TEST_F(UnstartedRuntimeTest, FloatConversion) {
995   Thread* self = Thread::Current();
996   ScopedObjectAccess soa(self);
997 
998   StackHandleScope<1> hs(self);
999   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1000   Handle<mirror::Class> double_class = hs.NewHandle(
1001           class_linker->FindClass(self,
1002                                   "Ljava/lang/Double;",
1003                                   ScopedNullHandle<mirror::ClassLoader>()));
1004   ASSERT_TRUE(double_class != nullptr);
1005   ASSERT_TRUE(class_linker->EnsureInitialized(self, double_class, true, true));
1006 
1007   ArtMethod* method = double_class->FindClassMethod("toString",
1008                                                     "(D)Ljava/lang/String;",
1009                                                     class_linker->GetImagePointerSize());
1010   ASSERT_TRUE(method != nullptr);
1011   ASSERT_TRUE(method->IsDirect());
1012   ASSERT_TRUE(method->GetDeclaringClass() == double_class.Get());
1013 
1014   // create instruction data for invoke-direct {v0, v1} of method with fake index
1015   uint16_t inst_data[3] = { 0x2070, 0x0000, 0x0010 };
1016 
1017   JValue result;
1018   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, method, 0);
1019 
1020   shadow_frame->SetVRegDouble(0, 1.23);
1021   interpreter::DoCall<false, false>(method,
1022                                     self,
1023                                     *shadow_frame,
1024                                     Instruction::At(inst_data),
1025                                     inst_data[0],
1026                                     &result);
1027   ObjPtr<mirror::String> string_result = down_cast<mirror::String*>(result.GetL());
1028   ASSERT_TRUE(string_result != nullptr);
1029 
1030   std::string mod_utf = string_result->ToModifiedUtf8();
1031   EXPECT_EQ("1.23", mod_utf);
1032 }
1033 
TEST_F(UnstartedRuntimeTest,ThreadCurrentThread)1034 TEST_F(UnstartedRuntimeTest, ThreadCurrentThread) {
1035   Thread* self = Thread::Current();
1036   ScopedObjectAccess soa(self);
1037 
1038   JValue result;
1039   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, nullptr, 0);
1040 
1041   StackHandleScope<1> hs(self);
1042   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1043   Handle<mirror::Class> thread_class = hs.NewHandle(
1044       class_linker->FindClass(self, "Ljava/lang/Thread;", ScopedNullHandle<mirror::ClassLoader>()));
1045   ASSERT_TRUE(thread_class.Get() != nullptr);
1046   ASSERT_TRUE(class_linker->EnsureInitialized(self, thread_class, true, true));
1047 
1048   // Negative test. In general, currentThread should fail (as we should not leak a peer that will
1049   // be recreated at runtime).
1050   PrepareForAborts();
1051 
1052   {
1053     EnterTransactionMode();
1054     UnstartedThreadCurrentThread(self, shadow_frame.get(), &result, 0);
1055     ASSERT_TRUE(IsTransactionAborted());
1056     ExitTransactionMode();
1057     ASSERT_TRUE(self->IsExceptionPending());
1058     self->ClearException();
1059   }
1060 }
1061 
TEST_F(UnstartedRuntimeTest,LogManager)1062 TEST_F(UnstartedRuntimeTest, LogManager) {
1063   Thread* self = Thread::Current();
1064   ScopedObjectAccess soa(self);
1065 
1066   StackHandleScope<1> hs(self);
1067   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1068   Handle<mirror::Class> log_manager_class = hs.NewHandle(
1069       class_linker->FindClass(self,
1070                               "Ljava/util/logging/LogManager;",
1071                               ScopedNullHandle<mirror::ClassLoader>()));
1072   ASSERT_TRUE(log_manager_class.Get() != nullptr);
1073   ASSERT_TRUE(class_linker->EnsureInitialized(self, log_manager_class, true, true));
1074 }
1075 
1076 class UnstartedClassForNameTest : public UnstartedRuntimeTest {
1077  public:
1078   template <typename T>
RunTest(T & runner,bool in_transaction,bool should_succeed)1079   void RunTest(T& runner, bool in_transaction, bool should_succeed) {
1080     Thread* self = Thread::Current();
1081     ScopedObjectAccess soa(self);
1082 
1083     // Ensure that Class is initialized.
1084     {
1085       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1086       StackHandleScope<1> hs(self);
1087       Handle<mirror::Class> h_class = hs.NewHandle(GetClassRoot<mirror::Class>());
1088       CHECK(class_linker->EnsureInitialized(self, h_class, true, true));
1089     }
1090 
1091     // A selection of classes from different core classpath components.
1092     constexpr const char* kTestCases[] = {
1093         "java.net.CookieManager",  // From libcore.
1094         "dalvik.system.ClassExt",  // From libart.
1095     };
1096 
1097     if (in_transaction) {
1098       // For transaction mode, we cannot load any classes, as the pre-fence initialization of
1099       // classes isn't transactional. Load them ahead of time.
1100       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1101       for (const char* name : kTestCases) {
1102         class_linker->FindClass(self,
1103                                 DotToDescriptor(name).c_str(),
1104                                 ScopedNullHandle<mirror::ClassLoader>());
1105         CHECK(!self->IsExceptionPending()) << self->GetException()->Dump();
1106       }
1107     }
1108 
1109     if (!should_succeed) {
1110       // Negative test. In general, currentThread should fail (as we should not leak a peer that will
1111       // be recreated at runtime).
1112       PrepareForAborts();
1113     }
1114 
1115     JValue result;
1116     UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, nullptr, 0);
1117 
1118     for (const char* name : kTestCases) {
1119       ObjPtr<mirror::String> name_string = mirror::String::AllocFromModifiedUtf8(self, name);
1120       CHECK(name_string != nullptr);
1121 
1122       if (in_transaction) {
1123         EnterTransactionMode();
1124       }
1125       CHECK(!self->IsExceptionPending());
1126 
1127       runner(self, shadow_frame.get(), name_string, &result);
1128 
1129       if (should_succeed) {
1130         CHECK(!self->IsExceptionPending()) << name << " " << self->GetException()->Dump();
1131         CHECK(result.GetL() != nullptr) << name;
1132       } else {
1133         CHECK(self->IsExceptionPending()) << name;
1134         if (in_transaction) {
1135           ASSERT_TRUE(IsTransactionAborted());
1136         }
1137         self->ClearException();
1138       }
1139 
1140       if (in_transaction) {
1141         ExitTransactionMode();
1142       }
1143     }
1144   }
1145 
GetBootClassLoader()1146   mirror::ClassLoader* GetBootClassLoader() REQUIRES_SHARED(Locks::mutator_lock_) {
1147     Thread* self = Thread::Current();
1148     StackHandleScope<2> hs(self);
1149     MutableHandle<mirror::ClassLoader> boot_cp = hs.NewHandle<mirror::ClassLoader>(nullptr);
1150 
1151     {
1152       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1153 
1154       // Create the fake boot classloader. Any instance is fine, they are technically interchangeable.
1155       Handle<mirror::Class> boot_cp_class = hs.NewHandle(
1156           class_linker->FindClass(self,
1157                                   "Ljava/lang/BootClassLoader;",
1158                                   ScopedNullHandle<mirror::ClassLoader>()));
1159       CHECK(boot_cp_class != nullptr);
1160       CHECK(class_linker->EnsureInitialized(self, boot_cp_class, true, true));
1161 
1162       boot_cp.Assign(boot_cp_class->AllocObject(self)->AsClassLoader());
1163       CHECK(boot_cp != nullptr);
1164 
1165       ArtMethod* boot_cp_init = boot_cp_class->FindConstructor(
1166           "()V", class_linker->GetImagePointerSize());
1167       CHECK(boot_cp_init != nullptr);
1168 
1169       JValue result;
1170       UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, boot_cp_init, 0);
1171       shadow_frame->SetVRegReference(0, boot_cp.Get());
1172 
1173       // create instruction data for invoke-direct {v0} of method with fake index
1174       uint16_t inst_data[3] = { 0x1070, 0x0000, 0x0010 };
1175 
1176       interpreter::DoCall<false, false>(boot_cp_init,
1177                                         self,
1178                                         *shadow_frame,
1179                                         Instruction::At(inst_data),
1180                                         inst_data[0],
1181                                         &result);
1182       CHECK(!self->IsExceptionPending());
1183     }
1184 
1185     return boot_cp.Get();
1186   }
1187 };
1188 
TEST_F(UnstartedClassForNameTest,ClassForName)1189 TEST_F(UnstartedClassForNameTest, ClassForName) {
1190   auto runner = [](Thread* self,
1191                    ShadowFrame* shadow_frame,
1192                    ObjPtr<mirror::String> name,
1193                    JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) {
1194     shadow_frame->SetVRegReference(0, name);
1195     UnstartedClassForName(self, shadow_frame, result, 0);
1196   };
1197   RunTest(runner, false, true);
1198 }
1199 
TEST_F(UnstartedClassForNameTest,ClassForNameLong)1200 TEST_F(UnstartedClassForNameTest, ClassForNameLong) {
1201   auto runner = [](Thread* self,
1202                    ShadowFrame* shadow_frame,
1203                    ObjPtr<mirror::String> name,
1204                    JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) {
1205     shadow_frame->SetVRegReference(0, name);
1206     shadow_frame->SetVReg(1, 0);
1207     shadow_frame->SetVRegReference(2, nullptr);
1208     UnstartedClassForNameLong(self, shadow_frame, result, 0);
1209   };
1210   RunTest(runner, false, true);
1211 }
1212 
TEST_F(UnstartedClassForNameTest,ClassForNameLongWithClassLoader)1213 TEST_F(UnstartedClassForNameTest, ClassForNameLongWithClassLoader) {
1214   Thread* self = Thread::Current();
1215   ScopedObjectAccess soa(self);
1216 
1217   StackHandleScope<1> hs(self);
1218   Handle<mirror::ClassLoader> boot_cp = hs.NewHandle(GetBootClassLoader());
1219 
1220   auto runner = [&](Thread* th,
1221                     ShadowFrame* shadow_frame,
1222                     ObjPtr<mirror::String> name,
1223                     JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) {
1224     shadow_frame->SetVRegReference(0, name);
1225     shadow_frame->SetVReg(1, 0);
1226     shadow_frame->SetVRegReference(2, boot_cp.Get());
1227     UnstartedClassForNameLong(th, shadow_frame, result, 0);
1228   };
1229   RunTest(runner, false, true);
1230 }
1231 
TEST_F(UnstartedClassForNameTest,ClassForNameLongWithClassLoaderTransaction)1232 TEST_F(UnstartedClassForNameTest, ClassForNameLongWithClassLoaderTransaction) {
1233   Thread* self = Thread::Current();
1234   ScopedObjectAccess soa(self);
1235 
1236   StackHandleScope<1> hs(self);
1237   Handle<mirror::ClassLoader> boot_cp = hs.NewHandle(GetBootClassLoader());
1238 
1239   auto runner = [&](Thread* th,
1240                     ShadowFrame* shadow_frame,
1241                     ObjPtr<mirror::String> name,
1242                     JValue* result)
1243       REQUIRES_SHARED(Locks::mutator_lock_) {
1244     shadow_frame->SetVRegReference(0, name);
1245     shadow_frame->SetVReg(1, 0);
1246     shadow_frame->SetVRegReference(2, boot_cp.Get());
1247     UnstartedClassForNameLong(th, shadow_frame, result, 0);
1248   };
1249   RunTest(runner, true, true);
1250 }
1251 
TEST_F(UnstartedClassForNameTest,ClassForNameLongWithClassLoaderFail)1252 TEST_F(UnstartedClassForNameTest, ClassForNameLongWithClassLoaderFail) {
1253   Thread* self = Thread::Current();
1254   ScopedObjectAccess soa(self);
1255 
1256   StackHandleScope<2> hs(self);
1257   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1258   jobject path_jobj = class_linker->CreatePathClassLoader(self, {});
1259   ASSERT_TRUE(path_jobj != nullptr);
1260   Handle<mirror::ClassLoader> path_cp = hs.NewHandle<mirror::ClassLoader>(
1261       self->DecodeJObject(path_jobj)->AsClassLoader());
1262 
1263   auto runner = [&](Thread* th,
1264                     ShadowFrame* shadow_frame,
1265                     ObjPtr<mirror::String> name,
1266                     JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) {
1267     shadow_frame->SetVRegReference(0, name);
1268     shadow_frame->SetVReg(1, 0);
1269     shadow_frame->SetVRegReference(2, path_cp.Get());
1270     UnstartedClassForNameLong(th, shadow_frame, result, 0);
1271   };
1272   RunTest(runner, true, false);
1273 }
1274 
TEST_F(UnstartedRuntimeTest,ClassGetSignatureAnnotation)1275 TEST_F(UnstartedRuntimeTest, ClassGetSignatureAnnotation) {
1276   Thread* self = Thread::Current();
1277   ScopedObjectAccess soa(self);
1278 
1279   StackHandleScope<1> hs(self);
1280   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1281   Handle<mirror::Class> list_class = hs.NewHandle(
1282       class_linker->FindClass(self,
1283                               "Ljava/util/List;",
1284                               ScopedNullHandle<mirror::ClassLoader>()));
1285   ASSERT_TRUE(list_class.Get() != nullptr);
1286   ASSERT_TRUE(class_linker->EnsureInitialized(self, list_class, true, true));
1287 
1288   JValue result;
1289   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, nullptr, 0);
1290 
1291   shadow_frame->SetVRegReference(0, list_class.Get());
1292   UnstartedClassGetSignatureAnnotation(self, shadow_frame.get(), &result, 0);
1293   ASSERT_TRUE(result.GetL() != nullptr);
1294   ASSERT_FALSE(self->IsExceptionPending());
1295 
1296   ASSERT_TRUE(result.GetL()->IsObjectArray());
1297   ObjPtr<mirror::ObjectArray<mirror::Object>> array =
1298       result.GetL()->AsObjectArray<mirror::Object>();
1299   std::ostringstream oss;
1300   for (int32_t i = 0; i != array->GetLength(); ++i) {
1301     ObjPtr<mirror::Object> elem = array->Get(i);
1302     ASSERT_TRUE(elem != nullptr);
1303     ASSERT_TRUE(elem->IsString());
1304     oss << elem->AsString()->ToModifiedUtf8();
1305   }
1306   std::string output_string = oss.str();
1307   ASSERT_EQ(output_string, "<E:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Collection<TE;>;");
1308 }
1309 
TEST_F(UnstartedRuntimeTest,ConstructorNewInstance0)1310 TEST_F(UnstartedRuntimeTest, ConstructorNewInstance0) {
1311   Thread* self = Thread::Current();
1312   ScopedObjectAccess soa(self);
1313 
1314   StackHandleScope<4> hs(self);
1315   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1316 
1317   // Get Throwable.
1318   Handle<mirror::Class> throw_class = hs.NewHandle(GetClassRoot<mirror::Throwable>());
1319   ASSERT_TRUE(class_linker->EnsureInitialized(self, throw_class, true, true));
1320 
1321   // Get an input object.
1322   Handle<mirror::String> input = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "abd"));
1323 
1324   // Find the constructor.
1325   ArtMethod* throw_cons = throw_class->FindConstructor(
1326       "(Ljava/lang/String;)V", class_linker->GetImagePointerSize());
1327   ASSERT_TRUE(throw_cons != nullptr);
1328   Handle<mirror::Constructor> cons;
1329   if (class_linker->GetImagePointerSize() == PointerSize::k64) {
1330      cons = hs.NewHandle(
1331         mirror::Constructor::CreateFromArtMethod<PointerSize::k64, false>(self, throw_cons));
1332     ASSERT_TRUE(cons != nullptr);
1333   } else {
1334     cons = hs.NewHandle(
1335         mirror::Constructor::CreateFromArtMethod<PointerSize::k32, false>(self, throw_cons));
1336     ASSERT_TRUE(cons != nullptr);
1337   }
1338 
1339   Handle<mirror::ObjectArray<mirror::Object>> args = hs.NewHandle(
1340       mirror::ObjectArray<mirror::Object>::Alloc(
1341           self, GetClassRoot<mirror::ObjectArray<mirror::Object>>(class_linker_), 1));
1342   ASSERT_TRUE(args != nullptr);
1343   args->Set(0, input.Get());
1344 
1345   // OK, we're ready now.
1346   JValue result;
1347   UniqueDeoptShadowFramePtr shadow_frame = CreateShadowFrame(10, nullptr, nullptr, 0);
1348   shadow_frame->SetVRegReference(0, cons.Get());
1349   shadow_frame->SetVRegReference(1, args.Get());
1350   UnstartedConstructorNewInstance0(self, shadow_frame.get(), &result, 0);
1351 
1352   ASSERT_TRUE(result.GetL() != nullptr);
1353   ASSERT_FALSE(self->IsExceptionPending());
1354 
1355   // Should be a new object.
1356   ASSERT_NE(result.GetL(), input.Get());
1357   // Should be of type Throwable.
1358   ASSERT_OBJ_PTR_EQ(GetClassRoot<mirror::Throwable>(), result.GetL()->GetClass());
1359   // Should have the right string.
1360   ObjPtr<mirror::String> result_msg =
1361       reinterpret_cast<mirror::Throwable*>(result.GetL())->GetDetailMessage();
1362   EXPECT_OBJ_PTR_EQ(input.Get(), result_msg);
1363 }
1364 
TEST_F(UnstartedRuntimeTest,IdentityHashCode)1365 TEST_F(UnstartedRuntimeTest, IdentityHashCode) {
1366   Thread* self = Thread::Current();
1367   ScopedObjectAccess soa(self);
1368   UniqueDeoptShadowFramePtr tmp = CreateShadowFrame(10, nullptr, nullptr, 0);
1369 
1370   JValue result;
1371   UnstartedSystemIdentityHashCode(self, tmp.get(), &result, 0);
1372 
1373   EXPECT_EQ(0, result.GetI());
1374   ASSERT_FALSE(self->IsExceptionPending());
1375 
1376   ObjPtr<mirror::String> str = mirror::String::AllocFromModifiedUtf8(self, "abd");
1377   tmp->SetVRegReference(0, str);
1378   UnstartedSystemIdentityHashCode(self, tmp.get(), &result, 0);
1379   EXPECT_NE(0, result.GetI());
1380   EXPECT_EQ(str->IdentityHashCode(), result.GetI());
1381   ASSERT_FALSE(self->IsExceptionPending());
1382 }
1383 
1384 }  // namespace interpreter
1385 }  // namespace art
1386