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