Move CppConfiguration's treatment of pic, --start-lib/--end-lib, and fission to

CppHelper.  In CppHelper, CcToolchainProvider and CppConfiguration are used
sepereately, allowing toolchain information to be removed from
CppConfiguration.

This is necessary to introduce hermetic toolchains, which require that
toolchain information be seperated from the configuration, into the c++ rules.

PiperOrigin-RevId: 176694160

11 files changed, 169 insertions, 113 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcBinary.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcBinary.java
index 642c05c752..d31815208a 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcBinary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcBinary.java
@@ -154,7 +154,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
       builder.addSymlinksToArtifacts(cppCompilationContext.getAdditionalInputs());
       builder.addSymlinksToArtifacts(
           cppCompilationContext.getTransitiveModules(
-              CppHelper.usePic(context, !isLinkShared(context))));
+              CppHelper.usePic(context, toolchain, !isLinkShared(context))));
     }
     return builder.build();
   }
@@ -327,7 +327,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
 
         // If we are using a toolchain supporting interface library and targeting Windows, we build
         // the interface library with the link action and add it to `interface_output` output group.
-        if (cppConfiguration.useInterfaceSharedObjects()) {
+        if (CppHelper.useInterfaceSharedObjects(cppConfiguration, ccToolchain)) {
           interfaceLibrary = ruleContext.getRelatedArtifact(binary.getRootRelativePath(), ".ifso");
           linkActionBuilder.setInterfaceOutput(interfaceLibrary);
           linkActionBuilder.addActionOutput(interfaceLibrary);
@@ -338,7 +338,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
     // Store immutable context for use in other *_binary rules that are implemented by
     // linking the interpreter (Java, Python, etc.) together with native deps.
     CppLinkAction.Context linkContext = new CppLinkAction.Context(linkActionBuilder);
-    boolean usePic = CppHelper.usePic(ruleContext, !isLinkShared(ruleContext));
+    boolean usePic = CppHelper.usePic(ruleContext, ccToolchain, !isLinkShared(ruleContext));
 
     if (linkActionBuilder.hasLtoBitcodeInputs()
         && featureConfiguration.isEnabled(CppRuleClasses.THIN_LTO)) {
@@ -393,7 +393,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
             ruleContext,
             ccCompilationOutputs,
             linkStaticness,
-            cppConfiguration.useFission(),
+            CppHelper.useFission(cppConfiguration, ccToolchain),
             usePic,
             ltoBackendArtifacts);
     Artifact dwpFile =
@@ -402,14 +402,15 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
 
     // The debug package should include the dwp file only if it was explicitly requested.
     Artifact explicitDwpFile = dwpFile;
-    if (!cppConfiguration.useFission()) {
+    if (!CppHelper.useFission(cppConfiguration, ccToolchain)) {
       explicitDwpFile = null;
     } else {
       // For cc_test rules, include the dwp in the runfiles if Fission is enabled and the test was
       // built statically.
       if (TargetUtils.isTestRule(ruleContext.getRule())
           && linkStaticness != LinkStaticness.DYNAMIC
-          && cppConfiguration.shouldBuildTestDwp()) {
+          && CppHelper.useFission(cppConfiguration, ccToolchain)
+          && cppConfiguration.buildTestDwpIsActivated()) {
         filesToBuild = NestedSetBuilder.fromNestedSet(filesToBuild).add(dwpFile).build();
       }
     }
@@ -455,6 +456,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
     RuleConfiguredTargetBuilder ruleBuilder = new RuleConfiguredTargetBuilder(ruleContext);
     addTransitiveInfoProviders(
         ruleContext,
+        ccToolchain,
         cppConfiguration,
         common,
         ruleBuilder,
@@ -549,7 +551,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
         builder.addLibrary(library);
       }
     } else {
-      boolean usePic = CppHelper.usePic(context, !isLinkShared(context));
+      boolean usePic = CppHelper.usePic(context, toolchain, !isLinkShared(context));
       Iterable<Artifact> objectFiles = info.getCcCompilationOutputs().getObjectFiles(usePic);
 
       if (fake) {
@@ -644,8 +646,13 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
 
   @VisibleForTesting
   public static Iterable<Artifact> getDwpInputs(
-      RuleContext context, NestedSet<Artifact> picDwoArtifacts, NestedSet<Artifact> dwoArtifacts) {
-    return CppHelper.usePic(context, !isLinkShared(context)) ? picDwoArtifacts : dwoArtifacts;
+      RuleContext context,
+      CcToolchainProvider toolchain,
+      NestedSet<Artifact> picDwoArtifacts,
+      NestedSet<Artifact> dwoArtifacts) {
+    return CppHelper.usePic(context, toolchain, !isLinkShared(context))
+        ? picDwoArtifacts
+        : dwoArtifacts;
   }
 
   /**
@@ -656,9 +663,12 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
       CcToolchainProvider toolchain,
       Artifact dwpOutput,
       DwoArtifactsCollector dwoArtifactsCollector) {
-    Iterable<Artifact> allInputs = getDwpInputs(context,
-        dwoArtifactsCollector.getPicDwoArtifacts(),
-        dwoArtifactsCollector.getDwoArtifacts());
+    Iterable<Artifact> allInputs =
+        getDwpInputs(
+            context,
+            toolchain,
+            dwoArtifactsCollector.getPicDwoArtifacts(),
+            dwoArtifactsCollector.getDwoArtifacts());
 
     // No inputs? Just generate a trivially empty .dwp.
     //
@@ -823,6 +833,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
 
   private static void addTransitiveInfoProviders(
       RuleContext ruleContext,
+      CcToolchainProvider toolchain,
       CppConfiguration cppConfiguration,
       CcCommon common,
       RuleConfiguredTargetBuilder builder,
@@ -845,7 +856,7 @@ public abstract class CcBinary implements RuleConfiguredTargetFactory {
         ccCompilationOutputs.getFilesToCompile(
             cppConfiguration.isLipoContextCollector(),
             cppConfiguration.processHeadersInDependencies(),
-            CppHelper.usePic(ruleContext, false));
+            CppHelper.usePic(ruleContext, toolchain, false));
     builder
         .setFilesToBuild(filesToBuild)
         .addProvider(CppCompilationContext.class, cppCompilationContext)
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java
index 8fec3dce88..71a79df679 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibrary.java
@@ -188,7 +188,7 @@ public abstract class CcLibrary implements RuleConfiguredTargetFactory {
       dynamicLibraries.add(
         CppHelper.getLinuxLinkedArtifact(
           ruleContext, ruleContext.getConfiguration(), LinkTargetType.DYNAMIC_LIBRARY));
-      if (ccToolchain.getCppConfiguration().useInterfaceSharedObjects()) {
+      if (CppHelper.useInterfaceSharedObjects(ccToolchain.getCppConfiguration(), ccToolchain)) {
         dynamicLibraries.add(
           CppHelper.getLinuxLinkedArtifact(
             ruleContext, ruleContext.getConfiguration(), LinkTargetType.INTERFACE_DYNAMIC_LIBRARY));
@@ -206,7 +206,7 @@ public abstract class CcLibrary implements RuleConfiguredTargetFactory {
       dynamicLibraries.add(
         CppHelper.getLinuxLinkedArtifact(
           ruleContext, ruleContext.getConfiguration(), LinkTargetType.DYNAMIC_LIBRARY));
-      if (ccToolchain.getCppConfiguration().useInterfaceSharedObjects()) {
+      if (CppHelper.useInterfaceSharedObjects(ccToolchain.getCppConfiguration(), ccToolchain)) {
         dynamicLibraries.add(
           CppHelper.getLinuxLinkedArtifact(
             ruleContext, ruleContext.getConfiguration(), LinkTargetType.INTERFACE_DYNAMIC_LIBRARY));
@@ -305,7 +305,8 @@ public abstract class CcLibrary implements RuleConfiguredTargetFactory {
             CppRunfilesProvider.class, new CppRunfilesProvider(staticRunfiles, sharedRunfiles))
         .addOutputGroup(
             OutputGroupProvider.HIDDEN_TOP_LEVEL,
-            collectHiddenTopLevelArtifacts(ruleContext, info.getCcCompilationOutputs()))
+            collectHiddenTopLevelArtifacts(
+                ruleContext, ccToolchain, info.getCcCompilationOutputs()))
         .addOutputGroup(
             CcLibraryHelper.HIDDEN_HEADER_TOKENS,
             CcLibraryHelper.collectHeaderTokens(ruleContext, info.getCcCompilationOutputs()));
@@ -313,13 +314,14 @@ public abstract class CcLibrary implements RuleConfiguredTargetFactory {
 
   private static NestedSet<Artifact> collectHiddenTopLevelArtifacts(
       RuleContext ruleContext,
+      CcToolchainProvider toolchain,
       CcCompilationOutputs ccCompilationOutputs) {
     // Ensure that we build all the dependencies, otherwise users may get confused.
     NestedSetBuilder<Artifact> artifactsToForceBuilder = NestedSetBuilder.stableOrder();
     CppConfiguration cppConfiguration = ruleContext.getFragment(CppConfiguration.class);
     boolean isLipoCollector = cppConfiguration.isLipoContextCollector();
     boolean processHeadersInDependencies = cppConfiguration.processHeadersInDependencies();
-    boolean usePic = CppHelper.usePic(ruleContext, false);
+    boolean usePic = CppHelper.usePic(ruleContext, toolchain, false);
     artifactsToForceBuilder.addTransitive(
         ccCompilationOutputs.getFilesToCompile(
             isLipoCollector, processHeadersInDependencies, usePic));
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibraryHelper.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibraryHelper.java
index 746d58ba11..ee2d8bc680 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibraryHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLibraryHelper.java
@@ -1066,7 +1066,7 @@ public final class CcLibraryHelper {
     if (emitCompileProviders) {
       boolean isLipoCollector = cppConfiguration.isLipoContextCollector();
       boolean processHeadersInDependencies = cppConfiguration.processHeadersInDependencies();
-      boolean usePic = CppHelper.usePic(ruleContext, false);
+      boolean usePic = CppHelper.usePic(ruleContext, ccToolchain, false);
       outputGroups.put(
           OutputGroupProvider.FILES_TO_COMPILE,
           ccOutputs.getFilesToCompile(isLipoCollector, processHeadersInDependencies, usePic));
@@ -1148,7 +1148,7 @@ public final class CcLibraryHelper {
               Link.LinkTargetType.DYNAMIC_LIBRARY,
               linkedArtifactNameSuffix));
 
-      if (ccToolchain.getCppConfiguration().useInterfaceSharedObjects()
+      if (CppHelper.useInterfaceSharedObjects(ccToolchain.getCppConfiguration(), ccToolchain)
           && emitInterfaceSharedObjects) {
         dynamicLibrary.add(
             CppHelper.getLinuxLinkedArtifact(
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java
index 521fcf634f..f85acefc70 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java
@@ -522,7 +522,7 @@ public class CcToolchain implements RuleConfiguredTargetFactory {
             getBuildVariables(ruleContext, toolchainInfo.getDefaultSysroot()),
             getBuiltinIncludes(ruleContext),
             coverageEnvironment.build(),
-            cppConfiguration.supportsInterfaceSharedObjects()
+            toolchainInfo.supportsInterfaceSharedObjects()
                 ? ruleContext.getPrerequisiteArtifact("$link_dynamic_library_tool", Mode.HOST)
                 : null,
             ruleContext.attributes().has("$def_parser")
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProvider.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProvider.java
index adec4f5ee2..36f9e4a4df 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProvider.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProvider.java
@@ -445,6 +445,20 @@ public final class CcToolchainProvider extends ToolchainInfo {
     return toolchainInfo.supportsEmbeddedRuntimes();
   }
 
+  /** Returns whether the toolchain supports the --start-lib/--end-lib options. */
+  public boolean supportsStartEndLib() {
+    return toolchainInfo.supportsStartEndLib();
+  }
+
+  /**
+   * Returns whether this toolchain supports interface shared objects.
+   *
+   * <p>Should be true if this toolchain generates ELF objects.
+   */
+  public boolean supportsInterfaceSharedObjects() {
+    return toolchainInfo.supportsInterfaceSharedObjects();
+  }
+
   @Nullable
   public CppConfiguration getCppConfiguration() {
     return cppConfiguration;
@@ -586,6 +600,14 @@ public final class CcToolchainProvider extends ToolchainInfo {
     return toolchainInfo.getAdditionalMakeVariables();
   }
 
+  /**
+   * Returns whether the toolchain supports "Fission" C++ builds, i.e. builds where compilation
+   * partitions object code and debug symbols into separate output files.
+   */
+  public boolean supportsFission() {
+    return toolchainInfo.supportsFission();
+  }
+
   @SkylarkCallable(
     name = "unfiltered_compiler_options_do_not_use",
     doc =
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
index 30dbdd976f..7341b84a88 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
@@ -222,8 +222,6 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
   private final boolean convertLipoToThinLto;
   private final PathFragment crosstoolTopPathFragment;
 
-  private final boolean usePicForBinaries;
-
   private final Path fdoZip;
 
   // TODO(bazel-team): All these labels (except for ccCompilerRuleLabel) can be removed once the
@@ -292,9 +290,6 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
             || (cppOptions.stripBinaries == StripMode.SOMETIMES
                 && compilationMode == CompilationMode.FASTBUILD));
 
-    this.usePicForBinaries =
-        cppToolchainInfo.toolchainNeedsPic() && compilationMode != CompilationMode.OPT;
-
     ListMultimap<CompilationMode, String> cFlags = ArrayListMultimap.create();
     ListMultimap<CompilationMode, String> cxxFlags = ArrayListMultimap.create();
     for (CrosstoolConfig.CompilationModeFlags flags : toolchain.getCompilationModeFlagsList()) {
@@ -535,44 +530,17 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
   }
 
   /**
-   * Returns whether the toolchain supports the --start-lib/--end-lib options.
-   */
-  public boolean supportsStartEndLib() {
-    return cppToolchainInfo.supportsStartEndLib();
-  }
-
-  /**
-   * Returns whether this toolchain supports interface shared objects.
+   * Returns whether the toolchain supports "Fission" C++ builds, i.e. builds where compilation
+   * partitions object code and debug symbols into separate output files.
    *
-   * <p>Should be true if this toolchain generates ELF objects.
-   */
-  public boolean supportsInterfaceSharedObjects() {
-    return cppToolchainInfo.supportsInterfaceSharedObjects();
-  }
-
-  /**
-   * Returns whether the toolchain supports "Fission" C++ builds, i.e. builds
-   * where compilation partitions object code and debug symbols into separate
-   * output files.
+   * <p>Deprecated: Use {@link CcToolchainProvider#supportsFission()}
    */
+  // TODO(b/64384912): Refactor out of reportInvalidOptions() and remove
+  @Deprecated
   public boolean supportsFission() {
     return cppToolchainInfo.supportsFission();
   }
 
-  /**
-   * Returns whether binaries must be compiled with position independent code.
-   */
-  public boolean usePicForBinaries() {
-    return usePicForBinaries;
-  }
-
-  /**
-   * Returns the type of archives being used.
-   */
-  public Link.ArchiveType archiveType() {
-    return useStartEndLib() ? Link.ArchiveType.START_END_LIB : Link.ArchiveType.REGULAR;
-  }
-
   @SkylarkCallable(
     name = "built_in_include_directories",
     structField = true,
@@ -1039,19 +1007,25 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
     return cppOptions.processHeadersInDependencies;
   }
 
+  /** Returns true if --fission contains the current compilation mode. */
+  public boolean fissionIsActiveForCurrentCompilationMode() {
+    return cppOptions.fissionModes.contains(compilationMode);
+  }
+
   /**
    * Returns true if Fission is specified for this build and supported by the crosstool.
+   *
+   * <p>Deprecated: Use {@link CppHelper#useFission(CppConfiguration, CcToolchainProvider)}
    */
+  // TODO(b/64384912): Remove usage in java_binary and configurationEnabledFeatures()
+  @Deprecated
   public boolean useFission() {
     return cppOptions.fissionModes.contains(compilationMode) && supportsFission();
   }
 
-  /**
-   * Returns true if Fission is enabled for this build and the user requested automatic building
-   * of .dwp files for C++ test targets.
-   */
-  public boolean shouldBuildTestDwp() {
-    return useFission() && cppOptions.buildTestDwp;
+  /** Returns true if --build_test_dwp is set on this build. */
+  public boolean buildTestDwpIsActivated() {
+    return cppOptions.buildTestDwp;
   }
 
   /**
@@ -1064,36 +1038,15 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
     return cppOptions.forcePic;
   }
 
-  public boolean useStartEndLib() {
-    return cppOptions.useStartEndLib && supportsStartEndLib();
-  }
-
-  /**
-   * Returns true if interface shared objects should be used.
-   */
-  public boolean useInterfaceSharedObjects() {
-    return supportsInterfaceSharedObjects() && cppOptions.useInterfaceSharedObjects;
+  /** Returns true if --start_end_lib is set on this build. */
+  public boolean startEndLibIsRequested() {
+    return cppOptions.useStartEndLib;
   }
 
   public boolean forceIgnoreDashStatic() {
     return cppOptions.forceIgnoreDashStatic;
   }
 
-  /**
-   * Returns true if shared libraries must be compiled with position independent code
-   * on this platform or in this configuration.
-   */
-  public boolean needsPic() {
-    return forcePic() || cppToolchainInfo.toolchainNeedsPic();
-  }
-
-  /**
-   * Returns true iff we should use ".pic.o" files when linking executables.
-   */
-  public boolean usePicObjectsForBinaries() {
-    return forcePic() || usePicForBinaries();
-  }
-
   public boolean legacyWholeArchive() {
     return cppOptions.legacyWholeArchive;
   }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppHelper.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppHelper.java
index c673b87ea0..507e2d81f5 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppHelper.java
@@ -41,6 +41,7 @@ import com.google.devtools.build.lib.analysis.actions.ParameterFileWriteAction;
 import com.google.devtools.build.lib.analysis.actions.SpawnAction;
 import com.google.devtools.build.lib.analysis.actions.SymlinkAction;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
+import com.google.devtools.build.lib.analysis.config.CompilationMode;
 import com.google.devtools.build.lib.analysis.configuredtargets.RuleConfiguredTarget.Mode;
 import com.google.devtools.build.lib.analysis.platform.ToolchainInfo;
 import com.google.devtools.build.lib.cmdline.Label;
@@ -557,22 +558,42 @@ public class CppHelper {
   // TODO(bazel-team): figure out a way to merge these 2 methods. See the Todo in
   // CcCommonConfiguredTarget.noCoptsMatches().
   /**
-   * Determines if we should apply -fPIC for this rule's C++ compilations. This determination
-   * is generally made by the global C++ configuration settings "needsPic" and
-   * and "usePicForBinaries". However, an individual rule may override these settings by applying
-   * -fPIC" to its "nocopts" attribute. This allows incompatible rules to "opt out" of global PIC
-   * settings (see bug: "Provide a way to turn off -fPIC for targets that can't be built that way").
+   * Determines if we should apply -fPIC for this rule's C++ compilations. This determination is
+   * generally made by the global C++ configuration settings "needsPic" and "usePicForBinaries".
+   * However, an individual rule may override these settings by applying -fPIC" to its "nocopts"
+   * attribute. This allows incompatible rules to "opt out" of global PIC settings (see bug:
+   * "Provide a way to turn off -fPIC for targets that can't be built that way").
    *
    * @param ruleContext the context of the rule to check
    * @param forBinary true if compiling for a binary, false if for a shared library
    * @return true if this rule's compilations should apply -fPIC, false otherwise
    */
-  public static boolean usePic(RuleContext ruleContext, boolean forBinary) {
+  public static boolean usePic(
+      RuleContext ruleContext, CcToolchainProvider toolchain, boolean forBinary) {
     if (CcCommon.noCoptsMatches("-fPIC", ruleContext)) {
       return false;
     }
     CppConfiguration config = ruleContext.getFragment(CppConfiguration.class);
-    return forBinary ? config.usePicObjectsForBinaries() : config.needsPic();
+    return forBinary ? usePicObjectsForBinaries(config, toolchain) : needsPic(config, toolchain);
+  }
+
+  /** Returns whether binaries must be compiled with position independent code. */
+  public static boolean usePicForBinaries(CppConfiguration config, CcToolchainProvider toolchain) {
+    return toolchain.toolchainNeedsPic() && config.getCompilationMode() != CompilationMode.OPT;
+  }
+
+  /** Returns true iff we should use ".pic.o" files when linking executables. */
+  public static boolean usePicObjectsForBinaries(
+      CppConfiguration config, CcToolchainProvider toolchain) {
+    return config.forcePic() || usePicForBinaries(config, toolchain);
+  }
+
+  /**
+   * Returns true if shared libraries must be compiled with position independent code for the build
+   * implied by the given config and toolchain.
+   */
+  public static boolean needsPic(CppConfiguration config, CcToolchainProvider toolchain) {
+    return config.forcePic() || toolchain.toolchainNeedsPic();
   }
 
   /**
@@ -885,4 +906,39 @@ public class CppHelper {
             .build(ruleContext));
     return defFile;
   }
+
+  /**
+   * Returns true if the build implied by the given config and toolchain uses --start-lib/--end-lib
+   * ld options.
+   */
+  public static boolean useStartEndLib(CppConfiguration config, CcToolchainProvider toolchain) {
+    return config.startEndLibIsRequested() && toolchain.supportsStartEndLib();
+  }
+
+  /**
+   * Returns the type of archives being used by the build implied by the given config and toolchain.
+   */
+  public static Link.ArchiveType getArchiveType(
+      CppConfiguration config, CcToolchainProvider toolchain) {
+    return useStartEndLib(config, toolchain)
+        ? Link.ArchiveType.START_END_LIB
+        : Link.ArchiveType.REGULAR;
+  }
+
+  /**
+   * Returns true if interface shared objects should be used in the build implied by the given
+   * config and toolchain.
+   */
+  public static boolean useInterfaceSharedObjects(
+      CppConfiguration config, CcToolchainProvider toolchain) {
+    return toolchain.supportsInterfaceSharedObjects() && config.getUseInterfaceSharedObjects();
+  }
+
+  /**
+   * Returns true if Fission is specified and supported by the CROSSTOOL for the build implied by
+   * the given configuration and toolchain.
+   */
+  public static boolean useFission(CppConfiguration config, CcToolchainProvider toolchain) {
+    return config.fissionIsActiveForCurrentCompilationMode() && toolchain.supportsFission();
+  }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java
index 104530284b..ec49bb2a09 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java
@@ -564,7 +564,7 @@ public class CppLinkActionBuilder {
               toolchain,
               fdoSupport,
               usePicForLtoBackendActions,
-              cppConfiguration.useFission(),
+              CppHelper.useFission(cppConfiguration, toolchain),
               argv);
       ltoOutputs.add(ltoArtifacts);
     }
@@ -651,7 +651,9 @@ public class CppLinkActionBuilder {
             .add(
                 ImmutableIterable.from(
                     Link.mergeInputsCmdLine(
-                        uniqueLibraries, needWholeArchive, cppConfiguration.archiveType())))
+                        uniqueLibraries,
+                        needWholeArchive,
+                        CppHelper.getArchiveType(cppConfiguration, toolchain))))
             .build();
 
     // ruleContext can only be null during testing. This is kind of ugly.
@@ -849,7 +851,9 @@ public class CppLinkActionBuilder {
     Iterable<Artifact> expandedInputs =
         LinkerInputs.toLibraryArtifacts(
             Link.mergeInputsDependencies(
-                uniqueLibraries, needWholeArchive, cppConfiguration.archiveType()));
+                uniqueLibraries,
+                needWholeArchive,
+                CppHelper.getArchiveType(cppConfiguration, toolchain)));
     Iterable<Artifact> expandedNonLibraryInputs = LinkerInputs.toLibraryArtifacts(objectFileInputs);
 
     if (!isLtoIndexing && allLtoArtifacts != null) {
@@ -934,7 +938,7 @@ public class CppLinkActionBuilder {
 
   private boolean shouldUseLinkDynamicLibraryTool() {
     return linkType.equals(LinkTargetType.DYNAMIC_LIBRARY)
-        && cppConfiguration.supportsInterfaceSharedObjects()
+        && toolchain.supportsInterfaceSharedObjects()
         && !featureConfiguration.hasConfiguredLinkerPathInActionConfig();
   }
 
@@ -1460,7 +1464,8 @@ public class CppLinkActionBuilder {
         buildVariables.addStringVariable(STRIP_DEBUG_SYMBOLS_VARIABLE, "");
       }
 
-      if (getLinkType().staticness().equals(Staticness.DYNAMIC) && cppConfiguration.useFission()) {
+      if (getLinkType().staticness().equals(Staticness.DYNAMIC)
+          && CppHelper.useFission(cppConfiguration, toolchain)) {
         buildVariables.addStringVariable(IS_USING_FISSION_VARIABLE, "");
       }
 
@@ -1687,7 +1692,7 @@ public class CppLinkActionBuilder {
       // As a bonus, we can rephrase --nostart_end_lib as --features=-start_end_lib and get rid
       // of a command line option.
 
-      Preconditions.checkState(cppConfiguration.useStartEndLib());
+      Preconditions.checkState(CppHelper.useStartEndLib(cppConfiguration, toolchain));
       Map<Artifact, Artifact> ltoMap = new HashMap<>();
       for (LtoBackendArtifacts l : allLtoArtifacts) {
         ltoMap.put(l.getBitcodeFile(), l.getObjectFile());
@@ -1776,7 +1781,8 @@ public class CppLinkActionBuilder {
         PathFragment solibDir,
         String rpathRoot) {
       Preconditions.checkState(input.getArtifactCategory() == ArtifactCategory.DYNAMIC_LIBRARY);
-      Preconditions.checkState(!Link.useStartEndLib(input, cppConfiguration.archiveType()));
+      Preconditions.checkState(
+          !Link.useStartEndLib(input, CppHelper.getArchiveType(cppConfiguration, toolchain)));
 
       Artifact inputArtifact = input.getArtifact();
       PathFragment libDir = inputArtifact.getExecPath().getParentDirectory();
@@ -1841,7 +1847,7 @@ public class CppLinkActionBuilder {
       Preconditions.checkState(ltoMap == null || thinltoParamFile != null);
 
       // start-lib/end-lib library: adds its input object files.
-      if (Link.useStartEndLib(input, cppConfiguration.archiveType())) {
+      if (Link.useStartEndLib(input, CppHelper.getArchiveType(cppConfiguration, toolchain))) {
         Iterable<Artifact> archiveMembers = input.getObjectFiles();
         if (!Iterables.isEmpty(archiveMembers)) {
           ImmutableList.Builder<String> nonLtoArchiveMembersBuilder = ImmutableList.builder();
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 ade706c70f..a28de87f26 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
@@ -443,7 +443,7 @@ public final class CppModel {
    * @return whether this target needs to generate pic actions.
    */
   private boolean getGeneratePicActions() {
-    return CppHelper.usePic(ruleContext, false);
+    return CppHelper.usePic(ruleContext, ccToolchain, false);
   }
 
   /**
@@ -451,8 +451,9 @@ public final class CppModel {
    */
   private boolean getGenerateNoPicActions() {
     return
-        // If we always need pic for everything, then don't bother to create a no-pic action.
-        (!CppHelper.usePic(ruleContext, true) || !CppHelper.usePic(ruleContext, false))
+    // If we always need pic for everything, then don't bother to create a no-pic action.
+    (!CppHelper.usePic(ruleContext, ccToolchain, true)
+            || !CppHelper.usePic(ruleContext, ccToolchain, false))
         // onlySingleOutput guarantees that the code is only ever linked into a dynamic library - so
         // we don't need a no-pic action even if linking into a binary would require it.
         && !((onlySingleOutput && getGeneratePicActions()));
@@ -743,7 +744,8 @@ public final class CppModel {
                 // The source action does not generate dwo when it has bitcode
                 // output (since it isn't generating a native object with debug
                 // info). In that case the LtoBackendAction will generate the dwo.
-                /* generateDwo= */ cppConfiguration.useFission() && !bitcodeOutput,
+                /* generateDwo= */ CppHelper.useFission(cppConfiguration, ccToolchain)
+                    && !bitcodeOutput,
                 isGenerateDotdFile(sourceArtifact),
                 source.getBuildVariables());
             break;
@@ -844,7 +846,7 @@ public final class CppModel {
             ? CppHelper.getCompileOutputArtifact(ruleContext, gcnoFileName, configuration)
             : null;
 
-    boolean generateDwo = cppConfiguration.useFission();
+    boolean generateDwo = CppHelper.useFission(cppConfiguration, ccToolchain);
     Artifact dwoFile = generateDwo ? getDwoFile(builder.getOutputFile()) : null;
     // TODO(tejohnson): Add support for ThinLTO if needed.
     boolean bitcodeOutput =
@@ -1320,8 +1322,9 @@ public final class CppModel {
     }
 
     AnalysisEnvironment env = ruleContext.getAnalysisEnvironment();
-    boolean usePicForBinaries = CppHelper.usePic(ruleContext, /* forBinary= */ true);
-    boolean usePicForSharedLibs = CppHelper.usePic(ruleContext, /* forBinary= */ false);
+    boolean usePicForBinaries = CppHelper.usePic(ruleContext, ccToolchain, /* forBinary= */ true);
+    boolean usePicForSharedLibs =
+        CppHelper.usePic(ruleContext, ccToolchain, /* forBinary= */ false);
 
     // Create static library (.a). The linkType only reflects whether the library is alwayslink or
     // not. The PIC-ness is determined by whether we need to use PIC or not. There are three cases
@@ -1411,7 +1414,8 @@ public final class CppModel {
 
     List<String> sonameLinkopts = ImmutableList.of();
     Artifact soInterface = null;
-    if (cppConfiguration.useInterfaceSharedObjects() && allowInterfaceSharedObjects) {
+    if (CppHelper.useInterfaceSharedObjects(cppConfiguration, ccToolchain)
+        && allowInterfaceSharedObjects) {
       soInterface =
           CppHelper.getLinuxLinkedArtifact(
               ruleContext,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/JavaBinary.java b/src/main/java/com/google/devtools/build/lib/rules/java/JavaBinary.java
index 1c2f22ca0d..ed229fee77 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/JavaBinary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/JavaBinary.java
@@ -133,8 +133,10 @@ public class JavaBinary implements RuleConfiguredTargetFactory {
 
     CppConfiguration cppConfiguration = ruleContext.getConfiguration().getFragment(
         CppConfiguration.class);
-    boolean stripAsDefault = cppConfiguration.useFission()
-        && cppConfiguration.getCompilationMode() == CompilationMode.OPT;
+    // TODO(b/64384912): Remove in favor of CcToolchainProvider
+    boolean stripAsDefault =
+        cppConfiguration.useFission()
+            && cppConfiguration.getCompilationMode() == CompilationMode.OPT;
     Artifact launcher = semantics.getLauncher(ruleContext, common, deployArchiveBuilder,
         runfilesBuilder, jvmFlags, attributesBuilder, stripAsDefault);
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
index b421f736b1..9d40f8ecd6 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
@@ -254,7 +254,7 @@ public abstract class NativeDepsHelper {
     if (!builder.getLtoBitcodeFiles().isEmpty()
         && featureConfiguration.isEnabled(CppRuleClasses.THIN_LTO)) {
       builder.setLtoIndexing(true);
-      builder.setUsePicForLtoBackendActions(CppHelper.usePic(ruleContext, false));
+      builder.setUsePicForLtoBackendActions(CppHelper.usePic(ruleContext, toolchain, false));
       CppLinkAction indexAction = builder.build();
       ruleContext.registerAction(indexAction);
       builder.setLtoIndexing(false);