blob: 092fe52b247230be4dc39a9fd7212dcd84fdfc5e [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"
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +000025#include "base/timing_logger.h"
Brian Carlstrom51c24672013-07-11 16:00:56 -070026#include "class_reference.h"
Brian Carlstrom0755ec52012-01-11 15:19:46 -080027#include "compiled_class.h"
Brian Carlstrom3320cf42011-10-04 14:58:28 -070028#include "compiled_method.h"
Nicolas Geoffrayf5df8972014-02-14 18:37:08 +000029#include "compiler_backend.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070030#include "dex_file.h"
Elliott Hughes0f3c5532012-03-30 14:51:51 -070031#include "instruction_set.h"
32#include "invoke_type.h"
Brian Carlstrom51c24672013-07-11 16:00:56 -070033#include "method_reference.h"
Brian Carlstrom56d947f2013-07-15 13:14:23 -070034#include "os.h"
Ian Rogers1cb0a1d2011-10-06 15:24:35 -070035#include "runtime.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070036#include "safe_map.h"
Mathieu Chartier0e4627e2012-10-23 16:13:36 -070037#include "thread_pool.h"
Nicolas Geoffray818f2102014-02-18 16:43:35 +000038#include "utils/arena_allocator.h"
Mathieu Chartier193bad92013-08-29 18:46:00 -070039#include "utils/dedupe_set.h"
Ian Rogers0571d352011-11-03 19:51:38 -070040
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070041namespace art {
42
Vladimir Marko2bc47802014-02-10 09:43:07 +000043namespace verifier {
44class MethodVerifier;
45} // namespace verifier
46
Ian Rogersc8b306f2012-02-17 21:34:44 -080047class AOTCompilationStats;
Ian Rogers89756f22013-03-04 16:40:02 -080048class DexCompilationUnit;
Vladimir Marko5816ed42013-11-27 17:04:20 +000049class DexFileToMethodInlinerMap;
Vladimir Marko2bc47802014-02-10 09:43:07 +000050class InlineIGetIPutData;
Brian Carlstromc50d8e12013-07-23 22:35:16 -070051class OatWriter;
Nicolas Geoffrayf5df8972014-02-14 18:37:08 +000052class ParallelCompilationManager;
Elliott Hughes601a1232012-02-02 17:47:38 -080053class TimingLogger;
Vladimir Markoc7f83202014-01-24 17:55:18 +000054class VerificationResults;
Vladimir Marko2730db02014-01-27 11:15:17 +000055class VerifiedMethod;
Ian Rogers996cc582012-02-14 22:23:29 -080056
Ian Rogers848871b2013-08-05 10:56:33 -070057enum EntryPointCallingConvention {
58 // ABI of invocations to a method's interpreter entry point.
59 kInterpreterAbi,
60 // ABI of calls to a method's native code, only used for native methods.
61 kJniAbi,
62 // ABI of calls to a method's portable code entry point.
63 kPortableAbi,
64 // ABI of calls to a method's quick code entry point.
65 kQuickAbi
66};
67
Sebastien Hertz75021222013-07-16 18:34:50 +020068enum DexToDexCompilationLevel {
69 kDontDexToDexCompile, // Only meaning wrt image time interpretation.
70 kRequired, // Dex-to-dex compilation required for correctness.
71 kOptimize // Perform required transformation and peep-hole optimizations.
72};
73
buzbee4df2bbd2012-10-11 14:46:06 -070074// Thread-local storage compiler worker threads
75class CompilerTls {
buzbee4df2bbd2012-10-11 14:46:06 -070076 public:
77 CompilerTls() : llvm_info_(NULL) {}
78 ~CompilerTls() {}
79
80 void* GetLLVMInfo() { return llvm_info_; }
81
82 void SetLLVMInfo(void* llvm_info) { llvm_info_ = llvm_info; }
83
84 private:
85 void* llvm_info_;
buzbee4df2bbd2012-10-11 14:46:06 -070086};
87
Ian Rogers1212a022013-03-04 10:48:41 -080088class CompilerDriver {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070089 public:
Brian Carlstrom96391602013-06-13 19:49:50 -070090 typedef std::set<std::string> DescriptorSet;
91
Brian Carlstromaded5f72011-10-07 17:15:04 -070092 // Create a compiler targeting the requested "instruction_set".
Brian Carlstromae826982011-11-09 01:33:42 -080093 // "image" should be true if image specific optimizations should be
94 // enabled. "image_classes" lets the compiler know what classes it
95 // can assume will be in the image, with NULL implying all available
96 // classes.
Vladimir Markoc7f83202014-01-24 17:55:18 +000097 explicit CompilerDriver(VerificationResults* verification_results,
Vladimir Marko5816ed42013-11-27 17:04:20 +000098 DexFileToMethodInlinerMap* method_inliner_map,
Nicolas Geoffrayf5df8972014-02-14 18:37:08 +000099 CompilerBackend::Kind compiler_backend_kind,
100 InstructionSet instruction_set,
Dave Allison70202782013-10-22 17:52:19 -0700101 InstructionSetFeatures instruction_set_features,
Brian Carlstrom96391602013-06-13 19:49:50 -0700102 bool image, DescriptorSet* image_classes,
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000103 size_t thread_count, bool dump_stats, bool dump_passes,
104 CumulativeLogger* timer);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700105
Ian Rogers1212a022013-03-04 10:48:41 -0800106 ~CompilerDriver();
Ian Rogers2c8f6532011-09-02 17:16:34 -0700107
Brian Carlstrom45602482013-07-21 22:07:55 -0700108 void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800109 TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700110 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstrom8a487412011-08-29 20:08:52 -0700111
Ian Rogersef7d42f2014-01-06 12:55:46 -0800112 // Compile a single Method.
113 void CompileOne(mirror::ArtMethod* method, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700114 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700115
Vladimir Markoc7f83202014-01-24 17:55:18 +0000116 VerificationResults* GetVerificationResults() const {
117 return verification_results_;
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000118 }
119
Vladimir Marko5816ed42013-11-27 17:04:20 +0000120 DexFileToMethodInlinerMap* GetMethodInlinerMap() const {
121 return method_inliner_map_;
122 }
123
Dave Allison70202782013-10-22 17:52:19 -0700124 const InstructionSet& GetInstructionSet() const {
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700125 return instruction_set_;
126 }
127
Dave Allison70202782013-10-22 17:52:19 -0700128 const InstructionSetFeatures& GetInstructionSetFeatures() const {
129 return instruction_set_features_;
130 }
131
Nicolas Geoffrayf5df8972014-02-14 18:37:08 +0000132 CompilerBackend* GetCompilerBackend() const {
133 return compiler_backend_.get();
buzbeec531cef2012-10-18 07:09:20 -0700134 }
135
Ian Rogerse6bb3b22013-08-19 21:51:45 -0700136 // Are we compiling and creating an image file?
Brian Carlstromaded5f72011-10-07 17:15:04 -0700137 bool IsImage() const {
138 return image_;
139 }
140
Brian Carlstrom96391602013-06-13 19:49:50 -0700141 DescriptorSet* GetImageClasses() const {
142 return image_classes_.get();
143 }
144
buzbee4df2bbd2012-10-11 14:46:06 -0700145 CompilerTls* GetTls();
146
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700147 // Generate the trampolines that are invoked by unresolved direct methods.
Ian Rogers848871b2013-08-05 10:56:33 -0700148 const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const
149 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
150 const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const
151 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
152 const std::vector<uint8_t>* CreateJniDlsymLookup() const
153 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700154 const std::vector<uint8_t>* CreatePortableImtConflictTrampoline() const
155 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700156 const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const
157 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers848871b2013-08-05 10:56:33 -0700158 const std::vector<uint8_t>* CreatePortableToInterpreterBridge() const
159 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700160 const std::vector<uint8_t>* CreateQuickImtConflictTrampoline() const
161 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700162 const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
163 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers848871b2013-08-05 10:56:33 -0700164 const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700165 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
166
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700167 CompiledClass* GetCompiledClass(ClassReference ref) const
168 LOCKS_EXCLUDED(compiled_classes_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -0700169
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700170 CompiledMethod* GetCompiledMethod(MethodReference ref) const
171 LOCKS_EXCLUDED(compiled_methods_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800172
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700173 void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
174 uint16_t class_def_index);
175 bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index);
Ian Rogersfffdb022013-01-04 15:14:08 -0800176
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700177 // Callbacks from compiler to see what runtime checks must be generated.
Ian Rogers0571d352011-11-03 19:51:38 -0700178
Ian Rogers5ddb4102014-01-07 08:58:46 -0800179 bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx);
Ian Rogers1bddec32012-02-04 12:27:34 -0800180
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700181 bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700182 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800183
184 // Are runtime access checks necessary in the compiled code?
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700185 bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
Ian Rogersc9e463c2013-06-05 16:52:26 -0700186 uint32_t type_idx, bool* type_known_final = NULL,
187 bool* type_known_abstract = NULL,
188 bool* equals_referrers_class = NULL)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700189 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800190
191 // Are runtime access and instantiable checks necessary in the code?
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700192 bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
193 uint32_t type_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700194 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800195
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800196 bool CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx,
197 bool* is_type_initialized, bool* use_direct_type_ptr,
198 uintptr_t* direct_type_ptr);
199
Vladimir Marko2bc47802014-02-10 09:43:07 +0000200 // Can we fast path instance field access in a verified accessor?
201 // If yes, computes field's offset and volatility and whether the method is static or not.
202 static bool ComputeSpecialAccessorInfo(uint32_t field_idx, bool is_put,
203 verifier::MethodVerifier* verifier,
204 InlineIGetIPutData* result)
205 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
206
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700207 // Can we fast path instance field access? Computes field's offset and volatility.
Ian Rogers9b297bf2013-09-06 11:11:25 -0700208 bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
209 int* field_offset, bool* is_volatile)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700210 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800211
212 // Can we fastpath static field access? Computes field's offset, volatility and whether the
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700213 // field is within the referrer (which can avoid checking class initialization).
Ian Rogers9b297bf2013-09-06 11:11:25 -0700214 bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
Ian Rogers5ddb4102014-01-07 08:58:46 -0800215 int* field_offset, int* storage_index,
216 bool* is_referrers_class, bool* is_volatile, bool* is_initialized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700217 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers1bddec32012-02-04 12:27:34 -0800218
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700219 // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
220 // index.
Ian Rogerse3cd2f02013-05-24 15:32:56 -0700221 bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
Ian Rogers65ec92c2013-09-06 10:49:58 -0700222 bool update_stats, bool enable_devirtualization,
223 InvokeType* type, MethodReference* target_method, int* vtable_idx,
224 uintptr_t* direct_code, uintptr_t* direct_method)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700225 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800226
Vladimir Marko2730db02014-01-27 11:15:17 +0000227 const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const;
228 bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc);
Ian Rogersfae370a2013-06-05 08:33:27 -0700229
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700230 // Record patch information for later fix up.
231 void AddCodePatch(const DexFile* dex_file,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700232 uint16_t referrer_class_def_idx,
Brian Carlstromf5822582012-03-19 22:34:31 -0700233 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700234 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700235 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700236 InvokeType target_invoke_type,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700237 size_t literal_offset)
238 LOCKS_EXCLUDED(compiled_methods_lock_);
Mark Mendell55d0eac2014-02-06 11:02:52 -0800239 void AddRelativeCodePatch(const DexFile* dex_file,
240 uint16_t referrer_class_def_idx,
241 uint32_t referrer_method_idx,
242 InvokeType referrer_invoke_type,
243 uint32_t target_method_idx,
244 InvokeType target_invoke_type,
245 size_t literal_offset,
246 int32_t pc_relative_offset)
247 LOCKS_EXCLUDED(compiled_methods_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700248 void AddMethodPatch(const DexFile* dex_file,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700249 uint16_t referrer_class_def_idx,
Brian Carlstromf5822582012-03-19 22:34:31 -0700250 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700251 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700252 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700253 InvokeType target_invoke_type,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700254 size_t literal_offset)
255 LOCKS_EXCLUDED(compiled_methods_lock_);
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800256 void AddClassPatch(const DexFile* dex_file,
257 uint16_t referrer_class_def_idx,
258 uint32_t referrer_method_idx,
259 uint32_t target_method_idx,
260 size_t literal_offset)
261 LOCKS_EXCLUDED(compiled_methods_lock_);
Ian Rogers3fa13792012-03-18 15:53:45 -0700262
Brian Carlstrom96391602013-06-13 19:49:50 -0700263 bool GetSupportBootImageFixup() const {
264 return support_boot_image_fixup_;
265 }
266
267 void SetSupportBootImageFixup(bool support_boot_image_fixup) {
268 support_boot_image_fixup_ = support_boot_image_fixup;
269 }
270
Mathieu Chartierf6c4b3b2013-08-24 16:11:37 -0700271 ArenaPool& GetArenaPool() {
272 return arena_pool_;
273 }
Brian Carlstrom96391602013-06-13 19:49:50 -0700274
Brian Carlstrom3f47c122013-03-07 00:02:40 -0800275 bool WriteElf(const std::string& android_root,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800276 bool is_host,
277 const std::vector<const DexFile*>& dex_files,
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700278 OatWriter& oat_writer,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800279 File* file);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800280
281 // TODO: move to a common home for llvm helpers once quick/portable are merged
282 static void InstructionSetToLLVMTarget(InstructionSet instruction_set,
283 std::string& target_triple,
284 std::string& target_cpu,
285 std::string& target_attr);
286
Elliott Hughes6f4976c2012-03-13 21:19:01 -0700287 void SetCompilerContext(void* compiler_context) {
288 compiler_context_ = compiler_context;
289 }
290
291 void* GetCompilerContext() const {
292 return compiler_context_;
293 }
294
Logan Chien08e1ba32012-05-08 15:08:51 +0800295 size_t GetThreadCount() const {
296 return thread_count_;
297 }
298
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800299 class CallPatchInformation;
300 class TypePatchInformation;
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000301
302 bool GetDumpPasses() const {
303 return dump_passes_;
304 }
305
306 CumulativeLogger& GetTimingsLogger() const {
307 return *timings_logger_;
308 }
309
Brian Carlstromf5822582012-03-19 22:34:31 -0700310 class PatchInformation {
311 public:
Brian Carlstromf5822582012-03-19 22:34:31 -0700312 const DexFile& GetDexFile() const {
313 return *dex_file_;
314 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700315 uint16_t GetReferrerClassDefIdx() const {
316 return referrer_class_def_idx_;
317 }
Brian Carlstromf5822582012-03-19 22:34:31 -0700318 uint32_t GetReferrerMethodIdx() const {
319 return referrer_method_idx_;
320 }
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800321 size_t GetLiteralOffset() const {
322 return literal_offset_;
323 }
324
325 virtual bool IsCall() const {
326 return false;
327 }
328 virtual bool IsType() const {
329 return false;
330 }
331 virtual const CallPatchInformation* AsCall() const {
332 LOG(FATAL) << "Unreachable";
333 return nullptr;
334 }
335 virtual const TypePatchInformation* AsType() const {
336 LOG(FATAL) << "Unreachable";
337 return nullptr;
338 }
339
340 protected:
341 PatchInformation(const DexFile* dex_file,
342 uint16_t referrer_class_def_idx,
343 uint32_t referrer_method_idx,
344 size_t literal_offset)
345 : dex_file_(dex_file),
346 referrer_class_def_idx_(referrer_class_def_idx),
347 referrer_method_idx_(referrer_method_idx),
348 literal_offset_(literal_offset) {
349 CHECK(dex_file_ != NULL);
350 }
351 virtual ~PatchInformation() {}
352
353 const DexFile* const dex_file_;
354 const uint16_t referrer_class_def_idx_;
355 const uint32_t referrer_method_idx_;
356 const size_t literal_offset_;
357
358 friend class CompilerDriver;
359 };
360
361 class CallPatchInformation : public PatchInformation {
362 public:
Ian Rogers08f753d2012-08-24 14:35:25 -0700363 InvokeType GetReferrerInvokeType() const {
364 return referrer_invoke_type_;
Brian Carlstromf5822582012-03-19 22:34:31 -0700365 }
366 uint32_t GetTargetMethodIdx() const {
367 return target_method_idx_;
368 }
Ian Rogers08f753d2012-08-24 14:35:25 -0700369 InvokeType GetTargetInvokeType() const {
370 return target_invoke_type_;
Brian Carlstromf5822582012-03-19 22:34:31 -0700371 }
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800372
373 const CallPatchInformation* AsCall() const {
374 return this;
375 }
376 bool IsCall() const {
377 return true;
Brian Carlstromf5822582012-03-19 22:34:31 -0700378 }
Mark Mendell55d0eac2014-02-06 11:02:52 -0800379 virtual bool IsRelative() const {
380 return false;
381 }
382 virtual int RelativeOffset() const {
383 return 0;
384 }
Brian Carlstromf5822582012-03-19 22:34:31 -0700385
Mark Mendell55d0eac2014-02-06 11:02:52 -0800386 protected:
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800387 CallPatchInformation(const DexFile* dex_file,
388 uint16_t referrer_class_def_idx,
389 uint32_t referrer_method_idx,
390 InvokeType referrer_invoke_type,
391 uint32_t target_method_idx,
392 InvokeType target_invoke_type,
393 size_t literal_offset)
394 : PatchInformation(dex_file, referrer_class_def_idx,
395 referrer_method_idx, literal_offset),
396 referrer_invoke_type_(referrer_invoke_type),
397 target_method_idx_(target_method_idx),
398 target_invoke_type_(target_invoke_type) {
Brian Carlstromf5822582012-03-19 22:34:31 -0700399 }
400
Mark Mendell55d0eac2014-02-06 11:02:52 -0800401 private:
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700402 const InvokeType referrer_invoke_type_;
403 const uint32_t target_method_idx_;
404 const InvokeType target_invoke_type_;
Brian Carlstromf5822582012-03-19 22:34:31 -0700405
Ian Rogers1212a022013-03-04 10:48:41 -0800406 friend class CompilerDriver;
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800407 DISALLOW_COPY_AND_ASSIGN(CallPatchInformation);
Brian Carlstromf5822582012-03-19 22:34:31 -0700408 };
409
Mark Mendell55d0eac2014-02-06 11:02:52 -0800410 class RelativeCallPatchInformation : public CallPatchInformation {
411 public:
412 bool IsRelative() const {
413 return true;
414 }
415 int RelativeOffset() const {
416 return offset_;
417 }
418
419 private:
420 RelativeCallPatchInformation(const DexFile* dex_file,
421 uint16_t referrer_class_def_idx,
422 uint32_t referrer_method_idx,
423 InvokeType referrer_invoke_type,
424 uint32_t target_method_idx,
425 InvokeType target_invoke_type,
426 size_t literal_offset,
427 int32_t pc_relative_offset)
428 : CallPatchInformation(dex_file, referrer_class_def_idx,
429 referrer_method_idx, referrer_invoke_type,
430 target_method_idx, target_invoke_type, literal_offset),
431 offset_(pc_relative_offset) {
432 }
433
434 const int offset_;
435
436 friend class CompilerDriver;
437 DISALLOW_COPY_AND_ASSIGN(RelativeCallPatchInformation);
438 };
439
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800440 class TypePatchInformation : public PatchInformation {
441 public:
442 uint32_t GetTargetTypeIdx() const {
443 return target_type_idx_;
444 }
445
446 bool IsType() const {
447 return true;
448 }
449 const TypePatchInformation* AsType() const {
450 return this;
451 }
452
453 private:
454 TypePatchInformation(const DexFile* dex_file,
455 uint16_t referrer_class_def_idx,
456 uint32_t referrer_method_idx,
457 uint32_t target_type_idx,
458 size_t literal_offset)
459 : PatchInformation(dex_file, referrer_class_def_idx,
460 referrer_method_idx, literal_offset),
461 target_type_idx_(target_type_idx) {
462 }
463
464 const uint32_t target_type_idx_;
465
466 friend class CompilerDriver;
467 DISALLOW_COPY_AND_ASSIGN(TypePatchInformation);
468 };
469
470 const std::vector<const CallPatchInformation*>& GetCodeToPatch() const {
Brian Carlstromf5822582012-03-19 22:34:31 -0700471 return code_to_patch_;
472 }
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800473 const std::vector<const CallPatchInformation*>& GetMethodsToPatch() const {
Brian Carlstromf5822582012-03-19 22:34:31 -0700474 return methods_to_patch_;
475 }
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800476 const std::vector<const TypePatchInformation*>& GetClassesToPatch() const {
477 return classes_to_patch_;
478 }
Brian Carlstromf5822582012-03-19 22:34:31 -0700479
Ian Rogers3d1548d2012-09-24 14:08:03 -0700480 // Checks if class specified by type_idx is one of the image_classes_
Ian Rogersdfb325e2013-10-30 01:00:44 -0700481 bool IsImageClass(const char* descriptor) const;
Ian Rogers3d1548d2012-09-24 14:08:03 -0700482
Ian Rogers8f3c9ae2013-08-20 17:26:41 -0700483 void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
484 LOCKS_EXCLUDED(compiled_classes_lock_);
Ian Rogers3d1548d2012-09-24 14:08:03 -0700485
Mathieu Chartier193bad92013-08-29 18:46:00 -0700486 std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code);
487 std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code);
488 std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code);
489 std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code);
490
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700491 private:
Ian Rogers2ed3b952012-03-17 11:49:39 -0700492 // Compute constant code and method pointers when possible
Ian Rogers83883d72013-10-21 21:07:24 -0700493 void GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type,
494 bool no_guarantee_of_dex_cache_entry,
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700495 mirror::Class* referrer_class,
Brian Carlstromea46f952013-07-30 01:26:50 -0700496 mirror::ArtMethod* method,
Ian Rogers65ec92c2013-09-06 10:49:58 -0700497 bool update_stats,
Ian Rogers83883d72013-10-21 21:07:24 -0700498 MethodReference* target_method,
Ian Rogers65ec92c2013-09-06 10:49:58 -0700499 uintptr_t* direct_code, uintptr_t* direct_method)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700500 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2ed3b952012-03-17 11:49:39 -0700501
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700502 void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800503 ThreadPool& thread_pool, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700504 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -0800505
Ian Rogers5fe9af72013-11-14 00:17:20 -0800506 void LoadImageClasses(TimingLogger& timings);
Brian Carlstrom96391602013-06-13 19:49:50 -0700507
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700508 // Attempt to resolve all type, methods, fields, and strings
509 // referenced from code in the dex file following PathClassLoader
510 // ordering semantics.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700511 void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800512 ThreadPool& thread_pool, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700513 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstrom2f663822012-11-07 22:49:06 -0800514 void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800515 ThreadPool& thread_pool, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700516 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700517
Ian Rogers3d1548d2012-09-24 14:08:03 -0700518 void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800519 ThreadPool& thread_pool, TimingLogger& timings);
Brian Carlstrom2f663822012-11-07 22:49:06 -0800520 void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800521 ThreadPool& thread_pool, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700522 LOCKS_EXCLUDED(Locks::mutator_lock_);
jeffhao98eacac2011-09-14 16:11:53 -0700523
Brian Carlstrom2f663822012-11-07 22:49:06 -0800524 void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800525 ThreadPool& thread_pool, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700526 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers64b6d142012-10-29 16:34:15 -0700527 void InitializeClasses(jobject class_loader, const DexFile& dex_file,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800528 ThreadPool& thread_pool, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700529 LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
Brian Carlstroma5a97a22011-09-15 14:08:49 -0700530
Ian Rogers5fe9af72013-11-14 00:17:20 -0800531 void UpdateImageClasses(TimingLogger& timings)
Mathieu Chartier590fee92013-09-13 13:46:47 -0700532 LOCKS_EXCLUDED(Locks::mutator_lock_);
Brian Carlstrom96391602013-06-13 19:49:50 -0700533 static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
534 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
535
Ian Rogers3d1548d2012-09-24 14:08:03 -0700536 void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800537 ThreadPool& thread_pool, TimingLogger& timings);
Brian Carlstrom2f663822012-11-07 22:49:06 -0800538 void CompileDexFile(jobject class_loader, const DexFile& dex_file,
Ian Rogers5fe9af72013-11-14 00:17:20 -0800539 ThreadPool& thread_pool, TimingLogger& timings)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700540 LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers08f753d2012-08-24 14:35:25 -0700541 void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700542 InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx,
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200543 jobject class_loader, const DexFile& dex_file,
Sebastien Hertz75021222013-07-16 18:34:50 +0200544 DexToDexCompilationLevel dex_to_dex_compilation_level)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700545 LOCKS_EXCLUDED(compiled_methods_lock_);
Brian Carlstrom83db7722011-08-26 17:32:56 -0700546
Ian Rogers219b5a82013-03-04 13:48:24 -0800547 static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700548 LOCKS_EXCLUDED(Locks::mutator_lock_);
Elliott Hughesc225caa2012-02-03 15:43:37 -0800549
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -0800550 std::vector<const CallPatchInformation*> code_to_patch_;
551 std::vector<const CallPatchInformation*> methods_to_patch_;
552 std::vector<const TypePatchInformation*> classes_to_patch_;
Ian Rogers3fa13792012-03-18 15:53:45 -0700553
Vladimir Markoc7f83202014-01-24 17:55:18 +0000554 VerificationResults* verification_results_;
Vladimir Marko5816ed42013-11-27 17:04:20 +0000555 DexFileToMethodInlinerMap* method_inliner_map_;
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000556
Nicolas Geoffrayf5df8972014-02-14 18:37:08 +0000557 UniquePtr<CompilerBackend> compiler_backend_;
buzbeec531cef2012-10-18 07:09:20 -0700558
Dave Allison70202782013-10-22 17:52:19 -0700559 const InstructionSet instruction_set_;
560 const InstructionSetFeatures instruction_set_features_;
Ian Rogers2c8f6532011-09-02 17:16:34 -0700561
Ian Rogersfffdb022013-01-04 15:14:08 -0800562 // All class references that require
Ian Rogers8f3c9ae2013-08-20 17:26:41 -0700563 mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Ian Rogersfffdb022013-01-04 15:14:08 -0800564 std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
565
Elliott Hughesa0e18062012-04-13 15:59:59 -0700566 typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
Ian Rogersfffdb022013-01-04 15:14:08 -0800567 // All class references that this compiler has compiled.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700568 mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Elliott Hughesf8349362012-06-18 15:00:06 -0700569 ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800570
Ian Rogerse3cd2f02013-05-24 15:32:56 -0700571 typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable;
Ian Rogersfffdb022013-01-04 15:14:08 -0800572 // All method references that this compiler has compiled.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700573 mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Elliott Hughesf8349362012-06-18 15:00:06 -0700574 MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700575
Brian Carlstrom96391602013-06-13 19:49:50 -0700576 const bool image_;
577
578 // If image_ is true, specifies the classes that will be included in
579 // the image. Note if image_classes_ is NULL, all classes are
580 // included in the image.
581 UniquePtr<DescriptorSet> image_classes_;
582
Elliott Hughes5523ee02012-02-03 18:18:34 -0800583 size_t thread_count_;
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800584 uint64_t start_ns_;
585
Ian Rogersc8b306f2012-02-17 21:34:44 -0800586 UniquePtr<AOTCompilationStats> stats_;
Ian Rogers996cc582012-02-14 22:23:29 -0800587
Brian Carlstromba0668e2012-03-26 13:14:07 -0700588 bool dump_stats_;
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000589 const bool dump_passes_;
590
591 CumulativeLogger* const timings_logger_;
Brian Carlstromba0668e2012-03-26 13:14:07 -0700592
Ian Rogers1212a022013-03-04 10:48:41 -0800593 typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
594 typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
Logan Chienf7015fd2012-03-18 01:19:37 +0800595
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800596 void* compiler_library_;
Elliott Hughes46f060a2012-03-09 17:36:50 -0800597
Sebastien Hertz75021222013-07-16 18:34:50 +0200598 typedef void (*DexToDexCompilerFn)(CompilerDriver& driver,
599 const DexFile::CodeItem* code_item,
600 uint32_t access_flags, InvokeType invoke_type,
601 uint32_t class_dex_idx, uint32_t method_idx,
602 jobject class_loader, const DexFile& dex_file,
603 DexToDexCompilationLevel dex_to_dex_compilation_level);
Sebastien Hertz75021222013-07-16 18:34:50 +0200604 DexToDexCompilerFn dex_to_dex_compiler_;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200605
Elliott Hughes6f4976c2012-03-13 21:19:01 -0700606 void* compiler_context_;
607
buzbee4df2bbd2012-10-11 14:46:06 -0700608 pthread_key_t tls_key_;
609
Mathieu Chartierf6c4b3b2013-08-24 16:11:37 -0700610 // Arena pool used by the compiler.
611 ArenaPool arena_pool_;
612
Ian Rogers1212a022013-03-04 10:48:41 -0800613 typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver);
Logan Chienf7015fd2012-03-18 01:19:37 +0800614 CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
615
616 typedef const void* (*CompilerGetMethodCodeAddrFn)
Brian Carlstromea46f952013-07-30 01:26:50 -0700617 (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method);
Logan Chienf7015fd2012-03-18 01:19:37 +0800618 CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
619
Brian Carlstrom96391602013-06-13 19:49:50 -0700620 bool support_boot_image_fixup_;
621
Mathieu Chartier193bad92013-08-29 18:46:00 -0700622 // DeDuplication data structures, these own the corresponding byte arrays.
623 class DedupeHashFunc {
624 public:
625 size_t operator()(const std::vector<uint8_t>& array) const {
Ian Rogersd133b972013-09-05 11:01:30 -0700626 // For small arrays compute a hash using every byte.
Mathieu Chartier193bad92013-08-29 18:46:00 -0700627 static const size_t kSmallArrayThreshold = 16;
Ian Rogersd133b972013-09-05 11:01:30 -0700628 size_t hash = 0x811c9dc5;
629 if (array.size() <= kSmallArrayThreshold) {
630 for (uint8_t b : array) {
631 hash = (hash * 16777619) ^ b;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700632 }
633 } else {
Ian Rogers936bf022013-09-06 08:44:06 -0700634 // For larger arrays use the 2 bytes at 6 bytes (the location of a push registers
635 // instruction field for quick generated code on ARM) and then select a number of other
636 // values at random.
Ian Rogersd133b972013-09-05 11:01:30 -0700637 static const size_t kRandomHashCount = 16;
Ian Rogers936bf022013-09-06 08:44:06 -0700638 for (size_t i = 0; i < 2; ++i) {
639 uint8_t b = array[i + 6];
Ian Rogersd133b972013-09-05 11:01:30 -0700640 hash = (hash * 16777619) ^ b;
641 }
Ian Rogers936bf022013-09-06 08:44:06 -0700642 for (size_t i = 2; i < kRandomHashCount; ++i) {
Mathieu Chartier193bad92013-08-29 18:46:00 -0700643 size_t r = i * 1103515245 + 12345;
Ian Rogersd133b972013-09-05 11:01:30 -0700644 uint8_t b = array[r % array.size()];
645 hash = (hash * 16777619) ^ b;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700646 }
647 }
Ian Rogersd133b972013-09-05 11:01:30 -0700648 hash += hash << 13;
649 hash ^= hash >> 7;
650 hash += hash << 3;
651 hash ^= hash >> 17;
652 hash += hash << 5;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700653 return hash;
654 }
655 };
Ian Rogersd133b972013-09-05 11:01:30 -0700656 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_code_;
657 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_mapping_table_;
658 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_vmap_table_;
659 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_gc_map_;
Mathieu Chartier193bad92013-08-29 18:46:00 -0700660
Ian Rogers1212a022013-03-04 10:48:41 -0800661 DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700662};
663
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700664} // namespace art
665
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700666#endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_