blob: 9b9a8843399a3c1ef7d0da4b872e4402a997cf3d [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
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 Carlstrom9ea1cb12011-08-24 23:18:18 -070016
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
18#define ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070019
Elliott Hughes8add92d2012-01-18 18:18:43 -080020#include <set>
21#include <string>
Logan Chiendf576142012-03-20 17:36:32 +080022#include <vector>
Elliott Hughese5448b52012-01-18 16:44:06 -080023
Elliott Hughes76b61672012-12-12 17:47:30 -080024#include "base/mutex.h"
Brian Carlstrom51c24672013-07-11 16:00:56 -070025#include "class_reference.h"
Brian Carlstrom0755ec52012-01-11 15:19:46 -080026#include "compiled_class.h"
Brian Carlstrom3320cf42011-10-04 14:58:28 -070027#include "compiled_method.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070028#include "dex_file.h"
Mathieu Chartierf6c4b3b2013-08-24 16:11:37 -070029#include "dex/arena_allocator.h"
Elliott Hughes0f3c5532012-03-30 14:51:51 -070030#include "instruction_set.h"
31#include "invoke_type.h"
Brian Carlstrom51c24672013-07-11 16:00:56 -070032#include "method_reference.h"
Brian Carlstrom56d947f2013-07-15 13:14:23 -070033#include "os.h"
Ian Rogers1cb0a1d2011-10-06 15:24:35 -070034#include "runtime.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070035#include "safe_map.h"
Mathieu Chartier0e4627e2012-10-23 16:13:36 -070036#include "thread_pool.h"
Mathieu Chartier193bad92013-08-29 18:46:00 -070037#include "utils/dedupe_set.h"
Ian Rogers0571d352011-11-03 19:51:38 -070038
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070039namespace art {
40
Ian Rogersc8b306f2012-02-17 21:34:44 -080041class AOTCompilationStats;
Ian Rogers219b5a82013-03-04 13:48:24 -080042class ParallelCompilationManager;
Ian Rogers89756f22013-03-04 16:40:02 -080043class DexCompilationUnit;
Brian Carlstromc50d8e12013-07-23 22:35:16 -070044class OatWriter;
Elliott Hughes601a1232012-02-02 17:47:38 -080045class TimingLogger;
Ian Rogers996cc582012-02-14 22:23:29 -080046
buzbeec531cef2012-10-18 07:09:20 -070047enum CompilerBackend {
48 kQuick,
buzbee1fd33462013-03-25 13:40:45 -070049 kPortable,
50 kNoBackend
buzbeec531cef2012-10-18 07:09:20 -070051};
52
Ian Rogers848871b2013-08-05 10:56:33 -070053enum EntryPointCallingConvention {
54 // ABI of invocations to a method's interpreter entry point.
55 kInterpreterAbi,
56 // ABI of calls to a method's native code, only used for native methods.
57 kJniAbi,
58 // ABI of calls to a method's portable code entry point.
59 kPortableAbi,
60 // ABI of calls to a method's quick code entry point.
61 kQuickAbi
62};
63
Sebastien Hertz75021222013-07-16 18:34:50 +020064enum DexToDexCompilationLevel {
65 kDontDexToDexCompile, // Only meaning wrt image time interpretation.
66 kRequired, // Dex-to-dex compilation required for correctness.
67 kOptimize // Perform required transformation and peep-hole optimizations.
68};
69
buzbee4df2bbd2012-10-11 14:46:06 -070070// Thread-local storage compiler worker threads
71class CompilerTls {
buzbee4df2bbd2012-10-11 14:46:06 -070072 public:
73 CompilerTls() : llvm_info_(NULL) {}
74 ~CompilerTls() {}
75
76 void* GetLLVMInfo() { return llvm_info_; }
77
78 void SetLLVMInfo(void* llvm_info) { llvm_info_ = llvm_info; }
79
80 private:
81 void* llvm_info_;
buzbee4df2bbd2012-10-11 14:46:06 -070082};
83
Ian Rogers1212a022013-03-04 10:48:41 -080084class CompilerDriver {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070085 public:
Brian Carlstrom96391602013-06-13 19:49:50 -070086 typedef std::set<std::string> DescriptorSet;
87
Brian Carlstromaded5f72011-10-07 17:15:04 -070088 // Create a compiler targeting the requested "instruction_set".
Brian Carlstromae826982011-11-09 01:33:42 -080089 // "image" should be true if image specific optimizations should be
90 // enabled. "image_classes" lets the compiler know what classes it
91 // can assume will be in the image, with NULL implying all available
92 // classes.
Brian Carlstrom96391602013-06-13 19:49:50 -070093 explicit CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
94 bool image, DescriptorSet* image_classes,
Brian Carlstrom45602482013-07-21 22:07:55 -070095 size_t thread_count, bool dump_stats);
Brian Carlstrom3320cf42011-10-04 14:58:28 -070096
Ian Rogers1212a022013-03-04 10:48:41 -080097 ~CompilerDriver();
Ian Rogers2c8f6532011-09-02 17:16:34 -070098
Brian Carlstrom45602482013-07-21 22:07:55 -070099 void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700100 base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700101 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstrom8a487412011-08-29 20:08:52 -0700102
103 // Compile a single Method
Brian Carlstromea46f952013-07-30 01:26:50 -0700104 void CompileOne(const mirror::ArtMethod* method, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700105 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700106
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700107 InstructionSet GetInstructionSet() const {
108 return instruction_set_;
109 }
110
buzbeec531cef2012-10-18 07:09:20 -0700111 CompilerBackend GetCompilerBackend() const {
112 return compiler_backend_;
113 }
114
Ian Rogerse6bb3b22013-08-19 21:51:45 -0700115 // Are we compiling and creating an image file?
Brian Carlstromaded5f72011-10-07 17:15:04 -0700116 bool IsImage() const {
117 return image_;
118 }
119
Brian Carlstrom96391602013-06-13 19:49:50 -0700120 DescriptorSet* GetImageClasses() const {
121 return image_classes_.get();
122 }
123
buzbee4df2bbd2012-10-11 14:46:06 -0700124 CompilerTls* GetTls();
125
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700126 // Generate the trampolines that are invoked by unresolved direct methods.
Ian Rogers848871b2013-08-05 10:56:33 -0700127 const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const
128 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
129 const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const
130 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
131 const std::vector<uint8_t>* CreateJniDlsymLookup() const
132 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700133 const std::vector<uint8_t>* CreatePortableImtConflictTrampoline() const
134 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700135 const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const
136 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers848871b2013-08-05 10:56:33 -0700137 const std::vector<uint8_t>* CreatePortableToInterpreterBridge() const
138 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700139 const std::vector<uint8_t>* CreateQuickImtConflictTrampoline() const
140 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700141 const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
142 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers848871b2013-08-05 10:56:33 -0700143 const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700144 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
145
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700146 CompiledClass* GetCompiledClass(ClassReference ref) const
147 LOCKS_EXCLUDED(compiled_classes_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -0700148
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700149 CompiledMethod* GetCompiledMethod(MethodReference ref) const
150 LOCKS_EXCLUDED(compiled_methods_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800151
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700152 void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
153 uint16_t class_def_index);
154 bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index);
Ian Rogersfffdb022013-01-04 15:14:08 -0800155
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700156 // Callbacks from compiler to see what runtime checks must be generated.
Ian Rogers0571d352011-11-03 19:51:38 -0700157
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700158 bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700159 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800160
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700161 bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700162 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800163
164 // Are runtime access checks necessary in the compiled code?
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700165 bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
Ian Rogersc9e463c2013-06-05 16:52:26 -0700166 uint32_t type_idx, bool* type_known_final = NULL,
167 bool* type_known_abstract = NULL,
168 bool* equals_referrers_class = NULL)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700169 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800170
171 // Are runtime access and instantiable checks necessary in the code?
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700172 bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
173 uint32_t type_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700174 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800175
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700176 // Can we fast path instance field access? Computes field's offset and volatility.
Ian Rogers9b297bf2013-09-06 11:11:25 -0700177 bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
178 int* field_offset, bool* is_volatile)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700179 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800180
181 // Can we fastpath static field access? Computes field's offset, volatility and whether the
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700182 // field is within the referrer (which can avoid checking class initialization).
Ian Rogers9b297bf2013-09-06 11:11:25 -0700183 bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
184 int* field_offset, int* ssb_index,
185 bool* is_referrers_class, bool* is_volatile)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700186 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800187
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700188 // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
189 // index.
Ian Rogerse3cd2f02013-05-24 15:32:56 -0700190 bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
Ian Rogers65ec92c2013-09-06 10:49:58 -0700191 bool update_stats, bool enable_devirtualization,
192 InvokeType* type, MethodReference* target_method, int* vtable_idx,
193 uintptr_t* direct_code, uintptr_t* direct_method)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700194 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800195
Ian Rogersfae370a2013-06-05 08:33:27 -0700196 bool IsSafeCast(const MethodReference& mr, uint32_t dex_pc);
197
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700198 // Record patch information for later fix up.
199 void AddCodePatch(const DexFile* dex_file,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700200 uint16_t referrer_class_def_idx,
Brian Carlstromf5822582012-03-19 22:34:31 -0700201 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700202 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700203 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700204 InvokeType target_invoke_type,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700205 size_t literal_offset)
206 LOCKS_EXCLUDED(compiled_methods_lock_);
207 void AddMethodPatch(const DexFile* dex_file,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700208 uint16_t referrer_class_def_idx,
Brian Carlstromf5822582012-03-19 22:34:31 -0700209 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700210 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700211 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700212 InvokeType target_invoke_type,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700213 size_t literal_offset)
214 LOCKS_EXCLUDED(compiled_methods_lock_);
Ian Rogers3fa13792012-03-18 15:53:45 -0700215
Logan Chien8b977d32012-02-21 19:14:55 +0800216 void SetBitcodeFileName(std::string const& filename);
Logan Chienf7015fd2012-03-18 01:19:37 +0800217
Brian Carlstrom96391602013-06-13 19:49:50 -0700218 bool GetSupportBootImageFixup() const {
219 return support_boot_image_fixup_;
220 }
221
222 void SetSupportBootImageFixup(bool support_boot_image_fixup) {
223 support_boot_image_fixup_ = support_boot_image_fixup;
224 }
225
Mathieu Chartierf6c4b3b2013-08-24 16:11:37 -0700226 ArenaPool& GetArenaPool() {
227 return arena_pool_;
228 }
Brian Carlstrom96391602013-06-13 19:49:50 -0700229
Brian Carlstrom3f47c122013-03-07 00:02:40 -0800230 bool WriteElf(const std::string& android_root,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800231 bool is_host,
232 const std::vector<const DexFile*>& dex_files,
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700233 OatWriter& oat_writer,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800234 File* file);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800235
236 // TODO: move to a common home for llvm helpers once quick/portable are merged
237 static void InstructionSetToLLVMTarget(InstructionSet instruction_set,
238 std::string& target_triple,
239 std::string& target_cpu,
240 std::string& target_attr);
241
Elliott Hughes6f4976c2012-03-13 21:19:01 -0700242 void SetCompilerContext(void* compiler_context) {
243 compiler_context_ = compiler_context;
244 }
245
246 void* GetCompilerContext() const {
247 return compiler_context_;
248 }
249
Logan Chien08e1ba32012-05-08 15:08:51 +0800250 size_t GetThreadCount() const {
251 return thread_count_;
252 }
253
Brian Carlstromf5822582012-03-19 22:34:31 -0700254 class PatchInformation {
255 public:
Brian Carlstromf5822582012-03-19 22:34:31 -0700256 const DexFile& GetDexFile() const {
257 return *dex_file_;
258 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700259 uint16_t GetReferrerClassDefIdx() const {
260 return referrer_class_def_idx_;
261 }
Brian Carlstromf5822582012-03-19 22:34:31 -0700262 uint32_t GetReferrerMethodIdx() const {
263 return referrer_method_idx_;
264 }
Ian Rogers08f753d2012-08-24 14:35:25 -0700265 InvokeType GetReferrerInvokeType() const {
266 return referrer_invoke_type_;
Brian Carlstromf5822582012-03-19 22:34:31 -0700267 }
268 uint32_t GetTargetMethodIdx() const {
269 return target_method_idx_;
270 }
Ian Rogers08f753d2012-08-24 14:35:25 -0700271 InvokeType GetTargetInvokeType() const {
272 return target_invoke_type_;
Brian Carlstromf5822582012-03-19 22:34:31 -0700273 }
274 size_t GetLiteralOffset() const {;
275 return literal_offset_;
276 }
277
278 private:
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700279 PatchInformation(const DexFile* dex_file,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700280 uint16_t referrer_class_def_idx,
Brian Carlstromf5822582012-03-19 22:34:31 -0700281 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700282 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700283 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700284 InvokeType target_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700285 size_t literal_offset)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700286 : dex_file_(dex_file),
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700287 referrer_class_def_idx_(referrer_class_def_idx),
Brian Carlstromf5822582012-03-19 22:34:31 -0700288 referrer_method_idx_(referrer_method_idx),
Ian Rogers08f753d2012-08-24 14:35:25 -0700289 referrer_invoke_type_(referrer_invoke_type),
Brian Carlstromf5822582012-03-19 22:34:31 -0700290 target_method_idx_(target_method_idx),
Ian Rogers08f753d2012-08-24 14:35:25 -0700291 target_invoke_type_(target_invoke_type),
Brian Carlstromf5822582012-03-19 22:34:31 -0700292 literal_offset_(literal_offset) {
293 CHECK(dex_file_ != NULL);
294 }
295
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700296 const DexFile* const dex_file_;
297 const uint16_t referrer_class_def_idx_;
298 const uint32_t referrer_method_idx_;
299 const InvokeType referrer_invoke_type_;
300 const uint32_t target_method_idx_;
301 const InvokeType target_invoke_type_;
302 const size_t literal_offset_;
Brian Carlstromf5822582012-03-19 22:34:31 -0700303
Ian Rogers1212a022013-03-04 10:48:41 -0800304 friend class CompilerDriver;
Brian Carlstrom6c403e12012-03-20 13:22:55 -0700305 DISALLOW_COPY_AND_ASSIGN(PatchInformation);
Brian Carlstromf5822582012-03-19 22:34:31 -0700306 };
307
308 const std::vector<const PatchInformation*>& GetCodeToPatch() const {
309 return code_to_patch_;
310 }
311 const std::vector<const PatchInformation*>& GetMethodsToPatch() const {
312 return methods_to_patch_;
313 }
314
Ian Rogers3d1548d2012-09-24 14:08:03 -0700315 // Checks if class specified by type_idx is one of the image_classes_
Ian Rogersdfb325e2013-10-30 01:00:44 -0700316 bool IsImageClass(const char* descriptor) const;
Ian Rogers3d1548d2012-09-24 14:08:03 -0700317
Ian Rogers8f3c9ae2013-08-20 17:26:41 -0700318 void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
319 LOCKS_EXCLUDED(compiled_classes_lock_);
Ian Rogers3d1548d2012-09-24 14:08:03 -0700320
Mathieu Chartier193bad92013-08-29 18:46:00 -0700321 std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code);
322 std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code);
323 std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code);
324 std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code);
325
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700326 private:
Ian Rogers2ed3b952012-03-17 11:49:39 -0700327 // Compute constant code and method pointers when possible
Ian Rogers83883d72013-10-21 21:07:24 -0700328 void GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type,
329 bool no_guarantee_of_dex_cache_entry,
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700330 mirror::Class* referrer_class,
Brian Carlstromea46f952013-07-30 01:26:50 -0700331 mirror::ArtMethod* method,
Ian Rogers65ec92c2013-09-06 10:49:58 -0700332 bool update_stats,
Ian Rogers83883d72013-10-21 21:07:24 -0700333 MethodReference* target_method,
Ian Rogers65ec92c2013-09-06 10:49:58 -0700334 uintptr_t* direct_code, uintptr_t* direct_method)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700335 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2ed3b952012-03-17 11:49:39 -0700336
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700337 void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700338 ThreadPool& thread_pool, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700339 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -0800340
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700341 void LoadImageClasses(base::TimingLogger& timings);
Brian Carlstrom96391602013-06-13 19:49:50 -0700342
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700343 // Attempt to resolve all type, methods, fields, and strings
344 // referenced from code in the dex file following PathClassLoader
345 // ordering semantics.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700346 void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700347 ThreadPool& thread_pool, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700348 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstrom2f663822012-11-07 22:49:06 -0800349 void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700350 ThreadPool& thread_pool, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700351 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700352
Ian Rogers3d1548d2012-09-24 14:08:03 -0700353 void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700354 ThreadPool& thread_pool, base::TimingLogger& timings);
Brian Carlstrom2f663822012-11-07 22:49:06 -0800355 void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700356 ThreadPool& thread_pool, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700357 LOCKS_EXCLUDED(Locks::mutator_lock_);
jeffhao98eacac2011-09-14 16:11:53 -0700358
Brian Carlstrom2f663822012-11-07 22:49:06 -0800359 void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700360 ThreadPool& thread_pool, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700361 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers64b6d142012-10-29 16:34:15 -0700362 void InitializeClasses(jobject class_loader, const DexFile& dex_file,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700363 ThreadPool& thread_pool, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700364 LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
Brian Carlstroma5a97a22011-09-15 14:08:49 -0700365
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700366 void UpdateImageClasses(base::TimingLogger& timings);
Brian Carlstrom96391602013-06-13 19:49:50 -0700367 static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
368 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
369
Ian Rogers3d1548d2012-09-24 14:08:03 -0700370 void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700371 ThreadPool& thread_pool, base::TimingLogger& timings);
Brian Carlstrom2f663822012-11-07 22:49:06 -0800372 void CompileDexFile(jobject class_loader, const DexFile& dex_file,
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700373 ThreadPool& thread_pool, base::TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700374 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers08f753d2012-08-24 14:35:25 -0700375 void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700376 InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx,
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200377 jobject class_loader, const DexFile& dex_file,
Sebastien Hertz75021222013-07-16 18:34:50 +0200378 DexToDexCompilationLevel dex_to_dex_compilation_level)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700379 LOCKS_EXCLUDED(compiled_methods_lock_);
Brian Carlstrom83db7722011-08-26 17:32:56 -0700380
Ian Rogers219b5a82013-03-04 13:48:24 -0800381 static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700382 LOCKS_EXCLUDED(Locks::mutator_lock_);
Elliott Hughesc225caa2012-02-03 15:43:37 -0800383
Brian Carlstromf5822582012-03-19 22:34:31 -0700384 std::vector<const PatchInformation*> code_to_patch_;
385 std::vector<const PatchInformation*> methods_to_patch_;
Ian Rogers3fa13792012-03-18 15:53:45 -0700386
buzbeec531cef2012-10-18 07:09:20 -0700387 CompilerBackend compiler_backend_;
388
Ian Rogers2c8f6532011-09-02 17:16:34 -0700389 InstructionSet instruction_set_;
Ian Rogers2c8f6532011-09-02 17:16:34 -0700390
Ian Rogersfffdb022013-01-04 15:14:08 -0800391 // All class references that require
Ian Rogers8f3c9ae2013-08-20 17:26:41 -0700392 mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Ian Rogersfffdb022013-01-04 15:14:08 -0800393 std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
394
Elliott Hughesa0e18062012-04-13 15:59:59 -0700395 typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
Ian Rogersfffdb022013-01-04 15:14:08 -0800396 // All class references that this compiler has compiled.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700397 mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Elliott Hughesf8349362012-06-18 15:00:06 -0700398 ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800399
Ian Rogerse3cd2f02013-05-24 15:32:56 -0700400 typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable;
Ian Rogersfffdb022013-01-04 15:14:08 -0800401 // All method references that this compiler has compiled.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700402 mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Elliott Hughesf8349362012-06-18 15:00:06 -0700403 MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700404
Brian Carlstrom96391602013-06-13 19:49:50 -0700405 const bool image_;
406
407 // If image_ is true, specifies the classes that will be included in
408 // the image. Note if image_classes_ is NULL, all classes are
409 // included in the image.
410 UniquePtr<DescriptorSet> image_classes_;
411
Elliott Hughes5523ee02012-02-03 18:18:34 -0800412 size_t thread_count_;
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800413 uint64_t start_ns_;
414
Ian Rogersc8b306f2012-02-17 21:34:44 -0800415 UniquePtr<AOTCompilationStats> stats_;
Ian Rogers996cc582012-02-14 22:23:29 -0800416
Brian Carlstromba0668e2012-03-26 13:14:07 -0700417 bool dump_stats_;
Brian Carlstromba0668e2012-03-26 13:14:07 -0700418
Ian Rogers1212a022013-03-04 10:48:41 -0800419 typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
420 typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
Logan Chienf7015fd2012-03-18 01:19:37 +0800421
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800422 void* compiler_library_;
Elliott Hughes46f060a2012-03-09 17:36:50 -0800423
Ian Rogers1212a022013-03-04 10:48:41 -0800424 typedef CompiledMethod* (*CompilerFn)(CompilerDriver& driver,
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800425 const DexFile::CodeItem* code_item,
Ian Rogers08f753d2012-08-24 14:35:25 -0700426 uint32_t access_flags, InvokeType invoke_type,
Ian Rogersfffdb022013-01-04 15:14:08 -0800427 uint32_t class_dex_idx, uint32_t method_idx,
428 jobject class_loader, const DexFile& dex_file);
Sebastien Hertz75021222013-07-16 18:34:50 +0200429
430 typedef void (*DexToDexCompilerFn)(CompilerDriver& driver,
431 const DexFile::CodeItem* code_item,
432 uint32_t access_flags, InvokeType invoke_type,
433 uint32_t class_dex_idx, uint32_t method_idx,
434 jobject class_loader, const DexFile& dex_file,
435 DexToDexCompilationLevel dex_to_dex_compilation_level);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800436 CompilerFn compiler_;
Brian Carlstrom51c24672013-07-11 16:00:56 -0700437#ifdef ART_SEA_IR_MODE
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700438 CompilerFn sea_ir_compiler_;
Brian Carlstrom51c24672013-07-11 16:00:56 -0700439#endif
Elliott Hughes46f060a2012-03-09 17:36:50 -0800440
Sebastien Hertz75021222013-07-16 18:34:50 +0200441 DexToDexCompilerFn dex_to_dex_compiler_;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200442
Elliott Hughes6f4976c2012-03-13 21:19:01 -0700443 void* compiler_context_;
444
Ian Rogers1212a022013-03-04 10:48:41 -0800445 typedef CompiledMethod* (*JniCompilerFn)(CompilerDriver& driver,
Elliott Hughes46f060a2012-03-09 17:36:50 -0800446 uint32_t access_flags, uint32_t method_idx,
Elliott Hughes46f060a2012-03-09 17:36:50 -0800447 const DexFile& dex_file);
448 JniCompilerFn jni_compiler_;
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800449
buzbee4df2bbd2012-10-11 14:46:06 -0700450 pthread_key_t tls_key_;
451
Mathieu Chartierf6c4b3b2013-08-24 16:11:37 -0700452 // Arena pool used by the compiler.
453 ArenaPool arena_pool_;
454
Ian Rogers1212a022013-03-04 10:48:41 -0800455 typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver);
Logan Chienf7015fd2012-03-18 01:19:37 +0800456 CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
457
458 typedef const void* (*CompilerGetMethodCodeAddrFn)
Brian Carlstromea46f952013-07-30 01:26:50 -0700459 (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method);
Logan Chienf7015fd2012-03-18 01:19:37 +0800460 CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
461
Brian Carlstrom96391602013-06-13 19:49:50 -0700462 bool support_boot_image_fixup_;
463
Mathieu Chartier193bad92013-08-29 18:46:00 -0700464 // DeDuplication data structures, these own the corresponding byte arrays.
465 class DedupeHashFunc {
466 public:
467 size_t operator()(const std::vector<uint8_t>& array) const {
Ian Rogersd133b972013-09-05 11:01:30 -0700468 // For small arrays compute a hash using every byte.
Mathieu Chartier193bad92013-08-29 18:46:00 -0700469 static const size_t kSmallArrayThreshold = 16;
Ian Rogersd133b972013-09-05 11:01:30 -0700470 size_t hash = 0x811c9dc5;
471 if (array.size() <= kSmallArrayThreshold) {
472 for (uint8_t b : array) {
473 hash = (hash * 16777619) ^ b;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700474 }
475 } else {
Ian Rogers936bf022013-09-06 08:44:06 -0700476 // For larger arrays use the 2 bytes at 6 bytes (the location of a push registers
477 // instruction field for quick generated code on ARM) and then select a number of other
478 // values at random.
Ian Rogersd133b972013-09-05 11:01:30 -0700479 static const size_t kRandomHashCount = 16;
Ian Rogers936bf022013-09-06 08:44:06 -0700480 for (size_t i = 0; i < 2; ++i) {
481 uint8_t b = array[i + 6];
Ian Rogersd133b972013-09-05 11:01:30 -0700482 hash = (hash * 16777619) ^ b;
483 }
Ian Rogers936bf022013-09-06 08:44:06 -0700484 for (size_t i = 2; i < kRandomHashCount; ++i) {
Mathieu Chartier193bad92013-08-29 18:46:00 -0700485 size_t r = i * 1103515245 + 12345;
Ian Rogersd133b972013-09-05 11:01:30 -0700486 uint8_t b = array[r % array.size()];
487 hash = (hash * 16777619) ^ b;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700488 }
489 }
Ian Rogersd133b972013-09-05 11:01:30 -0700490 hash += hash << 13;
491 hash ^= hash >> 7;
492 hash += hash << 3;
493 hash ^= hash >> 17;
494 hash += hash << 5;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700495 return hash;
496 }
497 };
Ian Rogersd133b972013-09-05 11:01:30 -0700498 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_code_;
499 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_mapping_table_;
500 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_vmap_table_;
501 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_gc_map_;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700502
Ian Rogers1212a022013-03-04 10:48:41 -0800503 DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700504};
505
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700506} // namespace art
507
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700508#endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_