compiler_driver.cc revision e0099d4d4839cabfb26270a746580e9d4ec3a6c6 
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  std::unique_ptr<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  std::unique_ptr<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<2> hs(self);
735      Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(*dex_file)));
736      Handle<mirror::Class> klass(hs.NewHandle(
737          class_linker->ResolveType(*dex_file, exception_type_idx, dex_cache,
738                                    NullHandle<mirror::ClassLoader>())));
739      if (klass.Get() == NULL) {
740        const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
741        const char* descriptor = dex_file->GetTypeDescriptor(type_id);
742        LOG(FATAL) << "Failed to resolve class " << descriptor;
743      }
744      DCHECK(java_lang_Throwable->IsAssignableFrom(klass.Get()));
745    }
746    // Resolving exceptions may load classes that reference more exceptions, iterate until no
747    // more are found
748  } while (!unresolved_exception_types.empty());
749
750  // We walk the roots looking for classes so that we'll pick up the
751  // above classes plus any classes them depend on such super
752  // classes, interfaces, and the required ClassLinker roots.
753  class_linker->VisitClasses(RecordImageClassesVisitor, image_classes_.get());
754
755  CHECK_NE(image_classes_->size(), 0U);
756}
757
758static void MaybeAddToImageClasses(Handle<mirror::Class> c,
759                                   CompilerDriver::DescriptorSet* image_classes)
760    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
761  Thread* self = Thread::Current();
762  StackHandleScope<1> hs(self);
763  // Make a copy of the handle so that we don't clobber it doing Assign.
764  Handle<mirror::Class> klass(hs.NewHandle(c.Get()));
765  while (!klass->IsObjectClass()) {
766    std::string descriptor(klass->GetDescriptor());
767    std::pair<CompilerDriver::DescriptorSet::iterator, bool> result =
768        image_classes->insert(descriptor);
769    if (result.second) {
770        VLOG(compiler) << "Adding " << descriptor << " to image classes";
771    } else {
772      return;
773    }
774    for (size_t i = 0; i < klass->NumDirectInterfaces(); ++i) {
775      StackHandleScope<1> hs(self);
776      MaybeAddToImageClasses(hs.NewHandle(mirror::Class::GetDirectInterface(self, klass, i)),
777                             image_classes);
778    }
779    if (klass->IsArrayClass()) {
780      StackHandleScope<1> hs(self);
781      MaybeAddToImageClasses(hs.NewHandle(klass->GetComponentType()), image_classes);
782    }
783    klass.Assign(klass->GetSuperClass());
784  }
785}
786
787void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void* arg) {
788  DCHECK(object != NULL);
789  DCHECK(arg != NULL);
790  CompilerDriver* compiler_driver = reinterpret_cast<CompilerDriver*>(arg);
791  StackHandleScope<1> hs(Thread::Current());
792  MaybeAddToImageClasses(hs.NewHandle(object->GetClass()), compiler_driver->image_classes_.get());
793}
794
795void CompilerDriver::UpdateImageClasses(TimingLogger* timings) {
796  if (IsImage()) {
797    timings->NewSplit("UpdateImageClasses");
798
799    // Update image_classes_ with classes for objects created by <clinit> methods.
800    Thread* self = Thread::Current();
801    const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
802    gc::Heap* heap = Runtime::Current()->GetHeap();
803    // TODO: Image spaces only?
804    ScopedObjectAccess soa(Thread::Current());
805    WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
806    heap->VisitObjects(FindClinitImageClassesCallback, this);
807    self->EndAssertNoThreadSuspension(old_cause);
808  }
809}
810
811bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx) {
812  if (IsImage() &&
813      IsImageClass(dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_))) {
814    if (kIsDebugBuild) {
815      ScopedObjectAccess soa(Thread::Current());
816      mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
817      mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
818      CHECK(resolved_class != NULL);
819    }
820    stats_->TypeInDexCache();
821    return true;
822  } else {
823    stats_->TypeNotInDexCache();
824    return false;
825  }
826}
827
828bool CompilerDriver::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file,
829                                                        uint32_t string_idx) {
830  // See also Compiler::ResolveDexFile
831
832  bool result = false;
833  if (IsImage()) {
834    // We resolve all const-string strings when building for the image.
835    ScopedObjectAccess soa(Thread::Current());
836    StackHandleScope<1> hs(soa.Self());
837    Handle<mirror::DexCache> dex_cache(
838        hs.NewHandle(Runtime::Current()->GetClassLinker()->FindDexCache(dex_file)));
839    Runtime::Current()->GetClassLinker()->ResolveString(dex_file, string_idx, dex_cache);
840    result = true;
841  }
842  if (result) {
843    stats_->StringInDexCache();
844  } else {
845    stats_->StringNotInDexCache();
846  }
847  return result;
848}
849
850bool CompilerDriver::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
851                                                uint32_t type_idx,
852                                                bool* type_known_final, bool* type_known_abstract,
853                                                bool* equals_referrers_class) {
854  if (type_known_final != NULL) {
855    *type_known_final = false;
856  }
857  if (type_known_abstract != NULL) {
858    *type_known_abstract = false;
859  }
860  if (equals_referrers_class != NULL) {
861    *equals_referrers_class = false;
862  }
863  ScopedObjectAccess soa(Thread::Current());
864  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
865  // Get type from dex cache assuming it was populated by the verifier
866  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
867  if (resolved_class == NULL) {
868    stats_->TypeNeedsAccessCheck();
869    return false;  // Unknown class needs access checks.
870  }
871  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
872  if (equals_referrers_class != NULL) {
873    *equals_referrers_class = (method_id.class_idx_ == type_idx);
874  }
875  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
876  if (referrer_class == NULL) {
877    stats_->TypeNeedsAccessCheck();
878    return false;  // Incomplete referrer knowledge needs access check.
879  }
880  // Perform access check, will return true if access is ok or false if we're going to have to
881  // check this at runtime (for example for class loaders).
882  bool result = referrer_class->CanAccess(resolved_class);
883  if (result) {
884    stats_->TypeDoesntNeedAccessCheck();
885    if (type_known_final != NULL) {
886      *type_known_final = resolved_class->IsFinal() && !resolved_class->IsArrayClass();
887    }
888    if (type_known_abstract != NULL) {
889      *type_known_abstract = resolved_class->IsAbstract() && !resolved_class->IsArrayClass();
890    }
891  } else {
892    stats_->TypeNeedsAccessCheck();
893  }
894  return result;
895}
896
897bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx,
898                                                            const DexFile& dex_file,
899                                                            uint32_t type_idx) {
900  ScopedObjectAccess soa(Thread::Current());
901  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
902  // Get type from dex cache assuming it was populated by the verifier.
903  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
904  if (resolved_class == NULL) {
905    stats_->TypeNeedsAccessCheck();
906    return false;  // Unknown class needs access checks.
907  }
908  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
909  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
910  if (referrer_class == NULL) {
911    stats_->TypeNeedsAccessCheck();
912    return false;  // Incomplete referrer knowledge needs access check.
913  }
914  // Perform access and instantiable checks, will return true if access is ok or false if we're
915  // going to have to check this at runtime (for example for class loaders).
916  bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable();
917  if (result) {
918    stats_->TypeDoesntNeedAccessCheck();
919  } else {
920    stats_->TypeNeedsAccessCheck();
921  }
922  return result;
923}
924
925bool CompilerDriver::CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx,
926                                        bool* is_type_initialized, bool* use_direct_type_ptr,
927                                        uintptr_t* direct_type_ptr, bool* out_is_finalizable) {
928  ScopedObjectAccess soa(Thread::Current());
929  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
930  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
931  if (resolved_class == nullptr) {
932    return false;
933  }
934  *out_is_finalizable = resolved_class->IsFinalizable();
935  const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot();
936  if (compiling_boot) {
937    // boot -> boot class pointers.
938    // True if the class is in the image at boot compiling time.
939    const bool is_image_class = IsImage() && IsImageClass(
940        dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_));
941    // True if pc relative load works.
942    const bool support_boot_image_fixup = GetSupportBootImageFixup();
943    if (is_image_class && support_boot_image_fixup) {
944      *is_type_initialized = resolved_class->IsInitialized();
945      *use_direct_type_ptr = false;
946      *direct_type_ptr = 0;
947      return true;
948    } else {
949      return false;
950    }
951  } else {
952    // True if the class is in the image at app compiling time.
953    const bool class_in_image =
954        Runtime::Current()->GetHeap()->FindSpaceFromObject(resolved_class, false)->IsImageSpace();
955    if (class_in_image) {
956      // boot -> app class pointers.
957      *is_type_initialized = resolved_class->IsInitialized();
958      *use_direct_type_ptr = true;
959      *direct_type_ptr = reinterpret_cast<uintptr_t>(resolved_class);
960      return true;
961    } else {
962      // app -> app class pointers.
963      // Give up because app does not have an image and class
964      // isn't created at compile time.  TODO: implement this
965      // if/when each app gets an image.
966      return false;
967    }
968  }
969}
970
971void CompilerDriver::ProcessedInstanceField(bool resolved) {
972  if (!resolved) {
973    stats_->UnresolvedInstanceField();
974  } else {
975    stats_->ResolvedInstanceField();
976  }
977}
978
979void CompilerDriver::ProcessedStaticField(bool resolved, bool local) {
980  if (!resolved) {
981    stats_->UnresolvedStaticField();
982  } else if (local) {
983    stats_->ResolvedLocalStaticField();
984  } else {
985    stats_->ResolvedStaticField();
986  }
987}
988
989void CompilerDriver::ProcessedInvoke(InvokeType invoke_type, int flags) {
990  stats_->ProcessedInvoke(invoke_type, flags);
991}
992
993bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
994                                              bool is_put, MemberOffset* field_offset,
995                                              bool* is_volatile) {
996  ScopedObjectAccess soa(Thread::Current());
997  // Try to resolve the field and compiling method's class.
998  mirror::ArtField* resolved_field;
999  mirror::Class* referrer_class;
1000  mirror::DexCache* dex_cache;
1001  {
1002    StackHandleScope<3> hs(soa.Self());
1003    Handle<mirror::DexCache> dex_cache_handle(
1004        hs.NewHandle(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile())));
1005    Handle<mirror::ClassLoader> class_loader_handle(
1006        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())));
1007    Handle<mirror::ArtField> resolved_field_handle(hs.NewHandle(
1008        ResolveField(soa, dex_cache_handle, class_loader_handle, mUnit, field_idx, false)));
1009    referrer_class = (resolved_field_handle.Get() != nullptr)
1010        ? ResolveCompilingMethodsClass(soa, dex_cache_handle, class_loader_handle, mUnit) : nullptr;
1011    resolved_field = resolved_field_handle.Get();
1012    dex_cache = dex_cache_handle.Get();
1013  }
1014  bool result = false;
1015  if (resolved_field != nullptr && referrer_class != nullptr) {
1016    *is_volatile = IsFieldVolatile(resolved_field);
1017    std::pair<bool, bool> fast_path = IsFastInstanceField(
1018        dex_cache, referrer_class, resolved_field, field_idx, field_offset);
1019    result = is_put ? fast_path.second : fast_path.first;
1020  }
1021  if (!result) {
1022    // Conservative defaults.
1023    *is_volatile = true;
1024    *field_offset = MemberOffset(static_cast<size_t>(-1));
1025  }
1026  ProcessedInstanceField(result);
1027  return result;
1028}
1029
1030bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
1031                                            bool is_put, MemberOffset* field_offset,
1032                                            uint32_t* storage_index, bool* is_referrers_class,
1033                                            bool* is_volatile, bool* is_initialized) {
1034  ScopedObjectAccess soa(Thread::Current());
1035  // Try to resolve the field and compiling method's class.
1036  mirror::ArtField* resolved_field;
1037  mirror::Class* referrer_class;
1038  mirror::DexCache* dex_cache;
1039  {
1040    StackHandleScope<3> hs(soa.Self());
1041    Handle<mirror::DexCache> dex_cache_handle(
1042        hs.NewHandle(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile())));
1043    Handle<mirror::ClassLoader> class_loader_handle(
1044        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())));
1045    Handle<mirror::ArtField> resolved_field_handle(hs.NewHandle(
1046        ResolveField(soa, dex_cache_handle, class_loader_handle, mUnit, field_idx, true)));
1047    referrer_class = (resolved_field_handle.Get() != nullptr)
1048        ? ResolveCompilingMethodsClass(soa, dex_cache_handle, class_loader_handle, mUnit) : nullptr;
1049    resolved_field = resolved_field_handle.Get();
1050    dex_cache = dex_cache_handle.Get();
1051  }
1052  bool result = false;
1053  if (resolved_field != nullptr && referrer_class != nullptr) {
1054    *is_volatile = IsFieldVolatile(resolved_field);
1055    std::pair<bool, bool> fast_path = IsFastStaticField(
1056        dex_cache, referrer_class, resolved_field, field_idx, field_offset,
1057        storage_index, is_referrers_class, is_initialized);
1058    result = is_put ? fast_path.second : fast_path.first;
1059  }
1060  if (!result) {
1061    // Conservative defaults.
1062    *is_volatile = true;
1063    *field_offset = MemberOffset(static_cast<size_t>(-1));
1064    *storage_index = -1;
1065    *is_referrers_class = false;
1066    *is_initialized = false;
1067  }
1068  ProcessedStaticField(result, *is_referrers_class);
1069  return result;
1070}
1071
1072void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type,
1073                                                   bool no_guarantee_of_dex_cache_entry,
1074                                                   mirror::Class* referrer_class,
1075                                                   mirror::ArtMethod* method,
1076                                                   int* stats_flags,
1077                                                   MethodReference* target_method,
1078                                                   uintptr_t* direct_code,
1079                                                   uintptr_t* direct_method) {
1080  // For direct and static methods compute possible direct_code and direct_method values, ie
1081  // an address for the Method* being invoked and an address of the code for that Method*.
1082  // For interface calls compute a value for direct_method that is the interface method being
1083  // invoked, so this can be passed to the out-of-line runtime support code.
1084  *direct_code = 0;
1085  *direct_method = 0;
1086  bool use_dex_cache = false;
1087  const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot();
1088  if (compiler_->IsPortable()) {
1089    if (sharp_type != kStatic && sharp_type != kDirect) {
1090      return;
1091    }
1092    use_dex_cache = true;
1093  } else {
1094    if (sharp_type != kStatic && sharp_type != kDirect) {
1095      return;
1096    }
1097    // TODO: support patching on all architectures.
1098    use_dex_cache = compiling_boot && !support_boot_image_fixup_;
1099  }
1100  bool method_code_in_boot = (method->GetDeclaringClass()->GetClassLoader() == nullptr);
1101  if (!use_dex_cache) {
1102    if (!method_code_in_boot) {
1103      use_dex_cache = true;
1104    } else {
1105      bool has_clinit_trampoline =
1106          method->IsStatic() && !method->GetDeclaringClass()->IsInitialized();
1107      if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) {
1108        // Ensure we run the clinit trampoline unless we are invoking a static method in the same
1109        // class.
1110        use_dex_cache = true;
1111      }
1112    }
1113  }
1114  if (method_code_in_boot) {
1115    *stats_flags |= kFlagDirectCallToBoot | kFlagDirectMethodToBoot;
1116  }
1117  if (!use_dex_cache && compiling_boot) {
1118    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 && !use_dex_cache) {
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    bool method_in_image = compiling_boot ||
1156        Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace();
1157    if (method_in_image) {
1158      CHECK(!method->IsAbstract());
1159      *type = sharp_type;
1160      *direct_method = compiling_boot ? -1 : reinterpret_cast<uintptr_t>(method);
1161      *direct_code = compiling_boot ? -1 : compiler_->GetEntryPointOf(method);
1162      target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1163      target_method->dex_method_index = method->GetDexMethodIndex();
1164    } else if (!must_use_direct_pointers) {
1165      // Set the code and rely on the dex cache for the method.
1166      *type = sharp_type;
1167      *direct_code = compiler_->GetEntryPointOf(method);
1168    } else {
1169      // Direct pointers were required but none were available.
1170      VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method);
1171    }
1172  }
1173}
1174
1175bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
1176                                       bool update_stats, bool enable_devirtualization,
1177                                       InvokeType* invoke_type, MethodReference* target_method,
1178                                       int* vtable_idx, uintptr_t* direct_code,
1179                                       uintptr_t* direct_method) {
1180  InvokeType orig_invoke_type = *invoke_type;
1181  int stats_flags = 0;
1182  ScopedObjectAccess soa(Thread::Current());
1183  // Try to resolve the method and compiling method's class.
1184  mirror::ArtMethod* resolved_method;
1185  mirror::Class* referrer_class;
1186  StackHandleScope<3> hs(soa.Self());
1187  Handle<mirror::DexCache> dex_cache(
1188      hs.NewHandle(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile())));
1189  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
1190      soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())));
1191  {
1192    uint32_t method_idx = target_method->dex_method_index;
1193    Handle<mirror::ArtMethod> resolved_method_handle(hs.NewHandle(
1194        ResolveMethod(soa, dex_cache, class_loader, mUnit, method_idx, orig_invoke_type)));
1195    referrer_class = (resolved_method_handle.Get() != nullptr)
1196        ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader, mUnit) : nullptr;
1197    resolved_method = resolved_method_handle.Get();
1198  }
1199  bool result = false;
1200  if (resolved_method != nullptr) {
1201    *vtable_idx = GetResolvedMethodVTableIndex(resolved_method, orig_invoke_type);
1202
1203    if (enable_devirtualization) {
1204      DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1205      const MethodReference* devirt_target = mUnit->GetVerifiedMethod()->GetDevirtTarget(dex_pc);
1206
1207      stats_flags = IsFastInvoke(
1208          soa, dex_cache, class_loader, mUnit, referrer_class, resolved_method,
1209          invoke_type, target_method, devirt_target, direct_code, direct_method);
1210      result = stats_flags != 0;
1211    } else {
1212      // Devirtualization not enabled. Inline IsFastInvoke(), dropping the devirtualization parts.
1213      if (UNLIKELY(referrer_class == nullptr) ||
1214          UNLIKELY(!referrer_class->CanAccessResolvedMethod(resolved_method->GetDeclaringClass(),
1215                                                            resolved_method, dex_cache.Get(),
1216                                                            target_method->dex_method_index)) ||
1217          *invoke_type == kSuper) {
1218        // Slow path. (Without devirtualization, all super calls go slow path as well.)
1219      } else {
1220        // Sharpening failed so generate a regular resolved method dispatch.
1221        stats_flags = kFlagMethodResolved;
1222        GetCodeAndMethodForDirectCall(invoke_type, *invoke_type, false, referrer_class, resolved_method,
1223                                      &stats_flags, target_method, direct_code, direct_method);
1224        result = true;
1225      }
1226    }
1227  }
1228  if (!result) {
1229    // Conservative defaults.
1230    *vtable_idx = -1;
1231    *direct_code = 0u;
1232    *direct_method = 0u;
1233  }
1234  if (update_stats) {
1235    ProcessedInvoke(orig_invoke_type, stats_flags);
1236  }
1237  return result;
1238}
1239
1240const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file,
1241                                                        uint32_t method_idx) const {
1242  MethodReference ref(dex_file, method_idx);
1243  return verification_results_->GetVerifiedMethod(ref);
1244}
1245
1246bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) {
1247  DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1248  bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc);
1249  if (result) {
1250    stats_->SafeCast();
1251  } else {
1252    stats_->NotASafeCast();
1253  }
1254  return result;
1255}
1256
1257void CompilerDriver::AddCodePatch(const DexFile* dex_file,
1258                                  uint16_t referrer_class_def_idx,
1259                                  uint32_t referrer_method_idx,
1260                                  InvokeType referrer_invoke_type,
1261                                  uint32_t target_method_idx,
1262                                  const DexFile* target_dex_file,
1263                                  InvokeType target_invoke_type,
1264                                  size_t literal_offset) {
1265  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1266  code_to_patch_.push_back(new CallPatchInformation(dex_file,
1267                                                    referrer_class_def_idx,
1268                                                    referrer_method_idx,
1269                                                    referrer_invoke_type,
1270                                                    target_method_idx,
1271                                                    target_dex_file,
1272                                                    target_invoke_type,
1273                                                    literal_offset));
1274}
1275void CompilerDriver::AddRelativeCodePatch(const DexFile* dex_file,
1276                                          uint16_t referrer_class_def_idx,
1277                                          uint32_t referrer_method_idx,
1278                                          InvokeType referrer_invoke_type,
1279                                          uint32_t target_method_idx,
1280                                          const DexFile* target_dex_file,
1281                                          InvokeType target_invoke_type,
1282                                          size_t literal_offset,
1283                                          int32_t pc_relative_offset) {
1284  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1285  code_to_patch_.push_back(new RelativeCallPatchInformation(dex_file,
1286                                                            referrer_class_def_idx,
1287                                                            referrer_method_idx,
1288                                                            referrer_invoke_type,
1289                                                            target_method_idx,
1290                                                            target_dex_file,
1291                                                            target_invoke_type,
1292                                                            literal_offset,
1293                                                            pc_relative_offset));
1294}
1295void CompilerDriver::AddMethodPatch(const DexFile* dex_file,
1296                                    uint16_t referrer_class_def_idx,
1297                                    uint32_t referrer_method_idx,
1298                                    InvokeType referrer_invoke_type,
1299                                    uint32_t target_method_idx,
1300                                    const DexFile* target_dex_file,
1301                                    InvokeType target_invoke_type,
1302                                    size_t literal_offset) {
1303  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1304  methods_to_patch_.push_back(new CallPatchInformation(dex_file,
1305                                                       referrer_class_def_idx,
1306                                                       referrer_method_idx,
1307                                                       referrer_invoke_type,
1308                                                       target_method_idx,
1309                                                       target_dex_file,
1310                                                       target_invoke_type,
1311                                                       literal_offset));
1312}
1313void CompilerDriver::AddClassPatch(const DexFile* dex_file,
1314                                    uint16_t referrer_class_def_idx,
1315                                    uint32_t referrer_method_idx,
1316                                    uint32_t target_type_idx,
1317                                    size_t literal_offset) {
1318  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1319  classes_to_patch_.push_back(new TypePatchInformation(dex_file,
1320                                                       referrer_class_def_idx,
1321                                                       referrer_method_idx,
1322                                                       target_type_idx,
1323                                                       literal_offset));
1324}
1325
1326class ParallelCompilationManager {
1327 public:
1328  typedef void Callback(const ParallelCompilationManager* manager, size_t index);
1329
1330  ParallelCompilationManager(ClassLinker* class_linker,
1331                             jobject class_loader,
1332                             CompilerDriver* compiler,
1333                             const DexFile* dex_file,
1334                             ThreadPool* thread_pool)
1335    : index_(0),
1336      class_linker_(class_linker),
1337      class_loader_(class_loader),
1338      compiler_(compiler),
1339      dex_file_(dex_file),
1340      thread_pool_(thread_pool) {}
1341
1342  ClassLinker* GetClassLinker() const {
1343    CHECK(class_linker_ != NULL);
1344    return class_linker_;
1345  }
1346
1347  jobject GetClassLoader() const {
1348    return class_loader_;
1349  }
1350
1351  CompilerDriver* GetCompiler() const {
1352    CHECK(compiler_ != NULL);
1353    return compiler_;
1354  }
1355
1356  const DexFile* GetDexFile() const {
1357    CHECK(dex_file_ != NULL);
1358    return dex_file_;
1359  }
1360
1361  void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) {
1362    Thread* self = Thread::Current();
1363    self->AssertNoPendingException();
1364    CHECK_GT(work_units, 0U);
1365
1366    index_.StoreRelaxed(begin);
1367    for (size_t i = 0; i < work_units; ++i) {
1368      thread_pool_->AddTask(self, new ForAllClosure(this, end, callback));
1369    }
1370    thread_pool_->StartWorkers(self);
1371
1372    // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1373    // thread destructor's called below perform join).
1374    CHECK_NE(self->GetState(), kRunnable);
1375
1376    // Wait for all the worker threads to finish.
1377    thread_pool_->Wait(self, true, false);
1378  }
1379
1380  size_t NextIndex() {
1381    return index_.FetchAndAddSequentiallyConsistent(1);
1382  }
1383
1384 private:
1385  class ForAllClosure : public Task {
1386   public:
1387    ForAllClosure(ParallelCompilationManager* manager, size_t end, Callback* callback)
1388        : manager_(manager),
1389          end_(end),
1390          callback_(callback) {}
1391
1392    virtual void Run(Thread* self) {
1393      while (true) {
1394        const size_t index = manager_->NextIndex();
1395        if (UNLIKELY(index >= end_)) {
1396          break;
1397        }
1398        callback_(manager_, index);
1399        self->AssertNoPendingException();
1400      }
1401    }
1402
1403    virtual void Finalize() {
1404      delete this;
1405    }
1406
1407   private:
1408    ParallelCompilationManager* const manager_;
1409    const size_t end_;
1410    Callback* const callback_;
1411  };
1412
1413  AtomicInteger index_;
1414  ClassLinker* const class_linker_;
1415  const jobject class_loader_;
1416  CompilerDriver* const compiler_;
1417  const DexFile* const dex_file_;
1418  ThreadPool* const thread_pool_;
1419
1420  DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager);
1421};
1422
1423// Return true if the class should be skipped during compilation.
1424//
1425// The first case where we skip is for redundant class definitions in
1426// the boot classpath. We skip all but the first definition in that case.
1427//
1428// The second case where we skip is when an app bundles classes found
1429// in the boot classpath. Since at runtime we will select the class from
1430// the boot classpath, we ignore the one from the app.
1431static bool SkipClass(ClassLinker* class_linker, jobject class_loader, const DexFile& dex_file,
1432                      const DexFile::ClassDef& class_def) {
1433  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1434  if (class_loader == NULL) {
1435    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_linker->GetBootClassPath());
1436    CHECK(pair.second != NULL);
1437    if (pair.first != &dex_file) {
1438      LOG(WARNING) << "Skipping class " << descriptor << " from " << dex_file.GetLocation()
1439                   << " previously found in " << pair.first->GetLocation();
1440      return true;
1441    }
1442    return false;
1443  }
1444  return class_linker->IsInBootClassPath(descriptor);
1445}
1446
1447// A fast version of SkipClass above if the class pointer is available
1448// that avoids the expensive FindInClassPath search.
1449static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass)
1450    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1451  DCHECK(klass != NULL);
1452  const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile();
1453  if (&dex_file != &original_dex_file) {
1454    if (class_loader == NULL) {
1455      LOG(WARNING) << "Skipping class " << PrettyDescriptor(klass) << " from "
1456                   << dex_file.GetLocation() << " previously found in "
1457                   << original_dex_file.GetLocation();
1458    }
1459    return true;
1460  }
1461  return false;
1462}
1463
1464static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager,
1465                                         size_t class_def_index)
1466    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1467  ATRACE_CALL();
1468  Thread* self = Thread::Current();
1469  jobject jclass_loader = manager->GetClassLoader();
1470  const DexFile& dex_file = *manager->GetDexFile();
1471  ClassLinker* class_linker = manager->GetClassLinker();
1472
1473  // If an instance field is final then we need to have a barrier on the return, static final
1474  // fields are assigned within the lock held for class initialization. Conservatively assume
1475  // constructor barriers are always required.
1476  bool requires_constructor_barrier = true;
1477
1478  // Method and Field are the worst. We can't resolve without either
1479  // context from the code use (to disambiguate virtual vs direct
1480  // method and instance vs static field) or from class
1481  // definitions. While the compiler will resolve what it can as it
1482  // needs it, here we try to resolve fields and methods used in class
1483  // definitions, since many of them many never be referenced by
1484  // generated code.
1485  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1486  if (!SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1487    ScopedObjectAccess soa(self);
1488    StackHandleScope<2> hs(soa.Self());
1489    Handle<mirror::ClassLoader> class_loader(
1490        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1491    Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file)));
1492    // Resolve the class.
1493    mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
1494                                                     class_loader);
1495    bool resolve_fields_and_methods;
1496    if (klass == NULL) {
1497      // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
1498      // attempt to resolve methods and fields when there is no declaring class.
1499      CHECK(soa.Self()->IsExceptionPending());
1500      soa.Self()->ClearException();
1501      resolve_fields_and_methods = false;
1502    } else {
1503      resolve_fields_and_methods = manager->GetCompiler()->IsImage();
1504    }
1505    // Note the class_data pointer advances through the headers,
1506    // static fields, instance fields, direct methods, and virtual
1507    // methods.
1508    const byte* class_data = dex_file.GetClassData(class_def);
1509    if (class_data == NULL) {
1510      // Empty class such as a marker interface.
1511      requires_constructor_barrier = false;
1512    } else {
1513      ClassDataItemIterator it(dex_file, class_data);
1514      while (it.HasNextStaticField()) {
1515        if (resolve_fields_and_methods) {
1516          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1517                                                               dex_cache, class_loader, true);
1518          if (field == NULL) {
1519            CHECK(soa.Self()->IsExceptionPending());
1520            soa.Self()->ClearException();
1521          }
1522        }
1523        it.Next();
1524      }
1525      // We require a constructor barrier if there are final instance fields.
1526      requires_constructor_barrier = false;
1527      while (it.HasNextInstanceField()) {
1528        if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
1529          requires_constructor_barrier = true;
1530        }
1531        if (resolve_fields_and_methods) {
1532          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1533                                                               dex_cache, class_loader, false);
1534          if (field == NULL) {
1535            CHECK(soa.Self()->IsExceptionPending());
1536            soa.Self()->ClearException();
1537          }
1538        }
1539        it.Next();
1540      }
1541      if (resolve_fields_and_methods) {
1542        while (it.HasNextDirectMethod()) {
1543          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1544                                                                  dex_cache, class_loader,
1545                                                                  NullHandle<mirror::ArtMethod>(),
1546                                                                  it.GetMethodInvokeType(class_def));
1547          if (method == NULL) {
1548            CHECK(soa.Self()->IsExceptionPending());
1549            soa.Self()->ClearException();
1550          }
1551          it.Next();
1552        }
1553        while (it.HasNextVirtualMethod()) {
1554          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1555                                                                  dex_cache, class_loader,
1556                                                                  NullHandle<mirror::ArtMethod>(),
1557                                                                  it.GetMethodInvokeType(class_def));
1558          if (method == NULL) {
1559            CHECK(soa.Self()->IsExceptionPending());
1560            soa.Self()->ClearException();
1561          }
1562          it.Next();
1563        }
1564        DCHECK(!it.HasNext());
1565      }
1566    }
1567  }
1568  if (requires_constructor_barrier) {
1569    manager->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index);
1570  }
1571}
1572
1573static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx)
1574    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1575  // Class derived values are more complicated, they require the linker and loader.
1576  ScopedObjectAccess soa(Thread::Current());
1577  ClassLinker* class_linker = manager->GetClassLinker();
1578  const DexFile& dex_file = *manager->GetDexFile();
1579  StackHandleScope<2> hs(soa.Self());
1580  Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file)));
1581  Handle<mirror::ClassLoader> class_loader(
1582      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader())));
1583  mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
1584
1585  if (klass == NULL) {
1586    CHECK(soa.Self()->IsExceptionPending());
1587    mirror::Throwable* exception = soa.Self()->GetException(NULL);
1588    VLOG(compiler) << "Exception during type resolution: " << exception->Dump();
1589    if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) {
1590      // There's little point continuing compilation if the heap is exhausted.
1591      LOG(FATAL) << "Out of memory during type resolution for compilation";
1592    }
1593    soa.Self()->ClearException();
1594  }
1595}
1596
1597void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
1598                                    ThreadPool* thread_pool, TimingLogger* timings) {
1599  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1600
1601  // TODO: we could resolve strings here, although the string table is largely filled with class
1602  //       and method names.
1603
1604  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1605  if (IsImage()) {
1606    // For images we resolve all types, such as array, whereas for applications just those with
1607    // classdefs are resolved by ResolveClassFieldsAndMethods.
1608    timings->NewSplit("Resolve Types");
1609    context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
1610  }
1611
1612  timings->NewSplit("Resolve MethodsAndFields");
1613  context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
1614}
1615
1616void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1617                            ThreadPool* thread_pool, TimingLogger* timings) {
1618  for (size_t i = 0; i != dex_files.size(); ++i) {
1619    const DexFile* dex_file = dex_files[i];
1620    CHECK(dex_file != NULL);
1621    VerifyDexFile(class_loader, *dex_file, thread_pool, timings);
1622  }
1623}
1624
1625static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index)
1626    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1627  ATRACE_CALL();
1628  ScopedObjectAccess soa(Thread::Current());
1629  const DexFile& dex_file = *manager->GetDexFile();
1630  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1631  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1632  ClassLinker* class_linker = manager->GetClassLinker();
1633  jobject jclass_loader = manager->GetClassLoader();
1634  StackHandleScope<3> hs(soa.Self());
1635  Handle<mirror::ClassLoader> class_loader(
1636      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1637  Handle<mirror::Class> klass(
1638      hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader)));
1639  if (klass.Get() == nullptr) {
1640    CHECK(soa.Self()->IsExceptionPending());
1641    soa.Self()->ClearException();
1642
1643    /*
1644     * At compile time, we can still structurally verify the class even if FindClass fails.
1645     * This is to ensure the class is structurally sound for compilation. An unsound class
1646     * will be rejected by the verifier and later skipped during compilation in the compiler.
1647     */
1648    Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file)));
1649    std::string error_msg;
1650    if (verifier::MethodVerifier::VerifyClass(&dex_file, dex_cache, class_loader, &class_def, true,
1651                                              &error_msg) ==
1652                                                  verifier::MethodVerifier::kHardFailure) {
1653      LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor)
1654                 << " because: " << error_msg;
1655    }
1656  } else if (!SkipClass(jclass_loader, dex_file, klass.Get())) {
1657    CHECK(klass->IsResolved()) << PrettyClass(klass.Get());
1658    class_linker->VerifyClass(klass);
1659
1660    if (klass->IsErroneous()) {
1661      // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
1662      CHECK(soa.Self()->IsExceptionPending());
1663      soa.Self()->ClearException();
1664    }
1665
1666    CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
1667        << PrettyDescriptor(klass.Get()) << ": state=" << klass->GetStatus();
1668  }
1669  soa.Self()->AssertNoPendingException();
1670}
1671
1672void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
1673                                   ThreadPool* thread_pool, TimingLogger* timings) {
1674  timings->NewSplit("Verify Dex File");
1675  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1676  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1677  context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
1678}
1679
1680static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
1681    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1682  ATRACE_CALL();
1683  jobject jclass_loader = manager->GetClassLoader();
1684  const DexFile& dex_file = *manager->GetDexFile();
1685  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1686  const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_);
1687  const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_);
1688
1689  ScopedObjectAccess soa(Thread::Current());
1690  StackHandleScope<3> hs(soa.Self());
1691  Handle<mirror::ClassLoader> class_loader(
1692      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1693  Handle<mirror::Class> klass(
1694      hs.NewHandle(manager->GetClassLinker()->FindClass(soa.Self(), descriptor, class_loader)));
1695
1696  if (klass.Get() != nullptr && !SkipClass(jclass_loader, dex_file, klass.Get())) {
1697    // Only try to initialize classes that were successfully verified.
1698    if (klass->IsVerified()) {
1699      // Attempt to initialize the class but bail if we either need to initialize the super-class
1700      // or static fields.
1701      manager->GetClassLinker()->EnsureInitialized(klass, false, false);
1702      if (!klass->IsInitialized()) {
1703        // We don't want non-trivial class initialization occurring on multiple threads due to
1704        // deadlock problems. For example, a parent class is initialized (holding its lock) that
1705        // refers to a sub-class in its static/class initializer causing it to try to acquire the
1706        // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock)
1707        // after first initializing its parents, whose locks are acquired. This leads to a
1708        // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock.
1709        // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
1710        // than use a special Object for the purpose we use the Class of java.lang.Class.
1711        Handle<mirror::Class> h_klass(hs.NewHandle(klass->GetClass()));
1712        ObjectLock<mirror::Class> lock(soa.Self(), h_klass);
1713        // Attempt to initialize allowing initialization of parent classes but still not static
1714        // fields.
1715        manager->GetClassLinker()->EnsureInitialized(klass, false, true);
1716        if (!klass->IsInitialized()) {
1717          // We need to initialize static fields, we only do this for image classes that aren't
1718          // marked with the $NoPreloadHolder (which implies this should not be initialized early).
1719          bool can_init_static_fields = manager->GetCompiler()->IsImage() &&
1720              manager->GetCompiler()->IsImageClass(descriptor) &&
1721              !StringPiece(descriptor).ends_with("$NoPreloadHolder;");
1722          if (can_init_static_fields) {
1723            VLOG(compiler) << "Initializing: " << descriptor;
1724            // TODO multithreading support. We should ensure the current compilation thread has
1725            // exclusive access to the runtime and the transaction. To achieve this, we could use
1726            // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity
1727            // checks in Thread::AssertThreadSuspensionIsAllowable.
1728            Runtime* const runtime = Runtime::Current();
1729            Transaction transaction;
1730
1731            // Run the class initializer in transaction mode.
1732            runtime->EnterTransactionMode(&transaction);
1733            const mirror::Class::Status old_status = klass->GetStatus();
1734            bool success = manager->GetClassLinker()->EnsureInitialized(klass, true, true);
1735            // TODO we detach transaction from runtime to indicate we quit the transactional
1736            // mode which prevents the GC from visiting objects modified during the transaction.
1737            // Ensure GC is not run so don't access freed objects when aborting transaction.
1738            const char* old_casue = soa.Self()->StartAssertNoThreadSuspension("Transaction end");
1739            runtime->ExitTransactionMode();
1740
1741            if (!success) {
1742              CHECK(soa.Self()->IsExceptionPending());
1743              ThrowLocation throw_location;
1744              mirror::Throwable* exception = soa.Self()->GetException(&throw_location);
1745              VLOG(compiler) << "Initialization of " << descriptor << " aborted because of "
1746                  << exception->Dump();
1747              soa.Self()->ClearException();
1748              transaction.Abort();
1749              CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored";
1750            }
1751            soa.Self()->EndAssertNoThreadSuspension(old_casue);
1752          }
1753        }
1754        soa.Self()->AssertNoPendingException();
1755      }
1756    }
1757    // Record the final class status if necessary.
1758    ClassReference ref(manager->GetDexFile(), class_def_index);
1759    manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
1760  }
1761  // Clear any class not found or verification exceptions.
1762  soa.Self()->ClearException();
1763}
1764
1765void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
1766                                       ThreadPool* thread_pool, TimingLogger* timings) {
1767  timings->NewSplit("InitializeNoClinit");
1768  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1769  ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
1770  size_t thread_count;
1771  if (IsImage()) {
1772    // TODO: remove this when transactional mode supports multithreading.
1773    thread_count = 1U;
1774  } else {
1775    thread_count = thread_count_;
1776  }
1777  context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count);
1778  if (IsImage()) {
1779    // Prune garbage objects created during aborted transactions.
1780    Runtime::Current()->GetHeap()->CollectGarbage(true);
1781  }
1782}
1783
1784void CompilerDriver::InitializeClasses(jobject class_loader,
1785                                       const std::vector<const DexFile*>& dex_files,
1786                                       ThreadPool* thread_pool, TimingLogger* timings) {
1787  for (size_t i = 0; i != dex_files.size(); ++i) {
1788    const DexFile* dex_file = dex_files[i];
1789    CHECK(dex_file != NULL);
1790    InitializeClasses(class_loader, *dex_file, thread_pool, timings);
1791  }
1792}
1793
1794void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1795                             ThreadPool* thread_pool, TimingLogger* timings) {
1796  for (size_t i = 0; i != dex_files.size(); ++i) {
1797    const DexFile* dex_file = dex_files[i];
1798    CHECK(dex_file != NULL);
1799    CompileDexFile(class_loader, *dex_file, thread_pool, timings);
1800  }
1801}
1802
1803void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) {
1804  ATRACE_CALL();
1805  jobject jclass_loader = manager->GetClassLoader();
1806  const DexFile& dex_file = *manager->GetDexFile();
1807  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1808  ClassLinker* class_linker = manager->GetClassLinker();
1809  if (SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1810    return;
1811  }
1812  ClassReference ref(&dex_file, class_def_index);
1813  // Skip compiling classes with generic verifier failures since they will still fail at runtime
1814  if (manager->GetCompiler()->verification_results_->IsClassRejected(ref)) {
1815    return;
1816  }
1817  const byte* class_data = dex_file.GetClassData(class_def);
1818  if (class_data == NULL) {
1819    // empty class, probably a marker interface
1820    return;
1821  }
1822
1823  // Can we run DEX-to-DEX compiler on this class ?
1824  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
1825  {
1826    ScopedObjectAccess soa(Thread::Current());
1827    StackHandleScope<1> hs(soa.Self());
1828    Handle<mirror::ClassLoader> class_loader(
1829        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1830    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(soa.Self(), class_loader, dex_file,
1831                                                               class_def);
1832  }
1833  ClassDataItemIterator it(dex_file, class_data);
1834  // Skip fields
1835  while (it.HasNextStaticField()) {
1836    it.Next();
1837  }
1838  while (it.HasNextInstanceField()) {
1839    it.Next();
1840  }
1841  CompilerDriver* driver = manager->GetCompiler();
1842  // Compile direct methods
1843  int64_t previous_direct_method_idx = -1;
1844  while (it.HasNextDirectMethod()) {
1845    uint32_t method_idx = it.GetMemberIndex();
1846    if (method_idx == previous_direct_method_idx) {
1847      // smali can create dex files with two encoded_methods sharing the same method_idx
1848      // http://code.google.com/p/smali/issues/detail?id=119
1849      it.Next();
1850      continue;
1851    }
1852    previous_direct_method_idx = method_idx;
1853    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1854                          it.GetMethodInvokeType(class_def), class_def_index,
1855                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1856    it.Next();
1857  }
1858  // Compile virtual methods
1859  int64_t previous_virtual_method_idx = -1;
1860  while (it.HasNextVirtualMethod()) {
1861    uint32_t method_idx = it.GetMemberIndex();
1862    if (method_idx == previous_virtual_method_idx) {
1863      // smali can create dex files with two encoded_methods sharing the same method_idx
1864      // http://code.google.com/p/smali/issues/detail?id=119
1865      it.Next();
1866      continue;
1867    }
1868    previous_virtual_method_idx = method_idx;
1869    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1870                          it.GetMethodInvokeType(class_def), class_def_index,
1871                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1872    it.Next();
1873  }
1874  DCHECK(!it.HasNext());
1875}
1876
1877void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
1878                                    ThreadPool* thread_pool, TimingLogger* timings) {
1879  timings->NewSplit("Compile Dex File");
1880  ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this,
1881                                     &dex_file, thread_pool);
1882  context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
1883}
1884
1885void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
1886                                   InvokeType invoke_type, uint16_t class_def_idx,
1887                                   uint32_t method_idx, jobject class_loader,
1888                                   const DexFile& dex_file,
1889                                   DexToDexCompilationLevel dex_to_dex_compilation_level) {
1890  CompiledMethod* compiled_method = NULL;
1891  uint64_t start_ns = NanoTime();
1892
1893  if ((access_flags & kAccNative) != 0) {
1894    // Are we interpreting only and have support for generic JNI down calls?
1895    if (!compiler_options_->IsCompilationEnabled() &&
1896        (instruction_set_ == kX86_64 || instruction_set_ == kArm64)) {
1897      // Leaving this empty will trigger the generic JNI version
1898    } else {
1899      compiled_method = compiler_->JniCompile(access_flags, method_idx, dex_file);
1900      CHECK(compiled_method != NULL);
1901    }
1902  } else if ((access_flags & kAccAbstract) != 0) {
1903  } else {
1904    MethodReference method_ref(&dex_file, method_idx);
1905    bool compile = verification_results_->IsCandidateForCompilation(method_ref, access_flags);
1906    if (compile) {
1907      // NOTE: if compiler declines to compile this method, it will return NULL.
1908      compiled_method = compiler_->Compile(code_item, access_flags, invoke_type, class_def_idx,
1909                                           method_idx, class_loader, dex_file);
1910    }
1911    if (compiled_method == nullptr && dex_to_dex_compilation_level != kDontDexToDexCompile) {
1912      // TODO: add a command-line option to disable DEX-to-DEX compilation ?
1913      (*dex_to_dex_compiler_)(*this, code_item, access_flags,
1914                              invoke_type, class_def_idx,
1915                              method_idx, class_loader, dex_file,
1916                              dex_to_dex_compilation_level);
1917    }
1918  }
1919  uint64_t duration_ns = NanoTime() - start_ns;
1920  if (duration_ns > MsToNs(compiler_->GetMaximumCompilationTimeBeforeWarning())) {
1921    LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
1922                 << " took " << PrettyDuration(duration_ns);
1923  }
1924
1925  Thread* self = Thread::Current();
1926  if (compiled_method != NULL) {
1927    MethodReference ref(&dex_file, method_idx);
1928    DCHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
1929    {
1930      MutexLock mu(self, compiled_methods_lock_);
1931      compiled_methods_.Put(ref, compiled_method);
1932    }
1933    DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
1934  }
1935
1936  if (self->IsExceptionPending()) {
1937    ScopedObjectAccess soa(self);
1938    LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
1939        << self->GetException(NULL)->Dump();
1940  }
1941}
1942
1943CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
1944  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1945  ClassTable::const_iterator it = compiled_classes_.find(ref);
1946  if (it == compiled_classes_.end()) {
1947    return NULL;
1948  }
1949  CHECK(it->second != NULL);
1950  return it->second;
1951}
1952
1953void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) {
1954  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1955  auto it = compiled_classes_.find(ref);
1956  if (it == compiled_classes_.end() || it->second->GetStatus() != status) {
1957    // An entry doesn't exist or the status is lower than the new status.
1958    if (it != compiled_classes_.end()) {
1959      CHECK_GT(status, it->second->GetStatus());
1960      delete it->second;
1961    }
1962    switch (status) {
1963      case mirror::Class::kStatusNotReady:
1964      case mirror::Class::kStatusError:
1965      case mirror::Class::kStatusRetryVerificationAtRuntime:
1966      case mirror::Class::kStatusVerified:
1967      case mirror::Class::kStatusInitialized:
1968        break;  // Expected states.
1969      default:
1970        LOG(FATAL) << "Unexpected class status for class "
1971            << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second)))
1972            << " of " << status;
1973    }
1974    CompiledClass* compiled_class = new CompiledClass(status);
1975    compiled_classes_.Overwrite(ref, compiled_class);
1976  }
1977}
1978
1979CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
1980  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1981  MethodTable::const_iterator it = compiled_methods_.find(ref);
1982  if (it == compiled_methods_.end()) {
1983    return NULL;
1984  }
1985  CHECK(it->second != NULL);
1986  return it->second;
1987}
1988
1989void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
1990                                                   uint16_t class_def_index) {
1991  WriterMutexLock mu(self, freezing_constructor_lock_);
1992  freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
1993}
1994
1995bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
1996                                                uint16_t class_def_index) {
1997  ReaderMutexLock mu(self, freezing_constructor_lock_);
1998  return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
1999}
2000
2001bool CompilerDriver::WriteElf(const std::string& android_root,
2002                              bool is_host,
2003                              const std::vector<const art::DexFile*>& dex_files,
2004                              OatWriter* oat_writer,
2005                              art::File* file)
2006    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2007  return compiler_->WriteElf(file, oat_writer, dex_files, android_root, is_host);
2008}
2009void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
2010                                                std::string* target_triple,
2011                                                std::string* target_cpu,
2012                                                std::string* target_attr) {
2013  switch (instruction_set) {
2014    case kThumb2:
2015      *target_triple = "thumb-none-linux-gnueabi";
2016      *target_cpu = "cortex-a9";
2017      *target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
2018      break;
2019
2020    case kArm:
2021      *target_triple = "armv7-none-linux-gnueabi";
2022      // TODO: Fix for Nexus S.
2023      *target_cpu = "cortex-a9";
2024      // TODO: Fix for Xoom.
2025      *target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
2026      break;
2027
2028    case kX86:
2029      *target_triple = "i386-pc-linux-gnu";
2030      *target_attr = "";
2031      break;
2032
2033    case kX86_64:
2034      *target_triple = "x86_64-pc-linux-gnu";
2035      *target_attr = "";
2036      break;
2037
2038    case kMips:
2039      *target_triple = "mipsel-unknown-linux";
2040      *target_attr = "mips32r2";
2041      break;
2042
2043    default:
2044      LOG(FATAL) << "Unknown instruction set: " << instruction_set;
2045    }
2046  }
2047
2048bool CompilerDriver::SkipCompilation(const std::string& method_name) {
2049  if (!profile_ok_) {
2050    return false;
2051  }
2052  // Methods that comprise topKPercentThreshold % of the total samples will be compiled.
2053  double topKPercentThreshold = 90.0;
2054#ifdef HAVE_ANDROID_OS
2055  char buf[PROP_VALUE_MAX];
2056  property_get("dalvik.vm.profile.compile_thr", buf, "90.0");
2057  topKPercentThreshold = strtod(buf, nullptr);
2058#endif
2059  // Test for reasonable thresholds.
2060  if (topKPercentThreshold < 10.0 || topKPercentThreshold > 90.0) {
2061    topKPercentThreshold = 90.0;
2062  }
2063
2064  // First find the method in the profile map.
2065  ProfileMap::iterator i = profile_map_.find(method_name);
2066  if (i == profile_map_.end()) {
2067    // Not in profile, no information can be determined.
2068    VLOG(compiler) << "not compiling " << method_name << " because it's not in the profile";
2069    return true;
2070  }
2071  const ProfileData& data = i->second;
2072
2073  // Compare against the start of the topK percentage bucket just in case the threshold
2074  // falls inside a bucket.
2075  bool compile = data.GetTopKUsedPercentage() - data.GetUsedPercent() <= topKPercentThreshold;
2076  if (compile) {
2077    LOG(INFO) << "compiling method " << method_name << " because its usage is part of top "
2078        << data.GetTopKUsedPercentage() << "% with a percent of " << data.GetUsedPercent() << "%";
2079  } else {
2080    VLOG(compiler) << "not compiling method " << method_name << " because it's not part of leading "
2081        << topKPercentThreshold << "% samples)";
2082  }
2083  return !compile;
2084}
2085}  // namespace art
2086