Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 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 | */ |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ |
| 18 | #define ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 19 | |
Elliott Hughes | 8add92d | 2012-01-18 18:18:43 -0800 | [diff] [blame] | 20 | #include <set> |
| 21 | #include <string> |
Logan Chien | df57614 | 2012-03-20 17:36:32 +0800 | [diff] [blame] | 22 | #include <vector> |
Elliott Hughes | e5448b5 | 2012-01-18 16:44:06 -0800 | [diff] [blame] | 23 | |
Elliott Hughes | 76b6167 | 2012-12-12 17:47:30 -0800 | [diff] [blame] | 24 | #include "base/mutex.h" |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 25 | #include "base/timing_logger.h" |
Brian Carlstrom | 51c2467 | 2013-07-11 16:00:56 -0700 | [diff] [blame] | 26 | #include "class_reference.h" |
Brian Carlstrom | 0755ec5 | 2012-01-11 15:19:46 -0800 | [diff] [blame] | 27 | #include "compiled_class.h" |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 28 | #include "compiled_method.h" |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 29 | #include "compiler.h" |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 30 | #include "dex_file.h" |
Alex Light | 78382fa | 2014-06-06 15:45:32 -0700 | [diff] [blame^] | 31 | #include "driver/compiler_options.h" |
Elliott Hughes | 0f3c553 | 2012-03-30 14:51:51 -0700 | [diff] [blame] | 32 | #include "instruction_set.h" |
| 33 | #include "invoke_type.h" |
Brian Carlstrom | 51c2467 | 2013-07-11 16:00:56 -0700 | [diff] [blame] | 34 | #include "method_reference.h" |
Brian Carlstrom | 56d947f | 2013-07-15 13:14:23 -0700 | [diff] [blame] | 35 | #include "os.h" |
Calin Juravle | 9dae5b4 | 2014-04-07 16:36:21 +0300 | [diff] [blame] | 36 | #include "profiler.h" |
Ian Rogers | 1cb0a1d | 2011-10-06 15:24:35 -0700 | [diff] [blame] | 37 | #include "runtime.h" |
Elliott Hughes | a0e1806 | 2012-04-13 15:59:59 -0700 | [diff] [blame] | 38 | #include "safe_map.h" |
Mathieu Chartier | 0e4627e | 2012-10-23 16:13:36 -0700 | [diff] [blame] | 39 | #include "thread_pool.h" |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 40 | #include "utils/arena_allocator.h" |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 41 | #include "utils/dedupe_set.h" |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 42 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 43 | namespace art { |
| 44 | |
Vladimir Marko | 2bc4780 | 2014-02-10 09:43:07 +0000 | [diff] [blame] | 45 | namespace verifier { |
| 46 | class MethodVerifier; |
| 47 | } // namespace verifier |
| 48 | |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 49 | class CompilerOptions; |
Ian Rogers | 89756f2 | 2013-03-04 16:40:02 -0800 | [diff] [blame] | 50 | class DexCompilationUnit; |
Vladimir Marko | 5816ed4 | 2013-11-27 17:04:20 +0000 | [diff] [blame] | 51 | class DexFileToMethodInlinerMap; |
Ian Rogers | b48b9eb | 2014-02-28 16:20:21 -0800 | [diff] [blame] | 52 | struct InlineIGetIPutData; |
Brian Carlstrom | c50d8e1 | 2013-07-23 22:35:16 -0700 | [diff] [blame] | 53 | class OatWriter; |
Nicolas Geoffray | f5df897 | 2014-02-14 18:37:08 +0000 | [diff] [blame] | 54 | class ParallelCompilationManager; |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 55 | class ScopedObjectAccess; |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 56 | template<class T> class Handle; |
Elliott Hughes | 601a123 | 2012-02-02 17:47:38 -0800 | [diff] [blame] | 57 | class TimingLogger; |
Vladimir Marko | c7f8320 | 2014-01-24 17:55:18 +0000 | [diff] [blame] | 58 | class VerificationResults; |
Vladimir Marko | 2730db0 | 2014-01-27 11:15:17 +0000 | [diff] [blame] | 59 | class VerifiedMethod; |
Ian Rogers | 996cc58 | 2012-02-14 22:23:29 -0800 | [diff] [blame] | 60 | |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 61 | enum EntryPointCallingConvention { |
| 62 | // ABI of invocations to a method's interpreter entry point. |
| 63 | kInterpreterAbi, |
| 64 | // ABI of calls to a method's native code, only used for native methods. |
| 65 | kJniAbi, |
| 66 | // ABI of calls to a method's portable code entry point. |
| 67 | kPortableAbi, |
| 68 | // ABI of calls to a method's quick code entry point. |
| 69 | kQuickAbi |
| 70 | }; |
| 71 | |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 72 | enum DexToDexCompilationLevel { |
| 73 | kDontDexToDexCompile, // Only meaning wrt image time interpretation. |
| 74 | kRequired, // Dex-to-dex compilation required for correctness. |
| 75 | kOptimize // Perform required transformation and peep-hole optimizations. |
| 76 | }; |
| 77 | |
buzbee | 4df2bbd | 2012-10-11 14:46:06 -0700 | [diff] [blame] | 78 | // Thread-local storage compiler worker threads |
| 79 | class CompilerTls { |
buzbee | 4df2bbd | 2012-10-11 14:46:06 -0700 | [diff] [blame] | 80 | public: |
| 81 | CompilerTls() : llvm_info_(NULL) {} |
| 82 | ~CompilerTls() {} |
| 83 | |
| 84 | void* GetLLVMInfo() { return llvm_info_; } |
| 85 | |
| 86 | void SetLLVMInfo(void* llvm_info) { llvm_info_ = llvm_info; } |
| 87 | |
| 88 | private: |
| 89 | void* llvm_info_; |
buzbee | 4df2bbd | 2012-10-11 14:46:06 -0700 | [diff] [blame] | 90 | }; |
| 91 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 92 | class CompilerDriver { |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 93 | public: |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 94 | typedef std::set<std::string> DescriptorSet; |
| 95 | |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 96 | // Create a compiler targeting the requested "instruction_set". |
Brian Carlstrom | ae82698 | 2011-11-09 01:33:42 -0800 | [diff] [blame] | 97 | // "image" should be true if image specific optimizations should be |
| 98 | // enabled. "image_classes" lets the compiler know what classes it |
| 99 | // can assume will be in the image, with NULL implying all available |
| 100 | // classes. |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 101 | explicit CompilerDriver(const CompilerOptions* compiler_options, |
| 102 | VerificationResults* verification_results, |
Vladimir Marko | 5816ed4 | 2013-11-27 17:04:20 +0000 | [diff] [blame] | 103 | DexFileToMethodInlinerMap* method_inliner_map, |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 104 | Compiler::Kind compiler_kind, |
Nicolas Geoffray | f5df897 | 2014-02-14 18:37:08 +0000 | [diff] [blame] | 105 | InstructionSet instruction_set, |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 106 | InstructionSetFeatures instruction_set_features, |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 107 | bool image, DescriptorSet* image_classes, |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 108 | size_t thread_count, bool dump_stats, bool dump_passes, |
Alex Light | 78382fa | 2014-06-06 15:45:32 -0700 | [diff] [blame^] | 109 | CumulativeLogger* timer, std::string profile_file = ""); |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 110 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 111 | ~CompilerDriver(); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 112 | |
Brian Carlstrom | 4560248 | 2013-07-21 22:07:55 -0700 | [diff] [blame] | 113 | void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 114 | TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 115 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 8a48741 | 2011-08-29 20:08:52 -0700 | [diff] [blame] | 116 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 117 | // Compile a single Method. |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 118 | void CompileOne(mirror::ArtMethod* method, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 119 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 120 | |
Vladimir Marko | c7f8320 | 2014-01-24 17:55:18 +0000 | [diff] [blame] | 121 | VerificationResults* GetVerificationResults() const { |
| 122 | return verification_results_; |
Vladimir Marko | 2b5eaa2 | 2013-12-13 13:59:30 +0000 | [diff] [blame] | 123 | } |
| 124 | |
Vladimir Marko | 5816ed4 | 2013-11-27 17:04:20 +0000 | [diff] [blame] | 125 | DexFileToMethodInlinerMap* GetMethodInlinerMap() const { |
| 126 | return method_inliner_map_; |
| 127 | } |
| 128 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 129 | InstructionSet GetInstructionSet() const { |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 130 | return instruction_set_; |
| 131 | } |
| 132 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 133 | InstructionSetFeatures GetInstructionSetFeatures() const { |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 134 | return instruction_set_features_; |
| 135 | } |
| 136 | |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 137 | const CompilerOptions& GetCompilerOptions() const { |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 138 | return *compiler_options_; |
| 139 | } |
| 140 | |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 141 | Compiler* GetCompiler() const { |
| 142 | return compiler_.get(); |
buzbee | c531cef | 2012-10-18 07:09:20 -0700 | [diff] [blame] | 143 | } |
| 144 | |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 145 | bool ProfilePresent() const { |
Calin Juravle | c1b643c | 2014-05-30 23:44:11 +0100 | [diff] [blame] | 146 | return profile_present_; |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 147 | } |
| 148 | |
Ian Rogers | e6bb3b2 | 2013-08-19 21:51:45 -0700 | [diff] [blame] | 149 | // Are we compiling and creating an image file? |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 150 | bool IsImage() const { |
| 151 | return image_; |
| 152 | } |
| 153 | |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 154 | DescriptorSet* GetImageClasses() const { |
| 155 | return image_classes_.get(); |
| 156 | } |
| 157 | |
buzbee | 4df2bbd | 2012-10-11 14:46:06 -0700 | [diff] [blame] | 158 | CompilerTls* GetTls(); |
| 159 | |
Jeff Hao | 0aba0ba | 2013-06-03 14:49:28 -0700 | [diff] [blame] | 160 | // Generate the trampolines that are invoked by unresolved direct methods. |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 161 | const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const |
| 162 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 163 | const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const |
| 164 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 165 | const std::vector<uint8_t>* CreateJniDlsymLookup() const |
| 166 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Jeff Hao | 88474b4 | 2013-10-23 16:24:40 -0700 | [diff] [blame] | 167 | const std::vector<uint8_t>* CreatePortableImtConflictTrampoline() const |
| 168 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Jeff Hao | 0aba0ba | 2013-06-03 14:49:28 -0700 | [diff] [blame] | 169 | const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const |
| 170 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 171 | const std::vector<uint8_t>* CreatePortableToInterpreterBridge() const |
| 172 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Andreas Gampe | 2da8823 | 2014-02-27 12:26:20 -0800 | [diff] [blame] | 173 | const std::vector<uint8_t>* CreateQuickGenericJniTrampoline() const |
| 174 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Jeff Hao | 88474b4 | 2013-10-23 16:24:40 -0700 | [diff] [blame] | 175 | const std::vector<uint8_t>* CreateQuickImtConflictTrampoline() const |
| 176 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Jeff Hao | 0aba0ba | 2013-06-03 14:49:28 -0700 | [diff] [blame] | 177 | const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const |
| 178 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 179 | const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const |
Jeff Hao | 0aba0ba | 2013-06-03 14:49:28 -0700 | [diff] [blame] | 180 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 181 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 182 | CompiledClass* GetCompiledClass(ClassReference ref) const |
| 183 | LOCKS_EXCLUDED(compiled_classes_lock_); |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 184 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 185 | CompiledMethod* GetCompiledMethod(MethodReference ref) const |
| 186 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Brian Carlstrom | 0755ec5 | 2012-01-11 15:19:46 -0800 | [diff] [blame] | 187 | |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 188 | void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, |
| 189 | uint16_t class_def_index); |
| 190 | bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index); |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 191 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 192 | // Callbacks from compiler to see what runtime checks must be generated. |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 193 | |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 194 | bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 195 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 196 | bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 197 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 198 | |
| 199 | // Are runtime access checks necessary in the compiled code? |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 200 | bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, |
Ian Rogers | c9e463c | 2013-06-05 16:52:26 -0700 | [diff] [blame] | 201 | uint32_t type_idx, bool* type_known_final = NULL, |
| 202 | bool* type_known_abstract = NULL, |
| 203 | bool* equals_referrers_class = NULL) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 204 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 205 | |
| 206 | // Are runtime access and instantiable checks necessary in the code? |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 207 | bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, |
| 208 | uint32_t type_idx) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 209 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 210 | |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 211 | bool CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx, |
| 212 | bool* is_type_initialized, bool* use_direct_type_ptr, |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 213 | uintptr_t* direct_type_ptr, bool* out_is_finalizable); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 214 | |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 215 | // Get the DexCache for the |
| 216 | mirror::DexCache* GetDexCache(const DexCompilationUnit* mUnit) |
| 217 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 218 | |
| 219 | mirror::ClassLoader* GetClassLoader(ScopedObjectAccess& soa, const DexCompilationUnit* mUnit) |
| 220 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 221 | |
| 222 | // Resolve compiling method's class. Returns nullptr on failure. |
| 223 | mirror::Class* ResolveCompilingMethodsClass( |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 224 | ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
| 225 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit) |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 226 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 227 | |
| 228 | // Resolve a field. Returns nullptr on failure, including incompatible class change. |
| 229 | // NOTE: Unlike ClassLinker's ResolveField(), this method enforces is_static. |
| 230 | mirror::ArtField* ResolveField( |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 231 | ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
| 232 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 233 | uint32_t field_idx, bool is_static) |
| 234 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 235 | |
| 236 | // Get declaration location of a resolved field. |
| 237 | void GetResolvedFieldDexFileLocation( |
| 238 | mirror::ArtField* resolved_field, const DexFile** declaring_dex_file, |
| 239 | uint16_t* declaring_class_idx, uint16_t* declaring_field_idx) |
| 240 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 241 | |
| 242 | bool IsFieldVolatile(mirror::ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 243 | |
| 244 | // Can we fast-path an IGET/IPUT access to an instance field? If yes, compute the field offset. |
| 245 | std::pair<bool, bool> IsFastInstanceField( |
| 246 | mirror::DexCache* dex_cache, mirror::Class* referrer_class, |
| 247 | mirror::ArtField* resolved_field, uint16_t field_idx, MemberOffset* field_offset) |
| 248 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 249 | |
| 250 | // Can we fast-path an SGET/SPUT access to a static field? If yes, compute the field offset, |
| 251 | // the type index of the declaring class in the referrer's dex file and whether the declaring |
| 252 | // class is the referrer's class or at least can be assumed to be initialized. |
| 253 | std::pair<bool, bool> IsFastStaticField( |
| 254 | mirror::DexCache* dex_cache, mirror::Class* referrer_class, |
| 255 | mirror::ArtField* resolved_field, uint16_t field_idx, MemberOffset* field_offset, |
| 256 | uint32_t* storage_index, bool* is_referrers_class, bool* is_initialized) |
| 257 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 258 | |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 259 | // Resolve a method. Returns nullptr on failure, including incompatible class change. |
| 260 | mirror::ArtMethod* ResolveMethod( |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 261 | ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
| 262 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 263 | uint32_t method_idx, InvokeType invoke_type) |
| 264 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 265 | |
| 266 | // Get declaration location of a resolved field. |
| 267 | void GetResolvedMethodDexFileLocation( |
| 268 | mirror::ArtMethod* resolved_method, const DexFile** declaring_dex_file, |
| 269 | uint16_t* declaring_class_idx, uint16_t* declaring_method_idx) |
| 270 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 271 | |
| 272 | // Get declaration location of a resolved field. |
| 273 | uint16_t GetResolvedMethodVTableIndex( |
| 274 | mirror::ArtMethod* resolved_method, InvokeType type) |
| 275 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 276 | |
| 277 | // Can we fast-path an INVOKE? If no, returns 0. If yes, returns a non-zero opaque flags value |
| 278 | // for ProcessedInvoke() and computes the necessary lowering info. |
| 279 | int IsFastInvoke( |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 280 | ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
| 281 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 282 | mirror::Class* referrer_class, mirror::ArtMethod* resolved_method, InvokeType* invoke_type, |
| 283 | MethodReference* target_method, const MethodReference* devirt_target, |
| 284 | uintptr_t* direct_code, uintptr_t* direct_method) |
| 285 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 286 | |
Vladimir Marko | 9820b7c | 2014-01-02 16:40:37 +0000 | [diff] [blame] | 287 | // Does invokation of the resolved method need class initialization? |
| 288 | bool NeedsClassInitialization(mirror::Class* referrer_class, mirror::ArtMethod* resolved_method) |
| 289 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 290 | |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 291 | void ProcessedInstanceField(bool resolved); |
| 292 | void ProcessedStaticField(bool resolved, bool local); |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 293 | void ProcessedInvoke(InvokeType invoke_type, int flags); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 294 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 295 | // Can we fast path instance field access? Computes field's offset and volatility. |
Ian Rogers | 9b297bf | 2013-09-06 11:11:25 -0700 | [diff] [blame] | 296 | bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 297 | MemberOffset* field_offset, bool* is_volatile) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 298 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 299 | |
| 300 | // Can we fastpath static field access? Computes field's offset, volatility and whether the |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 301 | // field is within the referrer (which can avoid checking class initialization). |
Ian Rogers | 9b297bf | 2013-09-06 11:11:25 -0700 | [diff] [blame] | 302 | bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 303 | MemberOffset* field_offset, uint32_t* storage_index, |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 304 | bool* is_referrers_class, bool* is_volatile, bool* is_initialized) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 305 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 306 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 307 | // Can we fastpath a interface, super class or virtual method call? Computes method's vtable |
| 308 | // index. |
Ian Rogers | e3cd2f0 | 2013-05-24 15:32:56 -0700 | [diff] [blame] | 309 | bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, |
Ian Rogers | 65ec92c | 2013-09-06 10:49:58 -0700 | [diff] [blame] | 310 | bool update_stats, bool enable_devirtualization, |
| 311 | InvokeType* type, MethodReference* target_method, int* vtable_idx, |
| 312 | uintptr_t* direct_code, uintptr_t* direct_method) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 313 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | a32a6fd | 2012-02-06 20:18:44 -0800 | [diff] [blame] | 314 | |
Vladimir Marko | 2730db0 | 2014-01-27 11:15:17 +0000 | [diff] [blame] | 315 | const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const; |
| 316 | bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc); |
Ian Rogers | fae370a | 2013-06-05 08:33:27 -0700 | [diff] [blame] | 317 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 318 | // Record patch information for later fix up. |
| 319 | void AddCodePatch(const DexFile* dex_file, |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 320 | uint16_t referrer_class_def_idx, |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 321 | uint32_t referrer_method_idx, |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 322 | InvokeType referrer_invoke_type, |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 323 | uint32_t target_method_idx, |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 324 | const DexFile* target_dex_file, |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 325 | InvokeType target_invoke_type, |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 326 | size_t literal_offset) |
| 327 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 328 | void AddRelativeCodePatch(const DexFile* dex_file, |
| 329 | uint16_t referrer_class_def_idx, |
| 330 | uint32_t referrer_method_idx, |
| 331 | InvokeType referrer_invoke_type, |
| 332 | uint32_t target_method_idx, |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 333 | const DexFile* target_dex_file, |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 334 | InvokeType target_invoke_type, |
| 335 | size_t literal_offset, |
| 336 | int32_t pc_relative_offset) |
| 337 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 338 | void AddMethodPatch(const DexFile* dex_file, |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 339 | uint16_t referrer_class_def_idx, |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 340 | uint32_t referrer_method_idx, |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 341 | InvokeType referrer_invoke_type, |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 342 | uint32_t target_method_idx, |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 343 | const DexFile* target_dex_file, |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 344 | InvokeType target_invoke_type, |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 345 | size_t literal_offset) |
| 346 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 347 | void AddClassPatch(const DexFile* dex_file, |
| 348 | uint16_t referrer_class_def_idx, |
| 349 | uint32_t referrer_method_idx, |
| 350 | uint32_t target_method_idx, |
| 351 | size_t literal_offset) |
| 352 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Ian Rogers | 3fa1379 | 2012-03-18 15:53:45 -0700 | [diff] [blame] | 353 | |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 354 | bool GetSupportBootImageFixup() const { |
| 355 | return support_boot_image_fixup_; |
| 356 | } |
| 357 | |
| 358 | void SetSupportBootImageFixup(bool support_boot_image_fixup) { |
| 359 | support_boot_image_fixup_ = support_boot_image_fixup; |
| 360 | } |
| 361 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 362 | ArenaPool* GetArenaPool() { |
| 363 | return &arena_pool_; |
Mathieu Chartier | f6c4b3b | 2013-08-24 16:11:37 -0700 | [diff] [blame] | 364 | } |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 365 | |
Brian Carlstrom | 3f47c12 | 2013-03-07 00:02:40 -0800 | [diff] [blame] | 366 | bool WriteElf(const std::string& android_root, |
Brian Carlstrom | 265091e | 2013-01-30 14:08:26 -0800 | [diff] [blame] | 367 | bool is_host, |
| 368 | const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 369 | OatWriter* oat_writer, |
Brian Carlstrom | 265091e | 2013-01-30 14:08:26 -0800 | [diff] [blame] | 370 | File* file); |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 371 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 372 | // TODO: move to a common home for llvm helpers once quick/portable are merged. |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 373 | static void InstructionSetToLLVMTarget(InstructionSet instruction_set, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 374 | std::string* target_triple, |
| 375 | std::string* target_cpu, |
| 376 | std::string* target_attr); |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 377 | |
Elliott Hughes | 6f4976c | 2012-03-13 21:19:01 -0700 | [diff] [blame] | 378 | void SetCompilerContext(void* compiler_context) { |
| 379 | compiler_context_ = compiler_context; |
| 380 | } |
| 381 | |
| 382 | void* GetCompilerContext() const { |
| 383 | return compiler_context_; |
| 384 | } |
| 385 | |
Logan Chien | 08e1ba3 | 2012-05-08 15:08:51 +0800 | [diff] [blame] | 386 | size_t GetThreadCount() const { |
| 387 | return thread_count_; |
| 388 | } |
| 389 | |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 390 | class CallPatchInformation; |
| 391 | class TypePatchInformation; |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 392 | |
| 393 | bool GetDumpPasses() const { |
| 394 | return dump_passes_; |
| 395 | } |
| 396 | |
Alex Light | 78382fa | 2014-06-06 15:45:32 -0700 | [diff] [blame^] | 397 | bool DidIncludeDebugSymbols() const { |
| 398 | return compiler_options_->GetIncludeDebugSymbols(); |
| 399 | } |
| 400 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 401 | CumulativeLogger* GetTimingsLogger() const { |
| 402 | return timings_logger_; |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 403 | } |
| 404 | |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 405 | class PatchInformation { |
| 406 | public: |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 407 | const DexFile& GetDexFile() const { |
| 408 | return *dex_file_; |
| 409 | } |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 410 | uint16_t GetReferrerClassDefIdx() const { |
| 411 | return referrer_class_def_idx_; |
| 412 | } |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 413 | uint32_t GetReferrerMethodIdx() const { |
| 414 | return referrer_method_idx_; |
| 415 | } |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 416 | size_t GetLiteralOffset() const { |
| 417 | return literal_offset_; |
| 418 | } |
| 419 | |
| 420 | virtual bool IsCall() const { |
| 421 | return false; |
| 422 | } |
| 423 | virtual bool IsType() const { |
| 424 | return false; |
| 425 | } |
| 426 | virtual const CallPatchInformation* AsCall() const { |
| 427 | LOG(FATAL) << "Unreachable"; |
| 428 | return nullptr; |
| 429 | } |
| 430 | virtual const TypePatchInformation* AsType() const { |
| 431 | LOG(FATAL) << "Unreachable"; |
| 432 | return nullptr; |
| 433 | } |
| 434 | |
| 435 | protected: |
| 436 | PatchInformation(const DexFile* dex_file, |
| 437 | uint16_t referrer_class_def_idx, |
| 438 | uint32_t referrer_method_idx, |
| 439 | size_t literal_offset) |
| 440 | : dex_file_(dex_file), |
| 441 | referrer_class_def_idx_(referrer_class_def_idx), |
| 442 | referrer_method_idx_(referrer_method_idx), |
| 443 | literal_offset_(literal_offset) { |
| 444 | CHECK(dex_file_ != NULL); |
| 445 | } |
| 446 | virtual ~PatchInformation() {} |
| 447 | |
| 448 | const DexFile* const dex_file_; |
| 449 | const uint16_t referrer_class_def_idx_; |
| 450 | const uint32_t referrer_method_idx_; |
| 451 | const size_t literal_offset_; |
| 452 | |
| 453 | friend class CompilerDriver; |
| 454 | }; |
| 455 | |
| 456 | class CallPatchInformation : public PatchInformation { |
| 457 | public: |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 458 | InvokeType GetReferrerInvokeType() const { |
| 459 | return referrer_invoke_type_; |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 460 | } |
| 461 | uint32_t GetTargetMethodIdx() const { |
| 462 | return target_method_idx_; |
| 463 | } |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 464 | const DexFile* GetTargetDexFile() const { |
| 465 | return target_dex_file_; |
| 466 | } |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 467 | InvokeType GetTargetInvokeType() const { |
| 468 | return target_invoke_type_; |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 469 | } |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 470 | |
| 471 | const CallPatchInformation* AsCall() const { |
| 472 | return this; |
| 473 | } |
| 474 | bool IsCall() const { |
| 475 | return true; |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 476 | } |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 477 | virtual bool IsRelative() const { |
| 478 | return false; |
| 479 | } |
| 480 | virtual int RelativeOffset() const { |
| 481 | return 0; |
| 482 | } |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 483 | |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 484 | protected: |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 485 | CallPatchInformation(const DexFile* dex_file, |
| 486 | uint16_t referrer_class_def_idx, |
| 487 | uint32_t referrer_method_idx, |
| 488 | InvokeType referrer_invoke_type, |
| 489 | uint32_t target_method_idx, |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 490 | const DexFile* target_dex_file, |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 491 | InvokeType target_invoke_type, |
| 492 | size_t literal_offset) |
| 493 | : PatchInformation(dex_file, referrer_class_def_idx, |
| 494 | referrer_method_idx, literal_offset), |
| 495 | referrer_invoke_type_(referrer_invoke_type), |
| 496 | target_method_idx_(target_method_idx), |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 497 | target_dex_file_(target_dex_file), |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 498 | target_invoke_type_(target_invoke_type) { |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 499 | } |
| 500 | |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 501 | private: |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 502 | const InvokeType referrer_invoke_type_; |
| 503 | const uint32_t target_method_idx_; |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 504 | const DexFile* target_dex_file_; |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 505 | const InvokeType target_invoke_type_; |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 506 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 507 | friend class CompilerDriver; |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 508 | DISALLOW_COPY_AND_ASSIGN(CallPatchInformation); |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 509 | }; |
| 510 | |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 511 | class RelativeCallPatchInformation : public CallPatchInformation { |
| 512 | public: |
| 513 | bool IsRelative() const { |
| 514 | return true; |
| 515 | } |
| 516 | int RelativeOffset() const { |
| 517 | return offset_; |
| 518 | } |
| 519 | |
| 520 | private: |
| 521 | RelativeCallPatchInformation(const DexFile* dex_file, |
| 522 | uint16_t referrer_class_def_idx, |
| 523 | uint32_t referrer_method_idx, |
| 524 | InvokeType referrer_invoke_type, |
| 525 | uint32_t target_method_idx, |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 526 | const DexFile* target_dex_file, |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 527 | InvokeType target_invoke_type, |
| 528 | size_t literal_offset, |
| 529 | int32_t pc_relative_offset) |
| 530 | : CallPatchInformation(dex_file, referrer_class_def_idx, |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 531 | referrer_method_idx, referrer_invoke_type, target_method_idx, |
| 532 | target_dex_file, target_invoke_type, literal_offset), |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 533 | offset_(pc_relative_offset) { |
| 534 | } |
| 535 | |
| 536 | const int offset_; |
| 537 | |
| 538 | friend class CompilerDriver; |
| 539 | DISALLOW_COPY_AND_ASSIGN(RelativeCallPatchInformation); |
| 540 | }; |
| 541 | |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 542 | class TypePatchInformation : public PatchInformation { |
| 543 | public: |
| 544 | uint32_t GetTargetTypeIdx() const { |
| 545 | return target_type_idx_; |
| 546 | } |
| 547 | |
| 548 | bool IsType() const { |
| 549 | return true; |
| 550 | } |
| 551 | const TypePatchInformation* AsType() const { |
| 552 | return this; |
| 553 | } |
| 554 | |
| 555 | private: |
| 556 | TypePatchInformation(const DexFile* dex_file, |
| 557 | uint16_t referrer_class_def_idx, |
| 558 | uint32_t referrer_method_idx, |
| 559 | uint32_t target_type_idx, |
| 560 | size_t literal_offset) |
| 561 | : PatchInformation(dex_file, referrer_class_def_idx, |
| 562 | referrer_method_idx, literal_offset), |
| 563 | target_type_idx_(target_type_idx) { |
| 564 | } |
| 565 | |
| 566 | const uint32_t target_type_idx_; |
| 567 | |
| 568 | friend class CompilerDriver; |
| 569 | DISALLOW_COPY_AND_ASSIGN(TypePatchInformation); |
| 570 | }; |
| 571 | |
| 572 | const std::vector<const CallPatchInformation*>& GetCodeToPatch() const { |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 573 | return code_to_patch_; |
| 574 | } |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 575 | const std::vector<const CallPatchInformation*>& GetMethodsToPatch() const { |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 576 | return methods_to_patch_; |
| 577 | } |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 578 | const std::vector<const TypePatchInformation*>& GetClassesToPatch() const { |
| 579 | return classes_to_patch_; |
| 580 | } |
Brian Carlstrom | f582258 | 2012-03-19 22:34:31 -0700 | [diff] [blame] | 581 | |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 582 | // Checks if class specified by type_idx is one of the image_classes_ |
Ian Rogers | dfb325e | 2013-10-30 01:00:44 -0700 | [diff] [blame] | 583 | bool IsImageClass(const char* descriptor) const; |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 584 | |
Ian Rogers | 8f3c9ae | 2013-08-20 17:26:41 -0700 | [diff] [blame] | 585 | void RecordClassStatus(ClassReference ref, mirror::Class::Status status) |
| 586 | LOCKS_EXCLUDED(compiled_classes_lock_); |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 587 | |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 588 | std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code); |
| 589 | std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code); |
| 590 | std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code); |
| 591 | std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code); |
Mark Mendell | ae9fd93 | 2014-02-10 16:14:35 -0800 | [diff] [blame] | 592 | std::vector<uint8_t>* DeduplicateCFIInfo(const std::vector<uint8_t>* cfi_info); |
| 593 | |
| 594 | /* |
| 595 | * @brief return the pointer to the Call Frame Information. |
| 596 | * @return pointer to call frame information for this compilation. |
| 597 | */ |
| 598 | std::vector<uint8_t>* GetCallFrameInformation() const { |
| 599 | return cfi_info_.get(); |
| 600 | } |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 601 | |
Calin Juravle | bb0b53f | 2014-05-23 17:33:29 +0100 | [diff] [blame] | 602 | ProfileFile profile_file_; |
Calin Juravle | c1b643c | 2014-05-30 23:44:11 +0100 | [diff] [blame] | 603 | bool profile_present_; |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 604 | |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 605 | // Should the compiler run on this method given profile information? |
| 606 | bool SkipCompilation(const std::string& method_name); |
| 607 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 608 | private: |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 609 | // These flags are internal to CompilerDriver for collecting INVOKE resolution statistics. |
| 610 | // The only external contract is that unresolved method has flags 0 and resolved non-0. |
| 611 | enum { |
| 612 | kBitMethodResolved = 0, |
| 613 | kBitVirtualMadeDirect, |
| 614 | kBitPreciseTypeDevirtualization, |
| 615 | kBitDirectCallToBoot, |
| 616 | kBitDirectMethodToBoot |
| 617 | }; |
| 618 | static constexpr int kFlagMethodResolved = 1 << kBitMethodResolved; |
| 619 | static constexpr int kFlagVirtualMadeDirect = 1 << kBitVirtualMadeDirect; |
| 620 | static constexpr int kFlagPreciseTypeDevirtualization = 1 << kBitPreciseTypeDevirtualization; |
| 621 | static constexpr int kFlagDirectCallToBoot = 1 << kBitDirectCallToBoot; |
| 622 | static constexpr int kFlagDirectMethodToBoot = 1 << kBitDirectMethodToBoot; |
| 623 | static constexpr int kFlagsMethodResolvedVirtualMadeDirect = |
| 624 | kFlagMethodResolved | kFlagVirtualMadeDirect; |
| 625 | static constexpr int kFlagsMethodResolvedPreciseTypeDevirtualization = |
| 626 | kFlagsMethodResolvedVirtualMadeDirect | kFlagPreciseTypeDevirtualization; |
| 627 | |
| 628 | public: // TODO make private or eliminate. |
| 629 | // Compute constant code and method pointers when possible. |
Ian Rogers | 83883d7 | 2013-10-21 21:07:24 -0700 | [diff] [blame] | 630 | void GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type, |
| 631 | bool no_guarantee_of_dex_cache_entry, |
Ian Rogers | 4f6ad8a | 2013-03-18 15:27:28 -0700 | [diff] [blame] | 632 | mirror::Class* referrer_class, |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 633 | mirror::ArtMethod* method, |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 634 | int* stats_flags, |
Ian Rogers | 83883d7 | 2013-10-21 21:07:24 -0700 | [diff] [blame] | 635 | MethodReference* target_method, |
Ian Rogers | 65ec92c | 2013-09-06 10:49:58 -0700 | [diff] [blame] | 636 | uintptr_t* direct_code, uintptr_t* direct_method) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 637 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 2ed3b95 | 2012-03-17 11:49:39 -0700 | [diff] [blame] | 638 | |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 639 | private: |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 640 | void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 641 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 642 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | ae82698 | 2011-11-09 01:33:42 -0800 | [diff] [blame] | 643 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 644 | void LoadImageClasses(TimingLogger* timings); |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 645 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 646 | // Attempt to resolve all type, methods, fields, and strings |
| 647 | // referenced from code in the dex file following PathClassLoader |
| 648 | // ordering semantics. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 649 | void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 650 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 651 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 652 | void ResolveDexFile(jobject class_loader, const DexFile& dex_file, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 653 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 654 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 655 | |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 656 | void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 657 | ThreadPool* thread_pool, TimingLogger* timings); |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 658 | void VerifyDexFile(jobject class_loader, const DexFile& dex_file, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 659 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 660 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
jeffhao | 98eacac | 2011-09-14 16:11:53 -0700 | [diff] [blame] | 661 | |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 662 | void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 663 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 664 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 665 | void InitializeClasses(jobject class_loader, const DexFile& dex_file, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 666 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 667 | LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_); |
Brian Carlstrom | a5a97a2 | 2011-09-15 14:08:49 -0700 | [diff] [blame] | 668 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 669 | void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 670 | static void FindClinitImageClassesCallback(mirror::Object* object, void* arg) |
| 671 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 672 | |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 673 | void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 674 | ThreadPool* thread_pool, TimingLogger* timings); |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 675 | void CompileDexFile(jobject class_loader, const DexFile& dex_file, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 676 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 677 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 678 | void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 679 | InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx, |
Sebastien Hertz | 2d6ba51 | 2013-05-17 11:31:37 +0200 | [diff] [blame] | 680 | jobject class_loader, const DexFile& dex_file, |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 681 | DexToDexCompilationLevel dex_to_dex_compilation_level) |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 682 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Brian Carlstrom | 83db772 | 2011-08-26 17:32:56 -0700 | [diff] [blame] | 683 | |
Ian Rogers | 219b5a8 | 2013-03-04 13:48:24 -0800 | [diff] [blame] | 684 | static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 685 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Elliott Hughes | c225caa | 2012-02-03 15:43:37 -0800 | [diff] [blame] | 686 | |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 687 | std::vector<const CallPatchInformation*> code_to_patch_; |
| 688 | std::vector<const CallPatchInformation*> methods_to_patch_; |
| 689 | std::vector<const TypePatchInformation*> classes_to_patch_; |
Ian Rogers | 3fa1379 | 2012-03-18 15:53:45 -0700 | [diff] [blame] | 690 | |
Brian Carlstrom | ae7083d | 2014-02-24 21:56:02 -0800 | [diff] [blame] | 691 | const CompilerOptions* const compiler_options_; |
| 692 | VerificationResults* const verification_results_; |
| 693 | DexFileToMethodInlinerMap* const method_inliner_map_; |
Vladimir Marko | 2b5eaa2 | 2013-12-13 13:59:30 +0000 | [diff] [blame] | 694 | |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 695 | std::unique_ptr<Compiler> compiler_; |
buzbee | c531cef | 2012-10-18 07:09:20 -0700 | [diff] [blame] | 696 | |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 697 | const InstructionSet instruction_set_; |
| 698 | const InstructionSetFeatures instruction_set_features_; |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 699 | |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 700 | // All class references that require |
Ian Rogers | 8f3c9ae | 2013-08-20 17:26:41 -0700 | [diff] [blame] | 701 | mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 702 | std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_); |
| 703 | |
Elliott Hughes | a0e1806 | 2012-04-13 15:59:59 -0700 | [diff] [blame] | 704 | typedef SafeMap<const ClassReference, CompiledClass*> ClassTable; |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 705 | // All class references that this compiler has compiled. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 706 | mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 707 | ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_); |
Brian Carlstrom | 0755ec5 | 2012-01-11 15:19:46 -0800 | [diff] [blame] | 708 | |
Ian Rogers | e3cd2f0 | 2013-05-24 15:32:56 -0700 | [diff] [blame] | 709 | typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable; |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 710 | // All method references that this compiler has compiled. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 711 | mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 712 | MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_); |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 713 | |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 714 | const bool image_; |
| 715 | |
| 716 | // If image_ is true, specifies the classes that will be included in |
| 717 | // the image. Note if image_classes_ is NULL, all classes are |
| 718 | // included in the image. |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 719 | std::unique_ptr<DescriptorSet> image_classes_; |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 720 | |
Elliott Hughes | 5523ee0 | 2012-02-03 18:18:34 -0800 | [diff] [blame] | 721 | size_t thread_count_; |
Elliott Hughes | bb551fa | 2012-01-25 16:35:29 -0800 | [diff] [blame] | 722 | uint64_t start_ns_; |
| 723 | |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 724 | class AOTCompilationStats; |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 725 | std::unique_ptr<AOTCompilationStats> stats_; |
Ian Rogers | 996cc58 | 2012-02-14 22:23:29 -0800 | [diff] [blame] | 726 | |
Brian Carlstrom | ba0668e | 2012-03-26 13:14:07 -0700 | [diff] [blame] | 727 | bool dump_stats_; |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 728 | const bool dump_passes_; |
| 729 | |
| 730 | CumulativeLogger* const timings_logger_; |
Brian Carlstrom | ba0668e | 2012-03-26 13:14:07 -0700 | [diff] [blame] | 731 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 732 | typedef void (*CompilerCallbackFn)(CompilerDriver& driver); |
| 733 | typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver); |
Logan Chien | f7015fd | 2012-03-18 01:19:37 +0800 | [diff] [blame] | 734 | |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 735 | void* compiler_library_; |
Elliott Hughes | 46f060a | 2012-03-09 17:36:50 -0800 | [diff] [blame] | 736 | |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 737 | typedef void (*DexToDexCompilerFn)(CompilerDriver& driver, |
| 738 | const DexFile::CodeItem* code_item, |
| 739 | uint32_t access_flags, InvokeType invoke_type, |
| 740 | uint32_t class_dex_idx, uint32_t method_idx, |
| 741 | jobject class_loader, const DexFile& dex_file, |
| 742 | DexToDexCompilationLevel dex_to_dex_compilation_level); |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 743 | DexToDexCompilerFn dex_to_dex_compiler_; |
Sebastien Hertz | 2d6ba51 | 2013-05-17 11:31:37 +0200 | [diff] [blame] | 744 | |
Elliott Hughes | 6f4976c | 2012-03-13 21:19:01 -0700 | [diff] [blame] | 745 | void* compiler_context_; |
| 746 | |
buzbee | 4df2bbd | 2012-10-11 14:46:06 -0700 | [diff] [blame] | 747 | pthread_key_t tls_key_; |
| 748 | |
Mathieu Chartier | f6c4b3b | 2013-08-24 16:11:37 -0700 | [diff] [blame] | 749 | // Arena pool used by the compiler. |
| 750 | ArenaPool arena_pool_; |
| 751 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 752 | typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver); |
Logan Chien | f7015fd | 2012-03-18 01:19:37 +0800 | [diff] [blame] | 753 | CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_; |
| 754 | |
| 755 | typedef const void* (*CompilerGetMethodCodeAddrFn) |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 756 | (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method); |
Logan Chien | f7015fd | 2012-03-18 01:19:37 +0800 | [diff] [blame] | 757 | CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_; |
| 758 | |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 759 | bool support_boot_image_fixup_; |
| 760 | |
Mark Mendell | ae9fd93 | 2014-02-10 16:14:35 -0800 | [diff] [blame] | 761 | // Call Frame Information, which might be generated to help stack tracebacks. |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 762 | std::unique_ptr<std::vector<uint8_t>> cfi_info_; |
Mark Mendell | ae9fd93 | 2014-02-10 16:14:35 -0800 | [diff] [blame] | 763 | |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 764 | // DeDuplication data structures, these own the corresponding byte arrays. |
| 765 | class DedupeHashFunc { |
| 766 | public: |
| 767 | size_t operator()(const std::vector<uint8_t>& array) const { |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 768 | // For small arrays compute a hash using every byte. |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 769 | static const size_t kSmallArrayThreshold = 16; |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 770 | size_t hash = 0x811c9dc5; |
| 771 | if (array.size() <= kSmallArrayThreshold) { |
| 772 | for (uint8_t b : array) { |
| 773 | hash = (hash * 16777619) ^ b; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 774 | } |
| 775 | } else { |
Ian Rogers | 936bf02 | 2013-09-06 08:44:06 -0700 | [diff] [blame] | 776 | // For larger arrays use the 2 bytes at 6 bytes (the location of a push registers |
| 777 | // instruction field for quick generated code on ARM) and then select a number of other |
| 778 | // values at random. |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 779 | static const size_t kRandomHashCount = 16; |
Ian Rogers | 936bf02 | 2013-09-06 08:44:06 -0700 | [diff] [blame] | 780 | for (size_t i = 0; i < 2; ++i) { |
| 781 | uint8_t b = array[i + 6]; |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 782 | hash = (hash * 16777619) ^ b; |
| 783 | } |
Ian Rogers | 936bf02 | 2013-09-06 08:44:06 -0700 | [diff] [blame] | 784 | for (size_t i = 2; i < kRandomHashCount; ++i) { |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 785 | size_t r = i * 1103515245 + 12345; |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 786 | uint8_t b = array[r % array.size()]; |
| 787 | hash = (hash * 16777619) ^ b; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 788 | } |
| 789 | } |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 790 | hash += hash << 13; |
| 791 | hash ^= hash >> 7; |
| 792 | hash += hash << 3; |
| 793 | hash ^= hash >> 17; |
| 794 | hash += hash << 5; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 795 | return hash; |
| 796 | } |
| 797 | }; |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 798 | DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_code_; |
| 799 | DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_mapping_table_; |
| 800 | DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_vmap_table_; |
| 801 | DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_gc_map_; |
Mark Mendell | ae9fd93 | 2014-02-10 16:14:35 -0800 | [diff] [blame] | 802 | DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_cfi_info_; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 803 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 804 | DISALLOW_COPY_AND_ASSIGN(CompilerDriver); |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 805 | }; |
| 806 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 807 | } // namespace art |
| 808 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 809 | #endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ |