diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 79d8121..d0cc5af 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -67,10 +67,10 @@
 import com.android.tools.r8.optimize.MemberRebindingAnalysis;
 import com.android.tools.r8.optimize.MemberRebindingIdentityLens;
 import com.android.tools.r8.optimize.MemberRebindingIdentityLensFactory;
+import com.android.tools.r8.optimize.RedundantBridgeRemover;
 import com.android.tools.r8.optimize.bridgehoisting.BridgeHoisting;
 import com.android.tools.r8.optimize.interfaces.analysis.CfOpenClosedInterfacesAnalysis;
 import com.android.tools.r8.optimize.proto.ProtoNormalizer;
-import com.android.tools.r8.optimize.redundantbridgeremoval.RedundantBridgeRemover;
 import com.android.tools.r8.origin.CommandLineOrigin;
 import com.android.tools.r8.profile.art.ArtProfileCompletenessChecker;
 import com.android.tools.r8.profile.rewriting.ProfileCollectionAdditions;
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
index a664d9d..97ceb6e 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
@@ -747,7 +747,7 @@
                   dataResourceConsumer.accept(adapted, options.reporter);
                 } else {
                   options.reporter.warning(
-                      new StringDiagnostic("Resource '" + file.getName() + "' already exists."));
+                      new StringDiagnostic("Resource '" + adapted.getName() + "' already exists."));
                 }
                 options.reporter.failIfPendingErrors();
               }
diff --git a/src/main/java/com/android/tools/r8/dex/code/DexCompareHelper.java b/src/main/java/com/android/tools/r8/dex/code/DexCompareHelper.java
index 93c2501..6af977e 100644
--- a/src/main/java/com/android/tools/r8/dex/code/DexCompareHelper.java
+++ b/src/main/java/com/android/tools/r8/dex/code/DexCompareHelper.java
@@ -11,7 +11,7 @@
   static final int DEX_ITEM_CONST_STRING_COMPARE_ID;
   static final int DEX_RECORD_FIELD_VALUES_COMPARE_ID;
 
-  private static int HIGHEST_DEX_OPCODE = 0xFF;
+  private static final int HIGHEST_DEX_OPCODE = 0xFF;
 
   static {
     int lastId = HIGHEST_DEX_OPCODE;
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index f9a5279..f30986c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -475,9 +475,9 @@
     return isInstanceInitializer() || willBeInlinedIntoInstanceInitializer(dexItemFactory);
   }
 
-  public boolean isDefaultInstanceInitializer() {
+  public boolean isDefaultInitializer() {
     checkIfObsolete();
-    return isInstanceInitializer() && getParameters().isEmpty();
+    return isInstanceInitializer() && getReference().proto.parameters.isEmpty();
   }
 
   public boolean isClassInitializer() {
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 2dfb637..13c5ab8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -602,9 +602,6 @@
   public final DexType javaUtilSetType = createStaticallyKnownType("Ljava/util/Set;");
 
   public final DexType androidAppActivity = createStaticallyKnownType("Landroid/app/Activity;");
-  public final DexType androidAppFragment = createStaticallyKnownType("Landroid/app/Fragment;");
-  public final DexType androidAppZygotePreload =
-      createStaticallyKnownType("Landroid/app/ZygotePreload;");
   public final DexType androidOsBuildType = createStaticallyKnownType("Landroid/os/Build;");
   public final DexType androidOsBuildVersionType =
       createStaticallyKnownType("Landroid/os/Build$VERSION;");
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
index e5d9dfe..47b1c27 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
@@ -25,12 +25,12 @@
 
   public static final FieldAccessInfoImpl MISSING_FIELD_ACCESS_INFO = new FieldAccessInfoImpl(null);
 
-  public static int FLAG_IS_READ_FROM_ANNOTATION = 1 << 0;
-  public static int FLAG_IS_READ_FROM_METHOD_HANDLE = 1 << 1;
-  public static int FLAG_IS_WRITTEN_FROM_METHOD_HANDLE = 1 << 2;
-  public static int FLAG_HAS_REFLECTIVE_READ = 1 << 3;
-  public static int FLAG_HAS_REFLECTIVE_WRITE = 1 << 4;
-  public static int FLAG_IS_READ_FROM_RECORD_INVOKE_DYNAMIC = 1 << 5;
+  public static final int FLAG_IS_READ_FROM_ANNOTATION = 1 << 0;
+  public static final int FLAG_IS_READ_FROM_METHOD_HANDLE = 1 << 1;
+  public static final int FLAG_IS_WRITTEN_FROM_METHOD_HANDLE = 1 << 2;
+  public static final int FLAG_HAS_REFLECTIVE_READ = 1 << 3;
+  public static final int FLAG_HAS_REFLECTIVE_WRITE = 1 << 4;
+  public static final int FLAG_IS_READ_FROM_RECORD_INVOKE_DYNAMIC = 1 << 5;
 
   // A direct reference to the definition of the field.
   private DexField field;
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
index d871616..637026f 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
+import com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite.FieldReadBeforeWriteAnalysis;
 import com.android.tools.r8.ir.code.FieldInstruction;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
@@ -69,6 +70,7 @@
       IRCode code,
       BytecodeMetadataProvider.Builder bytecodeMetadataProviderBuilder,
       OptimizationFeedback feedback,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis,
       MethodProcessor methodProcessor) {
     if (!methodProcessor.isPrimaryMethodProcessor()) {
       return;
@@ -85,7 +87,8 @@
             appView.appInfo().resolveField(fieldInstruction.getField()).getProgramField();
         if (field != null) {
           if (fieldAssignmentTracker != null) {
-            fieldAssignmentTracker.recordFieldAccess(fieldInstruction, field, code.context());
+            fieldAssignmentTracker.recordFieldAccess(
+                fieldInstruction, field, fieldReadBeforeWriteAnalysis);
           }
           if (fieldBitAccessAnalysis != null) {
             fieldBitAccessAnalysis.recordFieldAccess(
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
index 0db5825..dc90a85 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMergerUtils;
+import com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite.FieldReadBeforeWriteAnalysis;
 import com.android.tools.r8.ir.analysis.fieldaccess.state.ConcreteArrayTypeFieldState;
 import com.android.tools.r8.ir.analysis.fieldaccess.state.ConcreteClassTypeFieldState;
 import com.android.tools.r8.ir.analysis.fieldaccess.state.ConcretePrimitiveTypeFieldState;
@@ -34,6 +35,8 @@
 import com.android.tools.r8.ir.analysis.value.SingleValue;
 import com.android.tools.r8.ir.analysis.value.UnknownValue;
 import com.android.tools.r8.ir.code.FieldInstruction;
+import com.android.tools.r8.ir.code.FieldPut;
+import com.android.tools.r8.ir.code.InstancePut;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.NewInstance;
 import com.android.tools.r8.ir.code.Value;
@@ -179,16 +182,23 @@
         });
   }
 
-  void recordFieldAccess(FieldInstruction instruction, ProgramField field, ProgramMethod context) {
+  void recordFieldAccess(
+      FieldInstruction instruction,
+      ProgramField field,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis) {
     if (instruction.isFieldPut()) {
-      recordFieldPut(field, instruction.value(), context);
+      recordFieldPut(instruction.asFieldPut(), field, fieldReadBeforeWriteAnalysis);
     }
   }
 
-  private void recordFieldPut(ProgramField field, Value value, ProgramMethod context) {
+  private void recordFieldPut(
+      FieldPut fieldPut,
+      ProgramField field,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis) {
     // For now only attempt to prove that fields are definitely null. In order to prove a single
     // value for fields that are not definitely null, we need to prove that the given field is never
     // read before it is written.
+    Value value = fieldPut.value();
     AbstractValue abstractValue =
         value.isZero() ? abstractValueFactory.createZeroValue() : AbstractValue.unknown();
     fieldStates.compute(
@@ -203,12 +213,8 @@
               return ConcretePrimitiveTypeFieldState.create(abstractValue);
             }
             assert fieldType.isClassType();
-            DynamicType dynamicType =
-                WideningUtils.widenDynamicNonReceiverType(
-                    appView,
-                    value.getDynamicType(appView).withNullability(Nullability.maybeNull()),
-                    field.getType());
-            return ConcreteClassTypeFieldState.create(abstractValue, dynamicType);
+            return ConcreteClassTypeFieldState.create(
+                abstractValue, getDynamicType(fieldPut, field, fieldReadBeforeWriteAnalysis));
           }
 
           if (fieldState.isUnknown()) {
@@ -231,10 +237,31 @@
 
           ConcreteClassTypeFieldState classFieldState = fieldState.asClass();
           return classFieldState.mutableJoin(
-              appView, abstractValue, value.getDynamicType(appView), field);
+              appView,
+              abstractValue,
+              getDynamicType(fieldPut, field, fieldReadBeforeWriteAnalysis),
+              field);
         });
   }
 
+  private DynamicType getDynamicType(
+      FieldPut fieldPut,
+      ProgramField field,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis) {
+    DynamicTypeWithUpperBound dynamicType = fieldPut.value().getDynamicType(appView);
+    if (fieldPut.isInstancePut()) {
+      InstancePut instancePut = fieldPut.asInstancePut();
+      if (fieldReadBeforeWriteAnalysis.isInstanceFieldMaybeReadBeforeInstruction(
+          instancePut.object(), field.getDefinition(), instancePut)) {
+        dynamicType = dynamicType.withNullability(Nullability.maybeNull());
+      }
+    } else if (fieldReadBeforeWriteAnalysis.isStaticFieldMaybeReadBeforeInstruction(
+        field.getDefinition(), fieldPut.asStaticPut())) {
+      dynamicType = dynamicType.withNullability(Nullability.maybeNull());
+    }
+    return WideningUtils.widenDynamicNonReceiverType(appView, dynamicType, field.getType());
+  }
+
   void recordAllocationSite(NewInstance instruction, DexProgramClass clazz, ProgramMethod context) {
     Map<DexEncodedField, AbstractValue> abstractInstanceFieldValuesForClass =
         abstractInstanceFieldValues.get(clazz);
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/FieldReadBeforeWriteAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/FieldReadBeforeWriteAnalysis.java
new file mode 100644
index 0000000..fb6bae0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/FieldReadBeforeWriteAnalysis.java
@@ -0,0 +1,33 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.Value;
+
+public abstract class FieldReadBeforeWriteAnalysis {
+
+  public static FieldReadBeforeWriteAnalysis create(
+      AppView<?> appView, IRCode code, ProgramMethod context) {
+    if (appView.hasLiveness()) {
+      return new FieldReadBeforeWriteAnalysisImpl(appView.withLiveness(), code, context);
+    }
+    return trivial();
+  }
+
+  public static TrivialFieldReadBeforeWriteAnalysis trivial() {
+    return new TrivialFieldReadBeforeWriteAnalysis();
+  }
+
+  public abstract boolean isInstanceFieldMaybeReadBeforeInstruction(
+      Value receiver, DexEncodedField field, Instruction instruction);
+
+  public abstract boolean isStaticFieldMaybeReadBeforeInstruction(
+      DexEncodedField field, Instruction instruction);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/FieldReadBeforeWriteAnalysisImpl.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/FieldReadBeforeWriteAnalysisImpl.java
new file mode 100644
index 0000000..7e7ac89
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/FieldReadBeforeWriteAnalysisImpl.java
@@ -0,0 +1,209 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.analysis.fieldvalueanalysis.AbstractFieldSet;
+import com.android.tools.r8.ir.analysis.fieldvalueanalysis.ConcreteMutableFieldSet;
+import com.android.tools.r8.ir.analysis.fieldvalueanalysis.EmptyFieldSet;
+import com.android.tools.r8.ir.analysis.fieldvalueanalysis.KnownFieldSet;
+import com.android.tools.r8.ir.analysis.fieldvalueanalysis.UnknownFieldSet;
+import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InstructionIterator;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.DequeUtils;
+import java.util.Deque;
+import java.util.IdentityHashMap;
+import java.util.Map;
+
+class FieldReadBeforeWriteAnalysisImpl extends FieldReadBeforeWriteAnalysis {
+
+  private final AppView<AppInfoWithLiveness> appView;
+  private final IRCode code;
+  private final ProgramMethod context;
+
+  private Map<BasicBlock, AbstractFieldSet> fieldsMaybeReadBeforeBlockInclusiveCache;
+
+  public FieldReadBeforeWriteAnalysisImpl(
+      AppView<AppInfoWithLiveness> appView, IRCode code, ProgramMethod context) {
+    this.appView = appView;
+    this.code = code;
+    this.context = context;
+  }
+
+  @Override
+  public boolean isInstanceFieldMaybeReadBeforeInstruction(
+      Value receiver, DexEncodedField field, Instruction instruction) {
+    if (!code.context().getDefinition().isInstanceInitializer()
+        || receiver.getAliasedValue() != code.getThis()) {
+      return true;
+    }
+    return isFieldMaybeReadBeforeInstructionInInitializer(field, instruction);
+  }
+
+  @Override
+  public boolean isStaticFieldMaybeReadBeforeInstruction(
+      DexEncodedField field, Instruction instruction) {
+    if (!code.context().getDefinition().isClassInitializer()
+        || field.getHolderType() != code.context().getHolderType()) {
+      return true;
+    }
+    return isFieldMaybeReadBeforeInstructionInInitializer(field, instruction);
+  }
+
+  public boolean isFieldMaybeReadBeforeInstructionInInitializer(
+      DexEncodedField field, Instruction instruction) {
+    BasicBlock block = instruction.getBlock();
+
+    // First check if the field may be read in any of the (transitive) predecessor blocks.
+    if (fieldMaybeReadBeforeBlock(field, block)) {
+      return true;
+    }
+
+    // Then check if any of the instructions that precede the given instruction in the current block
+    // may read the field.
+    InstructionIterator instructionIterator = block.iterator();
+    while (instructionIterator.hasNext()) {
+      Instruction current = instructionIterator.next();
+      if (current == instruction) {
+        break;
+      }
+      if (current.readSet(appView, context).contains(field)) {
+        return true;
+      }
+    }
+
+    // Otherwise, the field is not read prior to the given instruction.
+    return false;
+  }
+
+  private boolean fieldMaybeReadBeforeBlock(DexEncodedField field, BasicBlock block) {
+    for (BasicBlock predecessor : block.getPredecessors()) {
+      if (fieldMaybeReadBeforeBlockInclusive(field, predecessor)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private boolean fieldMaybeReadBeforeBlockInclusive(DexEncodedField field, BasicBlock block) {
+    return getOrCreateFieldsMaybeReadBeforeBlockInclusive().get(block).contains(field);
+  }
+
+  private Map<BasicBlock, AbstractFieldSet> getOrCreateFieldsMaybeReadBeforeBlockInclusive() {
+    if (fieldsMaybeReadBeforeBlockInclusiveCache == null) {
+      fieldsMaybeReadBeforeBlockInclusiveCache = createFieldsMaybeReadBeforeBlockInclusive();
+    }
+    return fieldsMaybeReadBeforeBlockInclusiveCache;
+  }
+
+  /**
+   * Eagerly creates a mapping from each block to the set of fields that may be read in that block
+   * and its transitive predecessors.
+   */
+  private Map<BasicBlock, AbstractFieldSet> createFieldsMaybeReadBeforeBlockInclusive() {
+    Map<BasicBlock, AbstractFieldSet> result = new IdentityHashMap<>();
+    Deque<BasicBlock> worklist = DequeUtils.newArrayDeque(code.entryBlock());
+    while (!worklist.isEmpty()) {
+      BasicBlock block = worklist.removeFirst();
+      boolean seenBefore = result.containsKey(block);
+      AbstractFieldSet readSet =
+          result.computeIfAbsent(block, ignore -> EmptyFieldSet.getInstance());
+      if (readSet.isTop()) {
+        // We already have unknown information for this block.
+        continue;
+      }
+
+      assert readSet.isKnownFieldSet();
+      KnownFieldSet knownReadSet = readSet.asKnownFieldSet();
+      int oldSize = seenBefore ? knownReadSet.size() : -1;
+
+      // Everything that is read in the predecessor blocks should also be included in the read set
+      // for the current block, so here we join the information from the predecessor blocks into the
+      // current read set.
+      boolean blockOrPredecessorMaybeReadAnyField = false;
+      for (BasicBlock predecessor : block.getPredecessors()) {
+        AbstractFieldSet predecessorReadSet =
+            result.getOrDefault(predecessor, EmptyFieldSet.getInstance());
+        if (predecessorReadSet.isBottom()) {
+          continue;
+        }
+        if (predecessorReadSet.isTop()) {
+          blockOrPredecessorMaybeReadAnyField = true;
+          break;
+        }
+        assert predecessorReadSet.isConcreteFieldSet();
+        if (!knownReadSet.isConcreteFieldSet()) {
+          knownReadSet = new ConcreteMutableFieldSet();
+        }
+        knownReadSet.asConcreteFieldSet().addAll(predecessorReadSet.asConcreteFieldSet());
+      }
+
+      if (!blockOrPredecessorMaybeReadAnyField) {
+        // Finally, we update the read set with the fields that are read by the instructions in the
+        // current block. This can be skipped if the block has already been processed.
+        if (seenBefore) {
+          assert verifyFieldSetContainsAllFieldReadsInBlock(knownReadSet, block, context);
+        } else {
+          for (Instruction instruction : block.getInstructions()) {
+            AbstractFieldSet instructionReadSet = instruction.readSet(appView, context);
+            if (instructionReadSet.isBottom()) {
+              continue;
+            }
+            if (instructionReadSet.isTop()) {
+              blockOrPredecessorMaybeReadAnyField = true;
+              break;
+            }
+            if (!knownReadSet.isConcreteFieldSet()) {
+              knownReadSet = new ConcreteMutableFieldSet();
+            }
+            knownReadSet.asConcreteFieldSet().addAll(instructionReadSet.asConcreteFieldSet());
+          }
+        }
+      }
+
+      boolean changed = false;
+      if (blockOrPredecessorMaybeReadAnyField) {
+        // Record that this block reads all fields.
+        result.put(block, UnknownFieldSet.getInstance());
+        changed = true;
+      } else {
+        if (knownReadSet != readSet) {
+          result.put(block, knownReadSet.asConcreteFieldSet());
+        }
+        if (knownReadSet.size() != oldSize) {
+          assert knownReadSet.size() > oldSize;
+          changed = true;
+        }
+      }
+
+      if (changed) {
+        // Rerun the analysis for all successors because the state of the current block changed.
+        worklist.addAll(block.getSuccessors());
+      }
+    }
+    return result;
+  }
+
+  private boolean verifyFieldSetContainsAllFieldReadsInBlock(
+      KnownFieldSet readSet, BasicBlock block, ProgramMethod context) {
+    for (Instruction instruction : block.getInstructions()) {
+      AbstractFieldSet instructionReadSet = instruction.readSet(appView, context);
+      assert !instructionReadSet.isTop();
+      if (instructionReadSet.isBottom()) {
+        continue;
+      }
+      for (DexEncodedField field : instructionReadSet.asConcreteFieldSet().getFields()) {
+        assert readSet.contains(field);
+      }
+    }
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/TrivialFieldReadBeforeWriteAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/TrivialFieldReadBeforeWriteAnalysis.java
new file mode 100644
index 0000000..9cd76dc
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/readbeforewrite/TrivialFieldReadBeforeWriteAnalysis.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite;
+
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.Value;
+
+class TrivialFieldReadBeforeWriteAnalysis extends FieldReadBeforeWriteAnalysis {
+
+  @Override
+  public boolean isInstanceFieldMaybeReadBeforeInstruction(
+      Value receiver, DexEncodedField field, Instruction instruction) {
+    return true;
+  }
+
+  @Override
+  public boolean isStaticFieldMaybeReadBeforeInstruction(
+      DexEncodedField field, Instruction instruction) {
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java
index b18d02a..854d046 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java
@@ -39,7 +39,7 @@
     return this;
   }
 
-  Set<DexEncodedField> getFields() {
+  public Set<DexEncodedField> getFields() {
     if (InternalOptions.assertionsEnabled()) {
       return Collections.unmodifiableSet(fields);
     }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
index 9c09ef2..50c075e 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
@@ -10,13 +10,14 @@
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite.FieldReadBeforeWriteAnalysis;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.DominatorTree;
 import com.android.tools.r8.ir.code.DominatorTree.Assumption;
 import com.android.tools.r8.ir.code.FieldInstruction;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.InstancePut;
 import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InstructionIterator;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization.ClassInitializerDefaultsResult;
@@ -24,14 +25,11 @@
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfo;
 import com.android.tools.r8.ir.optimize.info.field.UnknownInstanceFieldInitializationInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.DequeUtils;
 import com.android.tools.r8.utils.ListUtils;
 import java.util.ArrayList;
-import java.util.Deque;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 
 public abstract class FieldValueAnalysis {
 
@@ -53,16 +51,20 @@
   final OptimizationFeedback feedback;
 
   private DominatorTree dominatorTree;
-  private Map<BasicBlock, AbstractFieldSet> fieldsMaybeReadBeforeBlockInclusiveCache;
+  private FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis;
 
   final Map<DexEncodedField, List<FieldInitializationInfo>> putsPerField = new IdentityHashMap<>();
 
   FieldValueAnalysis(
-      AppView<AppInfoWithLiveness> appView, IRCode code, OptimizationFeedback feedback) {
+      AppView<AppInfoWithLiveness> appView,
+      IRCode code,
+      OptimizationFeedback feedback,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis) {
     this.appView = appView;
     this.code = code;
-    this.feedback = feedback;
     this.context = code.context();
+    this.feedback = feedback;
+    this.fieldReadBeforeWriteAnalysis = fieldReadBeforeWriteAnalysis;
   }
 
   DominatorTree getOrCreateDominatorTree() {
@@ -72,13 +74,6 @@
     return dominatorTree;
   }
 
-  private Map<BasicBlock, AbstractFieldSet> getOrCreateFieldsMaybeReadBeforeBlockInclusive() {
-    if (fieldsMaybeReadBeforeBlockInclusiveCache == null) {
-      fieldsMaybeReadBeforeBlockInclusiveCache = createFieldsMaybeReadBeforeBlockInclusive();
-    }
-    return fieldsMaybeReadBeforeBlockInclusiveCache;
-  }
-
   boolean isInstanceFieldValueAnalysis() {
     return false;
   }
@@ -95,9 +90,9 @@
     return null;
   }
 
-  abstract boolean isSubjectToOptimizationIgnoringPinning(DexEncodedField field);
+  abstract boolean isSubjectToOptimizationIgnoringPinning(ProgramField field);
 
-  abstract boolean isSubjectToOptimization(DexEncodedField field);
+  abstract boolean isSubjectToOptimization(ProgramField field);
 
   void recordFieldPut(DexEncodedField field, Instruction instruction) {
     recordFieldPut(field, instruction, UnknownInstanceFieldInitializationInfo.getInstance());
@@ -127,13 +122,12 @@
           DexField field = fieldPut.getField();
           ProgramField programField = appInfo.resolveField(field).getProgramField();
           if (programField != null) {
-            DexEncodedField encodedField = programField.getDefinition();
-            if (isSubjectToOptimization(encodedField)) {
-              recordFieldPut(encodedField, fieldPut);
+            if (isSubjectToOptimization(programField)) {
+              recordFieldPut(programField.getDefinition(), fieldPut);
             } else if (isStaticFieldValueAnalysis()
                 && programField.getHolder().isEnum()
-                && isSubjectToOptimizationIgnoringPinning(encodedField)) {
-              recordFieldPut(encodedField, fieldPut);
+                && isSubjectToOptimizationIgnoringPinning(programField)) {
+              recordFieldPut(programField.getDefinition(), fieldPut);
             }
           }
         } else if (isInstanceFieldValueAnalysis()
@@ -144,186 +138,54 @@
       }
     }
 
+    boolean checkDominance = !isStraightLineCode;
     List<BasicBlock> normalExitBlocks = code.computeNormalExitBlocks();
-    for (Entry<DexEncodedField, List<FieldInitializationInfo>> entry : putsPerField.entrySet()) {
-      DexEncodedField field = entry.getKey();
-      List<FieldInitializationInfo> fieldPuts = entry.getValue();
-      if (fieldPuts.size() > 1) {
-        continue;
-      }
-      FieldInitializationInfo info = ListUtils.first(fieldPuts);
-      Instruction instruction = info.instruction;
-      if (instruction.isInvokeDirect()) {
-        asInstanceFieldValueAnalysis()
-            .recordInstanceFieldIsInitializedWithInfo(field, info.instanceFieldInitializationInfo);
-        continue;
-      }
-      FieldInstruction fieldPut = instruction.asFieldInstruction();
-      if (!isStraightLineCode) {
-        if (!getOrCreateDominatorTree().dominatesAllOf(fieldPut.getBlock(), normalExitBlocks)) {
-          continue;
-        }
-      }
-      boolean priorReadsWillReadSameValue =
-          !classInitializerDefaultsResult.hasStaticValue(field) && fieldPut.value().isZero();
-      if (!priorReadsWillReadSameValue && fieldMaybeReadBeforeInstruction(field, fieldPut)) {
-        // TODO(b/172528424): Generalize to InstanceFieldValueAnalysis.
-        if (isStaticFieldValueAnalysis()) {
-          // At this point the value read in the field can be only the default static value, if read
-          // prior to the put, or the value put, if read after the put. We still want to record it
-          // because the default static value is typically null/0, so code present after a null/0
-          // check can take advantage of the optimization.
-          DexValue valueBeforePut = classInitializerDefaultsResult.getStaticValue(field);
-          asStaticFieldValueAnalysis()
-              .updateFieldOptimizationInfoWith2Values(field, fieldPut.value(), valueBeforePut);
-        }
-        continue;
-      }
-      updateFieldOptimizationInfo(field, fieldPut, fieldPut.value());
-    }
-  }
-
-  private boolean fieldMaybeReadBeforeInstruction(
-      DexEncodedField encodedField, Instruction instruction) {
-    BasicBlock block = instruction.getBlock();
-
-    // First check if the field may be read in any of the (transitive) predecessor blocks.
-    if (fieldMaybeReadBeforeBlock(encodedField, block)) {
-      return true;
-    }
-
-    // Then check if any of the instructions that precede the given instruction in the current block
-    // may read the field.
-    InstructionIterator instructionIterator = block.iterator();
-    while (instructionIterator.hasNext()) {
-      Instruction current = instructionIterator.next();
-      if (current == instruction) {
-        break;
-      }
-      if (current.readSet(appView, context).contains(encodedField)) {
-        return true;
-      }
-    }
-
-    // Otherwise, the field is not read prior to the given instruction.
-    return false;
-  }
-
-  private boolean fieldMaybeReadBeforeBlock(DexEncodedField encodedField, BasicBlock block) {
-    for (BasicBlock predecessor : block.getPredecessors()) {
-      if (fieldMaybeReadBeforeBlockInclusive(encodedField, predecessor)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  private boolean fieldMaybeReadBeforeBlockInclusive(
-      DexEncodedField encodedField, BasicBlock block) {
-    return getOrCreateFieldsMaybeReadBeforeBlockInclusive().get(block).contains(encodedField);
-  }
-
-  /**
-   * Eagerly creates a mapping from each block to the set of fields that may be read in that block
-   * and its transitive predecessors.
-   */
-  private Map<BasicBlock, AbstractFieldSet> createFieldsMaybeReadBeforeBlockInclusive() {
-    Map<BasicBlock, AbstractFieldSet> result = new IdentityHashMap<>();
-    Deque<BasicBlock> worklist = DequeUtils.newArrayDeque(code.entryBlock());
-    while (!worklist.isEmpty()) {
-      BasicBlock block = worklist.removeFirst();
-      boolean seenBefore = result.containsKey(block);
-      AbstractFieldSet readSet =
-          result.computeIfAbsent(block, ignore -> EmptyFieldSet.getInstance());
-      if (readSet.isTop()) {
-        // We already have unknown information for this block.
-        continue;
-      }
-
-      assert readSet.isKnownFieldSet();
-      KnownFieldSet knownReadSet = readSet.asKnownFieldSet();
-      int oldSize = seenBefore ? knownReadSet.size() : -1;
-
-      // Everything that is read in the predecessor blocks should also be included in the read set
-      // for the current block, so here we join the information from the predecessor blocks into the
-      // current read set.
-      boolean blockOrPredecessorMaybeReadAnyField = false;
-      for (BasicBlock predecessor : block.getPredecessors()) {
-        AbstractFieldSet predecessorReadSet =
-            result.getOrDefault(predecessor, EmptyFieldSet.getInstance());
-        if (predecessorReadSet.isBottom()) {
-          continue;
-        }
-        if (predecessorReadSet.isTop()) {
-          blockOrPredecessorMaybeReadAnyField = true;
-          break;
-        }
-        assert predecessorReadSet.isConcreteFieldSet();
-        if (!knownReadSet.isConcreteFieldSet()) {
-          knownReadSet = new ConcreteMutableFieldSet();
-        }
-        knownReadSet.asConcreteFieldSet().addAll(predecessorReadSet.asConcreteFieldSet());
-      }
-
-      if (!blockOrPredecessorMaybeReadAnyField) {
-        // Finally, we update the read set with the fields that are read by the instructions in the
-        // current block. This can be skipped if the block has already been processed.
-        if (seenBefore) {
-          assert verifyFieldSetContainsAllFieldReadsInBlock(knownReadSet, block, context);
-        } else {
-          for (Instruction instruction : block.getInstructions()) {
-            AbstractFieldSet instructionReadSet = instruction.readSet(appView, context);
-            if (instructionReadSet.isBottom()) {
-              continue;
-            }
-            if (instructionReadSet.isTop()) {
-              blockOrPredecessorMaybeReadAnyField = true;
-              break;
-            }
-            if (!knownReadSet.isConcreteFieldSet()) {
-              knownReadSet = new ConcreteMutableFieldSet();
-            }
-            knownReadSet.asConcreteFieldSet().addAll(instructionReadSet.asConcreteFieldSet());
+    putsPerField.forEach(
+        (field, fieldPuts) -> {
+          if (fieldPuts.size() > 1) {
+            return;
           }
-        }
-      }
-
-      boolean changed = false;
-      if (blockOrPredecessorMaybeReadAnyField) {
-        // Record that this block reads all fields.
-        result.put(block, UnknownFieldSet.getInstance());
-        changed = true;
-      } else {
-        if (knownReadSet != readSet) {
-          result.put(block, knownReadSet.asConcreteFieldSet());
-        }
-        if (knownReadSet.size() != oldSize) {
-          assert knownReadSet.size() > oldSize;
-          changed = true;
-        }
-      }
-
-      if (changed) {
-        // Rerun the analysis for all successors because the state of the current block changed.
-        worklist.addAll(block.getSuccessors());
-      }
-    }
-    return result;
-  }
-
-  private boolean verifyFieldSetContainsAllFieldReadsInBlock(
-      KnownFieldSet readSet, BasicBlock block, ProgramMethod context) {
-    for (Instruction instruction : block.getInstructions()) {
-      AbstractFieldSet instructionReadSet = instruction.readSet(appView, context);
-      assert !instructionReadSet.isTop();
-      if (instructionReadSet.isBottom()) {
-        continue;
-      }
-      for (DexEncodedField field : instructionReadSet.asConcreteFieldSet().getFields()) {
-        assert readSet.contains(field);
-      }
-    }
-    return true;
+          FieldInitializationInfo info = ListUtils.first(fieldPuts);
+          Instruction instruction = info.instruction;
+          if (instruction.isInvokeDirect()) {
+            asInstanceFieldValueAnalysis()
+                .recordInstanceFieldIsInitializedWithInfo(
+                    field, info.instanceFieldInitializationInfo);
+            return;
+          }
+          FieldInstruction fieldPut = instruction.asFieldInstruction();
+          if (checkDominance
+              && !getOrCreateDominatorTree()
+                  .dominatesAllOf(fieldPut.getBlock(), normalExitBlocks)) {
+            return;
+          }
+          boolean priorReadsWillReadSameValue =
+              !classInitializerDefaultsResult.hasStaticValue(field) && fieldPut.value().isZero();
+          if (!priorReadsWillReadSameValue) {
+            if (fieldPut.isInstancePut()) {
+              InstancePut instancePut = fieldPut.asInstancePut();
+              if (fieldReadBeforeWriteAnalysis.isInstanceFieldMaybeReadBeforeInstruction(
+                  instancePut.object(), field, instancePut)) {
+                return;
+              }
+            } else {
+              if (fieldReadBeforeWriteAnalysis.isStaticFieldMaybeReadBeforeInstruction(
+                  field, fieldPut)) {
+                // TODO(b/172528424): Generalize to InstanceFieldValueAnalysis.
+                // At this point the value read in the field can be only the default static value,
+                // if read prior to the put, or the value put, if read after the put. We still want
+                // to record it because the default static value is typically null/0, so code
+                // present after a null/0 check can take advantage of the optimization.
+                DexValue valueBeforePut = classInitializerDefaultsResult.getStaticValue(field);
+                asStaticFieldValueAnalysis()
+                    .updateFieldOptimizationInfoWith2Values(
+                        field, fieldPut.value(), valueBeforePut);
+                return;
+              }
+            }
+          }
+          updateFieldOptimizationInfo(field, fieldPut, fieldPut.value());
+        });
   }
 
   abstract void updateFieldOptimizationInfo(
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java
index c4061ec..9ae014f 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java
@@ -11,7 +11,9 @@
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite.FieldReadBeforeWriteAnalysis;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
@@ -50,9 +52,10 @@
       AppView<AppInfoWithLiveness> appView,
       IRCode code,
       OptimizationFeedback feedback,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis,
       DexClassAndMethod parentConstructor,
       InvokeDirect parentConstructorCall) {
-    super(appView, code, feedback);
+    super(appView, code, feedback, fieldReadBeforeWriteAnalysis);
     this.factory = appView.instanceFieldInitializationInfoFactory();
     this.parentConstructor = parentConstructor;
     this.parentConstructorCall = parentConstructorCall;
@@ -67,10 +70,11 @@
       IRCode code,
       ClassInitializerDefaultsResult classInitializerDefaultsResult,
       OptimizationFeedback feedback,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis,
       Timing timing) {
     timing.begin("Analyze instance initializer");
     InstanceFieldInitializationInfoCollection result =
-        run(appView, code, classInitializerDefaultsResult, feedback);
+        run(appView, code, classInitializerDefaultsResult, feedback, fieldReadBeforeWriteAnalysis);
     timing.end();
     return result;
   }
@@ -79,7 +83,8 @@
       AppView<?> appView,
       IRCode code,
       ClassInitializerDefaultsResult classInitializerDefaultsResult,
-      OptimizationFeedback feedback) {
+      OptimizationFeedback feedback,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis) {
     assert appView.appInfo().hasLiveness();
     assert appView.enableWholeProgramOptimizations();
     assert code.context().getDefinition().isInstanceInitializer();
@@ -101,6 +106,7 @@
             appView.withLiveness(),
             code,
             feedback,
+            fieldReadBeforeWriteAnalysis,
             parentConstructor,
             parentConstructorCall);
     analysis.computeFieldOptimizationInfo(classInitializerDefaultsResult);
@@ -119,12 +125,12 @@
   }
 
   @Override
-  boolean isSubjectToOptimization(DexEncodedField field) {
-    return !field.isStatic() && field.getHolderType() == context.getHolderType();
+  boolean isSubjectToOptimization(ProgramField field) {
+    return !field.getAccessFlags().isStatic() && field.getHolderType() == context.getHolderType();
   }
 
   @Override
-  boolean isSubjectToOptimizationIgnoringPinning(DexEncodedField field) {
+  boolean isSubjectToOptimizationIgnoringPinning(ProgramField field) {
     throw new Unreachable("Used by static analysis only.");
   }
 
@@ -203,7 +209,7 @@
     if (abstractValue.isSingleValue()) {
       return abstractValue.asSingleValue();
     }
-    DexType fieldType = field.type();
+    DexType fieldType = field.getType();
     if (fieldType.isClassType()) {
       ClassTypeElement dynamicLowerBoundType = value.getDynamicLowerBoundType(appView);
       TypeElement dynamicUpperBoundType = value.getDynamicUpperBoundType(appView);
@@ -229,7 +235,7 @@
 
   private boolean fieldNeverWrittenBetweenInstancePutAndMethodExit(
       DexEncodedField field, InstancePut instancePut) {
-    if (field.isFinal()) {
+    if (field.getAccessFlags().isFinal()) {
       return true;
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
index 4df6b75..5f8381d 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
@@ -15,6 +15,8 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.DexValue.DexValueNull;
+import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite.FieldReadBeforeWriteAnalysis;
 import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
@@ -49,8 +51,11 @@
   private final Map<Value, AbstractValue> computedValues = new IdentityHashMap<>();
 
   private StaticFieldValueAnalysis(
-      AppView<AppInfoWithLiveness> appView, IRCode code, OptimizationFeedback feedback) {
-    super(appView, code, feedback);
+      AppView<AppInfoWithLiveness> appView,
+      IRCode code,
+      OptimizationFeedback feedback,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis) {
+    super(appView, code, feedback, fieldReadBeforeWriteAnalysis);
     builder = StaticFieldValues.builder(code.context().getHolder());
   }
 
@@ -59,13 +64,15 @@
       IRCode code,
       ClassInitializerDefaultsResult classInitializerDefaultsResult,
       OptimizationFeedback feedback,
+      FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis,
       Timing timing) {
     assert appView.appInfo().hasLiveness();
     assert appView.enableWholeProgramOptimizations();
     assert code.context().getDefinition().isClassInitializer();
     timing.begin("Analyze class initializer");
     StaticFieldValues result =
-        new StaticFieldValueAnalysis(appView.withLiveness(), code, feedback)
+        new StaticFieldValueAnalysis(
+                appView.withLiveness(), code, feedback, fieldReadBeforeWriteAnalysis)
             .analyze(classInitializerDefaultsResult);
     timing.end();
     return result;
@@ -117,19 +124,22 @@
   }
 
   @Override
-  boolean isSubjectToOptimization(DexEncodedField field) {
-    return field.isStatic()
-        && field.getHolderType() == context.getHolderType()
-        && appView.appInfo().isFieldOnlyWrittenInMethod(field, context.getDefinition());
-  }
-
-  @Override
-  boolean isSubjectToOptimizationIgnoringPinning(DexEncodedField field) {
-    return field.isStatic()
+  boolean isSubjectToOptimization(ProgramField field) {
+    return field.getAccessFlags().isStatic()
         && field.getHolderType() == context.getHolderType()
         && appView
             .appInfo()
-            .isFieldOnlyWrittenInMethodIgnoringPinning(field, context.getDefinition());
+            .isFieldOnlyWrittenInMethod(field.getDefinition(), context.getDefinition());
+  }
+
+  @Override
+  boolean isSubjectToOptimizationIgnoringPinning(ProgramField field) {
+    return field.getAccessFlags().isStatic()
+        && field.getHolderType() == context.getHolderType()
+        && appView
+            .appInfo()
+            .isFieldOnlyWrittenInMethodIgnoringPinning(
+                field.getDefinition(), context.getDefinition());
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index fc8d1f2..bc02268 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.ir.analysis.VerifyTypesHelper;
 import com.android.tools.r8.ir.analysis.constant.SparseConditionalConstantPropagation;
 import com.android.tools.r8.ir.analysis.fieldaccess.FieldAccessAnalysis;
+import com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite.FieldReadBeforeWriteAnalysis;
 import com.android.tools.r8.ir.analysis.fieldvalueanalysis.InstanceFieldValueAnalysis;
 import com.android.tools.r8.ir.analysis.fieldvalueanalysis.StaticFieldValueAnalysis;
 import com.android.tools.r8.ir.analysis.fieldvalueanalysis.StaticFieldValues;
@@ -979,10 +980,16 @@
       timing.end();
     }
 
+    FieldReadBeforeWriteAnalysis fieldReadBeforeWriteAnalysis =
+        FieldReadBeforeWriteAnalysis.create(appView, code, method);
     if (fieldAccessAnalysis != null) {
       timing.begin("Analyze field accesses");
       fieldAccessAnalysis.recordFieldAccesses(
-          code, bytecodeMetadataProviderBuilder, feedback, methodProcessor);
+          code,
+          bytecodeMetadataProviderBuilder,
+          feedback,
+          fieldReadBeforeWriteAnalysis,
+          methodProcessor);
       if (classInitializerDefaultsResult != null) {
         fieldAccessAnalysis.acceptClassInitializerDefaultsResult(classInitializerDefaultsResult);
       }
@@ -999,11 +1006,21 @@
       if (method.getDefinition().isClassInitializer()) {
         staticFieldValues =
             StaticFieldValueAnalysis.run(
-                appView, code, classInitializerDefaultsResult, feedback, timing);
+                appView,
+                code,
+                classInitializerDefaultsResult,
+                feedback,
+                fieldReadBeforeWriteAnalysis,
+                timing);
       } else {
         instanceFieldInitializationInfos =
             InstanceFieldValueAnalysis.run(
-                appView, code, classInitializerDefaultsResult, feedback, timing);
+                appView,
+                code,
+                classInitializerDefaultsResult,
+                feedback,
+                fieldReadBeforeWriteAnalysis,
+                timing);
       }
     }
     enumUnboxer.recordEnumState(method.getHolder(), staticFieldValues);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java b/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java
index c2e13af..125b53c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java
@@ -86,7 +86,7 @@
           continue;
         }
 
-        if (method.getDefinition().isDefaultInstanceInitializer()
+        if (method.getDefinition().isDefaultInitializer()
             && appView.hasProguardCompatibilityActions()
             && appView.getProguardCompatibilityActions().isCompatInstantiated(method.getHolder())) {
           continue;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
index 5f9e4f2..c147322 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
@@ -96,6 +96,7 @@
 import com.android.tools.r8.ir.optimize.enums.eligibility.Reason.MissingExactDynamicEnumTypeForEnumWithSubtypesReason;
 import com.android.tools.r8.ir.optimize.enums.eligibility.Reason.MissingInstanceFieldValueForEnumInstanceReason;
 import com.android.tools.r8.ir.optimize.enums.eligibility.Reason.MissingObjectStateForEnumInstanceReason;
+import com.android.tools.r8.ir.optimize.enums.eligibility.Reason.UnboxedValueNonComparable;
 import com.android.tools.r8.ir.optimize.enums.eligibility.Reason.UnsupportedInstanceFieldValueForEnumInstanceReason;
 import com.android.tools.r8.ir.optimize.enums.eligibility.Reason.UnsupportedLibraryInvokeReason;
 import com.android.tools.r8.ir.optimize.info.MutableFieldOptimizationInfo;
@@ -1369,6 +1370,24 @@
     return reason;
   }
 
+  private Reason comparableAsUnboxedValues(InvokeMethod invoke) {
+    assert invoke.inValues().size() == 2;
+    TypeElement type1 = invoke.getFirstArgument().getType();
+    TypeElement type2 = invoke.getLastArgument().getType();
+    DexProgramClass candidate1 = getEnumUnboxingCandidateOrNull(type1);
+    DexProgramClass candidate2 = getEnumUnboxingCandidateOrNull(type2);
+    assert candidate1 != null || candidate2 != null;
+    if (type1.isNullType() || type2.isNullType()) {
+      // Comparing an unboxed enum to null is always allowed.
+      return Reason.ELIGIBLE;
+    }
+    if (candidate1 == candidate2) {
+      // Comparing two unboxed enum values is valid only if they come from the same enum.
+      return Reason.ELIGIBLE;
+    }
+    return new UnboxedValueNonComparable(invoke.getInvokedMethod(), type1, type2);
+  }
+
   private Reason analyzeLibraryInvoke(
       InvokeMethod invoke,
       IRCode code,
@@ -1382,13 +1401,9 @@
       // TODO(b/147860220): EnumSet and EnumMap may be interesting to model.
       if (singleTargetReference == factory.enumMembers.compareTo
           || singleTargetReference == factory.enumMembers.compareToWithObject) {
-        DexProgramClass otherEnumClass =
-            getEnumUnboxingCandidateOrNull(invoke.getLastArgument().getType());
-        if (otherEnumClass == enumClass || invoke.getLastArgument().getType().isNullType()) {
-          return Reason.ELIGIBLE;
-        }
+        return comparableAsUnboxedValues(invoke);
       } else if (singleTargetReference == factory.enumMembers.equals) {
-        return Reason.ELIGIBLE;
+        return comparableAsUnboxedValues(invoke);
       } else if (singleTargetReference == factory.enumMembers.nameMethod
           || singleTargetReference == factory.enumMembers.toString) {
         assert invoke.asInvokeMethodWithReceiver().getReceiver() == enumValue;
@@ -1415,6 +1430,17 @@
         // This is a hidden null check.
         return Reason.ELIGIBLE;
       }
+      if (singleTargetReference == factory.objectMembers.toString) {
+        assert invoke.asInvokeMethodWithReceiver().getReceiver() == enumValue;
+        addRequiredNameData(enumClass);
+        return Reason.ELIGIBLE;
+      }
+      if (singleTargetReference == factory.objectMembers.hashCode) {
+        return Reason.ELIGIBLE;
+      }
+      if (singleTargetReference == factory.objectMembers.equals) {
+        return comparableAsUnboxedValues(invoke);
+      }
       return new UnsupportedLibraryInvokeReason(singleTargetReference);
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/eligibility/Reason.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/eligibility/Reason.java
index 26c35b2..bfd215d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/eligibility/Reason.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/eligibility/Reason.java
@@ -6,6 +6,7 @@
 
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.google.common.collect.ImmutableList;
 
 public abstract class Reason {
@@ -268,6 +269,43 @@
     }
   }
 
+  public static class UnboxedValueNonComparable extends Reason {
+
+    private final DexMethod invokedMethod;
+    private final TypeElement type1;
+    private final TypeElement type2;
+
+    public UnboxedValueNonComparable(
+        DexMethod invokedMethod, TypeElement type1, TypeElement type2) {
+      this.invokedMethod = invokedMethod;
+      this.type1 = type1;
+      this.type2 = type2;
+    }
+
+    @Override
+    public Object getKind() {
+      return ImmutableList.of(getClass(), invokedMethod);
+    }
+
+    private static String typeInformation(TypeElement type) {
+      if (type.isClassType()) {
+        return type.asClassType().getClassType().toSourceString();
+      }
+      return type.toString();
+    }
+
+    @Override
+    public String toString() {
+      return "NonComparableElements("
+          + invokedMethod.toSourceString()
+          + " - "
+          + typeInformation(type1)
+          + " vs "
+          + typeInformation(type2)
+          + ")";
+    }
+  }
+
   public static class UnsupportedStaticFieldReason extends Reason {
 
     private final DexField field;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
index f518d5e..8b7bd6b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
@@ -28,16 +28,16 @@
   public static final DefaultMethodOptimizationInfo DEFAULT_INSTANCE =
       new DefaultMethodOptimizationInfo();
 
-  static Set<DexType> UNKNOWN_INITIALIZED_CLASSES_ON_NORMAL_EXIT = ImmutableSet.of();
-  static int UNKNOWN_RETURNED_ARGUMENT = -1;
-  static boolean UNKNOWN_NEVER_RETURNS_NORMALLY = false;
-  static AbstractValue UNKNOWN_ABSTRACT_RETURN_VALUE = UnknownValue.getInstance();
-  static boolean UNKNOWN_TRIGGERS_CLASS_INIT_BEFORE_ANY_SIDE_EFFECT = false;
-  static boolean UNKNOWN_INITIALIZER_ENABLING_JAVA_ASSERTIONS = false;
-  static boolean UNKNOWN_MAY_HAVE_SIDE_EFFECTS = true;
-  static boolean UNKNOWN_RETURN_VALUE_ONLY_DEPENDS_ON_ARGUMENTS = false;
-  static BitSet NO_NULL_PARAMETER_OR_THROW_FACTS = null;
-  static BitSet NO_NULL_PARAMETER_ON_NORMAL_EXITS_FACTS = null;
+  static final Set<DexType> UNKNOWN_INITIALIZED_CLASSES_ON_NORMAL_EXIT = ImmutableSet.of();
+  static final int UNKNOWN_RETURNED_ARGUMENT = -1;
+  static final boolean UNKNOWN_NEVER_RETURNS_NORMALLY = false;
+  static final AbstractValue UNKNOWN_ABSTRACT_RETURN_VALUE = UnknownValue.getInstance();
+  static final boolean UNKNOWN_TRIGGERS_CLASS_INIT_BEFORE_ANY_SIDE_EFFECT = false;
+  static final boolean UNKNOWN_INITIALIZER_ENABLING_JAVA_ASSERTIONS = false;
+  static final boolean UNKNOWN_MAY_HAVE_SIDE_EFFECTS = true;
+  static final boolean UNKNOWN_RETURN_VALUE_ONLY_DEPENDS_ON_ARGUMENTS = false;
+  static final BitSet NO_NULL_PARAMETER_OR_THROW_FACTS = null;
+  static final BitSet NO_NULL_PARAMETER_ON_NORMAL_EXITS_FACTS = null;
 
   protected DefaultMethodOptimizationInfo() {}
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
index f8e784e..c92342f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
@@ -420,9 +420,10 @@
                 }
                 builder.setParent(invokedMethod);
               } else {
-                builder
-                    .markAllFieldsAsRead()
-                    .setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+                builder.markAllFieldsAsRead();
+                if (invoke.instructionMayHaveSideEffects(appView, context)) {
+                  builder.setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+                }
                 for (Value inValue : invoke.inValues()) {
                   if (couldBeReceiverValue(inValue, receiver, aliasesThroughAssumeAndCheckCasts)) {
                     builder.setReceiverMayEscapeOutsideConstructorChain();
@@ -453,9 +454,10 @@
           case INVOKE_VIRTUAL:
             {
               InvokeMethod invoke = instruction.asInvokeMethod();
-              builder
-                  .markAllFieldsAsRead()
-                  .setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+              builder.markAllFieldsAsRead();
+              if (invoke.instructionMayHaveSideEffects(appView, context)) {
+                builder.setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+              }
               for (Value argument : invoke.arguments()) {
                 if (couldBeReceiverValue(argument, receiver, aliasesThroughAssumeAndCheckCasts)) {
                   builder.setReceiverMayEscapeOutsideConstructorChain();
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java
index c3fc071..1d92c11 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapSupplier.java
@@ -17,7 +17,7 @@
 
 public class ProguardMapSupplier {
 
-  public static int PG_MAP_ID_LENGTH = 7;
+  public static final int PG_MAP_ID_LENGTH = 7;
 
   // Hash of the Proguard map (excluding the header up to and including the hash marker).
   public static class ProguardMapId {
diff --git a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemover.java b/src/main/java/com/android/tools/r8/optimize/RedundantBridgeRemover.java
similarity index 72%
rename from src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemover.java
rename to src/main/java/com/android/tools/r8/optimize/RedundantBridgeRemover.java
index c050859..763c40f 100644
--- a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemover.java
+++ b/src/main/java/com/android/tools/r8/optimize/RedundantBridgeRemover.java
@@ -1,10 +1,9 @@
 // Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.optimize.redundantbridgeremoval;
+package com.android.tools.r8.optimize;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexMethod;
@@ -16,35 +15,23 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.ir.optimize.info.bridge.BridgeInfo;
-import com.android.tools.r8.optimize.InvokeSingleTargetExtractor;
 import com.android.tools.r8.optimize.InvokeSingleTargetExtractor.InvokeKind;
-import com.android.tools.r8.optimize.MemberRebindingIdentityLens;
+import com.android.tools.r8.optimize.redundantbridgeremoval.RedundantBridgeRemovalLens;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.KeepMethodInfo;
-import com.android.tools.r8.utils.IterableUtils;
 import com.android.tools.r8.utils.ThreadUtils;
-import com.android.tools.r8.utils.WorkList;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import com.google.common.collect.Iterables;
-import java.util.Collections;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
-import java.util.function.Consumer;
 
 public class RedundantBridgeRemover {
 
   private final AppView<AppInfoWithLiveness> appView;
-  private final RedundantBridgeRemovalOptions redundantBridgeRemovalOptions;
-
-  private final InvokedReflectivelyFromPlatformAnalysis invokedReflectivelyFromPlatformAnalysis =
-      new InvokedReflectivelyFromPlatformAnalysis();
 
   public RedundantBridgeRemover(AppView<AppInfoWithLiveness> appView) {
     this.appView = appView;
-    this.redundantBridgeRemovalOptions =
-        appView.options().getRedundantBridgeRemovalOptions().ensureInitialized();
   }
 
   private DexClassAndMethod getTargetForRedundantBridge(ProgramMethod method) {
@@ -65,9 +52,6 @@
     if (!isTargetingSuperMethod(method, targetExtractor.getKind(), target)) {
       return null;
     }
-    if (invokedReflectivelyFromPlatformAnalysis.isMaybeInvokedReflectivelyFromPlatform(method)) {
-      return null;
-    }
     // This is a visibility forward, so check for the direct target.
     DexClassAndMethod targetMethod =
         appView.appInfo().unsafeResolveMethodDueToDexFormatLegacy(target).getResolutionPair();
@@ -252,88 +236,4 @@
         });
     appView.pruneItems(prunedItemsBuilder.build(), executorService);
   }
-
-  class InvokedReflectivelyFromPlatformAnalysis {
-
-    // Maps each class to a boolean indicating if the class inherits from android.app.Fragment or
-    // android.app.ZygotePreload.
-    private final Map<DexClass, Boolean> cache = new ConcurrentHashMap<>();
-
-    boolean isMaybeInvokedReflectivelyFromPlatform(ProgramMethod method) {
-      return method.getDefinition().isDefaultInstanceInitializer()
-          && !method.getHolder().isAbstract()
-          && computeIsPlatformReflectingOnDefaultConstructor(method.getHolder());
-    }
-
-    private boolean computeIsPlatformReflectingOnDefaultConstructor(DexProgramClass clazz) {
-      Boolean cacheResult = cache.get(clazz);
-      if (cacheResult != null) {
-        return cacheResult;
-      }
-      WorkList.<WorklistItem>newIdentityWorkList(new NotProcessedWorklistItem(clazz))
-          .process(WorklistItem::accept);
-      assert cache.containsKey(clazz);
-      return cache.get(clazz);
-    }
-
-    abstract class WorklistItem implements Consumer<WorkList<WorklistItem>> {
-
-      protected final DexClass clazz;
-
-      WorklistItem(DexClass clazz) {
-        this.clazz = clazz;
-      }
-
-      Iterable<DexClass> getImmediateSupertypes() {
-        return IterableUtils.flatMap(
-            clazz.allImmediateSupertypes(),
-            supertype -> {
-              DexClass definition = appView.definitionFor(supertype);
-              return definition != null
-                  ? Collections.singletonList(definition)
-                  : Collections.emptyList();
-            });
-      }
-    }
-
-    class NotProcessedWorklistItem extends WorklistItem {
-
-      NotProcessedWorklistItem(DexClass clazz) {
-        super(clazz);
-      }
-
-      @Override
-      public void accept(WorkList<WorklistItem> worklist) {
-        // Enqueue a worklist item to process the current class after processing its super classes.
-        worklist.addFirstIgnoringSeenSet(new ProcessedWorklistItem(clazz));
-        // Enqueue all superclasses for processing.
-        for (DexClass supertype : getImmediateSupertypes()) {
-          if (!cache.containsKey(supertype)) {
-            worklist.addFirstIgnoringSeenSet(new NotProcessedWorklistItem(supertype));
-          }
-        }
-      }
-    }
-
-    class ProcessedWorklistItem extends WorklistItem {
-
-      ProcessedWorklistItem(DexClass clazz) {
-        super(clazz);
-      }
-
-      @Override
-      public void accept(WorkList<WorklistItem> worklist) {
-        cache.put(
-            clazz,
-            Iterables.any(
-                getImmediateSupertypes(),
-                supertype ->
-                    cache.get(supertype)
-                        || (supertype.isLibraryClass()
-                            && redundantBridgeRemovalOptions
-                                .isPlatformReflectingOnDefaultConstructorInSubclasses(
-                                    supertype.asLibraryClass()))));
-      }
-    }
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemovalOptions.java b/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemovalOptions.java
deleted file mode 100644
index a902764..0000000
--- a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemovalOptions.java
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.optimize.redundantbridgeremoval;
-
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexLibraryClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.SetUtils;
-import java.util.Collections;
-import java.util.Set;
-
-public class RedundantBridgeRemovalOptions {
-
-  private final InternalOptions options;
-
-  private Set<DexType> noConstructorShrinkingHierarchies;
-
-  public RedundantBridgeRemovalOptions(InternalOptions options) {
-    this.options = options;
-  }
-
-  public void clearNoConstructorShrinkingHierarchiesForTesting() {
-    noConstructorShrinkingHierarchies = Collections.emptySet();
-  }
-
-  public RedundantBridgeRemovalOptions ensureInitialized() {
-    if (noConstructorShrinkingHierarchies == null) {
-      DexItemFactory dexItemFactory = options.dexItemFactory();
-      noConstructorShrinkingHierarchies =
-          SetUtils.newIdentityHashSet(
-              dexItemFactory.androidAppFragment, dexItemFactory.androidAppZygotePreload);
-    }
-    return this;
-  }
-
-  public boolean isPlatformReflectingOnDefaultConstructorInSubclasses(DexLibraryClass clazz) {
-    return noConstructorShrinkingHierarchies.contains(clazz.getType());
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index 39d8035..07a5bb2 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -954,14 +954,6 @@
     return staticInitializer != null && isFieldOnlyWrittenInMethod(field, staticInitializer);
   }
 
-  public boolean mayPropagateArgumentsTo(ProgramMethod method) {
-    DexMethod reference = method.getReference();
-    return method.getDefinition().hasCode()
-        && !method.getDefinition().isLibraryMethodOverride().isPossiblyTrue()
-        && !neverReprocess.contains(reference)
-        && !keepInfo.getMethodInfo(method).isPinned(options());
-  }
-
   public boolean mayPropagateValueFor(
       AppView<AppInfoWithLiveness> appView, DexClassAndMember<?, ?> member) {
     assert checkIfObsolete();
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index ca51281..86cdb5a 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -1624,9 +1624,9 @@
 
   static class FieldAccessMetadata {
 
-    private static int DEFERRED_MASK = 1;
-    private static int FROM_METHOD_HANDLE_MASK = 2;
-    private static int FROM_RECORD_METHOD_HANDLE_MASK = 4;
+    private static final int DEFERRED_MASK = 1;
+    private static final int FROM_METHOD_HANDLE_MASK = 2;
+    private static final int FROM_RECORD_METHOD_HANDLE_MASK = 4;
 
     static FieldAccessMetadata DEFAULT = new FieldAccessMetadata(0);
     static FieldAccessMetadata FROM_METHOD_HANDLE =
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 7286734..722a412 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -74,7 +74,6 @@
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.naming.MapVersion;
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagatorEventConsumer;
-import com.android.tools.r8.optimize.redundantbridgeremoval.RedundantBridgeRemovalOptions;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.profile.art.ArtProfileOptions;
@@ -890,8 +889,6 @@
   private final OpenClosedInterfacesOptions openClosedInterfacesOptions =
       new OpenClosedInterfacesOptions();
   private final ProtoShrinkingOptions protoShrinking = new ProtoShrinkingOptions();
-  private final RedundantBridgeRemovalOptions redundantBridgeRemovalOptions =
-      new RedundantBridgeRemovalOptions(this);
   private final KotlinOptimizationOptions kotlinOptimizationOptions =
       new KotlinOptimizationOptions();
   private final ApiModelTestingOptions apiModelTestingOptions = new ApiModelTestingOptions();
@@ -960,10 +957,6 @@
     return cfCodeAnalysisOptions;
   }
 
-  public RedundantBridgeRemovalOptions getRedundantBridgeRemovalOptions() {
-    return redundantBridgeRemovalOptions;
-  }
-
   public DumpInputFlags getDumpInputFlags() {
     return dumpInputFlags;
   }
@@ -1677,6 +1670,7 @@
     private boolean enable =
         !Version.isDevelopmentVersion()
             || System.getProperty("com.android.tools.r8.disableHorizontalClassMerging") == null;
+    private boolean enableInitial = true;
     // TODO(b/205611444): Enable by default.
     private boolean enableClassInitializerDeadlockDetection = true;
     private boolean enableInterfaceMerging =
@@ -1692,6 +1686,10 @@
       enable = false;
     }
 
+    public void disableInitialRoundOfClassMerging() {
+      enableInitial = false;
+    }
+
     public void disableSyntheticMerging() {
       enableSyntheticMerging = false;
     }
@@ -1729,7 +1727,7 @@
         return false;
       }
       if (mode.isInitial()) {
-        return inlinerOptions.enableInlining && isShrinking();
+        return enableInitial && inlinerOptions.enableInlining && isShrinking();
       }
       assert mode.isFinal();
       return true;
@@ -2064,7 +2062,7 @@
       }
     }
 
-    public static int NO_LIMIT = -1;
+    public static final int NO_LIMIT = -1;
 
     public ArgumentPropagatorEventConsumer argumentPropagatorEventConsumer =
         ArgumentPropagatorEventConsumer.emptyConsumer();
@@ -2919,7 +2917,8 @@
   }
 
   public boolean canHaveNonReboundConstructorInvoke() {
-    return isGeneratingDex() && minApiLevel.isGreaterThanOrEqualTo(AndroidApiLevel.L);
+    // TODO(b/246679983): Turned off while diagnosing b/246679983.
+    return false && isGeneratingDex() && minApiLevel.isGreaterThanOrEqualTo(AndroidApiLevel.L);
   }
 
   // b/238399429 Some art 6 vms have issues with multiple monitors in the same method
diff --git a/src/test/java/com/android/tools/r8/TestParameters.java b/src/test/java/com/android/tools/r8/TestParameters.java
index 206a8ab..c22f43e 100644
--- a/src/test/java/com/android/tools/r8/TestParameters.java
+++ b/src/test/java/com/android/tools/r8/TestParameters.java
@@ -58,7 +58,8 @@
    * runtime error.
    */
   public boolean canHaveNonReboundConstructorInvoke() {
-    return isDexRuntime() && getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L);
+    // TODO(b/246679983): Turned off while diagnosing b/246679983.
+    return false && isDexRuntime() && getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L);
   }
 
   public boolean canUseDefaultAndStaticInterfaceMethods() {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingTest.java
new file mode 100644
index 0000000..70f55b4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingTest.java
@@ -0,0 +1,111 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.classmerging.horizontal;
+
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class HorizontalClassMergingAfterConstructorShrinkingTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsStartingAtIncluding(AndroidApiLevel.L)
+        .build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    // TODO(b/276385221): Disabled constructor shrinking for now
+    Assume.assumeTrue(parameters.canHaveNonReboundConstructorInvoke());
+    assertTrue(parameters.canHaveNonReboundConstructorInvoke());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addOptionsModification(
+            options -> options.horizontalClassMergerOptions().disableInitialRoundOfClassMerging())
+        .addHorizontallyMergedClassesInspector(
+            inspector ->
+                inspector.assertIsCompleteMergeGroup(A.class, B.class).assertNoOtherClassesMerged())
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        // TODO(b/276385221): Should not trigger A.<init>.
+        .assertSuccessWithOutputLines("Ouch!", "B");
+  }
+
+  static class Main {
+
+    static {
+      new B().setFieldOnB().printFieldOnB();
+    }
+
+    public static void main(String[] args) {
+      if (System.currentTimeMillis() < 0) {
+        new A().setFieldOnA().printFieldOnA();
+      }
+    }
+  }
+
+  @NeverClassInline
+  static class A {
+
+    Object field;
+
+    A() {
+      System.out.println("Ouch!");
+    }
+
+    @NeverInline
+    A setFieldOnA() {
+      field = "A";
+      return this;
+    }
+
+    @NeverInline
+    void printFieldOnA() {
+      System.out.println(field);
+    }
+  }
+
+  @NeverClassInline
+  static class B {
+
+    Object field;
+
+    // Removed by constructor shrinking.
+    B() {}
+
+    @NeverInline
+    B setFieldOnB() {
+      field = "B";
+      return this;
+    }
+
+    @NeverInline
+    void printFieldOnB() {
+      System.out.println(field);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/SyntheticBridgeSignaturesTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/SyntheticBridgeSignaturesTest.java
index e8d7572..b7bb268 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/SyntheticBridgeSignaturesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/SyntheticBridgeSignaturesTest.java
@@ -13,14 +13,12 @@
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.VerticallyMergedClassesInspector;
 import com.google.common.collect.ImmutableSet;
 import java.util.List;
-import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -49,9 +47,6 @@
 
   @Test
   public void test() throws Throwable {
-    Assume.assumeTrue(
-        "b/273921056",
-        parameters.isCfRuntime() || !parameters.getDexRuntimeVersion().isEqualTo(Version.V14_0_0));
     R8TestCompileResult compileResult =
         testForR8(parameters.getBackend())
             .addInnerClasses(getClass())
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
index 22529e5..3d2be09 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
@@ -223,9 +223,6 @@
   // This test has a cycle in the call graph consisting of the methods A.<init> and B.<init>.
   @Test
   public void testCallGraphCycle() throws Throwable {
-    Assume.assumeTrue(
-        "b/273921056",
-        parameters.isCfRuntime() || !parameters.getDexRuntimeVersion().isEqualTo(Version.V14_0_0));
     String main = "classmerging.CallGraphCycleTest";
     Path[] programFiles =
         new Path[] {
@@ -319,9 +316,6 @@
 
   @Test
   public void testFieldCollision() throws Throwable {
-    Assume.assumeTrue(
-        "b/273921056",
-        parameters.isCfRuntime() || !parameters.getDexRuntimeVersion().isEqualTo(Version.V14_0_0));
     String main = "classmerging.FieldCollisionTest";
     Path[] programFiles =
         new Path[] {
@@ -429,9 +423,6 @@
 
   @Test
   public void testPinnedParameterTypes() throws Throwable {
-    Assume.assumeTrue(
-        "b/273921056",
-        parameters.isCfRuntime() || !parameters.getDexRuntimeVersion().isEqualTo(Version.V14_0_0));
     String main = "classmerging.PinnedParameterTypesTest";
     Path[] programFiles =
         new Path[] {
@@ -457,9 +448,6 @@
 
   @Test
   public void testPinnedArrayParameterTypes() throws Throwable {
-    Assume.assumeTrue(
-        "b/273921056",
-        parameters.isCfRuntime() || !parameters.getDexRuntimeVersion().isEqualTo(Version.V14_0_0));
     String main = "classmerging.PinnedArrayParameterTypesTest";
     Path[] programFiles =
         new Path[] {
@@ -853,9 +841,6 @@
   //   }
   @Test
   public void testSuperCallToMergedClassIsRewritten() throws Throwable {
-    Assume.assumeTrue(
-        "b/273921056",
-        parameters.isCfRuntime() || !parameters.getDexRuntimeVersion().isEqualTo(Version.V14_0_0));
     assumeTrue(parameters.isDexRuntime()); // Due to smali input.
     assumeFalse(parameters.getRuntime().asDex().getVm().getVersion() == Version.V5_1_1);
     assumeFalse(parameters.getRuntime().asDex().getVm().getVersion() == Version.V6_0_1);
diff --git a/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java b/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java
index 6676e2c..265bb19 100644
--- a/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java
+++ b/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java
@@ -36,7 +36,6 @@
 import java.util.jar.JarEntry;
 import java.util.jar.JarInputStream;
 import java.util.stream.Collectors;
-import org.junit.Assume;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.junit.runner.RunWith;
@@ -143,10 +142,6 @@
   public void testContinuousSingleStep() throws Throwable {
     DebugTestConfig config = compiledJars.apply(jarPath);
     assert config != null;
-    Assume.assumeTrue(
-        "b/273921056",
-        config.isCfRuntime()
-            || !config.getRuntime().asDex().getVersion().isEqualTo(Version.V14_0_0));
     runContinuousTest(mainClass, config, MAIN_METHOD_NAME);
   }
 
diff --git a/src/test/java/com/android/tools/r8/debug/LocalsTest.java b/src/test/java/com/android/tools/r8/debug/LocalsTest.java
index a2254be..35178f8 100644
--- a/src/test/java/com/android/tools/r8/debug/LocalsTest.java
+++ b/src/test/java/com/android/tools/r8/debug/LocalsTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.debug;
 
-import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.Command;
 import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.FrameInspector;
 import java.util.ArrayList;
@@ -15,7 +14,6 @@
 import org.apache.harmony.jpda.tests.framework.jdwp.JDWPConstants.Tag;
 import org.apache.harmony.jpda.tests.framework.jdwp.Value;
 import org.junit.Assert;
-import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -279,10 +277,6 @@
 
   @Test
   public void testLocals_MoreThan16() throws Throwable {
-    Assume.assumeTrue(
-        "b/273921056",
-        config.isCfRuntime()
-            || !config.getRuntime().asDex().getVersion().isEqualTo(Version.V14_0_0));
     final int minIndex = 1;
     final int maxIndex = 16;
     Map<String, Value> arrayLocals = new HashMap<>();
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/CallToOtherEnumCompareToMethodNegativeUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/CallToOtherEnumCompareToMethodNegativeUnboxingTest.java
new file mode 100644
index 0000000..f190a34
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/CallToOtherEnumCompareToMethodNegativeUnboxingTest.java
@@ -0,0 +1,73 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.enumunboxing;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.utils.codeinspector.EnumUnboxingInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class CallToOtherEnumCompareToMethodNegativeUnboxingTest extends EnumUnboxingTestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters)
+        .addInnerClasses(getClass())
+        .run(parameters.getRuntime(), Main.class)
+        .applyIf(
+            parameters.isCfRuntime()
+                || parameters.getDexRuntimeVersion().isNewerThanOrEqual(Version.V7_0_0),
+            runResult -> runResult.assertFailureWithErrorThatThrows(ClassCastException.class),
+            runResult -> runResult.assertSuccessWithOutputLines("0"));
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addKeepClassRules(Foo.class)
+        .addEnumUnboxingInspector(EnumUnboxingInspector::assertNoEnumsUnboxed)
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .applyIf(
+            parameters.isCfRuntime()
+                || parameters.getDexRuntimeVersion().isNewerThanOrEqual(Version.V7_0_0),
+            runResult -> runResult.assertFailureWithErrorThatThrows(ClassCastException.class),
+            runResult -> runResult.assertSuccessWithOutputLines("0"));
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      Enum<?> fooEnum = Foo.A;
+      Enum<Bar> fooEnumInDisguise = (Enum<Bar>) fooEnum;
+      System.out.println(fooEnumInDisguise.compareTo(Bar.B));
+    }
+  }
+
+  enum Foo {
+    A
+  }
+
+  enum Bar {
+    B
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/InvalidEqualsEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/InvalidEqualsEnumUnboxingTest.java
new file mode 100644
index 0000000..2ed2d40
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/InvalidEqualsEnumUnboxingTest.java
@@ -0,0 +1,75 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.EnumUnboxingInspector;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class InvalidEqualsEnumUnboxingTest extends EnumUnboxingTestBase {
+
+  private final TestParameters parameters;
+  private final boolean enumValueOptimization;
+  private final EnumKeepRules enumKeepRules;
+
+  @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+  public static List<Object[]> data() {
+    return enumUnboxingTestParameters();
+  }
+
+  public InvalidEqualsEnumUnboxingTest(
+      TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+    this.parameters = parameters;
+    this.enumValueOptimization = enumValueOptimization;
+    this.enumKeepRules = enumKeepRules;
+  }
+
+  @Test
+  public void testEnumUnboxing() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(EnumEquals.class)
+        .addEnumUnboxingInspector(EnumUnboxingInspector::assertNoEnumsUnboxed)
+        .enableNeverClassInliningAnnotations()
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters)
+        .run(parameters.getRuntime(), EnumEquals.class)
+        .assertSuccessWithOutputLines("false", "false");
+  }
+
+  static class EnumEquals {
+
+    @NeverClassInline
+    enum MyEnumEquals {
+      A,
+      B
+    }
+
+    @NeverClassInline
+    enum MyEnumEquals1 {
+      A,
+      B
+    }
+
+    @NeverClassInline
+    enum MyEnumEquals2 {
+      A,
+      B
+    }
+
+    public static void main(String[] args) {
+      Object guineaPig = new Object();
+      System.out.println(MyEnumEquals.A.equals(guineaPig));
+      System.out.println(MyEnumEquals1.A.equals(MyEnumEquals2.A));
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
index 2cdeffd..bb382f8 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
@@ -26,6 +26,7 @@
 import com.android.tools.r8.graph.DirectMappedDexApplication;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
+import com.android.tools.r8.ir.analysis.fieldaccess.readbeforewrite.FieldReadBeforeWriteAnalysis;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.conversion.MethodProcessorEventConsumer;
 import com.android.tools.r8.ir.conversion.MethodProcessorWithWave;
@@ -96,7 +97,11 @@
         method -> {
           IRCode code = method.buildIR(appView);
           fieldAccessAnalysis.recordFieldAccesses(
-              code, BytecodeMetadataProvider.builder(), feedback, new PrimaryMethodProcessorMock());
+              code,
+              BytecodeMetadataProvider.builder(),
+              feedback,
+              FieldReadBeforeWriteAnalysis.trivial(),
+              new PrimaryMethodProcessorMock());
         });
 
     int bitsReadInBitField = feedback.bitsReadPerField.getInt(uniqueFieldByName(clazz, "bitField"));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonNullInstanceFieldPropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonNullInstanceFieldPropagationTest.java
new file mode 100644
index 0000000..972cc79
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/NonNullInstanceFieldPropagationTest.java
@@ -0,0 +1,68 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.membervaluepropagation;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class NonNullInstanceFieldPropagationTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters)
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+              assertEquals(1, inspector.allClasses().size());
+              assertEquals(1, mainClassSubject.allMethods().size());
+              assertEquals(0, mainClassSubject.allFields().size());
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithEmptyOutput();
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      Main p = new Main();
+      p.mThreadChecker.assertOnValidThread();
+    }
+
+    public final ThreadChecker mThreadChecker = new ThreadChecker();
+  }
+
+  static class ThreadChecker {
+    public void assertOnValidThread() {
+      if (System.currentTimeMillis() == 0) {
+        throw new RuntimeException();
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java b/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java
index a7c2581..d843a4c 100644
--- a/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java
+++ b/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java
@@ -72,6 +72,10 @@
     return dexVm.getVersion().isNewerThanOrEqual(Version.V4_4_4);
   }
 
+  static boolean isAndroidK(DexVm dexVm, Tool tool) {
+    return dexVm.getVersion().isEqualTo(Version.V4_4_4);
+  }
+
   static boolean isAndroidLOrAbove(DexVm dexVm, Tool tool) {
     return dexVm.getVersion().isNewerThan(Version.V4_4_4);
   }
@@ -126,11 +130,13 @@
           .put("ClassObjectReference.ReflectedType002Test", RunJdwpTests::isAndroidLOrAbove)
           .put("ClassType.InvokeMethodTest", RunJdwpTests::isAndroidLOrAbove)
           .put("ClassType.InvokeMethod002Test", RunJdwpTests::isAndroidLOrAbove)
-          .put("ClassType.InvokeMethodAfterMultipleThreadSuspensionTest",
+          .put(
+              "ClassType.InvokeMethodAfterMultipleThreadSuspensionTest",
               RunJdwpTests::isAndroidNOrAbove)
           .put("ClassType.InvokeMethodWithSuspensionTest", RunJdwpTests::isAndroidMOrAbove)
           .put("ClassType.NewInstanceTest", RunJdwpTests::isAndroidLOrAbove)
-          .put("ClassType.NewInstanceAfterMultipleThreadSuspensionTest",
+          .put(
+              "ClassType.NewInstanceAfterMultipleThreadSuspensionTest",
               RunJdwpTests::isAndroidNOrAbove)
           .put("ClassType.NewInstanceStringTest", RunJdwpTests::isAndroidOOrAbove)
           .put("ClassType.NewInstanceTagTest", RunJdwpTests::isAndroidNOrAbove)
@@ -164,7 +170,9 @@
           .put("Method.IsObsoleteTest", RunJdwpTests::isAndroidNOrAbove)
           .put("Method.LineTableTest", or(RunJdwpTests::isAndroidKOrAbove, RunJdwpTests::isJava))
           .put("Method.VariableTableTest", RunJdwpTests::isAndroidOOrAbove)
-          .put("Method.VariableTableWithGenericTest", RunJdwpTests::isAndroidOOrAbove)
+          .put(
+              "Method.VariableTableWithGenericTest",
+              or(RunJdwpTests::isAndroidOOrAbove, RunJdwpTests::isAndroidK))
           .put("MultiSession.AttachConnectorTest", RunJdwpTests::isAndroidLOrAbove)
           .put("MultiSession.BreakpointTest", RunJdwpTests::isAndroidLOrAbove)
           .put("MultiSession.ClassObjectIDTest", RunJdwpTests::isAndroidLOrAbove)
@@ -183,7 +191,8 @@
           .put("ObjectReference.GetValues002Test", RunJdwpTests::isAndroidLOrAbove)
           .put("ObjectReference.InvokeMethodDefaultTest", RunJdwpTests::isAndroidNOrAbove)
           .put("ObjectReference.InvokeMethodDefault002Test", RunJdwpTests::isAndroidNOrAbove)
-          .put("ObjectReference.InvokeMethodAfterMultipleThreadSuspensionTest",
+          .put(
+              "ObjectReference.InvokeMethodAfterMultipleThreadSuspensionTest",
               RunJdwpTests::isAndroidNOrAbove)
           .put("ObjectReference.InvokeMethodWithSuspensionTest", RunJdwpTests::isAndroidMOrAbove)
           .put("ObjectReference.IsCollectedTest", RunJdwpTests::isAndroidLOrAbove)
diff --git a/src/test/java/com/android/tools/r8/naming/AdaptResourceFileNamesTest.java b/src/test/java/com/android/tools/r8/naming/AdaptResourceFileNamesTest.java
index 92404f0..8078ed6 100644
--- a/src/test/java/com/android/tools/r8/naming/AdaptResourceFileNamesTest.java
+++ b/src/test/java/com/android/tools/r8/naming/AdaptResourceFileNamesTest.java
@@ -101,6 +101,7 @@
         "  void <init>();",
         "}",
         "-neverclassinline class *",
+        "-nohorizontalclassmerging class adaptresourcefilenames.B",
         "-nohorizontalclassmerging class adaptresourcefilenames.pkg.C",
         "-nohorizontalclassmerging class adaptresourcefilenames.pkg.innerpkg.D");
   }
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java
index c83d81d..2d38860 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java
@@ -75,22 +75,15 @@
   }
 
   private void inspectD8(ArtProfileInspector profileInspector, CodeInspector inspector) {
-    inspect(profileInspector, inspector, false, false);
+    inspect(profileInspector, inspector, false);
   }
 
   private void inspectR8(ArtProfileInspector profileInspector, CodeInspector inspector) {
-    inspect(
-        profileInspector,
-        inspector,
-        parameters.canHaveNonReboundConstructorInvoke(),
-        parameters.isCfRuntime());
+    inspect(profileInspector, inspector, parameters.isCfRuntime());
   }
 
   public void inspect(
-      ArtProfileInspector profileInspector,
-      CodeInspector inspector,
-      boolean canHaveNonReboundConstructorInvoke,
-      boolean canUseLambdas) {
+      ArtProfileInspector profileInspector, CodeInspector inspector, boolean canUseLambdas) {
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
 
@@ -103,26 +96,21 @@
     assertThat(lambdaClassSubject, notIf(isPresent(), canUseLambdas));
 
     MethodSubject lambdaInitializerSubject = lambdaClassSubject.uniqueInstanceInitializer();
-    assertThat(
-        lambdaInitializerSubject,
-        notIf(isPresent(), canHaveNonReboundConstructorInvoke || canUseLambdas));
+    assertThat(lambdaInitializerSubject, notIf(isPresent(), canUseLambdas));
 
     MethodSubject lambdaMainMethodSubject =
         lambdaClassSubject.uniqueMethodThatMatches(FoundMethodSubject::isVirtual);
     assertThat(lambdaMainMethodSubject, notIf(isPresent(), canUseLambdas));
 
     if (canUseLambdas) {
-      profileInspector.assertContainsMethodRule(mainMethodSubject);
+      profileInspector.assertContainsMethodRule(mainMethodSubject).assertContainsNoOtherRules();
     } else {
       profileInspector
           .assertContainsClassRules(lambdaClassSubject)
-          .assertContainsMethodRules(mainMethodSubject, lambdaMainMethodSubject)
-          .applyIf(
-              !canHaveNonReboundConstructorInvoke,
-              i -> i.assertContainsMethodRule(lambdaInitializerSubject));
+          .assertContainsMethodRules(
+              mainMethodSubject, lambdaInitializerSubject, lambdaMainMethodSubject)
+          .assertContainsNoOtherRules();
     }
-
-    profileInspector.assertContainsNoOtherRules();
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java
index 577518d..7d9e9ab 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java
@@ -104,22 +104,17 @@
 
   private void inspectD8(ArtProfileInspector profileInspector, CodeInspector inspector)
       throws Exception {
-    inspect(profileInspector, inspector, false, parameters.canUseNestBasedAccessesWhenDesugaring());
+    inspect(profileInspector, inspector, parameters.canUseNestBasedAccessesWhenDesugaring());
   }
 
   private void inspectR8(ArtProfileInspector profileInspector, CodeInspector inspector)
       throws Exception {
-    inspect(
-        profileInspector,
-        inspector,
-        parameters.canHaveNonReboundConstructorInvoke(),
-        parameters.canUseNestBasedAccesses());
+    inspect(profileInspector, inspector, parameters.canUseNestBasedAccesses());
   }
 
   private void inspect(
       ArtProfileInspector profileInspector,
       CodeInspector inspector,
-      boolean canHaveNonReboundConstructorInvoke,
       boolean canUseNestBasedAccesses)
       throws Exception {
     ClassSubject nestMemberClassSubject = inspector.clazz(NestMember.class);
@@ -133,7 +128,7 @@
         syntheticConstructorArgumentClassSubject, notIf(isPresent(), canUseNestBasedAccesses));
 
     MethodSubject instanceInitializer = nestMemberClassSubject.init();
-    assertThat(instanceInitializer, notIf(isPresent(), canHaveNonReboundConstructorInvoke));
+    assertThat(instanceInitializer, isPresent());
 
     MethodSubject instanceInitializerWithSyntheticArgumentSubject =
         syntheticConstructorArgumentClassSubject.isPresent()
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
index 6d03704..5f1886d 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
@@ -149,7 +149,6 @@
         profileInspector,
         inspector,
         SyntheticItemsTestUtils.syntheticRecordTagClass(),
-        false,
         parameters.canUseNestBasedAccessesWhenDesugaring(),
         parameters.canUseRecordsWhenDesugaring());
   }
@@ -159,7 +158,6 @@
         profileInspector,
         inspector,
         RECORD_REFERENCE,
-        parameters.canHaveNonReboundConstructorInvoke(),
         parameters.canUseNestBasedAccesses(),
         parameters.canUseRecords());
   }
@@ -168,7 +166,6 @@
       ArtProfileInspector profileInspector,
       CodeInspector inspector,
       ClassReference recordClassReference,
-      boolean canHaveNonReboundConstructorInvoke,
       boolean canUseNestBasedAccesses,
       boolean canUseRecords) {
     ClassSubject mainClassSubject = inspector.clazz(MAIN_REFERENCE);
@@ -180,14 +177,11 @@
     ClassSubject recordTagClassSubject = inspector.clazz(recordClassReference);
     assertThat(recordTagClassSubject, notIf(isPresent(), canUseRecords));
     if (!canUseRecords) {
-      assertEquals(
-          canHaveNonReboundConstructorInvoke ? 0 : 1, recordTagClassSubject.allMethods().size());
+      assertEquals(1, recordTagClassSubject.allMethods().size());
     }
 
     MethodSubject recordTagInstanceInitializerSubject = recordTagClassSubject.init();
-    assertThat(
-        recordTagInstanceInitializerSubject,
-        notIf(isPresent(), canHaveNonReboundConstructorInvoke || canUseRecords));
+    assertThat(recordTagInstanceInitializerSubject, notIf(isPresent(), canUseRecords));
 
     ClassSubject personRecordClassSubject = inspector.clazz(PERSON_REFERENCE);
     assertThat(personRecordClassSubject, isPresent());
@@ -296,13 +290,11 @@
                         hashCodeHelperClassSubject,
                         toStringHelperClassSubject)
                     .assertContainsMethodRules(
+                        recordTagInstanceInitializerSubject,
                         equalsHelperMethodSubject,
                         getFieldsAsObjectsMethodSubject,
                         hashCodeHelperMethodSubject,
-                        toStringHelperMethodSubject)
-                    .applyIf(
-                        !canHaveNonReboundConstructorInvoke,
-                        j -> j.assertContainsMethodRule(recordTagInstanceInitializerSubject)))
+                        toStringHelperMethodSubject))
         .assertContainsNoOtherRules();
   }
 }
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java
index ef6b3a3..385f94b 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java
@@ -68,7 +68,6 @@
     public void inspect(
         ArtProfileInspector profileInspector,
         CodeInspector inspector,
-        boolean canHaveNonReboundConstructorInvoke,
         boolean canUseLambdas,
         boolean canAccessModifyLambdaImplementationMethods) {
       ClassSubject mainClassSubject = inspector.clazz(Main.class);
@@ -107,9 +106,7 @@
       assertThat(lambdaClassSubject, notIf(isPresent(), canUseLambdas));
 
       MethodSubject lambdaInitializerSubject = lambdaClassSubject.uniqueInstanceInitializer();
-      assertThat(
-          lambdaInitializerSubject,
-          notIf(isPresent(), canHaveNonReboundConstructorInvoke || canUseLambdas));
+      assertThat(lambdaInitializerSubject, notIf(isPresent(), canUseLambdas));
 
       MethodSubject lambdaMainMethodSubject =
           lambdaClassSubject.uniqueMethodThatMatches(FoundMethodSubject::isVirtual);
@@ -122,9 +119,7 @@
 
       MethodSubject otherLambdaInitializerSubject =
           otherLambdaClassSubject.uniqueInstanceInitializer();
-      assertThat(
-          otherLambdaInitializerSubject,
-          notIf(isPresent(), canHaveNonReboundConstructorInvoke || canUseLambdas));
+      assertThat(otherLambdaInitializerSubject, notIf(isPresent(), canUseLambdas));
 
       MethodSubject otherLambdaMainMethodSubject =
           otherLambdaClassSubject.uniqueMethodThatMatches(FoundMethodSubject::isVirtual);
@@ -154,12 +149,8 @@
             // interface method implementation does not need to be included in the profile.
             profileInspector
                 .assertContainsClassRules(lambdaClassSubject, otherLambdaClassSubject)
-                .assertContainsMethodRules(mainMethodSubject)
-                .applyIf(
-                    !canHaveNonReboundConstructorInvoke,
-                    i ->
-                        i.assertContainsMethodRules(
-                            lambdaInitializerSubject, otherLambdaInitializerSubject))
+                .assertContainsMethodRules(
+                    mainMethodSubject, lambdaInitializerSubject, otherLambdaInitializerSubject)
                 .assertContainsNoOtherRules();
             break;
           case IMPLEMENTATION_METHOD:
@@ -230,16 +221,11 @@
   }
 
   private void inspectD8(ArtProfileInspector profileInspector, CodeInspector inspector) {
-    artProfileInputOutput.inspect(profileInspector, inspector, false, false, true);
+    artProfileInputOutput.inspect(profileInspector, inspector, false, true);
   }
 
   private void inspectR8(ArtProfileInspector profileInspector, CodeInspector inspector) {
-    artProfileInputOutput.inspect(
-        profileInspector,
-        inspector,
-        parameters.canHaveNonReboundConstructorInvoke(),
-        parameters.isCfRuntime(),
-        false);
+    artProfileInputOutput.inspect(profileInspector, inspector, parameters.isCfRuntime(), false);
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java b/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
index 31d557e..babd7a7 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepClassMembersFieldTest.java
@@ -59,7 +59,10 @@
     Bar value = new Bar();
 
     public static void main(String[] args) {
-      new Foo();
+      Foo foo = new Foo();
+      if (System.currentTimeMillis() < 0) {
+        System.out.println(foo);
+      }
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/constructor/ForwardingConstructorUsedFromPlatformShakingOnDexTest.java b/src/test/java/com/android/tools/r8/shaking/constructor/ForwardingConstructorUsedFromPlatformShakingOnDexTest.java
index 7dacf64..534bbb9 100644
--- a/src/test/java/com/android/tools/r8/shaking/constructor/ForwardingConstructorUsedFromPlatformShakingOnDexTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/constructor/ForwardingConstructorUsedFromPlatformShakingOnDexTest.java
@@ -5,21 +5,14 @@
 package com.android.tools.r8.shaking.constructor;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.onlyIf;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assume.assumeFalse;
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.apimodel.ApiModelingTestHelper;
-import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.google.common.collect.ImmutableList;
-import java.util.List;
-import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -29,168 +22,48 @@
 @RunWith(Parameterized.class)
 public class ForwardingConstructorUsedFromPlatformShakingOnDexTest extends TestBase {
 
-  private static final String APPLICATION_INFO_DESCRIPTOR = "Landroid/content/pm/ApplicationInfo;";
-  private static final String FRAGMENT_DESCRIPTOR = "Landroid/app/Fragment;";
-  private static final String ZYGOTE_PRELOAD_DESCRIPTOR = "Landroid/app/ZygotePreload;";
-
-  private static final String EXPECTED_OUTPUT =
-      StringUtils.lines(
-          "Fragment.onCreate()", "MyFragment.onCreate()", "MyZygotePreload.doPreload()");
-
-  private static List<byte[]> transformedProgramClassFileData;
-  private static List<byte[]> transformedLibraryClassFileData;
-
   @Parameter(0)
-  public boolean enableModeling;
-
-  @Parameter(1)
   public TestParameters parameters;
 
-  @Parameters(name = "{1}, modeling: {0}")
-  public static List<Object[]> data() {
-    return buildParameters(
-        BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
-  }
-
-  @BeforeClass
-  public static void setup() throws Exception {
-    transformedProgramClassFileData = getTransformedProgramClasses();
-    transformedLibraryClassFileData = getTransformedLibraryClasses();
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
   @Test
-  public void testRuntime() throws Exception {
-    assumeFalse(enableModeling);
-    testForRuntime(parameters)
-        .addProgramClassFileData(transformedProgramClassFileData)
-        .addProgramClassFileData(transformedLibraryClassFileData)
-        .run(parameters.getRuntime(), Main.class)
-        .assertSuccessWithOutput(EXPECTED_OUTPUT);
-  }
-
-  @Test
-  public void testR8() throws Exception {
+  public void test() throws Exception {
     testForR8(parameters.getBackend())
-        .addProgramClassFileData(transformedProgramClassFileData)
-        .addLibraryClassFileData(transformedLibraryClassFileData)
+        .addProgramClasses(Main.class, MyFragment.class)
+        .addLibraryClasses(Fragment.class)
         .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
         .addKeepMainRule(Main.class)
-        .applyIf(
-            !enableModeling,
-            testBuilder ->
-                testBuilder.addOptionsModification(
-                    options ->
-                        options
-                            .getRedundantBridgeRemovalOptions()
-                            .clearNoConstructorShrinkingHierarchiesForTesting()))
-        // Since Fragment is first defined in API 11.
-        .apply(ApiModelingTestHelper::disableStubbingOfClasses)
         .enableNeverClassInliningAnnotations()
         .setMinApi(parameters)
         .compile()
         .inspect(this::inspect)
-        .addRunClasspathClassFileData(transformedLibraryClassFileData)
+        .addBootClasspathClasses(Fragment.class)
         .run(parameters.getRuntime(), Main.class)
-        .applyIf(
-            enableModeling || !parameters.canHaveNonReboundConstructorInvoke(),
-            runResult -> runResult.assertSuccessWithOutput(EXPECTED_OUTPUT),
-            runResult -> runResult.assertFailureWithErrorThatThrows(NoSuchMethodException.class));
-  }
-
-  private static List<byte[]> getTransformedProgramClasses() throws Exception {
-    return ImmutableList.of(
-        transformer(Main.class)
-            .replaceClassDescriptorInMethodInstructions(
-                descriptor(Fragment.class), FRAGMENT_DESCRIPTOR)
-            .replaceClassDescriptorInMethodInstructions(
-                descriptor(ZygotePreload.class), ZYGOTE_PRELOAD_DESCRIPTOR)
-            .transform(),
-        transformer(MyFragment.class)
-            .replaceClassDescriptorInMethodInstructions(
-                descriptor(Fragment.class), FRAGMENT_DESCRIPTOR)
-            .setSuper(FRAGMENT_DESCRIPTOR)
-            .transform(),
-        transformer(MyZygotePreload.class)
-            .replaceClassDescriptorInMembers(
-                descriptor(ApplicationInfo.class), APPLICATION_INFO_DESCRIPTOR)
-            .setImplementsClassDescriptors(ZYGOTE_PRELOAD_DESCRIPTOR)
-            .transform());
-  }
-
-  private static List<byte[]> getTransformedLibraryClasses() throws Exception {
-    return ImmutableList.of(
-        transformer(ApplicationInfo.class)
-            .setClassDescriptor(APPLICATION_INFO_DESCRIPTOR)
-            .transform(),
-        transformer(Fragment.class).setClassDescriptor(FRAGMENT_DESCRIPTOR).transform(),
-        transformer(Platform.class)
-            .replaceClassDescriptorInMembers(descriptor(Fragment.class), FRAGMENT_DESCRIPTOR)
-            .replaceClassDescriptorInMethodInstructions(
-                descriptor(Fragment.class), FRAGMENT_DESCRIPTOR)
-            .replaceClassDescriptorInMembers(
-                descriptor(ZygotePreload.class), ZYGOTE_PRELOAD_DESCRIPTOR)
-            .replaceClassDescriptorInMethodInstructions(
-                descriptor(ApplicationInfo.class), APPLICATION_INFO_DESCRIPTOR)
-            .replaceClassDescriptorInMethodInstructions(
-                descriptor(ZygotePreload.class), ZYGOTE_PRELOAD_DESCRIPTOR)
-            .transform(),
-        transformer(ZygotePreload.class)
-            .replaceClassDescriptorInMembers(
-                descriptor(ApplicationInfo.class), APPLICATION_INFO_DESCRIPTOR)
-            .setClassDescriptor(ZYGOTE_PRELOAD_DESCRIPTOR)
-            .transform());
+        .assertSuccessWithOutputLines("Instantiating");
   }
 
   private void inspect(CodeInspector inspector) {
     ClassSubject myFragmentClassSubject = inspector.clazz(MyFragment.class);
     assertThat(myFragmentClassSubject, isPresent());
-    assertThat(
-        myFragmentClassSubject.init(),
-        onlyIf(enableModeling || !parameters.canHaveNonReboundConstructorInvoke(), isPresent()));
-
-    ClassSubject myZygotePreloadClassSubject = inspector.clazz(MyZygotePreload.class);
-    assertThat(myZygotePreloadClassSubject, isPresent());
-    assertThat(
-        myZygotePreloadClassSubject.init(),
-        onlyIf(enableModeling || !parameters.canHaveNonReboundConstructorInvoke(), isPresent()));
+    assertThat(myFragmentClassSubject.init(), isPresent());
   }
 
-  // Library classes.
-
-  public abstract static class ApplicationInfo {}
-
   public abstract static class Fragment {
 
-    public void onCreate() {
-      System.out.println("Fragment.onCreate()");
+    public Fragment newInstance() throws Exception {
+      System.out.println("Instantiating");
+      return getClass().getDeclaredConstructor().newInstance();
     }
   }
 
-  public interface ZygotePreload {
-
-    void doPreload(ApplicationInfo applicationInfo);
-  }
-
-  public static class Platform {
-
-    public static void accept(Fragment fragment) throws Exception {
-      Fragment newFragment = fragment.getClass().getDeclaredConstructor().newInstance();
-      newFragment.onCreate();
-    }
-
-    public static void accept(ZygotePreload runnable) throws Exception {
-      ZygotePreload newZygotePreload = runnable.getClass().getDeclaredConstructor().newInstance();
-      newZygotePreload.doPreload(null);
-    }
-  }
-
-  // Program classes.
-
   public static class Main {
 
     public static void main(String[] args) throws Exception {
-      Platform.accept(new MyFragment());
-      Platform.accept(new MyZygotePreload());
+      new MyFragment().newInstance();
     }
   }
 
@@ -198,21 +71,5 @@
   public static class MyFragment extends Fragment {
 
     public MyFragment() {}
-
-    @Override
-    public void onCreate() {
-      super.onCreate();
-      System.out.println("MyFragment.onCreate()");
-    }
-  }
-
-  public static class MyZygotePreload implements ZygotePreload {
-
-    public MyZygotePreload() {}
-
-    @Override
-    public void doPreload(ApplicationInfo applicationInfo) {
-      System.out.println("MyZygotePreload.doPreload()");
-    }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java
index c075406..3cbb42d 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java
@@ -22,6 +22,11 @@
     this.unboxedEnums = unboxedEnums;
   }
 
+  public EnumUnboxingInspector assertNoEnumsUnboxed() {
+    assertTrue(unboxedEnums.isEmpty());
+    return this;
+  }
+
   public EnumUnboxingInspector assertUnboxed(String typeName) {
     assertTrue(
         unboxedEnums.isUnboxedEnum(
diff --git a/third_party/jdwp-tests.tar.gz.sha1 b/third_party/jdwp-tests.tar.gz.sha1
index d3eeb60..0da9451 100644
--- a/third_party/jdwp-tests.tar.gz.sha1
+++ b/third_party/jdwp-tests.tar.gz.sha1
@@ -1 +1 @@
-db49b6093abaa165e422734a755cdcecf36c03db
\ No newline at end of file
+86eeaa4cfe57d20b03af02310acac89892db3bd3
\ No newline at end of file
diff --git a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1 b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
index c845f51..f548507 100644
--- a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
+++ b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
@@ -1 +1 @@
-e01c698069f2b52bd80864b70adfeaf0c27e5f4f
\ No newline at end of file
+99369b53116d6ab88384f57930b203cd7de55c0a
\ No newline at end of file