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