compiler_driver.cc revision 4a200f56b7075309316b04d550c9cc50f8314edd 
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#include "compiler_driver.h"
18
19#define ATRACE_TAG ATRACE_TAG_DALVIK
20#include <utils/Trace.h>
21
22#include <vector>
23#include <unistd.h>
24#include <fstream>
25
26#include "base/stl_util.h"
27#include "base/timing_logger.h"
28#include "class_linker.h"
29#include "compiler.h"
30#include "compiler_driver-inl.h"
31#include "dex_compilation_unit.h"
32#include "dex_file-inl.h"
33#include "dex/verification_results.h"
34#include "dex/verified_method.h"
35#include "dex/quick/dex_file_method_inliner.h"
36#include "driver/compiler_options.h"
37#include "jni_internal.h"
38#include "object_utils.h"
39#include "runtime.h"
40#include "gc/accounting/card_table-inl.h"
41#include "gc/accounting/heap_bitmap.h"
42#include "gc/space/space.h"
43#include "mirror/art_field-inl.h"
44#include "mirror/art_method-inl.h"
45#include "mirror/class_loader.h"
46#include "mirror/class-inl.h"
47#include "mirror/dex_cache-inl.h"
48#include "mirror/object-inl.h"
49#include "mirror/object_array-inl.h"
50#include "mirror/throwable.h"
51#include "scoped_thread_state_change.h"
52#include "ScopedLocalRef.h"
53#include "sirt_ref-inl.h"
54#include "thread.h"
55#include "thread_pool.h"
56#include "trampolines/trampoline_compiler.h"
57#include "transaction.h"
58#include "verifier/method_verifier.h"
59#include "verifier/method_verifier-inl.h"
60
61namespace art {
62
63static double Percentage(size_t x, size_t y) {
64  return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
65}
66
67static void DumpStat(size_t x, size_t y, const char* str) {
68  if (x == 0 && y == 0) {
69    return;
70  }
71  LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
72}
73
74class CompilerDriver::AOTCompilationStats {
75 public:
76  AOTCompilationStats()
77      : stats_lock_("AOT compilation statistics lock"),
78        types_in_dex_cache_(0), types_not_in_dex_cache_(0),
79        strings_in_dex_cache_(0), strings_not_in_dex_cache_(0),
80        resolved_types_(0), unresolved_types_(0),
81        resolved_instance_fields_(0), unresolved_instance_fields_(0),
82        resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0),
83        type_based_devirtualization_(0),
84        safe_casts_(0), not_safe_casts_(0) {
85    for (size_t i = 0; i <= kMaxInvokeType; i++) {
86      resolved_methods_[i] = 0;
87      unresolved_methods_[i] = 0;
88      virtual_made_direct_[i] = 0;
89      direct_calls_to_boot_[i] = 0;
90      direct_methods_to_boot_[i] = 0;
91    }
92  }
93
94  void Dump() {
95    DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache");
96    DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache");
97    DumpStat(resolved_types_, unresolved_types_, "types resolved");
98    DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
99    DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
100             "static fields resolved");
101    DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
102             "static fields local to a class");
103    DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information");
104    // Note, the code below subtracts the stat value so that when added to the stat value we have
105    // 100% of samples. TODO: clean this up.
106    DumpStat(type_based_devirtualization_,
107             resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] +
108             resolved_methods_[kInterface] + unresolved_methods_[kInterface] -
109             type_based_devirtualization_,
110             "virtual/interface calls made direct based on type information");
111
112    for (size_t i = 0; i <= kMaxInvokeType; i++) {
113      std::ostringstream oss;
114      oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
115      DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
116      if (virtual_made_direct_[i] > 0) {
117        std::ostringstream oss2;
118        oss2 << static_cast<InvokeType>(i) << " methods made direct";
119        DumpStat(virtual_made_direct_[i],
120                 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
121                 oss2.str().c_str());
122      }
123      if (direct_calls_to_boot_[i] > 0) {
124        std::ostringstream oss2;
125        oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
126        DumpStat(direct_calls_to_boot_[i],
127                 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
128                 oss2.str().c_str());
129      }
130      if (direct_methods_to_boot_[i] > 0) {
131        std::ostringstream oss2;
132        oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
133        DumpStat(direct_methods_to_boot_[i],
134                 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
135                 oss2.str().c_str());
136      }
137    }
138  }
139
140// Allow lossy statistics in non-debug builds.
141#ifndef NDEBUG
142#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
143#else
144#define STATS_LOCK()
145#endif
146
147  void TypeInDexCache() {
148    STATS_LOCK();
149    types_in_dex_cache_++;
150  }
151
152  void TypeNotInDexCache() {
153    STATS_LOCK();
154    types_not_in_dex_cache_++;
155  }
156
157  void StringInDexCache() {
158    STATS_LOCK();
159    strings_in_dex_cache_++;
160  }
161
162  void StringNotInDexCache() {
163    STATS_LOCK();
164    strings_not_in_dex_cache_++;
165  }
166
167  void TypeDoesntNeedAccessCheck() {
168    STATS_LOCK();
169    resolved_types_++;
170  }
171
172  void TypeNeedsAccessCheck() {
173    STATS_LOCK();
174    unresolved_types_++;
175  }
176
177  void ResolvedInstanceField() {
178    STATS_LOCK();
179    resolved_instance_fields_++;
180  }
181
182  void UnresolvedInstanceField() {
183    STATS_LOCK();
184    unresolved_instance_fields_++;
185  }
186
187  void ResolvedLocalStaticField() {
188    STATS_LOCK();
189    resolved_local_static_fields_++;
190  }
191
192  void ResolvedStaticField() {
193    STATS_LOCK();
194    resolved_static_fields_++;
195  }
196
197  void UnresolvedStaticField() {
198    STATS_LOCK();
199    unresolved_static_fields_++;
200  }
201
202  // Indicate that type information from the verifier led to devirtualization.
203  void PreciseTypeDevirtualization() {
204    STATS_LOCK();
205    type_based_devirtualization_++;
206  }
207
208  // Indicate that a method of the given type was resolved at compile time.
209  void ResolvedMethod(InvokeType type) {
210    DCHECK_LE(type, kMaxInvokeType);
211    STATS_LOCK();
212    resolved_methods_[type]++;
213  }
214
215  // Indicate that a method of the given type was unresolved at compile time as it was in an
216  // unknown dex file.
217  void UnresolvedMethod(InvokeType type) {
218    DCHECK_LE(type, kMaxInvokeType);
219    STATS_LOCK();
220    unresolved_methods_[type]++;
221  }
222
223  // Indicate that a type of virtual method dispatch has been converted into a direct method
224  // dispatch.
225  void VirtualMadeDirect(InvokeType type) {
226    DCHECK(type == kVirtual || type == kInterface || type == kSuper);
227    STATS_LOCK();
228    virtual_made_direct_[type]++;
229  }
230
231  // Indicate that a method of the given type was able to call directly into boot.
232  void DirectCallsToBoot(InvokeType type) {
233    DCHECK_LE(type, kMaxInvokeType);
234    STATS_LOCK();
235    direct_calls_to_boot_[type]++;
236  }
237
238  // Indicate that a method of the given type was able to be resolved directly from boot.
239  void DirectMethodsToBoot(InvokeType type) {
240    DCHECK_LE(type, kMaxInvokeType);
241    STATS_LOCK();
242    direct_methods_to_boot_[type]++;
243  }
244
245  void ProcessedInvoke(InvokeType type, int flags) {
246    STATS_LOCK();
247    if (flags == 0) {
248      unresolved_methods_[type]++;
249    } else {
250      DCHECK_NE((flags & kFlagMethodResolved), 0);
251      resolved_methods_[type]++;
252      if ((flags & kFlagVirtualMadeDirect) != 0) {
253        virtual_made_direct_[type]++;
254        if ((flags & kFlagPreciseTypeDevirtualization) != 0) {
255          type_based_devirtualization_++;
256        }
257      } else {
258        DCHECK_EQ((flags & kFlagPreciseTypeDevirtualization), 0);
259      }
260      if ((flags & kFlagDirectCallToBoot) != 0) {
261        direct_calls_to_boot_[type]++;
262      }
263      if ((flags & kFlagDirectMethodToBoot) != 0) {
264        direct_methods_to_boot_[type]++;
265      }
266    }
267  }
268
269  // A check-cast could be eliminated due to verifier type analysis.
270  void SafeCast() {
271    STATS_LOCK();
272    safe_casts_++;
273  }
274
275  // A check-cast couldn't be eliminated due to verifier type analysis.
276  void NotASafeCast() {
277    STATS_LOCK();
278    not_safe_casts_++;
279  }
280
281 private:
282  Mutex stats_lock_;
283
284  size_t types_in_dex_cache_;
285  size_t types_not_in_dex_cache_;
286
287  size_t strings_in_dex_cache_;
288  size_t strings_not_in_dex_cache_;
289
290  size_t resolved_types_;
291  size_t unresolved_types_;
292
293  size_t resolved_instance_fields_;
294  size_t unresolved_instance_fields_;
295
296  size_t resolved_local_static_fields_;
297  size_t resolved_static_fields_;
298  size_t unresolved_static_fields_;
299  // Type based devirtualization for invoke interface and virtual.
300  size_t type_based_devirtualization_;
301
302  size_t resolved_methods_[kMaxInvokeType + 1];
303  size_t unresolved_methods_[kMaxInvokeType + 1];
304  size_t virtual_made_direct_[kMaxInvokeType + 1];
305  size_t direct_calls_to_boot_[kMaxInvokeType + 1];
306  size_t direct_methods_to_boot_[kMaxInvokeType + 1];
307
308  size_t safe_casts_;
309  size_t not_safe_casts_;
310
311  DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
312};
313
314
315extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler,
316                                              const art::DexFile::CodeItem* code_item,
317                                              uint32_t access_flags,
318                                              art::InvokeType invoke_type,
319                                              uint16_t class_def_idx,
320                                              uint32_t method_idx,
321                                              jobject class_loader,
322                                              const art::DexFile& dex_file);
323
324CompilerDriver::CompilerDriver(const CompilerOptions* compiler_options,
325                               VerificationResults* verification_results,
326                               DexFileToMethodInlinerMap* method_inliner_map,
327                               Compiler::Kind compiler_kind,
328                               InstructionSet instruction_set,
329                               InstructionSetFeatures instruction_set_features,
330                               bool image, DescriptorSet* image_classes, size_t thread_count,
331                               bool dump_stats, bool dump_passes, CumulativeLogger* timer,
332                               std::string profile_file)
333    : profile_ok_(false), compiler_options_(compiler_options),
334      verification_results_(verification_results),
335      method_inliner_map_(method_inliner_map),
336      compiler_(Compiler::Create(compiler_kind)),
337      instruction_set_(instruction_set),
338      instruction_set_features_(instruction_set_features),
339      instruction_set_is_64_bit_(instruction_set == kX86_64 || instruction_set == kArm64),
340      freezing_constructor_lock_("freezing constructor lock"),
341      compiled_classes_lock_("compiled classes lock"),
342      compiled_methods_lock_("compiled method lock"),
343      image_(image),
344      image_classes_(image_classes),
345      thread_count_(thread_count),
346      start_ns_(0),
347      stats_(new AOTCompilationStats),
348      dump_stats_(dump_stats),
349      dump_passes_(dump_passes),
350      timings_logger_(timer),
351      compiler_library_(NULL),
352      compiler_context_(NULL),
353      compiler_enable_auto_elf_loading_(NULL),
354      compiler_get_method_code_addr_(NULL),
355      support_boot_image_fixup_(instruction_set != kMips),
356      cfi_info_(nullptr),
357      dedupe_code_("dedupe code"),
358      dedupe_mapping_table_("dedupe mapping table"),
359      dedupe_vmap_table_("dedupe vmap table"),
360      dedupe_gc_map_("dedupe gc map"),
361      dedupe_cfi_info_("dedupe cfi info") {
362  DCHECK(compiler_options_ != nullptr);
363  DCHECK(verification_results_ != nullptr);
364  DCHECK(method_inliner_map_ != nullptr);
365
366  CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key");
367
368  // Read the profile file if one is provided.
369  if (profile_file != "") {
370    profile_ok_ = ReadProfile(profile_file);
371  }
372
373  dex_to_dex_compiler_ = reinterpret_cast<DexToDexCompilerFn>(ArtCompileDEX);
374
375  compiler_->Init(*this);
376
377  CHECK(!Runtime::Current()->IsStarted());
378  if (!image_) {
379    CHECK(image_classes_.get() == NULL);
380  }
381
382  // Are we generating CFI information?
383  if (compiler_options->GetGenerateGDBInformation()) {
384    cfi_info_.reset(compiler_->GetCallFrameInformationInitialization(*this));
385  }
386}
387
388std::vector<uint8_t>* CompilerDriver::DeduplicateCode(const std::vector<uint8_t>& code) {
389  return dedupe_code_.Add(Thread::Current(), code);
390}
391
392std::vector<uint8_t>* CompilerDriver::DeduplicateMappingTable(const std::vector<uint8_t>& code) {
393  return dedupe_mapping_table_.Add(Thread::Current(), code);
394}
395
396std::vector<uint8_t>* CompilerDriver::DeduplicateVMapTable(const std::vector<uint8_t>& code) {
397  return dedupe_vmap_table_.Add(Thread::Current(), code);
398}
399
400std::vector<uint8_t>* CompilerDriver::DeduplicateGCMap(const std::vector<uint8_t>& code) {
401  return dedupe_gc_map_.Add(Thread::Current(), code);
402}
403
404std::vector<uint8_t>* CompilerDriver::DeduplicateCFIInfo(const std::vector<uint8_t>* cfi_info) {
405  if (cfi_info == nullptr) {
406    return nullptr;
407  }
408  return dedupe_cfi_info_.Add(Thread::Current(), *cfi_info);
409}
410
411CompilerDriver::~CompilerDriver() {
412  Thread* self = Thread::Current();
413  {
414    MutexLock mu(self, compiled_classes_lock_);
415    STLDeleteValues(&compiled_classes_);
416  }
417  {
418    MutexLock mu(self, compiled_methods_lock_);
419    STLDeleteValues(&compiled_methods_);
420  }
421  {
422    MutexLock mu(self, compiled_methods_lock_);
423    STLDeleteElements(&code_to_patch_);
424  }
425  {
426    MutexLock mu(self, compiled_methods_lock_);
427    STLDeleteElements(&methods_to_patch_);
428  }
429  {
430    MutexLock mu(self, compiled_methods_lock_);
431    STLDeleteElements(&classes_to_patch_);
432  }
433  CHECK_PTHREAD_CALL(pthread_key_delete, (tls_key_), "delete tls key");
434  compiler_->UnInit(*this);
435}
436
437CompilerTls* CompilerDriver::GetTls() {
438  // Lazily create thread-local storage
439  CompilerTls* res = static_cast<CompilerTls*>(pthread_getspecific(tls_key_));
440  if (res == NULL) {
441    res = new CompilerTls();
442    CHECK_PTHREAD_CALL(pthread_setspecific, (tls_key_, res), "compiler tls");
443  }
444  return res;
445}
446
447#define CREATE_TRAMPOLINE(type, abi, offset) \
448    if (instruction_set_is_64_bit_) { \
449      return CreateTrampoline64(instruction_set_, abi, \
450                                type ## _ENTRYPOINT_OFFSET(8, offset)); \
451    } else { \
452      return CreateTrampoline32(instruction_set_, abi, \
453                                type ## _ENTRYPOINT_OFFSET(4, offset)); \
454    }
455
456const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterBridge() const {
457  CREATE_TRAMPOLINE(INTERPRETER, kInterpreterAbi, pInterpreterToInterpreterBridge)
458}
459
460const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToCompiledCodeBridge() const {
461  CREATE_TRAMPOLINE(INTERPRETER, kInterpreterAbi, pInterpreterToCompiledCodeBridge)
462}
463
464const std::vector<uint8_t>* CompilerDriver::CreateJniDlsymLookup() const {
465  CREATE_TRAMPOLINE(JNI, kJniAbi, pDlsymLookup)
466}
467
468const std::vector<uint8_t>* CompilerDriver::CreatePortableImtConflictTrampoline() const {
469  CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableImtConflictTrampoline)
470}
471
472const std::vector<uint8_t>* CompilerDriver::CreatePortableResolutionTrampoline() const {
473  CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableResolutionTrampoline)
474}
475
476const std::vector<uint8_t>* CompilerDriver::CreatePortableToInterpreterBridge() const {
477  CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableToInterpreterBridge)
478}
479
480const std::vector<uint8_t>* CompilerDriver::CreateQuickGenericJniTrampoline() const {
481  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickGenericJniTrampoline)
482}
483
484const std::vector<uint8_t>* CompilerDriver::CreateQuickImtConflictTrampoline() const {
485  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickImtConflictTrampoline)
486}
487
488const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const {
489  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickResolutionTrampoline)
490}
491
492const std::vector<uint8_t>* CompilerDriver::CreateQuickToInterpreterBridge() const {
493  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickToInterpreterBridge)
494}
495#undef CREATE_TRAMPOLINE
496
497void CompilerDriver::CompileAll(jobject class_loader,
498                                const std::vector<const DexFile*>& dex_files,
499                                TimingLogger* timings) {
500  DCHECK(!Runtime::Current()->IsStarted());
501  UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", thread_count_ - 1));
502  PreCompile(class_loader, dex_files, thread_pool.get(), timings);
503  Compile(class_loader, dex_files, thread_pool.get(), timings);
504  if (dump_stats_) {
505    stats_->Dump();
506  }
507}
508
509static DexToDexCompilationLevel GetDexToDexCompilationlevel(
510    Thread* self, SirtRef<mirror::ClassLoader>& class_loader, const DexFile& dex_file,
511    const DexFile::ClassDef& class_def) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
512  const char* descriptor = dex_file.GetClassDescriptor(class_def);
513  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
514  mirror::Class* klass = class_linker->FindClass(self, descriptor, class_loader);
515  if (klass == NULL) {
516    CHECK(self->IsExceptionPending());
517    self->ClearException();
518    return kDontDexToDexCompile;
519  }
520  // The verifier can only run on "quick" instructions at runtime (see usage of
521  // FindAccessedFieldAtDexPc and FindInvokedMethodAtDexPc in ThrowNullPointerExceptionFromDexPC
522  // function). Since image classes can be verified again while compiling an application,
523  // we must prevent the DEX-to-DEX compiler from introducing them.
524  // TODO: find a way to enable "quick" instructions for image classes and remove this check.
525  bool compiling_image_classes = class_loader.get() == nullptr;
526  if (compiling_image_classes) {
527    return kRequired;
528  } else if (klass->IsVerified()) {
529    // Class is verified so we can enable DEX-to-DEX compilation for performance.
530    return kOptimize;
531  } else if (klass->IsCompileTimeVerified()) {
532    // Class verification has soft-failed. Anyway, ensure at least correctness.
533    DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
534    return kRequired;
535  } else {
536    // Class verification has failed: do not run DEX-to-DEX compilation.
537    return kDontDexToDexCompile;
538  }
539}
540
541void CompilerDriver::CompileOne(mirror::ArtMethod* method, TimingLogger* timings) {
542  DCHECK(!Runtime::Current()->IsStarted());
543  Thread* self = Thread::Current();
544  jobject jclass_loader;
545  const DexFile* dex_file;
546  uint16_t class_def_idx;
547  uint32_t method_idx = method->GetDexMethodIndex();
548  uint32_t access_flags = method->GetAccessFlags();
549  InvokeType invoke_type = method->GetInvokeType();
550  {
551    ScopedObjectAccessUnchecked soa(self);
552    ScopedLocalRef<jobject>
553      local_class_loader(soa.Env(),
554                    soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader()));
555    jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
556    // Find the dex_file
557    MethodHelper mh(method);
558    dex_file = &mh.GetDexFile();
559    class_def_idx = mh.GetClassDefIndex();
560  }
561  const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
562  self->TransitionFromRunnableToSuspended(kNative);
563
564  std::vector<const DexFile*> dex_files;
565  dex_files.push_back(dex_file);
566
567  UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", 0U));
568  PreCompile(jclass_loader, dex_files, thread_pool.get(), timings);
569
570  // Can we run DEX-to-DEX compiler on this class ?
571  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
572  {
573    ScopedObjectAccess soa(Thread::Current());
574    const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx);
575    SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
576                                              soa.Decode<mirror::ClassLoader*>(jclass_loader));
577    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(self, class_loader, *dex_file,
578                                                               class_def);
579  }
580  CompileMethod(code_item, access_flags, invoke_type, class_def_idx, method_idx, jclass_loader,
581                *dex_file, dex_to_dex_compilation_level);
582
583  self->GetJniEnv()->DeleteGlobalRef(jclass_loader);
584
585  self->TransitionFromSuspendedToRunnable();
586}
587
588void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
589                             ThreadPool* thread_pool, TimingLogger* timings) {
590  for (size_t i = 0; i != dex_files.size(); ++i) {
591    const DexFile* dex_file = dex_files[i];
592    CHECK(dex_file != NULL);
593    ResolveDexFile(class_loader, *dex_file, thread_pool, timings);
594  }
595}
596
597void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
598                                ThreadPool* thread_pool, TimingLogger* timings) {
599  LoadImageClasses(timings);
600
601  if (!compiler_options_->IsVerificationEnabled()) {
602    VLOG(compiler) << "Verify none mode specified, skipping pre-compilation";
603    return;
604  }
605
606  Resolve(class_loader, dex_files, thread_pool, timings);
607
608  Verify(class_loader, dex_files, thread_pool, timings);
609
610  InitializeClasses(class_loader, dex_files, thread_pool, timings);
611
612  UpdateImageClasses(timings);
613}
614
615bool CompilerDriver::IsImageClass(const char* descriptor) const {
616  if (!IsImage()) {
617    return true;
618  } else {
619    return image_classes_->find(descriptor) != image_classes_->end();
620  }
621}
622
623static void ResolveExceptionsForMethod(MethodHelper* mh,
624    std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve)
625    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
626  const DexFile::CodeItem* code_item = mh->GetCodeItem();
627  if (code_item == NULL) {
628    return;  // native or abstract method
629  }
630  if (code_item->tries_size_ == 0) {
631    return;  // nothing to process
632  }
633  const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0);
634  size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list);
635  for (size_t i = 0; i < num_encoded_catch_handlers; i++) {
636    int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list);
637    bool has_catch_all = false;
638    if (encoded_catch_handler_size <= 0) {
639      encoded_catch_handler_size = -encoded_catch_handler_size;
640      has_catch_all = true;
641    }
642    for (int32_t j = 0; j < encoded_catch_handler_size; j++) {
643      uint16_t encoded_catch_handler_handlers_type_idx =
644          DecodeUnsignedLeb128(&encoded_catch_handler_list);
645      // Add to set of types to resolve if not already in the dex cache resolved types
646      if (!mh->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) {
647        exceptions_to_resolve.insert(
648            std::pair<uint16_t, const DexFile*>(encoded_catch_handler_handlers_type_idx,
649                                                &mh->GetDexFile()));
650      }
651      // ignore address associated with catch handler
652      DecodeUnsignedLeb128(&encoded_catch_handler_list);
653    }
654    if (has_catch_all) {
655      // ignore catch all address
656      DecodeUnsignedLeb128(&encoded_catch_handler_list);
657    }
658  }
659}
660
661static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg)
662    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
663  std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve =
664      reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
665  MethodHelper mh;
666  for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
667    mirror::ArtMethod* m = c->GetVirtualMethod(i);
668    mh.ChangeMethod(m);
669    ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
670  }
671  for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
672    mirror::ArtMethod* m = c->GetDirectMethod(i);
673    mh.ChangeMethod(m);
674    ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
675  }
676  return true;
677}
678
679static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg)
680    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
681  CompilerDriver::DescriptorSet* image_classes =
682      reinterpret_cast<CompilerDriver::DescriptorSet*>(arg);
683  image_classes->insert(ClassHelper(klass).GetDescriptor());
684  return true;
685}
686
687// Make a list of descriptors for classes to include in the image
688void CompilerDriver::LoadImageClasses(TimingLogger* timings)
689      LOCKS_EXCLUDED(Locks::mutator_lock_) {
690  if (!IsImage()) {
691    return;
692  }
693
694  timings->NewSplit("LoadImageClasses");
695  // Make a first class to load all classes explicitly listed in the file
696  Thread* self = Thread::Current();
697  ScopedObjectAccess soa(self);
698  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
699  for (auto it = image_classes_->begin(), end = image_classes_->end(); it != end;) {
700    const std::string& descriptor(*it);
701    SirtRef<mirror::Class> klass(self, class_linker->FindSystemClass(self, descriptor.c_str()));
702    if (klass.get() == NULL) {
703      VLOG(compiler) << "Failed to find class " << descriptor;
704      image_classes_->erase(it++);
705      self->ClearException();
706    } else {
707      ++it;
708    }
709  }
710
711  // Resolve exception classes referenced by the loaded classes. The catch logic assumes
712  // exceptions are resolved by the verifier when there is a catch block in an interested method.
713  // Do this here so that exception classes appear to have been specified image classes.
714  std::set<std::pair<uint16_t, const DexFile*> > unresolved_exception_types;
715  SirtRef<mirror::Class> java_lang_Throwable(self,
716                                     class_linker->FindSystemClass(self, "Ljava/lang/Throwable;"));
717  do {
718    unresolved_exception_types.clear();
719    class_linker->VisitClasses(ResolveCatchBlockExceptionsClassVisitor,
720                               &unresolved_exception_types);
721    for (const std::pair<uint16_t, const DexFile*>& exception_type : unresolved_exception_types) {
722      uint16_t exception_type_idx = exception_type.first;
723      const DexFile* dex_file = exception_type.second;
724      SirtRef<mirror::DexCache> dex_cache(self, class_linker->FindDexCache(*dex_file));
725      SirtRef<mirror::ClassLoader> class_loader(self, nullptr);
726      SirtRef<mirror::Class> klass(self, class_linker->ResolveType(*dex_file, exception_type_idx,
727                                                                   dex_cache, class_loader));
728      if (klass.get() == NULL) {
729        const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
730        const char* descriptor = dex_file->GetTypeDescriptor(type_id);
731        LOG(FATAL) << "Failed to resolve class " << descriptor;
732      }
733      DCHECK(java_lang_Throwable->IsAssignableFrom(klass.get()));
734    }
735    // Resolving exceptions may load classes that reference more exceptions, iterate until no
736    // more are found
737  } while (!unresolved_exception_types.empty());
738
739  // We walk the roots looking for classes so that we'll pick up the
740  // above classes plus any classes them depend on such super
741  // classes, interfaces, and the required ClassLinker roots.
742  class_linker->VisitClasses(RecordImageClassesVisitor, image_classes_.get());
743
744  CHECK_NE(image_classes_->size(), 0U);
745}
746
747static void MaybeAddToImageClasses(mirror::Class* klass, CompilerDriver::DescriptorSet* image_classes)
748    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
749  while (!klass->IsObjectClass()) {
750    ClassHelper kh(klass);
751    const char* descriptor = kh.GetDescriptor();
752    std::pair<CompilerDriver::DescriptorSet::iterator, bool> result =
753        image_classes->insert(descriptor);
754    if (result.second) {
755        VLOG(compiler) << "Adding " << descriptor << " to image classes";
756    } else {
757      return;
758    }
759    for (size_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
760      MaybeAddToImageClasses(kh.GetDirectInterface(i), image_classes);
761    }
762    if (klass->IsArrayClass()) {
763      MaybeAddToImageClasses(klass->GetComponentType(), image_classes);
764    }
765    klass = klass->GetSuperClass();
766  }
767}
768
769void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void* arg) {
770  DCHECK(object != NULL);
771  DCHECK(arg != NULL);
772  CompilerDriver* compiler_driver = reinterpret_cast<CompilerDriver*>(arg);
773  MaybeAddToImageClasses(object->GetClass(), compiler_driver->image_classes_.get());
774}
775
776void CompilerDriver::UpdateImageClasses(TimingLogger* timings) {
777  if (IsImage()) {
778    timings->NewSplit("UpdateImageClasses");
779
780    // Update image_classes_ with classes for objects created by <clinit> methods.
781    Thread* self = Thread::Current();
782    const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
783    gc::Heap* heap = Runtime::Current()->GetHeap();
784    // TODO: Image spaces only?
785    ScopedObjectAccess soa(Thread::Current());
786    WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
787    heap->VisitObjects(FindClinitImageClassesCallback, this);
788    self->EndAssertNoThreadSuspension(old_cause);
789  }
790}
791
792bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx) {
793  if (IsImage() &&
794      IsImageClass(dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_))) {
795    if (kIsDebugBuild) {
796      ScopedObjectAccess soa(Thread::Current());
797      mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
798      mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
799      CHECK(resolved_class != NULL);
800    }
801    stats_->TypeInDexCache();
802    return true;
803  } else {
804    stats_->TypeNotInDexCache();
805    return false;
806  }
807}
808
809bool CompilerDriver::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file,
810                                                        uint32_t string_idx) {
811  // See also Compiler::ResolveDexFile
812
813  bool result = false;
814  if (IsImage()) {
815    // We resolve all const-string strings when building for the image.
816    ScopedObjectAccess soa(Thread::Current());
817    SirtRef<mirror::DexCache> dex_cache(soa.Self(), Runtime::Current()->GetClassLinker()->FindDexCache(dex_file));
818    Runtime::Current()->GetClassLinker()->ResolveString(dex_file, string_idx, dex_cache);
819    result = true;
820  }
821  if (result) {
822    stats_->StringInDexCache();
823  } else {
824    stats_->StringNotInDexCache();
825  }
826  return result;
827}
828
829bool CompilerDriver::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
830                                                uint32_t type_idx,
831                                                bool* type_known_final, bool* type_known_abstract,
832                                                bool* equals_referrers_class) {
833  if (type_known_final != NULL) {
834    *type_known_final = false;
835  }
836  if (type_known_abstract != NULL) {
837    *type_known_abstract = false;
838  }
839  if (equals_referrers_class != NULL) {
840    *equals_referrers_class = false;
841  }
842  ScopedObjectAccess soa(Thread::Current());
843  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
844  // Get type from dex cache assuming it was populated by the verifier
845  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
846  if (resolved_class == NULL) {
847    stats_->TypeNeedsAccessCheck();
848    return false;  // Unknown class needs access checks.
849  }
850  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
851  if (equals_referrers_class != NULL) {
852    *equals_referrers_class = (method_id.class_idx_ == type_idx);
853  }
854  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
855  if (referrer_class == NULL) {
856    stats_->TypeNeedsAccessCheck();
857    return false;  // Incomplete referrer knowledge needs access check.
858  }
859  // Perform access check, will return true if access is ok or false if we're going to have to
860  // check this at runtime (for example for class loaders).
861  bool result = referrer_class->CanAccess(resolved_class);
862  if (result) {
863    stats_->TypeDoesntNeedAccessCheck();
864    if (type_known_final != NULL) {
865      *type_known_final = resolved_class->IsFinal() && !resolved_class->IsArrayClass();
866    }
867    if (type_known_abstract != NULL) {
868      *type_known_abstract = resolved_class->IsAbstract() && !resolved_class->IsArrayClass();
869    }
870  } else {
871    stats_->TypeNeedsAccessCheck();
872  }
873  return result;
874}
875
876bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx,
877                                                            const DexFile& dex_file,
878                                                            uint32_t type_idx) {
879  ScopedObjectAccess soa(Thread::Current());
880  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
881  // Get type from dex cache assuming it was populated by the verifier.
882  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
883  if (resolved_class == NULL) {
884    stats_->TypeNeedsAccessCheck();
885    return false;  // Unknown class needs access checks.
886  }
887  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
888  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
889  if (referrer_class == NULL) {
890    stats_->TypeNeedsAccessCheck();
891    return false;  // Incomplete referrer knowledge needs access check.
892  }
893  // Perform access and instantiable checks, will return true if access is ok or false if we're
894  // going to have to check this at runtime (for example for class loaders).
895  bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable();
896  if (result) {
897    stats_->TypeDoesntNeedAccessCheck();
898  } else {
899    stats_->TypeNeedsAccessCheck();
900  }
901  return result;
902}
903
904bool CompilerDriver::CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx,
905                                        bool* is_type_initialized, bool* use_direct_type_ptr,
906                                        uintptr_t* direct_type_ptr) {
907  ScopedObjectAccess soa(Thread::Current());
908  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
909  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
910  if (resolved_class == nullptr) {
911    return false;
912  }
913  const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot();
914  if (compiling_boot) {
915    // boot -> boot class pointers.
916    // True if the class is in the image at boot compiling time.
917    const bool is_image_class = IsImage() && IsImageClass(
918        dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_));
919    // True if pc relative load works.
920    const bool support_boot_image_fixup = GetSupportBootImageFixup();
921    if (is_image_class && support_boot_image_fixup) {
922      *is_type_initialized = resolved_class->IsInitialized();
923      *use_direct_type_ptr = false;
924      *direct_type_ptr = 0;
925      return true;
926    } else {
927      return false;
928    }
929  } else {
930    // True if the class is in the image at app compiling time.
931    const bool class_in_image =
932        Runtime::Current()->GetHeap()->FindSpaceFromObject(resolved_class, false)->IsImageSpace();
933    if (class_in_image) {
934      // boot -> app class pointers.
935      *is_type_initialized = resolved_class->IsInitialized();
936      *use_direct_type_ptr = true;
937      *direct_type_ptr = reinterpret_cast<uintptr_t>(resolved_class);
938      return true;
939    } else {
940      // app -> app class pointers.
941      // Give up because app does not have an image and class
942      // isn't created at compile time.  TODO: implement this
943      // if/when each app gets an image.
944      return false;
945    }
946  }
947}
948
949void CompilerDriver::ProcessedInstanceField(bool resolved) {
950  if (!resolved) {
951    stats_->UnresolvedInstanceField();
952  } else {
953    stats_->ResolvedInstanceField();
954  }
955}
956
957void CompilerDriver::ProcessedStaticField(bool resolved, bool local) {
958  if (!resolved) {
959    stats_->UnresolvedStaticField();
960  } else if (local) {
961    stats_->ResolvedLocalStaticField();
962  } else {
963    stats_->ResolvedStaticField();
964  }
965}
966
967void CompilerDriver::ProcessedInvoke(InvokeType invoke_type, int flags) {
968  stats_->ProcessedInvoke(invoke_type, flags);
969}
970
971bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
972                                              bool is_put, MemberOffset* field_offset,
973                                              bool* is_volatile) {
974  ScopedObjectAccess soa(Thread::Current());
975  // Try to resolve the field and compiling method's class.
976  mirror::ArtField* resolved_field;
977  mirror::Class* referrer_class;
978  mirror::DexCache* dex_cache;
979  {
980    SirtRef<mirror::DexCache> dex_cache_sirt(soa.Self(),
981        mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()));
982    SirtRef<mirror::ClassLoader> class_loader_sirt(soa.Self(),
983        soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
984    SirtRef<mirror::ArtField> resolved_field_sirt(soa.Self(),
985        ResolveField(soa, dex_cache_sirt, class_loader_sirt, mUnit, field_idx, false));
986    referrer_class = (resolved_field_sirt.get() != nullptr)
987        ? ResolveCompilingMethodsClass(soa, dex_cache_sirt, class_loader_sirt, mUnit) : nullptr;
988    resolved_field = resolved_field_sirt.get();
989    dex_cache = dex_cache_sirt.get();
990  }
991  bool result = false;
992  if (resolved_field != nullptr && referrer_class != nullptr) {
993    *is_volatile = IsFieldVolatile(resolved_field);
994    std::pair<bool, bool> fast_path = IsFastInstanceField(
995        dex_cache, referrer_class, resolved_field, field_idx, field_offset);
996    result = is_put ? fast_path.second : fast_path.first;
997  }
998  if (!result) {
999    // Conservative defaults.
1000    *is_volatile = true;
1001    *field_offset = MemberOffset(static_cast<size_t>(-1));
1002  }
1003  ProcessedInstanceField(result);
1004  return result;
1005}
1006
1007bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
1008                                            bool is_put, MemberOffset* field_offset,
1009                                            uint32_t* storage_index, bool* is_referrers_class,
1010                                            bool* is_volatile, bool* is_initialized) {
1011  ScopedObjectAccess soa(Thread::Current());
1012  // Try to resolve the field and compiling method's class.
1013  mirror::ArtField* resolved_field;
1014  mirror::Class* referrer_class;
1015  mirror::DexCache* dex_cache;
1016  {
1017    SirtRef<mirror::DexCache> dex_cache_sirt(soa.Self(),
1018        mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()));
1019    SirtRef<mirror::ClassLoader> class_loader_sirt(soa.Self(),
1020        soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
1021    SirtRef<mirror::ArtField> resolved_field_sirt(soa.Self(),
1022        ResolveField(soa, dex_cache_sirt, class_loader_sirt, mUnit, field_idx, true));
1023    referrer_class = (resolved_field_sirt.get() != nullptr)
1024        ? ResolveCompilingMethodsClass(soa, dex_cache_sirt, class_loader_sirt, mUnit) : nullptr;
1025    resolved_field = resolved_field_sirt.get();
1026    dex_cache = dex_cache_sirt.get();
1027  }
1028  bool result = false;
1029  if (resolved_field != nullptr && referrer_class != nullptr) {
1030    *is_volatile = IsFieldVolatile(resolved_field);
1031    std::pair<bool, bool> fast_path = IsFastStaticField(
1032        dex_cache, referrer_class, resolved_field, field_idx, field_offset,
1033        storage_index, is_referrers_class, is_initialized);
1034    result = is_put ? fast_path.second : fast_path.first;
1035  }
1036  if (!result) {
1037    // Conservative defaults.
1038    *is_volatile = true;
1039    *field_offset = MemberOffset(static_cast<size_t>(-1));
1040    *storage_index = -1;
1041    *is_referrers_class = false;
1042    *is_initialized = false;
1043  }
1044  ProcessedStaticField(result, *is_referrers_class);
1045  return result;
1046}
1047
1048void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type,
1049                                                   bool no_guarantee_of_dex_cache_entry,
1050                                                   mirror::Class* referrer_class,
1051                                                   mirror::ArtMethod* method,
1052                                                   int* stats_flags,
1053                                                   MethodReference* target_method,
1054                                                   uintptr_t* direct_code,
1055                                                   uintptr_t* direct_method) {
1056  // For direct and static methods compute possible direct_code and direct_method values, ie
1057  // an address for the Method* being invoked and an address of the code for that Method*.
1058  // For interface calls compute a value for direct_method that is the interface method being
1059  // invoked, so this can be passed to the out-of-line runtime support code.
1060  *direct_code = 0;
1061  *direct_method = 0;
1062  bool use_dex_cache = false;
1063  const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot();
1064  if (compiler_->IsPortable()) {
1065    if (sharp_type != kStatic && sharp_type != kDirect) {
1066      return;
1067    }
1068    use_dex_cache = true;
1069  } else {
1070    if (sharp_type != kStatic && sharp_type != kDirect) {
1071      return;
1072    }
1073    // TODO: support patching on all architectures.
1074    use_dex_cache = compiling_boot && !support_boot_image_fixup_;
1075  }
1076  bool method_code_in_boot = (method->GetDeclaringClass()->GetClassLoader() == nullptr);
1077  if (!use_dex_cache) {
1078    if (!method_code_in_boot) {
1079      use_dex_cache = true;
1080    } else {
1081      bool has_clinit_trampoline =
1082          method->IsStatic() && !method->GetDeclaringClass()->IsInitialized();
1083      if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) {
1084        // Ensure we run the clinit trampoline unless we are invoking a static method in the same
1085        // class.
1086        use_dex_cache = true;
1087      }
1088    }
1089  }
1090  if (method_code_in_boot) {
1091    *stats_flags |= kFlagDirectCallToBoot | kFlagDirectMethodToBoot;
1092  }
1093  if (!use_dex_cache && compiling_boot) {
1094    MethodHelper mh(method);
1095    if (!IsImageClass(mh.GetDeclaringClassDescriptor())) {
1096      // We can only branch directly to Methods that are resolved in the DexCache.
1097      // Otherwise we won't invoke the resolution trampoline.
1098      use_dex_cache = true;
1099    }
1100  }
1101  // The method is defined not within this dex file. We need a dex cache slot within the current
1102  // dex file or direct pointers.
1103  bool must_use_direct_pointers = false;
1104  if (target_method->dex_file == method->GetDeclaringClass()->GetDexCache()->GetDexFile()) {
1105    target_method->dex_method_index = method->GetDexMethodIndex();
1106  } else {
1107    if (no_guarantee_of_dex_cache_entry) {
1108      // See if the method is also declared in this dex cache.
1109      uint32_t dex_method_idx = MethodHelper(method).FindDexMethodIndexInOtherDexFile(
1110          *target_method->dex_file, target_method->dex_method_index);
1111      if (dex_method_idx != DexFile::kDexNoIndex) {
1112        target_method->dex_method_index = dex_method_idx;
1113      } else {
1114        if (compiling_boot) {
1115          target_method->dex_method_index = method->GetDexMethodIndex();
1116          target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1117        }
1118        must_use_direct_pointers = true;
1119      }
1120    }
1121  }
1122  if (use_dex_cache) {
1123    if (must_use_direct_pointers) {
1124      // Fail. Test above showed the only safe dispatch was via the dex cache, however, the direct
1125      // pointers are required as the dex cache lacks an appropriate entry.
1126      VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method);
1127    } else {
1128      *type = sharp_type;
1129    }
1130  } else {
1131    if (compiling_boot) {
1132      *type = sharp_type;
1133      *direct_method = -1;
1134      *direct_code = -1;
1135    } else {
1136      bool method_in_image =
1137          Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace();
1138      if (method_in_image) {
1139        CHECK(!method->IsAbstract());
1140        *type = sharp_type;
1141        *direct_method = reinterpret_cast<uintptr_t>(method);
1142        *direct_code = compiler_->GetEntryPointOf(method);
1143        target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1144        target_method->dex_method_index = method->GetDexMethodIndex();
1145      } else if (!must_use_direct_pointers) {
1146        // Set the code and rely on the dex cache for the method.
1147        *type = sharp_type;
1148        *direct_code = compiler_->GetEntryPointOf(method);
1149      } else {
1150        // Direct pointers were required but none were available.
1151        VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method);
1152      }
1153    }
1154  }
1155}
1156
1157bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
1158                                       bool update_stats, bool enable_devirtualization,
1159                                       InvokeType* invoke_type, MethodReference* target_method,
1160                                       int* vtable_idx, uintptr_t* direct_code,
1161                                       uintptr_t* direct_method) {
1162  InvokeType orig_invoke_type = *invoke_type;
1163  int stats_flags = 0;
1164  ScopedObjectAccess soa(Thread::Current());
1165  // Try to resolve the method and compiling method's class.
1166  mirror::ArtMethod* resolved_method;
1167  mirror::Class* referrer_class;
1168  SirtRef<mirror::DexCache> dex_cache(soa.Self(),
1169      mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()));
1170  SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
1171      soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
1172  {
1173    uint32_t method_idx = target_method->dex_method_index;
1174    SirtRef<mirror::ArtMethod> resolved_method_sirt(soa.Self(),
1175        ResolveMethod(soa, dex_cache, class_loader, mUnit, method_idx, orig_invoke_type));
1176    referrer_class = (resolved_method_sirt.get() != nullptr)
1177        ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader, mUnit) : nullptr;
1178    resolved_method = resolved_method_sirt.get();
1179  }
1180  bool result = false;
1181  if (resolved_method != nullptr) {
1182    *vtable_idx = GetResolvedMethodVTableIndex(resolved_method, orig_invoke_type);
1183
1184    if (enable_devirtualization) {
1185      DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1186      const MethodReference* devirt_target = mUnit->GetVerifiedMethod()->GetDevirtTarget(dex_pc);
1187
1188      stats_flags = IsFastInvoke(
1189          soa, dex_cache, class_loader, mUnit, referrer_class, resolved_method,
1190          invoke_type, target_method, devirt_target, direct_code, direct_method);
1191      result = stats_flags != 0;
1192    } else {
1193      // Devirtualization not enabled. Inline IsFastInvoke(), dropping the devirtualization parts.
1194      if (UNLIKELY(referrer_class == nullptr) ||
1195          UNLIKELY(!referrer_class->CanAccessResolvedMethod(resolved_method->GetDeclaringClass(),
1196                                                            resolved_method, dex_cache.get(),
1197                                                            target_method->dex_method_index)) ||
1198          *invoke_type == kSuper) {
1199        // Slow path. (Without devirtualization, all super calls go slow path as well.)
1200      } else {
1201        // Sharpening failed so generate a regular resolved method dispatch.
1202        stats_flags = kFlagMethodResolved;
1203        GetCodeAndMethodForDirectCall(invoke_type, *invoke_type, false, referrer_class, resolved_method,
1204                                      &stats_flags, target_method, direct_code, direct_method);
1205        result = true;
1206      }
1207    }
1208  }
1209  if (!result) {
1210    // Conservative defaults.
1211    *vtable_idx = -1;
1212    *direct_code = 0u;
1213    *direct_method = 0u;
1214  }
1215  if (update_stats) {
1216    ProcessedInvoke(orig_invoke_type, stats_flags);
1217  }
1218  return result;
1219}
1220
1221const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file,
1222                                                        uint32_t method_idx) const {
1223  MethodReference ref(dex_file, method_idx);
1224  return verification_results_->GetVerifiedMethod(ref);
1225}
1226
1227bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) {
1228  DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1229  bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc);
1230  if (result) {
1231    stats_->SafeCast();
1232  } else {
1233    stats_->NotASafeCast();
1234  }
1235  return result;
1236}
1237
1238void CompilerDriver::AddCodePatch(const DexFile* dex_file,
1239                                  uint16_t referrer_class_def_idx,
1240                                  uint32_t referrer_method_idx,
1241                                  InvokeType referrer_invoke_type,
1242                                  uint32_t target_method_idx,
1243                                  const DexFile* target_dex_file,
1244                                  InvokeType target_invoke_type,
1245                                  size_t literal_offset) {
1246  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1247  code_to_patch_.push_back(new CallPatchInformation(dex_file,
1248                                                    referrer_class_def_idx,
1249                                                    referrer_method_idx,
1250                                                    referrer_invoke_type,
1251                                                    target_method_idx,
1252                                                    target_dex_file,
1253                                                    target_invoke_type,
1254                                                    literal_offset));
1255}
1256void CompilerDriver::AddRelativeCodePatch(const DexFile* dex_file,
1257                                          uint16_t referrer_class_def_idx,
1258                                          uint32_t referrer_method_idx,
1259                                          InvokeType referrer_invoke_type,
1260                                          uint32_t target_method_idx,
1261                                          const DexFile* target_dex_file,
1262                                          InvokeType target_invoke_type,
1263                                          size_t literal_offset,
1264                                          int32_t pc_relative_offset) {
1265  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1266  code_to_patch_.push_back(new RelativeCallPatchInformation(dex_file,
1267                                                            referrer_class_def_idx,
1268                                                            referrer_method_idx,
1269                                                            referrer_invoke_type,
1270                                                            target_method_idx,
1271                                                            target_dex_file,
1272                                                            target_invoke_type,
1273                                                            literal_offset,
1274                                                            pc_relative_offset));
1275}
1276void CompilerDriver::AddMethodPatch(const DexFile* dex_file,
1277                                    uint16_t referrer_class_def_idx,
1278                                    uint32_t referrer_method_idx,
1279                                    InvokeType referrer_invoke_type,
1280                                    uint32_t target_method_idx,
1281                                    const DexFile* target_dex_file,
1282                                    InvokeType target_invoke_type,
1283                                    size_t literal_offset) {
1284  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1285  methods_to_patch_.push_back(new CallPatchInformation(dex_file,
1286                                                       referrer_class_def_idx,
1287                                                       referrer_method_idx,
1288                                                       referrer_invoke_type,
1289                                                       target_method_idx,
1290                                                       target_dex_file,
1291                                                       target_invoke_type,
1292                                                       literal_offset));
1293}
1294void CompilerDriver::AddClassPatch(const DexFile* dex_file,
1295                                    uint16_t referrer_class_def_idx,
1296                                    uint32_t referrer_method_idx,
1297                                    uint32_t target_type_idx,
1298                                    size_t literal_offset) {
1299  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1300  classes_to_patch_.push_back(new TypePatchInformation(dex_file,
1301                                                       referrer_class_def_idx,
1302                                                       referrer_method_idx,
1303                                                       target_type_idx,
1304                                                       literal_offset));
1305}
1306
1307class ParallelCompilationManager {
1308 public:
1309  typedef void Callback(const ParallelCompilationManager* manager, size_t index);
1310
1311  ParallelCompilationManager(ClassLinker* class_linker,
1312                             jobject class_loader,
1313                             CompilerDriver* compiler,
1314                             const DexFile* dex_file,
1315                             ThreadPool* thread_pool)
1316    : index_(0),
1317      class_linker_(class_linker),
1318      class_loader_(class_loader),
1319      compiler_(compiler),
1320      dex_file_(dex_file),
1321      thread_pool_(thread_pool) {}
1322
1323  ClassLinker* GetClassLinker() const {
1324    CHECK(class_linker_ != NULL);
1325    return class_linker_;
1326  }
1327
1328  jobject GetClassLoader() const {
1329    return class_loader_;
1330  }
1331
1332  CompilerDriver* GetCompiler() const {
1333    CHECK(compiler_ != NULL);
1334    return compiler_;
1335  }
1336
1337  const DexFile* GetDexFile() const {
1338    CHECK(dex_file_ != NULL);
1339    return dex_file_;
1340  }
1341
1342  void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) {
1343    Thread* self = Thread::Current();
1344    self->AssertNoPendingException();
1345    CHECK_GT(work_units, 0U);
1346
1347    index_ = begin;
1348    for (size_t i = 0; i < work_units; ++i) {
1349      thread_pool_->AddTask(self, new ForAllClosure(this, end, callback));
1350    }
1351    thread_pool_->StartWorkers(self);
1352
1353    // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1354    // thread destructor's called below perform join).
1355    CHECK_NE(self->GetState(), kRunnable);
1356
1357    // Wait for all the worker threads to finish.
1358    thread_pool_->Wait(self, true, false);
1359  }
1360
1361  size_t NextIndex() {
1362    return index_.FetchAndAdd(1);
1363  }
1364
1365 private:
1366  class ForAllClosure : public Task {
1367   public:
1368    ForAllClosure(ParallelCompilationManager* manager, size_t end, Callback* callback)
1369        : manager_(manager),
1370          end_(end),
1371          callback_(callback) {}
1372
1373    virtual void Run(Thread* self) {
1374      while (true) {
1375        const size_t index = manager_->NextIndex();
1376        if (UNLIKELY(index >= end_)) {
1377          break;
1378        }
1379        callback_(manager_, index);
1380        self->AssertNoPendingException();
1381      }
1382    }
1383
1384    virtual void Finalize() {
1385      delete this;
1386    }
1387
1388   private:
1389    ParallelCompilationManager* const manager_;
1390    const size_t end_;
1391    Callback* const callback_;
1392  };
1393
1394  AtomicInteger index_;
1395  ClassLinker* const class_linker_;
1396  const jobject class_loader_;
1397  CompilerDriver* const compiler_;
1398  const DexFile* const dex_file_;
1399  ThreadPool* const thread_pool_;
1400
1401  DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager);
1402};
1403
1404// Return true if the class should be skipped during compilation.
1405//
1406// The first case where we skip is for redundant class definitions in
1407// the boot classpath. We skip all but the first definition in that case.
1408//
1409// The second case where we skip is when an app bundles classes found
1410// in the boot classpath. Since at runtime we will select the class from
1411// the boot classpath, we ignore the one from the app.
1412static bool SkipClass(ClassLinker* class_linker, jobject class_loader, const DexFile& dex_file,
1413                      const DexFile::ClassDef& class_def) {
1414  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1415  if (class_loader == NULL) {
1416    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_linker->GetBootClassPath());
1417    CHECK(pair.second != NULL);
1418    if (pair.first != &dex_file) {
1419      LOG(WARNING) << "Skipping class " << descriptor << " from " << dex_file.GetLocation()
1420                   << " previously found in " << pair.first->GetLocation();
1421      return true;
1422    }
1423    return false;
1424  }
1425  return class_linker->IsInBootClassPath(descriptor);
1426}
1427
1428// A fast version of SkipClass above if the class pointer is available
1429// that avoids the expensive FindInClassPath search.
1430static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass)
1431    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1432  DCHECK(klass != NULL);
1433  const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile();
1434  if (&dex_file != &original_dex_file) {
1435    if (class_loader == NULL) {
1436      LOG(WARNING) << "Skipping class " << PrettyDescriptor(klass) << " from "
1437                   << dex_file.GetLocation() << " previously found in "
1438                   << original_dex_file.GetLocation();
1439    }
1440    return true;
1441  }
1442  return false;
1443}
1444
1445static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager,
1446                                         size_t class_def_index)
1447    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1448  ATRACE_CALL();
1449  Thread* self = Thread::Current();
1450  jobject jclass_loader = manager->GetClassLoader();
1451  const DexFile& dex_file = *manager->GetDexFile();
1452  ClassLinker* class_linker = manager->GetClassLinker();
1453
1454  // If an instance field is final then we need to have a barrier on the return, static final
1455  // fields are assigned within the lock held for class initialization. Conservatively assume
1456  // constructor barriers are always required.
1457  bool requires_constructor_barrier = true;
1458
1459  // Method and Field are the worst. We can't resolve without either
1460  // context from the code use (to disambiguate virtual vs direct
1461  // method and instance vs static field) or from class
1462  // definitions. While the compiler will resolve what it can as it
1463  // needs it, here we try to resolve fields and methods used in class
1464  // definitions, since many of them many never be referenced by
1465  // generated code.
1466  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1467  if (!SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1468    ScopedObjectAccess soa(self);
1469    SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader));
1470    SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file));
1471    // Resolve the class.
1472    mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
1473                                                     class_loader);
1474    bool resolve_fields_and_methods;
1475    if (klass == NULL) {
1476      // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
1477      // attempt to resolve methods and fields when there is no declaring class.
1478      CHECK(soa.Self()->IsExceptionPending());
1479      soa.Self()->ClearException();
1480      resolve_fields_and_methods = false;
1481    } else {
1482      resolve_fields_and_methods = manager->GetCompiler()->IsImage();
1483    }
1484    // Note the class_data pointer advances through the headers,
1485    // static fields, instance fields, direct methods, and virtual
1486    // methods.
1487    const byte* class_data = dex_file.GetClassData(class_def);
1488    if (class_data == NULL) {
1489      // Empty class such as a marker interface.
1490      requires_constructor_barrier = false;
1491    } else {
1492      ClassDataItemIterator it(dex_file, class_data);
1493      while (it.HasNextStaticField()) {
1494        if (resolve_fields_and_methods) {
1495          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1496                                                               dex_cache, class_loader, true);
1497          if (field == NULL) {
1498            CHECK(soa.Self()->IsExceptionPending());
1499            soa.Self()->ClearException();
1500          }
1501        }
1502        it.Next();
1503      }
1504      // We require a constructor barrier if there are final instance fields.
1505      requires_constructor_barrier = false;
1506      while (it.HasNextInstanceField()) {
1507        if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
1508          requires_constructor_barrier = true;
1509        }
1510        if (resolve_fields_and_methods) {
1511          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1512                                                               dex_cache, class_loader, false);
1513          if (field == NULL) {
1514            CHECK(soa.Self()->IsExceptionPending());
1515            soa.Self()->ClearException();
1516          }
1517        }
1518        it.Next();
1519      }
1520      if (resolve_fields_and_methods) {
1521        while (it.HasNextDirectMethod()) {
1522          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1523                                                                  dex_cache, class_loader, NULL,
1524                                                                  it.GetMethodInvokeType(class_def));
1525          if (method == NULL) {
1526            CHECK(soa.Self()->IsExceptionPending());
1527            soa.Self()->ClearException();
1528          }
1529          it.Next();
1530        }
1531        while (it.HasNextVirtualMethod()) {
1532          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1533                                                                  dex_cache, class_loader, NULL,
1534                                                                  it.GetMethodInvokeType(class_def));
1535          if (method == NULL) {
1536            CHECK(soa.Self()->IsExceptionPending());
1537            soa.Self()->ClearException();
1538          }
1539          it.Next();
1540        }
1541        DCHECK(!it.HasNext());
1542      }
1543    }
1544  }
1545  if (requires_constructor_barrier) {
1546    manager->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index);
1547  }
1548}
1549
1550static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx)
1551    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1552  // Class derived values are more complicated, they require the linker and loader.
1553  ScopedObjectAccess soa(Thread::Current());
1554  ClassLinker* class_linker = manager->GetClassLinker();
1555  const DexFile& dex_file = *manager->GetDexFile();
1556  SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file));
1557  SirtRef<mirror::ClassLoader> class_loader(
1558      soa.Self(), soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()));
1559  mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
1560
1561  if (klass == NULL) {
1562    CHECK(soa.Self()->IsExceptionPending());
1563    mirror::Throwable* exception = soa.Self()->GetException(NULL);
1564    VLOG(compiler) << "Exception during type resolution: " << exception->Dump();
1565    if (strcmp("Ljava/lang/OutOfMemoryError;",
1566               ClassHelper(exception->GetClass()).GetDescriptor()) == 0) {
1567      // There's little point continuing compilation if the heap is exhausted.
1568      LOG(FATAL) << "Out of memory during type resolution for compilation";
1569    }
1570    soa.Self()->ClearException();
1571  }
1572}
1573
1574void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
1575                                    ThreadPool* thread_pool, TimingLogger* timings) {
1576  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1577
1578  // TODO: we could resolve strings here, although the string table is largely filled with class
1579  //       and method names.
1580
1581  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1582  if (IsImage()) {
1583    // For images we resolve all types, such as array, whereas for applications just those with
1584    // classdefs are resolved by ResolveClassFieldsAndMethods.
1585    timings->NewSplit("Resolve Types");
1586    context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
1587  }
1588
1589  timings->NewSplit("Resolve MethodsAndFields");
1590  context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
1591}
1592
1593void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1594                            ThreadPool* thread_pool, TimingLogger* timings) {
1595  for (size_t i = 0; i != dex_files.size(); ++i) {
1596    const DexFile* dex_file = dex_files[i];
1597    CHECK(dex_file != NULL);
1598    VerifyDexFile(class_loader, *dex_file, thread_pool, timings);
1599  }
1600}
1601
1602static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index)
1603    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1604  ATRACE_CALL();
1605  ScopedObjectAccess soa(Thread::Current());
1606  const DexFile& dex_file = *manager->GetDexFile();
1607  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1608  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1609  ClassLinker* class_linker = manager->GetClassLinker();
1610  jobject jclass_loader = manager->GetClassLoader();
1611  SirtRef<mirror::ClassLoader> class_loader(
1612      soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader));
1613  SirtRef<mirror::Class> klass(soa.Self(), class_linker->FindClass(soa.Self(), descriptor,
1614                                                                   class_loader));
1615  if (klass.get() == nullptr) {
1616    CHECK(soa.Self()->IsExceptionPending());
1617    soa.Self()->ClearException();
1618
1619    /*
1620     * At compile time, we can still structurally verify the class even if FindClass fails.
1621     * This is to ensure the class is structurally sound for compilation. An unsound class
1622     * will be rejected by the verifier and later skipped during compilation in the compiler.
1623     */
1624    SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file));
1625    std::string error_msg;
1626    if (verifier::MethodVerifier::VerifyClass(&dex_file, dex_cache, class_loader, &class_def, true,
1627                                              &error_msg) ==
1628                                                  verifier::MethodVerifier::kHardFailure) {
1629      LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor)
1630                 << " because: " << error_msg;
1631    }
1632  } else if (!SkipClass(jclass_loader, dex_file, klass.get())) {
1633    CHECK(klass->IsResolved()) << PrettyClass(klass.get());
1634    class_linker->VerifyClass(klass);
1635
1636    if (klass->IsErroneous()) {
1637      // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
1638      CHECK(soa.Self()->IsExceptionPending());
1639      soa.Self()->ClearException();
1640    }
1641
1642    CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
1643        << PrettyDescriptor(klass.get()) << ": state=" << klass->GetStatus();
1644  }
1645  soa.Self()->AssertNoPendingException();
1646}
1647
1648void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
1649                                   ThreadPool* thread_pool, TimingLogger* timings) {
1650  timings->NewSplit("Verify Dex File");
1651  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1652  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1653  context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
1654}
1655
1656static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
1657    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1658  ATRACE_CALL();
1659  jobject jclass_loader = manager->GetClassLoader();
1660  const DexFile& dex_file = *manager->GetDexFile();
1661  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1662  const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_);
1663  const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_);
1664
1665  ScopedObjectAccess soa(Thread::Current());
1666  SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
1667                                            soa.Decode<mirror::ClassLoader*>(jclass_loader));
1668  SirtRef<mirror::Class> klass(soa.Self(),
1669                               manager->GetClassLinker()->FindClass(soa.Self(), descriptor,
1670                                                                    class_loader));
1671
1672  if (klass.get() != nullptr && !SkipClass(jclass_loader, dex_file, klass.get())) {
1673    // Only try to initialize classes that were successfully verified.
1674    if (klass->IsVerified()) {
1675      // Attempt to initialize the class but bail if we either need to initialize the super-class
1676      // or static fields.
1677      manager->GetClassLinker()->EnsureInitialized(klass, false, false);
1678      if (!klass->IsInitialized()) {
1679        // We don't want non-trivial class initialization occurring on multiple threads due to
1680        // deadlock problems. For example, a parent class is initialized (holding its lock) that
1681        // refers to a sub-class in its static/class initializer causing it to try to acquire the
1682        // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock)
1683        // after first initializing its parents, whose locks are acquired. This leads to a
1684        // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock.
1685        // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
1686        // than use a special Object for the purpose we use the Class of java.lang.Class.
1687        SirtRef<mirror::Class> sirt_klass(soa.Self(), klass->GetClass());
1688        ObjectLock<mirror::Class> lock(soa.Self(), &sirt_klass);
1689        // Attempt to initialize allowing initialization of parent classes but still not static
1690        // fields.
1691        manager->GetClassLinker()->EnsureInitialized(klass, false, true);
1692        if (!klass->IsInitialized()) {
1693          // We need to initialize static fields, we only do this for image classes that aren't
1694          // marked with the $NoPreloadHolder (which implies this should not be initialized early).
1695          bool can_init_static_fields = manager->GetCompiler()->IsImage() &&
1696              manager->GetCompiler()->IsImageClass(descriptor) &&
1697              !StringPiece(descriptor).ends_with("$NoPreloadHolder;");
1698          if (can_init_static_fields) {
1699            VLOG(compiler) << "Initializing: " << descriptor;
1700            if (strcmp("Ljava/lang/Void;", descriptor) == 0) {
1701              // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
1702              ObjectLock<mirror::Class> lock(soa.Self(), &klass);
1703              mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
1704              CHECK_EQ(fields->GetLength(), 1);
1705              fields->Get(0)->SetObj<false>(klass.get(),
1706                                                     manager->GetClassLinker()->FindPrimitiveClass('V'));
1707              klass->SetStatus(mirror::Class::kStatusInitialized, soa.Self());
1708            } else {
1709              // TODO multithreading support. We should ensure the current compilation thread has
1710              // exclusive access to the runtime and the transaction. To achieve this, we could use
1711              // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity
1712              // checks in Thread::AssertThreadSuspensionIsAllowable.
1713              Runtime* const runtime = Runtime::Current();
1714              Transaction transaction;
1715
1716              // Run the class initializer in transaction mode.
1717              runtime->EnterTransactionMode(&transaction);
1718              const mirror::Class::Status old_status = klass->GetStatus();
1719              bool success = manager->GetClassLinker()->EnsureInitialized(klass, true, true);
1720              // TODO we detach transaction from runtime to indicate we quit the transactional
1721              // mode which prevents the GC from visiting objects modified during the transaction.
1722              // Ensure GC is not run so don't access freed objects when aborting transaction.
1723              const char* old_casue = soa.Self()->StartAssertNoThreadSuspension("Transaction end");
1724              runtime->ExitTransactionMode();
1725
1726              if (!success) {
1727                CHECK(soa.Self()->IsExceptionPending());
1728                ThrowLocation throw_location;
1729                mirror::Throwable* exception = soa.Self()->GetException(&throw_location);
1730                VLOG(compiler) << "Initialization of " << descriptor << " aborted because of "
1731                               << exception->Dump();
1732                soa.Self()->ClearException();
1733                transaction.Abort();
1734                CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored";
1735              }
1736              soa.Self()->EndAssertNoThreadSuspension(old_casue);
1737            }
1738          }
1739        }
1740        soa.Self()->AssertNoPendingException();
1741      }
1742    }
1743    // Record the final class status if necessary.
1744    ClassReference ref(manager->GetDexFile(), class_def_index);
1745    manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
1746  }
1747  // Clear any class not found or verification exceptions.
1748  soa.Self()->ClearException();
1749}
1750
1751void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
1752                                       ThreadPool* thread_pool, TimingLogger* timings) {
1753  timings->NewSplit("InitializeNoClinit");
1754  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1755  ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
1756  size_t thread_count;
1757  if (IsImage()) {
1758    // TODO: remove this when transactional mode supports multithreading.
1759    thread_count = 1U;
1760  } else {
1761    thread_count = thread_count_;
1762  }
1763  context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count);
1764  if (IsImage()) {
1765    // Prune garbage objects created during aborted transactions.
1766    Runtime::Current()->GetHeap()->CollectGarbage(true);
1767  }
1768}
1769
1770void CompilerDriver::InitializeClasses(jobject class_loader,
1771                                       const std::vector<const DexFile*>& dex_files,
1772                                       ThreadPool* thread_pool, TimingLogger* timings) {
1773  for (size_t i = 0; i != dex_files.size(); ++i) {
1774    const DexFile* dex_file = dex_files[i];
1775    CHECK(dex_file != NULL);
1776    InitializeClasses(class_loader, *dex_file, thread_pool, timings);
1777  }
1778}
1779
1780void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1781                             ThreadPool* thread_pool, TimingLogger* timings) {
1782  for (size_t i = 0; i != dex_files.size(); ++i) {
1783    const DexFile* dex_file = dex_files[i];
1784    CHECK(dex_file != NULL);
1785    CompileDexFile(class_loader, *dex_file, thread_pool, timings);
1786  }
1787}
1788
1789void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) {
1790  ATRACE_CALL();
1791  jobject jclass_loader = manager->GetClassLoader();
1792  const DexFile& dex_file = *manager->GetDexFile();
1793  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1794  ClassLinker* class_linker = manager->GetClassLinker();
1795  if (SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1796    return;
1797  }
1798  ClassReference ref(&dex_file, class_def_index);
1799  // Skip compiling classes with generic verifier failures since they will still fail at runtime
1800  if (manager->GetCompiler()->verification_results_->IsClassRejected(ref)) {
1801    return;
1802  }
1803  const byte* class_data = dex_file.GetClassData(class_def);
1804  if (class_data == NULL) {
1805    // empty class, probably a marker interface
1806    return;
1807  }
1808
1809  // Can we run DEX-to-DEX compiler on this class ?
1810  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
1811  {
1812    ScopedObjectAccess soa(Thread::Current());
1813    SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
1814                                              soa.Decode<mirror::ClassLoader*>(jclass_loader));
1815    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(soa.Self(), class_loader, dex_file,
1816                                                               class_def);
1817  }
1818  ClassDataItemIterator it(dex_file, class_data);
1819  // Skip fields
1820  while (it.HasNextStaticField()) {
1821    it.Next();
1822  }
1823  while (it.HasNextInstanceField()) {
1824    it.Next();
1825  }
1826  CompilerDriver* driver = manager->GetCompiler();
1827  // Compile direct methods
1828  int64_t previous_direct_method_idx = -1;
1829  while (it.HasNextDirectMethod()) {
1830    uint32_t method_idx = it.GetMemberIndex();
1831    if (method_idx == previous_direct_method_idx) {
1832      // smali can create dex files with two encoded_methods sharing the same method_idx
1833      // http://code.google.com/p/smali/issues/detail?id=119
1834      it.Next();
1835      continue;
1836    }
1837    previous_direct_method_idx = method_idx;
1838    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1839                          it.GetMethodInvokeType(class_def), class_def_index,
1840                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1841    it.Next();
1842  }
1843  // Compile virtual methods
1844  int64_t previous_virtual_method_idx = -1;
1845  while (it.HasNextVirtualMethod()) {
1846    uint32_t method_idx = it.GetMemberIndex();
1847    if (method_idx == previous_virtual_method_idx) {
1848      // smali can create dex files with two encoded_methods sharing the same method_idx
1849      // http://code.google.com/p/smali/issues/detail?id=119
1850      it.Next();
1851      continue;
1852    }
1853    previous_virtual_method_idx = method_idx;
1854    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1855                          it.GetMethodInvokeType(class_def), class_def_index,
1856                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1857    it.Next();
1858  }
1859  DCHECK(!it.HasNext());
1860}
1861
1862void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
1863                                    ThreadPool* thread_pool, TimingLogger* timings) {
1864  timings->NewSplit("Compile Dex File");
1865  ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this,
1866                                     &dex_file, thread_pool);
1867  context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
1868}
1869
1870void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
1871                                   InvokeType invoke_type, uint16_t class_def_idx,
1872                                   uint32_t method_idx, jobject class_loader,
1873                                   const DexFile& dex_file,
1874                                   DexToDexCompilationLevel dex_to_dex_compilation_level) {
1875  CompiledMethod* compiled_method = NULL;
1876  uint64_t start_ns = NanoTime();
1877
1878  if ((access_flags & kAccNative) != 0) {
1879    // Are we interpreting only and have support for generic JNI down calls?
1880    if (!compiler_options_->IsCompilationEnabled() &&
1881        (instruction_set_ == kX86_64 || instruction_set_ == kArm64)) {
1882      // Leaving this empty will trigger the generic JNI version
1883    } else {
1884      compiled_method = compiler_->JniCompile(*this, access_flags, method_idx, dex_file);
1885      CHECK(compiled_method != NULL);
1886    }
1887  } else if ((access_flags & kAccAbstract) != 0) {
1888  } else {
1889    MethodReference method_ref(&dex_file, method_idx);
1890    bool compile = verification_results_->IsCandidateForCompilation(method_ref, access_flags);
1891    if (compile) {
1892      // NOTE: if compiler declines to compile this method, it will return NULL.
1893      compiled_method = compiler_->Compile(
1894          *this, code_item, access_flags, invoke_type, class_def_idx,
1895          method_idx, class_loader, dex_file);
1896    } else if (dex_to_dex_compilation_level != kDontDexToDexCompile) {
1897      // TODO: add a mode to disable DEX-to-DEX compilation ?
1898      (*dex_to_dex_compiler_)(*this, code_item, access_flags,
1899                              invoke_type, class_def_idx,
1900                              method_idx, class_loader, dex_file,
1901                              dex_to_dex_compilation_level);
1902    }
1903  }
1904  uint64_t duration_ns = NanoTime() - start_ns;
1905  if (duration_ns > MsToNs(compiler_->GetMaximumCompilationTimeBeforeWarning())) {
1906    LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
1907                 << " took " << PrettyDuration(duration_ns);
1908  }
1909
1910  Thread* self = Thread::Current();
1911  if (compiled_method != NULL) {
1912    MethodReference ref(&dex_file, method_idx);
1913    DCHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
1914    {
1915      MutexLock mu(self, compiled_methods_lock_);
1916      compiled_methods_.Put(ref, compiled_method);
1917    }
1918    DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
1919  }
1920
1921  if (self->IsExceptionPending()) {
1922    ScopedObjectAccess soa(self);
1923    LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
1924        << self->GetException(NULL)->Dump();
1925  }
1926}
1927
1928CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
1929  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1930  ClassTable::const_iterator it = compiled_classes_.find(ref);
1931  if (it == compiled_classes_.end()) {
1932    return NULL;
1933  }
1934  CHECK(it->second != NULL);
1935  return it->second;
1936}
1937
1938void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) {
1939  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1940  auto it = compiled_classes_.find(ref);
1941  if (it == compiled_classes_.end() || it->second->GetStatus() != status) {
1942    // An entry doesn't exist or the status is lower than the new status.
1943    if (it != compiled_classes_.end()) {
1944      CHECK_GT(status, it->second->GetStatus());
1945      delete it->second;
1946    }
1947    switch (status) {
1948      case mirror::Class::kStatusNotReady:
1949      case mirror::Class::kStatusError:
1950      case mirror::Class::kStatusRetryVerificationAtRuntime:
1951      case mirror::Class::kStatusVerified:
1952      case mirror::Class::kStatusInitialized:
1953        break;  // Expected states.
1954      default:
1955        LOG(FATAL) << "Unexpected class status for class "
1956            << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second)))
1957            << " of " << status;
1958    }
1959    CompiledClass* compiled_class = new CompiledClass(status);
1960    compiled_classes_.Overwrite(ref, compiled_class);
1961  }
1962}
1963
1964CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
1965  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1966  MethodTable::const_iterator it = compiled_methods_.find(ref);
1967  if (it == compiled_methods_.end()) {
1968    return NULL;
1969  }
1970  CHECK(it->second != NULL);
1971  return it->second;
1972}
1973
1974void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
1975                                                   uint16_t class_def_index) {
1976  WriterMutexLock mu(self, freezing_constructor_lock_);
1977  freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
1978}
1979
1980bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
1981                                                uint16_t class_def_index) {
1982  ReaderMutexLock mu(self, freezing_constructor_lock_);
1983  return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
1984}
1985
1986bool CompilerDriver::WriteElf(const std::string& android_root,
1987                              bool is_host,
1988                              const std::vector<const art::DexFile*>& dex_files,
1989                              OatWriter* oat_writer,
1990                              art::File* file)
1991    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1992  return compiler_->WriteElf(file, oat_writer, dex_files, android_root, is_host, *this);
1993}
1994void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
1995                                                std::string* target_triple,
1996                                                std::string* target_cpu,
1997                                                std::string* target_attr) {
1998  switch (instruction_set) {
1999    case kThumb2:
2000      *target_triple = "thumb-none-linux-gnueabi";
2001      *target_cpu = "cortex-a9";
2002      *target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
2003      break;
2004
2005    case kArm:
2006      *target_triple = "armv7-none-linux-gnueabi";
2007      // TODO: Fix for Nexus S.
2008      *target_cpu = "cortex-a9";
2009      // TODO: Fix for Xoom.
2010      *target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
2011      break;
2012
2013    case kX86:
2014      *target_triple = "i386-pc-linux-gnu";
2015      *target_attr = "";
2016      break;
2017
2018    case kMips:
2019      *target_triple = "mipsel-unknown-linux";
2020      *target_attr = "mips32r2";
2021      break;
2022
2023    default:
2024      LOG(FATAL) << "Unknown instruction set: " << instruction_set;
2025    }
2026  }
2027
2028bool CompilerDriver::ReadProfile(const std::string& filename) {
2029  VLOG(compiler) << "reading profile file " << filename;
2030  struct stat st;
2031  int err = stat(filename.c_str(), &st);
2032  if (err == -1) {
2033    VLOG(compiler) << "not found";
2034    return false;
2035  }
2036  std::ifstream in(filename.c_str());
2037  if (!in) {
2038    VLOG(compiler) << "profile file " << filename << " exists but can't be opened";
2039    VLOG(compiler) << "file owner: " << st.st_uid << ":" << st.st_gid;
2040    VLOG(compiler) << "me: " << getuid() << ":" << getgid();
2041    VLOG(compiler) << "file permissions: " << std::oct << st.st_mode;
2042    VLOG(compiler) << "errno: " << errno;
2043    return false;
2044  }
2045  // The first line contains summary information.
2046  std::string line;
2047  std::getline(in, line);
2048  if (in.eof()) {
2049    return false;
2050  }
2051  std::vector<std::string> summary_info;
2052  Split(line, '/', summary_info);
2053  if (summary_info.size() != 3) {
2054    // Bad summary info.  It should be count/total/bootpath
2055    return false;
2056  }
2057  // This is the number of hits in all methods.
2058  uint32_t total_count = 0;
2059  for (int i = 0 ; i < 3; ++i) {
2060    total_count += atoi(summary_info[i].c_str());
2061  }
2062
2063  // Now read each line until the end of file.  Each line consists of 3 fields separated by /
2064  while (!in.eof()) {
2065    std::getline(in, line);
2066    if (in.eof()) {
2067      break;
2068    }
2069    std::vector<std::string> info;
2070    Split(line, '/', info);
2071    if (info.size() != 3) {
2072      // Malformed.
2073      break;
2074    }
2075    const std::string& methodname = info[0];
2076    uint32_t count = atoi(info[1].c_str());
2077    uint32_t size = atoi(info[2].c_str());
2078    double percent = (count * 100.0) / total_count;
2079    // Add it to the profile map
2080    profile_map_[methodname] = ProfileData(methodname, count, size, percent);
2081  }
2082  return true;
2083}
2084
2085bool CompilerDriver::SkipCompilation(const std::string& method_name) {
2086  if (!profile_ok_) {
2087    return true;
2088  }
2089  constexpr double kThresholdPercent = 2.0;      // Anything above this threshold will be compiled.
2090
2091  // First find the method in the profile map.
2092  ProfileMap::iterator i = profile_map_.find(method_name);
2093  if (i == profile_map_.end()) {
2094    // Not in profile, no information can be determined.
2095    VLOG(compiler) << "not compiling " << method_name << " because it's not in the profile";
2096    return true;
2097  }
2098  const ProfileData& data = i->second;
2099  bool compile = data.IsAbove(kThresholdPercent);
2100  if (compile) {
2101    LOG(INFO) << "compiling method " << method_name << " because its usage is " <<
2102        data.GetPercent() << "%";
2103  } else {
2104    VLOG(compiler) << "not compiling method " << method_name << " because usage is too low ("
2105        << data.GetPercent() << "%)";
2106  }
2107  return !compile;
2108}
2109}  // namespace art
2110