• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef ART_RUNTIME_COMMON_RUNTIME_TEST_H_
18 #define ART_RUNTIME_COMMON_RUNTIME_TEST_H_
19 
20 #include <gtest/gtest.h>
21 #include <jni.h>
22 
23 #include <functional>
24 #include <string>
25 
26 #include <android-base/logging.h>
27 
28 #include "arch/instruction_set.h"
29 #include "base/common_art_test.h"
30 #include "base/locks.h"
31 #include "base/os.h"
32 #include "base/unix_file/fd_file.h"
33 #include "dex/art_dex_file_loader.h"
34 #include "dex/compact_dex_level.h"
35 // TODO: Add inl file and avoid including inl.
36 #include "obj_ptr-inl.h"
37 #include "runtime_globals.h"
38 #include "scoped_thread_state_change-inl.h"
39 
40 namespace art {
41 
42 class MethodReference;
43 class TypeReference;
44 
45 using LogSeverity = android::base::LogSeverity;
46 using ScopedLogSeverity = android::base::ScopedLogSeverity;
47 
48 template<class MirrorType>
MakeObjPtr(MirrorType * ptr)49 static inline ObjPtr<MirrorType> MakeObjPtr(MirrorType* ptr) REQUIRES_SHARED(Locks::mutator_lock_) {
50   return ptr;
51 }
52 
53 template<class MirrorType>
MakeObjPtr(ObjPtr<MirrorType> ptr)54 static inline ObjPtr<MirrorType> MakeObjPtr(ObjPtr<MirrorType> ptr)
55     REQUIRES_SHARED(Locks::mutator_lock_) {
56   return ptr;
57 }
58 
59 // OBJ pointer helpers to avoid needing .Decode everywhere.
60 #define EXPECT_OBJ_PTR_EQ(a, b) EXPECT_EQ(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr())
61 #define ASSERT_OBJ_PTR_EQ(a, b) ASSERT_EQ(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr())
62 #define EXPECT_OBJ_PTR_NE(a, b) EXPECT_NE(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr())
63 #define ASSERT_OBJ_PTR_NE(a, b) ASSERT_NE(MakeObjPtr(a).Ptr(), MakeObjPtr(b).Ptr())
64 
65 class ClassLinker;
66 class CompilerCallbacks;
67 class DexFile;
68 class JavaVMExt;
69 class Runtime;
70 using RuntimeOptions = std::vector<std::pair<std::string, const void*>>;
71 class Thread;
72 class VariableSizedHandleScope;
73 
74 class CommonRuntimeTestImpl : public CommonArtTestImpl {
75  public:
76   CommonRuntimeTestImpl();
77   virtual ~CommonRuntimeTestImpl();
78 
79   // A helper function to fill the heap.
80   static void FillHeap(Thread* self,
81                        ClassLinker* class_linker,
82                        VariableSizedHandleScope* handle_scope)
83       REQUIRES_SHARED(Locks::mutator_lock_);
84   // A helper to set up a small heap (4M) to make FillHeap faster.
85   static void SetUpRuntimeOptionsForFillHeap(RuntimeOptions *options);
86 
87   template <typename Mutator>
MutateDexFile(File * output_dex,const std::string & input_jar,const Mutator & mutator)88   bool MutateDexFile(File* output_dex, const std::string& input_jar, const Mutator& mutator) {
89     std::vector<std::unique_ptr<const DexFile>> dex_files;
90     std::string error_msg;
91     ArtDexFileLoader dex_file_loader(input_jar);
92     CHECK(dex_file_loader.Open(/*verify=*/true,
93                                /*verify_checksum=*/true,
94                                &error_msg,
95                                &dex_files))
96         << error_msg;
97     EXPECT_EQ(dex_files.size(), 1u) << "Only one input dex is supported";
98     const std::unique_ptr<const DexFile>& dex = dex_files[0];
99     CHECK(dex->EnableWrite()) << "Failed to enable write";
100     DexFile* dex_file = const_cast<DexFile*>(dex.get());
101     mutator(dex_file);
102     const_cast<DexFile::Header&>(dex_file->GetHeader()).checksum_ = dex_file->CalculateChecksum();
103     if (!output_dex->WriteFully(dex->Begin(), dex->Size())) {
104       return false;
105     }
106     if (output_dex->Flush() != 0) {
107       PLOG(FATAL) << "Could not flush the output file.";
108     }
109     return true;
110   }
111 
112   void MakeInterpreted(ObjPtr<mirror::Class> klass)
113       REQUIRES_SHARED(Locks::mutator_lock_);
114 
115   bool StartDex2OatCommandLine(/*out*/std::vector<std::string>* argv,
116                                /*out*/std::string* error_msg,
117                                bool use_runtime_bcp_and_image = true);
118 
119   bool CompileBootImage(const std::vector<std::string>& extra_args,
120                         const std::string& image_file_name_prefix,
121                         ArrayRef<const std::string> dex_files,
122                         ArrayRef<const std::string> dex_locations,
123                         std::string* error_msg,
124                         const std::string& use_fd_prefix = "");
125 
126   bool CompileBootImage(const std::vector<std::string>& extra_args,
127                         const std::string& image_file_name_prefix,
128                         ArrayRef<const std::string> dex_files,
129                         std::string* error_msg,
130                         const std::string& use_fd_prefix = "") {
131     return CompileBootImage(
132         extra_args, image_file_name_prefix, dex_files, dex_files, error_msg, use_fd_prefix);
133   }
134 
135   bool RunDex2Oat(const std::vector<std::string>& args, std::string* error_msg);
136 
137  protected:
138   // Allow subclases such as CommonCompilerTest to add extra options.
SetUpRuntimeOptions(RuntimeOptions * options ATTRIBUTE_UNUSED)139   virtual void SetUpRuntimeOptions(RuntimeOptions* options ATTRIBUTE_UNUSED) {}
140 
141   // Called before the runtime is created.
PreRuntimeCreate()142   virtual void PreRuntimeCreate() {}
143 
144   // Called after the runtime is created.
PostRuntimeCreate()145   virtual void PostRuntimeCreate() {}
146 
147   // Loads the test dex file identified by the given dex_name into a PathClassLoader.
148   // Returns the created class loader.
149   jobject LoadDex(const char* dex_name) REQUIRES_SHARED(Locks::mutator_lock_);
150   // Loads the test dex file identified by the given first_dex_name and second_dex_name
151   // into a PathClassLoader. Returns the created class loader.
152   jobject LoadMultiDex(const char* first_dex_name, const char* second_dex_name)
153       REQUIRES_SHARED(Locks::mutator_lock_);
154 
155   // The following helper functions return global JNI references to the class loader.
156   jobject LoadDexInPathClassLoader(const std::string& dex_name,
157                                    jobject parent_loader,
158                                    jobject shared_libraries = nullptr,
159                                    jobject shared_libraries_after = nullptr);
160   jobject LoadDexInPathClassLoader(const std::vector<std::string>& dex_names,
161                                    jobject parent_loader,
162                                    jobject shared_libraries = nullptr,
163                                    jobject shared_libraries_after = nullptr);
164   jobject LoadDexInDelegateLastClassLoader(const std::string& dex_name, jobject parent_loader);
165   jobject LoadDexInInMemoryDexClassLoader(const std::string& dex_name, jobject parent_loader);
166   jobject LoadDexInWellKnownClassLoader(ScopedObjectAccess& soa,
167                                         const std::vector<std::string>& dex_names,
168                                         ObjPtr<mirror::Class> loader_class,
169                                         jobject parent_loader,
170                                         jobject shared_libraries = nullptr,
171                                         jobject shared_libraries_after = nullptr)
172       REQUIRES_SHARED(Locks::mutator_lock_);
173 
174   void VisitDexes(ArrayRef<const std::string> dexes,
175                   const std::function<void(MethodReference)>& method_visitor,
176                   const std::function<void(TypeReference)>& class_visitor,
177                   size_t method_frequency = 1u,
178                   size_t class_frequency = 1u);
179 
180   void GenerateProfile(ArrayRef<const std::string> dexes,
181                        File* out_file,
182                        size_t method_frequency = 1u,
183                        size_t type_frequency = 1u,
184                        bool for_boot_image = false);
185   void GenerateBootProfile(ArrayRef<const std::string> dexes,
186                            File* out_file,
187                            size_t method_frequency = 1u,
188                            size_t type_frequency = 1u) {
189     return GenerateProfile(
190         dexes, out_file, method_frequency, type_frequency, /*for_boot_image=*/ true);
191   }
192 
193   std::unique_ptr<Runtime> runtime_;
194 
195   // The class_linker_, java_lang_dex_file_, and boot_class_path_ are all
196   // owned by the runtime.
197   ClassLinker* class_linker_;
198   const DexFile* java_lang_dex_file_;
199   std::vector<const DexFile*> boot_class_path_;
200 
201   // Get the dex files from a PathClassLoader or DelegateLastClassLoader.
202   // This only looks into the current class loader and does not recurse into the parents.
203   std::vector<const DexFile*> GetDexFiles(jobject jclass_loader);
204   std::vector<const DexFile*> GetDexFiles(Thread* self, Handle<mirror::ClassLoader> class_loader)
205     REQUIRES_SHARED(Locks::mutator_lock_);
206 
207   // Get the first dex file from a PathClassLoader. Will abort if it is null.
208   const DexFile* GetFirstDexFile(jobject jclass_loader);
209 
210   std::unique_ptr<CompilerCallbacks> callbacks_;
211 
212   bool use_boot_image_;
213 
214   virtual void SetUp();
215 
216   virtual void TearDown();
217 
218   // Called to finish up runtime creation and filling test fields. By default runs root
219   // initializers, initialize well-known classes, and creates the heap thread pool.
220   virtual void FinalizeSetup();
221 
222   // Returns the directory where the pre-compiled boot.art can be found.
223   static std::string GetImageLocation();
224   static std::string GetSystemImageFile();
225 
226   static void EnterTransactionMode() REQUIRES_SHARED(Locks::mutator_lock_);
227   static void ExitTransactionMode();
228   static void RollbackAndExitTransactionMode() REQUIRES_SHARED(Locks::mutator_lock_);
229   static bool IsTransactionAborted();
230 };
231 
232 template <typename TestType>
233 class CommonRuntimeTestBase : public TestType, public CommonRuntimeTestImpl {
234  public:
CommonRuntimeTestBase()235   CommonRuntimeTestBase() {}
~CommonRuntimeTestBase()236   virtual ~CommonRuntimeTestBase() {}
237 
238  protected:
SetUp()239   void SetUp() override {
240     CommonRuntimeTestImpl::SetUp();
241   }
242 
TearDown()243   void TearDown() override {
244     CommonRuntimeTestImpl::TearDown();
245   }
246 };
247 
248 using CommonRuntimeTest = CommonRuntimeTestBase<testing::Test>;
249 
250 template <typename Param>
251 using CommonRuntimeTestWithParam = CommonRuntimeTestBase<testing::TestWithParam<Param>>;
252 
253 // Sets a CheckJni abort hook to catch failures. Note that this will cause CheckJNI to carry on
254 // rather than aborting, so be careful!
255 class CheckJniAbortCatcher {
256  public:
257   CheckJniAbortCatcher();
258 
259   ~CheckJniAbortCatcher();
260 
261   void Check(const std::string& expected_text);
262   void Check(const char* expected_text);
263 
264  private:
265   static void Hook(void* data, const std::string& reason);
266 
267   JavaVMExt* const vm_;
268   std::string actual_;
269 
270   DISALLOW_COPY_AND_ASSIGN(CheckJniAbortCatcher);
271 };
272 
273 #define TEST_DISABLED() \
274   do { \
275     printf("WARNING: TEST DISABLED\n"); \
276     return; \
277   } while (false)
278 
279 #define TEST_DISABLED_FOR_ARM() \
280   if (kRuntimeISA == InstructionSet::kArm || kRuntimeISA == InstructionSet::kThumb2) { \
281     printf("WARNING: TEST DISABLED FOR ARM\n"); \
282     return; \
283   }
284 
285 #define TEST_DISABLED_FOR_ARM64() \
286   if (kRuntimeISA == InstructionSet::kArm64) { \
287     printf("WARNING: TEST DISABLED FOR ARM64\n"); \
288     return; \
289   }
290 
291 #define TEST_DISABLED_FOR_X86() \
292   if (kRuntimeISA == InstructionSet::kX86) { \
293     printf("WARNING: TEST DISABLED FOR X86\n"); \
294     return; \
295   }
296 
297 #define TEST_DISABLED_FOR_X86_64() \
298   if (kRuntimeISA == InstructionSet::kX86_64) { \
299     printf("WARNING: TEST DISABLED FOR X86_64\n"); \
300     return; \
301   }
302 
303 #define TEST_DISABLED_WITHOUT_BAKER_READ_BARRIERS() \
304   if (!gUseReadBarrier || !kUseBakerReadBarrier) { \
305     printf("WARNING: TEST DISABLED FOR GC WITHOUT BAKER READ BARRIER\n"); \
306     return; \
307   }
308 
309 #define TEST_DISABLED_FOR_HEAP_POISONING() \
310   if (kPoisonHeapReferences) { \
311     printf("WARNING: TEST DISABLED FOR HEAP POISONING\n"); \
312     return; \
313   }
314 
315 #define TEST_DISABLED_FOR_MEMORY_TOOL_WITH_HEAP_POISONING_WITHOUT_READ_BARRIERS() \
316   if (kRunningOnMemoryTool && kPoisonHeapReferences && !gUseReadBarrier) { \
317     printf("WARNING: TEST DISABLED FOR MEMORY TOOL WITH HEAP POISONING WITHOUT READ BARRIERS\n"); \
318     return; \
319   }
320 
321 #define TEST_DISABLED_FOR_KERNELS_WITH_CACHE_SEGFAULT() \
322   if (CacheOperationsMaySegFault()) { \
323     printf("WARNING: TEST DISABLED ON KERNEL THAT SEGFAULT ON CACHE OPERATIONS\n"); \
324     return; \
325   }
326 
327 }  // namespace art
328 
329 #endif  // ART_RUNTIME_COMMON_RUNTIME_TEST_H_
330