diff --git a/src/main/java/com/android/tools/r8/BackportedMethodList.java b/src/main/java/com/android/tools/r8/BackportedMethodList.java
new file mode 100644
index 0000000..befc767
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/BackportedMethodList.java
@@ -0,0 +1,111 @@
+// 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;
+
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.ExceptionUtils;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.ThreadUtils;
+import java.util.concurrent.ExecutorService;
+
+/**
+ * Tool to extract the list of methods which is backported by the D8 and R8 compilers.
+ *
+ * <p>The D8 and R8 compilers will backport some simple Java APIs which are not present on all API
+ * levels. One example of this is the static method <code>int Integer.divideUnsigned(int a, int b)
+ * </code> which was added from API level 26.
+ *
+ * <p>As these backported methods is supported on all API levels, tools like linters and code
+ * checkers need this information to avoid false negatives when analyzing code.
+ *
+ * <p>This tool will generate a list of all the backported methods for the associated version of D8
+ * and R8.
+ *
+ * <p>This tool will <strong>not</strong> provide information about the APIs supported when using
+ * library desugaring. That information is provided in the dependencies used for library desugaring.
+ * However, in place of library desugaring backporting will be able to backport additional methods.
+ * If library desugaring is used, then passing information about that to this tool will provide the
+ * more precise list. See b/149078312.
+ *
+ * <p>The tool is invoked by calling {@link #run(BackportedMethodListCommand)
+ * BackportedMethodList.run} with an appropriate {@link BackportedMethodListCommand}.
+ *
+ * <p>For example:
+ *
+ * <pre>
+ *   BackportedMethodList.run(BackportedMethodListCommand.builder()
+ *       .setMinApiLevel(apiLevel)
+ *       .setOutputPath(Paths.get("methods-list.txt"))
+ *       .build());
+ * </pre>
+ *
+ * The above generates the list of backported methods for a compilation with a min API of <code>
+ * apiLevel</code> into the file <code>methods-list.txt</code>.
+ */
+@Keep
+public class BackportedMethodList {
+
+  static final String USAGE_MESSAGE =
+      StringUtils.joinLines(
+          "Usage: BackportedMethodList [options]",
+          " Options are:",
+          "  --output <file>         # Output result in <file>.",
+          "  --min-api <number>      # Minimum Android API level for the application",
+          "  --desugared-lib <file>  # Desugared library configuration (JSON from the",
+          "                          # configuration)",
+          "  --lib <file>            # The compilation SDK library (android.jar)",
+          "  --version               # Print the version of BackportedMethodList.",
+          "  --help                  # Print this message.");
+
+  private static String formatMethod(DexMethod method) {
+    return DescriptorUtils.getClassBinaryNameFromDescriptor(method.holder.descriptor.toString())
+        + '#'
+        + method.name
+        + method.proto.toDescriptorString();
+  }
+
+  public static void run(BackportedMethodListCommand command) throws CompilationFailedException {
+    if (command.isPrintHelp()) {
+      System.out.println(USAGE_MESSAGE);
+      return;
+    }
+    if (command.isPrintVersion()) {
+      System.out.println("BackportedMethodList " + Version.getVersionString());
+      return;
+    }
+    InternalOptions options = command.getInternalOptions();
+    ExecutorService executorService = ThreadUtils.getExecutorService(options);
+    try {
+      ExceptionUtils.withD8CompilationHandler(
+          command.getReporter(),
+          () -> {
+            BackportedMethodRewriter.generateListOfBackportedMethods(
+                    command.getInputApp(), options, executorService)
+                .stream()
+                .map(BackportedMethodList::formatMethod)
+                .sorted()
+                .forEach(
+                    formattedMethod ->
+                        command
+                            .getBackportedMethodListConsumer()
+                            .accept(formattedMethod, command.getReporter()));
+            command.getBackportedMethodListConsumer().finished(command.getReporter());
+          });
+    } finally {
+      executorService.shutdown();
+    }
+  }
+
+  public static void run(String[] args) throws CompilationFailedException {
+    run(BackportedMethodListCommand.parse(args).build());
+  }
+
+  public static void main(String[] args) {
+    ExceptionUtils.withMainProgramHandler(() -> run(args));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/BackportedMethodListCommand.java b/src/main/java/com/android/tools/r8/BackportedMethodListCommand.java
new file mode 100644
index 0000000..a4af022
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/BackportedMethodListCommand.java
@@ -0,0 +1,341 @@
+// 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;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
+import com.android.tools.r8.ir.desugar.DesugaredLibraryConfigurationParser;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.collect.ImmutableSet;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Immutable command structure for an invocation of the {@link BackportedMethodList} tool.
+ *
+ * <p>To build a BackportedMethodList command use the {@link BackportedMethodListCommand.Builder}
+ * class. For example:
+ *
+ * <pre>
+ *   BackportedMethodListCommand command = BackportedMethodListCommand.builder()
+ *     .setMinApiLevel(apiLevel)
+ *     .setOutputPath(Paths.get("methods-list.txt"))
+ *     .build();
+ * </pre>
+ */
+@Keep
+public class BackportedMethodListCommand {
+
+  private final boolean printHelp;
+  private final boolean printVersion;
+  private final Reporter reporter;
+  private final int minApiLevel;
+  private final DesugaredLibraryConfiguration desugaredLibraryConfiguration;
+  private final AndroidApp app;
+  private final StringConsumer backportedMethodListConsumer;
+  private final DexItemFactory factory;
+
+  public boolean isPrintHelp() {
+    return printHelp;
+  }
+
+  public boolean isPrintVersion() {
+    return printVersion;
+  }
+
+  Reporter getReporter() {
+    return reporter;
+  }
+
+  public int getMinApiLevel() {
+    return minApiLevel;
+  }
+
+  public DesugaredLibraryConfiguration getDesugaredLibraryConfiguration() {
+    return desugaredLibraryConfiguration;
+  }
+
+  public StringConsumer getBackportedMethodListConsumer() {
+    return backportedMethodListConsumer;
+  }
+
+  AndroidApp getInputApp() {
+    return app;
+  }
+
+  private BackportedMethodListCommand(boolean printHelp, boolean printVersion) {
+    this.printHelp = printHelp;
+    this.printVersion = printVersion;
+    this.reporter = new Reporter();
+    this.minApiLevel = -1;
+    this.desugaredLibraryConfiguration = null;
+    this.app = null;
+    this.backportedMethodListConsumer = null;
+    this.factory = null;
+  }
+
+  private BackportedMethodListCommand(
+      Reporter reporter,
+      int minApiLevel,
+      DesugaredLibraryConfiguration desugaredLibraryConfiguration,
+      AndroidApp app,
+      StringConsumer backportedMethodListConsumer,
+      DexItemFactory factory) {
+    this.printHelp = false;
+    this.printVersion = false;
+    this.reporter = reporter;
+    this.minApiLevel = minApiLevel;
+    this.desugaredLibraryConfiguration = desugaredLibraryConfiguration;
+    this.app = app;
+    this.backportedMethodListConsumer = backportedMethodListConsumer;
+    this.factory = factory;
+  }
+
+  InternalOptions getInternalOptions() {
+    InternalOptions options = new InternalOptions(factory, getReporter());
+    options.minApiLevel = minApiLevel;
+    options.desugaredLibraryConfiguration = desugaredLibraryConfiguration;
+    return options;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static Builder builder(DiagnosticsHandler diagnosticsHandler) {
+    return new Builder(diagnosticsHandler);
+  }
+
+  public static Builder parse(String[] args) {
+    final Set<String> OPTIONS_WITH_PARAMETER =
+        ImmutableSet.of("--output", "--min-api", "--desugared-lib", "--lib");
+
+    boolean hasDefinedApiLevel = false;
+    Builder builder = builder();
+    for (int i = 0; i < args.length; i++) {
+      String arg = args[i].trim();
+      String nextArg = null;
+      if (OPTIONS_WITH_PARAMETER.contains(arg)) {
+        if (++i < args.length) {
+          nextArg = args[i];
+        } else {
+          builder.error(new StringDiagnostic("Missing parameter for " + args[i - 1] + "."));
+          break;
+        }
+      }
+      if (arg.equals("--help")) {
+        builder.setPrintHelp(true);
+      } else if (arg.equals("--version")) {
+        builder.setPrintVersion(true);
+      } else if (arg.equals("--min-api")) {
+        if (hasDefinedApiLevel) {
+          builder.error(new StringDiagnostic("Cannot set multiple --min-api options"));
+        } else {
+          parseMinApi(builder, nextArg);
+          hasDefinedApiLevel = true;
+        }
+      } else if (arg.equals("--desugared-lib")) {
+        builder.addDesugaredLibraryConfiguration(StringResource.fromFile(Paths.get(nextArg)));
+      } else if (arg.equals("--lib")) {
+        builder.addLibraryFiles(Paths.get(nextArg));
+      } else if (arg.equals("--output")) {
+        builder.setOutputPath(Paths.get(nextArg));
+      } else {
+        builder.error(new StringDiagnostic("Unknown option: " + arg));
+      }
+    }
+    return builder;
+  }
+
+  private static void parseMinApi(Builder builder, String minApiString) {
+    int minApi;
+    try {
+      minApi = Integer.parseInt(minApiString);
+    } catch (NumberFormatException e) {
+      builder.error(new StringDiagnostic("Invalid argument to --min-api: " + minApiString));
+      return;
+    }
+    if (minApi < 1) {
+      builder.error(new StringDiagnostic("Invalid argument to --min-api: " + minApiString));
+      return;
+    }
+    builder.setMinApiLevel(minApi);
+  }
+
+  @Keep
+  public static class Builder {
+
+    private final Reporter reporter;
+    private int minApiLevel = AndroidApiLevel.B.getLevel();
+    private List<StringResource> desugaredLibraryConfigurationResources = new ArrayList<>();
+    private final AndroidApp.Builder app;
+    private StringConsumer backportedMethodListConsumer;
+    private boolean printHelp = false;
+    private boolean printVersion = false;
+
+    private Builder() {
+      this(new DiagnosticsHandler() {});
+    }
+
+    private Builder(DiagnosticsHandler diagnosticsHandler) {
+      this.app = AndroidApp.builder();
+      this.reporter = new Reporter(diagnosticsHandler);
+    }
+
+    /**
+     * Set the minimum API level for the application compiled.
+     *
+     * <p>The tool will only report backported methods which are not present at this API level.
+     *
+     * <p>The default is 1 if never set.
+     */
+    public Builder setMinApiLevel(int minApiLevel) {
+      if (minApiLevel <= 0) {
+        reporter.error(new StringDiagnostic("Invalid minApiLevel: " + minApiLevel));
+      } else {
+        this.minApiLevel = minApiLevel;
+      }
+      return this;
+    }
+
+    public int getMinApiLevel() {
+      return minApiLevel;
+    }
+
+    /** Desugared library configuration */
+    public Builder addDesugaredLibraryConfiguration(StringResource configuration) {
+      desugaredLibraryConfigurationResources.add(configuration);
+      return this;
+    }
+
+    /** Desugared library configuration */
+    public Builder addDesugaredLibraryConfiguration(String configuration) {
+      return addDesugaredLibraryConfiguration(
+          StringResource.fromString(configuration, Origin.unknown()));
+    }
+
+    /** The compilation SDK library (android.jar) */
+    public Builder addLibraryResourceProvider(ClassFileResourceProvider provider) {
+      app.addLibraryResourceProvider(provider);
+      return this;
+    }
+
+    /** The compilation SDK library (android.jar) */
+    public Builder addLibraryFiles(Path... files) {
+      addLibraryFiles(Arrays.asList(files));
+      return this;
+    }
+
+    /** The compilation SDK library (android.jar) */
+    public Builder addLibraryFiles(Collection<Path> files) {
+      for (Path path : files) {
+        app.addLibraryFile(path);
+      }
+      return this;
+    }
+
+    DesugaredLibraryConfiguration getDesugaredLibraryConfiguration(DexItemFactory factory) {
+      if (desugaredLibraryConfigurationResources.isEmpty()) {
+        return DesugaredLibraryConfiguration.empty();
+      }
+      if (desugaredLibraryConfigurationResources.size() > 1) {
+        reporter.fatalError("Only one desugared library configuration is supported.");
+      }
+      StringResource desugaredLibraryConfigurationResource =
+          desugaredLibraryConfigurationResources.get(0);
+      DesugaredLibraryConfigurationParser libraryParser =
+          new DesugaredLibraryConfigurationParser(factory, null, false, getMinApiLevel());
+      return libraryParser.parse(desugaredLibraryConfigurationResource);
+    }
+
+    /** Output file for the backported method list */
+    public Builder setOutputPath(Path outputPath) {
+      backportedMethodListConsumer =
+          new StringConsumer.FileConsumer(outputPath) {
+            @Override
+            public void accept(String string, DiagnosticsHandler handler) {
+              super.accept(string, handler);
+              super.accept(System.lineSeparator(), handler);
+            }
+          };
+      return this;
+    }
+
+    /** Consumer receiving the the backported method list */
+    public Builder setConsumer(StringConsumer consumer) {
+      this.backportedMethodListConsumer = consumer;
+      return this;
+    }
+
+    /** True if the print-help flag is enabled. */
+    public boolean isPrintHelp() {
+      return printHelp;
+    }
+
+    /** Set the value of the print-help flag. */
+    public Builder setPrintHelp(boolean printHelp) {
+      this.printHelp = printHelp;
+      return this;
+    }
+
+    /** True if the print-version flag is enabled. */
+    public boolean isPrintVersion() {
+      return printVersion;
+    }
+
+    /** Set the value of the print-version flag. */
+    public Builder setPrintVersion(boolean printVersion) {
+      this.printVersion = printVersion;
+      return this;
+    }
+
+    private void error(Diagnostic diagnostic) {
+      reporter.error(diagnostic);
+    }
+
+    public BackportedMethodListCommand build() {
+      AndroidApp library = app.build();
+      if (!desugaredLibraryConfigurationResources.isEmpty()
+          && library.getLibraryResourceProviders().isEmpty()) {
+        reporter.error(
+            new StringDiagnostic("With desugared library configuration a library is required"));
+      }
+
+      if (isPrintHelp() || isPrintVersion()) {
+        return new BackportedMethodListCommand(isPrintHelp(), isPrintVersion());
+      }
+
+      if (backportedMethodListConsumer == null) {
+        backportedMethodListConsumer =
+            new StringConsumer() {
+              @Override
+              public void accept(String string, DiagnosticsHandler handler) {
+                System.out.println(string);
+              }
+
+              @Override
+              public void finished(DiagnosticsHandler handler) {}
+            };
+      }
+      DexItemFactory factory = new DexItemFactory();
+      return new BackportedMethodListCommand(
+          reporter,
+          minApiLevel,
+          getDesugaredLibraryConfiguration(factory),
+          library,
+          backportedMethodListConsumer,
+          factory);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/GenerateBackportedMethodList.java b/src/main/java/com/android/tools/r8/GenerateBackportedMethodList.java
deleted file mode 100644
index 90f577b..0000000
--- a/src/main/java/com/android/tools/r8/GenerateBackportedMethodList.java
+++ /dev/null
@@ -1,19 +0,0 @@
-// 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;
-
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
-import com.android.tools.r8.utils.AndroidApiLevel;
-
-public class GenerateBackportedMethodList {
-
-  public static void main(String[] args) {
-    BackportedMethodRewriter.generateListOfBackportedMethods(AndroidApiLevel.B).stream()
-        .map(DexMethod::toSourceString)
-        .sorted()
-        .forEach(System.out::println);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/SwissArmyKnife.java b/src/main/java/com/android/tools/r8/SwissArmyKnife.java
index d13081c..89aa64e 100644
--- a/src/main/java/com/android/tools/r8/SwissArmyKnife.java
+++ b/src/main/java/com/android/tools/r8/SwissArmyKnife.java
@@ -79,6 +79,9 @@
       case "l8":
         L8.main(shift(args));
         break;
+      case "backportedmethods":
+        BackportedMethodList.main(shift(args));
+        break;
       default:
         runDefault(args);
         break;
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 076b8a3..b3252ab 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.27";
+  public static final String LABEL = "2.0.28";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index 8c632a2..5d1671b 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -4,12 +4,18 @@
 
 package com.android.tools.r8.ir.desugar;
 
+import static com.android.tools.r8.utils.ExceptionUtils.unwrapExecutionException;
+
+import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.ClassAccessFlags;
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexAnnotationSet;
+import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexApplication.Builder;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
@@ -43,10 +49,13 @@
 import com.android.tools.r8.ir.desugar.backports.OptionalMethodRewrites;
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.StringDiagnostic;
+import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -81,15 +90,29 @@
     this.rewritableMethods = new RewritableMethods(appView.options(), appView);
   }
 
-  public static List<DexMethod> generateListOfBackportedMethods(AndroidApiLevel apiLevel) {
-    List<DexMethod> methods = new ArrayList<>();
-    InternalOptions options = new InternalOptions();
-    options.minApiLevel = apiLevel.getLevel();
-    AppView<?> appView = AppView.createForD8(null, options);
-    BackportedMethodRewriter.RewritableMethods rewritableMethods =
-        new BackportedMethodRewriter.RewritableMethods(options, appView);
-    rewritableMethods.visit(methods::add);
-    return methods;
+  public static List<DexMethod> generateListOfBackportedMethods(
+      AndroidApp androidApp, InternalOptions options, ExecutorService executor) throws IOException {
+    try {
+      List<DexMethod> methods = new ArrayList<>();
+      PrefixRewritingMapper rewritePrefix =
+          options.desugaredLibraryConfiguration.createPrefixRewritingMapper(options);
+      AppInfo appInfo = null;
+      if (androidApp != null) {
+        DexApplication app =
+            new ApplicationReader(androidApp, options, Timing.empty()).read(executor);
+        appInfo =
+            options.desugaredLibraryConfiguration.getRewritePrefix().isEmpty()
+                ? new AppInfo(app)
+                : new AppInfoWithClassHierarchy(app);
+      }
+      AppView<?> appView = AppView.createForD8(appInfo, options, rewritePrefix);
+      BackportedMethodRewriter.RewritableMethods rewritableMethods =
+          new BackportedMethodRewriter.RewritableMethods(options, appView);
+      rewritableMethods.visit(methods::add);
+      return methods;
+    } catch (ExecutionException e) {
+      throw unwrapExecutionException(e);
+    }
   }
 
   public void desugar(IRCode code) {
diff --git a/src/test/java/com/android/tools/r8/BackportedMethodListTest.java b/src/test/java/com/android/tools/r8/BackportedMethodListTest.java
new file mode 100644
index 0000000..bb344d7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/BackportedMethodListTest.java
@@ -0,0 +1,154 @@
+// 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;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Assume;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class BackportedMethodListTest {
+
+  @Rule public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
+
+  enum Mode {
+    NO_LIBRARY,
+    LIBRARY,
+    LIBRARY_DESUGAR
+  }
+
+  @Parameterized.Parameters(name = "Mode: {0}")
+  public static Object[] data() {
+    return Mode.values();
+  }
+
+  private final Mode mode;
+
+  public BackportedMethodListTest(Mode mode) {
+    this.mode = mode;
+  }
+
+  private static class ListStringConsumer implements StringConsumer {
+    List<String> strings = new ArrayList<>();
+    boolean finished = false;
+
+    @Override
+    public void accept(String string, DiagnosticsHandler handler) {
+      strings.add(string);
+    }
+
+    @Override
+    public void finished(DiagnosticsHandler handler) {
+      finished = true;
+    }
+  }
+
+  private void checkContent(int apiLevel, List<String> backports) {
+    // Java 8 methods added at various API levels.
+    assertEquals(
+        apiLevel < AndroidApiLevel.K.getLevel(), backports.contains("java/lang/Byte#compare(BB)I"));
+    assertEquals(
+        apiLevel < AndroidApiLevel.N.getLevel(),
+        backports.contains("java/lang/Integer#hashCode(I)I"));
+    assertEquals(
+        apiLevel < AndroidApiLevel.O.getLevel(),
+        backports.contains("java/lang/Short#toUnsignedLong(S)J"));
+
+    // Java 9, 10 and 11 Optional methods which require Android N or library desugaring.
+    assertEquals(
+        mode == Mode.LIBRARY_DESUGAR || apiLevel >= AndroidApiLevel.N.getLevel(),
+        backports.contains(
+            "java/util/Optional#or(Ljava/util/function/Supplier;)Ljava/util/Optional;"));
+    assertEquals(
+        mode == Mode.LIBRARY_DESUGAR || apiLevel >= AndroidApiLevel.N.getLevel(),
+        backports.contains("java/util/OptionalInt#orElseThrow()I"));
+    assertEquals(
+        mode == Mode.LIBRARY_DESUGAR || apiLevel >= AndroidApiLevel.N.getLevel(),
+        backports.contains("java/util/OptionalLong#isEmpty()Z"));
+
+    // Java 9, 10 and 11 methods.
+    assertTrue(backports.contains("java/lang/StrictMath#multiplyExact(JI)J"));
+    assertTrue(backports.contains("java/util/List#copyOf(Ljava/util/Collection;)Ljava/util/List;"));
+    assertTrue(backports.contains("java/lang/Character#toString(I)Ljava/lang/String;"));
+  }
+
+  private void addLibraryDesugaring(BackportedMethodListCommand.Builder builder) {
+    builder
+        .addDesugaredLibraryConfiguration(
+            StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING))
+        .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P.getLevel()));
+  }
+
+  @Test
+  public void testConsumer() throws Exception {
+    for (int apiLevel = 1; apiLevel < AndroidApiLevel.LATEST.getLevel(); apiLevel++) {
+      ListStringConsumer consumer = new ListStringConsumer();
+      BackportedMethodListCommand.Builder builder =
+          BackportedMethodListCommand.builder().setMinApiLevel(apiLevel).setConsumer(consumer);
+      if (mode == Mode.LIBRARY) {
+        builder.addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P.getLevel()));
+      } else if (mode == Mode.LIBRARY_DESUGAR) {
+        addLibraryDesugaring(builder);
+      }
+      BackportedMethodList.run(builder.build());
+      assertTrue(consumer.finished);
+      checkContent(apiLevel, consumer.strings);
+    }
+  }
+
+  @Test
+  public void testFile() throws Exception {
+    for (int apiLevel = 1; apiLevel < AndroidApiLevel.LATEST.getLevel(); apiLevel++) {
+      Path output = temp.newFile().toPath();
+      BackportedMethodListCommand.Builder builder =
+          BackportedMethodListCommand.builder().setMinApiLevel(apiLevel).setOutputPath(output);
+      if (mode == Mode.LIBRARY) {
+        builder.addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P.getLevel()));
+      } else if (mode == Mode.LIBRARY_DESUGAR) {
+        addLibraryDesugaring(builder);
+      }
+      BackportedMethodList.run(builder.build());
+      checkContent(apiLevel, Files.readAllLines(output));
+    }
+  }
+
+  @Test
+  public void testFullList() throws Exception {
+    Assume.assumeTrue(mode == Mode.NO_LIBRARY);
+    ListStringConsumer consumer = new ListStringConsumer();
+    // Not setting neither min API level not library should produce the full list.
+    BackportedMethodList.run(BackportedMethodListCommand.builder().setConsumer(consumer).build());
+    assertTrue(consumer.finished);
+    checkContent(1, consumer.strings);
+  }
+
+  @Test
+  public void requireLibraryForDesugar() {
+    Assume.assumeTrue(mode == Mode.LIBRARY_DESUGAR);
+    // Require library when a desugar configuration is passed.
+    try {
+      BackportedMethodList.run(
+          BackportedMethodListCommand.builder()
+              .addDesugaredLibraryConfiguration(
+                  StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING))
+              .setConsumer(new ListStringConsumer())
+              .build());
+      fail("Expected failure");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/TestBackportedNotPresentInAndroidJar.java b/src/test/java/com/android/tools/r8/desugar/backports/TestBackportedNotPresentInAndroidJar.java
index 2c7cbe5..83682b2 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/TestBackportedNotPresentInAndroidJar.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/TestBackportedNotPresentInAndroidJar.java
@@ -13,6 +13,8 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -34,8 +36,11 @@
       // Check that the backported methods for each API level are are not present in the
       // android.jar for that level.
       CodeInspector inspector = new CodeInspector(ToolHelper.getAndroidJar(apiLevel));
+      InternalOptions options = new InternalOptions();
+      options.minApiLevel = apiLevel.getLevel();
       List<DexMethod> backportedMethods =
-          BackportedMethodRewriter.generateListOfBackportedMethods(apiLevel);
+          BackportedMethodRewriter.generateListOfBackportedMethods(
+              null, options, ThreadUtils.getExecutorService(options));
       for (DexMethod method : backportedMethods) {
         // Two different DexItemFactories are in play, but as toSourceString is used for lookup
         // that is not an issue.