compiler_driver.cc revision f832284dd847ff077577bb5712225430bbbb3b67 
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 "runtime.h"
39#include "gc/accounting/card_table-inl.h"
40#include "gc/accounting/heap_bitmap.h"
41#include "gc/space/space.h"
42#include "mirror/art_field-inl.h"
43#include "mirror/art_method-inl.h"
44#include "mirror/class_loader.h"
45#include "mirror/class-inl.h"
46#include "mirror/dex_cache-inl.h"
47#include "mirror/object-inl.h"
48#include "mirror/object_array-inl.h"
49#include "mirror/throwable.h"
50#include "scoped_thread_state_change.h"
51#include "ScopedLocalRef.h"
52#include "handle_scope-inl.h"
53#include "thread.h"
54#include "thread_pool.h"
55#include "trampolines/trampoline_compiler.h"
56#include "transaction.h"
57#include "verifier/method_verifier.h"
58#include "verifier/method_verifier-inl.h"
59
60#ifdef HAVE_ANDROID_OS
61#include "cutils/properties.h"
62#endif
63
64namespace art {
65
66static double Percentage(size_t x, size_t y) {
67  return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
68}
69
70static void DumpStat(size_t x, size_t y, const char* str) {
71  if (x == 0 && y == 0) {
72    return;
73  }
74  LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
75}
76
77class CompilerDriver::AOTCompilationStats {
78 public:
79  AOTCompilationStats()
80      : stats_lock_("AOT compilation statistics lock"),
81        types_in_dex_cache_(0), types_not_in_dex_cache_(0),
82        strings_in_dex_cache_(0), strings_not_in_dex_cache_(0),
83        resolved_types_(0), unresolved_types_(0),
84        resolved_instance_fields_(0), unresolved_instance_fields_(0),
85        resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0),
86        type_based_devirtualization_(0),
87        safe_casts_(0), not_safe_casts_(0) {
88    for (size_t i = 0; i <= kMaxInvokeType; i++) {
89      resolved_methods_[i] = 0;
90      unresolved_methods_[i] = 0;
91      virtual_made_direct_[i] = 0;
92      direct_calls_to_boot_[i] = 0;
93      direct_methods_to_boot_[i] = 0;
94    }
95  }
96
97  void Dump() {
98    DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache");
99    DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache");
100    DumpStat(resolved_types_, unresolved_types_, "types resolved");
101    DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
102    DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
103             "static fields resolved");
104    DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
105             "static fields local to a class");
106    DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information");
107    // Note, the code below subtracts the stat value so that when added to the stat value we have
108    // 100% of samples. TODO: clean this up.
109    DumpStat(type_based_devirtualization_,
110             resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] +
111             resolved_methods_[kInterface] + unresolved_methods_[kInterface] -
112             type_based_devirtualization_,
113             "virtual/interface calls made direct based on type information");
114
115    for (size_t i = 0; i <= kMaxInvokeType; i++) {
116      std::ostringstream oss;
117      oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
118      DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
119      if (virtual_made_direct_[i] > 0) {
120        std::ostringstream oss2;
121        oss2 << static_cast<InvokeType>(i) << " methods made direct";
122        DumpStat(virtual_made_direct_[i],
123                 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
124                 oss2.str().c_str());
125      }
126      if (direct_calls_to_boot_[i] > 0) {
127        std::ostringstream oss2;
128        oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
129        DumpStat(direct_calls_to_boot_[i],
130                 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
131                 oss2.str().c_str());
132      }
133      if (direct_methods_to_boot_[i] > 0) {
134        std::ostringstream oss2;
135        oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
136        DumpStat(direct_methods_to_boot_[i],
137                 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
138                 oss2.str().c_str());
139      }
140    }
141  }
142
143// Allow lossy statistics in non-debug builds.
144#ifndef NDEBUG
145#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
146#else
147#define STATS_LOCK()
148#endif
149
150  void TypeInDexCache() {
151    STATS_LOCK();
152    types_in_dex_cache_++;
153  }
154
155  void TypeNotInDexCache() {
156    STATS_LOCK();
157    types_not_in_dex_cache_++;
158  }
159
160  void StringInDexCache() {
161    STATS_LOCK();
162    strings_in_dex_cache_++;
163  }
164
165  void StringNotInDexCache() {
166    STATS_LOCK();
167    strings_not_in_dex_cache_++;
168  }
169
170  void TypeDoesntNeedAccessCheck() {
171    STATS_LOCK();
172    resolved_types_++;
173  }
174
175  void TypeNeedsAccessCheck() {
176    STATS_LOCK();
177    unresolved_types_++;
178  }
179
180  void ResolvedInstanceField() {
181    STATS_LOCK();
182    resolved_instance_fields_++;
183  }
184
185  void UnresolvedInstanceField() {
186    STATS_LOCK();
187    unresolved_instance_fields_++;
188  }
189
190  void ResolvedLocalStaticField() {
191    STATS_LOCK();
192    resolved_local_static_fields_++;
193  }
194
195  void ResolvedStaticField() {
196    STATS_LOCK();
197    resolved_static_fields_++;
198  }
199
200  void UnresolvedStaticField() {
201    STATS_LOCK();
202    unresolved_static_fields_++;
203  }
204
205  // Indicate that type information from the verifier led to devirtualization.
206  void PreciseTypeDevirtualization() {
207    STATS_LOCK();
208    type_based_devirtualization_++;
209  }
210
211  // Indicate that a method of the given type was resolved at compile time.
212  void ResolvedMethod(InvokeType type) {
213    DCHECK_LE(type, kMaxInvokeType);
214    STATS_LOCK();
215    resolved_methods_[type]++;
216  }
217
218  // Indicate that a method of the given type was unresolved at compile time as it was in an
219  // unknown dex file.
220  void UnresolvedMethod(InvokeType type) {
221    DCHECK_LE(type, kMaxInvokeType);
222    STATS_LOCK();
223    unresolved_methods_[type]++;
224  }
225
226  // Indicate that a type of virtual method dispatch has been converted into a direct method
227  // dispatch.
228  void VirtualMadeDirect(InvokeType type) {
229    DCHECK(type == kVirtual || type == kInterface || type == kSuper);
230    STATS_LOCK();
231    virtual_made_direct_[type]++;
232  }
233
234  // Indicate that a method of the given type was able to call directly into boot.
235  void DirectCallsToBoot(InvokeType type) {
236    DCHECK_LE(type, kMaxInvokeType);
237    STATS_LOCK();
238    direct_calls_to_boot_[type]++;
239  }
240
241  // Indicate that a method of the given type was able to be resolved directly from boot.
242  void DirectMethodsToBoot(InvokeType type) {
243    DCHECK_LE(type, kMaxInvokeType);
244    STATS_LOCK();
245    direct_methods_to_boot_[type]++;
246  }
247
248  void ProcessedInvoke(InvokeType type, int flags) {
249    STATS_LOCK();
250    if (flags == 0) {
251      unresolved_methods_[type]++;
252    } else {
253      DCHECK_NE((flags & kFlagMethodResolved), 0);
254      resolved_methods_[type]++;
255      if ((flags & kFlagVirtualMadeDirect) != 0) {
256        virtual_made_direct_[type]++;
257        if ((flags & kFlagPreciseTypeDevirtualization) != 0) {
258          type_based_devirtualization_++;
259        }
260      } else {
261        DCHECK_EQ((flags & kFlagPreciseTypeDevirtualization), 0);
262      }
263      if ((flags & kFlagDirectCallToBoot) != 0) {
264        direct_calls_to_boot_[type]++;
265      }
266      if ((flags & kFlagDirectMethodToBoot) != 0) {
267        direct_methods_to_boot_[type]++;
268      }
269    }
270  }
271
272  // A check-cast could be eliminated due to verifier type analysis.
273  void SafeCast() {
274    STATS_LOCK();
275    safe_casts_++;
276  }
277
278  // A check-cast couldn't be eliminated due to verifier type analysis.
279  void NotASafeCast() {
280    STATS_LOCK();
281    not_safe_casts_++;
282  }
283
284 private:
285  Mutex stats_lock_;
286
287  size_t types_in_dex_cache_;
288  size_t types_not_in_dex_cache_;
289
290  size_t strings_in_dex_cache_;
291  size_t strings_not_in_dex_cache_;
292
293  size_t resolved_types_;
294  size_t unresolved_types_;
295
296  size_t resolved_instance_fields_;
297  size_t unresolved_instance_fields_;
298
299  size_t resolved_local_static_fields_;
300  size_t resolved_static_fields_;
301  size_t unresolved_static_fields_;
302  // Type based devirtualization for invoke interface and virtual.
303  size_t type_based_devirtualization_;
304
305  size_t resolved_methods_[kMaxInvokeType + 1];
306  size_t unresolved_methods_[kMaxInvokeType + 1];
307  size_t virtual_made_direct_[kMaxInvokeType + 1];
308  size_t direct_calls_to_boot_[kMaxInvokeType + 1];
309  size_t direct_methods_to_boot_[kMaxInvokeType + 1];
310
311  size_t safe_casts_;
312  size_t not_safe_casts_;
313
314  DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
315};
316
317
318extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler,
319                                              const art::DexFile::CodeItem* code_item,
320                                              uint32_t access_flags,
321                                              art::InvokeType invoke_type,
322                                              uint16_t class_def_idx,
323                                              uint32_t method_idx,
324                                              jobject class_loader,
325                                              const art::DexFile& dex_file);
326
327CompilerDriver::CompilerDriver(const CompilerOptions* compiler_options,
328                               VerificationResults* verification_results,
329                               DexFileToMethodInlinerMap* method_inliner_map,
330                               Compiler::Kind compiler_kind,
331                               InstructionSet instruction_set,
332                               InstructionSetFeatures instruction_set_features,
333                               bool image, DescriptorSet* image_classes, size_t thread_count,
334                               bool dump_stats, bool dump_passes, CumulativeLogger* timer,
335                               std::string profile_file)
336    : profile_ok_(false), compiler_options_(compiler_options),
337      verification_results_(verification_results),
338      method_inliner_map_(method_inliner_map),
339      compiler_(Compiler::Create(this, compiler_kind)),
340      instruction_set_(instruction_set),
341      instruction_set_features_(instruction_set_features),
342      freezing_constructor_lock_("freezing constructor lock"),
343      compiled_classes_lock_("compiled classes lock"),
344      compiled_methods_lock_("compiled method lock"),
345      image_(image),
346      image_classes_(image_classes),
347      thread_count_(thread_count),
348      start_ns_(0),
349      stats_(new AOTCompilationStats),
350      dump_stats_(dump_stats),
351      dump_passes_(dump_passes),
352      timings_logger_(timer),
353      compiler_library_(NULL),
354      compiler_context_(NULL),
355      compiler_enable_auto_elf_loading_(NULL),
356      compiler_get_method_code_addr_(NULL),
357      support_boot_image_fixup_(instruction_set != kMips),
358      cfi_info_(nullptr),
359      dedupe_code_("dedupe code"),
360      dedupe_mapping_table_("dedupe mapping table"),
361      dedupe_vmap_table_("dedupe vmap table"),
362      dedupe_gc_map_("dedupe gc map"),
363      dedupe_cfi_info_("dedupe cfi info") {
364  DCHECK(compiler_options_ != nullptr);
365  DCHECK(verification_results_ != nullptr);
366  DCHECK(method_inliner_map_ != nullptr);
367
368  CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key");
369
370  // Read the profile file if one is provided.
371  if (profile_file != "") {
372    profile_ok_ = ProfileHelper::LoadProfileMap(profile_map_, profile_file);
373  }
374
375  dex_to_dex_compiler_ = reinterpret_cast<DexToDexCompilerFn>(ArtCompileDEX);
376
377  compiler_->Init();
378
379  CHECK(!Runtime::Current()->IsStarted());
380  if (image_) {
381    CHECK(image_classes_.get() != nullptr);
382  } else {
383    CHECK(image_classes_.get() == nullptr);
384  }
385
386  // Are we generating CFI information?
387  if (compiler_options->GetGenerateGDBInformation()) {
388    cfi_info_.reset(compiler_->GetCallFrameInformationInitialization(*this));
389  }
390}
391
392std::vector<uint8_t>* CompilerDriver::DeduplicateCode(const std::vector<uint8_t>& code) {
393  return dedupe_code_.Add(Thread::Current(), code);
394}
395
396std::vector<uint8_t>* CompilerDriver::DeduplicateMappingTable(const std::vector<uint8_t>& code) {
397  return dedupe_mapping_table_.Add(Thread::Current(), code);
398}
399
400std::vector<uint8_t>* CompilerDriver::DeduplicateVMapTable(const std::vector<uint8_t>& code) {
401  return dedupe_vmap_table_.Add(Thread::Current(), code);
402}
403
404std::vector<uint8_t>* CompilerDriver::DeduplicateGCMap(const std::vector<uint8_t>& code) {
405  return dedupe_gc_map_.Add(Thread::Current(), code);
406}
407
408std::vector<uint8_t>* CompilerDriver::DeduplicateCFIInfo(const std::vector<uint8_t>* cfi_info) {
409  if (cfi_info == nullptr) {
410    return nullptr;
411  }
412  return dedupe_cfi_info_.Add(Thread::Current(), *cfi_info);
413}
414
415CompilerDriver::~CompilerDriver() {
416  Thread* self = Thread::Current();
417  {
418    MutexLock mu(self, compiled_classes_lock_);
419    STLDeleteValues(&compiled_classes_);
420  }
421  {
422    MutexLock mu(self, compiled_methods_lock_);
423    STLDeleteValues(&compiled_methods_);
424  }
425  {
426    MutexLock mu(self, compiled_methods_lock_);
427    STLDeleteElements(&code_to_patch_);
428  }
429  {
430    MutexLock mu(self, compiled_methods_lock_);
431    STLDeleteElements(&methods_to_patch_);
432  }
433  {
434    MutexLock mu(self, compiled_methods_lock_);
435    STLDeleteElements(&classes_to_patch_);
436  }
437  CHECK_PTHREAD_CALL(pthread_key_delete, (tls_key_), "delete tls key");
438  compiler_->UnInit();
439}
440
441CompilerTls* CompilerDriver::GetTls() {
442  // Lazily create thread-local storage
443  CompilerTls* res = static_cast<CompilerTls*>(pthread_getspecific(tls_key_));
444  if (res == NULL) {
445    res = new CompilerTls();
446    CHECK_PTHREAD_CALL(pthread_setspecific, (tls_key_, res), "compiler tls");
447  }
448  return res;
449}
450
451#define CREATE_TRAMPOLINE(type, abi, offset) \
452    if (Is64BitInstructionSet(instruction_set_)) { \
453      return CreateTrampoline64(instruction_set_, abi, \
454                                type ## _ENTRYPOINT_OFFSET(8, offset)); \
455    } else { \
456      return CreateTrampoline32(instruction_set_, abi, \
457                                type ## _ENTRYPOINT_OFFSET(4, offset)); \
458    }
459
460const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterBridge() const {
461  CREATE_TRAMPOLINE(INTERPRETER, kInterpreterAbi, pInterpreterToInterpreterBridge)
462}
463
464const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToCompiledCodeBridge() const {
465  CREATE_TRAMPOLINE(INTERPRETER, kInterpreterAbi, pInterpreterToCompiledCodeBridge)
466}
467
468const std::vector<uint8_t>* CompilerDriver::CreateJniDlsymLookup() const {
469  CREATE_TRAMPOLINE(JNI, kJniAbi, pDlsymLookup)
470}
471
472const std::vector<uint8_t>* CompilerDriver::CreatePortableImtConflictTrampoline() const {
473  CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableImtConflictTrampoline)
474}
475
476const std::vector<uint8_t>* CompilerDriver::CreatePortableResolutionTrampoline() const {
477  CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableResolutionTrampoline)
478}
479
480const std::vector<uint8_t>* CompilerDriver::CreatePortableToInterpreterBridge() const {
481  CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableToInterpreterBridge)
482}
483
484const std::vector<uint8_t>* CompilerDriver::CreateQuickGenericJniTrampoline() const {
485  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickGenericJniTrampoline)
486}
487
488const std::vector<uint8_t>* CompilerDriver::CreateQuickImtConflictTrampoline() const {
489  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickImtConflictTrampoline)
490}
491
492const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const {
493  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickResolutionTrampoline)
494}
495
496const std::vector<uint8_t>* CompilerDriver::CreateQuickToInterpreterBridge() const {
497  CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickToInterpreterBridge)
498}
499#undef CREATE_TRAMPOLINE
500
501void CompilerDriver::CompileAll(jobject class_loader,
502                                const std::vector<const DexFile*>& dex_files,
503                                TimingLogger* timings) {
504  DCHECK(!Runtime::Current()->IsStarted());
505  UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", thread_count_ - 1));
506  PreCompile(class_loader, dex_files, thread_pool.get(), timings);
507  Compile(class_loader, dex_files, thread_pool.get(), timings);
508  if (dump_stats_) {
509    stats_->Dump();
510  }
511}
512
513static DexToDexCompilationLevel GetDexToDexCompilationlevel(
514    Thread* self, Handle<mirror::ClassLoader>& class_loader, const DexFile& dex_file,
515    const DexFile::ClassDef& class_def) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
516  const char* descriptor = dex_file.GetClassDescriptor(class_def);
517  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
518  mirror::Class* klass = class_linker->FindClass(self, descriptor, class_loader);
519  if (klass == NULL) {
520    CHECK(self->IsExceptionPending());
521    self->ClearException();
522    return kDontDexToDexCompile;
523  }
524  // The verifier can only run on "quick" instructions at runtime (see usage of
525  // FindAccessedFieldAtDexPc and FindInvokedMethodAtDexPc in ThrowNullPointerExceptionFromDexPC
526  // function). Since image classes can be verified again while compiling an application,
527  // we must prevent the DEX-to-DEX compiler from introducing them.
528  // TODO: find a way to enable "quick" instructions for image classes and remove this check.
529  bool compiling_image_classes = class_loader.Get() == nullptr;
530  if (compiling_image_classes) {
531    return kRequired;
532  } else if (klass->IsVerified()) {
533    // Class is verified so we can enable DEX-to-DEX compilation for performance.
534    return kOptimize;
535  } else if (klass->IsCompileTimeVerified()) {
536    // Class verification has soft-failed. Anyway, ensure at least correctness.
537    DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
538    return kRequired;
539  } else {
540    // Class verification has failed: do not run DEX-to-DEX compilation.
541    return kDontDexToDexCompile;
542  }
543}
544
545void CompilerDriver::CompileOne(mirror::ArtMethod* method, TimingLogger* timings) {
546  DCHECK(!Runtime::Current()->IsStarted());
547  Thread* self = Thread::Current();
548  jobject jclass_loader;
549  const DexFile* dex_file;
550  uint16_t class_def_idx;
551  uint32_t method_idx = method->GetDexMethodIndex();
552  uint32_t access_flags = method->GetAccessFlags();
553  InvokeType invoke_type = method->GetInvokeType();
554  {
555    ScopedObjectAccessUnchecked soa(self);
556    ScopedLocalRef<jobject>
557      local_class_loader(soa.Env(),
558                    soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader()));
559    jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
560    // Find the dex_file
561    MethodHelper mh(method);
562    dex_file = &mh.GetDexFile();
563    class_def_idx = mh.GetClassDefIndex();
564  }
565  const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
566  self->TransitionFromRunnableToSuspended(kNative);
567
568  std::vector<const DexFile*> dex_files;
569  dex_files.push_back(dex_file);
570
571  UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", 0U));
572  PreCompile(jclass_loader, dex_files, thread_pool.get(), timings);
573
574  // Can we run DEX-to-DEX compiler on this class ?
575  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
576  {
577    ScopedObjectAccess soa(Thread::Current());
578    const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx);
579    StackHandleScope<1> hs(soa.Self());
580    Handle<mirror::ClassLoader> class_loader(
581        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
582    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(self, class_loader, *dex_file,
583                                                               class_def);
584  }
585  CompileMethod(code_item, access_flags, invoke_type, class_def_idx, method_idx, jclass_loader,
586                *dex_file, dex_to_dex_compilation_level);
587
588  self->GetJniEnv()->DeleteGlobalRef(jclass_loader);
589
590  self->TransitionFromSuspendedToRunnable();
591}
592
593void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
594                             ThreadPool* thread_pool, TimingLogger* timings) {
595  for (size_t i = 0; i != dex_files.size(); ++i) {
596    const DexFile* dex_file = dex_files[i];
597    CHECK(dex_file != nullptr);
598    ResolveDexFile(class_loader, *dex_file, thread_pool, timings);
599  }
600}
601
602void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
603                                ThreadPool* thread_pool, TimingLogger* timings) {
604  LoadImageClasses(timings);
605
606  if (!compiler_options_->IsVerificationEnabled()) {
607    VLOG(compiler) << "Verify none mode specified, skipping pre-compilation";
608    return;
609  }
610
611  Resolve(class_loader, dex_files, thread_pool, timings);
612
613  Verify(class_loader, dex_files, thread_pool, timings);
614
615  InitializeClasses(class_loader, dex_files, thread_pool, timings);
616
617  UpdateImageClasses(timings);
618}
619
620bool CompilerDriver::IsImageClass(const char* descriptor) const {
621  if (!IsImage()) {
622    return true;
623  } else {
624    return image_classes_->find(descriptor) != image_classes_->end();
625  }
626}
627
628static void ResolveExceptionsForMethod(MethodHelper* mh,
629    std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve)
630    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
631  const DexFile::CodeItem* code_item = mh->GetCodeItem();
632  if (code_item == NULL) {
633    return;  // native or abstract method
634  }
635  if (code_item->tries_size_ == 0) {
636    return;  // nothing to process
637  }
638  const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0);
639  size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list);
640  for (size_t i = 0; i < num_encoded_catch_handlers; i++) {
641    int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list);
642    bool has_catch_all = false;
643    if (encoded_catch_handler_size <= 0) {
644      encoded_catch_handler_size = -encoded_catch_handler_size;
645      has_catch_all = true;
646    }
647    for (int32_t j = 0; j < encoded_catch_handler_size; j++) {
648      uint16_t encoded_catch_handler_handlers_type_idx =
649          DecodeUnsignedLeb128(&encoded_catch_handler_list);
650      // Add to set of types to resolve if not already in the dex cache resolved types
651      if (!mh->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) {
652        exceptions_to_resolve.insert(
653            std::pair<uint16_t, const DexFile*>(encoded_catch_handler_handlers_type_idx,
654                                                &mh->GetDexFile()));
655      }
656      // ignore address associated with catch handler
657      DecodeUnsignedLeb128(&encoded_catch_handler_list);
658    }
659    if (has_catch_all) {
660      // ignore catch all address
661      DecodeUnsignedLeb128(&encoded_catch_handler_list);
662    }
663  }
664}
665
666static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg)
667    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
668  std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve =
669      reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
670  MethodHelper mh;
671  for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
672    mirror::ArtMethod* m = c->GetVirtualMethod(i);
673    mh.ChangeMethod(m);
674    ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
675  }
676  for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
677    mirror::ArtMethod* m = c->GetDirectMethod(i);
678    mh.ChangeMethod(m);
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<3> hs(self);
735      Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(*dex_file)));
736      auto class_loader(hs.NewHandle<mirror::ClassLoader>(nullptr));
737      Handle<mirror::Class> klass(hs.NewHandle(
738          class_linker->ResolveType(*dex_file, exception_type_idx, dex_cache, class_loader)));
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    MethodHelper mh(method);
1119    if (!IsImageClass(mh.GetDeclaringClassDescriptor())) {
1120      // We can only branch directly to Methods that are resolved in the DexCache.
1121      // Otherwise we won't invoke the resolution trampoline.
1122      use_dex_cache = true;
1123    }
1124  }
1125  // The method is defined not within this dex file. We need a dex cache slot within the current
1126  // dex file or direct pointers.
1127  bool must_use_direct_pointers = false;
1128  if (target_method->dex_file == method->GetDeclaringClass()->GetDexCache()->GetDexFile()) {
1129    target_method->dex_method_index = method->GetDexMethodIndex();
1130  } else {
1131    if (no_guarantee_of_dex_cache_entry) {
1132      // See if the method is also declared in this dex cache.
1133      uint32_t dex_method_idx = MethodHelper(method).FindDexMethodIndexInOtherDexFile(
1134          *target_method->dex_file, target_method->dex_method_index);
1135      if (dex_method_idx != DexFile::kDexNoIndex) {
1136        target_method->dex_method_index = dex_method_idx;
1137      } else {
1138        if (compiling_boot) {
1139          target_method->dex_method_index = method->GetDexMethodIndex();
1140          target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1141        }
1142        must_use_direct_pointers = true;
1143      }
1144    }
1145  }
1146  if (use_dex_cache) {
1147    if (must_use_direct_pointers) {
1148      // Fail. Test above showed the only safe dispatch was via the dex cache, however, the direct
1149      // pointers are required as the dex cache lacks an appropriate entry.
1150      VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method);
1151    } else {
1152      *type = sharp_type;
1153    }
1154  } else {
1155    if (compiling_boot) {
1156      *type = sharp_type;
1157      *direct_method = -1;
1158      *direct_code = -1;
1159    } else {
1160      bool method_in_image =
1161          Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace();
1162      if (method_in_image) {
1163        CHECK(!method->IsAbstract());
1164        *type = sharp_type;
1165        *direct_method = reinterpret_cast<uintptr_t>(method);
1166        *direct_code = compiler_->GetEntryPointOf(method);
1167        target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1168        target_method->dex_method_index = method->GetDexMethodIndex();
1169      } else if (!must_use_direct_pointers) {
1170        // Set the code and rely on the dex cache for the method.
1171        *type = sharp_type;
1172        *direct_code = compiler_->GetEntryPointOf(method);
1173      } else {
1174        // Direct pointers were required but none were available.
1175        VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method);
1176      }
1177    }
1178  }
1179}
1180
1181bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
1182                                       bool update_stats, bool enable_devirtualization,
1183                                       InvokeType* invoke_type, MethodReference* target_method,
1184                                       int* vtable_idx, uintptr_t* direct_code,
1185                                       uintptr_t* direct_method) {
1186  InvokeType orig_invoke_type = *invoke_type;
1187  int stats_flags = 0;
1188  ScopedObjectAccess soa(Thread::Current());
1189  // Try to resolve the method and compiling method's class.
1190  mirror::ArtMethod* resolved_method;
1191  mirror::Class* referrer_class;
1192  StackHandleScope<3> hs(soa.Self());
1193  Handle<mirror::DexCache> dex_cache(
1194      hs.NewHandle(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile())));
1195  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
1196      soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())));
1197  {
1198    uint32_t method_idx = target_method->dex_method_index;
1199    Handle<mirror::ArtMethod> resolved_method_handle(hs.NewHandle(
1200        ResolveMethod(soa, dex_cache, class_loader, mUnit, method_idx, orig_invoke_type)));
1201    referrer_class = (resolved_method_handle.Get() != nullptr)
1202        ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader, mUnit) : nullptr;
1203    resolved_method = resolved_method_handle.Get();
1204  }
1205  bool result = false;
1206  if (resolved_method != nullptr) {
1207    *vtable_idx = GetResolvedMethodVTableIndex(resolved_method, orig_invoke_type);
1208
1209    if (enable_devirtualization) {
1210      DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1211      const MethodReference* devirt_target = mUnit->GetVerifiedMethod()->GetDevirtTarget(dex_pc);
1212
1213      stats_flags = IsFastInvoke(
1214          soa, dex_cache, class_loader, mUnit, referrer_class, resolved_method,
1215          invoke_type, target_method, devirt_target, direct_code, direct_method);
1216      result = stats_flags != 0;
1217    } else {
1218      // Devirtualization not enabled. Inline IsFastInvoke(), dropping the devirtualization parts.
1219      if (UNLIKELY(referrer_class == nullptr) ||
1220          UNLIKELY(!referrer_class->CanAccessResolvedMethod(resolved_method->GetDeclaringClass(),
1221                                                            resolved_method, dex_cache.Get(),
1222                                                            target_method->dex_method_index)) ||
1223          *invoke_type == kSuper) {
1224        // Slow path. (Without devirtualization, all super calls go slow path as well.)
1225      } else {
1226        // Sharpening failed so generate a regular resolved method dispatch.
1227        stats_flags = kFlagMethodResolved;
1228        GetCodeAndMethodForDirectCall(invoke_type, *invoke_type, false, referrer_class, resolved_method,
1229                                      &stats_flags, target_method, direct_code, direct_method);
1230        result = true;
1231      }
1232    }
1233  }
1234  if (!result) {
1235    // Conservative defaults.
1236    *vtable_idx = -1;
1237    *direct_code = 0u;
1238    *direct_method = 0u;
1239  }
1240  if (update_stats) {
1241    ProcessedInvoke(orig_invoke_type, stats_flags);
1242  }
1243  return result;
1244}
1245
1246const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file,
1247                                                        uint32_t method_idx) const {
1248  MethodReference ref(dex_file, method_idx);
1249  return verification_results_->GetVerifiedMethod(ref);
1250}
1251
1252bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) {
1253  DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1254  bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc);
1255  if (result) {
1256    stats_->SafeCast();
1257  } else {
1258    stats_->NotASafeCast();
1259  }
1260  return result;
1261}
1262
1263void CompilerDriver::AddCodePatch(const DexFile* dex_file,
1264                                  uint16_t referrer_class_def_idx,
1265                                  uint32_t referrer_method_idx,
1266                                  InvokeType referrer_invoke_type,
1267                                  uint32_t target_method_idx,
1268                                  const DexFile* target_dex_file,
1269                                  InvokeType target_invoke_type,
1270                                  size_t literal_offset) {
1271  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1272  code_to_patch_.push_back(new CallPatchInformation(dex_file,
1273                                                    referrer_class_def_idx,
1274                                                    referrer_method_idx,
1275                                                    referrer_invoke_type,
1276                                                    target_method_idx,
1277                                                    target_dex_file,
1278                                                    target_invoke_type,
1279                                                    literal_offset));
1280}
1281void CompilerDriver::AddRelativeCodePatch(const DexFile* dex_file,
1282                                          uint16_t referrer_class_def_idx,
1283                                          uint32_t referrer_method_idx,
1284                                          InvokeType referrer_invoke_type,
1285                                          uint32_t target_method_idx,
1286                                          const DexFile* target_dex_file,
1287                                          InvokeType target_invoke_type,
1288                                          size_t literal_offset,
1289                                          int32_t pc_relative_offset) {
1290  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1291  code_to_patch_.push_back(new RelativeCallPatchInformation(dex_file,
1292                                                            referrer_class_def_idx,
1293                                                            referrer_method_idx,
1294                                                            referrer_invoke_type,
1295                                                            target_method_idx,
1296                                                            target_dex_file,
1297                                                            target_invoke_type,
1298                                                            literal_offset,
1299                                                            pc_relative_offset));
1300}
1301void CompilerDriver::AddMethodPatch(const DexFile* dex_file,
1302                                    uint16_t referrer_class_def_idx,
1303                                    uint32_t referrer_method_idx,
1304                                    InvokeType referrer_invoke_type,
1305                                    uint32_t target_method_idx,
1306                                    const DexFile* target_dex_file,
1307                                    InvokeType target_invoke_type,
1308                                    size_t literal_offset) {
1309  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1310  methods_to_patch_.push_back(new CallPatchInformation(dex_file,
1311                                                       referrer_class_def_idx,
1312                                                       referrer_method_idx,
1313                                                       referrer_invoke_type,
1314                                                       target_method_idx,
1315                                                       target_dex_file,
1316                                                       target_invoke_type,
1317                                                       literal_offset));
1318}
1319void CompilerDriver::AddClassPatch(const DexFile* dex_file,
1320                                    uint16_t referrer_class_def_idx,
1321                                    uint32_t referrer_method_idx,
1322                                    uint32_t target_type_idx,
1323                                    size_t literal_offset) {
1324  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1325  classes_to_patch_.push_back(new TypePatchInformation(dex_file,
1326                                                       referrer_class_def_idx,
1327                                                       referrer_method_idx,
1328                                                       target_type_idx,
1329                                                       literal_offset));
1330}
1331
1332class ParallelCompilationManager {
1333 public:
1334  typedef void Callback(const ParallelCompilationManager* manager, size_t index);
1335
1336  ParallelCompilationManager(ClassLinker* class_linker,
1337                             jobject class_loader,
1338                             CompilerDriver* compiler,
1339                             const DexFile* dex_file,
1340                             ThreadPool* thread_pool)
1341    : index_(0),
1342      class_linker_(class_linker),
1343      class_loader_(class_loader),
1344      compiler_(compiler),
1345      dex_file_(dex_file),
1346      thread_pool_(thread_pool) {}
1347
1348  ClassLinker* GetClassLinker() const {
1349    CHECK(class_linker_ != NULL);
1350    return class_linker_;
1351  }
1352
1353  jobject GetClassLoader() const {
1354    return class_loader_;
1355  }
1356
1357  CompilerDriver* GetCompiler() const {
1358    CHECK(compiler_ != NULL);
1359    return compiler_;
1360  }
1361
1362  const DexFile* GetDexFile() const {
1363    CHECK(dex_file_ != NULL);
1364    return dex_file_;
1365  }
1366
1367  void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) {
1368    Thread* self = Thread::Current();
1369    self->AssertNoPendingException();
1370    CHECK_GT(work_units, 0U);
1371
1372    index_ = begin;
1373    for (size_t i = 0; i < work_units; ++i) {
1374      thread_pool_->AddTask(self, new ForAllClosure(this, end, callback));
1375    }
1376    thread_pool_->StartWorkers(self);
1377
1378    // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1379    // thread destructor's called below perform join).
1380    CHECK_NE(self->GetState(), kRunnable);
1381
1382    // Wait for all the worker threads to finish.
1383    thread_pool_->Wait(self, true, false);
1384  }
1385
1386  size_t NextIndex() {
1387    return index_.FetchAndAdd(1);
1388  }
1389
1390 private:
1391  class ForAllClosure : public Task {
1392   public:
1393    ForAllClosure(ParallelCompilationManager* manager, size_t end, Callback* callback)
1394        : manager_(manager),
1395          end_(end),
1396          callback_(callback) {}
1397
1398    virtual void Run(Thread* self) {
1399      while (true) {
1400        const size_t index = manager_->NextIndex();
1401        if (UNLIKELY(index >= end_)) {
1402          break;
1403        }
1404        callback_(manager_, index);
1405        self->AssertNoPendingException();
1406      }
1407    }
1408
1409    virtual void Finalize() {
1410      delete this;
1411    }
1412
1413   private:
1414    ParallelCompilationManager* const manager_;
1415    const size_t end_;
1416    Callback* const callback_;
1417  };
1418
1419  AtomicInteger index_;
1420  ClassLinker* const class_linker_;
1421  const jobject class_loader_;
1422  CompilerDriver* const compiler_;
1423  const DexFile* const dex_file_;
1424  ThreadPool* const thread_pool_;
1425
1426  DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager);
1427};
1428
1429// Return true if the class should be skipped during compilation.
1430//
1431// The first case where we skip is for redundant class definitions in
1432// the boot classpath. We skip all but the first definition in that case.
1433//
1434// The second case where we skip is when an app bundles classes found
1435// in the boot classpath. Since at runtime we will select the class from
1436// the boot classpath, we ignore the one from the app.
1437static bool SkipClass(ClassLinker* class_linker, jobject class_loader, const DexFile& dex_file,
1438                      const DexFile::ClassDef& class_def) {
1439  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1440  if (class_loader == NULL) {
1441    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_linker->GetBootClassPath());
1442    CHECK(pair.second != NULL);
1443    if (pair.first != &dex_file) {
1444      LOG(WARNING) << "Skipping class " << descriptor << " from " << dex_file.GetLocation()
1445                   << " previously found in " << pair.first->GetLocation();
1446      return true;
1447    }
1448    return false;
1449  }
1450  return class_linker->IsInBootClassPath(descriptor);
1451}
1452
1453// A fast version of SkipClass above if the class pointer is available
1454// that avoids the expensive FindInClassPath search.
1455static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass)
1456    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1457  DCHECK(klass != NULL);
1458  const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile();
1459  if (&dex_file != &original_dex_file) {
1460    if (class_loader == NULL) {
1461      LOG(WARNING) << "Skipping class " << PrettyDescriptor(klass) << " from "
1462                   << dex_file.GetLocation() << " previously found in "
1463                   << original_dex_file.GetLocation();
1464    }
1465    return true;
1466  }
1467  return false;
1468}
1469
1470static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager,
1471                                         size_t class_def_index)
1472    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1473  ATRACE_CALL();
1474  Thread* self = Thread::Current();
1475  jobject jclass_loader = manager->GetClassLoader();
1476  const DexFile& dex_file = *manager->GetDexFile();
1477  ClassLinker* class_linker = manager->GetClassLinker();
1478
1479  // If an instance field is final then we need to have a barrier on the return, static final
1480  // fields are assigned within the lock held for class initialization. Conservatively assume
1481  // constructor barriers are always required.
1482  bool requires_constructor_barrier = true;
1483
1484  // Method and Field are the worst. We can't resolve without either
1485  // context from the code use (to disambiguate virtual vs direct
1486  // method and instance vs static field) or from class
1487  // definitions. While the compiler will resolve what it can as it
1488  // needs it, here we try to resolve fields and methods used in class
1489  // definitions, since many of them many never be referenced by
1490  // generated code.
1491  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1492  if (!SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1493    ScopedObjectAccess soa(self);
1494    StackHandleScope<2> hs(soa.Self());
1495    Handle<mirror::ClassLoader> class_loader(
1496        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1497    Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file)));
1498    // Resolve the class.
1499    mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
1500                                                     class_loader);
1501    bool resolve_fields_and_methods;
1502    if (klass == NULL) {
1503      // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
1504      // attempt to resolve methods and fields when there is no declaring class.
1505      CHECK(soa.Self()->IsExceptionPending());
1506      soa.Self()->ClearException();
1507      resolve_fields_and_methods = false;
1508    } else {
1509      resolve_fields_and_methods = manager->GetCompiler()->IsImage();
1510    }
1511    // Note the class_data pointer advances through the headers,
1512    // static fields, instance fields, direct methods, and virtual
1513    // methods.
1514    const byte* class_data = dex_file.GetClassData(class_def);
1515    if (class_data == NULL) {
1516      // Empty class such as a marker interface.
1517      requires_constructor_barrier = false;
1518    } else {
1519      ClassDataItemIterator it(dex_file, class_data);
1520      while (it.HasNextStaticField()) {
1521        if (resolve_fields_and_methods) {
1522          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1523                                                               dex_cache, class_loader, true);
1524          if (field == NULL) {
1525            CHECK(soa.Self()->IsExceptionPending());
1526            soa.Self()->ClearException();
1527          }
1528        }
1529        it.Next();
1530      }
1531      // We require a constructor barrier if there are final instance fields.
1532      requires_constructor_barrier = false;
1533      while (it.HasNextInstanceField()) {
1534        if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
1535          requires_constructor_barrier = true;
1536        }
1537        if (resolve_fields_and_methods) {
1538          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1539                                                               dex_cache, class_loader, false);
1540          if (field == NULL) {
1541            CHECK(soa.Self()->IsExceptionPending());
1542            soa.Self()->ClearException();
1543          }
1544        }
1545        it.Next();
1546      }
1547      if (resolve_fields_and_methods) {
1548        while (it.HasNextDirectMethod()) {
1549          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1550                                                                  dex_cache, class_loader, NULL,
1551                                                                  it.GetMethodInvokeType(class_def));
1552          if (method == NULL) {
1553            CHECK(soa.Self()->IsExceptionPending());
1554            soa.Self()->ClearException();
1555          }
1556          it.Next();
1557        }
1558        while (it.HasNextVirtualMethod()) {
1559          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1560                                                                  dex_cache, class_loader, NULL,
1561                                                                  it.GetMethodInvokeType(class_def));
1562          if (method == NULL) {
1563            CHECK(soa.Self()->IsExceptionPending());
1564            soa.Self()->ClearException();
1565          }
1566          it.Next();
1567        }
1568        DCHECK(!it.HasNext());
1569      }
1570    }
1571  }
1572  if (requires_constructor_barrier) {
1573    manager->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index);
1574  }
1575}
1576
1577static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx)
1578    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1579  // Class derived values are more complicated, they require the linker and loader.
1580  ScopedObjectAccess soa(Thread::Current());
1581  ClassLinker* class_linker = manager->GetClassLinker();
1582  const DexFile& dex_file = *manager->GetDexFile();
1583  StackHandleScope<2> hs(soa.Self());
1584  Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file)));
1585  Handle<mirror::ClassLoader> class_loader(
1586      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader())));
1587  mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
1588
1589  if (klass == NULL) {
1590    CHECK(soa.Self()->IsExceptionPending());
1591    mirror::Throwable* exception = soa.Self()->GetException(NULL);
1592    VLOG(compiler) << "Exception during type resolution: " << exception->Dump();
1593    if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) {
1594      // There's little point continuing compilation if the heap is exhausted.
1595      LOG(FATAL) << "Out of memory during type resolution for compilation";
1596    }
1597    soa.Self()->ClearException();
1598  }
1599}
1600
1601void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
1602                                    ThreadPool* thread_pool, TimingLogger* timings) {
1603  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1604
1605  // TODO: we could resolve strings here, although the string table is largely filled with class
1606  //       and method names.
1607
1608  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1609  if (IsImage()) {
1610    // For images we resolve all types, such as array, whereas for applications just those with
1611    // classdefs are resolved by ResolveClassFieldsAndMethods.
1612    timings->NewSplit("Resolve Types");
1613    context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
1614  }
1615
1616  timings->NewSplit("Resolve MethodsAndFields");
1617  context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
1618}
1619
1620void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1621                            ThreadPool* thread_pool, TimingLogger* timings) {
1622  for (size_t i = 0; i != dex_files.size(); ++i) {
1623    const DexFile* dex_file = dex_files[i];
1624    CHECK(dex_file != NULL);
1625    VerifyDexFile(class_loader, *dex_file, thread_pool, timings);
1626  }
1627}
1628
1629static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index)
1630    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1631  ATRACE_CALL();
1632  ScopedObjectAccess soa(Thread::Current());
1633  const DexFile& dex_file = *manager->GetDexFile();
1634  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1635  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1636  ClassLinker* class_linker = manager->GetClassLinker();
1637  jobject jclass_loader = manager->GetClassLoader();
1638  StackHandleScope<3> hs(soa.Self());
1639  Handle<mirror::ClassLoader> class_loader(
1640      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1641  Handle<mirror::Class> klass(
1642      hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader)));
1643  if (klass.Get() == nullptr) {
1644    CHECK(soa.Self()->IsExceptionPending());
1645    soa.Self()->ClearException();
1646
1647    /*
1648     * At compile time, we can still structurally verify the class even if FindClass fails.
1649     * This is to ensure the class is structurally sound for compilation. An unsound class
1650     * will be rejected by the verifier and later skipped during compilation in the compiler.
1651     */
1652    Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file)));
1653    std::string error_msg;
1654    if (verifier::MethodVerifier::VerifyClass(&dex_file, dex_cache, class_loader, &class_def, true,
1655                                              &error_msg) ==
1656                                                  verifier::MethodVerifier::kHardFailure) {
1657      LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor)
1658                 << " because: " << error_msg;
1659    }
1660  } else if (!SkipClass(jclass_loader, dex_file, klass.Get())) {
1661    CHECK(klass->IsResolved()) << PrettyClass(klass.Get());
1662    class_linker->VerifyClass(klass);
1663
1664    if (klass->IsErroneous()) {
1665      // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
1666      CHECK(soa.Self()->IsExceptionPending());
1667      soa.Self()->ClearException();
1668    }
1669
1670    CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
1671        << PrettyDescriptor(klass.Get()) << ": state=" << klass->GetStatus();
1672  }
1673  soa.Self()->AssertNoPendingException();
1674}
1675
1676void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
1677                                   ThreadPool* thread_pool, TimingLogger* timings) {
1678  timings->NewSplit("Verify Dex File");
1679  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1680  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1681  context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
1682}
1683
1684static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
1685    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1686  ATRACE_CALL();
1687  jobject jclass_loader = manager->GetClassLoader();
1688  const DexFile& dex_file = *manager->GetDexFile();
1689  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1690  const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_);
1691  const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_);
1692
1693  ScopedObjectAccess soa(Thread::Current());
1694  StackHandleScope<3> hs(soa.Self());
1695  Handle<mirror::ClassLoader> class_loader(
1696      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1697  Handle<mirror::Class> klass(
1698      hs.NewHandle(manager->GetClassLinker()->FindClass(soa.Self(), descriptor, class_loader)));
1699
1700  if (klass.Get() != nullptr && !SkipClass(jclass_loader, dex_file, klass.Get())) {
1701    // Only try to initialize classes that were successfully verified.
1702    if (klass->IsVerified()) {
1703      // Attempt to initialize the class but bail if we either need to initialize the super-class
1704      // or static fields.
1705      manager->GetClassLinker()->EnsureInitialized(klass, false, false);
1706      if (!klass->IsInitialized()) {
1707        // We don't want non-trivial class initialization occurring on multiple threads due to
1708        // deadlock problems. For example, a parent class is initialized (holding its lock) that
1709        // refers to a sub-class in its static/class initializer causing it to try to acquire the
1710        // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock)
1711        // after first initializing its parents, whose locks are acquired. This leads to a
1712        // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock.
1713        // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
1714        // than use a special Object for the purpose we use the Class of java.lang.Class.
1715        Handle<mirror::Class> h_klass(hs.NewHandle(klass->GetClass()));
1716        ObjectLock<mirror::Class> lock(soa.Self(), h_klass);
1717        // Attempt to initialize allowing initialization of parent classes but still not static
1718        // fields.
1719        manager->GetClassLinker()->EnsureInitialized(klass, false, true);
1720        if (!klass->IsInitialized()) {
1721          // We need to initialize static fields, we only do this for image classes that aren't
1722          // marked with the $NoPreloadHolder (which implies this should not be initialized early).
1723          bool can_init_static_fields = manager->GetCompiler()->IsImage() &&
1724              manager->GetCompiler()->IsImageClass(descriptor) &&
1725              !StringPiece(descriptor).ends_with("$NoPreloadHolder;");
1726          if (can_init_static_fields) {
1727            VLOG(compiler) << "Initializing: " << descriptor;
1728            // TODO multithreading support. We should ensure the current compilation thread has
1729            // exclusive access to the runtime and the transaction. To achieve this, we could use
1730            // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity
1731            // checks in Thread::AssertThreadSuspensionIsAllowable.
1732            Runtime* const runtime = Runtime::Current();
1733            Transaction transaction;
1734
1735            // Run the class initializer in transaction mode.
1736            runtime->EnterTransactionMode(&transaction);
1737            const mirror::Class::Status old_status = klass->GetStatus();
1738            bool success = manager->GetClassLinker()->EnsureInitialized(klass, true, true);
1739            // TODO we detach transaction from runtime to indicate we quit the transactional
1740            // mode which prevents the GC from visiting objects modified during the transaction.
1741            // Ensure GC is not run so don't access freed objects when aborting transaction.
1742            const char* old_casue = soa.Self()->StartAssertNoThreadSuspension("Transaction end");
1743            runtime->ExitTransactionMode();
1744
1745            if (!success) {
1746              CHECK(soa.Self()->IsExceptionPending());
1747              ThrowLocation throw_location;
1748              mirror::Throwable* exception = soa.Self()->GetException(&throw_location);
1749              VLOG(compiler) << "Initialization of " << descriptor << " aborted because of "
1750                  << exception->Dump();
1751              soa.Self()->ClearException();
1752              transaction.Abort();
1753              CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored";
1754            }
1755            soa.Self()->EndAssertNoThreadSuspension(old_casue);
1756          }
1757        }
1758        soa.Self()->AssertNoPendingException();
1759      }
1760    }
1761    // Record the final class status if necessary.
1762    ClassReference ref(manager->GetDexFile(), class_def_index);
1763    manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
1764  }
1765  // Clear any class not found or verification exceptions.
1766  soa.Self()->ClearException();
1767}
1768
1769void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
1770                                       ThreadPool* thread_pool, TimingLogger* timings) {
1771  timings->NewSplit("InitializeNoClinit");
1772  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1773  ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
1774  size_t thread_count;
1775  if (IsImage()) {
1776    // TODO: remove this when transactional mode supports multithreading.
1777    thread_count = 1U;
1778  } else {
1779    thread_count = thread_count_;
1780  }
1781  context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count);
1782  if (IsImage()) {
1783    // Prune garbage objects created during aborted transactions.
1784    Runtime::Current()->GetHeap()->CollectGarbage(true);
1785  }
1786}
1787
1788void CompilerDriver::InitializeClasses(jobject class_loader,
1789                                       const std::vector<const DexFile*>& dex_files,
1790                                       ThreadPool* thread_pool, TimingLogger* timings) {
1791  for (size_t i = 0; i != dex_files.size(); ++i) {
1792    const DexFile* dex_file = dex_files[i];
1793    CHECK(dex_file != NULL);
1794    InitializeClasses(class_loader, *dex_file, thread_pool, timings);
1795  }
1796}
1797
1798void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1799                             ThreadPool* thread_pool, TimingLogger* timings) {
1800  for (size_t i = 0; i != dex_files.size(); ++i) {
1801    const DexFile* dex_file = dex_files[i];
1802    CHECK(dex_file != NULL);
1803    CompileDexFile(class_loader, *dex_file, thread_pool, timings);
1804  }
1805}
1806
1807void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) {
1808  ATRACE_CALL();
1809  jobject jclass_loader = manager->GetClassLoader();
1810  const DexFile& dex_file = *manager->GetDexFile();
1811  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1812  ClassLinker* class_linker = manager->GetClassLinker();
1813  if (SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1814    return;
1815  }
1816  ClassReference ref(&dex_file, class_def_index);
1817  // Skip compiling classes with generic verifier failures since they will still fail at runtime
1818  if (manager->GetCompiler()->verification_results_->IsClassRejected(ref)) {
1819    return;
1820  }
1821  const byte* class_data = dex_file.GetClassData(class_def);
1822  if (class_data == NULL) {
1823    // empty class, probably a marker interface
1824    return;
1825  }
1826
1827  // Can we run DEX-to-DEX compiler on this class ?
1828  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
1829  {
1830    ScopedObjectAccess soa(Thread::Current());
1831    StackHandleScope<1> hs(soa.Self());
1832    Handle<mirror::ClassLoader> class_loader(
1833        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1834    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(soa.Self(), class_loader, dex_file,
1835                                                               class_def);
1836  }
1837  ClassDataItemIterator it(dex_file, class_data);
1838  // Skip fields
1839  while (it.HasNextStaticField()) {
1840    it.Next();
1841  }
1842  while (it.HasNextInstanceField()) {
1843    it.Next();
1844  }
1845  CompilerDriver* driver = manager->GetCompiler();
1846  // Compile direct methods
1847  int64_t previous_direct_method_idx = -1;
1848  while (it.HasNextDirectMethod()) {
1849    uint32_t method_idx = it.GetMemberIndex();
1850    if (method_idx == previous_direct_method_idx) {
1851      // smali can create dex files with two encoded_methods sharing the same method_idx
1852      // http://code.google.com/p/smali/issues/detail?id=119
1853      it.Next();
1854      continue;
1855    }
1856    previous_direct_method_idx = method_idx;
1857    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1858                          it.GetMethodInvokeType(class_def), class_def_index,
1859                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1860    it.Next();
1861  }
1862  // Compile virtual methods
1863  int64_t previous_virtual_method_idx = -1;
1864  while (it.HasNextVirtualMethod()) {
1865    uint32_t method_idx = it.GetMemberIndex();
1866    if (method_idx == previous_virtual_method_idx) {
1867      // smali can create dex files with two encoded_methods sharing the same method_idx
1868      // http://code.google.com/p/smali/issues/detail?id=119
1869      it.Next();
1870      continue;
1871    }
1872    previous_virtual_method_idx = method_idx;
1873    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1874                          it.GetMethodInvokeType(class_def), class_def_index,
1875                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1876    it.Next();
1877  }
1878  DCHECK(!it.HasNext());
1879}
1880
1881void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
1882                                    ThreadPool* thread_pool, TimingLogger* timings) {
1883  timings->NewSplit("Compile Dex File");
1884  ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this,
1885                                     &dex_file, thread_pool);
1886  context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
1887}
1888
1889void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
1890                                   InvokeType invoke_type, uint16_t class_def_idx,
1891                                   uint32_t method_idx, jobject class_loader,
1892                                   const DexFile& dex_file,
1893                                   DexToDexCompilationLevel dex_to_dex_compilation_level) {
1894  CompiledMethod* compiled_method = NULL;
1895  uint64_t start_ns = NanoTime();
1896
1897  if ((access_flags & kAccNative) != 0) {
1898    // Are we interpreting only and have support for generic JNI down calls?
1899    if (!compiler_options_->IsCompilationEnabled() &&
1900        (instruction_set_ == kX86_64 || instruction_set_ == kArm64)) {
1901      // Leaving this empty will trigger the generic JNI version
1902    } else {
1903      compiled_method = compiler_->JniCompile(access_flags, method_idx, dex_file);
1904      CHECK(compiled_method != NULL);
1905    }
1906  } else if ((access_flags & kAccAbstract) != 0) {
1907  } else {
1908    MethodReference method_ref(&dex_file, method_idx);
1909    bool compile = verification_results_->IsCandidateForCompilation(method_ref, access_flags);
1910    if (compile) {
1911      // NOTE: if compiler declines to compile this method, it will return NULL.
1912      compiled_method = compiler_->Compile(code_item, access_flags, invoke_type, class_def_idx,
1913                                           method_idx, class_loader, dex_file);
1914    }
1915    if (compiled_method == nullptr && dex_to_dex_compilation_level != kDontDexToDexCompile) {
1916      // TODO: add a command-line option to disable DEX-to-DEX compilation ?
1917      (*dex_to_dex_compiler_)(*this, code_item, access_flags,
1918                              invoke_type, class_def_idx,
1919                              method_idx, class_loader, dex_file,
1920                              dex_to_dex_compilation_level);
1921    }
1922  }
1923  uint64_t duration_ns = NanoTime() - start_ns;
1924  if (duration_ns > MsToNs(compiler_->GetMaximumCompilationTimeBeforeWarning())) {
1925    LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
1926                 << " took " << PrettyDuration(duration_ns);
1927  }
1928
1929  Thread* self = Thread::Current();
1930  if (compiled_method != NULL) {
1931    MethodReference ref(&dex_file, method_idx);
1932    DCHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
1933    {
1934      MutexLock mu(self, compiled_methods_lock_);
1935      compiled_methods_.Put(ref, compiled_method);
1936    }
1937    DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
1938  }
1939
1940  if (self->IsExceptionPending()) {
1941    ScopedObjectAccess soa(self);
1942    LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
1943        << self->GetException(NULL)->Dump();
1944  }
1945}
1946
1947CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
1948  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1949  ClassTable::const_iterator it = compiled_classes_.find(ref);
1950  if (it == compiled_classes_.end()) {
1951    return NULL;
1952  }
1953  CHECK(it->second != NULL);
1954  return it->second;
1955}
1956
1957void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) {
1958  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1959  auto it = compiled_classes_.find(ref);
1960  if (it == compiled_classes_.end() || it->second->GetStatus() != status) {
1961    // An entry doesn't exist or the status is lower than the new status.
1962    if (it != compiled_classes_.end()) {
1963      CHECK_GT(status, it->second->GetStatus());
1964      delete it->second;
1965    }
1966    switch (status) {
1967      case mirror::Class::kStatusNotReady:
1968      case mirror::Class::kStatusError:
1969      case mirror::Class::kStatusRetryVerificationAtRuntime:
1970      case mirror::Class::kStatusVerified:
1971      case mirror::Class::kStatusInitialized:
1972        break;  // Expected states.
1973      default:
1974        LOG(FATAL) << "Unexpected class status for class "
1975            << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second)))
1976            << " of " << status;
1977    }
1978    CompiledClass* compiled_class = new CompiledClass(status);
1979    compiled_classes_.Overwrite(ref, compiled_class);
1980  }
1981}
1982
1983CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
1984  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1985  MethodTable::const_iterator it = compiled_methods_.find(ref);
1986  if (it == compiled_methods_.end()) {
1987    return NULL;
1988  }
1989  CHECK(it->second != NULL);
1990  return it->second;
1991}
1992
1993void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
1994                                                   uint16_t class_def_index) {
1995  WriterMutexLock mu(self, freezing_constructor_lock_);
1996  freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
1997}
1998
1999bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
2000                                                uint16_t class_def_index) {
2001  ReaderMutexLock mu(self, freezing_constructor_lock_);
2002  return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
2003}
2004
2005bool CompilerDriver::WriteElf(const std::string& android_root,
2006                              bool is_host,
2007                              const std::vector<const art::DexFile*>& dex_files,
2008                              OatWriter* oat_writer,
2009                              art::File* file)
2010    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2011  return compiler_->WriteElf(file, oat_writer, dex_files, android_root, is_host);
2012}
2013void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
2014                                                std::string* target_triple,
2015                                                std::string* target_cpu,
2016                                                std::string* target_attr) {
2017  switch (instruction_set) {
2018    case kThumb2:
2019      *target_triple = "thumb-none-linux-gnueabi";
2020      *target_cpu = "cortex-a9";
2021      *target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
2022      break;
2023
2024    case kArm:
2025      *target_triple = "armv7-none-linux-gnueabi";
2026      // TODO: Fix for Nexus S.
2027      *target_cpu = "cortex-a9";
2028      // TODO: Fix for Xoom.
2029      *target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
2030      break;
2031
2032    case kX86:
2033      *target_triple = "i386-pc-linux-gnu";
2034      *target_attr = "";
2035      break;
2036
2037    case kX86_64:
2038      *target_triple = "x86_64-pc-linux-gnu";
2039      *target_attr = "";
2040      break;
2041
2042    case kMips:
2043      *target_triple = "mipsel-unknown-linux";
2044      *target_attr = "mips32r2";
2045      break;
2046
2047    default:
2048      LOG(FATAL) << "Unknown instruction set: " << instruction_set;
2049    }
2050  }
2051
2052bool CompilerDriver::SkipCompilation(const std::string& method_name) {
2053  if (!profile_ok_) {
2054    return false;
2055  }
2056  // Methods that comprise topKPercentThreshold % of the total samples will be compiled.
2057  double topKPercentThreshold = 90.0;
2058#ifdef HAVE_ANDROID_OS
2059  char buf[PROP_VALUE_MAX];
2060  property_get("dalvik.vm.profile.compile_thr", buf, "90.0");
2061  topKPercentThreshold = strtod(buf, nullptr);
2062#endif
2063  // Test for reasonable thresholds.
2064  if (topKPercentThreshold < 10.0 || topKPercentThreshold > 90.0) {
2065    topKPercentThreshold = 90.0;
2066  }
2067
2068  // First find the method in the profile map.
2069  ProfileMap::iterator i = profile_map_.find(method_name);
2070  if (i == profile_map_.end()) {
2071    // Not in profile, no information can be determined.
2072    VLOG(compiler) << "not compiling " << method_name << " because it's not in the profile";
2073    return true;
2074  }
2075  const ProfileData& data = i->second;
2076
2077  // Compare against the start of the topK percentage bucket just in case the threshold
2078  // falls inside a bucket.
2079  bool compile = data.GetTopKUsedPercentage() - data.GetUsedPercent() <= topKPercentThreshold;
2080  if (compile) {
2081    LOG(INFO) << "compiling method " << method_name << " because its usage is part of top "
2082        << data.GetTopKUsedPercentage() << "% with a percent of " << data.GetUsedPercent() << "%";
2083  } else {
2084    VLOG(compiler) << "not compiling method " << method_name << " because it's not part of leading "
2085        << topKPercentThreshold << "% samples)";
2086  }
2087  return !compile;
2088}
2089}  // namespace art
2090