private void createHeaderAction(
String outputName,
Builder result,
AnalysisEnvironment env,
CppCompileActionBuilder builder,
boolean generateDotd) {
String outputNameBase =
CppHelper.getCompileArtifactName(
ruleContext, ArtifactCategory.GENERATED_HEADER, outputName);
builder
.setOutputs(ArtifactCategory.PROCESSED_HEADER, outputNameBase, generateDotd)
// If we generate pic actions, we prefer the header actions to use the pic artifacts.
.setPicMode(this.getGeneratePicActions());
setupCompileBuildVariables(
builder,
this.getGeneratePicActions(),
/*ccRelativeName=*/ null,
/*autoFdoImportPath=*/ null,
/*gcnoFile=*/ null,
/*dwoFile=*/ null,
ImmutableMap.<String, String>of());
semantics.finalizeCompileActionBuilder(ruleContext, builder);
CppCompileAction compileAction = builder.build();
env.registerAction(compileAction);
Artifact tokenFile = compileAction.getOutputFile();
result.addHeaderTokenFile(tokenFile);
}
private void createFakeSourceAction(
String outputName,
CcCompilationOutputs.Builder result,
AnalysisEnvironment env,
CppCompileActionBuilder builder,
ArtifactCategory outputCategory,
boolean addObject,
PathFragment ccRelativeName,
PathFragment execPath,
boolean usePic,
boolean generateDotd) {
String outputNameBase = getOutputNameBaseWith(outputName, usePic);
String tempOutputName =
ruleContext
.getConfiguration()
.getBinFragment()
.getRelative(CppHelper.getObjDirectory(ruleContext.getLabel()))
.getRelative(
CppHelper.getCompileArtifactName(
ruleContext,
outputCategory,
getOutputNameBaseWith(outputName + ".temp", usePic)))
.getPathString();
builder
.setPicMode(usePic)
.setOutputs(outputCategory, outputNameBase, generateDotd)
.setTempOutputFile(new PathFragment(tempOutputName));
setupCompileBuildVariables(
builder,
usePic,
ccRelativeName,
execPath,
/*gcnoFile=*/ null,
/*dwoFile=*/ null,
ImmutableMap.<String, String>of());
semantics.finalizeCompileActionBuilder(ruleContext, builder);
CppCompileAction action = builder.build();
env.registerAction(action);
if (addObject) {
if (usePic) {
result.addPicObjectFile(action.getOutputFile());
} else {
result.addObjectFile(action.getOutputFile());
}
}
}
/**
* 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();
}
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);
}
}
}
}
