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  */
16 
17 #ifndef ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
18 #define ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
19 
20 #include <set>
21 #include <string>
22 #include <unordered_set>
23 #include <vector>
24 
25 #include "arch/instruction_set.h"
26 #include "base/arena_allocator.h"
27 #include "base/bit_utils.h"
28 #include "base/mutex.h"
29 #include "base/timing_logger.h"
30 #include "class_reference.h"
31 #include "compiler.h"
32 #include "dex_file.h"
33 #include "invoke_type.h"
34 #include "method_reference.h"
35 #include "mirror/class.h"  // For mirror::Class::Status.
36 #include "os.h"
37 #include "profiler.h"
38 #include "runtime.h"
39 #include "safe_map.h"
40 #include "thread_pool.h"
41 #include "utils/array_ref.h"
42 #include "utils/dedupe_set.h"
43 #include "utils/dex_cache_arrays_layout.h"
44 #include "utils/swap_space.h"
45 
46 namespace art {
47 
48 namespace mirror {
49 class DexCache;
50 }  // namespace mirror
51 
52 namespace verifier {
53 class MethodVerifier;
54 }  // namespace verifier
55 
56 class CompiledClass;
57 class CompiledMethod;
58 class CompilerOptions;
59 class DexCompilationUnit;
60 class DexFileToMethodInlinerMap;
61 struct InlineIGetIPutData;
62 class InstructionSetFeatures;
63 class OatWriter;
64 class ParallelCompilationManager;
65 class ScopedObjectAccess;
66 template <class Allocator> class SrcMap;
67 class SrcMapElem;
68 using SwapSrcMap = SrcMap<SwapAllocator<SrcMapElem>>;
69 template<class T> class Handle;
70 class TimingLogger;
71 class VerificationResults;
72 class VerifiedMethod;
73 
74 enum EntryPointCallingConvention {
75   // ABI of invocations to a method's interpreter entry point.
76   kInterpreterAbi,
77   // ABI of calls to a method's native code, only used for native methods.
78   kJniAbi,
79   // ABI of calls to a method's quick code entry point.
80   kQuickAbi
81 };
82 
83 enum DexToDexCompilationLevel {
84   kDontDexToDexCompile,   // Only meaning wrt image time interpretation.
85   kRequired,              // Dex-to-dex compilation required for correctness.
86   kOptimize               // Perform required transformation and peep-hole optimizations.
87 };
88 std::ostream& operator<<(std::ostream& os, const DexToDexCompilationLevel& rhs);
89 
90 static constexpr bool kUseMurmur3Hash = true;
91 
92 class CompilerDriver {
93  public:
94   // Create a compiler targeting the requested "instruction_set".
95   // "image" should be true if image specific optimizations should be
96   // enabled.  "image_classes" lets the compiler know what classes it
97   // can assume will be in the image, with null implying all available
98   // classes.
99   explicit CompilerDriver(const CompilerOptions* compiler_options,
100                           VerificationResults* verification_results,
101                           DexFileToMethodInlinerMap* method_inliner_map,
102                           Compiler::Kind compiler_kind,
103                           InstructionSet instruction_set,
104                           const InstructionSetFeatures* instruction_set_features,
105                           bool image, std::unordered_set<std::string>* image_classes,
106                           std::unordered_set<std::string>* compiled_classes,
107                           std::unordered_set<std::string>* compiled_methods,
108                           size_t thread_count, bool dump_stats, bool dump_passes,
109                           const std::string& dump_cfg_file_name,
110                           CumulativeLogger* timer, int swap_fd,
111                           const std::string& profile_file);
112 
113   ~CompilerDriver();
114 
115   void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
116                   TimingLogger* timings)
117       LOCKS_EXCLUDED(Locks::mutator_lock_);
118 
119   CompiledMethod* CompileMethod(Thread* self, ArtMethod*)
120       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) WARN_UNUSED;
121 
122   // Compile a single Method.
123   void CompileOne(Thread* self, ArtMethod* method, TimingLogger* timings)
124       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
125 
GetVerificationResults()126   VerificationResults* GetVerificationResults() const {
127     return verification_results_;
128   }
129 
GetMethodInlinerMap()130   DexFileToMethodInlinerMap* GetMethodInlinerMap() const {
131     return method_inliner_map_;
132   }
133 
GetInstructionSet()134   InstructionSet GetInstructionSet() const {
135     return instruction_set_;
136   }
137 
GetInstructionSetFeatures()138   const InstructionSetFeatures* GetInstructionSetFeatures() const {
139     return instruction_set_features_;
140   }
141 
GetCompilerOptions()142   const CompilerOptions& GetCompilerOptions() const {
143     return *compiler_options_;
144   }
145 
GetCompiler()146   Compiler* GetCompiler() const {
147     return compiler_.get();
148   }
149 
ProfilePresent()150   bool ProfilePresent() const {
151     return profile_present_;
152   }
153 
154   // Are we compiling and creating an image file?
IsImage()155   bool IsImage() const {
156     return image_;
157   }
158 
GetImageClasses()159   const std::unordered_set<std::string>* GetImageClasses() const {
160     return image_classes_.get();
161   }
162 
163   // Generate the trampolines that are invoked by unresolved direct methods.
164   const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const
165       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
166   const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const
167       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
168   const std::vector<uint8_t>* CreateJniDlsymLookup() const
169       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
170   const std::vector<uint8_t>* CreateQuickGenericJniTrampoline() const
171       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
172   const std::vector<uint8_t>* CreateQuickImtConflictTrampoline() const
173       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
174   const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
175       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
176   const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const
177       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
178 
179   CompiledClass* GetCompiledClass(ClassReference ref) const
180       LOCKS_EXCLUDED(compiled_classes_lock_);
181 
182   CompiledMethod* GetCompiledMethod(MethodReference ref) const
183       LOCKS_EXCLUDED(compiled_methods_lock_);
184   size_t GetNonRelativeLinkerPatchCount() const
185       LOCKS_EXCLUDED(compiled_methods_lock_);
186 
187   // Remove and delete a compiled method.
188   void RemoveCompiledMethod(const MethodReference& method_ref);
189 
190   void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
191                                      uint16_t class_def_index);
192   bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
193                                   uint16_t class_def_index) const;
194 
195   // Callbacks from compiler to see what runtime checks must be generated.
196 
197   bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx);
198 
199   bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
200       LOCKS_EXCLUDED(Locks::mutator_lock_);
201 
202   // Are runtime access checks necessary in the compiled code?
203   bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
204                                   uint32_t type_idx, bool* type_known_final = nullptr,
205                                   bool* type_known_abstract = nullptr,
206                                   bool* equals_referrers_class = nullptr)
207       LOCKS_EXCLUDED(Locks::mutator_lock_);
208 
209   // Are runtime access and instantiable checks necessary in the code?
210   bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
211                                               uint32_t type_idx)
212      LOCKS_EXCLUDED(Locks::mutator_lock_);
213 
214   bool CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx,
215                           bool* is_type_initialized, bool* use_direct_type_ptr,
216                           uintptr_t* direct_type_ptr, bool* out_is_finalizable);
217 
218   // Query methods for the java.lang.ref.Reference class.
219   bool CanEmbedReferenceTypeInCode(ClassReference* ref,
220                                    bool* use_direct_type_ptr, uintptr_t* direct_type_ptr);
221   uint32_t GetReferenceSlowFlagOffset() const;
222   uint32_t GetReferenceDisableFlagOffset() const;
223 
224   // Get the DexCache for the
225   mirror::DexCache* GetDexCache(const DexCompilationUnit* mUnit)
226     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
227 
228   mirror::ClassLoader* GetClassLoader(ScopedObjectAccess& soa, const DexCompilationUnit* mUnit)
229     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
230 
231   // Resolve compiling method's class. Returns null on failure.
232   mirror::Class* ResolveCompilingMethodsClass(
233       const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
234       Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit)
235     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
236 
237   mirror::Class* ResolveClass(
238       const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
239       Handle<mirror::ClassLoader> class_loader, uint16_t type_index,
240       const DexCompilationUnit* mUnit)
241     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
242 
243   // Resolve a field. Returns null on failure, including incompatible class change.
244   // NOTE: Unlike ClassLinker's ResolveField(), this method enforces is_static.
245   ArtField* ResolveField(
246       const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
247       Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit,
248       uint32_t field_idx, bool is_static)
249     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
250 
251   // Resolve a field with a given dex file.
252   ArtField* ResolveFieldWithDexFile(
253       const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
254       Handle<mirror::ClassLoader> class_loader, const DexFile* dex_file,
255       uint32_t field_idx, bool is_static)
256     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
257 
258   // Get declaration location of a resolved field.
259   void GetResolvedFieldDexFileLocation(
260       ArtField* resolved_field, const DexFile** declaring_dex_file,
261       uint16_t* declaring_class_idx, uint16_t* declaring_field_idx)
262     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
263 
264   bool IsFieldVolatile(ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
265   MemberOffset GetFieldOffset(ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
266 
267   // Find a dex cache for a dex file.
268   inline mirror::DexCache* FindDexCache(const DexFile* dex_file)
269       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
270 
271   // Can we fast-path an IGET/IPUT access to an instance field? If yes, compute the field offset.
272   std::pair<bool, bool> IsFastInstanceField(
273       mirror::DexCache* dex_cache, mirror::Class* referrer_class,
274       ArtField* resolved_field, uint16_t field_idx)
275     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
276 
277   // Can we fast-path an SGET/SPUT access to a static field? If yes, compute the type index
278   // of the declaring class in the referrer's dex file.
279   std::pair<bool, bool> IsFastStaticField(
280       mirror::DexCache* dex_cache, mirror::Class* referrer_class,
281       ArtField* resolved_field, uint16_t field_idx, uint32_t* storage_index)
282     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
283 
284   // Return whether the declaring class of `resolved_method` is
285   // available to `referrer_class`. If this is true, compute the type
286   // index of the declaring class in the referrer's dex file and
287   // return it through the out argument `storage_index`; otherwise
288   // return DexFile::kDexNoIndex through `storage_index`.
289   bool IsClassOfStaticMethodAvailableToReferrer(mirror::DexCache* dex_cache,
290                                                 mirror::Class* referrer_class,
291                                                 ArtMethod* resolved_method,
292                                                 uint16_t method_idx,
293                                                 uint32_t* storage_index)
294       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
295 
296   // Is static field's in referrer's class?
297   bool IsStaticFieldInReferrerClass(mirror::Class* referrer_class, ArtField* resolved_field)
298     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
299 
300   // Is static field's class initialized?
301   bool IsStaticFieldsClassInitialized(mirror::Class* referrer_class,
302                                       ArtField* resolved_field)
303     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
304 
305   // Resolve a method. Returns null on failure, including incompatible class change.
306   ArtMethod* ResolveMethod(
307       ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
308       Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit,
309       uint32_t method_idx, InvokeType invoke_type, bool check_incompatible_class_change = true)
310     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
311 
312   // Get declaration location of a resolved field.
313   void GetResolvedMethodDexFileLocation(
314       ArtMethod* resolved_method, const DexFile** declaring_dex_file,
315       uint16_t* declaring_class_idx, uint16_t* declaring_method_idx)
316     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
317 
318   // Get the index in the vtable of the method.
319   uint16_t GetResolvedMethodVTableIndex(
320       ArtMethod* resolved_method, InvokeType type)
321     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
322 
323   // Can we fast-path an INVOKE? If no, returns 0. If yes, returns a non-zero opaque flags value
324   // for ProcessedInvoke() and computes the necessary lowering info.
325   int IsFastInvoke(
326       ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache,
327       Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit,
328       mirror::Class* referrer_class, ArtMethod* resolved_method, InvokeType* invoke_type,
329       MethodReference* target_method, const MethodReference* devirt_target,
330       uintptr_t* direct_code, uintptr_t* direct_method)
331     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
332 
333   // Is method's class initialized for an invoke?
334   // For static invokes to determine whether we need to consider potential call to <clinit>().
335   // For non-static invokes, assuming a non-null reference, the class is always initialized.
336   bool IsMethodsClassInitialized(mirror::Class* referrer_class, ArtMethod* resolved_method)
337     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
338 
339   // Get the layout of dex cache arrays for a dex file. Returns invalid layout if the
340   // dex cache arrays don't have a fixed layout.
341   DexCacheArraysLayout GetDexCacheArraysLayout(const DexFile* dex_file);
342 
343   void ProcessedInstanceField(bool resolved);
344   void ProcessedStaticField(bool resolved, bool local);
345   void ProcessedInvoke(InvokeType invoke_type, int flags);
346 
347   void ComputeFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
348                         const ScopedObjectAccess& soa, bool is_static,
349                         ArtField** resolved_field,
350                         mirror::Class** referrer_class,
351                         mirror::DexCache** dex_cache)
352       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
353 
354   // Can we fast path instance field access? Computes field's offset and volatility.
355   bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
356                                 MemberOffset* field_offset, bool* is_volatile)
357       LOCKS_EXCLUDED(Locks::mutator_lock_);
358 
359   ArtField* ComputeInstanceFieldInfo(uint32_t field_idx,
360                                              const DexCompilationUnit* mUnit,
361                                              bool is_put,
362                                              const ScopedObjectAccess& soa)
363       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
364 
365 
366   // Can we fastpath static field access? Computes field's offset, volatility and whether the
367   // field is within the referrer (which can avoid checking class initialization).
368   bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
369                               MemberOffset* field_offset, uint32_t* storage_index,
370                               bool* is_referrers_class, bool* is_volatile, bool* is_initialized,
371                               Primitive::Type* type)
372       LOCKS_EXCLUDED(Locks::mutator_lock_);
373 
374   // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
375   // index.
376   bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
377                          bool update_stats, bool enable_devirtualization,
378                          InvokeType* type, MethodReference* target_method, int* vtable_idx,
379                          uintptr_t* direct_code, uintptr_t* direct_method)
380       LOCKS_EXCLUDED(Locks::mutator_lock_);
381 
382   const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const;
383   bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc);
384 
GetSupportBootImageFixup()385   bool GetSupportBootImageFixup() const {
386     return support_boot_image_fixup_;
387   }
388 
SetSupportBootImageFixup(bool support_boot_image_fixup)389   void SetSupportBootImageFixup(bool support_boot_image_fixup) {
390     support_boot_image_fixup_ = support_boot_image_fixup;
391   }
392 
GetSwapSpaceAllocator()393   SwapAllocator<void>& GetSwapSpaceAllocator() {
394     return *swap_space_allocator_.get();
395   }
396 
397   bool WriteElf(const std::string& android_root,
398                 bool is_host,
399                 const std::vector<const DexFile*>& dex_files,
400                 OatWriter* oat_writer,
401                 File* file);
402 
SetCompilerContext(void * compiler_context)403   void SetCompilerContext(void* compiler_context) {
404     compiler_context_ = compiler_context;
405   }
406 
GetCompilerContext()407   void* GetCompilerContext() const {
408     return compiler_context_;
409   }
410 
GetThreadCount()411   size_t GetThreadCount() const {
412     return thread_count_;
413   }
414 
GetDumpStats()415   bool GetDumpStats() const {
416     return dump_stats_;
417   }
418 
GetDumpPasses()419   bool GetDumpPasses() const {
420     return dump_passes_;
421   }
422 
GetDumpCfgFileName()423   const std::string& GetDumpCfgFileName() const {
424     return dump_cfg_file_name_;
425   }
426 
GetTimingsLogger()427   CumulativeLogger* GetTimingsLogger() const {
428     return timings_logger_;
429   }
430 
SetDedupeEnabled(bool dedupe_enabled)431   void SetDedupeEnabled(bool dedupe_enabled) {
432     dedupe_enabled_ = dedupe_enabled;
433   }
DedupeEnabled()434   bool DedupeEnabled() const {
435     return dedupe_enabled_;
436   }
437 
438   // Checks if class specified by type_idx is one of the image_classes_
439   bool IsImageClass(const char* descriptor) const;
440 
441   // Checks whether the provided class should be compiled, i.e., is in classes_to_compile_.
442   bool IsClassToCompile(const char* descriptor) const;
443 
444   // Checks whether the provided method should be compiled, i.e., is in method_to_compile_.
445   bool IsMethodToCompile(const MethodReference& method_ref) const;
446 
447   void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
448       LOCKS_EXCLUDED(compiled_classes_lock_);
449 
450   // Checks if the specified method has been verified without failures. Returns
451   // false if the method is not in the verification results (GetVerificationResults).
452   bool IsMethodVerifiedWithoutFailures(uint32_t method_idx,
453                                        uint16_t class_def_idx,
454                                        const DexFile& dex_file) const;
455 
456   SwapVector<uint8_t>* DeduplicateCode(const ArrayRef<const uint8_t>& code);
457   SwapSrcMap* DeduplicateSrcMappingTable(const ArrayRef<SrcMapElem>& src_map);
458   SwapVector<uint8_t>* DeduplicateMappingTable(const ArrayRef<const uint8_t>& code);
459   SwapVector<uint8_t>* DeduplicateVMapTable(const ArrayRef<const uint8_t>& code);
460   SwapVector<uint8_t>* DeduplicateGCMap(const ArrayRef<const uint8_t>& code);
461   SwapVector<uint8_t>* DeduplicateCFIInfo(const ArrayRef<const uint8_t>& cfi_info);
462 
463   // Should the compiler run on this method given profile information?
464   bool SkipCompilation(const std::string& method_name);
465 
466   // Get memory usage during compilation.
467   std::string GetMemoryUsageString(bool extended) const;
468 
469   bool IsStringTypeIndex(uint16_t type_index, const DexFile* dex_file);
470   bool IsStringInit(uint32_t method_index, const DexFile* dex_file, int32_t* offset);
471 
SetHadHardVerifierFailure()472   void SetHadHardVerifierFailure() {
473     had_hard_verifier_failure_ = true;
474   }
475 
476  private:
477   // Return whether the declaring class of `resolved_member` is
478   // available to `referrer_class` for read or write access using two
479   // Boolean values returned as a pair. If is true at least for read
480   // access, compute the type index of the declaring class in the
481   // referrer's dex file and return it through the out argument
482   // `storage_index`; otherwise return DexFile::kDexNoIndex through
483   // `storage_index`.
484   template <typename ArtMember>
485   std::pair<bool, bool> IsClassOfStaticMemberAvailableToReferrer(mirror::DexCache* dex_cache,
486                                                                  mirror::Class* referrer_class,
487                                                                  ArtMember* resolved_member,
488                                                                  uint16_t member_idx,
489                                                                  uint32_t* storage_index)
490       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
491 
492   // Can `referrer_class` access the resolved `member`?
493   // Dispatch call to mirror::Class::CanAccessResolvedField or
494   // mirror::Class::CanAccessResolvedMember depending on the value of
495   // ArtMember.
496   template <typename ArtMember>
497   static bool CanAccessResolvedMember(mirror::Class* referrer_class,
498                                       mirror::Class* access_to,
499                                       ArtMember* member,
500                                       mirror::DexCache* dex_cache,
501                                       uint32_t field_idx)
502       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
503 
504   // Can we assume that the klass is initialized?
505   bool CanAssumeClassIsInitialized(mirror::Class* klass)
506       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
507   bool CanReferrerAssumeClassIsInitialized(mirror::Class* referrer_class, mirror::Class* klass)
508       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
509 
510   // Can we assume that the klass is loaded?
511   bool CanAssumeClassIsLoaded(mirror::Class* klass)
512       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
513 
514   // These flags are internal to CompilerDriver for collecting INVOKE resolution statistics.
515   // The only external contract is that unresolved method has flags 0 and resolved non-0.
516   enum {
517     kBitMethodResolved = 0,
518     kBitVirtualMadeDirect,
519     kBitPreciseTypeDevirtualization,
520     kBitDirectCallToBoot,
521     kBitDirectMethodToBoot
522   };
523   static constexpr int kFlagMethodResolved              = 1 << kBitMethodResolved;
524   static constexpr int kFlagVirtualMadeDirect           = 1 << kBitVirtualMadeDirect;
525   static constexpr int kFlagPreciseTypeDevirtualization = 1 << kBitPreciseTypeDevirtualization;
526   static constexpr int kFlagDirectCallToBoot            = 1 << kBitDirectCallToBoot;
527   static constexpr int kFlagDirectMethodToBoot          = 1 << kBitDirectMethodToBoot;
528   static constexpr int kFlagsMethodResolvedVirtualMadeDirect =
529       kFlagMethodResolved | kFlagVirtualMadeDirect;
530   static constexpr int kFlagsMethodResolvedPreciseTypeDevirtualization =
531       kFlagsMethodResolvedVirtualMadeDirect | kFlagPreciseTypeDevirtualization;
532 
533  public:  // TODO make private or eliminate.
534   // Compute constant code and method pointers when possible.
535   void GetCodeAndMethodForDirectCall(/*out*/InvokeType* type,
536                                      InvokeType sharp_type,
537                                      bool no_guarantee_of_dex_cache_entry,
538                                      const mirror::Class* referrer_class,
539                                      ArtMethod* method,
540                                      /*out*/int* stats_flags,
541                                      MethodReference* target_method,
542                                      uintptr_t* direct_code, uintptr_t* direct_method)
543       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
544 
545  private:
546   DexToDexCompilationLevel GetDexToDexCompilationlevel(
547       Thread* self, Handle<mirror::ClassLoader> class_loader, const DexFile& dex_file,
548       const DexFile::ClassDef& class_def) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
549 
550   void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
551                   ThreadPool* thread_pool, TimingLogger* timings)
552       LOCKS_EXCLUDED(Locks::mutator_lock_);
553 
554   void LoadImageClasses(TimingLogger* timings);
555 
556   // Attempt to resolve all type, methods, fields, and strings
557   // referenced from code in the dex file following PathClassLoader
558   // ordering semantics.
559   void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
560                ThreadPool* thread_pool, TimingLogger* timings)
561       LOCKS_EXCLUDED(Locks::mutator_lock_);
562   void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
563                       const std::vector<const DexFile*>& dex_files,
564                       ThreadPool* thread_pool, TimingLogger* timings)
565       LOCKS_EXCLUDED(Locks::mutator_lock_);
566 
567   void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
568               ThreadPool* thread_pool, TimingLogger* timings);
569   void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
570                      const std::vector<const DexFile*>& dex_files,
571                      ThreadPool* thread_pool, TimingLogger* timings)
572       LOCKS_EXCLUDED(Locks::mutator_lock_);
573 
574   void SetVerified(jobject class_loader, const std::vector<const DexFile*>& dex_files,
575                    ThreadPool* thread_pool, TimingLogger* timings);
576   void SetVerifiedDexFile(jobject class_loader, const DexFile& dex_file,
577                           const std::vector<const DexFile*>& dex_files,
578                           ThreadPool* thread_pool, TimingLogger* timings)
579       LOCKS_EXCLUDED(Locks::mutator_lock_);
580 
581   void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
582                          ThreadPool* thread_pool, TimingLogger* timings)
583       LOCKS_EXCLUDED(Locks::mutator_lock_);
584   void InitializeClasses(jobject class_loader, const DexFile& dex_file,
585                          const std::vector<const DexFile*>& dex_files,
586                          ThreadPool* thread_pool, TimingLogger* timings)
587       LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
588 
589   void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_);
590   static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
591       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
592 
593   void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
594                ThreadPool* thread_pool, TimingLogger* timings);
595   void CompileDexFile(jobject class_loader, const DexFile& dex_file,
596                       const std::vector<const DexFile*>& dex_files,
597                       ThreadPool* thread_pool, TimingLogger* timings)
598       LOCKS_EXCLUDED(Locks::mutator_lock_);
599   void CompileMethod(Thread* self, const DexFile::CodeItem* code_item, uint32_t access_flags,
600                      InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx,
601                      jobject class_loader, const DexFile& dex_file,
602                      DexToDexCompilationLevel dex_to_dex_compilation_level,
603                      bool compilation_enabled)
604       LOCKS_EXCLUDED(compiled_methods_lock_);
605 
606   static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
607       LOCKS_EXCLUDED(Locks::mutator_lock_);
608 
609   // Swap pool and allocator used for native allocations. May be file-backed. Needs to be first
610   // as other fields rely on this.
611   std::unique_ptr<SwapSpace> swap_space_;
612   std::unique_ptr<SwapAllocator<void> > swap_space_allocator_;
613 
614   ProfileFile profile_file_;
615   bool profile_present_;
616 
617   const CompilerOptions* const compiler_options_;
618   VerificationResults* const verification_results_;
619   DexFileToMethodInlinerMap* const method_inliner_map_;
620 
621   std::unique_ptr<Compiler> compiler_;
622   Compiler::Kind compiler_kind_;
623 
624   const InstructionSet instruction_set_;
625   const InstructionSetFeatures* const instruction_set_features_;
626 
627   // All class references that require
628   mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
629   std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
630 
631   typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
632   // All class references that this compiler has compiled.
633   mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
634   ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
635 
636   typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable;
637   // All method references that this compiler has compiled.
638   mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
639   MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
640   // Number of non-relative patches in all compiled methods. These patches need space
641   // in the .oat_patches ELF section if requested in the compiler options.
642   size_t non_relative_linker_patch_count_ GUARDED_BY(compiled_methods_lock_);
643 
644   const bool image_;
645 
646   // If image_ is true, specifies the classes that will be included in
647   // the image. Note if image_classes_ is null, all classes are
648   // included in the image.
649   std::unique_ptr<std::unordered_set<std::string>> image_classes_;
650 
651   // Specifies the classes that will be compiled. Note that if classes_to_compile_ is null,
652   // all classes are eligible for compilation (duplication filters etc. will still apply).
653   // This option may be restricted to the boot image, depending on a flag in the implementation.
654   std::unique_ptr<std::unordered_set<std::string>> classes_to_compile_;
655 
656   // Specifies the methods that will be compiled. Note that if methods_to_compile_ is null,
657   // all methods are eligible for compilation (compilation filters etc. will still apply).
658   // This option may be restricted to the boot image, depending on a flag in the implementation.
659   std::unique_ptr<std::unordered_set<std::string>> methods_to_compile_;
660 
661   bool had_hard_verifier_failure_;
662 
663   size_t thread_count_;
664 
665   class AOTCompilationStats;
666   std::unique_ptr<AOTCompilationStats> stats_;
667 
668   bool dedupe_enabled_;
669   bool dump_stats_;
670   const bool dump_passes_;
671   const std::string& dump_cfg_file_name_;
672 
673   CumulativeLogger* const timings_logger_;
674 
675   typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
676   typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
677 
678   typedef void (*DexToDexCompilerFn)(CompilerDriver& driver,
679                                      const DexFile::CodeItem* code_item,
680                                      uint32_t access_flags, InvokeType invoke_type,
681                                      uint32_t class_dex_idx, uint32_t method_idx,
682                                      jobject class_loader, const DexFile& dex_file,
683                                      DexToDexCompilationLevel dex_to_dex_compilation_level);
684   DexToDexCompilerFn dex_to_dex_compiler_;
685 
686   void* compiler_context_;
687 
688   bool support_boot_image_fixup_;
689 
690   // DeDuplication data structures, these own the corresponding byte arrays.
691   template <typename ContentType>
692   class DedupeHashFunc {
693    public:
operator()694     size_t operator()(const ArrayRef<ContentType>& array) const {
695       const uint8_t* data = reinterpret_cast<const uint8_t*>(array.data());
696       static_assert(IsPowerOfTwo(sizeof(ContentType)),
697           "ContentType is not power of two, don't know whether array layout is as assumed");
698       uint32_t len = sizeof(ContentType) * array.size();
699       if (kUseMurmur3Hash) {
700         static constexpr uint32_t c1 = 0xcc9e2d51;
701         static constexpr uint32_t c2 = 0x1b873593;
702         static constexpr uint32_t r1 = 15;
703         static constexpr uint32_t r2 = 13;
704         static constexpr uint32_t m = 5;
705         static constexpr uint32_t n = 0xe6546b64;
706 
707         uint32_t hash = 0;
708 
709         const int nblocks = len / 4;
710         typedef __attribute__((__aligned__(1))) uint32_t unaligned_uint32_t;
711         const unaligned_uint32_t *blocks = reinterpret_cast<const uint32_t*>(data);
712         int i;
713         for (i = 0; i < nblocks; i++) {
714           uint32_t k = blocks[i];
715           k *= c1;
716           k = (k << r1) | (k >> (32 - r1));
717           k *= c2;
718 
719           hash ^= k;
720           hash = ((hash << r2) | (hash >> (32 - r2))) * m + n;
721         }
722 
723         const uint8_t *tail = reinterpret_cast<const uint8_t*>(data + nblocks * 4);
724         uint32_t k1 = 0;
725 
726         switch (len & 3) {
727           case 3:
728             k1 ^= tail[2] << 16;
729             FALLTHROUGH_INTENDED;
730           case 2:
731             k1 ^= tail[1] << 8;
732             FALLTHROUGH_INTENDED;
733           case 1:
734             k1 ^= tail[0];
735 
736             k1 *= c1;
737             k1 = (k1 << r1) | (k1 >> (32 - r1));
738             k1 *= c2;
739             hash ^= k1;
740         }
741 
742         hash ^= len;
743         hash ^= (hash >> 16);
744         hash *= 0x85ebca6b;
745         hash ^= (hash >> 13);
746         hash *= 0xc2b2ae35;
747         hash ^= (hash >> 16);
748 
749         return hash;
750       } else {
751         size_t hash = 0x811c9dc5;
752         for (uint32_t i = 0; i < len; ++i) {
753           hash = (hash * 16777619) ^ data[i];
754         }
755         hash += hash << 13;
756         hash ^= hash >> 7;
757         hash += hash << 3;
758         hash ^= hash >> 17;
759         hash += hash << 5;
760         return hash;
761       }
762     }
763   };
764 
765   DedupeSet<ArrayRef<const uint8_t>,
766             SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_code_;
767   DedupeSet<ArrayRef<SrcMapElem>,
768             SwapSrcMap, size_t, DedupeHashFunc<SrcMapElem>, 4> dedupe_src_mapping_table_;
769   DedupeSet<ArrayRef<const uint8_t>,
770             SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_mapping_table_;
771   DedupeSet<ArrayRef<const uint8_t>,
772             SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_vmap_table_;
773   DedupeSet<ArrayRef<const uint8_t>,
774             SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_gc_map_;
775   DedupeSet<ArrayRef<const uint8_t>,
776             SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_cfi_info_;
777 
778   DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
779 };
780 
781 }  // namespace art
782 
783 #endif  // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
784