diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 0c85791..ea79264 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.1.32";
+  public static final String LABEL = "2.1.33";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/dex/DexParser.java b/src/main/java/com/android/tools/r8/dex/DexParser.java
index 26dca03..a416e51 100644
--- a/src/main/java/com/android/tools/r8/dex/DexParser.java
+++ b/src/main/java/com/android/tools/r8/dex/DexParser.java
@@ -642,8 +642,7 @@
       int size,
       DexMethodAnnotation[] annotations,
       DexParameterAnnotation[] parameters,
-      boolean skipCodes,
-      boolean ensureNonAbstract) {
+      boolean skipCodes) {
     DexEncodedMethod[] methods = new DexEncodedMethod[size];
     int methodIndex = 0;
     MemberAnnotationIterator<DexMethod, DexAnnotationSet> annotationIterator =
@@ -661,19 +660,13 @@
         code = codes.get(codeOff);
       }
       DexMethod method = indexedItems.getMethod(methodIndex);
-      DexEncodedMethod encodedMethod =
+      methods[i] =
           new DexEncodedMethod(
               method,
               accessFlags,
               annotationIterator.getNextFor(method),
               parameterAnnotationsIterator.getNextFor(method),
               code);
-      if (accessFlags.isAbstract() && ensureNonAbstract) {
-        accessFlags.unsetAbstract();
-        assert !options.isGeneratingClassFiles();
-        encodedMethod = encodedMethod.toEmptyThrowingMethodDex(false);
-      }
-      methods[i] = encodedMethod;
     }
     return methods;
   }
@@ -754,17 +747,13 @@
                 directMethodsSize,
                 annotationsDirectory.methods,
                 annotationsDirectory.parameters,
-                classKind != ClassKind.PROGRAM,
-                options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()
-                    && !flags.isAbstract());
+                classKind != ClassKind.PROGRAM);
         virtualMethods =
             readMethods(
                 virtualMethodsSize,
                 annotationsDirectory.methods,
                 annotationsDirectory.parameters,
-                classKind != ClassKind.PROGRAM,
-                options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()
-                    && !flags.isAbstract());
+                classKind != ClassKind.PROGRAM);
       }
 
       AttributesAndAnnotations attrs =
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 c2cdc32..be8c6f1 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -176,12 +176,10 @@
 
   private boolean verifyNoAbstractMethodsOnNonAbstractClasses(
       Iterable<DexEncodedMethod> methods, InternalOptions options) {
-    if (options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()) {
-      if (!isAbstract()) {
-        for (DexEncodedMethod method : methods) {
-          assert !method.isAbstract()
-              : "Non-abstract method on abstract class: `" + method.method.toSourceString() + "`";
-        }
+    if (options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug() && !isAbstract()) {
+      for (DexEncodedMethod method : methods) {
+        assert !method.isAbstract()
+            : "Non-abstract method on abstract class: `" + method.method.toSourceString() + "`";
       }
     }
     return true;
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 7071fda..cf25051 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -767,11 +767,6 @@
         null);
   }
 
-  public DexCode buildEmptyThrowingDexCode() {
-    Instruction insn[] = {new Const(0, 0), new Throw(0)};
-    return generateCodeFromTemplate(1, 0, insn);
-  }
-
   public DexEncodedMethod toEmptyThrowingMethod(InternalOptions options) {
     // Note that we are not marking this instance obsolete, since this util is only used by
     // TreePruner while keeping non-live yet targeted, empty method. Such method can be retrieved
@@ -794,17 +789,6 @@
     return builder.build();
   }
 
-  public CfCode buildEmptyThrowingCfCode() {
-    CfInstruction insn[] = {new CfConstNull(), new CfThrow()};
-    return new CfCode(
-        method.holder,
-        1,
-        method.proto.parameters.size() + 1,
-        Arrays.asList(insn),
-        Collections.emptyList(),
-        Collections.emptyList());
-  }
-
   private DexEncodedMethod toEmptyThrowingMethodCf() {
     checkIfObsolete();
     assert !shouldNotHaveCode();
@@ -818,6 +802,28 @@
     return builder.build();
   }
 
+  public Code buildEmptyThrowingCode(InternalOptions options) {
+    return options.isGeneratingClassFiles()
+        ? buildEmptyThrowingCfCode()
+        : buildEmptyThrowingDexCode();
+  }
+
+  public CfCode buildEmptyThrowingCfCode() {
+    CfInstruction insn[] = {new CfConstNull(), new CfThrow()};
+    return new CfCode(
+        method.holder,
+        1,
+        method.proto.parameters.size() + 1,
+        Arrays.asList(insn),
+        Collections.emptyList(),
+        Collections.emptyList());
+  }
+
+  public DexCode buildEmptyThrowingDexCode() {
+    Instruction insn[] = {new Const(0, 0), new Throw(0)};
+    return generateCodeFromTemplate(1, 0, insn);
+  }
+
   public DexEncodedMethod toMethodThatLogsError(AppView<?> appView) {
     if (appView.options().isGeneratingDex()) {
       return toMethodThatLogsErrorDexCode(appView.dexItemFactory());
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 75627a0..3a6d92b 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
@@ -489,6 +489,8 @@
   public DexApplication convert(DexApplication application, ExecutorService executor)
       throws ExecutionException {
     removeLambdaDeserializationMethods();
+    workaroundAbstractMethodOnNonAbstractClassVerificationBug(
+        executor, OptimizationFeedbackIgnore.getInstance());
 
     timing.begin("IR conversion");
     ThreadUtils.processItems(application.classes(), this::convertMethods, executor);
@@ -652,6 +654,28 @@
     }
   }
 
+  private void workaroundAbstractMethodOnNonAbstractClassVerificationBug(
+      ExecutorService executorService, OptimizationFeedback feedback) throws ExecutionException {
+    if (!options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()) {
+      return;
+    }
+    assert delayedOptimizationFeedback.noUpdatesLeft();
+    ThreadUtils.processItems(
+        appView.appInfo().classes(),
+        clazz -> {
+          if (!clazz.isAbstract()) {
+            clazz.forEachMethod(
+                method -> {
+                  if (method.isAbstract()) {
+                    method.accessFlags.unsetAbstract();
+                    finalizeEmptyThrowingCode(method, feedback);
+                  }
+                });
+          }
+        },
+        executorService);
+  }
+
   public DexApplication optimize() throws ExecutionException {
     ExecutorService executor = Executors.newSingleThreadExecutor();
     try {
@@ -667,6 +691,8 @@
     computeReachabilitySensitivity(application);
     collectLambdaMergingCandidates(application);
     collectStaticizerCandidates(application);
+    workaroundAbstractMethodOnNonAbstractClassVerificationBug(
+        executorService, simpleOptimizationFeedback);
 
     // The process is in two phases in general.
     // 1) Subject all DexEncodedMethods to optimization, except some optimizations that require
@@ -1705,10 +1731,7 @@
 
   private void finalizeEmptyThrowingCode(DexEncodedMethod method, OptimizationFeedback feedback) {
     assert options.isGeneratingClassFiles() || options.isGeneratingDex();
-    Code emptyThrowingCode =
-        options.isGeneratingClassFiles()
-            ? method.buildEmptyThrowingCfCode()
-            : method.buildEmptyThrowingDexCode();
+    Code emptyThrowingCode = method.buildEmptyThrowingCode(options);
     method.setCode(emptyThrowingCode, appView);
     feedback.markProcessed(method, ConstraintWithTarget.ALWAYS);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index 379fc28..5dc7874 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -726,11 +726,7 @@
       // enumUnboxerRewriter will generate invalid code.
       // To work around this problem we clear such methods, i.e., we replace the code object by
       // an empty throwing code object, so reprocessing won't take time and will be valid.
-      enumMethod.setCode(
-          appView.options().isGeneratingClassFiles()
-              ? enumMethod.buildEmptyThrowingCfCode()
-              : enumMethod.buildEmptyThrowingDexCode(),
-          appView);
+      enumMethod.setCode(enumMethod.buildEmptyThrowingCode(appView.options()), appView);
     }
 
     private DexEncodedMethod fixupEncodedMethodToUtility(
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 9696162..3de881b 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
@@ -140,8 +140,7 @@
 
   @Override
   public void markProcessed(DexEncodedMethod method, ConstraintWithTarget state) {
-    // Just as processed, don't provide any inlining constraints.
-    method.markProcessed(ConstraintWithTarget.NEVER);
+    method.markProcessed(state);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index 346caa4..fdaae48 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -300,8 +300,7 @@
         // Final classes cannot be abstract, so we have to keep the method in that case.
         // Also some other kinds of methods cannot be abstract, so keep them around.
         boolean allowAbstract =
-            (!options.canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug()
-                    || clazz.isAbstract())
+            (options.canUseAbstractMethodOnNonAbstractClass() || clazz.isAbstract())
                 && !method.isFinal()
                 && !method.accessFlags.isNative()
                 && !method.accessFlags.isStrict()
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 8c92acf..71539ef 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1250,6 +1250,22 @@
     return minApiLevel >= level.getLevel();
   }
 
+  /**
+   * Dex2Oat issues a warning for abstract methods on non-abstract classes, so we never allow this.
+   *
+   * <p>Note that having an invoke instruction that targets an abstract method on a non-abstract
+   * class will fail with a verification error on Dalvik. Therefore, this must not be more
+   * permissive than {@code return minApiLevel >= AndroidApiLevel.L.getLevel()}.
+   *
+   * <p>See b/132953944.
+   */
+  @SuppressWarnings("ConstantConditions")
+  public boolean canUseAbstractMethodOnNonAbstractClass() {
+    boolean result = false;
+    assert !(result && canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug());
+    return result;
+  }
+
   public boolean canUseConstClassInstructions(int cfVersion) {
     assert isGeneratingClassFiles();
     return cfVersion >= requiredCfVersionForConstClassInstructions();
@@ -1673,7 +1689,7 @@
   //
   // See b/132953944.
   public boolean canHaveDalvikAbstractMethodOnNonAbstractClassVerificationBug() {
-    return minApiLevel < AndroidApiLevel.L.getLevel();
+    return isGeneratingDex() && minApiLevel < AndroidApiLevel.L.getLevel();
   }
 
   // On dalvik we see issues when using an int value in places where a boolean, byte, char, or short
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index a109e20..61db3e3 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -135,7 +135,8 @@
             box.proguardConfiguration,
             box.syntheticProguardRules,
             proguardMapBuilder.toString(),
-            graphConsumer);
+            graphConsumer,
+            builder.getMinApiLevel());
     switch (allowedDiagnosticMessages) {
       case ALL:
         compileResult.assertDiagnosticThatMatches(new IsAnything<>());
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index 3a16807..5dac954 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -14,7 +14,6 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.List;
-import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 
 public class R8TestCompileResult extends TestCompileResult<R8TestCompileResult, R8TestRunResult> {
@@ -23,6 +22,7 @@
   private final List<ProguardConfigurationRule> syntheticProguardRules;
   private final String proguardMap;
   private final CollectingGraphConsumer graphConsumer;
+  private final int minApiLevel;
 
   R8TestCompileResult(
       TestState state,
@@ -31,12 +31,14 @@
       ProguardConfiguration proguardConfiguration,
       List<ProguardConfigurationRule> syntheticProguardRules,
       String proguardMap,
-      CollectingGraphConsumer graphConsumer) {
+      CollectingGraphConsumer graphConsumer,
+      int minApiLevel) {
     super(state, app, outputMode);
     this.proguardConfiguration = proguardConfiguration;
     this.syntheticProguardRules = syntheticProguardRules;
     this.proguardMap = proguardMap;
     this.graphConsumer = graphConsumer;
+    this.minApiLevel = minApiLevel;
   }
 
   @Override
@@ -65,11 +67,11 @@
   }
 
   @Override
-  public CodeInspector inspector() throws IOException, ExecutionException {
+  public CodeInspector inspector() throws IOException {
     return new CodeInspector(app, proguardMap);
   }
 
-  public GraphInspector graphInspector() throws IOException, ExecutionException {
+  public GraphInspector graphInspector() throws IOException {
     assert graphConsumer != null;
     return new GraphInspector(graphConsumer, inspector());
   }
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
index cacf66b..26186aa 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
@@ -635,9 +635,10 @@
         .forEach(
             p -> {
               try {
-                CodeInspector i = new CodeInspector(AndroidApp.builder().addProgramFiles(p).build());
+                CodeInspector i =
+                    new CodeInspector(AndroidApp.builder().addProgramFiles(p).build());
                 assertFalse("Found " + clazz + " in file " + p, i.clazz(clazz).isPresent());
-              } catch (IOException | ExecutionException e) {
+              } catch (IOException e) {
                 e.printStackTrace();
               }
             });
diff --git a/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
new file mode 100644
index 0000000..2f95543
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/AbstractMethodOnNonAbstractClassTest.java
@@ -0,0 +1,131 @@
+// 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.shaking;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class AbstractMethodOnNonAbstractClassTest extends TestBase {
+
+  private static final String DEX2OAT_WARNING =
+      "is abstract, but the declaring class is neither abstract nor an interface";
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public AbstractMethodOnNonAbstractClassTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testCompat() throws Exception {
+    R8TestCompileResult compileResult =
+        testForR8Compat(parameters.getBackend())
+            .addInnerClasses(AbstractMethodOnNonAbstractClassTest.class)
+            .addKeepMainRule(TestClass.class)
+            .setMinApi(parameters.getApiLevel())
+            .compile();
+
+    // A is not made abstract in compat mode.
+    ClassSubject classSubject = compileResult.inspector().clazz(A.class);
+    assertThat(classSubject, isPresent());
+    assertFalse(classSubject.isAbstract());
+
+    // A.m() is also not made abstract in compat mode.
+    MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+    assertThat(methodSubject, isPresent());
+    assertFalse(methodSubject.isAbstract());
+
+    if (parameters.isDexRuntime()) {
+      compileResult
+          .runDex2Oat(parameters.getRuntime())
+          .assertStderrMatches(not(containsString(DEX2OAT_WARNING)));
+    }
+
+    compileResult
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello world!");
+  }
+
+  @Test
+  public void testFull() throws Exception {
+    R8TestCompileResult compileResult =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(AbstractMethodOnNonAbstractClassTest.class)
+            .addKeepMainRule(TestClass.class)
+            .setMinApi(parameters.getApiLevel())
+            .compile();
+
+    // A is made abstract in full mode.
+    ClassSubject classSubject = compileResult.inspector().clazz(A.class);
+    assertThat(classSubject, isPresent());
+    assertTrue(classSubject.isAbstract());
+
+    // A.m() is also made abstract in full mode.
+    MethodSubject methodSubject = classSubject.uniqueMethodWithName("m");
+    assertThat(methodSubject, isPresent());
+    assertTrue(methodSubject.isAbstract());
+
+    if (parameters.isDexRuntime()) {
+      // There is no warning due to both A and A.m() being abstract.
+      compileResult
+          .runDex2Oat(parameters.getRuntime())
+          .assertStderrMatches(not(containsString(DEX2OAT_WARNING)));
+    }
+
+    compileResult
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello world!");
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      A b = System.currentTimeMillis() > 0 ? new B() : new C();
+      b.m();
+    }
+  }
+
+  static class A {
+
+    // Never called directly on A, thus can be made abstract.
+    void m() {}
+  }
+
+  static class B extends A {
+
+    @Override
+    void m() {
+      System.out.println("Hello world!");
+    }
+  }
+
+  static class C extends A {
+
+    @Override
+    void m() {
+      throw new RuntimeException();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java b/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java
index 912915b..ac43338 100644
--- a/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java
+++ b/src/test/java/com/android/tools/r8/smali/SmaliBuildTest.java
@@ -13,7 +13,6 @@
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
-import java.util.concurrent.ExecutionException;
 import org.junit.Test;
 
 public class SmaliBuildTest extends SmaliTestBase {
@@ -23,7 +22,7 @@
       CodeInspector inspector = new CodeInspector(application);
       ClassSubject clazz = inspector.clazz("java.lang.String");
       assertEquals(present, clazz.isPresent());
-    } catch (IOException | ExecutionException e) {
+    } catch (IOException e) {
       throw new RuntimeException(e);
     }
   }
diff --git a/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java b/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
index efcc42f..10962c8 100644
--- a/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
+++ b/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
@@ -126,7 +126,7 @@
       ClassSubject clazz = inspector.clazz(className);
       assertTrue(clazz.isPresent());
       return clazz.getDexProgramClass();
-    } catch (IOException | ExecutionException e) {
+    } catch (IOException e) {
       throw new RuntimeException(e);
     }
   }
@@ -135,7 +135,7 @@
     try {
       CodeInspector inspector = new CodeInspector(appPath);
       return getMethodSubject(inspector, signature);
-    } catch (IOException | ExecutionException e) {
+    } catch (IOException e) {
       throw new RuntimeException(e);
     }
   }
diff --git a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
index 3f1ad69..1f1d744 100644
--- a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -337,6 +337,10 @@
             });
   }
 
+  public ClassFileTransformer unsetAbstract() {
+    return setAccessFlags(ClassAccessFlags::unsetAbstract);
+  }
+
   public ClassFileTransformer setAnnotation() {
     return setAccessFlags(
         accessFlags -> {
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
index 39f7c44..b2edae2 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
@@ -55,7 +55,6 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ExecutionException;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -72,25 +71,25 @@
   public static MethodSignature MAIN =
       new MethodSignature("main", "void", new String[] {"java.lang.String[]"});
 
-  public CodeInspector(String path) throws IOException, ExecutionException {
+  public CodeInspector(String path) throws IOException {
     this(Paths.get(path));
   }
 
-  public CodeInspector(Path file, String mappingFile) throws IOException, ExecutionException {
+  public CodeInspector(Path file, String mappingFile) throws IOException {
     this(Collections.singletonList(file), mappingFile, null);
   }
 
-  public CodeInspector(Path file) throws IOException, ExecutionException {
+  public CodeInspector(Path file) throws IOException {
     this(Collections.singletonList(file), null, null);
   }
 
-  public CodeInspector(List<Path> files) throws IOException, ExecutionException {
+  public CodeInspector(List<Path> files) throws IOException {
     this(files, null, null);
   }
 
   public CodeInspector(
       List<Path> files, String mappingFile, Consumer<InternalOptions> optionsConsumer)
-      throws IOException, ExecutionException {
+      throws IOException {
     Path mappingPath = mappingFile != null ? Paths.get(mappingFile) : null;
     if (mappingPath != null && Files.exists(mappingPath)) {
       mapping = ClassNameMapper.mapperFromFile(mappingPath);
@@ -109,14 +108,14 @@
     application = new ApplicationReader(input, options, timing).read();
   }
 
-  public CodeInspector(AndroidApp app) throws IOException, ExecutionException {
+  public CodeInspector(AndroidApp app) throws IOException {
     this(
         new ApplicationReader(app, runOptionsConsumer(null), Timing.empty())
             .read(app.getProguardMapOutputData()));
   }
 
   public CodeInspector(AndroidApp app, Consumer<InternalOptions> optionsConsumer)
-      throws IOException, ExecutionException {
+      throws IOException {
     this(
         new ApplicationReader(app, runOptionsConsumer(optionsConsumer), Timing.empty())
             .read(app.getProguardMapOutputData()));
@@ -130,15 +129,13 @@
     return internalOptions;
   }
 
-  public CodeInspector(AndroidApp app, Path proguardMapFile)
-      throws IOException, ExecutionException {
+  public CodeInspector(AndroidApp app, Path proguardMapFile) throws IOException {
     this(
         new ApplicationReader(app, runOptionsConsumer(null), Timing.empty())
             .read(StringResource.fromFile(proguardMapFile)));
   }
 
-  public CodeInspector(AndroidApp app, String proguardMapContent)
-      throws IOException, ExecutionException {
+  public CodeInspector(AndroidApp app, String proguardMapContent) throws IOException {
     this(
         new ApplicationReader(app, runOptionsConsumer(null), Timing.empty())
             .read(StringResource.fromString(proguardMapContent, Origin.unknown())));
diff --git a/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
new file mode 100644
index 0000000..aca08d4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/workaround/InputWithAbstractMethodOnNonAbstractClassTest.java
@@ -0,0 +1,99 @@
+// 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.workaround;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbstract;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class InputWithAbstractMethodOnNonAbstractClassTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public InputWithAbstractMethodOnNonAbstractClassTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    testForD8()
+        .addProgramClasses(TestClass.class)
+        .addProgramClassFileData(transformer(Greeter.class).unsetAbstract().transform())
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello world!");
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(TestClass.class)
+        .addProgramClassFileData(transformer(Greeter.class).unsetAbstract().transform())
+        .addKeepMainRule(TestClass.class)
+        .addKeepClassAndMembersRules(Greeter.class)
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello world!");
+  }
+
+  @Test
+  public void testJVM() throws Exception {
+    assumeTrue(parameters.isCfRuntime());
+    testForJvm()
+        .addProgramClasses(TestClass.class)
+        .addProgramClassFileData(transformer(Greeter.class).unsetAbstract().transform())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Hello world!");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    MethodSubject methodOfInterest = inspector.clazz(Greeter.class).uniqueMethodWithName("dead");
+    assertThat(methodOfInterest, isPresent());
+    if (parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.L)) {
+      assertThat(methodOfInterest, not(isAbstract()));
+    } else {
+      assertThat(methodOfInterest, isAbstract());
+    }
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      Greeter.greet();
+    }
+  }
+
+  /*not-*/ abstract static class Greeter {
+
+    static void greet() {
+      System.out.println("Hello world!");
+    }
+
+    abstract void dead();
+  }
+}