// Copyright 2014 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.cpp;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.config.CompilationMode;
import com.google.devtools.build.lib.analysis.platform.ToolchainInfo;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.collect.nestedset.Order;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.events.Location;
import com.google.devtools.build.lib.skylarkinterface.SkylarkCallable;
import com.google.devtools.build.lib.skylarkinterface.SkylarkModule;
import com.google.devtools.build.lib.util.Pair;
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.util.Map;
import javax.annotation.Nullable;
/** Information about a C++ compiler used by the cc_*
rules. */
@SkylarkModule(name = "CcToolchainInfo", doc = "Information about the C++ compiler being used.")
@Immutable
public final class CcToolchainProvider extends ToolchainInfo {
public static final String SKYLARK_NAME = "CcToolchainInfo";
/** An empty toolchain to be returned in the error case (instead of null). */
public static final CcToolchainProvider EMPTY_TOOLCHAIN_IS_ERROR =
new CcToolchainProvider(
null,
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
null,
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
null,
NestedSetBuilder.emptySet(Order.STABLE_ORDER),
null,
PathFragment.EMPTY_FRAGMENT,
CppCompilationContext.EMPTY,
false,
false,
ImmutableMap.of(),
ImmutableList.of(),
NestedSetBuilder.>emptySet(Order.COMPILE_ORDER),
null,
ImmutableMap.of(),
ImmutableList.of(),
null);
@Nullable private final CppConfiguration cppConfiguration;
private final NestedSet crosstool;
private final NestedSet crosstoolMiddleman;
private final NestedSet compile;
private final NestedSet strip;
private final NestedSet objCopy;
private final NestedSet link;
private final Artifact interfaceSoBuilder;
private final NestedSet dwp;
private final NestedSet coverage;
private final NestedSet libcLink;
private final NestedSet staticRuntimeLinkInputs;
@Nullable private final Artifact staticRuntimeLinkMiddleman;
private final NestedSet dynamicRuntimeLinkInputs;
@Nullable private final Artifact dynamicRuntimeLinkMiddleman;
private final PathFragment dynamicRuntimeSolibDir;
private final CppCompilationContext cppCompilationContext;
private final boolean supportsParamFiles;
private final boolean supportsHeaderParsing;
private final ImmutableMap buildVariables;
private final ImmutableList builtinIncludeFiles;
private final NestedSet> coverageEnvironment;
@Nullable private final Artifact linkDynamicLibraryTool;
private final ImmutableMap environment;
private final ImmutableList builtInIncludeDirectories;
@Nullable private final PathFragment sysroot;
public CcToolchainProvider(
@Nullable CppConfiguration cppConfiguration,
NestedSet crosstool,
NestedSet crosstoolMiddleman,
NestedSet compile,
NestedSet strip,
NestedSet objCopy,
NestedSet link,
Artifact interfaceSoBuilder,
NestedSet dwp,
NestedSet coverage,
NestedSet libcLink,
NestedSet staticRuntimeLinkInputs,
@Nullable Artifact staticRuntimeLinkMiddleman,
NestedSet dynamicRuntimeLinkInputs,
@Nullable Artifact dynamicRuntimeLinkMiddleman,
PathFragment dynamicRuntimeSolibDir,
CppCompilationContext cppCompilationContext,
boolean supportsParamFiles,
boolean supportsHeaderParsing,
Map buildVariables,
ImmutableList builtinIncludeFiles,
NestedSet> coverageEnvironment,
Artifact linkDynamicLibraryTool,
ImmutableMap environment,
ImmutableList builtInIncludeDirectories,
@Nullable PathFragment sysroot) {
super(ImmutableMap.of(), Location.BUILTIN);
this.cppConfiguration = cppConfiguration;
this.crosstool = Preconditions.checkNotNull(crosstool);
this.crosstoolMiddleman = Preconditions.checkNotNull(crosstoolMiddleman);
this.compile = Preconditions.checkNotNull(compile);
this.strip = Preconditions.checkNotNull(strip);
this.objCopy = Preconditions.checkNotNull(objCopy);
this.link = Preconditions.checkNotNull(link);
this.interfaceSoBuilder = interfaceSoBuilder;
this.dwp = Preconditions.checkNotNull(dwp);
this.coverage = Preconditions.checkNotNull(coverage);
this.libcLink = Preconditions.checkNotNull(libcLink);
this.staticRuntimeLinkInputs = Preconditions.checkNotNull(staticRuntimeLinkInputs);
this.staticRuntimeLinkMiddleman = staticRuntimeLinkMiddleman;
this.dynamicRuntimeLinkInputs = Preconditions.checkNotNull(dynamicRuntimeLinkInputs);
this.dynamicRuntimeLinkMiddleman = dynamicRuntimeLinkMiddleman;
this.dynamicRuntimeSolibDir = Preconditions.checkNotNull(dynamicRuntimeSolibDir);
this.cppCompilationContext = Preconditions.checkNotNull(cppCompilationContext);
this.supportsParamFiles = supportsParamFiles;
this.supportsHeaderParsing = supportsHeaderParsing;
this.buildVariables = ImmutableMap.copyOf(buildVariables);
this.builtinIncludeFiles = builtinIncludeFiles;
this.coverageEnvironment = coverageEnvironment;
this.linkDynamicLibraryTool = linkDynamicLibraryTool;
this.environment = environment;
this.builtInIncludeDirectories = builtInIncludeDirectories;
this.sysroot = sysroot;
}
@SkylarkCallable(
name = "built_in_include_directories",
doc = "Returns the list of built-in directories of the compiler.",
structField = true
)
public ImmutableList getBuiltInIncludeDirectories() {
return builtInIncludeDirectories;
}
/**
* Returns all the files in Crosstool. Is not a middleman.
*/
public NestedSet getCrosstool() {
return crosstool;
}
/**
* Returns a middleman for all the files in Crosstool.
*/
public NestedSet getCrosstoolMiddleman() {
return crosstoolMiddleman;
}
/**
* Returns the files necessary for compilation.
*/
public NestedSet getCompile() {
return compile;
}
/**
* Returns the files necessary for a 'strip' invocation.
*/
public NestedSet getStrip() {
return strip;
}
/**
* Returns the files necessary for an 'objcopy' invocation.
*/
public NestedSet getObjcopy() {
return objCopy;
}
/**
* Returns the files necessary for linking, including the files needed for libc.
*/
public NestedSet getLink() {
return link;
}
public NestedSet getDwp() {
return dwp;
}
/**
* Returns the files necessary for capturing code coverage.
*/
public NestedSet getCoverage() {
return coverage;
}
public NestedSet getLibcLink() {
return libcLink;
}
/**
* Returns the static runtime libraries.
*/
public NestedSet getStaticRuntimeLinkInputs() {
return staticRuntimeLinkInputs;
}
/**
* Returns an aggregating middleman that represents the static runtime libraries.
*/
@Nullable public Artifact getStaticRuntimeLinkMiddleman() {
return staticRuntimeLinkMiddleman;
}
/**
* Returns the dynamic runtime libraries.
*/
public NestedSet getDynamicRuntimeLinkInputs() {
return dynamicRuntimeLinkInputs;
}
/**
* Returns an aggregating middleman that represents the dynamic runtime libraries.
*/
@Nullable public Artifact getDynamicRuntimeLinkMiddleman() {
return dynamicRuntimeLinkMiddleman;
}
/**
* Returns the name of the directory where the solib symlinks for the dynamic runtime libraries
* live. The directory itself will be under the root of the host configuration in the 'bin'
* directory.
*/
public PathFragment getDynamicRuntimeSolibDir() {
return dynamicRuntimeSolibDir;
}
/**
* Returns the C++ compilation context for the toolchain.
*/
public CppCompilationContext getCppCompilationContext() {
return cppCompilationContext;
}
/**
* Whether the toolchains supports parameter files.
*/
public boolean supportsParamFiles() {
return supportsParamFiles;
}
/**
* Whether the toolchains supports header parsing.
*/
public boolean supportsHeaderParsing() {
return supportsHeaderParsing;
}
/**
* Returns the configured features of the toolchain.
*/
@Nullable
public CcToolchainFeatures getFeatures() {
return cppConfiguration == null ? null : cppConfiguration.getFeatures();
}
/**
* Returns the compilation mode.
*/
@Nullable
public CompilationMode getCompilationMode() {
return cppConfiguration == null ? null : cppConfiguration.getCompilationMode();
}
@Nullable
public CppConfiguration getCppConfiguration() {
return cppConfiguration;
}
/**
* Returns build variables to be templated into the crosstool.
*/
public ImmutableMap getBuildVariables() {
return buildVariables;
}
/**
* Return the set of include files that may be included even if they are not mentioned in the
* source file or any of the headers included by it.
*/
public ImmutableList getBuiltinIncludeFiles() {
return builtinIncludeFiles;
}
/**
* Returns the environment variables that need to be added to tests that collect code coverage.
*/
public NestedSet> getCoverageEnvironment() {
return coverageEnvironment;
}
public ImmutableMap getEnvironment() {
return environment;
}
/**
* Returns the tool which should be used for linking dynamic libraries, or in case it's not
* specified by the crosstool this will be @tools_repository/tools/cpp:link_dynamic_library
*/
public Artifact getLinkDynamicLibraryTool() {
return linkDynamicLibraryTool;
}
/**
* Returns the tool that builds interface libraries from dynamic libraries.
*/
public Artifact getInterfaceSoBuilder() {
return interfaceSoBuilder;
}
@SkylarkCallable(
name = "sysroot",
structField = true,
doc =
"Returns the sysroot to be used. If the toolchain compiler does not support "
+ "different sysroots, or the sysroot is the same as the default sysroot, then "
+ "this method returns None
."
)
public PathFragment getSysroot() {
return sysroot;
}
@SkylarkCallable(
name = "unfiltered_compiler_options_do_not_use",
doc =
"Returns the default list of options which cannot be filtered by BUILD "
+ "rules. These should be appended to the command line after filtering."
)
public ImmutableList getUnfilteredCompilerOptionsWithSysroot(Iterable features) {
return cppConfiguration.getUnfilteredCompilerOptionsDoNotUse(features, sysroot);
}
public ImmutableList getUnfilteredCompilerOptions(Iterable features) {
return cppConfiguration.getUnfilteredCompilerOptionsDoNotUse(features, /* sysroot= */ null);
}
@SkylarkCallable(
name = "link_options_do_not_use",
structField = true,
doc =
"Returns the set of command-line linker options, including any flags "
+ "inferred from the command-line options."
)
public ImmutableList getLinkOptionsWithSysroot() {
return cppConfiguration.getLinkOptionsDoNotUse(sysroot);
}
public ImmutableList getLinkOptions() {
return cppConfiguration.getLinkOptionsDoNotUse(/* sysroot= */ null);
}
// Not all of CcToolchainProvider is exposed to Skylark, which makes implementing deep equality
// impossible: if Java-only parts are considered, the behavior is surprising in Skylark, if they
// are not, the behavior is surprising in Java. Thus, object identity it is.
@Override
public boolean equals(Object other) {
return other == this;
}
@Override
public int hashCode() {
return System.identityHashCode(this);
}
}