diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index c918040..6bb88a8 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 = "2.0.79";
+  public static final String LABEL = "2.0.80";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index 7ca1e54..756243a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -255,16 +255,14 @@
             // exception but we can not report it as error since it can also be the intended
             // behavior.
             warnMissingType(encodedMethod.method, invokedMethod.holder);
-          } else if (clazz.isInterface() && !clazz.isLibraryClass()) {
-            // NOTE: we intentionally don't desugar super calls into interface methods
-            // coming from android.jar since it is only possible in case v24+ version
-            // of android.jar is provided.
-            //
-            // We assume such calls are properly guarded by if-checks like
-            //    'if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.XYZ) { ... }'
-            //
-            // WARNING: This may result in incorrect code on older platforms!
-            // Retarget call to an appropriate method of companion class.
+            continue;
+          }
+          if (!clazz.isInterface()) {
+            // Skip non-interface invokes.
+            continue;
+          }
+          if (!clazz.isLibraryClass()) {
+            // For program and classpath retarget call to an appropriate method of companion class.
             DexMethod amendedMethod =
                 amendDefaultMethod(
                     appInfo.definitionFor(encodedMethod.method.holder), invokedMethod);
@@ -272,44 +270,32 @@
                 new InvokeStatic(defaultAsMethodOfCompanionClass(amendedMethod),
                     invokeSuper.outValue(), invokeSuper.arguments()));
           } else {
-            DexType dexType = maximallySpecificEmulatedInterfaceOrNull(invokedMethod);
-            if (dexType != null) {
-              // That invoke super may not resolve since the super method may not be present
-              // since it's in the emulated interface. We need to force resolution. If it resolves
-              // to a library method, then it needs to be rewritten.
-              // If it resolves to a program overrides, the invoke-super can remain.
-              DexEncodedMethod dexEncodedMethod =
-                  appView
-                      .appInfo()
-                      .lookupSuperTarget(invokeSuper.getInvokedMethod(), code.method.method.holder);
-              if (dexEncodedMethod != null) {
-                DexClass dexClass = appView.definitionFor(dexEncodedMethod.method.holder);
-                if (dexClass != null && dexClass.isLibraryClass()) {
-                  // Rewriting is required because the super invoke resolves into a missing
-                  // method (method is on desugared library). Find out if it needs to be
-                  // retarget or if it just calls a companion class method and rewrite.
-                  DexMethod retargetMethod =
-                      options.desugaredLibraryConfiguration.retargetMethod(
-                          dexEncodedMethod.method, appView);
-                  if (retargetMethod == null) {
-                    DexMethod originalCompanionMethod =
-                        instanceAsMethodOfCompanionClass(
-                            dexEncodedMethod.method, DEFAULT_METHOD_PREFIX, factory);
-                    DexMethod companionMethod =
-                        factory.createMethod(
-                            getCompanionClassType(dexType),
-                            factory.protoWithDifferentFirstParameter(
-                                originalCompanionMethod.proto, dexType),
-                            originalCompanionMethod.name);
-                    instructions.replaceCurrentInstruction(
-                        new InvokeStatic(
-                            companionMethod, invokeSuper.outValue(), invokeSuper.arguments()));
-                  } else {
-                    instructions.replaceCurrentInstruction(
-                        new InvokeStatic(
-                            retargetMethod, invokeSuper.outValue(), invokeSuper.arguments()));
-                  }
-                }
+            // Rewriting is required if the super invoke resolves to a default method on the
+            // desugared library. Retarget or rewrite to the desugared library companion class.
+            DexEncodedMethod dexEncodedMethod =
+                targetForInvokeSuperDispatchToDefaultMethod(
+                    invokedMethod, clazz.asLibraryClass(), code.method.method.holder);
+            if (dexEncodedMethod != null) {
+              DexMethod retargetMethod =
+                  options.desugaredLibraryConfiguration.retargetMethod(
+                      dexEncodedMethod.method, appView);
+              if (retargetMethod == null) {
+                DexMethod originalCompanionMethod =
+                    instanceAsMethodOfCompanionClass(
+                        dexEncodedMethod.method, DEFAULT_METHOD_PREFIX, factory);
+                DexMethod companionMethod =
+                    factory.createMethod(
+                        getCompanionClassType(clazz.type),
+                        factory.protoWithDifferentFirstParameter(
+                            originalCompanionMethod.proto, clazz.type),
+                        originalCompanionMethod.name);
+                instructions.replaceCurrentInstruction(
+                    new InvokeStatic(
+                        companionMethod, invokeSuper.outValue(), invokeSuper.arguments()));
+              } else {
+                instructions.replaceCurrentInstruction(
+                    new InvokeStatic(
+                        retargetMethod, invokeSuper.outValue(), invokeSuper.arguments()));
               }
             }
           }
@@ -384,6 +370,27 @@
     }
   }
 
+  private DexEncodedMethod targetForInvokeSuperDispatchToDefaultMethod(
+      DexMethod invokedSuperMethod, DexLibraryClass holder, DexType context) {
+    assert invokedSuperMethod.holder == holder.type;
+    assert holder.isInterface();
+    DexEncodedMethod definition = holder.lookupMethod(invokedSuperMethod);
+    if (definition == null || !definition.isDefaultMethod()) {
+      return null;
+    }
+    // Only default methods on emulated interfaces or rewritten types need to be dealt with.
+    if (!emulatedMethods.contains(invokedSuperMethod.name)
+        && !appView.rewritePrefix.hasRewrittenType(holder.type)) {
+      return null;
+    }
+    DexEncodedMethod target = appView.appInfo().lookupSuperTarget(invokedSuperMethod, context);
+    DexClass targetHolder = appView.definitionFor(target.method.holder);
+    if (targetHolder == null || !targetHolder.isLibraryClass()) {
+      return null;
+    }
+    return target;
+  }
+
   private DexType maximallySpecificEmulatedInterfaceOrNull(DexMethod invokedMethod) {
     // Here we try to avoid doing the expensive look-up on all invokes.
     if (!emulatedMethods.contains(invokedMethod.name)) {
diff --git a/src/test/java/com/android/tools/r8/D8TestBuilder.java b/src/test/java/com/android/tools/r8/D8TestBuilder.java
index d740e54..5ab2703 100644
--- a/src/test/java/com/android/tools/r8/D8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/D8TestBuilder.java
@@ -67,12 +67,9 @@
 
   @Override
   public D8TestBuilder enableCoreLibraryDesugaring(
-      AndroidApiLevel minAPILevel, KeepRuleConsumer keepRuleConsumer) {
-    if (minAPILevel.getLevel() < AndroidApiLevel.O.getLevel()) {
-      // Use P to mimic current Android Studio.
-      builder.addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P));
-      builder.addDesugaredLibraryConfiguration(
-          StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING));
+      AndroidApiLevel minApiLevel, KeepRuleConsumer keepRuleConsumer) {
+    if (minApiLevel.getLevel() < AndroidApiLevel.O.getLevel()) {
+      super.enableCoreLibraryDesugaring(minApiLevel, keepRuleConsumer);
       builder.setDesugaredLibraryKeepRuleConsumer(keepRuleConsumer);
     }
     return self();
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index 59ae602..52a7c29 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -357,12 +357,9 @@
 
   @Override
   public T enableCoreLibraryDesugaring(
-      AndroidApiLevel minAPILevel, KeepRuleConsumer keepRuleConsumer) {
-    if (minAPILevel.getLevel() < AndroidApiLevel.O.getLevel()) {
-      // Use P to mimic current Android Studio.
-      builder.addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P));
-      builder.addDesugaredLibraryConfiguration(
-          StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING));
+      AndroidApiLevel minApiLevel, KeepRuleConsumer keepRuleConsumer) {
+    if (minApiLevel.getLevel() < AndroidApiLevel.O.getLevel()) {
+      super.enableCoreLibraryDesugaring(minApiLevel, keepRuleConsumer);
       builder.setDesugaredLibraryKeepRuleConsumer(keepRuleConsumer);
     }
     return self();
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index cc8d46a..7627098 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -6,7 +6,6 @@
 import com.android.tools.r8.TestBase.Backend;
 import com.android.tools.r8.debug.DebugTestConfig;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase.KeepRuleConsumer;
-import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.AndroidAppConsumers;
@@ -286,8 +285,16 @@
   }
 
   public T enableCoreLibraryDesugaring(
-      AndroidApiLevel minAPILevel, KeepRuleConsumer keepRuleConsumer) {
-    throw new Unreachable("Should be overridden or is unsupported.");
+      AndroidApiLevel minApiLevel, KeepRuleConsumer keepRuleConsumer) {
+    assert minApiLevel.getLevel() < AndroidApiLevel.O.getLevel();
+    builder.addDesugaredLibraryConfiguration(
+        StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING));
+    // TODO(b/158543446): This should not be setting an implicit library file. Doing so causes
+    //  inconsistent library setup depending on the api level and makes tests hard to read and
+    //  reason about.
+    // Use P to mimic current Android Studio.
+    builder.addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P));
+    return self();
   }
 
   @Override
diff --git a/src/test/java/com/android/tools/r8/desugar/InvokeSuperToEmulatedDefaultMethodTest.java b/src/test/java/com/android/tools/r8/desugar/InvokeSuperToEmulatedDefaultMethodTest.java
new file mode 100644
index 0000000..5e1a10f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/InvokeSuperToEmulatedDefaultMethodTest.java
@@ -0,0 +1,155 @@
+// 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.desugar;
+
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class InvokeSuperToEmulatedDefaultMethodTest extends DesugaredLibraryTestBase {
+
+  private static final String EXPECTED = StringUtils.lines("bar", "bar");
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  private final TestParameters parameters;
+
+  public InvokeSuperToEmulatedDefaultMethodTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private boolean needsDefaultInterfaceMethodDesugaring() {
+    return parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N);
+  }
+
+  @Test
+  public void testReference() throws Exception {
+    assumeFalse(needsDefaultInterfaceMethodDesugaring());
+    testForRuntime(parameters)
+        .addInnerClasses(InvokeSuperToEmulatedDefaultMethodTest.class)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
+  public void testDesugaring() throws Exception {
+    assumeTrue(needsDefaultInterfaceMethodDesugaring());
+    testForD8()
+        .addInnerClasses(InvokeSuperToEmulatedDefaultMethodTest.class)
+        .setMinApi(parameters.getApiLevel())
+        .enableCoreLibraryDesugaring(parameters.getApiLevel())
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, parameters.getApiLevel())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  public interface StringMap extends Map<String, String> {
+
+    @Override
+    default String getOrDefault(Object key, String defaultValue) {
+      // Simple forward that targets the desugared library.
+      return Map.super.getOrDefault(key + "oo", defaultValue);
+    }
+  }
+
+  public interface StringMapIndirection extends StringMap {
+
+    @Override
+    default String getOrDefault(Object key, String defaultValue) {
+      // Simple forward to a program defined default method.
+      return StringMap.super.getOrDefault("f", defaultValue);
+    }
+  }
+
+  public static class StringHashMap implements StringMapIndirection {
+    HashMap<String, String> delegate = new HashMap<>();
+
+    @Override
+    public int size() {
+      return delegate.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return delegate.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+      return delegate.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+      return delegate.containsValue(value);
+    }
+
+    @Override
+    public String get(Object key) {
+      return delegate.get(key);
+    }
+
+    @Override
+    public String put(String key, String value) {
+      return delegate.put(key, value);
+    }
+
+    @Override
+    public String remove(Object key) {
+      return delegate.remove(key);
+    }
+
+    @Override
+    public void putAll(Map<? extends String, ? extends String> m) {
+      delegate.putAll(m);
+    }
+
+    @Override
+    public void clear() {
+      delegate.clear();
+    }
+
+    @Override
+    public Set<String> keySet() {
+      return delegate.keySet();
+    }
+
+    @Override
+    public Collection<String> values() {
+      return delegate.values();
+    }
+
+    @Override
+    public Set<Entry<String, String>> entrySet() {
+      return delegate.entrySet();
+    }
+  }
+
+  public static class TestClass {
+
+    public static void main(String[] args) {
+      StringHashMap map = new StringHashMap();
+      map.put("foo", "bar");
+      System.out.println(map.getOrDefault("foo", "not found"));
+      System.out.println(map.getOrDefault("bar", "not found"));
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/InvokeSuperToRewrittenDefaultMethodTest.java b/src/test/java/com/android/tools/r8/desugar/InvokeSuperToRewrittenDefaultMethodTest.java
new file mode 100644
index 0000000..2d6dc5f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/InvokeSuperToRewrittenDefaultMethodTest.java
@@ -0,0 +1,92 @@
+// 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.desugar;
+
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.function.Consumer;
+import java.util.function.IntConsumer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class InvokeSuperToRewrittenDefaultMethodTest extends DesugaredLibraryTestBase {
+
+  private static final String EXPECTED = StringUtils.lines("Y", "89");
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  private final TestParameters parameters;
+
+  public InvokeSuperToRewrittenDefaultMethodTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private boolean needsDefaultInterfaceMethodDesugaring() {
+    return parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N);
+  }
+
+  @Test
+  public void testReference() throws Exception {
+    assumeFalse(needsDefaultInterfaceMethodDesugaring());
+    testForRuntime(parameters)
+        .addInnerClasses(InvokeSuperToRewrittenDefaultMethodTest.class)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
+  public void testDesugaring() throws Exception {
+    assumeTrue(needsDefaultInterfaceMethodDesugaring());
+    testForD8()
+        .addInnerClasses(InvokeSuperToRewrittenDefaultMethodTest.class)
+        .setMinApi(parameters.getApiLevel())
+        .enableCoreLibraryDesugaring(parameters.getApiLevel())
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, parameters.getApiLevel())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @FunctionalInterface
+  public interface CharConsumer extends Consumer<Character>, IntConsumer {
+
+    void accept(char c);
+
+    @Override
+    default void accept(int value) {
+      accept((char) value);
+    }
+
+    @Override
+    default void accept(Character character) {
+      accept(character.charValue());
+    }
+
+    @Override
+    default Consumer<Character> andThen(Consumer<? super Character> after) {
+      // Simple forward to the default method of the parent.
+      // Must be rewritten to target the companion class of the rewritten Consumer type.
+      return Consumer.super.andThen(after);
+    }
+  }
+
+  public static class TestClass {
+
+    public static void main(String[] args) {
+      CharConsumer consumer = System.out::println;
+      consumer.andThen((Consumer<? super Character>) c -> System.out.println((int) c)).accept('Y');
+    }
+  }
+}