diff --git a/prelude/apple/prebuilt_apple_framework.bzl b/prelude/apple/prebuilt_apple_framework.bzl
index 2472d9ae..ec538416 100644
--- a/prelude/apple/prebuilt_apple_framework.bzl
+++ b/prelude/apple/prebuilt_apple_framework.bzl
@@ -5,6 +5,7 @@
 # License, Version 2.0 found in the LICENSE-APACHE file in the root directory
 # of this source tree.
 
+load("@prelude//cxx:cxx_context.bzl", "get_cxx_toolchain_info")
 load(
     "@prelude//cxx:cxx_library_utility.bzl",
     "cxx_attr_exported_linker_flags",
@@ -79,6 +80,7 @@ def prebuilt_apple_framework_impl(ctx: "context") -> ["provider"]:
         )
         providers.append(create_merged_link_info(
             ctx,
+            get_cxx_toolchain_info(ctx).pic_behavior,
             {link_style: LinkInfos(default = link) for link_style in LinkStyle},
         ))
 
diff --git a/prelude/cxx/cxx.bzl b/prelude/cxx/cxx.bzl
index 90d615f7..cce4e6ff 100644
--- a/prelude/cxx/cxx.bzl
+++ b/prelude/cxx/cxx.bzl
@@ -451,8 +451,10 @@ def prebuilt_cxx_library_impl(ctx: "context") -> ["provider"]:
         )]
 
     # Create the default output for the library rule given it's link style and preferred linkage
-    link_style = get_cxx_toolchain_info(ctx).linker_info.link_style
-    actual_link_style = get_actual_link_style(link_style, preferred_linkage)
+    cxx_toolchain = get_cxx_toolchain_info(ctx)
+    pic_behavior = cxx_toolchain.pic_behavior
+    link_style = cxx_toolchain.linker_info.link_style
+    actual_link_style = get_actual_link_style(link_style, preferred_linkage, pic_behavior)
     output = outputs[actual_link_style]
     providers.append(DefaultInfo(
         default_output = output,
@@ -462,6 +464,7 @@ def prebuilt_cxx_library_impl(ctx: "context") -> ["provider"]:
     # Propagate link info provider.
     providers.append(create_merged_link_info(
         ctx,
+        pic_behavior,
         # Add link info for each link style,
         libraries,
         preferred_linkage = preferred_linkage,
diff --git a/prelude/cxx/cxx_executable.bzl b/prelude/cxx/cxx_executable.bzl
index 1b5e1bbf..d044b5d6 100644
--- a/prelude/cxx/cxx_executable.bzl
+++ b/prelude/cxx/cxx_executable.bzl
@@ -302,6 +302,8 @@ def cxx_executable(ctx: "context", impl_params: CxxRuleConstructorParams.type, i
                 children = [d.link_group_lib_info for d in link_deps],
             )
 
+        pic_behavior = get_cxx_toolchain_info(ctx).pic_behavior
+
         # TODO(T110378098): Similar to shared libraries, we need to identify all the possible
         # scenarios for which we need to propagate up link info and simplify this logic. For now
         # base which links to use based on whether link groups are defined.
@@ -310,6 +312,7 @@ def cxx_executable(ctx: "context", impl_params: CxxRuleConstructorParams.type, i
             link_group,
             link_group_mappings,
             link_group_preferred_linkage,
+            pic_behavior = pic_behavior,
             link_group_libs = {
                 name: (lib.label, lib.shared_link_infos)
                 for name, lib in link_group_libs.items()
@@ -338,6 +341,7 @@ def cxx_executable(ctx: "context", impl_params: CxxRuleConstructorParams.type, i
                 link_group_mappings,
                 link_group_preferred_linkage,
                 link_style,
+                pic_behavior = pic_behavior,
                 roots = [d.linkable_graph.nodes.value.label for d in link_deps],
                 is_executable_link = True,
                 prefer_stripped = impl_params.prefer_stripped_objects,
diff --git a/prelude/cxx/cxx_library.bzl b/prelude/cxx/cxx_library.bzl
index 6380bd8d..6ed8c04c 100644
--- a/prelude/cxx/cxx_library.bzl
+++ b/prelude/cxx/cxx_library.bzl
@@ -59,6 +59,7 @@ load(
     "Linkage",
     "LinkedObject",  # @unused Used as a type
     "ObjectsLinkable",
+    "STATIC_LINK_STYLES",
     "SharedLibLinkable",
     "SwiftRuntimeLinkable",  # @unused Used as a type
     "SwiftmoduleLinkable",  # @unused Used as a type
@@ -66,6 +67,7 @@ load(
     "get_actual_link_style",
     "get_link_args",
     "get_link_styles_for_linkage",
+    "process_link_style_for_pic_behavior",
     "unpack_link_args",
     "wrap_link_info",
 )
@@ -439,7 +441,8 @@ def cxx_library_parameterized(ctx: "context", impl_params: "CxxRuleConstructorPa
 
     providers.extend(library_outputs.providers)
 
-    actual_link_style = get_actual_link_style(cxx_attr_link_style(ctx), preferred_linkage)
+    pic_behavior = get_cxx_toolchain_info(ctx).pic_behavior
+    actual_link_style = get_actual_link_style(cxx_attr_link_style(ctx), preferred_linkage, pic_behavior)
 
     # Output sub-targets for all link-styles.
     if impl_params.generate_sub_targets.link_style_outputs or impl_params.generate_providers.link_style_outputs:
@@ -510,6 +513,7 @@ def cxx_library_parameterized(ctx: "context", impl_params: "CxxRuleConstructorPa
 
         merged_native_link_info = create_merged_link_info(
             ctx,
+            pic_behavior,
             # Add link info for each link style,
             library_outputs.libraries,
             preferred_linkage = preferred_linkage,
@@ -551,6 +555,7 @@ def cxx_library_parameterized(ctx: "context", impl_params: "CxxRuleConstructorPa
     if impl_params.generate_sub_targets.headers:
         sub_targets["headers"] = [propagated_preprocessor, create_merged_link_info(
             ctx,
+            pic_behavior = pic_behavior,
             preferred_linkage = Linkage("static"),
             frameworks_linkable = frameworks_linkable,
         ), LinkGroupLibInfo(libs = {}), SharedLibraryInfo(set = None)] + additional_providers
@@ -755,8 +760,8 @@ def cxx_library_parameterized(ctx: "context", impl_params: "CxxRuleConstructorPa
 
 def get_default_cxx_library_product_name(ctx, impl_params) -> str:
     preferred_linkage = cxx_attr_preferred_linkage(ctx)
-    link_style = get_actual_link_style(cxx_attr_link_style(ctx), preferred_linkage)
-    if link_style in (LinkStyle("static"), LinkStyle("static_pic")):
+    link_style = get_actual_link_style(cxx_attr_link_style(ctx), preferred_linkage, get_cxx_toolchain_info(ctx).pic_behavior)
+    if link_style in STATIC_LINK_STYLES:
         return _base_static_library_name(ctx, False)
     else:
         return _soname(ctx, impl_params)
@@ -1008,6 +1013,8 @@ def _get_shared_library_links(
     logic here, simply diverge behavior on whether link groups are defined.
     """
 
+    pic_behavior = get_cxx_toolchain_info(ctx).pic_behavior
+
     # If we're not filtering for link groups, link against the shared dependencies
     if not link_group_mappings and not force_link_group_linking:
         link = cxx_inherited_link_info(ctx, dedupe(flatten([non_exported_deps, exported_deps])))
@@ -1036,14 +1043,20 @@ def _get_shared_library_links(
             ctx,
             link,
             frameworks_linkable,
-            LinkStyle(link_style_value),
+            # fPIC behaves differently on various combinations of toolchains + platforms.
+            # To get the link_style, we have to check the link_style against the toolchain's pic_behavior.
+            #
+            # For more info, check the PicBehavior.type docs.
+            process_link_style_for_pic_behavior(LinkStyle(link_style_value), pic_behavior),
             swiftmodule_linkable = swiftmodule_linkable,
             swift_runtime_linkable = swift_runtime_linkable,
         ), None, link_execution_preference
 
     # Else get filtered link group links
     prefer_stripped = cxx_is_gnu(ctx) and ctx.attrs.prefer_stripped_objects
+
     link_style = cxx_attr_link_style(ctx) if cxx_attr_link_style(ctx) != LinkStyle("static") else LinkStyle("static_pic")
+    link_style = process_link_style_for_pic_behavior(link_style, pic_behavior)
     filtered_labels_to_links_map = get_filtered_labels_to_links_map(
         linkable_graph_node_map_func(),
         link_group,
@@ -1055,6 +1068,7 @@ def _get_shared_library_links(
         },
         link_style = link_style,
         roots = linkable_deps(non_exported_deps + exported_deps),
+        pic_behavior = pic_behavior,
         prefer_stripped = prefer_stripped,
         force_static_follows_dependents = force_static_follows_dependents,
     )
diff --git a/prelude/cxx/link_groups.bzl b/prelude/cxx/link_groups.bzl
index 617f0fc2..6c7ad2c6 100644
--- a/prelude/cxx/link_groups.bzl
+++ b/prelude/cxx/link_groups.bzl
@@ -55,6 +55,7 @@ load(
     "cxx_is_gnu",
     "cxx_mk_shlib_intf",
 )
+load(":cxx_toolchain_types.bzl", "PicBehavior")
 load(
     ":groups.bzl",
     "Group",  # @unused Used as a type
@@ -204,12 +205,13 @@ def get_link_group_preferred_linkage(link_groups: [Group.type]) -> {"label": Lin
         if mapping.root != None and mapping.preferred_linkage != None
     }
 
-def transitively_update_shared_linkage(
+def _transitively_update_shared_linkage(
         linkable_graph_node_map: {"label": LinkableNode.type},
         link_group: [str, None],
         link_style: LinkStyle.type,
         link_group_preferred_linkage: {"label": Linkage.type},
-        link_group_roots: {"label": str}):
+        link_group_roots: {"label": str},
+        pic_behavior: PicBehavior.type):
     # Identify targets whose shared linkage style may be propagated to
     # dependencies. Implicitly created root libraries are skipped.
     shared_lib_roots = []
@@ -218,7 +220,7 @@ def transitively_update_shared_linkage(
         node = linkable_graph_node_map.get(target)
         if node == None:
             continue
-        actual_link_style = get_actual_link_style(link_style, link_group_preferred_linkage.get(target, node.preferred_linkage))
+        actual_link_style = get_actual_link_style(link_style, link_group_preferred_linkage.get(target, node.preferred_linkage), pic_behavior)
         if actual_link_style == LinkStyle("shared"):
             target_link_group = link_group_roots.get(target)
             if target_link_group == None or target_link_group == link_group:
@@ -229,7 +231,7 @@ def transitively_update_shared_linkage(
         linkable_node = linkable_graph_node_map[node]
         if linkable_node.preferred_linkage == Linkage("any"):
             link_group_preferred_linkage[node] = Linkage("shared")
-        return get_deps_for_link(linkable_node, link_style)
+        return get_deps_for_link(linkable_node, link_style, pic_behavior)
 
     breadth_first_traversal_by(
         linkable_graph_node_map,
@@ -244,6 +246,7 @@ def get_filtered_labels_to_links_map(
         link_group_preferred_linkage: {"label": Linkage.type},
         link_style: LinkStyle.type,
         roots: ["label"],
+        pic_behavior: PicBehavior.type,
         link_group_libs: {str: (["label", None], LinkInfos.type)} = {},
         prefer_stripped: bool = False,
         is_executable_link: bool = False,
@@ -291,12 +294,13 @@ def get_filtered_labels_to_links_map(
 
     # Transitively update preferred linkage to avoid runtime issues from
     # missing dependencies (e.g. for prebuilt shared libs).
-    transitively_update_shared_linkage(
+    _transitively_update_shared_linkage(
         linkable_graph_node_map,
         link_group,
         link_style,
         link_group_preferred_linkage,
         link_group_roots,
+        pic_behavior,
     )
 
     linkable_map = {}
@@ -338,7 +342,7 @@ def get_filtered_labels_to_links_map(
 
     for target in linkables:
         node = linkable_graph_node_map[target]
-        actual_link_style = get_actual_link_style(link_style, link_group_preferred_linkage.get(target, node.preferred_linkage))
+        actual_link_style = get_actual_link_style(link_style, link_group_preferred_linkage.get(target, node.preferred_linkage), pic_behavior)
 
         # Always link any shared dependencies
         if actual_link_style == LinkStyle("shared"):
@@ -573,6 +577,7 @@ def _create_link_group(
         spec.group.name,
         link_group_mappings,
         link_group_preferred_linkage,
+        pic_behavior = get_cxx_toolchain_info(ctx).pic_behavior,
         link_group_libs = link_group_libs,
         link_style = link_style,
         roots = roots,
diff --git a/prelude/cxx/omnibus.bzl b/prelude/cxx/omnibus.bzl
index 451ccaf3..6697520a 100644
--- a/prelude/cxx/omnibus.bzl
+++ b/prelude/cxx/omnibus.bzl
@@ -6,6 +6,7 @@
 # of this source tree.
 
 load("@prelude//:local_only.bzl", "get_resolved_cxx_binary_link_execution_preference")
+load("@prelude//cxx:cxx_toolchain_types.bzl", "PicBehavior")
 load(
     "@prelude//cxx:link.bzl",
     "cxx_link_shared_library",
@@ -195,7 +196,8 @@ def create_linkable_root(
         omnibus_graph = get_omnibus_graph(graph, {}, {})
 
         inputs = []
-        linker_info = get_cxx_toolchain_info(ctx).linker_info
+        toolchain_info = get_cxx_toolchain_info(ctx)
+        linker_info = toolchain_info.linker_info
         linker_type = linker_info.type
         inputs.append(LinkInfo(
             pre_flags =
@@ -215,12 +217,13 @@ def create_linkable_root(
         required_body = []
         required_exclusions = []
 
-        for dep in _link_deps(omnibus_graph.nodes, deps):
+        for dep in _link_deps(omnibus_graph.nodes, deps, toolchain_info.pic_behavior):
             node = omnibus_graph.nodes[dep]
 
             actual_link_style = get_actual_link_style(
                 LinkStyle("shared"),
                 node.preferred_linkage,
+                toolchain_info.pic_behavior,
             )
 
             if actual_link_style != LinkStyle("shared"):
@@ -334,7 +337,8 @@ def create_dummy_omnibus(ctx: "context", extra_ldflags: [""] = []) -> "artifact"
 
 def _link_deps(
         link_infos: {"label": LinkableNode.type},
-        deps: ["label"]) -> ["label"]:
+        deps: ["label"],
+        pic_behavior: PicBehavior.type) -> ["label"]:
     """
     Return transitive deps required to link dynamically against the given deps.
     This will following through deps of statically linked inputs and exported
@@ -342,7 +346,7 @@ def _link_deps(
     """
 
     def find_deps(node: "label"):
-        return get_deps_for_link(link_infos[node], LinkStyle("shared"))
+        return get_deps_for_link(link_infos[node], LinkStyle("shared"), pic_behavior)
 
     return breadth_first_traversal_by(link_infos, deps, find_deps)
 
@@ -368,6 +372,7 @@ def _create_root(
         label: "label",
         link_deps: ["label"],
         omnibus: "artifact",
+        pic_behavior: PicBehavior.type,
         extra_ldflags: [""] = [],
         prefer_stripped_objects: bool = False) -> OmnibusRootProduct.type:
     """
@@ -422,6 +427,7 @@ def _create_root(
         actual_link_style = get_actual_link_style(
             LinkStyle("shared"),
             node.preferred_linkage,
+            pic_behavior,
         )
 
         # If this dep needs to be linked statically, then link it directly.
@@ -627,6 +633,7 @@ def _create_omnibus(
         ctx: "context",
         spec: OmnibusSpec.type,
         annotated_root_products,
+        pic_behavior: PicBehavior.type,
         extra_ldflags: [""] = [],
         prefer_stripped_objects: bool = False) -> LinkedObject.type:
     inputs = []
@@ -665,6 +672,7 @@ def _create_omnibus(
         actual_link_style = get_actual_link_style(
             LinkStyle("static_pic"),
             node.preferred_linkage,
+            pic_behavior,
         )
         expect(actual_link_style == LinkStyle("static_pic"))
         body_input = get_link_info(
@@ -681,12 +689,15 @@ def _create_omnibus(
                 expect(dep in spec.excluded)
                 deps[dep] = None
 
+    toolchain_info = get_cxx_toolchain_info(ctx)
+
     # Now add deps of omnibus to the link
-    for label in _link_deps(spec.link_infos, deps.keys()):
+    for label in _link_deps(spec.link_infos, deps.keys(), toolchain_info.pic_behavior):
         node = spec.link_infos[label]
         actual_link_style = get_actual_link_style(
             LinkStyle("shared"),
             node.preferred_linkage,
+            toolchain_info.pic_behavior,
         )
         inputs.append(get_link_info(
             node,
@@ -694,7 +705,6 @@ def _create_omnibus(
             prefer_stripped = prefer_stripped_objects,
         ))
 
-    toolchain_info = get_cxx_toolchain_info(ctx)
     linker_info = toolchain_info.linker_info
 
     # Add global symbols version script.
@@ -774,7 +784,7 @@ def _build_omnibus_spec(
     # Find the deps of the root nodes.  These form the roots of the nodes
     # included in the omnibus link.
     first_order_root_deps = []
-    for label in _link_deps(graph.nodes, flatten([r.root.deps for r in roots.values()])):
+    for label in _link_deps(graph.nodes, flatten([r.root.deps for r in roots.values()]), get_cxx_toolchain_info(ctx).pic_behavior):
         # We only consider deps which aren't *only* statically linked.
         if _is_static_only(graph.nodes[label]):
             continue
@@ -836,7 +846,8 @@ def _implicit_exclusion_roots(ctx: "context", graph: OmnibusGraph.type) -> ["lab
     ]
 
 def _ordered_roots(
-        spec: OmnibusSpec.type) -> [("label", AnnotatedLinkableRoot.type, ["label"])]:
+        spec: OmnibusSpec.type,
+        pic_behavior: PicBehavior.type) -> [("label", AnnotatedLinkableRoot.type, ["label"])]:
     """
     Return information needed to link the roots nodes.
     """
@@ -844,7 +855,7 @@ def _ordered_roots(
     # Calculate all deps each root node needs to link against.
     link_deps = {}
     for label, root in spec.roots.items():
-        link_deps[label] = _link_deps(spec.link_infos, root.root.deps)
+        link_deps[label] = _link_deps(spec.link_infos, root.root.deps, pic_behavior)
 
     # Used the link deps to create the graph of root nodes.
     root_graph = {
@@ -869,6 +880,7 @@ def create_omnibus_libraries(
         extra_ldflags: [""] = [],
         prefer_stripped_objects: bool = False) -> OmnibusSharedLibraries.type:
     spec = _build_omnibus_spec(ctx, graph)
+    pic_behavior = get_cxx_toolchain_info(ctx).pic_behavior
 
     # Create dummy omnibus
     dummy_omnibus = create_dummy_omnibus(ctx, extra_ldflags)
@@ -877,7 +889,7 @@ def create_omnibus_libraries(
     root_products = {}
 
     # Link all root nodes against the dummy libomnibus lib.
-    for label, annotated_root, link_deps in _ordered_roots(spec):
+    for label, annotated_root, link_deps in _ordered_roots(spec, pic_behavior):
         product = _create_root(
             ctx,
             spec,
@@ -886,6 +898,7 @@ def create_omnibus_libraries(
             label,
             link_deps,
             dummy_omnibus,
+            pic_behavior,
             extra_ldflags,
             prefer_stripped_objects,
         )
@@ -903,6 +916,7 @@ def create_omnibus_libraries(
             ctx,
             spec,
             root_products,
+            pic_behavior,
             extra_ldflags,
             prefer_stripped_objects,
         )
diff --git a/prelude/cxx/prebuilt_cxx_library_group.bzl b/prelude/cxx/prebuilt_cxx_library_group.bzl
index 0a7971bb..26c72767 100644
--- a/prelude/cxx/prebuilt_cxx_library_group.bzl
+++ b/prelude/cxx/prebuilt_cxx_library_group.bzl
@@ -5,6 +5,7 @@
 # License, Version 2.0 found in the LICENSE-APACHE file in the root directory
 # of this source tree.
 
+load("@prelude//cxx:cxx_toolchain_types.bzl", "PicBehavior")
 load(
     "@prelude//cxx:preprocessor.bzl",
     "CPreprocessor",
@@ -228,16 +229,20 @@ def prebuilt_cxx_library_group_impl(ctx: "context") -> ["provider"]:
             pre_flags = args,
         ))
 
+    # This code is already compiled, so, the argument (probably) has little/no value.
+    pic_behavior = PicBehavior("supported")
+
     # Collect per-link-style default outputs.
     default_outputs = {}
     for link_style in LinkStyle:
-        actual_link_style = get_actual_link_style(link_style, preferred_linkage)
+        actual_link_style = get_actual_link_style(link_style, preferred_linkage, pic_behavior)
         default_outputs[link_style] = outputs[actual_link_style]
     providers.append(DefaultInfo(default_outputs = default_outputs[LinkStyle("static")]))
 
     # Provider for native link.
     providers.append(create_merged_link_info(
         ctx,
+        pic_behavior,
         libraries,
         preferred_linkage = preferred_linkage,
         # Export link info from our (non-exported) deps (e.g. when we're linking
diff --git a/prelude/haskell/haskell.bzl b/prelude/haskell/haskell.bzl
index 0355d2ef..ffcb9039 100644
--- a/prelude/haskell/haskell.bzl
+++ b/prelude/haskell/haskell.bzl
@@ -13,6 +13,7 @@ load(
     "@prelude//cxx:cxx_toolchain_types.bzl",
     "CxxPlatformInfo",
     "CxxToolchainInfo",
+    "PicBehavior",
 )
 load(
     "@prelude//cxx:preprocessor.bzl",
@@ -287,6 +288,9 @@ def haskell_prebuilt_library_impl(ctx: "context") -> ["provider"]:
 
     merged_link_info = create_merged_link_info(
         ctx,
+        # We don't have access to a CxxToolchain here (yet).
+        # Give that it's already built, this doesn't mean much, use a sane default.
+        pic_behavior = PicBehavior("supported"),
         link_infos = link_infos,
         exported_deps = native_infos,
     )
@@ -735,8 +739,10 @@ def haskell_library_impl(ctx: "context") -> ["provider"]:
             default_outputs = libs,
         )]
 
+    pic_behavior = ctx.attrs._cxx_toolchain[CxxToolchainInfo].pic_behavior
     merged_link_info = create_merged_link_info(
         ctx,
+        pic_behavior = pic_behavior,
         link_infos = link_infos,
         preferred_linkage = preferred_linkage,
         exported_deps = nlis,
@@ -758,7 +764,7 @@ def haskell_library_impl(ctx: "context") -> ["provider"]:
     )
 
     link_style = _cxx_toolchain_link_style(ctx)
-    actual_link_style = get_actual_link_style(link_style, preferred_linkage)
+    actual_link_style = get_actual_link_style(link_style, preferred_linkage, pic_behavior)
     default_output = hlib_infos[actual_link_style].libs
 
     inherited_pp_info = cxx_inherited_preprocessor_infos(_attr_deps(ctx))
diff --git a/prelude/linking/link_info.bzl b/prelude/linking/link_info.bzl
index 0168a46a..1f1ab0b3 100644
--- a/prelude/linking/link_info.bzl
+++ b/prelude/linking/link_info.bzl
@@ -389,6 +389,7 @@ def wrap_link_infos(
 def create_merged_link_info(
         # Target context for which to create the link info.
         ctx: "context",
+        pic_behavior: PicBehavior.type,
         # The link infos provided by this rule, as a map from link style (as
         # used by dependents) to `LinkInfo`.
         link_infos: {LinkStyle.type: LinkInfos.type} = {},
@@ -413,7 +414,7 @@ def create_merged_link_info(
     # link info given the target's preferred linkage, to be consumed by the
     # ultimate linking target.
     for link_style in LinkStyle:
-        actual_link_style = get_actual_link_style(link_style, preferred_linkage)
+        actual_link_style = get_actual_link_style(link_style, preferred_linkage, pic_behavior)
 
         children = []
         framework_linkables = []
@@ -612,8 +613,7 @@ def get_link_args(
 def get_actual_link_style(
         requested_link_style: LinkStyle.type,
         preferred_linkage: Linkage.type,
-        # In the next diff, I'll make this a required argument.
-        pic_behavior: PicBehavior.type = PicBehavior("supported")) -> LinkStyle.type:
+        pic_behavior: PicBehavior.type) -> LinkStyle.type:
     """
     Return how we link a library for a requested link style and preferred linkage.
     -----------------------------------------------------------------------------------|
diff --git a/prelude/linking/linkable_graph.bzl b/prelude/linking/linkable_graph.bzl
index 3265a1a1..bc2606c0 100644
--- a/prelude/linking/linkable_graph.bzl
+++ b/prelude/linking/linkable_graph.bzl
@@ -5,6 +5,7 @@
 # License, Version 2.0 found in the LICENSE-APACHE file in the root directory
 # of this source tree.
 
+load("@prelude//cxx:cxx_toolchain_types.bzl", "PicBehavior")
 load("@prelude//python:python.bzl", "PythonLibraryInfo")
 load("@prelude//utils:utils.bzl", "expect")
 load(
@@ -203,7 +204,8 @@ def get_link_info(
 
 def get_deps_for_link(
         node: LinkableNode.type,
-        link_style: LinkStyle.type) -> ["label"]:
+        link_style: LinkStyle.type,
+        pic_behavior: PicBehavior.type) -> ["label"]:
     """
     Return deps to follow when linking against this node with the given link
     style.
@@ -213,7 +215,7 @@ def get_deps_for_link(
     deps = node.exported_deps
 
     # If we're linking statically, include non-exported deps.
-    actual = get_actual_link_style(link_style, node.preferred_linkage)
+    actual = get_actual_link_style(link_style, node.preferred_linkage, pic_behavior)
     if actual != LinkStyle("shared") and node.deps:
         # Important that we don't mutate deps, but create a new list
         deps = deps + node.deps
diff --git a/prelude/ocaml/ocaml.bzl b/prelude/ocaml/ocaml.bzl
index cee7d036..93e3a803 100644
--- a/prelude/ocaml/ocaml.bzl
+++ b/prelude/ocaml/ocaml.bzl
@@ -821,6 +821,7 @@ def ocaml_object_impl(ctx: "context") -> ["provider"]:
         ))
     obj_link_info = create_merged_link_info(
         ctx,
+        pic_behavior = cxx_toolchain.pic_behavior,
         link_infos = link_infos,
         exported_deps = [deps_link_info],
     )
diff --git a/prelude/python/cxx_python_extension.bzl b/prelude/python/cxx_python_extension.bzl
index 88cb1612..ae82ca15 100644
--- a/prelude/python/cxx_python_extension.bzl
+++ b/prelude/python/cxx_python_extension.bzl
@@ -202,6 +202,7 @@ def cxx_python_extension_impl(ctx: "context") -> ["provider"]:
         ),
         merged_link_info = create_merged_link_info(
             ctx = ctx,
+            pic_behavior = get_cxx_toolchain_info(ctx).pic_behavior,
             link_infos = link_infos,
             preferred_linkage = Linkage("static"),
             deps = [d.merged_link_info for d in link_deps],
diff --git a/prelude/rust/rust_library.bzl b/prelude/rust/rust_library.bzl
index 4c5fbebb..f234f1b4 100644
--- a/prelude/rust/rust_library.bzl
+++ b/prelude/rust/rust_library.bzl
@@ -10,6 +10,7 @@ load(
     "@prelude//android:android_providers.bzl",
     "merge_android_packageable_info",
 )
+load("@prelude//cxx:cxx_toolchain_types.bzl", "PicBehavior")
 load(
     "@prelude//cxx:linker.bzl",
     "PDB_SUB_TARGET",
@@ -34,6 +35,7 @@ load(
     "Linkage",
     "LinkedObject",
     "MergedLinkInfo",
+    "STATIC_LINK_STYLES",
     "SharedLibLinkable",
     "create_merged_link_info",
     "get_actual_link_style",
@@ -136,6 +138,7 @@ def prebuilt_rust_library_impl(ctx: "context") -> ["provider"]:
     providers.append(
         create_merged_link_info(
             ctx,
+            PicBehavior("supported"),
             {link_style: LinkInfos(default = link) for link_style in LinkStyle},
             exported_deps = [d[MergedLinkInfo] for d in ctx.attrs.deps],
             # TODO(agallagher): This matches v1 behavior, but some of these libs
@@ -548,7 +551,7 @@ def _native_providers(
 
     link_infos = {}
     for link_style, arg in libraries.items():
-        if link_style in [LinkStyle("static"), LinkStyle("static_pic")]:
+        if link_style in STATIC_LINK_STYLES:
             link_infos[link_style] = LinkInfos(default = LinkInfo(linkables = [ArchiveLinkable(archive = Archive(artifact = arg), linker_type = linker_type)]))
         else:
             link_infos[link_style] = LinkInfos(default = LinkInfo(linkables = [SharedLibLinkable(lib = arg)]))
@@ -558,6 +561,7 @@ def _native_providers(
     # Native link provider.
     providers.append(create_merged_link_info(
         ctx,
+        compile_ctx.cxx_toolchain_info.pic_behavior,
         link_infos,
         exported_deps = [inherited_non_rust_link],
         preferred_linkage = preferred_linkage,
@@ -570,7 +574,7 @@ def _native_providers(
     shlib_name = get_default_shared_library_name(linker_info, ctx.label)
 
     # Only add a shared library if we generated one.
-    if get_actual_link_style(LinkStyle("shared"), preferred_linkage) == LinkStyle("shared"):
+    if get_actual_link_style(LinkStyle("shared"), preferred_linkage, compile_ctx.cxx_toolchain_info.pic_behavior) == LinkStyle("shared"):
         solibs[shlib_name] = LinkedObject(output = libraries[LinkStyle("shared")])
 
     # Native shared library provider.