Java tutorial
// Copyright 2014 The Bazel Authors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.devtools.build.lib.rules.cpp; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSetMultimap; import com.google.common.collect.Iterables; import com.google.devtools.build.lib.actions.Artifact; import com.google.devtools.build.lib.rules.cpp.Link.LinkStaticness; import com.google.devtools.build.lib.rules.cpp.LinkerInputs.LibraryToLink; import com.google.devtools.build.lib.util.Preconditions; import com.google.devtools.build.lib.vfs.FileSystemUtils; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; /** * A structured representation of the link outputs of a C++ rule. */ public class CcLinkingOutputs { public static final CcLinkingOutputs EMPTY = new Builder().build(); private final ImmutableList<LibraryToLink> staticLibraries; private final ImmutableList<LibraryToLink> picStaticLibraries; private final ImmutableList<LibraryToLink> dynamicLibraries; private final ImmutableList<LibraryToLink> executionDynamicLibraries; private CcLinkingOutputs(ImmutableList<LibraryToLink> staticLibraries, ImmutableList<LibraryToLink> picStaticLibraries, ImmutableList<LibraryToLink> dynamicLibraries, ImmutableList<LibraryToLink> executionDynamicLibraries) { this.staticLibraries = staticLibraries; this.picStaticLibraries = picStaticLibraries; this.dynamicLibraries = dynamicLibraries; this.executionDynamicLibraries = executionDynamicLibraries; } public ImmutableList<LibraryToLink> getStaticLibraries() { return staticLibraries; } public ImmutableList<LibraryToLink> getPicStaticLibraries() { return picStaticLibraries; } public ImmutableList<LibraryToLink> getDynamicLibraries() { return dynamicLibraries; } public ImmutableList<LibraryToLink> getExecutionDynamicLibraries() { return executionDynamicLibraries; } /** * Returns a map from library identifiers to sets of LibraryToLink from this CcLinkingOutputs * which share that library identifier. */ public ImmutableSetMultimap<String, LibraryToLink> getLibrariesByIdentifier() { return getLibrariesByIdentifier( Iterables.concat(staticLibraries, picStaticLibraries, dynamicLibraries, executionDynamicLibraries)); } /** * Gathers up a map from library identifiers to sets of LibraryToLink which share that library * identifier. */ public static ImmutableSetMultimap<String, LibraryToLink> getLibrariesByIdentifier( Iterable<LibraryToLink> inputs) { ImmutableSetMultimap.Builder<String, LibraryToLink> result = new ImmutableSetMultimap.Builder<>(); for (LibraryToLink library : inputs) { Preconditions.checkNotNull(library.getLibraryIdentifier()); result.put(library.getLibraryIdentifier(), library); } return result.build(); } /** * Add the ".a", ".pic.a" and/or ".so" files in appropriate order of preference depending on the * link preferences. * * <p>This method tries to simulate a search path for adding static and dynamic libraries, * allowing either to be preferred over the other depending on the link {@link LinkStaticness}. * * TODO(bazel-team): (2009) we should preserve the relative ordering of first and second * choice libraries. E.g. if srcs=['foo.a','bar.so','baz.a'] then we should link them in the * same order. Currently we link entries from the first choice list before those from the * second choice list, i.e. in the order {@code ['bar.so', 'foo.a', 'baz.a']}. * * @param linkingStatically whether to prefer static over dynamic libraries. Should be * <code>true</code> for binaries that are linked in fully static or mostly static mode. * @param preferPic whether to prefer pic over non pic libraries (usually used when linking * shared) */ public List<LibraryToLink> getPreferredLibraries(boolean linkingStatically, boolean preferPic) { return getPreferredLibraries(linkingStatically, preferPic, false); } /** * Returns the shared libraries that are linked against and therefore also need to be in the * runfiles. */ public Iterable<Artifact> getLibrariesForRunfiles(boolean linkingStatically) { List<LibraryToLink> libraries = getPreferredLibraries(linkingStatically, /*preferPic*/false, true); return PrecompiledFiles.getSharedLibrariesFrom(LinkerInputs.toLibraryArtifacts(libraries)); } /** * Add the ".a", ".pic.a" and/or ".so" files in appropriate order of * preference depending on the link preferences. */ private List<LibraryToLink> getPreferredLibraries(boolean linkingStatically, boolean preferPic, boolean forRunfiles) { List<LibraryToLink> candidates = new ArrayList<>(); // It's important that this code keeps the invariant that preferPic has no effect on the output // of .so libraries. That is, the resulting list should contain the same .so files in the same // order. if (linkingStatically) { // Prefer the static libraries. if (preferPic) { // First choice is the PIC static libraries. // Second choice is the other static libraries (may cause link error if they're not PIC, // but I think this is preferable to linking dynamically when you asked for statically). candidates.addAll(picStaticLibraries); candidates.addAll(staticLibraries); } else { // First choice is the non-pic static libraries (best performance); // second choice is the staticPicLibraries (at least they're static; // we can live with the extra overhead of PIC). candidates.addAll(staticLibraries); candidates.addAll(picStaticLibraries); } candidates.addAll(forRunfiles ? executionDynamicLibraries : dynamicLibraries); } else { // First choice is the dynamicLibraries. candidates.addAll(forRunfiles ? executionDynamicLibraries : dynamicLibraries); if (preferPic) { // Second choice is the staticPicLibraries (at least they're PIC, so we won't get a // link error). candidates.addAll(picStaticLibraries); candidates.addAll(staticLibraries); } else { candidates.addAll(staticLibraries); candidates.addAll(picStaticLibraries); } } return filterCandidates(candidates); } /** * Helper method to filter the candidates by removing equivalent library * entries from the list of candidates. * * @param candidates the library candidates to filter * @return the list of libraries with equivalent duplicate libraries removed. */ private List<LibraryToLink> filterCandidates(List<LibraryToLink> candidates) { List<LibraryToLink> libraries = new ArrayList<>(); Set<String> identifiers = new HashSet<>(); for (LibraryToLink library : candidates) { Preconditions.checkNotNull(library.getLibraryIdentifier()); if (identifiers.add(library.getLibraryIdentifier())) { libraries.add(library); } } return libraries; } /** * Returns the library identifier of an artifact: a string that is different for different * libraries, but is the same for the shared, static and pic versions of the same library. */ public static String libraryIdentifierOf(Artifact libraryArtifact) { String name = libraryArtifact.getRootRelativePath().getPathString(); String basename = FileSystemUtils.removeExtension(name); // Need to special-case file types with double extension. return name.endsWith(".pic.a") ? FileSystemUtils.removeExtension(basename) : name.endsWith(".nopic.a") ? FileSystemUtils.removeExtension(basename) : name.endsWith(".pic.lo") ? FileSystemUtils.removeExtension(basename) : basename; } public static Builder builder() { return new Builder(); } public static final class Builder { private final Set<LibraryToLink> staticLibraries = new LinkedHashSet<>(); private final Set<LibraryToLink> picStaticLibraries = new LinkedHashSet<>(); private final Set<LibraryToLink> dynamicLibraries = new LinkedHashSet<>(); private final Set<LibraryToLink> executionDynamicLibraries = new LinkedHashSet<>(); public CcLinkingOutputs build() { return new CcLinkingOutputs(ImmutableList.copyOf(staticLibraries), ImmutableList.copyOf(picStaticLibraries), ImmutableList.copyOf(dynamicLibraries), ImmutableList.copyOf(executionDynamicLibraries)); } public Builder merge(CcLinkingOutputs outputs) { staticLibraries.addAll(outputs.getStaticLibraries()); picStaticLibraries.addAll(outputs.getPicStaticLibraries()); dynamicLibraries.addAll(outputs.getDynamicLibraries()); executionDynamicLibraries.addAll(outputs.getExecutionDynamicLibraries()); return this; } public Builder addStaticLibrary(LibraryToLink library) { staticLibraries.add(library); return this; } public Builder addStaticLibraries(Iterable<LibraryToLink> libraries) { Iterables.addAll(staticLibraries, libraries); return this; } public Builder addPicStaticLibrary(LibraryToLink library) { picStaticLibraries.add(library); return this; } public Builder addPicStaticLibraries(Iterable<LibraryToLink> libraries) { Iterables.addAll(picStaticLibraries, libraries); return this; } public Builder addDynamicLibrary(LibraryToLink library) { dynamicLibraries.add(library); return this; } public Builder addDynamicLibraries(Iterable<LibraryToLink> libraries) { Iterables.addAll(dynamicLibraries, libraries); return this; } public Builder addExecutionDynamicLibrary(LibraryToLink library) { executionDynamicLibraries.add(library); return this; } public Builder addExecutionDynamicLibraries(Iterable<LibraryToLink> libraries) { Iterables.addAll(executionDynamicLibraries, libraries); return this; } } }