diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLinkingHelper.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLinkingHelper.java
index 7d31b969243471..7b79b4922c461c 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLinkingHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLinkingHelper.java
@@ -736,7 +736,8 @@ private boolean createDynamicLinkAction(
                 "-Wl,-soname="
                     + SolibSymlinkAction.getDynamicLibrarySoname(
                         linkerOutput.getRootRelativePath(),
-                        /* preserveName= */ false,
+                        /* preserveName= */ dynamicLinkType
+                            != LinkTargetType.NODEPS_DYNAMIC_LIBRARY,
                         actionConstructionContext.getConfiguration().getMnemonic()));
       }
     }
@@ -841,6 +842,10 @@ private boolean createDynamicLinkAction(
     if (dynamicLinkActionBuilder.getAllLtoBackendArtifacts() != null) {
       ccLinkingOutputs.addAllLtoArtifacts(dynamicLinkActionBuilder.getAllLtoBackendArtifacts());
     }
+    Artifact implLibraryLinkArtifact = getDynamicLibrarySolibSymlinkOutput(linkerOutput);
+    if (implLibraryLinkArtifact != null) {
+      dynamicLinkActionBuilder.setDynamicLibrarySolibSymlinkOutput(implLibraryLinkArtifact);
+    }
     CppLinkAction dynamicLinkAction = dynamicLinkActionBuilder.build();
     if (dynamicLinkType.isExecutable()) {
       ccLinkingOutputs.setExecutable(linkerOutput);
@@ -866,14 +871,16 @@ private boolean createDynamicLinkAction(
         }
         libraryToLinkBuilder.setDynamicLibrary(dynamicLibrary.getArtifact());
       } else {
-        Artifact implLibraryLinkArtifact =
-            SolibSymlinkAction.getDynamicLibrarySymlink(
-                /* actionRegistry= */ actionRegistry,
-                /* actionConstructionContext= */ actionConstructionContext,
-                ccToolchain.getSolibDirectory(),
-                dynamicLibrary.getArtifact(),
-                /* preserveName= */ false,
-                /* prefixConsumer= */ false);
+        if (dynamicLinkType == LinkTargetType.NODEPS_DYNAMIC_LIBRARY) {
+          implLibraryLinkArtifact =
+              SolibSymlinkAction.getDynamicLibrarySymlink(
+                  /* actionRegistry= */ actionRegistry,
+                  /* actionConstructionContext= */ actionConstructionContext,
+                  ccToolchain.getSolibDirectory(),
+                  dynamicLibrary.getArtifact(),
+                  /* preserveName= */ false,
+                  /* prefixConsumer= */ false);
+        }
         libraryToLinkBuilder.setDynamicLibrary(implLibraryLinkArtifact);
         libraryToLinkBuilder.setResolvedSymlinkDynamicLibrary(dynamicLibrary.getArtifact());
 
@@ -884,7 +891,8 @@ private boolean createDynamicLinkAction(
                   /* actionConstructionContext= */ actionConstructionContext,
                   ccToolchain.getSolibDirectory(),
                   interfaceLibrary.getArtifact(),
-                  /* preserveName= */ false,
+                  // Need to preserve name for transitive shared libraries that may be distributed.
+                  /* preserveName= */ dynamicLinkType != LinkTargetType.NODEPS_DYNAMIC_LIBRARY,
                   /* prefixConsumer= */ false);
           libraryToLinkBuilder.setInterfaceLibrary(libraryLinkArtifact);
           libraryToLinkBuilder.setResolvedSymlinkInterfaceLibrary(interfaceLibrary.getArtifact());
@@ -1048,4 +1056,24 @@ private static List<LinkerInputs.LibraryToLink> convertLibraryToLinkListToLinker
     }
     return librariesToLinkBuilder.build();
   }
+
+  @Nullable
+  private Artifact getDynamicLibrarySolibSymlinkOutput(Artifact linkerOutputArtifact) {
+    if (dynamicLinkType != LinkTargetType.DYNAMIC_LIBRARY
+        || neverlink
+        || featureConfiguration.isEnabled(CppRuleClasses.COPY_DYNAMIC_LIBRARIES_TO_BINARY)) {
+      return null;
+    }
+    return SolibSymlinkAction.getDynamicLibrarySymlink(
+        /* actionRegistry= */ actionRegistry,
+        /* actionConstructionContext= */ actionConstructionContext,
+        ccToolchain.getSolibDirectory(),
+        linkerOutputArtifact,
+        // For transitive shared libraries we want to preserve the name of the original library so
+        // that distribution artifacts can be linked against it and not against the mangled name.
+        // This makes it possible to find the library on the system if the RPATH has been set
+        // properly.
+        /* preserveName= */ true,
+        /* prefixConsumer= */ false);
+  }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
index 7a1968150e1844..6e959e14cc01be 100755
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
@@ -93,6 +93,18 @@
 import net.starlark.java.eval.StarlarkThread;
 import net.starlark.java.eval.Structure;
 import net.starlark.java.eval.Tuple;
+import com.google.devtools.build.docgen.annot.DocCategory;
+import com.google.devtools.build.lib.starlarkbuildapi.core.ProviderApi;
+import net.starlark.java.annot.Param;
+import net.starlark.java.annot.ParamType;
+import net.starlark.java.annot.StarlarkBuiltin;
+import net.starlark.java.annot.StarlarkMethod;
+import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
+import com.google.devtools.build.lib.packages.BuiltinProvider;
+import com.google.devtools.build.lib.packages.NativeInfo;
+import com.google.devtools.build.docgen.annot.StarlarkConstructor;
+import com.google.devtools.build.lib.starlarkbuildapi.core.StructApi;
+import net.starlark.java.eval.Starlark;
 
 /**
  * A module that contains Starlark utilities for C++ support.
@@ -139,11 +151,120 @@ public abstract class CcModule
 
   public abstract CppSemantics getSemantics(Language language);
 
+  /**
+   * This class exists only for a 6.3 cherrypick. For 7.0 this will be in Starlark.
+   */
+  @StarlarkBuiltin(
+    name = "CcSharedLibraryHintInfo",
+    category = DocCategory.PROVIDER,
+    documented = false
+  )
+  @Immutable
+  private static final class CcSharedLibraryHintInfo extends NativeInfo implements StructApi {
+    private static final Provider PROVIDER = new Provider();
+
+    private final List<String> attributes;
+    private final List<Label> owners;
+
+    public CcSharedLibraryHintInfo(
+        List<String> attributes,
+        List<Label> owners) {
+      this.attributes = attributes;
+      this.owners = owners;
+    }
+
+    @StarlarkMethod(
+      name = "attributes",
+      structField = true,
+      allowReturnNones = true,
+      documented = false)
+    @Nullable
+    public Sequence<String> getAttributes() {
+      return attributes == null ? null : StarlarkList.immutableCopyOf(attributes);
+    }
+
+    @StarlarkMethod(
+      name = "owners",
+      structField = true,
+      allowReturnNones = true,
+      documented = false)
+    @Nullable
+    public Sequence<Label> getOwners() {
+      return owners == null ? null : StarlarkList.immutableCopyOf(owners);
+    }
+
+    @Override
+    public Provider getProvider() {
+      return PROVIDER;
+    }
+
+    public static class Provider extends BuiltinProvider<CcSharedLibraryHintInfo>
+          implements ProviderApi {
+        private Provider() {
+          super("CcSharedLibraryHintInfo", CcSharedLibraryHintInfo.class);
+        }
+    }
+  }
+
+  @StarlarkMethod(
+    name = "CcSharedLibraryHintInfo_6_X_constructor_do_not_use",
+    documented = false,
+    parameters = {
+      @Param(
+          name = "attributes",
+          documented = false,
+          positional = false,
+          named = true,
+          defaultValue = "None",
+          allowedTypes = {
+            @ParamType(type = Sequence.class),
+            @ParamType(type = NoneType.class)
+          }),
+      @Param(
+          name = "owners",
+          documented = false,
+          positional = false,
+          named = true,
+          defaultValue = "None",
+          allowedTypes = {
+            @ParamType(type = Sequence.class),
+            @ParamType(type = NoneType.class)
+          }),
+    }
+  )
+  public CcSharedLibraryHintInfo ccSharedLibraryHintInfoConstructor(
+        Object starlarkAttributesObject,
+        Object starlarkOwnersObject) throws EvalException {
+      List<String> attributes = null;
+      if (starlarkAttributesObject != Starlark.NONE) {
+        attributes = convertFromNoneable(
+            starlarkAttributesObject, /* defaultValue= */ (Sequence<String>) null).getImmutableList();
+      }
+      List<Label> owners = null;
+      if (starlarkOwnersObject != Starlark.NONE) {
+        owners = convertFromNoneable(
+            starlarkOwnersObject, /* defaultValue= */ (Sequence<Label>) null).getImmutableList();
+      }
+      return new CcSharedLibraryHintInfo(
+          attributes,
+          owners
+      );
+  }
+
+  @StarlarkMethod(
+    name = "CcSharedLibraryHintInfo_6_X_getter_do_not_use",
+    documented = false,
+    structField = true)
+  public Provider getCcSharedLibraryHintInfo() {
+    return CcSharedLibraryHintInfo.PROVIDER;
+  }
+
   @Override
   public Provider getCcToolchainProvider() {
     return CcToolchainProvider.PROVIDER;
   }
 
+
   @Override
   public FeatureConfigurationForStarlark configureFeatures(
       Object ruleContextOrNone,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java
index ece793bfa81859..d00f2f7c88c5e5 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionBuilder.java
@@ -148,6 +148,10 @@ public Artifact create(
   private boolean isStampingEnabled;
   private final Map<String, String> executionInfo = new LinkedHashMap<>();
 
+  // We have to add the dynamicLibrarySolibOutput to the CppLinkActionBuilder so that it knows how
+  // to set up the RPATH properly with respect to the symlink itself and not the original library.
+  private Artifact dynamicLibrarySolibSymlinkOutput;
+
   /**
    * Creates a builder that builds {@link CppLinkAction}s.
    *
@@ -803,7 +807,8 @@ public CppLinkAction build() throws InterruptedException, RuleErrorException {
             nonExpandedLinkerInputs,
             needWholeArchive,
             ruleErrorConsumer,
-            ((RuleContext) actionConstructionContext).getWorkspaceName());
+            ((RuleContext) actionConstructionContext).getWorkspaceName(),
+            dynamicLibrarySolibSymlinkOutput);
     CollectedLibrariesToLink collectedLibrariesToLink =
         librariesToLinkCollector.collectLibrariesToLink();
 
@@ -1536,4 +1541,11 @@ public CppLinkActionBuilder addExecutionInfo(Map<String, String> executionInfo)
     this.executionInfo.putAll(executionInfo);
     return this;
   }
+
+  @CanIgnoreReturnValue
+  public CppLinkActionBuilder setDynamicLibrarySolibSymlinkOutput(
+      Artifact dynamicLibrarySolibSymlinkOutput) {
+    this.dynamicLibrarySolibSymlinkOutput = dynamicLibrarySolibSymlinkOutput;
+    return this;
+  }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/LibrariesToLinkCollector.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/LibrariesToLinkCollector.java
index abf3c1babf78be..0704dde0238ed9 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/LibrariesToLinkCollector.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/LibrariesToLinkCollector.java
@@ -61,6 +61,7 @@ public class LibrariesToLinkCollector {
   private final RuleErrorConsumer ruleErrorConsumer;
   private final Artifact output;
   private final String workspaceName;
+  private final Artifact dynamicLibrarySolibSymlinkOutput;
 
   public LibrariesToLinkCollector(
       boolean isNativeDeps,
@@ -79,7 +80,8 @@ public LibrariesToLinkCollector(
       Iterable<LinkerInput> linkerInputs,
       boolean needWholeArchive,
       RuleErrorConsumer ruleErrorConsumer,
-      String workspaceName) {
+      String workspaceName,
+      Artifact dynamicLibrarySolibSymlinkOutput) {
     this.isNativeDeps = isNativeDeps;
     this.cppConfiguration = cppConfiguration;
     this.ccToolchainProvider = toolchain;
@@ -95,6 +97,7 @@ public LibrariesToLinkCollector(
     this.ruleErrorConsumer = ruleErrorConsumer;
     this.output = output;
     this.workspaceName = workspaceName;
+    this.dynamicLibrarySolibSymlinkOutput = dynamicLibrarySolibSymlinkOutput;
 
     needToolchainLibrariesRpath =
         toolchainLibrariesSolibDir != null
@@ -164,81 +167,88 @@ private NestedSet<String> collectToolchainRuntimeLibrarySearchDirectories(
   }
 
   private ImmutableList<String> findPotentialSolibParents() {
-    // The runtime location of the solib directory relative to the binary depends on four factors:
-    //
-    // * whether the binary is contained in the main repository or an external repository;
-    // * whether the binary is executed directly or from a runfiles tree;
-    // * whether the binary is staged as a symlink (sandboxed execution; local execution if the
-    //   binary is in the runfiles of another target) or a regular file (remote execution) - the
-    //   dynamic linker follows sandbox and runfiles symlinks into its location under the
-    //   unsandboxed execroot, which thus becomes the effective $ORIGIN;
-    // * whether --experimental_sibling_repository_layout is enabled or not.
-    //
-    // The rpaths emitted into the binary thus have to cover the following cases (assuming that
-    // the binary target is located in the pkg `pkg` and has name `file`) for the directory used
-    // as $ORIGIN by the dynamic linker and the directory containing the solib directories:
-    //
-    // 1. main, direct, symlink:
-    //    $ORIGIN:    $EXECROOT/pkg
-    //    solib root: $EXECROOT
-    // 2. main, direct, regular file:
-    //    $ORIGIN:    $EXECROOT/pkg
-    //    solib root: $EXECROOT/pkg/file.runfiles/main_repo
-    // 3. main, runfiles, symlink:
-    //    $ORIGIN:    $EXECROOT/pkg
-    //    solib root: $EXECROOT
-    // 4. main, runfiles, regular file:
-    //    $ORIGIN:    other_target.runfiles/main_repo/pkg
-    //    solib root: other_target.runfiles/main_repo
-    // 5a. external, direct, symlink:
-    //    $ORIGIN:    $EXECROOT/external/other_repo/pkg
-    //    solib root: $EXECROOT
-    // 5b. external, direct, symlink, with --experimental_sibling_repository_layout:
-    //    $ORIGIN:    $EXECROOT/../other_repo/pkg
-    //    solib root: $EXECROOT/../other_repo
-    // 6a. external, direct, regular file:
-    //    $ORIGIN:    $EXECROOT/external/other_repo/pkg
-    //    solib root: $EXECROOT/external/other_repo/pkg/file.runfiles/main_repo
-    // 6b. external, direct, regular file, with --experimental_sibling_repository_layout:
-    //    $ORIGIN:    $EXECROOT/../other_repo/pkg
-    //    solib root: $EXECROOT/../other_repo/pkg/file.runfiles/other_repo
-    // 7a. external, runfiles, symlink:
-    //    $ORIGIN:    $EXECROOT/external/other_repo/pkg
-    //    solib root: $EXECROOT
-    // 7b. external, runfiles, symlink, with --experimental_sibling_repository_layout:
-    //    $ORIGIN:    $EXECROOT/../other_repo/pkg
-    //    solib root: $EXECROOT/../other_repo
-    // 8a. external, runfiles, regular file:
-    //    $ORIGIN:    other_target.runfiles/some_repo/pkg
-    //    solib root: other_target.runfiles/main_repo
-    // 8b. external, runfiles, regular file, with --experimental_sibling_repository_layout:
-    //    $ORIGIN:    other_target.runfiles/some_repo/pkg
-    //    solib root: other_target.runfiles/some_repo
-    //
-    // Cases 1, 3, 4, 5, 7, and 8b are covered by an rpath that walks up the root relative path.
-    // Cases 2 and 6 covered by walking into file.runfiles/main_repo.
-    // Case 8a is covered by walking up some_repo/pkg and then into main_repo.
-    boolean isExternal =
-        output.getRunfilesPath().startsWith(LabelConstants.EXTERNAL_RUNFILES_PATH_PREFIX);
-    boolean usesLegacyRepositoryLayout = output.getRoot().isLegacy();
     ImmutableList.Builder<String> solibParents = ImmutableList.builder();
-    // Handles cases 1, 3, 4, 5, and 7.
-    solibParents.add("../".repeat(output.getRootRelativePath().segmentCount() - 1));
-    // Handle cases 2 and 6.
-    String solibRepositoryName;
-    if (isExternal && !usesLegacyRepositoryLayout) {
-      // Case 6b
-      solibRepositoryName = output.getRunfilesPath().getSegment(1);
-    } else {
-      // Cases 2 and 6a
-      solibRepositoryName = workspaceName;
+    ImmutableList.Builder<Artifact> outputs = ImmutableList.builder();
+    outputs.add(output);
+    if (dynamicLibrarySolibSymlinkOutput != null) {
+      outputs.add(dynamicLibrarySolibSymlinkOutput);
     }
-    solibParents.add(output.getFilename() + ".runfiles/" + solibRepositoryName + "/");
-    if (isExternal && usesLegacyRepositoryLayout) {
-      // Handles case 8a. The runfiles path is of the form ../some_repo/pkg/file and we need to
-      // walk up some_repo/pkg and then down into main_repo.
-      solibParents.add(
-          "../".repeat(output.getRunfilesPath().segmentCount() - 2) + workspaceName + "/");
+    for (Artifact output : outputs.build()) {
+      // The runtime location of the solib directory relative to the binary depends on four factors:
+      //
+      // * whether the binary is contained in the main repository or an external repository;
+      // * whether the binary is executed directly or from a runfiles tree;
+      // * whether the binary is staged as a symlink (sandboxed execution; local execution if the
+      //   binary is in the runfiles of another target) or a regular file (remote execution) - the
+      //   dynamic linker follows sandbox and runfiles symlinks into its location under the
+      //   unsandboxed execroot, which thus becomes the effective $ORIGIN;
+      // * whether --experimental_sibling_repository_layout is enabled or not.
+      //
+      // The rpaths emitted into the binary thus have to cover the following cases (assuming that
+      // the binary target is located in the pkg `pkg` and has name `file`) for the directory used
+      // as $ORIGIN by the dynamic linker and the directory containing the solib directories:
+      //
+      // 1. main, direct, symlink:
+      //    $ORIGIN:    $EXECROOT/pkg
+      //    solib root: $EXECROOT
+      // 2. main, direct, regular file:
+      //    $ORIGIN:    $EXECROOT/pkg
+      //    solib root: $EXECROOT/pkg/file.runfiles/main_repo
+      // 3. main, runfiles, symlink:
+      //    $ORIGIN:    $EXECROOT/pkg
+      //    solib root: $EXECROOT
+      // 4. main, runfiles, regular file:
+      //    $ORIGIN:    other_target.runfiles/main_repo/pkg
+      //    solib root: other_target.runfiles/main_repo
+      // 5a. external, direct, symlink:
+      //    $ORIGIN:    $EXECROOT/external/other_repo/pkg
+      //    solib root: $EXECROOT
+      // 5b. external, direct, symlink, with --experimental_sibling_repository_layout:
+      //    $ORIGIN:    $EXECROOT/../other_repo/pkg
+      //    solib root: $EXECROOT/../other_repo
+      // 6a. external, direct, regular file:
+      //    $ORIGIN:    $EXECROOT/external/other_repo/pkg
+      //    solib root: $EXECROOT/external/other_repo/pkg/file.runfiles/main_repo
+      // 6b. external, direct, regular file, with --experimental_sibling_repository_layout:
+      //    $ORIGIN:    $EXECROOT/../other_repo/pkg
+      //    solib root: $EXECROOT/../other_repo/pkg/file.runfiles/other_repo
+      // 7a. external, runfiles, symlink:
+      //    $ORIGIN:    $EXECROOT/external/other_repo/pkg
+      //    solib root: $EXECROOT
+      // 7b. external, runfiles, symlink, with --experimental_sibling_repository_layout:
+      //    $ORIGIN:    $EXECROOT/../other_repo/pkg
+      //    solib root: $EXECROOT/../other_repo
+      // 8a. external, runfiles, regular file:
+      //    $ORIGIN:    other_target.runfiles/some_repo/pkg
+      //    solib root: other_target.runfiles/main_repo
+      // 8b. external, runfiles, regular file, with --experimental_sibling_repository_layout:
+      //    $ORIGIN:    other_target.runfiles/some_repo/pkg
+      //    solib root: other_target.runfiles/some_repo
+      //
+      // Cases 1, 3, 4, 5, 7, and 8b are covered by an rpath that walks up the root relative path.
+      // Cases 2 and 6 covered by walking into file.runfiles/main_repo.
+      // Case 8a is covered by walking up some_repo/pkg and then into main_repo.
+      boolean isExternal =
+          output.getRunfilesPath().startsWith(LabelConstants.EXTERNAL_RUNFILES_PATH_PREFIX);
+      boolean usesLegacyRepositoryLayout = output.getRoot().isLegacy();
+      // Handles cases 1, 3, 4, 5, and 7.
+      solibParents.add("../".repeat(output.getRootRelativePath().segmentCount() - 1));
+      // Handle cases 2 and 6.
+      String solibRepositoryName;
+      if (isExternal && !usesLegacyRepositoryLayout) {
+        // Case 6b
+        solibRepositoryName = output.getRunfilesPath().getSegment(1);
+      } else {
+        // Cases 2 and 6a
+        solibRepositoryName = workspaceName;
+      }
+      solibParents.add(output.getFilename() + ".runfiles/" + solibRepositoryName + "/");
+      if (isExternal && usesLegacyRepositoryLayout) {
+        // Handles case 8a. The runfiles path is of the form ../some_repo/pkg/file and we need to
+        // walk up some_repo/pkg and then down into main_repo.
+        solibParents.add(
+            "../".repeat(output.getRunfilesPath().segmentCount() - 2) + workspaceName + "/");
+      }
     }
 
     return solibParents.build();
diff --git a/src/main/starlark/builtins_bzl/common/cc/cc_binary.bzl b/src/main/starlark/builtins_bzl/common/cc/cc_binary.bzl
index d74b43a5f710e7..ffaa2feb4e4fd5 100644
--- a/src/main/starlark/builtins_bzl/common/cc/cc_binary.bzl
+++ b/src/main/starlark/builtins_bzl/common/cc/cc_binary.bzl
@@ -15,7 +15,7 @@
 """cc_binary Starlark implementation replacing native"""
 
 load(":common/cc/semantics.bzl", "semantics")
-load(":common/cc/experimental_cc_shared_library.bzl", "CcSharedLibraryInfo", "GraphNodeInfo", "build_exports_map_from_only_dynamic_deps", "build_link_once_static_libs_map", "merge_cc_shared_library_infos", "throw_linked_but_not_exported_errors")
+load(":common/cc/experimental_cc_shared_library.bzl", "GraphNodeInfo", "add_unused_dynamic_deps", "build_exports_map_from_only_dynamic_deps", "build_link_once_static_libs_map", "merge_cc_shared_library_infos", "separate_static_and_dynamic_link_libraries", "throw_linked_but_not_exported_errors", "sort_linker_inputs")
 load(":common/cc/cc_helper.bzl", "cc_helper")
 
 CcInfo = _builtins.toplevel.CcInfo
@@ -333,44 +333,10 @@ def _collect_transitive_dwo_artifacts(cc_compilation_outputs, cc_debug_context,
             transitive_dwo_files = cc_debug_context.files
     return depset(dwo_files, transitive = [transitive_dwo_files])
 
-def _separate_static_and_dynamic_link_libraries(direct_children, can_be_linked_dynamically):
-    link_statically_labels = {}
-    link_dynamically_labels = {}
-    all_children = list(direct_children)
-    seen_labels = {}
-
-    # Some of the logic here is a duplicate from cc_shared_library.
-    # But some parts are different hence rewriting.
-    for i in range(2147483647):
-        if i == len(all_children):
-            break
-        node = all_children[i]
-        node_label = str(node.label)
-        if node_label in seen_labels:
-            continue
-        seen_labels[node_label] = True
-        if node_label in can_be_linked_dynamically:
-            link_dynamically_labels[node_label] = True
-        else:
-            link_statically_labels[node_label] = True
-            all_children.extend(node.children)
-    return (link_statically_labels, link_dynamically_labels)
-
-def _get_preloaded_deps_from_dynamic_deps(ctx):
-    cc_infos = []
-    for dep in ctx.attr.dynamic_deps:
-        cc_shared_library_info = dep[CcSharedLibraryInfo]
-        preloaded_deps_field = cc_shared_library_info.preloaded_deps
-        if preloaded_deps_field != None:
-            cc_infos.append(preloaded_deps_field)
-
-    return cc_common.merge_cc_infos(direct_cc_infos = cc_infos, cc_infos = cc_infos).linking_context.linker_inputs.to_list()
-
-def _filter_libraries_that_are_linked_dynamically(ctx, cc_linking_context, cpp_config):
+def _filter_libraries_that_are_linked_dynamically(ctx, feature_configuration, cc_linking_context):
     merged_cc_shared_library_infos = merge_cc_shared_library_infos(ctx)
-    preloaded_deps = _get_preloaded_deps_from_dynamic_deps(ctx)
     link_once_static_libs_map = build_link_once_static_libs_map(merged_cc_shared_library_infos)
-    exports_map = build_exports_map_from_only_dynamic_deps(merged_cc_shared_library_infos)
+    transitive_exports = build_exports_map_from_only_dynamic_deps(merged_cc_shared_library_infos)
     static_linker_inputs = []
     linker_inputs = cc_linking_context.linker_inputs.to_list()
 
@@ -380,40 +346,64 @@ def _filter_libraries_that_are_linked_dynamically(ctx, cc_linking_context, cpp_c
     can_be_linked_dynamically = {}
     for linker_input in linker_inputs:
         owner = str(linker_input.owner)
-        if owner in exports_map:
+        if owner in transitive_exports:
             can_be_linked_dynamically[owner] = True
 
-    (link_statically_labels, link_dynamically_labels) = _separate_static_and_dynamic_link_libraries(graph_structure_aspect_nodes, can_be_linked_dynamically)
+    # Entries in unused_dynamic_linker_inputs will be marked None if they are
+    # used
+    (
+        targets_to_be_linked_statically_map,
+        targets_to_be_linked_dynamically_set,
+        topologically_sorted_labels,
+        unused_dynamic_linker_inputs,
+    ) = separate_static_and_dynamic_link_libraries(
+        ctx,
+        graph_structure_aspect_nodes,
+        can_be_linked_dynamically,
+    )
+
+    topologically_sorted_labels = [ctx.label] + topologically_sorted_labels
 
     linker_inputs_seen = {}
     linked_statically_but_not_exported = {}
+    label_to_linker_inputs = {}
+
+    def _add_linker_input_to_dict(owner, linker_input):
+        label_to_linker_inputs.setdefault(owner, []).append(linker_input)
+
+    linker_inputs_count = 0
     for linker_input in linker_inputs:
         stringified_linker_input = cc_helper.stringify_linker_input(linker_input)
         if stringified_linker_input in linker_inputs_seen:
             continue
         linker_inputs_seen[stringified_linker_input] = True
         owner = str(linker_input.owner)
-        if owner not in link_dynamically_labels and (owner in link_statically_labels or str(ctx.label) == owner):
+        if owner in targets_to_be_linked_dynamically_set:
+            unused_dynamic_linker_inputs[transitive_exports[owner].owner] = None
+            _add_linker_input_to_dict(linker_input.owner, transitive_exports[owner])
+            linker_inputs_count += 1
+        elif owner in targets_to_be_linked_statically_map or str(ctx.label) == owner:
             if owner in link_once_static_libs_map:
-                linked_statically_but_not_exported.setdefault(link_once_static_libs_map[owner], []).append(owner)
+                linked_statically_but_not_exported.setdefault(targets_to_be_linked_statically_map[owner], []).append(owner)
             else:
-                static_linker_inputs.append(linker_input)
+                _add_linker_input_to_dict(linker_input.owner, linker_input)
+                linker_inputs_count += 1
+
+    # Unlike Unix on Windows every dynamic dependency must be linked to the
+    # main binary, even indirect ones that are dependencies of direct
+    # dynamic dependencies of this binary.
+    link_indirect_deps = cc_common.is_enabled(feature_configuration = feature_configuration, feature_name = "targets_windows")
+    linker_inputs_count += add_unused_dynamic_deps(ctx, unused_dynamic_linker_inputs, _add_linker_input_to_dict, topologically_sorted_labels, link_indirect_deps)
 
     throw_linked_but_not_exported_errors(linked_statically_but_not_exported)
 
-    rule_impl_debug_files = None
-    if cpp_config.experimental_cc_shared_library_debug():
-        debug_linker_inputs_file = ["Owner: " + str(ctx.label)]
-        static_linker_inputs_and_preloaded_deps = static_linker_inputs + preloaded_deps
-        for linker_input in static_linker_inputs_and_preloaded_deps:
-            debug_linker_inputs_file.append(str(linker_input.owner))
-        link_once_static_libs_debug_file = ctx.actions.declare_file(ctx.label.name + "_link_once_static_libs.txt")
-        ctx.actions.write(link_once_static_libs_debug_file, "\n".join(debug_linker_inputs_file), False)
-        transitive_debug_files_list = []
-        for dep in ctx.attr.dynamic_deps:
-            transitive_debug_files_list.append(dep[OutputGroupInfo].rule_impl_debug_files)
-        rule_impl_debug_files = depset([link_once_static_libs_debug_file], transitive = transitive_debug_files_list)
-    return (cc_common.create_linking_context(linker_inputs = depset(exports_map.values() + static_linker_inputs + preloaded_deps, order = "topological")), rule_impl_debug_files)
+    sorted_linker_inputs = sort_linker_inputs(
+        topologically_sorted_labels,
+        label_to_linker_inputs,
+        linker_inputs_count,
+    )
+
+    return cc_common.create_linking_context(linker_inputs = depset(sorted_linker_inputs, order = "topological"))
 
 def _create_transitive_linking_actions(
         ctx,
@@ -493,9 +483,8 @@ def _create_transitive_linking_actions(
     cc_info = cc_common.merge_cc_infos(cc_infos = [cc_info_without_extra_link_time_libraries, extra_link_time_libraries_cc_info])
     cc_linking_context = cc_info.linking_context
 
-    rule_impl_debug_files = None
     if len(ctx.attr.dynamic_deps) > 0:
-        cc_linking_context, rule_impl_debug_files = _filter_libraries_that_are_linked_dynamically(ctx, cc_linking_context, cpp_config)
+        cc_linking_context = _filter_libraries_that_are_linked_dynamically(ctx, feature_configuration, cc_linking_context)
     link_deps_statically = True
     if linking_mode == _LINKING_DYNAMIC:
         link_deps_statically = False
@@ -526,7 +515,7 @@ def _create_transitive_linking_actions(
         win_def_file = win_def_file,
     )
     cc_launcher_info = cc_internal.create_cc_launcher_info(cc_info = cc_info_without_extra_link_time_libraries, compilation_outputs = cc_compilation_outputs_with_only_objects)
-    return (cc_linking_outputs, cc_launcher_info, rule_impl_debug_files, cc_linking_context)
+    return (cc_linking_outputs, cc_launcher_info, cc_linking_context)
 
 def _use_pic(ctx, cc_toolchain, cpp_config, feature_configuration):
     if _is_link_shared(ctx):
@@ -671,6 +660,8 @@ def cc_binary_impl(ctx, additional_linkopts):
     # Allows the dynamic library generated for code of test targets to be linked separately.
     link_compile_output_separately = ctx.attr._is_test and linking_mode == _LINKING_DYNAMIC and cpp_config.dynamic_mode() == "DEFAULT" and ("dynamic_link_test_srcs" in ctx.features)
 
+    is_windows_enabled = cc_common.is_enabled(feature_configuration = feature_configuration, feature_name = "targets_windows")
+
     # When linking the object files directly into the resulting binary, we do not need
     # library-level link outputs; thus, we do not let CcCompilationHelper produce link outputs
     # (either shared object files or archives) for a non-library link type [*], and add
@@ -695,6 +686,7 @@ def cc_binary_impl(ctx, additional_linkopts):
             linking_contexts = cc_helper.get_linking_contexts_from_deps(all_deps),
             stamp = cc_helper.is_stamping_enabled(ctx),
             alwayslink = True,
+            disallow_dynamic_library = is_windows_enabled,
         )
 
     is_static_mode = linking_mode != _LINKING_DYNAMIC
@@ -702,7 +694,7 @@ def cc_binary_impl(ctx, additional_linkopts):
     generated_def_file = None
     win_def_file = None
     if _is_link_shared(ctx):
-        if cc_common.is_enabled(feature_configuration = feature_configuration, feature_name = "targets_windows"):
+        if is_windows_enabled:
             # Make copy of a list, to avoid mutating frozen values.
             object_files = list(cc_compilation_outputs.objects)
             for linker_input in deps_cc_linking_context.linker_inputs.to_list():
@@ -735,7 +727,7 @@ def cc_binary_impl(ctx, additional_linkopts):
     if extra_link_time_libraries != None:
         linker_inputs_extra, runtime_libraries_extra = extra_link_time_libraries.build_libraries(ctx = ctx, static_mode = linking_mode != _LINKING_DYNAMIC, for_dynamic_library = _is_link_shared(ctx))
 
-    cc_linking_outputs_binary, cc_launcher_info, rule_impl_debug_files, deps_cc_linking_context = _create_transitive_linking_actions(
+    cc_linking_outputs_binary, cc_launcher_info, deps_cc_linking_context = _create_transitive_linking_actions(
         ctx,
         cc_toolchain,
         feature_configuration,
@@ -850,9 +842,6 @@ def cc_binary_impl(ctx, additional_linkopts):
     if generated_def_file != None:
         output_groups["def_file"] = depset([generated_def_file])
 
-    if rule_impl_debug_files != None:
-        output_groups["rule_impl_debug_files"] = rule_impl_debug_files
-
     if cc_linking_outputs_binary_library != None:
         # For consistency and readability.
         library_to_link = cc_linking_outputs_binary_library
diff --git a/src/main/starlark/builtins_bzl/common/cc/experimental_cc_shared_library.bzl b/src/main/starlark/builtins_bzl/common/cc/experimental_cc_shared_library.bzl
index 5972527b79876e..b9f3b5b7ac3df8 100644
--- a/src/main/starlark/builtins_bzl/common/cc/experimental_cc_shared_library.bzl
+++ b/src/main/starlark/builtins_bzl/common/cc/experimental_cc_shared_library.bzl
@@ -12,18 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""This is an experimental implementation of cc_shared_library.
-
-We may change the implementation at any moment or even delete this file. Do not
-rely on this. It requires bazel >1.2  and passing the flag
---experimental_cc_shared_library
-"""
+"""Implementation of cc_shared_library"""
 
 load(":common/cc/cc_helper.bzl", "cc_helper")
 load(":common/cc/semantics.bzl", "semantics")
 
 CcInfo = _builtins.toplevel.CcInfo
 cc_common = _builtins.toplevel.cc_common
+ProtoInfo = _builtins.toplevel.ProtoInfo
 
 # TODO(#5200): Add export_define to library_to_link and cc_library
 
@@ -33,28 +29,12 @@ cc_common = _builtins.toplevel.cc_common
 # used sparingly after making sure it's safe to use.
 LINKABLE_MORE_THAN_ONCE = "LINKABLE_MORE_THAN_ONCE"
 
-# Add this as a tag to any static lib target that doesn't export any symbols,
-# thus can be statically linked more than once. This is useful in some cases,
-# for example, a static lib has a constructor that needs to be run during
-# loading time of the shared lib that has it linked into, which is how the
-# code gets called by the OS. This static lib might need to be linked as a
-# whole archive dep for multiple shared libs, otherwise this static lib will
-# be dropped by the linker since there are no incoming symbol references.
-NO_EXPORTING = "NO_EXPORTING"
-
-CcSharedLibraryPermissionsInfo = provider(
-    "Permissions for a cc shared library.",
-    fields = {
-        "targets": "Matches targets that can be exported.",
-    },
-)
 GraphNodeInfo = provider(
     "Nodes in the graph of shared libraries.",
     fields = {
         "children": "Other GraphNodeInfo from dependencies of this target",
-        "label": "Label of the target visited",
+        "owners": "Owners of the linker inputs in the targets visited",
         "linkable_more_than_once": "Linkable into more than a single cc_shared_library",
-        "no_exporting": "The static lib doesn't export any symbols so don't export it",
     },
 )
 CcSharedLibraryInfo = provider(
@@ -67,44 +47,174 @@ CcSharedLibraryInfo = provider(
                                  "initializers. If we try to link them more than once, " +
                                  "we will throw an error",
         "linker_input": "the resulting linker input artifact for the shared library",
-        "preloaded_deps": "cc_libraries needed by this cc_shared_library that should" +
-                          " be linked the binary. If this is set, this cc_shared_library has to " +
-                          " be a direct dependency of the cc_binary",
     },
 )
 
+def _programmatic_error(message = ""):
+    fail("Your build has triggered a programmatic error in the cc_shared_library rule. " +
+         "Please file an issue in https://github.com/bazelbuild/bazel : {}".format(message))
+
+def _sort_linker_inputs(topologically_sorted_labels, label_to_linker_inputs, linker_inputs_count):
+    # len(label_to_linker_inputs) might not match the topologically_sorted_labels
+    # size. The latter is looking at nodes in the graph but a node may not
+    # necessarily contribute any linker_inputs. For example a cc_library with
+    # no sources and only deps. Every linker_input.owner must be in
+    # topologically_sorted_labels otherwise there is an error in the rule
+    # implementation of the target providing that linker_input, e.g. it's
+    # missing a CcSharedLibraryHintInfo if it had custom owner names for linker
+    # inputs.
+    sorted_linker_inputs = []
+    for label in topologically_sorted_labels:
+        if label not in label_to_linker_inputs:
+            # This is ok. It can happen if no linker_inputs
+            # were added by a node in the graph.
+            continue
+        sorted_linker_inputs.extend(label_to_linker_inputs[label])
+
+    if len(sorted_linker_inputs) != linker_inputs_count:
+        owners = []
+        for sorted_linker_input in sorted_linker_inputs:
+            owners.append(str(sorted_linker_input.owner))
+        _programmatic_error("{} vs {}".format(",".join(owners), linker_inputs_count))
+
+    return sorted_linker_inputs
+
 # For each target, find out whether it should be linked statically or
-# dynamically.
+# dynamically. The transitive_dynamic_dep_labels parameter is only needed for
+# binaries because they link all dynamic_deps (cc_binary|cc_test).
 def _separate_static_and_dynamic_link_libraries(
+        ctx,
         direct_children,
-        can_be_linked_dynamically,
-        preloaded_deps_direct_labels):
+        can_be_linked_dynamically):
+    (
+        transitive_dynamic_dep_labels,
+        all_dynamic_dep_linker_inputs,
+    ) = _build_map_direct_dynamic_dep_to_transitive_dynamic_deps(ctx)
+
     node = None
-    all_children = list(direct_children)
+    all_children = reversed(direct_children)
     targets_to_be_linked_statically_map = {}
     targets_to_be_linked_dynamically_set = {}
-
     seen_labels = {}
 
+    # The cc_shared_library graph is parallel to the cc_library graph.
+    # Propagation of linker inputs between cc_libraries happens via the CcInfo
+    # provider. Parallel to this we have cc_shared_libraries which may decide
+    # different partitions of the cc_library graph.
+    #
+    # In a previous implementation of cc_shared_library we relied on the
+    # topological sort given by flattening
+    # cc_info.linking_context.linker_inputs.to_list(), however this was wrong
+    # because the dependencies of a shared library (i.e. a pruned node here)
+    # influenced the final order.
+    #
+    # In order to fix this, the pruning below was changed from breadth-first
+    # traversal to depth-first traversal. While doing this we also recreate a
+    # depset with topological order that takes into account the pruned nodes
+    # and which will later be used to order the libraries in the linking
+    # command line. This will be in topological order and will respect the
+    # order of the deps as listed on the BUILD file as much as possible.
+    #
+    # Here we say "first_owner" because each node (see GraphNodeInfo) may have
+    # more than one linker_input (each potentially with a different owner) but
+    # using only the first owner as a key is enough.
+    first_owner_to_depset = {}
+
     # Horrible I know. Perhaps Starlark team gives me a way to prune a tree.
     for i in range(2147483647):
-        if i == len(all_children):
+        if not len(all_children):
             break
 
-        node = all_children[i]
-        node_label = str(node.label)
-
-        if node_label in seen_labels:
-            continue
-        seen_labels[node_label] = True
-
-        if node_label in can_be_linked_dynamically:
-            targets_to_be_linked_dynamically_set[node_label] = True
-        elif node_label not in preloaded_deps_direct_labels:
-            targets_to_be_linked_statically_map[node_label] = node.linkable_more_than_once
-            all_children.extend(node.children)
+        node = all_children[-1]
+
+        must_add_children = False
+
+        # The *_seen variables are used to track a programmatic error and fail
+        # if it happens.  Every value in node.owners presumably corresponds to
+        # a linker_input in the same exact target. Therefore if we have seen
+        # any of the owners already, then we must have also seen all the other
+        # owners in the same node. Viceversa when we haven't seen them yet. If
+        # both of these values are non-zero after the loop, the most likely
+        # reason would be a bug in the implementation. It could potentially be
+        # triggered by users if they use owner labels that do not keep most of
+        # the ctx.label.package and ctx.label.name which then clash with other
+        # target's owners (unlikely). For now though if the error is
+        # triggered, it's reasonable to require manual revision by
+        # the cc_shared_library implementation owners.
+        has_owners_seen = False
+        has_owners_not_seen = False
+        linked_dynamically = False
+        linked_statically = False
+        for owner in node.owners:
+            # TODO(bazel-team): Do not convert Labels to string to save on
+            # garbage string allocations.
+            owner_str = str(owner)
+
+            if owner_str in seen_labels:
+                has_owners_seen = True
+                continue
+
+            has_owners_not_seen = True
+            seen_labels[owner_str] = True
+
+            if owner_str in can_be_linked_dynamically:
+                targets_to_be_linked_dynamically_set[owner_str] = True
+                linked_dynamically = True
+            else:
+                targets_to_be_linked_statically_map[owner_str] = node.linkable_more_than_once
+                must_add_children = True
+                linked_statically = True
+
+        if has_owners_seen and has_owners_not_seen:
+            _programmatic_error()
+
+        if linked_dynamically and linked_statically:
+            error_owners_list = [str(owner) for owner in node.owners]
+
+            # Our granularity is target level. Unless there is a different
+            # unsupported custom implementation of this rule it should be
+            # impossible for two linker_inputs from the same target to be
+            # linked differently, one statically and the other dynamically.
+            _programmatic_error(
+                message = "Nodes with linker_inputs linked statically and dynamically:" +
+                          "\n{}".format("\n".join(error_owners_list)),
+            )
 
-    return (targets_to_be_linked_statically_map, targets_to_be_linked_dynamically_set)
+        if must_add_children:
+            # The order in which we process the children matter. all_children
+            # is being used as a stack, we will process first the nodes at the
+            # top of the stack (last in the list). The children are the
+            # dependencies of the current node, in order to respect the order
+            # in which dependencies were listed in the deps attribute in the
+            # BUILD file we must reverse the list so that the first one listed
+            # in the BUILD file is processed first.
+            all_children.extend(reversed(node.children))
+        else:
+            if node.owners[0] not in first_owner_to_depset:
+                # We have 3 cases in this branch:
+                #   1. Node has no children
+                #   2. The children have been pruned because the node is linked dynamically
+                #   3. Node has children that have been processed
+                # For case 3 we add the children's depsets. For case 2 we add the dynamic
+                # dep labels for transitive dynamic deps.
+                transitive = []
+                if str(node.owners[0]) in targets_to_be_linked_statically_map:
+                    for child in node.children:
+                        transitive.append(first_owner_to_depset[child.owners[0]])
+                elif str(node.owners[0]) in transitive_dynamic_dep_labels:
+                    transitive.append(transitive_dynamic_dep_labels[str(node.owners[0])])
+
+                first_owner_to_depset[node.owners[0]] = depset(direct = node.owners, transitive = transitive, order = "topological")
+            all_children.pop()
+
+    topologically_sorted_labels = []
+    if direct_children:
+        transitive = []
+        for child in direct_children:
+            transitive.append(first_owner_to_depset[child.owners[0]])
+        topologically_sorted_labels = depset(transitive = transitive, order = "topological").to_list()
+
+    return (targets_to_be_linked_statically_map, targets_to_be_linked_dynamically_set, topologically_sorted_labels, all_dynamic_dep_linker_inputs)
 
 def _create_linker_context(ctx, linker_inputs):
     return cc_common.create_linking_context(
@@ -115,11 +225,6 @@ def _merge_cc_shared_library_infos(ctx):
     dynamic_deps = []
     transitive_dynamic_deps = []
     for dep in ctx.attr.dynamic_deps:
-        # This error is not relevant for cc_binary.
-        if not hasattr(ctx.attr, "_cc_binary") and dep[CcSharedLibraryInfo].preloaded_deps != None:
-            fail("{} can only be a direct dependency of a " +
-                 " cc_binary because it has " +
-                 "preloaded_deps".format(str(dep.label)))
         dynamic_dep_entry = (
             dep[CcSharedLibraryInfo].exports,
             dep[CcSharedLibraryInfo].linker_input,
@@ -128,7 +233,7 @@ def _merge_cc_shared_library_infos(ctx):
         dynamic_deps.append(dynamic_dep_entry)
         transitive_dynamic_deps.append(dep[CcSharedLibraryInfo].dynamic_deps)
 
-    return depset(direct = dynamic_deps, transitive = transitive_dynamic_deps)
+    return depset(direct = dynamic_deps, transitive = transitive_dynamic_deps, order = "topological")
 
 def _build_exports_map_from_only_dynamic_deps(merged_shared_library_infos):
     exports_map = {}
@@ -156,7 +261,7 @@ def _build_link_once_static_libs_map(merged_shared_library_infos):
                 fail("Two shared libraries in dependencies link the same " +
                      " library statically. Both " + link_once_static_libs_map[static_lib] +
                      " and " + str(linker_input.owner) +
-                     " link statically" + static_lib)
+                     " link statically " + static_lib)
             link_once_static_libs_map[static_lib] = str(linker_input.owner)
     return link_once_static_libs_map
 
@@ -203,49 +308,61 @@ def _check_if_target_under_path(value, pattern):
 
     return pattern.package == value.package and pattern.name == value.name
 
-def _check_if_target_can_be_exported(target, current_label, permissions):
-    if permissions == None:
-        return True
+def _check_if_target_should_be_exported_with_filter(target, current_label, exports_filter):
+    for export_filter in exports_filter:
+        export_filter_label = current_label.relative(export_filter)
+        if _check_if_target_under_path(target, export_filter_label):
+            return True
 
-    if (target.workspace_name != current_label.workspace_name or
-        _same_package_or_above(current_label, target)):
-        return True
+    return False
 
-    matched_by_target = False
-    for permission in permissions:
-        for permission_target in permission[CcSharedLibraryPermissionsInfo].targets:
-            if _check_if_target_under_path(target, permission_target):
-                return True
+# Checks if the linker_input has code to link statically, i.e. either
+# archives or object files, ignores library.dynamic_library.
+def _contains_code_to_link(linker_input):
+    for library in linker_input.libraries:
+        if (library.static_library != None or
+            library.pic_static_library != None or
+            len(library.objects) or len(library.pic_objects)):
+            return True
 
     return False
 
-def _check_if_target_should_be_exported_without_filter(target, current_label, permissions):
-    return _check_if_target_should_be_exported_with_filter(target, current_label, None, permissions)
+def _find_top_level_linker_input_labels(
+        nodes,
+        linker_inputs_to_be_linked_statically_map,
+        targets_to_be_linked_dynamically_set):
+    top_level_linker_input_labels_set = {}
+    nodes_to_check = list(nodes)
 
-def _check_if_target_should_be_exported_with_filter(target, current_label, exports_filter, permissions):
-    should_be_exported = False
-    if exports_filter == None:
-        should_be_exported = True
-    else:
-        for export_filter in exports_filter:
-            export_filter_label = current_label.relative(export_filter)
-            if _check_if_target_under_path(target, export_filter_label):
-                should_be_exported = True
-                break
-
-    if should_be_exported:
-        if _check_if_target_can_be_exported(target, current_label, permissions):
-            return True
-        else:
-            matched_by_filter_text = ""
-            if exports_filter:
-                matched_by_filter_text = " (matched by filter) "
-            fail(str(target) + matched_by_filter_text +
-                 " cannot be exported from " + str(current_label) +
-                 " because it's not in the same package/subpackage and the library " +
-                 "doesn't have the necessary permissions. Use cc_shared_library_permissions.")
+    seen_nodes_set = {}
+    for i in range(2147483647):
+        if i == len(nodes_to_check):
+            break
 
-    return False
+        node = nodes_to_check[i]
+        must_add_children = False
+        node_str_owners = []
+        for owner in node.owners:
+            owner_str = str(owner)
+            node_str_owners.append(owner_str)
+            if owner_str in linker_inputs_to_be_linked_statically_map:
+                must_add_children = True
+                for linker_input in linker_inputs_to_be_linked_statically_map[owner_str]:
+                    if _contains_code_to_link(linker_input):
+                        top_level_linker_input_labels_set[owner_str] = True
+                        must_add_children = False
+                        break
+            elif owner_str not in targets_to_be_linked_dynamically_set:
+                # This can happen when there was a target in the graph that exported other libraries'
+                # linker_inputs but didn't contribute any linker_input of its own.
+                must_add_children = True
+
+        node_key = "".join(node_str_owners)
+        if must_add_children and node_key not in seen_nodes_set:
+            nodes_to_check.extend(node.children)
+            seen_nodes_set[node_key] = True
+
+    return top_level_linker_input_labels_set
 
 def _filter_inputs(
         ctx,
@@ -253,18 +370,19 @@ def _filter_inputs(
         cc_toolchain,
         deps,
         transitive_exports,
-        preloaded_deps_direct_labels,
         link_once_static_libs_map):
     linker_inputs = []
     curr_link_once_static_libs_set = {}
 
     graph_structure_aspect_nodes = []
-    dependency_linker_inputs = []
-    direct_exports = {}
-    for export in deps:
-        direct_exports[str(export.label)] = True
-        dependency_linker_inputs.extend(export[CcInfo].linking_context.linker_inputs.to_list())
-        graph_structure_aspect_nodes.append(export[GraphNodeInfo])
+    dependency_linker_inputs_sets = []
+    direct_deps_set = {}
+    for dep in deps:
+        direct_deps_set[str(dep.label)] = True
+        dependency_linker_inputs_sets.append(dep[CcInfo].linking_context.linker_inputs)
+        graph_structure_aspect_nodes.append(dep[GraphNodeInfo])
+
+    dependency_linker_inputs = depset(transitive = dependency_linker_inputs_sets, order = "topological").to_list()
 
     can_be_linked_dynamically = {}
     for linker_input in dependency_linker_inputs:
@@ -274,10 +392,29 @@ def _filter_inputs(
 
     # The targets_to_be_linked_statically_map points to whether the target to
     # be linked statically can be linked more than once.
-    (targets_to_be_linked_statically_map, targets_to_be_linked_dynamically_set) = _separate_static_and_dynamic_link_libraries(
+    # Entries in unused_dynamic_linker_inputs will be marked None if they are
+    # used
+    (
+        targets_to_be_linked_statically_map,
+        targets_to_be_linked_dynamically_set,
+        topologically_sorted_labels,
+        unused_dynamic_linker_inputs,
+    ) = _separate_static_and_dynamic_link_libraries(
+        ctx,
         graph_structure_aspect_nodes,
         can_be_linked_dynamically,
-        preloaded_deps_direct_labels,
+    )
+
+    linker_inputs_to_be_linked_statically_map = {}
+    for linker_input in dependency_linker_inputs:
+        owner = str(linker_input.owner)
+        if owner in targets_to_be_linked_statically_map:
+            linker_inputs_to_be_linked_statically_map.setdefault(owner, []).append(linker_input)
+
+    top_level_linker_input_labels_set = _find_top_level_linker_input_labels(
+        graph_structure_aspect_nodes,
+        linker_inputs_to_be_linked_statically_map,
+        targets_to_be_linked_dynamically_set,
     )
 
     # We keep track of precompiled_only_dynamic_libraries, so that we can add
@@ -285,6 +422,11 @@ def _filter_inputs(
     precompiled_only_dynamic_libraries = []
     exports = {}
     linker_inputs_seen = {}
+    linker_inputs_count = 0
+    label_to_linker_inputs = {}
+
+    def _add_linker_input_to_dict(owner, linker_input):
+        label_to_linker_inputs.setdefault(owner, []).append(linker_input)
 
     # We use this dictionary to give an error if a target containing only
     # precompiled dynamic libraries is placed directly in roots. If such a
@@ -300,10 +442,13 @@ def _filter_inputs(
         linker_inputs_seen[stringified_linker_input] = True
         owner = str(linker_input.owner)
         if owner in targets_to_be_linked_dynamically_set:
+            unused_dynamic_linker_inputs[transitive_exports[owner].owner] = None
+
             # Link the library in this iteration dynamically,
             # transitive_exports contains the artifacts produced by a
             # cc_shared_library
-            linker_inputs.append(transitive_exports[owner])
+            _add_linker_input_to_dict(linker_input.owner, transitive_exports[owner])
+            linker_inputs_count += 1
         elif owner in targets_to_be_linked_statically_map:
             if owner in link_once_static_libs_map:
                 # We are building a dictionary that will allow us to give
@@ -316,7 +461,6 @@ def _filter_inputs(
                 # link_once_static_libs_map[owner] but is not being exported
                 linked_statically_but_not_exported.setdefault(link_once_static_libs_map[owner], []).append(owner)
 
-            is_direct_export = owner in direct_exports
             dynamic_only_libraries = []
             static_libraries = []
             for library in linker_input.libraries:
@@ -328,30 +472,31 @@ def _filter_inputs(
             if len(dynamic_only_libraries):
                 precompiled_only_dynamic_libraries.extend(dynamic_only_libraries)
                 if not len(static_libraries):
-                    if is_direct_export:
+                    if owner in direct_deps_set:
                         dynamic_only_roots[owner] = True
-                    linker_inputs.append(linker_input)
+                    _add_linker_input_to_dict(linker_input.owner, linker_input)
+                    linker_inputs_count += 1
                     continue
             if len(static_libraries) and owner in dynamic_only_roots:
                 dynamic_only_roots.pop(owner)
 
             linker_input_to_be_linked_statically = linker_input
-            if is_direct_export:
+            if owner in top_level_linker_input_labels_set:
                 linker_input_to_be_linked_statically = _wrap_static_library_with_alwayslink(
                     ctx,
                     feature_configuration,
                     cc_toolchain,
                     linker_input,
                 )
-            elif _check_if_target_should_be_exported_with_filter(
+            if _check_if_target_should_be_exported_with_filter(
                 linker_input.owner,
                 ctx.label,
                 ctx.attr.exports_filter,
-                _get_permissions(ctx),
             ):
                 exports[owner] = True
 
-            linker_inputs.append(linker_input_to_be_linked_statically)
+            _add_linker_input_to_dict(linker_input.owner, linker_input_to_be_linked_statically)
+            linker_inputs_count += 1
 
             if not targets_to_be_linked_statically_map[owner]:
                 curr_link_once_static_libs_set[owner] = True
@@ -364,8 +509,16 @@ def _filter_inputs(
             message += dynamic_only_root + "\n"
         fail(message)
 
+    linker_inputs_count += _add_unused_dynamic_deps(ctx, unused_dynamic_linker_inputs, _add_linker_input_to_dict, topologically_sorted_labels, link_indirect_deps = False)
+
+    sorted_linker_inputs = _sort_linker_inputs(
+        topologically_sorted_labels,
+        label_to_linker_inputs,
+        linker_inputs_count,
+    )
+
     _throw_linked_but_not_exported_errors(linked_statically_but_not_exported)
-    return (exports, linker_inputs, curr_link_once_static_libs_set.keys(), precompiled_only_dynamic_libraries)
+    return (exports, sorted_linker_inputs, curr_link_once_static_libs_set.keys(), precompiled_only_dynamic_libraries)
 
 def _throw_linked_but_not_exported_errors(error_libs_dict):
     if not error_libs_dict:
@@ -399,11 +552,6 @@ def _same_package_or_above(label_a, label_b):
 
     return True
 
-def _get_permissions(ctx):
-    if ctx.fragments.cpp.experimental_enable_target_export_check():
-        return ctx.attr.permissions
-    return None
-
 def _get_deps(ctx):
     if len(ctx.attr.deps) and len(ctx.attr.roots):
         fail(
@@ -417,8 +565,47 @@ def _get_deps(ctx):
     if not len(deps):
         deps = ctx.attr.roots
 
+    if len(deps) == 0:
+        fail(
+            "'cc_shared_library' must have at least one dependency in 'deps' (or 'roots')",
+            attr = "deps",
+        )
+
     return deps
 
+def _build_map_direct_dynamic_dep_to_transitive_dynamic_deps(ctx):
+    all_dynamic_dep_linker_inputs = {}
+    direct_dynamic_dep_to_transitive_dynamic_deps = {}
+    for dep in ctx.attr.dynamic_deps:
+        owner = dep[CcSharedLibraryInfo].linker_input.owner
+        all_dynamic_dep_linker_inputs[owner] = dep[CcSharedLibraryInfo].linker_input
+        transitive_dynamic_dep_labels = []
+        for dynamic_dep in dep[CcSharedLibraryInfo].dynamic_deps.to_list():
+            all_dynamic_dep_linker_inputs[dynamic_dep[1].owner] = dynamic_dep[1]
+            transitive_dynamic_dep_labels.append(dynamic_dep[1].owner)
+        transitive_dynamic_dep_labels_set = depset(transitive_dynamic_dep_labels, order = "topological")
+        for export in dep[CcSharedLibraryInfo].exports:
+            direct_dynamic_dep_to_transitive_dynamic_deps[export] = transitive_dynamic_dep_labels_set
+
+    return direct_dynamic_dep_to_transitive_dynamic_deps, all_dynamic_dep_linker_inputs
+
+def _add_unused_dynamic_deps(ctx, unused_dynamic_linker_inputs, add_linker_inputs_lambda, topologically_sorted_labels, link_indirect_deps):
+    linker_inputs_count = 0
+    direct_dynamic_dep_labels = {dep[CcSharedLibraryInfo].linker_input.owner: True for dep in ctx.attr.dynamic_deps}
+    topologically_sorted_labels_set = {label: True for label in topologically_sorted_labels}
+    for dynamic_linker_input_owner, unused_linker_input in unused_dynamic_linker_inputs.items():
+        should_link_input = (unused_linker_input and
+                             (link_indirect_deps or dynamic_linker_input_owner in direct_dynamic_dep_labels))
+        if should_link_input:
+            add_linker_inputs_lambda(
+                dynamic_linker_input_owner,
+                unused_dynamic_linker_inputs[dynamic_linker_input_owner],
+            )
+            linker_inputs_count += 1
+            if dynamic_linker_input_owner not in topologically_sorted_labels_set:
+                topologically_sorted_labels.append(dynamic_linker_input_owner)
+    return linker_inputs_count
+
 def _cc_shared_library_impl(ctx):
     semantics.check_experimental_cc_shared_library(ctx)
 
@@ -443,7 +630,7 @@ def _cc_shared_library_impl(ctx):
     feature_configuration = cc_common.configure_features(
         ctx = ctx,
         cc_toolchain = cc_toolchain,
-        requested_features = ctx.features,
+        requested_features = ctx.features + ["force_no_whole_archive"],
         unsupported_features = ctx.disabled_features,
     )
 
@@ -464,18 +651,6 @@ def _cc_shared_library_impl(ctx):
             fail("Trying to export a library already exported by a different shared library: " +
                  str(export.label))
 
-        _check_if_target_should_be_exported_without_filter(export.label, ctx.label, _get_permissions(ctx))
-
-    preloaded_deps_direct_labels = {}
-    preloaded_dep_merged_cc_info = None
-    if len(ctx.attr.preloaded_deps) != 0:
-        preloaded_deps_cc_infos = []
-        for preloaded_dep in ctx.attr.preloaded_deps:
-            preloaded_deps_direct_labels[str(preloaded_dep.label)] = True
-            preloaded_deps_cc_infos.append(preloaded_dep[CcInfo])
-
-        preloaded_dep_merged_cc_info = cc_common.merge_cc_infos(cc_infos = preloaded_deps_cc_infos)
-
     link_once_static_libs_map = _build_link_once_static_libs_map(merged_cc_shared_library_info)
 
     (exports, linker_inputs, curr_link_once_static_libs_set, precompiled_only_dynamic_libraries) = _filter_inputs(
@@ -484,7 +659,6 @@ def _cc_shared_library_impl(ctx):
         cc_toolchain,
         deps,
         exports_map,
-        preloaded_deps_direct_labels,
         link_once_static_libs_map,
     )
 
@@ -546,10 +720,8 @@ def _cc_shared_library_impl(ctx):
     runfiles = ctx.runfiles(
         files = runfiles_files,
     )
-    transitive_debug_files = []
     for dep in ctx.attr.dynamic_deps:
         runfiles = runfiles.merge(dep[DefaultInfo].data_runfiles)
-        transitive_debug_files.append(dep[OutputGroupInfo].rule_impl_debug_files)
 
     precompiled_only_dynamic_libraries_runfiles = []
     for precompiled_dynamic_library in precompiled_only_dynamic_libraries:
@@ -561,22 +733,7 @@ def _cc_shared_library_impl(ctx):
     runfiles = runfiles.merge(ctx.runfiles(files = precompiled_only_dynamic_libraries_runfiles))
 
     for export in deps:
-        export_label = str(export.label)
-        if GraphNodeInfo in export and export[GraphNodeInfo].no_exporting:
-            if export_label in curr_link_once_static_libs_set:
-                curr_link_once_static_libs_set.remove(export_label)
-            continue
-        exports[export_label] = True
-
-    debug_files = []
-    exports_debug_file = ctx.actions.declare_file(ctx.label.name + "_exports.txt")
-    ctx.actions.write(content = "\n".join(["Owner:" + str(ctx.label)] + exports.keys()), output = exports_debug_file)
-
-    link_once_static_libs_debug_file = ctx.actions.declare_file(ctx.label.name + "_link_once_static_libs.txt")
-    ctx.actions.write(content = "\n".join(["Owner:" + str(ctx.label)] + curr_link_once_static_libs_set), output = link_once_static_libs_debug_file)
-
-    debug_files.append(exports_debug_file)
-    debug_files.append(link_once_static_libs_debug_file)
+        exports[str(export.label)] = True
 
     if not ctx.fragments.cpp.experimental_link_static_libraries_once():
         curr_link_once_static_libs_set = {}
@@ -603,7 +760,6 @@ def _cc_shared_library_impl(ctx):
         OutputGroupInfo(
             main_shared_library_output = depset(library),
             interface_library = depset(interface_library),
-            rule_impl_debug_files = depset(direct = debug_files, transitive = transitive_debug_files),
         ),
         CcSharedLibraryInfo(
             dynamic_deps = merged_cc_shared_library_info,
@@ -613,62 +769,53 @@ def _cc_shared_library_impl(ctx):
                 owner = ctx.label,
                 libraries = depset([linking_outputs.library_to_link] + precompiled_only_dynamic_libraries),
             ),
-            preloaded_deps = preloaded_dep_merged_cc_info,
         ),
     ]
 
 def _graph_structure_aspect_impl(target, ctx):
     children = []
 
-    # For now ignore cases when deps is of type label instead of label_list.
-    if hasattr(ctx.rule.attr, "deps") and type(ctx.rule.attr.deps) != "Target":
-        for dep in ctx.rule.attr.deps:
-            if GraphNodeInfo in dep:
-                children.append(dep[GraphNodeInfo])
+    attributes = dir(ctx.rule.attr)
+    owners = [ctx.label]
+    if cc_common.CcSharedLibraryHintInfo_6_X_getter_do_not_use in target:
+        hint_info = target[cc_common.CcSharedLibraryHintInfo_6_X_getter_do_not_use]
+        if hint_info.attributes != None:
+            attributes = hint_info.attributes
+        if hint_info.owners != None:
+            owners = hint_info.owners
+
+    # Collect graph structure info from any possible deplike attribute. The aspect
+    # itself applies across every deplike attribute (attr_aspects is *), so enumerate
+    # over all attributes and consume GraphNodeInfo if available.
+    for fieldname in attributes:
+        deps = getattr(ctx.rule.attr, fieldname, None)
+        if type(deps) == "list":
+            for dep in deps:
+                if type(dep) == "Target" and GraphNodeInfo in dep:
+                    children.append(dep[GraphNodeInfo])
+        elif type(deps) == "Target" and GraphNodeInfo in deps:
+            children.append(deps[GraphNodeInfo])
 
     # TODO(bazel-team): Add flag to Bazel that can toggle the initialization of
     # linkable_more_than_once.
     linkable_more_than_once = False
-    no_exporting = False
     if hasattr(ctx.rule.attr, "tags"):
         for tag in ctx.rule.attr.tags:
             if tag == LINKABLE_MORE_THAN_ONCE:
                 linkable_more_than_once = True
-            elif tag == NO_EXPORTING:
-                no_exporting = True
-
     return [GraphNodeInfo(
-        label = ctx.label,
+        owners = owners,
         children = children,
         linkable_more_than_once = linkable_more_than_once,
-        no_exporting = no_exporting,
-    )]
-
-def _cc_shared_library_permissions_impl(ctx):
-    targets = []
-    for target_filter in ctx.attr.targets:
-        target_filter_label = ctx.label.relative(target_filter)
-        if not _check_if_target_under_path(target_filter_label, ctx.label.relative(":__subpackages__")):
-            fail("A cc_shared_library_permissions rule can only list " +
-                 "targets that are in the same package or a sub-package")
-        targets.append(target_filter_label)
-
-    return [CcSharedLibraryPermissionsInfo(
-        targets = targets,
     )]
 
 graph_structure_aspect = aspect(
     attr_aspects = ["*"],
+    required_providers = [[CcInfo], [ProtoInfo], [cc_common.CcSharedLibraryHintInfo_6_X_getter_do_not_use]],
+    required_aspect_providers = [[CcInfo], [cc_common.CcSharedLibraryHintInfo_6_X_getter_do_not_use]],
     implementation = _graph_structure_aspect_impl,
 )
 
-cc_shared_library_permissions = rule(
-    implementation = _cc_shared_library_permissions_impl,
-    attrs = {
-        "targets": attr.string_list(),
-    },
-)
-
 cc_shared_library = rule(
     implementation = _cc_shared_library_impl,
     attrs = {
@@ -676,8 +823,6 @@ cc_shared_library = rule(
         "shared_lib_name": attr.string(),
         "dynamic_deps": attr.label_list(providers = [CcSharedLibraryInfo]),
         "exports_filter": attr.string_list(),
-        "permissions": attr.label_list(providers = [CcSharedLibraryPermissionsInfo]),
-        "preloaded_deps": attr.label_list(providers = [CcInfo]),
         "win_def_file": attr.label(allow_single_file = [".def"]),
         "roots": attr.label_list(providers = [CcInfo], aspects = [graph_structure_aspect]),
         "deps": attr.label_list(providers = [CcInfo], aspects = [graph_structure_aspect]),
@@ -693,7 +838,7 @@ cc_shared_library = rule(
         ),
     },
     toolchains = cc_helper.use_cpp_toolchain(),
-    fragments = ["google_cpp", "cpp"],
+    fragments = ["cpp"] + semantics.additional_fragments(),
     incompatible_use_toolchain_transition = True,
 )
 
@@ -702,3 +847,6 @@ merge_cc_shared_library_infos = _merge_cc_shared_library_infos
 build_link_once_static_libs_map = _build_link_once_static_libs_map
 build_exports_map_from_only_dynamic_deps = _build_exports_map_from_only_dynamic_deps
 throw_linked_but_not_exported_errors = _throw_linked_but_not_exported_errors
+separate_static_and_dynamic_link_libraries = _separate_static_and_dynamic_link_libraries
+sort_linker_inputs = _sort_linker_inputs
+add_unused_dynamic_deps = _add_unused_dynamic_deps
diff --git a/src/main/starlark/builtins_bzl/common/exports.bzl b/src/main/starlark/builtins_bzl/common/exports.bzl
index 33dc18b24a2a4d..1a9671cf5d0066 100755
--- a/src/main/starlark/builtins_bzl/common/exports.bzl
+++ b/src/main/starlark/builtins_bzl/common/exports.bzl
@@ -17,7 +17,7 @@
 load("@_builtins//:common/cc/cc_import.bzl", "cc_import")
 load("@_builtins//:common/cc/cc_binary_wrapper.bzl", "cc_binary")
 load("@_builtins//:common/cc/cc_test_wrapper.bzl", cc_test = "cc_test_wrapper")
-load("@_builtins//:common/cc/experimental_cc_shared_library.bzl", "CcSharedLibraryInfo", "cc_shared_library", "cc_shared_library_permissions")
+load("@_builtins//:common/cc/experimental_cc_shared_library.bzl", "CcSharedLibraryInfo", "cc_shared_library")
 load("@_builtins//:common/objc/objc_import.bzl", "objc_import")
 load("@_builtins//:common/objc/objc_library.bzl", "objc_library")
 load("@_builtins//:common/objc/compilation_support.bzl", "compilation_support")
@@ -54,7 +54,6 @@ exported_rules = {
     "objc_library": objc_library,
     "proto_library": proto_library,
     "+cc_shared_library": cc_shared_library,
-    "+cc_shared_library_permissions": cc_shared_library_permissions,
     "+cc_binary": cc_binary,
     "+cc_test": cc_test,
     "+cc_library": cc_library,
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/BUILD.builtin_test b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/BUILD.builtin_test
index de112ad08e23f4..952dea0c426454 100644
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/BUILD.builtin_test
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/BUILD.builtin_test
@@ -2,16 +2,23 @@ load(
     ":starlark_tests.bzl",
     "additional_inputs_test",
     "build_failure_test",
-    "debug_files_test",
     "interface_library_output_group_test",
-    "linking_suffix_test",
+    "linking_order_test",
     "paths_test",
     "runfiles_test",
-    "no_exporting_static_lib_test",
+    "check_linking_action_lib_parameters_test",
+    "forwarding_cc_lib",
+    "nocode_cc_lib",
+    "wrapped_cc_lib",
 )
 
 LINKABLE_MORE_THAN_ONCE = "LINKABLE_MORE_THAN_ONCE"
 
+NO_BUILD_TAGS = [
+    "manual",
+    "nobuilder",
+]
+
 licenses(["notice"])
 
 package(
@@ -36,9 +43,15 @@ cc_binary(
     name = "binary",
     srcs = ["main.cc"],
     dynamic_deps = ["foo_so"],
-    deps = ["foo"],
+    deps = [
+        ":foo",
+    ],
 )
 
+# TODO(bazel-team): Add a test for proto dependencies once these tests are run
+# directly from a BUILD file and not from within a shell test. Right now
+# mocking what's needed to have a single proto dependency makes it impractical.
+
 cc_binary(
     name = "binary_with_bar_so_twice",
     srcs = ["main.cc"],
@@ -73,7 +86,7 @@ cc_shared_library(
     name = "diamond2_so",
     dynamic_deps = [":a_so"],
     features = ["windows_export_all_symbols"],
-    deps = [":qux2"],
+    deps = [":bar"],
 )
 
 cc_binary(
@@ -100,13 +113,19 @@ cc_shared_library(
     }),
     dynamic_deps = [
         "bar_so",
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3:diff_pkg_so"
+        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3:diff_pkg_so",
+        "private_lib_so",
     ],
     features = ["windows_export_all_symbols"],
-    preloaded_deps = ["preloaded_dep"],
+    exports_filter = [
+        ":indirect_dep2",
+    ],
     deps = [
         "baz",
         "foo",
+        "cc_lib_with_no_srcs",
+        "nocode_cc_lib",
+        "should_not_be_linked_cc_lib",
         "a_suffix",
     ],
     user_link_flags = select({
@@ -119,12 +138,6 @@ cc_shared_library(
     }),
 )
 
-cc_library(
-    name = "preloaded_dep",
-    srcs = ["preloaded_dep.cc"],
-    hdrs = ["preloaded_dep.h"],
-)
-
 cc_library(
     name = "foo",
     srcs = [
@@ -139,18 +152,72 @@ cc_library(
         "//src/conditions:linux": ["IS_LINUX"],
         "//conditions:default": [],
     }),
-    deps = [
-        "preloaded_dep",
+    deps = select({
+        ":is_bazel": ["qux2"],
+        "//conditions:default": [],
+    }) + [
         "bar",
         "baz",
         # Not exported.
         "qux",
-        "qux2",
         "prebuilt",
         "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3:diff_pkg"
     ],
 )
 
+wrapped_cc_lib(
+    name = "wrapped_cc_lib",
+    deps = [
+        "indirect_dep",
+    ],
+)
+
+forwarding_cc_lib(
+    name = "cc_lib_with_no_srcs",
+    deps = [
+        "wrapped_cc_lib",
+    ],
+)
+
+wrapped_cc_lib(
+    name = "should_not_be_linked_wrapped",
+    deps = [
+        "indirect_dep3",
+    ],
+)
+
+forwarding_cc_lib(
+    name = "should_not_be_linked_cc_lib",
+    do_not_follow_deps = [
+        "should_not_be_linked_wrapped",
+    ],
+)
+
+nocode_cc_lib(
+    name = "nocode_cc_lib",
+    additional_inputs = [
+        ":additional_script.txt",
+    ],
+    deps = [
+        "indirect_dep2",
+    ],
+)
+
+cc_library(
+    name = "indirect_dep",
+    srcs = ["indirect_dep.cc"],
+)
+
+cc_library(
+    name = "indirect_dep2",
+    srcs = ["indirect_dep2.cc"],
+)
+
+cc_library(
+    name = "indirect_dep3",
+    srcs = ["indirect_dep3.cc"],
+)
+
 cc_library(
     name = "a_suffix",
     srcs = ["a_suffix.cc"],
@@ -175,7 +242,7 @@ cc_library(
     name = "qux2",
     srcs = ["qux2.cc"],
     hdrs = ["qux2.h"],
-    tags = [LINKABLE_MORE_THAN_ONCE],
+    tags = [LINKABLE_MORE_THAN_ONCE] + NO_BUILD_TAGS,
 )
 
 config_setting(
@@ -196,9 +263,6 @@ cc_shared_library(
         "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3:bar",
     ],
     features = ["windows_export_all_symbols"],
-    permissions = [
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3:permissions",
-    ],
     deps = [
         "bar",
         "bar2",
@@ -230,8 +294,10 @@ cc_library(
     hdrs = ["bar.h"],
     deps = [
         "barX",
-        "qux2",
-    ],
+    ] + select({
+        ":is_bazel": ["qux2"],
+        "//conditions:default": [],
+    }),
 )
 
 cc_library(
@@ -281,7 +347,7 @@ filegroup(
     output_group = "rule_impl_debug_files",
 )
 
-linking_suffix_test(
+linking_order_test(
     name = "linking_action_test",
     # TODO(bazel-team): Support this test on Windows and Mac.
     is_linux = select({
@@ -301,6 +367,24 @@ additional_inputs_test(
     target_under_test = ":foo_so",
 )
 
+cc_shared_library(
+    name = "private_lib_so",
+    deps = [
+        ":private_lib",
+    ],
+)
+
+genrule(
+    name = "private_cc_lib_source",
+    outs = ["private_cc_library.cc"],
+    cmd = "touch $@",
+)
+
+cc_library(
+    name = "private_lib",
+    srcs = [":private_cc_library.cc"]
+)
+
 build_failure_test(
     name = "link_once_repeated_test_binary",
     messages = [
@@ -321,22 +405,10 @@ paths_test(
     name = "path_matching_test",
 )
 
-build_failure_test(
-    name = "export_without_permissions_test",
-    message = "doesn't have the necessary permissions",
-    target_under_test = "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets:permissions_fail_so",
-)
-
-build_failure_test(
-    name = "forbidden_target_permissions_test",
-    message = "can only list targets that are in the same package or a sub-package",
-    target_under_test = "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets:permissions_fail",
-)
-
 cc_library(
     name = "prebuilt",
+    hdrs = ["direct_so_file_cc_lib.h"],
     srcs = [
-        "direct_so_file_cc_lib.h",
         ":just_main_output",
     ],
 )
@@ -393,60 +465,6 @@ cc_library(
     ],
 )
 
-cc_shared_library_permissions(
-    name = "permissions",
-    targets = [
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library:a_suffix",
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library:qux",
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library:qux2",
-    ],
-)
-
-cc_library(
-    name = "static_lib_no_exporting",
-    srcs = [
-        "bar.cc",
-        "bar.h",
-    ],
-    tags = ["NO_EXPORTING"],
-)
-
-cc_library(
-    name = "static_lib_exporting",
-    srcs = [
-        "bar2.cc",
-        "bar2.h",
-    ],
-)
-
-cc_shared_library(
-    name = "lib_with_no_exporting_roots_1",
-    deps = [":static_lib_no_exporting"],
-)
-
-cc_shared_library(
-    name = "lib_with_no_exporting_roots_2",
-    deps = [":static_lib_no_exporting"],
-    dynamic_deps = [":lib_with_no_exporting_roots_3"],
-)
-
-cc_shared_library(
-    name = "lib_with_no_exporting_roots_3",
-    deps = [":static_lib_no_exporting"],
-)
-
-cc_shared_library(
-    name = "lib_with_no_exporting_roots",
-    deps = [
-        ":static_lib_no_exporting",
-        ":static_lib_exporting",
-    ],
-    dynamic_deps = [
-        ":lib_with_no_exporting_roots_1",
-        ":lib_with_no_exporting_roots_2",
-    ],
-)
-
 build_failure_test(
     name = "two_dynamic_deps_same_export_in_so_test",
     message = "Two shared libraries in dependencies export the same symbols",
@@ -459,11 +477,6 @@ build_failure_test(
     target_under_test = "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets:two_dynamic_deps_same_export_in_binary",
 )
 
-debug_files_test(
-    name = "debug_files_test",
-    target_under_test = ":binary",
-)
-
 interface_library_output_group_test(
     name = "interface_library_output_group_test",
     is_windows = select({
@@ -482,7 +495,26 @@ runfiles_test(
     target_under_test = ":python_test",
 )
 
-no_exporting_static_lib_test(
-    name = "no_exporting_static_lib_test",
-    target_under_test = ":lib_with_no_exporting_roots",
+check_linking_action_lib_parameters_test(
+    name = "check_binary_doesnt_take_already_linked_in_libs",
+    target_under_test = ":binary",
+    libs_that_shouldnt_be_present = ["foo", "bar"],
+)
+
+check_linking_action_lib_parameters_test(
+    name = "check_shared_lib_doesnt_take_already_linked_in_libs",
+    target_under_test = ":foo_so",
+    libs_that_shouldnt_be_present = ["bar"],
+)
+
+build_failure_test(
+    name = "shared_library_without_deps",
+    message = "'cc_shared_library' must have at least one dependency in 'deps' (or 'roots')",
+    target_under_test = "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets:failing_with_no_deps_so",
+)
+
+build_failure_test(
+    name = "direct_dep_with_only_shared_lib_file",
+    message = "Do not place libraries which only contain a precompiled dynamic library",
+    target_under_test = "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets:failing_only_dynamic_lib",
 )
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/cc_shared_library_integration_test.sh b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/cc_shared_library_integration_test.sh
index a6b480bff2d95d..b49357f6c8833c 100755
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/cc_shared_library_integration_test.sh
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/cc_shared_library_integration_test.sh
@@ -38,16 +38,16 @@ function check_symbol_absent() {
 
 function test_shared_library_symbols() {
   foo_so=$(find . -name libfoo_so.so)
-  symbols=$(nm -D $foo_so)
+  symbols=$(nm $foo_so)
   check_symbol_present "$symbols" "U _Z3barv"
   check_symbol_present "$symbols" "T _Z3bazv"
   check_symbol_present "$symbols" "T _Z3foov"
-  # Check that the preloaded dep symbol is not present
-  check_symbol_present "$symbols" "U _Z13preloaded_depv"
-
-  check_symbol_absent "$symbols" "_Z3quxv"
+  check_symbol_present "$symbols" "T _Z3foov"
+  check_symbol_present "$symbols" "t _Z3quxv"
+  check_symbol_present "$symbols" "t _Z12indirect_depv"
+  check_symbol_present "$symbols" "t _Z13indirect_dep2v"
+  check_symbol_absent "$symbols" "_Z13indirect_dep3v"
   check_symbol_absent "$symbols" "_Z4bar3v"
-  check_symbol_absent "$symbols" "_Z4bar4v"
 }
 
 function test_shared_library_user_link_flags() {
@@ -66,17 +66,23 @@ function do_test_binary() {
 function test_binary() {
   binary=$(find . -name binary)
   do_test_binary $binary
-  check_symbol_present "$symbols" "T _Z13preloaded_depv"
 }
 
 function test_cc_test() {
   cc_test=$(find . -name cc_test)
   do_test_binary $cc_test
-  check_symbol_absent "$symbols" "_Z13preloaded_depv"
-  $LDD_BINARY $cc_test | (grep -q "preloaded_Udep.so" || (echo "Expected '"preloaded_Udep.so"'" && exit 1))
+}
+
+function test_number_of_linked_libs() {
+  binary=$(find . -name binary)
+  expected_num_libs="6"
+  num_libs=$(readelf -d  $binary | grep NEEDED | wc -l)
+  echo "$num_libs" | (grep -q  "$expected_num_libs" \
+    || (echo "Expected no more than "$expected_num_libs" linked libraries but was $num_libs" && exit 1))
 }
 
 test_shared_library_user_link_flags
 test_shared_library_symbols
 test_binary
 test_cc_test
+test_number_of_linked_libs
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets/BUILD.builtin_test b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets/BUILD.builtin_test
index 6ab7018d6e2f0b..5b0b495c8ed70f 100644
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets/BUILD.builtin_test
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/failing_targets/BUILD.builtin_test
@@ -32,22 +32,6 @@ cc_library(
     ],
 )
 
-cc_shared_library(
-    name = "permissions_fail_so",
-    deps = [
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3:bar",
-    ],
-    tags = TAGS,
-)
-
-cc_shared_library_permissions(
-    name = "permissions_fail",
-    tags = TAGS,
-    targets = [
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library:foo",
-    ],
-)
-
 cc_library(
     name = "a",
     srcs = ["a.cc"],
@@ -100,3 +84,32 @@ cc_shared_library(
     ],
     tags = TAGS,
 )
+
+cc_shared_library(
+    name = "failing_with_no_deps_so",
+    tags = TAGS,
+)
+
+
+cc_shared_library(
+    name = "failing_only_dynamic_lib",
+    deps = [
+        "dynamic_only",
+    ],
+    tags = TAGS,
+)
+
+cc_library(
+    name = "dynamic_only",
+    srcs = [
+        "libabc.so",
+    ],
+)
+
+genrule(
+    name = "abc_lib",
+    srcs = [],
+    outs = ["libabc.so"],
+    cmd = "touch \"$@\"",
+)
+
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/foo.cc b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/foo.cc
index 0559c0a3b9da9c..0fd81db5253a5f 100644
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/foo.cc
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/foo.cc
@@ -15,7 +15,6 @@
 #include "src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/baz.h"
 #include "src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/direct_so_file_cc_lib.h"
 #include "src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/direct_so_file_cc_lib2.h"
-#include "src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.h"
 #include "src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/qux.h"
 #include "src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3/diff_pkg.h"
 
@@ -27,7 +26,6 @@ int foo() {
 #ifdef IS_LINUX
   direct_so_file_cc_lib();
   direct_so_file_cc_lib2();
-  preloaded_dep();
 #endif
   return 42;
 }
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.cc b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep.cc
similarity index 73%
rename from src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.cc
rename to src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep.cc
index bfa422deb17eb2..e1b446f22ececb 100644
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.cc
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep.cc
@@ -1,4 +1,4 @@
-// Copyright 2016 The Bazel Authors. All rights reserved.
+// Copyright 2023 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.
@@ -11,6 +11,5 @@
 // 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.
-#include "src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.h"
 
-int preloaded_dep() { return 42; }
+int indirect_dep() { return 0; }
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.h b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep2.cc
similarity index 68%
rename from src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.h
rename to src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep2.cc
index d295eda86d8fea..a21e7d854c7669 100644
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/preloaded_dep.h
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep2.cc
@@ -1,4 +1,4 @@
-// Copyright 2016 The Bazel Authors. All rights reserved.
+// Copyright 2023 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.
@@ -11,9 +11,5 @@
 // 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.
-#ifndef EXAMPLES_TEST_CC_SHARED_LIBRARY_PRELOADED_DEP_H_
-#define EXAMPLES_TEST_CC_SHARED_LIBRARY_PRELOADED_DEP_H_
 
-int preloaded_dep();
-
-#endif  // EXAMPLES_TEST_CC_SHARED_LIBRARY_PRELOADED_DEP_H_
+int indirect_dep2() { return 0; }
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep3.cc b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep3.cc
new file mode 100644
index 00000000000000..3f5fba1c2bc644
--- /dev/null
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/indirect_dep3.cc
@@ -0,0 +1,15 @@
+// Copyright 2023 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.
+
+int indirect_dep3() { return 0; }
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/starlark_tests.bzl b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/starlark_tests.bzl
index c5de4978aab962..a1d8d18d05bc10 100644
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/starlark_tests.bzl
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library/starlark_tests.bzl
@@ -41,9 +41,19 @@ def _check_if_target_under_path(value, pattern):
 
     return pattern.package == value.package and pattern.name == value.name
 
-def _linking_suffix_test_impl(ctx):
+def _linking_order_test_impl(ctx):
     env = analysistest.begin(ctx)
 
+    def _filename(path):
+        filename = None
+        for i in range(len(path) - 1, -1, -1):
+            if path[i] == "/":
+                filename = path[i + 1:]
+                break
+
+        asserts.true(env, filename != None, "the test assumes the argument is a file path")
+        return filename
+
     if ctx.attr.is_linux:
         target_under_test = analysistest.target_under_test(env)
         actions = analysistest.target_actions(env)
@@ -57,13 +67,15 @@ def _linking_suffix_test_impl(ctx):
         user_libs = []
         for arg in args:
             if arg.endswith(".o"):
-                user_libs.append(arg)
-        asserts.true(env, user_libs[-1].endswith("a_suffix.pic.o"), "liba_suffix.pic.o should be the last user library linked")
+                user_libs.append(_filename(arg))
+
+        asserts.true(env, user_libs.index("foo.pic.o") < user_libs.index("baz.pic.o"), "'foo' should appear before 'bar' in command line")
+        asserts.true(env, user_libs[-1] == "a_suffix.pic.o", "liba_suffix.pic.o should be the last user library linked")
 
     return analysistest.end(env)
 
-linking_suffix_test = analysistest.make(
-    _linking_suffix_test_impl,
+linking_order_test = analysistest.make(
+    _linking_order_test_impl,
     attrs = {
         "is_linux": attr.bool(),
     },
@@ -143,29 +155,6 @@ def _paths_test_impl(ctx):
 
 paths_test = unittest.make(_paths_test_impl)
 
-def _debug_files_test_impl(ctx):
-    env = analysistest.begin(ctx)
-
-    target_under_test = analysistest.target_under_test(env)
-    actual_files = []
-    for debug_file in target_under_test[OutputGroupInfo].rule_impl_debug_files.to_list():
-        actual_files.append(debug_file.basename)
-
-    expected_files = [
-        "bar_so_exports.txt",
-        "bar_so_link_once_static_libs.txt",
-        "diff_pkg_so_exports.txt",
-        "diff_pkg_so_link_once_static_libs.txt",
-        "foo_so_exports.txt",
-        "foo_so_link_once_static_libs.txt",
-        "binary_link_once_static_libs.txt",
-    ]
-    asserts.equals(env, expected_files, actual_files)
-
-    return analysistest.end(env)
-
-debug_files_test = analysistest.make(_debug_files_test_impl)
-
 def _runfiles_test_impl(ctx):
     env = analysistest.begin(ctx)
     if not ctx.attr.is_linux:
@@ -176,6 +165,7 @@ def _runfiles_test_impl(ctx):
         "libfoo_so.so",
         "libbar_so.so",
         "libdiff_pkg_so.so",
+        "libprivate_lib_so.so",
         "Smain_Sstarlark_Stests_Sbuiltins_Ubzl_Scc_Scc_Ushared_Ulibrary_Stest_Ucc_Ushared_Ulibrary_Slibfoo_Uso.so",
         "Smain_Sstarlark_Stests_Sbuiltins_Ubzl_Scc_Scc_Ushared_Ulibrary_Stest_Ucc_Ushared_Ulibrary_Slibbar_Uso.so",
         "Smain_Sstarlark_Stests_Sbuiltins_Ubzl_Scc_Scc_Ushared_Ulibrary_Stest_Ucc_Ushared_Ulibrary3_Slibdiff_Upkg_Uso.so",
@@ -223,20 +213,104 @@ interface_library_output_group_test = analysistest.make(
     },
 )
 
-def _no_exporting_static_lib_test_impl(ctx):
+def _check_linking_action_lib_parameters_test_impl(ctx):
     env = analysistest.begin(ctx)
 
-    target_under_test = analysistest.target_under_test(env)
+    actions = analysistest.target_actions(env)
 
-    # There should be only one exported file
-    actual_file = target_under_test[CcSharedLibraryInfo].exports[0]
-
-    # Sometimes "@" is prefixed in some test environments
-    expected = "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library:static_lib_exporting"
-    asserts.true(env, actual_file.endswith(expected))
+    target_action = None
+    for action in actions:
+        if action.mnemonic == "FileWrite":
+            target_action = action
+            break
+    args = target_action.content.split("\n")
+    for arg in args:
+        for bad_lib_entry in ctx.attr.libs_that_shouldnt_be_present:
+            asserts.true(env, arg.find("{}.".format(bad_lib_entry)) == -1, "Should not have seen library `{}` in command line".format(arg))
 
     return analysistest.end(env)
 
-no_exporting_static_lib_test = analysistest.make(
-    _no_exporting_static_lib_test_impl,
+check_linking_action_lib_parameters_test = analysistest.make(
+    _check_linking_action_lib_parameters_test_impl,
+    attrs = {
+        "libs_that_shouldnt_be_present": attr.string_list(),
+    },
+)
+
+AspectCcInfo = provider("Takes a cc_info.", fields = {"cc_info": "cc_info"})
+WrappedCcInfo = provider("Takes a cc_info.", fields = {"cc_info": "cc_info"})
+
+def _forwarding_cc_lib_aspect_impl(target, ctx):
+    cc_info = target[WrappedCcInfo].cc_info
+    linker_inputs = []
+    owner = ctx.label.relative(ctx.label.name + ".custom")
+    for linker_input in cc_info.linking_context.linker_inputs.to_list():
+        if linker_input.owner == ctx.label.relative("indirect_dep"):
+            linker_inputs.append(cc_common.create_linker_input(
+                owner = owner,
+                libraries = depset(linker_input.libraries),
+            ))
+        else:
+            linker_inputs.append(linker_input)
+    cc_info = CcInfo(
+        compilation_context = cc_info.compilation_context,
+        linking_context = cc_common.create_linking_context(
+            linker_inputs = depset(linker_inputs),
+        ),
+    )
+    return [
+        AspectCcInfo(cc_info = cc_info),
+        cc_common.CcSharedLibraryHintInfo_6_X_constructor_do_not_use(
+            owners = [owner],
+        ),
+    ]
+
+forwarding_cc_lib_aspect = aspect(
+    implementation = _forwarding_cc_lib_aspect_impl,
+    required_providers = [WrappedCcInfo],
+    provides = [AspectCcInfo, cc_common.CcSharedLibraryHintInfo_6_X_getter_do_not_use],
+)
+
+def _wrapped_cc_lib_impl(ctx):
+    return [WrappedCcInfo(cc_info = ctx.attr.deps[0][CcInfo]), CcInfo()]
+
+wrapped_cc_lib = rule(
+    implementation = _wrapped_cc_lib_impl,
+    attrs = {
+        "deps": attr.label_list(providers = [CcInfo]),
+    },
+    provides = [WrappedCcInfo, CcInfo],
+)
+
+def _forwarding_cc_lib_impl(ctx):
+    hints = cc_common.CcSharedLibraryHintInfo_6_X_constructor_do_not_use(attributes = ["deps"])
+    if ctx.attr.deps:
+        return [ctx.attr.deps[0][AspectCcInfo].cc_info, hints]
+    else:
+        return [ctx.attr.do_not_follow_deps[0][AspectCcInfo].cc_info, hints]
+
+forwarding_cc_lib = rule(
+    implementation = _forwarding_cc_lib_impl,
+    attrs = {
+        "deps": attr.label_list(providers = [WrappedCcInfo], aspects = [forwarding_cc_lib_aspect]),
+        "do_not_follow_deps": attr.label_list(providers = [WrappedCcInfo], aspects = [forwarding_cc_lib_aspect]),
+    },
+    provides = [CcInfo, cc_common.CcSharedLibraryHintInfo_6_X_getter_do_not_use],
+)
+
+def _nocode_cc_lib_impl(ctx):
+    linker_input = cc_common.create_linker_input(
+        owner = ctx.label,
+        additional_inputs = depset([ctx.files.additional_inputs[0]]),
+    )
+    cc_info = CcInfo(linking_context = cc_common.create_linking_context(linker_inputs = depset([linker_input])))
+    return [cc_common.merge_cc_infos(cc_infos = [cc_info, ctx.attr.deps[0][CcInfo]])]
+
+nocode_cc_lib = rule(
+    implementation = _nocode_cc_lib_impl,
+    attrs = {
+        "additional_inputs": attr.label_list(allow_files = True),
+        "deps": attr.label_list(),
+    },
+    provides = [CcInfo],
 )
diff --git a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3/BUILD.builtin_test b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3/BUILD.builtin_test
index 364e7f84367aa6..39d541f8f37624 100644
--- a/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3/BUILD.builtin_test
+++ b/src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3/BUILD.builtin_test
@@ -21,10 +21,3 @@ cc_shared_library(
         ":diff_pkg",
     ],
 )
-
-cc_shared_library_permissions(
-    name = "permissions",
-    targets = [
-        "//src/main/starlark/tests/builtins_bzl/cc/cc_shared_library/test_cc_shared_library3:bar",
-    ],
-)