compiler_driver.cc revision 8f20ff4354fd3fdd7604a299b7bf4446e5f4584c 
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 <vector>
20
21#include <unistd.h>
22
23#include "base/stl_util.h"
24#include "base/timing_logger.h"
25#include "class_linker.h"
26#include "dex_compilation_unit.h"
27#include "dex_file-inl.h"
28#include "jni_internal.h"
29#include "object_utils.h"
30#include "runtime.h"
31#include "gc/accounting/card_table-inl.h"
32#include "gc/accounting/heap_bitmap.h"
33#include "gc/space/space.h"
34#include "mirror/class_loader.h"
35#include "mirror/class-inl.h"
36#include "mirror/dex_cache-inl.h"
37#include "mirror/field-inl.h"
38#include "mirror/abstract_method-inl.h"
39#include "mirror/object-inl.h"
40#include "mirror/object_array-inl.h"
41#include "mirror/throwable.h"
42#include "scoped_thread_state_change.h"
43#include "ScopedLocalRef.h"
44#include "stubs/stubs.h"
45#include "thread.h"
46#include "thread_pool.h"
47#include "verifier/method_verifier.h"
48
49#if defined(ART_USE_PORTABLE_COMPILER)
50#include "elf_writer_mclinker.h"
51#else
52#include "elf_writer_quick.h"
53#endif
54
55namespace art {
56
57static double Percentage(size_t x, size_t y) {
58  return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
59}
60
61static void DumpStat(size_t x, size_t y, const char* str) {
62  if (x == 0 && y == 0) {
63    return;
64  }
65  LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
66}
67
68class AOTCompilationStats {
69 public:
70  AOTCompilationStats()
71      : stats_lock_("AOT compilation statistics lock"),
72        types_in_dex_cache_(0), types_not_in_dex_cache_(0),
73        strings_in_dex_cache_(0), strings_not_in_dex_cache_(0),
74        resolved_types_(0), unresolved_types_(0),
75        resolved_instance_fields_(0), unresolved_instance_fields_(0),
76        resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0),
77        type_based_devirtualization_(0),
78        safe_casts_(0), not_safe_casts_(0) {
79    for (size_t i = 0; i <= kMaxInvokeType; i++) {
80      resolved_methods_[i] = 0;
81      unresolved_methods_[i] = 0;
82      virtual_made_direct_[i] = 0;
83      direct_calls_to_boot_[i] = 0;
84      direct_methods_to_boot_[i] = 0;
85    }
86  }
87
88  void Dump() {
89    DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache");
90    DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache");
91    DumpStat(resolved_types_, unresolved_types_, "types resolved");
92    DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
93    DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
94             "static fields resolved");
95    DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
96             "static fields local to a class");
97    DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information");
98    // Note, the code below subtracts the stat value so that when added to the stat value we have
99    // 100% of samples. TODO: clean this up.
100    DumpStat(type_based_devirtualization_,
101             resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] +
102             resolved_methods_[kInterface] + unresolved_methods_[kInterface] -
103             type_based_devirtualization_,
104             "virtual/interface calls made direct based on type information");
105
106    for (size_t i = 0; i <= kMaxInvokeType; i++) {
107      std::ostringstream oss;
108      oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
109      DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
110      if (virtual_made_direct_[i] > 0) {
111        std::ostringstream oss2;
112        oss2 << static_cast<InvokeType>(i) << " methods made direct";
113        DumpStat(virtual_made_direct_[i],
114                 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
115                 oss2.str().c_str());
116      }
117      if (direct_calls_to_boot_[i] > 0) {
118        std::ostringstream oss2;
119        oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
120        DumpStat(direct_calls_to_boot_[i],
121                 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
122                 oss2.str().c_str());
123      }
124      if (direct_methods_to_boot_[i] > 0) {
125        std::ostringstream oss2;
126        oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
127        DumpStat(direct_methods_to_boot_[i],
128                 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
129                 oss2.str().c_str());
130      }
131    }
132  }
133
134// Allow lossy statistics in non-debug builds.
135#ifndef NDEBUG
136#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
137#else
138#define STATS_LOCK()
139#endif
140
141  void TypeInDexCache() {
142    STATS_LOCK();
143    types_in_dex_cache_++;
144  }
145
146  void TypeNotInDexCache() {
147    STATS_LOCK();
148    types_not_in_dex_cache_++;
149  }
150
151  void StringInDexCache() {
152    STATS_LOCK();
153    strings_in_dex_cache_++;
154  }
155
156  void StringNotInDexCache() {
157    STATS_LOCK();
158    strings_not_in_dex_cache_++;
159  }
160
161  void TypeDoesntNeedAccessCheck() {
162    STATS_LOCK();
163    resolved_types_++;
164  }
165
166  void TypeNeedsAccessCheck() {
167    STATS_LOCK();
168    unresolved_types_++;
169  }
170
171  void ResolvedInstanceField() {
172    STATS_LOCK();
173    resolved_instance_fields_++;
174  }
175
176  void UnresolvedInstanceField() {
177    STATS_LOCK();
178    unresolved_instance_fields_++;
179  }
180
181  void ResolvedLocalStaticField() {
182    STATS_LOCK();
183    resolved_local_static_fields_++;
184  }
185
186  void ResolvedStaticField() {
187    STATS_LOCK();
188    resolved_static_fields_++;
189  }
190
191  void UnresolvedStaticField() {
192    STATS_LOCK();
193    unresolved_static_fields_++;
194  }
195
196  // Indicate that type information from the verifier led to devirtualization.
197  void PreciseTypeDevirtualization() {
198    STATS_LOCK();
199    type_based_devirtualization_++;
200  }
201
202  // Indicate that a method of the given type was resolved at compile time.
203  void ResolvedMethod(InvokeType type) {
204    DCHECK_LE(type, kMaxInvokeType);
205    STATS_LOCK();
206    resolved_methods_[type]++;
207  }
208
209  // Indicate that a method of the given type was unresolved at compile time as it was in an
210  // unknown dex file.
211  void UnresolvedMethod(InvokeType type) {
212    DCHECK_LE(type, kMaxInvokeType);
213    STATS_LOCK();
214    unresolved_methods_[type]++;
215  }
216
217  // Indicate that a type of virtual method dispatch has been converted into a direct method
218  // dispatch.
219  void VirtualMadeDirect(InvokeType type) {
220    DCHECK(type == kVirtual || type == kInterface || type == kSuper);
221    STATS_LOCK();
222    virtual_made_direct_[type]++;
223  }
224
225  // Indicate that a method of the given type was able to call directly into boot.
226  void DirectCallsToBoot(InvokeType type) {
227    DCHECK_LE(type, kMaxInvokeType);
228    STATS_LOCK();
229    direct_calls_to_boot_[type]++;
230  }
231
232  // Indicate that a method of the given type was able to be resolved directly from boot.
233  void DirectMethodsToBoot(InvokeType type) {
234    DCHECK_LE(type, kMaxInvokeType);
235    STATS_LOCK();
236    direct_methods_to_boot_[type]++;
237  }
238
239  // A check-cast could be eliminated due to verifier type analysis.
240  void SafeCast() {
241    STATS_LOCK();
242    safe_casts_++;
243  }
244
245  // A check-cast couldn't be eliminated due to verifier type analysis.
246  void NotASafeCast() {
247    STATS_LOCK();
248    not_safe_casts_++;
249  }
250
251 private:
252  Mutex stats_lock_;
253
254  size_t types_in_dex_cache_;
255  size_t types_not_in_dex_cache_;
256
257  size_t strings_in_dex_cache_;
258  size_t strings_not_in_dex_cache_;
259
260  size_t resolved_types_;
261  size_t unresolved_types_;
262
263  size_t resolved_instance_fields_;
264  size_t unresolved_instance_fields_;
265
266  size_t resolved_local_static_fields_;
267  size_t resolved_static_fields_;
268  size_t unresolved_static_fields_;
269  // Type based devirtualization for invoke interface and virtual.
270  size_t type_based_devirtualization_;
271
272  size_t resolved_methods_[kMaxInvokeType + 1];
273  size_t unresolved_methods_[kMaxInvokeType + 1];
274  size_t virtual_made_direct_[kMaxInvokeType + 1];
275  size_t direct_calls_to_boot_[kMaxInvokeType + 1];
276  size_t direct_methods_to_boot_[kMaxInvokeType + 1];
277
278  size_t safe_casts_;
279  size_t not_safe_casts_;
280
281  DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
282};
283
284extern "C" void ArtInitCompilerContext(art::CompilerDriver& driver);
285extern "C" void ArtInitQuickCompilerContext(art::CompilerDriver& compiler);
286
287extern "C" void ArtUnInitCompilerContext(art::CompilerDriver& driver);
288extern "C" void ArtUnInitQuickCompilerContext(art::CompilerDriver& compiler);
289
290extern "C" art::CompiledMethod* ArtCompileMethod(art::CompilerDriver& driver,
291                                                 const art::DexFile::CodeItem* code_item,
292                                                 uint32_t access_flags,
293                                                 art::InvokeType invoke_type,
294                                                 uint32_t class_def_idx,
295                                                 uint32_t method_idx,
296                                                 jobject class_loader,
297                                                 const art::DexFile& dex_file);
298extern "C" art::CompiledMethod* ArtQuickCompileMethod(art::CompilerDriver& compiler,
299                                                      const art::DexFile::CodeItem* code_item,
300                                                      uint32_t access_flags,
301                                                      art::InvokeType invoke_type,
302                                                      uint32_t class_def_idx,
303                                                      uint32_t method_idx,
304                                                      jobject class_loader,
305                                                      const art::DexFile& dex_file);
306
307extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler,
308                                              const art::DexFile::CodeItem* code_item,
309                                              uint32_t access_flags,
310                                              art::InvokeType invoke_type,
311                                              uint32_t class_def_idx,
312                                              uint32_t method_idx,
313                                              jobject class_loader,
314                                              const art::DexFile& dex_file);
315
316extern "C" art::CompiledMethod* SeaIrCompileMethod(art::CompilerDriver& compiler,
317                                                   const art::DexFile::CodeItem* code_item,
318                                                   uint32_t access_flags,
319                                                   art::InvokeType invoke_type,
320                                                   uint32_t class_def_idx,
321                                                   uint32_t method_idx,
322                                                   jobject class_loader,
323                                                   const art::DexFile& dex_file);
324
325extern "C" art::CompiledMethod* ArtLLVMJniCompileMethod(art::CompilerDriver& driver,
326                                                        uint32_t access_flags, uint32_t method_idx,
327                                                        const art::DexFile& dex_file);
328
329extern "C" art::CompiledMethod* ArtQuickJniCompileMethod(art::CompilerDriver& compiler,
330                                                         uint32_t access_flags, uint32_t method_idx,
331                                                         const art::DexFile& dex_file);
332
333extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
334                                               std::string const& filename);
335
336CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
337                               bool image, DescriptorSet* image_classes,
338                               size_t thread_count, bool dump_stats)
339    : compiler_backend_(compiler_backend),
340      instruction_set_(instruction_set),
341      freezing_constructor_lock_("freezing constructor lock"),
342      compiled_classes_lock_("compiled classes lock"),
343      compiled_methods_lock_("compiled method lock"),
344      image_(image),
345      image_classes_(image_classes),
346      thread_count_(thread_count),
347      start_ns_(0),
348      stats_(new AOTCompilationStats),
349      dump_stats_(dump_stats),
350      compiler_library_(NULL),
351      compiler_(NULL),
352      compiler_context_(NULL),
353      jni_compiler_(NULL),
354      compiler_enable_auto_elf_loading_(NULL),
355      compiler_get_method_code_addr_(NULL),
356      support_boot_image_fixup_(true) {
357
358  CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key");
359
360  // TODO: more work needed to combine initializations and allow per-method backend selection
361  typedef void (*InitCompilerContextFn)(CompilerDriver&);
362  InitCompilerContextFn init_compiler_context;
363  if (compiler_backend_ == kPortable) {
364    // Initialize compiler_context_
365    init_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtInitCompilerContext);
366    compiler_ = reinterpret_cast<CompilerFn>(ArtCompileMethod);
367  } else {
368    init_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtInitQuickCompilerContext);
369    compiler_ = reinterpret_cast<CompilerFn>(ArtQuickCompileMethod);
370  }
371
372  dex_to_dex_compiler_ = reinterpret_cast<CompilerFn>(ArtCompileDEX);
373
374#ifdef ART_SEA_IR_MODE
375  sea_ir_compiler_ = NULL;
376  if (Runtime::Current()->IsSeaIRMode()) {
377    sea_ir_compiler_ = reinterpret_cast<CompilerFn>(SeaIrCompileMethod);
378  }
379#endif
380
381  init_compiler_context(*this);
382
383  if (compiler_backend_ == kPortable) {
384    jni_compiler_ = reinterpret_cast<JniCompilerFn>(ArtLLVMJniCompileMethod);
385  } else {
386    jni_compiler_ = reinterpret_cast<JniCompilerFn>(ArtQuickJniCompileMethod);
387  }
388
389  CHECK(!Runtime::Current()->IsStarted());
390  if (!image_) {
391    CHECK(image_classes_.get() == NULL);
392  }
393}
394
395CompilerDriver::~CompilerDriver() {
396  Thread* self = Thread::Current();
397  {
398    MutexLock mu(self, compiled_classes_lock_);
399    STLDeleteValues(&compiled_classes_);
400  }
401  {
402    MutexLock mu(self, compiled_methods_lock_);
403    STLDeleteValues(&compiled_methods_);
404  }
405  {
406    MutexLock mu(self, compiled_methods_lock_);
407    STLDeleteElements(&code_to_patch_);
408  }
409  {
410    MutexLock mu(self, compiled_methods_lock_);
411    STLDeleteElements(&methods_to_patch_);
412  }
413  CHECK_PTHREAD_CALL(pthread_key_delete, (tls_key_), "delete tls key");
414  typedef void (*UninitCompilerContextFn)(CompilerDriver&);
415  UninitCompilerContextFn uninit_compiler_context;
416  // Uninitialize compiler_context_
417  // TODO: rework to combine initialization/uninitialization
418  if (compiler_backend_ == kPortable) {
419    uninit_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtUnInitCompilerContext);
420  } else {
421    uninit_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtUnInitQuickCompilerContext);
422  }
423  uninit_compiler_context(*this);
424}
425
426CompilerTls* CompilerDriver::GetTls() {
427  // Lazily create thread-local storage
428  CompilerTls* res = static_cast<CompilerTls*>(pthread_getspecific(tls_key_));
429  if (res == NULL) {
430    res = new CompilerTls();
431    CHECK_PTHREAD_CALL(pthread_setspecific, (tls_key_, res), "compiler tls");
432  }
433  return res;
434}
435
436const std::vector<uint8_t>* CompilerDriver::CreatePortableResolutionTrampoline() const {
437  switch (instruction_set_) {
438    case kArm:
439    case kThumb2:
440      return arm::CreatePortableResolutionTrampoline();
441    case kMips:
442      return mips::CreatePortableResolutionTrampoline();
443    case kX86:
444      return x86::CreatePortableResolutionTrampoline();
445    default:
446      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
447      return NULL;
448  }
449}
450
451const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const {
452  switch (instruction_set_) {
453    case kArm:
454    case kThumb2:
455      return arm::CreateQuickResolutionTrampoline();
456    case kMips:
457      return mips::CreateQuickResolutionTrampoline();
458    case kX86:
459      return x86::CreateQuickResolutionTrampoline();
460    default:
461      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
462      return NULL;
463  }
464}
465
466const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterEntry() const {
467  switch (instruction_set_) {
468    case kArm:
469    case kThumb2:
470      return arm::CreateInterpreterToInterpreterEntry();
471    case kMips:
472      return mips::CreateInterpreterToInterpreterEntry();
473    case kX86:
474      return x86::CreateInterpreterToInterpreterEntry();
475    default:
476      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
477      return NULL;
478  }
479}
480
481const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToQuickEntry() const {
482  switch (instruction_set_) {
483    case kArm:
484    case kThumb2:
485      return arm::CreateInterpreterToQuickEntry();
486    case kMips:
487      return mips::CreateInterpreterToQuickEntry();
488    case kX86:
489      return x86::CreateInterpreterToQuickEntry();
490    default:
491      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
492      return NULL;
493  }
494}
495
496void CompilerDriver::CompileAll(jobject class_loader,
497                                const std::vector<const DexFile*>& dex_files,
498                                TimingLogger& timings) {
499  DCHECK(!Runtime::Current()->IsStarted());
500  UniquePtr<ThreadPool> thread_pool(new ThreadPool(thread_count_));
501  PreCompile(class_loader, dex_files, *thread_pool.get(), timings);
502  Compile(class_loader, dex_files, *thread_pool.get(), timings);
503  if (dump_stats_) {
504    stats_->Dump();
505  }
506}
507
508static bool IsDexToDexCompilationAllowed(mirror::ClassLoader* class_loader,
509                                         const DexFile& dex_file,
510                                         const DexFile::ClassDef& class_def)
511    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
512  // Do not allow DEX-to-DEX compilation of image classes. This is to prevent the
513  // verifier from passing on "quick" instruction at compilation time. It must
514  // only pass on quick instructions at runtime.
515  if (class_loader == NULL) {
516    return false;
517  }
518  const char* descriptor = dex_file.GetClassDescriptor(class_def);
519  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
520  mirror::Class* klass = class_linker->FindClass(descriptor, class_loader);
521  if (klass == NULL) {
522    Thread* self = Thread::Current();
523    CHECK(self->IsExceptionPending());
524    self->ClearException();
525    return false;
526  }
527  // DEX-to-DEX compilation is only allowed on preverified classes.
528  return klass->IsVerified();
529}
530
531void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, TimingLogger& timings) {
532  DCHECK(!Runtime::Current()->IsStarted());
533  Thread* self = Thread::Current();
534  jobject jclass_loader;
535  const DexFile* dex_file;
536  uint32_t class_def_idx;
537  {
538    ScopedObjectAccessUnchecked soa(self);
539    ScopedLocalRef<jobject>
540      local_class_loader(soa.Env(),
541                    soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader()));
542    jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
543    // Find the dex_file
544    MethodHelper mh(method);
545    dex_file = &mh.GetDexFile();
546    class_def_idx = mh.GetClassDefIndex();
547  }
548  self->TransitionFromRunnableToSuspended(kNative);
549
550  std::vector<const DexFile*> dex_files;
551  dex_files.push_back(dex_file);
552
553  UniquePtr<ThreadPool> thread_pool(new ThreadPool(1U));
554  PreCompile(jclass_loader, dex_files, *thread_pool.get(), timings);
555
556  uint32_t method_idx = method->GetDexMethodIndex();
557  const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
558  // Can we run DEX-to-DEX compiler on this class ?
559  bool allow_dex_compilation;
560  {
561    ScopedObjectAccess soa(Thread::Current());
562    const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx);
563    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
564    allow_dex_compilation = IsDexToDexCompilationAllowed(class_loader, *dex_file, class_def);
565  }
566  CompileMethod(code_item, method->GetAccessFlags(), method->GetInvokeType(),
567                class_def_idx, method_idx, jclass_loader, *dex_file, allow_dex_compilation);
568
569  self->GetJniEnv()->DeleteGlobalRef(jclass_loader);
570
571  self->TransitionFromSuspendedToRunnable();
572}
573
574void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
575                             ThreadPool& thread_pool, TimingLogger& timings) {
576  for (size_t i = 0; i != dex_files.size(); ++i) {
577    const DexFile* dex_file = dex_files[i];
578    CHECK(dex_file != NULL);
579    ResolveDexFile(class_loader, *dex_file, thread_pool, timings);
580  }
581}
582
583void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
584                                ThreadPool& thread_pool, TimingLogger& timings) {
585  LoadImageClasses(timings);
586
587  Resolve(class_loader, dex_files, thread_pool, timings);
588
589  Verify(class_loader, dex_files, thread_pool, timings);
590
591  InitializeClasses(class_loader, dex_files, thread_pool, timings);
592
593  UpdateImageClasses(timings);
594}
595
596bool CompilerDriver::IsImageClass(const char* descriptor) const {
597  DCHECK(descriptor != NULL);
598  if (image_classes_.get() == NULL) {
599    return true;
600  }
601  return image_classes_->find(descriptor) != image_classes_->end();
602}
603
604static void ResolveExceptionsForMethod(MethodHelper* mh,
605    std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve)
606    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
607  const DexFile::CodeItem* code_item = mh->GetCodeItem();
608  if (code_item == NULL) {
609    return;  // native or abstract method
610  }
611  if (code_item->tries_size_ == 0) {
612    return;  // nothing to process
613  }
614  const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0);
615  size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list);
616  for (size_t i = 0; i < num_encoded_catch_handlers; i++) {
617    int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list);
618    bool has_catch_all = false;
619    if (encoded_catch_handler_size <= 0) {
620      encoded_catch_handler_size = -encoded_catch_handler_size;
621      has_catch_all = true;
622    }
623    for (int32_t j = 0; j < encoded_catch_handler_size; j++) {
624      uint16_t encoded_catch_handler_handlers_type_idx =
625          DecodeUnsignedLeb128(&encoded_catch_handler_list);
626      // Add to set of types to resolve if not already in the dex cache resolved types
627      if (!mh->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) {
628        exceptions_to_resolve.insert(
629            std::pair<uint16_t, const DexFile*>(encoded_catch_handler_handlers_type_idx,
630                                                &mh->GetDexFile()));
631      }
632      // ignore address associated with catch handler
633      DecodeUnsignedLeb128(&encoded_catch_handler_list);
634    }
635    if (has_catch_all) {
636      // ignore catch all address
637      DecodeUnsignedLeb128(&encoded_catch_handler_list);
638    }
639  }
640}
641
642static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg)
643    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
644  std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve =
645      reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
646  MethodHelper mh;
647  for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
648    mirror::AbstractMethod* m = c->GetVirtualMethod(i);
649    mh.ChangeMethod(m);
650    ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
651  }
652  for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
653    mirror::AbstractMethod* m = c->GetDirectMethod(i);
654    mh.ChangeMethod(m);
655    ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
656  }
657  return true;
658}
659
660static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg)
661    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
662  CompilerDriver::DescriptorSet* image_classes =
663      reinterpret_cast<CompilerDriver::DescriptorSet*>(arg);
664  image_classes->insert(ClassHelper(klass).GetDescriptor());
665  return true;
666}
667
668// Make a list of descriptors for classes to include in the image
669void CompilerDriver::LoadImageClasses(TimingLogger& timings)
670      LOCKS_EXCLUDED(Locks::mutator_lock_) {
671  if (image_classes_.get() == NULL) {
672    return;
673  }
674
675  // Make a first class to load all classes explicitly listed in the file
676  Thread* self = Thread::Current();
677  ScopedObjectAccess soa(self);
678  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
679  typedef DescriptorSet::iterator It;  // TODO: C++0x auto
680  for (It it = image_classes_->begin(), end = image_classes_->end(); it != end;) {
681    std::string descriptor(*it);
682    SirtRef<mirror::Class> klass(self, class_linker->FindSystemClass(descriptor.c_str()));
683    if (klass.get() == NULL) {
684      image_classes_->erase(it++);
685      LOG(WARNING) << "Failed to find class " << descriptor;
686      Thread::Current()->ClearException();
687    } else {
688      ++it;
689    }
690  }
691
692  // Resolve exception classes referenced by the loaded classes. The catch logic assumes
693  // exceptions are resolved by the verifier when there is a catch block in an interested method.
694  // Do this here so that exception classes appear to have been specified image classes.
695  std::set<std::pair<uint16_t, const DexFile*> > unresolved_exception_types;
696  SirtRef<mirror::Class> java_lang_Throwable(self,
697                                     class_linker->FindSystemClass("Ljava/lang/Throwable;"));
698  do {
699    unresolved_exception_types.clear();
700    class_linker->VisitClasses(ResolveCatchBlockExceptionsClassVisitor,
701                               &unresolved_exception_types);
702    typedef std::set<std::pair<uint16_t, const DexFile*> >::const_iterator It;  // TODO: C++0x auto
703    for (It it = unresolved_exception_types.begin(),
704         end = unresolved_exception_types.end();
705         it != end; ++it) {
706      uint16_t exception_type_idx = it->first;
707      const DexFile* dex_file = it->second;
708      mirror::DexCache* dex_cache = class_linker->FindDexCache(*dex_file);
709      mirror:: ClassLoader* class_loader = NULL;
710      SirtRef<mirror::Class> klass(self, class_linker->ResolveType(*dex_file, exception_type_idx,
711                                                                   dex_cache, class_loader));
712      if (klass.get() == NULL) {
713        const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
714        const char* descriptor = dex_file->GetTypeDescriptor(type_id);
715        LOG(FATAL) << "Failed to resolve class " << descriptor;
716      }
717      DCHECK(java_lang_Throwable->IsAssignableFrom(klass.get()));
718    }
719    // Resolving exceptions may load classes that reference more exceptions, iterate until no
720    // more are found
721  } while (!unresolved_exception_types.empty());
722
723  // We walk the roots looking for classes so that we'll pick up the
724  // above classes plus any classes them depend on such super
725  // classes, interfaces, and the required ClassLinker roots.
726  class_linker->VisitClasses(RecordImageClassesVisitor, image_classes_.get());
727
728  CHECK_NE(image_classes_->size(), 0U);
729  timings.AddSplit("LoadImageClasses");
730}
731
732static void MaybeAddToImageClasses(mirror::Class* klass, CompilerDriver::DescriptorSet* image_classes)
733    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
734  while (!klass->IsObjectClass()) {
735    ClassHelper kh(klass);
736    const char* descriptor = kh.GetDescriptor();
737    std::pair<CompilerDriver::DescriptorSet::iterator, bool> result =
738        image_classes->insert(descriptor);
739    if (result.second) {
740      LOG(INFO) << "Adding " << descriptor << " to image classes";
741    } else {
742      return;
743    }
744    for (size_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
745      MaybeAddToImageClasses(kh.GetDirectInterface(i), image_classes);
746    }
747    if (klass->IsArrayClass()) {
748      MaybeAddToImageClasses(klass->GetComponentType(), image_classes);
749    }
750    klass = klass->GetSuperClass();
751  }
752}
753
754void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void* arg) {
755  DCHECK(object != NULL);
756  DCHECK(arg != NULL);
757  CompilerDriver* compiler_driver = reinterpret_cast<CompilerDriver*>(arg);
758  MaybeAddToImageClasses(object->GetClass(), compiler_driver->image_classes_.get());
759}
760
761void CompilerDriver::UpdateImageClasses(TimingLogger& timings) {
762  if (image_classes_.get() == NULL) {
763    return;
764  }
765
766  // Update image_classes_ with classes for objects created by <clinit> methods.
767  Thread* self = Thread::Current();
768  const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
769  gc::Heap* heap = Runtime::Current()->GetHeap();
770  // TODO: Image spaces only?
771  WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
772  heap->FlushAllocStack();
773  heap->GetLiveBitmap()->Walk(FindClinitImageClassesCallback, this);
774  self->EndAssertNoThreadSuspension(old_cause);
775  timings.AddSplit("UpdateImageClasses");
776}
777
778void CompilerDriver::RecordClassStatus(ClassReference ref, CompiledClass* compiled_class) {
779  MutexLock mu(Thread::Current(), CompilerDriver::compiled_classes_lock_);
780  compiled_classes_.Put(ref, compiled_class);
781}
782
783bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file,
784                                                      uint32_t type_idx) {
785  if (IsImage() && IsImageClass(dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx)))) {
786    if (kIsDebugBuild) {
787      ScopedObjectAccess soa(Thread::Current());
788      mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
789      mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
790      CHECK(resolved_class != NULL);
791    }
792    stats_->TypeInDexCache();
793    return true;
794  } else {
795    stats_->TypeNotInDexCache();
796    return false;
797  }
798}
799
800bool CompilerDriver::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file,
801                                                        uint32_t string_idx) {
802  // See also Compiler::ResolveDexFile
803
804  bool result = false;
805  if (IsImage()) {
806    // We resolve all const-string strings when building for the image.
807    ScopedObjectAccess soa(Thread::Current());
808    mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
809    Runtime::Current()->GetClassLinker()->ResolveString(dex_file, string_idx, dex_cache);
810    result = true;
811  }
812  if (result) {
813    stats_->StringInDexCache();
814  } else {
815    stats_->StringNotInDexCache();
816  }
817  return result;
818}
819
820bool CompilerDriver::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
821                                                uint32_t type_idx,
822                                                bool* type_known_final, bool* type_known_abstract,
823                                                bool* equals_referrers_class) {
824  if (type_known_final != NULL) {
825    *type_known_final = false;
826  }
827  if (type_known_abstract != NULL) {
828    *type_known_abstract = false;
829  }
830  if (equals_referrers_class != NULL) {
831    *equals_referrers_class = false;
832  }
833  ScopedObjectAccess soa(Thread::Current());
834  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
835  // Get type from dex cache assuming it was populated by the verifier
836  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
837  if (resolved_class == NULL) {
838    stats_->TypeNeedsAccessCheck();
839    return false;  // Unknown class needs access checks.
840  }
841  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
842  if (equals_referrers_class != NULL) {
843    *equals_referrers_class = (method_id.class_idx_ == type_idx);
844  }
845  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
846  if (referrer_class == NULL) {
847    stats_->TypeNeedsAccessCheck();
848    return false;  // Incomplete referrer knowledge needs access check.
849  }
850  // Perform access check, will return true if access is ok or false if we're going to have to
851  // check this at runtime (for example for class loaders).
852  bool result = referrer_class->CanAccess(resolved_class);
853  if (result) {
854    stats_->TypeDoesntNeedAccessCheck();
855    if (type_known_final != NULL) {
856      *type_known_final = resolved_class->IsFinal() && !resolved_class->IsArrayClass();
857    }
858    if (type_known_abstract != NULL) {
859      *type_known_abstract = resolved_class->IsAbstract() && !resolved_class->IsArrayClass();
860    }
861  } else {
862    stats_->TypeNeedsAccessCheck();
863  }
864  return result;
865}
866
867bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx,
868                                                            const DexFile& dex_file,
869                                                            uint32_t type_idx) {
870  ScopedObjectAccess soa(Thread::Current());
871  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
872  // Get type from dex cache assuming it was populated by the verifier.
873  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
874  if (resolved_class == NULL) {
875    stats_->TypeNeedsAccessCheck();
876    return false;  // Unknown class needs access checks.
877  }
878  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
879  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
880  if (referrer_class == NULL) {
881    stats_->TypeNeedsAccessCheck();
882    return false;  // Incomplete referrer knowledge needs access check.
883  }
884  // Perform access and instantiable checks, will return true if access is ok or false if we're
885  // going to have to check this at runtime (for example for class loaders).
886  bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable();
887  if (result) {
888    stats_->TypeDoesntNeedAccessCheck();
889  } else {
890    stats_->TypeNeedsAccessCheck();
891  }
892  return result;
893}
894
895static mirror::Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa,
896                                                   mirror::DexCache* dex_cache,
897                                                   const DexCompilationUnit* mUnit)
898    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
899  // The passed dex_cache is a hint, sanity check before asking the class linker that will take a
900  // lock.
901  if (dex_cache->GetDexFile() != mUnit->GetDexFile()) {
902    dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
903  }
904  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
905  const DexFile::MethodId& referrer_method_id = mUnit->GetDexFile()->GetMethodId(mUnit->GetDexMethodIndex());
906  return mUnit->GetClassLinker()->ResolveType(*mUnit->GetDexFile(), referrer_method_id.class_idx_,
907                                              dex_cache, class_loader);
908}
909
910static mirror::Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
911                                                                const DexCompilationUnit* mUnit,
912                                                                uint32_t field_idx)
913    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
914  mirror::DexCache* dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
915  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
916  return mUnit->GetClassLinker()->ResolveField(*mUnit->GetDexFile(), field_idx, dex_cache,
917                                               class_loader, false);
918}
919
920static mirror::AbstractMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
921                                                                          const DexCompilationUnit* mUnit,
922                                                                          uint32_t method_idx,
923                                                                          InvokeType type)
924    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
925  mirror::DexCache* dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
926  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
927  return mUnit->GetClassLinker()->ResolveMethod(*mUnit->GetDexFile(), method_idx, dex_cache,
928                                                class_loader, NULL, type);
929}
930
931bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
932                                              int& field_offset, bool& is_volatile, bool is_put) {
933  ScopedObjectAccess soa(Thread::Current());
934  // Conservative defaults.
935  field_offset = -1;
936  is_volatile = true;
937  // Try to resolve field and ignore if an Incompatible Class Change Error (ie is static).
938  mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
939  if (resolved_field != NULL && !resolved_field->IsStatic()) {
940    mirror::Class* referrer_class =
941        ComputeCompilingMethodsClass(soa, resolved_field->GetDeclaringClass()->GetDexCache(),
942                                     mUnit);
943    if (referrer_class != NULL) {
944      mirror::Class* fields_class = resolved_field->GetDeclaringClass();
945      bool access_ok = referrer_class->CanAccess(fields_class) &&
946                       referrer_class->CanAccessMember(fields_class,
947                                                       resolved_field->GetAccessFlags());
948      if (!access_ok) {
949        // The referring class can't access the resolved field, this may occur as a result of a
950        // protected field being made public by a sub-class. Resort to the dex file to determine
951        // the correct class for the access check.
952        const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
953        mirror::Class* dex_fields_class = mUnit->GetClassLinker()->ResolveType(dex_file,
954                                                         dex_file.GetFieldId(field_idx).class_idx_,
955                                                         referrer_class);
956        access_ok = referrer_class->CanAccess(dex_fields_class) &&
957                    referrer_class->CanAccessMember(dex_fields_class,
958                                                    resolved_field->GetAccessFlags());
959      }
960      bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal() &&
961          fields_class != referrer_class;
962      if (access_ok && !is_write_to_final_from_wrong_class) {
963        field_offset = resolved_field->GetOffset().Int32Value();
964        is_volatile = resolved_field->IsVolatile();
965        stats_->ResolvedInstanceField();
966        return true;  // Fast path.
967      }
968    }
969  }
970  // Clean up any exception left by field/type resolution
971  if (soa.Self()->IsExceptionPending()) {
972    soa.Self()->ClearException();
973  }
974  stats_->UnresolvedInstanceField();
975  return false;  // Incomplete knowledge needs slow path.
976}
977
978bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
979                                            int& field_offset, int& ssb_index,
980                                            bool& is_referrers_class, bool& is_volatile,
981                                            bool is_put) {
982  ScopedObjectAccess soa(Thread::Current());
983  // Conservative defaults.
984  field_offset = -1;
985  ssb_index = -1;
986  is_referrers_class = false;
987  is_volatile = true;
988  // Try to resolve field and ignore if an Incompatible Class Change Error (ie isn't static).
989  mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
990  if (resolved_field != NULL && resolved_field->IsStatic()) {
991    mirror::Class* referrer_class =
992        ComputeCompilingMethodsClass(soa, resolved_field->GetDeclaringClass()->GetDexCache(),
993                                     mUnit);
994    if (referrer_class != NULL) {
995      mirror::Class* fields_class = resolved_field->GetDeclaringClass();
996      if (fields_class == referrer_class) {
997        is_referrers_class = true;  // implies no worrying about class initialization
998        field_offset = resolved_field->GetOffset().Int32Value();
999        is_volatile = resolved_field->IsVolatile();
1000        stats_->ResolvedLocalStaticField();
1001        return true;  // fast path
1002      } else {
1003        bool access_ok = referrer_class->CanAccess(fields_class) &&
1004                         referrer_class->CanAccessMember(fields_class,
1005                                                         resolved_field->GetAccessFlags());
1006        if (!access_ok) {
1007          // The referring class can't access the resolved field, this may occur as a result of a
1008          // protected field being made public by a sub-class. Resort to the dex file to determine
1009          // the correct class for the access check. Don't change the field's class as that is
1010          // used to identify the SSB.
1011          const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
1012          mirror::Class* dex_fields_class =
1013              mUnit->GetClassLinker()->ResolveType(dex_file,
1014                                                   dex_file.GetFieldId(field_idx).class_idx_,
1015                                                   referrer_class);
1016          access_ok = referrer_class->CanAccess(dex_fields_class) &&
1017                      referrer_class->CanAccessMember(dex_fields_class,
1018                                                      resolved_field->GetAccessFlags());
1019        }
1020        bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal();
1021        if (access_ok && !is_write_to_final_from_wrong_class) {
1022          // We have the resolved field, we must make it into a ssbIndex for the referrer
1023          // in its static storage base (which may fail if it doesn't have a slot for it)
1024          // TODO: for images we can elide the static storage base null check
1025          // if we know there's a non-null entry in the image
1026          mirror::DexCache* dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
1027          if (fields_class->GetDexCache() == dex_cache) {
1028            // common case where the dex cache of both the referrer and the field are the same,
1029            // no need to search the dex file
1030            ssb_index = fields_class->GetDexTypeIndex();
1031            field_offset = resolved_field->GetOffset().Int32Value();
1032            is_volatile = resolved_field->IsVolatile();
1033            stats_->ResolvedStaticField();
1034            return true;
1035          }
1036          // Search dex file for localized ssb index, may fail if field's class is a parent
1037          // of the class mentioned in the dex file and there is no dex cache entry.
1038          const DexFile::StringId* string_id =
1039              mUnit->GetDexFile()->FindStringId(FieldHelper(resolved_field).GetDeclaringClassDescriptor());
1040          if (string_id != NULL) {
1041            const DexFile::TypeId* type_id =
1042               mUnit->GetDexFile()->FindTypeId(mUnit->GetDexFile()->GetIndexForStringId(*string_id));
1043            if (type_id != NULL) {
1044              // medium path, needs check of static storage base being initialized
1045              ssb_index = mUnit->GetDexFile()->GetIndexForTypeId(*type_id);
1046              field_offset = resolved_field->GetOffset().Int32Value();
1047              is_volatile = resolved_field->IsVolatile();
1048              stats_->ResolvedStaticField();
1049              return true;
1050            }
1051          }
1052        }
1053      }
1054    }
1055  }
1056  // Clean up any exception left by field/type resolution
1057  if (soa.Self()->IsExceptionPending()) {
1058    soa.Self()->ClearException();
1059  }
1060  stats_->UnresolvedStaticField();
1061  return false;  // Incomplete knowledge needs slow path.
1062}
1063
1064void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
1065                                                   mirror::Class* referrer_class,
1066                                                   mirror::AbstractMethod* method,
1067                                                   uintptr_t& direct_code,
1068                                                   uintptr_t& direct_method,
1069                                                   bool update_stats) {
1070  // For direct and static methods compute possible direct_code and direct_method values, ie
1071  // an address for the Method* being invoked and an address of the code for that Method*.
1072  // For interface calls compute a value for direct_method that is the interface method being
1073  // invoked, so this can be passed to the out-of-line runtime support code.
1074  direct_code = 0;
1075  direct_method = 0;
1076  if (compiler_backend_ == kPortable) {
1077    if (sharp_type != kStatic && sharp_type != kDirect) {
1078      return;
1079    }
1080  } else {
1081    if (sharp_type != kStatic && sharp_type != kDirect && sharp_type != kInterface) {
1082      return;
1083    }
1084  }
1085  bool method_code_in_boot = method->GetDeclaringClass()->GetClassLoader() == NULL;
1086  if (!method_code_in_boot) {
1087    return;
1088  }
1089  bool has_clinit_trampoline = method->IsStatic() && !method->GetDeclaringClass()->IsInitialized();
1090  if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) {
1091    // Ensure we run the clinit trampoline unless we are invoking a static method in the same class.
1092    return;
1093  }
1094  if (update_stats) {
1095    if (sharp_type != kInterface) {  // Interfaces always go via a trampoline.
1096      stats_->DirectCallsToBoot(type);
1097    }
1098    stats_->DirectMethodsToBoot(type);
1099  }
1100  bool compiling_boot = Runtime::Current()->GetHeap()->GetContinuousSpaces().size() == 1;
1101  if (compiling_boot) {
1102    if (support_boot_image_fixup_) {
1103      MethodHelper mh(method);
1104      if (IsImageClass(mh.GetDeclaringClassDescriptor())) {
1105        // We can only branch directly to Methods that are resolved in the DexCache.
1106        // Otherwise we won't invoke the resolution trampoline.
1107        direct_method = -1;
1108        direct_code = -1;
1109      }
1110    }
1111  } else {
1112    if (Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace()) {
1113      direct_method = reinterpret_cast<uintptr_t>(method);
1114    }
1115    direct_code = reinterpret_cast<uintptr_t>(method->GetEntryPointFromCompiledCode());
1116  }
1117}
1118
1119bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
1120                                       InvokeType& invoke_type,
1121                                       MethodReference& target_method,
1122                                       int& vtable_idx,
1123                                       uintptr_t& direct_code, uintptr_t& direct_method,
1124                                       bool update_stats) {
1125  ScopedObjectAccess soa(Thread::Current());
1126  vtable_idx = -1;
1127  direct_code = 0;
1128  direct_method = 0;
1129  mirror::AbstractMethod* resolved_method =
1130      ComputeMethodReferencedFromCompilingMethod(soa, mUnit, target_method.dex_method_index,
1131                                                 invoke_type);
1132  if (resolved_method != NULL) {
1133    // Don't try to fast-path if we don't understand the caller's class or this appears to be an
1134    // Incompatible Class Change Error.
1135    mirror::Class* referrer_class =
1136        ComputeCompilingMethodsClass(soa, resolved_method->GetDeclaringClass()->GetDexCache(),
1137                                     mUnit);
1138    bool icce = resolved_method->CheckIncompatibleClassChange(invoke_type);
1139    if (referrer_class != NULL && !icce) {
1140      mirror::Class* methods_class = resolved_method->GetDeclaringClass();
1141      if (!referrer_class->CanAccess(methods_class) ||
1142          !referrer_class->CanAccessMember(methods_class,
1143                                           resolved_method->GetAccessFlags())) {
1144        // The referring class can't access the resolved method, this may occur as a result of a
1145        // protected method being made public by implementing an interface that re-declares the
1146        // method public. Resort to the dex file to determine the correct class for the access
1147        // check.
1148        uint16_t class_idx =
1149            target_method.dex_file->GetMethodId(target_method.dex_method_index).class_idx_;
1150        methods_class = mUnit->GetClassLinker()->ResolveType(*target_method.dex_file,
1151                                                             class_idx, referrer_class);
1152      }
1153      if (referrer_class->CanAccess(methods_class) &&
1154          referrer_class->CanAccessMember(methods_class, resolved_method->GetAccessFlags())) {
1155        const bool kEnableFinalBasedSharpening = true;
1156        // Sharpen a virtual call into a direct call when the target is known not to have been
1157        // overridden (ie is final).
1158        bool can_sharpen_virtual_based_on_type =
1159            (invoke_type == kVirtual) && (resolved_method->IsFinal() || methods_class->IsFinal());
1160        // For invoke-super, ensure the vtable index will be correct to dispatch in the vtable of
1161        // the super class.
1162        bool can_sharpen_super_based_on_type = (invoke_type == kSuper) &&
1163            (referrer_class != methods_class) && referrer_class->IsSubClass(methods_class) &&
1164            resolved_method->GetMethodIndex() < methods_class->GetVTable()->GetLength() &&
1165            (methods_class->GetVTable()->Get(resolved_method->GetMethodIndex()) == resolved_method);
1166
1167        if (kEnableFinalBasedSharpening && (can_sharpen_virtual_based_on_type ||
1168                                            can_sharpen_super_based_on_type)) {
1169          // Sharpen a virtual call into a direct call. The method_idx is into referrer's
1170          // dex cache, check that this resolved method is where we expect it.
1171          CHECK(referrer_class->GetDexCache()->GetResolvedMethod(target_method.dex_method_index) ==
1172                resolved_method) << PrettyMethod(resolved_method);
1173          if (update_stats) {
1174            stats_->ResolvedMethod(invoke_type);
1175            stats_->VirtualMadeDirect(invoke_type);
1176          }
1177          GetCodeAndMethodForDirectCall(invoke_type, kDirect, referrer_class, resolved_method,
1178                                        direct_code, direct_method, update_stats);
1179          invoke_type = kDirect;
1180          return true;
1181        }
1182        const bool kEnableVerifierBasedSharpening = true;
1183        if (kEnableVerifierBasedSharpening && (invoke_type == kVirtual ||
1184                                               invoke_type == kInterface)) {
1185          // Did the verifier record a more precise invoke target based on its type information?
1186          const MethodReference caller_method(mUnit->GetDexFile(), mUnit->GetDexMethodIndex());
1187          const MethodReference* devirt_map_target =
1188              verifier::MethodVerifier::GetDevirtMap(caller_method, dex_pc);
1189          if (devirt_map_target != NULL) {
1190            mirror::DexCache* target_dex_cache =
1191                mUnit->GetClassLinker()->FindDexCache(*devirt_map_target->dex_file);
1192            mirror::ClassLoader* class_loader =
1193                soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
1194            mirror::AbstractMethod* called_method =
1195                mUnit->GetClassLinker()->ResolveMethod(*devirt_map_target->dex_file,
1196                                                       devirt_map_target->dex_method_index,
1197                                                       target_dex_cache, class_loader, NULL,
1198                                                       kVirtual);
1199            CHECK(called_method != NULL);
1200            CHECK(!called_method->IsAbstract());
1201            GetCodeAndMethodForDirectCall(invoke_type, kDirect, referrer_class, called_method,
1202                                          direct_code, direct_method, update_stats);
1203            bool compiler_needs_dex_cache =
1204                (GetCompilerBackend() == kPortable) ||
1205                (GetCompilerBackend() == kQuick && instruction_set_ != kThumb2) ||
1206                (direct_code == 0) || (direct_code == static_cast<unsigned int>(-1)) ||
1207                (direct_method == 0) || (direct_method == static_cast<unsigned int>(-1));
1208            if ((devirt_map_target->dex_file != target_method.dex_file) &&
1209                compiler_needs_dex_cache) {
1210              // We need to use the dex cache to find either the method or code, and the dex file
1211              // containing the method isn't the one expected for the target method. Try to find
1212              // the method within the expected target dex file.
1213              // TODO: the -1 could be handled as direct code if the patching new the target dex
1214              //       file.
1215              // TODO: quick only supports direct pointers with Thumb2.
1216              // TODO: the following should be factored into a common helper routine to find
1217              //       one dex file's method within another.
1218              const DexFile* dexfile = target_method.dex_file;
1219              const DexFile* cm_dexfile =
1220                  called_method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1221              const DexFile::MethodId& cm_method_id =
1222                  cm_dexfile->GetMethodId(called_method->GetDexMethodIndex());
1223              const char* cm_descriptor = cm_dexfile->StringByTypeIdx(cm_method_id.class_idx_);
1224              const DexFile::StringId* descriptor = dexfile->FindStringId(cm_descriptor);
1225              if (descriptor != NULL) {
1226                const DexFile::TypeId* type_id =
1227                    dexfile->FindTypeId(dexfile->GetIndexForStringId(*descriptor));
1228                if (type_id != NULL) {
1229                  const char* cm_name = cm_dexfile->GetMethodName(cm_method_id);
1230                  const DexFile::StringId* name = dexfile->FindStringId(cm_name);
1231                  if (name != NULL) {
1232                    uint16_t return_type_idx;
1233                    std::vector<uint16_t> param_type_idxs;
1234                    bool success = dexfile->CreateTypeList(&return_type_idx, &param_type_idxs,
1235                                                           cm_dexfile->GetMethodSignature(cm_method_id));
1236                    if (success) {
1237                      const DexFile::ProtoId* sig =
1238                          dexfile->FindProtoId(return_type_idx, param_type_idxs);
1239                      if (sig != NULL) {
1240                        const  DexFile::MethodId* method_id = dexfile->FindMethodId(*type_id,
1241                                                                                    *name, *sig);
1242                        if (method_id != NULL) {
1243                          if (update_stats) {
1244                            stats_->ResolvedMethod(invoke_type);
1245                            stats_->VirtualMadeDirect(invoke_type);
1246                            stats_->PreciseTypeDevirtualization();
1247                          }
1248                          target_method.dex_method_index = dexfile->GetIndexForMethodId(*method_id);
1249                          invoke_type = kDirect;
1250                          return true;
1251                        }
1252                      }
1253                    }
1254                  }
1255                }
1256              }
1257              // TODO: the stats for direct code and method are off as we failed to find the direct
1258              //       method in the referring method's dex cache/file.
1259            } else {
1260              if (update_stats) {
1261                stats_->ResolvedMethod(invoke_type);
1262                stats_->VirtualMadeDirect(invoke_type);
1263                stats_->PreciseTypeDevirtualization();
1264              }
1265              target_method = *devirt_map_target;
1266              invoke_type = kDirect;
1267              return true;
1268            }
1269          }
1270        }
1271        if (invoke_type == kSuper) {
1272          // Unsharpened super calls are suspicious so go slow-path.
1273        } else {
1274          // Sharpening failed so generate a regular resolved method dispatch.
1275          if (update_stats) {
1276            stats_->ResolvedMethod(invoke_type);
1277          }
1278          if (invoke_type == kVirtual || invoke_type == kSuper) {
1279            vtable_idx = resolved_method->GetMethodIndex();
1280          }
1281          GetCodeAndMethodForDirectCall(invoke_type, invoke_type, referrer_class, resolved_method,
1282                                        direct_code, direct_method, update_stats);
1283          return true;
1284        }
1285      }
1286    }
1287  }
1288  // Clean up any exception left by method/invoke_type resolution
1289  if (soa.Self()->IsExceptionPending()) {
1290      soa.Self()->ClearException();
1291  }
1292  if (update_stats) {
1293    stats_->UnresolvedMethod(invoke_type);
1294  }
1295  return false;  // Incomplete knowledge needs slow path.
1296}
1297
1298bool CompilerDriver::IsSafeCast(const MethodReference& mr, uint32_t dex_pc) {
1299  bool result = verifier::MethodVerifier::IsSafeCast(mr, dex_pc);
1300  if (result) {
1301    stats_->SafeCast();
1302  } else {
1303    stats_->NotASafeCast();
1304  }
1305  return result;
1306}
1307
1308
1309void CompilerDriver::AddCodePatch(const DexFile* dex_file,
1310                            uint32_t referrer_method_idx,
1311                            InvokeType referrer_invoke_type,
1312                            uint32_t target_method_idx,
1313                            InvokeType target_invoke_type,
1314                            size_t literal_offset) {
1315  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1316  code_to_patch_.push_back(new PatchInformation(dex_file,
1317                                                referrer_method_idx,
1318                                                referrer_invoke_type,
1319                                                target_method_idx,
1320                                                target_invoke_type,
1321                                                literal_offset));
1322}
1323void CompilerDriver::AddMethodPatch(const DexFile* dex_file,
1324                              uint32_t referrer_method_idx,
1325                              InvokeType referrer_invoke_type,
1326                              uint32_t target_method_idx,
1327                              InvokeType target_invoke_type,
1328                              size_t literal_offset) {
1329  MutexLock mu(Thread::Current(), compiled_methods_lock_);
1330  methods_to_patch_.push_back(new PatchInformation(dex_file,
1331                                                   referrer_method_idx,
1332                                                   referrer_invoke_type,
1333                                                   target_method_idx,
1334                                                   target_invoke_type,
1335                                                   literal_offset));
1336}
1337
1338class ParallelCompilationManager {
1339 public:
1340  typedef void Callback(const ParallelCompilationManager* manager, size_t index);
1341
1342  ParallelCompilationManager(ClassLinker* class_linker,
1343                             jobject class_loader,
1344                             CompilerDriver* compiler,
1345                             const DexFile* dex_file,
1346                             ThreadPool& thread_pool)
1347    : class_linker_(class_linker),
1348      class_loader_(class_loader),
1349      compiler_(compiler),
1350      dex_file_(dex_file),
1351      thread_pool_(&thread_pool) {}
1352
1353  ClassLinker* GetClassLinker() const {
1354    CHECK(class_linker_ != NULL);
1355    return class_linker_;
1356  }
1357
1358  jobject GetClassLoader() const {
1359    return class_loader_;
1360  }
1361
1362  CompilerDriver* GetCompiler() const {
1363    CHECK(compiler_ != NULL);
1364    return compiler_;
1365  }
1366
1367  const DexFile* GetDexFile() const {
1368    CHECK(dex_file_ != NULL);
1369    return dex_file_;
1370  }
1371
1372  void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) {
1373    Thread* self = Thread::Current();
1374    self->AssertNoPendingException();
1375    CHECK_GT(work_units, 0U);
1376
1377    std::vector<ForAllClosure*> closures(work_units);
1378    for (size_t i = 0; i < work_units; ++i) {
1379      closures[i] = new ForAllClosure(this, begin + i, end, callback, work_units);
1380      thread_pool_->AddTask(self, closures[i]);
1381    }
1382    thread_pool_->StartWorkers(self);
1383
1384    // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1385    // thread destructor's called below perform join).
1386    CHECK_NE(self->GetState(), kRunnable);
1387
1388    // Wait for all the worker threads to finish.
1389    thread_pool_->Wait(self, true, false);
1390  }
1391
1392 private:
1393  class ForAllClosure : public Task {
1394   public:
1395    ForAllClosure(ParallelCompilationManager* manager, size_t begin, size_t end, Callback* callback,
1396                  size_t stripe)
1397        : manager_(manager),
1398          begin_(begin),
1399          end_(end),
1400          callback_(callback),
1401          stripe_(stripe) {}
1402
1403    virtual void Run(Thread* self) {
1404      for (size_t i = begin_; i < end_; i += stripe_) {
1405        callback_(manager_, i);
1406        self->AssertNoPendingException();
1407      }
1408    }
1409
1410    virtual void Finalize() {
1411      delete this;
1412    }
1413
1414   private:
1415    const ParallelCompilationManager* const manager_;
1416    const size_t begin_;
1417    const size_t end_;
1418    const Callback* const callback_;
1419    const size_t stripe_;
1420  };
1421
1422  ClassLinker* const class_linker_;
1423  const jobject class_loader_;
1424  CompilerDriver* const compiler_;
1425  const DexFile* const dex_file_;
1426  ThreadPool* const thread_pool_;
1427};
1428
1429// Return true if the class should be skipped during compilation. We
1430// never skip classes in the boot class loader. However, if we have a
1431// non-boot class loader and we can resolve the class in the boot
1432// class loader, we do skip the class. This happens if an app bundles
1433// classes found in the boot classpath. Since at runtime we will
1434// select the class from the boot classpath, do not attempt to resolve
1435// or compile it now.
1436static bool SkipClass(mirror::ClassLoader* class_loader,
1437                      const DexFile& dex_file,
1438                      const DexFile::ClassDef& class_def)
1439    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1440  if (class_loader == NULL) {
1441    return false;
1442  }
1443  const char* descriptor = dex_file.GetClassDescriptor(class_def);
1444  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1445  mirror::Class* klass = class_linker->FindClass(descriptor, NULL);
1446  if (klass == NULL) {
1447    Thread* self = Thread::Current();
1448    CHECK(self->IsExceptionPending());
1449    self->ClearException();
1450    return false;
1451  }
1452  return true;
1453}
1454
1455static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager, size_t class_def_index)
1456    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1457  ScopedObjectAccess soa(Thread::Current());
1458  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
1459  const DexFile& dex_file = *manager->GetDexFile();
1460
1461  // Method and Field are the worst. We can't resolve without either
1462  // context from the code use (to disambiguate virtual vs direct
1463  // method and instance vs static field) or from class
1464  // definitions. While the compiler will resolve what it can as it
1465  // needs it, here we try to resolve fields and methods used in class
1466  // definitions, since many of them many never be referenced by
1467  // generated code.
1468  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1469  if (SkipClass(class_loader, dex_file, class_def)) {
1470    return;
1471  }
1472
1473  // Note the class_data pointer advances through the headers,
1474  // static fields, instance fields, direct methods, and virtual
1475  // methods.
1476  const byte* class_data = dex_file.GetClassData(class_def);
1477  if (class_data == NULL) {
1478    // empty class such as a marker interface
1479    return;
1480  }
1481  Thread* self = Thread::Current();
1482  ClassLinker* class_linker = manager->GetClassLinker();
1483  mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1484  ClassDataItemIterator it(dex_file, class_data);
1485  while (it.HasNextStaticField()) {
1486    mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
1487                                                      class_loader, true);
1488    if (field == NULL) {
1489      CHECK(self->IsExceptionPending());
1490      self->ClearException();
1491    }
1492    it.Next();
1493  }
1494  // If an instance field is final then we need to have a barrier on the return, static final
1495  // fields are assigned within the lock held for class initialization.
1496  bool requires_constructor_barrier = false;
1497  while (it.HasNextInstanceField()) {
1498    if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
1499      requires_constructor_barrier = true;
1500    }
1501
1502    mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
1503                                                      class_loader, false);
1504    if (field == NULL) {
1505      CHECK(self->IsExceptionPending());
1506      self->ClearException();
1507    }
1508    it.Next();
1509  }
1510  if (requires_constructor_barrier) {
1511    manager->GetCompiler()->AddRequiresConstructorBarrier(soa.Self(), manager->GetDexFile(),
1512                                                          class_def_index);
1513  }
1514  while (it.HasNextDirectMethod()) {
1515    mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1516                                                                 dex_cache, class_loader, NULL,
1517                                                                 it.GetMethodInvokeType(class_def));
1518    if (method == NULL) {
1519      CHECK(self->IsExceptionPending());
1520      self->ClearException();
1521    }
1522    it.Next();
1523  }
1524  while (it.HasNextVirtualMethod()) {
1525    mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
1526                                                                 dex_cache, class_loader, NULL,
1527                                                                 it.GetMethodInvokeType(class_def));
1528    if (method == NULL) {
1529      CHECK(self->IsExceptionPending());
1530      self->ClearException();
1531    }
1532    it.Next();
1533  }
1534  DCHECK(!it.HasNext());
1535}
1536
1537static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx)
1538    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1539  // Class derived values are more complicated, they require the linker and loader.
1540  ScopedObjectAccess soa(Thread::Current());
1541  ClassLinker* class_linker = manager->GetClassLinker();
1542  const DexFile& dex_file = *manager->GetDexFile();
1543  mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1544  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
1545  mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
1546
1547  if (klass == NULL) {
1548    CHECK(soa.Self()->IsExceptionPending());
1549    Thread::Current()->ClearException();
1550  }
1551}
1552
1553void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
1554                                    ThreadPool& thread_pool, TimingLogger& timings) {
1555  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1556
1557  // TODO: we could resolve strings here, although the string table is largely filled with class
1558  //       and method names.
1559
1560  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1561  context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
1562  timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
1563
1564  context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
1565  timings.AddSplit("Resolve " + dex_file.GetLocation() + " MethodsAndFields");
1566}
1567
1568void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1569                            ThreadPool& thread_pool, TimingLogger& timings) {
1570  for (size_t i = 0; i != dex_files.size(); ++i) {
1571    const DexFile* dex_file = dex_files[i];
1572    CHECK(dex_file != NULL);
1573    VerifyDexFile(class_loader, *dex_file, thread_pool, timings);
1574  }
1575}
1576
1577static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index)
1578    LOCKS_EXCLUDED(Locks::mutator_lock_) {
1579  ScopedObjectAccess soa(Thread::Current());
1580  const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
1581  const char* descriptor = manager->GetDexFile()->GetClassDescriptor(class_def);
1582  mirror::Class* klass =
1583      manager->GetClassLinker()->FindClass(descriptor,
1584                                           soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()));
1585  if (klass == NULL) {
1586    CHECK(soa.Self()->IsExceptionPending());
1587    soa.Self()->ClearException();
1588
1589    /*
1590     * At compile time, we can still structurally verify the class even if FindClass fails.
1591     * This is to ensure the class is structurally sound for compilation. An unsound class
1592     * will be rejected by the verifier and later skipped during compilation in the compiler.
1593     */
1594    mirror::DexCache* dex_cache =  manager->GetClassLinker()->FindDexCache(*manager->GetDexFile());
1595    std::string error_msg;
1596    if (verifier::MethodVerifier::VerifyClass(manager->GetDexFile(),
1597                                              dex_cache,
1598                                              soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()),
1599                                              class_def_index, error_msg, true) ==
1600                                                  verifier::MethodVerifier::kHardFailure) {
1601      const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
1602      LOG(ERROR) << "Verification failed on class "
1603                 << PrettyDescriptor(manager->GetDexFile()->GetClassDescriptor(class_def))
1604                 << " because: " << error_msg;
1605    }
1606    return;
1607  }
1608  CHECK(klass->IsResolved()) << PrettyClass(klass);
1609  manager->GetClassLinker()->VerifyClass(klass);
1610
1611  if (klass->IsErroneous()) {
1612    // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
1613    CHECK(soa.Self()->IsExceptionPending());
1614    soa.Self()->ClearException();
1615  }
1616
1617  CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
1618      << PrettyDescriptor(klass) << ": state=" << klass->GetStatus();
1619  soa.Self()->AssertNoPendingException();
1620}
1621
1622void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
1623                                   ThreadPool& thread_pool, TimingLogger& timings) {
1624  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1625  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
1626  context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
1627  timings.AddSplit("Verify " + dex_file.GetLocation());
1628}
1629
1630static const char* class_initializer_black_list[] = {
1631  "Landroid/app/ActivityThread;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1632  "Landroid/bluetooth/BluetoothAudioGateway;", // Calls android.bluetooth.BluetoothAudioGateway.classInitNative().
1633  "Landroid/bluetooth/HeadsetBase;", // Calls android.bluetooth.HeadsetBase.classInitNative().
1634  "Landroid/content/res/CompatibilityInfo;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
1635  "Landroid/content/res/CompatibilityInfo$1;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
1636  "Landroid/content/UriMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1637  "Landroid/database/CursorWindow;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
1638  "Landroid/database/sqlite/SQLiteConnection;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1639  "Landroid/database/sqlite/SQLiteConnection$Operation;", // Requires SimpleDateFormat -> java.util.Locale.
1640  "Landroid/database/sqlite/SQLiteDatabaseConfiguration;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1641  "Landroid/database/sqlite/SQLiteDebug;", // Calls android.util.Log.isLoggable.
1642  "Landroid/database/sqlite/SQLiteOpenHelper;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
1643  "Landroid/database/sqlite/SQLiteQueryBuilder;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1644  "Landroid/drm/DrmManagerClient;", // Calls System.loadLibrary.
1645  "Landroid/graphics/drawable/AnimatedRotateDrawable;", // Sub-class of Drawable.
1646  "Landroid/graphics/drawable/AnimationDrawable;", // Sub-class of Drawable.
1647  "Landroid/graphics/drawable/BitmapDrawable;", // Sub-class of Drawable.
1648  "Landroid/graphics/drawable/ClipDrawable;", // Sub-class of Drawable.
1649  "Landroid/graphics/drawable/ColorDrawable;", // Sub-class of Drawable.
1650  "Landroid/graphics/drawable/Drawable;", // Requires android.graphics.Rect.
1651  "Landroid/graphics/drawable/DrawableContainer;", // Sub-class of Drawable.
1652  "Landroid/graphics/drawable/GradientDrawable;", // Sub-class of Drawable.
1653  "Landroid/graphics/drawable/LayerDrawable;", // Sub-class of Drawable.
1654  "Landroid/graphics/drawable/NinePatchDrawable;", // Sub-class of Drawable.
1655  "Landroid/graphics/drawable/RotateDrawable;", // Sub-class of Drawable.
1656  "Landroid/graphics/drawable/ScaleDrawable;", // Sub-class of Drawable.
1657  "Landroid/graphics/drawable/ShapeDrawable;", // Sub-class of Drawable.
1658  "Landroid/graphics/drawable/StateListDrawable;", // Sub-class of Drawable.
1659  "Landroid/graphics/drawable/TransitionDrawable;", // Sub-class of Drawable.
1660  "Landroid/graphics/Matrix;", // Calls android.graphics.Matrix.native_create.
1661  "Landroid/graphics/Matrix$1;", // Requires Matrix.
1662  "Landroid/graphics/PixelFormat;", // Calls android.graphics.PixelFormat.nativeClassInit().
1663  "Landroid/graphics/Rect;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1664  "Landroid/graphics/SurfaceTexture;", // Calls android.graphics.SurfaceTexture.nativeClassInit().
1665  "Landroid/graphics/Typeface;", // Calls android.graphics.Typeface.nativeCreate.
1666  "Landroid/inputmethodservice/ExtractEditText;", // Requires android.widget.TextView.
1667  "Landroid/media/AmrInputStream;", // Calls OsConstants.initConstants.
1668  "Landroid/media/CamcorderProfile;", // Calls OsConstants.initConstants.
1669  "Landroid/media/CameraProfile;", // Calls System.loadLibrary.
1670  "Landroid/media/DecoderCapabilities;", // Calls System.loadLibrary.
1671  "Landroid/media/EncoderCapabilities;", // Calls OsConstants.initConstants.
1672  "Landroid/media/ExifInterface;", // Calls OsConstants.initConstants.
1673  "Landroid/media/MediaCodec;", // Calls OsConstants.initConstants.
1674  "Landroid/media/MediaCodecList;", // Calls OsConstants.initConstants.
1675  "Landroid/media/MediaCrypto;", // Calls OsConstants.initConstants.
1676  "Landroid/media/MediaDrm;", // Calls OsConstants.initConstants.
1677  "Landroid/media/MediaExtractor;", // Calls OsConstants.initConstants.
1678  "Landroid/media/MediaFile;", // Requires DecoderCapabilities.
1679  "Landroid/media/MediaMetadataRetriever;", // Calls OsConstants.initConstants.
1680  "Landroid/media/MediaMuxer;", // Calls OsConstants.initConstants.
1681  "Landroid/media/MediaPlayer;", // Calls System.loadLibrary.
1682  "Landroid/media/MediaRecorder;", // Calls System.loadLibrary.
1683  "Landroid/media/MediaScanner;", // Calls System.loadLibrary.
1684  "Landroid/media/ResampleInputStream;", // Calls OsConstants.initConstants.
1685  "Landroid/media/SoundPool;", // Calls OsConstants.initConstants.
1686  "Landroid/media/videoeditor/MediaArtistNativeHelper;", // Calls OsConstants.initConstants.
1687  "Landroid/media/videoeditor/VideoEditorProfile;", // Calls OsConstants.initConstants.
1688  "Landroid/mtp/MtpDatabase;", // Calls OsConstants.initConstants.
1689  "Landroid/mtp/MtpDevice;", // Calls OsConstants.initConstants.
1690  "Landroid/mtp/MtpServer;", // Calls OsConstants.initConstants.
1691  "Landroid/net/NetworkInfo;", // Calls java.util.EnumMap.<init> -> java.lang.Enum.getSharedConstants -> System.identityHashCode.
1692  "Landroid/net/Proxy;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1693  "Landroid/net/SSLCertificateSocketFactory;", // Requires javax.net.ssl.HttpsURLConnection.
1694  "Landroid/net/Uri;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
1695  "Landroid/net/Uri$AbstractHierarchicalUri;", // Requires Uri.
1696  "Landroid/net/Uri$HierarchicalUri;", // Requires Uri.
1697  "Landroid/net/Uri$OpaqueUri;", // Requires Uri.
1698  "Landroid/net/Uri$StringUri;", // Requires Uri.
1699  "Landroid/net/WebAddress;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1700  "Landroid/nfc/NdefRecord;", // Calls String.getBytes -> java.nio.charset.Charset.
1701  "Landroid/opengl/EGL14;", // Calls android.opengl.EGL14._nativeClassInit.
1702  "Landroid/opengl/GLES10;", // Calls android.opengl.GLES10._nativeClassInit.
1703  "Landroid/opengl/GLES10Ext;", // Calls android.opengl.GLES10Ext._nativeClassInit.
1704  "Landroid/opengl/GLES11;", // Requires GLES10.
1705  "Landroid/opengl/GLES11Ext;", // Calls android.opengl.GLES11Ext._nativeClassInit.
1706  "Landroid/opengl/GLES20;", // Calls android.opengl.GLES20._nativeClassInit.
1707  "Landroid/opengl/GLUtils;", // Calls android.opengl.GLUtils.nativeClassInit.
1708  "Landroid/os/Build;", // Calls -..-> android.os.SystemProperties.native_get.
1709  "Landroid/os/Build$VERSION;", // Requires Build.
1710  "Landroid/os/Debug;", // Requires android.os.Environment.
1711  "Landroid/os/Environment;", // Calls System.getenv.
1712  "Landroid/os/FileUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1713  "Landroid/os/StrictMode;", // Calls android.util.Log.isLoggable.
1714  "Landroid/os/StrictMode$VmPolicy;", // Requires StrictMode.
1715  "Landroid/os/Trace;", // Calls android.os.Trace.nativeGetEnabledTags.
1716  "Landroid/os/UEventObserver;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
1717  "Landroid/provider/ContactsContract;", // Calls OsConstants.initConstants.
1718  "Landroid/provider/Settings$Global;", // Calls OsConstants.initConstants.
1719  "Landroid/provider/Settings$Secure;", // Requires android.net.Uri.
1720  "Landroid/provider/Settings$System;", // Requires android.net.Uri.
1721  "Landroid/renderscript/RenderScript;", // Calls System.loadLibrary.
1722  "Landroid/server/BluetoothService;", // Calls android.server.BluetoothService.classInitNative.
1723  "Landroid/server/BluetoothEventLoop;", // Calls android.server.BluetoothEventLoop.classInitNative.
1724  "Landroid/telephony/PhoneNumberUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1725  "Landroid/telephony/TelephonyManager;", // Calls OsConstants.initConstants.
1726  "Landroid/text/AutoText;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
1727  "Landroid/text/Layout;", // Calls com.android.internal.util.ArrayUtils.emptyArray -> System.identityHashCode.
1728  "Landroid/text/BoringLayout;", // Requires Layout.
1729  "Landroid/text/DynamicLayout;", // Requires Layout.
1730  "Landroid/text/Html$HtmlParser;", // Calls -..-> String.toLowerCase -> java.util.Locale.
1731  "Landroid/text/StaticLayout;", // Requires Layout.
1732  "Landroid/text/TextUtils;", // Requires android.util.DisplayMetrics.
1733  "Landroid/util/DisplayMetrics;", // Calls SystemProperties.native_get_int.
1734  "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1735  "Landroid/view/Choreographer;", // Calls SystemProperties.native_get_boolean.
1736  "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1737  "Landroid/view/GLES20Canvas;", // Calls GLES20Canvas.nIsAvailable().
1738  "Landroid/view/GLES20RecordingCanvas;", // Requires android.view.GLES20Canvas.
1739  "Landroid/view/GestureDetector;", // Calls android.view.GLES20Canvas.nIsAvailable.
1740  "Landroid/view/HardwareRenderer$Gl20Renderer;", // Requires SystemProperties.native_get.
1741  "Landroid/view/HardwareRenderer$GlRenderer;", // Requires SystemProperties.native_get.
1742  "Landroid/view/InputEventConsistencyVerifier;", // Requires android.os.Build.
1743  "Landroid/view/Surface;", // Requires SystemProperties.native_get.
1744  "Landroid/view/SurfaceControl;", // Calls OsConstants.initConstants.
1745  "Landroid/view/animation/AlphaAnimation;", // Requires Animation.
1746  "Landroid/view/animation/Animation;", // Calls SystemProperties.native_get_boolean.
1747  "Landroid/view/animation/AnimationSet;", // Calls OsConstants.initConstants.
1748  "Landroid/view/textservice/SpellCheckerSubtype;", // Calls Class.getDex().
1749  "Landroid/webkit/JniUtil;", // Calls System.loadLibrary.
1750  "Landroid/webkit/PluginManager;", // // Calls OsConstants.initConstants.
1751  "Landroid/webkit/WebViewCore;", // Calls System.loadLibrary.
1752  "Landroid/webkit/WebViewFactory$Preloader;",  // Calls to Class.forName.
1753  "Landroid/webkit/WebViewInputDispatcher;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1754  "Landroid/webkit/URLUtil;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1755  "Landroid/widget/AutoCompleteTextView;", // Requires TextView.
1756  "Landroid/widget/Button;", // Requires TextView.
1757  "Landroid/widget/CheckBox;", // Requires TextView.
1758  "Landroid/widget/CheckedTextView;", // Requires TextView.
1759  "Landroid/widget/CompoundButton;", // Requires TextView.
1760  "Landroid/widget/EditText;", // Requires TextView.
1761  "Landroid/widget/NumberPicker;", // Requires java.util.Locale.
1762  "Landroid/widget/ScrollBarDrawable;", // Sub-class of Drawable.
1763  "Landroid/widget/SearchView$SearchAutoComplete;", // Requires TextView.
1764  "Landroid/widget/Switch;", // Requires TextView.
1765  "Landroid/widget/TextView;", // Calls Paint.<init> -> Paint.native_init.
1766  "Lcom/android/i18n/phonenumbers/AsYouTypeFormatter;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1767  "Lcom/android/i18n/phonenumbers/MetadataManager;", // Calls OsConstants.initConstants.
1768  "Lcom/android/i18n/phonenumbers/PhoneNumberMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1769  "Lcom/android/i18n/phonenumbers/PhoneNumberUtil;", // Requires java.util.logging.LogManager.
1770  "Lcom/android/i18n/phonenumbers/geocoding/AreaCodeMap;", // Calls OsConstants.initConstants.
1771  "Lcom/android/i18n/phonenumbers/geocoding/PhoneNumberOfflineGeocoder;", // Calls OsConstants.initConstants.
1772  "Lcom/android/internal/os/SamplingProfilerIntegration;", // Calls SystemProperties.native_get_int.
1773  "Lcom/android/internal/policy/impl/PhoneWindow;", // Calls android.os.Binder.init.
1774  "Lcom/android/internal/view/menu/ActionMenuItemView;", // Requires TextView.
1775  "Lcom/android/internal/widget/DialogTitle;", // Requires TextView.
1776  "Lcom/android/org/bouncycastle/asn1/StreamUtil;", // Calls Runtime.getRuntime().maxMemory().
1777  "Lcom/android/org/bouncycastle/asn1/pkcs/MacData;", // Calls native ... -> java.math.NativeBN.BN_new().
1778  "Lcom/android/org/bouncycastle/asn1/pkcs/RSASSAPSSparams;", // Calls native ... -> java.math.NativeBN.BN_new().
1779  "Lcom/android/org/bouncycastle/asn1/cms/SignedData;", // Calls native ... -> java.math.NativeBN.BN_new().
1780  "Lcom/android/org/bouncycastle/asn1/x509/GeneralSubtree;", // Calls native ... -> java.math.NativeBN.BN_new().
1781  "Lcom/android/org/bouncycastle/asn1/x9/X9ECParameters;", // Calls native ... -> java.math.NativeBN.BN_new().
1782  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$MD5;", // Requires com.android.org.conscrypt.NativeCrypto.
1783  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto.
1784  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto.
1785  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto.
1786  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto.
1787  "Lcom/android/org/bouncycastle/crypto/engines/RSABlindedEngine;", // Calls native ... -> java.math.NativeBN.BN_new().
1788  "Lcom/android/org/bouncycastle/crypto/generators/DHKeyGeneratorHelper;", // Calls native ... -> java.math.NativeBN.BN_new().
1789  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
1790  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersHelper;", // Calls System.getenv -> OsConstants.initConstants.
1791  "Lcom/android/org/bouncycastle/crypto/generators/DSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
1792  "Lcom/android/org/bouncycastle/crypto/generators/DSAParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
1793  "Lcom/android/org/bouncycastle/crypto/generators/RSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
1794  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
1795  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
1796  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$EC;", // Calls OsConstants.initConstants.
1797  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDH;", // Calls OsConstants.initConstants.
1798  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDHC;", // Calls OsConstants.initConstants.
1799  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDSA;", // Calls OsConstants.initConstants.
1800  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECMQV;", // Calls OsConstants.initConstants.
1801  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
1802  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new().
1803  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new().
1804  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
1805  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi$BCPKCS12KeyStore;", // Calls Thread.currentThread.
1806  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi;", // Calls Thread.currentThread.
1807  "Lcom/android/org/bouncycastle/jce/PKCS10CertificationRequest;", // Calls native ... -> java.math.NativeBN.BN_new().
1808  "Lcom/android/org/bouncycastle/jce/provider/CertBlacklist;", // Calls System.getenv -> OsConstants.initConstants.
1809  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new().
1810  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new().
1811  "Lcom/android/org/bouncycastle/jce/provider/PKIXCertPathValidatorSpi;", // Calls System.getenv -> OsConstants.initConstants.
1812  "Lcom/android/org/bouncycastle/math/ec/ECConstants;", // Calls native ... -> java.math.NativeBN.BN_new().
1813  "Lcom/android/org/bouncycastle/math/ec/Tnaf;", // Calls native ... -> java.math.NativeBN.BN_new().
1814  "Lcom/android/org/bouncycastle/util/BigIntegers;", // Calls native ... -> java.math.NativeBN.BN_new().
1815  "Lcom/android/org/bouncycastle/x509/X509Util;", // Calls native ... -> java.math.NativeBN.BN_new().
1816  "Lcom/android/org/conscrypt/CipherSuite;", // Calls OsConstants.initConstants.
1817  "Lcom/android/org/conscrypt/FileClientSessionCache$CacheFile;", // Calls OsConstants.initConstants.
1818  "Lcom/android/org/conscrypt/HandshakeIODataStream;", // Calls OsConstants.initConstants.
1819  "Lcom/android/org/conscrypt/Logger;", // Calls OsConstants.initConstants.
1820  "Lcom/android/org/conscrypt/NativeCrypto;", // Calls native NativeCrypto.clinit().
1821  "Lcom/android/org/conscrypt/OpenSSLECKeyPairGenerator;", // Calls OsConstants.initConstants.
1822  "Lcom/android/org/conscrypt/OpenSSLEngine;", // Requires com.android.org.conscrypt.NativeCrypto.
1823  "Lcom/android/org/conscrypt/OpenSSLMac$HmacMD5;", // Calls native NativeCrypto.clinit().
1824  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA1;", // Calls native NativeCrypto.clinit().
1825  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA256;", // Calls native NativeCrypto.clinit().
1826  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA384;", // Calls native NativeCrypto.clinit().
1827  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA512;", // Calls native NativeCrypto.clinit().
1828  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$MD5;", // Requires com.android.org.conscrypt.NativeCrypto.
1829  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto.
1830  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto.
1831  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto.
1832  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto.
1833  "Lcom/android/org/conscrypt/OpenSSLX509CertPath;", // Calls OsConstants.initConstants.
1834  "Lcom/android/org/conscrypt/OpenSSLX509CertificateFactory;", // Calls OsConstants.initConstants.
1835  "Lcom/android/org/conscrypt/PRF;", // Calls OsConstants.initConstants.
1836  "Lcom/android/org/conscrypt/SSLSessionImpl;", // Calls OsConstants.initConstants.
1837  "Lcom/android/org/conscrypt/TrustedCertificateStore;", // Calls System.getenv -> OsConstants.initConstants.
1838  "Lcom/android/okhttp/ConnectionPool;", // Calls OsConstants.initConstants.
1839  "Lcom/android/okhttp/OkHttpClient;", // Calls OsConstants.initConstants.
1840  "Lcom/android/okhttp/internal/DiskLruCache;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1841  "Lcom/android/okhttp/internal/Util;", // Calls OsConstants.initConstants.
1842  "Lcom/android/okhttp/internal/http/HttpsURLConnectionImpl;", // Calls VMClassLoader.getBootClassPathSize.
1843  "Lcom/android/okhttp/internal/spdy/SpdyConnection;", // Calls OsConstants.initConstants.
1844  "Lcom/android/okhttp/internal/spdy/SpdyReader;", // Calls OsConstants.initConstants.
1845  "Lcom/android/okhttp/internal/tls/OkHostnameVerifier;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1846  "Lcom/google/android/gles_jni/EGLContextImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
1847  "Lcom/google/android/gles_jni/EGLImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
1848  "Lcom/google/android/gles_jni/GLImpl;", // Calls com.google.android.gles_jni.GLImpl._nativeClassInit.
1849  "Lgov/nist/core/GenericObject;", // Calls OsConstants.initConstants.
1850  "Lgov/nist/core/Host;", // Calls OsConstants.initConstants.
1851  "Lgov/nist/core/HostPort;", // Calls OsConstants.initConstants.
1852  "Lgov/nist/core/NameValue;", // Calls OsConstants.initConstants.
1853  "Lgov/nist/core/net/DefaultNetworkLayer;", // Calls OsConstants.initConstants.
1854  "Lgov/nist/javax/sip/Utils;", // Calls OsConstants.initConstants.
1855  "Lgov/nist/javax/sip/address/AddressImpl;", // Calls OsConstants.initConstants.
1856  "Lgov/nist/javax/sip/address/Authority;", // Calls OsConstants.initConstants.
1857  "Lgov/nist/javax/sip/address/GenericURI;", // Calls OsConstants.initConstants.
1858  "Lgov/nist/javax/sip/address/NetObject;", // Calls OsConstants.initConstants.
1859  "Lgov/nist/javax/sip/address/SipUri;", // Calls OsConstants.initConstants.
1860  "Lgov/nist/javax/sip/address/TelephoneNumber;", // Calls OsConstants.initConstants.
1861  "Lgov/nist/javax/sip/address/UserInfo;", // Calls OsConstants.initConstants.
1862  "Lgov/nist/javax/sip/header/Accept;", // Calls OsConstants.initConstants.
1863  "Lgov/nist/javax/sip/header/AcceptEncoding;", // Calls OsConstants.initConstants.
1864  "Lgov/nist/javax/sip/header/AcceptLanguage;", // Calls OsConstants.initConstants.
1865  "Lgov/nist/javax/sip/header/AddressParametersHeader;", // Calls OsConstants.initConstants.
1866  "Lgov/nist/javax/sip/header/AlertInfoList;", // Calls OsConstants.initConstants.
1867  "Lgov/nist/javax/sip/header/AllowEvents;", // Calls OsConstants.initConstants.
1868  "Lgov/nist/javax/sip/header/AllowEventsList;", // Calls OsConstants.initConstants.
1869  "Lgov/nist/javax/sip/header/AuthenticationInfo;", // Calls OsConstants.initConstants.
1870  "Lgov/nist/javax/sip/header/Authorization;", // Calls OsConstants.initConstants.
1871  "Lgov/nist/javax/sip/header/CSeq;", // Calls OsConstants.initConstants.
1872  "Lgov/nist/javax/sip/header/CallIdentifier;", // Calls OsConstants.initConstants.
1873  "Lgov/nist/javax/sip/header/Challenge;", // Calls OsConstants.initConstants.
1874  "Lgov/nist/javax/sip/header/ContactList;", // Calls OsConstants.initConstants.
1875  "Lgov/nist/javax/sip/header/ContentEncoding;", // Calls OsConstants.initConstants.
1876  "Lgov/nist/javax/sip/header/ContentEncodingList;", // Calls OsConstants.initConstants.
1877  "Lgov/nist/javax/sip/header/ContentLanguageList;", // Calls OsConstants.initConstants.
1878  "Lgov/nist/javax/sip/header/ContentType;", // Calls OsConstants.initConstants.
1879  "Lgov/nist/javax/sip/header/Credentials;", // Calls OsConstants.initConstants.
1880  "Lgov/nist/javax/sip/header/ErrorInfoList;", // Calls OsConstants.initConstants.
1881  "Lgov/nist/javax/sip/header/Expires;", // Calls OsConstants.initConstants.
1882  "Lgov/nist/javax/sip/header/From;", // Calls OsConstants.initConstants.
1883  "Lgov/nist/javax/sip/header/MimeVersion;", // Calls OsConstants.initConstants.
1884  "Lgov/nist/javax/sip/header/NameMap;", // Calls OsConstants.initConstants.
1885  "Lgov/nist/javax/sip/header/Priority;", // Calls OsConstants.initConstants.
1886  "Lgov/nist/javax/sip/header/Protocol;", // Calls OsConstants.initConstants.
1887  "Lgov/nist/javax/sip/header/ProxyAuthenticate;", // Calls OsConstants.initConstants.
1888  "Lgov/nist/javax/sip/header/ProxyAuthenticateList;", // Calls OsConstants.initConstants.
1889  "Lgov/nist/javax/sip/header/ProxyAuthorizationList;", // Calls OsConstants.initConstants.
1890  "Lgov/nist/javax/sip/header/ProxyRequire;", // Calls OsConstants.initConstants.
1891  "Lgov/nist/javax/sip/header/ProxyRequireList;", // Calls OsConstants.initConstants.
1892  "Lgov/nist/javax/sip/header/RSeq;", // Calls OsConstants.initConstants.
1893  "Lgov/nist/javax/sip/header/RecordRoute;", // Calls OsConstants.initConstants.
1894  "Lgov/nist/javax/sip/header/ReferTo;", // Calls OsConstants.initConstants.
1895  "Lgov/nist/javax/sip/header/RequestLine;", // Calls OsConstants.initConstants.
1896  "Lgov/nist/javax/sip/header/Require;", // Calls OsConstants.initConstants.
1897  "Lgov/nist/javax/sip/header/RetryAfter;", // Calls OsConstants.initConstants.
1898  "Lgov/nist/javax/sip/header/SIPETag;", // Calls OsConstants.initConstants.
1899  "Lgov/nist/javax/sip/header/SIPHeader;", // Calls OsConstants.initConstants.
1900  "Lgov/nist/javax/sip/header/SIPHeaderNamesCache;", // Calls OsConstants.initConstants.
1901  "Lgov/nist/javax/sip/header/StatusLine;", // Calls OsConstants.initConstants.
1902  "Lgov/nist/javax/sip/header/SubscriptionState;", // Calls OsConstants.initConstants.
1903  "Lgov/nist/javax/sip/header/TimeStamp;", // Calls OsConstants.initConstants.
1904  "Lgov/nist/javax/sip/header/UserAgent;", // Calls OsConstants.initConstants.
1905  "Lgov/nist/javax/sip/header/Unsupported;", // Calls OsConstants.initConstants.
1906  "Lgov/nist/javax/sip/header/Warning;", // Calls OsConstants.initConstants.
1907  "Lgov/nist/javax/sip/header/ViaList;", // Calls OsConstants.initConstants.
1908  "Lgov/nist/javax/sip/header/extensions/Join;", // Calls OsConstants.initConstants.
1909  "Lgov/nist/javax/sip/header/extensions/References;", // Calls OsConstants.initConstants.
1910  "Lgov/nist/javax/sip/header/extensions/Replaces;", // Calls OsConstants.initConstants.
1911  "Lgov/nist/javax/sip/header/ims/PAccessNetworkInfo;", // Calls OsConstants.initConstants.
1912  "Lgov/nist/javax/sip/header/ims/PAssertedIdentity;", // Calls OsConstants.initConstants.
1913  "Lgov/nist/javax/sip/header/ims/PAssertedIdentityList;", // Calls OsConstants.initConstants.
1914  "Lgov/nist/javax/sip/header/ims/PAssociatedURI;",  // Calls OsConstants.initConstants.
1915  "Lgov/nist/javax/sip/header/ims/PCalledPartyID;", // Calls OsConstants.initConstants.
1916  "Lgov/nist/javax/sip/header/ims/PChargingVector;", // Calls OsConstants.initConstants.
1917  "Lgov/nist/javax/sip/header/ims/PPreferredIdentity;",  // Calls OsConstants.initConstants.
1918  "Lgov/nist/javax/sip/header/ims/PVisitedNetworkIDList;", // Calls OsConstants.initConstants.
1919  "Lgov/nist/javax/sip/header/ims/PathList;", // Calls OsConstants.initConstants.
1920  "Lgov/nist/javax/sip/header/ims/SecurityAgree;", // Calls OsConstants.initConstants.
1921  "Lgov/nist/javax/sip/header/ims/SecurityClient;", // Calls OsConstants.initConstants.
1922  "Lgov/nist/javax/sip/header/ims/ServiceRoute;", // Calls OsConstants.initConstants.
1923  "Ljava/io/Console;", // Has FileDescriptor(s).
1924  "Ljava/io/File;", // Calls to Random.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
1925  "Ljava/io/FileDescriptor;", // Requires libcore.io.OsConstants.
1926  "Ljava/io/ObjectInputStream;", // Requires java.lang.ClassLoader$SystemClassLoader.
1927  "Ljava/io/ObjectStreamClass;",  // Calls to Class.forName -> java.io.FileDescriptor.
1928  "Ljava/io/ObjectStreamConstants;", // Instance of non-image class SerializablePermission.
1929  "Ljava/lang/ClassLoader$SystemClassLoader;", // Calls System.getProperty -> OsConstants.initConstants.
1930  "Ljava/lang/HexStringParser;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1931  "Ljava/lang/ProcessManager;", // Calls Thread.currentThread.
1932  "Ljava/lang/Runtime;", // Calls System.getProperty -> OsConstants.initConstants.
1933  "Ljava/lang/System;", // Calls OsConstants.initConstants.
1934  "Ljava/math/BigDecimal;", // Calls native ... -> java.math.NativeBN.BN_new().
1935  "Ljava/math/BigInteger;", // Calls native ... -> java.math.NativeBN.BN_new().
1936  "Ljava/math/Primality;", // Calls native ... -> java.math.NativeBN.BN_new().
1937  "Ljava/math/Multiplication;", // Calls native ... -> java.math.NativeBN.BN_new().
1938  "Ljava/net/InetAddress;", // Requires libcore.io.OsConstants.
1939  "Ljava/net/Inet4Address;", // Sub-class of InetAddress.
1940  "Ljava/net/Inet6Address;", // Sub-class of InetAddress.
1941  "Ljava/net/InetUnixAddress;", // Sub-class of InetAddress.
1942  "Ljava/nio/charset/Charset;", // Calls Charset.getDefaultCharset -> System.getProperty -> OsConstants.initConstants.
1943  "Ljava/nio/charset/CharsetICU;", // Sub-class of Charset.
1944  "Ljava/nio/charset/Charsets;", // Calls Charset.forName.
1945  "Ljava/nio/charset/StandardCharsets;", // Calls OsConstants.initConstants.
1946  "Ljava/security/AlgorithmParameterGenerator;", // Calls OsConstants.initConstants.
1947  "Ljava/security/KeyPairGenerator$KeyPairGeneratorImpl;", // Calls OsConstants.initConstants.
1948  "Ljava/security/KeyPairGenerator;", // Calls OsConstants.initConstants.
1949  "Ljava/security/Security;", // Tries to do disk IO for "security.properties".
1950  "Ljava/security/spec/RSAKeyGenParameterSpec;", // java.math.NativeBN.BN_new()
1951  "Ljava/sql/Date;", // Calls OsConstants.initConstants.
1952  "Ljava/sql/DriverManager;", // Calls OsConstants.initConstants.
1953  "Ljava/sql/Time;", // Calls OsConstants.initConstants.
1954  "Ljava/sql/Timestamp;", // Calls OsConstants.initConstants.
1955  "Ljava/util/Date;", // Calls Date.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
1956  "Ljava/util/ListResourceBundle;", // Calls OsConstants.initConstants.
1957  "Ljava/util/Locale;", // Calls System.getProperty -> OsConstants.initConstants.
1958  "Ljava/util/PropertyResourceBundle;", // Calls OsConstants.initConstants.
1959  "Ljava/util/ResourceBundle;", // Calls OsConstants.initConstants.
1960  "Ljava/util/ResourceBundle$MissingBundle;", // Calls OsConstants.initConstants.
1961  "Ljava/util/Scanner;", // regex.Pattern.compileImpl.
1962  "Ljava/util/SimpleTimeZone;", // Sub-class of TimeZone.
1963  "Ljava/util/TimeZone;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
1964  "Ljava/util/concurrent/ConcurrentHashMap$Segment;", // Calls Runtime.getRuntime().availableProcessors().
1965  "Ljava/util/concurrent/ConcurrentSkipListMap;", // Calls OsConstants.initConstants.
1966  "Ljava/util/concurrent/Exchanger;", // Calls OsConstants.initConstants.
1967  "Ljava/util/concurrent/ForkJoinPool;", // Calls OsConstants.initConstants.
1968  "Ljava/util/concurrent/LinkedTransferQueue;", // Calls OsConstants.initConstants.
1969  "Ljava/util/concurrent/Phaser;", // Calls OsConstants.initConstants.
1970  "Ljava/util/concurrent/ScheduledThreadPoolExecutor;", // Calls AtomicLong.VMSupportsCS8()
1971  "Ljava/util/concurrent/SynchronousQueue;", // Calls OsConstants.initConstants.
1972  "Ljava/util/concurrent/atomic/AtomicLong;", // Calls AtomicLong.VMSupportsCS8()
1973  "Ljava/util/logging/LogManager;", // Calls System.getProperty -> OsConstants.initConstants.
1974  "Ljava/util/prefs/AbstractPreferences;", // Calls OsConstants.initConstants.
1975  "Ljava/util/prefs/FilePreferencesImpl;", // Calls OsConstants.initConstants.
1976  "Ljava/util/prefs/FilePreferencesFactoryImpl;", // Calls OsConstants.initConstants.
1977  "Ljava/util/prefs/Preferences;", // Calls OsConstants.initConstants.
1978  "Ljavax/crypto/KeyAgreement;", // Calls OsConstants.initConstants.
1979  "Ljavax/crypto/KeyGenerator;", // Calls OsConstants.initConstants.
1980  "Ljavax/security/cert/X509Certificate;", // Calls VMClassLoader.getBootClassPathSize.
1981  "Ljavax/security/cert/X509Certificate$1;", // Calls VMClassLoader.getBootClassPathSize.
1982  "Ljavax/microedition/khronos/egl/EGL10;", // Requires EGLContext.
1983  "Ljavax/microedition/khronos/egl/EGLContext;", // Requires com.google.android.gles_jni.EGLImpl.
1984  "Ljavax/net/ssl/HttpsURLConnection$DefaultHolder;", // Calls VMClassLoader.getBootClassPathSize().
1985  "Ljavax/xml/datatype/DatatypeConstants;", // Calls OsConstants.initConstants.
1986  "Ljavax/xml/datatype/FactoryFinder;", // Calls OsConstants.initConstants.
1987  "Ljavax/xml/namespace/QName;", // Calls OsConstants.initConstants.
1988  "Ljavax/xml/validation/SchemaFactoryFinder;", // Calls OsConstants.initConstants.
1989  "Ljavax/xml/xpath/XPathConstants;", // Calls OsConstants.initConstants.
1990  "Ljavax/xml/xpath/XPathFactoryFinder;", // Calls OsConstants.initConstants.
1991  "Llibcore/icu/LocaleData;", // Requires java.util.Locale.
1992  "Llibcore/icu/TimeZoneNames;", // Requires java.util.TimeZone.
1993  "Llibcore/io/IoUtils;",  // Calls Random.<init> -> System.currentTimeMillis -> FileDescriptor -> OsConstants.initConstants.
1994  "Llibcore/io/OsConstants;", // Platform specific.
1995  "Llibcore/net/MimeUtils;", // Calls libcore.net.MimeUtils.getContentTypesPropertiesStream -> System.getProperty.
1996  "Llibcore/reflect/Types;", // Calls OsConstants.initConstants.
1997  "Llibcore/util/ZoneInfo;", // Sub-class of TimeZone.
1998  "Llibcore/util/ZoneInfoDB;", // Calls System.getenv -> OsConstants.initConstants.
1999  "Lorg/apache/commons/logging/LogFactory;", // Calls System.getProperty.
2000  "Lorg/apache/commons/logging/impl/LogFactoryImpl;", // Calls OsConstants.initConstants.
2001  "Lorg/apache/harmony/security/fortress/Services;", // Calls ClassLoader.getSystemClassLoader -> System.getProperty.
2002  "Lorg/apache/harmony/security/provider/cert/X509CertFactoryImpl;", // Requires java.nio.charsets.Charsets.
2003  "Lorg/apache/harmony/security/provider/crypto/RandomBitsSupplier;", // Requires java.io.File.
2004  "Lorg/apache/harmony/security/utils/AlgNameMapper;", // Requires java.util.Locale.
2005  "Lorg/apache/harmony/security/pkcs10/CertificationRequest;", // Calls Thread.currentThread.
2006  "Lorg/apache/harmony/security/pkcs10/CertificationRequestInfo;", // Calls Thread.currentThread.
2007  "Lorg/apache/harmony/security/pkcs7/AuthenticatedAttributes;", // Calls Thread.currentThread.
2008  "Lorg/apache/harmony/security/pkcs7/SignedData;", // Calls Thread.currentThread.
2009  "Lorg/apache/harmony/security/pkcs7/SignerInfo;", // Calls Thread.currentThread.
2010  "Lorg/apache/harmony/security/pkcs8/PrivateKeyInfo;", // Calls Thread.currentThread.
2011  "Lorg/apache/harmony/security/provider/crypto/SHA1PRNG_SecureRandomImpl;", // Calls OsConstants.initConstants.
2012  "Lorg/apache/harmony/security/x501/AttributeTypeAndValue;", // Calls IntegralToString.convertInt -> Thread.currentThread.
2013  "Lorg/apache/harmony/security/x501/DirectoryString;", // Requires BigInteger.
2014  "Lorg/apache/harmony/security/x501/Name;", // Requires org.apache.harmony.security.x501.AttributeTypeAndValue.
2015  "Lorg/apache/harmony/security/x509/AccessDescription;", // Calls Thread.currentThread.
2016  "Lorg/apache/harmony/security/x509/AuthorityKeyIdentifier;", // Calls Thread.currentThread.
2017  "Lorg/apache/harmony/security/x509/CRLDistributionPoints;", // Calls Thread.currentThread.
2018  "Lorg/apache/harmony/security/x509/Certificate;", // Requires org.apache.harmony.security.x509.TBSCertificate.
2019  "Lorg/apache/harmony/security/x509/CertificateIssuer;", // Calls Thread.currentThread.
2020  "Lorg/apache/harmony/security/x509/CertificateList;", // Calls Thread.currentThread.
2021  "Lorg/apache/harmony/security/x509/DistributionPoint;", // Calls Thread.currentThread.
2022  "Lorg/apache/harmony/security/x509/DistributionPointName;", // Calls Thread.currentThread.
2023  "Lorg/apache/harmony/security/x509/EDIPartyName;", // Calls native ... -> java.math.NativeBN.BN_new().
2024  "Lorg/apache/harmony/security/x509/GeneralName;", // Requires org.apache.harmony.security.x501.Name.
2025  "Lorg/apache/harmony/security/x509/GeneralNames;", // Requires GeneralName.
2026  "Lorg/apache/harmony/security/x509/GeneralSubtree;", // Calls Thread.currentThread.
2027  "Lorg/apache/harmony/security/x509/GeneralSubtrees;", // Calls Thread.currentThread.
2028  "Lorg/apache/harmony/security/x509/InfoAccessSyntax;", // Calls Thread.currentThread.
2029  "Lorg/apache/harmony/security/x509/IssuingDistributionPoint;", // Calls Thread.currentThread.
2030  "Lorg/apache/harmony/security/x509/NameConstraints;", // Calls Thread.currentThread.
2031  "Lorg/apache/harmony/security/x509/TBSCertList$RevokedCertificate;", // Calls NativeBN.BN_new().
2032  "Lorg/apache/harmony/security/x509/TBSCertList;", // Calls Thread.currentThread.
2033  "Lorg/apache/harmony/security/x509/TBSCertificate;",  // Requires org.apache.harmony.security.x501.Name.
2034  "Lorg/apache/harmony/security/x509/Time;", // Calls native ... -> java.math.NativeBN.BN_new().
2035  "Lorg/apache/harmony/security/x509/Validity;", // Requires x509.Time.
2036  "Lorg/apache/harmony/security/x509/tsp/TSTInfo;", // Calls Thread.currentThread.
2037  "Lorg/apache/harmony/xml/ExpatParser;", // Calls native ExpatParser.staticInitialize.
2038  "Lorg/apache/harmony/xml/ExpatParser$EntityParser;", // Calls ExpatParser.staticInitialize.
2039  "Lorg/apache/http/conn/params/ConnRouteParams;", // Requires java.util.Locale.
2040  "Lorg/apache/http/conn/ssl/SSLSocketFactory;", // Calls java.security.Security.getProperty.
2041  "Lorg/apache/http/conn/util/InetAddressUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
2042};
2043
2044static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
2045    LOCKS_EXCLUDED(Locks::mutator_lock_) {
2046  const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
2047  ScopedObjectAccess soa(Thread::Current());
2048  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
2049  const char* descriptor = manager->GetDexFile()->GetClassDescriptor(class_def);
2050  mirror::Class* klass = manager->GetClassLinker()->FindClass(descriptor, class_loader);
2051  bool compiling_boot = Runtime::Current()->GetHeap()->GetContinuousSpaces().size() == 1;
2052  bool can_init_static_fields = compiling_boot &&
2053      manager->GetCompiler()->IsImageClass(descriptor);
2054  if (klass != NULL) {
2055    // We don't want class initialization occurring on multiple threads due to deadlock problems.
2056    // For example, a parent class is initialized (holding its lock) that refers to a sub-class
2057    // in its static/class initializer causing it to try to acquire the sub-class' lock. While
2058    // on a second thread the sub-class is initialized (holding its lock) after first initializing
2059    // its parents, whose locks are acquired. This leads to a parent-to-child and a child-to-parent
2060    // lock ordering and consequent potential deadlock.
2061    // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
2062    // than use a special Object for the purpose we use the Class of java.lang.Class.
2063    ObjectLock lock1(soa.Self(), klass->GetClass());
2064    // The lock required to initialize the class.
2065    ObjectLock lock2(soa.Self(), klass);
2066    // Only try to initialize classes that were successfully verified.
2067    if (klass->IsVerified()) {
2068      manager->GetClassLinker()->EnsureInitialized(klass, false, can_init_static_fields);
2069      if (soa.Self()->IsExceptionPending()) {
2070        soa.Self()->GetException(NULL)->Dump();
2071      }
2072      if (!klass->IsInitialized()) {
2073        if (can_init_static_fields) {
2074          bool is_black_listed = false;
2075          for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
2076            if (StringPiece(descriptor) == class_initializer_black_list[i]) {
2077              is_black_listed = true;
2078              break;
2079            }
2080          }
2081          if (!is_black_listed) {
2082            LOG(INFO) << "Initializing: " << descriptor;
2083            if (StringPiece(descriptor) == "Ljava/lang/Void;") {
2084              // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
2085              mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
2086              CHECK_EQ(fields->GetLength(), 1);
2087              fields->Get(0)->SetObj(klass, manager->GetClassLinker()->FindPrimitiveClass('V'));
2088              klass->SetStatus(mirror::Class::kStatusInitialized);
2089            } else {
2090              manager->GetClassLinker()->EnsureInitialized(klass, true, can_init_static_fields);
2091            }
2092            soa.Self()->AssertNoPendingException();
2093          }
2094        }
2095      }
2096      // If successfully initialized place in SSB array.
2097      if (klass->IsInitialized()) {
2098        klass->GetDexCache()->GetInitializedStaticStorage()->Set(klass->GetDexTypeIndex(), klass);
2099      }
2100    }
2101    // Record the final class status if necessary.
2102    mirror::Class::Status status = klass->GetStatus();
2103    ClassReference ref(manager->GetDexFile(), class_def_index);
2104    CompiledClass* compiled_class = manager->GetCompiler()->GetCompiledClass(ref);
2105    if (compiled_class == NULL) {
2106      compiled_class = new CompiledClass(status);
2107      manager->GetCompiler()->RecordClassStatus(ref, compiled_class);
2108    } else {
2109      DCHECK_GE(status, compiled_class->GetStatus()) << descriptor;
2110    }
2111  }
2112  // Clear any class not found or verification exceptions.
2113  soa.Self()->ClearException();
2114}
2115
2116void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
2117                                       ThreadPool& thread_pool, TimingLogger& timings) {
2118#ifndef NDEBUG
2119  for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
2120    const char* descriptor = class_initializer_black_list[i];
2121    CHECK(IsValidDescriptor(descriptor)) << descriptor;
2122  }
2123#endif
2124  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
2125  ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
2126  context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count_);
2127  timings.AddSplit("InitializeNoClinit " + dex_file.GetLocation());
2128}
2129
2130void CompilerDriver::InitializeClasses(jobject class_loader,
2131                                       const std::vector<const DexFile*>& dex_files,
2132                                       ThreadPool& thread_pool, TimingLogger& timings) {
2133  for (size_t i = 0; i != dex_files.size(); ++i) {
2134    const DexFile* dex_file = dex_files[i];
2135    CHECK(dex_file != NULL);
2136    InitializeClasses(class_loader, *dex_file, thread_pool, timings);
2137  }
2138}
2139
2140void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
2141                       ThreadPool& thread_pool, TimingLogger& timings) {
2142  for (size_t i = 0; i != dex_files.size(); ++i) {
2143    const DexFile* dex_file = dex_files[i];
2144    CHECK(dex_file != NULL);
2145    CompileDexFile(class_loader, *dex_file, thread_pool, timings);
2146  }
2147}
2148
2149void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) {
2150  jobject jclass_loader = manager->GetClassLoader();
2151  const DexFile& dex_file = *manager->GetDexFile();
2152  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
2153  {
2154    ScopedObjectAccess soa(Thread::Current());
2155    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
2156    if (SkipClass(class_loader, dex_file, class_def)) {
2157      return;
2158    }
2159  }
2160  ClassReference ref(&dex_file, class_def_index);
2161  // Skip compiling classes with generic verifier failures since they will still fail at runtime
2162  if (verifier::MethodVerifier::IsClassRejected(ref)) {
2163    return;
2164  }
2165  const byte* class_data = dex_file.GetClassData(class_def);
2166  if (class_data == NULL) {
2167    // empty class, probably a marker interface
2168    return;
2169  }
2170  // Can we run DEX-to-DEX compiler on this class ?
2171  bool allow_dex_compilation;
2172  {
2173    ScopedObjectAccess soa(Thread::Current());
2174    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
2175    allow_dex_compilation = IsDexToDexCompilationAllowed(class_loader, dex_file, class_def);
2176  }
2177  ClassDataItemIterator it(dex_file, class_data);
2178  // Skip fields
2179  while (it.HasNextStaticField()) {
2180    it.Next();
2181  }
2182  while (it.HasNextInstanceField()) {
2183    it.Next();
2184  }
2185  // Compile direct methods
2186  int64_t previous_direct_method_idx = -1;
2187  while (it.HasNextDirectMethod()) {
2188    uint32_t method_idx = it.GetMemberIndex();
2189    if (method_idx == previous_direct_method_idx) {
2190      // smali can create dex files with two encoded_methods sharing the same method_idx
2191      // http://code.google.com/p/smali/issues/detail?id=119
2192      it.Next();
2193      continue;
2194    }
2195    previous_direct_method_idx = method_idx;
2196    manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
2197                                          it.GetMethodInvokeType(class_def), class_def_index,
2198                                          method_idx, jclass_loader, dex_file, allow_dex_compilation);
2199    it.Next();
2200  }
2201  // Compile virtual methods
2202  int64_t previous_virtual_method_idx = -1;
2203  while (it.HasNextVirtualMethod()) {
2204    uint32_t method_idx = it.GetMemberIndex();
2205    if (method_idx == previous_virtual_method_idx) {
2206      // smali can create dex files with two encoded_methods sharing the same method_idx
2207      // http://code.google.com/p/smali/issues/detail?id=119
2208      it.Next();
2209      continue;
2210    }
2211    previous_virtual_method_idx = method_idx;
2212    manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
2213                                          it.GetMethodInvokeType(class_def), class_def_index,
2214                                          method_idx, jclass_loader, dex_file, allow_dex_compilation);
2215    it.Next();
2216  }
2217  DCHECK(!it.HasNext());
2218}
2219
2220void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
2221                                    ThreadPool& thread_pool, TimingLogger& timings) {
2222  ParallelCompilationManager context(NULL, class_loader, this, &dex_file, thread_pool);
2223  context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
2224  timings.AddSplit("Compile " + dex_file.GetLocation());
2225}
2226
2227void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
2228                                   InvokeType invoke_type, uint32_t class_def_idx,
2229                                   uint32_t method_idx, jobject class_loader,
2230                                   const DexFile& dex_file,
2231                                   bool allow_dex_to_dex_compilation) {
2232  CompiledMethod* compiled_method = NULL;
2233  uint64_t start_ns = NanoTime();
2234
2235  if ((access_flags & kAccNative) != 0) {
2236    compiled_method = (*jni_compiler_)(*this, access_flags, method_idx, dex_file);
2237    CHECK(compiled_method != NULL);
2238  } else if ((access_flags & kAccAbstract) != 0) {
2239  } else {
2240    // In small mode we only compile image classes.
2241    bool dont_compile = (Runtime::Current()->IsSmallMode() &&
2242                         ((image_classes_.get() == NULL) || (image_classes_->size() == 0)));
2243
2244    // Don't compile class initializers, ever.
2245    if (((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
2246      dont_compile = true;
2247    } else if (code_item->insns_size_in_code_units_ < Runtime::Current()->GetSmallModeMethodDexSizeLimit()) {
2248    // Do compile small methods.
2249      dont_compile = false;
2250    }
2251    if (!dont_compile) {
2252      CompilerFn compiler = compiler_;
2253#ifdef ART_SEA_IR_MODE
2254      bool use_sea = Runtime::Current()->IsSeaIRMode();
2255      use_sea = use_sea && (std::string::npos != PrettyMethod(method_idx, dex_file).find("fibonacci"));
2256      if (use_sea) {
2257        compiler = sea_ir_compiler_;
2258      }
2259#endif
2260      compiled_method = (*compiler)(*this, code_item, access_flags, invoke_type, class_def_idx,
2261                                    method_idx, class_loader, dex_file);
2262      CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
2263    } else if (allow_dex_to_dex_compilation) {
2264      // TODO: add a mode to disable DEX-to-DEX compilation ?
2265      compiled_method = (*dex_to_dex_compiler_)(*this, code_item, access_flags,
2266                                                invoke_type, class_def_idx,
2267                                                method_idx, class_loader, dex_file);
2268      // No native code is generated.
2269      CHECK(compiled_method == NULL) << PrettyMethod(method_idx, dex_file);
2270    }
2271  }
2272  uint64_t duration_ns = NanoTime() - start_ns;
2273#ifdef ART_USE_PORTABLE_COMPILER
2274  const uint64_t kWarnMilliSeconds = 1000;
2275#else
2276  const uint64_t kWarnMilliSeconds = 100;
2277#endif
2278  if (duration_ns > MsToNs(kWarnMilliSeconds)) {
2279    LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
2280                 << " took " << PrettyDuration(duration_ns);
2281  }
2282
2283  Thread* self = Thread::Current();
2284  if (compiled_method != NULL) {
2285    MethodReference ref(&dex_file, method_idx);
2286    CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
2287    {
2288      MutexLock mu(self, compiled_methods_lock_);
2289      compiled_methods_.Put(ref, compiled_method);
2290    }
2291    DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
2292  }
2293
2294  if (self->IsExceptionPending()) {
2295    ScopedObjectAccess soa(self);
2296    LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
2297        << self->GetException(NULL)->Dump();
2298  }
2299}
2300
2301CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
2302  MutexLock mu(Thread::Current(), compiled_classes_lock_);
2303  ClassTable::const_iterator it = compiled_classes_.find(ref);
2304  if (it == compiled_classes_.end()) {
2305    return NULL;
2306  }
2307  CHECK(it->second != NULL);
2308  return it->second;
2309}
2310
2311CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
2312  MutexLock mu(Thread::Current(), compiled_methods_lock_);
2313  MethodTable::const_iterator it = compiled_methods_.find(ref);
2314  if (it == compiled_methods_.end()) {
2315    return NULL;
2316  }
2317  CHECK(it->second != NULL);
2318  return it->second;
2319}
2320
2321void CompilerDriver::SetBitcodeFileName(std::string const& filename) {
2322  typedef void (*SetBitcodeFileNameFn)(CompilerDriver&, std::string const&);
2323
2324  SetBitcodeFileNameFn set_bitcode_file_name =
2325    reinterpret_cast<SetBitcodeFileNameFn>(compilerLLVMSetBitcodeFileName);
2326
2327  set_bitcode_file_name(*this, filename);
2328}
2329
2330
2331void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
2332                                             size_t class_def_index) {
2333  MutexLock mu(self, freezing_constructor_lock_);
2334  freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
2335}
2336
2337bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
2338                                          size_t class_def_index) {
2339  MutexLock mu(self, freezing_constructor_lock_);
2340  return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
2341}
2342
2343bool CompilerDriver::WriteElf(const std::string& android_root,
2344                              bool is_host,
2345                              const std::vector<const art::DexFile*>& dex_files,
2346                              OatWriter& oat_writer,
2347                              art::File* file)
2348    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2349#if defined(ART_USE_PORTABLE_COMPILER)
2350  return art::ElfWriterMclinker::Create(file, oat_writer, dex_files, android_root, is_host, *this);
2351#else
2352  return art::ElfWriterQuick::Create(file, oat_writer, dex_files, android_root, is_host, *this);
2353#endif
2354}
2355void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
2356                                                std::string& target_triple,
2357                                                std::string& target_cpu,
2358                                                std::string& target_attr) {
2359  switch (instruction_set) {
2360    case kThumb2:
2361      target_triple = "thumb-none-linux-gnueabi";
2362      target_cpu = "cortex-a9";
2363      target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
2364      break;
2365
2366    case kArm:
2367      target_triple = "armv7-none-linux-gnueabi";
2368      // TODO: Fix for Nexus S.
2369      target_cpu = "cortex-a9";
2370      // TODO: Fix for Xoom.
2371      target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
2372      break;
2373
2374    case kX86:
2375      target_triple = "i386-pc-linux-gnu";
2376      target_attr = "";
2377      break;
2378
2379    case kMips:
2380      target_triple = "mipsel-unknown-linux";
2381      target_attr = "mips32r2";
2382      break;
2383
2384    default:
2385      LOG(FATAL) << "Unknown instruction set: " << instruction_set;
2386    }
2387  }
2388}  // namespace art
2389