diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
index e469f0a..07e0617 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
@@ -20,6 +20,7 @@
 import com.android.tools.r8.errors.UnsupportedMainDexListUsageDiagnostic;
 import com.android.tools.r8.graph.ApplicationReaderMap;
 import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexApplicationReadFlags;
 import com.android.tools.r8.graph.DexClass;
@@ -379,6 +380,20 @@
       }
     }
 
+    private boolean includeAnnotationClass(DexProgramClass clazz) {
+      if (!options.pruneNonVissibleAnnotationClasses) {
+        return true;
+      }
+      DexAnnotation retentionAnnotation =
+          clazz.annotations().getFirstMatching(itemFactory.retentionType);
+      // Default is CLASS retention, read if retained.
+      if (retentionAnnotation == null) {
+        return DexAnnotation.retainCompileTimeAnnotation(clazz.getType(), application.options);
+      }
+      // Otherwise only read runtime visible annotations.
+      return retentionAnnotation.annotation.toString().contains("RUNTIME");
+    }
+
     private void readClassSources(
         List<ProgramResource> classSources, Queue<DexProgramClass> classes) {
       if (classSources.isEmpty()) {
@@ -386,7 +401,15 @@
       }
       hasReadProgramResourceFromCf = true;
       JarClassFileReader<DexProgramClass> reader =
-          new JarClassFileReader<>(application, classes::add, PROGRAM);
+          new JarClassFileReader<>(
+              application,
+              clazz -> {
+                if (clazz.isAnnotation() && !includeAnnotationClass(clazz)) {
+                  return;
+                }
+                classes.add(clazz);
+              },
+              PROGRAM);
       // Read classes in parallel.
       for (ProgramResource input : classSources) {
         futures.add(
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java b/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java
index 4952830..b648635 100644
--- a/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java
@@ -128,15 +128,18 @@
           if (proto.parameters.isEmpty()) {
             DexType valueType = proto.returnType.toBaseType(appView.dexItemFactory());
             if (valueType.isClassType()) {
-              if (isEnum(valueType)) {
-                value = true;
-                break;
-              } else if (isAnnotation(valueType) && isAnnotationWithEnum(valueType)) {
-                value = true;
-                break;
-              }
+              assert !value;
+              boolean notLibraryOrTakeBootClasspath =
+                  !appInfo().definitionFor(valueType).isLibraryClass()
+                      || !appView.options().ignoreBootClasspathEnumsForMaindexTracing;
+              value =
+                  (isEnum(valueType) && notLibraryOrTakeBootClasspath)
+                      || (isAnnotation(valueType) && isAnnotationWithEnum(valueType));
             }
           }
+          if (value) {
+            break;
+          }
         }
       }
       annotationTypeContainEnum.put(dexType, value);
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 1899f46..0fdc11c 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -519,6 +519,10 @@
   // Intermediate builds also emits or update synthesized classes mapping.
   public boolean intermediate = false;
   public boolean retainCompileTimeAnnotations = true;
+  public boolean ignoreBootClasspathEnumsForMaindexTracing =
+      System.getProperty("com.android.tools.r8.ignoreBootClasspathEnumsForMaindexTracing") != null;
+  public boolean pruneNonVissibleAnnotationClasses =
+      System.getProperty("com.android.tools.r8.pruneNonVissibleAnnotationClasses") != null;
   public List<String> logArgumentsFilter = ImmutableList.of();
 
   // Flag to turn on/offLoad/store optimization in the Cf back-end.
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexRuntimeAndProgramEnumInAnnotationTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexRuntimeAndProgramEnumInAnnotationTest.java
new file mode 100644
index 0000000..9d5f2f1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexRuntimeAndProgramEnumInAnnotationTest.java
@@ -0,0 +1,162 @@
+// Copyright (c) 2021, 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.maindexlist;
+
+import static com.android.tools.r8.maindexlist.MainDexRuntimeAndProgramEnumInAnnotationTest.EnumForAnnotation.TEST;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MainDexRuntimeAndProgramEnumInAnnotationTest extends TestBase {
+
+  Set<Class<?>> CUSTOM_CLASSES =
+      ImmutableSet.of(
+          B.class,
+          Main.class,
+          EnumForAnnotation.class,
+          RuntimeRetentionAnnotationWithProgramEnum.class);
+  Set<Class<?>> DEFAULT_CLASSES =
+      Sets.union(
+          CUSTOM_CLASSES,
+          ImmutableSet.of(
+              C.class,
+              RuntimeRetentionAnnotationWithRuntimeEnum.class,
+              RuntimeRetentionAnnotationWithoutEnum.class));
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public boolean ignoreBootclasspathEnumsForMaindexTracing;
+
+  @Parameters(name = "{0}, ignoreBootclasspathEnumsForMaindexTracing: {1}")
+  public static List<Object[]> parameters() {
+    return buildParameters(
+        getTestParameters()
+            .withDexRuntimes()
+            .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+            .build(),
+        BooleanUtils.values());
+  }
+
+  @Test
+  public void testMainDex() throws Exception {
+    testForMainDexListGenerator(temp)
+        .addInnerClasses(getClass())
+        .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+        .addMainDexRules(
+            "-keep class " + Main.class.getTypeName() + " {",
+            "  public static void main(java.lang.String[]);",
+            "}")
+        .applyIf(
+            ignoreBootclasspathEnumsForMaindexTracing,
+            builder ->
+                builder.addOptionsModification(
+                    options -> {
+                      options.ignoreBootClasspathEnumsForMaindexTracing = true;
+                    }))
+        .run()
+        .inspectMainDexClasses(
+            mainDexList -> {
+              assertEquals(
+                  (ignoreBootclasspathEnumsForMaindexTracing ? CUSTOM_CLASSES : DEFAULT_CLASSES)
+                      .stream().map(Reference::classFromClass).collect(Collectors.toSet()),
+                  new HashSet<>(mainDexList));
+            });
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    testForD8(temp)
+        .addInnerClasses(getClass())
+        .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+        .setMinApi(parameters.getApiLevel())
+        .applyIf(
+            ignoreBootclasspathEnumsForMaindexTracing,
+            builder ->
+                builder.addOptionsModification(
+                    options -> options.ignoreBootClasspathEnumsForMaindexTracing = true))
+        .collectMainDexClasses()
+        .addMainDexRules(
+            "-keep class " + Main.class.getTypeName() + " {",
+            "  public static void main(java.lang.String[]);",
+            "}")
+        .compile()
+        .inspectMainDexClasses(
+            mainDexClasses -> {
+              assertEquals(
+                  (ignoreBootclasspathEnumsForMaindexTracing ? CUSTOM_CLASSES : DEFAULT_CLASSES)
+                      .stream().map(TestBase::typeName).collect(Collectors.toSet()),
+                  mainDexClasses);
+            });
+  }
+
+  public enum EnumForAnnotation {
+    TEST
+  }
+
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target(ElementType.TYPE)
+  public @interface RuntimeRetentionAnnotationWithoutEnum {}
+
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target(ElementType.TYPE)
+  public @interface RuntimeRetentionAnnotationWithProgramEnum {
+
+    EnumForAnnotation value() default TEST;
+  }
+
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target(ElementType.TYPE)
+  public @interface RuntimeRetentionAnnotationWithRuntimeEnum {
+
+    ElementType value();
+  }
+
+  @RuntimeRetentionAnnotationWithoutEnum
+  public static class A {
+
+    public static void main(String[] args) {}
+  }
+
+  @RuntimeRetentionAnnotationWithProgramEnum
+  public static class B {
+
+    public static void main(String[] args) {}
+  }
+
+  @RuntimeRetentionAnnotationWithRuntimeEnum(ElementType.TYPE)
+  public static class C {
+
+    public static void main(String[] args) {}
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      System.out.println("Hello, world!");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexSourceAndClassRetentionTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexSourceAndClassRetentionTest.java
index 4bcb143..089f670 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexSourceAndClassRetentionTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexSourceAndClassRetentionTest.java
@@ -4,21 +4,20 @@
 
 package com.android.tools.r8.maindexlist;
 
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.google.common.collect.ImmutableSet;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.junit.Test;
@@ -35,12 +34,17 @@
   @Parameter(0)
   public TestParameters parameters;
 
-  @Parameters(name = "{0}")
-  public static TestParametersCollection parameters() {
-    return getTestParameters()
-        .withDexRuntimes()
-        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
-        .build();
+  @Parameter(1)
+  public boolean pruneNonVisibleAnnotationClasses;
+
+  @Parameters(name = "{0}, pruneNonVisibleAnnotationClasses: {1}")
+  public static List<Object[]> parameters() {
+    return buildParameters(
+        getTestParameters()
+            .withDexRuntimes()
+            .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+            .build(),
+        BooleanUtils.values());
   }
 
   @Test
@@ -52,6 +56,12 @@
             "-keep class " + Main.class.getTypeName() + " {",
             "  public static void main(java.lang.String[]);",
             "}")
+        .applyIf(
+            pruneNonVisibleAnnotationClasses,
+            builder -> {
+              builder.addOptionsModification(
+                  options -> options.pruneNonVissibleAnnotationClasses = true);
+            })
         .run()
         .inspectMainDexClasses(
             mainDexList -> {
@@ -69,6 +79,12 @@
         .addInnerClasses(getClass())
         .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
         .setMinApi(parameters.getApiLevel())
+        .applyIf(
+            pruneNonVisibleAnnotationClasses,
+            builder -> {
+              builder.addOptionsModification(
+                  options -> options.pruneNonVissibleAnnotationClasses = true);
+            })
         .collectMainDexClasses()
         .addMainDexRules(
             "-keep class " + Main.class.getTypeName() + " {",
@@ -80,8 +96,12 @@
             inspector -> {
               // Source and class retention annotation classes are still in the output, but does not
               // annotate anything.
-              assertThat(inspector.clazz(SourceRetentionAnnotation.class), isPresent());
-              assertThat(inspector.clazz(ClassRetentionAnnotation.class), isPresent());
+              assertEquals(
+                  pruneNonVisibleAnnotationClasses,
+                  !inspector.clazz(SourceRetentionAnnotation.class).isPresent());
+              assertEquals(
+                  pruneNonVisibleAnnotationClasses,
+                  !inspector.clazz(ClassRetentionAnnotation.class).isPresent());
               assertEquals(0, inspector.clazz(Main.class).annotations().size());
               assertEquals(0, inspector.clazz(A.class).annotations().size());
             })