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 | |
Ian Rogers | d582fa4 | 2014-11-05 23:46:43 -0800 | [diff] [blame] | 24 | #include "arch/instruction_set.h" |
Elliott Hughes | 76b6167 | 2012-12-12 17:47:30 -0800 | [diff] [blame] | 25 | #include "base/mutex.h" |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 26 | #include "base/timing_logger.h" |
Brian Carlstrom | 51c2467 | 2013-07-11 16:00:56 -0700 | [diff] [blame] | 27 | #include "class_reference.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 "invoke_type.h" |
Brian Carlstrom | 51c2467 | 2013-07-11 16:00:56 -0700 | [diff] [blame] | 33 | #include "method_reference.h" |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 34 | #include "mirror/class.h" // For mirror::Class::Status. |
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" |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 42 | #include "utils/swap_space.h" |
| 43 | #include "utils.h" |
Mathieu Chartier | ab972ef | 2014-12-03 17:38:22 -0800 | [diff] [blame] | 44 | #include "dex/verified_method.h" |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 45 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 46 | namespace art { |
| 47 | |
Vladimir Marko | 2bc4780 | 2014-02-10 09:43:07 +0000 | [diff] [blame] | 48 | namespace verifier { |
| 49 | class MethodVerifier; |
| 50 | } // namespace verifier |
| 51 | |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 52 | class CompiledClass; |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 53 | class CompilerOptions; |
Ian Rogers | 89756f2 | 2013-03-04 16:40:02 -0800 | [diff] [blame] | 54 | class DexCompilationUnit; |
Vladimir Marko | 5816ed4 | 2013-11-27 17:04:20 +0000 | [diff] [blame] | 55 | class DexFileToMethodInlinerMap; |
Ian Rogers | b48b9eb | 2014-02-28 16:20:21 -0800 | [diff] [blame] | 56 | struct InlineIGetIPutData; |
Ian Rogers | d582fa4 | 2014-11-05 23:46:43 -0800 | [diff] [blame] | 57 | class InstructionSetFeatures; |
Brian Carlstrom | c50d8e1 | 2013-07-23 22:35:16 -0700 | [diff] [blame] | 58 | class OatWriter; |
Nicolas Geoffray | f5df897 | 2014-02-14 18:37:08 +0000 | [diff] [blame] | 59 | class ParallelCompilationManager; |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 60 | class ScopedObjectAccess; |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 61 | template<class T> class Handle; |
Elliott Hughes | 601a123 | 2012-02-02 17:47:38 -0800 | [diff] [blame] | 62 | class TimingLogger; |
Vladimir Marko | c7f8320 | 2014-01-24 17:55:18 +0000 | [diff] [blame] | 63 | class VerificationResults; |
Vladimir Marko | 2730db0 | 2014-01-27 11:15:17 +0000 | [diff] [blame] | 64 | class VerifiedMethod; |
Ian Rogers | 996cc58 | 2012-02-14 22:23:29 -0800 | [diff] [blame] | 65 | |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 66 | enum EntryPointCallingConvention { |
| 67 | // ABI of invocations to a method's interpreter entry point. |
| 68 | kInterpreterAbi, |
| 69 | // ABI of calls to a method's native code, only used for native methods. |
| 70 | kJniAbi, |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 71 | // ABI of calls to a method's quick code entry point. |
| 72 | kQuickAbi |
| 73 | }; |
| 74 | |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 75 | enum DexToDexCompilationLevel { |
| 76 | kDontDexToDexCompile, // Only meaning wrt image time interpretation. |
| 77 | kRequired, // Dex-to-dex compilation required for correctness. |
| 78 | kOptimize // Perform required transformation and peep-hole optimizations. |
| 79 | }; |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 80 | std::ostream& operator<<(std::ostream& os, const DexToDexCompilationLevel& rhs); |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 81 | |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 82 | static constexpr bool kUseMurmur3Hash = true; |
| 83 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 84 | class CompilerDriver { |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 85 | public: |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 86 | // Create a compiler targeting the requested "instruction_set". |
Brian Carlstrom | ae82698 | 2011-11-09 01:33:42 -0800 | [diff] [blame] | 87 | // "image" should be true if image specific optimizations should be |
| 88 | // enabled. "image_classes" lets the compiler know what classes it |
Andreas Gampe | 2ed8def | 2014-08-28 14:41:02 -0700 | [diff] [blame] | 89 | // can assume will be in the image, with nullptr implying all available |
Brian Carlstrom | ae82698 | 2011-11-09 01:33:42 -0800 | [diff] [blame] | 90 | // classes. |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 91 | explicit CompilerDriver(const CompilerOptions* compiler_options, |
| 92 | VerificationResults* verification_results, |
Vladimir Marko | 5816ed4 | 2013-11-27 17:04:20 +0000 | [diff] [blame] | 93 | DexFileToMethodInlinerMap* method_inliner_map, |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 94 | Compiler::Kind compiler_kind, |
Nicolas Geoffray | f5df897 | 2014-02-14 18:37:08 +0000 | [diff] [blame] | 95 | InstructionSet instruction_set, |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 96 | const InstructionSetFeatures* instruction_set_features, |
Ian Rogers | 1ff3c98 | 2014-08-12 02:30:58 -0700 | [diff] [blame] | 97 | bool image, std::set<std::string>* image_classes, |
Andreas Gampe | 4bf3ae9 | 2014-11-11 13:28:29 -0800 | [diff] [blame] | 98 | std::set<std::string>* compiled_classes, |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 99 | size_t thread_count, bool dump_stats, bool dump_passes, |
David Brazdil | 866c031 | 2015-01-13 21:21:31 +0000 | [diff] [blame] | 100 | const std::string& dump_cfg_file_name, |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 101 | CumulativeLogger* timer, int swap_fd, |
| 102 | const std::string& profile_file); |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 103 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 104 | ~CompilerDriver(); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 105 | |
Brian Carlstrom | 4560248 | 2013-07-21 22:07:55 -0700 | [diff] [blame] | 106 | void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 107 | TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 108 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 8a48741 | 2011-08-29 20:08:52 -0700 | [diff] [blame] | 109 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 110 | // Compile a single Method. |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 111 | void CompileOne(mirror::ArtMethod* method, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 112 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 113 | |
Vladimir Marko | c7f8320 | 2014-01-24 17:55:18 +0000 | [diff] [blame] | 114 | VerificationResults* GetVerificationResults() const { |
| 115 | return verification_results_; |
Vladimir Marko | 2b5eaa2 | 2013-12-13 13:59:30 +0000 | [diff] [blame] | 116 | } |
| 117 | |
Vladimir Marko | 5816ed4 | 2013-11-27 17:04:20 +0000 | [diff] [blame] | 118 | DexFileToMethodInlinerMap* GetMethodInlinerMap() const { |
| 119 | return method_inliner_map_; |
| 120 | } |
| 121 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 122 | InstructionSet GetInstructionSet() const { |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 123 | return instruction_set_; |
| 124 | } |
| 125 | |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 126 | const InstructionSetFeatures* GetInstructionSetFeatures() const { |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 127 | return instruction_set_features_; |
| 128 | } |
| 129 | |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 130 | const CompilerOptions& GetCompilerOptions() const { |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 131 | return *compiler_options_; |
| 132 | } |
| 133 | |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 134 | Compiler* GetCompiler() const { |
| 135 | return compiler_.get(); |
buzbee | c531cef | 2012-10-18 07:09:20 -0700 | [diff] [blame] | 136 | } |
| 137 | |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 138 | bool ProfilePresent() const { |
Calin Juravle | c1b643c | 2014-05-30 23:44:11 +0100 | [diff] [blame] | 139 | return profile_present_; |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 140 | } |
| 141 | |
Ian Rogers | e6bb3b2 | 2013-08-19 21:51:45 -0700 | [diff] [blame] | 142 | // Are we compiling and creating an image file? |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 143 | bool IsImage() const { |
| 144 | return image_; |
| 145 | } |
| 146 | |
Ian Rogers | 1ff3c98 | 2014-08-12 02:30:58 -0700 | [diff] [blame] | 147 | const std::set<std::string>* GetImageClasses() const { |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 148 | return image_classes_.get(); |
| 149 | } |
| 150 | |
Jeff Hao | 0aba0ba | 2013-06-03 14:49:28 -0700 | [diff] [blame] | 151 | // Generate the trampolines that are invoked by unresolved direct methods. |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 152 | const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const |
| 153 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 154 | const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const |
| 155 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 156 | const std::vector<uint8_t>* CreateJniDlsymLookup() const |
| 157 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Andreas Gampe | 2da8823 | 2014-02-27 12:26:20 -0800 | [diff] [blame] | 158 | const std::vector<uint8_t>* CreateQuickGenericJniTrampoline() const |
| 159 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Jeff Hao | 88474b4 | 2013-10-23 16:24:40 -0700 | [diff] [blame] | 160 | const std::vector<uint8_t>* CreateQuickImtConflictTrampoline() const |
| 161 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Jeff Hao | 0aba0ba | 2013-06-03 14:49:28 -0700 | [diff] [blame] | 162 | const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const |
| 163 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 164 | const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const |
Jeff Hao | 0aba0ba | 2013-06-03 14:49:28 -0700 | [diff] [blame] | 165 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 166 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 167 | CompiledClass* GetCompiledClass(ClassReference ref) const |
| 168 | LOCKS_EXCLUDED(compiled_classes_lock_); |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 169 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 170 | CompiledMethod* GetCompiledMethod(MethodReference ref) const |
| 171 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Vladimir Marko | f4da675 | 2014-08-01 19:04:18 +0100 | [diff] [blame] | 172 | size_t GetNonRelativeLinkerPatchCount() const |
| 173 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Brian Carlstrom | 0755ec5 | 2012-01-11 15:19:46 -0800 | [diff] [blame] | 174 | |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 175 | void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, |
| 176 | uint16_t class_def_index); |
| 177 | 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] | 178 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 179 | // Callbacks from compiler to see what runtime checks must be generated. |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 180 | |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 181 | bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 182 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 183 | bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 184 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 185 | |
| 186 | // Are runtime access checks necessary in the compiled code? |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 187 | bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, |
Andreas Gampe | 2ed8def | 2014-08-28 14:41:02 -0700 | [diff] [blame] | 188 | uint32_t type_idx, bool* type_known_final = nullptr, |
| 189 | bool* type_known_abstract = nullptr, |
| 190 | bool* equals_referrers_class = nullptr) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 191 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 192 | |
| 193 | // Are runtime access and instantiable checks necessary in the code? |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 194 | bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, |
| 195 | uint32_t type_idx) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 196 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 197 | |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 198 | bool CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx, |
| 199 | bool* is_type_initialized, bool* use_direct_type_ptr, |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 200 | uintptr_t* direct_type_ptr, bool* out_is_finalizable); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 201 | |
Fred Shih | e7f82e2 | 2014-08-06 10:46:37 -0700 | [diff] [blame] | 202 | // Query methods for the java.lang.ref.Reference class. |
| 203 | bool CanEmbedReferenceTypeInCode(ClassReference* ref, |
| 204 | bool* use_direct_type_ptr, uintptr_t* direct_type_ptr); |
| 205 | uint32_t GetReferenceSlowFlagOffset() const; |
| 206 | uint32_t GetReferenceDisableFlagOffset() const; |
| 207 | |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 208 | // Get the DexCache for the |
| 209 | mirror::DexCache* GetDexCache(const DexCompilationUnit* mUnit) |
| 210 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 211 | |
| 212 | mirror::ClassLoader* GetClassLoader(ScopedObjectAccess& soa, const DexCompilationUnit* mUnit) |
| 213 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 214 | |
| 215 | // Resolve compiling method's class. Returns nullptr on failure. |
| 216 | mirror::Class* ResolveCompilingMethodsClass( |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 217 | const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 218 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit) |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 219 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 220 | |
| 221 | // Resolve a field. Returns nullptr on failure, including incompatible class change. |
| 222 | // NOTE: Unlike ClassLinker's ResolveField(), this method enforces is_static. |
| 223 | mirror::ArtField* ResolveField( |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 224 | const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 225 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 226 | uint32_t field_idx, bool is_static) |
| 227 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 228 | |
| 229 | // Get declaration location of a resolved field. |
| 230 | void GetResolvedFieldDexFileLocation( |
| 231 | mirror::ArtField* resolved_field, const DexFile** declaring_dex_file, |
| 232 | uint16_t* declaring_class_idx, uint16_t* declaring_field_idx) |
| 233 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 234 | |
| 235 | bool IsFieldVolatile(mirror::ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 236 | MemberOffset GetFieldOffset(mirror::ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 237 | |
| 238 | // Can we fast-path an IGET/IPUT access to an instance field? If yes, compute the field offset. |
| 239 | std::pair<bool, bool> IsFastInstanceField( |
| 240 | mirror::DexCache* dex_cache, mirror::Class* referrer_class, |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 241 | mirror::ArtField* resolved_field, uint16_t field_idx) |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 242 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 243 | |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 244 | // Can we fast-path an SGET/SPUT access to a static field? If yes, compute the type index |
| 245 | // of the declaring class in the referrer's dex file. |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 246 | std::pair<bool, bool> IsFastStaticField( |
| 247 | mirror::DexCache* dex_cache, mirror::Class* referrer_class, |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 248 | mirror::ArtField* resolved_field, uint16_t field_idx, uint32_t* storage_index) |
| 249 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 250 | |
| 251 | // Is static field's in referrer's class? |
| 252 | bool IsStaticFieldInReferrerClass(mirror::Class* referrer_class, mirror::ArtField* resolved_field) |
| 253 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 254 | |
| 255 | // Is static field's class initialized? |
| 256 | bool IsStaticFieldsClassInitialized(mirror::Class* referrer_class, |
| 257 | mirror::ArtField* resolved_field) |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 258 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 259 | |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 260 | // Resolve a method. Returns nullptr on failure, including incompatible class change. |
| 261 | mirror::ArtMethod* ResolveMethod( |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 262 | ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
| 263 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 264 | uint32_t method_idx, InvokeType invoke_type) |
| 265 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 266 | |
| 267 | // Get declaration location of a resolved field. |
| 268 | void GetResolvedMethodDexFileLocation( |
| 269 | mirror::ArtMethod* resolved_method, const DexFile** declaring_dex_file, |
| 270 | uint16_t* declaring_class_idx, uint16_t* declaring_method_idx) |
| 271 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 272 | |
Nicolas Geoffray | e982f0b | 2014-08-13 02:11:24 +0100 | [diff] [blame] | 273 | // Get the index in the vtable of the method. |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 274 | uint16_t GetResolvedMethodVTableIndex( |
| 275 | mirror::ArtMethod* resolved_method, InvokeType type) |
| 276 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 277 | |
| 278 | // Can we fast-path an INVOKE? If no, returns 0. If yes, returns a non-zero opaque flags value |
| 279 | // for ProcessedInvoke() and computes the necessary lowering info. |
| 280 | int IsFastInvoke( |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 281 | ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, |
| 282 | Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 283 | mirror::Class* referrer_class, mirror::ArtMethod* resolved_method, InvokeType* invoke_type, |
| 284 | MethodReference* target_method, const MethodReference* devirt_target, |
| 285 | uintptr_t* direct_code, uintptr_t* direct_method) |
| 286 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 287 | |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 288 | // Is method's class initialized for an invoke? |
| 289 | // For static invokes to determine whether we need to consider potential call to <clinit>(). |
| 290 | // For non-static invokes, assuming a non-null reference, the class is always initialized. |
| 291 | bool IsMethodsClassInitialized(mirror::Class* referrer_class, mirror::ArtMethod* resolved_method) |
Vladimir Marko | 9820b7c | 2014-01-02 16:40:37 +0000 | [diff] [blame] | 292 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 293 | |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 294 | void ProcessedInstanceField(bool resolved); |
| 295 | void ProcessedStaticField(bool resolved, bool local); |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 296 | void ProcessedInvoke(InvokeType invoke_type, int flags); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 297 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 298 | // 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] | 299 | bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 300 | MemberOffset* field_offset, bool* is_volatile) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 301 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 302 | |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 303 | mirror::ArtField* ComputeInstanceFieldInfo(uint32_t field_idx, |
| 304 | const DexCompilationUnit* mUnit, |
| 305 | bool is_put, |
| 306 | const ScopedObjectAccess& soa) |
| 307 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 308 | |
| 309 | |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 310 | // 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] | 311 | // field is within the referrer (which can avoid checking class initialization). |
Ian Rogers | 9b297bf | 2013-09-06 11:11:25 -0700 | [diff] [blame] | 312 | bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 313 | MemberOffset* field_offset, uint32_t* storage_index, |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 314 | bool* is_referrers_class, bool* is_volatile, bool* is_initialized, |
| 315 | Primitive::Type* type) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 316 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 317 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 318 | // Can we fastpath a interface, super class or virtual method call? Computes method's vtable |
| 319 | // index. |
Ian Rogers | e3cd2f0 | 2013-05-24 15:32:56 -0700 | [diff] [blame] | 320 | bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, |
Ian Rogers | 65ec92c | 2013-09-06 10:49:58 -0700 | [diff] [blame] | 321 | bool update_stats, bool enable_devirtualization, |
| 322 | InvokeType* type, MethodReference* target_method, int* vtable_idx, |
| 323 | uintptr_t* direct_code, uintptr_t* direct_method) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 324 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | a32a6fd | 2012-02-06 20:18:44 -0800 | [diff] [blame] | 325 | |
Vladimir Marko | 2730db0 | 2014-01-27 11:15:17 +0000 | [diff] [blame] | 326 | const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const; |
| 327 | bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc); |
Ian Rogers | fae370a | 2013-06-05 08:33:27 -0700 | [diff] [blame] | 328 | |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 329 | bool GetSupportBootImageFixup() const { |
| 330 | return support_boot_image_fixup_; |
| 331 | } |
| 332 | |
| 333 | void SetSupportBootImageFixup(bool support_boot_image_fixup) { |
| 334 | support_boot_image_fixup_ = support_boot_image_fixup; |
| 335 | } |
| 336 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 337 | ArenaPool* GetArenaPool() { |
| 338 | return &arena_pool_; |
Mathieu Chartier | f6c4b3b | 2013-08-24 16:11:37 -0700 | [diff] [blame] | 339 | } |
Mathieu Chartier | 49285c5 | 2014-12-02 15:43:48 -0800 | [diff] [blame] | 340 | const ArenaPool* GetArenaPool() const { |
| 341 | return &arena_pool_; |
| 342 | } |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 343 | SwapAllocator<void>& GetSwapSpaceAllocator() { |
| 344 | return *swap_space_allocator_.get(); |
| 345 | } |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 346 | |
Brian Carlstrom | 3f47c12 | 2013-03-07 00:02:40 -0800 | [diff] [blame] | 347 | bool WriteElf(const std::string& android_root, |
Brian Carlstrom | 265091e | 2013-01-30 14:08:26 -0800 | [diff] [blame] | 348 | bool is_host, |
| 349 | const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 350 | OatWriter* oat_writer, |
Brian Carlstrom | 265091e | 2013-01-30 14:08:26 -0800 | [diff] [blame] | 351 | File* file); |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 352 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 353 | // 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] | 354 | static void InstructionSetToLLVMTarget(InstructionSet instruction_set, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 355 | std::string* target_triple, |
| 356 | std::string* target_cpu, |
| 357 | std::string* target_attr); |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 358 | |
Elliott Hughes | 6f4976c | 2012-03-13 21:19:01 -0700 | [diff] [blame] | 359 | void SetCompilerContext(void* compiler_context) { |
| 360 | compiler_context_ = compiler_context; |
| 361 | } |
| 362 | |
| 363 | void* GetCompilerContext() const { |
| 364 | return compiler_context_; |
| 365 | } |
| 366 | |
Logan Chien | 08e1ba3 | 2012-05-08 15:08:51 +0800 | [diff] [blame] | 367 | size_t GetThreadCount() const { |
| 368 | return thread_count_; |
| 369 | } |
| 370 | |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 371 | bool GetDumpPasses() const { |
| 372 | return dump_passes_; |
| 373 | } |
| 374 | |
David Brazdil | 866c031 | 2015-01-13 21:21:31 +0000 | [diff] [blame] | 375 | const std::string& GetDumpCfgFileName() const { |
| 376 | return dump_cfg_file_name_; |
| 377 | } |
| 378 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 379 | CumulativeLogger* GetTimingsLogger() const { |
| 380 | return timings_logger_; |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 381 | } |
| 382 | |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 383 | // 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] | 384 | bool IsImageClass(const char* descriptor) const; |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 385 | |
Andreas Gampe | 4bf3ae9 | 2014-11-11 13:28:29 -0800 | [diff] [blame] | 386 | // Checks if the provided class should be compiled, i.e., is in classes_to_compile_. |
| 387 | bool IsClassToCompile(const char* descriptor) const; |
| 388 | |
Ian Rogers | 8f3c9ae | 2013-08-20 17:26:41 -0700 | [diff] [blame] | 389 | void RecordClassStatus(ClassReference ref, mirror::Class::Status status) |
| 390 | LOCKS_EXCLUDED(compiled_classes_lock_); |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 391 | |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 392 | SwapVector<uint8_t>* DeduplicateCode(const ArrayRef<const uint8_t>& code); |
| 393 | SwapSrcMap* DeduplicateSrcMappingTable(const ArrayRef<SrcMapElem>& src_map); |
| 394 | SwapVector<uint8_t>* DeduplicateMappingTable(const ArrayRef<const uint8_t>& code); |
| 395 | SwapVector<uint8_t>* DeduplicateVMapTable(const ArrayRef<const uint8_t>& code); |
| 396 | SwapVector<uint8_t>* DeduplicateGCMap(const ArrayRef<const uint8_t>& code); |
| 397 | SwapVector<uint8_t>* DeduplicateCFIInfo(const ArrayRef<const uint8_t>& cfi_info); |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 398 | |
Dave Allison | 39c3bfb | 2014-01-28 18:33:52 -0800 | [diff] [blame] | 399 | // Should the compiler run on this method given profile information? |
| 400 | bool SkipCompilation(const std::string& method_name); |
| 401 | |
Mathieu Chartier | ab972ef | 2014-12-03 17:38:22 -0800 | [diff] [blame] | 402 | // Get memory usage during compilation. |
Andreas Gampe | 8d295f8 | 2015-01-20 14:50:21 -0800 | [diff] [blame] | 403 | std::string GetMemoryUsageString(bool extended) const; |
Mathieu Chartier | ab972ef | 2014-12-03 17:38:22 -0800 | [diff] [blame] | 404 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 405 | private: |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 406 | // These flags are internal to CompilerDriver for collecting INVOKE resolution statistics. |
| 407 | // The only external contract is that unresolved method has flags 0 and resolved non-0. |
| 408 | enum { |
| 409 | kBitMethodResolved = 0, |
| 410 | kBitVirtualMadeDirect, |
| 411 | kBitPreciseTypeDevirtualization, |
| 412 | kBitDirectCallToBoot, |
| 413 | kBitDirectMethodToBoot |
| 414 | }; |
| 415 | static constexpr int kFlagMethodResolved = 1 << kBitMethodResolved; |
| 416 | static constexpr int kFlagVirtualMadeDirect = 1 << kBitVirtualMadeDirect; |
| 417 | static constexpr int kFlagPreciseTypeDevirtualization = 1 << kBitPreciseTypeDevirtualization; |
| 418 | static constexpr int kFlagDirectCallToBoot = 1 << kBitDirectCallToBoot; |
| 419 | static constexpr int kFlagDirectMethodToBoot = 1 << kBitDirectMethodToBoot; |
| 420 | static constexpr int kFlagsMethodResolvedVirtualMadeDirect = |
| 421 | kFlagMethodResolved | kFlagVirtualMadeDirect; |
| 422 | static constexpr int kFlagsMethodResolvedPreciseTypeDevirtualization = |
| 423 | kFlagsMethodResolvedVirtualMadeDirect | kFlagPreciseTypeDevirtualization; |
| 424 | |
| 425 | public: // TODO make private or eliminate. |
| 426 | // Compute constant code and method pointers when possible. |
Igor Murashkin | d6dee67 | 2014-10-16 18:36:16 -0700 | [diff] [blame] | 427 | void GetCodeAndMethodForDirectCall(/*out*/InvokeType* type, |
| 428 | InvokeType sharp_type, |
Ian Rogers | 83883d7 | 2013-10-21 21:07:24 -0700 | [diff] [blame] | 429 | bool no_guarantee_of_dex_cache_entry, |
Igor Murashkin | d6dee67 | 2014-10-16 18:36:16 -0700 | [diff] [blame] | 430 | const mirror::Class* referrer_class, |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 431 | mirror::ArtMethod* method, |
Igor Murashkin | d6dee67 | 2014-10-16 18:36:16 -0700 | [diff] [blame] | 432 | /*out*/int* stats_flags, |
Ian Rogers | 83883d7 | 2013-10-21 21:07:24 -0700 | [diff] [blame] | 433 | MethodReference* target_method, |
Ian Rogers | 65ec92c | 2013-09-06 10:49:58 -0700 | [diff] [blame] | 434 | uintptr_t* direct_code, uintptr_t* direct_method) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 435 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 2ed3b95 | 2012-03-17 11:49:39 -0700 | [diff] [blame] | 436 | |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 437 | private: |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 438 | void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 439 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 440 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | ae82698 | 2011-11-09 01:33:42 -0800 | [diff] [blame] | 441 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 442 | void LoadImageClasses(TimingLogger* timings); |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 443 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 444 | // Attempt to resolve all type, methods, fields, and strings |
| 445 | // referenced from code in the dex file following PathClassLoader |
| 446 | // ordering semantics. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 447 | void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 448 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 449 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 450 | void ResolveDexFile(jobject class_loader, const DexFile& dex_file, |
Andreas Gampe | de7b436 | 2014-07-28 18:38:57 -0700 | [diff] [blame] | 451 | const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 452 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 453 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 454 | |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 455 | void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 456 | ThreadPool* thread_pool, TimingLogger* timings); |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 457 | void VerifyDexFile(jobject class_loader, const DexFile& dex_file, |
Andreas Gampe | de7b436 | 2014-07-28 18:38:57 -0700 | [diff] [blame] | 458 | const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 459 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 460 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
jeffhao | 98eacac | 2011-09-14 16:11:53 -0700 | [diff] [blame] | 461 | |
Andreas Gampe | 2ed8def | 2014-08-28 14:41:02 -0700 | [diff] [blame] | 462 | void SetVerified(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
| 463 | ThreadPool* thread_pool, TimingLogger* timings); |
| 464 | void SetVerifiedDexFile(jobject class_loader, const DexFile& dex_file, |
| 465 | const std::vector<const DexFile*>& dex_files, |
| 466 | ThreadPool* thread_pool, TimingLogger* timings) |
| 467 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
| 468 | |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 469 | void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 470 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 471 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 472 | void InitializeClasses(jobject class_loader, const DexFile& dex_file, |
Andreas Gampe | de7b436 | 2014-07-28 18:38:57 -0700 | [diff] [blame] | 473 | const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 474 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 475 | LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_); |
Brian Carlstrom | a5a97a2 | 2011-09-15 14:08:49 -0700 | [diff] [blame] | 476 | |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 477 | void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_); |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 478 | static void FindClinitImageClassesCallback(mirror::Object* object, void* arg) |
| 479 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 480 | |
Ian Rogers | 3d1548d | 2012-09-24 14:08:03 -0700 | [diff] [blame] | 481 | void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 482 | ThreadPool* thread_pool, TimingLogger* timings); |
Brian Carlstrom | 2f66382 | 2012-11-07 22:49:06 -0800 | [diff] [blame] | 483 | void CompileDexFile(jobject class_loader, const DexFile& dex_file, |
Andreas Gampe | de7b436 | 2014-07-28 18:38:57 -0700 | [diff] [blame] | 484 | const std::vector<const DexFile*>& dex_files, |
Ian Rogers | 3d50407 | 2014-03-01 09:16:49 -0800 | [diff] [blame] | 485 | ThreadPool* thread_pool, TimingLogger* timings) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 486 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Ian Rogers | 08f753d | 2012-08-24 14:35:25 -0700 | [diff] [blame] | 487 | void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, |
Ian Rogers | 8b2c0b9 | 2013-09-19 02:56:49 -0700 | [diff] [blame] | 488 | InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx, |
Sebastien Hertz | 2d6ba51 | 2013-05-17 11:31:37 +0200 | [diff] [blame] | 489 | jobject class_loader, const DexFile& dex_file, |
Andreas Gampe | 4bf3ae9 | 2014-11-11 13:28:29 -0800 | [diff] [blame] | 490 | DexToDexCompilationLevel dex_to_dex_compilation_level, |
| 491 | bool compilation_enabled) |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 492 | LOCKS_EXCLUDED(compiled_methods_lock_); |
Brian Carlstrom | 83db772 | 2011-08-26 17:32:56 -0700 | [diff] [blame] | 493 | |
Ian Rogers | 219b5a8 | 2013-03-04 13:48:24 -0800 | [diff] [blame] | 494 | static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 495 | LOCKS_EXCLUDED(Locks::mutator_lock_); |
Elliott Hughes | c225caa | 2012-02-03 15:43:37 -0800 | [diff] [blame] | 496 | |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 497 | // Swap pool and allocator used for native allocations. May be file-backed. Needs to be first |
| 498 | // as other fields rely on this. |
| 499 | std::unique_ptr<SwapSpace> swap_space_; |
| 500 | std::unique_ptr<SwapAllocator<void> > swap_space_allocator_; |
| 501 | |
| 502 | ProfileFile profile_file_; |
| 503 | bool profile_present_; |
| 504 | |
Brian Carlstrom | ae7083d | 2014-02-24 21:56:02 -0800 | [diff] [blame] | 505 | const CompilerOptions* const compiler_options_; |
| 506 | VerificationResults* const verification_results_; |
| 507 | DexFileToMethodInlinerMap* const method_inliner_map_; |
Vladimir Marko | 2b5eaa2 | 2013-12-13 13:59:30 +0000 | [diff] [blame] | 508 | |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 509 | std::unique_ptr<Compiler> compiler_; |
buzbee | c531cef | 2012-10-18 07:09:20 -0700 | [diff] [blame] | 510 | |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 511 | const InstructionSet instruction_set_; |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 512 | const InstructionSetFeatures* const instruction_set_features_; |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 513 | |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 514 | // All class references that require |
Ian Rogers | 8f3c9ae | 2013-08-20 17:26:41 -0700 | [diff] [blame] | 515 | mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 516 | std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_); |
| 517 | |
Elliott Hughes | a0e1806 | 2012-04-13 15:59:59 -0700 | [diff] [blame] | 518 | typedef SafeMap<const ClassReference, CompiledClass*> ClassTable; |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 519 | // All class references that this compiler has compiled. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 520 | mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 521 | ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_); |
Brian Carlstrom | 0755ec5 | 2012-01-11 15:19:46 -0800 | [diff] [blame] | 522 | |
Ian Rogers | e3cd2f0 | 2013-05-24 15:32:56 -0700 | [diff] [blame] | 523 | typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable; |
Ian Rogers | fffdb02 | 2013-01-04 15:14:08 -0800 | [diff] [blame] | 524 | // All method references that this compiler has compiled. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 525 | mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 526 | MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_); |
Vladimir Marko | f4da675 | 2014-08-01 19:04:18 +0100 | [diff] [blame] | 527 | // Number of non-relative patches in all compiled methods. These patches need space |
| 528 | // in the .oat_patches ELF section if requested in the compiler options. |
| 529 | size_t non_relative_linker_patch_count_ GUARDED_BY(compiled_methods_lock_); |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 530 | |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 531 | const bool image_; |
| 532 | |
| 533 | // If image_ is true, specifies the classes that will be included in |
Andreas Gampe | 2ed8def | 2014-08-28 14:41:02 -0700 | [diff] [blame] | 534 | // the image. Note if image_classes_ is nullptr, all classes are |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 535 | // included in the image. |
Ian Rogers | 1ff3c98 | 2014-08-12 02:30:58 -0700 | [diff] [blame] | 536 | std::unique_ptr<std::set<std::string>> image_classes_; |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 537 | |
Andreas Gampe | 4bf3ae9 | 2014-11-11 13:28:29 -0800 | [diff] [blame] | 538 | // If image_ is true, specifies the classes that will be compiled in |
| 539 | // the image. Note if classes_to_compile_ is nullptr, all classes are |
| 540 | // included in the image. |
| 541 | std::unique_ptr<std::set<std::string>> classes_to_compile_; |
| 542 | |
Elliott Hughes | 5523ee0 | 2012-02-03 18:18:34 -0800 | [diff] [blame] | 543 | size_t thread_count_; |
Elliott Hughes | bb551fa | 2012-01-25 16:35:29 -0800 | [diff] [blame] | 544 | |
Vladimir Marko | f096aad | 2014-01-23 15:51:58 +0000 | [diff] [blame] | 545 | class AOTCompilationStats; |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 546 | std::unique_ptr<AOTCompilationStats> stats_; |
Ian Rogers | 996cc58 | 2012-02-14 22:23:29 -0800 | [diff] [blame] | 547 | |
Brian Carlstrom | ba0668e | 2012-03-26 13:14:07 -0700 | [diff] [blame] | 548 | bool dump_stats_; |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 549 | const bool dump_passes_; |
David Brazdil | 866c031 | 2015-01-13 21:21:31 +0000 | [diff] [blame] | 550 | const std::string& dump_cfg_file_name_; |
Nicolas Geoffray | ea3fa0b | 2014-02-10 11:59:41 +0000 | [diff] [blame] | 551 | |
| 552 | CumulativeLogger* const timings_logger_; |
Brian Carlstrom | ba0668e | 2012-03-26 13:14:07 -0700 | [diff] [blame] | 553 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 554 | typedef void (*CompilerCallbackFn)(CompilerDriver& driver); |
| 555 | typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver); |
Logan Chien | f7015fd | 2012-03-18 01:19:37 +0800 | [diff] [blame] | 556 | |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 557 | typedef void (*DexToDexCompilerFn)(CompilerDriver& driver, |
| 558 | const DexFile::CodeItem* code_item, |
| 559 | uint32_t access_flags, InvokeType invoke_type, |
| 560 | uint32_t class_dex_idx, uint32_t method_idx, |
| 561 | jobject class_loader, const DexFile& dex_file, |
| 562 | DexToDexCompilationLevel dex_to_dex_compilation_level); |
Sebastien Hertz | 7502122 | 2013-07-16 18:34:50 +0200 | [diff] [blame] | 563 | DexToDexCompilerFn dex_to_dex_compiler_; |
Sebastien Hertz | 2d6ba51 | 2013-05-17 11:31:37 +0200 | [diff] [blame] | 564 | |
Elliott Hughes | 6f4976c | 2012-03-13 21:19:01 -0700 | [diff] [blame] | 565 | void* compiler_context_; |
| 566 | |
Mathieu Chartier | f6c4b3b | 2013-08-24 16:11:37 -0700 | [diff] [blame] | 567 | // Arena pool used by the compiler. |
| 568 | ArenaPool arena_pool_; |
| 569 | |
Brian Carlstrom | 9639160 | 2013-06-13 19:49:50 -0700 | [diff] [blame] | 570 | bool support_boot_image_fixup_; |
| 571 | |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 572 | // DeDuplication data structures, these own the corresponding byte arrays. |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 573 | template <typename ContentType> |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 574 | class DedupeHashFunc { |
| 575 | public: |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 576 | size_t operator()(const ArrayRef<ContentType>& array) const { |
| 577 | const uint8_t* data = reinterpret_cast<const uint8_t*>(array.data()); |
| 578 | static_assert(IsPowerOfTwo(sizeof(ContentType)), |
| 579 | "ContentType is not power of two, don't know whether array layout is as assumed"); |
| 580 | uint32_t len = sizeof(ContentType) * array.size(); |
| 581 | if (kUseMurmur3Hash) { |
| 582 | static constexpr uint32_t c1 = 0xcc9e2d51; |
| 583 | static constexpr uint32_t c2 = 0x1b873593; |
| 584 | static constexpr uint32_t r1 = 15; |
| 585 | static constexpr uint32_t r2 = 13; |
| 586 | static constexpr uint32_t m = 5; |
| 587 | static constexpr uint32_t n = 0xe6546b64; |
| 588 | |
| 589 | uint32_t hash = 0; |
| 590 | |
| 591 | const int nblocks = len / 4; |
| 592 | typedef __attribute__((__aligned__(1))) uint32_t unaligned_uint32_t; |
| 593 | const unaligned_uint32_t *blocks = reinterpret_cast<const uint32_t*>(data); |
| 594 | int i; |
| 595 | for (i = 0; i < nblocks; i++) { |
| 596 | uint32_t k = blocks[i]; |
| 597 | k *= c1; |
| 598 | k = (k << r1) | (k >> (32 - r1)); |
| 599 | k *= c2; |
| 600 | |
| 601 | hash ^= k; |
| 602 | hash = ((hash << r2) | (hash >> (32 - r2))) * m + n; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 603 | } |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 604 | |
| 605 | const uint8_t *tail = reinterpret_cast<const uint8_t*>(data + nblocks * 4); |
| 606 | uint32_t k1 = 0; |
| 607 | |
| 608 | switch (len & 3) { |
| 609 | case 3: |
| 610 | k1 ^= tail[2] << 16; |
| 611 | FALLTHROUGH_INTENDED; |
| 612 | case 2: |
| 613 | k1 ^= tail[1] << 8; |
| 614 | FALLTHROUGH_INTENDED; |
| 615 | case 1: |
| 616 | k1 ^= tail[0]; |
| 617 | |
| 618 | k1 *= c1; |
| 619 | k1 = (k1 << r1) | (k1 >> (32 - r1)); |
| 620 | k1 *= c2; |
| 621 | hash ^= k1; |
| 622 | } |
| 623 | |
| 624 | hash ^= len; |
| 625 | hash ^= (hash >> 16); |
| 626 | hash *= 0x85ebca6b; |
| 627 | hash ^= (hash >> 13); |
| 628 | hash *= 0xc2b2ae35; |
| 629 | hash ^= (hash >> 16); |
| 630 | |
| 631 | return hash; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 632 | } else { |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 633 | size_t hash = 0x811c9dc5; |
| 634 | for (uint32_t i = 0; i < len; ++i) { |
| 635 | hash = (hash * 16777619) ^ data[i]; |
Ian Rogers | d133b97 | 2013-09-05 11:01:30 -0700 | [diff] [blame] | 636 | } |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 637 | hash += hash << 13; |
| 638 | hash ^= hash >> 7; |
| 639 | hash += hash << 3; |
| 640 | hash ^= hash >> 17; |
| 641 | hash += hash << 5; |
| 642 | return hash; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 643 | } |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 644 | } |
| 645 | }; |
Yevgeny Rouban | e3ea838 | 2014-08-08 16:29:38 +0700 | [diff] [blame] | 646 | |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 647 | DedupeSet<ArrayRef<const uint8_t>, |
| 648 | SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_code_; |
| 649 | DedupeSet<ArrayRef<SrcMapElem>, |
| 650 | SwapSrcMap, size_t, DedupeHashFunc<SrcMapElem>, 4> dedupe_src_mapping_table_; |
| 651 | DedupeSet<ArrayRef<const uint8_t>, |
| 652 | SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_mapping_table_; |
| 653 | DedupeSet<ArrayRef<const uint8_t>, |
| 654 | SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_vmap_table_; |
| 655 | DedupeSet<ArrayRef<const uint8_t>, |
| 656 | SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_gc_map_; |
| 657 | DedupeSet<ArrayRef<const uint8_t>, |
| 658 | SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_cfi_info_; |
Mathieu Chartier | 193bad9 | 2013-08-29 18:46:00 -0700 | [diff] [blame] | 659 | |
Ian Rogers | 1212a02 | 2013-03-04 10:48:41 -0800 | [diff] [blame] | 660 | DISALLOW_COPY_AND_ASSIGN(CompilerDriver); |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 661 | }; |
| 662 | |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 663 | } // namespace art |
| 664 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 665 | #endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ |