compiler_driver.h revision be0e546730e532ef0987cd4bde2c6f5a1b14dd2a 
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 <vector>
23
24#include "base/mutex.h"
25#include "base/timing_logger.h"
26#include "class_reference.h"
27#include "compiled_class.h"
28#include "compiled_method.h"
29#include "compiler_backend.h"
30#include "dex_file.h"
31#include "instruction_set.h"
32#include "invoke_type.h"
33#include "method_reference.h"
34#include "os.h"
35#include "runtime.h"
36#include "safe_map.h"
37#include "thread_pool.h"
38#include "utils/arena_allocator.h"
39#include "utils/dedupe_set.h"
40
41namespace art {
42
43namespace verifier {
44class MethodVerifier;
45}  // namespace verifier
46
47class AOTCompilationStats;
48class CompilerOptions;
49class DexCompilationUnit;
50class DexFileToMethodInlinerMap;
51struct InlineIGetIPutData;
52class OatWriter;
53class ParallelCompilationManager;
54class ScopedObjectAccess;
55class TimingLogger;
56class VerificationResults;
57class VerifiedMethod;
58
59enum EntryPointCallingConvention {
60  // ABI of invocations to a method's interpreter entry point.
61  kInterpreterAbi,
62  // ABI of calls to a method's native code, only used for native methods.
63  kJniAbi,
64  // ABI of calls to a method's portable code entry point.
65  kPortableAbi,
66  // ABI of calls to a method's quick code entry point.
67  kQuickAbi
68};
69
70enum DexToDexCompilationLevel {
71  kDontDexToDexCompile,   // Only meaning wrt image time interpretation.
72  kRequired,              // Dex-to-dex compilation required for correctness.
73  kOptimize               // Perform required transformation and peep-hole optimizations.
74};
75
76// Thread-local storage compiler worker threads
77class CompilerTls {
78  public:
79    CompilerTls() : llvm_info_(NULL) {}
80    ~CompilerTls() {}
81
82    void* GetLLVMInfo() { return llvm_info_; }
83
84    void SetLLVMInfo(void* llvm_info) { llvm_info_ = llvm_info; }
85
86  private:
87    void* llvm_info_;
88};
89
90class CompilerDriver {
91 public:
92  typedef std::set<std::string> DescriptorSet;
93
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                          CompilerBackend::Kind compiler_backend_kind,
103                          InstructionSet instruction_set,
104                          InstructionSetFeatures instruction_set_features,
105                          bool image, DescriptorSet* image_classes,
106                          size_t thread_count, bool dump_stats, bool dump_passes,
107                          CumulativeLogger* timer);
108
109  ~CompilerDriver();
110
111  void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
112                  TimingLogger* timings)
113      LOCKS_EXCLUDED(Locks::mutator_lock_);
114
115  // Compile a single Method.
116  void CompileOne(mirror::ArtMethod* method, TimingLogger* timings)
117      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
118
119  VerificationResults* GetVerificationResults() const {
120    return verification_results_;
121  }
122
123  DexFileToMethodInlinerMap* GetMethodInlinerMap() const {
124    return method_inliner_map_;
125  }
126
127  InstructionSet GetInstructionSet() const {
128    return instruction_set_;
129  }
130
131  InstructionSetFeatures GetInstructionSetFeatures() const {
132    return instruction_set_features_;
133  }
134
135  const CompilerOptions& GetCompilerOptions() const {
136    return *compiler_options_;
137  }
138
139  CompilerBackend* GetCompilerBackend() const {
140    return compiler_backend_.get();
141  }
142
143  // Are we compiling and creating an image file?
144  bool IsImage() const {
145    return image_;
146  }
147
148  DescriptorSet* GetImageClasses() const {
149    return image_classes_.get();
150  }
151
152  CompilerTls* GetTls();
153
154  // Generate the trampolines that are invoked by unresolved direct methods.
155  const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const
156      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
157  const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const
158      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
159  const std::vector<uint8_t>* CreateJniDlsymLookup() const
160      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
161  const std::vector<uint8_t>* CreatePortableImtConflictTrampoline() const
162      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
163  const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const
164      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
165  const std::vector<uint8_t>* CreatePortableToInterpreterBridge() const
166      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
167  const std::vector<uint8_t>* CreateQuickImtConflictTrampoline() const
168      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
169  const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
170      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
171  const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const
172      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
173
174  CompiledClass* GetCompiledClass(ClassReference ref) const
175      LOCKS_EXCLUDED(compiled_classes_lock_);
176
177  CompiledMethod* GetCompiledMethod(MethodReference ref) const
178      LOCKS_EXCLUDED(compiled_methods_lock_);
179
180  void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
181                                     uint16_t class_def_index);
182  bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index);
183
184  // Callbacks from compiler to see what runtime checks must be generated.
185
186  bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx);
187
188  bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
189      LOCKS_EXCLUDED(Locks::mutator_lock_);
190
191  // Are runtime access checks necessary in the compiled code?
192  bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
193                                  uint32_t type_idx, bool* type_known_final = NULL,
194                                  bool* type_known_abstract = NULL,
195                                  bool* equals_referrers_class = NULL)
196      LOCKS_EXCLUDED(Locks::mutator_lock_);
197
198  // Are runtime access and instantiable checks necessary in the code?
199  bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
200                                              uint32_t type_idx)
201     LOCKS_EXCLUDED(Locks::mutator_lock_);
202
203  bool CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx,
204                          bool* is_type_initialized, bool* use_direct_type_ptr,
205                          uintptr_t* direct_type_ptr);
206
207  // Get the DexCache for the
208  mirror::DexCache* GetDexCache(const DexCompilationUnit* mUnit)
209    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
210
211  mirror::ClassLoader* GetClassLoader(ScopedObjectAccess& soa, const DexCompilationUnit* mUnit)
212    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
213
214  // Resolve compiling method's class. Returns nullptr on failure.
215  mirror::Class* ResolveCompilingMethodsClass(
216      ScopedObjectAccess& soa, const SirtRef<mirror::DexCache>& dex_cache,
217      const SirtRef<mirror::ClassLoader>& class_loader, const DexCompilationUnit* mUnit)
218    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
219
220  // Resolve a field. Returns nullptr on failure, including incompatible class change.
221  // NOTE: Unlike ClassLinker's ResolveField(), this method enforces is_static.
222  mirror::ArtField* ResolveField(
223      ScopedObjectAccess& soa, const SirtRef<mirror::DexCache>& dex_cache,
224      const SirtRef<mirror::ClassLoader>& class_loader, const DexCompilationUnit* mUnit,
225      uint32_t field_idx, bool is_static)
226    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
227
228  // Get declaration location of a resolved field.
229  void GetResolvedFieldDexFileLocation(
230      mirror::ArtField* resolved_field, const DexFile** declaring_dex_file,
231      uint16_t* declaring_class_idx, uint16_t* declaring_field_idx)
232    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
233
234  bool IsFieldVolatile(mirror::ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
235
236  // Can we fast-path an IGET/IPUT access to an instance field? If yes, compute the field offset.
237  std::pair<bool, bool> IsFastInstanceField(
238      mirror::DexCache* dex_cache, mirror::Class* referrer_class,
239      mirror::ArtField* resolved_field, uint16_t field_idx, MemberOffset* field_offset)
240    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
241
242  // Can we fast-path an SGET/SPUT access to a static field? If yes, compute the field offset,
243  // the type index of the declaring class in the referrer's dex file and whether the declaring
244  // class is the referrer's class or at least can be assumed to be initialized.
245  std::pair<bool, bool> IsFastStaticField(
246      mirror::DexCache* dex_cache, mirror::Class* referrer_class,
247      mirror::ArtField* resolved_field, uint16_t field_idx, MemberOffset* field_offset,
248      uint32_t* storage_index, bool* is_referrers_class, bool* is_initialized)
249    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
250
251  void ProcessedInstanceField(bool resolved);
252  void ProcessedStaticField(bool resolved, bool local);
253
254  // Can we fast path instance field access in a verified accessor?
255  // If yes, computes field's offset and volatility and whether the method is static or not.
256  static bool ComputeSpecialAccessorInfo(uint32_t field_idx, bool is_put,
257                                         verifier::MethodVerifier* verifier,
258                                         InlineIGetIPutData* result)
259      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
260
261  // Can we fast path instance field access? Computes field's offset and volatility.
262  bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
263                                MemberOffset* field_offset, bool* is_volatile)
264      LOCKS_EXCLUDED(Locks::mutator_lock_);
265
266  // Can we fastpath static field access? Computes field's offset, volatility and whether the
267  // field is within the referrer (which can avoid checking class initialization).
268  bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put,
269                              MemberOffset* field_offset, uint32_t* storage_index,
270                              bool* is_referrers_class, bool* is_volatile, bool* is_initialized)
271      LOCKS_EXCLUDED(Locks::mutator_lock_);
272
273  // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
274  // index.
275  bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
276                         bool update_stats, bool enable_devirtualization,
277                         InvokeType* type, MethodReference* target_method, int* vtable_idx,
278                         uintptr_t* direct_code, uintptr_t* direct_method)
279      LOCKS_EXCLUDED(Locks::mutator_lock_);
280
281  const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const;
282  bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc);
283
284  // Record patch information for later fix up.
285  void AddCodePatch(const DexFile* dex_file,
286                    uint16_t referrer_class_def_idx,
287                    uint32_t referrer_method_idx,
288                    InvokeType referrer_invoke_type,
289                    uint32_t target_method_idx,
290                    InvokeType target_invoke_type,
291                    size_t literal_offset)
292      LOCKS_EXCLUDED(compiled_methods_lock_);
293  void AddRelativeCodePatch(const DexFile* dex_file,
294                            uint16_t referrer_class_def_idx,
295                            uint32_t referrer_method_idx,
296                            InvokeType referrer_invoke_type,
297                            uint32_t target_method_idx,
298                            InvokeType target_invoke_type,
299                            size_t literal_offset,
300                            int32_t pc_relative_offset)
301      LOCKS_EXCLUDED(compiled_methods_lock_);
302  void AddMethodPatch(const DexFile* dex_file,
303                      uint16_t referrer_class_def_idx,
304                      uint32_t referrer_method_idx,
305                      InvokeType referrer_invoke_type,
306                      uint32_t target_method_idx,
307                      InvokeType target_invoke_type,
308                      size_t literal_offset)
309      LOCKS_EXCLUDED(compiled_methods_lock_);
310  void AddClassPatch(const DexFile* dex_file,
311                     uint16_t referrer_class_def_idx,
312                     uint32_t referrer_method_idx,
313                     uint32_t target_method_idx,
314                     size_t literal_offset)
315      LOCKS_EXCLUDED(compiled_methods_lock_);
316
317  bool GetSupportBootImageFixup() const {
318    return support_boot_image_fixup_;
319  }
320
321  void SetSupportBootImageFixup(bool support_boot_image_fixup) {
322    support_boot_image_fixup_ = support_boot_image_fixup;
323  }
324
325  ArenaPool* GetArenaPool() {
326    return &arena_pool_;
327  }
328
329  bool WriteElf(const std::string& android_root,
330                bool is_host,
331                const std::vector<const DexFile*>& dex_files,
332                OatWriter* oat_writer,
333                File* file);
334
335  // TODO: move to a common home for llvm helpers once quick/portable are merged.
336  static void InstructionSetToLLVMTarget(InstructionSet instruction_set,
337                                         std::string* target_triple,
338                                         std::string* target_cpu,
339                                         std::string* target_attr);
340
341  void SetCompilerContext(void* compiler_context) {
342    compiler_context_ = compiler_context;
343  }
344
345  void* GetCompilerContext() const {
346    return compiler_context_;
347  }
348
349  size_t GetThreadCount() const {
350    return thread_count_;
351  }
352
353  class CallPatchInformation;
354  class TypePatchInformation;
355
356  bool GetDumpPasses() const {
357    return dump_passes_;
358  }
359
360  CumulativeLogger* GetTimingsLogger() const {
361    return timings_logger_;
362  }
363
364  class PatchInformation {
365   public:
366    const DexFile& GetDexFile() const {
367      return *dex_file_;
368    }
369    uint16_t GetReferrerClassDefIdx() const {
370      return referrer_class_def_idx_;
371    }
372    uint32_t GetReferrerMethodIdx() const {
373      return referrer_method_idx_;
374    }
375    size_t GetLiteralOffset() const {
376      return literal_offset_;
377    }
378
379    virtual bool IsCall() const {
380      return false;
381    }
382    virtual bool IsType() const {
383      return false;
384    }
385    virtual const CallPatchInformation* AsCall() const {
386      LOG(FATAL) << "Unreachable";
387      return nullptr;
388    }
389    virtual const TypePatchInformation* AsType() const {
390      LOG(FATAL) << "Unreachable";
391      return nullptr;
392    }
393
394   protected:
395    PatchInformation(const DexFile* dex_file,
396                     uint16_t referrer_class_def_idx,
397                     uint32_t referrer_method_idx,
398                     size_t literal_offset)
399      : dex_file_(dex_file),
400        referrer_class_def_idx_(referrer_class_def_idx),
401        referrer_method_idx_(referrer_method_idx),
402        literal_offset_(literal_offset) {
403      CHECK(dex_file_ != NULL);
404    }
405    virtual ~PatchInformation() {}
406
407    const DexFile* const dex_file_;
408    const uint16_t referrer_class_def_idx_;
409    const uint32_t referrer_method_idx_;
410    const size_t literal_offset_;
411
412    friend class CompilerDriver;
413  };
414
415  class CallPatchInformation : public PatchInformation {
416   public:
417    InvokeType GetReferrerInvokeType() const {
418      return referrer_invoke_type_;
419    }
420    uint32_t GetTargetMethodIdx() const {
421      return target_method_idx_;
422    }
423    InvokeType GetTargetInvokeType() const {
424      return target_invoke_type_;
425    }
426
427    const CallPatchInformation* AsCall() const {
428      return this;
429    }
430    bool IsCall() const {
431      return true;
432    }
433    virtual bool IsRelative() const {
434      return false;
435    }
436    virtual int RelativeOffset() const {
437      return 0;
438    }
439
440   protected:
441    CallPatchInformation(const DexFile* dex_file,
442                         uint16_t referrer_class_def_idx,
443                         uint32_t referrer_method_idx,
444                         InvokeType referrer_invoke_type,
445                         uint32_t target_method_idx,
446                         InvokeType target_invoke_type,
447                         size_t literal_offset)
448        : PatchInformation(dex_file, referrer_class_def_idx,
449                           referrer_method_idx, literal_offset),
450          referrer_invoke_type_(referrer_invoke_type),
451          target_method_idx_(target_method_idx),
452          target_invoke_type_(target_invoke_type) {
453    }
454
455   private:
456    const InvokeType referrer_invoke_type_;
457    const uint32_t target_method_idx_;
458    const InvokeType target_invoke_type_;
459
460    friend class CompilerDriver;
461    DISALLOW_COPY_AND_ASSIGN(CallPatchInformation);
462  };
463
464  class RelativeCallPatchInformation : public CallPatchInformation {
465   public:
466    bool IsRelative() const {
467      return true;
468    }
469    int RelativeOffset() const {
470      return offset_;
471    }
472
473   private:
474    RelativeCallPatchInformation(const DexFile* dex_file,
475                                 uint16_t referrer_class_def_idx,
476                                 uint32_t referrer_method_idx,
477                                 InvokeType referrer_invoke_type,
478                                 uint32_t target_method_idx,
479                                 InvokeType target_invoke_type,
480                                 size_t literal_offset,
481                                 int32_t pc_relative_offset)
482        : CallPatchInformation(dex_file, referrer_class_def_idx,
483                           referrer_method_idx, referrer_invoke_type,
484                           target_method_idx, target_invoke_type, literal_offset),
485          offset_(pc_relative_offset) {
486    }
487
488    const int offset_;
489
490    friend class CompilerDriver;
491    DISALLOW_COPY_AND_ASSIGN(RelativeCallPatchInformation);
492  };
493
494  class TypePatchInformation : public PatchInformation {
495   public:
496    uint32_t GetTargetTypeIdx() const {
497      return target_type_idx_;
498    }
499
500    bool IsType() const {
501      return true;
502    }
503    const TypePatchInformation* AsType() const {
504      return this;
505    }
506
507   private:
508    TypePatchInformation(const DexFile* dex_file,
509                         uint16_t referrer_class_def_idx,
510                         uint32_t referrer_method_idx,
511                         uint32_t target_type_idx,
512                         size_t literal_offset)
513        : PatchInformation(dex_file, referrer_class_def_idx,
514                           referrer_method_idx, literal_offset),
515          target_type_idx_(target_type_idx) {
516    }
517
518    const uint32_t target_type_idx_;
519
520    friend class CompilerDriver;
521    DISALLOW_COPY_AND_ASSIGN(TypePatchInformation);
522  };
523
524  const std::vector<const CallPatchInformation*>& GetCodeToPatch() const {
525    return code_to_patch_;
526  }
527  const std::vector<const CallPatchInformation*>& GetMethodsToPatch() const {
528    return methods_to_patch_;
529  }
530  const std::vector<const TypePatchInformation*>& GetClassesToPatch() const {
531    return classes_to_patch_;
532  }
533
534  // Checks if class specified by type_idx is one of the image_classes_
535  bool IsImageClass(const char* descriptor) const;
536
537  void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
538      LOCKS_EXCLUDED(compiled_classes_lock_);
539
540  std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code);
541  std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code);
542  std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code);
543  std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code);
544  std::vector<uint8_t>* DeduplicateCFIInfo(const std::vector<uint8_t>* cfi_info);
545
546  /*
547   * @brief return the pointer to the Call Frame Information.
548   * @return pointer to call frame information for this compilation.
549   */
550  std::vector<uint8_t>* GetCallFrameInformation() const {
551    return cfi_info_.get();
552  }
553
554 private:
555  // Compute constant code and method pointers when possible
556  void GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type,
557                                     bool no_guarantee_of_dex_cache_entry,
558                                     mirror::Class* referrer_class,
559                                     mirror::ArtMethod* method,
560                                     bool update_stats,
561                                     MethodReference* target_method,
562                                     uintptr_t* direct_code, uintptr_t* direct_method)
563      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
564
565  void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
566                  ThreadPool* thread_pool, TimingLogger* timings)
567      LOCKS_EXCLUDED(Locks::mutator_lock_);
568
569  void LoadImageClasses(TimingLogger* timings);
570
571  // Attempt to resolve all type, methods, fields, and strings
572  // referenced from code in the dex file following PathClassLoader
573  // ordering semantics.
574  void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
575               ThreadPool* thread_pool, TimingLogger* timings)
576      LOCKS_EXCLUDED(Locks::mutator_lock_);
577  void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
578                      ThreadPool* thread_pool, TimingLogger* timings)
579      LOCKS_EXCLUDED(Locks::mutator_lock_);
580
581  void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
582              ThreadPool* thread_pool, TimingLogger* timings);
583  void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
584                     ThreadPool* thread_pool, TimingLogger* timings)
585      LOCKS_EXCLUDED(Locks::mutator_lock_);
586
587  void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
588                         ThreadPool* thread_pool, TimingLogger* timings)
589      LOCKS_EXCLUDED(Locks::mutator_lock_);
590  void InitializeClasses(jobject class_loader, const DexFile& dex_file,
591                         ThreadPool* thread_pool, TimingLogger* timings)
592      LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
593
594  void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_);
595  static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
596      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
597
598  void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
599               ThreadPool* thread_pool, TimingLogger* timings);
600  void CompileDexFile(jobject class_loader, const DexFile& dex_file,
601                      ThreadPool* thread_pool, TimingLogger* timings)
602      LOCKS_EXCLUDED(Locks::mutator_lock_);
603  void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
604                     InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx,
605                     jobject class_loader, const DexFile& dex_file,
606                     DexToDexCompilationLevel dex_to_dex_compilation_level)
607      LOCKS_EXCLUDED(compiled_methods_lock_);
608
609  static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
610      LOCKS_EXCLUDED(Locks::mutator_lock_);
611
612  std::vector<const CallPatchInformation*> code_to_patch_;
613  std::vector<const CallPatchInformation*> methods_to_patch_;
614  std::vector<const TypePatchInformation*> classes_to_patch_;
615
616  const CompilerOptions* const compiler_options_;
617  VerificationResults* const verification_results_;
618  DexFileToMethodInlinerMap* const method_inliner_map_;
619
620  UniquePtr<CompilerBackend> compiler_backend_;
621
622  const InstructionSet instruction_set_;
623  const InstructionSetFeatures instruction_set_features_;
624
625  // All class references that require
626  mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
627  std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
628
629  typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
630  // All class references that this compiler has compiled.
631  mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
632  ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
633
634  typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable;
635  // All method references that this compiler has compiled.
636  mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
637  MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
638
639  const bool image_;
640
641  // If image_ is true, specifies the classes that will be included in
642  // the image. Note if image_classes_ is NULL, all classes are
643  // included in the image.
644  UniquePtr<DescriptorSet> image_classes_;
645
646  size_t thread_count_;
647  uint64_t start_ns_;
648
649  UniquePtr<AOTCompilationStats> stats_;
650
651  bool dump_stats_;
652  const bool dump_passes_;
653
654  CumulativeLogger* const timings_logger_;
655
656  typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
657  typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
658
659  void* compiler_library_;
660
661  typedef void (*DexToDexCompilerFn)(CompilerDriver& driver,
662                                     const DexFile::CodeItem* code_item,
663                                     uint32_t access_flags, InvokeType invoke_type,
664                                     uint32_t class_dex_idx, uint32_t method_idx,
665                                     jobject class_loader, const DexFile& dex_file,
666                                     DexToDexCompilationLevel dex_to_dex_compilation_level);
667  DexToDexCompilerFn dex_to_dex_compiler_;
668
669  void* compiler_context_;
670
671  pthread_key_t tls_key_;
672
673  // Arena pool used by the compiler.
674  ArenaPool arena_pool_;
675
676  typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver);
677  CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
678
679  typedef const void* (*CompilerGetMethodCodeAddrFn)
680      (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method);
681  CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
682
683  bool support_boot_image_fixup_;
684
685  // Call Frame Information, which might be generated to help stack tracebacks.
686  UniquePtr<std::vector<uint8_t> > cfi_info_;
687
688  // DeDuplication data structures, these own the corresponding byte arrays.
689  class DedupeHashFunc {
690   public:
691    size_t operator()(const std::vector<uint8_t>& array) const {
692      // For small arrays compute a hash using every byte.
693      static const size_t kSmallArrayThreshold = 16;
694      size_t hash = 0x811c9dc5;
695      if (array.size() <= kSmallArrayThreshold) {
696        for (uint8_t b : array) {
697          hash = (hash * 16777619) ^ b;
698        }
699      } else {
700        // For larger arrays use the 2 bytes at 6 bytes (the location of a push registers
701        // instruction field for quick generated code on ARM) and then select a number of other
702        // values at random.
703        static const size_t kRandomHashCount = 16;
704        for (size_t i = 0; i < 2; ++i) {
705          uint8_t b = array[i + 6];
706          hash = (hash * 16777619) ^ b;
707        }
708        for (size_t i = 2; i < kRandomHashCount; ++i) {
709          size_t r = i * 1103515245 + 12345;
710          uint8_t b = array[r % array.size()];
711          hash = (hash * 16777619) ^ b;
712        }
713      }
714      hash += hash << 13;
715      hash ^= hash >> 7;
716      hash += hash << 3;
717      hash ^= hash >> 17;
718      hash += hash << 5;
719      return hash;
720    }
721  };
722  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_code_;
723  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_mapping_table_;
724  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_vmap_table_;
725  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_gc_map_;
726  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_cfi_info_;
727
728  DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
729};
730
731}  // namespace art
732
733#endif  // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
734