diff options
30 files changed, 192 insertions, 152 deletions
diff --git a/runtime/class_linker-inl.h b/runtime/class_linker-inl.h index dba9b8fb48..126187f092 100644 --- a/runtime/class_linker-inl.h +++ b/runtime/class_linker-inl.h @@ -36,7 +36,8 @@ inline mirror::Class* ClassLinker::FindSystemClass(Thread* self, const char* des return FindClass(self, descriptor, ScopedNullHandle<mirror::ClassLoader>()); } -inline mirror::Class* ClassLinker::FindArrayClass(Thread* self, mirror::Class** element_class) { +inline mirror::Class* ClassLinker::FindArrayClass(Thread* self, + ObjPtr<mirror::Class>* element_class) { for (size_t i = 0; i < kFindArrayCacheSize; ++i) { // Read the cached array class once to avoid races with other threads setting it. mirror::Class* array_class = find_array_class_cache_[i].Read(); @@ -49,7 +50,7 @@ inline mirror::Class* ClassLinker::FindArrayClass(Thread* self, mirror::Class** descriptor += (*element_class)->GetDescriptor(&temp); StackHandleScope<2> hs(Thread::Current()); Handle<mirror::ClassLoader> class_loader(hs.NewHandle((*element_class)->GetClassLoader())); - HandleWrapper<mirror::Class> h_element_class(hs.NewHandleWrapper(element_class)); + HandleWrapperObjPtr<mirror::Class> h_element_class(hs.NewHandleWrapper(element_class)); mirror::Class* array_class = FindClass(self, descriptor.c_str(), class_loader); if (array_class != nullptr) { // Benign races in storing array class and incrementing index. diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc index 239cdaea69..594a70de0b 100644 --- a/runtime/class_linker.cc +++ b/runtime/class_linker.cc @@ -1961,7 +1961,7 @@ void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor) { // Add 100 in case new classes get loaded when we are filling in the object array. class_table_size = NumZygoteClasses() + NumNonZygoteClasses() + 100; } - mirror::Class* class_type = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass(); mirror::Class* array_of_class = FindArrayClass(self, &class_type); classes.Assign( mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, class_table_size)); @@ -2293,7 +2293,7 @@ bool ClassLinker::FindClassInPathClassLoader(ScopedObjectAccessAlreadyRunnable& const char* descriptor, size_t hash, Handle<mirror::ClassLoader> class_loader, - mirror::Class** result) { + ObjPtr<mirror::Class>* result) { // Termination case: boot class-loader. if (IsBootClassLoader(soa, class_loader.Get())) { // The boot class loader, search the boot class path. @@ -2451,12 +2451,12 @@ mirror::Class* ClassLinker::FindClass(Thread* self, } } else { ScopedObjectAccessUnchecked soa(self); - mirror::Class* cp_klass; + ObjPtr<mirror::Class> cp_klass; if (FindClassInPathClassLoader(soa, self, descriptor, hash, class_loader, &cp_klass)) { // The chain was understood. So the value in cp_klass is either the class we were looking // for, or not found. if (cp_klass != nullptr) { - return cp_klass; + return cp_klass.Ptr(); } // TODO: We handle the boot classpath loader in FindClassInPathClassLoader. Try to unify this // and the branch above. TODO: throw the right exception here. @@ -7797,7 +7797,7 @@ mirror::MethodType* ClassLinker::ResolveMethodType(const DexFile& dex_file, // other than by looking at the shorty ? const size_t num_method_args = strlen(dex_file.StringDataByIdx(proto_id.shorty_idx_)) - 1; - mirror::Class* class_type = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass(); mirror::Class* array_of_class = FindArrayClass(self, &class_type); Handle<mirror::ObjectArray<mirror::Class>> method_params(hs.NewHandle( mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, num_method_args))); @@ -8152,12 +8152,12 @@ void ClassLinker::VisitClassLoaders(ClassLoaderVisitor* visitor) const { } } -void ClassLinker::InsertDexFileInToClassLoader(mirror::Object* dex_file, - mirror::ClassLoader* class_loader) { +void ClassLinker::InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file, + ObjPtr<mirror::ClassLoader> class_loader) { DCHECK(dex_file != nullptr); Thread* const self = Thread::Current(); WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); - ClassTable* const table = ClassTableForClassLoader(class_loader); + ClassTable* const table = ClassTableForClassLoader(class_loader.Ptr()); DCHECK(table != nullptr); if (table->InsertStrongRoot(dex_file) && class_loader != nullptr) { // It was not already inserted, perform the write barrier to let the GC know the class loader's diff --git a/runtime/class_linker.h b/runtime/class_linker.h index 70cc768686..6437010f3f 100644 --- a/runtime/class_linker.h +++ b/runtime/class_linker.h @@ -181,7 +181,7 @@ class ClassLinker { const char* descriptor, size_t hash, Handle<mirror::ClassLoader> class_loader, - mirror::Class** result) + ObjPtr<mirror::Class>* result) REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!dex_lock_); @@ -192,7 +192,7 @@ class ClassLinker { REQUIRES(!dex_lock_); // Finds the array class given for the element class. - mirror::Class* FindArrayClass(Thread* self, mirror::Class** element_class) + mirror::Class* FindArrayClass(Thread* self, ObjPtr<mirror::Class>* element_class) REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!dex_lock_); @@ -606,7 +606,8 @@ class ClassLinker { REQUIRES_SHARED(Locks::mutator_lock_); // May be called with null class_loader due to legacy code. b/27954959 - void InsertDexFileInToClassLoader(mirror::Object* dex_file, mirror::ClassLoader* class_loader) + void InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file, + ObjPtr<mirror::ClassLoader> class_loader) REQUIRES(!Locks::classlinker_classes_lock_) REQUIRES_SHARED(Locks::mutator_lock_); diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc index 6279717acb..4fac830d16 100644 --- a/runtime/class_linker_test.cc +++ b/runtime/class_linker_test.cc @@ -216,7 +216,7 @@ class ClassLinkerTest : public CommonRuntimeTest { EXPECT_STREQ(direct_interface0->GetDescriptor(&temp), "Ljava/lang/Cloneable;"); ObjPtr<mirror::Class> direct_interface1 = mirror::Class::GetDirectInterface(self, array, 1); EXPECT_STREQ(direct_interface1->GetDescriptor(&temp), "Ljava/io/Serializable;"); - mirror::Class* array_ptr = array->GetComponentType(); + ObjPtr<mirror::Class> array_ptr = array->GetComponentType(); EXPECT_OBJ_PTR_EQ(class_linker_->FindArrayClass(self, &array_ptr), array.Get()); PointerSize pointer_size = class_linker_->GetImagePointerSize(); diff --git a/runtime/class_table.cc b/runtime/class_table.cc index 2ae7e8cc30..d43505054e 100644 --- a/runtime/class_table.cc +++ b/runtime/class_table.cc @@ -156,7 +156,7 @@ uint32_t ClassTable::ClassDescriptorHashEquals::operator()(const char* descripto return ComputeModifiedUtf8Hash(descriptor); } -bool ClassTable::InsertStrongRoot(mirror::Object* obj) { +bool ClassTable::InsertStrongRoot(ObjPtr<mirror::Object> obj) { WriterMutexLock mu(Thread::Current(), lock_); DCHECK(obj != nullptr); for (GcRoot<mirror::Object>& root : strong_roots_) { @@ -167,7 +167,7 @@ bool ClassTable::InsertStrongRoot(mirror::Object* obj) { strong_roots_.push_back(GcRoot<mirror::Object>(obj)); // If `obj` is a dex cache associated with a new oat file with GC roots, add it to oat_files_. if (obj->IsDexCache()) { - const DexFile* dex_file = down_cast<mirror::DexCache*>(obj)->GetDexFile(); + const DexFile* dex_file = ObjPtr<mirror::DexCache>::DownCast(obj)->GetDexFile(); if (dex_file != nullptr && dex_file->GetOatDexFile() != nullptr) { const OatFile* oat_file = dex_file->GetOatDexFile()->GetOatFile(); if (!oat_file->GetBssGcRoots().empty() && !ContainsElement(oat_files_, oat_file)) { diff --git a/runtime/class_table.h b/runtime/class_table.h index acb15c7879..20e434d90b 100644 --- a/runtime/class_table.h +++ b/runtime/class_table.h @@ -27,6 +27,7 @@ #include "base/mutex.h" #include "dex_file.h" #include "gc_root.h" +#include "obj_ptr.h" #include "object_callbacks.h" #include "runtime.h" @@ -136,7 +137,7 @@ class ClassTable { REQUIRES_SHARED(Locks::mutator_lock_); // Return true if we inserted the strong root, false if it already exists. - bool InsertStrongRoot(mirror::Object* obj) + bool InsertStrongRoot(ObjPtr<mirror::Object> obj) REQUIRES(!lock_) REQUIRES_SHARED(Locks::mutator_lock_); diff --git a/runtime/dex_file_annotations.cc b/runtime/dex_file_annotations.cc index 576c4aa849..e5383341fb 100644 --- a/runtime/dex_file_annotations.cc +++ b/runtime/dex_file_annotations.cc @@ -254,7 +254,7 @@ mirror::Object* ProcessEncodedAnnotation(Handle<mirror::Class> klass, const uint return nullptr; } - mirror::Class* annotation_member_class = + ObjPtr<mirror::Class> annotation_member_class = soa.Decode<mirror::Class>(WellKnownClasses::libcore_reflect_AnnotationMember).Ptr(); mirror::Class* annotation_member_array_class = class_linker->FindArrayClass(self, &annotation_member_class); @@ -731,7 +731,7 @@ mirror::ObjectArray<mirror::String>* GetSignatureValue(Handle<mirror::Class> kla if (annotation_item == nullptr) { return nullptr; } - mirror::Class* string_class = mirror::String::GetJavaLangString(); + ObjPtr<mirror::Class> string_class = mirror::String::GetJavaLangString(); Handle<mirror::Class> string_array_class(hs.NewHandle( Runtime::Current()->GetClassLinker()->FindArrayClass(Thread::Current(), &string_class))); if (string_array_class.Get() == nullptr) { @@ -757,7 +757,7 @@ mirror::ObjectArray<mirror::Class>* GetThrowsValue(Handle<mirror::Class> klass, if (annotation_item == nullptr) { return nullptr; } - mirror::Class* class_class = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_class = mirror::Class::GetJavaLangClass(); Handle<mirror::Class> class_array_class(hs.NewHandle( Runtime::Current()->GetClassLinker()->FindArrayClass(Thread::Current(), &class_class))); if (class_array_class.Get() == nullptr) { @@ -839,8 +839,8 @@ mirror::ObjectArray<mirror::Object>* ProcessAnnotationSetRefList( Thread* self = Thread::Current(); ScopedObjectAccessUnchecked soa(self); StackHandleScope<1> hs(self); - mirror::Class* annotation_array_class = - soa.Decode<mirror::Class>(WellKnownClasses::java_lang_annotation_Annotation__array).Ptr(); + ObjPtr<mirror::Class> annotation_array_class = + soa.Decode<mirror::Class>(WellKnownClasses::java_lang_annotation_Annotation__array); mirror::Class* annotation_array_array_class = Runtime::Current()->GetClassLinker()->FindArrayClass(self, &annotation_array_class); if (annotation_array_array_class == nullptr) { @@ -1049,7 +1049,7 @@ bool GetParametersMetadataForMethod(ArtMethod* method, StackHandleScope<5> hs(Thread::Current()); // Extract the parameters' names String[]. - mirror::Class* string_class = mirror::String::GetJavaLangString(); + ObjPtr<mirror::Class> string_class = mirror::String::GetJavaLangString(); Handle<mirror::Class> string_array_class(hs.NewHandle( Runtime::Current()->GetClassLinker()->FindArrayClass(Thread::Current(), &string_class))); if (UNLIKELY(string_array_class.Get() == nullptr)) { @@ -1139,7 +1139,7 @@ mirror::ObjectArray<mirror::Class>* GetDeclaredClasses(Handle<mirror::Class> kla return nullptr; } StackHandleScope<1> hs(Thread::Current()); - mirror::Class* class_class = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_class = mirror::Class::GetJavaLangClass(); Handle<mirror::Class> class_array_class(hs.NewHandle( Runtime::Current()->GetClassLinker()->FindArrayClass(hs.Self(), &class_class))); if (class_array_class.Get() == nullptr) { diff --git a/runtime/interpreter/unstarted_runtime.cc b/runtime/interpreter/unstarted_runtime.cc index 4a3654be3e..4347c37f62 100644 --- a/runtime/interpreter/unstarted_runtime.cc +++ b/runtime/interpreter/unstarted_runtime.cc @@ -1472,13 +1472,17 @@ void UnstartedRuntime::UnstartedJNIVMRuntimeNewUnpaddedArray( uint32_t* args, JValue* result) { int32_t length = args[1]; DCHECK_GE(length, 0); - mirror::Class* element_class = reinterpret_cast<mirror::Object*>(args[0])->AsClass(); + ObjPtr<mirror::Class> element_class = reinterpret_cast<mirror::Object*>(args[0])->AsClass(); Runtime* runtime = Runtime::Current(); - mirror::Class* array_class = runtime->GetClassLinker()->FindArrayClass(self, &element_class); + ObjPtr<mirror::Class> array_class = + runtime->GetClassLinker()->FindArrayClass(self, &element_class); DCHECK(array_class != nullptr); gc::AllocatorType allocator = runtime->GetHeap()->GetCurrentAllocator(); - result->SetL(mirror::Array::Alloc<true, true>(self, array_class, length, - array_class->GetComponentSizeShift(), allocator)); + result->SetL(mirror::Array::Alloc<true, true>(self, + array_class, + length, + array_class->GetComponentSizeShift(), + allocator)); } void UnstartedRuntime::UnstartedJNIVMStackGetCallingClassLoader( @@ -1601,10 +1605,10 @@ void UnstartedRuntime::UnstartedJNIArrayCreateObjectArray( ThrowNegativeArraySizeException(length); return; } - mirror::Class* element_class = reinterpret_cast<mirror::Class*>(args[0])->AsClass(); + ObjPtr<mirror::Class> element_class = reinterpret_cast<mirror::Class*>(args[0])->AsClass(); Runtime* runtime = Runtime::Current(); ClassLinker* class_linker = runtime->GetClassLinker(); - mirror::Class* array_class = class_linker->FindArrayClass(self, &element_class); + ObjPtr<mirror::Class> array_class = class_linker->FindArrayClass(self, &element_class); if (UNLIKELY(array_class == nullptr)) { CHECK(self->IsExceptionPending()); return; diff --git a/runtime/interpreter/unstarted_runtime_test.cc b/runtime/interpreter/unstarted_runtime_test.cc index 6a4add3bb8..b190c81aff 100644 --- a/runtime/interpreter/unstarted_runtime_test.cc +++ b/runtime/interpreter/unstarted_runtime_test.cc @@ -81,20 +81,21 @@ class UnstartedRuntimeTest : public CommonRuntimeTest { static mirror::ObjectArray<mirror::Object>* CreateObjectArray( Thread* self, - mirror::Class* component_type, + ObjPtr<mirror::Class> component_type, const StackHandleScope<3>& data) REQUIRES_SHARED(Locks::mutator_lock_) { Runtime* runtime = Runtime::Current(); - mirror::Class* array_type = runtime->GetClassLinker()->FindArrayClass(self, &component_type); + ObjPtr<mirror::Class> array_type = + runtime->GetClassLinker()->FindArrayClass(self, &component_type); CHECK(array_type != nullptr); - mirror::ObjectArray<mirror::Object>* result = + ObjPtr<mirror::ObjectArray<mirror::Object>> result = mirror::ObjectArray<mirror::Object>::Alloc(self, array_type, 3); CHECK(result != nullptr); for (size_t i = 0; i < 3; ++i) { result->Set(static_cast<int32_t>(i), data.GetReference(i)); CHECK(!self->IsExceptionPending()); } - return result; + return result.Ptr(); } static void CheckObjectArray(mirror::ObjectArray<mirror::Object>* array, diff --git a/runtime/jni_internal.cc b/runtime/jni_internal.cc index 8eebe56da7..305a7e8d23 100644 --- a/runtime/jni_internal.cc +++ b/runtime/jni_internal.cc @@ -1904,11 +1904,12 @@ class JNI { // Compute the array class corresponding to the given element class. ScopedObjectAccess soa(env); - mirror::Class* array_class; + ObjPtr<mirror::Class> array_class; { - mirror::Class* element_class = soa.Decode<mirror::Class>(element_jclass).Ptr(); + ObjPtr<mirror::Class> element_class = soa.Decode<mirror::Class>(element_jclass).Ptr(); if (UNLIKELY(element_class->IsPrimitive())) { - soa.Vm()->JniAbortF("NewObjectArray", "not an object type: %s", + soa.Vm()->JniAbortF("NewObjectArray", + "not an object type: %s", PrettyDescriptor(element_class).c_str()); return nullptr; } diff --git a/runtime/mirror/array.cc b/runtime/mirror/array.cc index 1aa38dd6b4..8afa4aa744 100644 --- a/runtime/mirror/array.cc +++ b/runtime/mirror/array.cc @@ -60,7 +60,7 @@ static Array* RecursiveCreateMultiArray(Thread* self, for (int32_t i = 0; i < array_length; i++) { StackHandleScope<1> hs2(self); Handle<mirror::Class> h_component_type(hs2.NewHandle(array_class->GetComponentType())); - Array* sub_array = RecursiveCreateMultiArray(self, h_component_type, + ObjPtr<Array> sub_array = RecursiveCreateMultiArray(self, h_component_type, current_dimension + 1, dimensions); if (UNLIKELY(sub_array == nullptr)) { CHECK(self->IsExceptionPending()); @@ -93,7 +93,7 @@ Array* Array::CreateMultiArray(Thread* self, Handle<Class> element_class, // Find/generate the array class. ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); - mirror::Class* element_class_ptr = element_class.Get(); + ObjPtr<mirror::Class> element_class_ptr = element_class.Get(); StackHandleScope<1> hs(self); MutableHandle<mirror::Class> array_class( hs.NewHandle(class_linker->FindArrayClass(self, &element_class_ptr))); @@ -102,7 +102,7 @@ Array* Array::CreateMultiArray(Thread* self, Handle<Class> element_class, return nullptr; } for (int32_t i = 1; i < dimensions->GetLength(); ++i) { - mirror::Class* array_class_ptr = array_class.Get(); + ObjPtr<mirror::Class> array_class_ptr = array_class.Get(); array_class.Assign(class_linker->FindArrayClass(self, &array_class_ptr)); if (UNLIKELY(array_class.Get() == nullptr)) { CHECK(self->IsExceptionPending()); @@ -110,11 +110,11 @@ Array* Array::CreateMultiArray(Thread* self, Handle<Class> element_class, } } // Create the array. - Array* new_array = RecursiveCreateMultiArray(self, array_class, 0, dimensions); + ObjPtr<Array> new_array = RecursiveCreateMultiArray(self, array_class, 0, dimensions); if (UNLIKELY(new_array == nullptr)) { CHECK(self->IsExceptionPending()); } - return new_array; + return new_array.Ptr(); } void Array::ThrowArrayIndexOutOfBoundsException(int32_t index) { @@ -136,12 +136,13 @@ Array* Array::CopyOf(Thread* self, int32_t new_length) { heap->GetCurrentNonMovingAllocator(); const auto component_size = GetClass()->GetComponentSize(); const auto component_shift = GetClass()->GetComponentSizeShift(); - Array* new_array = Alloc<true>(self, GetClass(), new_length, component_shift, allocator_type); + ObjPtr<Array> new_array = Alloc<true>(self, GetClass(), new_length, component_shift, allocator_type); if (LIKELY(new_array != nullptr)) { - memcpy(new_array->GetRawData(component_size, 0), h_this->GetRawData(component_size, 0), + memcpy(new_array->GetRawData(component_size, 0), + h_this->GetRawData(component_size, 0), std::min(h_this->GetLength(), new_length) << component_shift); } - return new_array; + return new_array.Ptr(); } diff --git a/runtime/mirror/dex_cache-inl.h b/runtime/mirror/dex_cache-inl.h index 13d0108b2f..2c1926f3a1 100644 --- a/runtime/mirror/dex_cache-inl.h +++ b/runtime/mirror/dex_cache-inl.h @@ -44,8 +44,8 @@ inline mirror::String* DexCache::GetResolvedString(uint32_t string_idx) { return StringDexCachePair::Lookup(GetStrings(), string_idx, NumStrings()).Read(); } -inline void DexCache::SetResolvedString(uint32_t string_idx, mirror::String* resolved) { - StringDexCachePair::Assign(GetStrings(), string_idx, resolved, NumStrings()); +inline void DexCache::SetResolvedString(uint32_t string_idx, ObjPtr<mirror::String> resolved) { + StringDexCachePair::Assign(GetStrings(), string_idx, resolved.Ptr(), NumStrings()); Runtime* const runtime = Runtime::Current(); if (UNLIKELY(runtime->IsActiveTransaction())) { DCHECK(runtime->IsAotCompiler()); diff --git a/runtime/mirror/dex_cache.h b/runtime/mirror/dex_cache.h index bbe98c2d53..91cf1c3e6b 100644 --- a/runtime/mirror/dex_cache.h +++ b/runtime/mirror/dex_cache.h @@ -211,7 +211,7 @@ class MANAGED DexCache FINAL : public Object { mirror::String* GetResolvedString(uint32_t string_idx) ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_); - void SetResolvedString(uint32_t string_idx, mirror::String* resolved) ALWAYS_INLINE + void SetResolvedString(uint32_t string_idx, ObjPtr<mirror::String> resolved) ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_); // Clear a string for a string_idx, used to undo string intern transactions to make sure diff --git a/runtime/mirror/method_type_test.cc b/runtime/mirror/method_type_test.cc index a968bff84d..03ab93069c 100644 --- a/runtime/mirror/method_type_test.cc +++ b/runtime/mirror/method_type_test.cc @@ -52,7 +52,7 @@ static mirror::MethodType* CreateMethodType(const std::string& return_type, soa.Self(), FullyQualifiedType(return_type).c_str(), boot_class_loader)); CHECK(return_clazz.Get() != nullptr); - mirror::Class* class_type = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass(); mirror::Class* class_array_type = class_linker->FindArrayClass(self, &class_type); Handle<mirror::ObjectArray<mirror::Class>> param_classes = hs.NewHandle( mirror::ObjectArray<mirror::Class>::Alloc(self, class_array_type, param_types.size())); diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc index 086da60728..df0849a628 100644 --- a/runtime/native/dalvik_system_DexFile.cc +++ b/runtime/native/dalvik_system_DexFile.cc @@ -218,7 +218,7 @@ static jboolean DexFile_closeDexFile(JNIEnv* env, jclass, jobject cookie) { { ScopedObjectAccess soa(env); ObjPtr<mirror::Object> dex_files_object = soa.Decode<mirror::Object>(cookie); - mirror::LongArray* long_dex_files = dex_files_object->AsLongArray(); + ObjPtr<mirror::LongArray> long_dex_files = dex_files_object->AsLongArray(); // Delete dex files associated with this dalvik.system.DexFile since there should not be running // code using it. dex_files is a vector due to multidex. ClassLinker* const class_linker = runtime->GetClassLinker(); @@ -279,15 +279,15 @@ static jclass DexFile_defineClassNative(JNIEnv* env, Handle<mirror::ClassLoader> class_loader( hs.NewHandle(soa.Decode<mirror::ClassLoader>(javaLoader))); class_linker->RegisterDexFile(*dex_file, class_loader.Get()); - mirror::Class* result = class_linker->DefineClass(soa.Self(), - descriptor.c_str(), - hash, - class_loader, - *dex_file, - *dex_class_def); + ObjPtr<mirror::Class> result = class_linker->DefineClass(soa.Self(), + descriptor.c_str(), + hash, + class_loader, + *dex_file, + *dex_class_def); // Add the used dex file. This only required for the DexFile.loadClass API since normal // class loaders already keep their dex files live. - class_linker->InsertDexFileInToClassLoader(soa.Decode<mirror::Object>(dexFile).Ptr(), + class_linker->InsertDexFileInToClassLoader(soa.Decode<mirror::Object>(dexFile), class_loader.Get()); if (result != nullptr) { VLOG(class_linker) << "DexFile_defineClassNative returning " << result diff --git a/runtime/native/dalvik_system_InMemoryDexClassLoader_DexData.cc b/runtime/native/dalvik_system_InMemoryDexClassLoader_DexData.cc index e32545bc2e..db245aa0d8 100644 --- a/runtime/native/dalvik_system_InMemoryDexClassLoader_DexData.cc +++ b/runtime/native/dalvik_system_InMemoryDexClassLoader_DexData.cc @@ -150,14 +150,18 @@ static jclass InMemoryDexClassLoader_DexData_findClass( Handle<mirror::ClassLoader> class_loader( handle_scope.NewHandle(soa.Decode<mirror::ClassLoader>(loader))); class_linker->RegisterDexFile(*dex_file, class_loader.Get()); - mirror::Class* result = class_linker->DefineClass( - soa.Self(), class_descriptor, hash, class_loader, *dex_file, *dex_class_def); + ObjPtr<mirror::Class> result = class_linker->DefineClass( + soa.Self(), + class_descriptor, + hash, class_loader, + *dex_file, + *dex_class_def); if (result != nullptr) { // Ensure the class table has a strong reference to the // InMemoryClassLoader/DexData instance now that a class has // been loaded. - class_linker->InsertDexFileInToClassLoader( - soa.Decode<mirror::Object>(dexData).Ptr(), class_loader.Get()); + class_linker->InsertDexFileInToClassLoader(soa.Decode<mirror::Object>(dexData), + class_loader.Get()); return soa.AddLocalReference<jclass>(result); } } diff --git a/runtime/native/dalvik_system_VMRuntime.cc b/runtime/native/dalvik_system_VMRuntime.cc index e458e2d83a..888fddb4fa 100644 --- a/runtime/native/dalvik_system_VMRuntime.cc +++ b/runtime/native/dalvik_system_VMRuntime.cc @@ -74,21 +74,23 @@ static jobject VMRuntime_newNonMovableArray(JNIEnv* env, jobject, jclass javaEle ThrowNegativeArraySizeException(length); return nullptr; } - mirror::Class* element_class = soa.Decode<mirror::Class>(javaElementClass).Ptr(); + ObjPtr<mirror::Class> element_class = soa.Decode<mirror::Class>(javaElementClass); if (UNLIKELY(element_class == nullptr)) { ThrowNullPointerException("element class == null"); return nullptr; } Runtime* runtime = Runtime::Current(); - mirror::Class* array_class = + ObjPtr<mirror::Class> array_class = runtime->GetClassLinker()->FindArrayClass(soa.Self(), &element_class); if (UNLIKELY(array_class == nullptr)) { return nullptr; } gc::AllocatorType allocator = runtime->GetHeap()->GetCurrentNonMovingAllocator(); - mirror::Array* result = mirror::Array::Alloc<true>(soa.Self(), array_class, length, - array_class->GetComponentSizeShift(), - allocator); + ObjPtr<mirror::Array> result = mirror::Array::Alloc<true>(soa.Self(), + array_class, + length, + array_class->GetComponentSizeShift(), + allocator); return soa.AddLocalReference<jobject>(result); } @@ -99,21 +101,24 @@ static jobject VMRuntime_newUnpaddedArray(JNIEnv* env, jobject, jclass javaEleme ThrowNegativeArraySizeException(length); return nullptr; } - mirror::Class* element_class = soa.Decode<mirror::Class>(javaElementClass).Ptr(); + ObjPtr<mirror::Class> element_class = soa.Decode<mirror::Class>(javaElementClass); if (UNLIKELY(element_class == nullptr)) { ThrowNullPointerException("element class == null"); return nullptr; } Runtime* runtime = Runtime::Current(); - mirror::Class* array_class = runtime->GetClassLinker()->FindArrayClass(soa.Self(), - &element_class); + ObjPtr<mirror::Class> array_class = runtime->GetClassLinker()->FindArrayClass(soa.Self(), + &element_class); if (UNLIKELY(array_class == nullptr)) { return nullptr; } gc::AllocatorType allocator = runtime->GetHeap()->GetCurrentAllocator(); - mirror::Array* result = mirror::Array::Alloc<true, true>(soa.Self(), array_class, length, - array_class->GetComponentSizeShift(), - allocator); + ObjPtr<mirror::Array> result = mirror::Array::Alloc<true, true>( + soa.Self(), + array_class, + length, + array_class->GetComponentSizeShift(), + allocator); return soa.AddLocalReference<jobject>(result); } @@ -127,7 +132,7 @@ static jlong VMRuntime_addressOf(JNIEnv* env, jobject, jobject javaArray) { ThrowIllegalArgumentException("not an array"); return 0; } - if (Runtime::Current()->GetHeap()->IsMovableObject(array.Ptr())) { + if (Runtime::Current()->GetHeap()->IsMovableObject(array)) { ThrowRuntimeException("Trying to get address of movable array object"); return 0; } @@ -263,7 +268,7 @@ static void VMRuntime_runHeapTasks(JNIEnv* env, jobject) { Runtime::Current()->GetHeap()->GetTaskProcessor()->RunAllTasks(ThreadForEnv(env)); } -typedef std::map<std::string, mirror::String*> StringTable; +typedef std::map<std::string, ObjPtr<mirror::String>> StringTable; class PreloadDexCachesStringsVisitor : public SingleRootVisitor { public: @@ -271,7 +276,7 @@ class PreloadDexCachesStringsVisitor : public SingleRootVisitor { void VisitRoot(mirror::Object* root, const RootInfo& info ATTRIBUTE_UNUSED) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) { - mirror::String* string = root->AsString(); + ObjPtr<mirror::String> string = root->AsString(); table_->operator[](string->ToModifiedUtf8()) = string; } @@ -283,7 +288,7 @@ class PreloadDexCachesStringsVisitor : public SingleRootVisitor { static void PreloadDexCachesResolveString( Handle<mirror::DexCache> dex_cache, uint32_t string_idx, StringTable& strings) REQUIRES_SHARED(Locks::mutator_lock_) { - mirror::String* string = dex_cache->GetResolvedString(string_idx); + ObjPtr<mirror::String> string = dex_cache->GetResolvedString(string_idx); if (string != nullptr) { return; } @@ -298,10 +303,11 @@ static void PreloadDexCachesResolveString( } // Based on ClassLinker::ResolveType. -static void PreloadDexCachesResolveType( - Thread* self, mirror::DexCache* dex_cache, uint32_t type_idx) +static void PreloadDexCachesResolveType(Thread* self, + ObjPtr<mirror::DexCache> dex_cache, + uint32_t type_idx) REQUIRES_SHARED(Locks::mutator_lock_) { - mirror::Class* klass = dex_cache->GetResolvedType(type_idx); + ObjPtr<mirror::Class> klass = dex_cache->GetResolvedType(type_idx); if (klass != nullptr) { return; } @@ -364,7 +370,7 @@ static void PreloadDexCachesResolveMethod(Handle<mirror::DexCache> dex_cache, ui } const DexFile* dex_file = dex_cache->GetDexFile(); const DexFile::MethodId& method_id = dex_file->GetMethodId(method_idx); - mirror::Class* klass = dex_cache->GetResolvedType(method_id.class_idx_); + ObjPtr<mirror::Class> klass = dex_cache->GetResolvedType(method_id.class_idx_); if (klass == nullptr) { return; } @@ -439,25 +445,25 @@ static void PreloadDexCachesStatsFilled(DexCacheStats* filled) Thread* const self = Thread::Current(); for (const DexFile* dex_file : class_linker->GetBootClassPath()) { CHECK(dex_file != nullptr); - mirror::DexCache* const dex_cache = class_linker->FindDexCache(self, *dex_file, true); + ObjPtr<mirror::DexCache> const dex_cache = class_linker->FindDexCache(self, *dex_file, true); // If dex cache was deallocated, just continue. if (dex_cache == nullptr) { continue; } for (size_t j = 0; j < dex_cache->NumStrings(); j++) { - mirror::String* string = dex_cache->GetResolvedString(j); + ObjPtr<mirror::String> string = dex_cache->GetResolvedString(j); if (string != nullptr) { filled->num_strings++; } } for (size_t j = 0; j < dex_cache->NumResolvedTypes(); j++) { - mirror::Class* klass = dex_cache->GetResolvedType(j); + ObjPtr<mirror::Class> klass = dex_cache->GetResolvedType(j); if (klass != nullptr) { filled->num_types++; } } for (size_t j = 0; j < dex_cache->NumResolvedFields(); j++) { - ArtField* field = class_linker->GetResolvedField(j, dex_cache); + ArtField* field = class_linker->GetResolvedField(j, dex_cache.Ptr()); if (field != nullptr) { filled->num_fields++; } diff --git a/runtime/native/dalvik_system_VMStack.cc b/runtime/native/dalvik_system_VMStack.cc index 0dd8cdd2d9..36825cb870 100644 --- a/runtime/native/dalvik_system_VMStack.cc +++ b/runtime/native/dalvik_system_VMStack.cc @@ -87,10 +87,10 @@ static jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass) { bool VisitFrame() REQUIRES_SHARED(Locks::mutator_lock_) { DCHECK(class_loader == nullptr); - mirror::Class* c = GetMethod()->GetDeclaringClass(); + ObjPtr<mirror::Class> c = GetMethod()->GetDeclaringClass(); // c is null for runtime methods. if (c != nullptr) { - mirror::Object* cl = c->GetClassLoader(); + ObjPtr<mirror::Object> cl = c->GetClassLoader(); if (cl != nullptr) { class_loader = cl; return false; @@ -99,7 +99,7 @@ static jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass) { return true; } - mirror::Object* class_loader; + ObjPtr<mirror::Object> class_loader; }; ScopedFastNativeObjectAccess soa(env); ClosestUserClassLoaderVisitor visitor(soa.Self()); diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc index ceb37c488e..ac5dbdabf7 100644 --- a/runtime/native/java_lang_Class.cc +++ b/runtime/native/java_lang_Class.cc @@ -497,13 +497,13 @@ static jobjectArray Class_getDeclaredClasses(JNIEnv* env, jobject javaThis) { // Pending exception from GetDeclaredClasses. return nullptr; } - mirror::Class* class_class = mirror::Class::GetJavaLangClass(); - mirror::Class* class_array_class = + ObjPtr<mirror::Class> class_class = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_array_class = Runtime::Current()->GetClassLinker()->FindArrayClass(soa.Self(), &class_class); if (class_array_class == nullptr) { return nullptr; } - mirror::ObjectArray<mirror::Class>* empty_array = + ObjPtr<mirror::ObjectArray<mirror::Class>> empty_array = mirror::ObjectArray<mirror::Class>::Alloc(soa.Self(), class_array_class, 0); return soa.AddLocalReference<jobjectArray>(empty_array); } @@ -527,7 +527,7 @@ static jobject Class_getEnclosingConstructorNative(JNIEnv* env, jobject javaThis if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { return nullptr; } - mirror::Object* method = annotations::GetEnclosingMethod(klass); + ObjPtr<mirror::Object> method = annotations::GetEnclosingMethod(klass); if (method != nullptr) { if (soa.Decode<mirror::Class>(WellKnownClasses::java_lang_reflect_Constructor) == method->GetClass()) { @@ -544,7 +544,7 @@ static jobject Class_getEnclosingMethodNative(JNIEnv* env, jobject javaThis) { if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { return nullptr; } - mirror::Object* method = annotations::GetEnclosingMethod(klass); + ObjPtr<mirror::Object> method = annotations::GetEnclosingMethod(klass); if (method != nullptr) { if (soa.Decode<mirror::Class>(WellKnownClasses::java_lang_reflect_Method) == method->GetClass()) { @@ -660,7 +660,7 @@ static jobject Class_newInstance(JNIEnv* env, jobject javaThis) { // Invoke the string allocator to return an empty string for the string class. if (klass->IsStringClass()) { gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); - mirror::Object* obj = mirror::String::AllocEmptyString<true>(soa.Self(), allocator_type); + ObjPtr<mirror::Object> obj = mirror::String::AllocEmptyString<true>(soa.Self(), allocator_type); if (UNLIKELY(soa.Self()->IsExceptionPending())) { return nullptr; } else { diff --git a/runtime/native/java_lang_DexCache.cc b/runtime/native/java_lang_DexCache.cc index 1fd7ed11e1..71379a51a5 100644 --- a/runtime/native/java_lang_DexCache.cc +++ b/runtime/native/java_lang_DexCache.cc @@ -68,7 +68,7 @@ static void DexCache_setResolvedType(JNIEnv* env, jobject javaDexCache, jint typ ScopedFastNativeObjectAccess soa(env); ObjPtr<mirror::DexCache> dex_cache = soa.Decode<mirror::DexCache>(javaDexCache); CHECK_LT(static_cast<size_t>(type_index), dex_cache->NumResolvedTypes()); - dex_cache->SetResolvedType(type_index, soa.Decode<mirror::Class>(type).Ptr()); + dex_cache->SetResolvedType(type_index, soa.Decode<mirror::Class>(type)); } static void DexCache_setResolvedString(JNIEnv* env, jobject javaDexCache, jint string_index, @@ -76,7 +76,7 @@ static void DexCache_setResolvedString(JNIEnv* env, jobject javaDexCache, jint s ScopedFastNativeObjectAccess soa(env); ObjPtr<mirror::DexCache> dex_cache = soa.Decode<mirror::DexCache>(javaDexCache); CHECK_LT(static_cast<size_t>(string_index), dex_cache->GetDexFile()->NumStringIds()); - dex_cache->SetResolvedString(string_index, soa.Decode<mirror::String>(string).Ptr()); + dex_cache->SetResolvedString(string_index, soa.Decode<mirror::String>(string)); } static JNINativeMethod gMethods[] = { diff --git a/runtime/native/java_lang_String.cc b/runtime/native/java_lang_String.cc index 5a49c203af..ea266d131d 100644 --- a/runtime/native/java_lang_String.cc +++ b/runtime/native/java_lang_String.cc @@ -57,7 +57,8 @@ static jstring String_concat(JNIEnv* env, jobject java_this, jobject java_string int32_t length_this = string_this->GetLength(); int32_t length_arg = string_arg->GetLength(); if (length_arg > 0 && length_this > 0) { - mirror::String* result = mirror::String::AllocFromStrings(soa.Self(), string_this, string_arg); + ObjPtr<mirror::String> result = + mirror::String::AllocFromStrings(soa.Self(), string_this, string_arg); return soa.AddLocalReference<jstring>(result); } jobject string_original = (length_this == 0) ? java_string_arg : java_this; @@ -76,8 +77,11 @@ static jstring String_fastSubstring(JNIEnv* env, jobject java_this, jint start, StackHandleScope<1> hs(soa.Self()); Handle<mirror::String> string_this(hs.NewHandle(soa.Decode<mirror::String>(java_this))); gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); - mirror::String* result = mirror::String::AllocFromString<true>(soa.Self(), length, string_this, - start, allocator_type); + ObjPtr<mirror::String> result = mirror::String::AllocFromString<true>(soa.Self(), + length, + string_this, + start, + allocator_type); return soa.AddLocalReference<jstring>(result); } diff --git a/runtime/native/java_lang_StringFactory.cc b/runtime/native/java_lang_StringFactory.cc index 119f2b87ba..e0738a49b9 100644 --- a/runtime/native/java_lang_StringFactory.cc +++ b/runtime/native/java_lang_StringFactory.cc @@ -44,9 +44,12 @@ static jstring StringFactory_newStringFromBytes(JNIEnv* env, jclass, jbyteArray return nullptr; } gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); - mirror::String* result = mirror::String::AllocFromByteArray<true>(soa.Self(), byte_count, - byte_array, offset, high, - allocator_type); + ObjPtr<mirror::String> result = mirror::String::AllocFromByteArray<true>(soa.Self(), + byte_count, + byte_array, + offset, + high, + allocator_type); return soa.AddLocalReference<jstring>(result); } @@ -58,9 +61,11 @@ static jstring StringFactory_newStringFromChars(JNIEnv* env, jclass, jint offset StackHandleScope<1> hs(soa.Self()); Handle<mirror::CharArray> char_array(hs.NewHandle(soa.Decode<mirror::CharArray>(java_data))); gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); - mirror::String* result = mirror::String::AllocFromCharArray<true>(soa.Self(), char_count, - char_array, offset, - allocator_type); + ObjPtr<mirror::String> result = mirror::String::AllocFromCharArray<true>(soa.Self(), + char_count, + char_array, + offset, + allocator_type); return soa.AddLocalReference<jstring>(result); } @@ -73,8 +78,11 @@ static jstring StringFactory_newStringFromString(JNIEnv* env, jclass, jstring to StackHandleScope<1> hs(soa.Self()); Handle<mirror::String> string(hs.NewHandle(soa.Decode<mirror::String>(to_copy))); gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); - mirror::String* result = mirror::String::AllocFromString<true>(soa.Self(), string->GetLength(), - string, 0, allocator_type); + ObjPtr<mirror::String> result = mirror::String::AllocFromString<true>(soa.Self(), + string->GetLength(), + string, + 0, + allocator_type); return soa.AddLocalReference<jstring>(result); } diff --git a/runtime/native/java_lang_System.cc b/runtime/native/java_lang_System.cc index 3f5fa73b45..eaf2d65bab 100644 --- a/runtime/native/java_lang_System.cc +++ b/runtime/native/java_lang_System.cc @@ -71,8 +71,8 @@ static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, ThrowArrayStoreException_NotAnArray("destination", dstObject); return; } - mirror::Array* srcArray = srcObject->AsArray(); - mirror::Array* dstArray = dstObject->AsArray(); + ObjPtr<mirror::Array> srcArray = srcObject->AsArray(); + ObjPtr<mirror::Array> dstArray = dstObject->AsArray(); // Bounds checking. if (UNLIKELY(srcPos < 0) || UNLIKELY(dstPos < 0) || UNLIKELY(count < 0) || @@ -85,8 +85,8 @@ static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, return; } - mirror::Class* dstComponentType = dstArray->GetClass()->GetComponentType(); - mirror::Class* srcComponentType = srcArray->GetClass()->GetComponentType(); + ObjPtr<mirror::Class> dstComponentType = dstArray->GetClass()->GetComponentType(); + ObjPtr<mirror::Class> srcComponentType = srcArray->GetClass()->GetComponentType(); Primitive::Type dstComponentPrimitiveType = dstComponentType->GetPrimitiveType(); if (LIKELY(srcComponentType == dstComponentType)) { @@ -143,8 +143,10 @@ static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, return; } // Arrays hold distinct types and so therefore can't alias - use memcpy instead of memmove. - mirror::ObjectArray<mirror::Object>* dstObjArray = dstArray->AsObjectArray<mirror::Object>(); - mirror::ObjectArray<mirror::Object>* srcObjArray = srcArray->AsObjectArray<mirror::Object>(); + ObjPtr<mirror::ObjectArray<mirror::Object>> dstObjArray = + dstArray->AsObjectArray<mirror::Object>(); + ObjPtr<mirror::ObjectArray<mirror::Object>> srcObjArray = + srcArray->AsObjectArray<mirror::Object>(); // If we're assigning into say Object[] then we don't need per element checks. if (dstComponentType->IsAssignableFrom(srcComponentType)) { dstObjArray->AssignableMemcpy(dstPos, srcObjArray, srcPos, count); @@ -157,8 +159,9 @@ static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, // Template to convert general array to that of its specific primitive type. template <typename T> -inline T* AsPrimitiveArray(mirror::Array* array) { - return down_cast<T*>(array); +inline ObjPtr<T> AsPrimitiveArray(ObjPtr<mirror::Array> array) + REQUIRES_SHARED(Locks::mutator_lock_) { + return ObjPtr<T>::DownCast(array); } template <typename T, Primitive::Type kPrimType> @@ -168,8 +171,8 @@ inline void System_arraycopyTUnchecked(JNIEnv* env, jobject javaSrc, jint srcPos ObjPtr<mirror::Object> srcObject = soa.Decode<mirror::Object>(javaSrc); ObjPtr<mirror::Object> dstObject = soa.Decode<mirror::Object>(javaDst); DCHECK(dstObject != nullptr); - mirror::Array* srcArray = srcObject->AsArray(); - mirror::Array* dstArray = dstObject->AsArray(); + ObjPtr<mirror::Array> srcArray = srcObject->AsArray(); + ObjPtr<mirror::Array> dstArray = dstObject->AsArray(); DCHECK_GE(count, 0); DCHECK_EQ(srcArray->GetClass(), dstArray->GetClass()); DCHECK_EQ(srcArray->GetClass()->GetComponentType()->GetPrimitiveType(), kPrimType); diff --git a/runtime/native/java_lang_VMClassLoader.cc b/runtime/native/java_lang_VMClassLoader.cc index 73d12f1a59..1fe89bf2f8 100644 --- a/runtime/native/java_lang_VMClassLoader.cc +++ b/runtime/native/java_lang_VMClassLoader.cc @@ -37,24 +37,24 @@ static jclass VMClassLoader_findLoadedClass(JNIEnv* env, jclass, jobject javaLoa ClassLinker* cl = Runtime::Current()->GetClassLinker(); std::string descriptor(DotToDescriptor(name.c_str())); const size_t descriptor_hash = ComputeModifiedUtf8Hash(descriptor.c_str()); - mirror::Class* c = cl->LookupClass(soa.Self(), - descriptor.c_str(), - descriptor_hash, - loader.Ptr()); + ObjPtr<mirror::Class> c = cl->LookupClass(soa.Self(), + descriptor.c_str(), + descriptor_hash, + loader.Ptr()); if (c != nullptr && c->IsResolved()) { return soa.AddLocalReference<jclass>(c); } // If class is erroneous, throw the earlier failure, wrapped in certain cases. See b/28787733. if (c != nullptr && c->IsErroneous()) { - cl->ThrowEarlierClassFailure(c); + cl->ThrowEarlierClassFailure(c.Ptr()); Thread* self = soa.Self(); - mirror::Class* eiie_class = + ObjPtr<mirror::Class> eiie_class = self->DecodeJObject(WellKnownClasses::java_lang_ExceptionInInitializerError)->AsClass(); - mirror::Class* iae_class = + ObjPtr<mirror::Class> iae_class = self->DecodeJObject(WellKnownClasses::java_lang_IllegalAccessError)->AsClass(); - mirror::Class* ncdfe_class = + ObjPtr<mirror::Class> ncdfe_class = self->DecodeJObject(WellKnownClasses::java_lang_NoClassDefFoundError)->AsClass(); - mirror::Class* exception = self->GetException()->GetClass(); + ObjPtr<mirror::Class> exception = self->GetException()->GetClass(); if (exception == eiie_class || exception == iae_class || exception == ncdfe_class) { self->ThrowNewWrappedException("Ljava/lang/ClassNotFoundException;", PrettyDescriptor(c).c_str()); diff --git a/runtime/native/java_lang_ref_FinalizerReference.cc b/runtime/native/java_lang_ref_FinalizerReference.cc index 1f03c7cff6..c7d06f4665 100644 --- a/runtime/native/java_lang_ref_FinalizerReference.cc +++ b/runtime/native/java_lang_ref_FinalizerReference.cc @@ -28,8 +28,7 @@ namespace art { static jboolean FinalizerReference_makeCircularListIfUnenqueued(JNIEnv* env, jobject javaThis) { ScopedFastNativeObjectAccess soa(env); ObjPtr<mirror::FinalizerReference> ref = soa.Decode<mirror::FinalizerReference>(javaThis); - return Runtime::Current()->GetHeap()->GetReferenceProcessor()->MakeCircularListIfUnenqueued( - ref.Ptr()); + return Runtime::Current()->GetHeap()->GetReferenceProcessor()->MakeCircularListIfUnenqueued(ref); } static JNINativeMethod gMethods[] = { diff --git a/runtime/native/java_lang_reflect_Array.cc b/runtime/native/java_lang_reflect_Array.cc index 6f2da33291..d827f818c5 100644 --- a/runtime/native/java_lang_reflect_Array.cc +++ b/runtime/native/java_lang_reflect_Array.cc @@ -40,8 +40,9 @@ static jobject Array_createMultiArray( DCHECK_EQ(dimensions_obj->GetClass()->GetComponentType()->GetPrimitiveType(), Primitive::kPrimInt); Handle<mirror::IntArray> dimensions_array( - hs.NewHandle(down_cast<mirror::IntArray*>(dimensions_obj.Ptr()))); - mirror::Array* new_array = mirror::Array::CreateMultiArray(soa.Self(), element_class, + hs.NewHandle(ObjPtr<mirror::IntArray>::DownCast(dimensions_obj))); + mirror::Array* new_array = mirror::Array::CreateMultiArray(soa.Self(), + element_class, dimensions_array); return soa.AddLocalReference<jobject>(new_array); } @@ -53,17 +54,20 @@ static jobject Array_createObjectArray(JNIEnv* env, jclass, jclass javaElementCl ThrowNegativeArraySizeException(length); return nullptr; } - mirror::Class* element_class = soa.Decode<mirror::Class>(javaElementClass).Ptr(); + ObjPtr<mirror::Class> element_class = soa.Decode<mirror::Class>(javaElementClass); Runtime* runtime = Runtime::Current(); ClassLinker* class_linker = runtime->GetClassLinker(); - mirror::Class* array_class = class_linker->FindArrayClass(soa.Self(), &element_class); + ObjPtr<mirror::Class> array_class = class_linker->FindArrayClass(soa.Self(), &element_class); if (UNLIKELY(array_class == nullptr)) { CHECK(soa.Self()->IsExceptionPending()); return nullptr; } DCHECK(array_class->IsObjectArrayClass()); - mirror::Array* new_array = mirror::ObjectArray<mirror::Object*>::Alloc( - soa.Self(), array_class, length, runtime->GetHeap()->GetCurrentAllocator()); + ObjPtr<mirror::Array> new_array = mirror::ObjectArray<mirror::Object*>::Alloc( + soa.Self(), + array_class, + length, + runtime->GetHeap()->GetCurrentAllocator()); return soa.AddLocalReference<jobject>(new_array); } diff --git a/runtime/native/java_lang_reflect_Constructor.cc b/runtime/native/java_lang_reflect_Constructor.cc index 505f85d94c..a81ba7d4fc 100644 --- a/runtime/native/java_lang_reflect_Constructor.cc +++ b/runtime/native/java_lang_reflect_Constructor.cc @@ -39,13 +39,13 @@ static jobjectArray Constructor_getExceptionTypes(JNIEnv* env, jobject javaMetho annotations::GetExceptionTypesForMethod(method); if (result_array == nullptr) { // Return an empty array instead of a null pointer. - mirror::Class* class_class = mirror::Class::GetJavaLangClass(); - mirror::Class* class_array_class = + ObjPtr<mirror::Class> class_class = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_array_class = Runtime::Current()->GetClassLinker()->FindArrayClass(soa.Self(), &class_class); if (class_array_class == nullptr) { return nullptr; } - mirror::ObjectArray<mirror::Class>* empty_array = + ObjPtr<mirror::ObjectArray<mirror::Class>> empty_array = mirror::ObjectArray<mirror::Class>::Alloc(soa.Self(), class_array_class, 0); return soa.AddLocalReference<jobjectArray>(empty_array); } else { diff --git a/runtime/native/java_lang_reflect_Method.cc b/runtime/native/java_lang_reflect_Method.cc index b5f2f7ca90..a6589bc073 100644 --- a/runtime/native/java_lang_reflect_Method.cc +++ b/runtime/native/java_lang_reflect_Method.cc @@ -44,7 +44,7 @@ static jobjectArray Method_getExceptionTypes(JNIEnv* env, jobject javaMethod) { ScopedFastNativeObjectAccess soa(env); ArtMethod* method = ArtMethod::FromReflectedMethod(soa, javaMethod); if (method->GetDeclaringClass()->IsProxyClass()) { - mirror::Class* klass = method->GetDeclaringClass(); + ObjPtr<mirror::Class> klass = method->GetDeclaringClass(); int throws_index = -1; size_t i = 0; for (const auto& m : klass->GetDeclaredVirtualMethods(kRuntimePointerSize)) { @@ -62,8 +62,8 @@ static jobjectArray Method_getExceptionTypes(JNIEnv* env, jobject javaMethod) { annotations::GetExceptionTypesForMethod(method); if (result_array == nullptr) { // Return an empty array instead of a null pointer - mirror::Class* class_class = mirror::Class::GetJavaLangClass(); - mirror::Class* class_array_class = + ObjPtr<mirror::Class> class_class = mirror::Class::GetJavaLangClass(); + ObjPtr<mirror::Class> class_array_class = Runtime::Current()->GetClassLinker()->FindArrayClass(soa.Self(), &class_class); if (class_array_class == nullptr) { return nullptr; diff --git a/runtime/native/sun_misc_Unsafe.cc b/runtime/native/sun_misc_Unsafe.cc index 670c4ac19a..cdf4b14dbb 100644 --- a/runtime/native/sun_misc_Unsafe.cc +++ b/runtime/native/sun_misc_Unsafe.cc @@ -305,7 +305,8 @@ static void Unsafe_copyMemory(JNIEnv *env, jobject unsafe ATTRIBUTE_UNUSED, jlon } template<typename T> -static void copyToArray(jlong srcAddr, mirror::PrimitiveArray<T>* array, +static void copyToArray(jlong srcAddr, + ObjPtr<mirror::PrimitiveArray<T>> array, size_t array_offset, size_t size) REQUIRES_SHARED(Locks::mutator_lock_) { @@ -318,7 +319,8 @@ static void copyToArray(jlong srcAddr, mirror::PrimitiveArray<T>* array, } template<typename T> -static void copyFromArray(jlong dstAddr, mirror::PrimitiveArray<T>* array, +static void copyFromArray(jlong dstAddr, + ObjPtr<mirror::PrimitiveArray<T>> array, size_t array_offset, size_t size) REQUIRES_SHARED(Locks::mutator_lock_) { @@ -347,15 +349,15 @@ static void Unsafe_copyMemoryToPrimitiveArray(JNIEnv *env, size_t sz = (size_t)size; size_t dst_offset = (size_t)dstOffset; ObjPtr<mirror::Object> dst = soa.Decode<mirror::Object>(dstObj); - mirror::Class* component_type = dst->GetClass()->GetComponentType(); + ObjPtr<mirror::Class> component_type = dst->GetClass()->GetComponentType(); if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) { - copyToArray(srcAddr, dst->AsByteSizedArray(), dst_offset, sz); + copyToArray(srcAddr, MakeObjPtr(dst->AsByteSizedArray()), dst_offset, sz); } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) { - copyToArray(srcAddr, dst->AsShortSizedArray(), dst_offset, sz); + copyToArray(srcAddr, MakeObjPtr(dst->AsShortSizedArray()), dst_offset, sz); } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) { - copyToArray(srcAddr, dst->AsIntArray(), dst_offset, sz); + copyToArray(srcAddr, MakeObjPtr(dst->AsIntArray()), dst_offset, sz); } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) { - copyToArray(srcAddr, dst->AsLongArray(), dst_offset, sz); + copyToArray(srcAddr, MakeObjPtr(dst->AsLongArray()), dst_offset, sz); } else { ThrowIllegalAccessException("not a primitive array"); } @@ -378,15 +380,15 @@ static void Unsafe_copyMemoryFromPrimitiveArray(JNIEnv *env, size_t sz = (size_t)size; size_t src_offset = (size_t)srcOffset; ObjPtr<mirror::Object> src = soa.Decode<mirror::Object>(srcObj); - mirror::Class* component_type = src->GetClass()->GetComponentType(); + ObjPtr<mirror::Class> component_type = src->GetClass()->GetComponentType(); if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) { - copyFromArray(dstAddr, src->AsByteSizedArray(), src_offset, sz); + copyFromArray(dstAddr, MakeObjPtr(src->AsByteSizedArray()), src_offset, sz); } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) { - copyFromArray(dstAddr, src->AsShortSizedArray(), src_offset, sz); + copyFromArray(dstAddr, MakeObjPtr(src->AsShortSizedArray()), src_offset, sz); } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) { - copyFromArray(dstAddr, src->AsIntArray(), src_offset, sz); + copyFromArray(dstAddr, MakeObjPtr(src->AsIntArray()), src_offset, sz); } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) { - copyFromArray(dstAddr, src->AsLongArray(), src_offset, sz); + copyFromArray(dstAddr, MakeObjPtr(src->AsLongArray()), src_offset, sz); } else { ThrowIllegalAccessException("not a primitive array"); } diff --git a/runtime/verifier/reg_type.cc b/runtime/verifier/reg_type.cc index a84668ba02..626d9cf189 100644 --- a/runtime/verifier/reg_type.cc +++ b/runtime/verifier/reg_type.cc @@ -748,7 +748,7 @@ mirror::Class* RegType::ClassJoin(mirror::Class* s, mirror::Class* t) { DCHECK(result->IsObjectClass()); return result; } - mirror::Class* common_elem = ClassJoin(s_ct, t_ct); + ObjPtr<mirror::Class> common_elem = ClassJoin(s_ct, t_ct); ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); mirror::Class* array_class = class_linker->FindArrayClass(Thread::Current(), &common_elem); DCHECK(array_class != nullptr); |