diff --git a/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java b/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
index a081d34..4869bc5 100644
--- a/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
+++ b/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
@@ -188,7 +188,7 @@
     while (iterator.hasNext()) {
       result = result.join(toTypeElement(iterator.next()), appView);
     }
-    // All types are reference types so the join is either a class or an array.
+    // All types are reference types so the join is either a class, an interface or an array.
     if (result.isClassType()) {
       ClassTypeElement classType = result.asClassType();
       if (classType.getClassType().isIdenticalTo(appView.dexItemFactory().objectType)
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfConstDynamic.java b/src/main/java/com/android/tools/r8/cf/code/CfConstDynamic.java
index c16eae4..9936ef6 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfConstDynamic.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfConstDynamic.java
@@ -31,9 +31,10 @@
 import com.android.tools.r8.optimize.interfaces.analysis.CfFrameState;
 import com.android.tools.r8.utils.structural.CompareToVisitor;
 import com.android.tools.r8.utils.structural.HashingVisitor;
-import java.util.ArrayList;
+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import java.util.List;
 import java.util.ListIterator;
+import java.util.function.Supplier;
 import org.objectweb.asm.ConstantDynamic;
 import org.objectweb.asm.MethodVisitor;
 
@@ -41,22 +42,8 @@
 
   private final ConstantDynamicReference reference;
 
-  public CfConstDynamic(
-      int symbolicReferenceId,
-      DexString name,
-      DexType type,
-      DexMethodHandle bootstrapMethod,
-      List<DexValue> bootstrapMethodArguments) {
-    assert symbolicReferenceId >= 0;
-    assert name != null;
-    assert type != null;
-    assert bootstrapMethod != null;
-    assert bootstrapMethodArguments != null;
-    assert bootstrapMethodArguments.isEmpty();
-
-    reference =
-        new ConstantDynamicReference(
-            symbolicReferenceId, name, type, bootstrapMethod, bootstrapMethodArguments);
+  public CfConstDynamic(ConstantDynamicReference constantDynamicReference) {
+    reference = constantDynamicReference;
   }
 
   @Override
@@ -86,27 +73,14 @@
   }
 
   public static CfConstDynamic fromAsmConstantDynamic(
-      int symbolicReferenceId,
       ConstantDynamic insn,
       JarApplicationReader application,
-      DexType clazz) {
-    String constantName = insn.getName();
-    String constantDescriptor = insn.getDescriptor();
-    DexMethodHandle bootstrapMethodHandle =
-        DexMethodHandle.fromAsmHandle(insn.getBootstrapMethod(), application, clazz);
-    int argumentCount = insn.getBootstrapMethodArgumentCount();
-    List<DexValue> bootstrapMethodArguments = new ArrayList<>(argumentCount);
-    for (int i = 0; i < argumentCount; i++) {
-      Object argument = insn.getBootstrapMethodArgument(i);
-      DexValue dexValue = DexValue.fromAsmBootstrapArgument(argument, application, clazz);
-      bootstrapMethodArguments.add(dexValue);
-    }
+      DexType clazz,
+      Supplier<Reference2IntMap<ConstantDynamic>> constantDynamicSymbolicReferencesSupplier) {
+    assert insn.getBootstrapMethodArgumentCount() == 0;
     return new CfConstDynamic(
-        symbolicReferenceId,
-        application.getString(constantName),
-        application.getTypeFromDescriptor(constantDescriptor),
-        bootstrapMethodHandle,
-        bootstrapMethodArguments);
+        ConstantDynamicReference.fromAsmConstantDynamic(
+            insn, application, clazz, constantDynamicSymbolicReferencesSupplier));
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfFrameVerifier.java b/src/main/java/com/android/tools/r8/cf/code/CfFrameVerifier.java
index d1b3d3e..86ea3c0 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfFrameVerifier.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfFrameVerifier.java
@@ -248,29 +248,32 @@
     // safe assuming an incoming type state T. The type state T is derived from ExcStackFrame
     // by replacing the operand stack with a stack whose sole element is the handler's
     // exception class.
-    for (CfLabel target : tryCatchRange.getTargets()) {
+    List<CfLabel> targets = tryCatchRange.getTargets();
+    for (int i = 0; i < targets.size(); i++) {
+      CfLabel target = targets.get(i);
+      DexType guard = tryCatchRange.guards.get(i);
       CfFrame destinationFrame = labelToFrameMap.get(target);
       if (destinationFrame == null) {
         return CfCodeStackMapValidatingException.invalidTryCatchRange(
             method, tryCatchRange, "No frame for target catch range target", appView);
       }
-      // From the spec: the handler's exception class is assignable to the class Throwable.
-      for (DexType guard : tryCatchRange.guards) {
-        if (!config.getAssignability().isAssignable(guard, factory.throwableType)) {
-          return CfCodeStackMapValidatingException.invalidTryCatchRange(
-              method,
-              tryCatchRange,
-              "Could not assign " + guard.getTypeName() + " to java.lang.Throwable",
-              appView);
-        }
-        Deque<PreciseFrameType> sourceStack =
-            ImmutableDeque.of(FrameType.initializedNonNullReference(guard));
-        AssignabilityResult assignabilityResult =
-            config.getAssignability().isStackAssignable(sourceStack, destinationFrame.getStack());
-        if (assignabilityResult.isFailed()) {
-          return CfCodeStackMapValidatingException.invalidTryCatchRange(
-              method, tryCatchRange, assignabilityResult.asFailed().getMessage(), appView);
-        }
+      Deque<PreciseFrameType> sourceStack =
+          ImmutableDeque.of(FrameType.initializedNonNullReference(guard));
+      AssignabilityResult assignabilityResult =
+          config.getAssignability().isStackAssignable(sourceStack, destinationFrame.getStack());
+      if (assignabilityResult.isFailed()) {
+        return CfCodeStackMapValidatingException.invalidTryCatchRange(
+            method, tryCatchRange, assignabilityResult.asFailed().getMessage(), appView);
+      }
+    }
+    // From the spec: the handler's exception class is assignable to the class Throwable.
+    for (DexType guard : tryCatchRange.guards) {
+      if (!config.getAssignability().isAssignable(guard, factory.throwableType)) {
+        return CfCodeStackMapValidatingException.invalidTryCatchRange(
+            method,
+            tryCatchRange,
+            "Could not assign " + guard.getTypeName() + " to java.lang.Throwable",
+            appView);
       }
     }
     return null;
diff --git a/src/main/java/com/android/tools/r8/graph/DexCallSite.java b/src/main/java/com/android/tools/r8/graph/DexCallSite.java
index c09e32a..2cf72f1 100644
--- a/src/main/java/com/android/tools/r8/graph/DexCallSite.java
+++ b/src/main/java/com/android/tools/r8/graph/DexCallSite.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.utils.structural.StructuralMapping;
 import com.android.tools.r8.utils.structural.StructuralSpecification;
 import com.google.common.io.BaseEncoding;
+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.ObjectOutputStream;
@@ -24,9 +25,10 @@
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Supplier;
+import org.objectweb.asm.ConstantDynamic;
 import org.objectweb.asm.Handle;
 import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.InvokeDynamicInsnNode;
 
 public final class DexCallSite extends IndexedDexItem
     implements StructuralItem<DexCallSite>, LirConstant {
@@ -76,17 +78,13 @@
   }
 
   public static DexCallSite fromAsmInvokeDynamic(
-      InvokeDynamicInsnNode insn, JarApplicationReader application, DexType clazz) {
-    return fromAsmInvokeDynamic(application, clazz, insn.name, insn.desc, insn.bsm, insn.bsmArgs);
-  }
-
-  public static DexCallSite fromAsmInvokeDynamic(
       JarApplicationReader application,
       DexType clazz,
       String name,
       String desc,
       Handle bsmHandle,
-      Object[] bsmArgs) {
+      Object[] bsmArgs,
+      Supplier<Reference2IntMap<ConstantDynamic>> constantDynamicSymbolicReferencesSupplier) {
     // Bootstrap method
     if (bsmHandle.getTag() != Opcodes.H_INVOKESTATIC
         && bsmHandle.getTag() != Opcodes.H_NEWINVOKESPECIAL) {
@@ -99,7 +97,9 @@
     // Decode static bootstrap arguments
     List<DexValue> bootstrapArgs = new ArrayList<>();
     for (Object arg : bsmArgs) {
-      bootstrapArgs.add(DexValue.fromAsmBootstrapArgument(arg, application, clazz));
+      bootstrapArgs.add(
+          DexValue.fromAsmBootstrapArgument(
+              arg, application, clazz, constantDynamicSymbolicReferencesSupplier));
     }
 
     // Construct call site
diff --git a/src/main/java/com/android/tools/r8/graph/DexValue.java b/src/main/java/com/android/tools/r8/graph/DexValue.java
index 38b5634..f4f7a60 100644
--- a/src/main/java/com/android/tools/r8/graph/DexValue.java
+++ b/src/main/java/com/android/tools/r8/graph/DexValue.java
@@ -9,6 +9,7 @@
 import com.android.tools.r8.dex.FileWriter;
 import com.android.tools.r8.dex.IndexedItemCollection;
 import com.android.tools.r8.dex.MixedSectionCollection;
+import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
@@ -19,6 +20,7 @@
 import com.android.tools.r8.ir.code.DexItemBasedConstString;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.desugar.constantdynamic.ConstantDynamicReference;
 import com.android.tools.r8.naming.dexitembasedstring.NameComputationInfo;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.EncodedValueUtils;
@@ -26,8 +28,11 @@
 import com.android.tools.r8.utils.structural.HashingVisitor;
 import com.android.tools.r8.utils.structural.StructuralItem;
 import com.android.tools.r8.utils.structural.StructuralMapping;
+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import java.util.Arrays;
 import java.util.function.Consumer;
+import java.util.function.Supplier;
+import org.objectweb.asm.ConstantDynamic;
 import org.objectweb.asm.Handle;
 import org.objectweb.asm.Type;
 
@@ -51,7 +56,8 @@
     ARRAY(0x1c),
     ANNOTATION(0x1d),
     NULL(0x1e),
-    BOOLEAN(0x1f);
+    BOOLEAN(0x1f),
+    CONST_DYNAMIC(-1);
 
     public static DexValueKind fromId(int id) {
       switch (id) {
@@ -91,6 +97,8 @@
           return NULL;
         case 0x1f:
           return BOOLEAN;
+        case -1:
+          return CONST_DYNAMIC;
         default:
           throw new Unreachable();
       }
@@ -162,6 +170,14 @@
     return null;
   }
 
+  public boolean isDexValueConstDynamic() {
+    return false;
+  }
+
+  public DexValueConstDynamic asDexValueConstDynamic() {
+    return null;
+  }
+
   public boolean isDexValueMethodType() {
     return false;
   }
@@ -313,7 +329,10 @@
   public abstract AbstractValue toAbstractValue(AbstractValueFactory factory);
 
   public static DexValue fromAsmBootstrapArgument(
-      Object value, JarApplicationReader application, DexType clazz) {
+      Object value,
+      JarApplicationReader application,
+      DexType clazz,
+      Supplier<Reference2IntMap<ConstantDynamic>> constantDynamicSymbolicReferencesSupplier) {
     if (value instanceof Integer) {
       return DexValue.DexValueInt.create((Integer) value);
     } else if (value instanceof Long) {
@@ -334,12 +353,23 @@
         case Type.METHOD:
           return new DexValue.DexValueMethodType(
               application.getProto(((Type) value).getDescriptor()));
+        case Type.ARRAY:
+          DexType arrayType = application.getTypeFromDescriptor(((Type) value).getDescriptor());
+          assert arrayType.isArrayType();
+          return new DexValue.DexValueType(arrayType);
         default:
           throw new Unreachable("Type sort is not supported: " + type.getSort());
       }
     } else if (value instanceof Handle) {
       return new DexValue.DexValueMethodHandle(
           DexMethodHandle.fromAsmHandle((Handle) value, application, clazz));
+    } else if (value instanceof ConstantDynamic) {
+      return new DexValue.DexValueConstDynamic(
+          ConstantDynamicReference.fromAsmConstantDynamic(
+              (ConstantDynamic) value,
+              application,
+              clazz,
+              constantDynamicSymbolicReferencesSupplier));
     } else {
       throw new Unreachable(
           "Unsupported bootstrap static argument of type " + value.getClass().getSimpleName());
@@ -2054,4 +2084,96 @@
       return UnknownValue.getInstance();
     }
   }
+
+  public static class DexValueConstDynamic extends DexValue {
+
+    private final ConstantDynamicReference value;
+
+    public DexValueConstDynamic(ConstantDynamicReference value) {
+      this.value = value;
+    }
+
+    @Override
+    public boolean isDexValueConstDynamic() {
+      return true;
+    }
+
+    @Override
+    public DexValueConstDynamic asDexValueConstDynamic() {
+      return this;
+    }
+
+    @Override
+    int internalAcceptCompareTo(DexValue other, CompareToVisitor visitor) {
+      return value.acceptCompareTo(other.asDexValueConstDynamic().value, visitor);
+    }
+
+    @Override
+    void internalAcceptHashing(HashingVisitor visitor) {
+      value.acceptHashing(visitor);
+    }
+
+    @Override
+    public DexValueKind getValueKind() {
+      return DexValueKind.CONST_DYNAMIC;
+    }
+
+    private CompilationError throwCannotConvertToDex() {
+      throw new CompilationError("DexValueConstDynamic should be desugared");
+    }
+
+    @Override
+    public void collectIndexedItems(AppView<?> appView, IndexedItemCollection indexedItems) {
+      throw throwCannotConvertToDex();
+    }
+
+    @Override
+    public void sort() {
+      // Intentionally empty.
+    }
+
+    @Override
+    public void writeTo(DexOutputBuffer dest, ObjectToOffsetMapping mapping) {
+      throw throwCannotConvertToDex();
+    }
+
+    @Override
+    public int hashCode() {
+      return 7 * value.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (other instanceof DexValueConstDynamic) {
+        DexValueConstDynamic otherCstDynamic = (DexValueConstDynamic) other;
+        return otherCstDynamic.value.equals(value);
+      }
+      return false;
+    }
+
+    @Override
+    public String toString() {
+      return "Item " + getValueKind() + " " + value;
+    }
+
+    @Override
+    public DexType getType(DexItemFactory factory) {
+      return null;
+    }
+
+    @Override
+    public Object getBoxedValue() {
+      throw new Unreachable("No boxed value for DexValueConstDynamic");
+    }
+
+    @Override
+    public Object asAsmEncodedObject() {
+      throw new Unreachable("No ASM conversion for DexValueConstDynamic");
+    }
+
+    @Override
+    public AbstractValue toAbstractValue(AbstractValueFactory factory) {
+      return UnknownValue.getInstance();
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
index 2ad9817..c41f8df 100644
--- a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
@@ -921,7 +921,14 @@
     @Override
     public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
       DexCallSite callSite =
-          DexCallSite.fromAsmInvokeDynamic(application, method.holder, name, desc, bsm, bsmArgs);
+          DexCallSite.fromAsmInvokeDynamic(
+              application,
+              method.holder,
+              name,
+              desc,
+              bsm,
+              bsmArgs,
+              constantDynamicSymbolicReferencesSupplier);
       addInstruction(new CfInvokeDynamic(callSite));
     }
 
@@ -1027,16 +1034,12 @@
         // instance from ASM, even when they are equal (i.e. all their components are equal). See
         // ConstantDynamicMultipleConstantsWithDifferentSymbolicReferenceUsingSameBSMAndArgumentsTest
         // for an example.
-        Reference2IntMap<ConstantDynamic> constantDynamicSymbolicReferences =
-            constantDynamicSymbolicReferencesSupplier.get();
-        int symbolicReferenceId = constantDynamicSymbolicReferences.getOrDefault(cst, -1);
-        if (symbolicReferenceId == -1) {
-          symbolicReferenceId = constantDynamicSymbolicReferences.size();
-          constantDynamicSymbolicReferences.put((ConstantDynamic) cst, symbolicReferenceId);
-        }
         addInstruction(
             CfConstDynamic.fromAsmConstantDynamic(
-                symbolicReferenceId, (ConstantDynamic) cst, application, method.holder));
+                (ConstantDynamic) cst,
+                application,
+                method.holder,
+                constantDynamicSymbolicReferencesSupplier));
       } else {
         throw new CompilationError("Unsupported constant: " + cst.toString());
       }
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/ResourceAccessAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/ResourceAccessAnalysis.java
index f70748d..fa4979c 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/ResourceAccessAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/ResourceAccessAnalysis.java
@@ -25,7 +25,6 @@
 import com.android.tools.r8.ir.conversion.MethodConversionOptions;
 import com.android.tools.r8.shaking.Enqueuer;
 import com.android.tools.r8.shaking.EnqueuerWorklist;
-import com.android.tools.r8.utils.DescriptorUtils;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntList;
 import java.util.IdentityHashMap;
@@ -36,16 +35,19 @@
   private final R8ResourceShrinkerState resourceShrinkerState;
   private final Map<DexType, RClassFieldToValueStore> fieldToValueMapping = new IdentityHashMap<>();
   private final AppView<? extends AppInfoWithClassHierarchy> appView;
+  private final Enqueuer enqueuer;
 
-  private ResourceAccessAnalysis(AppView<? extends AppInfoWithClassHierarchy> appView) {
+  private ResourceAccessAnalysis(
+      AppView<? extends AppInfoWithClassHierarchy> appView, Enqueuer enqueuer) {
     this.appView = appView;
     this.resourceShrinkerState = appView.getResourceShrinkerState();
+    this.enqueuer = enqueuer;
   }
 
   public static void register(
       AppView<? extends AppInfoWithClassHierarchy> appView, Enqueuer enqueuer) {
     if (enabled(appView, enqueuer)) {
-      enqueuer.registerFieldAccessAnalysis(new ResourceAccessAnalysis(appView));
+      enqueuer.registerFieldAccessAnalysis(new ResourceAccessAnalysis(appView, enqueuer));
     }
   }
 
@@ -73,7 +75,7 @@
     if (resolvedField == null) {
       return;
     }
-    if (getMaybeCachedIsRClass(resolvedField.getHolder())) {
+    if (enqueuer.isRClass(resolvedField.getHolder())) {
       DexType holderType = resolvedField.getHolderType();
       if (!fieldToValueMapping.containsKey(holderType)) {
         populateRClassValues(resolvedField);
@@ -189,18 +191,6 @@
     }
   }
 
-  private final Map<DexProgramClass, Boolean> cachedClassLookups = new IdentityHashMap<>();
-
-  private boolean getMaybeCachedIsRClass(DexProgramClass holder) {
-    Boolean result = cachedClassLookups.get(holder);
-    if (result != null) {
-      return result;
-    }
-    boolean isRClass = DescriptorUtils.isRClassDescriptor(holder.getType().toDescriptorString());
-    cachedClassLookups.put(holder, isRClass);
-    return isRClass;
-  }
-
   private static class RClassFieldToValueStore {
     private Map<DexField, IntList> valueMapping;
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicReference.java b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicReference.java
index 478e4cf..2f27eab 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicReference.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/constantdynamic/ConstantDynamicReference.java
@@ -7,12 +7,17 @@
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.graph.JarApplicationReader;
 import com.android.tools.r8.utils.structural.Equatable;
 import com.android.tools.r8.utils.structural.StructuralItem;
 import com.android.tools.r8.utils.structural.StructuralMapping;
 import com.android.tools.r8.utils.structural.StructuralSpecification;
+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Supplier;
+import org.objectweb.asm.ConstantDynamic;
 
 public class ConstantDynamicReference implements StructuralItem<ConstantDynamicReference> {
   private final int symbolicReferenceId;
@@ -25,13 +30,53 @@
     spec.withInt(c -> c.symbolicReferenceId);
   }
 
-  public ConstantDynamicReference(
+  public static ConstantDynamicReference fromAsmConstantDynamic(
+      ConstantDynamic cst,
+      JarApplicationReader application,
+      DexType clazz,
+      Supplier<Reference2IntMap<ConstantDynamic>> constantDynamicSymbolicReferencesSupplier) {
+
+    Reference2IntMap<ConstantDynamic> constantDynamicSymbolicReferences =
+        constantDynamicSymbolicReferencesSupplier.get();
+    int symbolicReferenceId = constantDynamicSymbolicReferences.getOrDefault(cst, -1);
+    if (symbolicReferenceId == -1) {
+      symbolicReferenceId = constantDynamicSymbolicReferences.size();
+      constantDynamicSymbolicReferences.put(cst, symbolicReferenceId);
+    }
+
+    String constantName = cst.getName();
+    String constantDescriptor = cst.getDescriptor();
+    DexMethodHandle bootstrapMethodHandle =
+        DexMethodHandle.fromAsmHandle(cst.getBootstrapMethod(), application, clazz);
+    int argumentCount = cst.getBootstrapMethodArgumentCount();
+    List<DexValue> bootstrapMethodArguments1 = new ArrayList<>(argumentCount);
+    for (int i = 0; i < argumentCount; i++) {
+      Object argument = cst.getBootstrapMethodArgument(i);
+      DexValue dexValue =
+          DexValue.fromAsmBootstrapArgument(
+              argument, application, clazz, constantDynamicSymbolicReferencesSupplier);
+      bootstrapMethodArguments1.add(dexValue);
+    }
+
+    return new ConstantDynamicReference(
+        symbolicReferenceId,
+        application.getString(constantName),
+        application.getTypeFromDescriptor(constantDescriptor),
+        bootstrapMethodHandle,
+        bootstrapMethodArguments1);
+  }
+
+  private ConstantDynamicReference(
       int symbolicReferenceId,
       DexString name,
       DexType type,
       DexMethodHandle bootstrapMethod,
       List<DexValue> bootstrapMethodArguments) {
-    assert bootstrapMethodArguments.isEmpty();
+    assert symbolicReferenceId >= 0;
+    assert name != null;
+    assert type != null;
+    assert bootstrapMethod != null;
+    assert bootstrapMethodArguments != null;
     this.symbolicReferenceId = symbolicReferenceId;
     this.name = name;
     this.type = type;
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
index 1f95169..7ee35d8 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
@@ -774,6 +774,10 @@
       return resolvedMethod.getReference();
     }
 
+    if (isMonomorphicVirtualMethod(resolvedMethod)) {
+      return resolvedMethod.getReference();
+    }
+
     if (invoke.isInvokeInterface()) {
       assert !isMonomorphicVirtualMethod(resolvedMethod);
       return getVirtualRootMethod(resolvedMethod);
@@ -781,10 +785,6 @@
 
     assert invoke.isInvokeSuper() || invoke.isInvokeVirtual();
 
-    if (isMonomorphicVirtualMethod(resolvedMethod)) {
-      return resolvedMethod.getReference();
-    }
-
     DexMethod rootMethod = getVirtualRootMethod(resolvedMethod);
     assert rootMethod != null;
     assert !isMonomorphicVirtualMethod(resolvedMethod)
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysisBase.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysisBase.java
index b5f1374..0165f8e 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysisBase.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysisBase.java
@@ -3,9 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.optimize.argumentpropagation.codescanner;
 
-import static com.android.tools.r8.utils.MapUtils.ignoreKey;
-
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
@@ -14,8 +13,13 @@
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.collections.DexMethodSignatureMap;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
+import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.IdentityHashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.Consumer;
 
 /**
@@ -27,58 +31,86 @@
   protected static class VirtualRootMethod {
 
     private final VirtualRootMethod parent;
-    private final ProgramMethod root;
-    private final ProgramMethodSet overrides = ProgramMethodSet.create();
+    private final ProgramMethod method;
+
+    private Set<VirtualRootMethod> overrides = Collections.emptySet();
+    private List<VirtualRootMethod> siblings = Collections.emptyList();
+    private boolean mayDispatchOutsideProgram = false;
 
     VirtualRootMethod(ProgramMethod root) {
       this(root, null);
     }
 
-    VirtualRootMethod(ProgramMethod root, VirtualRootMethod parent) {
-      assert root != null;
+    VirtualRootMethod(ProgramMethod method, VirtualRootMethod parent) {
+      assert method != null;
       this.parent = parent;
-      this.root = root;
+      this.method = method;
     }
 
-    void addOverride(ProgramMethod override) {
-      assert override.getDefinition() != root.getDefinition();
-      assert override.getMethodSignature().equals(root.getMethodSignature());
+    void addOverride(VirtualRootMethod override) {
+      assert !override.getMethod().isStructurallyEqualTo(method);
+      assert override.getMethod().getReference().match(method.getReference());
+      if (overrides.isEmpty()) {
+        overrides = Sets.newIdentityHashSet();
+      }
       overrides.add(override);
       if (hasParent()) {
         getParent().addOverride(override);
       }
     }
 
+    void addSibling(VirtualRootMethod sibling) {
+      if (siblings.isEmpty()) {
+        siblings = new ArrayList<>(1);
+      }
+      siblings.add(sibling);
+    }
+
+    void setMayDispatchOutsideProgram() {
+      mayDispatchOutsideProgram = true;
+    }
+
     boolean hasParent() {
       return parent != null;
     }
 
+    boolean hasSiblings() {
+      return !siblings.isEmpty();
+    }
+
     VirtualRootMethod getParent() {
       return parent;
     }
 
-    ProgramMethod getRoot() {
-      return root;
+    VirtualRootMethod getRoot() {
+      return hasParent() ? getParent().getRoot() : this;
     }
 
-    ProgramMethod getSingleNonAbstractMethod() {
-      ProgramMethod singleNonAbstractMethod = root.getAccessFlags().isAbstract() ? null : root;
-      for (ProgramMethod override : overrides) {
-        if (!override.getAccessFlags().isAbstract()) {
-          if (singleNonAbstractMethod != null) {
+    ProgramMethod getMethod() {
+      return method;
+    }
+
+    VirtualRootMethod getSingleDispatchTarget() {
+      assert !hasParent();
+      if (isMayDispatchOutsideProgramSet()) {
+        return null;
+      }
+      VirtualRootMethod singleDispatchTarget = isAbstract() ? null : this;
+      for (VirtualRootMethod override : overrides) {
+        if (!override.isAbstract()) {
+          if (singleDispatchTarget != null) {
             // Not a single non-abstract method.
             return null;
           }
-          singleNonAbstractMethod = override;
+          singleDispatchTarget = override;
         }
       }
-      assert singleNonAbstractMethod == null
-          || !singleNonAbstractMethod.getAccessFlags().isAbstract();
-      return singleNonAbstractMethod;
+      assert singleDispatchTarget == null || !singleDispatchTarget.isAbstract();
+      return singleDispatchTarget;
     }
 
-    void forEach(Consumer<ProgramMethod> consumer) {
-      consumer.accept(root);
+    void forEach(Consumer<VirtualRootMethod> consumer) {
+      consumer.accept(this);
       overrides.forEach(consumer);
     }
 
@@ -86,10 +118,12 @@
       return !overrides.isEmpty();
     }
 
-    boolean isInterfaceMethodWithSiblings() {
-      // TODO(b/190154391): Conservatively returns true for all interface methods, but should only
-      //  return true for those with siblings.
-      return root.getHolder().isInterface();
+    boolean isAbstract() {
+      return method.getAccessFlags().isAbstract();
+    }
+
+    boolean isMayDispatchOutsideProgramSet() {
+      return mayDispatchOutsideProgram;
     }
   }
 
@@ -122,18 +156,48 @@
           DexMethodSignatureMap<VirtualRootMethod> virtualRootMethodsForSuperclass =
               virtualRootMethodsPerClass.get(superclass);
           virtualRootMethodsForSuperclass.forEach(
-              (signature, info) ->
-                  virtualRootMethodsForClass.computeIfAbsent(
-                      signature, ignoreKey(() -> new VirtualRootMethod(info.getRoot(), info))));
+              (signature, info) -> {
+                virtualRootMethodsForClass.compute(
+                    signature,
+                    (ignore, existing) -> {
+                      if (existing == null || existing == info) {
+                        return info;
+                      } else {
+                        // We iterate the immediate supertypes in-order using
+                        // forEachImmediateProgramSuperClass. Therefore, the current method is
+                        // guaranteed to be an interface method when existing != null.
+                        assert info.getMethod().getHolder().isInterface();
+                        if (!existing.getMethod().getHolder().isInterface()) {
+                          existing.addSibling(info);
+                          info.addOverride(existing);
+                        }
+                        return existing;
+                      }
+                    });
+                if (!clazz.isInterface() && superclass.isInterface()) {
+                  DexClassAndMethod resolvedMethod =
+                      appView.appInfo().resolveMethodOnClass(clazz, signature).getResolutionPair();
+                  if (resolvedMethod != null
+                      && !resolvedMethod.isProgramMethod()
+                      && !resolvedMethod.getAccessFlags().isAbstract()) {
+                    info.setMayDispatchOutsideProgram();
+                  }
+                }
+              });
         });
     clazz.forEachProgramVirtualMethod(
-        method -> {
-          if (virtualRootMethodsForClass.containsKey(method)) {
-            virtualRootMethodsForClass.get(method).getParent().addOverride(method);
-          } else {
-            virtualRootMethodsForClass.put(method, new VirtualRootMethod(method));
-          }
-        });
+        method ->
+            virtualRootMethodsForClass.compute(
+                method,
+                (ignore, parent) -> {
+                  if (parent == null) {
+                    return new VirtualRootMethod(method);
+                  } else {
+                    VirtualRootMethod override = new VirtualRootMethod(method, parent);
+                    parent.addOverride(override);
+                    return override;
+                  }
+                }));
     return virtualRootMethodsForClass;
   }
 
@@ -147,37 +211,43 @@
           VirtualRootMethod virtualRootMethod =
               virtualRootMethodsForClass.remove(rootCandidate.getMethodSignature());
           acceptVirtualMethod(rootCandidate, virtualRootMethod);
-          if (!rootCandidate.isStructurallyEqualTo(virtualRootMethod.getRoot())) {
+          if (virtualRootMethod.hasParent()
+              || !rootCandidate.isStructurallyEqualTo(virtualRootMethod.getMethod())) {
             return;
           }
-          boolean isMonomorphicVirtualMethod =
-              !clazz.isInterface() && !virtualRootMethod.hasOverrides();
-          if (isMonomorphicVirtualMethod) {
+          if (!virtualRootMethod.hasOverrides()
+              && !virtualRootMethod.hasSiblings()
+              && !virtualRootMethod.isMayDispatchOutsideProgramSet()) {
             monomorphicVirtualRootMethods.add(rootCandidate);
-          } else {
-            ProgramMethod singleNonAbstractMethod = virtualRootMethod.getSingleNonAbstractMethod();
-            if (singleNonAbstractMethod != null
-                && !virtualRootMethod.isInterfaceMethodWithSiblings()) {
+            return;
+          }
+          if (!rootCandidate.getHolder().isInterface()) {
+            VirtualRootMethod singleDispatchTarget = virtualRootMethod.getSingleDispatchTarget();
+            if (singleDispatchTarget != null) {
               virtualRootMethod.forEach(
-                  method -> {
-                    // Interface methods can have siblings and can therefore not be mapped to their
-                    // unique non-abstract implementation, unless the interface method does not have
-                    // any siblings.
-                    virtualRootMethods.put(
-                        method.getReference(), singleNonAbstractMethod.getReference());
-                  });
-              if (!singleNonAbstractMethod.getHolder().isInterface()) {
-                monomorphicVirtualNonRootMethods.add(singleNonAbstractMethod);
-              }
-            } else {
-              virtualRootMethod.forEach(
-                  method ->
-                      virtualRootMethods.put(method.getReference(), rootCandidate.getReference()));
+                  method -> setRootMethod(method, virtualRootMethod, singleDispatchTarget));
+              monomorphicVirtualNonRootMethods.add(singleDispatchTarget.getMethod());
+              return;
             }
           }
+          virtualRootMethod.forEach(
+              method -> setRootMethod(method, virtualRootMethod, virtualRootMethod));
         });
   }
 
+  private void setRootMethod(
+      VirtualRootMethod method, VirtualRootMethod currentRoot, VirtualRootMethod root) {
+    // Since the same method can have multiple roots due to interface methods, we only allow
+    // controlling the virtual root of methods that are rooted at the current root. Otherwise, we
+    // would be setting the virtual root of the same method multiple times, which could lead to
+    // non-determinism in the result (i.e., the `virtualRootMethods` map).
+    if (method.getRoot() == currentRoot) {
+      DexMethod rootReference = root.getMethod().getReference();
+      DexMethod previous = virtualRootMethods.put(method.getMethod().getReference(), rootReference);
+      assert previous == null || previous.isIdenticalTo(rootReference);
+    }
+  }
+
   protected void acceptVirtualMethod(ProgramMethod method, VirtualRootMethod virtualRootMethod) {
     // Intentionally empty.
   }
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/InterfaceMethodArgumentPropagator.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/InterfaceMethodArgumentPropagator.java
index 675bff8..5fcd8db 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/InterfaceMethodArgumentPropagator.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/InterfaceMethodArgumentPropagator.java
@@ -108,10 +108,12 @@
             return;
           }
 
-          // TODO(b/190154391): We should always have an unknown or polymorphic state, but it would
-          //  be better to use a monomorphic state when the interface method is a default method
-          //  with no overrides (CF backend only). In this case, there is no need to add methodState
-          //  to interfaceState.
+          // If the method state is monomorphic, then this is an interface method with no overrides.
+          // In this case, there is no need to add methodState to interfaceState.
+          if (methodState.isMonomorphic()) {
+            return;
+          }
+
           assert methodState.isUnknown() || methodState.asConcrete().isPolymorphic();
           interfaceState.addMethodState(appView, method, methodState);
         });
diff --git a/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java
index a6e1da7..70b50c9 100644
--- a/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java
+++ b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java
@@ -68,8 +68,8 @@
   }
 
   public void run(ExecutorService executorService) throws ExecutionException {
-    // TODO(b/335584013): Re-enable monomorphic method analysis.
-    ProgramMethodSet monomorphicVirtualMethods = ProgramMethodSet.empty();
+    ProgramMethodSet monomorphicVirtualMethods =
+        computeMonomorphicVirtualRootMethods(executorService);
     ProgramMethodMap<ProgramMethod> singleCallerMethods =
         new SingleCallerScanner(appView, monomorphicVirtualMethods)
             .getSingleCallerMethods(executorService);
diff --git a/src/main/java/com/android/tools/r8/profile/art/ArtProfileOptions.java b/src/main/java/com/android/tools/r8/profile/art/ArtProfileOptions.java
index 9e78975..2568376 100644
--- a/src/main/java/com/android/tools/r8/profile/art/ArtProfileOptions.java
+++ b/src/main/java/com/android/tools/r8/profile/art/ArtProfileOptions.java
@@ -57,7 +57,7 @@
     return enableCompletenessCheckForTesting
         && !options.isDesugaredLibraryCompilation()
         && !options.getStartupOptions().isStartupCompletenessCheckForTestingEnabled()
-        && !options.getStartupInstrumentationOptions().isStartupInstrumentationEnabled();
+        && !options.getInstrumentationOptions().isInstrumentationEnabled();
   }
 
   public boolean isNopCheckForTestingEnabled() {
diff --git a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/InstrumentationOptions.java b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/InstrumentationOptions.java
new file mode 100644
index 0000000..c1d3fa5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/InstrumentationOptions.java
@@ -0,0 +1,122 @@
+// Copyright (c) 2024, 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.profile.startup.instrumentation;
+
+import static com.android.tools.r8.utils.SystemPropertyUtils.getSystemPropertyForDevelopment;
+import static com.android.tools.r8.utils.SystemPropertyUtils.parseSystemPropertyForDevelopmentOrDefault;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableSet;
+import java.util.Collections;
+import java.util.Set;
+
+public class InstrumentationOptions {
+
+  /** Set of method references where all calls to the exact method reference should print. */
+  private Set<DexMethod> callSitesToInstrument = Collections.emptySet();
+
+  /**
+   * When enabled, each method will be instrumented to notify the startup InstrumentationServer that
+   * it has been executed.
+   *
+   * <p>This will also inject the startup runtime library (i.e., the InstrumentationServer) into the
+   * app.
+   */
+  private boolean enableExecutedClassesAndMethodsInstrumentation =
+      parseSystemPropertyForDevelopmentOrDefault(
+          "com.android.tools.r8.instrumentation.executedclassesandmethods", false);
+
+  /**
+   * Specifies the synthetic context of the startup runtime library. When this is set, the startup
+   * runtime library will only be injected into the app when the synthetic context is in the
+   * program. This can be used to avoid that the startup runtime library is injected multiple times
+   * in presence of separate compilation.
+   *
+   * <p>Example synthetic context: "app.tivi.home.MainActivity".
+   *
+   * <p>Note that this is only meaningful when one or more instrumentations are enabled.
+   */
+  private String syntheticServerContext =
+      getSystemPropertyForDevelopment(
+          "com.android.tools.r8.instrumentation.syntheticservercontext");
+
+  /**
+   * Specifies the logcat tag that should be used by the InstrumentationServer when logging events.
+   *
+   * <p>When a logcat tag is not specified, the InstrumentationServer will not print events to
+   * logcat. Instead, the startup events must be obtained by requesting the InstrumentationServer to
+   * write the events to a file.
+   */
+  private String tag = getSystemPropertyForDevelopment("com.android.tools.r8.instrumentation.tag");
+
+  public InstrumentationOptions(InternalOptions options) {
+    String callSitesToInstrumentString =
+        getSystemPropertyForDevelopment("com.android.tools.r8.instrumentation.callsites");
+    if (callSitesToInstrumentString != null) {
+      setCallSitesToInstrument(
+          parseCallSitesToInstrument(callSitesToInstrumentString, options.dexItemFactory()));
+    }
+  }
+
+  private static Set<DexMethod> parseCallSitesToInstrument(
+      String smaliStrings, DexItemFactory factory) {
+    ImmutableSet.Builder<DexMethod> builder = ImmutableSet.builder();
+    for (String smaliString : Splitter.on(':').split(smaliStrings)) {
+      MethodReference methodReference = MethodReferenceUtils.parseSmaliString(smaliString);
+      if (methodReference == null) {
+        throw new IllegalArgumentException(smaliString);
+      }
+      builder.add(MethodReferenceUtils.toDexMethod(methodReference, factory));
+    }
+    return builder.build();
+  }
+
+  public boolean isInstrumentationEnabled() {
+    return enableExecutedClassesAndMethodsInstrumentation || !callSitesToInstrument.isEmpty();
+  }
+
+  public Set<DexMethod> getCallSitesToInstrument() {
+    return callSitesToInstrument;
+  }
+
+  public void setCallSitesToInstrument(Set<DexMethod> callSitesToInstrument) {
+    this.callSitesToInstrument = callSitesToInstrument;
+  }
+
+  public boolean isExecutedClassesAndMethodsInstrumentationEnabled() {
+    return enableExecutedClassesAndMethodsInstrumentation;
+  }
+
+  public InstrumentationOptions setEnableExecutedClassesAndMethodsInstrumentation() {
+    enableExecutedClassesAndMethodsInstrumentation = true;
+    return this;
+  }
+
+  public boolean hasSyntheticServerContext() {
+    return syntheticServerContext != null;
+  }
+
+  public String getSyntheticServerContext() {
+    return syntheticServerContext;
+  }
+
+  public boolean hasTag() {
+    return tag != null;
+  }
+
+  public String getTag() {
+    return tag;
+  }
+
+  public InstrumentationOptions setTag(String tag) {
+    this.tag = tag;
+    return this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java
index 521d784..5c43c8b 100644
--- a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java
+++ b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java
@@ -58,7 +58,7 @@
   private final DexItemFactory dexItemFactory;
   private final InternalOptions options;
   private final StartupInstrumentationReferences references;
-  private final StartupInstrumentationOptions startupInstrumentationOptions;
+  private final InstrumentationOptions instrumentationOptions;
 
   private StartupInstrumentation(AppView<AppInfo> appView) {
     this.appView = appView;
@@ -66,12 +66,12 @@
     this.dexItemFactory = appView.dexItemFactory();
     this.options = appView.options();
     this.references = new StartupInstrumentationReferences(dexItemFactory);
-    this.startupInstrumentationOptions = options.getStartupInstrumentationOptions();
+    this.instrumentationOptions = options.getInstrumentationOptions();
   }
 
   public static void run(AppView<AppInfo> appView, ExecutorService executorService)
       throws ExecutionException {
-    if (appView.options().getStartupInstrumentationOptions().isStartupInstrumentationEnabled()
+    if (appView.options().getInstrumentationOptions().isInstrumentationEnabled()
         && appView.options().isGeneratingDex()) {
       StartupInstrumentation startupInstrumentation = new StartupInstrumentation(appView);
       startupInstrumentation.instrumentAllClasses(executorService);
@@ -97,11 +97,11 @@
     // If the startup options has a synthetic context for the startup instrumentation server, then
     // only inject the runtime library if the synthetic context exists in program to avoid injecting
     // the runtime library multiple times when there is separate compilation.
-    if (startupInstrumentationOptions.hasStartupInstrumentationServerSyntheticContext()) {
+    if (instrumentationOptions.hasSyntheticServerContext()) {
       DexType syntheticContext =
           dexItemFactory.createType(
               DescriptorUtils.javaTypeToDescriptor(
-                  startupInstrumentationOptions.getStartupInstrumentationServerSyntheticContext()));
+                  instrumentationOptions.getSyntheticServerContext()));
       if (asProgramClassOrNull(appView.definitionFor(syntheticContext)) == null) {
         return;
       }
@@ -126,7 +126,7 @@
   private List<DexProgramClass> createStartupRuntimeLibraryClasses() {
     DexProgramClass instrumentationServerImplClass =
         InstrumentationServerImplFactory.createClass(dexItemFactory);
-    if (startupInstrumentationOptions.hasStartupInstrumentationTag()) {
+    if (instrumentationOptions.hasTag()) {
       instrumentationServerImplClass
           .lookupUniqueStaticFieldWithName(dexItemFactory.createString("writeToLogcat"))
           .setStaticValue(DexValueBoolean.create(true));
@@ -137,9 +137,7 @@
       instrumentationServerImplClass
           .lookupUniqueStaticFieldWithName(dexItemFactory.createString("logcatTag"))
           .setStaticValue(
-              new DexValueString(
-                  dexItemFactory.createString(
-                      startupInstrumentationOptions.getStartupInstrumentationTag())));
+              new DexValueString(dexItemFactory.createString(instrumentationOptions.getTag())));
     }
 
     return ImmutableList.of(
@@ -162,7 +160,8 @@
   }
 
   private boolean ensureClassInitializer(DexProgramClass clazz) {
-    if (clazz.hasClassInitializer()) {
+    if (clazz.hasClassInitializer()
+        || !instrumentationOptions.isExecutedClassesAndMethodsInstrumentationEnabled()) {
       return false;
     }
     ComputedApiLevel computedApiLevel =
@@ -191,7 +190,8 @@
     instructionIterator.positionBeforeNextInstructionThatMatches(not(Instruction::isArgument));
 
     // Insert invoke to record that the enclosing class is a startup class.
-    if (method.getDefinition().isClassInitializer()) {
+    if (instrumentationOptions.isExecutedClassesAndMethodsInstrumentationEnabled()
+        && method.getDefinition().isClassInitializer()) {
       DexType classToPrint = method.getHolderType();
       Value descriptorValue =
           instructionIterator.insertConstStringInstruction(
@@ -209,15 +209,16 @@
       Value descriptorValue =
           instructionIterator.insertConstStringInstruction(
               appView, code, dexItemFactory.createString(method.getReference().toSmaliString()));
-      instructionIterator.add(
-          InvokeStatic.builder()
-              .setMethod(references.addMethod)
-              .setSingleArgument(descriptorValue)
-              .setPosition(Position.syntheticNone())
-              .build());
+      if (instrumentationOptions.isExecutedClassesAndMethodsInstrumentationEnabled()) {
+        instructionIterator.add(
+            InvokeStatic.builder()
+                .setMethod(references.addMethod)
+                .setSingleArgument(descriptorValue)
+                .setPosition(Position.syntheticNone())
+                .build());
+      }
 
-      Set<DexMethod> callSitesToInstrument =
-          startupInstrumentationOptions.getCallSitesToInstrument();
+      Set<DexMethod> callSitesToInstrument = instrumentationOptions.getCallSitesToInstrument();
       if (!callSitesToInstrument.isEmpty()) {
         do {
           while (instructionIterator.hasNext()) {
diff --git a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationOptions.java b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationOptions.java
deleted file mode 100644
index 4a11409..0000000
--- a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationOptions.java
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright (c) 2022, 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.profile.startup.instrumentation;
-
-import static com.android.tools.r8.utils.SystemPropertyUtils.getSystemPropertyForDevelopment;
-import static com.android.tools.r8.utils.SystemPropertyUtils.parseSystemPropertyForDevelopmentOrDefault;
-
-import com.android.tools.r8.graph.DexMethod;
-import java.util.Collections;
-import java.util.Set;
-
-public class StartupInstrumentationOptions {
-
-  /** Set of method references where all calls to the exact method reference should print. */
-  private Set<DexMethod> callSitesToInstrument = Collections.emptySet();
-
-  /**
-   * When enabled, each method will be instrumented to notify the startup InstrumentationServer that
-   * it has been executed.
-   *
-   * <p>This will also inject the startup runtime library (i.e., the InstrumentationServer) into the
-   * app.
-   */
-  private boolean enableStartupInstrumentation =
-      parseSystemPropertyForDevelopmentOrDefault(
-          "com.android.tools.r8.startup.instrumentation.instrument", false);
-
-  /**
-   * Specifies the synthetic context of the startup runtime library. When this is set, the startup
-   * runtime library will only be injected into the app when the synthetic context is in the
-   * program. This can be used to avoid that the startup runtime library is injected multiple times
-   * in presence of separate compilation.
-   *
-   * <p>Example synthetic context: "app.tivi.home.MainActivity".
-   *
-   * <p>Note that this is only meaningful when {@link #enableStartupInstrumentation} is set to true.
-   */
-  private String startupInstrumentationServerSyntheticContext =
-      getSystemPropertyForDevelopment(
-          "com.android.tools.r8.startup.instrumentation.instrumentationserversyntheticcontext");
-
-  /**
-   * Specifies the logcat tag that should be used by the InstrumentationServer when logging events.
-   *
-   * <p>When a logcat tag is not specified, the InstrumentationServer will not print events to
-   * logcat. Instead, the startup events must be obtained by requesting the InstrumentationServer to
-   * write the events to a file.
-   */
-  private String startupInstrumentationTag =
-      getSystemPropertyForDevelopment(
-          "com.android.tools.r8.startup.instrumentation.instrumentationtag");
-
-  public Set<DexMethod> getCallSitesToInstrument() {
-    return callSitesToInstrument;
-  }
-
-  public void setCallSitesToInstrument(Set<DexMethod> callSitesToInstrument) {
-    this.callSitesToInstrument = callSitesToInstrument;
-  }
-
-  public boolean hasStartupInstrumentationServerSyntheticContext() {
-    return startupInstrumentationServerSyntheticContext != null;
-  }
-
-  public String getStartupInstrumentationServerSyntheticContext() {
-    return startupInstrumentationServerSyntheticContext;
-  }
-
-  public StartupInstrumentationOptions setStartupInstrumentationServerSyntheticContext(
-      String startupInstrumentationServerSyntheticContext) {
-    this.startupInstrumentationServerSyntheticContext =
-        startupInstrumentationServerSyntheticContext;
-    return this;
-  }
-
-  public boolean hasStartupInstrumentationTag() {
-    return startupInstrumentationTag != null;
-  }
-
-  public String getStartupInstrumentationTag() {
-    return startupInstrumentationTag;
-  }
-
-  public StartupInstrumentationOptions setStartupInstrumentationTag(
-      String startupInstrumentationTag) {
-    this.startupInstrumentationTag = startupInstrumentationTag;
-    return this;
-  }
-
-  public boolean isStartupInstrumentationEnabled() {
-    return enableStartupInstrumentation;
-  }
-
-  public StartupInstrumentationOptions setEnableStartupInstrumentation() {
-    enableStartupInstrumentation = true;
-    return this;
-  }
-}
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 25a690e..6041570 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -268,6 +268,8 @@
   private final Set<EnqueuerConstClassAnalysis> constClassAnalyses = new LinkedHashSet<>();
   private final Set<EnqueuerNewInstanceAnalysis> newInstanceAnalyses = new LinkedHashSet<>();
 
+  private final Map<DexProgramClass, Boolean> rClassLookupCache = new IdentityHashMap<>();
+
   // Don't hold a direct pointer to app info (use appView).
   private AppInfoWithClassHierarchy appInfo;
   private final AppView<AppInfoWithClassHierarchy> appView;
@@ -3804,6 +3806,12 @@
         analysis -> analysis.traceInvokeSuper(reference, resolutionResults, context));
   }
 
+  public boolean isRClass(DexProgramClass dexProgramClass) {
+    return rClassLookupCache.computeIfAbsent(
+        dexProgramClass,
+        clazz -> DescriptorUtils.isRClassDescriptor(clazz.getType().toDescriptorString()));
+  }
+
   // Returns the set of live types.
   public MainDexInfo traceMainDex(ExecutorService executorService, Timing timing)
       throws ExecutionException {
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracing.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracing.java
index 78abb50..51e854f 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracing.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracing.java
@@ -21,13 +21,11 @@
 
   public static EnqueuerDeferredTracing create(
       AppView<? extends AppInfoWithClassHierarchy> appView, Enqueuer enqueuer, Mode mode) {
-    if (mode.isInitialTreeShaking()) {
+    InternalOptions options = appView.options();
+    if (!options.isShrinking() || !options.enableEnqueuerDeferredTracing) {
       return empty();
     }
-    InternalOptions options = appView.options();
-    if (!options.isOptimizing()
-        || !options.isShrinking()
-        || !options.enableEnqueuerDeferredTracing) {
+    if (!options.isOptimizing() && !options.isOptimizedResourceShrinking()) {
       return empty();
     }
     return new EnqueuerDeferredTracingImpl(appView, enqueuer, mode);
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingImpl.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingImpl.java
index 1eacba7..5291978 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingImpl.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingImpl.java
@@ -128,6 +128,11 @@
     // field's holder. Therefore, we unconditionally trace the class initializer in this case.
     // The corresponding IR rewriter will rewrite the field access into an init-class instruction.
     if (accessKind.isStatic()) {
+      if (enqueuer.getMode().isInitialTreeShaking() && field.getHolder() != context.getHolder()) {
+        // TODO(b/338000616): No support for InitClass until we have LIR in the initial round of
+        //  tree shaking.
+        return false;
+      }
       KeepReason reason =
           enqueuer.getGraphReporter().reportClassReferencedFrom(field.getHolder(), context);
       enqueuer.getWorklist().enqueueTraceTypeReferenceAction(field.getHolder(), reason);
@@ -148,7 +153,7 @@
     }
 
     assert enqueuer.getKeepInfo(field).isBottom();
-    assert !enqueuer.getKeepInfo(field).isPinned(options);
+    assert !enqueuer.getKeepInfo(field).isPinned(options) || options.isOptimizedResourceShrinking();
 
     FieldAccessInfo info = enqueuer.getFieldAccessInfoCollection().get(field.getReference());
     if (info.hasReflectiveAccess()
@@ -162,6 +167,12 @@
                     || !minimumKeepInfo.isShrinkingAllowed())) {
       return false;
     }
+    if (!options.isOptimizing()) {
+      assert options.isOptimizedResourceShrinking();
+      if (!enqueuer.isRClass(field.getHolder())) {
+        return false;
+      }
+    }
 
     if (info.isWritten()) {
       // If the assigned value may have an override of Object#finalize() then give up.
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
index bb72018..4644989 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -684,11 +684,7 @@
     // actually equal.
     GraphLens graphLens = appView.graphLens();
     boolean includeContext =
-        intermediate
-            || appView
-                .options()
-                .getStartupInstrumentationOptions()
-                .isStartupInstrumentationEnabled();
+        intermediate || appView.options().getInstrumentationOptions().isInstrumentationEnabled();
     List<T> sortedPotentialMembers =
         ListUtils.sort(
             potentialEquivalence,
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 23a0e46..18de8df 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -63,7 +63,6 @@
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.graph.analysis.ResourceAccessAnalysis;
 import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.analysis.proto.ProtoReferences;
@@ -89,7 +88,7 @@
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.profile.art.ArtProfileOptions;
 import com.android.tools.r8.profile.startup.StartupOptions;
-import com.android.tools.r8.profile.startup.instrumentation.StartupInstrumentationOptions;
+import com.android.tools.r8.profile.startup.instrumentation.InstrumentationOptions;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
@@ -198,7 +197,6 @@
 
   public ResourceShrinkerConfiguration resourceShrinkerConfiguration =
       ResourceShrinkerConfiguration.DEFAULT_CONFIGURATION;
-  public ResourceAccessAnalysis resourceAccessAnalysis = null;
 
   public boolean checkIfCancelled() {
     if (cancelCompilationChecker == null) {
@@ -263,6 +261,7 @@
     proguardConfiguration = null;
     enableTreeShaking = false;
     enableMinification = false;
+    instrumentationOptions = new InstrumentationOptions(this);
   }
 
   // Constructor for D8, L8, Lint and other non-shrinkers.
@@ -275,6 +274,7 @@
     enableTreeShaking = false;
     enableMinification = false;
     disableGlobalOptimizations();
+    instrumentationOptions = new InstrumentationOptions(this);
   }
 
   // Constructor for R8.
@@ -288,6 +288,7 @@
     itemFactory = proguardConfiguration.getDexItemFactory();
     enableTreeShaking = proguardConfiguration.isShrinking();
     enableMinification = proguardConfiguration.isObfuscating();
+    instrumentationOptions = new InstrumentationOptions(this);
 
     if (!proguardConfiguration.isOptimizing()) {
       // TODO(b/171457102): Avoid the need for this.
@@ -946,8 +947,7 @@
   private final MappingComposeOptions mappingComposeOptions = new MappingComposeOptions();
   private final ArtProfileOptions artProfileOptions = new ArtProfileOptions(this);
   private final StartupOptions startupOptions = new StartupOptions();
-  private final StartupInstrumentationOptions startupInstrumentationOptions =
-      new StartupInstrumentationOptions();
+  private final InstrumentationOptions instrumentationOptions;
   public final TestingOptions testing = new TestingOptions();
 
   public List<ProguardConfigurationRule> mainDexKeepRules = ImmutableList.of();
@@ -1043,8 +1043,8 @@
     return startupOptions;
   }
 
-  public StartupInstrumentationOptions getStartupInstrumentationOptions() {
-    return startupInstrumentationOptions;
+  public InstrumentationOptions getInstrumentationOptions() {
+    return instrumentationOptions;
   }
 
   public TestingOptions getTestingOptions() {
diff --git a/src/main/java/com/android/tools/r8/utils/collections/DexMethodSignatureMap.java b/src/main/java/com/android/tools/r8/utils/collections/DexMethodSignatureMap.java
index 377be48..e4872c7 100644
--- a/src/main/java/com/android/tools/r8/utils/collections/DexMethodSignatureMap.java
+++ b/src/main/java/com/android/tools/r8/utils/collections/DexMethodSignatureMap.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexMethodSignature;
+import com.android.tools.r8.graph.ProgramMethod;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -143,6 +144,12 @@
     return backing.compute(key, remappingFunction);
   }
 
+  public T compute(
+      ProgramMethod method,
+      BiFunction<? super DexMethodSignature, ? super T, ? extends T> remappingFunction) {
+    return compute(method.getMethodSignature(), remappingFunction);
+  }
+
   @Override
   public T merge(
       DexMethodSignature key,
diff --git a/src/test/examplesJava21/switchpatternmatching/EnumSwitchTest.java b/src/test/examplesJava21/switchpatternmatching/EnumSwitchTest.java
index 07f10ad..90001a5 100644
--- a/src/test/examplesJava21/switchpatternmatching/EnumSwitchTest.java
+++ b/src/test/examplesJava21/switchpatternmatching/EnumSwitchTest.java
@@ -13,7 +13,6 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.TestRuntime.CfVm;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -41,38 +40,31 @@
     CodeInspector inspector = new CodeInspector(ToolHelper.getClassFileForTestClass(Main.class));
     // javac generated an invokedynamic using bootstrap method
     // java.lang.runtime.SwitchBootstraps.typeSwitch.
-    try {
-      assertEquals(
-          1,
-          inspector
-              .clazz(Main.class)
-              .uniqueMethodWithOriginalName("enumSwitch")
-              .streamInstructions()
-              .filter(InstructionSubject::isInvokeDynamic)
-              .map(
-                  instruction ->
-                      instruction
-                          .asCfInstruction()
-                          .getInstruction()
-                          .asInvokeDynamic()
-                          .getCallSite()
-                          .getBootstrapMethod()
-                          .member
-                          .asDexMethod())
-              .filter(
-                  method ->
-                      method
-                          .getHolderType()
-                          .toString()
-                          .contains("java.lang.runtime.SwitchBootstraps"))
-              .filter(method -> method.toString().contains("typeSwitch"))
-              .count());
-    } catch (CompilationError e) {
-      assertEquals("Could not parse code", e.getMessage());
-      assertEquals(
-          "Unsupported bootstrap static argument of type ConstantDynamic",
-          e.getCause().getMessage());
-    }
+    assertEquals(
+        1,
+        inspector
+            .clazz(Main.class)
+            .uniqueMethodWithOriginalName("enumSwitch")
+            .streamInstructions()
+            .filter(InstructionSubject::isInvokeDynamic)
+            .map(
+                instruction ->
+                    instruction
+                        .asCfInstruction()
+                        .getInstruction()
+                        .asInvokeDynamic()
+                        .getCallSite()
+                        .getBootstrapMethod()
+                        .member
+                        .asDexMethod())
+            .filter(
+                method ->
+                    method
+                        .getHolderType()
+                        .toString()
+                        .contains("java.lang.runtime.SwitchBootstraps"))
+            .filter(method -> method.toString().contains("typeSwitch"))
+            .count());
 
     parameters.assumeJvmTestParameters();
     testForJvm(parameters)
@@ -116,6 +108,7 @@
   static final class C implements I {}
 
   static class Main {
+
     static void enumSwitch(I i) {
       switch (i) {
         case E.E1 -> {
diff --git a/src/test/examplesJava21/switchpatternmatching/StringSwitchTest.java b/src/test/examplesJava21/switchpatternmatching/StringSwitchTest.java
index a330d75..144af9d 100644
--- a/src/test/examplesJava21/switchpatternmatching/StringSwitchTest.java
+++ b/src/test/examplesJava21/switchpatternmatching/StringSwitchTest.java
@@ -104,18 +104,18 @@
         case null -> {
           System.out.println("null");
         }
-        case "y", "Y" -> {
-          System.out.println("y or Y");
-        }
-        case "n", "N" -> {
-          System.out.println("n or N");
-        }
         case String s when s.equalsIgnoreCase("YES") -> {
           System.out.println("yes");
         }
+        case "y", "Y" -> {
+          System.out.println("y or Y");
+        }
         case String s when s.equalsIgnoreCase("NO") -> {
           System.out.println("no");
         }
+        case "n", "N" -> {
+          System.out.println("n or N");
+        }
         case String s -> {
           System.out.println("unknown");
         }
diff --git a/src/test/examplesJava21/switchpatternmatching/TypeSwitchTest.java b/src/test/examplesJava21/switchpatternmatching/TypeSwitchTest.java
index 5ad94ba..f272cde 100644
--- a/src/test/examplesJava21/switchpatternmatching/TypeSwitchTest.java
+++ b/src/test/examplesJava21/switchpatternmatching/TypeSwitchTest.java
@@ -13,7 +13,6 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.TestRuntime.CfVm;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -48,24 +47,19 @@
     CodeInspector inspector = new CodeInspector(ToolHelper.getClassFileForTestClass(Main.class));
     // javac generated an invokedynamic using bootstrap method argument of an arrya type (sort 9
     // is org.objectweb.asm.Type.ARRAY).
-    try {
       inspector
           .clazz(Main.class)
           .uniqueMethodWithOriginalName("typeSwitch")
           .streamInstructions()
           .filter(InstructionSubject::isInvokeDynamic)
           .count();
-    } catch (CompilationError e) {
-      assertEquals("Could not parse code", e.getMessage());
-      assertEquals("Type sort is not supported: 9", e.getCause().getMessage());
-    }
     // javac generated an invokedynamic using bootstrap method
     // java.lang.runtime.SwitchBootstraps.typeSwitch.
     assertEquals(
         1,
         inspector
             .clazz(Main.class)
-            .uniqueMethodWithOriginalName("typeSwitchNoArray")
+            .uniqueMethodWithOriginalName("typeSwitch")
             .streamInstructions()
             .filter(InstructionSubject::isInvokeDynamic)
             .map(
@@ -127,17 +121,6 @@
 
   static class Main {
 
-    // No array version only for loading into code inspector.
-    static void typeSwitchNoArray(Object obj) {
-      switch (obj) {
-        case null -> System.out.println("null");
-        case String string -> System.out.println("String");
-        case Color color -> System.out.println("Color: " + color);
-        case Point point -> System.out.println("Record class: " + point);
-        default -> System.out.println("Other");
-      }
-    }
-
     static void typeSwitch(Object obj) {
       switch (obj) {
         case null -> System.out.println("null");
diff --git a/src/test/java/com/android/tools/r8/androidresources/NoOptResourceShrinkingTest.java b/src/test/java/com/android/tools/r8/androidresources/NoOptResourceShrinkingTest.java
new file mode 100644
index 0000000..2248d93
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/androidresources/NoOptResourceShrinkingTest.java
@@ -0,0 +1,83 @@
+// Copyright (c) 2024, 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.androidresources;
+
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.androidresources.AndroidResourceTestingUtils.AndroidTestResource;
+import com.android.tools.r8.androidresources.AndroidResourceTestingUtils.AndroidTestResourceBuilder;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+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 NoOptResourceShrinkingTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public boolean optimized;
+
+  @Parameters(name = "{0}, optimized: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withDefaultDexRuntime().withAllApiLevels().build(),
+        BooleanUtils.values());
+  }
+
+  public static AndroidTestResource getTestResources(TemporaryFolder temp) throws Exception {
+    return new AndroidTestResourceBuilder()
+        .withSimpleManifestAndAppNameString()
+        .addRClassInitializeWithDefaultValues(R.string.class)
+        .build(temp);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    AndroidTestResource testResources = getTestResources(temp);
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters)
+        .addProgramClasses(FooBar.class)
+        .applyIf(optimized, R8TestBuilder::enableOptimizedShrinking)
+        .addAndroidResources(testResources)
+        .addKeepMainRule(FooBar.class)
+        .addDontOptimize()
+        .compile()
+        .inspectShrunkenResources(
+            resourceTableInspector -> {
+              resourceTableInspector.assertContainsResourceWithName("string", "bar");
+              resourceTableInspector.assertContainsResourceWithName("string", "foo");
+              resourceTableInspector.assertDoesNotContainResourceWithName(
+                  "string", "unused_string");
+            })
+        .run(parameters.getRuntime(), FooBar.class)
+        .assertSuccess();
+  }
+
+  public static class FooBar {
+
+    public static void main(String[] args) {
+      if (System.currentTimeMillis() == 0) {
+        System.out.println(R.string.bar);
+        System.out.println(R.string.foo);
+      }
+    }
+  }
+
+  public static class R {
+
+    public static class string {
+      public static int bar;
+      public static int foo;
+      public static int unused_string;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/androidresources/optimizedshrinking/TestOptimizedShrinking.java b/src/test/java/com/android/tools/r8/androidresources/optimizedshrinking/TestOptimizedShrinking.java
index 74c7102..584426b 100644
--- a/src/test/java/com/android/tools/r8/androidresources/optimizedshrinking/TestOptimizedShrinking.java
+++ b/src/test/java/com/android/tools/r8/androidresources/optimizedshrinking/TestOptimizedShrinking.java
@@ -107,7 +107,7 @@
 
                 // In optimized mode we track these correctly, so we should not unconditionally keep
                 // all attributes.
-                if (optimized && !debug) {
+                if (optimized) {
                   resourceTableInspector.assertDoesNotContainResourceWithName(
                       "attr", "attr_unused_styleable" + i);
                 } else {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
index c2ab4e2..2cbfd3f 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
@@ -38,8 +38,16 @@
         .addInnerClasses(EmptyEnumUnboxingTest.class)
         .addKeepMainRule(Main.class)
         .addKeepRules(enumKeepRules.getKeepRules())
-        // TODO(b/166532373): Unbox enum with no cases.
-        .addEnumUnboxingInspector(inspector -> inspector.assertNotUnboxed(MyEnum.class))
+        .addEnumUnboxingInspector(
+            inspector -> {
+              if (enumKeepRules.isStudio()) {
+                // TODO(b/166532373): Unbox enum with no cases.
+                inspector.assertNotUnboxed(MyEnum.class);
+              } else {
+                assert enumKeepRules.isNone();
+                inspector.assertUnboxed(MyEnum.class);
+              }
+            })
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
diff --git a/src/test/java/com/android/tools/r8/internal/GMSCoreLatestTest.java b/src/test/java/com/android/tools/r8/internal/GMSCoreLatestTest.java
index ef9401a..bfb7a05 100644
--- a/src/test/java/com/android/tools/r8/internal/GMSCoreLatestTest.java
+++ b/src/test/java/com/android/tools/r8/internal/GMSCoreLatestTest.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AssertionUtils;
 import com.google.common.collect.Sets;
@@ -24,6 +25,7 @@
 import java.util.Collections;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.Lock;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -68,8 +70,10 @@
                     options -> {
                       options.testing.processingContextsConsumer =
                           id -> assertNull(idsRoundOne.put(id, id));
+                      options
+                          .getOpenClosedInterfacesOptions()
+                          .suppressSingleOpenInterface(Reference.classFromClass(Lock.class));
                     }));
-
     compileResult.runDex2Oat(parameters.getRuntime()).assertNoVerificationErrors();
 
     Map<String, String> idsRoundTwo = new ConcurrentHashMap<>();
@@ -83,6 +87,9 @@
                             AssertionUtils.assertNotNull(idsRoundOne.get(id));
                             assertNull(idsRoundTwo.put(id, id));
                           };
+                      options
+                          .getOpenClosedInterfacesOptions()
+                          .suppressSingleOpenInterface(Reference.classFromClass(Lock.class));
                     }));
 
     // Verify that the result of the two compilations was the same.
diff --git a/src/test/java/com/android/tools/r8/internal/GMSCoreV10Test.java b/src/test/java/com/android/tools/r8/internal/GMSCoreV10Test.java
index 4c61934..484a349 100644
--- a/src/test/java/com/android/tools/r8/internal/GMSCoreV10Test.java
+++ b/src/test/java/com/android/tools/r8/internal/GMSCoreV10Test.java
@@ -15,9 +15,11 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.concurrent.locks.Lock;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -59,6 +61,9 @@
                 builder.addOptionsModification(
                     options -> {
                       options.testing.forceJumboStringProcessing = true;
+                      options
+                          .getOpenClosedInterfacesOptions()
+                          .suppressSingleOpenInterface(Reference.classFromClass(Lock.class));
                     }))
         .runDex2Oat(parameters.getRuntime())
         .assertNoVerificationErrors();
diff --git a/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java b/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java
index cd06774..c6cf0e3 100644
--- a/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java
+++ b/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java
@@ -91,9 +91,9 @@
             .addOptionsModification(
                 options ->
                     options
-                        .getStartupInstrumentationOptions()
-                        .setEnableStartupInstrumentation()
-                        .setStartupInstrumentationTag("r8"))
+                        .getInstrumentationOptions()
+                        .setEnableExecutedClassesAndMethodsInstrumentation()
+                        .setTag("r8"))
             .enableCoreLibraryDesugaring(
                 LibraryDesugaringTestConfiguration.builder()
                     .addDesugaredLibraryConfiguration(
diff --git a/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java b/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java
index a8cf85a..742d9ce 100644
--- a/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java
+++ b/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java
@@ -78,9 +78,9 @@
         .addOptionsModification(
             options ->
                 options
-                    .getStartupInstrumentationOptions()
-                    .setEnableStartupInstrumentation()
-                    .setStartupInstrumentationTag("r8"))
+                    .getInstrumentationOptions()
+                    .setEnableExecutedClassesAndMethodsInstrumentation()
+                    .setTag("r8"))
         .setMinApi(apiLevel)
         .release()
         .compile()
@@ -98,9 +98,9 @@
         .addOptionsModification(
             options ->
                 options
-                    .getStartupInstrumentationOptions()
-                    .setEnableStartupInstrumentation()
-                    .setStartupInstrumentationTag("r8"))
+                    .getInstrumentationOptions()
+                    .setEnableExecutedClassesAndMethodsInstrumentation()
+                    .setTag("r8"))
         .setMinApi(apiLevel)
         .release()
         .compile()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/PropagationFromBaseMethodWithSingleTargetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/PropagationFromBaseMethodWithSingleTargetTest.java
new file mode 100644
index 0000000..9a48d47
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/PropagationFromBaseMethodWithSingleTargetTest.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2024, 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.callsites;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.NoParameterTypeStrengthening;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+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;
+
+/**
+ * Reproduction of b/336791970 where we incorrectly mark A.m() as a monomorphic method meaning that
+ * the argument "B" in the call that resolves to A.m() is not propagated to B.m().
+ */
+@RunWith(Parameterized.class)
+public class PropagationFromBaseMethodWithSingleTargetTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .enableNoHorizontalClassMergingAnnotations()
+        .enableNoParameterTypeStrengtheningAnnotations()
+        .enableNoVerticalClassMergingAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("B", "C");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      A a = System.currentTimeMillis() > 0 ? new B() : new A();
+      a.m("B");
+      call(new C());
+    }
+
+    @NeverInline
+    @NoParameterTypeStrengthening
+    static void call(I i) {
+      i.m("C");
+    }
+  }
+
+  @NoVerticalClassMerging
+  interface I {
+
+    void m(String s);
+  }
+
+  static class A {
+
+    public void m(String s) {
+      System.out.println(s);
+    }
+  }
+
+  @NoHorizontalClassMerging
+  static class B extends A {
+
+    @Override
+    public void m(String s) {
+      System.out.println(s);
+    }
+  }
+
+  @NeverClassInline
+  @NoHorizontalClassMerging
+  static class C extends A implements I {}
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/IllegalSingleCallerInliningOfNonAbstractSiblingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/IllegalSingleCallerInliningOfNonAbstractSiblingTest.java
new file mode 100644
index 0000000..117b090
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/IllegalSingleCallerInliningOfNonAbstractSiblingTest.java
@@ -0,0 +1,78 @@
+// Copyright (c) 2024, 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.inliner;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ir.optimize.Inliner.Reason;
+import com.google.common.collect.ImmutableSet;
+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 IllegalSingleCallerInliningOfNonAbstractSiblingTest 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)
+        .addOptionsModification(
+            options -> options.testing.validInliningReasons = ImmutableSet.of(Reason.SINGLE_CALLER))
+        .enableNoHorizontalClassMergingAnnotations()
+        .enableNoVerticalClassMergingAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("A", "A");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      I i = System.currentTimeMillis() > 0 ? new B() : new C();
+      i.m();
+
+      new A().m();
+    }
+  }
+
+  interface I {
+
+    default void m() {
+      System.out.println("C");
+    }
+  }
+
+  @NeverClassInline
+  @NoHorizontalClassMerging
+  @NoVerticalClassMerging
+  static class A {
+
+    public void m() {
+      System.out.println("A");
+    }
+  }
+
+  static class B extends A implements I {}
+
+  @NoHorizontalClassMerging
+  static class C implements I {}
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/PreconditionExtendsRemovedClassIfRuleTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/PreconditionExtendsRemovedClassIfRuleTest.java
new file mode 100644
index 0000000..c709731
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/PreconditionExtendsRemovedClassIfRuleTest.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2024, 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.shaking.ifrule;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NoUnusedInterfaceRemoval;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+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 PreconditionExtendsRemovedClassIfRuleTest extends TestBase {
+
+  @Parameter(0)
+  public boolean enableUnusedInterfaceRemoval;
+
+  @Parameter(1)
+  public boolean enableVerticalClassMerging;
+
+  @Parameter(2)
+  public TestParameters parameters;
+
+  @Parameters(name = "{2}, unused: {0}, vertical: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        BooleanUtils.values(),
+        BooleanUtils.values(),
+        getTestParameters().withDefaultRuntimes().withMaximumApiLevel().build());
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addKeepRules(
+            "-if class * implements " + I.class.getTypeName(),
+            "-keep class <1> {",
+            "  void unused();",
+            "}")
+        .applyIf(
+            enableUnusedInterfaceRemoval,
+            R8TestBuilder::addNoUnusedInterfaceRemovalAnnotations,
+            R8TestBuilder::enableNoUnusedInterfaceRemovalAnnotations)
+        .applyIf(
+            enableVerticalClassMerging,
+            R8TestBuilder::addNoVerticalClassMergingAnnotations,
+            R8TestBuilder::enableNoVerticalClassMergingAnnotations)
+        .setMinApi(parameters)
+        .compile()
+        // TODO(b/337905171): Should keep unused.
+        .inspect(
+            inspector ->
+                assertThat(
+                    inspector.clazz(A.class).uniqueMethodWithOriginalName("unused"),
+                    isAbsentIf(enableUnusedInterfaceRemoval)));
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      System.out.println(A.class);
+    }
+  }
+
+  @NoUnusedInterfaceRemoval
+  @NoVerticalClassMerging
+  public interface I {}
+
+  public static class A implements I {
+
+    // Kept by -if.
+    void unused() {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/SubsequentExtendsRemovedClassIfRuleTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/SubsequentExtendsRemovedClassIfRuleTest.java
new file mode 100644
index 0000000..0f99416
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/SubsequentExtendsRemovedClassIfRuleTest.java
@@ -0,0 +1,83 @@
+// Copyright (c) 2024, 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.shaking.ifrule;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NoUnusedInterfaceRemoval;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+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 SubsequentExtendsRemovedClassIfRuleTest extends TestBase {
+
+  @Parameter(0)
+  public boolean enableUnusedInterfaceRemoval;
+
+  @Parameter(1)
+  public boolean enableVerticalClassMerging;
+
+  @Parameter(2)
+  public TestParameters parameters;
+
+  @Parameters(name = "{2}, unused: {0}, vertical: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        BooleanUtils.values(),
+        BooleanUtils.values(),
+        getTestParameters().withDefaultRuntimes().withMaximumApiLevel().build());
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addKeepRules("-if interface *", "-keep class * implements <1> {", "  void unused();", "}")
+        .applyIf(
+            enableUnusedInterfaceRemoval,
+            R8TestBuilder::addNoUnusedInterfaceRemovalAnnotations,
+            R8TestBuilder::enableNoUnusedInterfaceRemovalAnnotations)
+        .applyIf(
+            enableVerticalClassMerging,
+            R8TestBuilder::addNoVerticalClassMergingAnnotations,
+            R8TestBuilder::enableNoVerticalClassMergingAnnotations)
+        .allowUnusedProguardConfigurationRules(enableUnusedInterfaceRemoval)
+        .setMinApi(parameters)
+        .compile()
+        // TODO(b/337905171): Should keep unused.
+        .inspect(
+            inspector ->
+                assertThat(
+                    inspector.clazz(A.class).uniqueMethodWithOriginalName("unused"),
+                    isAbsentIf(enableUnusedInterfaceRemoval)));
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      System.out.println(A.class);
+    }
+  }
+
+  @NoUnusedInterfaceRemoval
+  @NoVerticalClassMerging
+  public interface I {}
+
+  public static class A implements I {
+
+    // Kept by -if.
+    void unused() {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java b/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java
index f51ab4b..41c6730 100644
--- a/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java
+++ b/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java
@@ -23,7 +23,7 @@
 import com.android.tools.r8.profile.art.ArtProfileBuilderUtils;
 import com.android.tools.r8.profile.art.HumanReadableArtProfileParser;
 import com.android.tools.r8.profile.art.HumanReadableArtProfileParserBuilder;
-import com.android.tools.r8.profile.startup.instrumentation.StartupInstrumentationOptions;
+import com.android.tools.r8.profile.startup.instrumentation.InstrumentationOptions;
 import com.android.tools.r8.startup.StartupClassBuilder;
 import com.android.tools.r8.startup.StartupMethodBuilder;
 import com.android.tools.r8.startup.StartupProfileBuilder;
@@ -100,11 +100,12 @@
     testBuilder
         .addOptionsModification(
             options -> {
-              StartupInstrumentationOptions startupInstrumentationOptions =
-                  options.getStartupInstrumentationOptions().setEnableStartupInstrumentation();
+              InstrumentationOptions startupInstrumentationOptions =
+                  options
+                      .getInstrumentationOptions()
+                      .setEnableExecutedClassesAndMethodsInstrumentation();
               if (logcat) {
-                startupInstrumentationOptions.setStartupInstrumentationTag(
-                    startupInstrumentationTag);
+                startupInstrumentationOptions.setTag(startupInstrumentationTag);
               }
             })
         .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
diff --git a/tools/r8_release.py b/tools/r8_release.py
index 263aa76..6cebc5e 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -17,7 +17,7 @@
 
 import utils
 
-R8_DEV_BRANCH = '8.5'
+R8_DEV_BRANCH = '8.6'
 R8_VERSION_FILE = os.path.join('src', 'main', 'java', 'com', 'android', 'tools',
                                'r8', 'Version.java')
 THIS_FILE_RELATIVE = os.path.join('tools', 'r8_release.py')
diff --git a/tools/startup/instrument.py b/tools/startup/instrument.py
index 9752670..7e2870f 100755
--- a/tools/startup/instrument.py
+++ b/tools/startup/instrument.py
@@ -30,6 +30,14 @@
     result.add_argument('--discard',
                         action='append',
                         help='Name of dex files to discard')
+    result.add_argument('--print-boxing-unboxing-callsites',
+                        action='store_true',
+                        default=False,
+                        help='Print caller->callee edges for primitive boxing')
+    result.add_argument('--print-executed-classes-and-methods',
+                        action='store_true',
+                        default=False,
+                        help='Print the classes and methods that are executed')
     result.add_argument('--out',
                         help='Destination of resulting apk',
                         required=True)
@@ -52,14 +60,40 @@
                         tmp_dir):
     d8_cmd = [
         'java', '-cp', utils.R8_JAR,
-        '-Dcom.android.tools.r8.startup.instrumentation.instrument=1',
-        '-Dcom.android.tools.r8.startup.instrumentation.instrumentationtag=R8'
+        '-Dcom.android.tools.r8.instrumentation.tag=R8'
     ]
+    if options.print_boxing_unboxing_callsites:
+        callsites = ':'.join([
+                # Boxing
+                "Ljava/lang/Boolean;->valueOf(Z)Ljava/lang/Boolean;",
+                "Ljava/lang/Byte;->valueOf(B)Ljava/lang/Byte;",
+                "Ljava/lang/Character;->valueOf(C)Ljava/lang/Character;",
+                "Ljava/lang/Double;->valueOf(D)Ljava/lang/Double;",
+                "Ljava/lang/Float;->valueOf(F)Ljava/lang/Float;",
+                "Ljava/lang/Integer;->valueOf(I)Ljava/lang/Integer;",
+                "Ljava/lang/Long;->valueOf(J)Ljava/lang/Long;",
+                "Ljava/lang/Short;->valueOf(S)Ljava/lang/Short;",
+                # Unboxing
+                "Ljava/lang/Boolean;->booleanValue()Z",
+                "Ljava/lang/Byte;->byteValue()B",
+                "Ljava/lang/Character;->charValue()C",
+                "Ljava/lang/Double;->doubleValue()D",
+                "Ljava/lang/Float;->floatValue()F",
+                "Ljava/lang/Integer;->intValue()I",
+                "Ljava/lang/Long;->longValue()J",
+                "Ljava/lang/Short;->shortValue()S"
+            ])
+        d8_cmd.append(
+            '-Dcom.android.tools.r8.instrumentation.callsites='
+                + callsites)
+    if options.print_executed_classes_and_methods:
+        d8_cmd.append(
+            '-Dcom.android.tools.r8.instrumentation.executedclassesandmethods=1')
     if not include_instrumentation_server:
         # We avoid injecting the InstrumentationServer by specifying it should only
         # be added if foo.bar.Baz is in the program.
         d8_cmd.append(
-            '-Dcom.android.tools.r8.startup.instrumentation.instrumentationserversyntheticcontext=foo.bar.Baz'
+            '-Dcom.android.tools.r8.instrumentation.syntheticservercontext=foo.bar.Baz'
         )
     d8_cmd.extend([
         'com.android.tools.r8.D8', '--min-api',