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_COMPILER_COMMON_COMPILER_TEST_H_
18 #define ART_COMPILER_COMMON_COMPILER_TEST_H_
19 
20 #include <list>
21 #include <unordered_set>
22 #include <vector>
23 
24 #include "common_runtime_test.h"
25 #include "compiler.h"
26 #include "jit/profile_compilation_info.h"
27 #include "oat_file.h"
28 
29 namespace art {
30 namespace mirror {
31   class ClassLoader;
32 }  // namespace mirror
33 
34 class CompilerDriver;
35 class CompilerOptions;
36 class CumulativeLogger;
37 class VerificationResults;
38 
39 template<class T> class Handle;
40 
41 class CommonCompilerTest : public CommonRuntimeTest {
42  public:
43   CommonCompilerTest();
44   ~CommonCompilerTest();
45 
46   // Create an OatMethod based on pointers (for unit tests).
47   OatFile::OatMethod CreateOatMethod(const void* code);
48 
49   void MakeExecutable(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_);
50 
51   static void MakeExecutable(const void* code_start, size_t code_length);
52 
53   void MakeExecutable(ObjPtr<mirror::ClassLoader> class_loader, const char* class_name)
54       REQUIRES_SHARED(Locks::mutator_lock_);
55 
56  protected:
57   virtual void SetUp();
58 
59   virtual void SetUpRuntimeOptions(RuntimeOptions* options);
60 
61   Compiler::Kind GetCompilerKind() const;
62   void SetCompilerKind(Compiler::Kind compiler_kind);
63 
64   InstructionSet GetInstructionSet() const;
65 
66   // Get the set of image classes given to the compiler-driver in SetUp. Note: the compiler
67   // driver assumes ownership of the set, so the test should properly release the set.
68   virtual std::unordered_set<std::string>* GetImageClasses();
69 
70   // Get the set of compiled classes given to the compiler-driver in SetUp. Note: the compiler
71   // driver assumes ownership of the set, so the test should properly release the set.
72   virtual std::unordered_set<std::string>* GetCompiledClasses();
73 
74   // Get the set of compiled methods given to the compiler-driver in SetUp. Note: the compiler
75   // driver assumes ownership of the set, so the test should properly release the set.
76   virtual std::unordered_set<std::string>* GetCompiledMethods();
77 
78   virtual ProfileCompilationInfo* GetProfileCompilationInfo();
79 
GetCompilerFilter()80   virtual CompilerFilter::Filter GetCompilerFilter() const {
81     return CompilerFilter::kDefaultCompilerFilter;
82   }
83 
84   virtual void TearDown();
85 
86   void CompileClass(mirror::ClassLoader* class_loader, const char* class_name)
87       REQUIRES_SHARED(Locks::mutator_lock_);
88 
89   void CompileMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_);
90 
91   void CompileDirectMethod(Handle<mirror::ClassLoader> class_loader, const char* class_name,
92                            const char* method_name, const char* signature)
93       REQUIRES_SHARED(Locks::mutator_lock_);
94 
95   void CompileVirtualMethod(Handle<mirror::ClassLoader> class_loader, const char* class_name,
96                             const char* method_name, const char* signature)
97       REQUIRES_SHARED(Locks::mutator_lock_);
98 
99   void CreateCompilerDriver(Compiler::Kind kind, InstructionSet isa, size_t number_of_threads = 2U);
100 
101   void ReserveImageSpace();
102 
103   void UnreserveImageSpace();
104 
105   Compiler::Kind compiler_kind_ = Compiler::kOptimizing;
106   std::unique_ptr<CompilerOptions> compiler_options_;
107   std::unique_ptr<VerificationResults> verification_results_;
108   std::unique_ptr<CompilerDriver> compiler_driver_;
109   std::unique_ptr<CumulativeLogger> timer_;
110   std::unique_ptr<const InstructionSetFeatures> instruction_set_features_;
111 
112 
113  private:
114   std::unique_ptr<MemMap> image_reservation_;
115 
116   // Chunks must not move their storage after being created - use the node-based std::list.
117   std::list<std::vector<uint8_t>> header_code_and_maps_chunks_;
118 };
119 
120 }  // namespace art
121 
122 #endif  // ART_COMPILER_COMMON_COMPILER_TEST_H_
123