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