• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
39 namespace art {
40 
41 class AOTCompilationStats;
42 class ParallelCompilationManager;
43 class DexCompilationUnit;
44 class OatWriter;
45 class TimingLogger;
46 
47 enum CompilerBackend {
48   kQuick,
49   kPortable,
50   kNoBackend
51 };
52 
53 enum 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 
64 enum 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
71 class CompilerTls {
72   public:
CompilerTls()73     CompilerTls() : llvm_info_(NULL) {}
~CompilerTls()74     ~CompilerTls() {}
75 
GetLLVMInfo()76     void* GetLLVMInfo() { return llvm_info_; }
77 
SetLLVMInfo(void * llvm_info)78     void SetLLVMInfo(void* llvm_info) { llvm_info_ = llvm_info; }
79 
80   private:
81     void* llvm_info_;
82 };
83 
84 class 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 
GetInstructionSet()107   InstructionSet GetInstructionSet() const {
108     return instruction_set_;
109   }
110 
GetCompilerBackend()111   CompilerBackend GetCompilerBackend() const {
112     return compiler_backend_;
113   }
114 
115   // Are we compiling and creating an image file?
IsImage()116   bool IsImage() const {
117     return image_;
118   }
119 
GetImageClasses()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,
149                                      uint16_t class_def_index);
150   bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index);
151 
152   // Callbacks from compiler to see what runtime checks must be generated.
153 
154   bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx)
155       LOCKS_EXCLUDED(Locks::mutator_lock_);
156 
157   bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
158       LOCKS_EXCLUDED(Locks::mutator_lock_);
159 
160   // Are runtime access checks necessary in the compiled code?
161   bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
162                                   uint32_t type_idx, bool* type_known_final = NULL,
163                                   bool* type_known_abstract = NULL,
164                                   bool* equals_referrers_class = NULL)
165       LOCKS_EXCLUDED(Locks::mutator_lock_);
166 
167   // Are runtime access and instantiable checks necessary in the code?
168   bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
169                                               uint32_t type_idx)
170      LOCKS_EXCLUDED(Locks::mutator_lock_);
171 
172   // Can we fast path instance field access? Computes field's offset and volatility.
173   bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
174                                 int& field_offset, bool& is_volatile, bool is_put)
175       LOCKS_EXCLUDED(Locks::mutator_lock_);
176 
177   // Can we fastpath static field access? Computes field's offset, volatility and whether the
178   // field is within the referrer (which can avoid checking class initialization).
179   bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
180                               int& field_offset, int& ssb_index,
181                               bool& is_referrers_class, bool& is_volatile, bool is_put)
182       LOCKS_EXCLUDED(Locks::mutator_lock_);
183 
184   // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
185   // index.
186   bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
187                          InvokeType& type, MethodReference& target_method, int& vtable_idx,
188                          uintptr_t& direct_code, uintptr_t& direct_method, bool update_stats)
189       LOCKS_EXCLUDED(Locks::mutator_lock_);
190 
191   bool IsSafeCast(const MethodReference& mr, uint32_t dex_pc);
192 
193   // Record patch information for later fix up.
194   void AddCodePatch(const DexFile* dex_file,
195                     uint16_t referrer_class_def_idx,
196                     uint32_t referrer_method_idx,
197                     InvokeType referrer_invoke_type,
198                     uint32_t target_method_idx,
199                     InvokeType target_invoke_type,
200                     size_t literal_offset)
201       LOCKS_EXCLUDED(compiled_methods_lock_);
202   void AddMethodPatch(const DexFile* dex_file,
203                       uint16_t referrer_class_def_idx,
204                       uint32_t referrer_method_idx,
205                       InvokeType referrer_invoke_type,
206                       uint32_t target_method_idx,
207                       InvokeType target_invoke_type,
208                       size_t literal_offset)
209       LOCKS_EXCLUDED(compiled_methods_lock_);
210 
211   void SetBitcodeFileName(std::string const& filename);
212 
GetSupportBootImageFixup()213   bool GetSupportBootImageFixup() const {
214     return support_boot_image_fixup_;
215   }
216 
SetSupportBootImageFixup(bool support_boot_image_fixup)217   void SetSupportBootImageFixup(bool support_boot_image_fixup) {
218     support_boot_image_fixup_ = support_boot_image_fixup;
219   }
220 
GetArenaPool()221   ArenaPool& GetArenaPool() {
222     return arena_pool_;
223   }
224 
225   bool WriteElf(const std::string& android_root,
226                 bool is_host,
227                 const std::vector<const DexFile*>& dex_files,
228                 OatWriter& oat_writer,
229                 File* file);
230 
231   // TODO: move to a common home for llvm helpers once quick/portable are merged
232   static void InstructionSetToLLVMTarget(InstructionSet instruction_set,
233                                          std::string& target_triple,
234                                          std::string& target_cpu,
235                                          std::string& target_attr);
236 
SetCompilerContext(void * compiler_context)237   void SetCompilerContext(void* compiler_context) {
238     compiler_context_ = compiler_context;
239   }
240 
GetCompilerContext()241   void* GetCompilerContext() const {
242     return compiler_context_;
243   }
244 
GetThreadCount()245   size_t GetThreadCount() const {
246     return thread_count_;
247   }
248 
249   class PatchInformation {
250    public:
GetDexFile()251     const DexFile& GetDexFile() const {
252       return *dex_file_;
253     }
GetReferrerClassDefIdx()254     uint16_t GetReferrerClassDefIdx() const {
255       return referrer_class_def_idx_;
256     }
GetReferrerMethodIdx()257     uint32_t GetReferrerMethodIdx() const {
258       return referrer_method_idx_;
259     }
GetReferrerInvokeType()260     InvokeType GetReferrerInvokeType() const {
261       return referrer_invoke_type_;
262     }
GetTargetMethodIdx()263     uint32_t GetTargetMethodIdx() const {
264       return target_method_idx_;
265     }
GetTargetInvokeType()266     InvokeType GetTargetInvokeType() const {
267       return target_invoke_type_;
268     }
GetLiteralOffset()269     size_t GetLiteralOffset() const {;
270       return literal_offset_;
271     }
272 
273    private:
PatchInformation(const DexFile * dex_file,uint16_t referrer_class_def_idx,uint32_t referrer_method_idx,InvokeType referrer_invoke_type,uint32_t target_method_idx,InvokeType target_invoke_type,size_t literal_offset)274     PatchInformation(const DexFile* dex_file,
275                      uint16_t referrer_class_def_idx,
276                      uint32_t referrer_method_idx,
277                      InvokeType referrer_invoke_type,
278                      uint32_t target_method_idx,
279                      InvokeType target_invoke_type,
280                      size_t literal_offset)
281       : dex_file_(dex_file),
282         referrer_class_def_idx_(referrer_class_def_idx),
283         referrer_method_idx_(referrer_method_idx),
284         referrer_invoke_type_(referrer_invoke_type),
285         target_method_idx_(target_method_idx),
286         target_invoke_type_(target_invoke_type),
287         literal_offset_(literal_offset) {
288       CHECK(dex_file_ != NULL);
289     }
290 
291     const DexFile* const dex_file_;
292     const uint16_t referrer_class_def_idx_;
293     const uint32_t referrer_method_idx_;
294     const InvokeType referrer_invoke_type_;
295     const uint32_t target_method_idx_;
296     const InvokeType target_invoke_type_;
297     const size_t literal_offset_;
298 
299     friend class CompilerDriver;
300     DISALLOW_COPY_AND_ASSIGN(PatchInformation);
301   };
302 
GetCodeToPatch()303   const std::vector<const PatchInformation*>& GetCodeToPatch() const {
304     return code_to_patch_;
305   }
GetMethodsToPatch()306   const std::vector<const PatchInformation*>& GetMethodsToPatch() const {
307     return methods_to_patch_;
308   }
309 
310   // Checks if class specified by type_idx is one of the image_classes_
311   bool IsImageClass(const char* descriptor) const;
312 
313   void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
314       LOCKS_EXCLUDED(compiled_classes_lock_);
315 
316   std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code);
317   std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code);
318   std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code);
319   std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code);
320 
321  private:
322   // Compute constant code and method pointers when possible
323   void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
324                                      mirror::Class* referrer_class,
325                                      mirror::ArtMethod* method,
326                                      uintptr_t& direct_code, uintptr_t& direct_method,
327                                      bool update_stats)
328       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
329 
330   void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
331                   ThreadPool& thread_pool, base::TimingLogger& timings)
332       LOCKS_EXCLUDED(Locks::mutator_lock_);
333 
334   void LoadImageClasses(base::TimingLogger& timings);
335 
336   // Attempt to resolve all type, methods, fields, and strings
337   // referenced from code in the dex file following PathClassLoader
338   // ordering semantics.
339   void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
340                ThreadPool& thread_pool, base::TimingLogger& timings)
341       LOCKS_EXCLUDED(Locks::mutator_lock_);
342   void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
343                       ThreadPool& thread_pool, base::TimingLogger& timings)
344       LOCKS_EXCLUDED(Locks::mutator_lock_);
345 
346   void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
347               ThreadPool& thread_pool, base::TimingLogger& timings);
348   void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
349                      ThreadPool& thread_pool, base::TimingLogger& timings)
350       LOCKS_EXCLUDED(Locks::mutator_lock_);
351 
352   void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
353                          ThreadPool& thread_pool, base::TimingLogger& timings)
354       LOCKS_EXCLUDED(Locks::mutator_lock_);
355   void InitializeClasses(jobject class_loader, const DexFile& dex_file,
356                          ThreadPool& thread_pool, base::TimingLogger& timings)
357       LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
358 
359   void UpdateImageClasses(base::TimingLogger& timings);
360   static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
361       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
362 
363   void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
364                ThreadPool& thread_pool, base::TimingLogger& timings);
365   void CompileDexFile(jobject class_loader, const DexFile& dex_file,
366                       ThreadPool& thread_pool, base::TimingLogger& timings)
367       LOCKS_EXCLUDED(Locks::mutator_lock_);
368   void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
369                      InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx,
370                      jobject class_loader, const DexFile& dex_file,
371                      DexToDexCompilationLevel dex_to_dex_compilation_level)
372       LOCKS_EXCLUDED(compiled_methods_lock_);
373 
374   static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
375       LOCKS_EXCLUDED(Locks::mutator_lock_);
376 
377   std::vector<const PatchInformation*> code_to_patch_;
378   std::vector<const PatchInformation*> methods_to_patch_;
379 
380   CompilerBackend compiler_backend_;
381 
382   InstructionSet instruction_set_;
383 
384   // All class references that require
385   mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
386   std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
387 
388   typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
389   // All class references that this compiler has compiled.
390   mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
391   ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
392 
393   typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable;
394   // All method references that this compiler has compiled.
395   mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
396   MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
397 
398   const bool image_;
399 
400   // If image_ is true, specifies the classes that will be included in
401   // the image. Note if image_classes_ is NULL, all classes are
402   // included in the image.
403   UniquePtr<DescriptorSet> image_classes_;
404 
405   size_t thread_count_;
406   uint64_t start_ns_;
407 
408   UniquePtr<AOTCompilationStats> stats_;
409 
410   bool dump_stats_;
411 
412   typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
413   typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
414 
415   void* compiler_library_;
416 
417   typedef CompiledMethod* (*CompilerFn)(CompilerDriver& driver,
418                                         const DexFile::CodeItem* code_item,
419                                         uint32_t access_flags, InvokeType invoke_type,
420                                         uint32_t class_dex_idx, uint32_t method_idx,
421                                         jobject class_loader, const DexFile& dex_file);
422 
423   typedef void (*DexToDexCompilerFn)(CompilerDriver& driver,
424                                      const DexFile::CodeItem* code_item,
425                                      uint32_t access_flags, InvokeType invoke_type,
426                                      uint32_t class_dex_idx, uint32_t method_idx,
427                                      jobject class_loader, const DexFile& dex_file,
428                                      DexToDexCompilationLevel dex_to_dex_compilation_level);
429   CompilerFn compiler_;
430 #ifdef ART_SEA_IR_MODE
431   CompilerFn sea_ir_compiler_;
432 #endif
433 
434   DexToDexCompilerFn dex_to_dex_compiler_;
435 
436   void* compiler_context_;
437 
438   typedef CompiledMethod* (*JniCompilerFn)(CompilerDriver& driver,
439                                            uint32_t access_flags, uint32_t method_idx,
440                                            const DexFile& dex_file);
441   JniCompilerFn jni_compiler_;
442 
443   pthread_key_t tls_key_;
444 
445   // Arena pool used by the compiler.
446   ArenaPool arena_pool_;
447 
448   typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver);
449   CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
450 
451   typedef const void* (*CompilerGetMethodCodeAddrFn)
452       (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method);
453   CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
454 
455   bool support_boot_image_fixup_;
456 
457   // DeDuplication data structures, these own the corresponding byte arrays.
458   class DedupeHashFunc {
459    public:
operator()460     size_t operator()(const std::vector<uint8_t>& array) const {
461       // Take a random sample of bytes.
462       static const size_t kSmallArrayThreshold = 16;
463       static const size_t kRandomHashCount = 16;
464       size_t hash = 0;
465       if (array.size() < kSmallArrayThreshold) {
466         for (auto c : array) {
467           hash = hash * 54 + c;
468         }
469       } else {
470         for (size_t i = 0; i < kRandomHashCount; ++i) {
471           size_t r = i * 1103515245 + 12345;
472           hash = hash * 54 + array[r % array.size()];
473         }
474       }
475       return hash;
476     }
477   };
478   DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_code_;
479   DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_mapping_table_;
480   DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_vmap_table_;
481   DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_gc_map_;
482 
483   DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
484 };
485 
486 }  // namespace art
487 
488 #endif  // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_
489