Add a CODEC for LibraryToLink, which is required to serialize CppLinkAction.
PiperOrigin-RevId: 185029456
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/LinkerInputs.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/LinkerInputs.java
index 469d424..70ab54d 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/LinkerInputs.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/LinkerInputs.java
@@ -20,6 +20,11 @@
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.collect.CollectionUtils;
import com.google.devtools.build.lib.concurrent.ThreadSafety;
+import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec;
+import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
+import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec.Strategy;
+import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec.VisibleForSerialization;
+import com.google.devtools.build.lib.vfs.FileSystemProvider;
/**
* Factory for creating new {@link LinkerInput} objects.
@@ -135,7 +140,11 @@
* A library the user can link to. This is different from a simple linker input in that it also
* has a library identifier.
*/
+ @AutoCodec(strategy = Strategy.POLYMORPHIC, dependency = FileSystemProvider.class)
public interface LibraryToLink extends LinkerInput {
+ public static final InjectingObjectCodec<LibraryToLink, FileSystemProvider> CODEC =
+ new LinkerInputs_LibraryToLink_AutoCodec();
+
ImmutableMap<Artifact, Artifact> getLtoBitcodeFiles();
/**
@@ -156,17 +165,23 @@
}
/**
- * This class represents a solib library symlink. Its library identifier is inherited from
- * the library that it links to.
+ * This class represents a solib library symlink. Its library identifier is inherited from the
+ * library that it links to.
*/
@ThreadSafety.Immutable
+ @AutoCodec(dependency = FileSystemProvider.class)
public static class SolibLibraryToLink implements LibraryToLink {
+ public static final InjectingObjectCodec<SolibLibraryToLink, FileSystemProvider> CODEC =
+ new LinkerInputs_SolibLibraryToLink_AutoCodec();
+
private final Artifact solibSymlinkArtifact;
private final Artifact libraryArtifact;
private final String libraryIdentifier;
- private SolibLibraryToLink(Artifact solibSymlinkArtifact, Artifact libraryArtifact,
- String libraryIdentifier) {
+ @AutoCodec.Instantiator
+ @VisibleForSerialization
+ SolibLibraryToLink(
+ Artifact solibSymlinkArtifact, Artifact libraryArtifact, String libraryIdentifier) {
Preconditions.checkArgument(
Link.SHARED_LIBRARY_FILETYPES.matches(solibSymlinkArtifact.getFilename()));
this.solibSymlinkArtifact = solibSymlinkArtifact;
@@ -249,11 +264,14 @@
}
}
- /**
- * This class represents a library that may contain object files.
- */
+ /** This class represents a library that may contain object files. */
@ThreadSafety.Immutable
- private static class CompoundLibraryToLink implements LibraryToLink {
+ @AutoCodec(dependency = FileSystemProvider.class)
+ @VisibleForSerialization
+ static class CompoundLibraryToLink implements LibraryToLink {
+ public static final InjectingObjectCodec<CompoundLibraryToLink, FileSystemProvider> CODEC =
+ new LinkerInputs_CompoundLibraryToLink_AutoCodec();
+
private final Artifact libraryArtifact;
private final ArtifactCategory category;
private final String libraryIdentifier;
@@ -261,6 +279,23 @@
private final ImmutableMap<Artifact, Artifact> ltoBitcodeFiles;
private final ImmutableMap<Artifact, LtoBackendArtifacts> sharedNonLtoBackends;
+ @AutoCodec.Instantiator
+ @VisibleForSerialization
+ CompoundLibraryToLink(
+ Artifact libraryArtifact,
+ ArtifactCategory category,
+ String libraryIdentifier,
+ Iterable<Artifact> objectFiles,
+ ImmutableMap<Artifact, Artifact> ltoBitcodeFiles,
+ ImmutableMap<Artifact, LtoBackendArtifacts> sharedNonLtoBackends) {
+ this.libraryArtifact = libraryArtifact;
+ this.category = category;
+ this.libraryIdentifier = libraryIdentifier;
+ this.objectFiles = objectFiles;
+ this.ltoBitcodeFiles = ltoBitcodeFiles;
+ this.sharedNonLtoBackends = sharedNonLtoBackends;
+ }
+
private CompoundLibraryToLink(
Artifact libraryArtifact,
ArtifactCategory category,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/LtoBackendArtifacts.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/LtoBackendArtifacts.java
index 935eac4..6ab5488 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/LtoBackendArtifacts.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/LtoBackendArtifacts.java
@@ -22,6 +22,10 @@
import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FeatureConfiguration;
import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Variables;
import com.google.devtools.build.lib.rules.cpp.CppConfiguration.Tool;
+import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec;
+import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
+import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec.VisibleForSerialization;
+import com.google.devtools.build.lib.vfs.FileSystemProvider;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.util.ArrayList;
@@ -35,20 +39,25 @@
* step process:
*
* <ul>
- * <li>1. Bitcode generation (N times). This is produces intermediate LLVM bitcode from a source
- * file. For this product, it reuses the .o extension.
- * <li>2. Indexing (once on N files). This takes all bitcode .o files, and for each .o file, it
- * decides from which other .o files symbols can be inlined. In addition, it generates an index
- * for looking up these symbols, and an imports file for identifying new input files for each
- * step 3 {@link LtoBackendAction}.
- * <li>3. Backend compile (N times). This is the traditional compilation, and uses the same command
- * line as the Bitcode generation in 1). Since the compiler has many bit code files available,
- * it can inline functions and propagate constants across .o files. This step is costly, as it
- * will do traditional optimization. The result is a .lto.o file, a traditional ELF object file.
- * <li>4. Backend link (once). This is the traditional link, and produces the final executable.
+ * <li>1. Bitcode generation (N times). This is produces intermediate LLVM bitcode from a source
+ * file. For this product, it reuses the .o extension.
+ * <li>2. Indexing (once on N files). This takes all bitcode .o files, and for each .o file, it
+ * decides from which other .o files symbols can be inlined. In addition, it generates an
+ * index for looking up these symbols, and an imports file for identifying new input files for
+ * each step 3 {@link LtoBackendAction}.
+ * <li>3. Backend compile (N times). This is the traditional compilation, and uses the same
+ * command line as the Bitcode generation in 1). Since the compiler has many bit code files
+ * available, it can inline functions and propagate constants across .o files. This step is
+ * costly, as it will do traditional optimization. The result is a .lto.o file, a traditional
+ * ELF object file.
+ * <li>4. Backend link (once). This is the traditional link, and produces the final executable.
* </ul>
*/
+@AutoCodec(dependency = FileSystemProvider.class)
public final class LtoBackendArtifacts {
+ public static final InjectingObjectCodec<LtoBackendArtifacts, FileSystemProvider> CODEC =
+ new LtoBackendArtifacts_AutoCodec();
+
// A file containing mapping of symbol => bitcode file containing the symbol.
private final Artifact index;
@@ -64,6 +73,21 @@
// The corresponding dwoFile if fission is used.
private Artifact dwoFile;
+ @AutoCodec.Instantiator
+ @VisibleForSerialization
+ LtoBackendArtifacts(
+ Artifact index,
+ Artifact bitcodeFile,
+ Artifact imports,
+ Artifact objectFile,
+ Artifact dwoFile) {
+ this.index = index;
+ this.bitcodeFile = bitcodeFile;
+ this.imports = imports;
+ this.objectFile = objectFile;
+ this.dwoFile = dwoFile;
+ }
+
LtoBackendArtifacts(
PathFragment ltoOutputRootPrefix,
Artifact bitcodeFile,
