compiler_driver.cc revision f096aad9203d7c50b2f9cbe1c1215a50c265a059 
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::ComputeSpecialAccessorInfo(uint32_t field_idx, bool is_put,
965                                                verifier::MethodVerifier* verifier,
966                                                InlineIGetIPutData* result) {
967  mirror::DexCache* dex_cache = verifier->GetDexCache();
968  uint32_t method_idx = verifier->GetMethodReference().dex_method_index;
969  mirror::ArtMethod* method = dex_cache->GetResolvedMethod(method_idx);
970  mirror::ArtField* field = dex_cache->GetResolvedField(field_idx);
971  if (method == nullptr || field == nullptr || field->IsStatic()) {
972    return false;
973  }
974  mirror::Class* method_class = method->GetDeclaringClass();
975  mirror::Class* field_class = field->GetDeclaringClass();
976  if (!method_class->CanAccessResolvedField(field_class, field, dex_cache, field_idx) ||
977      (is_put && field->IsFinal() && method_class != field_class)) {
978    return false;
979  }
980  DCHECK_GE(field->GetOffset().Int32Value(), 0);
981  result->field_idx = field_idx;
982  result->field_offset = field->GetOffset().Int32Value();
983  result->is_volatile = field->IsVolatile();
984  return true;
985}
986
987bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
988                                              bool is_put, MemberOffset* field_offset,
989                                              bool* is_volatile) {
990  ScopedObjectAccess soa(Thread::Current());
991  // Try to resolve the field and compiling method's class.
992  mirror::ArtField* resolved_field;
993  mirror::Class* referrer_class;
994  mirror::DexCache* dex_cache;
995  {
996    SirtRef<mirror::DexCache> dex_cache_sirt(soa.Self(),
997        mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()));
998    SirtRef<mirror::ClassLoader> class_loader_sirt(soa.Self(),
999        soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
1000    SirtRef<mirror::ArtField> resolved_field_sirt(soa.Self(),
1001        ResolveField(soa, dex_cache_sirt, class_loader_sirt, mUnit, field_idx, false));
1002    referrer_class = (resolved_field_sirt.get() != nullptr)
1003        ? ResolveCompilingMethodsClass(soa, dex_cache_sirt, class_loader_sirt, mUnit) : nullptr;
1004    resolved_field = resolved_field_sirt.get();
1005    dex_cache = dex_cache_sirt.get();
1006  }
1007  bool result = false;
1008  if (resolved_field != nullptr && referrer_class != nullptr) {
1009    *is_volatile = IsFieldVolatile(resolved_field);
1010    std::pair<bool, bool> fast_path = IsFastInstanceField(
1011        dex_cache, referrer_class, resolved_field, field_idx, field_offset);
1012    result = is_put ? fast_path.second : fast_path.first;
1013  }
1014  if (!result) {
1015    // Conservative defaults.
1016    *is_volatile = true;
1017    *field_offset = MemberOffset(static_cast<size_t>(-1));
1018  }
1019  ProcessedInstanceField(result);
1020  return result;
1021}
1022
1023bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
1024                                            bool is_put, MemberOffset* field_offset,
1025                                            uint32_t* storage_index, bool* is_referrers_class,
1026                                            bool* is_volatile, bool* is_initialized) {
1027  ScopedObjectAccess soa(Thread::Current());
1028  // Try to resolve the field and compiling method's class.
1029  mirror::ArtField* resolved_field;
1030  mirror::Class* referrer_class;
1031  mirror::DexCache* dex_cache;
1032  {
1033    SirtRef<mirror::DexCache> dex_cache_sirt(soa.Self(),
1034        mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()));
1035    SirtRef<mirror::ClassLoader> class_loader_sirt(soa.Self(),
1036        soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
1037    SirtRef<mirror::ArtField> resolved_field_sirt(soa.Self(),
1038        ResolveField(soa, dex_cache_sirt, class_loader_sirt, mUnit, field_idx, true));
1039    referrer_class = (resolved_field_sirt.get() != nullptr)
1040        ? ResolveCompilingMethodsClass(soa, dex_cache_sirt, class_loader_sirt, mUnit) : nullptr;
1041    resolved_field = resolved_field_sirt.get();
1042    dex_cache = dex_cache_sirt.get();
1043  }
1044  bool result = false;
1045  if (resolved_field != nullptr && referrer_class != nullptr) {
1046    *is_volatile = IsFieldVolatile(resolved_field);
1047    std::pair<bool, bool> fast_path = IsFastStaticField(
1048        dex_cache, referrer_class, resolved_field, field_idx, field_offset,
1049        storage_index, is_referrers_class, is_initialized);
1050    result = is_put ? fast_path.second : fast_path.first;
1051  }
1052  if (!result) {
1053    // Conservative defaults.
1054    *is_volatile = true;
1055    *field_offset = MemberOffset(static_cast<size_t>(-1));
1056    *storage_index = -1;
1057    *is_referrers_class = false;
1058    *is_initialized = false;
1059  }
1060  ProcessedStaticField(result, *is_referrers_class);
1061  return result;
1062}
1063
1064void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type,
1065                                                   bool no_guarantee_of_dex_cache_entry,
1066                                                   mirror::Class* referrer_class,
1067                                                   mirror::ArtMethod* method,
1068                                                   int* stats_flags,
1069                                                   MethodReference* target_method,
1070                                                   uintptr_t* direct_code,
1071                                                   uintptr_t* direct_method) {
1072  // For direct and static methods compute possible direct_code and direct_method values, ie
1073  // an address for the Method* being invoked and an address of the code for that Method*.
1074  // For interface calls compute a value for direct_method that is the interface method being
1075  // invoked, so this can be passed to the out-of-line runtime support code.
1076  *direct_code = 0;
1077  *direct_method = 0;
1078  bool use_dex_cache = false;
1079  const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot();
1080  if (compiler_backend_->IsPortable()) {
1081    if (sharp_type != kStatic && sharp_type != kDirect) {
1082      return;
1083    }
1084    use_dex_cache = true;
1085  } else {
1086    if (sharp_type != kStatic && sharp_type != kDirect) {
1087      return;
1088    }
1089    // TODO: support patching on all architectures.
1090    use_dex_cache = compiling_boot && !support_boot_image_fixup_;
1091  }
1092  bool method_code_in_boot = (method->GetDeclaringClass()->GetClassLoader() == nullptr);
1093  if (!use_dex_cache) {
1094    if (!method_code_in_boot) {
1095      use_dex_cache = true;
1096    } else {
1097      bool has_clinit_trampoline =
1098          method->IsStatic() && !method->GetDeclaringClass()->IsInitialized();
1099      if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) {
1100        // Ensure we run the clinit trampoline unless we are invoking a static method in the same
1101        // class.
1102        use_dex_cache = true;
1103      }
1104    }
1105  }
1106  if (method_code_in_boot) {
1107    *stats_flags |= kFlagDirectCallToBoot | kFlagDirectMethodToBoot;
1108  }
1109  if (!use_dex_cache && compiling_boot) {
1110    MethodHelper mh(method);
1111    if (!IsImageClass(mh.GetDeclaringClassDescriptor())) {
1112      // We can only branch directly to Methods that are resolved in the DexCache.
1113      // Otherwise we won't invoke the resolution trampoline.
1114      use_dex_cache = true;
1115    }
1116  }
1117  // The method is defined not within this dex file. We need a dex cache slot within the current
1118  // dex file or direct pointers.
1119  bool must_use_direct_pointers = false;
1120  if (target_method->dex_file == method->GetDeclaringClass()->GetDexCache()->GetDexFile()) {
1121    target_method->dex_method_index = method->GetDexMethodIndex();
1122  } else {
1123    // TODO: support patching from one dex file to another in the boot image.
1124    use_dex_cache = use_dex_cache || compiling_boot;
1125    if (no_guarantee_of_dex_cache_entry) {
1126      // See if the method is also declared in this dex cache.
1127      uint32_t dex_method_idx = MethodHelper(method).FindDexMethodIndexInOtherDexFile(
1128          *target_method->dex_file, target_method->dex_method_index);
1129      if (dex_method_idx != DexFile::kDexNoIndex) {
1130        target_method->dex_method_index = dex_method_idx;
1131      } else {
1132        must_use_direct_pointers = true;
1133      }
1134    }
1135  }
1136  if (use_dex_cache) {
1137    if (must_use_direct_pointers) {
1138      // Fail. Test above showed the only safe dispatch was via the dex cache, however, the direct
1139      // pointers are required as the dex cache lacks an appropriate entry.
1140      VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method);
1141    } else {
1142      *type = sharp_type;
1143    }
1144  } else {
1145    if (compiling_boot) {
1146      *type = sharp_type;
1147      *direct_method = -1;
1148      *direct_code = -1;
1149    } else {
1150      bool method_in_image =
1151          Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace();
1152      if (method_in_image) {
1153        CHECK(!method->IsAbstract());
1154        *type = sharp_type;
1155        *direct_method = reinterpret_cast<uintptr_t>(method);
1156        *direct_code = compiler_backend_->GetEntryPointOf(method);
1157        target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1158        target_method->dex_method_index = method->GetDexMethodIndex();
1159      } else if (!must_use_direct_pointers) {
1160        // Set the code and rely on the dex cache for the method.
1161        *type = sharp_type;
1162        *direct_code = compiler_backend_->GetEntryPointOf(method);
1163      } else {
1164        // Direct pointers were required but none were available.
1165        VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method);
1166      }
1167    }
1168  }
1169}
1170
1171bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
1172                                       bool update_stats, bool enable_devirtualization,
1173                                       InvokeType* invoke_type, MethodReference* target_method,
1174                                       int* vtable_idx, uintptr_t* direct_code,
1175                                       uintptr_t* direct_method) {
1176  InvokeType orig_invoke_type = *invoke_type;
1177  int stats_flags = 0;
1178  ScopedObjectAccess soa(Thread::Current());
1179  // Try to resolve the method and compiling method's class.
1180  mirror::ArtMethod* resolved_method;
1181  mirror::Class* referrer_class;
1182  SirtRef<mirror::DexCache> dex_cache(soa.Self(),
1183      mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()));
1184  SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
1185      soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
1186  {
1187    uint32_t method_idx = target_method->dex_method_index;
1188    SirtRef<mirror::ArtMethod> resolved_method_sirt(soa.Self(),
1189        ResolveMethod(soa, dex_cache, class_loader, mUnit, method_idx, orig_invoke_type));
1190    referrer_class = (resolved_method_sirt.get() != nullptr)
1191        ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader, mUnit) : nullptr;
1192    resolved_method = resolved_method_sirt.get();
1193  }
1194  bool result = false;
1195  if (resolved_method != nullptr) {
1196    *vtable_idx = GetResolvedMethodVTableIndex(resolved_method, orig_invoke_type);
1197
1198    if (enable_devirtualization) {
1199      DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1200      const MethodReference* devirt_target = mUnit->GetVerifiedMethod()->GetDevirtTarget(dex_pc);
1201
1202      stats_flags = IsFastInvoke(
1203          soa, dex_cache, class_loader, mUnit, referrer_class, resolved_method,
1204          invoke_type, target_method, devirt_target, direct_code, direct_method);
1205      result = stats_flags != 0;
1206    } else {
1207      // Devirtualization not enabled. Inline IsFastInvoke(), dropping the devirtualization parts.
1208      if (UNLIKELY(referrer_class == nullptr) ||
1209          UNLIKELY(!referrer_class->CanAccessResolvedMethod(resolved_method->GetDeclaringClass(),
1210                                                            resolved_method, dex_cache.get(),
1211                                                            target_method->dex_method_index)) ||
1212          *invoke_type == kSuper) {
1213        // Slow path. (Without devirtualization, all super calls go slow path as well.)
1214      } else {
1215        // Sharpening failed so generate a regular resolved method dispatch.
1216        stats_flags = kFlagMethodResolved;
1217        GetCodeAndMethodForDirectCall(invoke_type, *invoke_type, false, referrer_class, resolved_method,
1218                                      &stats_flags, target_method, direct_code, direct_method);
1219        result = true;
1220      }
1221    }
1222  }
1223  if (!result) {
1224    // Conservative defaults.
1225    *vtable_idx = -1;
1226    *direct_code = 0u;
1227    *direct_method = 0u;
1228  }
1229  if (update_stats) {
1230    ProcessedInvoke(orig_invoke_type, stats_flags);
1231  }
1232  return result;
1233}
1234
1235const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file,
1236                                                        uint32_t method_idx) const {
1237  MethodReference ref(dex_file, method_idx);
1238  return verification_results_->GetVerifiedMethod(ref);
1239}
1240
1241bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) {
1242  DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1243  bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc);
1244  if (result) {
1245    stats_->SafeCast();
1246  } else {
1247    stats_->NotASafeCast();
1248  }
1249  return result;
1250}
1251
1252void CompilerDriver::AddCodePatch(const DexFile* dex_file,
1253                                  uint16_t referrer_class_def_idx,
1254                                  uint32_t referrer_method_idx,
1255                                  InvokeType referrer_invoke_type,
1256                                  uint32_t target_method_idx,
1257                                  InvokeType target_invoke_type,
1258                                  size_t literal_offset) {
1259  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1260  code_to_patch_.push_back(new CallPatchInformation(dex_file,
1261                                                    referrer_class_def_idx,
1262                                                    referrer_method_idx,
1263                                                    referrer_invoke_type,
1264                                                    target_method_idx,
1265                                                    target_invoke_type,
1266                                                    literal_offset));
1267}
1268void CompilerDriver::AddRelativeCodePatch(const DexFile* dex_file,
1269                                          uint16_t referrer_class_def_idx,
1270                                          uint32_t referrer_method_idx,
1271                                          InvokeType referrer_invoke_type,
1272                                          uint32_t target_method_idx,
1273                                          InvokeType target_invoke_type,
1274                                          size_t literal_offset,
1275                                          int32_t pc_relative_offset) {
1276  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1277  code_to_patch_.push_back(new RelativeCallPatchInformation(dex_file,
1278                                                            referrer_class_def_idx,
1279                                                            referrer_method_idx,
1280                                                            referrer_invoke_type,
1281                                                            target_method_idx,
1282                                                            target_invoke_type,
1283                                                            literal_offset,
1284                                                            pc_relative_offset));
1285}
1286void CompilerDriver::AddMethodPatch(const DexFile* dex_file,
1287                                    uint16_t referrer_class_def_idx,
1288                                    uint32_t referrer_method_idx,
1289                                    InvokeType referrer_invoke_type,
1290                                    uint32_t target_method_idx,
1291                                    InvokeType target_invoke_type,
1292                                    size_t literal_offset) {
1293  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1294  methods_to_patch_.push_back(new CallPatchInformation(dex_file,
1295                                                       referrer_class_def_idx,
1296                                                       referrer_method_idx,
1297                                                       referrer_invoke_type,
1298                                                       target_method_idx,
1299                                                       target_invoke_type,
1300                                                       literal_offset));
1301}
1302void CompilerDriver::AddClassPatch(const DexFile* dex_file,
1303                                    uint16_t referrer_class_def_idx,
1304                                    uint32_t referrer_method_idx,
1305                                    uint32_t target_type_idx,
1306                                    size_t literal_offset) {
1307  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1308  classes_to_patch_.push_back(new TypePatchInformation(dex_file,
1309                                                       referrer_class_def_idx,
1310                                                       referrer_method_idx,
1311                                                       target_type_idx,
1312                                                       literal_offset));
1313}
1314
1315class ParallelCompilationManager {
1316 public:
1317  typedef void Callback(const ParallelCompilationManager* manager, size_t index);
1318
1319  ParallelCompilationManager(ClassLinker* class_linker,
1320                             jobject class_loader,
1321                             CompilerDriver* compiler,
1322                             const DexFile* dex_file,
1323                             ThreadPool* thread_pool)
1324    : index_(0),
1325      class_linker_(class_linker),
1326      class_loader_(class_loader),
1327      compiler_(compiler),
1328      dex_file_(dex_file),
1329      thread_pool_(thread_pool) {}
1330
1331  ClassLinker* GetClassLinker() const {
1332    CHECK(class_linker_ != NULL);
1333    return class_linker_;
1334  }
1335
1336  jobject GetClassLoader() const {
1337    return class_loader_;
1338  }
1339
1340  CompilerDriver* GetCompiler() const {
1341    CHECK(compiler_ != NULL);
1342    return compiler_;
1343  }
1344
1345  const DexFile* GetDexFile() const {
1346    CHECK(dex_file_ != NULL);
1347    return dex_file_;
1348  }
1349
1350  void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) {
1351    Thread* self = Thread::Current();
1352    self->AssertNoPendingException();
1353    CHECK_GT(work_units, 0U);
1354
1355    index_ = begin;
1356    for (size_t i = 0; i < work_units; ++i) {
1357      thread_pool_->AddTask(self, new ForAllClosure(this, end, callback));
1358    }
1359    thread_pool_->StartWorkers(self);
1360
1361    // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1362    // thread destructor's called below perform join).
1363    CHECK_NE(self->GetState(), kRunnable);
1364
1365    // Wait for all the worker threads to finish.
1366    thread_pool_->Wait(self, true, false);
1367  }
1368
1369  size_t NextIndex() {
1370    return index_.FetchAndAdd(1);
1371  }
1372
1373 private:
1374  class ForAllClosure : public Task {
1375   public:
1376    ForAllClosure(ParallelCompilationManager* manager, size_t end, Callback* callback)
1377        : manager_(manager),
1378          end_(end),
1379          callback_(callback) {}
1380
1381    virtual void Run(Thread* self) {
1382      while (true) {
1383        const size_t index = manager_->NextIndex();
1384        if (UNLIKELY(index >= end_)) {
1385          break;
1386        }
1387        callback_(manager_, index);
1388        self->AssertNoPendingException();
1389      }
1390    }
1391
1392    virtual void Finalize() {
1393      delete this;
1394    }
1395
1396   private:
1397    ParallelCompilationManager* const manager_;
1398    const size_t end_;
1399    Callback* const callback_;
1400  };
1401
1402  AtomicInteger index_;
1403  ClassLinker* const class_linker_;
1404  const jobject class_loader_;
1405  CompilerDriver* const compiler_;
1406  const DexFile* const dex_file_;
1407  ThreadPool* const thread_pool_;
1408
1409  DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager);
1410};
1411
1412// Return true if the class should be skipped during compilation.
1413//
1414// The first case where we skip is for redundant class definitions in
1415// the boot classpath. We skip all but the first definition in that case.
1416//
1417// The second case where we skip is when an app bundles classes found
1418// in the boot classpath. Since at runtime we will select the class from
1419// the boot classpath, we ignore the one from the app.
1420static bool SkipClass(ClassLinker* class_linker, jobject class_loader, const DexFile& dex_file,
1421                      const DexFile::ClassDef& class_def) {
1422  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1423  if (class_loader == NULL) {
1424    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_linker->GetBootClassPath());
1425    CHECK(pair.second != NULL);
1426    if (pair.first != &dex_file) {
1427      LOG(WARNING) << "Skipping class " << descriptor << " from " << dex_file.GetLocation()
1428                   << " previously found in " << pair.first->GetLocation();
1429      return true;
1430    }
1431    return false;
1432  }
1433  return class_linker->IsInBootClassPath(descriptor);
1434}
1435
1436// A fast version of SkipClass above if the class pointer is available
1437// that avoids the expensive FindInClassPath search.
1438static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass)
1439    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1440  DCHECK(klass != NULL);
1441  const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile();
1442  if (&dex_file != &original_dex_file) {
1443    if (class_loader == NULL) {
1444      LOG(WARNING) << "Skipping class " << PrettyDescriptor(klass) << " from "
1445                   << dex_file.GetLocation() << " previously found in "
1446                   << original_dex_file.GetLocation();
1447    }
1448    return true;
1449  }
1450  return false;
1451}
1452
1453static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager,
1454                                         size_t class_def_index)
1455    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1456  ATRACE_CALL();
1457  Thread* self = Thread::Current();
1458  jobject jclass_loader = manager->GetClassLoader();
1459  const DexFile& dex_file = *manager->GetDexFile();
1460  ClassLinker* class_linker = manager->GetClassLinker();
1461
1462  // If an instance field is final then we need to have a barrier on the return, static final
1463  // fields are assigned within the lock held for class initialization. Conservatively assume
1464  // constructor barriers are always required.
1465  bool requires_constructor_barrier = true;
1466
1467  // Method and Field are the worst. We can't resolve without either
1468  // context from the code use (to disambiguate virtual vs direct
1469  // method and instance vs static field) or from class
1470  // definitions. While the compiler will resolve what it can as it
1471  // needs it, here we try to resolve fields and methods used in class
1472  // definitions, since many of them many never be referenced by
1473  // generated code.
1474  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1475  if (!SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1476    ScopedObjectAccess soa(self);
1477    SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader));
1478    SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file));
1479    // Resolve the class.
1480    mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
1481                                                     class_loader);
1482    bool resolve_fields_and_methods;
1483    if (klass == NULL) {
1484      // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
1485      // attempt to resolve methods and fields when there is no declaring class.
1486      CHECK(soa.Self()->IsExceptionPending());
1487      soa.Self()->ClearException();
1488      resolve_fields_and_methods = false;
1489    } else {
1490      resolve_fields_and_methods = manager->GetCompiler()->IsImage();
1491    }
1492    // Note the class_data pointer advances through the headers,
1493    // static fields, instance fields, direct methods, and virtual
1494    // methods.
1495    const byte* class_data = dex_file.GetClassData(class_def);
1496    if (class_data == NULL) {
1497      // Empty class such as a marker interface.
1498      requires_constructor_barrier = false;
1499    } else {
1500      ClassDataItemIterator it(dex_file, class_data);
1501      while (it.HasNextStaticField()) {
1502        if (resolve_fields_and_methods) {
1503          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1504                                                               dex_cache, class_loader, true);
1505          if (field == NULL) {
1506            CHECK(soa.Self()->IsExceptionPending());
1507            soa.Self()->ClearException();
1508          }
1509        }
1510        it.Next();
1511      }
1512      // We require a constructor barrier if there are final instance fields.
1513      requires_constructor_barrier = false;
1514      while (it.HasNextInstanceField()) {
1515        if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
1516          requires_constructor_barrier = true;
1517        }
1518        if (resolve_fields_and_methods) {
1519          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1520                                                               dex_cache, class_loader, false);
1521          if (field == NULL) {
1522            CHECK(soa.Self()->IsExceptionPending());
1523            soa.Self()->ClearException();
1524          }
1525        }
1526        it.Next();
1527      }
1528      if (resolve_fields_and_methods) {
1529        while (it.HasNextDirectMethod()) {
1530          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1531                                                                  dex_cache, class_loader, NULL,
1532                                                                  it.GetMethodInvokeType(class_def));
1533          if (method == NULL) {
1534            CHECK(soa.Self()->IsExceptionPending());
1535            soa.Self()->ClearException();
1536          }
1537          it.Next();
1538        }
1539        while (it.HasNextVirtualMethod()) {
1540          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1541                                                                  dex_cache, class_loader, NULL,
1542                                                                  it.GetMethodInvokeType(class_def));
1543          if (method == NULL) {
1544            CHECK(soa.Self()->IsExceptionPending());
1545            soa.Self()->ClearException();
1546          }
1547          it.Next();
1548        }
1549        DCHECK(!it.HasNext());
1550      }
1551    }
1552  }
1553  if (requires_constructor_barrier) {
1554    manager->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index);
1555  }
1556}
1557
1558static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx)
1559    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1560  // Class derived values are more complicated, they require the linker and loader.
1561  ScopedObjectAccess soa(Thread::Current());
1562  ClassLinker* class_linker = manager->GetClassLinker();
1563  const DexFile& dex_file = *manager->GetDexFile();
1564  SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file));
1565  SirtRef<mirror::ClassLoader> class_loader(
1566      soa.Self(), soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()));
1567  mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
1568
1569  if (klass == NULL) {
1570    CHECK(soa.Self()->IsExceptionPending());
1571    mirror::Throwable* exception = soa.Self()->GetException(NULL);
1572    VLOG(compiler) << "Exception during type resolution: " << exception->Dump();
1573    if (strcmp("Ljava/lang/OutOfMemoryError;",
1574               ClassHelper(exception->GetClass()).GetDescriptor()) == 0) {
1575      // There's little point continuing compilation if the heap is exhausted.
1576      LOG(FATAL) << "Out of memory during type resolution for compilation";
1577    }
1578    soa.Self()->ClearException();
1579  }
1580}
1581
1582void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
1583                                    ThreadPool* thread_pool, TimingLogger* timings) {
1584  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1585
1586  // TODO: we could resolve strings here, although the string table is largely filled with class
1587  //       and method names.
1588
1589  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1590  if (IsImage()) {
1591    // For images we resolve all types, such as array, whereas for applications just those with
1592    // classdefs are resolved by ResolveClassFieldsAndMethods.
1593    timings->NewSplit("Resolve Types");
1594    context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
1595  }
1596
1597  timings->NewSplit("Resolve MethodsAndFields");
1598  context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
1599}
1600
1601void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1602                            ThreadPool* thread_pool, TimingLogger* timings) {
1603  for (size_t i = 0; i != dex_files.size(); ++i) {
1604    const DexFile* dex_file = dex_files[i];
1605    CHECK(dex_file != NULL);
1606    VerifyDexFile(class_loader, *dex_file, thread_pool, timings);
1607  }
1608}
1609
1610static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index)
1611    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1612  ATRACE_CALL();
1613  ScopedObjectAccess soa(Thread::Current());
1614  const DexFile& dex_file = *manager->GetDexFile();
1615  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1616  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1617  ClassLinker* class_linker = manager->GetClassLinker();
1618  jobject jclass_loader = manager->GetClassLoader();
1619  SirtRef<mirror::ClassLoader> class_loader(
1620      soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader));
1621  SirtRef<mirror::Class> klass(soa.Self(), class_linker->FindClass(soa.Self(), descriptor,
1622                                                                   class_loader));
1623  if (klass.get() == nullptr) {
1624    CHECK(soa.Self()->IsExceptionPending());
1625    soa.Self()->ClearException();
1626
1627    /*
1628     * At compile time, we can still structurally verify the class even if FindClass fails.
1629     * This is to ensure the class is structurally sound for compilation. An unsound class
1630     * will be rejected by the verifier and later skipped during compilation in the compiler.
1631     */
1632    SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file));
1633    std::string error_msg;
1634    if (verifier::MethodVerifier::VerifyClass(&dex_file, dex_cache, class_loader, &class_def, true,
1635                                              &error_msg) ==
1636                                                  verifier::MethodVerifier::kHardFailure) {
1637      LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor)
1638                 << " because: " << error_msg;
1639    }
1640  } else if (!SkipClass(jclass_loader, dex_file, klass.get())) {
1641    CHECK(klass->IsResolved()) << PrettyClass(klass.get());
1642    class_linker->VerifyClass(klass);
1643
1644    if (klass->IsErroneous()) {
1645      // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
1646      CHECK(soa.Self()->IsExceptionPending());
1647      soa.Self()->ClearException();
1648    }
1649
1650    CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
1651        << PrettyDescriptor(klass.get()) << ": state=" << klass->GetStatus();
1652  }
1653  soa.Self()->AssertNoPendingException();
1654}
1655
1656void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
1657                                   ThreadPool* thread_pool, TimingLogger* timings) {
1658  timings->NewSplit("Verify Dex File");
1659  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1660  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1661  context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
1662}
1663
1664static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
1665    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1666  ATRACE_CALL();
1667  jobject jclass_loader = manager->GetClassLoader();
1668  const DexFile& dex_file = *manager->GetDexFile();
1669  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1670  const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_);
1671  const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_);
1672
1673  ScopedObjectAccess soa(Thread::Current());
1674  SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
1675                                            soa.Decode<mirror::ClassLoader*>(jclass_loader));
1676  SirtRef<mirror::Class> klass(soa.Self(),
1677                               manager->GetClassLinker()->FindClass(soa.Self(), descriptor,
1678                                                                    class_loader));
1679
1680  if (klass.get() != nullptr && !SkipClass(jclass_loader, dex_file, klass.get())) {
1681    // Only try to initialize classes that were successfully verified.
1682    if (klass->IsVerified()) {
1683      // Attempt to initialize the class but bail if we either need to initialize the super-class
1684      // or static fields.
1685      manager->GetClassLinker()->EnsureInitialized(klass, false, false);
1686      if (!klass->IsInitialized()) {
1687        // We don't want non-trivial class initialization occurring on multiple threads due to
1688        // deadlock problems. For example, a parent class is initialized (holding its lock) that
1689        // refers to a sub-class in its static/class initializer causing it to try to acquire the
1690        // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock)
1691        // after first initializing its parents, whose locks are acquired. This leads to a
1692        // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock.
1693        // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
1694        // than use a special Object for the purpose we use the Class of java.lang.Class.
1695        SirtRef<mirror::Class> sirt_klass(soa.Self(), klass->GetClass());
1696        ObjectLock<mirror::Class> lock(soa.Self(), &sirt_klass);
1697        // Attempt to initialize allowing initialization of parent classes but still not static
1698        // fields.
1699        manager->GetClassLinker()->EnsureInitialized(klass, false, true);
1700        if (!klass->IsInitialized()) {
1701          // We need to initialize static fields, we only do this for image classes that aren't
1702          // marked with the $NoPreloadHolder (which implies this should not be initialized early).
1703          bool can_init_static_fields = manager->GetCompiler()->IsImage() &&
1704              manager->GetCompiler()->IsImageClass(descriptor) &&
1705              !StringPiece(descriptor).ends_with("$NoPreloadHolder;");
1706          if (can_init_static_fields) {
1707            VLOG(compiler) << "Initializing: " << descriptor;
1708            if (strcmp("Ljava/lang/Void;", descriptor) == 0) {
1709              // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
1710              ObjectLock<mirror::Class> lock(soa.Self(), &klass);
1711              mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
1712              CHECK_EQ(fields->GetLength(), 1);
1713              fields->Get(0)->SetObj<false>(klass.get(),
1714                                                     manager->GetClassLinker()->FindPrimitiveClass('V'));
1715              klass->SetStatus(mirror::Class::kStatusInitialized, soa.Self());
1716            } else {
1717              // TODO multithreading support. We should ensure the current compilation thread has
1718              // exclusive access to the runtime and the transaction. To achieve this, we could use
1719              // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity
1720              // checks in Thread::AssertThreadSuspensionIsAllowable.
1721              Runtime* const runtime = Runtime::Current();
1722              Transaction transaction;
1723
1724              // Run the class initializer in transaction mode.
1725              runtime->EnterTransactionMode(&transaction);
1726              const mirror::Class::Status old_status = klass->GetStatus();
1727              bool success = manager->GetClassLinker()->EnsureInitialized(klass, true, true);
1728              // TODO we detach transaction from runtime to indicate we quit the transactional
1729              // mode which prevents the GC from visiting objects modified during the transaction.
1730              // Ensure GC is not run so don't access freed objects when aborting transaction.
1731              const char* old_casue = soa.Self()->StartAssertNoThreadSuspension("Transaction end");
1732              runtime->ExitTransactionMode();
1733
1734              if (!success) {
1735                CHECK(soa.Self()->IsExceptionPending());
1736                ThrowLocation throw_location;
1737                mirror::Throwable* exception = soa.Self()->GetException(&throw_location);
1738                VLOG(compiler) << "Initialization of " << descriptor << " aborted because of "
1739                               << exception->Dump();
1740                soa.Self()->ClearException();
1741                transaction.Abort();
1742                CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored";
1743              }
1744              soa.Self()->EndAssertNoThreadSuspension(old_casue);
1745            }
1746          }
1747        }
1748        soa.Self()->AssertNoPendingException();
1749      }
1750    }
1751    // Record the final class status if necessary.
1752    ClassReference ref(manager->GetDexFile(), class_def_index);
1753    manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
1754  }
1755  // Clear any class not found or verification exceptions.
1756  soa.Self()->ClearException();
1757}
1758
1759void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
1760                                       ThreadPool* thread_pool, TimingLogger* timings) {
1761  timings->NewSplit("InitializeNoClinit");
1762  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1763  ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
1764  size_t thread_count;
1765  if (IsImage()) {
1766    // TODO: remove this when transactional mode supports multithreading.
1767    thread_count = 1U;
1768  } else {
1769    thread_count = thread_count_;
1770  }
1771  context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count);
1772  if (IsImage()) {
1773    // Prune garbage objects created during aborted transactions.
1774    Runtime::Current()->GetHeap()->CollectGarbage(true);
1775  }
1776}
1777
1778void CompilerDriver::InitializeClasses(jobject class_loader,
1779                                       const std::vector<const DexFile*>& dex_files,
1780                                       ThreadPool* thread_pool, TimingLogger* timings) {
1781  for (size_t i = 0; i != dex_files.size(); ++i) {
1782    const DexFile* dex_file = dex_files[i];
1783    CHECK(dex_file != NULL);
1784    InitializeClasses(class_loader, *dex_file, thread_pool, timings);
1785  }
1786}
1787
1788void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1789                             ThreadPool* thread_pool, TimingLogger* timings) {
1790  for (size_t i = 0; i != dex_files.size(); ++i) {
1791    const DexFile* dex_file = dex_files[i];
1792    CHECK(dex_file != NULL);
1793    CompileDexFile(class_loader, *dex_file, thread_pool, timings);
1794  }
1795}
1796
1797void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) {
1798  ATRACE_CALL();
1799  jobject jclass_loader = manager->GetClassLoader();
1800  const DexFile& dex_file = *manager->GetDexFile();
1801  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1802  ClassLinker* class_linker = manager->GetClassLinker();
1803  if (SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
1804    return;
1805  }
1806  ClassReference ref(&dex_file, class_def_index);
1807  // Skip compiling classes with generic verifier failures since they will still fail at runtime
1808  if (manager->GetCompiler()->verification_results_->IsClassRejected(ref)) {
1809    return;
1810  }
1811  const byte* class_data = dex_file.GetClassData(class_def);
1812  if (class_data == NULL) {
1813    // empty class, probably a marker interface
1814    return;
1815  }
1816
1817  // Can we run DEX-to-DEX compiler on this class ?
1818  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
1819  {
1820    ScopedObjectAccess soa(Thread::Current());
1821    SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
1822                                              soa.Decode<mirror::ClassLoader*>(jclass_loader));
1823    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(soa.Self(), class_loader, dex_file,
1824                                                               class_def);
1825  }
1826  ClassDataItemIterator it(dex_file, class_data);
1827  // Skip fields
1828  while (it.HasNextStaticField()) {
1829    it.Next();
1830  }
1831  while (it.HasNextInstanceField()) {
1832    it.Next();
1833  }
1834  CompilerDriver* driver = manager->GetCompiler();
1835  // Compile direct methods
1836  int64_t previous_direct_method_idx = -1;
1837  while (it.HasNextDirectMethod()) {
1838    uint32_t method_idx = it.GetMemberIndex();
1839    if (method_idx == previous_direct_method_idx) {
1840      // smali can create dex files with two encoded_methods sharing the same method_idx
1841      // http://code.google.com/p/smali/issues/detail?id=119
1842      it.Next();
1843      continue;
1844    }
1845    previous_direct_method_idx = method_idx;
1846    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1847                          it.GetMethodInvokeType(class_def), class_def_index,
1848                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1849    it.Next();
1850  }
1851  // Compile virtual methods
1852  int64_t previous_virtual_method_idx = -1;
1853  while (it.HasNextVirtualMethod()) {
1854    uint32_t method_idx = it.GetMemberIndex();
1855    if (method_idx == previous_virtual_method_idx) {
1856      // smali can create dex files with two encoded_methods sharing the same method_idx
1857      // http://code.google.com/p/smali/issues/detail?id=119
1858      it.Next();
1859      continue;
1860    }
1861    previous_virtual_method_idx = method_idx;
1862    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
1863                          it.GetMethodInvokeType(class_def), class_def_index,
1864                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
1865    it.Next();
1866  }
1867  DCHECK(!it.HasNext());
1868}
1869
1870void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
1871                                    ThreadPool* thread_pool, TimingLogger* timings) {
1872  timings->NewSplit("Compile Dex File");
1873  ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this,
1874                                     &dex_file, thread_pool);
1875  context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
1876}
1877
1878void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
1879                                   InvokeType invoke_type, uint16_t class_def_idx,
1880                                   uint32_t method_idx, jobject class_loader,
1881                                   const DexFile& dex_file,
1882                                   DexToDexCompilationLevel dex_to_dex_compilation_level) {
1883  CompiledMethod* compiled_method = NULL;
1884  uint64_t start_ns = NanoTime();
1885
1886  if ((access_flags & kAccNative) != 0) {
1887#if defined(__x86_64__)
1888    // leaving this empty will trigger the generic JNI version
1889#else
1890    compiled_method = compiler_backend_->JniCompile(*this, access_flags, method_idx, dex_file);
1891    CHECK(compiled_method != NULL);
1892#endif
1893  } else if ((access_flags & kAccAbstract) != 0) {
1894  } else {
1895    MethodReference method_ref(&dex_file, method_idx);
1896    bool compile = verification_results_->IsCandidateForCompilation(method_ref, access_flags);
1897    if (compile) {
1898      // NOTE: if compiler declines to compile this method, it will return NULL.
1899      compiled_method = compiler_backend_->Compile(
1900          *this, code_item, access_flags, invoke_type, class_def_idx,
1901          method_idx, class_loader, dex_file);
1902    } else if (dex_to_dex_compilation_level != kDontDexToDexCompile) {
1903      // TODO: add a mode to disable DEX-to-DEX compilation ?
1904      (*dex_to_dex_compiler_)(*this, code_item, access_flags,
1905                              invoke_type, class_def_idx,
1906                              method_idx, class_loader, dex_file,
1907                              dex_to_dex_compilation_level);
1908    }
1909  }
1910  uint64_t duration_ns = NanoTime() - start_ns;
1911  if (duration_ns > MsToNs(compiler_backend_->GetMaximumCompilationTimeBeforeWarning())) {
1912    LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
1913                 << " took " << PrettyDuration(duration_ns);
1914  }
1915
1916  Thread* self = Thread::Current();
1917  if (compiled_method != NULL) {
1918    MethodReference ref(&dex_file, method_idx);
1919    DCHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
1920    {
1921      MutexLock mu(self, compiled_methods_lock_);
1922      compiled_methods_.Put(ref, compiled_method);
1923    }
1924    DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
1925  }
1926
1927  if (self->IsExceptionPending()) {
1928    ScopedObjectAccess soa(self);
1929    LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
1930        << self->GetException(NULL)->Dump();
1931  }
1932}
1933
1934CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
1935  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1936  ClassTable::const_iterator it = compiled_classes_.find(ref);
1937  if (it == compiled_classes_.end()) {
1938    return NULL;
1939  }
1940  CHECK(it->second != NULL);
1941  return it->second;
1942}
1943
1944void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) {
1945  MutexLock mu(Thread::Current(), compiled_classes_lock_);
1946  auto it = compiled_classes_.find(ref);
1947  if (it == compiled_classes_.end() || it->second->GetStatus() != status) {
1948    // An entry doesn't exist or the status is lower than the new status.
1949    if (it != compiled_classes_.end()) {
1950      CHECK_GT(status, it->second->GetStatus());
1951      delete it->second;
1952    }
1953    switch (status) {
1954      case mirror::Class::kStatusNotReady:
1955      case mirror::Class::kStatusError:
1956      case mirror::Class::kStatusRetryVerificationAtRuntime:
1957      case mirror::Class::kStatusVerified:
1958      case mirror::Class::kStatusInitialized:
1959        break;  // Expected states.
1960      default:
1961        LOG(FATAL) << "Unexpected class status for class "
1962            << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second)))
1963            << " of " << status;
1964    }
1965    CompiledClass* compiled_class = new CompiledClass(status);
1966    compiled_classes_.Overwrite(ref, compiled_class);
1967  }
1968}
1969
1970CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
1971  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1972  MethodTable::const_iterator it = compiled_methods_.find(ref);
1973  if (it == compiled_methods_.end()) {
1974    return NULL;
1975  }
1976  CHECK(it->second != NULL);
1977  return it->second;
1978}
1979
1980void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
1981                                                   uint16_t class_def_index) {
1982  WriterMutexLock mu(self, freezing_constructor_lock_);
1983  freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
1984}
1985
1986bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
1987                                                uint16_t class_def_index) {
1988  ReaderMutexLock mu(self, freezing_constructor_lock_);
1989  return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
1990}
1991
1992bool CompilerDriver::WriteElf(const std::string& android_root,
1993                              bool is_host,
1994                              const std::vector<const art::DexFile*>& dex_files,
1995                              OatWriter* oat_writer,
1996                              art::File* file)
1997    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1998  return compiler_backend_->WriteElf(file, oat_writer, dex_files, android_root, is_host, *this);
1999}
2000void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
2001                                                std::string* target_triple,
2002                                                std::string* target_cpu,
2003                                                std::string* target_attr) {
2004  switch (instruction_set) {
2005    case kThumb2:
2006      *target_triple = "thumb-none-linux-gnueabi";
2007      *target_cpu = "cortex-a9";
2008      *target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
2009      break;
2010
2011    case kArm:
2012      *target_triple = "armv7-none-linux-gnueabi";
2013      // TODO: Fix for Nexus S.
2014      *target_cpu = "cortex-a9";
2015      // TODO: Fix for Xoom.
2016      *target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
2017      break;
2018
2019    case kX86:
2020      *target_triple = "i386-pc-linux-gnu";
2021      *target_attr = "";
2022      break;
2023
2024    case kMips:
2025      *target_triple = "mipsel-unknown-linux";
2026      *target_attr = "mips32r2";
2027      break;
2028
2029    default:
2030      LOG(FATAL) << "Unknown instruction set: " << instruction_set;
2031    }
2032  }
2033
2034bool CompilerDriver::ReadProfile(const std::string& filename) {
2035  VLOG(compiler) << "reading profile file " << filename;
2036  struct stat st;
2037  int err = stat(filename.c_str(), &st);
2038  if (err == -1) {
2039    VLOG(compiler) << "not found";
2040    return false;
2041  }
2042  std::ifstream in(filename.c_str());
2043  if (!in) {
2044    VLOG(compiler) << "profile file " << filename << " exists but can't be opened";
2045    VLOG(compiler) << "file owner: " << st.st_uid << ":" << st.st_gid;
2046    VLOG(compiler) << "me: " << getuid() << ":" << getgid();
2047    VLOG(compiler) << "file permissions: " << std::oct << st.st_mode;
2048    VLOG(compiler) << "errno: " << errno;
2049    return false;
2050  }
2051  // The first line contains summary information.
2052  std::string line;
2053  std::getline(in, line);
2054  if (in.eof()) {
2055    return false;
2056  }
2057  std::vector<std::string> summary_info;
2058  Split(line, '/', summary_info);
2059  if (summary_info.size() != 3) {
2060    // Bad summary info.  It should be count/total/bootpath
2061    return false;
2062  }
2063  // This is the number of hits in all methods.
2064  uint32_t total_count = 0;
2065  for (int i = 0 ; i < 3; ++i) {
2066    total_count += atoi(summary_info[0].c_str());
2067  }
2068
2069  // Now read each line until the end of file.  Each line consists of 3 fields separated by /
2070  while (!in.eof()) {
2071    std::getline(in, line);
2072    if (in.eof()) {
2073      break;
2074    }
2075    std::vector<std::string> info;
2076    Split(line, '/', info);
2077    if (info.size() != 3) {
2078      // Malformed.
2079      break;
2080    }
2081    const std::string& methodname = info[0];
2082    uint32_t count = atoi(info[1].c_str());
2083    uint32_t size = atoi(info[2].c_str());
2084    double percent = (count * 100.0) / total_count;
2085    // Add it to the profile map
2086    profile_map_[methodname] = ProfileData(methodname, count, size, percent);
2087  }
2088  return true;
2089}
2090
2091bool CompilerDriver::SkipCompilation(const std::string& method_name) {
2092  if (!profile_ok_) {
2093    return true;
2094  }
2095  constexpr double kThresholdPercent = 2.0;      // Anything above this threshold will be compiled.
2096
2097  // First find the method in the profile map.
2098  ProfileMap::iterator i = profile_map_.find(method_name);
2099  if (i == profile_map_.end()) {
2100    // Not in profile, no information can be determined.
2101    VLOG(compiler) << "not compiling " << method_name << " because it's not in the profile";
2102    return true;
2103  }
2104  const ProfileData& data = i->second;
2105  bool compile = data.IsAbove(kThresholdPercent);
2106  if (compile) {
2107    LOG(INFO) << "compiling method " << method_name << " because its usage is " <<
2108        data.GetPercent() << "%";
2109  } else {
2110    VLOG(compiler) << "not compiling method " << method_name << " because usage is too low ("
2111        << data.GetPercent() << "%)";
2112  }
2113  return !compile;
2114}
2115}  // namespace art
2116