diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 02abab8..753d1b1 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.6.32";
+  public static final String LABEL = "1.6.33";
 
   private Version() {
   }
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 36e4cc8..e52c246 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -213,6 +213,8 @@
       createString("Ljava/lang/reflect/InvocationHandler;");
   public final DexString proxyDescriptor = createString("Ljava/lang/reflect/Proxy;");
   public final DexString serviceLoaderDescriptor = createString("Ljava/util/ServiceLoader;");
+  public final DexString serviceLoaderConfigurationErrorDescriptor =
+      createString("Ljava/util/ServiceConfigurationError;");
   public final DexString listDescriptor = createString("Ljava/util/List;");
   public final DexString comparatorDescriptor = createString("Ljava/util/Comparator;");
   public final DexString callableDescriptor = createString("Ljava/util/concurrent/Callable;");
@@ -301,6 +303,8 @@
   public final DexType invocationHandlerType = createType(invocationHandlerDescriptor);
   public final DexType proxyType = createType(proxyDescriptor);
   public final DexType serviceLoaderType = createType(serviceLoaderDescriptor);
+  public final DexType serviceLoaderConfigurationErrorType =
+      createType(serviceLoaderConfigurationErrorDescriptor);
   public final DexType listType = createType(listDescriptor);
   public final DexType comparatorType = createType(comparatorDescriptor);
   public final DexType callableType = createType(callableDescriptor);
@@ -574,6 +578,7 @@
   public class ThrowableMethods {
 
     public final DexMethod addSuppressed;
+    public final DexMethod getMessage;
     public final DexMethod getSuppressed;
     public final DexMethod initCause;
 
@@ -584,6 +589,12 @@
           createString("getSuppressed"), throwableArrayDescriptor, DexString.EMPTY_ARRAY);
       initCause = createMethod(throwableDescriptor, createString("initCause"), throwableDescriptor,
           new DexString[] { throwableDescriptor });
+      getMessage =
+          createMethod(
+              throwableDescriptor,
+              createString("getMessage"),
+              stringDescriptor,
+              DexString.EMPTY_ARRAY);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index 83ecf82..055b120 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
 import com.android.tools.r8.ir.desugar.NestBasedAccessDesugaring;
 import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
+import com.android.tools.r8.ir.optimize.ServiceLoaderRewriter;
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -258,7 +259,8 @@
         || name.contains(OutlineOptions.CLASS_NAME)
         || name.contains(TwrCloseResourceRewriter.UTILITY_CLASS_NAME)
         || name.contains(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME)
-        || name.contains(BackportedMethodRewriter.UTILITY_CLASS_NAME_PREFIX);
+        || name.contains(BackportedMethodRewriter.UTILITY_CLASS_NAME_PREFIX)
+        || name.contains(ServiceLoaderRewriter.SERVICE_LOADER_CLASS_NAME);
   }
 
   public boolean isProgramType(DexDefinitionSupplier definitions) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index e370192..9c4215e 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -161,6 +161,7 @@
   private final UninstantiatedTypeOptimization uninstantiatedTypeOptimization;
   private final TypeChecker typeChecker;
   private final DesugaredLibraryAPIConverter desugaredLibraryAPIConverter;
+  private final ServiceLoaderRewriter serviceLoaderRewriter;
 
   // Assumers that will insert Assume instructions.
   private final AliasIntroducer aliasIntroducer;
@@ -243,6 +244,7 @@
       this.d8NestBasedAccessDesugaring = null;
       this.stringSwitchRemover = null;
       this.desugaredLibraryAPIConverter = null;
+      this.serviceLoaderRewriter = null;
       return;
     }
     this.lambdaRewriter = options.enableDesugaring ? new LambdaRewriter(appView, this) : null;
@@ -309,6 +311,10 @@
               : null;
       this.typeChecker = new TypeChecker(appView.withLiveness());
       this.d8NestBasedAccessDesugaring = null;
+      this.serviceLoaderRewriter =
+          options.enableServiceLoaderRewriting
+              ? new ServiceLoaderRewriter(appView.withLiveness())
+              : null;
     } else {
       this.classInliner = null;
       this.classStaticizer = null;
@@ -326,6 +332,7 @@
       this.typeChecker = null;
       this.d8NestBasedAccessDesugaring =
           options.shouldDesugarNests() ? new D8NestBasedAccessDesugaring(appView) : null;
+      this.serviceLoaderRewriter = null;
     }
     this.stringSwitchRemover =
         options.isStringSwitchConversionEnabled()
@@ -717,6 +724,12 @@
     printPhase("Lambda merging finalization");
     finalizeLambdaMerging(application, feedback, builder, executorService);
 
+    if (serviceLoaderRewriter != null && serviceLoaderRewriter.getSynthesizedClass() != null) {
+      forEachSynthesizedServiceLoaderMethod(
+          executorService, serviceLoaderRewriter.getSynthesizedClass());
+      builder.addSynthesizedClass(serviceLoaderRewriter.getSynthesizedClass(), true);
+    }
+
     if (outliner != null) {
       printPhase("Outlining");
       timing.begin("IR conversion phase 3");
@@ -842,6 +855,24 @@
     ThreadUtils.awaitFutures(futures);
   }
 
+  private void forEachSynthesizedServiceLoaderMethod(
+      ExecutorService executorService, DexClass synthesizedClass) throws ExecutionException {
+    List<Future<?>> futures = new ArrayList<>();
+    for (DexEncodedMethod method : synthesizedClass.methods()) {
+      futures.add(
+          executorService.submit(
+              () -> {
+                IRCode code =
+                    method.buildIR(appView, appView.appInfo().originFor(method.method.holder));
+                assert code != null;
+                codeRewriter.rewriteMoveResult(code);
+                finalizeIR(method, code, OptimizationFeedbackIgnore.getInstance());
+                return null;
+              }));
+    }
+    ThreadUtils.awaitFutures(futures);
+  }
+
   private void collectLambdaMergingCandidates(DexApplication application) {
     if (lambdaMerger != null) {
       lambdaMerger.collectGroupCandidates(application, appView.withLiveness());
@@ -1092,9 +1123,9 @@
     // we will return with finalizeEmptyThrowingCode() above.
     assert code.verifyTypes(appView);
 
-    if (appView.enableWholeProgramOptimizations() && options.enableServiceLoaderRewriting) {
+    if (serviceLoaderRewriter != null) {
       assert appView.appInfo().hasLiveness();
-      ServiceLoaderRewriter.rewrite(code, appView.withLiveness());
+      serviceLoaderRewriter.rewrite(code);
     }
 
     if (classStaticizer != null) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
index 376e186..08aefe9 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
@@ -19,6 +19,8 @@
 
 public interface MethodOptimizationFeedback {
 
+  void markForceInline(DexEncodedMethod method);
+
   void markInlinedIntoSingleCallSite(DexEncodedMethod method);
 
   void markMethodCannotBeKept(DexEncodedMethod method);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/ServiceLoaderSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/ServiceLoaderSourceCode.java
new file mode 100644
index 0000000..74b1631
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/ServiceLoaderSourceCode.java
@@ -0,0 +1,113 @@
+// Copyright (c) 2019, 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.desugar;
+
+import static org.objectweb.asm.Opcodes.INVOKEINTERFACE;
+import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
+import static org.objectweb.asm.Opcodes.INVOKESTATIC;
+import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
+
+import com.android.tools.r8.cf.code.CfArrayStore;
+import com.android.tools.r8.cf.code.CfConstNumber;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfLabel;
+import com.android.tools.r8.cf.code.CfLoad;
+import com.android.tools.r8.cf.code.CfNew;
+import com.android.tools.r8.cf.code.CfNewArray;
+import com.android.tools.r8.cf.code.CfReturn;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStore;
+import com.android.tools.r8.cf.code.CfThrow;
+import com.android.tools.r8.cf.code.CfTryCatch;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.MemberType;
+import com.android.tools.r8.ir.code.ValueType;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+
+public class ServiceLoaderSourceCode {
+
+  // This is building the following implementation for service-loader rewriting:
+  // public static <S> Iterator<S> loadS() {
+  //   try {
+  //     return Arrays.asList(X, Y, Z).iterator();
+  //   } catch (Throwable t) {
+  //     throw new ServiceConfigurationError(t.getMessage(), t);
+  //   }
+  // }
+  public static CfCode generate(
+      DexType serviceType, List<DexClass> classes, DexItemFactory factory) {
+    ImmutableList.Builder<CfInstruction> builder = ImmutableList.builder();
+
+    CfLabel tryCatchStart = new CfLabel();
+    CfLabel tryCatchEnd = new CfLabel();
+
+    builder.add(
+        tryCatchStart,
+        new CfConstNumber(classes.size(), ValueType.INT),
+        new CfNewArray(factory.createArrayType(1, serviceType)));
+
+    for (int i = 0; i < classes.size(); i++) {
+      builder.add(
+          new CfStackInstruction(CfStackInstruction.Opcode.Dup),
+          new CfConstNumber(i, ValueType.INT),
+          new CfNew(classes.get(i).type),
+          new CfStackInstruction(CfStackInstruction.Opcode.Dup),
+          new CfInvoke(
+              INVOKESPECIAL,
+              factory.createMethod(
+                  classes.get(i).type,
+                  factory.createProto(factory.voidType),
+                  factory.constructorMethodName),
+              false),
+          new CfArrayStore(MemberType.OBJECT));
+    }
+
+    builder.add(
+        new CfInvoke(INVOKESTATIC, factory.utilArraysMethods.asList, false),
+        new CfInvoke(
+            INVOKEINTERFACE,
+            factory.createMethod(
+                factory.listType,
+                factory.createProto(factory.iteratorType),
+                factory.createString("iterator")),
+            true),
+        tryCatchEnd,
+        new CfReturn(ValueType.OBJECT));
+
+    // Build the exception handler.
+    CfLabel tryCatchHandler = new CfLabel();
+    builder.add(
+        tryCatchHandler,
+        new CfStore(ValueType.OBJECT, 0),
+        new CfNew(factory.serviceLoaderConfigurationErrorType),
+        new CfStackInstruction(CfStackInstruction.Opcode.Dup),
+        new CfLoad(ValueType.OBJECT, 0),
+        new CfInvoke(INVOKEVIRTUAL, factory.throwableMethods.getMessage, false),
+        new CfLoad(ValueType.OBJECT, 0),
+        new CfInvoke(
+            INVOKESPECIAL,
+            factory.createMethod(
+                factory.serviceLoaderConfigurationErrorType,
+                factory.createProto(factory.voidType, factory.stringType, factory.throwableType),
+                factory.constructorMethodName),
+            false),
+        new CfThrow());
+
+    CfTryCatch cfTryCatch =
+        new CfTryCatch(
+            tryCatchStart,
+            tryCatchEnd,
+            ImmutableList.of(factory.throwableType),
+            ImmutableList.of(tryCatchHandler));
+
+    return new CfCode(
+        null, 5, 1, builder.build(), ImmutableList.of(cfTryCatch), ImmutableList.of());
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
index 89e0f2d..7830f6e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
@@ -4,33 +4,36 @@
 
 package com.android.tools.r8.ir.optimize;
 
-import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
-
+import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ClassAccessFlags;
+import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
-import com.android.tools.r8.ir.code.ArrayPut;
+import com.android.tools.r8.graph.DexTypeList;
+import com.android.tools.r8.graph.MethodAccessFlags;
+import com.android.tools.r8.graph.ParameterAnnotationsList;
 import com.android.tools.r8.ir.code.ConstClass;
-import com.android.tools.r8.ir.code.ConstNumber;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.InvokeDirect;
-import com.android.tools.r8.ir.code.InvokeInterface;
 import com.android.tools.r8.ir.code.InvokeStatic;
 import com.android.tools.r8.ir.code.InvokeVirtual;
-import com.android.tools.r8.ir.code.MemberType;
-import com.android.tools.r8.ir.code.NewArrayEmpty;
-import com.android.tools.r8.ir.code.NewInstance;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.desugar.ServiceLoaderSourceCode;
+import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * ServiceLoaderRewriter will attempt to rewrite calls on the form of: ServiceLoader.load(X.class,
@@ -61,7 +64,24 @@
  */
 public class ServiceLoaderRewriter {
 
-  public static void rewrite(IRCode code, AppView<? extends AppInfoWithLiveness> appView) {
+  public static final String SERVICE_LOADER_CLASS_NAME = "$$ServiceLoaderMethods";
+  private static final String SERVICE_LOADER_METHOD_PREFIX_NAME = "$load";
+
+  private DexProgramClass synthesizedClass;
+  private ConcurrentHashMap<DexType, DexEncodedMethod> synthesizedServiceLoaders =
+      new ConcurrentHashMap<>();
+
+  private final AppView<? extends AppInfoWithLiveness> appView;
+
+  public ServiceLoaderRewriter(AppView<? extends AppInfoWithLiveness> appView) {
+    this.appView = appView;
+  }
+
+  public DexProgramClass getSynthesizedClass() {
+    return synthesizedClass;
+  }
+
+  public void rewrite(IRCode code) {
     DexItemFactory factory = appView.dexItemFactory();
     InstructionListIterator instructionIterator = code.instructionListIterator();
     while (instructionIterator.hasNext()) {
@@ -144,71 +164,106 @@
       }
 
       // We can perform the rewrite of the ServiceLoader.load call.
-      new Rewriter(appView, code, instructionIterator, serviceLoaderLoad)
-          .perform(classLoaderInvoke, constClass.getValue(), classes);
+      DexEncodedMethod synthesizedMethod =
+          synthesizedServiceLoaders.computeIfAbsent(
+              constClass.getValue(),
+              service -> {
+                DexEncodedMethod addedMethod = createSynthesizedMethod(service, classes);
+                if (appView.options().isGeneratingClassFiles()) {
+                  addedMethod.upgradeClassFileVersion(code.method.getClassFileVersion());
+                }
+                return addedMethod;
+              });
+
+      new Rewriter(code, instructionIterator, serviceLoaderLoad)
+          .perform(classLoaderInvoke, synthesizedMethod.method);
     }
   }
 
+  private DexEncodedMethod createSynthesizedMethod(DexType serviceType, List<DexClass> classes) {
+    DexType serviceLoaderType =
+        appView.dexItemFactory().createType("L" + SERVICE_LOADER_CLASS_NAME + ";");
+    if (synthesizedClass == null) {
+      synthesizedClass =
+          new DexProgramClass(
+              serviceLoaderType,
+              null,
+              new SynthesizedOrigin("Service Loader desugaring", getClass()),
+              ClassAccessFlags.fromDexAccessFlags(
+                  Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
+              appView.dexItemFactory().objectType,
+              DexTypeList.empty(),
+              appView.dexItemFactory().createString("ServiceLoader"),
+              null,
+              Collections.emptyList(),
+              null,
+              Collections.emptyList(),
+              DexAnnotationSet.empty(),
+              DexEncodedField.EMPTY_ARRAY, // Static fields.
+              DexEncodedField.EMPTY_ARRAY, // Instance fields.
+              DexEncodedMethod.EMPTY_ARRAY,
+              DexEncodedMethod.EMPTY_ARRAY, // Virtual methods.
+              appView.dexItemFactory().getSkipNameValidationForTesting());
+      appView.appInfo().addSynthesizedClass(synthesizedClass);
+    }
+    DexProto proto = appView.dexItemFactory().createProto(appView.dexItemFactory().iteratorType);
+    DexMethod method =
+        appView
+            .dexItemFactory()
+            .createMethod(
+                serviceLoaderType,
+                proto,
+                SERVICE_LOADER_METHOD_PREFIX_NAME + synthesizedServiceLoaders.size());
+    MethodAccessFlags methodAccess =
+        MethodAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_STATIC, false);
+    DexEncodedMethod encodedMethod =
+        new DexEncodedMethod(
+            method,
+            methodAccess,
+            DexAnnotationSet.empty(),
+            ParameterAnnotationsList.empty(),
+            ServiceLoaderSourceCode.generate(serviceType, classes, appView.dexItemFactory()));
+    synthesizedClass.addDirectMethod(encodedMethod);
+    return encodedMethod;
+  }
+
   /**
-   * Rewriter will look assume that code is on the form:
+   * Rewriter assumes that the code is of the form:
    *
    * <pre>
    * ConstClass         v1 <- X
-   * ConstClass         v2 <- X
+   * ConstClass         v2 <- X or NULL
    * Invoke-Virtual     v3 <- v2; method: java.lang.ClassLoader java.lang.Class.getClassLoader()
    * Invoke-Static      v4 <- v1, v3; method: java.util.ServiceLoader java.util.ServiceLoader
    *     .load(java.lang.Class, java.lang.ClassLoader)
    * Invoke-Virtual     v5 <- v4; method: java.util.Iterator java.util.ServiceLoader.iterator()
    * </pre>
    *
-   * and rewrites it to for classes impl(X) defined in META-INF/services/X:
+   * and rewrites it to:
    *
    * <pre>
-   * ConstClass         v1 <- X
-   * ConstClass         v2 <- X
-   * ConstNumber        va <-  impl(X).size() (INT)
-   * NewArrayEmpty      vb <- va X[]
-   * for i = 0 to C - 1:
-   *   ConstNumber        vc(i) <-  i (INT)
-   *   NewInstance        vd <-  impl(X).get(i)
-   *   Invoke-Direct      vd; method: void impl(X).get(i).<init>()
-   *   ArrayPut           vb, vc(i), vd
-   * end for
-   * Invoke-Static      ve <- vb; method: java.util.List java.util.Arrays.asList(java.lang.Object[])
-   * Invoke-Interface   v5 <- ve; method: java.util.Iterator java.util.List.iterator()
+   * Invoke-Static      v5 <- ; method: java.util.Iterator syn(X)()
    * </pre>
    *
-   * We rely on the DeadCodeRemover to remove the ConstClasses and any aliased values no longer
+   * where syn(X) is the synthesized method generated for the service class.
+   *
+   * <p>We rely on the DeadCodeRemover to remove the ConstClasses and any aliased values no longer
    * used.
    */
   private static class Rewriter {
 
-    private final AppView appView;
-    private final DexItemFactory factory;
     private final IRCode code;
     private final InvokeStatic serviceLoaderLoad;
 
     private InstructionListIterator iterator;
-    private MemberType memberType;
-    private Value valueArray;
-    private int index = 0;
 
-    public Rewriter(
-        AppView appView,
-        IRCode code,
-        InstructionListIterator iterator,
-        InvokeStatic serviceLoaderLoad) {
-      this.appView = appView;
-      this.factory = appView.dexItemFactory();
+    Rewriter(IRCode code, InstructionListIterator iterator, InvokeStatic serviceLoaderLoad) {
       this.iterator = iterator;
       this.code = code;
       this.serviceLoaderLoad = serviceLoaderLoad;
     }
 
-    public void perform(InvokeVirtual classLoaderInvoke, DexType dexType, List<DexClass> classes) {
-      assert valueArray == null;
-      assert memberType == null;
-
+    public void perform(InvokeVirtual classLoaderInvoke, DexMethod method) {
       // Remove the ClassLoader call since this can throw and will not be removed otherwise.
       if (classLoaderInvoke != null) {
         clearGetClassLoader(classLoaderInvoke);
@@ -220,69 +275,11 @@
           serviceLoaderLoad.outValue().singleUniqueUser().asInvokeVirtual();
       iterator.replaceCurrentInstruction(code.createConstNull());
 
-      // Build the array for the "loaded" classes.
-      ConstNumber arrayLength = code.createIntConstant(classes.size());
-      arrayLength.setPosition(serviceLoaderLoad.getPosition());
-      iterator.add(arrayLength);
-
-      DexType arrayType = factory.createArrayType(1, dexType);
-      TypeLatticeElement arrayLatticeElement =
-          TypeLatticeElement.fromDexType(arrayType, definitelyNotNull(), appView);
-      valueArray = code.createValue(arrayLatticeElement);
-      NewArrayEmpty newArrayEmpty =
-          new NewArrayEmpty(valueArray, arrayLength.outValue(), arrayType);
-      newArrayEmpty.setPosition(serviceLoaderLoad.getPosition());
-      iterator.add(newArrayEmpty);
-
-      this.memberType = MemberType.fromDexType(dexType);
-
-      // Add all new instances to the array.
-      classes.forEach(this::addNewServiceAndPutInArray);
-
-      // Build the Arrays.asList(...) instruction.
-      Value vArrayAsList =
-          code.createValue(
-              TypeLatticeElement.fromDexType(factory.listType, definitelyNotNull(), appView));
-      InvokeStatic arraysAsList =
-          new InvokeStatic(
-              factory.utilArraysMethods.asList, vArrayAsList, ImmutableList.of(valueArray));
-      arraysAsList.setPosition(serviceLoaderLoad.getPosition());
-      iterator.add(arraysAsList);
-
       // Find the iterator instruction and replace it.
       iterator.nextUntil(x -> x == serviceLoaderIterator);
-
-      DexMethod method =
-          factory.createMethod(
-              factory.listType, factory.createProto(factory.iteratorType), "iterator");
-      InvokeInterface arrayIterator =
-          new InvokeInterface(
-              method, serviceLoaderIterator.outValue(), ImmutableList.of(vArrayAsList));
-      iterator.replaceCurrentInstruction(arrayIterator);
-    }
-
-    private void addNewServiceAndPutInArray(DexClass clazz) {
-      ConstNumber indexInArray = code.createIntConstant(index++);
-      indexInArray.setPosition(serviceLoaderLoad.getPosition());
-      iterator.add(indexInArray);
-
-      TypeLatticeElement clazzLatticeElement =
-          TypeLatticeElement.fromDexType(clazz.type, definitelyNotNull(), appView);
-      Value vInstance = code.createValue(clazzLatticeElement);
-      NewInstance newInstance = new NewInstance(clazz.type, vInstance);
-      newInstance.setPosition(serviceLoaderLoad.getPosition());
-      iterator.add(newInstance);
-
-      DexMethod method = clazz.getDefaultInitializer().method;
-      assert method.getArity() == 0;
-      InvokeDirect invokeDirect =
-          new InvokeDirect(method, null, Collections.singletonList(vInstance));
-      invokeDirect.setPosition(serviceLoaderLoad.getPosition());
-      iterator.add(invokeDirect);
-
-      ArrayPut put = new ArrayPut(memberType, valueArray, indexInArray.outValue(), vInstance);
-      put.setPosition(serviceLoaderLoad.getPosition());
-      iterator.add(put);
+      InvokeStatic synthesizedInvoke =
+          new InvokeStatic(method, serviceLoaderIterator.outValue(), ImmutableList.of());
+      iterator.replaceCurrentInstruction(synthesizedInvoke);
     }
 
     private void clearGetClassLoader(InvokeVirtual classLoaderInvoke) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
index 162642c..d185a37 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
@@ -107,6 +107,11 @@
   // METHOD OPTIMIZATION INFO:
 
   @Override
+  public void markForceInline(DexEncodedMethod method) {
+    getMethodOptimizationInfoForUpdating(method).markForceInline();
+  }
+
+  @Override
   public synchronized void markInlinedIntoSingleCallSite(DexEncodedMethod method) {
     getMethodOptimizationInfoForUpdating(method).markInlinedIntoSingleCallSite();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
index ea5afa0..79b2e7f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
@@ -44,6 +44,9 @@
   // METHOD OPTIMIZATION INFO:
 
   @Override
+  public void markForceInline(DexEncodedMethod method) {}
+
+  @Override
   public void markInlinedIntoSingleCallSite(DexEncodedMethod method) {}
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
index 537cbd1..9119b4b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
@@ -52,6 +52,11 @@
   // METHOD OPTIMIZATION INFO.
 
   @Override
+  public void markForceInline(DexEncodedMethod method) {
+    // Ignored.
+  }
+
+  @Override
   public synchronized void markInlinedIntoSingleCallSite(DexEncodedMethod method) {
     method.getMutableOptimizationInfo().markInlinedIntoSingleCallSite();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
index a90efc7..4ce3033 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
@@ -79,6 +79,10 @@
     }
   }
 
+  public final boolean allLambdas(Predicate<LambdaInfo> predicate) {
+    return !anyLambda(lambda -> !predicate.test(lambda));
+  }
+
   public final boolean anyLambda(Predicate<LambdaInfo> predicate) {
     assert verifyLambdaIds(false);
     for (LambdaInfo info : lambdas.values()) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
index f399ad6..89451c9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
@@ -228,6 +228,11 @@
     // sequential lambda ids, create group lambda classes.
     Map<LambdaGroup, DexProgramClass> lambdaGroupsClasses = finalizeLambdaGroups();
 
+    // Mark all the implementation methods for force inlining.
+    for (LambdaGroup group : lambdaGroupsClasses.keySet()) {
+      group.forEachLambda(info -> info.clazz.virtualMethods().forEach(feedback::markForceInline));
+    }
+
     // Fixup optimization info to ensure that the optimization info does not refer to any merged
     // lambdas.
     LambdaMergerOptimizationInfoFixer optimizationInfoFixer =
@@ -238,7 +243,6 @@
     this.strategyFactory = (method, code) -> new ApplyStrategy(method, code, optimizationInfoFixer);
 
     // Add synthesized lambda group classes to the builder.
-
     for (Entry<LambdaGroup, DexProgramClass> entry : lambdaGroupsClasses.entrySet()) {
       DexProgramClass synthesizedClass = entry.getValue();
       appView.appInfo().addSynthesizedClass(synthesizedClass);
@@ -254,6 +258,18 @@
       synthesizedClass.forEachMethod(
           encodedMethod -> encodedMethod.markProcessed(ConstraintWithTarget.NEVER));
     }
+
+    // Verify that all implementation methods are marked for force inlining (i.e., check that the
+    // delayed optimization feedback has been flushed).
+    assert lambdaGroupsClasses.keySet().stream()
+        .allMatch(
+            group ->
+                group.allLambdas(
+                    lambda ->
+                        lambda.clazz.virtualMethods().stream()
+                            .map(DexEncodedMethod::getOptimizationInfo)
+                            .allMatch(MethodOptimizationInfo::forceInline)));
+
     converter.optimizeSynthesizedClasses(lambdaGroupsClasses.values(), executorService);
 
     // Rewrite lambda class references into lambda group class
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupClassBuilder.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupClassBuilder.java
index 4226daa..15d4160 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupClassBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupClassBuilder.java
@@ -105,14 +105,6 @@
         // anyways and our new method is a product of inlining.
         MethodAccessFlags accessFlags = MAIN_METHOD_FLAGS.copy();
 
-        // Mark all the impl methods for force inlining
-        // LambdaGroupVirtualMethodSourceCode relies on.
-        for (DexEncodedMethod implMethod : implMethods) {
-          if (implMethod != null) {
-            implMethod.getMutableOptimizationInfo().markForceInline();
-          }
-        }
-
         DexMethod method = factory.createMethod(group.getGroupClassType(), methodProto, methodName);
         result.add(
             new DexEncodedMethod(