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