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