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 #include <unordered_set>
20 #include <vector>
21 #include <unistd.h>
22 
23 #ifndef __APPLE__
24 #include <malloc.h>  // For mallinfo
25 #endif
26 
27 #include "android-base/strings.h"
28 
29 #include "art_field-inl.h"
30 #include "art_method-inl.h"
31 #include "base/array_ref.h"
32 #include "base/bit_vector.h"
33 #include "base/enums.h"
34 #include "base/stl_util.h"
35 #include "base/systrace.h"
36 #include "base/time_utils.h"
37 #include "base/timing_logger.h"
38 #include "class_linker-inl.h"
39 #include "compiled_class.h"
40 #include "compiled_method.h"
41 #include "compiler.h"
42 #include "compiler_callbacks.h"
43 #include "compiler_driver-inl.h"
44 #include "dex_compilation_unit.h"
45 #include "dex_file-inl.h"
46 #include "dex_instruction-inl.h"
47 #include "dex/dex_to_dex_compiler.h"
48 #include "dex/verification_results.h"
49 #include "dex/verified_method.h"
50 #include "driver/compiler_options.h"
51 #include "intrinsics_enum.h"
52 #include "jni_internal.h"
53 #include "object_lock.h"
54 #include "runtime.h"
55 #include "gc/accounting/card_table-inl.h"
56 #include "gc/accounting/heap_bitmap.h"
57 #include "gc/space/image_space.h"
58 #include "gc/space/space.h"
59 #include "mirror/class_loader.h"
60 #include "mirror/class-inl.h"
61 #include "mirror/dex_cache-inl.h"
62 #include "mirror/object-inl.h"
63 #include "mirror/object-refvisitor-inl.h"
64 #include "mirror/object_array-inl.h"
65 #include "mirror/throwable.h"
66 #include "scoped_thread_state_change-inl.h"
67 #include "ScopedLocalRef.h"
68 #include "handle_scope-inl.h"
69 #include "thread.h"
70 #include "thread_list.h"
71 #include "thread_pool.h"
72 #include "trampolines/trampoline_compiler.h"
73 #include "transaction.h"
74 #include "utils/atomic_method_ref_map-inl.h"
75 #include "utils/dex_cache_arrays_layout-inl.h"
76 #include "utils/swap_space.h"
77 #include "vdex_file.h"
78 #include "verifier/method_verifier.h"
79 #include "verifier/method_verifier-inl.h"
80 #include "verifier/verifier_deps.h"
81 #include "verifier/verifier_enums.h"
82 
83 namespace art {
84 
85 static constexpr bool kTimeCompileMethod = !kIsDebugBuild;
86 
87 // Print additional info during profile guided compilation.
88 static constexpr bool kDebugProfileGuidedCompilation = false;
89 
Percentage(size_t x,size_t y)90 static double Percentage(size_t x, size_t y) {
91   return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
92 }
93 
DumpStat(size_t x,size_t y,const char * str)94 static void DumpStat(size_t x, size_t y, const char* str) {
95   if (x == 0 && y == 0) {
96     return;
97   }
98   LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
99 }
100 
101 class CompilerDriver::AOTCompilationStats {
102  public:
AOTCompilationStats()103   AOTCompilationStats()
104       : stats_lock_("AOT compilation statistics lock"),
105         resolved_types_(0), unresolved_types_(0),
106         resolved_instance_fields_(0), unresolved_instance_fields_(0),
107         resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0),
108         type_based_devirtualization_(0),
109         safe_casts_(0), not_safe_casts_(0) {
110     for (size_t i = 0; i <= kMaxInvokeType; i++) {
111       resolved_methods_[i] = 0;
112       unresolved_methods_[i] = 0;
113       virtual_made_direct_[i] = 0;
114       direct_calls_to_boot_[i] = 0;
115       direct_methods_to_boot_[i] = 0;
116     }
117   }
118 
Dump()119   void Dump() {
120     DumpStat(resolved_types_, unresolved_types_, "types resolved");
121     DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
122     DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
123              "static fields resolved");
124     DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
125              "static fields local to a class");
126     DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information");
127     // Note, the code below subtracts the stat value so that when added to the stat value we have
128     // 100% of samples. TODO: clean this up.
129     DumpStat(type_based_devirtualization_,
130              resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] +
131              resolved_methods_[kInterface] + unresolved_methods_[kInterface] -
132              type_based_devirtualization_,
133              "virtual/interface calls made direct based on type information");
134 
135     for (size_t i = 0; i <= kMaxInvokeType; i++) {
136       std::ostringstream oss;
137       oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
138       DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
139       if (virtual_made_direct_[i] > 0) {
140         std::ostringstream oss2;
141         oss2 << static_cast<InvokeType>(i) << " methods made direct";
142         DumpStat(virtual_made_direct_[i],
143                  resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
144                  oss2.str().c_str());
145       }
146       if (direct_calls_to_boot_[i] > 0) {
147         std::ostringstream oss2;
148         oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
149         DumpStat(direct_calls_to_boot_[i],
150                  resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
151                  oss2.str().c_str());
152       }
153       if (direct_methods_to_boot_[i] > 0) {
154         std::ostringstream oss2;
155         oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
156         DumpStat(direct_methods_to_boot_[i],
157                  resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
158                  oss2.str().c_str());
159       }
160     }
161   }
162 
163 // Allow lossy statistics in non-debug builds.
164 #ifndef NDEBUG
165 #define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
166 #else
167 #define STATS_LOCK()
168 #endif
169 
TypeDoesntNeedAccessCheck()170   void TypeDoesntNeedAccessCheck() REQUIRES(!stats_lock_) {
171     STATS_LOCK();
172     resolved_types_++;
173   }
174 
TypeNeedsAccessCheck()175   void TypeNeedsAccessCheck() REQUIRES(!stats_lock_) {
176     STATS_LOCK();
177     unresolved_types_++;
178   }
179 
ResolvedInstanceField()180   void ResolvedInstanceField() REQUIRES(!stats_lock_) {
181     STATS_LOCK();
182     resolved_instance_fields_++;
183   }
184 
UnresolvedInstanceField()185   void UnresolvedInstanceField() REQUIRES(!stats_lock_) {
186     STATS_LOCK();
187     unresolved_instance_fields_++;
188   }
189 
ResolvedLocalStaticField()190   void ResolvedLocalStaticField() REQUIRES(!stats_lock_) {
191     STATS_LOCK();
192     resolved_local_static_fields_++;
193   }
194 
ResolvedStaticField()195   void ResolvedStaticField() REQUIRES(!stats_lock_) {
196     STATS_LOCK();
197     resolved_static_fields_++;
198   }
199 
UnresolvedStaticField()200   void UnresolvedStaticField() REQUIRES(!stats_lock_) {
201     STATS_LOCK();
202     unresolved_static_fields_++;
203   }
204 
205   // Indicate that type information from the verifier led to devirtualization.
PreciseTypeDevirtualization()206   void PreciseTypeDevirtualization() REQUIRES(!stats_lock_) {
207     STATS_LOCK();
208     type_based_devirtualization_++;
209   }
210 
211   // A check-cast could be eliminated due to verifier type analysis.
SafeCast()212   void SafeCast() REQUIRES(!stats_lock_) {
213     STATS_LOCK();
214     safe_casts_++;
215   }
216 
217   // A check-cast couldn't be eliminated due to verifier type analysis.
NotASafeCast()218   void NotASafeCast() REQUIRES(!stats_lock_) {
219     STATS_LOCK();
220     not_safe_casts_++;
221   }
222 
223  private:
224   Mutex stats_lock_;
225 
226   size_t resolved_types_;
227   size_t unresolved_types_;
228 
229   size_t resolved_instance_fields_;
230   size_t unresolved_instance_fields_;
231 
232   size_t resolved_local_static_fields_;
233   size_t resolved_static_fields_;
234   size_t unresolved_static_fields_;
235   // Type based devirtualization for invoke interface and virtual.
236   size_t type_based_devirtualization_;
237 
238   size_t resolved_methods_[kMaxInvokeType + 1];
239   size_t unresolved_methods_[kMaxInvokeType + 1];
240   size_t virtual_made_direct_[kMaxInvokeType + 1];
241   size_t direct_calls_to_boot_[kMaxInvokeType + 1];
242   size_t direct_methods_to_boot_[kMaxInvokeType + 1];
243 
244   size_t safe_casts_;
245   size_t not_safe_casts_;
246 
247   DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
248 };
249 
250 class CompilerDriver::DexFileMethodSet {
251  public:
DexFileMethodSet(const DexFile & dex_file)252   explicit DexFileMethodSet(const DexFile& dex_file)
253     : dex_file_(dex_file),
254       method_indexes_(dex_file.NumMethodIds(), false, Allocator::GetMallocAllocator()) {
255   }
256   DexFileMethodSet(DexFileMethodSet&& other) = default;
257 
GetDexFile() const258   const DexFile& GetDexFile() const { return dex_file_; }
259 
GetMethodIndexes()260   BitVector& GetMethodIndexes() { return method_indexes_; }
GetMethodIndexes() const261   const BitVector& GetMethodIndexes() const { return method_indexes_; }
262 
263  private:
264   const DexFile& dex_file_;
265   BitVector method_indexes_;
266 };
267 
CompilerDriver(const CompilerOptions * compiler_options,VerificationResults * verification_results,Compiler::Kind compiler_kind,InstructionSet instruction_set,const InstructionSetFeatures * instruction_set_features,std::unordered_set<std::string> * image_classes,std::unordered_set<std::string> * compiled_classes,std::unordered_set<std::string> * compiled_methods,size_t thread_count,bool dump_stats,bool dump_passes,CumulativeLogger * timer,int swap_fd,const ProfileCompilationInfo * profile_compilation_info)268 CompilerDriver::CompilerDriver(
269     const CompilerOptions* compiler_options,
270     VerificationResults* verification_results,
271     Compiler::Kind compiler_kind,
272     InstructionSet instruction_set,
273     const InstructionSetFeatures* instruction_set_features,
274     std::unordered_set<std::string>* image_classes,
275     std::unordered_set<std::string>* compiled_classes,
276     std::unordered_set<std::string>* compiled_methods,
277     size_t thread_count,
278     bool dump_stats,
279     bool dump_passes,
280     CumulativeLogger* timer,
281     int swap_fd,
282     const ProfileCompilationInfo* profile_compilation_info)
283     : compiler_options_(compiler_options),
284       verification_results_(verification_results),
285       compiler_(Compiler::Create(this, compiler_kind)),
286       compiler_kind_(compiler_kind),
287       instruction_set_(instruction_set == kArm ? kThumb2 : instruction_set),
288       instruction_set_features_(instruction_set_features),
289       requires_constructor_barrier_lock_("constructor barrier lock"),
290       compiled_classes_lock_("compiled classes lock"),
291       non_relative_linker_patch_count_(0u),
292       image_classes_(image_classes),
293       classes_to_compile_(compiled_classes),
294       methods_to_compile_(compiled_methods),
295       had_hard_verifier_failure_(false),
296       parallel_thread_count_(thread_count),
297       stats_(new AOTCompilationStats),
298       dump_stats_(dump_stats),
299       dump_passes_(dump_passes),
300       timings_logger_(timer),
301       compiler_context_(nullptr),
302       support_boot_image_fixup_(true),
303       dex_files_for_oat_file_(nullptr),
304       compiled_method_storage_(swap_fd),
305       profile_compilation_info_(profile_compilation_info),
306       max_arena_alloc_(0),
307       dex_to_dex_references_lock_("dex-to-dex references lock"),
308       dex_to_dex_references_(),
309       current_dex_to_dex_methods_(nullptr) {
310   DCHECK(compiler_options_ != nullptr);
311 
312   compiler_->Init();
313 
314   if (GetCompilerOptions().IsBootImage()) {
315     CHECK(image_classes_.get() != nullptr) << "Expected image classes for boot image";
316   }
317 }
318 
~CompilerDriver()319 CompilerDriver::~CompilerDriver() {
320   Thread* self = Thread::Current();
321   {
322     MutexLock mu(self, compiled_classes_lock_);
323     STLDeleteValues(&compiled_classes_);
324   }
325   compiled_methods_.Visit([this](const MethodReference& ref ATTRIBUTE_UNUSED,
326                                  CompiledMethod* method) {
327     if (method != nullptr) {
328       CompiledMethod::ReleaseSwapAllocatedCompiledMethod(this, method);
329     }
330   });
331   compiler_->UnInit();
332 }
333 
334 
335 #define CREATE_TRAMPOLINE(type, abi, offset) \
336     if (Is64BitInstructionSet(instruction_set_)) { \
337       return CreateTrampoline64(instruction_set_, abi, \
338                                 type ## _ENTRYPOINT_OFFSET(PointerSize::k64, offset)); \
339     } else { \
340       return CreateTrampoline32(instruction_set_, abi, \
341                                 type ## _ENTRYPOINT_OFFSET(PointerSize::k32, offset)); \
342     }
343 
CreateJniDlsymLookup() const344 std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateJniDlsymLookup() const {
345   CREATE_TRAMPOLINE(JNI, kJniAbi, pDlsymLookup)
346 }
347 
CreateQuickGenericJniTrampoline() const348 std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickGenericJniTrampoline()
349     const {
350   CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickGenericJniTrampoline)
351 }
352 
CreateQuickImtConflictTrampoline() const353 std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickImtConflictTrampoline()
354     const {
355   CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickImtConflictTrampoline)
356 }
357 
CreateQuickResolutionTrampoline() const358 std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickResolutionTrampoline()
359     const {
360   CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickResolutionTrampoline)
361 }
362 
CreateQuickToInterpreterBridge() const363 std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickToInterpreterBridge()
364     const {
365   CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickToInterpreterBridge)
366 }
367 #undef CREATE_TRAMPOLINE
368 
SetupIntrinsic(Thread * self,Intrinsics intrinsic,InvokeType invoke_type,const char * class_name,const char * method_name,const char * signature)369 static void SetupIntrinsic(Thread* self,
370                            Intrinsics intrinsic,
371                            InvokeType invoke_type,
372                            const char* class_name,
373                            const char* method_name,
374                            const char* signature)
375       REQUIRES_SHARED(Locks::mutator_lock_) {
376   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
377   PointerSize image_size = class_linker->GetImagePointerSize();
378   mirror::Class* cls = class_linker->FindSystemClass(self, class_name);
379   if (cls == nullptr) {
380     LOG(FATAL) << "Could not find class of intrinsic " << class_name;
381   }
382   ArtMethod* method = (invoke_type == kStatic || invoke_type == kDirect)
383       ? cls->FindDeclaredDirectMethod(method_name, signature, image_size)
384       : cls->FindDeclaredVirtualMethod(method_name, signature, image_size);
385   if (method == nullptr) {
386     LOG(FATAL) << "Could not find method of intrinsic "
387                << class_name << " " << method_name << " " << signature;
388   }
389   DCHECK_EQ(method->GetInvokeType(), invoke_type);
390   method->SetIntrinsic(static_cast<uint32_t>(intrinsic));
391 }
392 
CompileAll(jobject class_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)393 void CompilerDriver::CompileAll(jobject class_loader,
394                                 const std::vector<const DexFile*>& dex_files,
395                                 TimingLogger* timings) {
396   DCHECK(!Runtime::Current()->IsStarted());
397 
398   InitializeThreadPools();
399 
400   VLOG(compiler) << "Before precompile " << GetMemoryUsageString(false);
401   // Precompile:
402   // 1) Load image classes
403   // 2) Resolve all classes
404   // 3) Attempt to verify all classes
405   // 4) Attempt to initialize image classes, and trivially initialized classes
406   PreCompile(class_loader, dex_files, timings);
407   if (GetCompilerOptions().IsBootImage()) {
408     // We don't need to setup the intrinsics for non boot image compilation, as
409     // those compilations will pick up a boot image that have the ArtMethod already
410     // set with the intrinsics flag.
411     ScopedObjectAccess soa(Thread::Current());
412 #define SETUP_INTRINSICS(Name, InvokeType, NeedsEnvironmentOrCache, SideEffects, Exceptions, \
413                          ClassName, MethodName, Signature) \
414   SetupIntrinsic(soa.Self(), Intrinsics::k##Name, InvokeType, ClassName, MethodName, Signature);
415 #include "intrinsics_list.h"
416 INTRINSICS_LIST(SETUP_INTRINSICS)
417 #undef INTRINSICS_LIST
418 #undef SETUP_INTRINSICS
419   }
420   // Compile:
421   // 1) Compile all classes and methods enabled for compilation. May fall back to dex-to-dex
422   //    compilation.
423   if (GetCompilerOptions().IsAnyCompilationEnabled()) {
424     Compile(class_loader, dex_files, timings);
425   }
426   if (dump_stats_) {
427     stats_->Dump();
428   }
429 
430   FreeThreadPools();
431 }
432 
CompileAll(jobject class_loader,const std::vector<const DexFile * > & dex_files,VdexFile * vdex_file,TimingLogger * timings)433 void CompilerDriver::CompileAll(jobject class_loader,
434                                 const std::vector<const DexFile*>& dex_files,
435                                 VdexFile* vdex_file,
436                                 TimingLogger* timings) {
437   if (vdex_file != nullptr) {
438     // TODO: we unquicken unconditionnally, as we don't know
439     // if the boot image has changed. How exactly we'll know is under
440     // experimentation.
441     TimingLogger::ScopedTiming t("Unquicken", timings);
442     // We do not decompile a RETURN_VOID_NO_BARRIER into a RETURN_VOID, as the quickening
443     // optimization does not depend on the boot image (the optimization relies on not
444     // having final fields in a class, which does not change for an app).
445     VdexFile::Unquicken(dex_files, vdex_file->GetQuickeningInfo());
446 
447     Runtime::Current()->GetCompilerCallbacks()->SetVerifierDeps(
448         new verifier::VerifierDeps(dex_files, vdex_file->GetVerifierDepsData()));
449   }
450   CompileAll(class_loader, dex_files, timings);
451 }
452 
GetDexToDexCompilationLevel(Thread * self,const CompilerDriver & driver,Handle<mirror::ClassLoader> class_loader,const DexFile & dex_file,const DexFile::ClassDef & class_def)453 static optimizer::DexToDexCompilationLevel GetDexToDexCompilationLevel(
454     Thread* self, const CompilerDriver& driver, Handle<mirror::ClassLoader> class_loader,
455     const DexFile& dex_file, const DexFile::ClassDef& class_def)
456     REQUIRES_SHARED(Locks::mutator_lock_) {
457   auto* const runtime = Runtime::Current();
458   DCHECK(driver.GetCompilerOptions().IsQuickeningCompilationEnabled());
459   const char* descriptor = dex_file.GetClassDescriptor(class_def);
460   ClassLinker* class_linker = runtime->GetClassLinker();
461   mirror::Class* klass = class_linker->FindClass(self, descriptor, class_loader);
462   if (klass == nullptr) {
463     CHECK(self->IsExceptionPending());
464     self->ClearException();
465     return optimizer::DexToDexCompilationLevel::kDontDexToDexCompile;
466   }
467   // DexToDex at the kOptimize level may introduce quickened opcodes, which replace symbolic
468   // references with actual offsets. We cannot re-verify such instructions.
469   //
470   // We store the verification information in the class status in the oat file, which the linker
471   // can validate (checksums) and use to skip load-time verification. It is thus safe to
472   // optimize when a class has been fully verified before.
473   optimizer::DexToDexCompilationLevel max_level = optimizer::DexToDexCompilationLevel::kOptimize;
474   if (driver.GetCompilerOptions().GetDebuggable()) {
475     // We are debuggable so definitions of classes might be changed. We don't want to do any
476     // optimizations that could break that.
477     max_level = optimizer::DexToDexCompilationLevel::kDontDexToDexCompile;
478   }
479   if (klass->IsVerified()) {
480     // Class is verified so we can enable DEX-to-DEX compilation for performance.
481     return max_level;
482   } else {
483     // Class verification has failed: do not run DEX-to-DEX optimizations.
484     return optimizer::DexToDexCompilationLevel::kDontDexToDexCompile;
485   }
486 }
487 
GetDexToDexCompilationLevel(Thread * self,const CompilerDriver & driver,jobject jclass_loader,const DexFile & dex_file,const DexFile::ClassDef & class_def)488 static optimizer::DexToDexCompilationLevel GetDexToDexCompilationLevel(
489     Thread* self,
490     const CompilerDriver& driver,
491     jobject jclass_loader,
492     const DexFile& dex_file,
493     const DexFile::ClassDef& class_def) {
494   ScopedObjectAccess soa(self);
495   StackHandleScope<1> hs(soa.Self());
496   Handle<mirror::ClassLoader> class_loader(
497       hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
498   return GetDexToDexCompilationLevel(self, driver, class_loader, dex_file, class_def);
499 }
500 
501 // Does the runtime for the InstructionSet provide an implementation returned by
502 // GetQuickGenericJniStub allowing down calls that aren't compiled using a JNI compiler?
InstructionSetHasGenericJniStub(InstructionSet isa)503 static bool InstructionSetHasGenericJniStub(InstructionSet isa) {
504   switch (isa) {
505     case kArm:
506     case kArm64:
507     case kThumb2:
508     case kMips:
509     case kMips64:
510     case kX86:
511     case kX86_64: return true;
512     default: return false;
513   }
514 }
515 
CompileMethod(Thread * self,CompilerDriver * driver,const DexFile::CodeItem * code_item,uint32_t access_flags,InvokeType invoke_type,uint16_t class_def_idx,uint32_t method_idx,Handle<mirror::ClassLoader> class_loader,const DexFile & dex_file,optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level,bool compilation_enabled,Handle<mirror::DexCache> dex_cache)516 static void CompileMethod(Thread* self,
517                           CompilerDriver* driver,
518                           const DexFile::CodeItem* code_item,
519                           uint32_t access_flags,
520                           InvokeType invoke_type,
521                           uint16_t class_def_idx,
522                           uint32_t method_idx,
523                           Handle<mirror::ClassLoader> class_loader,
524                           const DexFile& dex_file,
525                           optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level,
526                           bool compilation_enabled,
527                           Handle<mirror::DexCache> dex_cache) {
528   DCHECK(driver != nullptr);
529   CompiledMethod* compiled_method = nullptr;
530   uint64_t start_ns = kTimeCompileMethod ? NanoTime() : 0;
531   MethodReference method_ref(&dex_file, method_idx);
532 
533   if (driver->GetCurrentDexToDexMethods() != nullptr) {
534     // This is the second pass when we dex-to-dex compile previously marked methods.
535     // TODO: Refactor the compilation to avoid having to distinguish the two passes
536     // here. That should be done on a higher level. http://b/29089975
537     if (driver->GetCurrentDexToDexMethods()->IsBitSet(method_idx)) {
538       const VerifiedMethod* verified_method =
539           driver->GetVerificationResults()->GetVerifiedMethod(method_ref);
540       // Do not optimize if a VerifiedMethod is missing. SafeCast elision,
541       // for example, relies on it.
542       compiled_method = optimizer::ArtCompileDEX(
543           driver,
544           code_item,
545           access_flags,
546           invoke_type,
547           class_def_idx,
548           method_idx,
549           class_loader,
550           dex_file,
551           (verified_method != nullptr)
552               ? dex_to_dex_compilation_level
553               : optimizer::DexToDexCompilationLevel::kDontDexToDexCompile);
554     }
555   } else if ((access_flags & kAccNative) != 0) {
556     // Are we extracting only and have support for generic JNI down calls?
557     if (!driver->GetCompilerOptions().IsJniCompilationEnabled() &&
558         InstructionSetHasGenericJniStub(driver->GetInstructionSet())) {
559       // Leaving this empty will trigger the generic JNI version
560     } else {
561       // Look-up the ArtMethod associated with this code_item (if any)
562       // -- It is later used to lookup any [optimization] annotations for this method.
563       ScopedObjectAccess soa(self);
564 
565       // TODO: Lookup annotation from DexFile directly without resolving method.
566       ArtMethod* method =
567           Runtime::Current()->GetClassLinker()->ResolveMethod<ClassLinker::kNoICCECheckForCache>(
568               dex_file,
569               method_idx,
570               dex_cache,
571               class_loader,
572               /* referrer */ nullptr,
573               invoke_type);
574 
575       // Query any JNI optimization annotations such as @FastNative or @CriticalNative.
576       Compiler::JniOptimizationFlags optimization_flags = Compiler::kNone;
577       if (UNLIKELY(method == nullptr)) {
578         // Failed method resolutions happen very rarely, e.g. ancestor class cannot be resolved.
579         DCHECK(self->IsExceptionPending());
580         self->ClearException();
581       } else if (method->IsAnnotatedWithFastNative()) {
582         // TODO: Will no longer need this CHECK once we have verifier checking this.
583         CHECK(!method->IsAnnotatedWithCriticalNative());
584         optimization_flags = Compiler::kFastNative;
585       } else if (method->IsAnnotatedWithCriticalNative()) {
586         // TODO: Will no longer need this CHECK once we have verifier checking this.
587         CHECK(!method->IsAnnotatedWithFastNative());
588         optimization_flags = Compiler::kCriticalNative;
589       }
590 
591       compiled_method = driver->GetCompiler()->JniCompile(access_flags,
592                                                           method_idx,
593                                                           dex_file,
594                                                           optimization_flags);
595       CHECK(compiled_method != nullptr);
596     }
597   } else if ((access_flags & kAccAbstract) != 0) {
598     // Abstract methods don't have code.
599   } else {
600     const VerifiedMethod* verified_method =
601         driver->GetVerificationResults()->GetVerifiedMethod(method_ref);
602     bool compile = compilation_enabled &&
603         // Basic checks, e.g., not <clinit>.
604         driver->GetVerificationResults()
605             ->IsCandidateForCompilation(method_ref, access_flags) &&
606         // Did not fail to create VerifiedMethod metadata.
607         verified_method != nullptr &&
608         // Do not have failures that should punt to the interpreter.
609         !verified_method->HasRuntimeThrow() &&
610         (verified_method->GetEncounteredVerificationFailures() &
611             (verifier::VERIFY_ERROR_FORCE_INTERPRETER | verifier::VERIFY_ERROR_LOCKING)) == 0 &&
612         // Is eligable for compilation by methods-to-compile filter.
613         driver->IsMethodToCompile(method_ref) &&
614         driver->ShouldCompileBasedOnProfile(method_ref);
615 
616     if (compile) {
617       // NOTE: if compiler declines to compile this method, it will return null.
618       compiled_method = driver->GetCompiler()->Compile(code_item,
619                                                        access_flags,
620                                                        invoke_type,
621                                                        class_def_idx,
622                                                        method_idx,
623                                                        class_loader,
624                                                        dex_file,
625                                                        dex_cache);
626     }
627     if (compiled_method == nullptr &&
628         dex_to_dex_compilation_level != optimizer::DexToDexCompilationLevel::kDontDexToDexCompile) {
629       DCHECK(!Runtime::Current()->UseJitCompilation());
630       // TODO: add a command-line option to disable DEX-to-DEX compilation ?
631       driver->MarkForDexToDexCompilation(self, method_ref);
632     }
633   }
634   if (kTimeCompileMethod) {
635     uint64_t duration_ns = NanoTime() - start_ns;
636     if (duration_ns > MsToNs(driver->GetCompiler()->GetMaximumCompilationTimeBeforeWarning())) {
637       LOG(WARNING) << "Compilation of " << dex_file.PrettyMethod(method_idx)
638                    << " took " << PrettyDuration(duration_ns);
639     }
640   }
641 
642   if (compiled_method != nullptr) {
643     // Count non-relative linker patches.
644     size_t non_relative_linker_patch_count = 0u;
645     for (const LinkerPatch& patch : compiled_method->GetPatches()) {
646       if (!patch.IsPcRelative()) {
647         ++non_relative_linker_patch_count;
648       }
649     }
650     bool compile_pic = driver->GetCompilerOptions().GetCompilePic();  // Off by default
651     // When compiling with PIC, there should be zero non-relative linker patches
652     CHECK(!compile_pic || non_relative_linker_patch_count == 0u);
653 
654     driver->AddCompiledMethod(method_ref, compiled_method, non_relative_linker_patch_count);
655   }
656 
657   if (self->IsExceptionPending()) {
658     ScopedObjectAccess soa(self);
659     LOG(FATAL) << "Unexpected exception compiling: " << dex_file.PrettyMethod(method_idx) << "\n"
660         << self->GetException()->Dump();
661   }
662 }
663 
CompileOne(Thread * self,ArtMethod * method,TimingLogger * timings)664 void CompilerDriver::CompileOne(Thread* self, ArtMethod* method, TimingLogger* timings) {
665   DCHECK(!Runtime::Current()->IsStarted());
666   jobject jclass_loader;
667   const DexFile* dex_file;
668   uint16_t class_def_idx;
669   uint32_t method_idx = method->GetDexMethodIndex();
670   uint32_t access_flags = method->GetAccessFlags();
671   InvokeType invoke_type = method->GetInvokeType();
672   StackHandleScope<2> hs(self);
673   Handle<mirror::DexCache> dex_cache(hs.NewHandle(method->GetDexCache()));
674   Handle<mirror::ClassLoader> class_loader(
675       hs.NewHandle(method->GetDeclaringClass()->GetClassLoader()));
676   {
677     ScopedObjectAccessUnchecked soa(self);
678     ScopedLocalRef<jobject> local_class_loader(
679         soa.Env(), soa.AddLocalReference<jobject>(class_loader.Get()));
680     jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
681     // Find the dex_file
682     dex_file = method->GetDexFile();
683     class_def_idx = method->GetClassDefIndex();
684   }
685   const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
686 
687   // Go to native so that we don't block GC during compilation.
688   ScopedThreadSuspension sts(self, kNative);
689 
690   std::vector<const DexFile*> dex_files;
691   dex_files.push_back(dex_file);
692 
693   InitializeThreadPools();
694 
695   PreCompile(jclass_loader, dex_files, timings);
696 
697   // Can we run DEX-to-DEX compiler on this class ?
698   optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level =
699       GetDexToDexCompilationLevel(self,
700                                   *this,
701                                   jclass_loader,
702                                   *dex_file,
703                                   dex_file->GetClassDef(class_def_idx));
704 
705   DCHECK(current_dex_to_dex_methods_ == nullptr);
706   CompileMethod(self,
707                 this,
708                 code_item,
709                 access_flags,
710                 invoke_type,
711                 class_def_idx,
712                 method_idx,
713                 class_loader,
714                 *dex_file,
715                 dex_to_dex_compilation_level,
716                 true,
717                 dex_cache);
718 
719   ArrayRef<DexFileMethodSet> dex_to_dex_references;
720   {
721     // From this point on, we shall not modify dex_to_dex_references_, so
722     // just grab a reference to it that we use without holding the mutex.
723     MutexLock lock(Thread::Current(), dex_to_dex_references_lock_);
724     dex_to_dex_references = ArrayRef<DexFileMethodSet>(dex_to_dex_references_);
725   }
726   if (!dex_to_dex_references.empty()) {
727     DCHECK_EQ(dex_to_dex_references.size(), 1u);
728     DCHECK(&dex_to_dex_references[0].GetDexFile() == dex_file);
729     current_dex_to_dex_methods_ = &dex_to_dex_references.front().GetMethodIndexes();
730     DCHECK(current_dex_to_dex_methods_->IsBitSet(method_idx));
731     DCHECK_EQ(current_dex_to_dex_methods_->NumSetBits(), 1u);
732     CompileMethod(self,
733                   this,
734                   code_item,
735                   access_flags,
736                   invoke_type,
737                   class_def_idx,
738                   method_idx,
739                   class_loader,
740                   *dex_file,
741                   dex_to_dex_compilation_level,
742                   true,
743                   dex_cache);
744     current_dex_to_dex_methods_ = nullptr;
745   }
746 
747   FreeThreadPools();
748 
749   self->GetJniEnv()->DeleteGlobalRef(jclass_loader);
750 }
751 
Resolve(jobject class_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)752 void CompilerDriver::Resolve(jobject class_loader,
753                              const std::vector<const DexFile*>& dex_files,
754                              TimingLogger* timings) {
755   // Resolution allocates classes and needs to run single-threaded to be deterministic.
756   bool force_determinism = GetCompilerOptions().IsForceDeterminism();
757   ThreadPool* resolve_thread_pool = force_determinism
758                                      ? single_thread_pool_.get()
759                                      : parallel_thread_pool_.get();
760   size_t resolve_thread_count = force_determinism ? 1U : parallel_thread_count_;
761 
762   for (size_t i = 0; i != dex_files.size(); ++i) {
763     const DexFile* dex_file = dex_files[i];
764     CHECK(dex_file != nullptr);
765     ResolveDexFile(class_loader,
766                    *dex_file,
767                    dex_files,
768                    resolve_thread_pool,
769                    resolve_thread_count,
770                    timings);
771   }
772 }
773 
774 // Resolve const-strings in the code. Done to have deterministic allocation behavior. Right now
775 // this is single-threaded for simplicity.
776 // TODO: Collect the relevant string indices in parallel, then allocate them sequentially in a
777 //       stable order.
778 
ResolveConstStrings(Handle<mirror::DexCache> dex_cache,const DexFile & dex_file,const DexFile::CodeItem * code_item)779 static void ResolveConstStrings(Handle<mirror::DexCache> dex_cache,
780                                 const DexFile& dex_file,
781                                 const DexFile::CodeItem* code_item)
782       REQUIRES_SHARED(Locks::mutator_lock_) {
783   if (code_item == nullptr) {
784     // Abstract or native method.
785     return;
786   }
787 
788   const uint16_t* code_ptr = code_item->insns_;
789   const uint16_t* code_end = code_item->insns_ + code_item->insns_size_in_code_units_;
790   ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
791 
792   while (code_ptr < code_end) {
793     const Instruction* inst = Instruction::At(code_ptr);
794     switch (inst->Opcode()) {
795       case Instruction::CONST_STRING:
796       case Instruction::CONST_STRING_JUMBO: {
797         dex::StringIndex string_index((inst->Opcode() == Instruction::CONST_STRING)
798             ? inst->VRegB_21c()
799             : inst->VRegB_31c());
800         mirror::String* string = class_linker->ResolveString(dex_file, string_index, dex_cache);
801         CHECK(string != nullptr) << "Could not allocate a string when forcing determinism";
802         break;
803       }
804 
805       default:
806         break;
807     }
808 
809     code_ptr += inst->SizeInCodeUnits();
810   }
811 }
812 
ResolveConstStrings(CompilerDriver * driver,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)813 static void ResolveConstStrings(CompilerDriver* driver,
814                                 const std::vector<const DexFile*>& dex_files,
815                                 TimingLogger* timings) {
816   ScopedObjectAccess soa(Thread::Current());
817   StackHandleScope<1> hs(soa.Self());
818   ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
819   MutableHandle<mirror::DexCache> dex_cache(hs.NewHandle<mirror::DexCache>(nullptr));
820 
821   for (const DexFile* dex_file : dex_files) {
822     dex_cache.Assign(class_linker->FindDexCache(soa.Self(), *dex_file));
823     TimingLogger::ScopedTiming t("Resolve const-string Strings", timings);
824 
825     size_t class_def_count = dex_file->NumClassDefs();
826     for (size_t class_def_index = 0; class_def_index < class_def_count; ++class_def_index) {
827       const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
828 
829       const uint8_t* class_data = dex_file->GetClassData(class_def);
830       if (class_data == nullptr) {
831         // empty class, probably a marker interface
832         continue;
833       }
834 
835       ClassDataItemIterator it(*dex_file, class_data);
836       // Skip fields
837       while (it.HasNextStaticField()) {
838         it.Next();
839       }
840       while (it.HasNextInstanceField()) {
841         it.Next();
842       }
843 
844       bool compilation_enabled = driver->IsClassToCompile(
845           dex_file->StringByTypeIdx(class_def.class_idx_));
846       if (!compilation_enabled) {
847         // Compilation is skipped, do not resolve const-string in code of this class.
848         // TODO: Make sure that inlining honors this.
849         continue;
850       }
851 
852       // Direct methods.
853       int64_t previous_direct_method_idx = -1;
854       while (it.HasNextDirectMethod()) {
855         uint32_t method_idx = it.GetMemberIndex();
856         if (method_idx == previous_direct_method_idx) {
857           // smali can create dex files with two encoded_methods sharing the same method_idx
858           // http://code.google.com/p/smali/issues/detail?id=119
859           it.Next();
860           continue;
861         }
862         previous_direct_method_idx = method_idx;
863         ResolveConstStrings(dex_cache, *dex_file, it.GetMethodCodeItem());
864         it.Next();
865       }
866       // Virtual methods.
867       int64_t previous_virtual_method_idx = -1;
868       while (it.HasNextVirtualMethod()) {
869         uint32_t method_idx = it.GetMemberIndex();
870         if (method_idx == previous_virtual_method_idx) {
871           // smali can create dex files with two encoded_methods sharing the same method_idx
872           // http://code.google.com/p/smali/issues/detail?id=119
873           it.Next();
874           continue;
875         }
876         previous_virtual_method_idx = method_idx;
877         ResolveConstStrings(dex_cache, *dex_file, it.GetMethodCodeItem());
878         it.Next();
879       }
880       DCHECK(!it.HasNext());
881     }
882   }
883 }
884 
CheckThreadPools()885 inline void CompilerDriver::CheckThreadPools() {
886   DCHECK(parallel_thread_pool_ != nullptr);
887   DCHECK(single_thread_pool_ != nullptr);
888 }
889 
EnsureVerifiedOrVerifyAtRuntime(jobject jclass_loader,const std::vector<const DexFile * > & dex_files)890 static void EnsureVerifiedOrVerifyAtRuntime(jobject jclass_loader,
891                                             const std::vector<const DexFile*>& dex_files) {
892   ScopedObjectAccess soa(Thread::Current());
893   StackHandleScope<2> hs(soa.Self());
894   Handle<mirror::ClassLoader> class_loader(
895       hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
896   MutableHandle<mirror::Class> cls(hs.NewHandle<mirror::Class>(nullptr));
897   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
898 
899   for (const DexFile* dex_file : dex_files) {
900     for (uint32_t i = 0; i < dex_file->NumClassDefs(); ++i) {
901       const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
902       const char* descriptor = dex_file->GetClassDescriptor(class_def);
903       cls.Assign(class_linker->FindClass(soa.Self(), descriptor, class_loader));
904       if (cls == nullptr) {
905         soa.Self()->ClearException();
906       } else if (&cls->GetDexFile() == dex_file) {
907         DCHECK(cls->IsErroneous() || cls->IsVerified() || cls->ShouldVerifyAtRuntime())
908             << cls->PrettyClass()
909             << " " << cls->GetStatus();
910       }
911     }
912   }
913 }
914 
PreCompile(jobject class_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)915 void CompilerDriver::PreCompile(jobject class_loader,
916                                 const std::vector<const DexFile*>& dex_files,
917                                 TimingLogger* timings) {
918   CheckThreadPools();
919 
920   for (const DexFile* dex_file : dex_files) {
921     // Can be already inserted if the caller is CompileOne. This happens for gtests.
922     if (!compiled_methods_.HaveDexFile(dex_file)) {
923       compiled_methods_.AddDexFile(dex_file);
924     }
925   }
926 
927   LoadImageClasses(timings);
928   VLOG(compiler) << "LoadImageClasses: " << GetMemoryUsageString(false);
929 
930   if (compiler_options_->IsAnyCompilationEnabled()) {
931     // Resolve eagerly to prepare for compilation.
932     Resolve(class_loader, dex_files, timings);
933     VLOG(compiler) << "Resolve: " << GetMemoryUsageString(false);
934   }
935 
936   if (compiler_options_->AssumeClassesAreVerified()) {
937     VLOG(compiler) << "Verify none mode specified, skipping verification.";
938     SetVerified(class_loader, dex_files, timings);
939   }
940 
941   if (!compiler_options_->IsVerificationEnabled()) {
942     return;
943   }
944 
945   if (GetCompilerOptions().IsForceDeterminism() && GetCompilerOptions().IsBootImage()) {
946     // Resolve strings from const-string. Do this now to have a deterministic image.
947     ResolveConstStrings(this, dex_files, timings);
948     VLOG(compiler) << "Resolve const-strings: " << GetMemoryUsageString(false);
949   }
950 
951   Verify(class_loader, dex_files, timings);
952   VLOG(compiler) << "Verify: " << GetMemoryUsageString(false);
953 
954   if (had_hard_verifier_failure_ && GetCompilerOptions().AbortOnHardVerifierFailure()) {
955     LOG(FATAL) << "Had a hard failure verifying all classes, and was asked to abort in such "
956                << "situations. Please check the log.";
957   }
958 
959   if (compiler_options_->IsAnyCompilationEnabled()) {
960     if (kIsDebugBuild) {
961       EnsureVerifiedOrVerifyAtRuntime(class_loader, dex_files);
962     }
963     InitializeClasses(class_loader, dex_files, timings);
964     VLOG(compiler) << "InitializeClasses: " << GetMemoryUsageString(false);
965   }
966 
967   UpdateImageClasses(timings);
968   VLOG(compiler) << "UpdateImageClasses: " << GetMemoryUsageString(false);
969 }
970 
IsImageClass(const char * descriptor) const971 bool CompilerDriver::IsImageClass(const char* descriptor) const {
972   if (image_classes_ != nullptr) {
973     // If we have a set of image classes, use those.
974     return image_classes_->find(descriptor) != image_classes_->end();
975   }
976   // No set of image classes, assume we include all the classes.
977   // NOTE: Currently only reachable from InitImageMethodVisitor for the app image case.
978   return !GetCompilerOptions().IsBootImage();
979 }
980 
IsClassToCompile(const char * descriptor) const981 bool CompilerDriver::IsClassToCompile(const char* descriptor) const {
982   if (classes_to_compile_ == nullptr) {
983     return true;
984   }
985   return classes_to_compile_->find(descriptor) != classes_to_compile_->end();
986 }
987 
IsMethodToCompile(const MethodReference & method_ref) const988 bool CompilerDriver::IsMethodToCompile(const MethodReference& method_ref) const {
989   if (methods_to_compile_ == nullptr) {
990     return true;
991   }
992 
993   std::string tmp = method_ref.dex_file->PrettyMethod(method_ref.dex_method_index, true);
994   return methods_to_compile_->find(tmp.c_str()) != methods_to_compile_->end();
995 }
996 
ShouldCompileBasedOnProfile(const MethodReference & method_ref) const997 bool CompilerDriver::ShouldCompileBasedOnProfile(const MethodReference& method_ref) const {
998   // Profile compilation info may be null if no profile is passed.
999   if (!CompilerFilter::DependsOnProfile(compiler_options_->GetCompilerFilter())) {
1000     // Use the compiler filter instead of the presence of profile_compilation_info_ since
1001     // we may want to have full speed compilation along with profile based layout optimizations.
1002     return true;
1003   }
1004   // If we are using a profile filter but do not have a profile compilation info, compile nothing.
1005   if (profile_compilation_info_ == nullptr) {
1006     return false;
1007   }
1008   bool result = profile_compilation_info_->ContainsMethod(method_ref);
1009 
1010   if (kDebugProfileGuidedCompilation) {
1011     LOG(INFO) << "[ProfileGuidedCompilation] "
1012         << (result ? "Compiled" : "Skipped") << " method:"
1013         << method_ref.dex_file->PrettyMethod(method_ref.dex_method_index, true);
1014   }
1015   return result;
1016 }
1017 
1018 class ResolveCatchBlockExceptionsClassVisitor : public ClassVisitor {
1019  public:
ResolveCatchBlockExceptionsClassVisitor()1020   ResolveCatchBlockExceptionsClassVisitor() : classes_() {}
1021 
operator ()(ObjPtr<mirror::Class> c)1022   virtual bool operator()(ObjPtr<mirror::Class> c) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
1023     classes_.push_back(c);
1024     return true;
1025   }
1026 
FindExceptionTypesToResolve(std::set<std::pair<dex::TypeIndex,const DexFile * >> * exceptions_to_resolve)1027   void FindExceptionTypesToResolve(
1028       std::set<std::pair<dex::TypeIndex, const DexFile*>>* exceptions_to_resolve)
1029       REQUIRES_SHARED(Locks::mutator_lock_) {
1030     const auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
1031     for (ObjPtr<mirror::Class> klass : classes_) {
1032       for (ArtMethod& method : klass->GetMethods(pointer_size)) {
1033         FindExceptionTypesToResolveForMethod(&method, exceptions_to_resolve);
1034       }
1035     }
1036   }
1037 
1038  private:
FindExceptionTypesToResolveForMethod(ArtMethod * method,std::set<std::pair<dex::TypeIndex,const DexFile * >> * exceptions_to_resolve)1039   void FindExceptionTypesToResolveForMethod(
1040       ArtMethod* method,
1041       std::set<std::pair<dex::TypeIndex, const DexFile*>>* exceptions_to_resolve)
1042       REQUIRES_SHARED(Locks::mutator_lock_) {
1043     const DexFile::CodeItem* code_item = method->GetCodeItem();
1044     if (code_item == nullptr) {
1045       return;  // native or abstract method
1046     }
1047     if (code_item->tries_size_ == 0) {
1048       return;  // nothing to process
1049     }
1050     const uint8_t* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0);
1051     size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list);
1052     for (size_t i = 0; i < num_encoded_catch_handlers; i++) {
1053       int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list);
1054       bool has_catch_all = false;
1055       if (encoded_catch_handler_size <= 0) {
1056         encoded_catch_handler_size = -encoded_catch_handler_size;
1057         has_catch_all = true;
1058       }
1059       for (int32_t j = 0; j < encoded_catch_handler_size; j++) {
1060         dex::TypeIndex encoded_catch_handler_handlers_type_idx =
1061             dex::TypeIndex(DecodeUnsignedLeb128(&encoded_catch_handler_list));
1062         // Add to set of types to resolve if not already in the dex cache resolved types
1063         if (!method->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) {
1064           exceptions_to_resolve->emplace(encoded_catch_handler_handlers_type_idx,
1065                                          method->GetDexFile());
1066         }
1067         // ignore address associated with catch handler
1068         DecodeUnsignedLeb128(&encoded_catch_handler_list);
1069       }
1070       if (has_catch_all) {
1071         // ignore catch all address
1072         DecodeUnsignedLeb128(&encoded_catch_handler_list);
1073       }
1074     }
1075   }
1076 
1077   std::vector<ObjPtr<mirror::Class>> classes_;
1078 };
1079 
1080 class RecordImageClassesVisitor : public ClassVisitor {
1081  public:
RecordImageClassesVisitor(std::unordered_set<std::string> * image_classes)1082   explicit RecordImageClassesVisitor(std::unordered_set<std::string>* image_classes)
1083       : image_classes_(image_classes) {}
1084 
operator ()(ObjPtr<mirror::Class> klass)1085   bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
1086     std::string temp;
1087     image_classes_->insert(klass->GetDescriptor(&temp));
1088     return true;
1089   }
1090 
1091  private:
1092   std::unordered_set<std::string>* const image_classes_;
1093 };
1094 
1095 // Make a list of descriptors for classes to include in the image
LoadImageClasses(TimingLogger * timings)1096 void CompilerDriver::LoadImageClasses(TimingLogger* timings) {
1097   CHECK(timings != nullptr);
1098   if (!GetCompilerOptions().IsBootImage()) {
1099     return;
1100   }
1101 
1102   TimingLogger::ScopedTiming t("LoadImageClasses", timings);
1103   // Make a first class to load all classes explicitly listed in the file
1104   Thread* self = Thread::Current();
1105   ScopedObjectAccess soa(self);
1106   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1107   CHECK(image_classes_.get() != nullptr);
1108   for (auto it = image_classes_->begin(), end = image_classes_->end(); it != end;) {
1109     const std::string& descriptor(*it);
1110     StackHandleScope<1> hs(self);
1111     Handle<mirror::Class> klass(
1112         hs.NewHandle(class_linker->FindSystemClass(self, descriptor.c_str())));
1113     if (klass == nullptr) {
1114       VLOG(compiler) << "Failed to find class " << descriptor;
1115       image_classes_->erase(it++);
1116       self->ClearException();
1117     } else {
1118       ++it;
1119     }
1120   }
1121 
1122   // Resolve exception classes referenced by the loaded classes. The catch logic assumes
1123   // exceptions are resolved by the verifier when there is a catch block in an interested method.
1124   // Do this here so that exception classes appear to have been specified image classes.
1125   std::set<std::pair<dex::TypeIndex, const DexFile*>> unresolved_exception_types;
1126   StackHandleScope<1> hs(self);
1127   Handle<mirror::Class> java_lang_Throwable(
1128       hs.NewHandle(class_linker->FindSystemClass(self, "Ljava/lang/Throwable;")));
1129   do {
1130     unresolved_exception_types.clear();
1131     {
1132       // Thread suspension is not allowed while ResolveCatchBlockExceptionsClassVisitor
1133       // is using a std::vector<ObjPtr<mirror::Class>>.
1134       ScopedAssertNoThreadSuspension ants(__FUNCTION__);
1135       ResolveCatchBlockExceptionsClassVisitor visitor;
1136       class_linker->VisitClasses(&visitor);
1137       visitor.FindExceptionTypesToResolve(&unresolved_exception_types);
1138     }
1139     for (const auto& exception_type : unresolved_exception_types) {
1140       dex::TypeIndex exception_type_idx = exception_type.first;
1141       const DexFile* dex_file = exception_type.second;
1142       StackHandleScope<2> hs2(self);
1143       Handle<mirror::DexCache> dex_cache(hs2.NewHandle(class_linker->RegisterDexFile(*dex_file,
1144                                                                                      nullptr)));
1145       Handle<mirror::Class> klass(hs2.NewHandle(
1146           (dex_cache != nullptr)
1147               ? class_linker->ResolveType(*dex_file,
1148                                           exception_type_idx,
1149                                           dex_cache,
1150                                           ScopedNullHandle<mirror::ClassLoader>())
1151               : nullptr));
1152       if (klass == nullptr) {
1153         const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
1154         const char* descriptor = dex_file->GetTypeDescriptor(type_id);
1155         LOG(FATAL) << "Failed to resolve class " << descriptor;
1156       }
1157       DCHECK(java_lang_Throwable->IsAssignableFrom(klass.Get()));
1158     }
1159     // Resolving exceptions may load classes that reference more exceptions, iterate until no
1160     // more are found
1161   } while (!unresolved_exception_types.empty());
1162 
1163   // We walk the roots looking for classes so that we'll pick up the
1164   // above classes plus any classes them depend on such super
1165   // classes, interfaces, and the required ClassLinker roots.
1166   RecordImageClassesVisitor visitor(image_classes_.get());
1167   class_linker->VisitClasses(&visitor);
1168 
1169   CHECK_NE(image_classes_->size(), 0U);
1170 }
1171 
MaybeAddToImageClasses(Thread * self,ObjPtr<mirror::Class> klass,std::unordered_set<std::string> * image_classes)1172 static void MaybeAddToImageClasses(Thread* self,
1173                                    ObjPtr<mirror::Class> klass,
1174                                    std::unordered_set<std::string>* image_classes)
1175     REQUIRES_SHARED(Locks::mutator_lock_) {
1176   DCHECK_EQ(self, Thread::Current());
1177   StackHandleScope<1> hs(self);
1178   std::string temp;
1179   const PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
1180   while (!klass->IsObjectClass()) {
1181     const char* descriptor = klass->GetDescriptor(&temp);
1182     std::pair<std::unordered_set<std::string>::iterator, bool> result =
1183         image_classes->insert(descriptor);
1184     if (!result.second) {  // Previously inserted.
1185       break;
1186     }
1187     VLOG(compiler) << "Adding " << descriptor << " to image classes";
1188     for (size_t i = 0, num_interfaces = klass->NumDirectInterfaces(); i != num_interfaces; ++i) {
1189       ObjPtr<mirror::Class> interface = mirror::Class::GetDirectInterface(self, klass, i);
1190       DCHECK(interface != nullptr);
1191       MaybeAddToImageClasses(self, interface, image_classes);
1192     }
1193     for (auto& m : klass->GetVirtualMethods(pointer_size)) {
1194       MaybeAddToImageClasses(self, m.GetDeclaringClass(), image_classes);
1195     }
1196     if (klass->IsArrayClass()) {
1197       MaybeAddToImageClasses(self, klass->GetComponentType(), image_classes);
1198     }
1199     klass.Assign(klass->GetSuperClass());
1200   }
1201 }
1202 
1203 // Keeps all the data for the update together. Also doubles as the reference visitor.
1204 // Note: we can use object pointers because we suspend all threads.
1205 class ClinitImageUpdate {
1206  public:
Create(VariableSizedHandleScope & hs,std::unordered_set<std::string> * image_class_descriptors,Thread * self,ClassLinker * linker)1207   static ClinitImageUpdate* Create(VariableSizedHandleScope& hs,
1208                                    std::unordered_set<std::string>* image_class_descriptors,
1209                                    Thread* self,
1210                                    ClassLinker* linker) {
1211     std::unique_ptr<ClinitImageUpdate> res(new ClinitImageUpdate(hs,
1212                                                                  image_class_descriptors,
1213                                                                  self,
1214                                                                  linker));
1215     return res.release();
1216   }
1217 
~ClinitImageUpdate()1218   ~ClinitImageUpdate() {
1219     // Allow others to suspend again.
1220     self_->EndAssertNoThreadSuspension(old_cause_);
1221   }
1222 
1223   // Visitor for VisitReferences.
operator ()(ObjPtr<mirror::Object> object,MemberOffset field_offset,bool) const1224   void operator()(ObjPtr<mirror::Object> object,
1225                   MemberOffset field_offset,
1226                   bool /* is_static */) const
1227       REQUIRES_SHARED(Locks::mutator_lock_) {
1228     mirror::Object* ref = object->GetFieldObject<mirror::Object>(field_offset);
1229     if (ref != nullptr) {
1230       VisitClinitClassesObject(ref);
1231     }
1232   }
1233 
1234   // java.lang.ref.Reference visitor for VisitReferences.
operator ()(ObjPtr<mirror::Class> klass ATTRIBUTE_UNUSED,ObjPtr<mirror::Reference> ref ATTRIBUTE_UNUSED) const1235   void operator()(ObjPtr<mirror::Class> klass ATTRIBUTE_UNUSED,
1236                   ObjPtr<mirror::Reference> ref ATTRIBUTE_UNUSED) const {}
1237 
1238   // Ignore class native roots.
VisitRootIfNonNull(mirror::CompressedReference<mirror::Object> * root ATTRIBUTE_UNUSED) const1239   void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED)
1240       const {}
VisitRoot(mirror::CompressedReference<mirror::Object> * root ATTRIBUTE_UNUSED) const1241   void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {}
1242 
Walk()1243   void Walk() REQUIRES_SHARED(Locks::mutator_lock_) {
1244     // Use the initial classes as roots for a search.
1245     for (Handle<mirror::Class> klass_root : image_classes_) {
1246       VisitClinitClassesObject(klass_root.Get());
1247     }
1248     Thread* self = Thread::Current();
1249     ScopedAssertNoThreadSuspension ants(__FUNCTION__);
1250     for (Handle<mirror::Class> h_klass : to_insert_) {
1251       MaybeAddToImageClasses(self, h_klass.Get(), image_class_descriptors_);
1252     }
1253   }
1254 
1255  private:
1256   class FindImageClassesVisitor : public ClassVisitor {
1257    public:
FindImageClassesVisitor(VariableSizedHandleScope & hs,ClinitImageUpdate * data)1258     explicit FindImageClassesVisitor(VariableSizedHandleScope& hs,
1259                                      ClinitImageUpdate* data)
1260         : data_(data),
1261           hs_(hs) {}
1262 
operator ()(ObjPtr<mirror::Class> klass)1263     bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
1264       std::string temp;
1265       const char* name = klass->GetDescriptor(&temp);
1266       if (data_->image_class_descriptors_->find(name) != data_->image_class_descriptors_->end()) {
1267         data_->image_classes_.push_back(hs_.NewHandle(klass));
1268       } else {
1269         // Check whether it is initialized and has a clinit. They must be kept, too.
1270         if (klass->IsInitialized() && klass->FindClassInitializer(
1271             Runtime::Current()->GetClassLinker()->GetImagePointerSize()) != nullptr) {
1272           data_->image_classes_.push_back(hs_.NewHandle(klass));
1273         }
1274       }
1275       return true;
1276     }
1277 
1278    private:
1279     ClinitImageUpdate* const data_;
1280     VariableSizedHandleScope& hs_;
1281   };
1282 
ClinitImageUpdate(VariableSizedHandleScope & hs,std::unordered_set<std::string> * image_class_descriptors,Thread * self,ClassLinker * linker)1283   ClinitImageUpdate(VariableSizedHandleScope& hs,
1284                     std::unordered_set<std::string>* image_class_descriptors,
1285                     Thread* self,
1286                     ClassLinker* linker) REQUIRES_SHARED(Locks::mutator_lock_)
1287       : hs_(hs),
1288         image_class_descriptors_(image_class_descriptors),
1289         self_(self) {
1290     CHECK(linker != nullptr);
1291     CHECK(image_class_descriptors != nullptr);
1292 
1293     // Make sure nobody interferes with us.
1294     old_cause_ = self->StartAssertNoThreadSuspension("Boot image closure");
1295 
1296     // Find all the already-marked classes.
1297     WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
1298     FindImageClassesVisitor visitor(hs_, this);
1299     linker->VisitClasses(&visitor);
1300   }
1301 
VisitClinitClassesObject(mirror::Object * object) const1302   void VisitClinitClassesObject(mirror::Object* object) const
1303       REQUIRES_SHARED(Locks::mutator_lock_) {
1304     DCHECK(object != nullptr);
1305     if (marked_objects_.find(object) != marked_objects_.end()) {
1306       // Already processed.
1307       return;
1308     }
1309 
1310     // Mark it.
1311     marked_objects_.insert(object);
1312 
1313     if (object->IsClass()) {
1314       // Add to the TODO list since MaybeAddToImageClasses may cause thread suspension. Thread
1315       // suspensionb is not safe to do in VisitObjects or VisitReferences.
1316       to_insert_.push_back(hs_.NewHandle(object->AsClass()));
1317     } else {
1318       // Else visit the object's class.
1319       VisitClinitClassesObject(object->GetClass());
1320     }
1321 
1322     // If it is not a DexCache, visit all references.
1323     if (!object->IsDexCache()) {
1324       object->VisitReferences(*this, *this);
1325     }
1326   }
1327 
1328   VariableSizedHandleScope& hs_;
1329   mutable std::vector<Handle<mirror::Class>> to_insert_;
1330   mutable std::unordered_set<mirror::Object*> marked_objects_;
1331   std::unordered_set<std::string>* const image_class_descriptors_;
1332   std::vector<Handle<mirror::Class>> image_classes_;
1333   Thread* const self_;
1334   const char* old_cause_;
1335 
1336   DISALLOW_COPY_AND_ASSIGN(ClinitImageUpdate);
1337 };
1338 
UpdateImageClasses(TimingLogger * timings)1339 void CompilerDriver::UpdateImageClasses(TimingLogger* timings) {
1340   if (GetCompilerOptions().IsBootImage()) {
1341     TimingLogger::ScopedTiming t("UpdateImageClasses", timings);
1342 
1343     Runtime* runtime = Runtime::Current();
1344 
1345     // Suspend all threads.
1346     ScopedSuspendAll ssa(__FUNCTION__);
1347 
1348     VariableSizedHandleScope hs(Thread::Current());
1349     std::string error_msg;
1350     std::unique_ptr<ClinitImageUpdate> update(ClinitImageUpdate::Create(hs,
1351                                                                         image_classes_.get(),
1352                                                                         Thread::Current(),
1353                                                                         runtime->GetClassLinker()));
1354 
1355     // Do the marking.
1356     update->Walk();
1357   }
1358 }
1359 
CanAssumeClassIsLoaded(mirror::Class * klass)1360 bool CompilerDriver::CanAssumeClassIsLoaded(mirror::Class* klass) {
1361   Runtime* runtime = Runtime::Current();
1362   if (!runtime->IsAotCompiler()) {
1363     DCHECK(runtime->UseJitCompilation());
1364     // Having the klass reference here implies that the klass is already loaded.
1365     return true;
1366   }
1367   if (!GetCompilerOptions().IsBootImage()) {
1368     // Assume loaded only if klass is in the boot image. App classes cannot be assumed
1369     // loaded because we don't even know what class loader will be used to load them.
1370     bool class_in_image = runtime->GetHeap()->FindSpaceFromObject(klass, false)->IsImageSpace();
1371     return class_in_image;
1372   }
1373   std::string temp;
1374   const char* descriptor = klass->GetDescriptor(&temp);
1375   return IsImageClass(descriptor);
1376 }
1377 
MarkForDexToDexCompilation(Thread * self,const MethodReference & method_ref)1378 void CompilerDriver::MarkForDexToDexCompilation(Thread* self, const MethodReference& method_ref) {
1379   MutexLock lock(self, dex_to_dex_references_lock_);
1380   // Since we're compiling one dex file at a time, we need to look for the
1381   // current dex file entry only at the end of dex_to_dex_references_.
1382   if (dex_to_dex_references_.empty() ||
1383       &dex_to_dex_references_.back().GetDexFile() != method_ref.dex_file) {
1384     dex_to_dex_references_.emplace_back(*method_ref.dex_file);
1385   }
1386   dex_to_dex_references_.back().GetMethodIndexes().SetBit(method_ref.dex_method_index);
1387 }
1388 
CanAccessTypeWithoutChecks(ObjPtr<mirror::Class> referrer_class,ObjPtr<mirror::Class> resolved_class)1389 bool CompilerDriver::CanAccessTypeWithoutChecks(ObjPtr<mirror::Class> referrer_class,
1390                                                 ObjPtr<mirror::Class> resolved_class) {
1391   if (resolved_class == nullptr) {
1392     stats_->TypeNeedsAccessCheck();
1393     return false;  // Unknown class needs access checks.
1394   }
1395   bool is_accessible = resolved_class->IsPublic();  // Public classes are always accessible.
1396   if (!is_accessible) {
1397     if (referrer_class == nullptr) {
1398       stats_->TypeNeedsAccessCheck();
1399       return false;  // Incomplete referrer knowledge needs access check.
1400     }
1401     // Perform access check, will return true if access is ok or false if we're going to have to
1402     // check this at runtime (for example for class loaders).
1403     is_accessible = referrer_class->CanAccess(resolved_class);
1404   }
1405   if (is_accessible) {
1406     stats_->TypeDoesntNeedAccessCheck();
1407   } else {
1408     stats_->TypeNeedsAccessCheck();
1409   }
1410   return is_accessible;
1411 }
1412 
CanAccessInstantiableTypeWithoutChecks(ObjPtr<mirror::Class> referrer_class,ObjPtr<mirror::Class> resolved_class,bool * finalizable)1413 bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(ObjPtr<mirror::Class> referrer_class,
1414                                                             ObjPtr<mirror::Class> resolved_class,
1415                                                             bool* finalizable) {
1416   if (resolved_class == nullptr) {
1417     stats_->TypeNeedsAccessCheck();
1418     // Be conservative.
1419     *finalizable = true;
1420     return false;  // Unknown class needs access checks.
1421   }
1422   *finalizable = resolved_class->IsFinalizable();
1423   bool is_accessible = resolved_class->IsPublic();  // Public classes are always accessible.
1424   if (!is_accessible) {
1425     if (referrer_class == nullptr) {
1426       stats_->TypeNeedsAccessCheck();
1427       return false;  // Incomplete referrer knowledge needs access check.
1428     }
1429     // Perform access and instantiable checks, will return true if access is ok or false if we're
1430     // going to have to check this at runtime (for example for class loaders).
1431     is_accessible = referrer_class->CanAccess(resolved_class);
1432   }
1433   bool result = is_accessible && resolved_class->IsInstantiable();
1434   if (result) {
1435     stats_->TypeDoesntNeedAccessCheck();
1436   } else {
1437     stats_->TypeNeedsAccessCheck();
1438   }
1439   return result;
1440 }
1441 
ProcessedInstanceField(bool resolved)1442 void CompilerDriver::ProcessedInstanceField(bool resolved) {
1443   if (!resolved) {
1444     stats_->UnresolvedInstanceField();
1445   } else {
1446     stats_->ResolvedInstanceField();
1447   }
1448 }
1449 
ProcessedStaticField(bool resolved,bool local)1450 void CompilerDriver::ProcessedStaticField(bool resolved, bool local) {
1451   if (!resolved) {
1452     stats_->UnresolvedStaticField();
1453   } else if (local) {
1454     stats_->ResolvedLocalStaticField();
1455   } else {
1456     stats_->ResolvedStaticField();
1457   }
1458 }
1459 
ComputeInstanceFieldInfo(uint32_t field_idx,const DexCompilationUnit * mUnit,bool is_put,const ScopedObjectAccess & soa)1460 ArtField* CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx,
1461                                                    const DexCompilationUnit* mUnit, bool is_put,
1462                                                    const ScopedObjectAccess& soa) {
1463   // Try to resolve the field and compiling method's class.
1464   ArtField* resolved_field;
1465   mirror::Class* referrer_class;
1466   Handle<mirror::DexCache> dex_cache(mUnit->GetDexCache());
1467   {
1468     Handle<mirror::ClassLoader> class_loader_handle = mUnit->GetClassLoader();
1469     resolved_field = ResolveField(soa, dex_cache, class_loader_handle, mUnit, field_idx, false);
1470     referrer_class = resolved_field != nullptr
1471         ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader_handle, mUnit) : nullptr;
1472   }
1473   bool can_link = false;
1474   if (resolved_field != nullptr && referrer_class != nullptr) {
1475     std::pair<bool, bool> fast_path = IsFastInstanceField(
1476         dex_cache.Get(), referrer_class, resolved_field, field_idx);
1477     can_link = is_put ? fast_path.second : fast_path.first;
1478   }
1479   ProcessedInstanceField(can_link);
1480   return can_link ? resolved_field : nullptr;
1481 }
1482 
ComputeInstanceFieldInfo(uint32_t field_idx,const DexCompilationUnit * mUnit,bool is_put,MemberOffset * field_offset,bool * is_volatile)1483 bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
1484                                               bool is_put, MemberOffset* field_offset,
1485                                               bool* is_volatile) {
1486   ScopedObjectAccess soa(Thread::Current());
1487   ArtField* resolved_field = ComputeInstanceFieldInfo(field_idx, mUnit, is_put, soa);
1488 
1489   if (resolved_field == nullptr) {
1490     // Conservative defaults.
1491     *is_volatile = true;
1492     *field_offset = MemberOffset(static_cast<size_t>(-1));
1493     return false;
1494   } else {
1495     *is_volatile = resolved_field->IsVolatile();
1496     *field_offset = resolved_field->GetOffset();
1497     return true;
1498   }
1499 }
1500 
GetVerifiedMethod(const DexFile * dex_file,uint32_t method_idx) const1501 const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file,
1502                                                         uint32_t method_idx) const {
1503   MethodReference ref(dex_file, method_idx);
1504   return verification_results_->GetVerifiedMethod(ref);
1505 }
1506 
IsSafeCast(const DexCompilationUnit * mUnit,uint32_t dex_pc)1507 bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) {
1508   if (!compiler_options_->IsVerificationEnabled()) {
1509     // If we didn't verify, every cast has to be treated as non-safe.
1510     return false;
1511   }
1512   DCHECK(mUnit->GetVerifiedMethod() != nullptr);
1513   bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc);
1514   if (result) {
1515     stats_->SafeCast();
1516   } else {
1517     stats_->NotASafeCast();
1518   }
1519   return result;
1520 }
1521 
1522 class CompilationVisitor {
1523  public:
~CompilationVisitor()1524   virtual ~CompilationVisitor() {}
1525   virtual void Visit(size_t index) = 0;
1526 };
1527 
1528 class ParallelCompilationManager {
1529  public:
ParallelCompilationManager(ClassLinker * class_linker,jobject class_loader,CompilerDriver * compiler,const DexFile * dex_file,const std::vector<const DexFile * > & dex_files,ThreadPool * thread_pool)1530   ParallelCompilationManager(ClassLinker* class_linker,
1531                              jobject class_loader,
1532                              CompilerDriver* compiler,
1533                              const DexFile* dex_file,
1534                              const std::vector<const DexFile*>& dex_files,
1535                              ThreadPool* thread_pool)
1536     : index_(0),
1537       class_linker_(class_linker),
1538       class_loader_(class_loader),
1539       compiler_(compiler),
1540       dex_file_(dex_file),
1541       dex_files_(dex_files),
1542       thread_pool_(thread_pool) {}
1543 
GetClassLinker() const1544   ClassLinker* GetClassLinker() const {
1545     CHECK(class_linker_ != nullptr);
1546     return class_linker_;
1547   }
1548 
GetClassLoader() const1549   jobject GetClassLoader() const {
1550     return class_loader_;
1551   }
1552 
GetCompiler() const1553   CompilerDriver* GetCompiler() const {
1554     CHECK(compiler_ != nullptr);
1555     return compiler_;
1556   }
1557 
GetDexFile() const1558   const DexFile* GetDexFile() const {
1559     CHECK(dex_file_ != nullptr);
1560     return dex_file_;
1561   }
1562 
GetDexFiles() const1563   const std::vector<const DexFile*>& GetDexFiles() const {
1564     return dex_files_;
1565   }
1566 
ForAll(size_t begin,size_t end,CompilationVisitor * visitor,size_t work_units)1567   void ForAll(size_t begin, size_t end, CompilationVisitor* visitor, size_t work_units)
1568       REQUIRES(!*Locks::mutator_lock_) {
1569     Thread* self = Thread::Current();
1570     self->AssertNoPendingException();
1571     CHECK_GT(work_units, 0U);
1572 
1573     index_.StoreRelaxed(begin);
1574     for (size_t i = 0; i < work_units; ++i) {
1575       thread_pool_->AddTask(self, new ForAllClosure(this, end, visitor));
1576     }
1577     thread_pool_->StartWorkers(self);
1578 
1579     // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1580     // thread destructor's called below perform join).
1581     CHECK_NE(self->GetState(), kRunnable);
1582 
1583     // Wait for all the worker threads to finish.
1584     thread_pool_->Wait(self, true, false);
1585 
1586     // And stop the workers accepting jobs.
1587     thread_pool_->StopWorkers(self);
1588   }
1589 
NextIndex()1590   size_t NextIndex() {
1591     return index_.FetchAndAddSequentiallyConsistent(1);
1592   }
1593 
1594  private:
1595   class ForAllClosure : public Task {
1596    public:
ForAllClosure(ParallelCompilationManager * manager,size_t end,CompilationVisitor * visitor)1597     ForAllClosure(ParallelCompilationManager* manager, size_t end, CompilationVisitor* visitor)
1598         : manager_(manager),
1599           end_(end),
1600           visitor_(visitor) {}
1601 
Run(Thread * self)1602     virtual void Run(Thread* self) {
1603       while (true) {
1604         const size_t index = manager_->NextIndex();
1605         if (UNLIKELY(index >= end_)) {
1606           break;
1607         }
1608         visitor_->Visit(index);
1609         self->AssertNoPendingException();
1610       }
1611     }
1612 
Finalize()1613     virtual void Finalize() {
1614       delete this;
1615     }
1616 
1617    private:
1618     ParallelCompilationManager* const manager_;
1619     const size_t end_;
1620     CompilationVisitor* const visitor_;
1621   };
1622 
1623   AtomicInteger index_;
1624   ClassLinker* const class_linker_;
1625   const jobject class_loader_;
1626   CompilerDriver* const compiler_;
1627   const DexFile* const dex_file_;
1628   const std::vector<const DexFile*>& dex_files_;
1629   ThreadPool* const thread_pool_;
1630 
1631   DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager);
1632 };
1633 
1634 // A fast version of SkipClass above if the class pointer is available
1635 // that avoids the expensive FindInClassPath search.
SkipClass(jobject class_loader,const DexFile & dex_file,mirror::Class * klass)1636 static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass)
1637     REQUIRES_SHARED(Locks::mutator_lock_) {
1638   DCHECK(klass != nullptr);
1639   const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile();
1640   if (&dex_file != &original_dex_file) {
1641     if (class_loader == nullptr) {
1642       LOG(WARNING) << "Skipping class " << klass->PrettyDescriptor() << " from "
1643                    << dex_file.GetLocation() << " previously found in "
1644                    << original_dex_file.GetLocation();
1645     }
1646     return true;
1647   }
1648   return false;
1649 }
1650 
CheckAndClearResolveException(Thread * self)1651 static void CheckAndClearResolveException(Thread* self)
1652     REQUIRES_SHARED(Locks::mutator_lock_) {
1653   CHECK(self->IsExceptionPending());
1654   mirror::Throwable* exception = self->GetException();
1655   std::string temp;
1656   const char* descriptor = exception->GetClass()->GetDescriptor(&temp);
1657   const char* expected_exceptions[] = {
1658       "Ljava/lang/IllegalAccessError;",
1659       "Ljava/lang/IncompatibleClassChangeError;",
1660       "Ljava/lang/InstantiationError;",
1661       "Ljava/lang/LinkageError;",
1662       "Ljava/lang/NoClassDefFoundError;",
1663       "Ljava/lang/NoSuchFieldError;",
1664       "Ljava/lang/NoSuchMethodError;"
1665   };
1666   bool found = false;
1667   for (size_t i = 0; (found == false) && (i < arraysize(expected_exceptions)); ++i) {
1668     if (strcmp(descriptor, expected_exceptions[i]) == 0) {
1669       found = true;
1670     }
1671   }
1672   if (!found) {
1673     LOG(FATAL) << "Unexpected exception " << exception->Dump();
1674   }
1675   self->ClearException();
1676 }
1677 
RequiresConstructorBarrier(const DexFile & dex_file,uint16_t class_def_idx) const1678 bool CompilerDriver::RequiresConstructorBarrier(const DexFile& dex_file,
1679                                                 uint16_t class_def_idx) const {
1680   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
1681   const uint8_t* class_data = dex_file.GetClassData(class_def);
1682   if (class_data == nullptr) {
1683     // Empty class such as a marker interface.
1684     return false;
1685   }
1686   ClassDataItemIterator it(dex_file, class_data);
1687   while (it.HasNextStaticField()) {
1688     it.Next();
1689   }
1690   // We require a constructor barrier if there are final instance fields.
1691   while (it.HasNextInstanceField()) {
1692     if (it.MemberIsFinal()) {
1693       return true;
1694     }
1695     it.Next();
1696   }
1697   return false;
1698 }
1699 
1700 class ResolveClassFieldsAndMethodsVisitor : public CompilationVisitor {
1701  public:
ResolveClassFieldsAndMethodsVisitor(const ParallelCompilationManager * manager)1702   explicit ResolveClassFieldsAndMethodsVisitor(const ParallelCompilationManager* manager)
1703       : manager_(manager) {}
1704 
Visit(size_t class_def_index)1705   void Visit(size_t class_def_index) OVERRIDE REQUIRES(!Locks::mutator_lock_) {
1706     ATRACE_CALL();
1707     Thread* const self = Thread::Current();
1708     jobject jclass_loader = manager_->GetClassLoader();
1709     const DexFile& dex_file = *manager_->GetDexFile();
1710     ClassLinker* class_linker = manager_->GetClassLinker();
1711 
1712     // If an instance field is final then we need to have a barrier on the return, static final
1713     // fields are assigned within the lock held for class initialization. Conservatively assume
1714     // constructor barriers are always required.
1715     bool requires_constructor_barrier = true;
1716 
1717     // Method and Field are the worst. We can't resolve without either
1718     // context from the code use (to disambiguate virtual vs direct
1719     // method and instance vs static field) or from class
1720     // definitions. While the compiler will resolve what it can as it
1721     // needs it, here we try to resolve fields and methods used in class
1722     // definitions, since many of them many never be referenced by
1723     // generated code.
1724     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1725     ScopedObjectAccess soa(self);
1726     StackHandleScope<2> hs(soa.Self());
1727     Handle<mirror::ClassLoader> class_loader(
1728         hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
1729     Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(
1730         soa.Self(), dex_file)));
1731     // Resolve the class.
1732     mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
1733                                                      class_loader);
1734     bool resolve_fields_and_methods;
1735     if (klass == nullptr) {
1736       // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
1737       // attempt to resolve methods and fields when there is no declaring class.
1738       CheckAndClearResolveException(soa.Self());
1739       resolve_fields_and_methods = false;
1740     } else {
1741       // We successfully resolved a class, should we skip it?
1742       if (SkipClass(jclass_loader, dex_file, klass)) {
1743         return;
1744       }
1745       // We want to resolve the methods and fields eagerly.
1746       resolve_fields_and_methods = true;
1747     }
1748     // Note the class_data pointer advances through the headers,
1749     // static fields, instance fields, direct methods, and virtual
1750     // methods.
1751     const uint8_t* class_data = dex_file.GetClassData(class_def);
1752     if (class_data == nullptr) {
1753       // Empty class such as a marker interface.
1754       requires_constructor_barrier = false;
1755     } else {
1756       ClassDataItemIterator it(dex_file, class_data);
1757       while (it.HasNextStaticField()) {
1758         if (resolve_fields_and_methods) {
1759           ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1760                                                                dex_cache, class_loader, true);
1761           if (field == nullptr) {
1762             CheckAndClearResolveException(soa.Self());
1763           }
1764         }
1765         it.Next();
1766       }
1767       // We require a constructor barrier if there are final instance fields.
1768       requires_constructor_barrier = false;
1769       while (it.HasNextInstanceField()) {
1770         if (it.MemberIsFinal()) {
1771           requires_constructor_barrier = true;
1772         }
1773         if (resolve_fields_and_methods) {
1774           ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
1775                                                                dex_cache, class_loader, false);
1776           if (field == nullptr) {
1777             CheckAndClearResolveException(soa.Self());
1778           }
1779         }
1780         it.Next();
1781       }
1782       if (resolve_fields_and_methods) {
1783         while (it.HasNextDirectMethod()) {
1784           ArtMethod* method = class_linker->ResolveMethod<ClassLinker::kNoICCECheckForCache>(
1785               dex_file, it.GetMemberIndex(), dex_cache, class_loader, nullptr,
1786               it.GetMethodInvokeType(class_def));
1787           if (method == nullptr) {
1788             CheckAndClearResolveException(soa.Self());
1789           }
1790           it.Next();
1791         }
1792         while (it.HasNextVirtualMethod()) {
1793           ArtMethod* method = class_linker->ResolveMethod<ClassLinker::kNoICCECheckForCache>(
1794               dex_file, it.GetMemberIndex(), dex_cache, class_loader, nullptr,
1795               it.GetMethodInvokeType(class_def));
1796           if (method == nullptr) {
1797             CheckAndClearResolveException(soa.Self());
1798           }
1799           it.Next();
1800         }
1801         DCHECK(!it.HasNext());
1802       }
1803     }
1804     manager_->GetCompiler()->SetRequiresConstructorBarrier(self,
1805                                                            &dex_file,
1806                                                            class_def_index,
1807                                                            requires_constructor_barrier);
1808   }
1809 
1810  private:
1811   const ParallelCompilationManager* const manager_;
1812 };
1813 
1814 class ResolveTypeVisitor : public CompilationVisitor {
1815  public:
ResolveTypeVisitor(const ParallelCompilationManager * manager)1816   explicit ResolveTypeVisitor(const ParallelCompilationManager* manager) : manager_(manager) {
1817   }
Visit(size_t type_idx)1818   void Visit(size_t type_idx) OVERRIDE REQUIRES(!Locks::mutator_lock_) {
1819   // Class derived values are more complicated, they require the linker and loader.
1820     ScopedObjectAccess soa(Thread::Current());
1821     ClassLinker* class_linker = manager_->GetClassLinker();
1822     const DexFile& dex_file = *manager_->GetDexFile();
1823     StackHandleScope<2> hs(soa.Self());
1824     Handle<mirror::ClassLoader> class_loader(
1825         hs.NewHandle(soa.Decode<mirror::ClassLoader>(manager_->GetClassLoader())));
1826     Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->RegisterDexFile(
1827         dex_file,
1828         class_loader.Get())));
1829     ObjPtr<mirror::Class> klass = (dex_cache != nullptr)
1830         ? class_linker->ResolveType(dex_file, dex::TypeIndex(type_idx), dex_cache, class_loader)
1831         : nullptr;
1832 
1833     if (klass == nullptr) {
1834       soa.Self()->AssertPendingException();
1835       mirror::Throwable* exception = soa.Self()->GetException();
1836       VLOG(compiler) << "Exception during type resolution: " << exception->Dump();
1837       if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) {
1838         // There's little point continuing compilation if the heap is exhausted.
1839         LOG(FATAL) << "Out of memory during type resolution for compilation";
1840       }
1841       soa.Self()->ClearException();
1842     }
1843   }
1844 
1845  private:
1846   const ParallelCompilationManager* const manager_;
1847 };
1848 
ResolveDexFile(jobject class_loader,const DexFile & dex_file,const std::vector<const DexFile * > & dex_files,ThreadPool * thread_pool,size_t thread_count,TimingLogger * timings)1849 void CompilerDriver::ResolveDexFile(jobject class_loader,
1850                                     const DexFile& dex_file,
1851                                     const std::vector<const DexFile*>& dex_files,
1852                                     ThreadPool* thread_pool,
1853                                     size_t thread_count,
1854                                     TimingLogger* timings) {
1855   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1856 
1857   // TODO: we could resolve strings here, although the string table is largely filled with class
1858   //       and method names.
1859 
1860   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files,
1861                                      thread_pool);
1862   if (GetCompilerOptions().IsBootImage()) {
1863     // For images we resolve all types, such as array, whereas for applications just those with
1864     // classdefs are resolved by ResolveClassFieldsAndMethods.
1865     TimingLogger::ScopedTiming t("Resolve Types", timings);
1866     ResolveTypeVisitor visitor(&context);
1867     context.ForAll(0, dex_file.NumTypeIds(), &visitor, thread_count);
1868   }
1869 
1870   TimingLogger::ScopedTiming t("Resolve MethodsAndFields", timings);
1871   ResolveClassFieldsAndMethodsVisitor visitor(&context);
1872   context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count);
1873 }
1874 
SetVerified(jobject class_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)1875 void CompilerDriver::SetVerified(jobject class_loader,
1876                                  const std::vector<const DexFile*>& dex_files,
1877                                  TimingLogger* timings) {
1878   // This can be run in parallel.
1879   for (const DexFile* dex_file : dex_files) {
1880     CHECK(dex_file != nullptr);
1881     SetVerifiedDexFile(class_loader,
1882                        *dex_file,
1883                        dex_files,
1884                        parallel_thread_pool_.get(),
1885                        parallel_thread_count_,
1886                        timings);
1887   }
1888 }
1889 
PopulateVerifiedMethods(const DexFile & dex_file,uint32_t class_def_index,VerificationResults * verification_results)1890 static void PopulateVerifiedMethods(const DexFile& dex_file,
1891                                     uint32_t class_def_index,
1892                                     VerificationResults* verification_results) {
1893   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1894   const uint8_t* class_data = dex_file.GetClassData(class_def);
1895   if (class_data == nullptr) {
1896     return;
1897   }
1898   ClassDataItemIterator it(dex_file, class_data);
1899   // Skip fields
1900   while (it.HasNextStaticField()) {
1901     it.Next();
1902   }
1903   while (it.HasNextInstanceField()) {
1904     it.Next();
1905   }
1906 
1907   while (it.HasNextDirectMethod()) {
1908     verification_results->CreateVerifiedMethodFor(MethodReference(&dex_file, it.GetMemberIndex()));
1909     it.Next();
1910   }
1911 
1912   while (it.HasNextVirtualMethod()) {
1913     verification_results->CreateVerifiedMethodFor(MethodReference(&dex_file, it.GetMemberIndex()));
1914     it.Next();
1915   }
1916   DCHECK(!it.HasNext());
1917 }
1918 
LoadAndUpdateStatus(const DexFile & dex_file,const DexFile::ClassDef & class_def,mirror::Class::Status status,Handle<mirror::ClassLoader> class_loader,Thread * self)1919 static void LoadAndUpdateStatus(const DexFile& dex_file,
1920                                 const DexFile::ClassDef& class_def,
1921                                 mirror::Class::Status status,
1922                                 Handle<mirror::ClassLoader> class_loader,
1923                                 Thread* self)
1924     REQUIRES_SHARED(Locks::mutator_lock_) {
1925   StackHandleScope<1> hs(self);
1926   const char* descriptor = dex_file.GetClassDescriptor(class_def);
1927   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1928   Handle<mirror::Class> cls(hs.NewHandle<mirror::Class>(
1929       class_linker->FindClass(self, descriptor, class_loader)));
1930   if (cls != nullptr) {
1931     // Check that the class is resolved with the current dex file. We might get
1932     // a boot image class, or a class in a different dex file for multidex, and
1933     // we should not update the status in that case.
1934     if (&cls->GetDexFile() == &dex_file) {
1935       ObjectLock<mirror::Class> lock(self, cls);
1936       mirror::Class::SetStatus(cls, status, self);
1937     }
1938   } else {
1939     DCHECK(self->IsExceptionPending());
1940     self->ClearException();
1941   }
1942 }
1943 
FastVerify(jobject jclass_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)1944 bool CompilerDriver::FastVerify(jobject jclass_loader,
1945                                 const std::vector<const DexFile*>& dex_files,
1946                                 TimingLogger* timings) {
1947   verifier::VerifierDeps* verifier_deps =
1948       Runtime::Current()->GetCompilerCallbacks()->GetVerifierDeps();
1949   // If there is an existing `VerifierDeps`, try to use it for fast verification.
1950   if (verifier_deps == nullptr) {
1951     return false;
1952   }
1953   TimingLogger::ScopedTiming t("Fast Verify", timings);
1954   ScopedObjectAccess soa(Thread::Current());
1955   StackHandleScope<2> hs(soa.Self());
1956   Handle<mirror::ClassLoader> class_loader(
1957       hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
1958   if (!verifier_deps->ValidateDependencies(class_loader, soa.Self())) {
1959     return false;
1960   }
1961 
1962   bool compiler_only_verifies = !GetCompilerOptions().IsAnyCompilationEnabled();
1963 
1964   // We successfully validated the dependencies, now update class status
1965   // of verified classes. Note that the dependencies also record which classes
1966   // could not be fully verified; we could try again, but that would hurt verification
1967   // time. So instead we assume these classes still need to be verified at
1968   // runtime.
1969   for (const DexFile* dex_file : dex_files) {
1970     // Fetch the list of unverified classes and turn it into a set for faster
1971     // lookups.
1972     const std::vector<dex::TypeIndex>& unverified_classes =
1973         verifier_deps->GetUnverifiedClasses(*dex_file);
1974     std::set<dex::TypeIndex> set(unverified_classes.begin(), unverified_classes.end());
1975     for (uint32_t i = 0; i < dex_file->NumClassDefs(); ++i) {
1976       const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
1977       if (set.find(class_def.class_idx_) == set.end()) {
1978         if (compiler_only_verifies) {
1979           // Just update the compiled_classes_ map. The compiler doesn't need to resolve
1980           // the type.
1981           compiled_classes_.Overwrite(
1982               ClassReference(dex_file, i), new CompiledClass(mirror::Class::kStatusVerified));
1983         } else {
1984           // Update the class status, so later compilation stages know they don't need to verify
1985           // the class.
1986           LoadAndUpdateStatus(
1987               *dex_file, class_def, mirror::Class::kStatusVerified, class_loader, soa.Self());
1988           // Create `VerifiedMethod`s for each methods, the compiler expects one for
1989           // quickening or compiling.
1990           // Note that this means:
1991           // - We're only going to compile methods that did verify.
1992           // - Quickening will not do checkcast ellision.
1993           // TODO(ngeoffray): Reconsider this once we refactor compiler filters.
1994           PopulateVerifiedMethods(*dex_file, i, verification_results_);
1995         }
1996       } else if (!compiler_only_verifies) {
1997         // Make sure later compilation stages know they should not try to verify
1998         // this class again.
1999         LoadAndUpdateStatus(*dex_file,
2000                             class_def,
2001                             mirror::Class::kStatusRetryVerificationAtRuntime,
2002                             class_loader,
2003                             soa.Self());
2004       }
2005     }
2006   }
2007   return true;
2008 }
2009 
Verify(jobject jclass_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)2010 void CompilerDriver::Verify(jobject jclass_loader,
2011                             const std::vector<const DexFile*>& dex_files,
2012                             TimingLogger* timings) {
2013   if (FastVerify(jclass_loader, dex_files, timings)) {
2014     return;
2015   }
2016 
2017   // If there is no existing `verifier_deps` (because of non-existing vdex), or
2018   // the existing `verifier_deps` is not valid anymore, create a new one for
2019   // non boot image compilation. The verifier will need it to record the new dependencies.
2020   // Then dex2oat can update the vdex file with these new dependencies.
2021   if (!GetCompilerOptions().IsBootImage()) {
2022     // Create the main VerifierDeps, and set it to this thread.
2023     verifier::VerifierDeps* verifier_deps = new verifier::VerifierDeps(dex_files);
2024     Runtime::Current()->GetCompilerCallbacks()->SetVerifierDeps(verifier_deps);
2025     Thread::Current()->SetVerifierDeps(verifier_deps);
2026     // Create per-thread VerifierDeps to avoid contention on the main one.
2027     // We will merge them after verification.
2028     for (ThreadPoolWorker* worker : parallel_thread_pool_->GetWorkers()) {
2029       worker->GetThread()->SetVerifierDeps(new verifier::VerifierDeps(dex_files));
2030     }
2031   }
2032 
2033   // Verification updates VerifierDeps and needs to run single-threaded to be deterministic.
2034   bool force_determinism = GetCompilerOptions().IsForceDeterminism();
2035   ThreadPool* verify_thread_pool =
2036       force_determinism ? single_thread_pool_.get() : parallel_thread_pool_.get();
2037   size_t verify_thread_count = force_determinism ? 1U : parallel_thread_count_;
2038   for (const DexFile* dex_file : dex_files) {
2039     CHECK(dex_file != nullptr);
2040     VerifyDexFile(jclass_loader,
2041                   *dex_file,
2042                   dex_files,
2043                   verify_thread_pool,
2044                   verify_thread_count,
2045                   timings);
2046   }
2047 
2048   if (!GetCompilerOptions().IsBootImage()) {
2049     // Merge all VerifierDeps into the main one.
2050     verifier::VerifierDeps* verifier_deps = Thread::Current()->GetVerifierDeps();
2051     for (ThreadPoolWorker* worker : parallel_thread_pool_->GetWorkers()) {
2052       verifier::VerifierDeps* thread_deps = worker->GetThread()->GetVerifierDeps();
2053       worker->GetThread()->SetVerifierDeps(nullptr);
2054       verifier_deps->MergeWith(*thread_deps, dex_files);;
2055       delete thread_deps;
2056     }
2057     Thread::Current()->SetVerifierDeps(nullptr);
2058   }
2059 }
2060 
2061 class VerifyClassVisitor : public CompilationVisitor {
2062  public:
VerifyClassVisitor(const ParallelCompilationManager * manager,verifier::HardFailLogMode log_level)2063   VerifyClassVisitor(const ParallelCompilationManager* manager, verifier::HardFailLogMode log_level)
2064      : manager_(manager), log_level_(log_level) {}
2065 
Visit(size_t class_def_index)2066   virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE {
2067     ATRACE_CALL();
2068     ScopedObjectAccess soa(Thread::Current());
2069     const DexFile& dex_file = *manager_->GetDexFile();
2070     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
2071     const char* descriptor = dex_file.GetClassDescriptor(class_def);
2072     ClassLinker* class_linker = manager_->GetClassLinker();
2073     jobject jclass_loader = manager_->GetClassLoader();
2074     StackHandleScope<3> hs(soa.Self());
2075     Handle<mirror::ClassLoader> class_loader(
2076         hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
2077     Handle<mirror::Class> klass(
2078         hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader)));
2079     verifier::FailureKind failure_kind;
2080     if (klass == nullptr) {
2081       CHECK(soa.Self()->IsExceptionPending());
2082       soa.Self()->ClearException();
2083 
2084       /*
2085        * At compile time, we can still structurally verify the class even if FindClass fails.
2086        * This is to ensure the class is structurally sound for compilation. An unsound class
2087        * will be rejected by the verifier and later skipped during compilation in the compiler.
2088        */
2089       Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(
2090           soa.Self(), dex_file)));
2091       std::string error_msg;
2092       failure_kind =
2093           verifier::MethodVerifier::VerifyClass(soa.Self(),
2094                                                 &dex_file,
2095                                                 dex_cache,
2096                                                 class_loader,
2097                                                 class_def,
2098                                                 Runtime::Current()->GetCompilerCallbacks(),
2099                                                 true /* allow soft failures */,
2100                                                 log_level_,
2101                                                 &error_msg);
2102       if (failure_kind == verifier::FailureKind::kHardFailure) {
2103         LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor)
2104                    << " because: " << error_msg;
2105         manager_->GetCompiler()->SetHadHardVerifierFailure();
2106       } else {
2107         // Force a soft failure for the VerifierDeps. This is a sanity measure, as
2108         // the vdex file already records that the class hasn't been resolved. It avoids
2109         // trying to do future verification optimizations when processing the vdex file.
2110         DCHECK(failure_kind == verifier::FailureKind::kSoftFailure ||
2111                failure_kind == verifier::FailureKind::kNoFailure)
2112             << failure_kind;
2113         failure_kind = verifier::FailureKind::kSoftFailure;
2114       }
2115     } else if (!SkipClass(jclass_loader, dex_file, klass.Get())) {
2116       CHECK(klass->IsResolved()) << klass->PrettyClass();
2117       failure_kind = class_linker->VerifyClass(soa.Self(), klass, log_level_);
2118 
2119       if (klass->IsErroneous()) {
2120         // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
2121         CHECK(soa.Self()->IsExceptionPending());
2122         soa.Self()->ClearException();
2123         manager_->GetCompiler()->SetHadHardVerifierFailure();
2124       }
2125 
2126       CHECK(klass->ShouldVerifyAtRuntime() || klass->IsVerified() || klass->IsErroneous())
2127           << klass->PrettyDescriptor() << ": state=" << klass->GetStatus();
2128 
2129       // Class has a meaningful status for the compiler now, record it.
2130       ClassReference ref(manager_->GetDexFile(), class_def_index);
2131       manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
2132 
2133       // It is *very* problematic if there are verification errors in the boot classpath. For example,
2134       // we rely on things working OK without verification when the decryption dialog is brought up.
2135       // So abort in a debug build if we find this violated.
2136       if (kIsDebugBuild) {
2137         // TODO(narayan): Remove this special case for signature polymorphic
2138         // invokes once verifier support is fully implemented.
2139         if (manager_->GetCompiler()->GetCompilerOptions().IsBootImage() &&
2140             !android::base::StartsWith(descriptor, "Ljava/lang/invoke/")) {
2141           DCHECK(klass->IsVerified()) << "Boot classpath class " << klass->PrettyClass()
2142               << " failed to fully verify: state= " << klass->GetStatus();
2143         }
2144         if (klass->IsVerified()) {
2145           DCHECK_EQ(failure_kind, verifier::FailureKind::kNoFailure);
2146         } else if (klass->ShouldVerifyAtRuntime()) {
2147           DCHECK_EQ(failure_kind, verifier::FailureKind::kSoftFailure);
2148         } else {
2149           DCHECK_EQ(failure_kind, verifier::FailureKind::kHardFailure);
2150         }
2151       }
2152     } else {
2153       // Make the skip a soft failure, essentially being considered as verify at runtime.
2154       failure_kind = verifier::FailureKind::kSoftFailure;
2155     }
2156     verifier::VerifierDeps::MaybeRecordVerificationStatus(
2157         dex_file, class_def.class_idx_, failure_kind);
2158     soa.Self()->AssertNoPendingException();
2159   }
2160 
2161  private:
2162   const ParallelCompilationManager* const manager_;
2163   const verifier::HardFailLogMode log_level_;
2164 };
2165 
VerifyDexFile(jobject class_loader,const DexFile & dex_file,const std::vector<const DexFile * > & dex_files,ThreadPool * thread_pool,size_t thread_count,TimingLogger * timings)2166 void CompilerDriver::VerifyDexFile(jobject class_loader,
2167                                    const DexFile& dex_file,
2168                                    const std::vector<const DexFile*>& dex_files,
2169                                    ThreadPool* thread_pool,
2170                                    size_t thread_count,
2171                                    TimingLogger* timings) {
2172   TimingLogger::ScopedTiming t("Verify Dex File", timings);
2173   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2174   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files,
2175                                      thread_pool);
2176   verifier::HardFailLogMode log_level = GetCompilerOptions().AbortOnHardVerifierFailure()
2177                               ? verifier::HardFailLogMode::kLogInternalFatal
2178                               : verifier::HardFailLogMode::kLogWarning;
2179   VerifyClassVisitor visitor(&context, log_level);
2180   context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count);
2181 }
2182 
2183 class SetVerifiedClassVisitor : public CompilationVisitor {
2184  public:
SetVerifiedClassVisitor(const ParallelCompilationManager * manager)2185   explicit SetVerifiedClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {}
2186 
Visit(size_t class_def_index)2187   virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE {
2188     ATRACE_CALL();
2189     ScopedObjectAccess soa(Thread::Current());
2190     const DexFile& dex_file = *manager_->GetDexFile();
2191     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
2192     const char* descriptor = dex_file.GetClassDescriptor(class_def);
2193     ClassLinker* class_linker = manager_->GetClassLinker();
2194     jobject jclass_loader = manager_->GetClassLoader();
2195     StackHandleScope<3> hs(soa.Self());
2196     Handle<mirror::ClassLoader> class_loader(
2197         hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
2198     Handle<mirror::Class> klass(
2199         hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader)));
2200     // Class might have failed resolution. Then don't set it to verified.
2201     if (klass != nullptr) {
2202       // Only do this if the class is resolved. If even resolution fails, quickening will go very,
2203       // very wrong.
2204       if (klass->IsResolved() && !klass->IsErroneousResolved()) {
2205         if (klass->GetStatus() < mirror::Class::kStatusVerified) {
2206           ObjectLock<mirror::Class> lock(soa.Self(), klass);
2207           // Set class status to verified.
2208           mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, soa.Self());
2209           // Mark methods as pre-verified. If we don't do this, the interpreter will run with
2210           // access checks.
2211           klass->SetSkipAccessChecksFlagOnAllMethods(
2212               GetInstructionSetPointerSize(manager_->GetCompiler()->GetInstructionSet()));
2213           klass->SetVerificationAttempted();
2214         }
2215         // Record the final class status if necessary.
2216         ClassReference ref(manager_->GetDexFile(), class_def_index);
2217         manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
2218       }
2219     } else {
2220       Thread* self = soa.Self();
2221       DCHECK(self->IsExceptionPending());
2222       self->ClearException();
2223     }
2224   }
2225 
2226  private:
2227   const ParallelCompilationManager* const manager_;
2228 };
2229 
SetVerifiedDexFile(jobject class_loader,const DexFile & dex_file,const std::vector<const DexFile * > & dex_files,ThreadPool * thread_pool,size_t thread_count,TimingLogger * timings)2230 void CompilerDriver::SetVerifiedDexFile(jobject class_loader,
2231                                         const DexFile& dex_file,
2232                                         const std::vector<const DexFile*>& dex_files,
2233                                         ThreadPool* thread_pool,
2234                                         size_t thread_count,
2235                                         TimingLogger* timings) {
2236   TimingLogger::ScopedTiming t("Verify Dex File", timings);
2237   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2238   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files,
2239                                      thread_pool);
2240   SetVerifiedClassVisitor visitor(&context);
2241   context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count);
2242 }
2243 
2244 class InitializeClassVisitor : public CompilationVisitor {
2245  public:
InitializeClassVisitor(const ParallelCompilationManager * manager)2246   explicit InitializeClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {}
2247 
Visit(size_t class_def_index)2248   void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE {
2249     ATRACE_CALL();
2250     jobject jclass_loader = manager_->GetClassLoader();
2251     const DexFile& dex_file = *manager_->GetDexFile();
2252     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
2253     const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_);
2254     const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_);
2255 
2256     ScopedObjectAccess soa(Thread::Current());
2257     StackHandleScope<3> hs(soa.Self());
2258     Handle<mirror::ClassLoader> class_loader(
2259         hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
2260     Handle<mirror::Class> klass(
2261         hs.NewHandle(manager_->GetClassLinker()->FindClass(soa.Self(), descriptor, class_loader)));
2262 
2263     if (klass != nullptr && !SkipClass(jclass_loader, dex_file, klass.Get())) {
2264       // Only try to initialize classes that were successfully verified.
2265       if (klass->IsVerified()) {
2266         // Attempt to initialize the class but bail if we either need to initialize the super-class
2267         // or static fields.
2268         manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, false);
2269         if (!klass->IsInitialized()) {
2270           // We don't want non-trivial class initialization occurring on multiple threads due to
2271           // deadlock problems. For example, a parent class is initialized (holding its lock) that
2272           // refers to a sub-class in its static/class initializer causing it to try to acquire the
2273           // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock)
2274           // after first initializing its parents, whose locks are acquired. This leads to a
2275           // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock.
2276           // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
2277           // than use a special Object for the purpose we use the Class of java.lang.Class.
2278           Handle<mirror::Class> h_klass(hs.NewHandle(klass->GetClass()));
2279           ObjectLock<mirror::Class> lock(soa.Self(), h_klass);
2280           // Attempt to initialize allowing initialization of parent classes but still not static
2281           // fields.
2282           manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, true);
2283           if (!klass->IsInitialized()) {
2284             // We need to initialize static fields, we only do this for image classes that aren't
2285             // marked with the $NoPreloadHolder (which implies this should not be initialized early).
2286             bool can_init_static_fields =
2287                 manager_->GetCompiler()->GetCompilerOptions().IsBootImage() &&
2288                 manager_->GetCompiler()->IsImageClass(descriptor) &&
2289                 !StringPiece(descriptor).ends_with("$NoPreloadHolder;");
2290             if (can_init_static_fields) {
2291               VLOG(compiler) << "Initializing: " << descriptor;
2292               // TODO multithreading support. We should ensure the current compilation thread has
2293               // exclusive access to the runtime and the transaction. To achieve this, we could use
2294               // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity
2295               // checks in Thread::AssertThreadSuspensionIsAllowable.
2296               Runtime* const runtime = Runtime::Current();
2297               Transaction transaction;
2298 
2299               // Run the class initializer in transaction mode.
2300               runtime->EnterTransactionMode(&transaction);
2301               const mirror::Class::Status old_status = klass->GetStatus();
2302               bool success = manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, true,
2303                                                                            true);
2304               // TODO we detach transaction from runtime to indicate we quit the transactional
2305               // mode which prevents the GC from visiting objects modified during the transaction.
2306               // Ensure GC is not run so don't access freed objects when aborting transaction.
2307 
2308               {
2309                 ScopedAssertNoThreadSuspension ants("Transaction end");
2310                 runtime->ExitTransactionMode();
2311 
2312                 if (!success) {
2313                   CHECK(soa.Self()->IsExceptionPending());
2314                   mirror::Throwable* exception = soa.Self()->GetException();
2315                   VLOG(compiler) << "Initialization of " << descriptor << " aborted because of "
2316                       << exception->Dump();
2317                   std::ostream* file_log = manager_->GetCompiler()->
2318                       GetCompilerOptions().GetInitFailureOutput();
2319                   if (file_log != nullptr) {
2320                     *file_log << descriptor << "\n";
2321                     *file_log << exception->Dump() << "\n";
2322                   }
2323                   soa.Self()->ClearException();
2324                   transaction.Rollback();
2325                   CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored";
2326                 }
2327               }
2328 
2329               if (!success) {
2330                 // On failure, still intern strings of static fields and seen in <clinit>, as these
2331                 // will be created in the zygote. This is separated from the transaction code just
2332                 // above as we will allocate strings, so must be allowed to suspend.
2333                 InternStrings(klass, class_loader);
2334               }
2335             }
2336           }
2337           soa.Self()->AssertNoPendingException();
2338         }
2339       }
2340       // Record the final class status if necessary.
2341       ClassReference ref(manager_->GetDexFile(), class_def_index);
2342       manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
2343     }
2344     // Clear any class not found or verification exceptions.
2345     soa.Self()->ClearException();
2346   }
2347 
2348  private:
InternStrings(Handle<mirror::Class> klass,Handle<mirror::ClassLoader> class_loader)2349   void InternStrings(Handle<mirror::Class> klass, Handle<mirror::ClassLoader> class_loader)
2350       REQUIRES_SHARED(Locks::mutator_lock_) {
2351     DCHECK(manager_->GetCompiler()->GetCompilerOptions().IsBootImage());
2352     DCHECK(klass->IsVerified());
2353     DCHECK(!klass->IsInitialized());
2354 
2355     StackHandleScope<1> hs(Thread::Current());
2356     Handle<mirror::DexCache> h_dex_cache = hs.NewHandle(klass->GetDexCache());
2357     const DexFile* dex_file = manager_->GetDexFile();
2358     const DexFile::ClassDef* class_def = klass->GetClassDef();
2359     ClassLinker* class_linker = manager_->GetClassLinker();
2360 
2361     // Check encoded final field values for strings and intern.
2362     annotations::RuntimeEncodedStaticFieldValueIterator value_it(*dex_file,
2363                                                                  &h_dex_cache,
2364                                                                  &class_loader,
2365                                                                  manager_->GetClassLinker(),
2366                                                                  *class_def);
2367     for ( ; value_it.HasNext(); value_it.Next()) {
2368       if (value_it.GetValueType() == annotations::RuntimeEncodedStaticFieldValueIterator::kString) {
2369         // Resolve the string. This will intern the string.
2370         art::ObjPtr<mirror::String> resolved = class_linker->ResolveString(
2371             *dex_file, dex::StringIndex(value_it.GetJavaValue().i), h_dex_cache);
2372         CHECK(resolved != nullptr);
2373       }
2374     }
2375 
2376     // Intern strings seen in <clinit>.
2377     ArtMethod* clinit = klass->FindClassInitializer(class_linker->GetImagePointerSize());
2378     if (clinit != nullptr) {
2379       const DexFile::CodeItem* code_item = clinit->GetCodeItem();
2380       DCHECK(code_item != nullptr);
2381       const Instruction* inst = Instruction::At(code_item->insns_);
2382 
2383       const uint32_t insns_size = code_item->insns_size_in_code_units_;
2384       for (uint32_t dex_pc = 0; dex_pc < insns_size;) {
2385         if (inst->Opcode() == Instruction::CONST_STRING) {
2386           ObjPtr<mirror::String> s = class_linker->ResolveString(
2387               *dex_file, dex::StringIndex(inst->VRegB_21c()), h_dex_cache);
2388           CHECK(s != nullptr);
2389         } else if (inst->Opcode() == Instruction::CONST_STRING_JUMBO) {
2390           ObjPtr<mirror::String> s = class_linker->ResolveString(
2391               *dex_file, dex::StringIndex(inst->VRegB_31c()), h_dex_cache);
2392           CHECK(s != nullptr);
2393         }
2394         dex_pc += inst->SizeInCodeUnits();
2395         inst = inst->Next();
2396       }
2397     }
2398   }
2399 
2400   const ParallelCompilationManager* const manager_;
2401 };
2402 
InitializeClasses(jobject jni_class_loader,const DexFile & dex_file,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)2403 void CompilerDriver::InitializeClasses(jobject jni_class_loader,
2404                                        const DexFile& dex_file,
2405                                        const std::vector<const DexFile*>& dex_files,
2406                                        TimingLogger* timings) {
2407   TimingLogger::ScopedTiming t("InitializeNoClinit", timings);
2408 
2409   // Initialization allocates objects and needs to run single-threaded to be deterministic.
2410   bool force_determinism = GetCompilerOptions().IsForceDeterminism();
2411   ThreadPool* init_thread_pool = force_determinism
2412                                      ? single_thread_pool_.get()
2413                                      : parallel_thread_pool_.get();
2414   size_t init_thread_count = force_determinism ? 1U : parallel_thread_count_;
2415 
2416   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2417   ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, dex_files,
2418                                      init_thread_pool);
2419   if (GetCompilerOptions().IsBootImage()) {
2420     // TODO: remove this when transactional mode supports multithreading.
2421     init_thread_count = 1U;
2422   }
2423   InitializeClassVisitor visitor(&context);
2424   context.ForAll(0, dex_file.NumClassDefs(), &visitor, init_thread_count);
2425 }
2426 
2427 class InitializeArrayClassesAndCreateConflictTablesVisitor : public ClassVisitor {
2428  public:
InitializeArrayClassesAndCreateConflictTablesVisitor(VariableSizedHandleScope & hs)2429   explicit InitializeArrayClassesAndCreateConflictTablesVisitor(VariableSizedHandleScope& hs)
2430       : hs_(hs) {}
2431 
operator ()(ObjPtr<mirror::Class> klass)2432   virtual bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE
2433       REQUIRES_SHARED(Locks::mutator_lock_) {
2434     if (Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(klass)) {
2435       return true;
2436     }
2437     if (klass->IsArrayClass()) {
2438       StackHandleScope<1> hs(Thread::Current());
2439       auto h_klass = hs.NewHandleWrapper(&klass);
2440       Runtime::Current()->GetClassLinker()->EnsureInitialized(hs.Self(), h_klass, true, true);
2441     }
2442     // Collect handles since there may be thread suspension in future EnsureInitialized.
2443     to_visit_.push_back(hs_.NewHandle(klass));
2444     return true;
2445   }
2446 
FillAllIMTAndConflictTables()2447   void FillAllIMTAndConflictTables() REQUIRES_SHARED(Locks::mutator_lock_) {
2448     for (Handle<mirror::Class> c : to_visit_) {
2449       // Create the conflict tables.
2450       FillIMTAndConflictTables(c.Get());
2451     }
2452   }
2453 
2454  private:
FillIMTAndConflictTables(ObjPtr<mirror::Class> klass)2455   void FillIMTAndConflictTables(ObjPtr<mirror::Class> klass)
2456       REQUIRES_SHARED(Locks::mutator_lock_) {
2457     if (!klass->ShouldHaveImt()) {
2458       return;
2459     }
2460     if (visited_classes_.find(klass) != visited_classes_.end()) {
2461       return;
2462     }
2463     if (klass->HasSuperClass()) {
2464       FillIMTAndConflictTables(klass->GetSuperClass());
2465     }
2466     if (!klass->IsTemp()) {
2467       Runtime::Current()->GetClassLinker()->FillIMTAndConflictTables(klass);
2468     }
2469     visited_classes_.insert(klass);
2470   }
2471 
2472   VariableSizedHandleScope& hs_;
2473   std::vector<Handle<mirror::Class>> to_visit_;
2474   std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr> visited_classes_;
2475 };
2476 
InitializeClasses(jobject class_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)2477 void CompilerDriver::InitializeClasses(jobject class_loader,
2478                                        const std::vector<const DexFile*>& dex_files,
2479                                        TimingLogger* timings) {
2480   for (size_t i = 0; i != dex_files.size(); ++i) {
2481     const DexFile* dex_file = dex_files[i];
2482     CHECK(dex_file != nullptr);
2483     InitializeClasses(class_loader, *dex_file, dex_files, timings);
2484   }
2485   if (GetCompilerOptions().IsBootImage() || GetCompilerOptions().IsAppImage()) {
2486     // Make sure that we call EnsureIntiailized on all the array classes to call
2487     // SetVerificationAttempted so that the access flags are set. If we do not do this they get
2488     // changed at runtime resulting in more dirty image pages.
2489     // Also create conflict tables.
2490     // Only useful if we are compiling an image (image_classes_ is not null).
2491     ScopedObjectAccess soa(Thread::Current());
2492     VariableSizedHandleScope hs(soa.Self());
2493     InitializeArrayClassesAndCreateConflictTablesVisitor visitor(hs);
2494     Runtime::Current()->GetClassLinker()->VisitClassesWithoutClassesLock(&visitor);
2495     visitor.FillAllIMTAndConflictTables();
2496   }
2497   if (GetCompilerOptions().IsBootImage()) {
2498     // Prune garbage objects created during aborted transactions.
2499     Runtime::Current()->GetHeap()->CollectGarbage(true);
2500   }
2501 }
2502 
Compile(jobject class_loader,const std::vector<const DexFile * > & dex_files,TimingLogger * timings)2503 void CompilerDriver::Compile(jobject class_loader,
2504                              const std::vector<const DexFile*>& dex_files,
2505                              TimingLogger* timings) {
2506   if (kDebugProfileGuidedCompilation) {
2507     LOG(INFO) << "[ProfileGuidedCompilation] " <<
2508         ((profile_compilation_info_ == nullptr)
2509             ? "null"
2510             : profile_compilation_info_->DumpInfo(&dex_files));
2511   }
2512 
2513   DCHECK(current_dex_to_dex_methods_ == nullptr);
2514   for (const DexFile* dex_file : dex_files) {
2515     CHECK(dex_file != nullptr);
2516     CompileDexFile(class_loader,
2517                    *dex_file,
2518                    dex_files,
2519                    parallel_thread_pool_.get(),
2520                    parallel_thread_count_,
2521                    timings);
2522     const ArenaPool* const arena_pool = Runtime::Current()->GetArenaPool();
2523     const size_t arena_alloc = arena_pool->GetBytesAllocated();
2524     max_arena_alloc_ = std::max(arena_alloc, max_arena_alloc_);
2525     Runtime::Current()->ReclaimArenaPoolMemory();
2526   }
2527 
2528   ArrayRef<DexFileMethodSet> dex_to_dex_references;
2529   {
2530     // From this point on, we shall not modify dex_to_dex_references_, so
2531     // just grab a reference to it that we use without holding the mutex.
2532     MutexLock lock(Thread::Current(), dex_to_dex_references_lock_);
2533     dex_to_dex_references = ArrayRef<DexFileMethodSet>(dex_to_dex_references_);
2534   }
2535   for (const auto& method_set : dex_to_dex_references) {
2536     current_dex_to_dex_methods_ = &method_set.GetMethodIndexes();
2537     CompileDexFile(class_loader,
2538                    method_set.GetDexFile(),
2539                    dex_files,
2540                    parallel_thread_pool_.get(),
2541                    parallel_thread_count_,
2542                    timings);
2543   }
2544   current_dex_to_dex_methods_ = nullptr;
2545 
2546   VLOG(compiler) << "Compile: " << GetMemoryUsageString(false);
2547 }
2548 
2549 class CompileClassVisitor : public CompilationVisitor {
2550  public:
CompileClassVisitor(const ParallelCompilationManager * manager)2551   explicit CompileClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {}
2552 
Visit(size_t class_def_index)2553   virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE {
2554     ATRACE_CALL();
2555     const DexFile& dex_file = *manager_->GetDexFile();
2556     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
2557     ClassLinker* class_linker = manager_->GetClassLinker();
2558     jobject jclass_loader = manager_->GetClassLoader();
2559     ClassReference ref(&dex_file, class_def_index);
2560     // Skip compiling classes with generic verifier failures since they will still fail at runtime
2561     if (manager_->GetCompiler()->verification_results_->IsClassRejected(ref)) {
2562       return;
2563     }
2564     // Use a scoped object access to perform to the quick SkipClass check.
2565     const char* descriptor = dex_file.GetClassDescriptor(class_def);
2566     ScopedObjectAccess soa(Thread::Current());
2567     StackHandleScope<3> hs(soa.Self());
2568     Handle<mirror::ClassLoader> class_loader(
2569         hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
2570     Handle<mirror::Class> klass(
2571         hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader)));
2572     Handle<mirror::DexCache> dex_cache;
2573     if (klass == nullptr) {
2574       soa.Self()->AssertPendingException();
2575       soa.Self()->ClearException();
2576       dex_cache = hs.NewHandle(class_linker->FindDexCache(soa.Self(), dex_file));
2577     } else if (SkipClass(jclass_loader, dex_file, klass.Get())) {
2578       return;
2579     } else {
2580       dex_cache = hs.NewHandle(klass->GetDexCache());
2581     }
2582 
2583     const uint8_t* class_data = dex_file.GetClassData(class_def);
2584     if (class_data == nullptr) {
2585       // empty class, probably a marker interface
2586       return;
2587     }
2588 
2589     // Go to native so that we don't block GC during compilation.
2590     ScopedThreadSuspension sts(soa.Self(), kNative);
2591 
2592     CompilerDriver* const driver = manager_->GetCompiler();
2593 
2594     // Can we run DEX-to-DEX compiler on this class ?
2595     optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level =
2596         GetDexToDexCompilationLevel(soa.Self(), *driver, jclass_loader, dex_file, class_def);
2597 
2598     ClassDataItemIterator it(dex_file, class_data);
2599     // Skip fields
2600     while (it.HasNextStaticField()) {
2601       it.Next();
2602     }
2603     while (it.HasNextInstanceField()) {
2604       it.Next();
2605     }
2606 
2607     bool compilation_enabled = driver->IsClassToCompile(
2608         dex_file.StringByTypeIdx(class_def.class_idx_));
2609 
2610     // Compile direct methods
2611     int64_t previous_direct_method_idx = -1;
2612     while (it.HasNextDirectMethod()) {
2613       uint32_t method_idx = it.GetMemberIndex();
2614       if (method_idx == previous_direct_method_idx) {
2615         // smali can create dex files with two encoded_methods sharing the same method_idx
2616         // http://code.google.com/p/smali/issues/detail?id=119
2617         it.Next();
2618         continue;
2619       }
2620       previous_direct_method_idx = method_idx;
2621       CompileMethod(soa.Self(),
2622                     driver,
2623                     it.GetMethodCodeItem(),
2624                     it.GetMethodAccessFlags(),
2625                     it.GetMethodInvokeType(class_def),
2626                     class_def_index,
2627                     method_idx,
2628                     class_loader,
2629                     dex_file,
2630                     dex_to_dex_compilation_level,
2631                     compilation_enabled,
2632                     dex_cache);
2633       it.Next();
2634     }
2635     // Compile virtual methods
2636     int64_t previous_virtual_method_idx = -1;
2637     while (it.HasNextVirtualMethod()) {
2638       uint32_t method_idx = it.GetMemberIndex();
2639       if (method_idx == previous_virtual_method_idx) {
2640         // smali can create dex files with two encoded_methods sharing the same method_idx
2641         // http://code.google.com/p/smali/issues/detail?id=119
2642         it.Next();
2643         continue;
2644       }
2645       previous_virtual_method_idx = method_idx;
2646       CompileMethod(soa.Self(),
2647                     driver, it.GetMethodCodeItem(),
2648                     it.GetMethodAccessFlags(),
2649                     it.GetMethodInvokeType(class_def),
2650                     class_def_index,
2651                     method_idx,
2652                     class_loader,
2653                     dex_file,
2654                     dex_to_dex_compilation_level,
2655                     compilation_enabled,
2656                     dex_cache);
2657       it.Next();
2658     }
2659     DCHECK(!it.HasNext());
2660   }
2661 
2662  private:
2663   const ParallelCompilationManager* const manager_;
2664 };
2665 
CompileDexFile(jobject class_loader,const DexFile & dex_file,const std::vector<const DexFile * > & dex_files,ThreadPool * thread_pool,size_t thread_count,TimingLogger * timings)2666 void CompilerDriver::CompileDexFile(jobject class_loader,
2667                                     const DexFile& dex_file,
2668                                     const std::vector<const DexFile*>& dex_files,
2669                                     ThreadPool* thread_pool,
2670                                     size_t thread_count,
2671                                     TimingLogger* timings) {
2672   TimingLogger::ScopedTiming t("Compile Dex File", timings);
2673   ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this,
2674                                      &dex_file, dex_files, thread_pool);
2675   CompileClassVisitor visitor(&context);
2676   context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count);
2677 }
2678 
AddCompiledMethod(const MethodReference & method_ref,CompiledMethod * const compiled_method,size_t non_relative_linker_patch_count)2679 void CompilerDriver::AddCompiledMethod(const MethodReference& method_ref,
2680                                        CompiledMethod* const compiled_method,
2681                                        size_t non_relative_linker_patch_count) {
2682   DCHECK(GetCompiledMethod(method_ref) == nullptr)
2683       << method_ref.dex_file->PrettyMethod(method_ref.dex_method_index);
2684   MethodTable::InsertResult result = compiled_methods_.Insert(method_ref,
2685                                                               /*expected*/ nullptr,
2686                                                               compiled_method);
2687   CHECK(result == MethodTable::kInsertResultSuccess);
2688   non_relative_linker_patch_count_.FetchAndAddRelaxed(non_relative_linker_patch_count);
2689   DCHECK(GetCompiledMethod(method_ref) != nullptr)
2690       << method_ref.dex_file->PrettyMethod(method_ref.dex_method_index);
2691 }
2692 
GetCompiledClass(ClassReference ref) const2693 CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
2694   MutexLock mu(Thread::Current(), compiled_classes_lock_);
2695   ClassTable::const_iterator it = compiled_classes_.find(ref);
2696   if (it == compiled_classes_.end()) {
2697     return nullptr;
2698   }
2699   CHECK(it->second != nullptr);
2700   return it->second;
2701 }
2702 
RecordClassStatus(ClassReference ref,mirror::Class::Status status)2703 void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) {
2704   switch (status) {
2705     case mirror::Class::kStatusNotReady:
2706     case mirror::Class::kStatusErrorResolved:
2707     case mirror::Class::kStatusErrorUnresolved:
2708     case mirror::Class::kStatusRetryVerificationAtRuntime:
2709     case mirror::Class::kStatusVerified:
2710     case mirror::Class::kStatusInitialized:
2711     case mirror::Class::kStatusResolved:
2712       break;  // Expected states.
2713     default:
2714       LOG(FATAL) << "Unexpected class status for class "
2715           << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second)))
2716           << " of " << status;
2717   }
2718 
2719   MutexLock mu(Thread::Current(), compiled_classes_lock_);
2720   auto it = compiled_classes_.find(ref);
2721   if (it == compiled_classes_.end()) {
2722     CompiledClass* compiled_class = new CompiledClass(status);
2723     compiled_classes_.Overwrite(ref, compiled_class);
2724   } else if (status > it->second->GetStatus()) {
2725     // Update the status if we now have a greater one. This happens with vdex,
2726     // which records a class is verified, but does not resolve it.
2727     it->second->SetStatus(status);
2728   }
2729 }
2730 
GetCompiledMethod(MethodReference ref) const2731 CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
2732   CompiledMethod* compiled_method = nullptr;
2733   compiled_methods_.Get(ref, &compiled_method);
2734   return compiled_method;
2735 }
2736 
IsMethodVerifiedWithoutFailures(uint32_t method_idx,uint16_t class_def_idx,const DexFile & dex_file) const2737 bool CompilerDriver::IsMethodVerifiedWithoutFailures(uint32_t method_idx,
2738                                                      uint16_t class_def_idx,
2739                                                      const DexFile& dex_file) const {
2740   const VerifiedMethod* verified_method = GetVerifiedMethod(&dex_file, method_idx);
2741   if (verified_method != nullptr) {
2742     return !verified_method->HasVerificationFailures();
2743   }
2744 
2745   // If we can't find verification metadata, check if this is a system class (we trust that system
2746   // classes have their methods verified). If it's not, be conservative and assume the method
2747   // has not been verified successfully.
2748 
2749   // TODO: When compiling the boot image it should be safe to assume that everything is verified,
2750   // even if methods are not found in the verification cache.
2751   const char* descriptor = dex_file.GetClassDescriptor(dex_file.GetClassDef(class_def_idx));
2752   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2753   Thread* self = Thread::Current();
2754   ScopedObjectAccess soa(self);
2755   bool is_system_class = class_linker->FindSystemClass(self, descriptor) != nullptr;
2756   if (!is_system_class) {
2757     self->ClearException();
2758   }
2759   return is_system_class;
2760 }
2761 
GetNonRelativeLinkerPatchCount() const2762 size_t CompilerDriver::GetNonRelativeLinkerPatchCount() const {
2763   return non_relative_linker_patch_count_.LoadRelaxed();
2764 }
2765 
SetRequiresConstructorBarrier(Thread * self,const DexFile * dex_file,uint16_t class_def_index,bool requires)2766 void CompilerDriver::SetRequiresConstructorBarrier(Thread* self,
2767                                                    const DexFile* dex_file,
2768                                                    uint16_t class_def_index,
2769                                                    bool requires) {
2770   WriterMutexLock mu(self, requires_constructor_barrier_lock_);
2771   requires_constructor_barrier_.emplace(ClassReference(dex_file, class_def_index), requires);
2772 }
2773 
RequiresConstructorBarrier(Thread * self,const DexFile * dex_file,uint16_t class_def_index)2774 bool CompilerDriver::RequiresConstructorBarrier(Thread* self,
2775                                                 const DexFile* dex_file,
2776                                                 uint16_t class_def_index) {
2777   ClassReference class_ref(dex_file, class_def_index);
2778   {
2779     ReaderMutexLock mu(self, requires_constructor_barrier_lock_);
2780     auto it = requires_constructor_barrier_.find(class_ref);
2781     if (it != requires_constructor_barrier_.end()) {
2782       return it->second;
2783     }
2784   }
2785   WriterMutexLock mu(self, requires_constructor_barrier_lock_);
2786   const bool requires = RequiresConstructorBarrier(*dex_file, class_def_index);
2787   requires_constructor_barrier_.emplace(class_ref, requires);
2788   return requires;
2789 }
2790 
GetMemoryUsageString(bool extended) const2791 std::string CompilerDriver::GetMemoryUsageString(bool extended) const {
2792   std::ostringstream oss;
2793   const gc::Heap* const heap = Runtime::Current()->GetHeap();
2794   const size_t java_alloc = heap->GetBytesAllocated();
2795   oss << "arena alloc=" << PrettySize(max_arena_alloc_) << " (" << max_arena_alloc_ << "B)";
2796   oss << " java alloc=" << PrettySize(java_alloc) << " (" << java_alloc << "B)";
2797 #if defined(__BIONIC__) || defined(__GLIBC__)
2798   const struct mallinfo info = mallinfo();
2799   const size_t allocated_space = static_cast<size_t>(info.uordblks);
2800   const size_t free_space = static_cast<size_t>(info.fordblks);
2801   oss << " native alloc=" << PrettySize(allocated_space) << " (" << allocated_space << "B)"
2802       << " free=" << PrettySize(free_space) << " (" << free_space << "B)";
2803 #endif
2804   compiled_method_storage_.DumpMemoryUsage(oss, extended);
2805   return oss.str();
2806 }
2807 
MayInlineInternal(const DexFile * inlined_from,const DexFile * inlined_into) const2808 bool CompilerDriver::MayInlineInternal(const DexFile* inlined_from,
2809                                        const DexFile* inlined_into) const {
2810   // We're not allowed to inline across dex files if we're the no-inline-from dex file.
2811   if (inlined_from != inlined_into &&
2812       compiler_options_->GetNoInlineFromDexFile() != nullptr &&
2813       ContainsElement(*compiler_options_->GetNoInlineFromDexFile(), inlined_from)) {
2814     return false;
2815   }
2816 
2817   return true;
2818 }
2819 
InitializeThreadPools()2820 void CompilerDriver::InitializeThreadPools() {
2821   size_t parallel_count = parallel_thread_count_ > 0 ? parallel_thread_count_ - 1 : 0;
2822   parallel_thread_pool_.reset(
2823       new ThreadPool("Compiler driver thread pool", parallel_count));
2824   single_thread_pool_.reset(new ThreadPool("Single-threaded Compiler driver thread pool", 0));
2825 }
2826 
FreeThreadPools()2827 void CompilerDriver::FreeThreadPools() {
2828   parallel_thread_pool_.reset();
2829   single_thread_pool_.reset();
2830 }
2831 
2832 }  // namespace art
2833