compiler_driver.h revision c50d8e11a098cc5c6239aa86b47d4fcf8cbb4899 
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 "instruction_set.h"
30#include "invoke_type.h"
31#include "method_reference.h"
32#include "os.h"
33#include "runtime.h"
34#include "safe_map.h"
35#include "thread_pool.h"
36
37namespace art {
38
39class AOTCompilationStats;
40class ParallelCompilationManager;
41class DexCompilationUnit;
42class OatWriter;
43class TimingLogger;
44
45enum CompilerBackend {
46  kQuick,
47  kPortable,
48  kNoBackend
49};
50
51// Thread-local storage compiler worker threads
52class CompilerTls {
53  public:
54    CompilerTls() : llvm_info_(NULL) {}
55    ~CompilerTls() {}
56
57    void* GetLLVMInfo() { return llvm_info_; }
58
59    void SetLLVMInfo(void* llvm_info) { llvm_info_ = llvm_info; }
60
61  private:
62    void* llvm_info_;
63};
64
65class CompilerDriver {
66 public:
67  typedef std::set<std::string> DescriptorSet;
68
69  // Create a compiler targeting the requested "instruction_set".
70  // "image" should be true if image specific optimizations should be
71  // enabled.  "image_classes" lets the compiler know what classes it
72  // can assume will be in the image, with NULL implying all available
73  // classes.
74  explicit CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
75                          bool image, DescriptorSet* image_classes,
76                          size_t thread_count, bool dump_stats);
77
78  ~CompilerDriver();
79
80  void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
81                  TimingLogger& timings)
82      LOCKS_EXCLUDED(Locks::mutator_lock_);
83
84  // Compile a single Method
85  void CompileOne(const mirror::AbstractMethod* method, TimingLogger& timings)
86      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
87
88  InstructionSet GetInstructionSet() const {
89    return instruction_set_;
90  }
91
92  CompilerBackend GetCompilerBackend() const {
93    return compiler_backend_;
94  }
95
96  bool IsImage() const {
97    return image_;
98  }
99
100  DescriptorSet* GetImageClasses() const {
101    return image_classes_.get();
102  }
103
104  CompilerTls* GetTls();
105
106  // Generate the trampolines that are invoked by unresolved direct methods.
107  const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const
108      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
109  const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
110      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
111  const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry() const
112      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
113  const std::vector<uint8_t>* CreateInterpreterToQuickEntry() const
114      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
115
116  CompiledClass* GetCompiledClass(ClassReference ref) const
117      LOCKS_EXCLUDED(compiled_classes_lock_);
118
119  CompiledMethod* GetCompiledMethod(MethodReference ref) const
120      LOCKS_EXCLUDED(compiled_methods_lock_);
121
122  void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, size_t class_def_index);
123  bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, size_t class_def_index);
124
125  // Callbacks from compiler to see what runtime checks must be generated.
126
127  bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx)
128      LOCKS_EXCLUDED(Locks::mutator_lock_);
129
130  bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
131      LOCKS_EXCLUDED(Locks::mutator_lock_);
132
133  // Are runtime access checks necessary in the compiled code?
134  bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
135                                  uint32_t type_idx, bool* type_known_final = NULL,
136                                  bool* type_known_abstract = NULL,
137                                  bool* equals_referrers_class = NULL)
138      LOCKS_EXCLUDED(Locks::mutator_lock_);
139
140  // Are runtime access and instantiable checks necessary in the code?
141  bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
142                                              uint32_t type_idx)
143     LOCKS_EXCLUDED(Locks::mutator_lock_);
144
145  // Can we fast path instance field access? Computes field's offset and volatility.
146  bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
147                                int& field_offset, bool& is_volatile, bool is_put)
148      LOCKS_EXCLUDED(Locks::mutator_lock_);
149
150  // Can we fastpath static field access? Computes field's offset, volatility and whether the
151  // field is within the referrer (which can avoid checking class initialization).
152  bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
153                              int& field_offset, int& ssb_index,
154                              bool& is_referrers_class, bool& is_volatile, bool is_put)
155      LOCKS_EXCLUDED(Locks::mutator_lock_);
156
157  // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
158  // index.
159  bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
160                         InvokeType& type, MethodReference& target_method, int& vtable_idx,
161                         uintptr_t& direct_code, uintptr_t& direct_method, bool update_stats)
162      LOCKS_EXCLUDED(Locks::mutator_lock_);
163
164  bool IsSafeCast(const MethodReference& mr, uint32_t dex_pc);
165
166  // Record patch information for later fix up.
167  void AddCodePatch(const DexFile* dex_file,
168                    uint32_t referrer_method_idx,
169                    InvokeType referrer_invoke_type,
170                    uint32_t target_method_idx,
171                    InvokeType target_invoke_type,
172                    size_t literal_offset)
173      LOCKS_EXCLUDED(compiled_methods_lock_);
174  void AddMethodPatch(const DexFile* dex_file,
175                      uint32_t referrer_method_idx,
176                      InvokeType referrer_invoke_type,
177                      uint32_t target_method_idx,
178                      InvokeType target_invoke_type,
179                      size_t literal_offset)
180      LOCKS_EXCLUDED(compiled_methods_lock_);
181
182  void SetBitcodeFileName(std::string const& filename);
183
184  bool GetSupportBootImageFixup() const {
185    return support_boot_image_fixup_;
186  }
187
188  void SetSupportBootImageFixup(bool support_boot_image_fixup) {
189    support_boot_image_fixup_ = support_boot_image_fixup;
190  }
191
192
193  bool WriteElf(const std::string& android_root,
194                bool is_host,
195                const std::vector<const DexFile*>& dex_files,
196                OatWriter& oat_writer,
197                File* file);
198
199  // TODO: move to a common home for llvm helpers once quick/portable are merged
200  static void InstructionSetToLLVMTarget(InstructionSet instruction_set,
201                                         std::string& target_triple,
202                                         std::string& target_cpu,
203                                         std::string& target_attr);
204
205  void SetCompilerContext(void* compiler_context) {
206    compiler_context_ = compiler_context;
207  }
208
209  void* GetCompilerContext() const {
210    return compiler_context_;
211  }
212
213  size_t GetThreadCount() const {
214    return thread_count_;
215  }
216
217  class PatchInformation {
218   public:
219    const DexFile& GetDexFile() const {
220      return *dex_file_;
221    }
222    uint32_t GetReferrerMethodIdx() const {
223      return referrer_method_idx_;
224    }
225    InvokeType GetReferrerInvokeType() const {
226      return referrer_invoke_type_;
227    }
228    uint32_t GetTargetMethodIdx() const {
229      return target_method_idx_;
230    }
231    InvokeType GetTargetInvokeType() const {
232      return target_invoke_type_;
233    }
234    size_t GetLiteralOffset() const {;
235      return literal_offset_;
236    }
237
238   private:
239    PatchInformation(const DexFile* dex_file,
240                     uint32_t referrer_method_idx,
241                     InvokeType referrer_invoke_type,
242                     uint32_t target_method_idx,
243                     InvokeType target_invoke_type,
244                     size_t literal_offset)
245      : dex_file_(dex_file),
246        referrer_method_idx_(referrer_method_idx),
247        referrer_invoke_type_(referrer_invoke_type),
248        target_method_idx_(target_method_idx),
249        target_invoke_type_(target_invoke_type),
250        literal_offset_(literal_offset) {
251      CHECK(dex_file_ != NULL);
252    }
253
254    const DexFile* dex_file_;
255    uint32_t referrer_method_idx_;
256    InvokeType referrer_invoke_type_;
257    uint32_t target_method_idx_;
258    InvokeType target_invoke_type_;
259    size_t literal_offset_;
260
261    friend class CompilerDriver;
262    DISALLOW_COPY_AND_ASSIGN(PatchInformation);
263  };
264
265  const std::vector<const PatchInformation*>& GetCodeToPatch() const {
266    return code_to_patch_;
267  }
268  const std::vector<const PatchInformation*>& GetMethodsToPatch() const {
269    return methods_to_patch_;
270  }
271
272  // Checks if class specified by type_idx is one of the image_classes_
273  bool IsImageClass(const char* descriptor) const;
274
275  void RecordClassStatus(ClassReference ref, CompiledClass* compiled_class);
276
277 private:
278  // Compute constant code and method pointers when possible
279  void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
280                                     mirror::Class* referrer_class,
281                                     mirror::AbstractMethod* method,
282                                     uintptr_t& direct_code, uintptr_t& direct_method,
283                                     bool update_stats)
284      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
285
286  void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
287                  ThreadPool& thread_pool, TimingLogger& timings)
288      LOCKS_EXCLUDED(Locks::mutator_lock_);
289
290  void LoadImageClasses(TimingLogger& timings);
291
292  // Attempt to resolve all type, methods, fields, and strings
293  // referenced from code in the dex file following PathClassLoader
294  // ordering semantics.
295  void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
296               ThreadPool& thread_pool, TimingLogger& timings)
297      LOCKS_EXCLUDED(Locks::mutator_lock_);
298  void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
299                      ThreadPool& thread_pool, TimingLogger& timings)
300      LOCKS_EXCLUDED(Locks::mutator_lock_);
301
302  void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
303              ThreadPool& thread_pool, TimingLogger& timings);
304  void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
305                     ThreadPool& thread_pool, TimingLogger& timings)
306      LOCKS_EXCLUDED(Locks::mutator_lock_);
307
308  void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
309                         ThreadPool& thread_pool, TimingLogger& timings)
310      LOCKS_EXCLUDED(Locks::mutator_lock_);
311  void InitializeClasses(jobject class_loader, const DexFile& dex_file,
312                         ThreadPool& thread_pool, TimingLogger& timings)
313      LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
314
315  void UpdateImageClasses(TimingLogger& timings);
316  static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
317      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
318
319  void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
320               ThreadPool& thread_pool, TimingLogger& timings);
321  void CompileDexFile(jobject class_loader, const DexFile& dex_file,
322                      ThreadPool& thread_pool, TimingLogger& timings)
323      LOCKS_EXCLUDED(Locks::mutator_lock_);
324  void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
325                     InvokeType invoke_type, uint32_t class_def_idx, uint32_t method_idx,
326                     jobject class_loader, const DexFile& dex_file,
327                     bool allow_dex_to_dex_compilation)
328      LOCKS_EXCLUDED(compiled_methods_lock_);
329
330  static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
331      LOCKS_EXCLUDED(Locks::mutator_lock_);
332
333  std::vector<const PatchInformation*> code_to_patch_;
334  std::vector<const PatchInformation*> methods_to_patch_;
335
336  CompilerBackend compiler_backend_;
337
338  InstructionSet instruction_set_;
339
340  // All class references that require
341  mutable Mutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
342  std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
343
344  typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
345  // All class references that this compiler has compiled.
346  mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
347  ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
348
349  typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable;
350  // All method references that this compiler has compiled.
351  mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
352  MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
353
354  const bool image_;
355
356  // If image_ is true, specifies the classes that will be included in
357  // the image. Note if image_classes_ is NULL, all classes are
358  // included in the image.
359  UniquePtr<DescriptorSet> image_classes_;
360
361  size_t thread_count_;
362  uint64_t start_ns_;
363
364  UniquePtr<AOTCompilationStats> stats_;
365
366  bool dump_stats_;
367
368  typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
369  typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
370
371  void* compiler_library_;
372
373  typedef CompiledMethod* (*CompilerFn)(CompilerDriver& driver,
374                                        const DexFile::CodeItem* code_item,
375                                        uint32_t access_flags, InvokeType invoke_type,
376                                        uint32_t class_dex_idx, uint32_t method_idx,
377                                        jobject class_loader, const DexFile& dex_file);
378  CompilerFn compiler_;
379#ifdef ART_SEA_IR_MODE
380  CompilerFn sea_ir_compiler_;
381#endif
382
383  CompilerFn dex_to_dex_compiler_;
384
385  void* compiler_context_;
386
387  typedef CompiledMethod* (*JniCompilerFn)(CompilerDriver& driver,
388                                           uint32_t access_flags, uint32_t method_idx,
389                                           const DexFile& dex_file);
390  JniCompilerFn jni_compiler_;
391
392  pthread_key_t tls_key_;
393
394  typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver);
395  CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
396
397  typedef const void* (*CompilerGetMethodCodeAddrFn)
398      (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::AbstractMethod* method);
399  CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
400
401  bool support_boot_image_fixup_;
402
403  DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
404};
405
406}  // namespace art
407
408#endif  // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
409