Add a CODEC for LibraryToLink, which is required to serialize CppLinkAction.

PiperOrigin-RevId: 185029456

2 files changed, 78 insertions, 19 deletions

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 469d424da5..70ab54de4f 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.common.collect.Iterables;
 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 @@ public abstract class LinkerInputs {
    * 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 @@ public abstract class LinkerInputs {
   }
 
   /**
-   * 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 @@ public abstract class LinkerInputs {
     }
   }
 
-  /**
-   * 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 @@ public abstract class LinkerInputs {
     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 935eac4f04..6ab5488005 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.analysis.config.BuildConfiguration;
 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 @@ import java.util.Map;
  * 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 @@ public final class LtoBackendArtifacts {
   // 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,