/**
* Build a {@link HeaderSymlinkTree} of all the shared libraries found via the top-level rule's
* transitive dependencies.
*/
public static SymlinkTree createSharedLibrarySymlinkTree(
TargetGraph targetGraph,
BuildRuleParams params,
SourcePathResolver pathResolver,
CxxPlatform cxxPlatform,
Predicate<Object> traverse) {
BuildTarget symlinkTreeTarget =
createSharedLibrarySymlinkTreeTarget(params.getBuildTarget(), cxxPlatform.getFlavor());
Path symlinkTreeRoot =
getSharedLibrarySymlinkTreePath(params.getBuildTarget(), cxxPlatform.getFlavor());
ImmutableSortedMap<String, SourcePath> libraries =
NativeLinkables.getTransitiveSharedLibraries(
targetGraph, cxxPlatform, params.getDeps(), Linker.LinkableDepType.SHARED, traverse);
ImmutableMap.Builder<Path, SourcePath> links = ImmutableMap.builder();
for (Map.Entry<String, SourcePath> ent : libraries.entrySet()) {
links.put(Paths.get(ent.getKey()), ent.getValue());
}
try {
return new SymlinkTree(
params.copyWithChanges(
symlinkTreeTarget,
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of()),
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
pathResolver,
symlinkTreeRoot,
links.build());
} catch (SymlinkTree.InvalidSymlinkTreeException e) {
throw new RuntimeException(e.getMessage());
}
}
@Test
public void testSimpleCxxBinaryWithHeader() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "simple", tmp);
workspace.setUp();
CxxPlatform cxxPlatform = DefaultCxxPlatforms.build(new CxxBuckConfig(new FakeBuckConfig()));
BuildTarget target = BuildTargetFactory.newInstance("//foo:simple_with_header");
CxxSourceRuleFactory cxxSourceRuleFactory = CxxSourceRuleFactoryHelper.of(target, cxxPlatform);
BuildTarget binaryTarget = CxxDescriptionEnhancer.createCxxLinkTarget(target);
String sourceName = "simple_with_header.cpp";
String headerName = "simple_with_header.h";
String headerFull = "foo/" + headerName;
BuildTarget preprocessTarget =
cxxSourceRuleFactory.createPreprocessBuildTarget(
sourceName, CxxSource.Type.CXX, CxxSourceRuleFactory.PicType.PDC);
BuildTarget compileTarget =
cxxSourceRuleFactory.createCompileBuildTarget(sourceName, CxxSourceRuleFactory.PicType.PDC);
BuildTarget headerSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
target, cxxPlatform.getFlavor(), HeaderVisibility.PRIVATE);
// Do a clean build, verify that it succeeds, and check that all expected targets built
// successfully.
workspace.runBuckCommand("build", target.toString()).assertSuccess();
BuckBuildLog buildLog = workspace.getBuildLog();
assertEquals(
ImmutableSet.of(
headerSymlinkTreeTarget, preprocessTarget, compileTarget, binaryTarget, target),
buildLog.getAllTargets());
buildLog.assertTargetBuiltLocally(headerSymlinkTreeTarget.toString());
buildLog.assertTargetBuiltLocally(preprocessTarget.toString());
buildLog.assertTargetBuiltLocally(compileTarget.toString());
buildLog.assertTargetBuiltLocally(binaryTarget.toString());
buildLog.assertTargetBuiltLocally(target.toString());
// Clear for new build.
workspace.resetBuildLogFile();
// Update the source file.
workspace.replaceFileContents(headerFull, "blah = 5", "blah = 6");
// Check that running a build again makes the source get recompiled and the binary
// re-linked, but does not cause the header rules to re-run.
workspace.runBuckCommand("build", target.toString()).assertSuccess();
buildLog = workspace.getBuildLog();
assertEquals(
ImmutableSet.of(
headerSymlinkTreeTarget, preprocessTarget, compileTarget, binaryTarget, target),
buildLog.getAllTargets());
buildLog.assertTargetHadMatchingRuleKey(headerSymlinkTreeTarget.toString());
buildLog.assertTargetBuiltLocally(preprocessTarget.toString());
buildLog.assertTargetBuiltLocally(compileTarget.toString());
assertThat(
buildLog.getLogEntry(binaryTarget).getSuccessType().get(),
Matchers.not(Matchers.equalTo(BuildRuleSuccessType.MATCHING_RULE_KEY)));
buildLog.assertTargetBuiltLocally(target.toString());
}
private void assertCompDir(Path compDir, Optional<String> failure) throws Exception {
ProjectFilesystem filesystem = new ProjectFilesystem(tmp.getRoot().toPath());
CxxPlatform platform = DefaultCxxPlatforms.build(new CxxBuckConfig(new FakeBuckConfig()));
// Build up the paths to various files the archive step will use.
ImmutableList<String> compiler =
platform.getCc().getCommandPrefix(new SourcePathResolver(new BuildRuleResolver()));
Path output = filesystem.resolve(Paths.get("output.o"));
Path relativeInput = Paths.get("input.c");
Path input = filesystem.resolve(relativeInput);
filesystem.writeContentsToPath("int main() {}", relativeInput);
ImmutableList.Builder<String> preprocessorCommand = ImmutableList.builder();
preprocessorCommand.addAll(compiler);
ImmutableList.Builder<String> compilerCommand = ImmutableList.builder();
compilerCommand.addAll(compiler);
compilerCommand.add("-g");
DebugPathSanitizer sanitizer =
new DebugPathSanitizer(200, File.separatorChar, compDir, ImmutableBiMap.<Path, Path>of());
// Build an archive step.
CxxPreprocessAndCompileStep step =
new CxxPreprocessAndCompileStep(
CxxPreprocessAndCompileStep.Operation.COMPILE_MUNGE_DEBUGINFO,
output,
relativeInput,
CxxSource.Type.C,
Optional.of(preprocessorCommand.build()),
Optional.of(compilerCommand.build()),
ImmutableMap.<Path, Path>of(),
sanitizer);
// Execute the archive step and verify it ran successfully.
ExecutionContext executionContext =
TestExecutionContext.newBuilder()
.setProjectFilesystem(new ProjectFilesystem(tmp.getRoot().toPath()))
.build();
TestConsole console = (TestConsole) executionContext.getConsole();
int exitCode = step.execute(executionContext);
if (failure.isPresent()) {
assertNotEquals("compile step succeeded", 0, exitCode);
assertThat(
console.getTextWrittenToStdErr(),
console.getTextWrittenToStdErr(),
Matchers.containsString(failure.get()));
} else {
assertEquals("compile step failed: " + console.getTextWrittenToStdErr(), 0, exitCode);
// Verify that we find the expected compilation dir embedded in the file.
String contents = new String(Files.readAllBytes(output));
assertThat(contents, Matchers.containsString(sanitizer.getCompilationDirectory()));
}
// Cleanup.
Files.delete(input);
Files.deleteIfExists(output);
}
@Override
public NativeLinkableInput getNativeLinkableInput(
TargetGraph targetGraph, CxxPlatform cxxPlatform, Linker.LinkableDepType type) {
if (!isPlatformSupported(cxxPlatform)) {
return NativeLinkableInput.of();
}
if (headerOnly.apply(cxxPlatform)) {
return NativeLinkableInput.of(
ImmutableList.<Arg>of(),
Preconditions.checkNotNull(frameworks),
ImmutableSet.<FrameworkPath>of());
}
// Build up the arguments used to link this library. If we're linking the
// whole archive, wrap the library argument in the necessary "ld" flags.
ImmutableList.Builder<Arg> linkerArgsBuilder = ImmutableList.builder();
linkerArgsBuilder.addAll(Preconditions.checkNotNull(exportedLinkerFlags.apply(cxxPlatform)));
if (type != Linker.LinkableDepType.SHARED || linkage == Linkage.STATIC) {
BuildRule rule =
requireBuildRule(
targetGraph,
cxxPlatform.getFlavor(),
type == Linker.LinkableDepType.STATIC
? CxxDescriptionEnhancer.STATIC_FLAVOR
: CxxDescriptionEnhancer.STATIC_PIC_FLAVOR);
Arg library =
new SourcePathArg(getResolver(), new BuildTargetSourcePath(rule.getBuildTarget()));
if (linkWhole) {
Linker linker = cxxPlatform.getLd();
linkerArgsBuilder.addAll(linker.linkWhole(library));
} else {
linkerArgsBuilder.add(library);
}
} else {
BuildRule rule =
requireBuildRule(
targetGraph, cxxPlatform.getFlavor(), CxxDescriptionEnhancer.SHARED_FLAVOR);
linkerArgsBuilder.add(
new SourcePathArg(getResolver(), new BuildTargetSourcePath(rule.getBuildTarget())));
}
final ImmutableList<Arg> linkerArgs = linkerArgsBuilder.build();
return NativeLinkableInput.of(
linkerArgs, Preconditions.checkNotNull(frameworks), Preconditions.checkNotNull(libraries));
}
@Override
public PythonPackageComponents getPythonPackageComponents(
TargetGraph targetGraph, PythonPlatform pythonPlatform, CxxPlatform cxxPlatform) {
if (headerOnly.apply(cxxPlatform)) {
return PythonPackageComponents.of();
}
if (linkage == Linkage.STATIC) {
return PythonPackageComponents.of();
}
if (!isPlatformSupported(cxxPlatform)) {
return PythonPackageComponents.of();
}
ImmutableMap.Builder<Path, SourcePath> libs = ImmutableMap.builder();
String sharedLibrarySoname =
soname.or(
CxxDescriptionEnhancer.getDefaultSharedLibrarySoname(getBuildTarget(), cxxPlatform));
BuildRule sharedLibraryBuildRule =
requireBuildRule(
targetGraph, cxxPlatform.getFlavor(), CxxDescriptionEnhancer.SHARED_FLAVOR);
libs.put(
Paths.get(sharedLibrarySoname),
new BuildTargetSourcePath(sharedLibraryBuildRule.getBuildTarget()));
return PythonPackageComponents.of(
/* modules */ ImmutableMap.<Path, SourcePath>of(),
/* resources */ ImmutableMap.<Path, SourcePath>of(),
/* nativeLibraries */ libs.build(),
/* prebuiltLibraries */ ImmutableSet.<SourcePath>of(),
/* zipSafe */ Optional.<Boolean>absent());
}
@Override
public CxxPreprocessorInput getCxxPreprocessorInput(
CxxPlatform cxxPlatform, HeaderVisibility headerVisibility)
throws NoSuchBuildTargetException {
CxxPreprocessorInput.Builder builder = CxxPreprocessorInput.builder();
switch (headerVisibility) {
case PUBLIC:
if (Preconditions.checkNotNull(hasHeaders.apply(cxxPlatform))) {
CxxPreprocessables.addHeaderSymlinkTree(
builder,
getBuildTarget(),
ruleResolver,
cxxPlatform.getFlavor(),
headerVisibility,
CxxPreprocessables.IncludeType.SYSTEM);
}
builder.putAllPreprocessorFlags(
Preconditions.checkNotNull(exportedPreprocessorFlags.apply(cxxPlatform)));
// Just pass the include dirs as system includes.
builder.addAllSystemIncludeRoots(
Iterables.transform(includeDirs, getProjectFilesystem().getAbsolutifier()));
return builder.build();
case PRIVATE:
return builder.build();
}
// We explicitly don't put this in a default statement because we
// want the compiler to warn if someone modifies the HeaderVisibility enum.
throw new RuntimeException("Invalid header visibility: " + headerVisibility);
}
public static String getDefaultSharedLibrarySoname(BuildTarget target, CxxPlatform platform) {
String libName =
Joiner.on('_')
.join(
ImmutableList.builder()
.addAll(
FluentIterable.from(target.getBasePath())
.transform(Functions.toStringFunction())
.filter(Predicates.not(Predicates.equalTo(""))))
.add(
target
.withoutFlavors(ImmutableSet.of(platform.getFlavor()))
.getShortNameAndFlavorPostfix())
.build());
String extension = platform.getSharedLibraryExtension();
return String.format("lib%s.%s", libName, extension);
}
public static HeaderSymlinkTree createHeaderSymlinkTree(
BuildRuleParams params,
BuildRuleResolver ruleResolver,
SourcePathResolver pathResolver,
CxxPlatform cxxPlatform,
boolean includeLexYaccHeaders,
ImmutableMap<String, SourcePath> lexSources,
ImmutableMap<String, SourcePath> yaccSources,
ImmutableMap<Path, SourcePath> headers,
HeaderVisibility headerVisibility) {
BuildTarget headerSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
params.getBuildTarget(), cxxPlatform.getFlavor(), headerVisibility);
Path headerSymlinkTreeRoot =
CxxDescriptionEnhancer.getHeaderSymlinkTreePath(
params.getBuildTarget(), cxxPlatform.getFlavor(), headerVisibility);
Optional<Path> headerMapLocation = Optional.absent();
if (cxxPlatform.getCpp().supportsHeaderMaps() && cxxPlatform.getCxxpp().supportsHeaderMaps()) {
headerMapLocation =
Optional.of(
getHeaderMapPath(params.getBuildTarget(), cxxPlatform.getFlavor(), headerVisibility));
}
CxxHeaderSourceSpec lexYaccSources;
if (includeLexYaccHeaders) {
lexYaccSources =
requireLexYaccSources(
params, ruleResolver, pathResolver, cxxPlatform, lexSources, yaccSources);
} else {
lexYaccSources = CxxHeaderSourceSpec.builder().build();
}
return CxxPreprocessables.createHeaderSymlinkTreeBuildRule(
pathResolver,
headerSymlinkTreeTarget,
params,
headerSymlinkTreeRoot,
headerMapLocation,
ImmutableMap.<Path, SourcePath>builder()
.putAll(headers)
.putAll(lexYaccSources.getCxxHeaders())
.build());
}
@Override
public CxxPreprocessorInput getCxxPreprocessorInput(
TargetGraph targetGraph, CxxPlatform cxxPlatform, HeaderVisibility headerVisibility) {
return CxxPreprocessables.getCxxPreprocessorInput(
targetGraph,
params,
ruleResolver,
cxxPlatform.getFlavor(),
headerVisibility,
CxxPreprocessables.IncludeType.LOCAL,
exportedPreprocessorFlags.apply(cxxPlatform),
cxxPlatform,
frameworks);
}
@Override
public NativeLinkableInput getNativeLinkableInput(
CxxPlatform cxxPlatform, Linker.LinkableDepType type) throws NoSuchBuildTargetException {
// Build the library path and linker arguments that we pass through the
// {@link NativeLinkable} interface for linking.
ImmutableList.Builder<Arg> linkerArgsBuilder = ImmutableList.builder();
linkerArgsBuilder.addAll(
StringArg.from(Preconditions.checkNotNull(exportedLinkerFlags.apply(cxxPlatform))));
if (!headerOnly) {
if (type == Linker.LinkableDepType.SHARED) {
Preconditions.checkState(getPreferredLinkage(cxxPlatform) != Linkage.STATIC);
final SourcePath sharedLibrary = requireSharedLibrary(cxxPlatform);
if (linkWithoutSoname) {
if (!(sharedLibrary instanceof PathSourcePath)) {
throw new HumanReadableException(
"%s: can only link prebuilt DSOs without sonames", getBuildTarget());
}
linkerArgsBuilder.add(new RelativeLinkArg((PathSourcePath) sharedLibrary));
} else {
linkerArgsBuilder.add(
new SourcePathArg(getResolver(), requireSharedLibrary(cxxPlatform)));
}
} else {
Preconditions.checkState(getPreferredLinkage(cxxPlatform) != Linkage.SHARED);
Path staticLibraryPath =
type == Linker.LinkableDepType.STATIC_PIC
? getStaticPicLibrary(cxxPlatform).get()
: PrebuiltCxxLibraryDescription.getStaticLibraryPath(
getBuildTarget(),
params.getCellRoots(),
ruleResolver,
cxxPlatform,
libDir,
libName);
SourcePathArg staticLibrary =
new SourcePathArg(
getResolver(), new PathSourcePath(getProjectFilesystem(), staticLibraryPath));
if (linkWhole) {
Linker linker = cxxPlatform.getLd();
linkerArgsBuilder.addAll(linker.linkWhole(staticLibrary));
} else {
linkerArgsBuilder.add(staticLibrary);
}
}
}
final ImmutableList<Arg> linkerArgs = linkerArgsBuilder.build();
return NativeLinkableInput.of(
linkerArgs, ImmutableSet.<FrameworkPath>of(), ImmutableSet.<FrameworkPath>of());
}
public static CxxPlatform build(
Flavor flavor,
Platform platform,
CxxBuckConfig config,
Tool as,
Tool aspp,
Tool cc,
Tool cxx,
Tool cpp,
Tool cxxpp,
Tool cxxld,
Optional<CxxPlatform.LinkerType> linkerType,
Tool ld,
Iterable<String> ldFlags,
Tool ar,
byte[] expectedGlobalHeader,
ImmutableList<String> cflags,
ImmutableList<String> cppflags,
Optional<Tool> lex,
Optional<Tool> yacc,
Optional<DebugPathSanitizer> debugPathSanitizer) {
// TODO(user, agallagher): Generalize this so we don't need all these setters.
CxxPlatform.Builder builder = CxxPlatform.builder();
builder
.setFlavor(flavor)
.setAs(getTool(flavor, "as", config).or(as))
.setAspp(getTool(flavor, "aspp", config).or(aspp))
.setCc(getTool(flavor, "cc", config).or(cc))
.setCxx(getTool(flavor, "cxx", config).or(cxx))
.setCpp(getTool(flavor, "cpp", config).or(cpp))
.setCxxpp(getTool(flavor, "cxxpp", config).or(cxxpp))
.setCxxld(getTool(flavor, "cxxld", config).or(cxxld))
.setLd(getLd(flavor, platform, config, linkerType, getTool(flavor, "ld", config).or(ld)))
.addAllLdflags(ldFlags)
.setAr(getTool(flavor, "ar", config).or(ar))
.setArExpectedGlobalHeader(expectedGlobalHeader)
.setLex(getTool(flavor, "lex", config).or(lex))
.setYacc(getTool(flavor, "yacc", config).or(yacc))
.setSharedLibraryExtension(CxxPlatforms.getSharedLibraryExtension(platform))
.setDebugPathSanitizer(debugPathSanitizer.or(CxxPlatforms.DEFAULT_DEBUG_PATH_SANITIZER));
builder.addAllCflags(cflags);
builder.addAllCxxflags(cflags);
builder.addAllCppflags(cppflags);
builder.addAllCxxppflags(cppflags);
builder.addAllCxxldflags(cflags);
CxxPlatforms.addToolFlagsFromConfig(config, builder);
return builder.build();
}
public static ImmutableMap<String, CxxSource> parseCxxSources(
BuildRuleParams params,
BuildRuleResolver resolver,
CxxPlatform cxxPlatform,
ImmutableSortedSet<SourceWithFlags> srcs,
PatternMatchedCollection<ImmutableSortedSet<SourceWithFlags>> platformSrcs) {
ImmutableMap.Builder<String, SourceWithFlags> sources = ImmutableMap.builder();
SourcePathResolver pathResolver = new SourcePathResolver(resolver);
putAllSources(srcs, sources, pathResolver, params.getBuildTarget());
for (ImmutableSortedSet<SourceWithFlags> sourcesWithFlags :
platformSrcs.getMatchingValues(cxxPlatform.getFlavor().toString())) {
putAllSources(sourcesWithFlags, sources, pathResolver, params.getBuildTarget());
}
return CxxCompilableEnhancer.resolveCxxSources(sources.build());
}
/**
* @return a map of header locations to input {@link SourcePath} objects formed by parsing the
* input {@link SourcePath} objects for the "headers" parameter.
*/
public static ImmutableMap<Path, SourcePath> parseHeaders(
BuildRuleParams params,
BuildRuleResolver resolver,
CxxPlatform cxxPlatform,
CxxConstructorArg args) {
ImmutableMap.Builder<String, SourcePath> headers = ImmutableMap.builder();
SourcePathResolver pathResolver = new SourcePathResolver(resolver);
putAllHeaders(args.headers.get(), headers, pathResolver, "headers", params.getBuildTarget());
for (SourceList sourceList :
args.platformHeaders.get().getMatchingValues(cxxPlatform.getFlavor().toString())) {
putAllHeaders(sourceList, headers, pathResolver, "platform_headers", params.getBuildTarget());
}
return CxxPreprocessables.resolveHeaderMap(
args.headerNamespace.transform(MorePaths.TO_PATH).or(params.getBuildTarget().getBasePath()),
headers.build());
}
/**
* Makes sure all build rules needed to produce the shared library are added to the action graph.
*
* @return the {@link SourcePath} representing the actual shared library.
*/
private SourcePath requireSharedLibrary(CxxPlatform cxxPlatform)
throws NoSuchBuildTargetException {
Path sharedLibraryPath =
PrebuiltCxxLibraryDescription.getSharedLibraryPath(
getBuildTarget(), params.getCellRoots(), ruleResolver, cxxPlatform, libDir, libName);
// If the shared library is prebuilt, just return a reference to it.
if (params.getProjectFilesystem().exists(sharedLibraryPath)) {
return new PathSourcePath(params.getProjectFilesystem(), sharedLibraryPath);
}
// Otherwise, generate it's build rule.
BuildRule sharedLibrary =
ruleResolver.requireRule(
getBuildTarget()
.withFlavors(cxxPlatform.getFlavor(), CxxDescriptionEnhancer.SHARED_FLAVOR));
return new BuildTargetSourcePath(sharedLibrary.getBuildTarget());
}
@Override
public ImmutableMap<BuildTarget, CxxPreprocessorInput> getTransitiveCxxPreprocessorInput(
TargetGraph targetGraph, CxxPlatform cxxPlatform, HeaderVisibility headerVisibility) {
Pair<Flavor, HeaderVisibility> key = new Pair<>(cxxPlatform.getFlavor(), headerVisibility);
ImmutableMap<BuildTarget, CxxPreprocessorInput> result = cxxPreprocessorInputCache.get(key);
if (result == null) {
Map<BuildTarget, CxxPreprocessorInput> builder = Maps.newLinkedHashMap();
builder.put(
getBuildTarget(), getCxxPreprocessorInput(targetGraph, cxxPlatform, headerVisibility));
for (BuildRule dep : getDeps()) {
if (dep instanceof CxxPreprocessorDep) {
builder.putAll(
((CxxPreprocessorDep) dep)
.getTransitiveCxxPreprocessorInput(targetGraph, cxxPlatform, headerVisibility));
}
}
result = ImmutableMap.copyOf(builder);
cxxPreprocessorInputCache.put(key, result);
}
return result;
}
@Override
public ImmutableMap<String, SourcePath> getSharedLibraries(
TargetGraph targetGraph, CxxPlatform cxxPlatform) {
if (headerOnly.apply(cxxPlatform)) {
return ImmutableMap.of();
}
if (linkage == Linkage.STATIC) {
return ImmutableMap.of();
}
if (!isPlatformSupported(cxxPlatform)) {
return ImmutableMap.of();
}
ImmutableMap.Builder<String, SourcePath> libs = ImmutableMap.builder();
String sharedLibrarySoname =
soname.or(
CxxDescriptionEnhancer.getDefaultSharedLibrarySoname(getBuildTarget(), cxxPlatform));
BuildRule sharedLibraryBuildRule =
requireBuildRule(
targetGraph, cxxPlatform.getFlavor(), CxxDescriptionEnhancer.SHARED_FLAVOR);
libs.put(
sharedLibrarySoname, new BuildTargetSourcePath(sharedLibraryBuildRule.getBuildTarget()));
return libs.build();
}
public static HeaderSymlinkTree requireHeaderSymlinkTree(
BuildRuleParams params,
BuildRuleResolver ruleResolver,
SourcePathResolver pathResolver,
CxxPlatform cxxPlatform,
boolean includeLexYaccHeaders,
ImmutableMap<String, SourcePath> lexSources,
ImmutableMap<String, SourcePath> yaccSources,
ImmutableMap<Path, SourcePath> headers,
HeaderVisibility headerVisibility) {
BuildTarget headerSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
params.getBuildTarget(), cxxPlatform.getFlavor(), headerVisibility);
// Check the cache...
Optional<BuildRule> rule = ruleResolver.getRuleOptional(headerSymlinkTreeTarget);
if (rule.isPresent()) {
Preconditions.checkState(rule.get() instanceof HeaderSymlinkTree);
return (HeaderSymlinkTree) rule.get();
}
HeaderSymlinkTree symlinkTree =
createHeaderSymlinkTree(
params,
ruleResolver,
pathResolver,
cxxPlatform,
includeLexYaccHeaders,
lexSources,
yaccSources,
headers,
headerVisibility);
ruleResolver.addToIndex(symlinkTree);
return symlinkTree;
}
private <A extends Arg> BuildRule createExtensionBuildRule(
TargetGraph targetGraph,
BuildRuleParams params,
BuildRuleResolver ruleResolver,
CxxPlatform cxxPlatform,
A args) {
SourcePathResolver pathResolver = new SourcePathResolver(ruleResolver);
// Extract all C/C++ sources from the constructor arg.
ImmutableMap<String, CxxSource> srcs =
CxxDescriptionEnhancer.parseCxxSources(params, ruleResolver, cxxPlatform, args);
ImmutableMap<Path, SourcePath> headers =
CxxDescriptionEnhancer.parseHeaders(params, ruleResolver, cxxPlatform, args);
ImmutableMap<String, SourcePath> lexSrcs =
CxxDescriptionEnhancer.parseLexSources(params, ruleResolver, args);
ImmutableMap<String, SourcePath> yaccSrcs =
CxxDescriptionEnhancer.parseYaccSources(params, ruleResolver, args);
CxxHeaderSourceSpec lexYaccSources =
CxxDescriptionEnhancer.createLexYaccBuildRules(
params,
ruleResolver,
cxxPlatform,
ImmutableList.<String>of(),
lexSrcs,
ImmutableList.<String>of(),
yaccSrcs);
// Setup the header symlink tree and combine all the preprocessor input from this rule
// and all dependencies.
HeaderSymlinkTree headerSymlinkTree =
CxxDescriptionEnhancer.requireHeaderSymlinkTree(
params,
ruleResolver,
new SourcePathResolver(ruleResolver),
cxxPlatform,
/* includeLexYaccHeaders */ true,
lexSrcs,
yaccSrcs,
headers,
HeaderVisibility.PRIVATE);
ImmutableList<CxxPreprocessorInput> cxxPreprocessorInput =
CxxDescriptionEnhancer.collectCxxPreprocessorInput(
targetGraph,
params,
cxxPlatform,
CxxFlags.getLanguageFlags(
args.preprocessorFlags,
args.platformPreprocessorFlags,
args.langPreprocessorFlags,
cxxPlatform),
args.prefixHeaders.get(),
ImmutableList.of(headerSymlinkTree),
ImmutableSet.<Path>of(),
CxxPreprocessables.getTransitiveCxxPreprocessorInput(
targetGraph, cxxPlatform, params.getDeps()));
ImmutableMap<String, CxxSource> allSources =
ImmutableMap.<String, CxxSource>builder()
.putAll(srcs)
.putAll(lexYaccSources.getCxxSources())
.build();
// Generate rule to build the object files.
ImmutableMap<CxxPreprocessAndCompile, SourcePath> picObjects =
CxxSourceRuleFactory.requirePreprocessAndCompileRules(
params,
ruleResolver,
pathResolver,
cxxPlatform,
cxxPreprocessorInput,
CxxFlags.getFlags(args.compilerFlags, args.platformCompilerFlags, cxxPlatform),
cxxBuckConfig.getPreprocessMode(),
allSources,
CxxSourceRuleFactory.PicType.PIC);
// Setup the rules to link the shared library.
String extensionName = getExtensionName(params.getBuildTarget());
Path extensionPath = getExtensionPath(params.getBuildTarget(), cxxPlatform.getFlavor());
return CxxLinkableEnhancer.createCxxLinkableBuildRule(
targetGraph,
cxxPlatform,
params,
pathResolver,
/* extraLdFlags */ CxxFlags.getFlags(
args.linkerFlags, args.platformLinkerFlags, cxxPlatform),
getExtensionTarget(params.getBuildTarget(), cxxPlatform.getFlavor()),
Linker.LinkType.SHARED,
Optional.of(extensionName),
extensionPath,
picObjects.values(),
Linker.LinkableDepType.SHARED,
params.getDeps(),
args.cxxRuntimeType,
Optional.<SourcePath>absent());
}
@Override
public NativeLinkableInput getNativeLinkableInput(
TargetGraph targetGraph, CxxPlatform cxxPlatform, Linker.LinkableDepType type) {
if (!isPlatformSupported(cxxPlatform)) {
return NativeLinkableInput.of();
}
if (headerOnly.apply(cxxPlatform)) {
return NativeLinkableInput.of(
ImmutableList.<SourcePath>of(),
ImmutableList.<String>of(),
Preconditions.checkNotNull(frameworks),
ImmutableSet.<FrameworkPath>of());
}
// Build up the arguments used to link this library. If we're linking the
// whole archive, wrap the library argument in the necessary "ld" flags.
final Pair<ImmutableList<String>, ImmutableSet<SourcePath>> flagsAndBuildInputs =
exportedLinkerFlags.apply(cxxPlatform);
ImmutableList.Builder<String> linkerArgsBuilder = ImmutableList.builder();
linkerArgsBuilder.addAll(flagsAndBuildInputs.getFirst());
final BuildRule libraryRule;
if (type != Linker.LinkableDepType.SHARED || linkage == Linkage.STATIC) {
libraryRule =
requireBuildRule(
targetGraph,
cxxPlatform.getFlavor(),
type == Linker.LinkableDepType.STATIC
? CxxDescriptionEnhancer.STATIC_FLAVOR
: CxxDescriptionEnhancer.STATIC_PIC_FLAVOR);
Path staticLibraryPath =
CxxDescriptionEnhancer.getStaticLibraryPath(
getBuildTarget(),
cxxPlatform.getFlavor(),
type == Linker.LinkableDepType.STATIC
? CxxSourceRuleFactory.PicType.PDC
: CxxSourceRuleFactory.PicType.PIC);
if (linkWhole) {
Linker linker = cxxPlatform.getLd();
linkerArgsBuilder.addAll(linker.linkWhole(staticLibraryPath.toString()));
} else {
linkerArgsBuilder.add(staticLibraryPath.toString());
}
} else {
String sharedLibrarySoname =
soname.or(
CxxDescriptionEnhancer.getDefaultSharedLibrarySoname(
params.getBuildTarget(), cxxPlatform));
Path sharedLibraryPath =
CxxDescriptionEnhancer.getSharedLibraryPath(
getBuildTarget(), sharedLibrarySoname, cxxPlatform);
libraryRule =
requireBuildRule(
targetGraph, cxxPlatform.getFlavor(), CxxDescriptionEnhancer.SHARED_FLAVOR);
linkerArgsBuilder.add(sharedLibraryPath.toString());
}
final ImmutableList<String> linkerArgs = linkerArgsBuilder.build();
return NativeLinkableInput.of(
ImmutableList.<SourcePath>builder()
.add(new BuildTargetSourcePath(libraryRule.getBuildTarget()))
.addAll(flagsAndBuildInputs.getSecond())
.build(),
linkerArgs,
Preconditions.checkNotNull(frameworks),
Preconditions.checkNotNull(libraries));
}
public void doTestSimpleCxxBinaryBuilds(String preprocessMode, boolean expectPreprocessorOutput)
throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "simple", tmp);
workspace.setUp();
workspace.writeContentsToPath(
String.format("[cxx]\npreprocess_mode = %s\n", preprocessMode), ".buckconfig");
CxxPlatform cxxPlatform = DefaultCxxPlatforms.build(new CxxBuckConfig(new FakeBuckConfig()));
BuildTarget target = BuildTargetFactory.newInstance("//foo:simple");
CxxSourceRuleFactory cxxSourceRuleFactory = CxxSourceRuleFactoryHelper.of(target, cxxPlatform);
BuildTarget binaryTarget = CxxDescriptionEnhancer.createCxxLinkTarget(target);
String sourceName = "simple.cpp";
String sourceFull = "foo/" + sourceName;
BuildTarget preprocessTarget =
cxxSourceRuleFactory.createPreprocessBuildTarget(
sourceName, CxxSource.Type.CXX, CxxSourceRuleFactory.PicType.PDC);
BuildTarget compileTarget =
cxxSourceRuleFactory.createCompileBuildTarget(sourceName, CxxSourceRuleFactory.PicType.PDC);
BuildTarget headerSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
target, cxxPlatform.getFlavor(), HeaderVisibility.PRIVATE);
// Do a clean build, verify that it succeeds, and check that all expected targets built
// successfully.
workspace.runBuckCommand("build", target.toString()).assertSuccess();
BuckBuildLog buildLog = workspace.getBuildLog();
ImmutableSet<BuildTarget> expectedTargets =
ImmutableSet.<BuildTarget>builder()
.addAll(ImmutableSet.of(headerSymlinkTreeTarget, compileTarget, binaryTarget, target))
.addAll(
(expectPreprocessorOutput
? ImmutableSet.of(preprocessTarget)
: ImmutableSet.<BuildTarget>of()))
.build();
assertEquals(expectedTargets, buildLog.getAllTargets());
buildLog.assertTargetBuiltLocally(headerSymlinkTreeTarget.toString());
if (expectPreprocessorOutput) {
buildLog.assertTargetBuiltLocally(preprocessTarget.toString());
}
buildLog.assertTargetBuiltLocally(compileTarget.toString());
buildLog.assertTargetBuiltLocally(binaryTarget.toString());
buildLog.assertTargetBuiltLocally(target.toString());
// Clear for new build.
workspace.resetBuildLogFile();
// Check that running a build again results in no builds since everything is up to
// date.
workspace.runBuckCommand("build", target.toString()).assertSuccess();
buildLog = workspace.getBuildLog();
assertEquals(ImmutableSet.of(target, binaryTarget), buildLog.getAllTargets());
buildLog.assertTargetHadMatchingRuleKey(binaryTarget.toString());
buildLog.assertTargetHadMatchingRuleKey(target.toString());
// Clear for new build.
workspace.resetBuildLogFile();
// Update the source file.
workspace.replaceFileContents(sourceFull, "{}", "{ return 0; }");
// Check that running a build again makes the source get recompiled and the binary
// re-linked, but does not cause the header rules to re-run.
workspace.runBuckCommand("build", target.toString()).assertSuccess();
buildLog = workspace.getBuildLog();
assertEquals(expectedTargets, buildLog.getAllTargets());
buildLog.assertTargetHadMatchingRuleKey(headerSymlinkTreeTarget.toString());
if (expectPreprocessorOutput) {
buildLog.assertTargetBuiltLocally(preprocessTarget.toString());
}
buildLog.assertTargetBuiltLocally(compileTarget.toString());
assertThat(
buildLog.getLogEntry(binaryTarget).getSuccessType().get(),
Matchers.not(Matchers.equalTo(BuildRuleSuccessType.MATCHING_RULE_KEY)));
buildLog.assertTargetBuiltLocally(target.toString());
// Clear for new build.
workspace.resetBuildLogFile();
// Update the source file.
workspace.replaceFileContents(sourceFull, "{ return 0; }", "won't compile");
// Check that running a build again makes the source get recompiled and the binary
// re-linked, but does not cause the header rules to re-run.
workspace.runBuckCommand("build", target.toString()).assertFailure();
buildLog = workspace.getBuildLog();
assertEquals(expectedTargets, buildLog.getAllTargets());
buildLog.assertTargetHadMatchingRuleKey(headerSymlinkTreeTarget.toString());
if (expectPreprocessorOutput) {
buildLog.assertTargetBuiltLocally(preprocessTarget.toString());
}
assertThat(
buildLog.getLogEntry(binaryTarget).getStatus(), Matchers.equalTo(BuildRuleStatus.CANCELED));
assertThat(
buildLog.getLogEntry(target).getStatus(), Matchers.equalTo(BuildRuleStatus.CANCELED));
}
@Test
public void testInferCxxBinaryWithDeps() throws IOException {
assumeTrue(Platform.detect() != Platform.WINDOWS);
ProjectWorkspace workspace = InferHelper.setupCxxInferWorkspace(this, tmp);
CxxPlatform cxxPlatform = DefaultCxxPlatforms.build(new CxxBuckConfig(new FakeBuckConfig()));
BuildTarget inputBuildTarget = BuildTargetFactory.newInstance("//foo:binary_with_deps");
String inputBuildTargetName =
inputBuildTarget.withFlavors(CxxInferEnhancer.INFER).getFullyQualifiedName();
/*
* Build the given target and check that it succeeds.
*/
workspace.runBuckCommand("build", inputBuildTargetName).assertSuccess();
/*
* Check that all the required build targets have been generated.
*/
String sourceName = "src_with_deps.c";
CxxSourceRuleFactory cxxSourceRuleFactory =
CxxSourceRuleFactoryHelper.of(inputBuildTarget, cxxPlatform);
// 1. create the targets of binary_with_deps
// this is unflavored, but bounded to the InferCapture build rule
BuildTarget topCaptureBuildTarget =
cxxSourceRuleFactory.createInferCaptureBuildTarget(sourceName);
// this is unflavored, but necessary to run the compiler successfully
BuildTarget topHeaderSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
inputBuildTarget, cxxPlatform.getFlavor(), HeaderVisibility.PRIVATE);
// this is flavored, and denotes the analysis step (generates a local report)
BuildTarget topInferAnalysisTarget =
inputBuildTarget.withFlavors(CxxInferEnhancer.INFER_ANALYZE);
// this is flavored and corresponds to the top level target (the one give in input to buck)
BuildTarget topInferReportTarget = inputBuildTarget.withFlavors(CxxInferEnhancer.INFER);
// 2. create the targets of dep_one
BuildTarget depOneBuildTarget = BuildTargetFactory.newInstance("//foo:dep_one");
String depOneSourceName = "dep_one.c";
String depOneSourceFull = "foo/" + depOneSourceName;
CxxSourceRuleFactory depOneSourceRuleFactory =
CxxSourceRuleFactoryHelper.of(depOneBuildTarget, cxxPlatform);
BuildTarget depOneCaptureBuildTarget =
depOneSourceRuleFactory.createInferCaptureBuildTarget(depOneSourceName);
BuildTarget depOneHeaderSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
depOneBuildTarget, cxxPlatform.getFlavor(), HeaderVisibility.PRIVATE);
BuildTarget depOneExportedHeaderSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
depOneBuildTarget, cxxPlatform.getFlavor(), HeaderVisibility.PUBLIC);
BuildTarget depOneInferAnalysisTarget =
depOneCaptureBuildTarget.withFlavors(
cxxPlatform.getFlavor(), CxxInferEnhancer.INFER_ANALYZE);
// 3. create the targets of dep_two
BuildTarget depTwoBuildTarget = BuildTargetFactory.newInstance("//foo:dep_two");
CxxSourceRuleFactory depTwoSourceRuleFactory =
CxxSourceRuleFactoryHelper.of(depTwoBuildTarget, cxxPlatform);
BuildTarget depTwoCaptureBuildTarget =
depTwoSourceRuleFactory.createInferCaptureBuildTarget("dep_two.c");
BuildTarget depTwoHeaderSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
depTwoBuildTarget, cxxPlatform.getFlavor(), HeaderVisibility.PRIVATE);
BuildTarget depTwoExportedHeaderSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
depTwoBuildTarget, cxxPlatform.getFlavor(), HeaderVisibility.PUBLIC);
BuildTarget depTwoInferAnalysisTarget =
depTwoCaptureBuildTarget.withFlavors(
cxxPlatform.getFlavor(), CxxInferEnhancer.INFER_ANALYZE);
// Check all the targets are in the buildLog
assertEquals(
ImmutableSet.of(
topCaptureBuildTarget,
topHeaderSymlinkTreeTarget,
topInferAnalysisTarget,
topInferReportTarget,
depOneCaptureBuildTarget,
depOneHeaderSymlinkTreeTarget,
depOneExportedHeaderSymlinkTreeTarget,
depOneInferAnalysisTarget,
depTwoCaptureBuildTarget,
depTwoHeaderSymlinkTreeTarget,
depTwoExportedHeaderSymlinkTreeTarget,
depTwoInferAnalysisTarget),
workspace.getBuildLog().getAllTargets());
/*
* Check that running a build again results in no builds since nothing has changed.
*/
workspace.resetBuildLogFile(); // clear for new build
workspace.runBuckCommand("build", inputBuildTargetName).assertSuccess();
BuckBuildLog buildLog = workspace.getBuildLog();
assertEquals(ImmutableSet.of(topInferReportTarget), buildLog.getAllTargets());
buildLog.assertTargetHadMatchingRuleKey(topInferReportTarget.toString());
/*
* Check that if a library source file changes then the capture/analysis rules run again on
* the main target and on dep_one only.
*/
workspace.resetBuildLogFile();
workspace.replaceFileContents(depOneSourceFull, "flag > 0", "flag < 0");
workspace.runBuckCommand("build", inputBuildTargetName).assertSuccess();
buildLog = workspace.getBuildLog();
assertEquals(
ImmutableSet.of(
topInferAnalysisTarget, // analysis runs again
topInferReportTarget, // report runs again
topCaptureBuildTarget, // cached
depTwoInferAnalysisTarget, // cached
depOneCaptureBuildTarget, // capture of the changed file runs again
depOneExportedHeaderSymlinkTreeTarget, // cached
depOneHeaderSymlinkTreeTarget, // cached
depOneInferAnalysisTarget), // analysis of the library runs again
buildLog.getAllTargets());
buildLog.assertTargetBuiltLocally(topInferAnalysisTarget.toString());
buildLog.assertTargetBuiltLocally(topInferReportTarget.toString());
buildLog.assertTargetHadMatchingRuleKey(topCaptureBuildTarget.toString());
buildLog.assertTargetHadMatchingRuleKey(depTwoInferAnalysisTarget.toString());
buildLog.assertTargetBuiltLocally(depOneCaptureBuildTarget.toString());
buildLog.assertTargetHadMatchingRuleKey(depOneExportedHeaderSymlinkTreeTarget.toString());
buildLog.assertTargetHadMatchingRuleKey(depOneHeaderSymlinkTreeTarget.toString());
buildLog.assertTargetBuiltLocally(depOneInferAnalysisTarget.toString());
}
@Test
public void testInferCxxBinaryWithoutDeps() throws IOException {
assumeTrue(Platform.detect() != Platform.WINDOWS);
ProjectWorkspace workspace = InferHelper.setupCxxInferWorkspace(this, tmp);
CxxPlatform cxxPlatform = DefaultCxxPlatforms.build(new CxxBuckConfig(new FakeBuckConfig()));
BuildTarget inputBuildTarget = BuildTargetFactory.newInstance("//foo:simple");
String inputBuildTargetName =
inputBuildTarget.withFlavors(CxxInferEnhancer.INFER).getFullyQualifiedName();
/*
* Build the given target and check that it succeeds.
*/
workspace.runBuckCommand("build", inputBuildTargetName).assertSuccess();
/*
* Check that all the required build targets have been generated.
*/
String sourceName = "simple.cpp";
String sourceFull = "foo/" + sourceName;
CxxSourceRuleFactory cxxSourceRuleFactory =
CxxSourceRuleFactoryHelper.of(inputBuildTarget, cxxPlatform);
// this is unflavored, but bounded to the InferCapture build rule
BuildTarget captureBuildTarget = cxxSourceRuleFactory.createInferCaptureBuildTarget(sourceName);
// this is unflavored, but necessary to run the compiler successfully
BuildTarget headerSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
inputBuildTarget, cxxPlatform.getFlavor(), HeaderVisibility.PRIVATE);
// this is flavored, and denotes the analysis step (generates a local report)
BuildTarget inferAnalysisTarget = inputBuildTarget.withFlavors(CxxInferEnhancer.INFER_ANALYZE);
// this is flavored and corresponds to the top level target (the one give in input to buck)
BuildTarget inferReportTarget = inputBuildTarget.withFlavors(CxxInferEnhancer.INFER);
ImmutableSet<BuildTarget> expectedTargets =
ImmutableSet.<BuildTarget>builder()
.addAll(
ImmutableSet.of(
headerSymlinkTreeTarget,
captureBuildTarget,
inferAnalysisTarget,
inferReportTarget))
.build();
BuckBuildLog buildLog = workspace.getBuildLog();
assertEquals(expectedTargets, buildLog.getAllTargets());
buildLog.assertTargetBuiltLocally(headerSymlinkTreeTarget.toString());
buildLog.assertTargetBuiltLocally(captureBuildTarget.toString());
buildLog.assertTargetBuiltLocally(inferAnalysisTarget.toString());
buildLog.assertTargetBuiltLocally(inferReportTarget.toString());
/*
* Check that running a build again results in no builds since nothing has changed.
*/
workspace.resetBuildLogFile(); // clear for new build
workspace.runBuckCommand("build", inputBuildTargetName).assertSuccess();
buildLog = workspace.getBuildLog();
assertEquals(ImmutableSet.of(inferReportTarget), buildLog.getAllTargets());
buildLog.assertTargetHadMatchingRuleKey(inferReportTarget.toString());
/*
* Check that changing the source file results in running the capture/analysis rules again.
*/
workspace.resetBuildLogFile();
workspace.replaceFileContents(sourceFull, "*s = 42;", "");
workspace.runBuckCommand("build", inputBuildTargetName).assertSuccess();
buildLog = workspace.getBuildLog();
assertEquals(expectedTargets, buildLog.getAllTargets());
buildLog.assertTargetBuiltLocally(captureBuildTarget.toString());
buildLog.assertTargetBuiltLocally(inferAnalysisTarget.toString());
buildLog.assertTargetHadMatchingRuleKey(headerSymlinkTreeTarget.toString());
}
private boolean isPlatformSupported(CxxPlatform cxxPlatform) {
return !supportedPlatformsRegex.isPresent()
|| supportedPlatformsRegex.get().matcher(cxxPlatform.getFlavor().toString()).find();
}
public static CxxLinkAndCompileRules createBuildRulesForCxxBinary(
TargetGraph targetGraph,
BuildRuleParams params,
BuildRuleResolver resolver,
CxxPlatform cxxPlatform,
ImmutableMap<String, CxxSource> srcs,
ImmutableMap<Path, SourcePath> headers,
ImmutableMap<String, SourcePath> lexSrcs,
ImmutableMap<String, SourcePath> yaccSrcs,
CxxPreprocessMode preprocessMode,
Linker.LinkableDepType linkStyle,
Optional<ImmutableList<String>> preprocessorFlags,
Optional<PatternMatchedCollection<ImmutableList<String>>> platformPreprocessorFlags,
Optional<ImmutableMap<CxxSource.Type, ImmutableList<String>>> langPreprocessorFlags,
Optional<ImmutableSortedSet<FrameworkPath>> frameworks,
Optional<ImmutableList<String>> compilerFlags,
Optional<PatternMatchedCollection<ImmutableList<String>>> platformCompilerFlags,
Optional<SourcePath> prefixHeader,
Optional<ImmutableList<String>> linkerFlags,
Optional<PatternMatchedCollection<ImmutableList<String>>> platformLinkerFlags,
Optional<Linker.CxxRuntimeType> cxxRuntimeType) {
SourcePathResolver sourcePathResolver = new SourcePathResolver(resolver);
Path linkOutput = getLinkOutputPath(params.getBuildTarget());
ImmutableList.Builder<Arg> argsBuilder = ImmutableList.builder();
CommandTool.Builder executableBuilder = new CommandTool.Builder();
// Setup the rules to run lex/yacc.
CxxHeaderSourceSpec lexYaccSources =
requireLexYaccSources(params, resolver, sourcePathResolver, cxxPlatform, lexSrcs, yaccSrcs);
// Setup the header symlink tree and combine all the preprocessor input from this rule
// and all dependencies.
HeaderSymlinkTree headerSymlinkTree =
requireHeaderSymlinkTree(
params,
resolver,
sourcePathResolver,
cxxPlatform,
/* includeLexYaccHeaders */ true,
lexSrcs,
yaccSrcs,
headers,
HeaderVisibility.PRIVATE);
ImmutableList<CxxPreprocessorInput> cxxPreprocessorInput =
collectCxxPreprocessorInput(
targetGraph,
params,
cxxPlatform,
CxxFlags.getLanguageFlags(
preprocessorFlags, platformPreprocessorFlags, langPreprocessorFlags, cxxPlatform),
ImmutableList.of(headerSymlinkTree),
getFrameworkSearchPaths(frameworks, cxxPlatform, new SourcePathResolver(resolver)),
CxxPreprocessables.getTransitiveCxxPreprocessorInput(
targetGraph,
cxxPlatform,
FluentIterable.from(params.getDeps())
.filter(Predicates.instanceOf(CxxPreprocessorDep.class))));
// The complete list of input sources.
ImmutableMap<String, CxxSource> sources =
ImmutableMap.<String, CxxSource>builder()
.putAll(srcs)
.putAll(lexYaccSources.getCxxSources())
.build();
// Generate and add all the build rules to preprocess and compile the source to the
// resolver and get the `SourcePath`s representing the generated object files.
ImmutableMap<CxxPreprocessAndCompile, SourcePath> objects =
CxxSourceRuleFactory.requirePreprocessAndCompileRules(
params,
resolver,
sourcePathResolver,
cxxPlatform,
cxxPreprocessorInput,
CxxFlags.getFlags(compilerFlags, platformCompilerFlags, cxxPlatform),
prefixHeader,
preprocessMode,
sources,
linkStyle == Linker.LinkableDepType.STATIC
? CxxSourceRuleFactory.PicType.PDC
: CxxSourceRuleFactory.PicType.PIC);
// Build up the linker flags, which support macro expansion.
ImmutableList<String> resolvedLinkerFlags =
CxxFlags.getFlags(linkerFlags, platformLinkerFlags, cxxPlatform);
argsBuilder.addAll(
FluentIterable.from(resolvedLinkerFlags)
.transform(
MacroArg.toMacroArgFunction(
MACRO_HANDLER,
params.getBuildTarget(),
params.getCellRoots(),
resolver,
params.getProjectFilesystem())));
// Special handling for dynamically linked binaries.
if (linkStyle == Linker.LinkableDepType.SHARED) {
// Create a symlink tree with for all shared libraries needed by this binary.
SymlinkTree sharedLibraries =
resolver.addToIndex(
createSharedLibrarySymlinkTree(
targetGraph,
params,
sourcePathResolver,
cxxPlatform,
Predicates.instanceOf(NativeLinkable.class)));
// Embed a origin-relative library path into the binary so it can find the shared libraries.
argsBuilder.addAll(
StringArg.from(
Linkers.iXlinker(
"-rpath",
String.format(
"%s/%s",
cxxPlatform.getLd().origin(),
linkOutput.getParent().relativize(sharedLibraries.getRoot()).toString()))));
// Add all the shared libraries and the symlink tree as inputs to the tool that represents
// this binary, so that users can attach the proper deps.
executableBuilder.addDep(sharedLibraries);
executableBuilder.addInputs(sharedLibraries.getLinks().values());
}
// Add object files into the args.
argsBuilder.addAll(SourcePathArg.from(sourcePathResolver, objects.values()));
// Generate the final link rule. We use the top-level target as the link rule's
// target, so that it corresponds to the actual binary we build.
CxxLink cxxLink =
CxxLinkableEnhancer.createCxxLinkableBuildRule(
targetGraph,
cxxPlatform,
params,
sourcePathResolver,
createCxxLinkTarget(params.getBuildTarget()),
Linker.LinkType.EXECUTABLE,
Optional.<String>absent(),
linkOutput,
argsBuilder.build(),
linkStyle,
params.getDeps(),
cxxRuntimeType,
Optional.<SourcePath>absent(),
ImmutableSet.<BuildTarget>of());
resolver.addToIndex(cxxLink);
// Add the output of the link as the lone argument needed to invoke this binary as a tool.
executableBuilder.addArg(new BuildTargetSourcePath(cxxLink.getBuildTarget()));
return new CxxLinkAndCompileRules(
cxxLink, ImmutableSortedSet.copyOf(objects.keySet()), executableBuilder.build());
}
public static Path getSharedLibraryPath(BuildTarget target, String soname, CxxPlatform platform) {
return BuildTargets.getGenPath(
createSharedLibraryBuildTarget(target, platform.getFlavor()), "%s/" + soname);
}
/**
* Generate {@link Lex} and {@link Yacc} rules generating C/C++ sources from the given lex/yacc
* sources.
*
* @return {@link CxxHeaderSourceSpec} containing the generated headers/sources
*/
public static CxxHeaderSourceSpec createLexYaccBuildRules(
BuildRuleParams params,
BuildRuleResolver resolver,
CxxPlatform cxxPlatform,
ImmutableList<String> lexFlags,
ImmutableMap<String, SourcePath> lexSrcs,
ImmutableList<String> yaccFlags,
ImmutableMap<String, SourcePath> yaccSrcs) {
if (!lexSrcs.isEmpty() && !cxxPlatform.getLex().isPresent()) {
throw new HumanReadableException(
"Platform %s must support lex to compile srcs %s", cxxPlatform, lexSrcs);
}
if (!yaccSrcs.isEmpty() && !cxxPlatform.getYacc().isPresent()) {
throw new HumanReadableException(
"Platform %s must support yacc to compile srcs %s", cxxPlatform, yaccSrcs);
}
SourcePathResolver pathResolver = new SourcePathResolver(resolver);
ImmutableMap.Builder<String, CxxSource> lexYaccCxxSourcesBuilder = ImmutableMap.builder();
ImmutableMap.Builder<Path, SourcePath> lexYaccHeadersBuilder = ImmutableMap.builder();
// Loop over all lex sources, generating build rule for each one and adding the sources
// and headers it generates to our bookkeeping maps.
UnflavoredBuildTarget unflavoredBuildTarget =
params.getBuildTarget().getUnflavoredBuildTarget();
for (ImmutableMap.Entry<String, SourcePath> ent : lexSrcs.entrySet()) {
final String name = ent.getKey();
final SourcePath source = ent.getValue();
BuildTarget target = createLexBuildTarget(unflavoredBuildTarget, name);
Path outputSource = getLexSourceOutputPath(unflavoredBuildTarget, name);
Path outputHeader = getLexHeaderOutputPath(unflavoredBuildTarget, name);
// Create the build rule to run lex on this source and add it to the resolver.
Lex lex =
new Lex(
params.copyWithChanges(
target,
Suppliers.ofInstance(
ImmutableSortedSet.copyOf(
pathResolver.filterBuildRuleInputs(ImmutableList.of(source)))),
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
pathResolver,
cxxPlatform.getLex().get(),
ImmutableList.<String>builder()
.addAll(cxxPlatform.getLexFlags())
.addAll(lexFlags)
.build(),
outputSource,
outputHeader,
source);
resolver.addToIndex(lex);
// Record the output source and header as {@link BuildRuleSourcePath} objects.
lexYaccCxxSourcesBuilder.put(
name + ".cc",
CxxSource.of(
CxxSource.Type.CXX,
new BuildTargetSourcePath(lex.getBuildTarget(), outputSource),
ImmutableList.<String>of()));
lexYaccHeadersBuilder.put(
params.getBuildTarget().getBasePath().resolve(name + ".h"),
new BuildTargetSourcePath(lex.getBuildTarget(), outputHeader));
}
// Loop over all yaccc sources, generating build rule for each one and adding the sources
// and headers it generates to our bookkeeping maps.
for (ImmutableMap.Entry<String, SourcePath> ent : yaccSrcs.entrySet()) {
final String name = ent.getKey();
final SourcePath source = ent.getValue();
BuildTarget target = createYaccBuildTarget(unflavoredBuildTarget, name);
Path outputPrefix =
getYaccOutputPrefix(unflavoredBuildTarget, Files.getNameWithoutExtension(name));
// Create the build rule to run yacc on this source and add it to the resolver.
Yacc yacc =
new Yacc(
params.copyWithChanges(
target,
Suppliers.ofInstance(
ImmutableSortedSet.copyOf(
pathResolver.filterBuildRuleInputs(ImmutableList.of(source)))),
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
pathResolver,
cxxPlatform.getYacc().get(),
ImmutableList.<String>builder()
.addAll(cxxPlatform.getYaccFlags())
.addAll(yaccFlags)
.build(),
outputPrefix,
source);
resolver.addToIndex(yacc);
// Record the output source and header as {@link BuildRuleSourcePath} objects.
lexYaccCxxSourcesBuilder.put(
name + ".cc",
CxxSource.of(
CxxSource.Type.CXX,
new BuildTargetSourcePath(
yacc.getBuildTarget(), Yacc.getSourceOutputPath(outputPrefix)),
ImmutableList.<String>of()));
lexYaccHeadersBuilder.put(
params.getBuildTarget().getBasePath().resolve(name + ".h"),
new BuildTargetSourcePath(yacc.getBuildTarget(), Yacc.getHeaderOutputPath(outputPrefix)));
}
return CxxHeaderSourceSpec.of(lexYaccHeadersBuilder.build(), lexYaccCxxSourcesBuilder.build());
}
