From 2c7800a1b1f2cea84c8d9376ccd347c97fff0c66 Mon Sep 17 00:00:00 2001 From: cpeyser Date: Tue, 19 Dec 2017 07:44:30 -0800 Subject: Move CppConfiguration#getCompilerFlags and #getCxxFlags to CcToolchainProvider. This is required to migrate the c++ rules to use platform based toolchain selection. PiperOrigin-RevId: 179552579 --- .../build/lib/rules/cpp/CcToolchainProvider.java | 50 +++++++++++ .../build/lib/rules/cpp/CppConfiguration.java | 63 +++++++------- .../devtools/build/lib/rules/cpp/CppHelper.java | 50 +++++++++++ .../build/lib/rules/cpp/CppLinkActionBuilder.java | 2 +- .../lib/rules/cpp/CppLinkstampCompileHelper.java | 5 +- .../devtools/build/lib/rules/cpp/CppModel.java | 28 +++++-- .../build/lib/rules/cpp/CppToolchainInfo.java | 96 +++++++++++++++++++++- 7 files changed, 256 insertions(+), 38 deletions(-) (limited to 'src/main/java') 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 getToolchainCompilerFlags() { + return toolchainInfo.getCompilerFlags(); + } + + /** Returns additional compiler flags for C++ arising from the {@link CToolchain} */ + ImmutableList getToolchainCxxFlags() { + return toolchainInfo.getCxxFlags(); + } + + /** + * Returns compiler flags arising from the {@link CToolchain} for C compilation by compilation + * mode. + */ + ImmutableListMultimap getCFlagsByCompilationMode() { + return toolchainInfo.getCFlagsByCompilationMode(); + } + + /** + * Returns compiler flags arising from the {@link CToolchain} for C++ compilation by compilation + * mode. + */ + ImmutableListMultimap getCxxFlagsByCompilationMode() { + return toolchainInfo.getCxxFlagsByCompilationMode(); + } + + /** Returns compiler flags arising from the {@link CToolchain} for C compilation by lipo mode. */ + ImmutableListMultimap getLipoCFlags() { + return toolchainInfo.getLipoCFlags(); + } + + /** + * Returns compiler flags arising from the {@link CToolchain} for C++ compilation by lipo mode. + */ + ImmutableListMultimap getLipoCxxFlags() { + return toolchainInfo.getLipoCxxFlags(); + } + + /** Returns optional compiler flags arising from the {@link CToolchain}. */ + ImmutableList getOptionalCompilerFlags() { + return toolchainInfo.getOptionalCompilerFlags(); + } + + /** Returns optional compiler flags for C++ arising from the {@link CToolchain}. */ + ImmutableList 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 copts; + private final ImmutableList cxxopts; private final ImmutableList linkOptions; private final ImmutableList 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 cFlags = ArrayListMultimap.create(); ListMultimap 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()); } @@ -339,11 +344,6 @@ public class CppConfiguration extends BuildConfiguration.Fragment { ImmutableList.of()); } - @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. + * + *

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 getCompilerOptions(Iterable 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}. + * + *

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 " + "compiler_options" ) + @Deprecated public ImmutableList getCxxOptions(Iterable 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 getCopts() { + return copts; + } + + /** Returns copts for c++ given at the Bazel command line. */ + public ImmutableList 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 collectLegacyCompileFlags( - String sourceFilename, ImmutableSet features) { - ImmutableList.Builder 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 @@ -239,6 +239,56 @@ public class CppHelper { return result; } + /** + * 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 getCompilerOptions( + CppConfiguration config, CcToolchainProvider toolchain, Iterable features) { + ImmutableList.Builder coptsBuilder = + ImmutableList.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 getCxxOptions( + CppConfiguration config, CcToolchainProvider toolchain, Iterable features) { + ImmutableList.Builder cxxOptsBuilder = + ImmutableList.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 getLtoBackendCommandLineOptions(ImmutableSet features) { List 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. * - *

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). + *

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> getLegacyCompileFlagsSupplier( - CppConfiguration cppConfiguration, String sourceFilename, ImmutableSet features) { - return () -> cppConfiguration.collectLegacyCompileFlags(sourceFilename, features); + CppConfiguration cppConfiguration, + CcToolchainProvider toolchain, + String sourceFilename, + ImmutableSet features) { + return () -> { + ImmutableList.Builder 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 additionalMakeVariables; + private final ImmutableList crosstoolCompilerFlags; + private final ImmutableList crosstoolCxxFlags; + private final ImmutableList crosstoolOptionalCompilerFlags; + private final ImmutableList crosstoolOptionalCxxFlags; + + private final ImmutableListMultimap cFlags; + private final ImmutableListMultimap cxxFlags; + private final ImmutableListMultimap lipoCFlags; + private final ImmutableListMultimap 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 cFlagsBuilder = + ImmutableListMultimap.builder(); + ImmutableListMultimap.Builder 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 lipoCFlagsBuilder = + ImmutableListMultimap.builder(); + ImmutableListMultimap.Builder 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 unfilteredCoptsBuilder = ImmutableList.builder(); + + unfilteredCoptsBuilder.addAll(toolchain.getUnfilteredCxxFlagList()); + ImmutableListMultimap.Builder 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 getRawBuiltInIncludeDirectories() { return rawBuiltInIncludeDirectories; } + + /** Returns compiler flags for C/C++/Asm compilation. */ + public ImmutableList getCompilerFlags() { + return crosstoolCompilerFlags; + } + + /** Returns additional compiler flags for C++ compilation. */ + public ImmutableList getCxxFlags() { + return crosstoolCxxFlags; + } + + /** Returns compiler flags for C compilation by compilation mode. */ + public ImmutableListMultimap getCFlagsByCompilationMode() { + return cFlags; + } + + /** Returns compiler flags for C++ compilation, by compilation mode. */ + public ImmutableListMultimap getCxxFlagsByCompilationMode() { + return cxxFlags; + } + + /** Returns compiler flags for C compilation by lipo mode. */ + public ImmutableListMultimap getLipoCFlags() { + return lipoCFlags; + } + + /** Returns compiler flags for C compilation by lipo mode. */ + public ImmutableListMultimap getLipoCxxFlags() { + return lipoCxxFlags; + } + + /** Returns optional compiler flags from this toolchain. */ + public ImmutableList getOptionalCompilerFlags() { + return crosstoolOptionalCompilerFlags; + } + + /** Returns optional compiler flags for C++ from this toolchain. */ + public ImmutableList getOptionalCxxFlags() { + return crosstoolOptionalCxxFlags; + } } -- cgit v1.2.3