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