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