getProvider() {
return PROVIDER;
}
/**
* See {@link #usePicForDynamicLibraries}. This method is there only to serve Starlark callers.
*/
@Override
public boolean usePicForDynamicLibrariesFromStarlark(
FeatureConfigurationForStarlark featureConfiguration) {
return usePicForDynamicLibraries(
featureConfiguration
.getCppConfigurationFromFeatureConfigurationCreatedForStarlark_andIKnowWhatImDoing(),
featureConfiguration.getFeatureConfiguration());
}
/**
* 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").
*
* @return true if this rule's compilations should apply -fPIC, false otherwise
*/
public boolean usePicForDynamicLibraries(
CppConfiguration cppConfiguration, FeatureConfiguration featureConfiguration) {
return cppConfiguration.forcePic()
|| featureConfiguration.isEnabled(CppRuleClasses.SUPPORTS_PIC);
}
/**
* Returns true if PER_OBJECT_DEBUG_INFO are specified and supported by the CROSSTOOL for the
* build implied by the given configuration, toolchain and feature configuration.
*/
public boolean shouldCreatePerObjectDebugInfo(
FeatureConfiguration featureConfiguration, CppConfiguration cppConfiguration) {
return cppConfiguration.fissionIsActiveForCurrentCompilationMode()
&& featureConfiguration.isEnabled(CppRuleClasses.PER_OBJECT_DEBUG_INFO);
}
/** Whether the toolchains supports header parsing. */
public boolean supportsHeaderParsing() {
return supportsHeaderParsing;
}
/**
* Returns true if headers should be parsed in this build.
*
* This means headers in 'srcs' and 'hdrs' will be "compiled" using {@link CppCompileAction}).
* It will run compiler's parser to ensure the header is self-contained. This is required for
* layering_check to work.
*/
public boolean shouldProcessHeaders(
FeatureConfiguration featureConfiguration, CppConfiguration cppConfiguration) {
return featureConfiguration.isEnabled(CppRuleClasses.PARSE_HEADERS);
}
public void addGlobalMakeVariables(ImmutableMap.Builder globalMakeEnvBuilder) {
ImmutableMap.Builder result = ImmutableMap.builder();
// hardcoded CC->gcc setting for unit tests
result.put("CC", getToolPathStringOrNull(Tool.GCC));
// Make variables provided by crosstool/gcc compiler suite.
result.put("AR", getToolPathStringOrNull(Tool.AR));
result.put("NM", getToolPathStringOrNull(Tool.NM));
result.put("LD", getToolPathStringOrNull(Tool.LD));
String objcopyTool = getToolPathStringOrNull(Tool.OBJCOPY);
if (objcopyTool != null) {
// objcopy is optional in Crosstool
result.put("OBJCOPY", objcopyTool);
}
result.put("STRIP", getToolPathStringOrNull(Tool.STRIP));
String gcovtool = getToolPathStringOrNull(Tool.GCOVTOOL);
if (gcovtool != null) {
// gcov-tool is optional in Crosstool
result.put("GCOVTOOL", gcovtool);
}
if (getTargetLibc().startsWith("glibc-")) {
result.put("GLIBC_VERSION", getTargetLibc().substring("glibc-".length()));
} else {
result.put("GLIBC_VERSION", getTargetLibc());
}
result.put("C_COMPILER", getCompiler());
// Deprecated variables
// TODO(bazel-team): delete all of these.
result.put("CROSSTOOLTOP", crosstoolTopPathFragment.getPathString());
// TODO(bazel-team): Remove when Starlark dependencies can be updated to rely on
// CcToolchainProvider.
result.putAll(getAdditionalMakeVariables());
String abiGlibcVersion = getAbiGlibcVersion();
if (abiGlibcVersion != null) {
result.put("ABI_GLIBC_VERSION", getAbiGlibcVersion());
}
String abi = getAbi();
if (abi != null) {
result.put("ABI", getAbi());
}
globalMakeEnvBuilder.putAll(result.buildOrThrow());
}
/**
* Returns the path fragment that is either absolute or relative to the execution root that can be
* used to execute the given tool.
*
* @throws RuleErrorException when the tool is not specified by the toolchain.
*/
public PathFragment getToolPathFragment(
CppConfiguration.Tool tool, RuleErrorConsumer ruleErrorConsumer) throws RuleErrorException {
PathFragment toolPathFragment = getToolPathFragmentOrNull(tool);
if (toolPathFragment == null) {
throw ruleErrorConsumer.throwWithRuleError(
String.format(
"cc_toolchain '%s' with identifier '%s' doesn't define a tool path for '%s'",
getCcToolchainLabel(), getToolchainIdentifier(), tool.getNamePart()));
}
return toolPathFragment;
}
/**
* Returns the path fragment that is either absolute or relative to the execution root that can be
* used to execute the given tool.
*/
@Nullable
public String getToolPathStringOrNull(Tool tool) {
PathFragment toolPathFragment = getToolPathFragmentOrNull(tool);
return toolPathFragment == null ? null : toolPathFragment.getPathString();
}
@Nullable
@Override
public String getToolPathStringOrNoneForStarlark(String toolString, StarlarkThread thread)
throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
Tool tool = Tool.valueOf(toolString);
PathFragment toolPathFragment = getToolPathFragmentOrNull(tool);
return toolPathFragment == null ? null : toolPathFragment.getPathString();
}
/**
* Returns the path fragment that is either absolute or relative to the execution root that can be
* used to execute the given tool.
*/
@Nullable
public PathFragment getToolPathFragmentOrNull(CppConfiguration.Tool tool) {
return toolPaths.get(tool.getNamePart());
}
@Override
public ImmutableList getBuiltInIncludeDirectoriesAsStrings() {
return builtInIncludeDirectories.stream()
.map(PathFragment::getSafePathString)
.collect(ImmutableList.toImmutableList());
}
@Override
public Depset getAllFilesForStarlark() {
return Depset.of(Artifact.class, getAllFiles());
}
@Override
public Depset getStaticRuntimeLibForStarlark(
FeatureConfigurationForStarlark featureConfigurationForStarlark) throws EvalException {
return Depset.of(
Artifact.class,
getStaticRuntimeLinkInputs(featureConfigurationForStarlark.getFeatureConfiguration()));
}
@Override
public Depset getDynamicRuntimeLibForStarlark(
FeatureConfigurationForStarlark featureConfigurationForStarlark) throws EvalException {
return Depset.of(
Artifact.class,
getDynamicRuntimeLinkInputs(featureConfigurationForStarlark.getFeatureConfiguration()));
}
public ImmutableList getBuiltInIncludeDirectories() {
return builtInIncludeDirectories;
}
/** Returns the identifier of the toolchain as specified in the {@code CToolchain} proto. */
@Override
public String getToolchainIdentifier() {
return toolchainIdentifier;
}
/** Returns all the files in Crosstool. */
public NestedSet getAllFiles() {
return allFiles;
}
/** Returns all the files in Crosstool + libc. */
public NestedSet getAllFilesIncludingLibc() {
return allFilesIncludingLibc;
}
@Override
public Depset getAllFilesIncludingLibcForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getAllFilesIncludingLibc());
}
/** Returns the files necessary for compilation. */
public NestedSet getCompilerFiles() {
return compilerFiles;
}
@Override
public Depset getCompilerFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getCompilerFiles());
}
/**
* Returns the files necessary for compilation excluding headers, assuming that included files
* will be discovered by input discovery. If the toolchain does not provide this fileset, falls
* back to {@link #getCompilerFiles()}.
*/
public NestedSet getCompilerFilesWithoutIncludes() {
if (compilerFilesWithoutIncludes.isEmpty()) {
return getCompilerFiles();
}
return compilerFilesWithoutIncludes;
}
/** Returns the files necessary for a 'strip' invocation. */
public NestedSet getStripFiles() {
return stripFiles;
}
@Override
public Depset getStripFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getStripFiles());
}
/** Returns the files necessary for an 'objcopy' invocation. */
public NestedSet getObjcopyFiles() {
return objcopyFiles;
}
@Override
public Depset getObjcopyFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getObjcopyFiles());
}
/**
* Returns the files necessary for an 'as' invocation. May be empty if the CROSSTOOL file does not
* define as_files.
*/
public NestedSet getAsFiles() {
return asFiles;
}
@Override
public Depset getAsFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getAsFiles());
}
/**
* Returns the files necessary for an 'ar' invocation. May be empty if the CROSSTOOL file does not
* define ar_files.
*/
public NestedSet getArFiles() {
return arFiles;
}
@Override
public Depset getArFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getArFiles());
}
/** Returns the files necessary for linking, including the files needed for libc. */
public NestedSet getLinkerFiles() {
return linkerFiles;
}
@Override
public Depset getLinkerFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getLinkerFiles());
}
public NestedSet getDwpFiles() {
return dwpFiles;
}
@Override
public Depset getDwpFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getDwpFiles());
}
/** Returns the files necessary for capturing code coverage. */
public NestedSet getCoverageFiles() {
return coverageFiles;
}
@Override
public Depset getCoverageFilesForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Depset.of(Artifact.class, getCoverageFiles());
}
public NestedSet getLibcLink(CppConfiguration cppConfiguration) {
if (cppConfiguration.equals(getCppConfigurationEvenThoughItCanBeDifferentThanWhatTargetHas())) {
return libcLink;
} else {
return targetLibcLink;
}
}
@Override
public String getArtifactNameForCategory(
String category, String outputName, StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return toolchainFeatures.getArtifactNameForCategory(
ArtifactCategory.valueOf(category), outputName);
}
/**
* Returns true if the featureConfiguration includes statically linking the cpp runtimes.
*
* @param featureConfiguration the relevant FeatureConfiguration.
*/
public boolean shouldStaticallyLinkCppRuntimes(FeatureConfiguration featureConfiguration) {
return featureConfiguration.isEnabled(CppRuleClasses.STATIC_LINK_CPP_RUNTIMES);
}
/** Returns the static runtime libraries. */
public NestedSet getStaticRuntimeLinkInputs(FeatureConfiguration featureConfiguration)
throws EvalException {
if (shouldStaticallyLinkCppRuntimes(featureConfiguration)) {
if (staticRuntimeLinkInputs == null) {
throw Starlark.errorf(
"Toolchain supports embedded runtimes, but didn't provide static_runtime_lib"
+ " attribute.");
}
return staticRuntimeLinkInputs;
} else {
return NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
}
/** Returns the dynamic runtime libraries. */
public NestedSet getDynamicRuntimeLinkInputs(FeatureConfiguration featureConfiguration)
throws EvalException {
if (shouldStaticallyLinkCppRuntimes(featureConfiguration)) {
if (dynamicRuntimeLinkInputs == null) {
throw new EvalException(
"Toolchain supports embedded runtimes, but didn't provide dynamic_runtime_lib"
+ " attribute.");
}
return dynamicRuntimeLinkInputs;
} else {
return NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
}
/**
* 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 exec configuration in the 'bin'
* directory.
*/
public PathFragment getDynamicRuntimeSolibDir() {
return dynamicRuntimeSolibDir;
}
@Override
public String getDynamicRuntimeSolibDirForStarlark() {
return getDynamicRuntimeSolibDir().getPathString();
}
/** Returns the {@code CcCompilationContext} for the toolchain. */
public CcCompilationContext getCcCompilationContext() {
return ccInfo.getCcCompilationContext();
}
/** Returns the {@code CcInfo} for the toolchain. */
public CcInfo getCcInfo() {
return ccInfo;
}
/** Whether the toolchains supports parameter files. */
public boolean supportsParamFiles() {
return supportsParamFiles;
}
/** Returns the configured features of the toolchain. */
@Nullable
public CcToolchainFeatures getFeatures() {
return toolchainFeatures;
}
@Override
public Label getCcToolchainLabel() {
return ccToolchainLabel;
}
/**
* Returns the run time sysroot, which is where the dynamic linker and system libraries are found
* at runtime. This is usually an absolute path. If the toolchain compiler does not support
* sysroots, then this method returns null.
*/
public PathFragment getRuntimeSysroot() {
return runtimeSysroot;
}
@Override
@Nullable
public String getRuntimeSysrootForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
PathFragment runtimeSysroot = getRuntimeSysroot();
return runtimeSysroot != null ? runtimeSysroot.getPathString() : null;
}
/**
* Return the name of the directory (relative to the bin directory) that holds mangled links to
* shared libraries. This name is always set to the '{@code _solib_}.
*/
public String getSolibDirectory() {
return solibDirectory;
}
@Override
public String getSolibDirectoryForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return getSolibDirectory();
}
/** Returns whether the toolchain supports dynamic linking. */
public boolean supportsDynamicLinker(FeatureConfiguration featureConfiguration) {
return featureConfiguration.isEnabled(CppRuleClasses.SUPPORTS_DYNAMIC_LINKER);
}
/** Returns whether the toolchain supports the --start-lib/--end-lib options. */
public boolean supportsStartEndLib(FeatureConfiguration featureConfiguration) {
return featureConfiguration.isEnabled(CppRuleClasses.SUPPORTS_START_END_LIB);
}
/** Returns whether this toolchain supports interface shared libraries. */
public boolean supportsInterfaceSharedLibraries(FeatureConfiguration featureConfiguration) {
return featureConfiguration.isEnabled(CppRuleClasses.SUPPORTS_INTERFACE_SHARED_LIBRARIES);
}
/**
* Return CppConfiguration instance that was used to configure CcToolchain.
*
* If C++ rules use platforms/toolchains without
* https://github.com/bazelbuild/proposals/blob/master/designs/2019-02-12-toolchain-transitions.md
* implemented, CcToolchain is analyzed in the exec configuration. This configuration is not what
* should be used by rules using the toolchain. This method should only be used to access stuff
* from CppConfiguration that is identical between exec and target (e.g. incompatible flag
* values). Don't use it if you don't know what you're doing.
*
*
Once toolchain transitions are implemented, we can safely use the CppConfiguration from the
* toolchain in rules.
*/
CppConfiguration getCppConfigurationEvenThoughItCanBeDifferentThanWhatTargetHas() {
return cppConfiguration;
}
/** Return context-sensitive fdo instrumentation path. */
public String getCSFdoInstrument() {
return cppConfiguration.getCSFdoInstrument();
}
/** Returns build variables to be templated into the crosstool. */
public CcToolchainVariables getBuildVariables(
StarlarkThread thread, BuildOptions buildOptions, CppConfiguration cppConfiguration)
throws EvalException, InterruptedException {
if (!cppConfiguration.enableCcToolchainResolution()) {
return buildVariables;
}
// With platforms, cc toolchain is analyzed in the exec configuration, so we can only reuse the
// same build variables instance if the inputs to the construction match.
PathFragment sysroot = getSysrootPathFragment(cppConfiguration);
String minOsVersion = cppConfiguration.getMinimumOsVersion();
if (Objects.equals(sysroot, this.sysroot)
&& Objects.equals(minOsVersion, this.cppConfiguration.getMinimumOsVersion())
&& (ccToolchainBuildVariablesFunc.getName().equals("cc_toolchain_build_variables")
|| buildOptions.equals(this.buildOptions))) {
return buildVariables;
}
// With platforms, cc toolchain is analyzed in the exec configuration, so we cannot reuse
// build variables instance.
AppleConfiguration appleConfiguration = new AppleConfiguration(buildOptions);
ApplePlatform platform = appleConfiguration.getSingleArchPlatform();
Object ccToolchainVariables =
Starlark.call(
thread,
ccToolchainBuildVariablesFunc,
ImmutableList.of(
/* platform */ platform,
/* cpu */ buildOptions.get(CoreOptions.class).cpu,
/* cpp_config */ cppConfiguration,
/* sysroot */ (sysroot != null ? sysroot.getPathString() : Starlark.NONE)),
ImmutableMap.of());
return (CcToolchainVariables) ccToolchainVariables;
}
@Override
public CcToolchainVariables getBuildVariablesForStarlark(
StarlarkRuleContext starlarkRuleContext,
CppConfiguration cppConfiguration,
StarlarkThread thread)
throws EvalException, InterruptedException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return getBuildVariables(
starlarkRuleContext.getRuleContext().getStarlarkThread(),
starlarkRuleContext.getRuleContext().getConfiguration().getOptions(),
cppConfiguration);
}
/**
* 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(CppConfiguration cppConfiguration) {
if (cppConfiguration.equals(getCppConfigurationEvenThoughItCanBeDifferentThanWhatTargetHas())) {
return builtinIncludeFiles;
} else {
return targetBuiltinIncludeFiles;
}
}
/**
* 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 grep-includes tool which is needing during linking because of linkstamping. */
@Nullable
public Artifact getGrepIncludes() {
return grepIncludes;
}
/** Returns the tool that builds interface libraries from dynamic libraries. */
public Artifact getInterfaceSoBuilder() {
return interfaceSoBuilder;
}
@Override
@Nullable
public String getSysroot() {
return sysroot != null ? sysroot.getPathString() : null;
}
public PathFragment getSysrootPathFragment(CppConfiguration cppConfiguration) {
if (cppConfiguration.equals(getCppConfigurationEvenThoughItCanBeDifferentThanWhatTargetHas())) {
return sysroot;
} else {
return targetSysroot;
}
}
/**
* Returns the abi we're using, which is a gcc version. E.g.: "gcc-3.4". Note that in practice we
* might be using gcc-3.4 as ABI even when compiling with gcc-4.1.0, because ABIs are backwards
* compatible.
*/
// TODO(bazel-team): The javadoc should clarify how this is used in Blaze.
public String getAbi() {
return abi;
}
@Override
public String getAbiForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return getAbi();
}
/**
* Returns the glibc version used by the abi we're using. This is a glibc version number (e.g.,
* "2.2.2"). Note that in practice we might be using glibc 2.2.2 as ABI even when compiling with
* gcc-4.2.2, gcc-4.3.1, or gcc-4.4.0 (which use glibc 2.3.6), because ABIs are backwards
* compatible.
*/
// TODO(bazel-team): The javadoc should clarify how this is used in Blaze.
public String getAbiGlibcVersion() {
return abiGlibcVersion;
}
@Override
public String getAbiGlibcVersionForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return getAbiGlibcVersion();
}
@Override
public String getCrosstoolTopPathForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return crosstoolTopPathFragment.getPathString();
}
/** Returns the compiler version string (e.g. "gcc-4.1.1"). */
@Override
public String getCompiler() {
return compiler;
}
/** Returns the libc version string (e.g. "glibc-2.2.2"). */
@Override
public String getTargetLibc() {
return targetLibc;
}
/** Returns the target architecture using blaze-specific constants (e.g. "piii"). */
@Override
public String getTargetCpu() {
return targetCpu;
}
/**
* Returns a map of additional make variables for use by {@link BuildConfigurationValue}. These
* are to used to allow some build rules to avoid the limits on stack frame sizes and
* variable-length arrays.
*
* The returned map must contain an entry for {@code STACK_FRAME_UNLIMITED}, though the entry
* may be an empty string.
*/
public ImmutableMap getAdditionalMakeVariables() {
return additionalMakeVariables;
}
@Override
public Dict getAdditionalMakeVariablesForStarlark(StarlarkThread thread)
throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return Dict.immutableCopyOf(getAdditionalMakeVariables());
}
/**
* Returns the legacy value of the CC_FLAGS Make variable.
*
* @deprecated Use the CC_FLAGS from feature configuration instead.
*/
// TODO(b/65151735): Remove when cc_flags is entirely from features.
@Deprecated
public String getLegacyCcFlagsMakeVariable() {
return legacyCcFlagsMakeVariable;
}
@Override
public String getLegacyCcFlagsMakeVariableForStarlark(StarlarkThread thread)
throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return legacyCcFlagsMakeVariable;
}
public FdoContext getFdoContext() {
return fdoContext;
}
@Override
public FdoContext getFdoContextForStarlark(StarlarkThread thread) throws EvalException {
CcModule.checkPrivateStarlarkificationAllowlist(thread);
return fdoContext;
}
@Override
public String objcopyExecutable() {
return objcopyExecutable;
}
@Override
public String compilerExecutable() {
return compilerExecutable;
}
@Override
public String preprocessorExecutable() {
return preprocessorExecutable;
}
@Override
public String nmExecutable() {
return nmExecutable;
}
@Override
public String objdumpExecutable() {
return objdumpExecutable;
}
@Override
public String arExecutable() {
return arExecutable;
}
@Override
public String stripExecutable() {
return stripExecutable;
}
@Override
public String ldExecutable() {
return ldExecutable;
}
@Override
public String gcovExecutable() {
return gcovExecutable;
}
/**
* Unused, for compatibility with things internal to Google.
*
* @deprecated use platforms
*/
@Deprecated
public String getTargetOS() {
return targetOS;
}
/** Returns the GNU System Name */
@Override
public String getTargetGnuSystemName() {
return targetSystemName;
}
/** Returns the architecture component of the GNU System Name */
public String getGnuSystemArch() {
if (targetSystemName.indexOf('-') == -1) {
return targetSystemName;
}
return targetSystemName.substring(0, targetSystemName.indexOf('-'));
}
// Not all of CcToolchainProvider is exposed to Starlark, which makes implementing deep equality
// impossible: if Java-only parts are considered, the behavior is surprising in Starlark, 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);
}
public boolean isToolConfiguration() {
return isToolConfiguration;
}
public LicensesProvider getLicensesProvider() {
return licensesProvider;
}
public PathFragment getDefaultSysroot() {
return defaultSysroot;
}
public boolean requireCtxInConfigureFeatures() {
return getCppConfigurationEvenThoughItCanBeDifferentThanWhatTargetHas()
.requireCtxInConfigureFeatures();
}
@VisibleForTesting
NestedSet getStaticRuntimeLibForTesting() {
return staticRuntimeLinkInputs;
}
@VisibleForTesting
NestedSet getDynamicRuntimeLibForTesting() {
return dynamicRuntimeLinkInputs;
}
public PackageSpecificationProvider getAllowlistForLayeringCheck() {
return allowlistForLayeringCheck;
}
public PackageSpecificationProvider getAllowlistForLooseHeaderCheck() {
return allowListForLooseHeaderCheck;
}
}