Disable read barrier checks for dex2oat dirty objects logic

Use kVerifyNone and kWithoutReadBarrier, like all other code in
image_writer.

Bug: 314961378
Test: (with aosp/2859865) lunch aosp_arm64-trunk_staging-userdebug &&
Test: m out/soong/dexpreopt_arm64/dex_artjars/linux_glibc/apex/art_boot_images/javalib/x86_64/boot-apache-xml.art
Change-Id: I7a4a129832797289185efa34605cff85a9a6078d

3 files changed, 23 insertions, 8 deletions

diff --git a/dex2oat/linker/image_writer.cc b/dex2oat/linker/image_writer.cc
index 090103d38b..c4954d3d29 100644
--- a/dex2oat/linker/image_writer.cc
+++ b/dex2oat/linker/image_writer.cc
@@ -188,7 +188,8 @@ class ReferenceFieldVisitor {
   void operator()(ObjPtr<mirror::Object> obj, MemberOffset offset, bool is_static) const
       REQUIRES_SHARED(Locks::mutator_lock_) {
     CHECK(!obj->IsObjectArray());
-    mirror::Object* field_obj = obj->GetFieldObject<mirror::Object>(offset);
+    mirror::Object* field_obj =
+        obj->GetFieldObject<mirror::Object, kVerifyNone, kWithoutReadBarrier>(offset);
     // Skip fields that contain null.
     if (field_obj == nullptr) {
       return;
@@ -205,7 +206,9 @@ class ReferenceFieldVisitor {
       CHECK(obj->IsClass());
       field = ArtField::FindStaticFieldWithOffset(obj->AsClass(), offset.Uint32Value());
     } else {
-      field = ArtField::FindInstanceFieldWithOffset(obj->GetClass(), offset.Uint32Value());
+      field = ArtField::
+          FindInstanceFieldWithOffset</*kExactOffset*/ true, kVerifyNone, kWithoutReadBarrier>(
+              obj->GetClass<kVerifyNone, kWithoutReadBarrier>(), offset.Uint32Value());
     }
     DCHECK(field != nullptr);
     visit_func_(*field_obj, *field);
@@ -283,9 +286,15 @@ HashMap<mirror::Object*, uint32_t> MatchDirtyObjectPaths(
       return nullptr;
     }
 
-    ObjPtr<mirror::Object> next_obj = array->GetWithoutChecks(idx);
+    ObjPtr<mirror::Object> next_obj =
+        array->GetWithoutChecks<kVerifyNone, kWithoutReadBarrier>(idx);
+    if (next_obj == nullptr) {
+      return nullptr;
+    }
+
     std::string temp;
-    if (next_obj == nullptr || next_obj->GetClass()->GetDescriptor(&temp) != ref_info.type) {
+    if (next_obj->GetClass<kVerifyNone, kWithoutReadBarrier>()->GetDescriptor(&temp) !=
+        ref_info.type) {
       return nullptr;
     }
     return next_obj.Ptr();
diff --git a/runtime/art_field-inl.h b/runtime/art_field-inl.h
index 58e13cf05e..43f2831f99 100644
--- a/runtime/art_field-inl.h
+++ b/runtime/art_field-inl.h
@@ -417,7 +417,7 @@ static inline ArtField* FindFieldWithOffset(
   return nullptr;
 }
 
-template <bool kExactOffset>
+template <bool kExactOffset, VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
 inline ArtField* ArtField::FindInstanceFieldWithOffset(ObjPtr<mirror::Class> klass,
                                                        uint32_t field_offset) {
   DCHECK(klass != nullptr);
@@ -426,8 +426,11 @@ inline ArtField* ArtField::FindInstanceFieldWithOffset(ObjPtr<mirror::Class> kla
     return field;
   }
   // We did not find field in the class: look into superclass.
-  return (klass->GetSuperClass() != nullptr) ?
-      FindInstanceFieldWithOffset<kExactOffset>(klass->GetSuperClass(), field_offset) : nullptr;
+  ObjPtr<mirror::Class> super_class = klass->GetSuperClass<kVerifyFlags, kReadBarrierOption>();
+  return (super_class != nullptr)
+      ? FindInstanceFieldWithOffset<kExactOffset, kVerifyFlags, kReadBarrierOption>(
+          super_class, field_offset) :
+      nullptr;
 }
 
 template <bool kExactOffset>
diff --git a/runtime/art_field.h b/runtime/art_field.h
index 99cedd1b3f..906eda408f 100644
--- a/runtime/art_field.h
+++ b/runtime/art_field.h
@@ -23,6 +23,7 @@
 #include "obj_ptr.h"
 #include "offsets.h"
 #include "read_barrier_option.h"
+#include "verify_object.h"
 
 namespace art {
 
@@ -198,7 +199,9 @@ class ArtField final {
   // Returns an instance field with this offset in the given class or null if not found.
   // If kExactOffset is true then we only find the matching offset, not the field containing the
   // offset.
-  template <bool kExactOffset = true>
+  template <bool kExactOffset = true,
+            VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
+            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
   static ArtField* FindInstanceFieldWithOffset(ObjPtr<mirror::Class> klass, uint32_t field_offset)
       REQUIRES_SHARED(Locks::mutator_lock_);