compiler_driver.h revision d133b97b1ccae88f6ee7040e288fd7a239ee4492 
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 "class_reference.h"
26#include "compiled_class.h"
27#include "compiled_method.h"
28#include "dex_file.h"
29#include "dex/arena_allocator.h"
30#include "instruction_set.h"
31#include "invoke_type.h"
32#include "method_reference.h"
33#include "os.h"
34#include "runtime.h"
35#include "safe_map.h"
36#include "thread_pool.h"
37#include "utils/dedupe_set.h"
38
39namespace art {
40
41class AOTCompilationStats;
42class ParallelCompilationManager;
43class DexCompilationUnit;
44class OatWriter;
45class TimingLogger;
46
47enum CompilerBackend {
48  kQuick,
49  kPortable,
50  kNoBackend
51};
52
53enum EntryPointCallingConvention {
54  // ABI of invocations to a method's interpreter entry point.
55  kInterpreterAbi,
56  // ABI of calls to a method's native code, only used for native methods.
57  kJniAbi,
58  // ABI of calls to a method's portable code entry point.
59  kPortableAbi,
60  // ABI of calls to a method's quick code entry point.
61  kQuickAbi
62};
63
64enum DexToDexCompilationLevel {
65  kDontDexToDexCompile,   // Only meaning wrt image time interpretation.
66  kRequired,              // Dex-to-dex compilation required for correctness.
67  kOptimize               // Perform required transformation and peep-hole optimizations.
68};
69
70// Thread-local storage compiler worker threads
71class CompilerTls {
72  public:
73    CompilerTls() : llvm_info_(NULL) {}
74    ~CompilerTls() {}
75
76    void* GetLLVMInfo() { return llvm_info_; }
77
78    void SetLLVMInfo(void* llvm_info) { llvm_info_ = llvm_info; }
79
80  private:
81    void* llvm_info_;
82};
83
84class CompilerDriver {
85 public:
86  typedef std::set<std::string> DescriptorSet;
87
88  // Create a compiler targeting the requested "instruction_set".
89  // "image" should be true if image specific optimizations should be
90  // enabled.  "image_classes" lets the compiler know what classes it
91  // can assume will be in the image, with NULL implying all available
92  // classes.
93  explicit CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
94                          bool image, DescriptorSet* image_classes,
95                          size_t thread_count, bool dump_stats);
96
97  ~CompilerDriver();
98
99  void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
100                  base::TimingLogger& timings)
101      LOCKS_EXCLUDED(Locks::mutator_lock_);
102
103  // Compile a single Method
104  void CompileOne(const mirror::ArtMethod* method, base::TimingLogger& timings)
105      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
106
107  InstructionSet GetInstructionSet() const {
108    return instruction_set_;
109  }
110
111  CompilerBackend GetCompilerBackend() const {
112    return compiler_backend_;
113  }
114
115  // Are we compiling and creating an image file?
116  bool IsImage() const {
117    return image_;
118  }
119
120  DescriptorSet* GetImageClasses() const {
121    return image_classes_.get();
122  }
123
124  CompilerTls* GetTls();
125
126  // Generate the trampolines that are invoked by unresolved direct methods.
127  const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const
128      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
129  const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const
130      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
131  const std::vector<uint8_t>* CreateJniDlsymLookup() const
132      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
133  const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const
134      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
135  const std::vector<uint8_t>* CreatePortableToInterpreterBridge() const
136      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
137  const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
138      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
139  const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const
140      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
141
142  CompiledClass* GetCompiledClass(ClassReference ref) const
143      LOCKS_EXCLUDED(compiled_classes_lock_);
144
145  CompiledMethod* GetCompiledMethod(MethodReference ref) const
146      LOCKS_EXCLUDED(compiled_methods_lock_);
147
148  void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, size_t class_def_index);
149  bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, size_t class_def_index);
150
151  // Callbacks from compiler to see what runtime checks must be generated.
152
153  bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx)
154      LOCKS_EXCLUDED(Locks::mutator_lock_);
155
156  bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
157      LOCKS_EXCLUDED(Locks::mutator_lock_);
158
159  // Are runtime access checks necessary in the compiled code?
160  bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
161                                  uint32_t type_idx, bool* type_known_final = NULL,
162                                  bool* type_known_abstract = NULL,
163                                  bool* equals_referrers_class = NULL)
164      LOCKS_EXCLUDED(Locks::mutator_lock_);
165
166  // Are runtime access and instantiable checks necessary in the code?
167  bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
168                                              uint32_t type_idx)
169     LOCKS_EXCLUDED(Locks::mutator_lock_);
170
171  // Can we fast path instance field access? Computes field's offset and volatility.
172  bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
173                                int& field_offset, bool& is_volatile, bool is_put)
174      LOCKS_EXCLUDED(Locks::mutator_lock_);
175
176  // Can we fastpath static field access? Computes field's offset, volatility and whether the
177  // field is within the referrer (which can avoid checking class initialization).
178  bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
179                              int& field_offset, int& ssb_index,
180                              bool& is_referrers_class, bool& is_volatile, bool is_put)
181      LOCKS_EXCLUDED(Locks::mutator_lock_);
182
183  // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
184  // index.
185  bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
186                         InvokeType& type, MethodReference& target_method, int& vtable_idx,
187                         uintptr_t& direct_code, uintptr_t& direct_method, bool update_stats)
188      LOCKS_EXCLUDED(Locks::mutator_lock_);
189
190  bool IsSafeCast(const MethodReference& mr, uint32_t dex_pc);
191
192  // Record patch information for later fix up.
193  void AddCodePatch(const DexFile* dex_file,
194                    uint32_t referrer_method_idx,
195                    InvokeType referrer_invoke_type,
196                    uint32_t target_method_idx,
197                    InvokeType target_invoke_type,
198                    size_t literal_offset)
199      LOCKS_EXCLUDED(compiled_methods_lock_);
200  void AddMethodPatch(const DexFile* dex_file,
201                      uint32_t referrer_method_idx,
202                      InvokeType referrer_invoke_type,
203                      uint32_t target_method_idx,
204                      InvokeType target_invoke_type,
205                      size_t literal_offset)
206      LOCKS_EXCLUDED(compiled_methods_lock_);
207
208  void SetBitcodeFileName(std::string const& filename);
209
210  bool GetSupportBootImageFixup() const {
211    return support_boot_image_fixup_;
212  }
213
214  void SetSupportBootImageFixup(bool support_boot_image_fixup) {
215    support_boot_image_fixup_ = support_boot_image_fixup;
216  }
217
218  ArenaPool& GetArenaPool() {
219    return arena_pool_;
220  }
221
222  bool WriteElf(const std::string& android_root,
223                bool is_host,
224                const std::vector<const DexFile*>& dex_files,
225                OatWriter& oat_writer,
226                File* file);
227
228  // TODO: move to a common home for llvm helpers once quick/portable are merged
229  static void InstructionSetToLLVMTarget(InstructionSet instruction_set,
230                                         std::string& target_triple,
231                                         std::string& target_cpu,
232                                         std::string& target_attr);
233
234  void SetCompilerContext(void* compiler_context) {
235    compiler_context_ = compiler_context;
236  }
237
238  void* GetCompilerContext() const {
239    return compiler_context_;
240  }
241
242  size_t GetThreadCount() const {
243    return thread_count_;
244  }
245
246  class PatchInformation {
247   public:
248    const DexFile& GetDexFile() const {
249      return *dex_file_;
250    }
251    uint32_t GetReferrerMethodIdx() const {
252      return referrer_method_idx_;
253    }
254    InvokeType GetReferrerInvokeType() const {
255      return referrer_invoke_type_;
256    }
257    uint32_t GetTargetMethodIdx() const {
258      return target_method_idx_;
259    }
260    InvokeType GetTargetInvokeType() const {
261      return target_invoke_type_;
262    }
263    size_t GetLiteralOffset() const {;
264      return literal_offset_;
265    }
266
267   private:
268    PatchInformation(const DexFile* dex_file,
269                     uint32_t referrer_method_idx,
270                     InvokeType referrer_invoke_type,
271                     uint32_t target_method_idx,
272                     InvokeType target_invoke_type,
273                     size_t literal_offset)
274      : dex_file_(dex_file),
275        referrer_method_idx_(referrer_method_idx),
276        referrer_invoke_type_(referrer_invoke_type),
277        target_method_idx_(target_method_idx),
278        target_invoke_type_(target_invoke_type),
279        literal_offset_(literal_offset) {
280      CHECK(dex_file_ != NULL);
281    }
282
283    const DexFile* dex_file_;
284    uint32_t referrer_method_idx_;
285    InvokeType referrer_invoke_type_;
286    uint32_t target_method_idx_;
287    InvokeType target_invoke_type_;
288    size_t literal_offset_;
289
290    friend class CompilerDriver;
291    DISALLOW_COPY_AND_ASSIGN(PatchInformation);
292  };
293
294  const std::vector<const PatchInformation*>& GetCodeToPatch() const {
295    return code_to_patch_;
296  }
297  const std::vector<const PatchInformation*>& GetMethodsToPatch() const {
298    return methods_to_patch_;
299  }
300
301  // Checks if class specified by type_idx is one of the image_classes_
302  bool IsImageClass(const char* descriptor) const;
303
304  void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
305      LOCKS_EXCLUDED(compiled_classes_lock_);
306
307  std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code);
308  std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code);
309  std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code);
310  std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code);
311
312 private:
313  // Compute constant code and method pointers when possible
314  void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
315                                     mirror::Class* referrer_class,
316                                     mirror::ArtMethod* method,
317                                     uintptr_t& direct_code, uintptr_t& direct_method,
318                                     bool update_stats)
319      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
320
321  void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
322                  ThreadPool& thread_pool, base::TimingLogger& timings)
323      LOCKS_EXCLUDED(Locks::mutator_lock_);
324
325  void LoadImageClasses(base::TimingLogger& timings);
326
327  // Attempt to resolve all type, methods, fields, and strings
328  // referenced from code in the dex file following PathClassLoader
329  // ordering semantics.
330  void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
331               ThreadPool& thread_pool, base::TimingLogger& timings)
332      LOCKS_EXCLUDED(Locks::mutator_lock_);
333  void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
334                      ThreadPool& thread_pool, base::TimingLogger& timings)
335      LOCKS_EXCLUDED(Locks::mutator_lock_);
336
337  void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
338              ThreadPool& thread_pool, base::TimingLogger& timings);
339  void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
340                     ThreadPool& thread_pool, base::TimingLogger& timings)
341      LOCKS_EXCLUDED(Locks::mutator_lock_);
342
343  void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
344                         ThreadPool& thread_pool, base::TimingLogger& timings)
345      LOCKS_EXCLUDED(Locks::mutator_lock_);
346  void InitializeClasses(jobject class_loader, const DexFile& dex_file,
347                         ThreadPool& thread_pool, base::TimingLogger& timings)
348      LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
349
350  void UpdateImageClasses(base::TimingLogger& timings);
351  static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
352      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
353
354  void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
355               ThreadPool& thread_pool, base::TimingLogger& timings);
356  void CompileDexFile(jobject class_loader, const DexFile& dex_file,
357                      ThreadPool& thread_pool, base::TimingLogger& timings)
358      LOCKS_EXCLUDED(Locks::mutator_lock_);
359  void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
360                     InvokeType invoke_type, uint32_t class_def_idx, uint32_t method_idx,
361                     jobject class_loader, const DexFile& dex_file,
362                     DexToDexCompilationLevel dex_to_dex_compilation_level)
363      LOCKS_EXCLUDED(compiled_methods_lock_);
364
365  static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
366      LOCKS_EXCLUDED(Locks::mutator_lock_);
367
368  std::vector<const PatchInformation*> code_to_patch_;
369  std::vector<const PatchInformation*> methods_to_patch_;
370
371  CompilerBackend compiler_backend_;
372
373  InstructionSet instruction_set_;
374
375  // All class references that require
376  mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
377  std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
378
379  typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
380  // All class references that this compiler has compiled.
381  mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
382  ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
383
384  typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable;
385  // All method references that this compiler has compiled.
386  mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
387  MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
388
389  const bool image_;
390
391  // If image_ is true, specifies the classes that will be included in
392  // the image. Note if image_classes_ is NULL, all classes are
393  // included in the image.
394  UniquePtr<DescriptorSet> image_classes_;
395
396  size_t thread_count_;
397  uint64_t start_ns_;
398
399  UniquePtr<AOTCompilationStats> stats_;
400
401  bool dump_stats_;
402
403  typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
404  typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
405
406  void* compiler_library_;
407
408  typedef CompiledMethod* (*CompilerFn)(CompilerDriver& driver,
409                                        const DexFile::CodeItem* code_item,
410                                        uint32_t access_flags, InvokeType invoke_type,
411                                        uint32_t class_dex_idx, uint32_t method_idx,
412                                        jobject class_loader, const DexFile& dex_file);
413
414  typedef void (*DexToDexCompilerFn)(CompilerDriver& driver,
415                                     const DexFile::CodeItem* code_item,
416                                     uint32_t access_flags, InvokeType invoke_type,
417                                     uint32_t class_dex_idx, uint32_t method_idx,
418                                     jobject class_loader, const DexFile& dex_file,
419                                     DexToDexCompilationLevel dex_to_dex_compilation_level);
420  CompilerFn compiler_;
421#ifdef ART_SEA_IR_MODE
422  CompilerFn sea_ir_compiler_;
423#endif
424
425  DexToDexCompilerFn dex_to_dex_compiler_;
426
427  void* compiler_context_;
428
429  typedef CompiledMethod* (*JniCompilerFn)(CompilerDriver& driver,
430                                           uint32_t access_flags, uint32_t method_idx,
431                                           const DexFile& dex_file);
432  JniCompilerFn jni_compiler_;
433
434  pthread_key_t tls_key_;
435
436  // Arena pool used by the compiler.
437  ArenaPool arena_pool_;
438
439  typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver);
440  CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
441
442  typedef const void* (*CompilerGetMethodCodeAddrFn)
443      (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method);
444  CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
445
446  bool support_boot_image_fixup_;
447
448  // DeDuplication data structures, these own the corresponding byte arrays.
449  class DedupeHashFunc {
450   public:
451    size_t operator()(const std::vector<uint8_t>& array) const {
452      // For small arrays compute a hash using every byte.
453      static const size_t kSmallArrayThreshold = 16;
454      size_t hash = 0x811c9dc5;
455      if (array.size() <= kSmallArrayThreshold) {
456        for (uint8_t b : array) {
457          hash = (hash * 16777619) ^ b;
458        }
459      } else {
460        // For larger arrays use the first 4 bytes and then select a number of other values at
461        // random.
462        static const size_t kRandomHashCount = 16;
463        for (size_t i = 0; i < 4; ++i) {
464          uint8_t b = array[i];
465          hash = (hash * 16777619) ^ b;
466        }
467        for (size_t i = 4; i < kRandomHashCount; ++i) {
468          size_t r = i * 1103515245 + 12345;
469          uint8_t b = array[r % array.size()];
470          hash = (hash * 16777619) ^ b;
471        }
472      }
473      hash += hash << 13;
474      hash ^= hash >> 7;
475      hash += hash << 3;
476      hash ^= hash >> 17;
477      hash += hash << 5;
478      return hash;
479    }
480  };
481  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_code_;
482  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_mapping_table_;
483  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_vmap_table_;
484  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_gc_map_;
485
486  DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
487};
488
489}  // namespace art
490
491#endif  // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
492