Move CppConfiguration#getCompilerFlags and #getCxxFlags to CcToolchainProvider.

This is required to migrate the c++ rules to use platform based toolchain selection.

PiperOrigin-RevId: 179552579

7 files changed, 256 insertions, 38 deletions

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 8ae8737f07..dc387e55c7 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
@@ -17,6 +17,7 @@ import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableListMultimap;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMap.Builder;
 import com.google.devtools.build.lib.actions.Artifact;
@@ -36,6 +37,7 @@ import com.google.devtools.build.lib.skylarkinterface.SkylarkModule;
 import com.google.devtools.build.lib.util.Pair;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CToolchain;
+import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CToolchain.OptionalFlag;
 import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.LipoMode;
 import java.util.Map;
 import javax.annotation.Nullable;
@@ -673,6 +675,54 @@ public final class CcToolchainProvider extends ToolchainInfo {
     return toolchainInfo.getSharedLibraryLinkOptions(flags, features);
   }
 
+  /** Returns compiler flags arising from the {@link CToolchain}. */
+  ImmutableList<String> getToolchainCompilerFlags() {
+    return toolchainInfo.getCompilerFlags();
+  }
+
+  /** Returns additional compiler flags for C++ arising from the {@link CToolchain} */
+  ImmutableList<String> getToolchainCxxFlags() {
+    return toolchainInfo.getCxxFlags();
+  }
+
+  /**
+   * Returns compiler flags arising from the {@link CToolchain} for C compilation by compilation
+   * mode.
+   */
+  ImmutableListMultimap<CompilationMode, String> getCFlagsByCompilationMode() {
+    return toolchainInfo.getCFlagsByCompilationMode();
+  }
+
+  /**
+   * Returns compiler flags arising from the {@link CToolchain} for C++ compilation by compilation
+   * mode.
+   */
+  ImmutableListMultimap<CompilationMode, String> getCxxFlagsByCompilationMode() {
+    return toolchainInfo.getCxxFlagsByCompilationMode();
+  }
+
+  /** Returns compiler flags arising from the {@link CToolchain} for C compilation by lipo mode. */
+  ImmutableListMultimap<LipoMode, String> getLipoCFlags() {
+    return toolchainInfo.getLipoCFlags();
+  }
+
+  /**
+   * Returns compiler flags arising from the {@link CToolchain} for C++ compilation by lipo mode.
+   */
+  ImmutableListMultimap<LipoMode, String> getLipoCxxFlags() {
+    return toolchainInfo.getLipoCxxFlags();
+  }
+
+  /** Returns optional compiler flags arising from the {@link CToolchain}. */
+  ImmutableList<OptionalFlag> getOptionalCompilerFlags() {
+    return toolchainInfo.getOptionalCompilerFlags();
+  }
+
+  /** Returns optional compiler flags for C++ arising from the {@link CToolchain}. */
+  ImmutableList<OptionalFlag> getOptionalCxxFlags() {
+    return toolchainInfo.getOptionalCxxFlags();
+  }
+
   /** Returns linker flags for fully statically linked outputs. */
   FlagList getFullyStaticLinkFlags(CompilationMode compilationMode, LipoMode lipoMode) {
     return new FlagList(
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 614955f64e..f50e314dbc 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
@@ -182,6 +182,8 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
   private final FlagList mostlyStaticLinkFlags;
   private final FlagList mostlyStaticSharedLinkFlags;
   private final FlagList dynamicLinkFlags;
+  private final ImmutableList<String> copts;
+  private final ImmutableList<String> cxxopts;
 
   private final ImmutableList<String> linkOptions;
   private final ImmutableList<String> ltoindexOptions;
@@ -230,6 +232,9 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
             || (cppOptions.stripBinaries == StripMode.SOMETIMES
                 && compilationMode == CompilationMode.FASTBUILD));
 
+    this.copts = ImmutableList.copyOf(cppOptions.coptList);
+    this.cxxopts = ImmutableList.copyOf(cppOptions.cxxoptList);
+
     ListMultimap<CompilationMode, String> cFlags = ArrayListMultimap.create();
     ListMultimap<CompilationMode, String> cxxFlags = ArrayListMultimap.create();
     for (CrosstoolConfig.CompilationModeFlags flags : toolchain.getCompilationModeFlagsList()) {
@@ -237,7 +242,7 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
       if (flags.getMode() == CrosstoolConfig.CompilationMode.COVERAGE) {
         continue;
       }
-      CompilationMode realmode = importCompilationMode(flags.getMode());
+      CompilationMode realmode = CppToolchainInfo.importCompilationMode(flags.getMode());
       cFlags.putAll(realmode, flags.getCompilerFlagList());
       cxxFlags.putAll(realmode, flags.getCxxFlagList());
     }
@@ -340,11 +345,6 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
   }
 
   @VisibleForTesting
-  static CompilationMode importCompilationMode(CrosstoolConfig.CompilationMode mode) {
-    return CompilationMode.valueOf(mode.name());
-  }
-
-  @VisibleForTesting
   static LinkingMode importLinkingMode(CrosstoolConfig.LinkingMode mode) {
     return LinkingMode.valueOf(mode.name());
   }
@@ -550,11 +550,13 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
   }
 
   /**
-   * Returns the default options to use for compiling C, C++, and assembler.
-   * This is just the options that should be used for all three languages.
-   * There may be additional C-specific or C++-specific options that should be used,
-   * in addition to the ones returned by this method.
+   * Returns the default options to use for compiling C, C++, and assembler. This is just the
+   * options that should be used for all three languages. There may be additional C-specific or
+   * C++-specific options that should be used, in addition to the ones returned by this method.
+   *
+   * <p>Deprecated: Use {@link CppHelper#getCompilerOptions}
    */
+  // TODO(b/64384912): Migrate skylark callers and remove.
   @SkylarkCallable(
     name = "compiler_options",
     doc =
@@ -563,6 +565,7 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
             + "There may be additional C-specific or C++-specific options that should be used, "
             + "in addition to the ones returned by this method"
   )
+  @Deprecated
   public ImmutableList<String> getCompilerOptions(Iterable<String> features) {
     return compilerFlags.evaluate(features);
   }
@@ -581,10 +584,12 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
   }
 
   /**
-   * Returns the list of additional C++-specific options to use for compiling
-   * C++. These should be go on the command line after the common options
-   * returned by {@link #getCompilerOptions}.
+   * Returns the list of additional C++-specific options to use for compiling C++. These should be
+   * on the command line after the common options returned by {@link #getCompilerOptions}.
+   *
+   * <p>Deprecated: Use {@link CppHelper#getCxxOptions}
    */
+  // TODO(b/64384912): Migrate skylark callers and remove.
   @SkylarkCallable(
     name = "cxx_options",
     doc =
@@ -592,6 +597,7 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
             + "These should be go on the command line after the common options returned by "
             + "<code>compiler_options</code>"
   )
+  @Deprecated
   public ImmutableList<String> getCxxOptions(Iterable<String> features) {
     return cxxFlags.evaluate(features);
   }
@@ -1141,6 +1147,21 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
     return lipoContextCollector;
   }
 
+  /** Returns whether this configuration will use libunwind for stack unwinding. */
+  public boolean isOmitfp() {
+    return cppOptions.experimentalOmitfp;
+  }
+
+  /** Returns copts given at the Bazel command line. */
+  public ImmutableList<String> getCopts() {
+    return copts;
+  }
+
+  /** Returns copts for c++ given at the Bazel command line. */
+  public ImmutableList<String> getCxxopts() {
+    return cxxopts;
+  }
+
   @Override
   public void reportInvalidOptions(EventHandler reporter, BuildOptions buildOptions) {
     CppOptions cppOptions = buildOptions.get(CppOptions.class);
@@ -1347,22 +1368,6 @@ public class CppConfiguration extends BuildConfiguration.Fragment {
     return requestedFeatures.build();
   }
 
-  public ImmutableList<String> collectLegacyCompileFlags(
-      String sourceFilename, ImmutableSet<String> features) {
-    ImmutableList.Builder<String> legacyCompileFlags = ImmutableList.builder();
-    legacyCompileFlags.addAll(getCompilerOptions(features));
-    if (CppFileTypes.C_SOURCE.matches(sourceFilename)) {
-      legacyCompileFlags.addAll(getCOptions());
-    }
-    if (CppFileTypes.CPP_SOURCE.matches(sourceFilename)
-        || CppFileTypes.CPP_HEADER.matches(sourceFilename)
-        || CppFileTypes.CPP_MODULE_MAP.matches(sourceFilename)
-        || CppFileTypes.CLIF_INPUT_PROTO.matches(sourceFilename)) {
-      legacyCompileFlags.addAll(getCxxOptions(features));
-    }
-    return legacyCompileFlags.build();
-  }
-
   public static PathFragment computeDefaultSysroot(CToolchain toolchain) {
     PathFragment defaultSysroot =
         toolchain.getBuiltinSysroot().length() == 0
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 411c1527e4..fec028a6a1 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
@@ -240,6 +240,56 @@ public class CppHelper {
   }
 
   /**
+   * Returns the default options to use for compiling C, C++, and assembler. This is just the
+   * options that should be used for all three languages. There may be additional C-specific or
+   * C++-specific options that should be used, in addition to the ones returned by this method.
+   */
+  //TODO(b/70784100): Figure out if these methods can be moved to CcToolchainProvider.
+  public static ImmutableList<String> getCompilerOptions(
+      CppConfiguration config, CcToolchainProvider toolchain, Iterable<String> features) {
+    ImmutableList.Builder<String> coptsBuilder =
+        ImmutableList.<String>builder()
+            .addAll(toolchain.getToolchainCompilerFlags())
+            .addAll(toolchain.getCFlagsByCompilationMode().get(config.getCompilationMode()))
+            .addAll(toolchain.getLipoCFlags().get(config.getLipoMode()));
+
+    if (config.isOmitfp()) {
+      coptsBuilder.add("-fomit-frame-pointer");
+      coptsBuilder.add("-fasynchronous-unwind-tables");
+      coptsBuilder.add("-DNO_FRAME_POINTER");
+    }
+
+    FlagList compilerFlags =
+        new FlagList(
+            coptsBuilder.build(),
+            FlagList.convertOptionalOptions(toolchain.getOptionalCompilerFlags()),
+            ImmutableList.copyOf(config.getCopts()));
+
+    return compilerFlags.evaluate(features);
+  }
+
+  /**
+   * Returns the list of additional C++-specific options to use for compiling C++. These should be
+   * go on the command line after the common options returned by {@link #getCompilerOptions}.
+   */
+  public static ImmutableList<String> getCxxOptions(
+      CppConfiguration config, CcToolchainProvider toolchain, Iterable<String> features) {
+    ImmutableList.Builder<String> cxxOptsBuilder =
+        ImmutableList.<String>builder()
+            .addAll(toolchain.getToolchainCxxFlags())
+            .addAll(toolchain.getCxxFlagsByCompilationMode().get(config.getCompilationMode()))
+            .addAll(toolchain.getLipoCxxFlags().get(config.getLipoMode()));
+
+    FlagList cxxFlags =
+        new FlagList(
+            cxxOptsBuilder.build(),
+            FlagList.convertOptionalOptions(toolchain.getOptionalCxxFlags()),
+            ImmutableList.copyOf(config.getCxxopts()));
+
+    return cxxFlags.evaluate(features);
+  }
+
+  /**
    * Returns the immutable list of linker options for fully statically linked outputs. Does not
    * include command-line options passed via --linkopt or --linkopts.
    *
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 1777257632..9949d7e0f2 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
@@ -584,7 +584,7 @@ public class CppLinkActionBuilder {
   private List<String> getLtoBackendCommandLineOptions(ImmutableSet<String> features) {
     List<String> argv = new ArrayList<>();
     argv.addAll(toolchain.getLinkOptions());
-    argv.addAll(cppConfiguration.getCompilerOptions(features));
+    argv.addAll(CppHelper.getCompilerOptions(cppConfiguration, toolchain, features));
     return argv;
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkstampCompileHelper.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkstampCompileHelper.java
index dac1517c4b..9b7ee60c60 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkstampCompileHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkstampCompileHelper.java
@@ -160,7 +160,10 @@ public class CppLinkstampCompileHelper {
     variables.addLazyStringSequenceVariable(
         CppModel.LEGACY_COMPILE_FLAGS_VARIABLE_NAME,
         CppModel.getLegacyCompileFlagsSupplier(
-            cppConfiguration, sourceFile.getExecPathString(), ImmutableSet.of()));
+            cppConfiguration,
+            ccToolchainProvider,
+            sourceFile.getExecPathString(),
+            ImmutableSet.of()));
     // Unfilterable flags coming from unfiltered_cxx_flag fields
     variables.addLazyStringSequenceVariable(
         CppModel.UNFILTERED_COMPILE_FLAGS_VARIABLE_NAME,
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 3610e2a8a4..30c9e977c4 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,13 +502,29 @@ public final class CppModel {
   /**
    * Supplier that computes legacy_compile_flags lazily at the execution phase.
    *
-   * <p>Dear friends of the lambda, this method exists to limit the scope of captured variables
-   * only to arguments (to prevent accidental capture of enclosing instance which could regress
-   * memory).
+   * <p>Dear friends of the lambda, this method exists to limit the scope of captured variables only
+   * to arguments (to prevent accidental capture of enclosing instance which could regress memory).
    */
   public static Supplier<ImmutableList<String>> getLegacyCompileFlagsSupplier(
-      CppConfiguration cppConfiguration, String sourceFilename, ImmutableSet<String> features) {
-    return () -> cppConfiguration.collectLegacyCompileFlags(sourceFilename, features);
+      CppConfiguration cppConfiguration,
+      CcToolchainProvider toolchain,
+      String sourceFilename,
+      ImmutableSet<String> features) {
+    return () -> {
+      ImmutableList.Builder<String> legacyCompileFlags = ImmutableList.builder();
+      legacyCompileFlags.addAll(
+          CppHelper.getCompilerOptions(cppConfiguration, toolchain, features));
+      if (CppFileTypes.C_SOURCE.matches(sourceFilename)) {
+        legacyCompileFlags.addAll(cppConfiguration.getCOptions());
+      }
+      if (CppFileTypes.CPP_SOURCE.matches(sourceFilename)
+          || CppFileTypes.CPP_HEADER.matches(sourceFilename)
+          || CppFileTypes.CPP_MODULE_MAP.matches(sourceFilename)
+          || CppFileTypes.CLIF_INPUT_PROTO.matches(sourceFilename)) {
+        legacyCompileFlags.addAll(CppHelper.getCxxOptions(cppConfiguration, toolchain, features));
+      }
+      return legacyCompileFlags.build();
+    };
   }
 
   private void setupCompileBuildVariables(
@@ -541,7 +557,7 @@ public final class CppModel {
     String sourceFilename = sourceFile.getExecPathString();
     buildVariables.addLazyStringSequenceVariable(
         LEGACY_COMPILE_FLAGS_VARIABLE_NAME,
-        getLegacyCompileFlagsSupplier(cppConfiguration, sourceFilename, features));
+        getLegacyCompileFlagsSupplier(cppConfiguration, ccToolchain, sourceFilename, features));
 
     if (!CppFileTypes.OBJC_SOURCE.matches(sourceFilename)
         && !CppFileTypes.OBJCPP_SOURCE.matches(sourceFilename)) {
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java
index dbdfc29289..be90290faf 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java
@@ -14,6 +14,7 @@
 
 package com.google.devtools.build.lib.rules.cpp;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableListMultimap;
@@ -93,6 +94,16 @@ public final class CppToolchainInfo {
 
   private final ImmutableMap<String, String> additionalMakeVariables;
 
+  private final ImmutableList<String> crosstoolCompilerFlags;
+  private final ImmutableList<String> crosstoolCxxFlags;
+  private final ImmutableList<OptionalFlag> crosstoolOptionalCompilerFlags;
+  private final ImmutableList<OptionalFlag> crosstoolOptionalCxxFlags;
+
+  private final ImmutableListMultimap<CompilationMode, String> cFlags;
+  private final ImmutableListMultimap<CompilationMode, String> cxxFlags;
+  private final ImmutableListMultimap<LipoMode, String> lipoCFlags;
+  private final ImmutableListMultimap<LipoMode, String> lipoCxxFlags;
+
   private final boolean supportsFission;
   private final boolean supportsStartEndLib;
   private final boolean supportsEmbeddedRuntimes;
@@ -194,6 +205,44 @@ public final class CppToolchainInfo {
     }
     this.toolPaths = ImmutableMap.copyOf(toolPathsCollector);
 
+    this.crosstoolCompilerFlags = ImmutableList.copyOf(toolchain.getCompilerFlagList());
+    this.crosstoolCxxFlags = ImmutableList.copyOf(toolchain.getCxxFlagList());
+    this.crosstoolOptionalCompilerFlags =
+        ImmutableList.copyOf(toolchain.getOptionalCompilerFlagList());
+    this.crosstoolOptionalCxxFlags = ImmutableList.copyOf(toolchain.getOptionalCxxFlagList());
+
+    ImmutableListMultimap.Builder<CompilationMode, String> cFlagsBuilder =
+        ImmutableListMultimap.builder();
+    ImmutableListMultimap.Builder<CompilationMode, String> cxxFlagsBuilder =
+        ImmutableListMultimap.builder();
+    for (CrosstoolConfig.CompilationModeFlags flags : toolchain.getCompilationModeFlagsList()) {
+      // Remove this when CROSSTOOL files no longer contain 'coverage'.
+      if (flags.getMode() == CrosstoolConfig.CompilationMode.COVERAGE) {
+        continue;
+      }
+      CompilationMode realmode = importCompilationMode(flags.getMode());
+      cFlagsBuilder.putAll(realmode, flags.getCompilerFlagList());
+      cxxFlagsBuilder.putAll(realmode, flags.getCxxFlagList());
+    }
+    cFlags = cFlagsBuilder.build();
+    cxxFlags = cxxFlagsBuilder.build();
+
+    ImmutableListMultimap.Builder<LipoMode, String> lipoCFlagsBuilder =
+        ImmutableListMultimap.builder();
+    ImmutableListMultimap.Builder<LipoMode, String> lipoCxxFlagsBuilder =
+        ImmutableListMultimap.builder();
+    for (CrosstoolConfig.LipoModeFlags flags : toolchain.getLipoModeFlagsList()) {
+      LipoMode realmode = flags.getMode();
+      lipoCFlagsBuilder.putAll(realmode, flags.getCompilerFlagList());
+      lipoCxxFlagsBuilder.putAll(realmode, flags.getCxxFlagList());
+    }
+    lipoCFlags = lipoCFlagsBuilder.build();
+    lipoCxxFlags = lipoCxxFlagsBuilder.build();
+
+    ImmutableList.Builder<String> unfilteredCoptsBuilder = ImmutableList.builder();
+
+    unfilteredCoptsBuilder.addAll(toolchain.getUnfilteredCxxFlagList());
+
     ImmutableListMultimap.Builder<CompilationMode, String> linkOptionsFromCompilationModeBuilder =
         ImmutableListMultimap.builder();
     for (CrosstoolConfig.CompilationModeFlags flags : toolchain.getCompilationModeFlagsList()) {
@@ -201,7 +250,7 @@ public final class CppToolchainInfo {
       if (flags.getMode() == CrosstoolConfig.CompilationMode.COVERAGE) {
         continue;
       }
-      CompilationMode realmode = CppConfiguration.importCompilationMode(flags.getMode());
+      CompilationMode realmode = importCompilationMode(flags.getMode());
       linkOptionsFromCompilationModeBuilder.putAll(realmode, flags.getLinkerFlagList());
     }
     linkOptionsFromCompilationMode = linkOptionsFromCompilationModeBuilder.build();
@@ -282,6 +331,11 @@ public final class CppToolchainInfo {
     this.ldExecutable = getToolPathFragment(CppConfiguration.Tool.LD);
   }
 
+  @VisibleForTesting
+  static CompilationMode importCompilationMode(CrosstoolConfig.CompilationMode mode) {
+    return CompilationMode.valueOf(mode.name());
+  }
+
   // TODO(bazel-team): Remove this once bazel supports all crosstool flags through
   // feature configuration, and all crosstools have been converted.
   private CToolchain addLegacyFeatures(CToolchain toolchain) {
@@ -674,4 +728,44 @@ public final class CppToolchainInfo {
   public ImmutableList<String> getRawBuiltInIncludeDirectories() {
     return rawBuiltInIncludeDirectories;
   }
+
+  /** Returns compiler flags for C/C++/Asm compilation. */
+  public ImmutableList<String> getCompilerFlags() {
+    return crosstoolCompilerFlags;
+  }
+
+  /** Returns additional compiler flags for C++ compilation. */
+  public ImmutableList<String> getCxxFlags() {
+    return crosstoolCxxFlags;
+  }
+
+  /** Returns compiler flags for C compilation by compilation mode. */
+  public ImmutableListMultimap<CompilationMode, String> getCFlagsByCompilationMode() {
+    return cFlags;
+  }
+
+  /** Returns compiler flags for C++ compilation, by compilation mode. */
+  public ImmutableListMultimap<CompilationMode, String> getCxxFlagsByCompilationMode() {
+    return cxxFlags;
+  }
+
+  /** Returns compiler flags for C compilation by lipo mode. */
+  public ImmutableListMultimap<LipoMode, String> getLipoCFlags() {
+    return lipoCFlags;
+  }
+
+  /** Returns compiler flags for C compilation by lipo mode. */
+  public ImmutableListMultimap<LipoMode, String> getLipoCxxFlags() {
+    return lipoCxxFlags;
+  }
+
+  /** Returns optional compiler flags from this toolchain. */
+  public ImmutableList<OptionalFlag> getOptionalCompilerFlags() {
+    return crosstoolOptionalCompilerFlags;
+  }
+
+  /** Returns optional compiler flags for C++ from this toolchain. */
+  public ImmutableList<OptionalFlag> getOptionalCxxFlags() {
+    return crosstoolOptionalCxxFlags;
+  }
 }