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