Remove GcRoot<> static from Throwable and related classes.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Bug: 31113334
Change-Id: I8115e6413a07419ec261af3ec5068833b72b5218

2 files changed, 15 insertions, 8 deletions

diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 3a49e4d21f..287e3d619a 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -3529,7 +3529,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
         ObjPtr<mirror::Class> klass =
             linker->ResolveType(handler_type_idx, dex_cache_, class_loader_);
         if (klass != nullptr) {
-          if (klass == mirror::Throwable::GetJavaLangThrowable()) {
+          if (klass == GetClassRoot<mirror::Throwable>()) {
             has_catch_all_handler = true;
           }
         } else {
diff --git a/runtime/verifier/reg_type_cache-inl.h b/runtime/verifier/reg_type_cache-inl.h
index 43c0ab9598..0469a3b394 100644
--- a/runtime/verifier/reg_type_cache-inl.h
+++ b/runtime/verifier/reg_type_cache-inl.h
@@ -124,36 +124,42 @@ inline const ImpreciseConstType& RegTypeCache::PosShortConstant() {
 }
 
 inline const PreciseReferenceType& RegTypeCache::JavaLangClass() {
-  const RegType* result = &FromClass("Ljava/lang/Class;", mirror::Class::GetJavaLangClass(), true);
+  const RegType* result = &FromClass("Ljava/lang/Class;",
+                                     GetClassRoot<mirror::Class>().Ptr(),
+                                     /* precise */ true);
   DCHECK(result->IsPreciseReference());
   return *down_cast<const PreciseReferenceType*>(result);
 }
 
 inline const PreciseReferenceType& RegTypeCache::JavaLangString() {
   // String is final and therefore always precise.
-  const RegType* result = &FromClass("Ljava/lang/String;", mirror::String::GetJavaLangString(),
-                                     true);
+  const RegType* result = &FromClass("Ljava/lang/String;",
+                                     GetClassRoot<mirror::String>().Ptr(),
+                                     /* precise */ true);
   DCHECK(result->IsPreciseReference());
   return *down_cast<const PreciseReferenceType*>(result);
 }
 
 inline const PreciseReferenceType& RegTypeCache::JavaLangInvokeMethodHandle() {
   const RegType* result = &FromClass("Ljava/lang/invoke/MethodHandle;",
-                                     GetClassRoot<mirror::MethodHandle>().Ptr(), true);
+                                     GetClassRoot<mirror::MethodHandle>().Ptr(),
+                                     /* precise */ true);
   DCHECK(result->IsPreciseReference());
   return *down_cast<const PreciseReferenceType*>(result);
 }
 
 inline const PreciseReferenceType& RegTypeCache::JavaLangInvokeMethodType() {
   const RegType* result = &FromClass("Ljava/lang/invoke/MethodType;",
-                                     GetClassRoot<mirror::MethodType>().Ptr(), true);
+                                     GetClassRoot<mirror::MethodType>().Ptr(),
+                                     /* precise */ true);
   DCHECK(result->IsPreciseReference());
   return *down_cast<const PreciseReferenceType*>(result);
 }
 
 inline const RegType&  RegTypeCache::JavaLangThrowable(bool precise) {
   const RegType* result = &FromClass("Ljava/lang/Throwable;",
-                                     mirror::Throwable::GetJavaLangThrowable(), precise);
+                                     GetClassRoot<mirror::Throwable>().Ptr(),
+                                     precise);
   if (precise) {
     DCHECK(result->IsPreciseReference());
     return *down_cast<const PreciseReferenceType*>(result);
@@ -165,7 +171,8 @@ inline const RegType&  RegTypeCache::JavaLangThrowable(bool precise) {
 
 inline const RegType& RegTypeCache::JavaLangObject(bool precise) {
   const RegType* result = &FromClass("Ljava/lang/Object;",
-                                     mirror::Class::GetJavaLangClass()->GetSuperClass(), precise);
+                                     GetClassRoot<mirror::Object>().Ptr(),
+                                     precise);
   if (precise) {
     DCHECK(result->IsPreciseReference());
     return *down_cast<const PreciseReferenceType*>(result);