Implement input pruning using .d files in objc behind a flag that defaults to

false.

--
MOS_MIGRATED_REVID=134452391

11 files changed, 500 insertions, 161 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/analysis/actions/LTOBackendAction.java b/src/main/java/com/google/devtools/build/lib/analysis/actions/LTOBackendAction.java
index c5dc74489d..06dd6e8c8a 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/actions/LTOBackendAction.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/actions/LTOBackendAction.java
@@ -25,6 +25,7 @@ import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.actions.ArtifactResolver;
 import com.google.devtools.build.lib.actions.PackageRootResolutionException;
 import com.google.devtools.build.lib.actions.PackageRootResolver;
+import com.google.devtools.build.lib.actions.ResourceSet;
 import com.google.devtools.build.lib.collect.nestedset.NestedSet;
 import com.google.devtools.build.lib.util.Fingerprint;
 import com.google.devtools.build.lib.vfs.FileSystemUtils;
@@ -228,11 +229,12 @@ public final class LTOBackendAction extends SpawnAction {
     }
 
     @Override
-    SpawnAction createSpawnAction(
+    protected SpawnAction createSpawnAction(
         ActionOwner owner,
         NestedSet<Artifact> tools,
         NestedSet<Artifact> inputsAndTools,
         ImmutableList<Artifact> outputs,
+        ResourceSet resourceSet,
         CommandLine actualCommandLine,
         ImmutableMap<String, String> env,
         ImmutableSet<String> clientEnvironmentVariables,
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/actions/SpawnAction.java b/src/main/java/com/google/devtools/build/lib/analysis/actions/SpawnAction.java
index 988e1d812e..5d8ad84e76 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/actions/SpawnAction.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/actions/SpawnAction.java
@@ -65,13 +65,13 @@ import javax.annotation.Nullable;
 
 /** An Action representing an arbitrary subprocess to be forked and exec'd. */
 public class SpawnAction extends AbstractAction implements ExecutionInfoSpecifier, CommandAction {
-  private static class ExtraActionInfoSupplier<T> {
+  
+  /** Sets extensions on ExtraActionInfo **/
+  protected static class ExtraActionInfoSupplier<T> {
     private final GeneratedExtension<ExtraActionInfo, T> extension;
     private final T value;
 
-    private ExtraActionInfoSupplier(
-        GeneratedExtension<ExtraActionInfo, T> extension,
-        T value) {
+    protected ExtraActionInfoSupplier(GeneratedExtension<ExtraActionInfo, T> extension, T value) {
       this.extension = extension;
       this.value = value;
     }
@@ -495,7 +495,7 @@ public class SpawnAction extends AbstractAction implements ExecutionInfoSpecifie
     private ImmutableMap<String, String> executionInfo = ImmutableMap.of();
     private boolean isShellCommand = false;
     private boolean useDefaultShellEnvironment = false;
-    private boolean executeUnconditionally;
+    protected boolean executeUnconditionally;
     private PathFragment executable;
     // executableArgs does not include the executable itself.
     private List<String> executableArgs;
@@ -505,7 +505,7 @@ public class SpawnAction extends AbstractAction implements ExecutionInfoSpecifie
     private String progressMessage;
     private ParamFileInfo paramFileInfo = null;
     private String mnemonic = "Unknown";
-    private ExtraActionInfoSupplier<?> extraActionInfoSupplier = null;
+    protected ExtraActionInfoSupplier<?> extraActionInfoSupplier = null;
     private boolean disableSandboxing = false;
 
     /**
@@ -669,6 +669,7 @@ public class SpawnAction extends AbstractAction implements ExecutionInfoSpecifie
           tools,
           inputsAndTools,
           ImmutableList.copyOf(outputs),
+          resourceSet,
           actualCommandLine,
           ImmutableMap.copyOf(env),
           clientEnvironmentVariables,
@@ -678,11 +679,13 @@ public class SpawnAction extends AbstractAction implements ExecutionInfoSpecifie
           mnemonic);
     }
 
-    SpawnAction createSpawnAction(
+    /** Creates a SpawnAction. */
+    protected SpawnAction createSpawnAction(
         ActionOwner owner,
         NestedSet<Artifact> tools,
         NestedSet<Artifact> inputsAndTools,
         ImmutableList<Artifact> outputs,
+        ResourceSet resourceSet,
         CommandLine actualCommandLine,
         ImmutableMap<String, String> env,
         ImmutableSet<String> clientEnvironmentVariables,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileAction.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileAction.java
index 322ed53c72..c3c93864a8 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileAction.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileAction.java
@@ -43,7 +43,6 @@ import com.google.devtools.build.lib.analysis.actions.ExecutionInfoSpecifier;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.analysis.config.PerLabelOptions;
 import com.google.devtools.build.lib.cmdline.Label;
-import com.google.devtools.build.lib.cmdline.RepositoryName;
 import com.google.devtools.build.lib.collect.CollectionUtils;
 import com.google.devtools.build.lib.collect.nestedset.NestedSet;
 import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
@@ -189,8 +188,8 @@ public class CppCompileAction extends AbstractAction
   @VisibleForTesting final CppConfiguration cppConfiguration;
   private final FeatureConfiguration featureConfiguration;
   protected final Class<? extends CppCompileActionContext> actionContext;
-  private final SpecialInputsHandler specialInputsHandler;
-  private final CppSemantics semantics;
+  protected final SpecialInputsHandler specialInputsHandler;
+  protected final CppSemantics cppSemantics;
 
   /**
    * Identifier for the actual execution time behavior of the action.
@@ -285,7 +284,7 @@ public class CppCompileAction extends AbstractAction
       ImmutableMap<String, String> environment,
       String actionName,
       RuleContext ruleContext,
-      CppSemantics semantics) {
+      CppSemantics cppSemantics) {
     super(
         owner,
         createInputs(
@@ -325,8 +324,8 @@ public class CppCompileAction extends AbstractAction
     // artifact and will definitely exist prior to this action execution.
     this.mandatoryInputs = mandatoryInputs;
     this.builtinIncludeFiles = CppHelper.getToolchain(ruleContext).getBuiltinIncludeFiles();
-    this.semantics = semantics;
-    if (semantics.needsIncludeValidation()) {
+    this.cppSemantics = cppSemantics;
+    if (cppSemantics.needsIncludeValidation()) {
       verifyIncludePaths(ruleContext);
     }
     this.additionalIncludeScannables = ImmutableList.copyOf(additionalIncludeScannables);
@@ -354,6 +353,12 @@ public class CppCompileAction extends AbstractAction
         continue;
       }
 
+      // One starting ../ is okay for getting to a sibling repository.
+      PathFragment originalInclude = include;
+      if (include.startsWith(new PathFragment(Label.EXTERNAL_PATH_PREFIX))) {
+        include = include.relativeTo(Label.EXTERNAL_PATH_PREFIX);
+      }
+
       if (include.isAbsolute()
           || !PathFragment.EMPTY_FRAGMENT.getRelative(include).normalize().isNormalized()) {
         ruleContext.ruleError(
@@ -462,9 +467,6 @@ public class CppCompileAction extends AbstractAction
       throws ActionExecutionException, InterruptedException {
     Executor executor = actionExecutionContext.getExecutor();
     Collection<Artifact> initialResult;
-    if (!shouldScanIncludes) {
-      return null;
-    }
     try {
       initialResult = executor.getContext(actionContext)
           .findAdditionalInputs(this, actionExecutionContext);
@@ -946,105 +948,6 @@ public class CppCompileAction extends AbstractAction
     }
   }
 
-  private DependencySet processDepset(Path execRoot, CppCompileActionContext.Reply reply)
-      throws IOException {
-    DotdFile dotdFile = getDotdFile();
-    Preconditions.checkNotNull(dotdFile);
-    DependencySet depSet = new DependencySet(execRoot);
-    // artifact() is null if we are using in-memory .d files. We also want to prepare for the
-    // case where we expected an in-memory .d file, but we did not get an appropriate response.
-    // Perhaps we produced the file locally.
-    if (dotdFile.artifact() != null || reply == null) {
-      return depSet.read(dotdFile.getPath());
-    } else {
-      // This is an in-memory .d file.
-      return depSet.process(reply.getContents());
-    }
-  }
-
-  /**
-   * Returns a collection with additional input artifacts relevant to the action by reading the
-   * dynamically-discovered dependency information from the .d file after the action has run.
-   *
-   * <p>Artifacts are considered inputs but not "mandatory" inputs.
-   *
-   * @param reply the reply from the compilation.
-   * @throws ActionExecutionException iff the .d is missing (when required), malformed, or has
-   *         unresolvable included artifacts.
-   */
-  @VisibleForTesting
-  @ThreadCompatible
-  public NestedSet<Artifact> discoverInputsFromDotdFiles(
-      Path execRoot, ArtifactResolver artifactResolver, Reply reply)
-      throws ActionExecutionException {
-    NestedSetBuilder<Artifact> inputs = NestedSetBuilder.stableOrder();
-    if (getDotdFile() == null) {
-      return inputs.build();
-    }
-    try {
-      // Read .d file.
-      DependencySet depSet = processDepset(execRoot, reply);
-
-      // Determine prefixes of allowed absolute inclusions.
-      CppConfiguration toolchain = cppConfiguration;
-      List<Path> systemIncludePrefixes = new ArrayList<>();
-      for (PathFragment includePath : toolchain.getBuiltInIncludeDirectories()) {
-        if (includePath.isAbsolute()) {
-          systemIncludePrefixes.add(execRoot.getFileSystem().getPath(includePath));
-        }
-      }
-
-      // Check inclusions.
-      IncludeProblems problems = new IncludeProblems();
-      Map<PathFragment, Artifact> allowedDerivedInputsMap = getAllowedDerivedInputsMap();
-      for (Path execPath : depSet.getDependencies()) {
-        // Module .pcm files are generated and thus aren't declared inputs.
-        if (execPath.getBaseName().endsWith(".pcm")) {
-          continue;
-        }
-        PathFragment execPathFragment = execPath.asFragment();
-        if (execPathFragment.isAbsolute()) {
-          // Absolute includes from system paths are ignored.
-          if (FileSystemUtils.startsWithAny(execPath, systemIncludePrefixes)) {
-            continue;
-          }
-          // Since gcc is given only relative paths on the command line,
-          // non-system include paths here should never be absolute. If they
-          // are, it's probably due to a non-hermetic #include, & we should stop
-          // the build with an error.
-          if (execPath.startsWith(execRoot)) {
-            execPathFragment = execPath.relativeTo(execRoot); // funky but tolerable path
-          } else {
-            problems.add(execPathFragment.getPathString());
-            continue;
-          }
-        }
-        Artifact artifact = allowedDerivedInputsMap.get(execPathFragment);
-        if (artifact == null) {
-          artifact = artifactResolver.resolveSourceArtifact(execPathFragment, RepositoryName.MAIN);
-        }
-        if (artifact != null) {
-          inputs.add(artifact);
-          // In some cases, execution backends need extra files for each included file. Add them
-          // to the set of actual inputs.
-          inputs.addAll(specialInputsHandler.getInputsForIncludedFile(artifact, artifactResolver));
-        } else {
-          // Abort if we see files that we can't resolve, likely caused by
-          // undeclared includes or illegal include constructs.
-          problems.add(execPathFragment.getPathString());
-        }
-      }
-      //TODO(b/22551695): Remove in favor of seperate implementations.
-      if (semantics == null || semantics.needsIncludeValidation()) {
-        problems.assertProblemFree(this, getSourceFile());
-      }
-    } catch (IOException e) {
-      // Some kind of IO or parse exception--wrap & rethrow it to stop the build.
-      throw new ActionExecutionException("error while parsing .d file", e, this, false);
-    }
-    return inputs.build();
-  }
-
   @Override
   public Iterable<Artifact> resolveInputsFromCache(
       ArtifactResolver artifactResolver,
@@ -1096,7 +999,7 @@ public class CppCompileAction extends AbstractAction
     }
   }
 
-  private Map<PathFragment, Artifact> getAllowedDerivedInputsMap() {
+  protected Map<PathFragment, Artifact> getAllowedDerivedInputsMap() {
     Map<PathFragment, Artifact> allowedDerivedInputMap = new HashMap<>();
     addToMap(allowedDerivedInputMap, mandatoryInputs);
     addToMap(allowedDerivedInputMap, getDeclaredIncludeSrcs());
@@ -1219,9 +1122,10 @@ public class CppCompileAction extends AbstractAction
 
     // This is the .d file scanning part.
     IncludeScanningContext scanningContext = executor.getContext(IncludeScanningContext.class);
+    Path execRoot = executor.getExecRoot();
+
     NestedSet<Artifact> discoveredInputs =
-        discoverInputsFromDotdFiles(
-            executor.getExecRoot(), scanningContext.getArtifactResolver(), reply);
+        discoverInputsFromDotdFiles(execRoot, scanningContext.getArtifactResolver(), reply);
     reply = null; // Clear in-memory .d files early.
 
     // Post-execute "include scanning", which modifies the action inputs to match what the compile
@@ -1239,14 +1143,64 @@ public class CppCompileAction extends AbstractAction
       updateActionInputs(discoveredInputs);
     }
 
-    // hdrs_check: Turning this off opens the door to incorrect builds.  However, we allow it
-    // to accommodate the current behavior in the objc rules.
-    if (semantics == null || semantics.needsIncludeValidation()) {
-      validateInclusions(
-          discoveredInputs,
-          actionExecutionContext.getArtifactExpander(),
-          executor.getEventHandler());
+    // hdrs_check: This cannot be switched off, because doing so would allow for incorrect builds.
+    validateInclusions(
+        discoveredInputs, actionExecutionContext.getArtifactExpander(), executor.getEventHandler());
+  }
+
+  @VisibleForTesting
+  public NestedSet<Artifact> discoverInputsFromDotdFiles(
+      Path execRoot, ArtifactResolver artifactResolver, Reply reply)
+      throws ActionExecutionException {
+    if (getDotdFile() == null) {
+      return NestedSetBuilder.<Artifact>stableOrder().build();
+    }
+    HeaderDiscovery.Builder discoveryBuilder =
+        new HeaderDiscovery.Builder()
+            .setAction(this)
+            .setDotdFile(getDotdFile())
+            .setSourceFile(getSourceFile())
+            .setSpecialInputsHandler(specialInputsHandler)
+            .setDependencySet(processDepset(execRoot, reply))
+            .setPermittedSystemIncludePrefixes(getPermittedSystemIncludePrefixes(execRoot))
+            .setAllowedDerivedinputsMap(getAllowedDerivedInputsMap());
+
+    if (cppSemantics.needsIncludeValidation()) {
+      discoveryBuilder.shouldValidateInclusions();
+    }
+
+    return discoveryBuilder.build().discoverInputsFromDotdFiles(execRoot, artifactResolver);
+  }
+
+  public DependencySet processDepset(Path execRoot, Reply reply) throws ActionExecutionException {
+    try {
+      DotdFile dotdFile = getDotdFile();
+      Preconditions.checkNotNull(dotdFile);
+      DependencySet depSet = new DependencySet(execRoot);
+      // artifact() is null if we are using in-memory .d files. We also want to prepare for the
+      // case where we expected an in-memory .d file, but we did not get an appropriate response.
+      // Perhaps we produced the file locally.
+      if (dotdFile.artifact() != null || reply == null) {
+        return depSet.read(dotdFile.getPath());
+      } else {
+        // This is an in-memory .d file.
+        return depSet.process(reply.getContents());
+      }
+    } catch (IOException e) {
+      // Some kind of IO or parse exception--wrap & rethrow it to stop the build.
+      throw new ActionExecutionException("error while parsing .d file", e, this, false);
+    }
+  }
+
+  public List<Path> getPermittedSystemIncludePrefixes(Path execRoot) {
+    CppConfiguration toolchain = cppConfiguration;
+    List<Path> systemIncludePrefixes = new ArrayList<>();
+    for (PathFragment includePath : toolchain.getBuiltInIncludeDirectories()) {
+      if (includePath.isAbsolute()) {
+        systemIncludePrefixes.add(execRoot.getFileSystem().getPath(includePath));
+      }
     }
+    return systemIncludePrefixes;
   }
 
   /**
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppModel.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppModel.java
index d7f7e83bc9..9878dd6bb0 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppModel.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppModel.java
@@ -502,7 +502,7 @@ public final class CppModel {
           initializeCompileAction(moduleMapArtifact, moduleMapLabel, /*forInterface=*/ true);
 
       builder.setSemantics(semantics);
-
+      
       // A header module compile action is just like a normal compile action, but:
       // - the compiled source file is the module map
       // - it creates a header module (.pcm file).
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/FakeCppCompileAction.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/FakeCppCompileAction.java
index ad7d5fe735..572853fc7d 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/FakeCppCompileAction.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/FakeCppCompileAction.java
@@ -34,6 +34,7 @@ import com.google.devtools.build.lib.analysis.RuleContext;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.collect.nestedset.NestedSet;
+import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadCompatible;
 import com.google.devtools.build.lib.events.Event;
 import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FeatureConfiguration;
@@ -41,6 +42,7 @@ import com.google.devtools.build.lib.util.Preconditions;
 import com.google.devtools.build.lib.util.ShellEscaper;
 import com.google.devtools.build.lib.util.io.FileOutErr;
 import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import java.io.IOException;
 import java.util.UUID;
@@ -79,7 +81,7 @@ public class FakeCppCompileAction extends CppCompileAction {
       ImmutableList<String> copts,
       Predicate<String> nocopts,
       RuleContext ruleContext,
-      CppSemantics semantics) {
+      CppSemantics cppSemantics) {
     super(
         owner,
         features,
@@ -117,7 +119,7 @@ public class FakeCppCompileAction extends CppCompileAction {
         ImmutableMap.<String, String>of(),
         CppCompileAction.CPP_COMPILE,
         ruleContext,
-        semantics);
+        cppSemantics);
     this.tempOutputFile = Preconditions.checkNotNull(tempOutputFile);
   }
 
@@ -148,9 +150,32 @@ public class FakeCppCompileAction extends CppCompileAction {
       }
     }
     IncludeScanningContext scanningContext = executor.getContext(IncludeScanningContext.class);
-    NestedSet<Artifact> discoveredInputs =
-        discoverInputsFromDotdFiles(
-            executor.getExecRoot(), scanningContext.getArtifactResolver(), reply);
+    Path execRoot = executor.getExecRoot();
+
+    NestedSet<Artifact> discoveredInputs;
+    if (getDotdFile() == null) {
+      discoveredInputs = NestedSetBuilder.<Artifact>stableOrder().build();
+    } else {
+      HeaderDiscovery.Builder discoveryBuilder =
+          new HeaderDiscovery.Builder()
+              .setAction(this)
+              .setDotdFile(getDotdFile())
+              .setSourceFile(getSourceFile())
+              .setSpecialInputsHandler(specialInputsHandler)
+              .setDependencySet(processDepset(execRoot, reply))
+              .setPermittedSystemIncludePrefixes(getPermittedSystemIncludePrefixes(execRoot))
+              .setAllowedDerivedinputsMap(getAllowedDerivedInputsMap());
+
+      if (cppSemantics.needsIncludeValidation()) {
+        discoveryBuilder.shouldValidateInclusions();
+      }
+
+      discoveredInputs =
+          discoveryBuilder
+              .build()
+              .discoverInputsFromDotdFiles(execRoot, scanningContext.getArtifactResolver());
+    }
+     
     reply = null; // Clear in-memory .d files early.
 
     // Even cc_fake_binary rules need to properly declare their dependencies...
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/HeaderDiscovery.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/HeaderDiscovery.java
index 512281ad93..e80856b7c2 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/HeaderDiscovery.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/HeaderDiscovery.java
@@ -36,6 +36,12 @@ import java.util.Map;
 /** Manages the process of obtaining inputs used in a compilation from .d files. */
 public class HeaderDiscovery {
 
+  /** Indicates if a compile should perform dotd pruning. */
+  public static enum DotdPruningMode {
+    USE,
+    DO_NOT_USE
+  }
+  
   private final Action action;
   private final Artifact sourceFile;
   private final DotdFile dotdFile;
@@ -46,7 +52,7 @@ public class HeaderDiscovery {
   private final DependencySet depSet;
   private final List<Path> permittedSystemIncludePrefixes;
   private final Map<PathFragment, Artifact> allowedDerivedInputsMap;
-
+  
   /**
    * Creates a HeaderDiscover instance
    *
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java b/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java
index 7faa6a516d..77faa716d2 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java
@@ -83,6 +83,7 @@ import com.google.devtools.build.lib.rules.apple.AppleConfiguration;
 import com.google.devtools.build.lib.rules.apple.AppleToolchain;
 import com.google.devtools.build.lib.rules.apple.Platform;
 import com.google.devtools.build.lib.rules.apple.Platform.PlatformType;
+import com.google.devtools.build.lib.rules.cpp.CppCompileAction.DotdFile;
 import com.google.devtools.build.lib.rules.cpp.CppModuleMap;
 import com.google.devtools.build.lib.rules.cpp.CppModuleMapAction;
 import com.google.devtools.build.lib.rules.objc.XcodeProvider.Builder;
@@ -655,19 +656,21 @@ public final class CompilationSupport {
     boolean runCodeCoverage =
         buildConfiguration.isCodeCoverageEnabled() && ObjcRuleClasses.isInstrumentable(sourceFile);
     boolean hasSwiftSources = compilationArtifacts.hasSwiftSources();
+    DotdFile dotdFile = intermediateArtifacts.dotdFile(sourceFile);
 
-    CustomCommandLine commandLine = compileActionCommandLine(
-        sourceFile,
-        objFile,
-        objcProvider,
-        priorityHeaders,
-        moduleMap,
-        compilationArtifacts.getPchFile(),
-        Optional.of(intermediateArtifacts.dotdFile(sourceFile)),
-        otherFlags,
-        runCodeCoverage,
-        isCPlusPlusSource,
-        hasSwiftSources);
+    CustomCommandLine commandLine =
+        compileActionCommandLine(
+            sourceFile,
+            objFile,
+            objcProvider,
+            priorityHeaders,
+            moduleMap,
+            compilationArtifacts.getPchFile(),
+            Optional.of(dotdFile.artifact()),
+            otherFlags,
+            runCodeCoverage,
+            isCPlusPlusSource,
+            hasSwiftSources);
 
     Optional<Artifact> gcnoFile = Optional.absent();
     if (runCodeCoverage && !buildConfiguration.isLLVMCoverageMapFormatEnabled()) {
@@ -684,24 +687,26 @@ public final class CompilationSupport {
       moduleMapInputs = objcProvider.get(MODULE_MAP);
     }
 
-    // TODO(bazel-team): Remote private headers from inputs once they're added to the provider.
+    // TODO(bazel-team): Remove private headers from inputs once they're added to the provider.
     ruleContext.registerAction(
-        ObjcRuleClasses.spawnAppleEnvActionBuilder(
+        ObjcCompileAction.Builder.createObjcCompileActionBuilderWithAppleEnv(
                 appleConfiguration, appleConfiguration.getSingleArchPlatform())
+            .setDotdPruningPlan(objcConfiguration.getDotdPruningPlan())
+            .setSourceFile(sourceFile)
+            .addMandatoryInputs(swiftHeader.asSet())
+            .addTransitiveMandatoryInputs(moduleMapInputs)
+            .addTransitiveMandatoryInputs(objcProvider.get(STATIC_FRAMEWORK_FILE))
+            .addTransitiveMandatoryInputs(objcProvider.get(DYNAMIC_FRAMEWORK_FILE))
+            .setDotdFile(dotdFile)
+            .addInputs(compilationArtifacts.getPrivateHdrs())
+            .addInputs(compilationArtifacts.getPchFile().asSet())
             .setMnemonic("ObjcCompile")
             .setExecutable(xcrunwrapper(ruleContext))
             .setCommandLine(commandLine)
-            .addInput(sourceFile)
-            .addInputs(swiftHeader.asSet())
-            .addTransitiveInputs(moduleMapInputs)
             .addOutput(objFile)
             .addOutputs(gcnoFile.asSet())
-            .addOutput(intermediateArtifacts.dotdFile(sourceFile))
+            .addOutput(dotdFile.artifact())
             .addTransitiveInputs(objcProvider.get(HEADER))
-            .addInputs(compilationArtifacts.getPrivateHdrs())
-            .addTransitiveInputs(objcProvider.get(STATIC_FRAMEWORK_FILE))
-            .addTransitiveInputs(objcProvider.get(DYNAMIC_FRAMEWORK_FILE))
-            .addInputs(compilationArtifacts.getPchFile().asSet())
             .build(ruleContext));
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/IntermediateArtifacts.java b/src/main/java/com/google/devtools/build/lib/rules/objc/IntermediateArtifacts.java
index 9b8ced2dfd..811e698ff7 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/IntermediateArtifacts.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/IntermediateArtifacts.java
@@ -20,6 +20,7 @@ import com.google.devtools.build.lib.analysis.RuleConfiguredTarget.Mode;
 import com.google.devtools.build.lib.analysis.RuleContext;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.rules.cpp.CppCompileAction.DotdFile;
 import com.google.devtools.build.lib.rules.cpp.CppModuleMap;
 import com.google.devtools.build.lib.util.Preconditions;
 import com.google.devtools.build.lib.vfs.FileSystemUtils;
@@ -397,11 +398,9 @@ public final class IntermediateArtifacts {
     return appendExtension("_runner.sh");
   }
 
-  /**
-   * Dependency file that is generated when compiling the {@code source} artifact.
-   */
-  public Artifact dotdFile(Artifact source) {
-     return inUniqueObjsDir(source, ".d");
+  /** Dependency file that is generated when compiling the {@code source} artifact. */
+  public DotdFile dotdFile(Artifact source) {
+    return new DotdFile(inUniqueObjsDir(source, ".d"));
   }
 
   /**
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcCommandLineOptions.java b/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcCommandLineOptions.java
index 86c0c0734f..3efdc8b4d4 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcCommandLineOptions.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcCommandLineOptions.java
@@ -249,6 +249,16 @@ public class ObjcCommandLineOptions extends FragmentOptions {
   )
   public boolean experimentalObjcLibrary;
   
+  @Option(
+    name = "objc_use_dotd_pruning",
+    defaultValue = "false",
+    category = "flags",
+    help =
+        "If set, .d files emited by clang will be used to prune the set of inputs passed into objc "
+            + "compiles."
+  )
+  public boolean useDotdPruning;
+  
   @VisibleForTesting static final String DEFAULT_MINIMUM_IOS = "7.0";
   @VisibleForTesting static final String DEFAULT_MINIMUM_WATCHOS = "2.0";
   @VisibleForTesting static final String DEFAULT_MINIMUM_TVOS = "9.0";
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcCompileAction.java b/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcCompileAction.java
new file mode 100644
index 0000000000..9a617f66ab
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcCompileAction.java
@@ -0,0 +1,325 @@
+// Copyright 2016 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.devtools.build.lib.rules.objc;
+
+import static com.google.devtools.build.lib.collect.nestedset.Order.STABLE_ORDER;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.devtools.build.lib.actions.ActionExecutionContext;
+import com.google.devtools.build.lib.actions.ActionExecutionException;
+import com.google.devtools.build.lib.actions.ActionOwner;
+import com.google.devtools.build.lib.actions.Artifact;
+import com.google.devtools.build.lib.actions.ArtifactResolver;
+import com.google.devtools.build.lib.actions.Executor;
+import com.google.devtools.build.lib.actions.ResourceSet;
+import com.google.devtools.build.lib.analysis.actions.CommandLine;
+import com.google.devtools.build.lib.analysis.actions.SpawnAction;
+import com.google.devtools.build.lib.collect.nestedset.NestedSet;
+import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadCompatible;
+import com.google.devtools.build.lib.profiler.Profiler;
+import com.google.devtools.build.lib.profiler.ProfilerTask;
+import com.google.devtools.build.lib.rules.apple.AppleConfiguration;
+import com.google.devtools.build.lib.rules.apple.Platform;
+import com.google.devtools.build.lib.rules.cpp.CppCompileAction.DotdFile;
+import com.google.devtools.build.lib.rules.cpp.HeaderDiscovery;
+import com.google.devtools.build.lib.rules.cpp.IncludeScanningContext;
+import com.google.devtools.build.lib.util.DependencySet;
+import com.google.devtools.build.lib.util.Fingerprint;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * An action that compiles objc or objc++ source.
+ *
+ * <p>We don't use a plain SpawnAction here because we implement .d input pruning, which requires
+ * post-execution filtering of input artifacts.
+ *
+ * <p>We don't use a CppCompileAction because the ObjcCompileAction uses custom logic instead of the
+ * CROSSTOOL to construct its command line.
+ */
+public class ObjcCompileAction extends SpawnAction {
+
+  private final DotdFile dotdFile;
+  private final Artifact sourceFile;
+  private final NestedSet<Artifact> mandatoryInputs;
+  private final HeaderDiscovery.DotdPruningMode dotdPruningPlan;
+
+  private static final String GUID = "a00d5bac-a72c-4f0f-99a7-d5fdc6072137";
+
+  private ObjcCompileAction(
+      ActionOwner owner,
+      Iterable<Artifact> tools,
+      Iterable<Artifact> inputs,
+      Iterable<Artifact> outputs,
+      ResourceSet resourceSet,
+      CommandLine argv,
+      ImmutableMap<String, String> environment,
+      ImmutableMap<String, String> executionInfo,
+      String progressMessage,
+      ImmutableMap<PathFragment, Artifact> inputManifests,
+      String mnemonic,
+      boolean executeUnconditionally,
+      ExtraActionInfoSupplier<?> extraActionInfoSupplier,
+      DotdFile dotdFile,
+      Artifact sourceFile,
+      NestedSet<Artifact> mandatoryInputs,
+      HeaderDiscovery.DotdPruningMode dotdPruningPlan) {
+    super(
+        owner,
+        tools,
+        inputs,
+        outputs,
+        resourceSet,
+        argv,
+        environment,
+        ImmutableSet.<String>of(),
+        executionInfo,
+        progressMessage,
+        inputManifests,
+        mnemonic,
+        executeUnconditionally,
+        extraActionInfoSupplier);
+
+    this.dotdFile = dotdFile;
+    this.sourceFile = sourceFile;
+    this.mandatoryInputs = mandatoryInputs;
+    this.dotdPruningPlan = dotdPruningPlan;
+  }
+
+  /** Returns the DotdPruningPlan for this compile */
+  @VisibleForTesting
+  public HeaderDiscovery.DotdPruningMode getDotdPruningPlan() {
+    return dotdPruningPlan;
+  }
+
+  @Override
+  public boolean discoversInputs() {
+    return true;
+  }
+
+  @Override
+  public Iterable<Artifact> discoverInputs(ActionExecutionContext actionExecutionContext) {
+    // We do not use include scanning for objc
+    return null;
+  }
+
+  @Override
+  public void execute(ActionExecutionContext actionExecutionContext)
+      throws ActionExecutionException, InterruptedException {
+    super.execute(actionExecutionContext);
+
+    if (dotdPruningPlan == HeaderDiscovery.DotdPruningMode.USE) {
+      Executor executor = actionExecutionContext.getExecutor();
+      IncludeScanningContext scanningContext = executor.getContext(IncludeScanningContext.class);
+      NestedSet<Artifact> discoveredInputs =
+          discoverInputsFromDotdFiles(
+              executor.getExecRoot(), scanningContext.getArtifactResolver());
+
+      updateActionInputs(discoveredInputs);
+    }
+  }
+
+  @VisibleForTesting
+  public NestedSet<Artifact> discoverInputsFromDotdFiles(
+      Path execRoot, ArtifactResolver artifactResolver) throws ActionExecutionException {
+    if (dotdFile == null) {
+      return NestedSetBuilder.<Artifact>stableOrder().build();
+    }
+    return new HeaderDiscovery.Builder()
+        .setAction(this)
+        .setSourceFile(sourceFile)
+        .setDotdFile(dotdFile)
+        .setDependencySet(processDepset(execRoot))
+        .setPermittedSystemIncludePrefixes(ImmutableList.<Path>of())
+        .setAllowedDerivedinputsMap(getAllowedDerivedInputsMap())
+        .build()
+        .discoverInputsFromDotdFiles(execRoot, artifactResolver);
+  }
+
+  private DependencySet processDepset(Path execRoot) throws ActionExecutionException {
+    try {
+      DependencySet depSet = new DependencySet(execRoot);
+      return depSet.read(dotdFile.getPath());
+    } catch (IOException e) {
+      // Some kind of IO or parse exception--wrap & rethrow it to stop the build.
+      throw new ActionExecutionException("error while parsing .d file", e, this, false);
+    }
+  }
+
+  /** Utility function that adds artifacts to an input map, but only if they are sources. */
+  private void addToMapIfSource(Map<PathFragment, Artifact> map, Iterable<Artifact> artifacts) {
+    for (Artifact artifact : artifacts) {
+      if (!artifact.isSourceArtifact()) {
+        map.put(artifact.getExecPath(), artifact);
+      }
+    }
+  }
+
+  private Map<PathFragment, Artifact> getAllowedDerivedInputsMap() {
+    Map<PathFragment, Artifact> allowedDerivedInputMap = new HashMap<>();
+    addToMapIfSource(allowedDerivedInputMap, getInputs());
+    allowedDerivedInputMap.put(sourceFile.getExecPath(), sourceFile);
+    return allowedDerivedInputMap;
+  }
+
+  /**
+   * Recalculates this action's live input collection, including sources, middlemen.
+   *
+   * @throws ActionExecutionException iff any errors happen during update.
+   */
+  @VisibleForTesting
+  @ThreadCompatible
+  public final synchronized void updateActionInputs(NestedSet<Artifact> discoveredInputs)
+      throws ActionExecutionException {
+    NestedSetBuilder<Artifact> inputs = NestedSetBuilder.stableOrder();
+    Profiler.instance().startTask(ProfilerTask.ACTION_UPDATE, this);
+    try {
+      inputs.addTransitive(mandatoryInputs);
+      inputs.addTransitive(discoveredInputs);
+    } finally {
+      Profiler.instance().completeTask(ProfilerTask.ACTION_UPDATE);
+      setInputs(inputs.build());
+    }
+  }
+
+  @Override
+  public String computeKey() {
+    Fingerprint f = new Fingerprint();
+    f.addString(GUID);
+    f.addString(super.computeKey());
+    f.addBoolean(dotdFile.artifact() == null);
+    f.addBoolean(dotdPruningPlan == HeaderDiscovery.DotdPruningMode.USE);
+    f.addPath(dotdFile.getSafeExecPath());
+    return f.hexDigestAndReset();
+  }
+
+  /** A Builder for ObjcCompileAction */
+  public static class Builder extends SpawnAction.Builder {
+
+    private DotdFile dotdFile;
+    private Artifact sourceFile;
+    private final NestedSetBuilder<Artifact> mandatoryInputs = new NestedSetBuilder<>(STABLE_ORDER);
+    private HeaderDiscovery.DotdPruningMode dotdPruningPlan;
+
+    /**
+     * Creates a new compile action builder with apple environment variables set that are typically
+     * needed by the apple toolchain.
+     */
+    public static ObjcCompileAction.Builder createObjcCompileActionBuilderWithAppleEnv(
+        AppleConfiguration appleConfiguration, Platform targetPlatform) {
+      return (Builder)
+          new ObjcCompileAction.Builder()
+              .setExecutionInfo(ObjcRuleClasses.darwinActionExecutionRequirement())
+              .setEnvironment(
+                  ObjcRuleClasses.appleToolchainEnvironment(appleConfiguration, targetPlatform));
+    }
+
+    @Override
+    public Builder addTools(Iterable<Artifact> artifacts) {
+      super.addTools(artifacts);
+      mandatoryInputs.addAll(artifacts);
+      return this;
+    }
+
+    /** Sets a .d file that will used to prune input headers */
+    public Builder setDotdFile(DotdFile dotdFile) {
+      Preconditions.checkNotNull(dotdFile);
+      this.dotdFile = dotdFile;
+      return this;
+    }
+
+    /** Sets the source file that is being compiled in this action */
+    public Builder setSourceFile(Artifact sourceFile) {
+      Preconditions.checkNotNull(sourceFile);
+      this.sourceFile = sourceFile;
+      this.mandatoryInputs.add(sourceFile);
+      this.addInput(sourceFile);
+      return this;
+    }
+
+    /** Add an input that cannot be pruned */
+    public Builder addMandatoryInput(Artifact input) {
+      Preconditions.checkNotNull(input);
+      this.mandatoryInputs.add(input);
+      this.addInput(input);
+      return this;
+    }
+
+    /** Add inputs that cannot be pruned */
+    public Builder addMandatoryInputs(Iterable<Artifact> input) {
+      Preconditions.checkNotNull(input);
+      this.mandatoryInputs.addAll(input);
+      this.addInputs(input);
+      return this;
+    }
+
+    /** Add inputs that cannot be pruned */
+    public Builder addTransitiveMandatoryInputs(NestedSet<Artifact> input) {
+      Preconditions.checkNotNull(input);
+      this.mandatoryInputs.addTransitive(input);
+      this.addTransitiveInputs(input);
+      return this;
+    }
+
+    /** Indicates that this compile action should perform .d pruning */
+    public Builder setDotdPruningPlan(HeaderDiscovery.DotdPruningMode dotdPruningPlan) {
+      Preconditions.checkNotNull(dotdPruningPlan);
+      this.dotdPruningPlan = dotdPruningPlan;
+      return this;
+    }
+
+    @Override
+    protected SpawnAction createSpawnAction(
+        ActionOwner owner,
+        NestedSet<Artifact> tools,
+        NestedSet<Artifact> inputsAndTools,
+        ImmutableList<Artifact> outputs,
+        ResourceSet resourceSet,
+        CommandLine actualCommandLine,
+        ImmutableMap<String, String> env,
+        ImmutableSet<String> clientEnvironmentVariables,
+        ImmutableMap<String, String> executionInfo,
+        String progressMessage,
+        ImmutableMap<PathFragment, Artifact> inputAndToolManifests,
+        String mnemonic) {
+      return new ObjcCompileAction(
+          owner,
+          tools,
+          inputsAndTools,
+          outputs,
+          resourceSet,
+          actualCommandLine,
+          env,
+          executionInfo,
+          progressMessage,
+          inputAndToolManifests,
+          mnemonic,
+          executeUnconditionally,
+          extraActionInfoSupplier,
+          dotdFile,
+          sourceFile,
+          mandatoryInputs.build(),
+          dotdPruningPlan);
+    }
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcConfiguration.java b/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcConfiguration.java
index 734f5466f3..ebe35c5212 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcConfiguration.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/ObjcConfiguration.java
@@ -23,12 +23,12 @@ import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
 import com.google.devtools.build.lib.rules.apple.DottedVersion;
 import com.google.devtools.build.lib.rules.apple.Platform.PlatformType;
+import com.google.devtools.build.lib.rules.cpp.HeaderDiscovery;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkCallable;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkModule;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkModuleCategory;
 import com.google.devtools.build.lib.util.Preconditions;
 import com.google.devtools.build.lib.vfs.Path;
-
 import javax.annotation.Nullable;
 
 /** A compiler configuration containing flags required for Objective-C compilation. */
@@ -79,6 +79,7 @@ public class ObjcConfiguration extends BuildConfiguration.Fragment {
   @Nullable private final Label extraEntitlements;
   private final boolean deviceDebugEntitlements;
   private final boolean experimentalObjcLibrary;
+  private final HeaderDiscovery.DotdPruningMode dotdPruningPlan;
 
   ObjcConfiguration(ObjcCommandLineOptions objcOptions, BuildConfiguration.Options options,
       @Nullable BlazeDirectories directories) {
@@ -115,6 +116,10 @@ public class ObjcConfiguration extends BuildConfiguration.Fragment {
     this.extraEntitlements = objcOptions.extraEntitlements;
     this.deviceDebugEntitlements = objcOptions.deviceDebugEntitlements;
     this.experimentalObjcLibrary = objcOptions.experimentalObjcLibrary;
+    this.dotdPruningPlan =
+        objcOptions.useDotdPruning
+            ? HeaderDiscovery.DotdPruningMode.USE
+            : HeaderDiscovery.DotdPruningMode.DO_NOT_USE;
   }
 
   /**
@@ -364,4 +369,9 @@ public class ObjcConfiguration extends BuildConfiguration.Fragment {
   public boolean useExperimentalObjcLibrary() {
     return experimentalObjcLibrary;
   }
+  
+  /** Returns the DotdPruningPlan for compiles in this build. */
+  public HeaderDiscovery.DotdPruningMode getDotdPruningPlan() {
+    return dotdPruningPlan;
+  }
 }