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