private void init() throws InterruptedException {
EvaluationResult<SkyValue> result;
try (AutoProfiler p = AutoProfiler.logged("evaluation and walkable graph", LOG)) {
result =
graphFactory.prepareAndGet(
universeScope, parserPrefix, loadingPhaseThreads, eventHandler);
}
graph = result.getWalkableGraph();
SkyKey universeKey = graphFactory.getUniverseKey(universeScope, parserPrefix);
universeTargetPatternKeys =
PrepareDepsOfPatternsFunction.getTargetPatternKeys(
PrepareDepsOfPatternsFunction.getSkyKeys(universeKey, eventHandler));
// The prepareAndGet call above evaluates a single PrepareDepsOfPatterns SkyKey.
// We expect to see either a single successfully evaluated value or a cycle in the result.
Collection<SkyValue> values = result.values();
if (!values.isEmpty()) {
Preconditions.checkState(
values.size() == 1,
"Universe query \"%s\" returned multiple" + " values unexpectedly (%s values in result)",
universeScope,
values.size());
Preconditions.checkNotNull(result.get(universeKey), result);
} else {
// No values in the result, so there must be an error. We expect the error to be a cycle.
boolean foundCycle = !Iterables.isEmpty(result.getError().getCycleInfo());
Preconditions.checkState(
foundCycle,
"Universe query \"%s\" failed with non-cycle error: %s",
universeScope,
result.getError());
}
}
private TransitiveLipoInfoProvider collectTransitiveLipoInfo(CcCompilationOutputs outputs) {
if (CppHelper.getFdoSupport(ruleContext).getFdoRoot() == null) {
return TransitiveLipoInfoProvider.EMPTY;
}
NestedSetBuilder<IncludeScannable> scannableBuilder = NestedSetBuilder.stableOrder();
// TODO(bazel-team): Only fetch the STL prerequisite in one place.
TransitiveInfoCollection stl = ruleContext.getPrerequisite(":stl", Mode.TARGET);
if (stl != null) {
TransitiveLipoInfoProvider provider = stl.getProvider(TransitiveLipoInfoProvider.class);
if (provider != null) {
scannableBuilder.addTransitive(provider.getTransitiveIncludeScannables());
}
}
for (TransitiveLipoInfoProvider dep :
AnalysisUtils.getProviders(deps, TransitiveLipoInfoProvider.class)) {
scannableBuilder.addTransitive(dep.getTransitiveIncludeScannables());
}
for (IncludeScannable scannable : outputs.getLipoScannables()) {
Preconditions.checkState(scannable.getIncludeScannerSources().size() == 1);
scannableBuilder.add(scannable);
}
return new TransitiveLipoInfoProvider(scannableBuilder.build());
}
private NodeEntry getEntryForValue(SkyKey key) {
NodeEntry entry =
Preconditions.checkNotNull(
graph.getBatch(null, Reason.WALKABLE_GRAPH_VALUE, ImmutableList.of(key)).get(key), key);
Preconditions.checkState(entry.isDone(), "%s %s", key, entry);
return entry;
}
/**
* Create a GlobValue wrapping {@code matches}. {@code matches} must have order {@link
* Order#STABLE_ORDER}.
*/
public GlobValue(NestedSet<PathFragment> matches) {
this.matches = Preconditions.checkNotNull(matches);
Preconditions.checkState(
matches.getOrder() == Order.STABLE_ORDER,
"Only STABLE_ORDER is supported, but got %s",
matches.getOrder());
}
public XcodeProvider build() {
Preconditions.checkState(
!testHost.isPresent() || (productType == XcodeProductType.UNIT_TEST),
"%s product types cannot have a test host (test host: %s).",
productType,
testHost);
return new XcodeProvider(this);
}
/**
* Like {@link #lookup(String)}, but instead of throwing an exception in the case where <code>
* varname</code> is not defined, <code>defaultValue</code> is returned instead.
*/
public Object lookup(String varname, Object defaultValue) {
Preconditions.checkState(!isSkylark);
try {
return lookup(varname);
} catch (NoSuchVariableException e) {
return defaultValue;
}
}
@Nullable
private AspectValue createAspect(
Environment env,
AspectKey key,
ConfiguredAspectFactory aspectFactory,
RuleConfiguredTarget associatedTarget,
Set<ConfigMatchingProvider> configConditions,
ListMultimap<Attribute, ConfiguredTarget> directDeps,
NestedSetBuilder<Package> transitivePackages)
throws AspectFunctionException, InterruptedException {
SkyframeBuildView view = buildViewProvider.getSkyframeBuildView();
BuildConfiguration configuration = associatedTarget.getConfiguration();
StoredEventHandler events = new StoredEventHandler();
CachingAnalysisEnvironment analysisEnvironment =
view.createAnalysisEnvironment(key, false, events, env, configuration);
if (env.valuesMissing()) {
return null;
}
ConfiguredAspect configuredAspect =
view.getConfiguredTargetFactory()
.createAspect(
analysisEnvironment,
associatedTarget,
aspectFactory,
key.getAspect(),
directDeps,
configConditions,
view.getHostConfiguration(associatedTarget.getConfiguration()));
events.replayOn(env.getListener());
if (events.hasErrors()) {
analysisEnvironment.disable(associatedTarget.getTarget());
throw new AspectFunctionException(
new AspectCreationException(
"Analysis of target '" + associatedTarget.getLabel() + "' failed; build aborted"));
}
Preconditions.checkState(
!analysisEnvironment.hasErrors(), "Analysis environment hasError() but no errors reported");
if (env.valuesMissing()) {
return null;
}
analysisEnvironment.disable(associatedTarget.getTarget());
Preconditions.checkNotNull(configuredAspect);
return new AspectValue(
key,
associatedTarget.getLabel(),
associatedTarget.getTarget().getLocation(),
configuredAspect,
ImmutableList.copyOf(analysisEnvironment.getRegisteredActions()),
transitivePackages.build());
}
/** Configure a BaseFunction from a @SkylarkSignature annotation */
public void configure(SkylarkSignature annotation) {
Preconditions.checkState(!isConfigured()); // must not be configured yet
this.paramDoc = new ArrayList<>();
this.signature =
SkylarkSignatureProcessor.getSignature(
getName(), annotation, unconfiguredDefaultValues, paramDoc, getEnforcedArgumentTypes());
this.objectType = annotation.objectType().equals(Object.class) ? null : annotation.objectType();
configure();
}
@Override
public Map<SkyKey, Iterable<SkyKey>> getDirectDeps(Iterable<SkyKey> keys) {
Map<SkyKey, NodeEntry> entries = graph.getBatch(null, Reason.WALKABLE_GRAPH_DEPS, keys);
Map<SkyKey, Iterable<SkyKey>> result = new HashMap<>(entries.size());
for (Entry<SkyKey, NodeEntry> entry : entries.entrySet()) {
Preconditions.checkState(entry.getValue().isDone(), entry);
result.put(entry.getKey(), entry.getValue().getDirectDeps());
}
return result;
}
/**
* The outer calling convention to a BaseFunction.
*
* @param args a list of all positional arguments (as in *starArg)
* @param kwargs a map for key arguments (as in **kwArgs)
* @param ast the expression for this function's definition
* @param env the Environment in the function is called
* @return the value resulting from evaluating the function with the given arguments
* @throws EvalException-s containing source information.
*/
public Object call(
List<Object> args,
@Nullable Map<String, Object> kwargs,
@Nullable FuncallExpression ast,
Environment env)
throws EvalException, InterruptedException {
Preconditions.checkState(isConfigured(), "Function %s was not configured", getName());
// ast is null when called from Java (as there's no Skylark call site).
Location loc = ast == null ? Location.BUILTIN : ast.getLocation();
Object[] arguments = processArguments(args, kwargs, loc);
canonicalizeArguments(arguments, loc);
return call(arguments, ast, env);
}
private static void assertSaneAnalysisError(ErrorInfo errorInfo, SkyKey key) {
Throwable cause = errorInfo.getException();
if (cause != null) {
// We should only be trying to configure targets when the loading phase succeeds, meaning
// that the only errors should be analysis errors.
Preconditions.checkState(
cause instanceof ConfiguredValueCreationException
|| cause instanceof ActionConflictException
// For top-level aspects
|| cause instanceof AspectCreationException
|| cause instanceof SkylarkImportFailedException
// Only if we run the reduced loading phase and then analyze with --nokeep_going.
|| cause instanceof NoSuchTargetException
|| cause instanceof NoSuchPackageException,
"%s -> %s",
key,
errorInfo);
}
}
public SkyQueryEnvironment(
boolean keepGoing,
boolean strictScope,
int loadingPhaseThreads,
Predicate<Label> labelFilter,
EventHandler eventHandler,
Set<Setting> settings,
Iterable<QueryFunction> extraFunctions,
String parserPrefix,
WalkableGraphFactory graphFactory,
List<String> universeScope,
PathPackageLocator pkgPath) {
super(keepGoing, strictScope, labelFilter, eventHandler, settings, extraFunctions);
this.loadingPhaseThreads = loadingPhaseThreads;
this.graphFactory = graphFactory;
this.pkgPath = pkgPath;
this.universeScope = Preconditions.checkNotNull(universeScope);
this.parserPrefix = parserPrefix;
Preconditions.checkState(
!universeScope.isEmpty(), "No queries can be performed with an empty universe");
}
/**
* Invokes the appropriate constructor to create a {@link ConfiguredTarget} instance.
*
* <p>For use in {@code ConfiguredTargetFunction}.
*
* <p>Returns null if Skyframe deps are missing or upon certain errors.
*/
@Nullable
ConfiguredTarget createConfiguredTarget(
Target target,
BuildConfiguration configuration,
CachingAnalysisEnvironment analysisEnvironment,
ListMultimap<Attribute, ConfiguredTarget> prerequisiteMap,
Set<ConfigMatchingProvider> configConditions)
throws InterruptedException {
Preconditions.checkState(
enableAnalysis, "Already in execution phase %s %s", target, configuration);
Preconditions.checkNotNull(analysisEnvironment);
Preconditions.checkNotNull(target);
Preconditions.checkNotNull(prerequisiteMap);
return factory.createConfiguredTarget(
analysisEnvironment,
artifactFactory,
target,
configuration,
getHostConfiguration(configuration),
prerequisiteMap,
configConditions);
}
/**
* If this instance is configured with DEPEND_ON_EXTERNAL_PKG and rootedPath is a file that isn't
* under a package root then this adds a dependency on the //external package. If the action is
* ERROR_OUT, it will throw an error instead.
*/
public void maybeHandleExternalFile(RootedPath rootedPath, SkyFunction.Environment env)
throws FileOutsidePackageRootsException {
if (isInternal(rootedPath, pkgLocator.get())) {
return;
}
externalFileSeen = true;
if (externalFileAction == ExternalFileAction.ERROR_OUT) {
throw new FileOutsidePackageRootsException(rootedPath);
}
// The outputBase may be null if we're not actually running a build.
Path outputBase = pkgLocator.get().getOutputBase();
if (outputBase != null
&& !rootedPath
.asPath()
.startsWith(pkgLocator.get().getOutputBase().getRelative(Label.EXTERNAL_PATH_PREFIX))) {
return;
}
// For files that are under $OUTPUT_BASE/external, add a dependency on the //external package
// so that if the WORKSPACE file changes, the File/DirectoryStateValue will be re-evaluated.
//
// Note that:
// - We don't add a dependency on the parent directory at the package root boundary, so
// the only transitive dependencies from files inside the package roots to external files
// are through symlinks. So the upwards transitive closure of external files is small.
// - The only way other than external repositories for external source files to get into the
// skyframe graph in the first place is through symlinks outside the package roots, which we
// neither want to encourage nor optimize for since it is not common. So the set of external
// files is small.
PackageValue pkgValue =
(PackageValue) env.getValue(PackageValue.key(Label.EXTERNAL_PACKAGE_IDENTIFIER));
if (pkgValue == null) {
return;
}
Preconditions.checkState(!pkgValue.getPackage().containsErrors());
}
/**
* Get SkyKeys for the FileValues for the given {@code pathFragments}. To do this, we look for a
* package lookup node for each path fragment, since package lookup nodes contain the "root" of a
* package. The returned SkyKeys correspond to FileValues that may not exist in the graph.
*/
private Collection<SkyKey> getSkyKeysForFileFragments(Iterable<PathFragment> pathFragments) {
Set<SkyKey> result = new HashSet<>();
Multimap<PathFragment, PathFragment> currentToOriginal = ArrayListMultimap.create();
for (PathFragment pathFragment : pathFragments) {
currentToOriginal.put(pathFragment, pathFragment);
}
while (!currentToOriginal.isEmpty()) {
Map<SkyKey, PathFragment> keys = new HashMap<>();
for (PathFragment pathFragment : currentToOriginal.keySet()) {
keys.put(
PackageLookupValue.key(PackageIdentifier.createInDefaultRepo(pathFragment)),
pathFragment);
}
Map<SkyKey, SkyValue> lookupValues = graph.getSuccessfulValues(keys.keySet());
for (Map.Entry<SkyKey, SkyValue> entry : lookupValues.entrySet()) {
PackageLookupValue packageLookupValue = (PackageLookupValue) entry.getValue();
if (packageLookupValue.packageExists()) {
PathFragment dir = keys.get(entry.getKey());
Collection<PathFragment> originalFiles = currentToOriginal.get(dir);
Preconditions.checkState(!originalFiles.isEmpty(), entry);
for (PathFragment fileName : originalFiles) {
result.add(
FileValue.key(RootedPath.toRootedPath(packageLookupValue.getRoot(), fileName)));
}
currentToOriginal.removeAll(dir);
}
}
Multimap<PathFragment, PathFragment> newCurrentToOriginal = ArrayListMultimap.create();
for (PathFragment pathFragment : currentToOriginal.keySet()) {
PathFragment parent = pathFragment.getParentDirectory();
if (parent != null) {
newCurrentToOriginal.putAll(parent, currentToOriginal.get(pathFragment));
}
}
currentToOriginal = newCurrentToOriginal;
}
return result;
}
public void importSymbol(String importString, Identifier symbol, String nameInLoadedFile)
throws NoSuchVariableException, LoadFailedException {
Preconditions.checkState(isGlobal()); // loading is only allowed at global scope.
if (!importedExtensions.containsKey(importString)) {
throw new LoadFailedException(importString);
}
Extension ext = importedExtensions.get(importString);
// TODO(bazel-team): Throw a LoadFailedException instead, with an appropriate message.
// Throwing a NoSuchVariableException is backward compatible, but backward.
if (!ext.containsKey(nameInLoadedFile)) {
throw new NoSuchVariableException(nameInLoadedFile);
}
Object value = ext.get(nameInLoadedFile);
try {
update(symbol.getName(), value);
} catch (EvalException e) {
throw new LoadFailedException(importString);
}
}
@Override
public ConfiguredTarget create(RuleContext ruleContext)
throws RuleErrorException, InterruptedException {
TransitiveInfoCollection lipoContextCollector =
ruleContext.getPrerequisite(":lipo_context_collector", Mode.DONT_CHECK);
if (lipoContextCollector != null
&& lipoContextCollector.getProvider(LipoContextProvider.class) == null) {
ruleContext.ruleError("--lipo_context must point to a cc_binary or a cc_test rule");
return null;
}
CppConfiguration cppConfiguration =
Preconditions.checkNotNull(ruleContext.getFragment(CppConfiguration.class));
Path fdoZip =
ruleContext.getConfiguration().getCompilationMode() == CompilationMode.OPT
? cppConfiguration.getFdoZip()
: null;
SkyKey fdoKey =
FdoSupportValue.key(
cppConfiguration.getLipoMode(), fdoZip, cppConfiguration.getFdoInstrument());
SkyFunction.Environment skyframeEnv = ruleContext.getAnalysisEnvironment().getSkyframeEnv();
FdoSupportValue fdoSupport;
try {
fdoSupport =
(FdoSupportValue)
skyframeEnv.getValueOrThrow(fdoKey, FdoException.class, IOException.class);
} catch (FdoException | IOException e) {
ruleContext.ruleError("cannot initialize FDO: " + e.getMessage());
return null;
}
if (skyframeEnv.valuesMissing()) {
return null;
}
final Label label = ruleContext.getLabel();
final NestedSet<Artifact> crosstool =
ruleContext
.getPrerequisite("all_files", Mode.HOST)
.getProvider(FileProvider.class)
.getFilesToBuild();
final NestedSet<Artifact> crosstoolMiddleman = getFiles(ruleContext, "all_files");
final NestedSet<Artifact> compile = getFiles(ruleContext, "compiler_files");
final NestedSet<Artifact> strip = getFiles(ruleContext, "strip_files");
final NestedSet<Artifact> objcopy = getFiles(ruleContext, "objcopy_files");
final NestedSet<Artifact> link = getFiles(ruleContext, "linker_files");
final NestedSet<Artifact> dwp = getFiles(ruleContext, "dwp_files");
final NestedSet<Artifact> libcLink = inputsForLibc(ruleContext);
String purposePrefix = Actions.escapeLabel(label) + "_";
String runtimeSolibDirBase = "_solib_" + "_" + Actions.escapeLabel(label);
final PathFragment runtimeSolibDir =
ruleContext.getConfiguration().getBinFragment().getRelative(runtimeSolibDirBase);
// Static runtime inputs.
TransitiveInfoCollection staticRuntimeLibDep =
selectDep(ruleContext, "static_runtime_libs", cppConfiguration.getStaticRuntimeLibsLabel());
final NestedSet<Artifact> staticRuntimeLinkInputs;
final Artifact staticRuntimeLinkMiddleman;
if (cppConfiguration.supportsEmbeddedRuntimes()) {
staticRuntimeLinkInputs =
staticRuntimeLibDep.getProvider(FileProvider.class).getFilesToBuild();
} else {
staticRuntimeLinkInputs = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
if (!staticRuntimeLinkInputs.isEmpty()) {
NestedSet<Artifact> staticRuntimeLinkMiddlemanSet =
CompilationHelper.getAggregatingMiddleman(
ruleContext, purposePrefix + "static_runtime_link", staticRuntimeLibDep);
staticRuntimeLinkMiddleman =
staticRuntimeLinkMiddlemanSet.isEmpty()
? null
: Iterables.getOnlyElement(staticRuntimeLinkMiddlemanSet);
} else {
staticRuntimeLinkMiddleman = null;
}
Preconditions.checkState(
(staticRuntimeLinkMiddleman == null) == staticRuntimeLinkInputs.isEmpty());
// Dynamic runtime inputs.
TransitiveInfoCollection dynamicRuntimeLibDep =
selectDep(
ruleContext, "dynamic_runtime_libs", cppConfiguration.getDynamicRuntimeLibsLabel());
final NestedSet<Artifact> dynamicRuntimeLinkInputs;
final Artifact dynamicRuntimeLinkMiddleman;
if (cppConfiguration.supportsEmbeddedRuntimes()) {
NestedSetBuilder<Artifact> dynamicRuntimeLinkInputsBuilder = NestedSetBuilder.stableOrder();
for (Artifact artifact :
dynamicRuntimeLibDep.getProvider(FileProvider.class).getFilesToBuild()) {
if (CppHelper.SHARED_LIBRARY_FILETYPES.matches(artifact.getFilename())) {
dynamicRuntimeLinkInputsBuilder.add(
SolibSymlinkAction.getCppRuntimeSymlink(
ruleContext, artifact, runtimeSolibDirBase, ruleContext.getConfiguration()));
} else {
dynamicRuntimeLinkInputsBuilder.add(artifact);
}
}
dynamicRuntimeLinkInputs = dynamicRuntimeLinkInputsBuilder.build();
} else {
dynamicRuntimeLinkInputs = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
if (!dynamicRuntimeLinkInputs.isEmpty()) {
List<Artifact> dynamicRuntimeLinkMiddlemanSet =
CppHelper.getAggregatingMiddlemanForCppRuntimes(
ruleContext,
purposePrefix + "dynamic_runtime_link",
dynamicRuntimeLibDep,
runtimeSolibDirBase,
ruleContext.getConfiguration());
dynamicRuntimeLinkMiddleman =
dynamicRuntimeLinkMiddlemanSet.isEmpty()
? null
: Iterables.getOnlyElement(dynamicRuntimeLinkMiddlemanSet);
} else {
dynamicRuntimeLinkMiddleman = null;
}
Preconditions.checkState(
(dynamicRuntimeLinkMiddleman == null) == dynamicRuntimeLinkInputs.isEmpty());
CppCompilationContext.Builder contextBuilder = new CppCompilationContext.Builder(ruleContext);
CppModuleMap moduleMap = createCrosstoolModuleMap(ruleContext);
if (moduleMap != null) {
contextBuilder.setCppModuleMap(moduleMap);
}
final CppCompilationContext context = contextBuilder.build();
boolean supportsParamFiles = ruleContext.attributes().get("supports_param_files", BOOLEAN);
boolean supportsHeaderParsing =
ruleContext.attributes().get("supports_header_parsing", BOOLEAN);
NestedSetBuilder<Pair<String, String>> coverageEnvironment = NestedSetBuilder.compileOrder();
coverageEnvironment.add(
Pair.of("COVERAGE_GCOV_PATH", cppConfiguration.getGcovExecutable().getPathString()));
if (cppConfiguration.getFdoInstrument() != null) {
coverageEnvironment.add(
Pair.of("FDO_DIR", cppConfiguration.getFdoInstrument().getPathString()));
}
CcToolchainProvider provider =
new CcToolchainProvider(
cppConfiguration,
crosstool,
fullInputsForCrosstool(ruleContext, crosstoolMiddleman),
compile,
strip,
objcopy,
fullInputsForLink(ruleContext, link),
dwp,
libcLink,
staticRuntimeLinkInputs,
staticRuntimeLinkMiddleman,
dynamicRuntimeLinkInputs,
dynamicRuntimeLinkMiddleman,
runtimeSolibDir,
context,
supportsParamFiles,
supportsHeaderParsing,
getBuildVariables(ruleContext),
getBuiltinIncludes(ruleContext),
coverageEnvironment.build());
RuleConfiguredTargetBuilder builder =
new RuleConfiguredTargetBuilder(ruleContext)
.add(CcToolchainProvider.class, provider)
.add(FdoSupportProvider.class, new FdoSupportProvider(fdoSupport.getFdoSupport()))
.setFilesToBuild(new NestedSetBuilder<Artifact>(Order.STABLE_ORDER).build())
.add(RunfilesProvider.class, RunfilesProvider.simple(Runfiles.EMPTY));
// If output_license is specified on the cc_toolchain rule, override the transitive licenses
// with that one. This is necessary because cc_toolchain is used in the target configuration,
// but it is sort-of-kind-of a tool, but various parts of it are linked into the output...
// ...so we trust the judgment of the author of the cc_toolchain rule to figure out what
// licenses should be propagated to C++ targets.
License outputLicense = ruleContext.getRule().getToolOutputLicense(ruleContext.attributes());
if (outputLicense != null && outputLicense != License.NO_LICENSE) {
final NestedSet<TargetLicense> license =
NestedSetBuilder.create(
Order.STABLE_ORDER, new TargetLicense(ruleContext.getLabel(), outputLicense));
LicensesProvider licensesProvider =
new LicensesProvider() {
@Override
public NestedSet<TargetLicense> getTransitiveLicenses() {
return license;
}
};
builder.add(LicensesProvider.class, licensesProvider);
}
return builder.build();
}
/** Configure a function based on its signature */
protected void configure() {
// this function is called after the signature was initialized
Preconditions.checkState(signature != null);
enforcedArgumentTypes = signature.getTypes();
}
/** Declares imported extensions for load() statements. */
public Builder setImportedExtensions(Map<String, Extension> importMap) {
Preconditions.checkState(this.importedExtensions == null);
this.importedExtensions = importMap;
return this;
}
/** Sets an EventHandler for errors and warnings. */
public Builder setEventHandler(EventHandler eventHandler) {
Preconditions.checkState(this.eventHandler == null);
this.eventHandler = eventHandler;
return this;
}
/** Inherits global bindings from the given parent Frame. */
public Builder setGlobals(Frame parent) {
Preconditions.checkState(this.parent == null);
this.parent = parent;
return this;
}
/** Create the C++ compile and link actions, and the corresponding C++-related providers. */
public Info build() {
// Fail early if there is no lipo context collector on the rule - otherwise we end up failing
// in lipo optimization.
Preconditions.checkState(
// 'cc_inc_library' rules do not compile, and thus are not affected by LIPO.
ruleContext.getRule().getRuleClass().equals("cc_inc_library")
|| ruleContext.getRule().isAttrDefined(":lipo_context_collector", BuildType.LABEL));
if (checkDepsGenerateCpp) {
for (LanguageDependentFragment dep :
AnalysisUtils.getProviders(deps, LanguageDependentFragment.class)) {
LanguageDependentFragment.Checker.depSupportsLanguage(
ruleContext, dep, CppRuleClasses.LANGUAGE);
}
}
CppModel model = initializeCppModel();
CppCompilationContext cppCompilationContext = initializeCppCompilationContext(model);
model.setContext(cppCompilationContext);
boolean compileHeaderModules = featureConfiguration.isEnabled(CppRuleClasses.HEADER_MODULES);
Preconditions.checkState(
!compileHeaderModules || cppCompilationContext.getCppModuleMap() != null,
"All cc rules must support module maps.");
// Create compile actions (both PIC and non-PIC).
CcCompilationOutputs ccOutputs = model.createCcCompileActions();
if (!objectFiles.isEmpty() || !picObjectFiles.isEmpty()) {
// Merge the pre-compiled object files into the compiler outputs.
ccOutputs =
new CcCompilationOutputs.Builder()
.merge(ccOutputs)
.addLTOBitcodeFile(ccOutputs.getLtoBitcodeFiles())
.addObjectFiles(objectFiles)
.addPicObjectFiles(picObjectFiles)
.build();
}
// Create link actions (only if there are object files or if explicitly requested).
CcLinkingOutputs ccLinkingOutputs = CcLinkingOutputs.EMPTY;
if (emitLinkActionsIfEmpty || !ccOutputs.isEmpty()) {
// On some systems, the linker gives an error message if there are no input files. Even with
// the check above, this can still happen if there is a .nopic.o or .o files in srcs, but no
// other files. To fix that, we'd have to check for each link action individually.
//
// An additional pre-existing issue is that the header check tokens are dropped if we don't
// generate any link actions, effectively disabling header checking in some cases.
if (linkType.isStaticLibraryLink()) {
// TODO(bazel-team): This can't create the link action for a cc_binary yet.
ccLinkingOutputs = model.createCcLinkActions(ccOutputs);
}
}
CcLinkingOutputs originalLinkingOutputs = ccLinkingOutputs;
if (!(staticLibraries.isEmpty()
&& picStaticLibraries.isEmpty()
&& dynamicLibraries.isEmpty())) {
// Merge the pre-compiled libraries (static & dynamic) into the linker outputs.
ccLinkingOutputs =
new CcLinkingOutputs.Builder()
.merge(ccLinkingOutputs)
.addStaticLibraries(staticLibraries)
.addPicStaticLibraries(picStaticLibraries)
.addDynamicLibraries(dynamicLibraries)
.addExecutionDynamicLibraries(dynamicLibraries)
.build();
}
DwoArtifactsCollector dwoArtifacts = DwoArtifactsCollector.transitiveCollector(ccOutputs, deps);
Runfiles cppStaticRunfiles = collectCppRunfiles(ccLinkingOutputs, true);
Runfiles cppSharedRunfiles = collectCppRunfiles(ccLinkingOutputs, false);
// By very careful when adding new providers here - it can potentially affect a lot of rules.
// We should consider merging most of these providers into a single provider.
Map<Class<? extends TransitiveInfoProvider>, TransitiveInfoProvider> providers =
new LinkedHashMap<>();
providers.put(
CppRunfilesProvider.class, new CppRunfilesProvider(cppStaticRunfiles, cppSharedRunfiles));
providers.put(CppCompilationContext.class, cppCompilationContext);
providers.put(
CppDebugFileProvider.class,
new CppDebugFileProvider(
dwoArtifacts.getDwoArtifacts(), dwoArtifacts.getPicDwoArtifacts()));
providers.put(TransitiveLipoInfoProvider.class, collectTransitiveLipoInfo(ccOutputs));
Map<String, NestedSet<Artifact>> outputGroups = new TreeMap<>();
outputGroups.put(OutputGroupProvider.TEMP_FILES, getTemps(ccOutputs));
if (emitCompileProviders) {
boolean isLipoCollector =
ruleContext.getFragment(CppConfiguration.class).isLipoContextCollector();
boolean processHeadersInDependencies =
ruleContext.getFragment(CppConfiguration.class).processHeadersInDependencies();
boolean usePic = CppHelper.usePic(ruleContext, false);
outputGroups.put(
OutputGroupProvider.FILES_TO_COMPILE,
ccOutputs.getFilesToCompile(isLipoCollector, processHeadersInDependencies, usePic));
outputGroups.put(
OutputGroupProvider.COMPILATION_PREREQUISITES,
CcCommon.collectCompilationPrerequisites(ruleContext, cppCompilationContext));
}
// TODO(bazel-team): Maybe we can infer these from other data at the places where they are
// used.
if (emitCcNativeLibrariesProvider) {
providers.put(
CcNativeLibraryProvider.class,
new CcNativeLibraryProvider(collectNativeCcLibraries(ccLinkingOutputs)));
}
providers.put(
CcExecutionDynamicLibrariesProvider.class,
collectExecutionDynamicLibraryArtifacts(ccLinkingOutputs.getExecutionDynamicLibraries()));
boolean forcePic = ruleContext.getFragment(CppConfiguration.class).forcePic();
if (emitCcSpecificLinkParamsProvider) {
providers.put(
CcSpecificLinkParamsProvider.class,
new CcSpecificLinkParamsProvider(
createCcLinkParamsStore(ccLinkingOutputs, cppCompilationContext, forcePic)));
} else {
providers.put(
CcLinkParamsProvider.class,
new CcLinkParamsProvider(
createCcLinkParamsStore(ccLinkingOutputs, cppCompilationContext, forcePic)));
}
return new Info(
providers,
outputGroups,
ccOutputs,
ccLinkingOutputs,
originalLinkingOutputs,
cppCompilationContext);
}
/** Enables Skylark for code read in this Environment. */
public Builder setSkylark() {
Preconditions.checkState(!isSkylark);
isSkylark = true;
return this;
}
@Override
@ThreadCompatible
public void execute(ActionExecutionContext actionExecutionContext)
throws ActionExecutionException, InterruptedException {
Executor executor = actionExecutionContext.getExecutor();
// First, do a normal compilation, to generate the ".d" file. The generated object file is built
// to a temporary location (tempOutputFile) and ignored afterwards.
LOG.info("Generating " + getDotdFile());
CppCompileActionContext context = executor.getContext(actionContext);
CppCompileActionContext.Reply reply = null;
try {
// We delegate stdout/stderr to nowhere, i.e. same as redirecting to /dev/null.
reply = context.execWithReply(this, actionExecutionContext.withFileOutErr(new FileOutErr()));
} catch (ExecException e) {
// We ignore failures here (other than capturing the Distributor reply).
// The compilation may well fail (that's the whole point of negative compilation tests).
// We execute it here just for the side effect of generating the ".d" file.
reply = context.getReplyFromException(e, this);
if (reply == null) {
// This can only happen if the ExecException does not come from remote execution.
throw e.toActionExecutionException(
"Fake C++ Compilation of rule '" + getOwner().getLabel() + "'",
executor.getVerboseFailures(),
this);
}
}
IncludeScanningContext scanningContext = executor.getContext(IncludeScanningContext.class);
NestedSet<Artifact> discoveredInputs =
discoverInputsFromDotdFiles(
executor.getExecRoot(), scanningContext.getArtifactResolver(), reply);
reply = null; // Clear in-memory .d files early.
// Even cc_fake_binary rules need to properly declare their dependencies...
// In fact, they need to declare their dependencies even more than cc_binary rules do.
// CcCommonConfiguredTarget passes in an empty set of declaredIncludeDirs,
// so this check below will only allow inclusion of header files that are explicitly
// listed in the "srcs" of the cc_fake_binary or in the "srcs" of a cc_library that it
// depends on.
try {
validateInclusions(
discoveredInputs,
actionExecutionContext.getArtifactExpander(),
executor.getEventHandler());
} catch (ActionExecutionException e) {
// TODO(bazel-team): (2009) make this into an error, once most of the current warnings
// are fixed.
executor
.getEventHandler()
.handle(
Event.warn(
getOwner().getLocation(),
e.getMessage() + ";\n this warning may eventually become an error"));
}
updateActionInputs(discoveredInputs);
// Generate a fake ".o" file containing the command line needed to generate
// the real object file.
LOG.info("Generating " + outputFile);
// A cc_fake_binary rule generates fake .o files and a fake target file,
// which merely contain instructions on building the real target. We need to
// be careful to use a new set of output file names in the instructions, as
// to not overwrite the fake output files when someone tries to follow the
// instructions. As the real compilation is executed by the test from its
// runfiles directory (where writing is forbidden), we patch the command
// line to write to $TEST_TMPDIR instead.
final String outputPrefix = "$TEST_TMPDIR/";
String argv =
Joiner.on(' ')
.join(
Iterables.transform(
getArgv(outputFile.getExecPath()),
new Function<String, String>() {
@Override
public String apply(String input) {
String result = ShellEscaper.escapeString(input);
// Once -c and -o options are added into action_config, the argument of
// getArgv(outputFile.getExecPath()) won't be used anymore. There will
// always be
// -c <tempOutputFile>, but here it has to be outputFile, so we replace it.
if (input.equals(tempOutputFile.getPathString())) {
result =
outputPrefix
+ ShellEscaper.escapeString(outputFile.getExecPathString());
}
if (input.equals(outputFile.getExecPathString())
|| input.equals(getDotdFile().getSafeExecPath().getPathString())) {
result = outputPrefix + ShellEscaper.escapeString(input);
}
return result;
}
}));
// Write the command needed to build the real .o file to the fake .o file.
// Generate a command to ensure that the output directory exists; otherwise
// the compilation would fail.
try {
// Ensure that the .d file and .o file are siblings, so that the "mkdir" below works for
// both.
Preconditions.checkState(
outputFile
.getExecPath()
.getParentDirectory()
.equals(getDotdFile().getSafeExecPath().getParentDirectory()));
FileSystemUtils.writeContent(
outputFile.getPath(),
ISO_8859_1,
outputFile.getPath().getBaseName()
+ ": "
+ "mkdir -p "
+ outputPrefix
+ "$(dirname "
+ outputFile.getExecPath()
+ ")"
+ " && "
+ argv
+ "\n");
} catch (IOException e) {
throw new ActionExecutionException(
"failed to create fake compile command for rule '"
+ getOwner().getLabel()
+ ": "
+ e.getMessage(),
this,
false);
}
}
/** Sets the test host. This is used for xctest targets. */
public Builder setTestHost(XcodeProvider testHost) {
Preconditions.checkState(!this.testHost.isPresent());
this.testHost = Optional.of(testHost);
this.addTransitiveSets(testHost);
return this;
}
/**
* Analyzes the specified targets using Skyframe as the driving framework.
*
* @return the configured targets that should be built along with a WalkableGraph of the analysis.
*/
public SkyframeAnalysisResult configureTargets(
EventHandler eventHandler,
List<ConfiguredTargetKey> values,
List<AspectValueKey> aspectKeys,
EventBus eventBus,
boolean keepGoing)
throws InterruptedException, ViewCreationFailedException {
enableAnalysis(true);
EvaluationResult<ActionLookupValue> result;
try {
result = skyframeExecutor.configureTargets(eventHandler, values, aspectKeys, keepGoing);
} finally {
enableAnalysis(false);
}
ImmutableMap<Action, ConflictException> badActions = skyframeExecutor.findArtifactConflicts();
Collection<AspectValue> goodAspects = Lists.newArrayListWithCapacity(values.size());
NestedSetBuilder<Package> packages = NestedSetBuilder.stableOrder();
for (AspectValueKey aspectKey : aspectKeys) {
AspectValue value = (AspectValue) result.get(AspectValue.key(aspectKey));
if (value == null) {
// Skip aspects that couldn't be applied to targets.
continue;
}
goodAspects.add(value);
packages.addTransitive(value.getTransitivePackages());
}
// Filter out all CTs that have a bad action and convert to a list of configured targets. This
// code ensures that the resulting list of configured targets has the same order as the incoming
// list of values, i.e., that the order is deterministic.
Collection<ConfiguredTarget> goodCts = Lists.newArrayListWithCapacity(values.size());
for (ConfiguredTargetKey value : values) {
ConfiguredTargetValue ctValue =
(ConfiguredTargetValue) result.get(ConfiguredTargetValue.key(value));
if (ctValue == null) {
continue;
}
goodCts.add(ctValue.getConfiguredTarget());
packages.addTransitive(ctValue.getTransitivePackages());
}
if (!result.hasError() && badActions.isEmpty()) {
setDeserializedArtifactOwners();
return new SkyframeAnalysisResult(
/*hasLoadingError=*/ false,
/*hasAnalysisError=*/ false,
ImmutableList.copyOf(goodCts),
result.getWalkableGraph(),
ImmutableList.copyOf(goodAspects),
LoadingPhaseRunner.collectPackageRoots(packages.build().toCollection()));
}
// --nokeep_going so we fail with an exception for the first error.
// TODO(bazel-team): We might want to report the other errors through the event bus but
// for keeping this code in parity with legacy we just report the first error for now.
if (!keepGoing) {
for (Map.Entry<Action, ConflictException> bad : badActions.entrySet()) {
ConflictException ex = bad.getValue();
try {
ex.rethrowTyped();
} catch (MutableActionGraph.ActionConflictException ace) {
ace.reportTo(eventHandler);
String errorMsg =
"Analysis of target '"
+ bad.getKey().getOwner().getLabel()
+ "' failed; build aborted";
throw new ViewCreationFailedException(errorMsg);
} catch (ArtifactPrefixConflictException apce) {
eventHandler.handle(Event.error(apce.getMessage()));
}
throw new ViewCreationFailedException(ex.getMessage());
}
Map.Entry<SkyKey, ErrorInfo> error = result.errorMap().entrySet().iterator().next();
SkyKey topLevel = error.getKey();
ErrorInfo errorInfo = error.getValue();
assertSaneAnalysisError(errorInfo, topLevel);
skyframeExecutor
.getCyclesReporter()
.reportCycles(errorInfo.getCycleInfo(), topLevel, eventHandler);
Throwable cause = errorInfo.getException();
Preconditions.checkState(
cause != null || !Iterables.isEmpty(errorInfo.getCycleInfo()), errorInfo);
String errorMsg = null;
if (topLevel.argument() instanceof ConfiguredTargetKey) {
errorMsg =
"Analysis of target '"
+ ConfiguredTargetValue.extractLabel(topLevel)
+ "' failed; build aborted";
} else if (topLevel.argument() instanceof AspectValueKey) {
AspectValueKey aspectKey = (AspectValueKey) topLevel.argument();
errorMsg = "Analysis of aspect '" + aspectKey.getDescription() + "' failed; build aborted";
} else {
assert false;
}
if (cause instanceof ActionConflictException) {
((ActionConflictException) cause).reportTo(eventHandler);
}
throw new ViewCreationFailedException(errorMsg);
}
boolean hasLoadingError = false;
// --keep_going : We notify the error and return a ConfiguredTargetValue
for (Map.Entry<SkyKey, ErrorInfo> errorEntry : result.errorMap().entrySet()) {
// Only handle errors of configured targets, not errors of top-level aspects.
// TODO(ulfjack): this is quadratic - if there are a lot of CTs, this could be rather slow.
if (!values.contains(errorEntry.getKey().argument())) {
continue;
}
SkyKey errorKey = errorEntry.getKey();
ConfiguredTargetKey label = (ConfiguredTargetKey) errorKey.argument();
Label topLevelLabel = label.getLabel();
ErrorInfo errorInfo = errorEntry.getValue();
assertSaneAnalysisError(errorInfo, errorKey);
skyframeExecutor
.getCyclesReporter()
.reportCycles(errorInfo.getCycleInfo(), errorKey, eventHandler);
Exception cause = errorInfo.getException();
Label analysisRootCause = null;
if (cause instanceof ConfiguredValueCreationException) {
ConfiguredValueCreationException ctCause = (ConfiguredValueCreationException) cause;
for (Label rootCause : ctCause.getRootCauses()) {
hasLoadingError = true;
eventBus.post(new LoadingFailureEvent(topLevelLabel, rootCause));
}
analysisRootCause = ctCause.getAnalysisRootCause();
} else if (!Iterables.isEmpty(errorInfo.getCycleInfo())) {
analysisRootCause =
maybeGetConfiguredTargetCycleCulprit(topLevelLabel, errorInfo.getCycleInfo());
} else if (cause instanceof ActionConflictException) {
((ActionConflictException) cause).reportTo(eventHandler);
}
eventHandler.handle(
Event.warn(
"errors encountered while analyzing target '"
+ topLevelLabel
+ "': it will not be built"));
if (analysisRootCause != null) {
eventBus.post(
new AnalysisFailureEvent(
LabelAndConfiguration.of(topLevelLabel, label.getConfiguration()),
analysisRootCause));
}
}
Collection<Exception> reportedExceptions = Sets.newHashSet();
for (Map.Entry<Action, ConflictException> bad : badActions.entrySet()) {
ConflictException ex = bad.getValue();
try {
ex.rethrowTyped();
} catch (MutableActionGraph.ActionConflictException ace) {
ace.reportTo(eventHandler);
eventHandler.handle(
Event.warn(
"errors encountered while analyzing target '"
+ bad.getKey().getOwner().getLabel()
+ "': it will not be built"));
} catch (ArtifactPrefixConflictException apce) {
if (reportedExceptions.add(apce)) {
eventHandler.handle(Event.error(apce.getMessage()));
}
}
}
if (!badActions.isEmpty()) {
// In order to determine the set of configured targets transitively error free from action
// conflict issues, we run a post-processing update() that uses the bad action map.
EvaluationResult<PostConfiguredTargetValue> actionConflictResult =
skyframeExecutor.postConfigureTargets(eventHandler, values, keepGoing, badActions);
goodCts = Lists.newArrayListWithCapacity(values.size());
for (ConfiguredTargetKey value : values) {
PostConfiguredTargetValue postCt =
actionConflictResult.get(PostConfiguredTargetValue.key(value));
if (postCt != null) {
goodCts.add(postCt.getCt());
}
}
}
setDeserializedArtifactOwners();
return new SkyframeAnalysisResult(
hasLoadingError,
result.hasError() || !badActions.isEmpty(),
ImmutableList.copyOf(goodCts),
result.getWalkableGraph(),
ImmutableList.copyOf(goodAspects),
LoadingPhaseRunner.collectPackageRoots(packages.build().toCollection()));
}
private void createSourceAction(
String outputName,
CcCompilationOutputs.Builder result,
AnalysisEnvironment env,
Artifact sourceArtifact,
CppCompileActionBuilder builder,
ArtifactCategory outputCategory,
boolean addObject,
boolean enableCoverage,
boolean generateDwo,
boolean generateDotd,
Map<String, String> sourceSpecificBuildVariables) {
PathFragment ccRelativeName = semantics.getEffectiveSourcePath(sourceArtifact);
if (cppConfiguration.isLipoOptimization()) {
// TODO(bazel-team): we shouldn't be needing this, merging context with the binary
// is a superset of necessary information.
LipoContextProvider lipoProvider =
Preconditions.checkNotNull(CppHelper.getLipoContextProvider(ruleContext), outputName);
builder.setContext(
CppCompilationContext.mergeForLipo(lipoProvider.getLipoContext(), context));
}
boolean generatePicAction = getGeneratePicActions();
// If we always need pic for everything, then don't bother to create a no-pic action.
boolean generateNoPicAction = getGenerateNoPicActions();
Preconditions.checkState(generatePicAction || generateNoPicAction);
if (fake) {
boolean usePic = !generateNoPicAction;
createFakeSourceAction(
outputName,
result,
env,
builder,
outputCategory,
addObject,
ccRelativeName,
sourceArtifact.getExecPath(),
usePic,
generateDotd);
} else {
// Create PIC compile actions (same as non-PIC, but use -fPIC and
// generate .pic.o, .pic.d, .pic.gcno instead of .o, .d, .gcno.)
if (generatePicAction) {
String picOutputBase =
CppHelper.getCompileArtifactName(ruleContext, ArtifactCategory.PIC_FILE, outputName);
CppCompileActionBuilder picBuilder =
copyAsPicBuilder(builder, picOutputBase, outputCategory, generateDotd);
String gcnoFileName =
CppHelper.getCompileArtifactName(
ruleContext, ArtifactCategory.COVERAGE_DATA_FILE, picOutputBase);
Artifact gcnoFile =
enableCoverage ? CppHelper.getCompileOutputArtifact(ruleContext, gcnoFileName) : null;
Artifact dwoFile = generateDwo ? getDwoFile(picBuilder.getOutputFile()) : null;
setupCompileBuildVariables(
picBuilder,
/*usePic=*/ true,
ccRelativeName,
sourceArtifact.getExecPath(),
gcnoFile,
dwoFile,
sourceSpecificBuildVariables);
if (maySaveTemps) {
result.addTemps(
createTempsActions(
sourceArtifact,
outputName,
picBuilder,
/*usePic=*/ true,
/*generateDotd=*/ generateDotd,
ccRelativeName));
}
picBuilder.setGcnoFile(gcnoFile);
picBuilder.setDwoFile(dwoFile);
semantics.finalizeCompileActionBuilder(ruleContext, picBuilder);
CppCompileAction picAction = picBuilder.build();
env.registerAction(picAction);
if (addObject) {
result.addPicObjectFile(picAction.getOutputFile());
if (featureConfiguration.isEnabled(CppRuleClasses.THIN_LTO)
&& CppFileTypes.LTO_SOURCE.matches(sourceArtifact.getFilename())) {
result.addLTOBitcodeFile(picAction.getOutputFile());
}
}
if (dwoFile != null) {
// Host targets don't produce .dwo files.
result.addPicDwoFile(dwoFile);
}
if (cppConfiguration.isLipoContextCollector() && !generateNoPicAction) {
result.addLipoScannable(picAction);
}
}
if (generateNoPicAction) {
Artifact noPicOutputFile =
CppHelper.getCompileOutputArtifact(
ruleContext,
CppHelper.getCompileArtifactName(ruleContext, outputCategory, outputName));
builder.setOutputs(outputCategory, outputName, generateDotd);
String gcnoFileName =
CppHelper.getCompileArtifactName(
ruleContext, ArtifactCategory.COVERAGE_DATA_FILE, outputName);
// Create non-PIC compile actions
Artifact gcnoFile =
!cppConfiguration.isLipoOptimization() && enableCoverage
? CppHelper.getCompileOutputArtifact(ruleContext, gcnoFileName)
: null;
Artifact noPicDwoFile = generateDwo ? getDwoFile(noPicOutputFile) : null;
setupCompileBuildVariables(
builder,
/*usePic=*/ false,
ccRelativeName,
sourceArtifact.getExecPath(),
gcnoFile,
noPicDwoFile,
sourceSpecificBuildVariables);
if (maySaveTemps) {
result.addTemps(
createTempsActions(
sourceArtifact,
outputName,
builder,
/*usePic=*/ false,
/*generateDotd*/ generateDotd,
ccRelativeName));
}
builder.setGcnoFile(gcnoFile);
builder.setDwoFile(noPicDwoFile);
semantics.finalizeCompileActionBuilder(ruleContext, builder);
CppCompileAction compileAction = builder.build();
env.registerAction(compileAction);
Artifact objectFile = compileAction.getOutputFile();
if (addObject) {
result.addObjectFile(objectFile);
if (featureConfiguration.isEnabled(CppRuleClasses.THIN_LTO)
&& CppFileTypes.LTO_SOURCE.matches(sourceArtifact.getFilename())) {
result.addLTOBitcodeFile(objectFile);
}
}
if (noPicDwoFile != null) {
// Host targets don't produce .dwo files.
result.addDwoFile(noPicDwoFile);
}
if (cppConfiguration.isLipoContextCollector()) {
result.addLipoScannable(compileAction);
}
}
}
}
/** Enables loading phase only functions in this Environment. */
public Builder setLoadingPhase() {
Preconditions.checkState(!isLoadingPhase);
isLoadingPhase = true;
return this;
}
/**
* Called from SkyframeExecutor to see whether the graph needs to be checked for artifact
* conflicts. Returns true if some configured target has been evaluated since the last time the
* graph was checked for artifact conflicts (with that last time marked by a call to {@link
* #resetEvaluatedConfiguredTargetFlag()}).
*/
boolean isSomeConfiguredTargetEvaluated() {
Preconditions.checkState(!enableAnalysis);
return someConfiguredTargetEvaluated;
}
/**
* Constructs the C++ linker actions. It generally generates two actions, one for a static library
* and one for a dynamic library. If PIC is required for shared libraries, but not for binaries,
* it additionally creates a third action to generate a PIC static library.
*
* <p>For dynamic libraries, this method can additionally create an interface shared library that
* can be used for linking, but doesn't contain any executable code. This increases the number of
* cache hits for link actions. Call {@link #setAllowInterfaceSharedObjects(boolean)} to enable
* this behavior.
*
* @throws RuleErrorException
*/
public CcLinkingOutputs createCcLinkActions(CcCompilationOutputs ccOutputs)
throws RuleErrorException {
// For now only handle static links. Note that the dynamic library link below ignores linkType.
// TODO(bazel-team): Either support non-static links or move this check to setLinkType().
Preconditions.checkState(linkType.isStaticLibraryLink(), "can only handle static links");
CcLinkingOutputs.Builder result = new CcLinkingOutputs.Builder();
if (cppConfiguration.isLipoContextCollector()) {
// Don't try to create LIPO link actions in collector mode,
// because it needs some data that's not available at this point.
return result.build();
}
AnalysisEnvironment env = ruleContext.getAnalysisEnvironment();
boolean usePicForBinaries = CppHelper.usePic(ruleContext, true);
boolean usePicForSharedLibs = CppHelper.usePic(ruleContext, 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
// for (usePicForSharedLibs usePicForBinaries):
//
// (1) (false false) -> no pic code
// (2) (true false) -> shared libraries as pic, but not binaries
// (3) (true true) -> both shared libraries and binaries as pic
//
// In case (3), we always need PIC, so only create one static library containing the PIC object
// files. The name therefore does not match the content.
//
// Presumably, it is done this way because the .a file is an implicit output of every cc_library
// rule, so we can't use ".pic.a" that in the always-PIC case.
// If the crosstool is configured to select an output artifact, we use that selection.
// Otherwise, we use linux defaults.
Artifact linkedArtifact = getLinkedArtifact(linkType);
CppLinkAction maybePicAction =
newLinkActionBuilder(linkedArtifact)
.addNonLibraryInputs(ccOutputs.getObjectFiles(usePicForBinaries))
.addNonLibraryInputs(ccOutputs.getHeaderTokenFiles())
.addLTOBitcodeFiles(ccOutputs.getLtoBitcodeFiles())
.setLinkType(linkType)
.setLinkStaticness(LinkStaticness.FULLY_STATIC)
.setFeatureConfiguration(featureConfiguration)
.build();
env.registerAction(maybePicAction);
result.addStaticLibrary(maybePicAction.getOutputLibrary());
// Create a second static library (.pic.a). Only in case (2) do we need both PIC and non-PIC
// static libraries. In that case, the first static library contains the non-PIC code, and this
// one contains the PIC code, so the names match the content.
if (!usePicForBinaries && usePicForSharedLibs) {
LinkTargetType picLinkType =
(linkType == LinkTargetType.ALWAYS_LINK_STATIC_LIBRARY)
? LinkTargetType.ALWAYS_LINK_PIC_STATIC_LIBRARY
: LinkTargetType.PIC_STATIC_LIBRARY;
// If the crosstool is configured to select an output artifact, we use that selection.
// Otherwise, we use linux defaults.
Artifact picArtifact = getLinkedArtifact(picLinkType);
CppLinkAction picAction =
newLinkActionBuilder(picArtifact)
.addNonLibraryInputs(ccOutputs.getObjectFiles(true))
.addNonLibraryInputs(ccOutputs.getHeaderTokenFiles())
.addLTOBitcodeFiles(ccOutputs.getLtoBitcodeFiles())
.setLinkType(picLinkType)
.setLinkStaticness(LinkStaticness.FULLY_STATIC)
.setFeatureConfiguration(featureConfiguration)
.build();
env.registerAction(picAction);
result.addPicStaticLibrary(picAction.getOutputLibrary());
}
if (!createDynamicLibrary) {
return result.build();
}
// Create dynamic library.
Artifact soImpl;
if (soImplArtifact == null) {
// If the crosstool is configured to select an output artifact, we use that selection.
// Otherwise, we use linux defaults.
soImpl = getLinkedArtifact(LinkTargetType.DYNAMIC_LIBRARY);
} else {
soImpl = soImplArtifact;
}
List<String> sonameLinkopts = ImmutableList.of();
Artifact soInterface = null;
if (cppConfiguration.useInterfaceSharedObjects() && allowInterfaceSharedObjects) {
soInterface =
CppHelper.getLinuxLinkedArtifact(ruleContext, LinkTargetType.INTERFACE_DYNAMIC_LIBRARY);
sonameLinkopts =
ImmutableList.of(
"-Wl,-soname="
+ SolibSymlinkAction.getDynamicLibrarySoname(
soImpl.getRootRelativePath(), false));
}
// Should we also link in any libraries that this library depends on?
// That is required on some systems...
CppLinkActionBuilder linkActionBuilder =
newLinkActionBuilder(soImpl)
.setInterfaceOutput(soInterface)
.addNonLibraryInputs(ccOutputs.getObjectFiles(usePicForSharedLibs))
.addNonLibraryInputs(ccOutputs.getHeaderTokenFiles())
.addLTOBitcodeFiles(ccOutputs.getLtoBitcodeFiles())
.setLinkType(LinkTargetType.DYNAMIC_LIBRARY)
.setLinkStaticness(LinkStaticness.DYNAMIC)
.addLinkopts(linkopts)
.addLinkopts(sonameLinkopts)
.setRuntimeInputs(
CppHelper.getToolchain(ruleContext).getDynamicRuntimeLinkMiddleman(),
CppHelper.getToolchain(ruleContext).getDynamicRuntimeLinkInputs())
.setFeatureConfiguration(featureConfiguration);
if (!ccOutputs.getLtoBitcodeFiles().isEmpty()
&& featureConfiguration.isEnabled(CppRuleClasses.THIN_LTO)) {
linkActionBuilder.setLTOIndexing(true);
CppLinkAction indexAction = linkActionBuilder.build();
env.registerAction(indexAction);
for (LTOBackendArtifacts ltoArtifacts : indexAction.getAllLTOBackendArtifacts()) {
ltoArtifacts.scheduleLTOBackendAction(ruleContext, usePicForSharedLibs);
}
linkActionBuilder.setLTOIndexing(false);
}
CppLinkAction action = linkActionBuilder.build();
env.registerAction(action);
LibraryToLink dynamicLibrary = action.getOutputLibrary();
LibraryToLink interfaceLibrary = action.getInterfaceOutputLibrary();
if (interfaceLibrary == null) {
interfaceLibrary = dynamicLibrary;
}
// If shared library has neverlink=1, then leave it untouched. Otherwise,
// create a mangled symlink for it and from now on reference it through
// mangled name only.
if (neverLink) {
result.addDynamicLibrary(interfaceLibrary);
result.addExecutionDynamicLibrary(dynamicLibrary);
} else {
LibraryToLink libraryLink =
SolibSymlinkAction.getDynamicLibrarySymlink(
ruleContext,
interfaceLibrary.getArtifact(),
false,
false,
ruleContext.getConfiguration());
result.addDynamicLibrary(libraryLink);
LibraryToLink implLibraryLink =
SolibSymlinkAction.getDynamicLibrarySymlink(
ruleContext,
dynamicLibrary.getArtifact(),
false,
false,
ruleContext.getConfiguration());
result.addExecutionDynamicLibrary(implLibraryLink);
}
return result.build();
}
