diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index 182c91c..41dd2c1 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -314,6 +314,15 @@
     fields(predicate).forEach(consumer);
   }
 
+  public void forEachInstanceField(Consumer<DexEncodedField> consumer) {
+    forEachInstanceFieldMatching(alwaysTrue(), consumer);
+  }
+
+  public void forEachInstanceFieldMatching(
+      Predicate<DexEncodedField> predicate, Consumer<DexEncodedField> consumer) {
+    instanceFields(predicate).forEach(consumer);
+  }
+
   public TraversalContinuation traverseFields(Function<DexEncodedField, TraversalContinuation> fn) {
     for (DexEncodedField field : fields()) {
       if (fn.apply(field).shouldBreak()) {
@@ -393,6 +402,10 @@
     return Arrays.asList(instanceFields);
   }
 
+  public Iterable<DexEncodedField> instanceFields(Predicate<? super DexEncodedField> predicate) {
+    return Iterables.filter(Arrays.asList(instanceFields), predicate::test);
+  }
+
   public void appendInstanceField(DexEncodedField field) {
     DexEncodedField[] newFields = new DexEncodedField[instanceFields.length + 1];
     System.arraycopy(instanceFields, 0, newFields, 0, instanceFields.length);
diff --git a/src/main/java/com/android/tools/r8/graph/DexCode.java b/src/main/java/com/android/tools/r8/graph/DexCode.java
index be89c66..378640d 100644
--- a/src/main/java/com/android/tools/r8/graph/DexCode.java
+++ b/src/main/java/com/android/tools/r8/graph/DexCode.java
@@ -259,7 +259,7 @@
     }
     for (TryHandler handler : handlers) {
       for (TypeAddrPair pair : handler.pairs) {
-        registry.registerTypeReference(pair.type);
+        registry.registerExceptionGuard(pair.type);
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index d3e536e..dedc362 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -2245,6 +2245,10 @@
     return createMethod(holder, createProto(voidType, parameters), constructorMethodName);
   }
 
+  public DexMethod createInstanceInitializer(DexType holder, DexTypeList parameters) {
+    return createInstanceInitializer(holder, parameters.values);
+  }
+
   public DexMethod createInstanceInitializerWithFreshProto(
       DexMethod method, List<DexType> extraTypes, Predicate<DexMethod> isFresh) {
     assert method.isInstanceInitializer(this);
diff --git a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
index 6be5551..0ebd1da 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -199,6 +199,10 @@
     forEachField(field -> consumer.accept(new ProgramField(this, field)));
   }
 
+  public void forEachProgramInstanceField(Consumer<? super ProgramField> consumer) {
+    forEachInstanceField(field -> consumer.accept(new ProgramField(this, field)));
+  }
+
   public void forEachProgramMember(Consumer<? super ProgramMember<?, ?>> consumer) {
     forEachProgramField(consumer);
     forEachProgramMethod(consumer);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java
index e0eaf2c..21f8a5c 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java
@@ -8,12 +8,9 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMergerGraphLens.Builder;
 import com.android.tools.r8.horizontalclassmerging.policies.SameInstanceFields.InstanceFieldInfo;
 import com.android.tools.r8.utils.IterableUtils;
-import com.android.tools.r8.utils.collections.BidirectionalManyToOneHashMap;
-import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneMap;
 import com.google.common.collect.Iterables;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -22,6 +19,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.BiConsumer;
 
 public class ClassInstanceFieldsMerger {
 
@@ -31,10 +29,6 @@
 
   private DexEncodedField classIdField;
 
-  // Map from target class field to all fields which should be merged into that field.
-  private final MutableBidirectionalManyToOneMap<DexEncodedField, DexEncodedField> fieldMappings =
-      BidirectionalManyToOneHashMap.newLinkedHashMap();
-
   public ClassInstanceFieldsMerger(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
@@ -42,7 +36,6 @@
     this.appView = appView;
     this.group = group;
     this.lensBuilder = lensBuilder;
-    group.forEachSource(this::addFields);
   }
 
   /**
@@ -55,13 +48,17 @@
    * Bar has fields 'A b' and 'B a'), we make a prepass that matches fields with the same reference
    * type.
    */
-  private void addFields(DexProgramClass clazz) {
+  public static void mapFields(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      DexProgramClass source,
+      DexProgramClass target,
+      BiConsumer<DexEncodedField, DexEncodedField> consumer) {
     Map<InstanceFieldInfo, LinkedList<DexEncodedField>> availableFieldsByExactInfo =
-        getAvailableFieldsByExactInfo();
+        getAvailableFieldsByExactInfo(target);
     List<DexEncodedField> needsMerge = new ArrayList<>();
 
     // Pass 1: Match fields that have the exact same type.
-    for (DexEncodedField oldField : clazz.instanceFields()) {
+    for (DexEncodedField oldField : source.instanceFields()) {
       InstanceFieldInfo info = InstanceFieldInfo.createExact(oldField);
       LinkedList<DexEncodedField> availableFieldsWithExactSameInfo =
           availableFieldsByExactInfo.get(info);
@@ -69,7 +66,7 @@
         needsMerge.add(oldField);
       } else {
         DexEncodedField newField = availableFieldsWithExactSameInfo.removeFirst();
-        fieldMappings.put(oldField, newField);
+        consumer.accept(oldField, newField);
         if (availableFieldsWithExactSameInfo.isEmpty()) {
           availableFieldsByExactInfo.remove(info);
         }
@@ -78,7 +75,7 @@
 
     // Pass 2: Match fields that do not have the same reference type.
     Map<InstanceFieldInfo, LinkedList<DexEncodedField>> availableFieldsByRelaxedInfo =
-        getAvailableFieldsByRelaxedInfo(availableFieldsByExactInfo);
+        getAvailableFieldsByRelaxedInfo(appView, availableFieldsByExactInfo);
     for (DexEncodedField oldField : needsMerge) {
       assert oldField.getType().isReferenceType();
       DexEncodedField newField =
@@ -87,14 +84,15 @@
               .removeFirst();
       assert newField != null;
       assert newField.getType().isReferenceType();
-      fieldMappings.put(oldField, newField);
+      consumer.accept(oldField, newField);
     }
   }
 
-  private Map<InstanceFieldInfo, LinkedList<DexEncodedField>> getAvailableFieldsByExactInfo() {
+  private static Map<InstanceFieldInfo, LinkedList<DexEncodedField>> getAvailableFieldsByExactInfo(
+      DexProgramClass target) {
     Map<InstanceFieldInfo, LinkedList<DexEncodedField>> availableFieldsByInfo =
         new LinkedHashMap<>();
-    for (DexEncodedField field : group.getTarget().instanceFields()) {
+    for (DexEncodedField field : target.instanceFields()) {
       availableFieldsByInfo
           .computeIfAbsent(InstanceFieldInfo.createExact(field), ignore -> new LinkedList<>())
           .add(field);
@@ -102,8 +100,10 @@
     return availableFieldsByInfo;
   }
 
-  private Map<InstanceFieldInfo, LinkedList<DexEncodedField>> getAvailableFieldsByRelaxedInfo(
-      Map<InstanceFieldInfo, LinkedList<DexEncodedField>> availableFieldsByExactInfo) {
+  private static Map<InstanceFieldInfo, LinkedList<DexEncodedField>>
+      getAvailableFieldsByRelaxedInfo(
+          AppView<? extends AppInfoWithClassHierarchy> appView,
+          Map<InstanceFieldInfo, LinkedList<DexEncodedField>> availableFieldsByExactInfo) {
     Map<InstanceFieldInfo, LinkedList<DexEncodedField>> availableFieldsByRelaxedInfo =
         new LinkedHashMap<>();
     availableFieldsByExactInfo.forEach(
@@ -125,26 +125,21 @@
     }
   }
 
-  public ProgramField getTargetField(ProgramField field) {
-    if (field.getHolder() == group.getTarget()) {
-      return field;
-    }
-    DexEncodedField targetField = fieldMappings.get(field.getDefinition());
-    return new ProgramField(group.getTarget(), targetField);
-  }
-
   public void setClassIdField(DexEncodedField classIdField) {
     this.classIdField = classIdField;
   }
 
   public DexEncodedField[] merge() {
+    assert group.hasInstanceFieldMap();
     List<DexEncodedField> newFields = new ArrayList<>();
     if (classIdField != null) {
       newFields.add(classIdField);
     }
-    fieldMappings.forEachManyToOneMapping(
-        (sourceFields, targetField) ->
-            newFields.add(mergeSourceFieldsToTargetField(targetField, sourceFields)));
+    group
+        .getInstanceFieldMap()
+        .forEachManyToOneMapping(
+            (sourceFields, targetField) ->
+                newFields.add(mergeSourceFieldsToTargetField(targetField, sourceFields)));
     return newFields.toArray(DexEncodedField.EMPTY_ARRAY);
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
index 3927d11..d1e98c7 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
@@ -27,12 +27,10 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
 import com.android.tools.r8.horizontalclassmerging.code.ClassInitializerMerger;
-import com.android.tools.r8.horizontalclassmerging.code.SyntheticClassInitializerConverter;
+import com.android.tools.r8.horizontalclassmerging.code.SyntheticInitializerConverter;
 import com.android.tools.r8.ir.analysis.value.NumberFromIntervalValue;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
-import com.android.tools.r8.shaking.KeepClassInfo;
-import com.android.tools.r8.utils.IterableUtils;
 import com.android.tools.r8.utils.SetUtils;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
@@ -40,7 +38,6 @@
 import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -78,6 +75,7 @@
 
   private ClassMerger(
       AppView<? extends AppInfoWithClassHierarchy> appView,
+      IRCodeProvider codeProvider,
       Mode mode,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
       MergeGroup group,
@@ -96,7 +94,7 @@
     this.classInitializerMerger = ClassInitializerMerger.create(group);
     this.instanceInitializerMergers =
         InstanceInitializerMergerCollection.create(
-            appView, classIdentifiers, group, classInstanceFieldsMerger, lensBuilder, mode);
+            appView, classIdentifiers, codeProvider, group, lensBuilder, mode);
     this.virtualMethodMergers = virtualMethodMergers;
 
     buildClassIdentifierMap();
@@ -109,14 +107,14 @@
 
   void mergeDirectMethods(
       SyntheticArgumentClass syntheticArgumentClass,
-      SyntheticClassInitializerConverter.Builder syntheticClassInitializerConverterBuilder) {
-    mergeInstanceInitializers(syntheticArgumentClass);
-    mergeStaticClassInitializers(syntheticClassInitializerConverterBuilder);
+      SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder) {
+    mergeInstanceInitializers(syntheticArgumentClass, syntheticInitializerConverterBuilder);
+    mergeStaticClassInitializers(syntheticInitializerConverterBuilder);
     group.forEach(this::mergeDirectMethods);
   }
 
   void mergeStaticClassInitializers(
-      SyntheticClassInitializerConverter.Builder syntheticClassInitializerConverterBuilder) {
+      SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder) {
     if (classInitializerMerger.isEmpty()) {
       return;
     }
@@ -145,7 +143,7 @@
     if (!definition.getCode().isCfCode()) {
       assert appView.options().isGeneratingDex();
       assert mode.isFinal();
-      syntheticClassInitializerConverterBuilder.add(group);
+      syntheticInitializerConverterBuilder.add(new ProgramMethod(group.getTarget(), definition));
     }
   }
 
@@ -187,16 +185,20 @@
         classMethodsBuilder::isFresh);
   }
 
-  void mergeInstanceInitializers(SyntheticArgumentClass syntheticArgumentClass) {
+  void mergeInstanceInitializers(
+      SyntheticArgumentClass syntheticArgumentClass,
+      SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder) {
     instanceInitializerMergers.forEach(
-        merger -> merger.merge(classMethodsBuilder, syntheticArgumentClass));
+        merger ->
+            merger.merge(
+                classMethodsBuilder, syntheticArgumentClass, syntheticInitializerConverterBuilder));
   }
 
   void mergeMethods(
       SyntheticArgumentClass syntheticArgumentClass,
-      SyntheticClassInitializerConverter.Builder syntheticClassInitializerConverterBuilder) {
+      SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder) {
     mergeVirtualMethods();
-    mergeDirectMethods(syntheticArgumentClass, syntheticClassInitializerConverterBuilder);
+    mergeDirectMethods(syntheticArgumentClass, syntheticInitializerConverterBuilder);
     classMethodsBuilder.setClassMethods(group.getTarget());
   }
 
@@ -316,51 +318,30 @@
 
   public void mergeGroup(
       SyntheticArgumentClass syntheticArgumentClass,
-      SyntheticClassInitializerConverter.Builder syntheticClassInitializerConverterBuilder) {
+      SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder) {
     fixAccessFlags();
     fixNestMemberAttributes();
     mergeAnnotations();
     mergeInterfaces();
     mergeFields();
-    mergeMethods(syntheticArgumentClass, syntheticClassInitializerConverterBuilder);
+    mergeMethods(syntheticArgumentClass, syntheticInitializerConverterBuilder);
   }
 
   public static class Builder {
     private final AppView<? extends AppInfoWithClassHierarchy> appView;
+    private final IRCodeProvider codeProvider;
     private Mode mode;
     private final MergeGroup group;
 
-    public Builder(AppView<? extends AppInfoWithClassHierarchy> appView, MergeGroup group) {
+    public Builder(
+        AppView<? extends AppInfoWithClassHierarchy> appView,
+        IRCodeProvider codeProvider,
+        MergeGroup group,
+        Mode mode) {
       this.appView = appView;
+      this.codeProvider = codeProvider;
       this.group = group;
-    }
-
-    Builder setMode(Mode mode) {
       this.mode = mode;
-      return this;
-    }
-
-    private void selectTarget() {
-      Iterable<DexProgramClass> candidates = Iterables.filter(group, DexClass::isPublic);
-      if (IterableUtils.isEmpty(candidates)) {
-        candidates = group;
-      }
-      Iterator<DexProgramClass> candidateIterator = candidates.iterator();
-      DexProgramClass target = IterableUtils.first(candidates);
-      while (candidateIterator.hasNext()) {
-        DexProgramClass current = candidateIterator.next();
-        KeepClassInfo keepClassInfo = appView.getKeepInfo().getClassInfo(current);
-        if (keepClassInfo.isMinificationAllowed(appView.options())) {
-          target = current;
-          break;
-        }
-        // Select the target with the shortest name.
-        if (current.getType().getDescriptor().size() < target.getType().getDescriptor().size) {
-          target = current;
-        }
-      }
-      group.setTarget(
-          appView.testing().horizontalClassMergingTarget.apply(appView, candidates, target));
     }
 
     private List<VirtualMethodMerger> createVirtualMethodMergers() {
@@ -393,8 +374,6 @@
 
     public ClassMerger build(
         HorizontalClassMergerGraphLens.Builder lensBuilder) {
-      selectTarget();
-
       List<VirtualMethodMerger> virtualMethodMergers = createVirtualMethodMergers();
 
       boolean requiresClassIdField =
@@ -405,7 +384,7 @@
         createClassIdField();
       }
 
-      return new ClassMerger(appView, mode, lensBuilder, group, virtualMethodMergers);
+      return new ClassMerger(appView, codeProvider, mode, lensBuilder, group, virtualMethodMergers);
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
index 4ad6f55..666bd64 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -9,7 +9,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DirectMappedDexApplication;
 import com.android.tools.r8.graph.PrunedItems;
-import com.android.tools.r8.horizontalclassmerging.code.SyntheticClassInitializerConverter;
+import com.android.tools.r8.horizontalclassmerging.code.SyntheticInitializerConverter;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
 import com.android.tools.r8.shaking.KeepInfoCollection;
@@ -65,6 +65,10 @@
     if (options.isEnabled(mode)) {
       timing.begin("HorizontalClassMerger (" + mode.toString() + ")");
       run(runtimeTypeCheckInfo, executorService, timing);
+
+      // Clear type elements cache after IR building.
+      appView.dexItemFactory().clearTypeElementsCache();
+
       timing.end();
     } else {
       appView.setHorizontallyMergedClasses(HorizontallyMergedClasses.empty(), mode);
@@ -74,8 +78,11 @@
   private void run(
       RuntimeTypeCheckInfo runtimeTypeCheckInfo, ExecutorService executorService, Timing timing)
       throws ExecutionException {
+    IRCodeProvider codeProvider = new IRCodeProvider(appView);
+
     // Run the policies on all program classes to produce a final grouping.
-    List<Policy> policies = PolicyScheduler.getPolicies(appView, mode, runtimeTypeCheckInfo);
+    List<Policy> policies =
+        PolicyScheduler.getPolicies(appView, codeProvider, mode, runtimeTypeCheckInfo);
     Collection<MergeGroup> groups = new PolicyExecutor().run(getInitialGroups(), policies, timing);
 
     // If there are no groups, then end horizontal class merging.
@@ -88,21 +95,20 @@
         new HorizontalClassMergerGraphLens.Builder();
 
     // Merge the classes.
-    List<ClassMerger> classMergers = initializeClassMergers(lensBuilder, groups);
+    List<ClassMerger> classMergers = initializeClassMergers(codeProvider, lensBuilder, groups);
     SyntheticArgumentClass syntheticArgumentClass =
         mode.isInitial()
             ? new SyntheticArgumentClass.Builder(appView.withLiveness()).build(groups)
             : null;
-    SyntheticClassInitializerConverter.Builder syntheticClassInitializerConverterBuilder =
-        SyntheticClassInitializerConverter.builder(appView);
-    applyClassMergers(
-        classMergers, syntheticArgumentClass, syntheticClassInitializerConverterBuilder);
+    SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder =
+        SyntheticInitializerConverter.builder(appView, codeProvider);
+    applyClassMergers(classMergers, syntheticArgumentClass, syntheticInitializerConverterBuilder);
 
-    SyntheticClassInitializerConverter syntheticClassInitializerConverter =
-        syntheticClassInitializerConverterBuilder.build();
-    if (!syntheticClassInitializerConverter.isEmpty()) {
+    SyntheticInitializerConverter syntheticInitializerConverter =
+        syntheticInitializerConverterBuilder.build();
+    if (!syntheticInitializerConverter.isEmpty()) {
       assert mode.isFinal();
-      syntheticClassInitializerConverterBuilder.build().convert(executorService);
+      syntheticInitializerConverterBuilder.build().convert(executorService);
     }
 
     // Generate the graph lens.
@@ -194,12 +200,16 @@
    * be merged and how the merging should be performed.
    */
   private List<ClassMerger> initializeClassMergers(
+      IRCodeProvider codeProvider,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
       Collection<MergeGroup> groups) {
     List<ClassMerger> classMergers = new ArrayList<>(groups.size());
     for (MergeGroup group : groups) {
       assert group.isNonTrivial();
-      classMergers.add(new ClassMerger.Builder(appView, group).setMode(mode).build(lensBuilder));
+      assert group.hasInstanceFieldMap();
+      assert group.hasTarget();
+      classMergers.add(
+          new ClassMerger.Builder(appView, codeProvider, group, mode).build(lensBuilder));
     }
     return classMergers;
   }
@@ -208,13 +218,10 @@
   private void applyClassMergers(
       Collection<ClassMerger> classMergers,
       SyntheticArgumentClass syntheticArgumentClass,
-      SyntheticClassInitializerConverter.Builder syntheticClassInitializerConverterBuilder) {
+      SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder) {
     for (ClassMerger merger : classMergers) {
-      merger.mergeGroup(syntheticArgumentClass, syntheticClassInitializerConverterBuilder);
+      merger.mergeGroup(syntheticArgumentClass, syntheticInitializerConverterBuilder);
     }
-
-    // Clear type elements cache after IR building.
-    appView.dexItemFactory().clearTypeElementsCache();
   }
 
   /**
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/IRCodeProvider.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/IRCodeProvider.java
new file mode 100644
index 0000000..6976e5a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/IRCodeProvider.java
@@ -0,0 +1,35 @@
+// Copyright (c) 2021, 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.horizontalclassmerging;
+
+import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.code.IRCode;
+
+public class IRCodeProvider {
+
+  private final AppView<AppInfo> appViewForConversion;
+
+  public IRCodeProvider(AppView<? extends AppInfoWithClassHierarchy> appView) {
+    // At this point the code rewritings described by repackaging and synthetic finalization have
+    // not been applied to the code objects. These code rewritings will be applied in the
+    // application writer. We therefore simulate that we are in D8, to allow building IR for each of
+    // the class initializers without applying the unapplied code rewritings, to avoid that we apply
+    // the lens more than once to the same piece of code.
+    AppView<AppInfo> appViewForConversion =
+        AppView.createForD8(AppInfo.createInitialAppInfo(appView.appInfo().app()));
+    appViewForConversion.setGraphLens(appView.graphLens());
+    this.appViewForConversion = appViewForConversion;
+  }
+
+  public IRCode buildIR(ProgramMethod method) {
+    return method
+        .getDefinition()
+        .getCode()
+        .buildIR(method, appViewForConversion, method.getOrigin());
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
index 9a6390a..bba2edd 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
@@ -21,20 +21,14 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InstancePut;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfo;
-import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoFactory;
-import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
 import com.android.tools.r8.utils.WorkList;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import java.util.ArrayList;
 import java.util.List;
@@ -43,36 +37,12 @@
 
   public static InstanceInitializerDescription analyze(
       AppView<? extends AppInfoWithClassHierarchy> appView,
+      IRCodeProvider codeProvider,
       MergeGroup group,
-      ProgramMethod instanceInitializer,
-      ClassInstanceFieldsMerger instanceFieldsMerger,
-      Mode mode) {
+      ProgramMethod instanceInitializer) {
     InstanceInitializerDescription.Builder builder =
         InstanceInitializerDescription.builder(appView, instanceInitializer);
-
-    if (mode.isFinal()) {
-      // TODO(b/189296638): We can't build IR in the final round of class merging without simulating
-      //  that we're in D8.
-      MethodOptimizationInfo optimizationInfo =
-          instanceInitializer.getDefinition().getOptimizationInfo();
-      if (optimizationInfo.mayHaveSideEffects()) {
-        return null;
-      }
-      InstanceInitializerInfo instanceInitializerInfo =
-          optimizationInfo.getContextInsensitiveInstanceInitializerInfo();
-      if (!instanceInitializerInfo.hasParent()) {
-        // We don't know the parent constructor of the first constructor.
-        return null;
-      }
-      DexMethod parent = instanceInitializerInfo.getParent();
-      if (parent.getArity() > 0) {
-        return null;
-      }
-      builder.addInvokeConstructor(parent, ImmutableList.of());
-      return builder.build();
-    }
-
-    IRCode code = instanceInitializer.buildIR(appView);
+    IRCode code = codeProvider.buildIR(instanceInitializer);
     WorkList<BasicBlock> workList = WorkList.newIdentityWorkList(code.entryBlock());
     while (workList.hasNext()) {
       BasicBlock block = workList.next();
@@ -118,12 +88,12 @@
               }
 
               InstanceFieldInitializationInfo initializationInfo =
-                  getInitializationInfo(instancePut.value(), appView, instanceInitializer);
+                  getInitializationInfo(appView, instancePut.value());
               if (initializationInfo == null) {
                 return invalid();
               }
 
-              ProgramField targetField = instanceFieldsMerger.getTargetField(sourceField);
+              ProgramField targetField = group.getTargetInstanceField(sourceField);
               assert targetField != null;
 
               builder.addInstancePut(targetField.getReference(), initializationInfo);
@@ -157,7 +127,7 @@
                   new ArrayList<>(invoke.arguments().size() - 1);
               for (Value argument : Iterables.skip(invoke.arguments(), 1)) {
                 InstanceFieldInitializationInfo initializationInfo =
-                    getInitializationInfo(argument, appView, instanceInitializer);
+                    getInitializationInfo(appView, argument);
                 if (initializationInfo == null) {
                   return invalid();
                 }
@@ -181,23 +151,28 @@
   }
 
   private static InstanceFieldInitializationInfo getInitializationInfo(
-      Value value,
-      AppView<? extends AppInfoWithClassHierarchy> appView,
-      ProgramMethod instanceInitializer) {
-    InstanceFieldInitializationInfoFactory factory =
-        appView.instanceFieldInitializationInfoFactory();
-
+      AppView<? extends AppInfoWithClassHierarchy> appView, Value value) {
     Value root = value.getAliasedValue();
-    if (root.isDefinedByInstructionSatisfying(Instruction::isArgument)) {
-      return factory.createArgumentInitializationInfo(
-          value.getDefinition().asArgument().getIndex());
+    if (root.isPhi()) {
+      return null;
     }
 
-    AbstractValue abstractValue = value.getAbstractValue(appView, instanceInitializer);
-    if (abstractValue.isSingleConstValue()) {
-      return abstractValue.asSingleConstValue();
+    Instruction definition = root.getDefinition();
+    if (definition.isArgument()) {
+      return appView
+          .instanceFieldInitializationInfoFactory()
+          .createArgumentInitializationInfo(root.getDefinition().asArgument().getIndex());
     }
-
+    if (definition.isConstNumber()) {
+      return appView
+          .abstractValueFactory()
+          .createSingleNumberValue(definition.asConstNumber().getRawValue());
+    }
+    if (definition.isConstString()) {
+      return appView
+          .abstractValueFactory()
+          .createSingleStringValue(definition.asConstString().getValue());
+    }
     return null;
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
index b67c652..eea6e6b 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
@@ -16,13 +16,9 @@
 import com.android.tools.r8.cf.code.CfLoad;
 import com.android.tools.r8.cf.code.CfPosition;
 import com.android.tools.r8.cf.code.CfReturnVoid;
-import com.android.tools.r8.code.Instruction;
-import com.android.tools.r8.code.InvokeDirectRange;
-import com.android.tools.r8.code.ReturnVoid;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
-import com.android.tools.r8.graph.DexCode;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
@@ -35,7 +31,6 @@
 import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfo;
 import com.android.tools.r8.utils.IntBox;
-import com.android.tools.r8.utils.IterableUtils;
 import com.google.common.collect.ImmutableList;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -236,34 +231,6 @@
     }
   }
 
-  public DexCode createDexCode(
-      DexMethod newMethodReference,
-      DexMethod originalMethodReference,
-      DexMethod syntheticMethodReference,
-      MergeGroup group,
-      boolean hasClassId,
-      int extraNulls) {
-    assert !hasClassId;
-    assert extraNulls == 0;
-    assert parentConstructorArguments.isEmpty();
-    assert instanceFieldAssignmentsPre.isEmpty();
-    assert instanceFieldAssignmentsPost.isEmpty();
-    Instruction[] instructions = new Instruction[2];
-    instructions[0] = new InvokeDirectRange(0, 1, parentConstructor);
-    instructions[1] = new ReturnVoid();
-    int incomingRegisterSize =
-        1 + IterableUtils.sumInt(newMethodReference.getParameters(), DexType::getRequiredRegisters);
-    int outgoingRegisterSize = 1;
-    return new DexCode(
-        incomingRegisterSize,
-        incomingRegisterSize,
-        outgoingRegisterSize,
-        instructions,
-        new DexCode.Try[0],
-        new DexCode.TryHandler[0],
-        null);
-  }
-
   @Override
   public boolean equals(Object obj) {
     if (obj == null || getClass() != obj.getClass()) {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
index 862a23c..e17c574 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
@@ -23,6 +23,7 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
 import com.android.tools.r8.horizontalclassmerging.code.ConstructorEntryPointSynthesizedCode;
+import com.android.tools.r8.horizontalclassmerging.code.SyntheticInitializerConverter;
 import com.android.tools.r8.ir.conversion.ExtraConstantIntParameter;
 import com.android.tools.r8.ir.conversion.ExtraParameter;
 import com.android.tools.r8.ir.conversion.ExtraUnusedNullParameter;
@@ -277,16 +278,7 @@
       boolean needsClassId,
       int extraNulls) {
     if (hasInstanceInitializerDescription()) {
-      if (mode.isInitial() || appView.options().isGeneratingClassFiles()) {
-        return instanceInitializerDescription.createCfCode(
-            newMethodReference,
-            getOriginalMethodReference(),
-            syntheticMethodReference,
-            group,
-            needsClassId,
-            extraNulls);
-      }
-      return instanceInitializerDescription.createDexCode(
+      return instanceInitializerDescription.createCfCode(
           newMethodReference,
           getOriginalMethodReference(),
           syntheticMethodReference,
@@ -311,7 +303,8 @@
   /** Synthesize a new method which selects the constructor based on a parameter type. */
   void merge(
       ClassMethodsBuilder classMethodsBuilder,
-      SyntheticArgumentClass syntheticArgumentClass) {
+      SyntheticArgumentClass syntheticArgumentClass,
+      SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder) {
     ProgramMethod representative = ListUtils.first(instanceInitializers);
 
     // Create merged instance initializer reference.
@@ -378,5 +371,15 @@
             true,
             getNewClassFileVersion());
     classMethodsBuilder.addDirectMethod(newInstanceInitializer);
+
+    if (mode.isFinal()) {
+      if (appView.options().isGeneratingDex() && !newInstanceInitializer.getCode().isDexCode()) {
+        syntheticInitializerConverterBuilder.add(
+            new ProgramMethod(group.getTarget(), newInstanceInitializer));
+      } else {
+        assert !appView.options().isGeneratingClassFiles()
+            || newInstanceInitializer.getCode().isCfCode();
+      }
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java
index b5e485b..dbf0943 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java
@@ -39,8 +39,8 @@
   public static InstanceInitializerMergerCollection create(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       Reference2IntMap<DexType> classIdentifiers,
+      IRCodeProvider codeProvider,
       MergeGroup group,
-      ClassInstanceFieldsMerger instanceFieldsMerger,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
       Mode mode) {
     // Create an instance initializer merger for each group of instance initializers that are
@@ -54,7 +54,7 @@
                 instanceInitializer -> {
                   InstanceInitializerDescription description =
                       InstanceInitializerAnalysis.analyze(
-                          appView, group, instanceInitializer, instanceFieldsMerger, mode);
+                          appView, codeProvider, group, instanceInitializer);
                   if (description != null) {
                     buildersByDescription
                         .computeIfAbsent(
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroup.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroup.java
index ba5d775..458f0ba 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroup.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroup.java
@@ -6,12 +6,20 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.shaking.KeepClassInfo;
 import com.android.tools.r8.utils.IterableUtils;
 import com.android.tools.r8.utils.IteratorUtils;
+import com.android.tools.r8.utils.collections.BidirectionalManyToOneHashMap;
+import com.android.tools.r8.utils.collections.BidirectionalManyToOneMap;
+import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneMap;
 import com.google.common.collect.Iterables;
 import java.util.Collection;
 import java.util.Iterator;
@@ -29,6 +37,8 @@
   private DexProgramClass target = null;
   private Metadata metadata = null;
 
+  private BidirectionalManyToOneMap<DexEncodedField, DexEncodedField> instanceFieldMap;
+
   public MergeGroup() {
     this.classes = new LinkedList<>();
   }
@@ -104,6 +114,31 @@
     this.classIdField = classIdField;
   }
 
+  public boolean hasInstanceFieldMap() {
+    return instanceFieldMap != null;
+  }
+
+  public BidirectionalManyToOneMap<DexEncodedField, DexEncodedField> getInstanceFieldMap() {
+    assert hasInstanceFieldMap();
+    return instanceFieldMap;
+  }
+
+  public void selectInstanceFieldMap(AppView<? extends AppInfoWithClassHierarchy> appView) {
+    assert hasTarget();
+    MutableBidirectionalManyToOneMap<DexEncodedField, DexEncodedField> instanceFieldMap =
+        BidirectionalManyToOneHashMap.newLinkedHashMap();
+    forEachSource(
+        source ->
+            ClassInstanceFieldsMerger.mapFields(appView, source, target, instanceFieldMap::put));
+    setInstanceFieldMap(instanceFieldMap);
+  }
+
+  public void setInstanceFieldMap(
+      BidirectionalManyToOneMap<DexEncodedField, DexEncodedField> instanceFieldMap) {
+    assert !hasInstanceFieldMap();
+    this.instanceFieldMap = instanceFieldMap;
+  }
+
   public Iterable<DexProgramClass> getSources() {
     assert hasTarget();
     return Iterables.filter(classes, clazz -> clazz != target);
@@ -122,8 +157,40 @@
     return target;
   }
 
-  public void setTarget(DexProgramClass target) {
-    assert classes.contains(target);
+  public ProgramField getTargetInstanceField(ProgramField field) {
+    assert hasTarget();
+    assert hasInstanceFieldMap();
+    if (field.getHolder() == getTarget()) {
+      return field;
+    }
+    DexEncodedField targetField = getInstanceFieldMap().get(field.getDefinition());
+    return new ProgramField(getTarget(), targetField);
+  }
+
+  public void selectTarget(AppView<? extends AppInfoWithClassHierarchy> appView) {
+    Iterable<DexProgramClass> candidates = Iterables.filter(getClasses(), DexClass::isPublic);
+    if (IterableUtils.isEmpty(candidates)) {
+      candidates = getClasses();
+    }
+    Iterator<DexProgramClass> candidateIterator = candidates.iterator();
+    DexProgramClass target = IterableUtils.first(candidates);
+    while (candidateIterator.hasNext()) {
+      DexProgramClass current = candidateIterator.next();
+      KeepClassInfo keepClassInfo = appView.getKeepInfo().getClassInfo(current);
+      if (keepClassInfo.isMinificationAllowed(appView.options())) {
+        target = current;
+        break;
+      }
+      // Select the target with the shortest name.
+      if (current.getType().getDescriptor().size() < target.getType().getDescriptor().size) {
+        target = current;
+      }
+    }
+    setTarget(appView.testing().horizontalClassMergingTarget.apply(appView, candidates, target));
+  }
+
+  private void setTarget(DexProgramClass target) {
+    assert !hasTarget();
     this.target = target;
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
index 6969f94..0d3bf0d 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.horizontalclassmerging.policies.AllInstantiatedOrUninstantiated;
 import com.android.tools.r8.horizontalclassmerging.policies.CheckAbstractClasses;
 import com.android.tools.r8.horizontalclassmerging.policies.CheckSyntheticClasses;
+import com.android.tools.r8.horizontalclassmerging.policies.FinalizeMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.policies.LimitClassGroups;
 import com.android.tools.r8.horizontalclassmerging.policies.MinimizeInstanceFieldCasts;
 import com.android.tools.r8.horizontalclassmerging.policies.NoAnnotationClasses;
@@ -56,12 +57,13 @@
 
   public static List<Policy> getPolicies(
       AppView<? extends AppInfoWithClassHierarchy> appView,
+      IRCodeProvider codeProvider,
       Mode mode,
       RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     List<Policy> policies =
         ImmutableList.<Policy>builder()
             .addAll(getSingleClassPolicies(appView, mode, runtimeTypeCheckInfo))
-            .addAll(getMultiClassPolicies(appView, mode, runtimeTypeCheckInfo))
+            .addAll(getMultiClassPolicies(appView, codeProvider, mode, runtimeTypeCheckInfo))
             .build();
     assert verifyPolicyOrderingConstraints(policies);
     return policies;
@@ -142,6 +144,7 @@
 
   private static List<Policy> getMultiClassPolicies(
       AppView<? extends AppInfoWithClassHierarchy> appView,
+      IRCodeProvider codeProvider,
       Mode mode,
       RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     ImmutableList.Builder<Policy> builder = ImmutableList.builder();
@@ -162,16 +165,24 @@
           new MinimizeInstanceFieldCasts());
     } else {
       assert mode.isFinal();
-      // TODO(b/185472598): Add support for merging class initializers with dex code.
       builder.add(
-          new NoInstanceInitializerMerging(mode),
           new NoVirtualMethodMerging(appView, mode),
           new NoConstructorCollisions(appView, mode));
     }
 
     addMultiClassPoliciesForInterfaceMerging(appView, mode, builder);
 
-    return builder.add(new LimitClassGroups(appView)).build();
+    builder.add(new LimitClassGroups(appView));
+
+    if (mode.isFinal()) {
+      // This needs to reason about equivalence of instance initializers, which relies on the
+      // mapping from instance fields on source classes to the instance fields on target classes.
+      // This policy therefore selects a target for each merge group and creates the mapping for
+      // instance fields. For this reason we run this policy in the very end.
+      builder.add(new NoInstanceInitializerMerging(appView, codeProvider, mode));
+    }
+
+    return builder.add(new FinalizeMergeGroup(appView, mode)).build();
   }
 
   private static void addRequiredMultiClassPolicies(
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/code/SyntheticClassInitializerConverter.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/code/SyntheticInitializerConverter.java
similarity index 66%
rename from src/main/java/com/android/tools/r8/horizontalclassmerging/code/SyntheticClassInitializerConverter.java
rename to src/main/java/com/android/tools/r8/horizontalclassmerging/code/SyntheticInitializerConverter.java
index a31333c..d2414ed 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/code/SyntheticClassInitializerConverter.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/code/SyntheticInitializerConverter.java
@@ -8,7 +8,7 @@
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.IRCodeProvider;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.conversion.IRConverter;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
@@ -23,19 +23,24 @@
  * Converts synthetic class initializers that have been created as a result of merging class
  * initializers into a single class initializer to DEX.
  */
-public class SyntheticClassInitializerConverter {
+public class SyntheticInitializerConverter {
 
   private final AppView<? extends AppInfoWithClassHierarchy> appView;
-  private final List<MergeGroup> groups;
+  private final IRCodeProvider codeProvider;
+  private final List<ProgramMethod> methods;
 
-  private SyntheticClassInitializerConverter(
-      AppView<? extends AppInfoWithClassHierarchy> appView, List<MergeGroup> groups) {
+  private SyntheticInitializerConverter(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      IRCodeProvider codeProvider,
+      List<ProgramMethod> methods) {
     this.appView = appView;
-    this.groups = groups;
+    this.codeProvider = codeProvider;
+    this.methods = methods;
   }
 
-  public static Builder builder(AppView<? extends AppInfoWithClassHierarchy> appView) {
-    return new Builder(appView);
+  public static Builder builder(
+      AppView<? extends AppInfoWithClassHierarchy> appView, IRCodeProvider codeProvider) {
+    return new Builder(appView, codeProvider);
   }
 
   public void convert(ExecutorService executorService) throws ExecutionException {
@@ -51,14 +56,9 @@
     // Build IR for each of the class initializers and finalize.
     IRConverter converter = new IRConverter(appViewForConversion, Timing.empty());
     ThreadUtils.processItems(
-        groups,
-        group -> {
-          ProgramMethod classInitializer = group.getTarget().getProgramClassInitializer();
-          IRCode code =
-              classInitializer
-                  .getDefinition()
-                  .getCode()
-                  .buildIR(classInitializer, appViewForConversion, classInitializer.getOrigin());
+        methods,
+        method -> {
+          IRCode code = codeProvider.buildIR(method);
           converter.removeDeadCodeAndFinalizeIR(
               code, OptimizationFeedbackIgnore.getInstance(), Timing.empty());
         },
@@ -66,25 +66,28 @@
   }
 
   public boolean isEmpty() {
-    return groups.isEmpty();
+    return methods.isEmpty();
   }
 
   public static class Builder {
 
     private final AppView<? extends AppInfoWithClassHierarchy> appView;
-    private final List<MergeGroup> groups = new ArrayList<>();
+    private final IRCodeProvider codeProvider;
+    private final List<ProgramMethod> methods = new ArrayList<>();
 
-    private Builder(AppView<? extends AppInfoWithClassHierarchy> appView) {
+    private Builder(
+        AppView<? extends AppInfoWithClassHierarchy> appView, IRCodeProvider codeProvider) {
       this.appView = appView;
+      this.codeProvider = codeProvider;
     }
 
-    public Builder add(MergeGroup group) {
-      this.groups.add(group);
+    public Builder add(ProgramMethod method) {
+      this.methods.add(method);
       return this;
     }
 
-    public SyntheticClassInitializerConverter build() {
-      return new SyntheticClassInitializerConverter(appView, groups);
+    public SyntheticInitializerConverter build() {
+      return new SyntheticInitializerConverter(appView, codeProvider, methods);
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/FinalizeMergeGroup.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/FinalizeMergeGroup.java
new file mode 100644
index 0000000..705c8cd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/FinalizeMergeGroup.java
@@ -0,0 +1,75 @@
+// Copyright (c) 2020, 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
+import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
+import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.SetUtils;
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * Identifies when instance initializer merging is required and bails out. This is needed to ensure
+ * that we don't need to append extra null arguments at constructor call sites, such that the result
+ * of the final round of class merging can be described as a renaming only.
+ *
+ * <p>This policy requires that all instance initializers with the same signature (relaxed, by
+ * converting references types to java.lang.Object) have the same behavior.
+ */
+public class FinalizeMergeGroup extends MultiClassPolicy {
+
+  private final AppView<? extends AppInfoWithClassHierarchy> appView;
+  private final Mode mode;
+
+  public FinalizeMergeGroup(AppView<? extends AppInfoWithClassHierarchy> appView, Mode mode) {
+    this.appView = appView;
+    this.mode = mode;
+  }
+
+  @Override
+  public Collection<MergeGroup> apply(MergeGroup group) {
+    if (mode.isInitial() || group.isInterfaceGroup()) {
+      group.selectTarget(appView);
+      group.selectInstanceFieldMap(appView);
+    } else {
+      // In the final round of merging each group should be finalized by the
+      // NoInstanceInitializerMerging policy.
+      assert verifyAlreadyFinalized(group);
+    }
+    return ListUtils.newLinkedList(group);
+  }
+
+  @Override
+  public String getName() {
+    return "FinalizeMergeGroup";
+  }
+
+  @Override
+  public boolean isIdentityForInterfaceGroups() {
+    return true;
+  }
+
+  private boolean verifyAlreadyFinalized(MergeGroup group) {
+    assert group.hasTarget();
+    assert group.getClasses().contains(group.getTarget());
+    assert group.hasInstanceFieldMap();
+    Set<DexType> types =
+        SetUtils.newIdentityHashSet(
+            builder -> group.forEach(clazz -> builder.accept(clazz.getType())));
+    group
+        .getInstanceFieldMap()
+        .forEach(
+            (sourceField, targetField) -> {
+              assert types.contains(sourceField.getHolderType());
+              assert types.contains(targetField.getHolderType());
+            });
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java
index 0ff172c..02b6bbd 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java
@@ -4,103 +4,261 @@
 
 package com.android.tools.r8.horizontalclassmerging.policies;
 
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexMethodSignature;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.horizontalclassmerging.ClassInstanceFieldsMerger;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
+import com.android.tools.r8.horizontalclassmerging.IRCodeProvider;
+import com.android.tools.r8.horizontalclassmerging.InstanceInitializerAnalysis;
+import com.android.tools.r8.horizontalclassmerging.InstanceInitializerDescription;
 import com.android.tools.r8.horizontalclassmerging.MergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
-import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
-import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
+import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.SetUtils;
+import com.android.tools.r8.utils.collections.BidirectionalManyToOneHashMap;
+import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneMap;
+import com.android.tools.r8.utils.collections.ProgramMethodMap;
+import com.google.common.collect.Iterators;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
 
 /**
  * Identifies when instance initializer merging is required and bails out. This is needed to ensure
  * that we don't need to append extra null arguments at constructor call sites, such that the result
  * of the final round of class merging can be described as a renaming only.
+ *
+ * <p>This policy requires that all instance initializers with the same signature (relaxed, by
+ * converting references types to java.lang.Object) have the same behavior.
  */
 public class NoInstanceInitializerMerging extends MultiClassPolicy {
 
-  public NoInstanceInitializerMerging(Mode mode) {
+  private final AppView<? extends AppInfoWithClassHierarchy> appView;
+  private final IRCodeProvider codeProvider;
+
+  public NoInstanceInitializerMerging(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      IRCodeProvider codeProvider,
+      Mode mode) {
     assert mode.isFinal();
+    this.appView = appView;
+    this.codeProvider = codeProvider;
   }
 
   @Override
   public Collection<MergeGroup> apply(MergeGroup group) {
+    assert !group.hasTarget();
+    assert !group.hasInstanceFieldMap();
+
+    if (group.isInterfaceGroup()) {
+      return ListUtils.newLinkedList(group);
+    }
+
+    // When we merge equivalent instance initializers with different protos, we find the least upper
+    // bound of each parameter type. As a result of this, the final instance initializer signatures
+    // are not known until all instance initializers in the group are known. Therefore, we disallow
+    // merging of classes that have multiple methods with the same relaxed method signature (where
+    // reference parameters are converted to java.lang.Object), to ensure that merging will result
+    // in a simple renaming (specifically, we must not need to append null arguments to constructor
+    // calls due to constructor collisions).
+    group.removeIf(this::hasMultipleInstanceInitializersWithSameRelaxedSignature);
+
+    if (group.isEmpty()) {
+      return Collections.emptyList();
+    }
+
+    // We want to allow merging of equivalent instance initializers. Equivalence depends on the
+    // mapping of instance fields, so we must compute this mapping now.
+    group.selectTarget(appView);
+    group.selectInstanceFieldMap(appView);
+
     Map<MergeGroup, Map<DexMethodSignature, ProgramMethod>> newGroups = new LinkedHashMap<>();
 
-    for (DexProgramClass clazz : group) {
-      Map<DexMethodSignature, ProgramMethod> classSignatures = new HashMap<>();
-      clazz.forEachProgramInstanceInitializer(
-          method -> classSignatures.put(method.getMethodSignature(), method));
+    // Caching of instance initializer descriptions, which are used to determine equivalence.
+    // TODO(b/181846319): Make this cache available to the instance initializer merger so that we
+    //  don't reanalyze instance initializers.
+    ProgramMethodMap<Optional<InstanceInitializerDescription>> instanceInitializerDescriptions =
+        ProgramMethodMap.create();
+    Function<ProgramMethod, Optional<InstanceInitializerDescription>>
+        instanceInitializerDescriptionProvider =
+            instanceInitializer ->
+                getOrComputeInstanceInitializerDescription(
+                    group, instanceInitializer, instanceInitializerDescriptions);
 
+    // Partition group into smaller groups where there are no (non-equivalent) instance initializer
+    // collisions.
+    for (DexProgramClass clazz : group) {
       MergeGroup newGroup = null;
+      Map<DexMethodSignature, ProgramMethod> classInstanceInitializers =
+          getInstanceInitializersByRelaxedSignature(clazz);
       for (Entry<MergeGroup, Map<DexMethodSignature, ProgramMethod>> entry : newGroups.entrySet()) {
-        Map<DexMethodSignature, ProgramMethod> groupSignatures = entry.getValue();
-        if (canAddClassToGroup(classSignatures.values(), groupSignatures)) {
-          newGroup = entry.getKey();
-          groupSignatures.putAll(classSignatures);
+        MergeGroup candidateGroup = entry.getKey();
+        Map<DexMethodSignature, ProgramMethod> groupInstanceInitializers = entry.getValue();
+        if (canAddClassToGroup(
+            classInstanceInitializers,
+            groupInstanceInitializers,
+            instanceInitializerDescriptionProvider)) {
+          newGroup = candidateGroup;
+          classInstanceInitializers.forEach(groupInstanceInitializers::put);
           break;
         }
       }
-
       if (newGroup != null) {
         newGroup.add(clazz);
       } else {
-        newGroups.put(new MergeGroup(clazz), classSignatures);
+        newGroups.put(new MergeGroup(clazz), classInstanceInitializers);
       }
     }
 
-    return removeTrivialGroups(newGroups.keySet());
+    // Remove trivial groups and finalize the newly created groups.
+    Collection<MergeGroup> newNonTrivialGroups = removeTrivialGroups(newGroups.keySet());
+    setInstanceFieldMaps(newNonTrivialGroups, group);
+    return newNonTrivialGroups;
   }
 
   private boolean canAddClassToGroup(
-      Iterable<ProgramMethod> classMethods,
-      Map<DexMethodSignature, ProgramMethod> groupSignatures) {
-    for (ProgramMethod classMethod : classMethods) {
-      ProgramMethod groupMethod = groupSignatures.get(classMethod.getMethodSignature());
-      if (groupMethod != null && !equivalent(classMethod, groupMethod)) {
+      Map<DexMethodSignature, ProgramMethod> classInstanceInitializers,
+      Map<DexMethodSignature, ProgramMethod> groupInstanceInitializers,
+      Function<ProgramMethod, Optional<InstanceInitializerDescription>>
+          instanceInitializerDescriptionProvider) {
+    for (Entry<DexMethodSignature, ProgramMethod> entry : classInstanceInitializers.entrySet()) {
+      DexMethodSignature relaxedSignature = entry.getKey();
+      ProgramMethod classInstanceInitializer = entry.getValue();
+      ProgramMethod groupInstanceInitializer = groupInstanceInitializers.get(relaxedSignature);
+      if (groupInstanceInitializer == null) {
+        continue;
+      }
+
+      Optional<InstanceInitializerDescription> classInstanceInitializerDescription =
+          instanceInitializerDescriptionProvider.apply(classInstanceInitializer);
+      if (!classInstanceInitializerDescription.isPresent()) {
+        return false;
+      }
+
+      Optional<InstanceInitializerDescription> groupInstanceInitializerDescription =
+          instanceInitializerDescriptionProvider.apply(groupInstanceInitializer);
+      if (!groupInstanceInitializerDescription.isPresent()
+          || !classInstanceInitializerDescription.equals(groupInstanceInitializerDescription)) {
         return false;
       }
     }
     return true;
   }
 
-  // For now, only recognize constructors with 0 parameters that call the same parent constructor.
-  private boolean equivalent(ProgramMethod method, ProgramMethod other) {
-    if (!method.getProto().getParameters().isEmpty()) {
+  private boolean hasMultipleInstanceInitializersWithSameRelaxedSignature(DexProgramClass clazz) {
+    Iterator<ProgramMethod> instanceInitializers = clazz.programInstanceInitializers().iterator();
+    if (!instanceInitializers.hasNext()) {
+      // No instance initializers.
       return false;
     }
 
-    MethodOptimizationInfo optimizationInfo = method.getDefinition().getOptimizationInfo();
-    InstanceInitializerInfo instanceInitializerInfo =
-        optimizationInfo.getContextInsensitiveInstanceInitializerInfo();
-    if (instanceInitializerInfo.isDefaultInstanceInitializerInfo()) {
+    ProgramMethod first = instanceInitializers.next();
+    if (!instanceInitializers.hasNext()) {
+      // Only a single instance initializer.
       return false;
     }
 
-    InstanceInitializerInfo otherInstanceInitializerInfo =
-        other.getDefinition().getOptimizationInfo().getContextInsensitiveInstanceInitializerInfo();
-    assert otherInstanceInitializerInfo.isNonTrivialInstanceInitializerInfo();
-    if (!instanceInitializerInfo.hasParent()
-        || instanceInitializerInfo.getParent().getArity() > 0) {
-      return false;
-    }
+    Set<DexMethod> seen = SetUtils.newIdentityHashSet(getRelaxedSignature(first));
+    return Iterators.any(
+        instanceInitializers,
+        instanceInitializer -> !seen.add(getRelaxedSignature(instanceInitializer)));
+  }
 
-    if (instanceInitializerInfo.getParent() != otherInstanceInitializerInfo.getParent()) {
-      return false;
+  private Map<DexMethodSignature, ProgramMethod> getInstanceInitializersByRelaxedSignature(
+      DexProgramClass clazz) {
+    Map<DexMethodSignature, ProgramMethod> result = new HashMap<>();
+    for (ProgramMethod instanceInitializer : clazz.programInstanceInitializers()) {
+      DexMethodSignature relaxedSignature = getRelaxedSignature(instanceInitializer).getSignature();
+      ProgramMethod previous = result.put(relaxedSignature, instanceInitializer);
+      assert previous == null;
     }
+    return result;
+  }
 
-    return !method.getDefinition().getOptimizationInfo().mayHaveSideEffects()
-        && !other.getDefinition().getOptimizationInfo().mayHaveSideEffects();
+  private Optional<InstanceInitializerDescription> getOrComputeInstanceInitializerDescription(
+      MergeGroup group,
+      ProgramMethod instanceInitializer,
+      ProgramMethodMap<Optional<InstanceInitializerDescription>> instanceInitializerDescriptions) {
+    return instanceInitializerDescriptions.computeIfAbsent(
+        instanceInitializer,
+        key -> {
+          InstanceInitializerDescription instanceInitializerDescription =
+              InstanceInitializerAnalysis.analyze(
+                  appView, codeProvider, group, instanceInitializer);
+          return Optional.ofNullable(instanceInitializerDescription);
+        });
+  }
+
+  private DexMethod getRelaxedSignature(ProgramMethod instanceInitializer) {
+    DexType objectType = appView.dexItemFactory().objectType;
+    DexTypeList parameters = instanceInitializer.getParameters();
+    DexTypeList relaxedParameters =
+        parameters.map(parameter -> parameter.isPrimitiveType() ? parameter : objectType);
+    return parameters != relaxedParameters
+        ? appView
+            .dexItemFactory()
+            .createInstanceInitializer(instanceInitializer.getHolderType(), relaxedParameters)
+        : instanceInitializer.getReference();
+  }
+
+  private void setInstanceFieldMaps(Iterable<MergeGroup> newGroups, MergeGroup group) {
+    for (MergeGroup newGroup : newGroups) {
+      // Set target.
+      newGroup.selectTarget(appView);
+
+      // Construct mapping from instance fields on old target to instance fields on new target.
+      // Note the importance of this: If we create a fresh mapping from the instance fields of each
+      // source class to the new target class, we could invalidate the constructor equivalence.
+      Map<DexEncodedField, DexEncodedField> oldTargetToNewTargetInstanceFieldMap =
+          new IdentityHashMap<>();
+      if (newGroup.getTarget() != group.getTarget()) {
+        ClassInstanceFieldsMerger.mapFields(
+            appView,
+            group.getTarget(),
+            newGroup.getTarget(),
+            oldTargetToNewTargetInstanceFieldMap::put);
+      }
+
+      // Construct mapping from source to target fields.
+      MutableBidirectionalManyToOneMap<DexEncodedField, DexEncodedField> instanceFieldMap =
+          BidirectionalManyToOneHashMap.newLinkedHashMap();
+      newGroup.forEachSource(
+          source ->
+              source.forEachProgramInstanceField(
+                  sourceField -> {
+                    DexEncodedField oldTargetInstanceField =
+                        group.getTargetInstanceField(sourceField).getDefinition();
+                    DexEncodedField newTargetInstanceField =
+                        oldTargetToNewTargetInstanceFieldMap.getOrDefault(
+                            oldTargetInstanceField, oldTargetInstanceField);
+                    instanceFieldMap.put(sourceField.getDefinition(), newTargetInstanceField);
+                  }));
+      newGroup.setInstanceFieldMap(instanceFieldMap);
+    }
   }
 
   @Override
   public String getName() {
     return "NoInstanceInitializerMerging";
   }
+
+  @Override
+  public boolean isIdentityForInterfaceGroups() {
+    return true;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/SetUtils.java b/src/main/java/com/android/tools/r8/utils/SetUtils.java
index 98ea2c4..070e63f 100644
--- a/src/main/java/com/android/tools/r8/utils/SetUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/SetUtils.java
@@ -25,6 +25,12 @@
     return result;
   }
 
+  public static <T> Set<T> newIdentityHashSet(ForEachable<T> forEachable) {
+    Set<T> result = Sets.newIdentityHashSet();
+    forEachable.forEach(result::add);
+    return result;
+  }
+
   public static <T> Set<T> newIdentityHashSet(Iterable<T> c) {
     Set<T> result = Sets.newIdentityHashSet();
     c.forEach(result::add);
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
index ba0ced5..a92437f 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
@@ -116,14 +116,14 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = false)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 16, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 10, "lambdadesugaring"))
         .run();
 
     test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
         .withMinApiLevel(ToolHelper.getMinApiLevelForDexVmNoHigherThan(AndroidApiLevel.K))
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 3, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 2, "lambdadesugaring"))
         .run();
   }
 
@@ -155,14 +155,14 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = false)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 16, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 10, "lambdadesugaring"))
         .run();
 
     test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
         .withMinApiLevel(AndroidApiLevel.N)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 3, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 2, "lambdadesugaring"))
         .run();
   }
 
diff --git a/src/test/java/com/android/tools/r8/classmerging/StatefulSingletonClassesMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/StatefulSingletonClassesMergingTest.java
new file mode 100644
index 0000000..fadf934
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/StatefulSingletonClassesMergingTest.java
@@ -0,0 +1,87 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.classmerging;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverPropagateValue;
+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;
+
+@RunWith(Parameterized.class)
+public class StatefulSingletonClassesMergingTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public StatefulSingletonClassesMergingTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addHorizontallyMergedClassesInspector(
+            inspector -> inspector.assertIsCompleteMergeGroup(A.class, B.class))
+        .enableInliningAnnotations()
+        .enableMemberValuePropagationAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .noClassStaticizing()
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("A", "B");
+  }
+
+  static class Main {
+    public static void main(String[] args) {
+      A.INSTANCE.f();
+      B.INSTANCE.g();
+    }
+  }
+
+  @NeverClassInline
+  static class A {
+
+    static final A INSTANCE = new A("A");
+
+    @NeverPropagateValue private final String data;
+
+    A(String data) {
+      this.data = data;
+    }
+
+    @NeverInline
+    void f() {
+      System.out.println(data);
+    }
+  }
+
+  @NeverClassInline
+  static class B {
+
+    static final B INSTANCE = new B("B");
+
+    @NeverPropagateValue private final String data;
+
+    B(String data) {
+      this.data = data;
+    }
+
+    @NeverInline
+    void g() {
+      System.out.println(data);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java
index e063a4b..d784a77 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java
@@ -8,6 +8,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
 import org.junit.Test;
 
 public class DistinguishExceptionClassesTest extends HorizontalClassMergingTestBase {
@@ -20,6 +21,8 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
+        .addHorizontallyMergedClassesInspector(
+            HorizontallyMergedClassesInspector::assertNoClassesMerged)
         .setMinApi(parameters.getApiLevel())
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("test success")