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