class_linker.cc revision 9583fbcf597eff6d0b3c5359b8e8d5f70ed82c40 
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 "class_linker.h"
18
19#include <fcntl.h>
20#include <sys/file.h>
21#include <sys/stat.h>
22
23#include <deque>
24#include <string>
25#include <utility>
26#include <vector>
27
28#include "base/casts.h"
29#include "base/logging.h"
30#include "base/stl_util.h"
31#include "base/unix_file/fd_file.h"
32#include "class_linker-inl.h"
33#include "compiler_callbacks.h"
34#include "debugger.h"
35#include "dex_file-inl.h"
36#include "gc/accounting/card_table-inl.h"
37#include "gc/accounting/heap_bitmap.h"
38#include "gc/heap.h"
39#include "gc/space/image_space.h"
40#include "intern_table.h"
41#include "interpreter/interpreter.h"
42#include "leb128.h"
43#include "oat.h"
44#include "oat_file.h"
45#include "mirror/art_field-inl.h"
46#include "mirror/art_method-inl.h"
47#include "mirror/class.h"
48#include "mirror/class-inl.h"
49#include "mirror/class_loader.h"
50#include "mirror/dex_cache-inl.h"
51#include "mirror/iftable-inl.h"
52#include "mirror/object-inl.h"
53#include "mirror/object_array-inl.h"
54#include "mirror/proxy.h"
55#include "mirror/stack_trace_element.h"
56#include "object_utils.h"
57#include "os.h"
58#include "runtime.h"
59#include "entrypoints/entrypoint_utils.h"
60#include "ScopedLocalRef.h"
61#include "scoped_thread_state_change.h"
62#include "sirt_ref.h"
63#include "stack_indirect_reference_table.h"
64#include "thread.h"
65#include "UniquePtr.h"
66#include "utils.h"
67#include "verifier/method_verifier.h"
68#include "well_known_classes.h"
69
70namespace art {
71
72static void ThrowNoClassDefFoundError(const char* fmt, ...)
73    __attribute__((__format__(__printf__, 1, 2)))
74    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
75static void ThrowNoClassDefFoundError(const char* fmt, ...) {
76  va_list args;
77  va_start(args, fmt);
78  Thread* self = Thread::Current();
79  ThrowLocation throw_location = self->GetCurrentLocationForThrow();
80  self->ThrowNewExceptionV(throw_location, "Ljava/lang/NoClassDefFoundError;", fmt, args);
81  va_end(args);
82}
83
84static void ThrowEarlierClassFailure(mirror::Class* c)
85    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
86  // The class failed to initialize on a previous attempt, so we want to throw
87  // a NoClassDefFoundError (v2 2.17.5).  The exception to this rule is if we
88  // failed in verification, in which case v2 5.4.1 says we need to re-throw
89  // the previous error.
90  if (!Runtime::Current()->IsCompiler()) {  // Give info if this occurs at runtime.
91    LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
92  }
93
94  CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
95  Thread* self = Thread::Current();
96  ThrowLocation throw_location = self->GetCurrentLocationForThrow();
97  if (c->GetVerifyErrorClass() != NULL) {
98    // TODO: change the verifier to store an _instance_, with a useful detail message?
99    ClassHelper ve_ch(c->GetVerifyErrorClass());
100    self->ThrowNewException(throw_location, ve_ch.GetDescriptor(), PrettyDescriptor(c).c_str());
101  } else {
102    self->ThrowNewException(throw_location, "Ljava/lang/NoClassDefFoundError;",
103                            PrettyDescriptor(c).c_str());
104  }
105}
106
107static void WrapExceptionInInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
108  Thread* self = Thread::Current();
109  JNIEnv* env = self->GetJniEnv();
110
111  ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
112  CHECK(cause.get() != NULL);
113
114  env->ExceptionClear();
115  bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
116  env->Throw(cause.get());
117
118  // We only wrap non-Error exceptions; an Error can just be used as-is.
119  if (!is_error) {
120    ThrowLocation throw_location = self->GetCurrentLocationForThrow();
121    self->ThrowNewWrappedException(throw_location, "Ljava/lang/ExceptionInInitializerError;", NULL);
122  }
123}
124
125static size_t Hash(const char* s) {
126  // This is the java.lang.String hashcode for convenience, not interoperability.
127  size_t hash = 0;
128  for (; *s != '\0'; ++s) {
129    hash = hash * 31 + *s;
130  }
131  return hash;
132}
133
134const char* ClassLinker::class_roots_descriptors_[] = {
135  "Ljava/lang/Class;",
136  "Ljava/lang/Object;",
137  "[Ljava/lang/Class;",
138  "[Ljava/lang/Object;",
139  "Ljava/lang/String;",
140  "Ljava/lang/DexCache;",
141  "Ljava/lang/ref/Reference;",
142  "Ljava/lang/reflect/ArtField;",
143  "Ljava/lang/reflect/ArtMethod;",
144  "Ljava/lang/reflect/Proxy;",
145  "[Ljava/lang/String;",
146  "[Ljava/lang/reflect/ArtField;",
147  "[Ljava/lang/reflect/ArtMethod;",
148  "Ljava/lang/ClassLoader;",
149  "Ljava/lang/Throwable;",
150  "Ljava/lang/ClassNotFoundException;",
151  "Ljava/lang/StackTraceElement;",
152  "Z",
153  "B",
154  "C",
155  "D",
156  "F",
157  "I",
158  "J",
159  "S",
160  "V",
161  "[Z",
162  "[B",
163  "[C",
164  "[D",
165  "[F",
166  "[I",
167  "[J",
168  "[S",
169  "[Ljava/lang/StackTraceElement;",
170};
171
172ClassLinker::ClassLinker(InternTable* intern_table)
173    // dex_lock_ is recursive as it may be used in stack dumping.
174    : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
175      dex_cache_image_class_lookup_required_(false),
176      failed_dex_cache_class_lookups_(0),
177      class_roots_(nullptr),
178      array_iftable_(nullptr),
179      find_array_class_cache_next_victim_(0),
180      init_done_(false),
181      dex_caches_dirty_(false),
182      class_table_dirty_(false),
183      intern_table_(intern_table),
184      portable_resolution_trampoline_(nullptr),
185      quick_resolution_trampoline_(nullptr),
186      portable_imt_conflict_trampoline_(nullptr),
187      quick_imt_conflict_trampoline_(nullptr),
188      quick_generic_jni_trampoline_(nullptr) {
189  CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
190  memset(find_array_class_cache_, 0, kFindArrayCacheSize * sizeof(mirror::Class*));
191}
192
193void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
194  VLOG(startup) << "ClassLinker::Init";
195  CHECK(Runtime::Current()->IsCompiler());
196
197  CHECK(!init_done_);
198
199  // java_lang_Class comes first, it's needed for AllocClass
200  Thread* self = Thread::Current();
201  gc::Heap* heap = Runtime::Current()->GetHeap();
202  // The GC can't handle an object with a null class since we can't get the size of this object.
203  heap->IncrementDisableMovingGC(self);
204  SirtRef<mirror::Class> java_lang_Class(self, down_cast<mirror::Class*>(
205      heap->AllocNonMovableObject<true>(self, nullptr, sizeof(mirror::ClassClass))));
206  CHECK(java_lang_Class.get() != NULL);
207  mirror::Class::SetClassClass(java_lang_Class.get());
208  java_lang_Class->SetClass(java_lang_Class.get());
209  if (kUseBrooksPointer) {
210    java_lang_Class->AssertSelfBrooksPointer();
211  }
212  java_lang_Class->SetClassSize(sizeof(mirror::ClassClass));
213  heap->DecrementDisableMovingGC(self);
214  // AllocClass(mirror::Class*) can now be used
215
216  // Class[] is used for reflection support.
217  SirtRef<mirror::Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
218  class_array_class->SetComponentType(java_lang_Class.get());
219
220  // java_lang_Object comes next so that object_array_class can be created.
221  SirtRef<mirror::Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
222  CHECK(java_lang_Object.get() != NULL);
223  // backfill Object as the super class of Class.
224  java_lang_Class->SetSuperClass(java_lang_Object.get());
225  java_lang_Object->SetStatus(mirror::Class::kStatusLoaded, self);
226
227  // Object[] next to hold class roots.
228  SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
229  object_array_class->SetComponentType(java_lang_Object.get());
230
231  // Setup the char class to be used for char[].
232  SirtRef<mirror::Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
233
234  // Setup the char[] class to be used for String.
235  SirtRef<mirror::Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
236  char_array_class->SetComponentType(char_class.get());
237  mirror::CharArray::SetArrayClass(char_array_class.get());
238
239  // Setup String.
240  SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
241  mirror::String::SetClass(java_lang_String.get());
242  java_lang_String->SetObjectSize(sizeof(mirror::String));
243  java_lang_String->SetStatus(mirror::Class::kStatusResolved, self);
244
245  // Create storage for root classes, save away our work so far (requires descriptors).
246  class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(),
247                                                           kClassRootsMax);
248  CHECK(class_roots_ != NULL);
249  SetClassRoot(kJavaLangClass, java_lang_Class.get());
250  SetClassRoot(kJavaLangObject, java_lang_Object.get());
251  SetClassRoot(kClassArrayClass, class_array_class.get());
252  SetClassRoot(kObjectArrayClass, object_array_class.get());
253  SetClassRoot(kCharArrayClass, char_array_class.get());
254  SetClassRoot(kJavaLangString, java_lang_String.get());
255
256  // Setup the primitive type classes.
257  SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
258  SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
259  SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
260  SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
261  SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
262  SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
263  SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
264  SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
265
266  // Create array interface entries to populate once we can load system classes.
267  array_iftable_ = AllocIfTable(self, 2);
268
269  // Create int array type for AllocDexCache (done in AppendToBootClassPath).
270  SirtRef<mirror::Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
271  int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
272  mirror::IntArray::SetArrayClass(int_array_class.get());
273  SetClassRoot(kIntArrayClass, int_array_class.get());
274
275  // now that these are registered, we can use AllocClass() and AllocObjectArray
276
277  // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
278  SirtRef<mirror::Class>
279      java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
280  SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
281  java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCache));
282  java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved, self);
283
284  // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
285  SirtRef<mirror::Class> java_lang_reflect_ArtField(self, AllocClass(self, java_lang_Class.get(),
286                                                                     sizeof(mirror::ArtFieldClass)));
287  CHECK(java_lang_reflect_ArtField.get() != NULL);
288  java_lang_reflect_ArtField->SetObjectSize(sizeof(mirror::ArtField));
289  SetClassRoot(kJavaLangReflectArtField, java_lang_reflect_ArtField.get());
290  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved, self);
291  mirror::ArtField::SetClass(java_lang_reflect_ArtField.get());
292
293  SirtRef<mirror::Class> java_lang_reflect_ArtMethod(self, AllocClass(self, java_lang_Class.get(),
294                                                                      sizeof(mirror::ArtMethodClass)));
295  CHECK(java_lang_reflect_ArtMethod.get() != NULL);
296  java_lang_reflect_ArtMethod->SetObjectSize(sizeof(mirror::ArtMethod));
297  SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.get());
298  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved, self);
299
300  mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.get());
301
302  // Set up array classes for string, field, method
303  SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(),
304                                                              sizeof(mirror::Class)));
305  object_array_string->SetComponentType(java_lang_String.get());
306  SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
307
308  SirtRef<mirror::Class> object_array_art_method(self, AllocClass(self, java_lang_Class.get(),
309                                                                  sizeof(mirror::Class)));
310  object_array_art_method->SetComponentType(java_lang_reflect_ArtMethod.get());
311  SetClassRoot(kJavaLangReflectArtMethodArrayClass, object_array_art_method.get());
312
313  SirtRef<mirror::Class> object_array_art_field(self, AllocClass(self, java_lang_Class.get(),
314                                                                 sizeof(mirror::Class)));
315  object_array_art_field->SetComponentType(java_lang_reflect_ArtField.get());
316  SetClassRoot(kJavaLangReflectArtFieldArrayClass, object_array_art_field.get());
317
318  // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
319  // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
320  // these roots.
321  CHECK_NE(0U, boot_class_path.size());
322  for (size_t i = 0; i != boot_class_path.size(); ++i) {
323    const DexFile* dex_file = boot_class_path[i];
324    CHECK(dex_file != NULL);
325    AppendToBootClassPath(*dex_file);
326  }
327
328  // now we can use FindSystemClass
329
330  // run char class through InitializePrimitiveClass to finish init
331  InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
332  SetClassRoot(kPrimitiveChar, char_class.get());  // needs descriptor
333
334  // Create runtime resolution and imt conflict methods. Also setup the default imt.
335  Runtime* runtime = Runtime::Current();
336  runtime->SetResolutionMethod(runtime->CreateResolutionMethod());
337  runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod());
338  runtime->SetDefaultImt(runtime->CreateDefaultImt(this));
339
340  // Object, String and DexCache need to be rerun through FindSystemClass to finish init
341  java_lang_Object->SetStatus(mirror::Class::kStatusNotReady, self);
342  mirror::Class* Object_class = FindSystemClass(self, "Ljava/lang/Object;");
343  CHECK_EQ(java_lang_Object.get(), Object_class);
344  CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
345  java_lang_String->SetStatus(mirror::Class::kStatusNotReady, self);
346  mirror::Class* String_class = FindSystemClass(self, "Ljava/lang/String;");
347  CHECK_EQ(java_lang_String.get(), String_class);
348  CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
349  java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady, self);
350  mirror::Class* DexCache_class = FindSystemClass(self, "Ljava/lang/DexCache;");
351  CHECK_EQ(java_lang_String.get(), String_class);
352  CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
353  CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(mirror::DexCache));
354
355  // Setup the primitive array type classes - can't be done until Object has a vtable.
356  SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z"));
357  mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
358
359  SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B"));
360  mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
361
362  mirror::Class* found_char_array_class = FindSystemClass(self, "[C");
363  CHECK_EQ(char_array_class.get(), found_char_array_class);
364
365  SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S"));
366  mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
367
368  mirror::Class* found_int_array_class = FindSystemClass(self, "[I");
369  CHECK_EQ(int_array_class.get(), found_int_array_class);
370
371  SetClassRoot(kLongArrayClass, FindSystemClass(self, "[J"));
372  mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
373
374  SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F"));
375  mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
376
377  SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D"));
378  mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
379
380  mirror::Class* found_class_array_class = FindSystemClass(self, "[Ljava/lang/Class;");
381  CHECK_EQ(class_array_class.get(), found_class_array_class);
382
383  mirror::Class* found_object_array_class = FindSystemClass(self, "[Ljava/lang/Object;");
384  CHECK_EQ(object_array_class.get(), found_object_array_class);
385
386  // Setup the single, global copy of "iftable".
387  mirror::Class* java_lang_Cloneable = FindSystemClass(self, "Ljava/lang/Cloneable;");
388  CHECK(java_lang_Cloneable != NULL);
389  mirror::Class* java_io_Serializable = FindSystemClass(self, "Ljava/io/Serializable;");
390  CHECK(java_io_Serializable != NULL);
391  // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
392  // crawl up and explicitly list all of the supers as well.
393  array_iftable_->SetInterface(0, java_lang_Cloneable);
394  array_iftable_->SetInterface(1, java_io_Serializable);
395
396  // Sanity check Class[] and Object[]'s interfaces.
397  ClassHelper kh(class_array_class.get());
398  CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
399  CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
400  kh.ChangeClass(object_array_class.get());
401  CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
402  CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
403  // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their
404  // dex_cache_ fields and register them in class_table_.
405  mirror::Class* Class_class = FindSystemClass(self, "Ljava/lang/Class;");
406  CHECK_EQ(java_lang_Class.get(), Class_class);
407
408  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady, self);
409  mirror::Class* Art_method_class = FindSystemClass(self, "Ljava/lang/reflect/ArtMethod;");
410  CHECK_EQ(java_lang_reflect_ArtMethod.get(), Art_method_class);
411
412  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady, self);
413  mirror::Class* Art_field_class = FindSystemClass(self, "Ljava/lang/reflect/ArtField;");
414  CHECK_EQ(java_lang_reflect_ArtField.get(), Art_field_class);
415
416  mirror::Class* String_array_class = FindSystemClass(self, class_roots_descriptors_[kJavaLangStringArrayClass]);
417  CHECK_EQ(object_array_string.get(), String_array_class);
418
419  mirror::Class* Art_method_array_class =
420      FindSystemClass(self, class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]);
421  CHECK_EQ(object_array_art_method.get(), Art_method_array_class);
422
423  mirror::Class* Art_field_array_class =
424      FindSystemClass(self, class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]);
425  CHECK_EQ(object_array_art_field.get(), Art_field_array_class);
426
427  // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
428
429  // Create java.lang.reflect.Proxy root.
430  mirror::Class* java_lang_reflect_Proxy = FindSystemClass(self, "Ljava/lang/reflect/Proxy;");
431  SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
432
433  // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
434  mirror::Class* java_lang_ref_Reference = FindSystemClass(self, "Ljava/lang/ref/Reference;");
435  SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
436  mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
437  java_lang_ref_FinalizerReference->SetAccessFlags(
438      java_lang_ref_FinalizerReference->GetAccessFlags() |
439          kAccClassIsReference | kAccClassIsFinalizerReference);
440  mirror::Class* java_lang_ref_PhantomReference = FindSystemClass(self, "Ljava/lang/ref/PhantomReference;");
441  java_lang_ref_PhantomReference->SetAccessFlags(
442      java_lang_ref_PhantomReference->GetAccessFlags() |
443          kAccClassIsReference | kAccClassIsPhantomReference);
444  mirror::Class* java_lang_ref_SoftReference = FindSystemClass(self, "Ljava/lang/ref/SoftReference;");
445  java_lang_ref_SoftReference->SetAccessFlags(
446      java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
447  mirror::Class* java_lang_ref_WeakReference = FindSystemClass(self, "Ljava/lang/ref/WeakReference;");
448  java_lang_ref_WeakReference->SetAccessFlags(
449      java_lang_ref_WeakReference->GetAccessFlags() |
450          kAccClassIsReference | kAccClassIsWeakReference);
451
452  // Setup the ClassLoader, verifying the object_size_.
453  mirror::Class* java_lang_ClassLoader = FindSystemClass(self, "Ljava/lang/ClassLoader;");
454  CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(mirror::ClassLoader));
455  SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
456
457  // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
458  // java.lang.StackTraceElement as a convenience.
459  SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;"));
460  mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
461  SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass(self, "Ljava/lang/ClassNotFoundException;"));
462  SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;"));
463  SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass(self, "[Ljava/lang/StackTraceElement;"));
464  mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
465
466  FinishInit(self);
467
468  VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
469}
470
471void ClassLinker::FinishInit(Thread* self) {
472  VLOG(startup) << "ClassLinker::FinishInit entering";
473
474  // Let the heap know some key offsets into java.lang.ref instances
475  // Note: we hard code the field indexes here rather than using FindInstanceField
476  // as the types of the field can't be resolved prior to the runtime being
477  // fully initialized
478  mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
479  mirror::Class* java_lang_ref_FinalizerReference =
480      FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
481
482  mirror::ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
483  FieldHelper fh(pendingNext);
484  CHECK_STREQ(fh.GetName(), "pendingNext");
485  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
486
487  mirror::ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
488  fh.ChangeField(queue);
489  CHECK_STREQ(fh.GetName(), "queue");
490  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
491
492  mirror::ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
493  fh.ChangeField(queueNext);
494  CHECK_STREQ(fh.GetName(), "queueNext");
495  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
496
497  mirror::ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
498  fh.ChangeField(referent);
499  CHECK_STREQ(fh.GetName(), "referent");
500  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
501
502  mirror::ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
503  fh.ChangeField(zombie);
504  CHECK_STREQ(fh.GetName(), "zombie");
505  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
506
507  gc::Heap* heap = Runtime::Current()->GetHeap();
508  heap->SetReferenceOffsets(referent->GetOffset(),
509                            queue->GetOffset(),
510                            queueNext->GetOffset(),
511                            pendingNext->GetOffset(),
512                            zombie->GetOffset());
513
514  // ensure all class_roots_ are initialized
515  for (size_t i = 0; i < kClassRootsMax; i++) {
516    ClassRoot class_root = static_cast<ClassRoot>(i);
517    mirror::Class* klass = GetClassRoot(class_root);
518    CHECK(klass != NULL);
519    DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
520    // note SetClassRoot does additional validation.
521    // if possible add new checks there to catch errors early
522  }
523
524  CHECK(array_iftable_ != NULL);
525
526  // disable the slow paths in FindClass and CreatePrimitiveClass now
527  // that Object, Class, and Object[] are setup
528  init_done_ = true;
529
530  VLOG(startup) << "ClassLinker::FinishInit exiting";
531}
532
533void ClassLinker::RunRootClinits() {
534  Thread* self = Thread::Current();
535  for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
536    mirror::Class* c = GetClassRoot(ClassRoot(i));
537    if (!c->IsArrayClass() && !c->IsPrimitive()) {
538      SirtRef<mirror::Class> sirt_class(self, GetClassRoot(ClassRoot(i)));
539      EnsureInitialized(sirt_class, true, true);
540      self->AssertNoPendingException();
541    }
542  }
543}
544
545bool ClassLinker::GenerateOatFile(const char* dex_filename,
546                                  int oat_fd,
547                                  const char* oat_cache_filename,
548                                  std::string* error_msg) {
549  Locks::mutator_lock_->AssertNotHeld(Thread::Current());  // Avoid starving GC.
550  std::string dex2oat(GetAndroidRoot());
551  dex2oat += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
552
553  gc::Heap* heap = Runtime::Current()->GetHeap();
554  std::string boot_image_option("--boot-image=");
555  boot_image_option += heap->GetImageSpace()->GetImageFilename();
556
557  std::string dex_file_option("--dex-file=");
558  dex_file_option += dex_filename;
559
560  std::string oat_fd_option("--oat-fd=");
561  StringAppendF(&oat_fd_option, "%d", oat_fd);
562
563  std::string oat_location_option("--oat-location=");
564  oat_location_option += oat_cache_filename;
565
566  std::vector<std::string> argv;
567  argv.push_back(dex2oat);
568  argv.push_back("--runtime-arg");
569  argv.push_back("-Xms64m");
570  argv.push_back("--runtime-arg");
571  argv.push_back("-Xmx64m");
572  argv.push_back("--runtime-arg");
573  argv.push_back("-classpath");
574  argv.push_back("--runtime-arg");
575  argv.push_back(Runtime::Current()->GetClassPathString());
576  if (!kIsTargetBuild) {
577    argv.push_back("--host");
578  }
579  argv.push_back(boot_image_option);
580  argv.push_back(dex_file_option);
581  argv.push_back(oat_fd_option);
582  argv.push_back(oat_location_option);
583  const std::vector<std::string>& compiler_options = Runtime::Current()->GetCompilerOptions();
584  for (size_t i = 0; compiler_options.size(); ++i) {
585    argv.push_back(compiler_options[i].c_str());
586  }
587
588  return Exec(argv, error_msg);
589}
590
591const OatFile* ClassLinker::RegisterOatFile(const OatFile* oat_file) {
592  WriterMutexLock mu(Thread::Current(), dex_lock_);
593  if (kIsDebugBuild) {
594    for (size_t i = 0; i < oat_files_.size(); ++i) {
595      CHECK_NE(oat_file, oat_files_[i]) << oat_file->GetLocation();
596    }
597  }
598  VLOG(class_linker) << "Registering " << oat_file->GetLocation();
599  oat_files_.push_back(oat_file);
600  return oat_file;
601}
602
603OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) {
604  VLOG(startup) << "ClassLinker::GetImageOatFile entering";
605  OatFile* oat_file = space->ReleaseOatFile();
606  CHECK_EQ(RegisterOatFile(oat_file), oat_file);
607  VLOG(startup) << "ClassLinker::GetImageOatFile exiting";
608  return *oat_file;
609}
610
611const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
612  const char* dex_location = dex_file.GetLocation().c_str();
613  uint32_t dex_location_checksum = dex_file.GetLocationChecksum();
614  return FindOpenedOatFileFromDexLocation(dex_location, &dex_location_checksum);
615}
616
617const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const char* dex_location,
618                                                             const uint32_t* const dex_location_checksum) {
619  ReaderMutexLock mu(Thread::Current(), dex_lock_);
620  for (size_t i = 0; i < oat_files_.size(); i++) {
621    const OatFile* oat_file = oat_files_[i];
622    DCHECK(oat_file != NULL);
623    const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
624                                                                      dex_location_checksum,
625                                                                      false);
626    if (oat_dex_file != NULL) {
627      return oat_file;
628    }
629  }
630  return NULL;
631}
632
633const DexFile* ClassLinker::FindDexFileInOatLocation(const char* dex_location,
634                                                     uint32_t dex_location_checksum,
635                                                     const char* oat_location,
636                                                     std::string* error_msg) {
637  UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
638                                            !Runtime::Current()->IsCompiler(),
639                                            error_msg));
640  if (oat_file.get() == nullptr) {
641    *error_msg = StringPrintf("Failed to find existing oat file at %s: %s", oat_location,
642                              error_msg->c_str());
643    return nullptr;
644  }
645  Runtime* runtime = Runtime::Current();
646  const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
647  uint32_t expected_image_oat_checksum = image_header.GetOatChecksum();
648  uint32_t actual_image_oat_checksum = oat_file->GetOatHeader().GetImageFileLocationOatChecksum();
649  if (expected_image_oat_checksum != actual_image_oat_checksum) {
650    *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat checksum of "
651                              "0x%x, found 0x%x", oat_location, expected_image_oat_checksum,
652                              actual_image_oat_checksum);
653    return nullptr;
654  }
655
656  uintptr_t expected_image_oat_offset = reinterpret_cast<uintptr_t>(image_header.GetOatDataBegin());
657  uint32_t actual_image_oat_offset = oat_file->GetOatHeader().GetImageFileLocationOatDataBegin();
658  if (expected_image_oat_offset != actual_image_oat_offset) {
659    *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat offset %"
660                              PRIuPTR ", found %ud", oat_location, expected_image_oat_offset,
661                              actual_image_oat_offset);
662    return nullptr;
663  }
664  // TODO: this registers the oat file now as we may use the oat_dex_file later and we want the
665  //       intern behavior of RegisterOatFile. However, if we take an early return we could remove
666  //       the oat file.
667  const OatFile* opened_oat_file = RegisterOatFile(oat_file.release());
668  const OatFile::OatDexFile* oat_dex_file = opened_oat_file->GetOatDexFile(dex_location,
669                                                                           &dex_location_checksum);
670  if (oat_dex_file == nullptr) {
671    *error_msg = StringPrintf("Failed to find oat file at '%s' containing '%s'", oat_location,
672                              dex_location);
673    return nullptr;
674  }
675  uint32_t expected_dex_checksum = dex_location_checksum;
676  uint32_t actual_dex_checksum = oat_dex_file->GetDexFileLocationChecksum();
677  if (expected_dex_checksum != actual_dex_checksum) {
678    *error_msg = StringPrintf("Failed to find oat file at '%s' with expected dex checksum of 0x%x, "
679                              "found 0x%x", oat_location, expected_dex_checksum,
680                              actual_dex_checksum);
681    return nullptr;
682  }
683  return oat_dex_file->OpenDexFile(error_msg);
684}
685
686class ScopedFlock {
687 public:
688  ScopedFlock() {}
689
690  bool Init(const char* filename, std::string* error_msg) {
691    while (true) {
692      file_.reset(OS::OpenFileWithFlags(filename, O_CREAT | O_RDWR));
693      if (file_.get() == NULL) {
694        *error_msg = StringPrintf("Failed to open file '%s'", filename);
695        return false;
696      }
697      int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_EX));
698      if (flock_result != 0) {
699        *error_msg = StringPrintf("Failed to lock file '%s': %s", filename, strerror(errno));
700        return false;
701      }
702      struct stat fstat_stat;
703      int fstat_result = TEMP_FAILURE_RETRY(fstat(file_->Fd(), &fstat_stat));
704      if (fstat_result != 0) {
705        *error_msg = StringPrintf("Failed to fstat file '%s': %s", filename, strerror(errno));
706        return false;
707      }
708      struct stat stat_stat;
709      int stat_result = TEMP_FAILURE_RETRY(stat(filename, &stat_stat));
710      if (stat_result != 0) {
711        PLOG(WARNING) << "Failed to stat, will retry: " << filename;
712        // ENOENT can happen if someone racing with us unlinks the file we created so just retry.
713        continue;
714      }
715      if (fstat_stat.st_dev != stat_stat.st_dev || fstat_stat.st_ino != stat_stat.st_ino) {
716        LOG(WARNING) << "File changed while locking, will retry: " << filename;
717        continue;
718      }
719      return true;
720    }
721  }
722
723  File& GetFile() {
724    return *file_;
725  }
726
727  ~ScopedFlock() {
728    if (file_.get() != NULL) {
729      int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_UN));
730      CHECK_EQ(0, flock_result);
731    }
732  }
733
734 private:
735  UniquePtr<File> file_;
736
737  DISALLOW_COPY_AND_ASSIGN(ScopedFlock);
738};
739
740const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const char* dex_location,
741                                                              uint32_t dex_location_checksum,
742                                                              const char* oat_location,
743                                                              std::string* error_msg) {
744  // We play a locking game here so that if two different processes
745  // race to generate (or worse, one tries to open a partial generated
746  // file) we will be okay. This is actually common with apps that use
747  // DexClassLoader to work around the dex method reference limit and
748  // that have a background service running in a separate process.
749  ScopedFlock scoped_flock;
750  if (!scoped_flock.Init(oat_location, error_msg)) {
751    return nullptr;
752  }
753
754  // Check if we already have an up-to-date output file
755  const DexFile* dex_file = FindDexFileInOatLocation(dex_location, dex_location_checksum,
756                                                     oat_location, error_msg);
757  if (dex_file != nullptr) {
758    return dex_file;
759  }
760  VLOG(class_linker) << "Failed to find dex file '" << dex_location << "' in oat location '"
761      << oat_location << "': " << *error_msg;
762  error_msg->clear();
763
764  // Generate the output oat file for the dex file
765  VLOG(class_linker) << "Generating oat file " << oat_location << " for " << dex_location;
766  if (!GenerateOatFile(dex_location, scoped_flock.GetFile().Fd(), oat_location, error_msg)) {
767    CHECK(!error_msg->empty());
768    return nullptr;
769  }
770  const OatFile* oat_file = OatFile::Open(oat_location, oat_location, NULL,
771                                          !Runtime::Current()->IsCompiler(),
772                                          error_msg);
773  if (oat_file == nullptr) {
774    *error_msg = StringPrintf("Failed to open generated oat file '%s': %s",
775                              oat_location, error_msg->c_str());
776    return nullptr;
777  }
778  oat_file = RegisterOatFile(oat_file);
779  const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
780                                                                    &dex_location_checksum);
781  if (oat_dex_file == nullptr) {
782    *error_msg = StringPrintf("Failed to find dex file '%s' (checksum 0x%x) in generated out file "
783                              "'%s'", dex_location, dex_location_checksum, oat_location);
784    return nullptr;
785  }
786  const DexFile* result = oat_dex_file->OpenDexFile(error_msg);
787  CHECK(result != nullptr) << *error_msg;
788  CHECK_EQ(dex_location_checksum, result->GetLocationChecksum())
789          << "dex_location=" << dex_location << " oat_location=" << oat_location << std::hex
790          << " dex_location_checksum=" << dex_location_checksum
791          << " DexFile::GetLocationChecksum()=" << result->GetLocationChecksum();
792  return result;
793}
794
795bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
796                                         const char* dex_location,
797                                         uint32_t dex_location_checksum,
798                                         std::string* error_msg) {
799  Runtime* runtime = Runtime::Current();
800  const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
801  uint32_t image_oat_checksum = image_header.GetOatChecksum();
802  uintptr_t image_oat_data_begin = reinterpret_cast<uintptr_t>(image_header.GetOatDataBegin());
803  bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
804                      && (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin() == image_oat_data_begin));
805
806  const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, &dex_location_checksum);
807  if (oat_dex_file == NULL) {
808    *error_msg = StringPrintf("oat file '%s' does not contain contents for '%s' with checksum 0x%x",
809                              oat_file->GetLocation().c_str(), dex_location, dex_location_checksum);
810    std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
811    for (size_t i = 0; i < oat_dex_files.size(); i++) {
812      const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
813      *error_msg  += StringPrintf("\noat file '%s' contains contents for '%s'",
814                                  oat_file->GetLocation().c_str(),
815                                  oat_dex_file->GetDexFileLocation().c_str());
816    }
817    return false;
818  }
819  bool dex_check = dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
820
821  if (image_check && dex_check) {
822    return true;
823  }
824
825  if (!image_check) {
826    ScopedObjectAccess soa(Thread::Current());
827    *error_msg = StringPrintf("oat file '%s' mismatch (0x%x, %d) with (0x%x, %" PRIdPTR ")",
828                              oat_file->GetLocation().c_str(),
829                              oat_file->GetOatHeader().GetImageFileLocationOatChecksum(),
830                              oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(),
831                              image_oat_checksum, image_oat_data_begin);
832  }
833  if (!dex_check) {
834    *error_msg = StringPrintf("oat file '%s' mismatch (0x%x) with '%s' (0x%x)",
835                              oat_file->GetLocation().c_str(),
836                              oat_dex_file->GetDexFileLocationChecksum(),
837                              dex_location, dex_location_checksum);
838  }
839  return false;
840}
841
842const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const std::string& oat_file_location,
843                                                            const char* dex_location,
844                                                            std::string* error_msg,
845                                                            bool* open_failed) {
846  UniquePtr<const OatFile> oat_file(FindOatFileFromOatLocation(oat_file_location, error_msg));
847  if (oat_file.get() == nullptr) {
848    *open_failed = true;
849    return nullptr;
850  }
851  *open_failed = false;
852  uint32_t dex_location_checksum;
853  if (!DexFile::GetChecksum(dex_location, &dex_location_checksum, error_msg)) {
854    // If no classes.dex found in dex_location, it has been stripped or is corrupt, assume oat is
855    // up-to-date. This is the common case in user builds for jar's and apk's in the /system
856    // directory.
857    const OatFile* opened_oat_file = oat_file.release();
858    opened_oat_file = RegisterOatFile(opened_oat_file);
859    const OatFile::OatDexFile* oat_dex_file = opened_oat_file->GetOatDexFile(dex_location, NULL);
860    if (oat_dex_file == nullptr) {
861      *error_msg = StringPrintf("Dex checksum mismatch for location '%s' and failed to find oat "
862                                "dex file '%s': %s", oat_file_location.c_str(), dex_location,
863                                error_msg->c_str());
864      return nullptr;
865    }
866    return oat_dex_file->OpenDexFile(error_msg);
867  }
868
869  bool verified = VerifyOatFileChecksums(oat_file.get(), dex_location, dex_location_checksum,
870                                         error_msg);
871  if (!verified) {
872    return nullptr;
873  }
874  const OatFile* opened_oat_file = oat_file.release();
875  opened_oat_file = RegisterOatFile(opened_oat_file);
876  return opened_oat_file->GetOatDexFile(dex_location,
877                                        &dex_location_checksum)->OpenDexFile(error_msg);
878}
879
880const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const char* dex_location,
881                                                                const uint32_t* const dex_location_checksum,
882                                                                std::string* error_msg) {
883  const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location,
884                                                                  dex_location_checksum);
885  if (open_oat_file != nullptr) {
886    const OatFile::OatDexFile* oat_dex_file = open_oat_file->GetOatDexFile(dex_location,
887                                                                           dex_location_checksum);
888    return oat_dex_file->OpenDexFile(error_msg);
889  }
890
891  // Look for an existing file next to dex. for example, for
892  // /foo/bar/baz.jar, look for /foo/bar/baz.odex.
893  std::string odex_filename(OatFile::DexFilenameToOdexFilename(dex_location));
894  bool open_failed;
895  const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(odex_filename, dex_location,
896                                                            error_msg, &open_failed);
897  if (dex_file != nullptr) {
898    return dex_file;
899  }
900  if (dex_location_checksum == nullptr) {
901    *error_msg = StringPrintf("Failed to open oat file from %s and no classes.dex found in %s: %s",
902                              odex_filename.c_str(), dex_location, error_msg->c_str());
903    return nullptr;
904  }
905
906  std::string cache_error_msg;
907  std::string cache_location(GetDalvikCacheFilenameOrDie(dex_location));
908  dex_file = VerifyAndOpenDexFileFromOatFile(cache_location, dex_location, &cache_error_msg,
909                                             &open_failed);
910  if (dex_file != nullptr) {
911    return dex_file;
912  }
913  if (!open_failed && TEMP_FAILURE_RETRY(unlink(cache_location.c_str())) != 0) {
914    PLOG(FATAL) << "Failed to remove obsolete oat file from " << cache_location;
915  }
916  VLOG(class_linker) << "Failed to open oat file from " << odex_filename
917      << " (error '" << *error_msg << "') or " << cache_location
918      << " (error '" << cache_error_msg << "').";
919
920  // Try to generate oat file if it wasn't found or was obsolete.
921  error_msg->clear();
922  return FindOrCreateOatFileForDexLocation(dex_location, *dex_location_checksum,
923                                           cache_location.c_str(), error_msg);
924}
925
926const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
927  ReaderMutexLock mu(Thread::Current(), dex_lock_);
928  for (size_t i = 0; i < oat_files_.size(); i++) {
929    const OatFile* oat_file = oat_files_[i];
930    DCHECK(oat_file != nullptr);
931    if (oat_file->GetLocation() == oat_location) {
932      return oat_file;
933    }
934  }
935  return nullptr;
936}
937
938const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location,
939                                                       std::string* error_msg) {
940  const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
941  if (oat_file != nullptr) {
942    return oat_file;
943  }
944
945  oat_file = OatFile::Open(oat_location, oat_location, NULL, !Runtime::Current()->IsCompiler(),
946                           error_msg);
947  if (oat_file == NULL) {
948    return NULL;
949  }
950  return oat_file;
951}
952
953static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
954    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
955  ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
956
957  DCHECK(obj != NULL);
958  DCHECK(class_linker != NULL);
959
960  if (obj->IsArtMethod()) {
961    mirror::ArtMethod* method = obj->AsArtMethod();
962    if (!method->IsNative()) {
963      method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
964      if (method != Runtime::Current()->GetResolutionMethod()) {
965        method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
966        method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
967      }
968    }
969  }
970}
971
972void ClassLinker::InitFromImage() {
973  VLOG(startup) << "ClassLinker::InitFromImage entering";
974  CHECK(!init_done_);
975
976  Thread* self = Thread::Current();
977  gc::Heap* heap = Runtime::Current()->GetHeap();
978  gc::space::ImageSpace* space = heap->GetImageSpace();
979  dex_cache_image_class_lookup_required_ = true;
980  CHECK(space != NULL);
981  OatFile& oat_file = GetImageOatFile(space);
982  CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
983  CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
984  CHECK(oat_file.GetOatHeader().GetImageFileLocation().empty());
985  portable_resolution_trampoline_ = oat_file.GetOatHeader().GetPortableResolutionTrampoline();
986  quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
987  portable_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetPortableImtConflictTrampoline();
988  quick_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetQuickImtConflictTrampoline();
989  quick_generic_jni_trampoline_ = oat_file.GetOatHeader().GetQuickGenericJniTrampoline();
990  mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
991  mirror::ObjectArray<mirror::DexCache>* dex_caches =
992      dex_caches_object->AsObjectArray<mirror::DexCache>();
993
994  SirtRef<mirror::ObjectArray<mirror::Class> > class_roots(
995      self,
996      space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>());
997  class_roots_ = class_roots.get();
998
999  // Special case of setting up the String class early so that we can test arbitrary objects
1000  // as being Strings or not
1001  mirror::String::SetClass(GetClassRoot(kJavaLangString));
1002
1003  CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
1004           static_cast<uint32_t>(dex_caches->GetLength()));
1005  for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
1006    SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
1007    const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
1008    const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location.c_str(),
1009                                                                     nullptr);
1010    CHECK(oat_dex_file != NULL) << oat_file.GetLocation() << " " << dex_file_location;
1011    std::string error_msg;
1012    const DexFile* dex_file = oat_dex_file->OpenDexFile(&error_msg);
1013    if (dex_file == NULL) {
1014      LOG(FATAL) << "Failed to open dex file " << dex_file_location
1015                 << " from within oat file " << oat_file.GetLocation()
1016                 << " error '" << error_msg << "'";
1017    }
1018
1019    CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
1020
1021    AppendToBootClassPath(*dex_file, dex_cache);
1022  }
1023
1024  // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
1025  // bitmap walk.
1026  mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod));
1027
1028  // Set entry point to interpreter if in InterpretOnly mode.
1029  if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
1030    ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
1031    heap->VisitObjects(InitFromImageInterpretOnlyCallback, this);
1032  }
1033
1034  // reinit class_roots_
1035  mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
1036  class_roots_ = class_roots.get();
1037
1038  // reinit array_iftable_ from any array class instance, they should be ==
1039  array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1040  DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
1041  // String class root was set above
1042  mirror::ArtField::SetClass(GetClassRoot(kJavaLangReflectArtField));
1043  mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1044  mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1045  mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1046  mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1047  mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1048  mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1049  mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1050  mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1051  mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1052  mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
1053
1054  FinishInit(self);
1055
1056  VLOG(startup) << "ClassLinker::InitFromImage exiting";
1057}
1058
1059// Keep in sync with InitCallback. Anything we visit, we need to
1060// reinit references to when reinitializing a ClassLinker from a
1061// mapped image.
1062void ClassLinker::VisitRoots(RootCallback* callback, void* arg, bool only_dirty, bool clean_dirty) {
1063  callback(reinterpret_cast<mirror::Object**>(&class_roots_), arg, 0, kRootVMInternal);
1064  Thread* self = Thread::Current();
1065  {
1066    ReaderMutexLock mu(self, dex_lock_);
1067    if (!only_dirty || dex_caches_dirty_) {
1068      for (mirror::DexCache*& dex_cache : dex_caches_) {
1069        callback(reinterpret_cast<mirror::Object**>(&dex_cache), arg, 0, kRootVMInternal);
1070        DCHECK(dex_cache != nullptr);
1071      }
1072      if (clean_dirty) {
1073        dex_caches_dirty_ = false;
1074      }
1075    }
1076  }
1077  {
1078    WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
1079    if (!only_dirty || class_table_dirty_) {
1080      for (std::pair<const size_t, mirror::Class*>& it : class_table_) {
1081        callback(reinterpret_cast<mirror::Object**>(&it.second), arg, 0, kRootStickyClass);
1082        DCHECK(it.second != nullptr);
1083      }
1084      if (clean_dirty) {
1085        class_table_dirty_ = false;
1086      }
1087    }
1088    // We deliberately ignore the class roots in the image since we
1089    // handle image roots by using the MS/CMS rescanning of dirty cards.
1090  }
1091  callback(reinterpret_cast<mirror::Object**>(&array_iftable_), arg, 0, kRootVMInternal);
1092  DCHECK(array_iftable_ != nullptr);
1093  for (size_t i = 0; i < kFindArrayCacheSize; ++i) {
1094    if (find_array_class_cache_[i] != nullptr) {
1095      callback(reinterpret_cast<mirror::Object**>(&find_array_class_cache_[i]), arg, 0,
1096               kRootVMInternal);
1097      DCHECK(find_array_class_cache_[i] != nullptr);
1098    }
1099  }
1100}
1101
1102void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) {
1103  if (dex_cache_image_class_lookup_required_) {
1104    MoveImageClassesToClassTable();
1105  }
1106  WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
1107  for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
1108    if (!visitor(it.second, arg)) {
1109      return;
1110    }
1111  }
1112}
1113
1114static bool GetClassesVisitor(mirror::Class* c, void* arg) {
1115  std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
1116  classes->insert(c);
1117  return true;
1118}
1119
1120void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) {
1121  std::set<mirror::Class*> classes;
1122  VisitClasses(GetClassesVisitor, &classes);
1123  for (mirror::Class* klass : classes) {
1124    if (!visitor(klass, arg)) {
1125      return;
1126    }
1127  }
1128}
1129
1130ClassLinker::~ClassLinker() {
1131  mirror::Class::ResetClass();
1132  mirror::String::ResetClass();
1133  mirror::ArtField::ResetClass();
1134  mirror::ArtMethod::ResetClass();
1135  mirror::BooleanArray::ResetArrayClass();
1136  mirror::ByteArray::ResetArrayClass();
1137  mirror::CharArray::ResetArrayClass();
1138  mirror::DoubleArray::ResetArrayClass();
1139  mirror::FloatArray::ResetArrayClass();
1140  mirror::IntArray::ResetArrayClass();
1141  mirror::LongArray::ResetArrayClass();
1142  mirror::ShortArray::ResetArrayClass();
1143  mirror::Throwable::ResetClass();
1144  mirror::StackTraceElement::ResetClass();
1145  STLDeleteElements(&boot_class_path_);
1146  STLDeleteElements(&oat_files_);
1147}
1148
1149mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
1150  gc::Heap* heap = Runtime::Current()->GetHeap();
1151  SirtRef<mirror::Class> dex_cache_class(self, GetClassRoot(kJavaLangDexCache));
1152  SirtRef<mirror::DexCache> dex_cache(
1153      self, down_cast<mirror::DexCache*>(
1154          heap->AllocObject<true>(self, dex_cache_class.get(), dex_cache_class->GetObjectSize())));
1155  if (dex_cache.get() == NULL) {
1156    return NULL;
1157  }
1158  SirtRef<mirror::String>
1159      location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
1160  if (location.get() == NULL) {
1161    return NULL;
1162  }
1163  SirtRef<mirror::ObjectArray<mirror::String> >
1164      strings(self, AllocStringArray(self, dex_file.NumStringIds()));
1165  if (strings.get() == NULL) {
1166    return NULL;
1167  }
1168  SirtRef<mirror::ObjectArray<mirror::Class> >
1169      types(self, AllocClassArray(self, dex_file.NumTypeIds()));
1170  if (types.get() == NULL) {
1171    return NULL;
1172  }
1173  SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
1174      methods(self, AllocArtMethodArray(self, dex_file.NumMethodIds()));
1175  if (methods.get() == NULL) {
1176    return NULL;
1177  }
1178  SirtRef<mirror::ObjectArray<mirror::ArtField> >
1179      fields(self, AllocArtFieldArray(self, dex_file.NumFieldIds()));
1180  if (fields.get() == NULL) {
1181    return NULL;
1182  }
1183  dex_cache->Init(&dex_file, location.get(), strings.get(), types.get(), methods.get(),
1184                  fields.get());
1185  return dex_cache.get();
1186}
1187
1188// Used to initialize a class in the allocation code path to ensure it is guarded by a StoreStore
1189// fence.
1190class InitializeClassVisitor {
1191 public:
1192  explicit InitializeClassVisitor(uint32_t class_size) : class_size_(class_size) {
1193  }
1194
1195  void operator()(mirror::Object* obj, size_t usable_size) const
1196      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1197    DCHECK_LE(class_size_, usable_size);
1198    // Avoid AsClass as object is not yet in live bitmap or allocation stack.
1199    mirror::Class* klass = down_cast<mirror::Class*>(obj);
1200    // DCHECK(klass->IsClass());
1201    klass->SetClassSize(class_size_);
1202    klass->SetPrimitiveType(Primitive::kPrimNot);  // Default to not being primitive.
1203    klass->SetDexClassDefIndex(DexFile::kDexNoIndex16);  // Default to no valid class def index.
1204    klass->SetDexTypeIndex(DexFile::kDexNoIndex16);  // Default to no valid type index.
1205  }
1206
1207 private:
1208  const uint32_t class_size_;
1209
1210  DISALLOW_COPY_AND_ASSIGN(InitializeClassVisitor);
1211};
1212
1213mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
1214                                       uint32_t class_size) {
1215  DCHECK_GE(class_size, sizeof(mirror::Class));
1216  gc::Heap* heap = Runtime::Current()->GetHeap();
1217  InitializeClassVisitor visitor(class_size);
1218  mirror::Object* k =
1219      kMovingClasses ? heap->AllocObject<true>(self, java_lang_Class, class_size, visitor)
1220                     : heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor);
1221  if (UNLIKELY(k == nullptr)) {
1222    CHECK(self->IsExceptionPending());  // OOME.
1223    return nullptr;
1224  }
1225  return k->AsClass();
1226}
1227
1228mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) {
1229  return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
1230}
1231
1232mirror::ArtField* ClassLinker::AllocArtField(Thread* self) {
1233  return down_cast<mirror::ArtField*>(
1234      GetClassRoot(kJavaLangReflectArtField)->AllocNonMovableObject(self));
1235}
1236
1237mirror::ArtMethod* ClassLinker::AllocArtMethod(Thread* self) {
1238  return down_cast<mirror::ArtMethod*>(
1239      GetClassRoot(kJavaLangReflectArtMethod)->AllocNonMovableObject(self));
1240}
1241
1242mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(
1243    Thread* self, size_t length) {
1244  return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(
1245      self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
1246}
1247
1248static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
1249    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1250  DCHECK(klass != NULL);
1251  // Wait for the class if it has not already been linked.
1252  if (!klass->IsResolved() && !klass->IsErroneous()) {
1253    SirtRef<mirror::Class> sirt_class(self, klass);
1254    ObjectLock<mirror::Class> lock(self, &sirt_class);
1255    // Check for circular dependencies between classes.
1256    if (!sirt_class->IsResolved() && sirt_class->GetClinitThreadId() == self->GetTid()) {
1257      ThrowClassCircularityError(sirt_class.get());
1258      sirt_class->SetStatus(mirror::Class::kStatusError, self);
1259      return nullptr;
1260    }
1261    // Wait for the pending initialization to complete.
1262    while (!sirt_class->IsResolved() && !sirt_class->IsErroneous()) {
1263      lock.WaitIgnoringInterrupts();
1264    }
1265    klass = sirt_class.get();
1266  }
1267  if (klass->IsErroneous()) {
1268    ThrowEarlierClassFailure(klass);
1269    return nullptr;
1270  }
1271  // Return the loaded class.  No exceptions should be pending.
1272  CHECK(klass->IsResolved()) << PrettyClass(klass);
1273  self->AssertNoPendingException();
1274  return klass;
1275}
1276
1277mirror::Class* ClassLinker::FindClass(Thread* self, const char* descriptor,
1278                                      const SirtRef<mirror::ClassLoader>& class_loader) {
1279  DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
1280  DCHECK(self != nullptr);
1281  self->AssertNoPendingException();
1282  if (descriptor[1] == '\0') {
1283    // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1284    // for primitive classes that aren't backed by dex files.
1285    return FindPrimitiveClass(descriptor[0]);
1286  }
1287  // Find the class in the loaded classes table.
1288  mirror::Class* klass = LookupClass(descriptor, class_loader.get());
1289  if (klass != NULL) {
1290    return EnsureResolved(self, klass);
1291  }
1292  // Class is not yet loaded.
1293  if (descriptor[0] == '[') {
1294    return CreateArrayClass(self, descriptor, class_loader);
1295  } else if (class_loader.get() == nullptr) {
1296    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1297    if (pair.second != NULL) {
1298      SirtRef<mirror::ClassLoader> class_loader(self, nullptr);
1299      return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
1300    }
1301  } else if (Runtime::Current()->UseCompileTimeClassPath()) {
1302    // First try the boot class path, we check the descriptor first to avoid an unnecessary
1303    // throw of a NoClassDefFoundError.
1304    if (IsInBootClassPath(descriptor)) {
1305      mirror::Class* system_class = FindSystemClass(self, descriptor);
1306      CHECK(system_class != NULL);
1307      return system_class;
1308    }
1309    // Next try the compile time class path.
1310    const std::vector<const DexFile*>* class_path;
1311    {
1312      ScopedObjectAccessUnchecked soa(self);
1313      ScopedLocalRef<jobject> jclass_loader(soa.Env(),
1314                                            soa.AddLocalReference<jobject>(class_loader.get()));
1315      class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1316    }
1317
1318    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
1319    if (pair.second != NULL) {
1320      return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
1321    }
1322
1323  } else {
1324    ScopedObjectAccessUnchecked soa(self);
1325    ScopedLocalRef<jobject> class_loader_object(soa.Env(),
1326                                                soa.AddLocalReference<jobject>(class_loader.get()));
1327    std::string class_name_string(DescriptorToDot(descriptor));
1328    ScopedLocalRef<jobject> result(soa.Env(), NULL);
1329    {
1330      ScopedThreadStateChange tsc(self, kNative);
1331      ScopedLocalRef<jobject> class_name_object(soa.Env(),
1332                                                soa.Env()->NewStringUTF(class_name_string.c_str()));
1333      if (class_name_object.get() == NULL) {
1334        return NULL;
1335      }
1336      CHECK(class_loader_object.get() != NULL);
1337      result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1338                                               WellKnownClasses::java_lang_ClassLoader_loadClass,
1339                                               class_name_object.get()));
1340    }
1341    if (self->IsExceptionPending()) {
1342      // If the ClassLoader threw, pass that exception up.
1343      return NULL;
1344    } else if (result.get() == NULL) {
1345      // broken loader - throw NPE to be compatible with Dalvik
1346      ThrowNullPointerException(NULL, StringPrintf("ClassLoader.loadClass returned null for %s",
1347                                                   class_name_string.c_str()).c_str());
1348      return NULL;
1349    } else {
1350      // success, return mirror::Class*
1351      return soa.Decode<mirror::Class*>(result.get());
1352    }
1353  }
1354
1355  ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
1356  return NULL;
1357}
1358
1359mirror::Class* ClassLinker::DefineClass(const char* descriptor,
1360                                        const SirtRef<mirror::ClassLoader>& class_loader,
1361                                        const DexFile& dex_file,
1362                                        const DexFile::ClassDef& dex_class_def) {
1363  Thread* self = Thread::Current();
1364  SirtRef<mirror::Class> klass(self, NULL);
1365  // Load the class from the dex file.
1366  if (UNLIKELY(!init_done_)) {
1367    // finish up init of hand crafted class_roots_
1368    if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
1369      klass.reset(GetClassRoot(kJavaLangObject));
1370    } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
1371      klass.reset(GetClassRoot(kJavaLangClass));
1372    } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
1373      klass.reset(GetClassRoot(kJavaLangString));
1374    } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
1375      klass.reset(GetClassRoot(kJavaLangDexCache));
1376    } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtField;") == 0) {
1377      klass.reset(GetClassRoot(kJavaLangReflectArtField));
1378    } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) {
1379      klass.reset(GetClassRoot(kJavaLangReflectArtMethod));
1380    } else {
1381      klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
1382    }
1383  } else {
1384    klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
1385  }
1386  if (UNLIKELY(klass.get() == NULL)) {
1387    CHECK(self->IsExceptionPending());  // Expect an OOME.
1388    return NULL;
1389  }
1390  klass->SetDexCache(FindDexCache(dex_file));
1391  LoadClass(dex_file, dex_class_def, klass, class_loader.get());
1392  // Check for a pending exception during load
1393  if (self->IsExceptionPending()) {
1394    klass->SetStatus(mirror::Class::kStatusError, self);
1395    return NULL;
1396  }
1397  ObjectLock<mirror::Class> lock(self, &klass);
1398  klass->SetClinitThreadId(self->GetTid());
1399  // Add the newly loaded class to the loaded classes table.
1400  mirror::Class* existing = InsertClass(descriptor, klass.get(), Hash(descriptor));
1401  if (existing != NULL) {
1402    // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
1403    // this thread to block.
1404    return EnsureResolved(self, existing);
1405  }
1406  // Finish loading (if necessary) by finding parents
1407  CHECK(!klass->IsLoaded());
1408  if (!LoadSuperAndInterfaces(klass, dex_file)) {
1409    // Loading failed.
1410    klass->SetStatus(mirror::Class::kStatusError, self);
1411    return NULL;
1412  }
1413  CHECK(klass->IsLoaded());
1414  // Link the class (if necessary)
1415  CHECK(!klass->IsResolved());
1416  // TODO: Use fast jobjects?
1417  SirtRef<mirror::ObjectArray<mirror::Class> > interfaces(self, nullptr);
1418  if (!LinkClass(self, klass, interfaces)) {
1419    // Linking failed.
1420    klass->SetStatus(mirror::Class::kStatusError, self);
1421    return NULL;
1422  }
1423  CHECK(klass->IsResolved());
1424
1425  /*
1426   * We send CLASS_PREPARE events to the debugger from here.  The
1427   * definition of "preparation" is creating the static fields for a
1428   * class and initializing them to the standard default values, but not
1429   * executing any code (that comes later, during "initialization").
1430   *
1431   * We did the static preparation in LinkClass.
1432   *
1433   * The class has been prepared and resolved but possibly not yet verified
1434   * at this point.
1435   */
1436  Dbg::PostClassPrepare(klass.get());
1437
1438  return klass.get();
1439}
1440
1441// Precomputes size that will be needed for Class, matching LinkStaticFields
1442uint32_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1443                                const DexFile::ClassDef& dex_class_def) {
1444  const byte* class_data = dex_file.GetClassData(dex_class_def);
1445  size_t num_ref = 0;
1446  size_t num_32 = 0;
1447  size_t num_64 = 0;
1448  if (class_data != NULL) {
1449    for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1450      const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
1451      const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
1452      char c = descriptor[0];
1453      if (c == 'L' || c == '[') {
1454        num_ref++;
1455      } else if (c == 'J' || c == 'D') {
1456        num_64++;
1457      } else {
1458        num_32++;
1459      }
1460    }
1461  }
1462  // start with generic class data
1463  uint32_t size = sizeof(mirror::Class);
1464  // follow with reference fields which must be contiguous at start
1465  size += (num_ref * sizeof(uint32_t));
1466  // if there are 64-bit fields to add, make sure they are aligned
1467  if (num_64 != 0 && size != RoundUp(size, 8)) {  // for 64-bit alignment
1468    if (num_32 != 0) {
1469      // use an available 32-bit field for padding
1470      num_32--;
1471    }
1472    size += sizeof(uint32_t);  // either way, we are adding a word
1473    DCHECK_EQ(size, RoundUp(size, 8));
1474  }
1475  // tack on any 64-bit fields now that alignment is assured
1476  size += (num_64 * sizeof(uint64_t));
1477  // tack on any remaining 32-bit fields
1478  size += (num_32 * sizeof(uint32_t));
1479  return size;
1480}
1481
1482const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, uint16_t class_def_idx) {
1483  DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
1484  const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1485  CHECK(oat_file != NULL) << dex_file.GetLocation();
1486  uint dex_location_checksum = dex_file.GetLocationChecksum();
1487  const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
1488                                                                    &dex_location_checksum);
1489  CHECK(oat_dex_file != NULL) << dex_file.GetLocation();
1490  const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_idx);
1491  CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << class_def_idx;
1492  return oat_class;
1493}
1494
1495static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint16_t class_def_idx,
1496                                                 uint32_t method_idx) {
1497  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
1498  const byte* class_data = dex_file.GetClassData(class_def);
1499  CHECK(class_data != NULL);
1500  ClassDataItemIterator it(dex_file, class_data);
1501  // Skip fields
1502  while (it.HasNextStaticField()) {
1503    it.Next();
1504  }
1505  while (it.HasNextInstanceField()) {
1506    it.Next();
1507  }
1508  // Process methods
1509  size_t class_def_method_index = 0;
1510  while (it.HasNextDirectMethod()) {
1511    if (it.GetMemberIndex() == method_idx) {
1512      return class_def_method_index;
1513    }
1514    class_def_method_index++;
1515    it.Next();
1516  }
1517  while (it.HasNextVirtualMethod()) {
1518    if (it.GetMemberIndex() == method_idx) {
1519      return class_def_method_index;
1520    }
1521    class_def_method_index++;
1522    it.Next();
1523  }
1524  DCHECK(!it.HasNext());
1525  LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1526  return 0;
1527}
1528
1529const OatFile::OatMethod ClassLinker::GetOatMethodFor(mirror::ArtMethod* method) {
1530  // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
1531  // method for direct methods (or virtual methods made direct).
1532  mirror::Class* declaring_class = method->GetDeclaringClass();
1533  size_t oat_method_index;
1534  if (method->IsStatic() || method->IsDirect()) {
1535    // Simple case where the oat method index was stashed at load time.
1536    oat_method_index = method->GetMethodIndex();
1537  } else {
1538    // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1539    // by search for its position in the declared virtual methods.
1540    oat_method_index = declaring_class->NumDirectMethods();
1541    size_t end = declaring_class->NumVirtualMethods();
1542    bool found = false;
1543    for (size_t i = 0; i < end; i++) {
1544      if (declaring_class->GetVirtualMethod(i) == method) {
1545        found = true;
1546        break;
1547      }
1548      oat_method_index++;
1549    }
1550    CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1551  }
1552  UniquePtr<const OatFile::OatClass>
1553      oat_class(GetOatClass(*declaring_class->GetDexCache()->GetDexFile(),
1554                            declaring_class->GetDexClassDefIndex()));
1555  CHECK(oat_class.get() != NULL);
1556  DCHECK_EQ(oat_method_index,
1557            GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
1558                                             method->GetDeclaringClass()->GetDexClassDefIndex(),
1559                                             method->GetDexMethodIndex()));
1560
1561  return oat_class->GetOatMethod(oat_method_index);
1562}
1563
1564// Special case to get oat code without overwriting a trampoline.
1565const void* ClassLinker::GetQuickOatCodeFor(mirror::ArtMethod* method) {
1566  CHECK(!method->IsAbstract()) << PrettyMethod(method);
1567  if (method->IsProxyMethod()) {
1568    return GetQuickProxyInvokeHandler();
1569  }
1570  const void* result = GetOatMethodFor(method).GetQuickCode();
1571  if (result == nullptr) {
1572    if (method->IsPortableCompiled()) {
1573      // No code? Do we expect portable code?
1574      result = GetQuickToPortableBridge();
1575    } else {
1576      // No code? You must mean to go into the interpreter.
1577      result = GetQuickToInterpreterBridge();
1578    }
1579  }
1580  return result;
1581}
1582
1583const void* ClassLinker::GetPortableOatCodeFor(mirror::ArtMethod* method,
1584                                               bool* have_portable_code) {
1585  CHECK(!method->IsAbstract()) << PrettyMethod(method);
1586  *have_portable_code = false;
1587  if (method->IsProxyMethod()) {
1588    return GetPortableProxyInvokeHandler();
1589  }
1590  const void* result = GetOatMethodFor(method).GetPortableCode();
1591  if (result == nullptr) {
1592    if (GetOatMethodFor(method).GetQuickCode() == nullptr) {
1593      // No code? You must mean to go into the interpreter.
1594      result = GetPortableToInterpreterBridge();
1595    } else {
1596      // No code? But there's quick code, so use a bridge.
1597      result = GetPortableToQuickBridge();
1598    }
1599  } else {
1600    *have_portable_code = true;
1601  }
1602  return result;
1603}
1604
1605const void* ClassLinker::GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
1606                                            uint32_t method_idx) {
1607  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, class_def_idx));
1608  CHECK(oat_class.get() != nullptr);
1609  uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
1610  return oat_class->GetOatMethod(oat_method_idx).GetQuickCode();
1611}
1612
1613const void* ClassLinker::GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
1614                                               uint32_t method_idx) {
1615  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, class_def_idx));
1616  CHECK(oat_class.get() != nullptr);
1617  uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
1618  return oat_class->GetOatMethod(oat_method_idx).GetPortableCode();
1619}
1620
1621// Returns true if the method must run with interpreter, false otherwise.
1622static bool NeedsInterpreter(mirror::ArtMethod* method, const void* quick_code,
1623                             const void* portable_code) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1624  if ((quick_code == nullptr) && (portable_code == nullptr)) {
1625    // No code: need interpreter.
1626    // May return true for native code, in the case of generic JNI
1627    // DCHECK(!method->IsNative());
1628    return true;
1629  }
1630#ifdef ART_SEA_IR_MODE
1631  ScopedObjectAccess soa(Thread::Current());
1632  if (std::string::npos != PrettyMethod(method).find("fibonacci")) {
1633    LOG(INFO) << "Found " << PrettyMethod(method);
1634    return false;
1635  }
1636#endif
1637  // If interpreter mode is enabled, every method (except native and proxy) must
1638  // be run with interpreter.
1639  return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
1640         !method->IsNative() && !method->IsProxyMethod();
1641}
1642
1643void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
1644  DCHECK(klass->IsInitialized()) << PrettyDescriptor(klass);
1645  if (klass->NumDirectMethods() == 0) {
1646    return;  // No direct methods => no static methods.
1647  }
1648  Runtime* runtime = Runtime::Current();
1649  if (!runtime->IsStarted() || runtime->UseCompileTimeClassPath()) {
1650    return;  // OAT file unavailable.
1651  }
1652  ClassHelper kh(klass);
1653  const DexFile& dex_file = kh.GetDexFile();
1654  const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1655  CHECK(dex_class_def != nullptr);
1656  const byte* class_data = dex_file.GetClassData(*dex_class_def);
1657  // There should always be class data if there were direct methods.
1658  CHECK(class_data != nullptr) << PrettyDescriptor(klass);
1659  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
1660  CHECK(oat_class.get() != nullptr);
1661  ClassDataItemIterator it(dex_file, class_data);
1662  // Skip fields
1663  while (it.HasNextStaticField()) {
1664    it.Next();
1665  }
1666  while (it.HasNextInstanceField()) {
1667    it.Next();
1668  }
1669  // Link the code of methods skipped by LinkCode.
1670  for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
1671    mirror::ArtMethod* method = klass->GetDirectMethod(method_index);
1672    if (!method->IsStatic()) {
1673      // Only update static methods.
1674      continue;
1675    }
1676    const void* portable_code = oat_class->GetOatMethod(method_index).GetPortableCode();
1677    const void* quick_code = oat_class->GetOatMethod(method_index).GetQuickCode();
1678    const bool enter_interpreter = NeedsInterpreter(method, quick_code, portable_code);
1679    bool have_portable_code = false;
1680    if (enter_interpreter) {
1681      // Use interpreter entry point.
1682
1683      // check whether the method is native, in which case it's generic JNI
1684      portable_code = GetPortableToInterpreterBridge();
1685      if (quick_code == nullptr && portable_code == nullptr && method->IsNative()) {
1686        quick_code = GetQuickGenericJniTrampoline();
1687      } else {
1688        quick_code = GetQuickToInterpreterBridge();
1689      }
1690    } else {
1691      if (portable_code == nullptr) {
1692        portable_code = GetPortableToQuickBridge();
1693      } else {
1694        have_portable_code = true;
1695      }
1696      if (quick_code == nullptr) {
1697        quick_code = GetQuickToPortableBridge();
1698      }
1699    }
1700    runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code, portable_code,
1701                                                     have_portable_code);
1702  }
1703  // Ignore virtual methods on the iterator.
1704}
1705
1706static void LinkCode(const SirtRef<mirror::ArtMethod>& method, const OatFile::OatClass* oat_class,
1707                     uint32_t method_index)
1708    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1709  // Method shouldn't have already been linked.
1710  DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
1711  DCHECK(method->GetEntryPointFromPortableCompiledCode() == nullptr);
1712  // Every kind of method should at least get an invoke stub from the oat_method.
1713  // non-abstract methods also get their code pointers.
1714  const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
1715  oat_method.LinkMethod(method.get());
1716
1717  // Install entry point from interpreter.
1718  Runtime* runtime = Runtime::Current();
1719  bool enter_interpreter = NeedsInterpreter(method.get(),
1720                                            method->GetEntryPointFromQuickCompiledCode(),
1721                                            method->GetEntryPointFromPortableCompiledCode());
1722  if (enter_interpreter) {
1723    method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
1724  } else {
1725    method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
1726  }
1727
1728  if (method->IsAbstract()) {
1729    method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
1730    method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
1731    return;
1732  }
1733
1734  bool have_portable_code = false;
1735  if (method->IsStatic() && !method->IsConstructor()) {
1736    // For static methods excluding the class initializer, install the trampoline.
1737    // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
1738    // after initializing class (see ClassLinker::InitializeClass method).
1739    method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionTrampoline(runtime->GetClassLinker()));
1740    method->SetEntryPointFromPortableCompiledCode(GetPortableResolutionTrampoline(runtime->GetClassLinker()));
1741  } else if (enter_interpreter) {
1742    // Set entry point from compiled code if there's no code or in interpreter only mode.
1743    method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
1744    method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
1745  } else if (method->GetEntryPointFromPortableCompiledCode() != nullptr) {
1746    DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
1747    have_portable_code = true;
1748    method->SetEntryPointFromQuickCompiledCode(GetQuickToPortableBridge());
1749  } else {
1750    DCHECK(method->GetEntryPointFromQuickCompiledCode() != nullptr);
1751    method->SetEntryPointFromPortableCompiledCode(GetPortableToQuickBridge());
1752  }
1753
1754  if (method->IsNative()) {
1755    // Unregistering restores the dlsym lookup stub.
1756    method->UnregisterNative(Thread::Current());
1757  }
1758
1759  // Allow instrumentation its chance to hijack code.
1760  runtime->GetInstrumentation()->UpdateMethodsCode(method.get(),
1761                                                   method->GetEntryPointFromQuickCompiledCode(),
1762                                                   method->GetEntryPointFromPortableCompiledCode(),
1763                                                   have_portable_code);
1764}
1765
1766void ClassLinker::LoadClass(const DexFile& dex_file,
1767                            const DexFile::ClassDef& dex_class_def,
1768                            const SirtRef<mirror::Class>& klass,
1769                            mirror::ClassLoader* class_loader) {
1770  CHECK(klass.get() != NULL);
1771  CHECK(klass->GetDexCache() != NULL);
1772  CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
1773  const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
1774  CHECK(descriptor != NULL);
1775
1776  klass->SetClass(GetClassRoot(kJavaLangClass));
1777  if (kUseBrooksPointer) {
1778    klass->AssertSelfBrooksPointer();
1779  }
1780  uint32_t access_flags = dex_class_def.access_flags_;
1781  // Make sure that none of our runtime-only flags are set.
1782  CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
1783  klass->SetAccessFlags(access_flags);
1784  klass->SetClassLoader(class_loader);
1785  DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
1786  klass->SetStatus(mirror::Class::kStatusIdx, NULL);
1787
1788  klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
1789  klass->SetDexTypeIndex(dex_class_def.class_idx_);
1790
1791  // Load fields fields.
1792  const byte* class_data = dex_file.GetClassData(dex_class_def);
1793  if (class_data == NULL) {
1794    return;  // no fields or methods - for example a marker interface
1795  }
1796  ClassDataItemIterator it(dex_file, class_data);
1797  Thread* self = Thread::Current();
1798  if (it.NumStaticFields() != 0) {
1799    mirror::ObjectArray<mirror::ArtField>* statics = AllocArtFieldArray(self, it.NumStaticFields());
1800    if (UNLIKELY(statics == NULL)) {
1801      CHECK(self->IsExceptionPending());  // OOME.
1802      return;
1803    }
1804    klass->SetSFields(statics);
1805  }
1806  if (it.NumInstanceFields() != 0) {
1807    mirror::ObjectArray<mirror::ArtField>* fields =
1808        AllocArtFieldArray(self, it.NumInstanceFields());
1809    if (UNLIKELY(fields == NULL)) {
1810      CHECK(self->IsExceptionPending());  // OOME.
1811      return;
1812    }
1813    klass->SetIFields(fields);
1814  }
1815  for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
1816    SirtRef<mirror::ArtField> sfield(self, AllocArtField(self));
1817    if (UNLIKELY(sfield.get() == NULL)) {
1818      CHECK(self->IsExceptionPending());  // OOME.
1819      return;
1820    }
1821    klass->SetStaticField(i, sfield.get());
1822    LoadField(dex_file, it, klass, sfield);
1823  }
1824  for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
1825    SirtRef<mirror::ArtField> ifield(self, AllocArtField(self));
1826    if (UNLIKELY(ifield.get() == NULL)) {
1827      CHECK(self->IsExceptionPending());  // OOME.
1828      return;
1829    }
1830    klass->SetInstanceField(i, ifield.get());
1831    LoadField(dex_file, it, klass, ifield);
1832  }
1833
1834  UniquePtr<const OatFile::OatClass> oat_class;
1835  if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1836    oat_class.reset(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
1837  }
1838
1839  // Load methods.
1840  if (it.NumDirectMethods() != 0) {
1841    // TODO: append direct methods to class object
1842    mirror::ObjectArray<mirror::ArtMethod>* directs =
1843         AllocArtMethodArray(self, it.NumDirectMethods());
1844    if (UNLIKELY(directs == NULL)) {
1845      CHECK(self->IsExceptionPending());  // OOME.
1846      return;
1847    }
1848    klass->SetDirectMethods(directs);
1849  }
1850  if (it.NumVirtualMethods() != 0) {
1851    // TODO: append direct methods to class object
1852    mirror::ObjectArray<mirror::ArtMethod>* virtuals =
1853        AllocArtMethodArray(self, it.NumVirtualMethods());
1854    if (UNLIKELY(virtuals == NULL)) {
1855      CHECK(self->IsExceptionPending());  // OOME.
1856      return;
1857    }
1858    klass->SetVirtualMethods(virtuals);
1859  }
1860  size_t class_def_method_index = 0;
1861  for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
1862    SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
1863    if (UNLIKELY(method.get() == NULL)) {
1864      CHECK(self->IsExceptionPending());  // OOME.
1865      return;
1866    }
1867    klass->SetDirectMethod(i, method.get());
1868    if (oat_class.get() != NULL) {
1869      LinkCode(method, oat_class.get(), class_def_method_index);
1870    }
1871    method->SetMethodIndex(class_def_method_index);
1872    class_def_method_index++;
1873  }
1874  for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
1875    SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
1876    if (UNLIKELY(method.get() == NULL)) {
1877      CHECK(self->IsExceptionPending());  // OOME.
1878      return;
1879    }
1880    klass->SetVirtualMethod(i, method.get());
1881    DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
1882    if (oat_class.get() != NULL) {
1883      LinkCode(method, oat_class.get(), class_def_method_index);
1884    }
1885    class_def_method_index++;
1886  }
1887  DCHECK(!it.HasNext());
1888}
1889
1890void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
1891                            const SirtRef<mirror::Class>& klass,
1892                            const SirtRef<mirror::ArtField>& dst) {
1893  uint32_t field_idx = it.GetMemberIndex();
1894  dst->SetDexFieldIndex(field_idx);
1895  dst->SetDeclaringClass(klass.get());
1896  dst->SetAccessFlags(it.GetMemberAccessFlags());
1897}
1898
1899mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
1900                                           const ClassDataItemIterator& it,
1901                                           const SirtRef<mirror::Class>& klass) {
1902  uint32_t dex_method_idx = it.GetMemberIndex();
1903  const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
1904  const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
1905
1906  mirror::ArtMethod* dst = AllocArtMethod(self);
1907  if (UNLIKELY(dst == NULL)) {
1908    CHECK(self->IsExceptionPending());  // OOME.
1909    return NULL;
1910  }
1911  DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass());
1912
1913  const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
1914  dst->SetDexMethodIndex(dex_method_idx);
1915  dst->SetDeclaringClass(klass.get());
1916  dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
1917
1918  dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
1919  dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
1920  dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
1921
1922  uint32_t access_flags = it.GetMemberAccessFlags();
1923
1924  if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
1925    // Set finalizable flag on declaring class.
1926    if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) {
1927      // Void return type.
1928      if (klass->GetClassLoader() != NULL) {  // All non-boot finalizer methods are flagged
1929        klass->SetFinalizable();
1930      } else {
1931        ClassHelper kh(klass.get());
1932        const char* klass_descriptor = kh.GetDescriptor();
1933        // The Enum class declares a "final" finalize() method to prevent subclasses from
1934        // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1935        // subclasses, so we exclude it here.
1936        // We also want to avoid setting the flag on Object, where we know that finalize() is
1937        // empty.
1938        if ((strcmp("Ljava/lang/Object;", klass_descriptor) != 0) &&
1939            (strcmp("Ljava/lang/Enum;", klass_descriptor) != 0)) {
1940          klass->SetFinalizable();
1941        }
1942      }
1943    }
1944  } else if (method_name[0] == '<') {
1945    // Fix broken access flags for initializers. Bug 11157540.
1946    bool is_init = (strcmp("<init>", method_name) == 0);
1947    bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0);
1948    if (UNLIKELY(!is_init && !is_clinit)) {
1949      LOG(WARNING) << "Unexpected '<' at start of method name " << method_name;
1950    } else {
1951      if (UNLIKELY((access_flags & kAccConstructor) == 0)) {
1952        LOG(WARNING) << method_name << " didn't have expected constructor access flag in class "
1953            << PrettyDescriptor(klass.get()) << " in dex file " << dex_file.GetLocation();
1954        access_flags |= kAccConstructor;
1955      }
1956    }
1957  }
1958  dst->SetAccessFlags(access_flags);
1959
1960  self->EndAssertNoThreadSuspension(old_cause);
1961  return dst;
1962}
1963
1964void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
1965  Thread* self = Thread::Current();
1966  SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
1967  CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
1968  AppendToBootClassPath(dex_file, dex_cache);
1969}
1970
1971void ClassLinker::AppendToBootClassPath(const DexFile& dex_file,
1972                                        const SirtRef<mirror::DexCache>& dex_cache) {
1973  CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
1974  boot_class_path_.push_back(&dex_file);
1975  RegisterDexFile(dex_file, dex_cache);
1976}
1977
1978bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
1979  dex_lock_.AssertSharedHeld(Thread::Current());
1980  for (size_t i = 0; i != dex_caches_.size(); ++i) {
1981    if (dex_caches_[i]->GetDexFile() == &dex_file) {
1982      return true;
1983    }
1984  }
1985  return false;
1986}
1987
1988bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
1989  ReaderMutexLock mu(Thread::Current(), dex_lock_);
1990  return IsDexFileRegisteredLocked(dex_file);
1991}
1992
1993void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file,
1994                                        const SirtRef<mirror::DexCache>& dex_cache) {
1995  dex_lock_.AssertExclusiveHeld(Thread::Current());
1996  CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
1997  CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()))
1998      << dex_cache->GetLocation()->ToModifiedUtf8() << " " << dex_file.GetLocation();
1999  dex_caches_.push_back(dex_cache.get());
2000  dex_cache->SetDexFile(&dex_file);
2001  dex_caches_dirty_ = true;
2002}
2003
2004void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
2005  Thread* self = Thread::Current();
2006  {
2007    ReaderMutexLock mu(self, dex_lock_);
2008    if (IsDexFileRegisteredLocked(dex_file)) {
2009      return;
2010    }
2011  }
2012  // Don't alloc while holding the lock, since allocation may need to
2013  // suspend all threads and another thread may need the dex_lock_ to
2014  // get to a suspend point.
2015  SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
2016  CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
2017  {
2018    WriterMutexLock mu(self, dex_lock_);
2019    if (IsDexFileRegisteredLocked(dex_file)) {
2020      return;
2021    }
2022    RegisterDexFileLocked(dex_file, dex_cache);
2023  }
2024}
2025
2026void ClassLinker::RegisterDexFile(const DexFile& dex_file,
2027                                  const SirtRef<mirror::DexCache>& dex_cache) {
2028  WriterMutexLock mu(Thread::Current(), dex_lock_);
2029  RegisterDexFileLocked(dex_file, dex_cache);
2030}
2031
2032mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
2033  ReaderMutexLock mu(Thread::Current(), dex_lock_);
2034  // Search assuming unique-ness of dex file.
2035  for (size_t i = 0; i != dex_caches_.size(); ++i) {
2036    mirror::DexCache* dex_cache = dex_caches_[i];
2037    if (dex_cache->GetDexFile() == &dex_file) {
2038      return dex_cache;
2039    }
2040  }
2041  // Search matching by location name.
2042  std::string location(dex_file.GetLocation());
2043  for (size_t i = 0; i != dex_caches_.size(); ++i) {
2044    mirror::DexCache* dex_cache = dex_caches_[i];
2045    if (dex_cache->GetDexFile()->GetLocation() == location) {
2046      return dex_cache;
2047    }
2048  }
2049  // Failure, dump diagnostic and abort.
2050  for (size_t i = 0; i != dex_caches_.size(); ++i) {
2051    mirror::DexCache* dex_cache = dex_caches_[i];
2052    LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
2053  }
2054  LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
2055  return NULL;
2056}
2057
2058void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) const {
2059  ReaderMutexLock mu(Thread::Current(), dex_lock_);
2060  for (size_t i = 0; i != dex_caches_.size(); ++i) {
2061    dex_caches_[i]->Fixup(resolution_method);
2062  }
2063}
2064
2065mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
2066  mirror::Class* klass = AllocClass(self, sizeof(mirror::Class));
2067  if (UNLIKELY(klass == NULL)) {
2068    return NULL;
2069  }
2070  return InitializePrimitiveClass(klass, type);
2071}
2072
2073mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class,
2074                                                     Primitive::Type type) {
2075  CHECK(primitive_class != NULL);
2076  // Must hold lock on object when initializing.
2077  Thread* self = Thread::Current();
2078  SirtRef<mirror::Class> sirt_class(self, primitive_class);
2079  ObjectLock<mirror::Class> lock(self, &sirt_class);
2080  primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
2081  primitive_class->SetPrimitiveType(type);
2082  primitive_class->SetStatus(mirror::Class::kStatusInitialized, self);
2083  const char* descriptor = Primitive::Descriptor(type);
2084  mirror::Class* existing = InsertClass(descriptor, primitive_class, Hash(descriptor));
2085  CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
2086  return primitive_class;
2087}
2088
2089// Create an array class (i.e. the class object for the array, not the
2090// array itself).  "descriptor" looks like "[C" or "[[[[B" or
2091// "[Ljava/lang/String;".
2092//
2093// If "descriptor" refers to an array of primitives, look up the
2094// primitive type's internally-generated class object.
2095//
2096// "class_loader" is the class loader of the class that's referring to
2097// us.  It's used to ensure that we're looking for the element type in
2098// the right context.  It does NOT become the class loader for the
2099// array class; that always comes from the base element class.
2100//
2101// Returns NULL with an exception raised on failure.
2102mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor,
2103                                             const SirtRef<mirror::ClassLoader>& class_loader) {
2104  // Identify the underlying component type
2105  CHECK_EQ('[', descriptor[0]);
2106  SirtRef<mirror::Class> component_type(self, FindClass(self, descriptor + 1, class_loader));
2107  if (component_type.get() == nullptr) {
2108    DCHECK(self->IsExceptionPending());
2109    return nullptr;
2110  }
2111
2112  // See if the component type is already loaded.  Array classes are
2113  // always associated with the class loader of their underlying
2114  // element type -- an array of Strings goes with the loader for
2115  // java/lang/String -- so we need to look for it there.  (The
2116  // caller should have checked for the existence of the class
2117  // before calling here, but they did so with *their* class loader,
2118  // not the component type's loader.)
2119  //
2120  // If we find it, the caller adds "loader" to the class' initiating
2121  // loader list, which should prevent us from going through this again.
2122  //
2123  // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
2124  // are the same, because our caller (FindClass) just did the
2125  // lookup.  (Even if we get this wrong we still have correct behavior,
2126  // because we effectively do this lookup again when we add the new
2127  // class to the hash table --- necessary because of possible races with
2128  // other threads.)
2129  if (class_loader.get() != component_type->GetClassLoader()) {
2130    mirror::Class* new_class = LookupClass(descriptor, component_type->GetClassLoader());
2131    if (new_class != NULL) {
2132      return new_class;
2133    }
2134  }
2135
2136  // Fill out the fields in the Class.
2137  //
2138  // It is possible to execute some methods against arrays, because
2139  // all arrays are subclasses of java_lang_Object_, so we need to set
2140  // up a vtable.  We can just point at the one in java_lang_Object_.
2141  //
2142  // Array classes are simple enough that we don't need to do a full
2143  // link step.
2144  SirtRef<mirror::Class> new_class(self, NULL);
2145  if (UNLIKELY(!init_done_)) {
2146    // Classes that were hand created, ie not by FindSystemClass
2147    if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
2148      new_class.reset(GetClassRoot(kClassArrayClass));
2149    } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
2150      new_class.reset(GetClassRoot(kObjectArrayClass));
2151    } else if (strcmp(descriptor, class_roots_descriptors_[kJavaLangStringArrayClass]) == 0) {
2152      new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
2153    } else if (strcmp(descriptor,
2154                      class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) == 0) {
2155      new_class.reset(GetClassRoot(kJavaLangReflectArtMethodArrayClass));
2156    } else if (strcmp(descriptor,
2157                      class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) == 0) {
2158      new_class.reset(GetClassRoot(kJavaLangReflectArtFieldArrayClass));
2159    } else if (strcmp(descriptor, "[C") == 0) {
2160      new_class.reset(GetClassRoot(kCharArrayClass));
2161    } else if (strcmp(descriptor, "[I") == 0) {
2162      new_class.reset(GetClassRoot(kIntArrayClass));
2163    }
2164  }
2165  if (new_class.get() == nullptr) {
2166    new_class.reset(AllocClass(self, sizeof(mirror::Class)));
2167    if (new_class.get() == nullptr) {
2168      return nullptr;
2169    }
2170    new_class->SetComponentType(component_type.get());
2171  }
2172  ObjectLock<mirror::Class> lock(self, &new_class);  // Must hold lock on object when initializing.
2173  DCHECK(new_class->GetComponentType() != NULL);
2174  mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
2175  new_class->SetSuperClass(java_lang_Object);
2176  new_class->SetVTable(java_lang_Object->GetVTable());
2177  new_class->SetPrimitiveType(Primitive::kPrimNot);
2178  new_class->SetClassLoader(component_type->GetClassLoader());
2179  new_class->SetStatus(mirror::Class::kStatusInitialized, self);
2180  // don't need to set new_class->SetObjectSize(..)
2181  // because Object::SizeOf delegates to Array::SizeOf
2182
2183
2184  // All arrays have java/lang/Cloneable and java/io/Serializable as
2185  // interfaces.  We need to set that up here, so that stuff like
2186  // "instanceof" works right.
2187  //
2188  // Note: The GC could run during the call to FindSystemClass,
2189  // so we need to make sure the class object is GC-valid while we're in
2190  // there.  Do this by clearing the interface list so the GC will just
2191  // think that the entries are null.
2192
2193
2194  // Use the single, global copies of "interfaces" and "iftable"
2195  // (remember not to free them for arrays).
2196  CHECK(array_iftable_ != nullptr);
2197  new_class->SetIfTable(array_iftable_);
2198
2199  // Inherit access flags from the component type.
2200  int access_flags = new_class->GetComponentType()->GetAccessFlags();
2201  // Lose any implementation detail flags; in particular, arrays aren't finalizable.
2202  access_flags &= kAccJavaFlagsMask;
2203  // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
2204  // and remove "interface".
2205  access_flags |= kAccAbstract | kAccFinal;
2206  access_flags &= ~kAccInterface;
2207
2208  new_class->SetAccessFlags(access_flags);
2209
2210  mirror::Class* existing = InsertClass(descriptor, new_class.get(), Hash(descriptor));
2211  if (existing == nullptr) {
2212    return new_class.get();
2213  }
2214  // Another thread must have loaded the class after we
2215  // started but before we finished.  Abandon what we've
2216  // done.
2217  //
2218  // (Yes, this happens.)
2219
2220  return existing;
2221}
2222
2223mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
2224  switch (Primitive::GetType(type)) {
2225    case Primitive::kPrimByte:
2226      return GetClassRoot(kPrimitiveByte);
2227    case Primitive::kPrimChar:
2228      return GetClassRoot(kPrimitiveChar);
2229    case Primitive::kPrimDouble:
2230      return GetClassRoot(kPrimitiveDouble);
2231    case Primitive::kPrimFloat:
2232      return GetClassRoot(kPrimitiveFloat);
2233    case Primitive::kPrimInt:
2234      return GetClassRoot(kPrimitiveInt);
2235    case Primitive::kPrimLong:
2236      return GetClassRoot(kPrimitiveLong);
2237    case Primitive::kPrimShort:
2238      return GetClassRoot(kPrimitiveShort);
2239    case Primitive::kPrimBoolean:
2240      return GetClassRoot(kPrimitiveBoolean);
2241    case Primitive::kPrimVoid:
2242      return GetClassRoot(kPrimitiveVoid);
2243    case Primitive::kPrimNot:
2244      break;
2245  }
2246  std::string printable_type(PrintableChar(type));
2247  ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
2248  return NULL;
2249}
2250
2251mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass,
2252                                        size_t hash) {
2253  if (VLOG_IS_ON(class_linker)) {
2254    mirror::DexCache* dex_cache = klass->GetDexCache();
2255    std::string source;
2256    if (dex_cache != NULL) {
2257      source += " from ";
2258      source += dex_cache->GetLocation()->ToModifiedUtf8();
2259    }
2260    LOG(INFO) << "Loaded class " << descriptor << source;
2261  }
2262  WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2263  mirror::Class* existing =
2264      LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash);
2265  if (existing != NULL) {
2266    return existing;
2267  }
2268  if (kIsDebugBuild && klass->GetClassLoader() == NULL && dex_cache_image_class_lookup_required_) {
2269    // Check a class loaded with the system class loader matches one in the image if the class
2270    // is in the image.
2271    existing = LookupClassFromImage(descriptor);
2272    if (existing != NULL) {
2273      CHECK(klass == existing);
2274    }
2275  }
2276  VerifyObject(klass);
2277  class_table_.insert(std::make_pair(hash, klass));
2278  class_table_dirty_ = true;
2279  return NULL;
2280}
2281
2282bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
2283  size_t hash = Hash(descriptor);
2284  WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2285  for (auto it = class_table_.lower_bound(hash), end = class_table_.end(); it != end && it->first == hash;
2286       ++it) {
2287    mirror::Class* klass = it->second;
2288    ClassHelper kh(klass);
2289    if ((klass->GetClassLoader() == class_loader) &&
2290        (strcmp(descriptor, kh.GetDescriptor()) == 0)) {
2291      class_table_.erase(it);
2292      return true;
2293    }
2294  }
2295  return false;
2296}
2297
2298mirror::Class* ClassLinker::LookupClass(const char* descriptor,
2299                                        const mirror::ClassLoader* class_loader) {
2300  size_t hash = Hash(descriptor);
2301  {
2302    ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2303    mirror::Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash);
2304    if (result != NULL) {
2305      return result;
2306    }
2307  }
2308  if (class_loader != NULL || !dex_cache_image_class_lookup_required_) {
2309    return NULL;
2310  } else {
2311    // Lookup failed but need to search dex_caches_.
2312    mirror::Class* result = LookupClassFromImage(descriptor);
2313    if (result != NULL) {
2314      InsertClass(descriptor, result, hash);
2315    } else {
2316      // Searching the image dex files/caches failed, we don't want to get into this situation
2317      // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image
2318      // classes into the class table.
2319      const int32_t kMaxFailedDexCacheLookups = 1000;
2320      if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) {
2321        MoveImageClassesToClassTable();
2322      }
2323    }
2324    return result;
2325  }
2326}
2327
2328mirror::Class* ClassLinker::LookupClassFromTableLocked(const char* descriptor,
2329                                                       const mirror::ClassLoader* class_loader,
2330                                                       size_t hash) {
2331  auto end = class_table_.end();
2332  for (auto it = class_table_.lower_bound(hash); it != end && it->first == hash; ++it) {
2333    mirror::Class* klass = it->second;
2334    ClassHelper kh(klass);
2335    if ((klass->GetClassLoader() == class_loader) &&
2336        (strcmp(descriptor, kh.GetDescriptor()) == 0)) {
2337      if (kIsDebugBuild) {
2338        // Check for duplicates in the table.
2339        for (++it; it != end && it->first == hash; ++it) {
2340          mirror::Class* klass2 = it->second;
2341          ClassHelper kh(klass2);
2342          CHECK(!((klass2->GetClassLoader() == class_loader) &&
2343                  (strcmp(descriptor, kh.GetDescriptor()) == 0)))
2344              << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
2345              << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
2346        }
2347      }
2348      return klass;
2349    }
2350  }
2351  return NULL;
2352}
2353
2354static mirror::ObjectArray<mirror::DexCache>* GetImageDexCaches()
2355    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2356  gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace();
2357  CHECK(image != NULL);
2358  mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
2359  return root->AsObjectArray<mirror::DexCache>();
2360}
2361
2362void ClassLinker::MoveImageClassesToClassTable() {
2363  Thread* self = Thread::Current();
2364  WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
2365  if (!dex_cache_image_class_lookup_required_) {
2366    return;  // All dex cache classes are already in the class table.
2367  }
2368  const char* old_no_suspend_cause =
2369      self->StartAssertNoThreadSuspension("Moving image classes to class table");
2370  mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
2371  for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
2372    mirror::DexCache* dex_cache = dex_caches->Get(i);
2373    mirror::ObjectArray<mirror::Class>* types = dex_cache->GetResolvedTypes();
2374    for (int32_t j = 0; j < types->GetLength(); j++) {
2375      mirror::Class* klass = types->Get(j);
2376      if (klass != NULL) {
2377        ClassHelper kh(klass);
2378        DCHECK(klass->GetClassLoader() == NULL);
2379        const char* descriptor = kh.GetDescriptor();
2380        size_t hash = Hash(descriptor);
2381        mirror::Class* existing = LookupClassFromTableLocked(descriptor, NULL, hash);
2382        if (existing != NULL) {
2383          CHECK(existing == klass) << PrettyClassAndClassLoader(existing) << " != "
2384              << PrettyClassAndClassLoader(klass);
2385        } else {
2386          class_table_.insert(std::make_pair(hash, klass));
2387        }
2388      }
2389    }
2390  }
2391  class_table_dirty_ = true;
2392  dex_cache_image_class_lookup_required_ = false;
2393  self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2394}
2395
2396mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) {
2397  Thread* self = Thread::Current();
2398  const char* old_no_suspend_cause =
2399      self->StartAssertNoThreadSuspension("Image class lookup");
2400  mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
2401  for (int32_t i = 0; i < dex_caches->GetLength(); ++i) {
2402    mirror::DexCache* dex_cache = dex_caches->Get(i);
2403    const DexFile* dex_file = dex_cache->GetDexFile();
2404    // Try binary searching the string/type index.
2405    const DexFile::StringId* string_id = dex_file->FindStringId(descriptor);
2406    if (string_id != NULL) {
2407      const DexFile::TypeId* type_id =
2408          dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
2409      if (type_id != NULL) {
2410        uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id);
2411        mirror::Class* klass = dex_cache->GetResolvedType(type_idx);
2412        if (klass != NULL) {
2413          self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2414          return klass;
2415        }
2416      }
2417    }
2418  }
2419  self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2420  return NULL;
2421}
2422
2423void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) {
2424  result.clear();
2425  if (dex_cache_image_class_lookup_required_) {
2426    MoveImageClassesToClassTable();
2427  }
2428  size_t hash = Hash(descriptor);
2429  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2430  for (auto it = class_table_.lower_bound(hash), end = class_table_.end();
2431      it != end && it->first == hash; ++it) {
2432    mirror::Class* klass = it->second;
2433    ClassHelper kh(klass);
2434    if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
2435      result.push_back(klass);
2436    }
2437  }
2438}
2439
2440void ClassLinker::VerifyClass(const SirtRef<mirror::Class>& klass) {
2441  // TODO: assert that the monitor on the Class is held
2442  Thread* self = Thread::Current();
2443  ObjectLock<mirror::Class> lock(self, &klass);
2444
2445  // Don't attempt to re-verify if already sufficiently verified.
2446  if (klass->IsVerified() ||
2447      (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
2448    return;
2449  }
2450
2451  // The class might already be erroneous, for example at compile time if we attempted to verify
2452  // this class as a parent to another.
2453  if (klass->IsErroneous()) {
2454    ThrowEarlierClassFailure(klass.get());
2455    return;
2456  }
2457
2458  if (klass->GetStatus() == mirror::Class::kStatusResolved) {
2459    klass->SetStatus(mirror::Class::kStatusVerifying, self);
2460  } else {
2461    CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
2462        << PrettyClass(klass.get());
2463    CHECK(!Runtime::Current()->IsCompiler());
2464    klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime, self);
2465  }
2466
2467  // Verify super class.
2468  SirtRef<mirror::Class> super(self, klass->GetSuperClass());
2469  if (super.get() != NULL) {
2470    // Acquire lock to prevent races on verifying the super class.
2471    ObjectLock<mirror::Class> lock(self, &super);
2472
2473    if (!super->IsVerified() && !super->IsErroneous()) {
2474      VerifyClass(super);
2475    }
2476    if (!super->IsCompileTimeVerified()) {
2477      std::string error_msg(StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
2478                                         PrettyDescriptor(klass.get()).c_str(),
2479                                         PrettyDescriptor(super.get()).c_str()));
2480      LOG(ERROR) << error_msg  << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
2481      SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
2482      if (cause.get() != nullptr) {
2483        self->ClearException();
2484      }
2485      ThrowVerifyError(klass.get(), "%s", error_msg.c_str());
2486      if (cause.get() != nullptr) {
2487        self->GetException(nullptr)->SetCause(cause.get());
2488      }
2489      ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex());
2490      if (Runtime::Current()->IsCompiler()) {
2491        Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref);
2492      }
2493      klass->SetStatus(mirror::Class::kStatusError, self);
2494      return;
2495    }
2496  }
2497
2498  // Try to use verification information from the oat file, otherwise do runtime verification.
2499  const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
2500  mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
2501  bool preverified = VerifyClassUsingOatFile(dex_file, klass.get(), oat_file_class_status);
2502  if (oat_file_class_status == mirror::Class::kStatusError) {
2503    VLOG(class_linker) << "Skipping runtime verification of erroneous class "
2504        << PrettyDescriptor(klass.get()) << " in "
2505        << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
2506    ThrowVerifyError(klass.get(), "Rejecting class %s because it failed compile-time verification",
2507                     PrettyDescriptor(klass.get()).c_str());
2508    klass->SetStatus(mirror::Class::kStatusError, self);
2509    return;
2510  }
2511  verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
2512  std::string error_msg;
2513  if (!preverified) {
2514    verifier_failure = verifier::MethodVerifier::VerifyClass(klass.get(),
2515                                                             Runtime::Current()->IsCompiler(),
2516                                                             &error_msg);
2517  }
2518  if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
2519    if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
2520      VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass.get())
2521          << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2522          << " because: " << error_msg;
2523    }
2524    self->AssertNoPendingException();
2525    // Make sure all classes referenced by catch blocks are resolved.
2526    ResolveClassExceptionHandlerTypes(dex_file, klass);
2527    if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
2528      // Even though there were no verifier failures we need to respect whether the super-class
2529      // was verified or requiring runtime reverification.
2530      if (super.get() == NULL || super->IsVerified()) {
2531        klass->SetStatus(mirror::Class::kStatusVerified, self);
2532      } else {
2533        CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
2534        klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
2535        // Pretend a soft failure occured so that we don't consider the class verified below.
2536        verifier_failure = verifier::MethodVerifier::kSoftFailure;
2537      }
2538    } else {
2539      CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2540      // Soft failures at compile time should be retried at runtime. Soft
2541      // failures at runtime will be handled by slow paths in the generated
2542      // code. Set status accordingly.
2543      if (Runtime::Current()->IsCompiler()) {
2544        klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
2545      } else {
2546        klass->SetStatus(mirror::Class::kStatusVerified, self);
2547      }
2548    }
2549  } else {
2550    LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass.get())
2551        << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2552        << " because: " << error_msg;
2553    self->AssertNoPendingException();
2554    ThrowVerifyError(klass.get(), "%s", error_msg.c_str());
2555    klass->SetStatus(mirror::Class::kStatusError, self);
2556  }
2557  if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
2558    // Class is verified so we don't need to do any access check on its methods.
2559    // Let the interpreter know it by setting the kAccPreverified flag onto each
2560    // method.
2561    // Note: we're going here during compilation and at runtime. When we set the
2562    // kAccPreverified flag when compiling image classes, the flag is recorded
2563    // in the image and is set when loading the image.
2564    klass->SetPreverifiedFlagOnAllMethods();
2565  }
2566}
2567
2568bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
2569                                          mirror::Class::Status& oat_file_class_status) {
2570  // If we're compiling, we can only verify the class using the oat file if
2571  // we are not compiling the image or if the class we're verifying is not part of
2572  // the app.  In other words, we will only check for preverification of bootclasspath
2573  // classes.
2574  if (Runtime::Current()->IsCompiler()) {
2575    // Are we compiling the bootclasspath?
2576    if (!Runtime::Current()->UseCompileTimeClassPath()) {
2577      return false;
2578    }
2579    // We are compiling an app (not the image).
2580
2581    // Is this an app class? (I.e. not a bootclasspath class)
2582    if (klass->GetClassLoader() != NULL) {
2583      return false;
2584    }
2585  }
2586
2587  const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
2588  // Make this work with gtests, which do not set up the image properly.
2589  // TODO: we should clean up gtests to set up the image path properly.
2590  if (Runtime::Current()->IsCompiler() && (oat_file == NULL)) {
2591    return false;
2592  }
2593
2594  CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
2595  uint dex_location_checksum = dex_file.GetLocationChecksum();
2596  const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
2597                                                                    &dex_location_checksum);
2598  CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
2599  uint16_t class_def_index = klass->GetDexClassDefIndex();
2600  UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
2601  CHECK(oat_class.get() != NULL)
2602          << dex_file.GetLocation() << " " << PrettyClass(klass) << " "
2603          << ClassHelper(klass).GetDescriptor();
2604  oat_file_class_status = oat_class->GetStatus();
2605  if (oat_file_class_status == mirror::Class::kStatusVerified ||
2606      oat_file_class_status == mirror::Class::kStatusInitialized) {
2607      return true;
2608  }
2609  if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
2610    // Compile time verification failed with a soft error. Compile time verification can fail
2611    // because we have incomplete type information. Consider the following:
2612    // class ... {
2613    //   Foo x;
2614    //   .... () {
2615    //     if (...) {
2616    //       v1 gets assigned a type of resolved class Foo
2617    //     } else {
2618    //       v1 gets assigned a type of unresolved class Bar
2619    //     }
2620    //     iput x = v1
2621    // } }
2622    // when we merge v1 following the if-the-else it results in Conflict
2623    // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2624    // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2625    // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2626    // at compile time).
2627    return false;
2628  }
2629  if (oat_file_class_status == mirror::Class::kStatusError) {
2630    // Compile time verification failed with a hard error. This is caused by invalid instructions
2631    // in the class. These errors are unrecoverable.
2632    return false;
2633  }
2634  if (oat_file_class_status == mirror::Class::kStatusNotReady) {
2635    // Status is uninitialized if we couldn't determine the status at compile time, for example,
2636    // not loading the class.
2637    // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2638    // isn't a problem and this case shouldn't occur
2639    return false;
2640  }
2641  LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
2642             << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " "
2643             << ClassHelper(klass).GetDescriptor();
2644
2645  return false;
2646}
2647
2648void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file,
2649                                                    const SirtRef<mirror::Class>& klass) {
2650  for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2651    ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2652  }
2653  for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2654    ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2655  }
2656}
2657
2658void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
2659                                                     mirror::ArtMethod* method) {
2660  // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2661  const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2662  if (code_item == NULL) {
2663    return;  // native or abstract method
2664  }
2665  if (code_item->tries_size_ == 0) {
2666    return;  // nothing to process
2667  }
2668  const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2669  uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2670  ClassLinker* linker = Runtime::Current()->GetClassLinker();
2671  for (uint32_t idx = 0; idx < handlers_size; idx++) {
2672    CatchHandlerIterator iterator(handlers_ptr);
2673    for (; iterator.HasNext(); iterator.Next()) {
2674      // Ensure exception types are resolved so that they don't need resolution to be delivered,
2675      // unresolved exception types will be ignored by exception delivery
2676      if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
2677        mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
2678        if (exception_type == NULL) {
2679          DCHECK(Thread::Current()->IsExceptionPending());
2680          Thread::Current()->ClearException();
2681        }
2682      }
2683    }
2684    handlers_ptr = iterator.EndDataPointer();
2685  }
2686}
2687
2688static void CheckProxyConstructor(mirror::ArtMethod* constructor);
2689static void CheckProxyMethod(mirror::ArtMethod* method,
2690                             SirtRef<mirror::ArtMethod>& prototype);
2691
2692mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccess& soa, jstring name,
2693                                             jobjectArray interfaces, jobject loader,
2694                                             jobjectArray methods, jobjectArray throws) {
2695  Thread* self = soa.Self();
2696  SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2697                                                sizeof(mirror::SynthesizedProxyClass)));
2698  if (klass.get() == NULL) {
2699    CHECK(self->IsExceptionPending());  // OOME.
2700    return NULL;
2701  }
2702  DCHECK(klass->GetClass() != NULL);
2703  klass->SetObjectSize(sizeof(mirror::Proxy));
2704  klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
2705  klass->SetClassLoader(soa.Decode<mirror::ClassLoader*>(loader));
2706  DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
2707  klass->SetName(soa.Decode<mirror::String*>(name));
2708  mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
2709  klass->SetDexCache(proxy_class->GetDexCache());
2710  klass->SetStatus(mirror::Class::kStatusIdx, self);
2711
2712  // Instance fields are inherited, but we add a couple of static fields...
2713  {
2714    mirror::ObjectArray<mirror::ArtField>* sfields = AllocArtFieldArray(self, 2);
2715    if (UNLIKELY(sfields == NULL)) {
2716      CHECK(self->IsExceptionPending());  // OOME.
2717      return NULL;
2718    }
2719    klass->SetSFields(sfields);
2720  }
2721  // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2722  // our proxy, so Class.getInterfaces doesn't return the flattened set.
2723  SirtRef<mirror::ArtField> interfaces_sfield(self, AllocArtField(self));
2724  if (UNLIKELY(interfaces_sfield.get() == NULL)) {
2725    CHECK(self->IsExceptionPending());  // OOME.
2726    return NULL;
2727  }
2728  klass->SetStaticField(0, interfaces_sfield.get());
2729  interfaces_sfield->SetDexFieldIndex(0);
2730  interfaces_sfield->SetDeclaringClass(klass.get());
2731  interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2732  // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
2733  SirtRef<mirror::ArtField> throws_sfield(self, AllocArtField(self));
2734  if (UNLIKELY(throws_sfield.get() == NULL)) {
2735    CHECK(self->IsExceptionPending());  // OOME.
2736    return NULL;
2737  }
2738  klass->SetStaticField(1, throws_sfield.get());
2739  throws_sfield->SetDexFieldIndex(1);
2740  throws_sfield->SetDeclaringClass(klass.get());
2741  throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2742
2743  // Proxies have 1 direct method, the constructor
2744  {
2745    mirror::ObjectArray<mirror::ArtMethod>* directs = AllocArtMethodArray(self, 1);
2746    if (UNLIKELY(directs == NULL)) {
2747      CHECK(self->IsExceptionPending());  // OOME.
2748      return NULL;
2749    }
2750    klass->SetDirectMethods(directs);
2751    mirror::ArtMethod* constructor = CreateProxyConstructor(self, klass, proxy_class);
2752    if (UNLIKELY(constructor == NULL)) {
2753      CHECK(self->IsExceptionPending());  // OOME.
2754      return NULL;
2755    }
2756    klass->SetDirectMethod(0, constructor);
2757  }
2758
2759  // Create virtual method using specified prototypes.
2760  size_t num_virtual_methods =
2761      soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods)->GetLength();
2762  {
2763    mirror::ObjectArray<mirror::ArtMethod>* virtuals = AllocArtMethodArray(self, num_virtual_methods);
2764    if (UNLIKELY(virtuals == NULL)) {
2765      CHECK(self->IsExceptionPending());  // OOME.
2766      return NULL;
2767    }
2768    klass->SetVirtualMethods(virtuals);
2769  }
2770  for (size_t i = 0; i < num_virtual_methods; ++i) {
2771    mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
2772        soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
2773    SirtRef<mirror::ArtMethod> prototype(self, decoded_methods->Get(i));
2774    mirror::ArtMethod* clone = CreateProxyMethod(self, klass, prototype);
2775    if (UNLIKELY(clone == NULL)) {
2776      CHECK(self->IsExceptionPending());  // OOME.
2777      return NULL;
2778    }
2779    klass->SetVirtualMethod(i, clone);
2780  }
2781
2782  klass->SetSuperClass(proxy_class);  // The super class is java.lang.reflect.Proxy
2783  klass->SetStatus(mirror::Class::kStatusLoaded, self);  // Class is now effectively in the loaded state
2784  self->AssertNoPendingException();
2785
2786  {
2787    ObjectLock<mirror::Class> lock(self, &klass);  // Must hold lock on object when resolved.
2788    // Link the fields and virtual methods, creating vtable and iftables
2789    SirtRef<mirror::ObjectArray<mirror::Class> > sirt_interfaces(
2790        self, soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2791    if (!LinkClass(self, klass, sirt_interfaces)) {
2792      klass->SetStatus(mirror::Class::kStatusError, self);
2793      return nullptr;
2794    }
2795
2796    interfaces_sfield->SetObject<false>(klass.get(), soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2797    throws_sfield->SetObject<false>(klass.get(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws));
2798    klass->SetStatus(mirror::Class::kStatusInitialized, self);
2799  }
2800
2801  // sanity checks
2802  if (kIsDebugBuild) {
2803    CHECK(klass->GetIFields() == NULL);
2804    CheckProxyConstructor(klass->GetDirectMethod(0));
2805    for (size_t i = 0; i < num_virtual_methods; ++i) {
2806      mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
2807          soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
2808      SirtRef<mirror::ArtMethod> prototype(self, decoded_methods->Get(i));
2809      CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2810    }
2811
2812    mirror::String* decoded_name = soa.Decode<mirror::String*>(name);
2813    std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2814                                                   decoded_name->ToModifiedUtf8().c_str()));
2815    CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2816
2817    std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2818                                               decoded_name->ToModifiedUtf8().c_str()));
2819    CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
2820
2821    mirror::SynthesizedProxyClass* synth_proxy_class =
2822        down_cast<mirror::SynthesizedProxyClass*>(klass.get());
2823    CHECK_EQ(synth_proxy_class->GetInterfaces(), soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2824    CHECK_EQ(synth_proxy_class->GetThrows(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws));
2825  }
2826  std::string descriptor(GetDescriptorForProxy(klass.get()));
2827  mirror::Class* existing = InsertClass(descriptor.c_str(), klass.get(), Hash(descriptor.c_str()));
2828  CHECK(existing == nullptr);
2829  return klass.get();
2830}
2831
2832std::string ClassLinker::GetDescriptorForProxy(mirror::Class* proxy_class) {
2833  DCHECK(proxy_class->IsProxyClass());
2834  mirror::String* name = proxy_class->GetName();
2835  DCHECK(name != NULL);
2836  return DotToDescriptor(name->ToModifiedUtf8().c_str());
2837}
2838
2839mirror::ArtMethod* ClassLinker::FindMethodForProxy(mirror::Class* proxy_class,
2840                                                   mirror::ArtMethod* proxy_method) {
2841  DCHECK(proxy_class->IsProxyClass());
2842  DCHECK(proxy_method->IsProxyMethod());
2843  // Locate the dex cache of the original interface/Object
2844  mirror::DexCache* dex_cache = NULL;
2845  {
2846    mirror::ObjectArray<mirror::Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
2847    ReaderMutexLock mu(Thread::Current(), dex_lock_);
2848    for (size_t i = 0; i != dex_caches_.size(); ++i) {
2849      if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2850        dex_cache = dex_caches_[i];
2851        break;
2852      }
2853    }
2854  }
2855  CHECK(dex_cache != NULL);
2856  uint32_t method_idx = proxy_method->GetDexMethodIndex();
2857  mirror::ArtMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
2858  CHECK(resolved_method != NULL);
2859  return resolved_method;
2860}
2861
2862
2863mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self,
2864                                                       const SirtRef<mirror::Class>& klass,
2865                                                       mirror::Class* proxy_class) {
2866  // Create constructor for Proxy that must initialize h
2867  mirror::ObjectArray<mirror::ArtMethod>* proxy_direct_methods =
2868      proxy_class->GetDirectMethods();
2869  CHECK_EQ(proxy_direct_methods->GetLength(), 16);
2870  mirror::ArtMethod* proxy_constructor = proxy_direct_methods->Get(2);
2871  // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2872  // code_ too)
2873  mirror::ArtMethod* constructor =
2874      down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self));
2875  if (constructor == NULL) {
2876    CHECK(self->IsExceptionPending());  // OOME.
2877    return NULL;
2878  }
2879  // Make this constructor public and fix the class to be our Proxy version
2880  constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
2881  constructor->SetDeclaringClass(klass.get());
2882  return constructor;
2883}
2884
2885static void CheckProxyConstructor(mirror::ArtMethod* constructor)
2886    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2887  CHECK(constructor->IsConstructor());
2888  MethodHelper mh(constructor);
2889  CHECK_STREQ(mh.GetName(), "<init>");
2890  CHECK_STREQ(mh.GetSignature().ToString().c_str(), "(Ljava/lang/reflect/InvocationHandler;)V");
2891  DCHECK(constructor->IsPublic());
2892}
2893
2894mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self,
2895                                                  const SirtRef<mirror::Class>& klass,
2896                                                  const SirtRef<mirror::ArtMethod>& prototype) {
2897  // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2898  // prototype method
2899  prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2900                                                                   prototype.get());
2901  // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
2902  // as necessary
2903  mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self));
2904  if (UNLIKELY(method == NULL)) {
2905    CHECK(self->IsExceptionPending());  // OOME.
2906    return NULL;
2907  }
2908
2909  // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2910  // the intersection of throw exceptions as defined in Proxy
2911  method->SetDeclaringClass(klass.get());
2912  method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
2913
2914  // At runtime the method looks like a reference and argument saving method, clone the code
2915  // related parameters from this method.
2916  mirror::ArtMethod* refs_and_args =
2917      Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
2918  method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2919  method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2920  method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
2921  method->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler());
2922  method->SetEntryPointFromPortableCompiledCode(GetPortableProxyInvokeHandler());
2923  method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
2924
2925  return method;
2926}
2927
2928static void CheckProxyMethod(mirror::ArtMethod* method,
2929                             SirtRef<mirror::ArtMethod>& prototype)
2930    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2931  // Basic sanity
2932  CHECK(!prototype->IsFinal());
2933  CHECK(method->IsFinal());
2934  CHECK(!method->IsAbstract());
2935
2936  // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2937  // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2938  CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2939  CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2940  CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2941  CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2942
2943  MethodHelper mh(method);
2944  MethodHelper mh2(prototype.get());
2945  CHECK_STREQ(mh.GetName(), mh2.GetName());
2946  CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
2947  // More complex sanity - via dex cache
2948  CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
2949}
2950
2951static bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics,
2952                                 bool can_init_parents)
2953    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2954  if (can_init_statics && can_init_parents) {
2955    return true;
2956  }
2957  if (!can_init_statics) {
2958    // Check if there's a class initializer.
2959    mirror::ArtMethod* clinit = klass->FindClassInitializer();
2960    if (clinit != NULL) {
2961      return false;
2962    }
2963    // Check if there are encoded static values needing initialization.
2964    if (klass->NumStaticFields() != 0) {
2965      ClassHelper kh(klass);
2966      const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
2967      DCHECK(dex_class_def != NULL);
2968      if (dex_class_def->static_values_off_ != 0) {
2969        return false;
2970      }
2971    }
2972  }
2973  if (!klass->IsInterface() && klass->HasSuperClass()) {
2974    mirror::Class* super_class = klass->GetSuperClass();
2975    if (!can_init_parents && !super_class->IsInitialized()) {
2976      return false;
2977    } else {
2978      if (!CanWeInitializeClass(super_class, can_init_statics, can_init_parents)) {
2979        return false;
2980      }
2981    }
2982  }
2983  return true;
2984}
2985
2986bool ClassLinker::IsInitialized() const {
2987  return init_done_;
2988}
2989
2990bool ClassLinker::InitializeClass(const SirtRef<mirror::Class>& klass, bool can_init_statics,
2991                                  bool can_init_parents) {
2992  // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
2993
2994  // Are we already initialized and therefore done?
2995  // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
2996  // an initialized class will never change its state.
2997  if (klass->IsInitialized()) {
2998    return true;
2999  }
3000
3001  // Fast fail if initialization requires a full runtime. Not part of the JLS.
3002  if (!CanWeInitializeClass(klass.get(), can_init_statics, can_init_parents)) {
3003    return false;
3004  }
3005
3006  Thread* self = Thread::Current();
3007  uint64_t t0;
3008  {
3009    ObjectLock<mirror::Class> lock(self, &klass);
3010
3011    // Re-check under the lock in case another thread initialized ahead of us.
3012    if (klass->IsInitialized()) {
3013      return true;
3014    }
3015
3016    // Was the class already found to be erroneous? Done under the lock to match the JLS.
3017    if (klass->IsErroneous()) {
3018      ThrowEarlierClassFailure(klass.get());
3019      return false;
3020    }
3021
3022    CHECK(klass->IsResolved()) << PrettyClass(klass.get()) << ": state=" << klass->GetStatus();
3023
3024    if (!klass->IsVerified()) {
3025      VerifyClass(klass);
3026      if (!klass->IsVerified()) {
3027        // We failed to verify, expect either the klass to be erroneous or verification failed at
3028        // compile time.
3029        if (klass->IsErroneous()) {
3030          CHECK(self->IsExceptionPending());
3031        } else {
3032          CHECK(Runtime::Current()->IsCompiler());
3033          CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
3034        }
3035        return false;
3036      }
3037    }
3038
3039    // If the class is kStatusInitializing, either this thread is
3040    // initializing higher up the stack or another thread has beat us
3041    // to initializing and we need to wait. Either way, this
3042    // invocation of InitializeClass will not be responsible for
3043    // running <clinit> and will return.
3044    if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
3045      // We caught somebody else in the act; was it us?
3046      if (klass->GetClinitThreadId() == self->GetTid()) {
3047        // Yes. That's fine. Return so we can continue initializing.
3048        return true;
3049      }
3050      // No. That's fine. Wait for another thread to finish initializing.
3051      return WaitForInitializeClass(klass, self, lock);
3052    }
3053
3054    if (!ValidateSuperClassDescriptors(klass)) {
3055      klass->SetStatus(mirror::Class::kStatusError, self);
3056      return false;
3057    }
3058
3059    CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass.get());
3060
3061    // From here out other threads may observe that we're initializing and so changes of state
3062    // require the a notification.
3063    klass->SetClinitThreadId(self->GetTid());
3064    klass->SetStatus(mirror::Class::kStatusInitializing, self);
3065
3066    t0 = NanoTime();
3067  }
3068
3069  // Initialize super classes, must be done while initializing for the JLS.
3070  if (!klass->IsInterface() && klass->HasSuperClass()) {
3071    mirror::Class* super_class = klass->GetSuperClass();
3072    if (!super_class->IsInitialized()) {
3073      CHECK(!super_class->IsInterface());
3074      CHECK(can_init_parents);
3075      SirtRef<mirror::Class> sirt_super(self, super_class);
3076      bool super_initialized = InitializeClass(sirt_super, can_init_statics, true);
3077      if (!super_initialized) {
3078        // The super class was verified ahead of entering initializing, we should only be here if
3079        // the super class became erroneous due to initialization.
3080        CHECK(sirt_super->IsErroneous() && self->IsExceptionPending())
3081            << "Super class initialization failed for " << PrettyDescriptor(sirt_super.get())
3082            << " that has unexpected status " << sirt_super->GetStatus()
3083            << "\nPending exception:\n"
3084            << (self->GetException(NULL) != NULL ? self->GetException(NULL)->Dump() : "");
3085        ObjectLock<mirror::Class> lock(self, &klass);
3086        // Initialization failed because the super-class is erroneous.
3087        klass->SetStatus(mirror::Class::kStatusError, self);
3088        return false;
3089      }
3090    }
3091  }
3092
3093  if (klass->NumStaticFields() > 0) {
3094    ClassHelper kh(klass.get());
3095    const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
3096    CHECK(dex_class_def != NULL);
3097    const DexFile& dex_file = kh.GetDexFile();
3098    SirtRef<mirror::ClassLoader> class_loader(self, klass->GetClassLoader());
3099    SirtRef<mirror::DexCache> dex_cache(self, kh.GetDexCache());
3100    EncodedStaticFieldValueIterator it(dex_file, &dex_cache, &class_loader,
3101                                       this, *dex_class_def);
3102    if (it.HasNext()) {
3103      CHECK(can_init_statics);
3104      // We reordered the fields, so we need to be able to map the field indexes to the right fields.
3105      SafeMap<uint32_t, mirror::ArtField*> field_map;
3106      ConstructFieldMap(dex_file, *dex_class_def, klass.get(), field_map);
3107      for (size_t i = 0; it.HasNext(); i++, it.Next()) {
3108        if (Runtime::Current()->IsActiveTransaction()) {
3109          it.ReadValueToField<true>(field_map.Get(i));
3110        } else {
3111          it.ReadValueToField<false>(field_map.Get(i));
3112        }
3113      }
3114    }
3115  }
3116
3117  mirror::ArtMethod* clinit = klass->FindClassInitializer();
3118  if (clinit != NULL) {
3119    CHECK(can_init_statics);
3120    if (LIKELY(Runtime::Current()->IsStarted())) {
3121      JValue result;
3122      clinit->Invoke(self, NULL, 0, &result, "V");
3123    } else {
3124      art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
3125    }
3126  }
3127
3128  uint64_t t1 = NanoTime();
3129
3130  bool success = true;
3131  {
3132    ObjectLock<mirror::Class> lock(self, &klass);
3133
3134    if (self->IsExceptionPending()) {
3135      WrapExceptionInInitializer();
3136      klass->SetStatus(mirror::Class::kStatusError, self);
3137      success = false;
3138    } else {
3139      RuntimeStats* global_stats = Runtime::Current()->GetStats();
3140      RuntimeStats* thread_stats = self->GetStats();
3141      ++global_stats->class_init_count;
3142      ++thread_stats->class_init_count;
3143      global_stats->class_init_time_ns += (t1 - t0);
3144      thread_stats->class_init_time_ns += (t1 - t0);
3145      // Set the class as initialized except if failed to initialize static fields.
3146      klass->SetStatus(mirror::Class::kStatusInitialized, self);
3147      if (VLOG_IS_ON(class_linker)) {
3148        ClassHelper kh(klass.get());
3149        LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
3150      }
3151      // Opportunistically set static method trampolines to their destination.
3152      FixupStaticTrampolines(klass.get());
3153    }
3154  }
3155  return success;
3156}
3157
3158bool ClassLinker::WaitForInitializeClass(const SirtRef<mirror::Class>& klass, Thread* self,
3159                                         ObjectLock<mirror::Class>& lock)
3160    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
3161  while (true) {
3162    self->AssertNoPendingException();
3163    CHECK(!klass->IsInitialized());
3164    lock.WaitIgnoringInterrupts();
3165
3166    // When we wake up, repeat the test for init-in-progress.  If
3167    // there's an exception pending (only possible if
3168    // "interruptShouldThrow" was set), bail out.
3169    if (self->IsExceptionPending()) {
3170      WrapExceptionInInitializer();
3171      klass->SetStatus(mirror::Class::kStatusError, self);
3172      return false;
3173    }
3174    // Spurious wakeup? Go back to waiting.
3175    if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
3176      continue;
3177    }
3178    if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
3179      // Compile time initialization failed.
3180      return false;
3181    }
3182    if (klass->IsErroneous()) {
3183      // The caller wants an exception, but it was thrown in a
3184      // different thread.  Synthesize one here.
3185      ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
3186                                PrettyDescriptor(klass.get()).c_str());
3187      return false;
3188    }
3189    if (klass->IsInitialized()) {
3190      return true;
3191    }
3192    LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass.get()) << " is "
3193        << klass->GetStatus();
3194  }
3195  LOG(FATAL) << "Not Reached" << PrettyClass(klass.get());
3196}
3197
3198bool ClassLinker::ValidateSuperClassDescriptors(const SirtRef<mirror::Class>& klass) {
3199  if (klass->IsInterface()) {
3200    return true;
3201  }
3202  Thread* self = Thread::Current();
3203  // begin with the methods local to the superclass
3204  if (klass->HasSuperClass() &&
3205      klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
3206    SirtRef<mirror::Class> super(self, klass->GetSuperClass());
3207    for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
3208      mirror::ArtMethod* method = klass->GetVTable()->Get(i);
3209      if (method != super->GetVTable()->Get(i) &&
3210          !IsSameMethodSignatureInDifferentClassContexts(self, method, super.get(), klass.get())) {
3211        ThrowLinkageError(klass.get(), "Class %s method %s resolves differently in superclass %s",
3212                          PrettyDescriptor(klass.get()).c_str(), PrettyMethod(method).c_str(),
3213                          PrettyDescriptor(super.get()).c_str());
3214        return false;
3215      }
3216    }
3217  }
3218  for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
3219    SirtRef<mirror::Class> interface(self, klass->GetIfTable()->GetInterface(i));
3220    if (klass->GetClassLoader() != interface->GetClassLoader()) {
3221      for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
3222        mirror::ArtMethod* method = klass->GetIfTable()->GetMethodArray(i)->Get(j);
3223        if (!IsSameMethodSignatureInDifferentClassContexts(self, method, interface.get(),
3224                                                           method->GetDeclaringClass())) {
3225          ThrowLinkageError(klass.get(), "Class %s method %s resolves differently in interface %s",
3226                            PrettyDescriptor(method->GetDeclaringClass()).c_str(),
3227                            PrettyMethod(method).c_str(),
3228                            PrettyDescriptor(interface.get()).c_str());
3229          return false;
3230        }
3231      }
3232    }
3233  }
3234  return true;
3235}
3236
3237// Returns true if classes referenced by the signature of the method are the
3238// same classes in klass1 as they are in klass2.
3239bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(Thread* self,
3240                                                                mirror::ArtMethod* method,
3241                                                                mirror::Class* klass1,
3242                                                                mirror::Class* klass2) {
3243  if (klass1 == klass2) {
3244    return true;
3245  }
3246  CHECK(klass1 != nullptr);
3247  CHECK(klass2 != nullptr);
3248  SirtRef<mirror::ClassLoader> loader1(self, klass1->GetClassLoader());
3249  SirtRef<mirror::ClassLoader> loader2(self, klass2->GetClassLoader());
3250  const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
3251  const DexFile::ProtoId& proto_id =
3252      dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
3253  for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
3254    const char* descriptor = it.GetDescriptor();
3255    if (descriptor == nullptr) {
3256      break;
3257    }
3258    if (descriptor[0] == 'L' || descriptor[0] == '[') {
3259      // Found a non-primitive type.
3260      if (!IsSameDescriptorInDifferentClassContexts(self, descriptor, loader1, loader2)) {
3261        return false;
3262      }
3263    }
3264  }
3265  // Check the return type
3266  const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
3267  if (descriptor[0] == 'L' || descriptor[0] == '[') {
3268    if (!IsSameDescriptorInDifferentClassContexts(self, descriptor, loader1, loader2)) {
3269      return false;
3270    }
3271  }
3272  return true;
3273}
3274
3275// Returns true if the descriptor resolves to the same class in the context of loader1 and loader2.
3276bool ClassLinker::IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor,
3277                                                           SirtRef<mirror::ClassLoader>& loader1,
3278                                                           SirtRef<mirror::ClassLoader>& loader2) {
3279  CHECK(descriptor != nullptr);
3280  SirtRef<mirror::Class> found1(self, FindClass(self, descriptor, loader1));
3281  if (found1.get() == nullptr) {
3282    self->ClearException();
3283  }
3284  mirror::Class* found2 = FindClass(self, descriptor, loader2);
3285  if (found2 == nullptr) {
3286    self->ClearException();
3287  }
3288  return found1.get() == found2;
3289}
3290
3291bool ClassLinker::EnsureInitialized(const SirtRef<mirror::Class>& c, bool can_init_fields,
3292                                    bool can_init_parents) {
3293  DCHECK(c.get() != NULL);
3294  if (c->IsInitialized()) {
3295    return true;
3296  }
3297
3298  bool success = InitializeClass(c, can_init_fields, can_init_parents);
3299  if (!success) {
3300    if (can_init_fields && can_init_parents) {
3301      CHECK(Thread::Current()->IsExceptionPending()) << PrettyClass(c.get());
3302    }
3303  }
3304  return success;
3305}
3306
3307void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
3308                                    mirror::Class* c,
3309                                    SafeMap<uint32_t, mirror::ArtField*>& field_map) {
3310  const byte* class_data = dex_file.GetClassData(dex_class_def);
3311  ClassDataItemIterator it(dex_file, class_data);
3312  Thread* self = Thread::Current();
3313  SirtRef<mirror::DexCache> dex_cache(self, c->GetDexCache());
3314  SirtRef<mirror::ClassLoader> class_loader(self, c->GetClassLoader());
3315  CHECK(!kMovingFields);
3316  for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
3317    field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), dex_cache, class_loader, true));
3318  }
3319}
3320
3321bool ClassLinker::LinkClass(Thread* self, const SirtRef<mirror::Class>& klass,
3322                            const SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
3323  CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
3324  if (!LinkSuperClass(klass)) {
3325    return false;
3326  }
3327  if (!LinkMethods(klass, interfaces)) {
3328    return false;
3329  }
3330  if (!LinkInstanceFields(klass)) {
3331    return false;
3332  }
3333  if (!LinkStaticFields(klass)) {
3334    return false;
3335  }
3336  CreateReferenceInstanceOffsets(klass);
3337  CreateReferenceStaticOffsets(klass);
3338  CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
3339  klass->SetStatus(mirror::Class::kStatusResolved, self);
3340  return true;
3341}
3342
3343bool ClassLinker::LoadSuperAndInterfaces(const SirtRef<mirror::Class>& klass,
3344                                         const DexFile& dex_file) {
3345  CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
3346  const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
3347  uint16_t super_class_idx = class_def.superclass_idx_;
3348  if (super_class_idx != DexFile::kDexNoIndex16) {
3349    mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
3350    if (super_class == NULL) {
3351      DCHECK(Thread::Current()->IsExceptionPending());
3352      return false;
3353    }
3354    // Verify
3355    if (!klass->CanAccess(super_class)) {
3356      ThrowIllegalAccessError(klass.get(), "Class %s extended by class %s is inaccessible",
3357                              PrettyDescriptor(super_class).c_str(),
3358                              PrettyDescriptor(klass.get()).c_str());
3359      return false;
3360    }
3361    klass->SetSuperClass(super_class);
3362  }
3363  const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
3364  if (interfaces != NULL) {
3365    for (size_t i = 0; i < interfaces->Size(); i++) {
3366      uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
3367      mirror::Class* interface = ResolveType(dex_file, idx, klass.get());
3368      if (interface == NULL) {
3369        DCHECK(Thread::Current()->IsExceptionPending());
3370        return false;
3371      }
3372      // Verify
3373      if (!klass->CanAccess(interface)) {
3374        // TODO: the RI seemed to ignore this in my testing.
3375        ThrowIllegalAccessError(klass.get(), "Interface %s implemented by class %s is inaccessible",
3376                                PrettyDescriptor(interface).c_str(),
3377                                PrettyDescriptor(klass.get()).c_str());
3378        return false;
3379      }
3380    }
3381  }
3382  // Mark the class as loaded.
3383  klass->SetStatus(mirror::Class::kStatusLoaded, NULL);
3384  return true;
3385}
3386
3387bool ClassLinker::LinkSuperClass(const SirtRef<mirror::Class>& klass) {
3388  CHECK(!klass->IsPrimitive());
3389  mirror::Class* super = klass->GetSuperClass();
3390  if (klass.get() == GetClassRoot(kJavaLangObject)) {
3391    if (super != NULL) {
3392      ThrowClassFormatError(klass.get(), "java.lang.Object must not have a superclass");
3393      return false;
3394    }
3395    return true;
3396  }
3397  if (super == NULL) {
3398    ThrowLinkageError(klass.get(), "No superclass defined for class %s",
3399                      PrettyDescriptor(klass.get()).c_str());
3400    return false;
3401  }
3402  // Verify
3403  if (super->IsFinal() || super->IsInterface()) {
3404    ThrowIncompatibleClassChangeError(klass.get(), "Superclass %s of %s is %s",
3405                                      PrettyDescriptor(super).c_str(),
3406                                      PrettyDescriptor(klass.get()).c_str(),
3407                                      super->IsFinal() ? "declared final" : "an interface");
3408    return false;
3409  }
3410  if (!klass->CanAccess(super)) {
3411    ThrowIllegalAccessError(klass.get(), "Superclass %s is inaccessible to class %s",
3412                            PrettyDescriptor(super).c_str(),
3413                            PrettyDescriptor(klass.get()).c_str());
3414    return false;
3415  }
3416
3417  // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
3418  if (super->IsFinalizable()) {
3419    klass->SetFinalizable();
3420  }
3421
3422  // Inherit reference flags (if any) from the superclass.
3423  int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
3424  if (reference_flags != 0) {
3425    klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
3426  }
3427  // Disallow custom direct subclasses of java.lang.ref.Reference.
3428  if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
3429    ThrowLinkageError(klass.get(),
3430                      "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
3431                      PrettyDescriptor(klass.get()).c_str());
3432    return false;
3433  }
3434
3435  if (kIsDebugBuild) {
3436    // Ensure super classes are fully resolved prior to resolving fields..
3437    while (super != NULL) {
3438      CHECK(super->IsResolved());
3439      super = super->GetSuperClass();
3440    }
3441  }
3442  return true;
3443}
3444
3445// Populate the class vtable and itable. Compute return type indices.
3446bool ClassLinker::LinkMethods(const SirtRef<mirror::Class>& klass,
3447                              const SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
3448  if (klass->IsInterface()) {
3449    // No vtable.
3450    size_t count = klass->NumVirtualMethods();
3451    if (!IsUint(16, count)) {
3452      ThrowClassFormatError(klass.get(), "Too many methods on interface: %zd", count);
3453      return false;
3454    }
3455    for (size_t i = 0; i < count; ++i) {
3456      klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
3457    }
3458    // Link interface method tables
3459    return LinkInterfaceMethods(klass, interfaces);
3460  } else {
3461    // Link virtual and interface method tables
3462    return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
3463  }
3464  return true;
3465}
3466
3467bool ClassLinker::LinkVirtualMethods(const SirtRef<mirror::Class>& klass) {
3468  Thread* self = Thread::Current();
3469  if (klass->HasSuperClass()) {
3470    uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3471    size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
3472    CHECK_LE(actual_count, max_count);
3473    // TODO: do not assign to the vtable field until it is fully constructed.
3474    SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3475      vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
3476    if (UNLIKELY(vtable.get() == NULL)) {
3477      CHECK(self->IsExceptionPending());  // OOME.
3478      return false;
3479    }
3480    // See if any of our virtual methods override the superclass.
3481    for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
3482      mirror::ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
3483      MethodHelper local_mh(local_method);
3484      size_t j = 0;
3485      for (; j < actual_count; ++j) {
3486        mirror::ArtMethod* super_method = vtable->Get(j);
3487        MethodHelper super_mh(super_method);
3488        if (local_mh.HasSameNameAndSignature(&super_mh)) {
3489          if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3490            if (super_method->IsFinal()) {
3491              ThrowLinkageError(klass.get(), "Method %s overrides final method in class %s",
3492                                PrettyMethod(local_method).c_str(),
3493                                super_mh.GetDeclaringClassDescriptor());
3494              return false;
3495            }
3496            vtable->Set<false>(j, local_method);
3497            local_method->SetMethodIndex(j);
3498            break;
3499          } else {
3500            LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3501                         << " would have incorrectly overridden the package-private method in "
3502                         << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
3503          }
3504        }
3505      }
3506      if (j == actual_count) {
3507        // Not overriding, append.
3508        vtable->Set<false>(actual_count, local_method);
3509        local_method->SetMethodIndex(actual_count);
3510        actual_count += 1;
3511      }
3512    }
3513    if (!IsUint(16, actual_count)) {
3514      ThrowClassFormatError(klass.get(), "Too many methods defined on class: %zd", actual_count);
3515      return false;
3516    }
3517    // Shrink vtable if possible
3518    CHECK_LE(actual_count, max_count);
3519    if (actual_count < max_count) {
3520      vtable.reset(vtable->CopyOf(self, actual_count));
3521      if (UNLIKELY(vtable.get() == NULL)) {
3522        CHECK(self->IsExceptionPending());  // OOME.
3523        return false;
3524      }
3525    }
3526    klass->SetVTable(vtable.get());
3527  } else {
3528    CHECK(klass.get() == GetClassRoot(kJavaLangObject));
3529    uint32_t num_virtual_methods = klass->NumVirtualMethods();
3530    if (!IsUint(16, num_virtual_methods)) {
3531      ThrowClassFormatError(klass.get(), "Too many methods: %d", num_virtual_methods);
3532      return false;
3533    }
3534    SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3535        vtable(self, AllocArtMethodArray(self, num_virtual_methods));
3536    if (UNLIKELY(vtable.get() == NULL)) {
3537      CHECK(self->IsExceptionPending());  // OOME.
3538      return false;
3539    }
3540    for (size_t i = 0; i < num_virtual_methods; ++i) {
3541      mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
3542      vtable->Set<false>(i, virtual_method);
3543      virtual_method->SetMethodIndex(i & 0xFFFF);
3544    }
3545    klass->SetVTable(vtable.get());
3546  }
3547  return true;
3548}
3549
3550bool ClassLinker::LinkInterfaceMethods(const SirtRef<mirror::Class>& klass,
3551                                       const SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
3552  // Set the imt table to be all conflicts by default.
3553  klass->SetImTable(Runtime::Current()->GetDefaultImt());
3554  size_t super_ifcount;
3555  if (klass->HasSuperClass()) {
3556    super_ifcount = klass->GetSuperClass()->GetIfTableCount();
3557  } else {
3558    super_ifcount = 0;
3559  }
3560  size_t ifcount = super_ifcount;
3561  uint32_t num_interfaces;
3562  {
3563    ClassHelper kh(klass.get());
3564    num_interfaces =
3565        interfaces.get() == nullptr ? kh.NumDirectInterfaces() : interfaces->GetLength();
3566    ifcount += num_interfaces;
3567    for (size_t i = 0; i < num_interfaces; i++) {
3568      mirror::Class* interface =
3569          interfaces.get() == nullptr ? kh.GetDirectInterface(i) : interfaces->Get(i);
3570      ifcount += interface->GetIfTableCount();
3571    }
3572  }
3573  if (ifcount == 0) {
3574    // Class implements no interfaces.
3575    DCHECK_EQ(klass->GetIfTableCount(), 0);
3576    DCHECK(klass->GetIfTable() == NULL);
3577    return true;
3578  }
3579  if (ifcount == super_ifcount) {
3580    // Class implements same interfaces as parent, are any of these not marker interfaces?
3581    bool has_non_marker_interface = false;
3582    mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
3583    for (size_t i = 0; i < ifcount; ++i) {
3584      if (super_iftable->GetMethodArrayCount(i) > 0) {
3585        has_non_marker_interface = true;
3586        break;
3587      }
3588    }
3589    if (!has_non_marker_interface) {
3590      // Class just inherits marker interfaces from parent so recycle parent's iftable.
3591      klass->SetIfTable(super_iftable);
3592      return true;
3593    }
3594  }
3595  Thread* self = Thread::Current();
3596  SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
3597  if (UNLIKELY(iftable.get() == NULL)) {
3598    CHECK(self->IsExceptionPending());  // OOME.
3599    return false;
3600  }
3601  if (super_ifcount != 0) {
3602    mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
3603    for (size_t i = 0; i < super_ifcount; i++) {
3604      mirror::Class* super_interface = super_iftable->GetInterface(i);
3605      iftable->SetInterface(i, super_interface);
3606    }
3607  }
3608  // Flatten the interface inheritance hierarchy.
3609  size_t idx = super_ifcount;
3610  for (size_t i = 0; i < num_interfaces; i++) {
3611    ClassHelper kh(klass.get());
3612    mirror::Class* interface =
3613        interfaces.get() == nullptr ? kh.GetDirectInterface(i) : interfaces->Get(i);
3614    DCHECK(interface != NULL);
3615    if (!interface->IsInterface()) {
3616      ClassHelper ih(interface);
3617      ThrowIncompatibleClassChangeError(klass.get(), "Class %s implements non-interface class %s",
3618                                        PrettyDescriptor(klass.get()).c_str(),
3619                                        PrettyDescriptor(ih.GetDescriptor()).c_str());
3620      return false;
3621    }
3622    // Check if interface is already in iftable
3623    bool duplicate = false;
3624    for (size_t j = 0; j < idx; j++) {
3625      mirror::Class* existing_interface = iftable->GetInterface(j);
3626      if (existing_interface == interface) {
3627        duplicate = true;
3628        break;
3629      }
3630    }
3631    if (!duplicate) {
3632      // Add this non-duplicate interface.
3633      iftable->SetInterface(idx++, interface);
3634      // Add this interface's non-duplicate super-interfaces.
3635      for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
3636        mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
3637        bool super_duplicate = false;
3638        for (size_t k = 0; k < idx; k++) {
3639          mirror::Class* existing_interface = iftable->GetInterface(k);
3640          if (existing_interface == super_interface) {
3641            super_duplicate = true;
3642            break;
3643          }
3644        }
3645        if (!super_duplicate) {
3646          iftable->SetInterface(idx++, super_interface);
3647        }
3648      }
3649    }
3650  }
3651  // Shrink iftable in case duplicates were found
3652  if (idx < ifcount) {
3653    iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
3654    if (UNLIKELY(iftable.get() == NULL)) {
3655      CHECK(self->IsExceptionPending());  // OOME.
3656      return false;
3657    }
3658    ifcount = idx;
3659  } else {
3660    CHECK_EQ(idx, ifcount);
3661  }
3662  klass->SetIfTable(iftable.get());
3663
3664  // If we're an interface, we don't need the vtable pointers, so we're done.
3665  if (klass->IsInterface()) {
3666    return true;
3667  }
3668  // Allocate imtable
3669  bool imtable_changed = false;
3670  SirtRef<mirror::ObjectArray<mirror::ArtMethod> > imtable(self, AllocArtMethodArray(self, kImtSize));
3671  if (UNLIKELY(imtable.get() == NULL)) {
3672    CHECK(self->IsExceptionPending());  // OOME.
3673    return false;
3674  }
3675  std::vector<mirror::ArtMethod*> miranda_list;
3676  for (size_t i = 0; i < ifcount; ++i) {
3677    size_t num_methods = iftable->GetInterface(i)->NumVirtualMethods();
3678    if (num_methods > 0) {
3679      SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3680          method_array(self, AllocArtMethodArray(self, num_methods));
3681      if (UNLIKELY(method_array.get() == nullptr)) {
3682        CHECK(self->IsExceptionPending());  // OOME.
3683        return false;
3684      }
3685      iftable->SetMethodArray(i, method_array.get());
3686      SirtRef<mirror::ObjectArray<mirror::ArtMethod> > vtable(self,
3687                                                              klass->GetVTableDuringLinking());
3688      for (size_t j = 0; j < num_methods; ++j) {
3689        mirror::ArtMethod* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j);
3690        MethodHelper interface_mh(interface_method);
3691        int32_t k;
3692        // For each method listed in the interface's method list, find the
3693        // matching method in our class's method list.  We want to favor the
3694        // subclass over the superclass, which just requires walking
3695        // back from the end of the vtable.  (This only matters if the
3696        // superclass defines a private method and this class redefines
3697        // it -- otherwise it would use the same vtable slot.  In .dex files
3698        // those don't end up in the virtual method table, so it shouldn't
3699        // matter which direction we go.  We walk it backward anyway.)
3700        for (k = vtable->GetLength() - 1; k >= 0; --k) {
3701          mirror::ArtMethod* vtable_method = vtable->Get(k);
3702          MethodHelper vtable_mh(vtable_method);
3703          if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3704            if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
3705              ThrowIllegalAccessError(klass.get(),
3706                                      "Method '%s' implementing interface method '%s' is not public",
3707                                      PrettyMethod(vtable_method).c_str(),
3708                                      PrettyMethod(interface_method).c_str());
3709              return false;
3710            }
3711            method_array->Set<false>(j, vtable_method);
3712            // Place method in imt if entry is empty, place conflict otherwise.
3713            uint32_t imt_index = interface_method->GetDexMethodIndex() % kImtSize;
3714            if (imtable->Get(imt_index) == NULL) {
3715              imtable->Set<false>(imt_index, vtable_method);
3716              imtable_changed = true;
3717            } else {
3718              imtable->Set<false>(imt_index, Runtime::Current()->GetImtConflictMethod());
3719            }
3720            break;
3721          }
3722        }
3723        if (k < 0) {
3724          SirtRef<mirror::ArtMethod> miranda_method(self, NULL);
3725          for (size_t mir = 0; mir < miranda_list.size(); mir++) {
3726            mirror::ArtMethod* mir_method = miranda_list[mir];
3727            MethodHelper vtable_mh(mir_method);
3728            if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3729              miranda_method.reset(miranda_list[mir]);
3730              break;
3731            }
3732          }
3733          if (miranda_method.get() == NULL) {
3734            // Point the interface table at a phantom slot.
3735            miranda_method.reset(down_cast<mirror::ArtMethod*>(interface_method->Clone(self)));
3736            if (UNLIKELY(miranda_method.get() == NULL)) {
3737              CHECK(self->IsExceptionPending());  // OOME.
3738              return false;
3739            }
3740            // TODO: If a methods move then the miranda_list may hold stale references.
3741            miranda_list.push_back(miranda_method.get());
3742          }
3743          method_array->Set<false>(j, miranda_method.get());
3744        }
3745      }
3746    }
3747  }
3748  if (imtable_changed) {
3749    // Fill in empty entries in interface method table with conflict.
3750    mirror::ArtMethod* imt_conflict_method = Runtime::Current()->GetImtConflictMethod();
3751    for (size_t i = 0; i < kImtSize; i++) {
3752      if (imtable->Get(i) == NULL) {
3753        imtable->Set<false>(i, imt_conflict_method);
3754      }
3755    }
3756    klass->SetImTable(imtable.get());
3757  }
3758  if (!miranda_list.empty()) {
3759    int old_method_count = klass->NumVirtualMethods();
3760    int new_method_count = old_method_count + miranda_list.size();
3761    mirror::ObjectArray<mirror::ArtMethod>* virtuals;
3762    if (old_method_count == 0) {
3763      virtuals = AllocArtMethodArray(self, new_method_count);
3764    } else {
3765      virtuals = klass->GetVirtualMethods()->CopyOf(self, new_method_count);
3766    }
3767    if (UNLIKELY(virtuals == NULL)) {
3768      CHECK(self->IsExceptionPending());  // OOME.
3769      return false;
3770    }
3771    klass->SetVirtualMethods(virtuals);
3772
3773    SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3774        vtable(self, klass->GetVTableDuringLinking());
3775    CHECK(vtable.get() != NULL);
3776    int old_vtable_count = vtable->GetLength();
3777    int new_vtable_count = old_vtable_count + miranda_list.size();
3778    vtable.reset(vtable->CopyOf(self, new_vtable_count));
3779    if (UNLIKELY(vtable.get() == NULL)) {
3780      CHECK(self->IsExceptionPending());  // OOME.
3781      return false;
3782    }
3783    for (size_t i = 0; i < miranda_list.size(); ++i) {
3784      mirror::ArtMethod* method = miranda_list[i];
3785      // Leave the declaring class alone as type indices are relative to it
3786      method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3787      method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3788      klass->SetVirtualMethod(old_method_count + i, method);
3789      vtable->Set<false>(old_vtable_count + i, method);
3790    }
3791    // TODO: do not assign to the vtable field until it is fully constructed.
3792    klass->SetVTable(vtable.get());
3793  }
3794
3795  mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
3796  for (int i = 0; i < vtable->GetLength(); ++i) {
3797    CHECK(vtable->Get(i) != NULL);
3798  }
3799
3800//  klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3801
3802  return true;
3803}
3804
3805bool ClassLinker::LinkInstanceFields(const SirtRef<mirror::Class>& klass) {
3806  CHECK(klass.get() != NULL);
3807  return LinkFields(klass, false);
3808}
3809
3810bool ClassLinker::LinkStaticFields(const SirtRef<mirror::Class>& klass) {
3811  CHECK(klass.get() != NULL);
3812  size_t allocated_class_size = klass->GetClassSize();
3813  bool success = LinkFields(klass, true);
3814  CHECK_EQ(allocated_class_size, klass->GetClassSize());
3815  return success;
3816}
3817
3818struct LinkFieldsComparator {
3819  explicit LinkFieldsComparator() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
3820  }
3821  // No thread safety analysis as will be called from STL. Checked lock held in constructor.
3822  bool operator()(mirror::ArtField* field1, mirror::ArtField* field2)
3823      NO_THREAD_SAFETY_ANALYSIS {
3824    // First come reference fields, then 64-bit, and finally 32-bit
3825    FieldHelper fh1(field1);
3826    Primitive::Type type1 = fh1.GetTypeAsPrimitiveType();
3827    FieldHelper fh2(field2);
3828    Primitive::Type type2 = fh2.GetTypeAsPrimitiveType();
3829    if (type1 != type2) {
3830      bool is_primitive1 = type1 != Primitive::kPrimNot;
3831      bool is_primitive2 = type2 != Primitive::kPrimNot;
3832      bool is64bit1 = is_primitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3833      bool is64bit2 = is_primitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
3834      int order1 = !is_primitive1 ? 0 : (is64bit1 ? 1 : 2);
3835      int order2 = !is_primitive2 ? 0 : (is64bit2 ? 1 : 2);
3836      if (order1 != order2) {
3837        return order1 < order2;
3838      }
3839    }
3840    // same basic group? then sort by string.
3841    const char* name1 = fh1.GetName();
3842    const char* name2 = fh2.GetName();
3843    return strcmp(name1, name2) < 0;
3844  }
3845};
3846
3847bool ClassLinker::LinkFields(const SirtRef<mirror::Class>& klass, bool is_static) {
3848  size_t num_fields =
3849      is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
3850
3851  mirror::ObjectArray<mirror::ArtField>* fields =
3852      is_static ? klass->GetSFields() : klass->GetIFields();
3853
3854  // Initialize size and field_offset
3855  size_t size;
3856  MemberOffset field_offset(0);
3857  if (is_static) {
3858    size = klass->GetClassSize();
3859    field_offset = mirror::Class::FieldsOffset();
3860  } else {
3861    mirror::Class* super_class = klass->GetSuperClass();
3862    if (super_class != NULL) {
3863      CHECK(super_class->IsResolved());
3864      field_offset = MemberOffset(super_class->GetObjectSize());
3865    }
3866    size = field_offset.Uint32Value();
3867  }
3868
3869  CHECK_EQ(num_fields == 0, fields == NULL);
3870
3871  // we want a relatively stable order so that adding new fields
3872  // minimizes disruption of C++ version such as Class and Method.
3873  std::deque<mirror::ArtField*> grouped_and_sorted_fields;
3874  for (size_t i = 0; i < num_fields; i++) {
3875    mirror::ArtField* f = fields->Get(i);
3876    CHECK(f != NULL);
3877    grouped_and_sorted_fields.push_back(f);
3878  }
3879  std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(),
3880            LinkFieldsComparator());
3881
3882  // References should be at the front.
3883  size_t current_field = 0;
3884  size_t num_reference_fields = 0;
3885  for (; current_field < num_fields; current_field++) {
3886    mirror::ArtField* field = grouped_and_sorted_fields.front();
3887    FieldHelper fh(field);
3888    Primitive::Type type = fh.GetTypeAsPrimitiveType();
3889    bool isPrimitive = type != Primitive::kPrimNot;
3890    if (isPrimitive) {
3891      break;  // past last reference, move on to the next phase
3892    }
3893    grouped_and_sorted_fields.pop_front();
3894    num_reference_fields++;
3895    fields->Set<false>(current_field, field);
3896    field->SetOffset(field_offset);
3897    field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
3898  }
3899
3900  // Now we want to pack all of the double-wide fields together.  If
3901  // we're not aligned, though, we want to shuffle one 32-bit field
3902  // into place.  If we can't find one, we'll have to pad it.
3903  if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
3904    for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
3905      mirror::ArtField* field = grouped_and_sorted_fields[i];
3906      FieldHelper fh(field);
3907      Primitive::Type type = fh.GetTypeAsPrimitiveType();
3908      CHECK(type != Primitive::kPrimNot);  // should only be working on primitive types
3909      if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
3910        continue;
3911      }
3912      fields->Set<false>(current_field++, field);
3913      field->SetOffset(field_offset);
3914      // drop the consumed field
3915      grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3916      break;
3917    }
3918    // whether we found a 32-bit field for padding or not, we advance
3919    field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
3920  }
3921
3922  // Alignment is good, shuffle any double-wide fields forward, and
3923  // finish assigning field offsets to all fields.
3924  DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
3925  while (!grouped_and_sorted_fields.empty()) {
3926    mirror::ArtField* field = grouped_and_sorted_fields.front();
3927    grouped_and_sorted_fields.pop_front();
3928    FieldHelper fh(field);
3929    Primitive::Type type = fh.GetTypeAsPrimitiveType();
3930    CHECK(type != Primitive::kPrimNot);  // should only be working on primitive types
3931    fields->Set<false>(current_field, field);
3932    field->SetOffset(field_offset);
3933    field_offset = MemberOffset(field_offset.Uint32Value() +
3934                                ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
3935                                 ? sizeof(uint64_t)
3936                                 : sizeof(uint32_t)));
3937    current_field++;
3938  }
3939
3940  // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it.
3941  if (!is_static &&
3942      (strcmp("Ljava/lang/ref/Reference;", ClassHelper(klass.get()).GetDescriptor()) == 0)) {
3943    // We know there are no non-reference fields in the Reference classes, and we know
3944    // that 'referent' is alphabetically last, so this is easy...
3945    CHECK_EQ(num_reference_fields, num_fields);
3946    FieldHelper fh(fields->Get(num_fields - 1));
3947    CHECK_STREQ(fh.GetName(), "referent");
3948    --num_reference_fields;
3949  }
3950
3951  if (kIsDebugBuild) {
3952    // Make sure that all reference fields appear before
3953    // non-reference fields, and all double-wide fields are aligned.
3954    bool seen_non_ref = false;
3955    for (size_t i = 0; i < num_fields; i++) {
3956      mirror::ArtField* field = fields->Get(i);
3957      if (false) {  // enable to debug field layout
3958        LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
3959                    << " class=" << PrettyClass(klass.get())
3960                    << " field=" << PrettyField(field)
3961                    << " offset=" << field->GetField32(MemberOffset(mirror::ArtField::OffsetOffset()),
3962                                                       false);
3963      }
3964      FieldHelper fh(field);
3965      Primitive::Type type = fh.GetTypeAsPrimitiveType();
3966      bool is_primitive = type != Primitive::kPrimNot;
3967      if ((strcmp("Ljava/lang/ref/Reference;", ClassHelper(klass.get()).GetDescriptor()) == 0)
3968          && (strcmp("referent", fh.GetName()) == 0)) {
3969        is_primitive = true;  // We lied above, so we have to expect a lie here.
3970      }
3971      if (is_primitive) {
3972        if (!seen_non_ref) {
3973          seen_non_ref = true;
3974          DCHECK_EQ(num_reference_fields, i);
3975        }
3976      } else {
3977        DCHECK(!seen_non_ref);
3978      }
3979    }
3980    if (!seen_non_ref) {
3981      DCHECK_EQ(num_fields, num_reference_fields);
3982    }
3983  }
3984  size = field_offset.Uint32Value();
3985  // Update klass
3986  if (is_static) {
3987    klass->SetNumReferenceStaticFields(num_reference_fields);
3988    klass->SetClassSize(size);
3989  } else {
3990    klass->SetNumReferenceInstanceFields(num_reference_fields);
3991    if (!klass->IsVariableSize()) {
3992      DCHECK_GE(size, sizeof(mirror::Object)) << ClassHelper(klass.get()).GetDescriptor();
3993      size_t previous_size = klass->GetObjectSize();
3994      if (previous_size != 0) {
3995        // Make sure that we didn't originally have an incorrect size.
3996        CHECK_EQ(previous_size, size);
3997      }
3998      klass->SetObjectSize(size);
3999    }
4000  }
4001  return true;
4002}
4003
4004//  Set the bitmap of reference offsets, refOffsets, from the ifields
4005//  list.
4006void ClassLinker::CreateReferenceInstanceOffsets(const SirtRef<mirror::Class>& klass) {
4007  uint32_t reference_offsets = 0;
4008  mirror::Class* super_class = klass->GetSuperClass();
4009  if (super_class != NULL) {
4010    reference_offsets = super_class->GetReferenceInstanceOffsets();
4011    // If our superclass overflowed, we don't stand a chance.
4012    if (reference_offsets == CLASS_WALK_SUPER) {
4013      klass->SetReferenceInstanceOffsets(reference_offsets);
4014      return;
4015    }
4016  }
4017  CreateReferenceOffsets(klass, false, reference_offsets);
4018}
4019
4020void ClassLinker::CreateReferenceStaticOffsets(const SirtRef<mirror::Class>& klass) {
4021  CreateReferenceOffsets(klass, true, 0);
4022}
4023
4024void ClassLinker::CreateReferenceOffsets(const SirtRef<mirror::Class>& klass, bool is_static,
4025                                         uint32_t reference_offsets) {
4026  size_t num_reference_fields =
4027      is_static ? klass->NumReferenceStaticFieldsDuringLinking()
4028                : klass->NumReferenceInstanceFieldsDuringLinking();
4029  mirror::ObjectArray<mirror::ArtField>* fields =
4030      is_static ? klass->GetSFields() : klass->GetIFields();
4031  // All of the fields that contain object references are guaranteed
4032  // to be at the beginning of the fields list.
4033  for (size_t i = 0; i < num_reference_fields; ++i) {
4034    // Note that byte_offset is the offset from the beginning of
4035    // object, not the offset into instance data
4036    mirror::ArtField* field = fields->Get(i);
4037    MemberOffset byte_offset = field->GetOffsetDuringLinking();
4038    CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
4039    if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
4040      uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
4041      CHECK_NE(new_bit, 0U);
4042      reference_offsets |= new_bit;
4043    } else {
4044      reference_offsets = CLASS_WALK_SUPER;
4045      break;
4046    }
4047  }
4048  // Update fields in klass
4049  if (is_static) {
4050    klass->SetReferenceStaticOffsets(reference_offsets);
4051  } else {
4052    klass->SetReferenceInstanceOffsets(reference_offsets);
4053  }
4054}
4055
4056mirror::String* ClassLinker::ResolveString(const DexFile& dex_file, uint32_t string_idx,
4057                                           const SirtRef<mirror::DexCache>& dex_cache) {
4058  DCHECK(dex_cache.get() != nullptr);
4059  mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
4060  if (resolved != NULL) {
4061    return resolved;
4062  }
4063  uint32_t utf16_length;
4064  const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
4065  mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
4066  dex_cache->SetResolvedString(string_idx, string);
4067  return string;
4068}
4069
4070mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
4071                                        mirror::Class* referrer) {
4072  Thread* self = Thread::Current();
4073  SirtRef<mirror::DexCache> dex_cache(self, referrer->GetDexCache());
4074  SirtRef<mirror::ClassLoader> class_loader(self, referrer->GetClassLoader());
4075  return ResolveType(dex_file, type_idx, dex_cache, class_loader);
4076}
4077
4078mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
4079                                        const SirtRef<mirror::DexCache>& dex_cache,
4080                                        const SirtRef<mirror::ClassLoader>& class_loader) {
4081  DCHECK(dex_cache.get() != NULL);
4082  mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
4083  if (resolved == NULL) {
4084    Thread* self = Thread::Current();
4085    const char* descriptor = dex_file.StringByTypeIdx(type_idx);
4086    resolved = FindClass(self, descriptor, class_loader);
4087    if (resolved != NULL) {
4088      // TODO: we used to throw here if resolved's class loader was not the
4089      //       boot class loader. This was to permit different classes with the
4090      //       same name to be loaded simultaneously by different loaders
4091      dex_cache->SetResolvedType(type_idx, resolved);
4092    } else {
4093      CHECK(self->IsExceptionPending())
4094          << "Expected pending exception for failed resolution of: " << descriptor;
4095      // Convert a ClassNotFoundException to a NoClassDefFoundError.
4096      SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
4097      if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
4098        DCHECK(resolved == NULL);  // No SirtRef needed to preserve resolved.
4099        self->ClearException();
4100        ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
4101        self->GetException(NULL)->SetCause(cause.get());
4102      }
4103    }
4104  }
4105  DCHECK((resolved == NULL) || resolved->IsResolved() || resolved->IsErroneous())
4106          << PrettyDescriptor(resolved) << " " << resolved->GetStatus();
4107  return resolved;
4108}
4109
4110mirror::ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
4111                                              uint32_t method_idx,
4112                                              const SirtRef<mirror::DexCache>& dex_cache,
4113                                              const SirtRef<mirror::ClassLoader>& class_loader,
4114                                              mirror::ArtMethod* referrer,
4115                                              InvokeType type) {
4116  DCHECK(dex_cache.get() != NULL);
4117  // Check for hit in the dex cache.
4118  mirror::ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
4119  if (resolved != NULL && !resolved->IsRuntimeMethod()) {
4120    return resolved;
4121  }
4122  // Fail, get the declaring class.
4123  const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
4124  mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
4125  if (klass == NULL) {
4126    DCHECK(Thread::Current()->IsExceptionPending());
4127    return NULL;
4128  }
4129  // Scan using method_idx, this saves string compares but will only hit for matching dex
4130  // caches/files.
4131  switch (type) {
4132    case kDirect:  // Fall-through.
4133    case kStatic:
4134      resolved = klass->FindDirectMethod(dex_cache.get(), method_idx);
4135      break;
4136    case kInterface:
4137      resolved = klass->FindInterfaceMethod(dex_cache.get(), method_idx);
4138      DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
4139      break;
4140    case kSuper:  // Fall-through.
4141    case kVirtual:
4142      resolved = klass->FindVirtualMethod(dex_cache.get(), method_idx);
4143      break;
4144    default:
4145      LOG(FATAL) << "Unreachable - invocation type: " << type;
4146  }
4147  if (resolved == NULL) {
4148    // Search by name, which works across dex files.
4149    const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
4150    const Signature signature = dex_file.GetMethodSignature(method_id);
4151    switch (type) {
4152      case kDirect:  // Fall-through.
4153      case kStatic:
4154        resolved = klass->FindDirectMethod(name, signature);
4155        break;
4156      case kInterface:
4157        resolved = klass->FindInterfaceMethod(name, signature);
4158        DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
4159        break;
4160      case kSuper:  // Fall-through.
4161      case kVirtual:
4162        resolved = klass->FindVirtualMethod(name, signature);
4163        break;
4164    }
4165  }
4166  if (resolved != NULL) {
4167    // We found a method, check for incompatible class changes.
4168    if (resolved->CheckIncompatibleClassChange(type)) {
4169      resolved = NULL;
4170    }
4171  }
4172  if (resolved != NULL) {
4173    // Be a good citizen and update the dex cache to speed subsequent calls.
4174    dex_cache->SetResolvedMethod(method_idx, resolved);
4175    return resolved;
4176  } else {
4177    // We failed to find the method which means either an access error, an incompatible class
4178    // change, or no such method. First try to find the method among direct and virtual methods.
4179    const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
4180    const Signature signature = dex_file.GetMethodSignature(method_id);
4181    switch (type) {
4182      case kDirect:
4183      case kStatic:
4184        resolved = klass->FindVirtualMethod(name, signature);
4185        break;
4186      case kInterface:
4187      case kVirtual:
4188      case kSuper:
4189        resolved = klass->FindDirectMethod(name, signature);
4190        break;
4191    }
4192
4193    // If we found something, check that it can be accessed by the referrer.
4194    if (resolved != NULL && referrer != NULL) {
4195      mirror::Class* methods_class = resolved->GetDeclaringClass();
4196      mirror::Class* referring_class = referrer->GetDeclaringClass();
4197      if (!referring_class->CanAccess(methods_class)) {
4198        ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
4199                                                      resolved, type);
4200        return NULL;
4201      } else if (!referring_class->CanAccessMember(methods_class,
4202                                                   resolved->GetAccessFlags())) {
4203        ThrowIllegalAccessErrorMethod(referring_class, resolved);
4204        return NULL;
4205      }
4206    }
4207
4208    // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
4209    // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
4210    switch (type) {
4211      case kDirect:
4212      case kStatic:
4213        if (resolved != NULL) {
4214          ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
4215        } else {
4216          resolved = klass->FindInterfaceMethod(name, signature);
4217          if (resolved != NULL) {
4218            ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
4219          } else {
4220            ThrowNoSuchMethodError(type, klass, name, signature);
4221          }
4222        }
4223        break;
4224      case kInterface:
4225        if (resolved != NULL) {
4226          ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
4227        } else {
4228          resolved = klass->FindVirtualMethod(name, signature);
4229          if (resolved != NULL) {
4230            ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
4231          } else {
4232            ThrowNoSuchMethodError(type, klass, name, signature);
4233          }
4234        }
4235        break;
4236      case kSuper:
4237        ThrowNoSuchMethodError(type, klass, name, signature);
4238        break;
4239      case kVirtual:
4240        if (resolved != NULL) {
4241          ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
4242        } else {
4243          resolved = klass->FindInterfaceMethod(name, signature);
4244          if (resolved != NULL) {
4245            ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
4246          } else {
4247            ThrowNoSuchMethodError(type, klass, name, signature);
4248          }
4249        }
4250        break;
4251    }
4252    DCHECK(Thread::Current()->IsExceptionPending());
4253    return NULL;
4254  }
4255}
4256
4257mirror::ArtField* ClassLinker::ResolveField(const DexFile& dex_file, uint32_t field_idx,
4258                                            const SirtRef<mirror::DexCache>& dex_cache,
4259                                            const SirtRef<mirror::ClassLoader>& class_loader,
4260                                            bool is_static) {
4261  DCHECK(dex_cache.get() != nullptr);
4262  mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
4263  if (resolved != NULL) {
4264    return resolved;
4265  }
4266  const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
4267  mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
4268  if (klass == NULL) {
4269    DCHECK(Thread::Current()->IsExceptionPending());
4270    return NULL;
4271  }
4272
4273  if (is_static) {
4274    resolved = klass->FindStaticField(dex_cache.get(), field_idx);
4275  } else {
4276    resolved = klass->FindInstanceField(dex_cache.get(), field_idx);
4277  }
4278
4279  if (resolved == NULL) {
4280    const char* name = dex_file.GetFieldName(field_id);
4281    const char* type = dex_file.GetFieldTypeDescriptor(field_id);
4282    if (is_static) {
4283      resolved = klass->FindStaticField(name, type);
4284    } else {
4285      resolved = klass->FindInstanceField(name, type);
4286    }
4287    if (resolved == NULL) {
4288      ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
4289      return NULL;
4290    }
4291  }
4292  dex_cache->SetResolvedField(field_idx, resolved);
4293  return resolved;
4294}
4295
4296mirror::ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
4297                                               uint32_t field_idx,
4298                                               const SirtRef<mirror::DexCache>& dex_cache,
4299                                               const SirtRef<mirror::ClassLoader>& class_loader) {
4300  DCHECK(dex_cache.get() != nullptr);
4301  mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
4302  if (resolved != NULL) {
4303    return resolved;
4304  }
4305  const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
4306  mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
4307  if (klass == NULL) {
4308    DCHECK(Thread::Current()->IsExceptionPending());
4309    return NULL;
4310  }
4311
4312  StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_));
4313  StringPiece type(dex_file.StringDataByIdx(
4314      dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_));
4315  resolved = klass->FindField(name, type);
4316  if (resolved != NULL) {
4317    dex_cache->SetResolvedField(field_idx, resolved);
4318  } else {
4319    ThrowNoSuchFieldError("", klass, type, name);
4320  }
4321  return resolved;
4322}
4323
4324const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer,
4325                                      uint32_t* length) {
4326  mirror::Class* declaring_class = referrer->GetDeclaringClass();
4327  mirror::DexCache* dex_cache = declaring_class->GetDexCache();
4328  const DexFile& dex_file = *dex_cache->GetDexFile();
4329  const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
4330  return dex_file.GetMethodShorty(method_id, length);
4331}
4332
4333void ClassLinker::DumpAllClasses(int flags) {
4334  if (dex_cache_image_class_lookup_required_) {
4335    MoveImageClassesToClassTable();
4336  }
4337  // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
4338  // lock held, because it might need to resolve a field's type, which would try to take the lock.
4339  std::vector<mirror::Class*> all_classes;
4340  {
4341    ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
4342    for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
4343      all_classes.push_back(it.second);
4344    }
4345  }
4346
4347  for (size_t i = 0; i < all_classes.size(); ++i) {
4348    all_classes[i]->DumpClass(std::cerr, flags);
4349  }
4350}
4351
4352void ClassLinker::DumpForSigQuit(std::ostream& os) {
4353  if (dex_cache_image_class_lookup_required_) {
4354    MoveImageClassesToClassTable();
4355  }
4356  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
4357  os << "Loaded classes: " << class_table_.size() << " allocated classes\n";
4358}
4359
4360size_t ClassLinker::NumLoadedClasses() {
4361  if (dex_cache_image_class_lookup_required_) {
4362    MoveImageClassesToClassTable();
4363  }
4364  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
4365  return class_table_.size();
4366}
4367
4368pid_t ClassLinker::GetClassesLockOwner() {
4369  return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
4370}
4371
4372pid_t ClassLinker::GetDexLockOwner() {
4373  return dex_lock_.GetExclusiveOwnerTid();
4374}
4375
4376void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
4377  DCHECK(!init_done_);
4378
4379  DCHECK(klass != NULL);
4380  DCHECK(klass->GetClassLoader() == NULL);
4381
4382  DCHECK(class_roots_ != NULL);
4383  DCHECK(class_roots_->Get(class_root) == NULL);
4384  class_roots_->Set<false>(class_root, klass);
4385}
4386
4387}  // namespace art
4388