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