diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 11d013c..d7a4efa 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.4.78";
+  public static final String LABEL = "1.4.79";
 
   private Version() {
   }
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 edd33c8..32fc687 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
@@ -559,7 +559,7 @@
     if (inliner != null) {
       printPhase("Double caller inlining");
       assert graphLenseForIR == graphLense();
-      inliner.processDoubleInlineCallers(this, feedback);
+      inliner.processDoubleInlineCallers(this, executorService, feedback);
       feedback.updateVisibleOptimizationInfo();
       assert graphLenseForIR == graphLense();
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index 2b0d831..30fb191 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -32,6 +32,7 @@
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.MainDexClasses;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -39,8 +40,10 @@
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 
 public class Inliner {
 
@@ -160,24 +163,29 @@
     return target;
   }
 
-  public synchronized void processDoubleInlineCallers(
-      IRConverter converter, OptimizationFeedback feedback) {
-    if (doubleInlineCallers.size() > 0) {
-      applyDoubleInlining = true;
-      List<DexEncodedMethod> methods = doubleInlineCallers
-          .stream()
-          .sorted(DexEncodedMethod::slowCompare)
-          .collect(Collectors.toList());
-      for (DexEncodedMethod method : methods) {
-        converter.processMethod(
-            method,
-            feedback,
-            x -> false,
-            CallSiteInformation.empty(),
-            Outliner::noProcessing);
-        assert method.isProcessed();
-      }
+  public void processDoubleInlineCallers(
+      IRConverter converter, ExecutorService executorService, OptimizationFeedback feedback)
+      throws ExecutionException {
+    if (doubleInlineCallers.isEmpty()) {
+      return;
     }
+    applyDoubleInlining = true;
+    List<Future<?>> futures = new ArrayList<>();
+    for (DexEncodedMethod method : doubleInlineCallers) {
+      futures.add(
+          executorService.submit(
+              () -> {
+                converter.processMethod(
+                    method,
+                    feedback,
+                    doubleInlineCallers::contains,
+                    CallSiteInformation.empty(),
+                    Outliner::noProcessing);
+                assert method.isProcessed();
+                return null;
+              }));
+    }
+    ThreadUtils.awaitFutures(futures);
   }
 
   /**
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
index 236cb92..f53c120 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
@@ -94,6 +94,7 @@
     String javaOutput = runOnJava(main);
     TestRunResult result = testForR8(backend)
         .addProgramClasses(classes)
+        .enableInliningAnnotations()
         .addKeepMainRule(main)
         .addKeepRules(
             "-dontobfuscate", "-allowaccessmodification", "-keepattributes LineNumberTable")
@@ -172,7 +173,6 @@
     String javaOutput = runOnJava(main);
     TestRunResult result = testForR8(backend)
         .addProgramClasses(classes)
-        .enableProguardTestOptions()
         .enableInliningAnnotations()
         .addKeepMainRule(main)
         .addKeepRules(
@@ -277,6 +277,7 @@
     String javaOutput = runOnJava(main);
     TestRunResult result = testForR8(backend)
         .addProgramClasses(classes)
+        .enableInliningAnnotations()
         .addKeepMainRule(main)
         .addKeepRules(
             "-dontobfuscate", "-allowaccessmodification", "-keepattributes LineNumberTable")
@@ -317,6 +318,8 @@
     String javaOutput = runOnJava(main);
     TestRunResult result = testForR8(backend)
         .addProgramClasses(classes)
+        .enableProguardTestOptions()
+        .enableInliningAnnotations()
         .addKeepMainRule(main)
         .addKeepRules(
             "-dontobfuscate", "-allowaccessmodification", "-keepattributes LineNumberTable")
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java
index 38e75c4..dcfb5eb 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.ir.optimize.classinliner.code;
 
+import com.android.tools.r8.NeverInline;
+
 public class C {
   public static class L {
     public final int x;
@@ -25,15 +27,18 @@
     }
   }
 
-  public synchronized static int method1() {
+  @NeverInline
+  public static int method1() {
     return new L(1).x;
   }
 
-  public synchronized static int method2() {
+  @NeverInline
+  public static int method2() {
     return new L(1).getX();
   }
 
-  public synchronized static int method3() {
+  @NeverInline
+  public static int method3() {
     return F.I.getX();
   }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/invalidroot/InvalidRootsTestClass.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/invalidroot/InvalidRootsTestClass.java
index 26dc8cc..8bba53e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/invalidroot/InvalidRootsTestClass.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/invalidroot/InvalidRootsTestClass.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.ir.optimize.classinliner.invalidroot;
 
+import com.android.tools.r8.NeverInline;
+
 public class InvalidRootsTestClass {
   private static int ID = 0;
 
@@ -19,7 +21,8 @@
     test.testRootInvalidatesAfterInlining();
   }
 
-  private synchronized void testExtraNeverReturnsNormally() {
+  @NeverInline
+  private void testExtraNeverReturnsNormally() {
     testExtraNeverReturnsNormallyA();
     testExtraNeverReturnsNormallyB();
 
@@ -31,7 +34,8 @@
     }
   }
 
-  private synchronized void testExtraNeverReturnsNormallyA() {
+  @NeverInline
+  private void testExtraNeverReturnsNormallyA() {
     try {
       neverReturnsNormallyExtra(next(), null);
     } catch (RuntimeException re) {
@@ -39,7 +43,8 @@
     }
   }
 
-  private synchronized void testExtraNeverReturnsNormallyB() {
+  @NeverInline
+  private void testExtraNeverReturnsNormallyB() {
     try {
       neverReturnsNormallyExtra(next(), null);
     } catch (RuntimeException re) {
@@ -47,7 +52,8 @@
     }
   }
 
-  private synchronized void testDirectNeverReturnsNormally() {
+  @NeverInline
+  private void testDirectNeverReturnsNormally() {
     try {
       NeverReturnsNormally a = new NeverReturnsNormally();
       System.out.println(a.foo());
@@ -56,7 +62,8 @@
     }
   }
 
-  private synchronized void testInitNeverReturnsNormally() {
+  @NeverInline
+  private void testInitNeverReturnsNormally() {
     try {
       new InitNeverReturnsNormally();
     } catch (RuntimeException re) {
@@ -85,7 +92,8 @@
     }
   }
 
-  private synchronized void testRootInvalidatesAfterInlining() {
+  @NeverInline
+  private void testRootInvalidatesAfterInlining() {
     A a = new A();
     try {
       notInlinedExtraMethod(next(), a);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java
index 7e3cba2..a2576bf 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.ir.optimize.classinliner.trivial;
 
+import com.android.tools.r8.NeverInline;
+
 public class TrivialTestClass {
   private static int ID = 0;
 
@@ -25,35 +27,42 @@
     test.testCycles();
   }
 
-  private synchronized void testInner() {
+  @NeverInline
+  private void testInner() {
     Inner inner = new Inner("inner{", 123, next() + "}");
     System.out.println(inner.toString() + " " + inner.getPrefix() + " = " + inner.prefix);
   }
 
-  private synchronized void testConstructorMapping1() {
+  @NeverInline
+  private void testConstructorMapping1() {
     ReferencedFields o = new ReferencedFields(next());
     System.out.println(o.getA());
   }
 
-  private synchronized void testConstructorMapping2() {
+  @NeverInline
+  private void testConstructorMapping2() {
     ReferencedFields o = new ReferencedFields(next());
     System.out.println(o.getB());
   }
 
-  private synchronized void testConstructorMapping3() {
+  @NeverInline
+  private void testConstructorMapping3() {
     ReferencedFields o = new ReferencedFields(next(), next());
     System.out.println(o.getA() + o.getB() + o.getConcat());
   }
 
-  private synchronized void testEmptyClass() {
+  @NeverInline
+  private void testEmptyClass() {
     new EmptyClass();
   }
 
-  private synchronized void testEmptyClassWithInitializer() {
+  @NeverInline
+  private void testEmptyClassWithInitializer() {
     new EmptyClassWithInitializer();
   }
 
-  private synchronized void testClassWithFinalizer() {
+  @NeverInline
+  private void testClassWithFinalizer() {
     new ClassWithFinal();
   }
 
@@ -61,7 +70,8 @@
     iface.foo();
   }
 
-  private synchronized void testCallOnIface1() {
+  @NeverInline
+  private void testCallOnIface1() {
     callOnIface1(new Iface1Impl(next()));
   }
 
@@ -69,14 +79,18 @@
     iface.foo();
   }
 
-  private synchronized void testCallOnIface2() {
+  @NeverInline
+  private void testCallOnIface2() {
     callOnIface2(new Iface2Impl(next()));
     System.out.println(Iface2Impl.CONSTANT); // Keep constant referenced
   }
 
-  private synchronized void testCycles() {
+  @NeverInline
+  private void testCycles() {
     new CycleReferenceAB("first").foo(3);
     new CycleReferenceBA("second").foo(4);
+    new CycleReferenceAB("third").foo(5);
+    new CycleReferenceBA("fourth").foo(6);
   }
 
   public class Inner {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/DoubleInliningInvokeSuperTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/DoubleInliningInvokeSuperTest.java
new file mode 100644
index 0000000..5d8b1f0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/DoubleInliningInvokeSuperTest.java
@@ -0,0 +1,83 @@
+// 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.optimize.inliner;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import org.junit.Test;
+
+// Regression test for b/128987064
+public class DoubleInliningInvokeSuperTest extends TestBase {
+
+  @Test
+  public void test() throws Exception {
+    testForR8(Backend.DEX)
+        .addInnerClasses(DoubleInliningInvokeSuperTest.class)
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules("-keepclassmembers class * { void fooCaller(...); }")
+        .enableClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .enableMergeAnnotations()
+        .run(TestClass.class)
+        .assertSuccess();
+  }
+
+  @NeverClassInline
+  @NeverMerge
+  static class A {
+    int x;
+    @NeverInline
+    A foo(int x) {
+      this.x = x;
+      return this;
+    }
+  }
+
+  @NeverClassInline
+  @NeverMerge
+  static class B extends A {
+    // B#foo is invoked twice by other wrappers in the same class.
+    @Override
+    B foo(int x) {
+      // this invoke-super should not be inlined to the class outside of the class hierarchy.
+      super.foo(x);
+      return this;
+    }
+
+    // place-holder to make B#foo to be a double-inline selected target.
+    B fooWrapper(Integer x) {
+      int y = System.currentTimeMillis() > 0 ? x * 2 : x;
+      return foo(y);
+    }
+
+    // Another B#foo caller.
+    B anotherWrapper(Integer x) {
+      int y = System.currentTimeMillis() > 0 ? x * 2 : x;
+      // invoke-super in B#foo is inlined here during double-inlining.
+      return foo(y);
+    }
+  }
+
+  static class TestClass {
+    // place-holder to make B#fooWrapper live. This one is force kept.
+    static void fooCaller(B b) {
+      System.out.println(b.fooWrapper(8).x);
+    }
+
+    public static void main(String[] args) {
+      B instance = new B();
+      // By invoking B#anotherWrapper twice, `main` is regarded as double-inline caller.
+      // Due to the name order, B#fooWrapper is processed first, and invoke-super is moved.
+      // Its inlining constraints aren't updated yet since inliner does not finish processing all
+      // the methods in the double-inline pool. Now, when processing `main`, invoke-super in
+      // B#anotherWrapper (which is inlined from B#foo) is flown to here, resulting in illegal
+      // invoke-super at the 2nd tree shaking phase.
+      System.out.println(instance.anotherWrapper(8).x);
+      System.out.println(instance.anotherWrapper(8).x);
+    }
+  }
+
+}