1 //! Resolution of mixing rlibs and dylibs
3 //! When producing a final artifact, such as a dynamic library, the compiler has
4 //! a choice between linking an rlib or linking a dylib of all upstream
5 //! dependencies. The linking phase must guarantee, however, that a library only
6 //! show up once in the object file. For example, it is illegal for library A to
7 //! be statically linked to B and C in separate dylibs, and then link B and C
8 //! into a crate D (because library A appears twice).
10 //! The job of this module is to calculate what format each upstream crate
11 //! should be used when linking each output type requested in this session. This
12 //! generally follows this set of rules:
14 //! 1. Each library must appear exactly once in the output.
15 //! 2. Each rlib contains only one library (it's just an object file)
16 //! 3. Each dylib can contain more than one library (due to static linking),
17 //! and can also bring in many dynamic dependencies.
19 //! With these constraints in mind, it's generally a very difficult problem to
20 //! find a solution that's not "all rlibs" or "all dylibs". I have suspicions
21 //! that NP-ness may come into the picture here...
23 //! The current selection algorithm below looks mostly similar to:
25 //! 1. If static linking is required, then require all upstream dependencies
26 //! to be available as rlibs. If not, generate an error.
27 //! 2. If static linking is requested (generating an executable), then
28 //! attempt to use all upstream dependencies as rlibs. If any are not
29 //! found, bail out and continue to step 3.
30 //! 3. Static linking has failed, at least one library must be dynamically
31 //! linked. Apply a heuristic by greedily maximizing the number of
32 //! dynamically linked libraries.
33 //! 4. Each upstream dependency available as a dynamic library is
34 //! registered. The dependencies all propagate, adding to a map. It is
35 //! possible for a dylib to add a static library as a dependency, but it
36 //! is illegal for two dylibs to add the same static library as a
37 //! dependency. The same dylib can be added twice. Additionally, it is
38 //! illegal to add a static dependency when it was previously found as a
39 //! dylib (and vice versa)
40 //! 5. After all dynamic dependencies have been traversed, re-traverse the
41 //! remaining dependencies and add them statically (if they haven't been
44 //! While not perfect, this algorithm should help support use-cases such as leaf
45 //! dependencies being static while the larger tree of inner dependencies are
46 //! all dynamic. This isn't currently very well battle tested, so it will likely
47 //! fall short in some use cases.
49 //! Currently, there is no way to specify the preference of linkage with a
50 //! particular library (other than a global dynamic/static switch).
51 //! Additionally, the algorithm is geared towards finding *any* solution rather
52 //! than finding a number of solutions (there are normally quite a few).
54 use crate::creader::CStore;
56 BadPanicStrategy, CrateDepMultiple, IncompatiblePanicInDropStrategy, LibRequired,
57 RequiredPanicStrategy, RlibRequired, RustcLibRequired, TwoPanicRuntimes,
60 use rustc_data_structures::fx::FxHashMap;
61 use rustc_hir::def_id::CrateNum;
62 use rustc_middle::middle::dependency_format::{Dependencies, DependencyList, Linkage};
63 use rustc_middle::ty::TyCtxt;
64 use rustc_session::config::CrateType;
65 use rustc_session::cstore::CrateDepKind;
66 use rustc_session::cstore::LinkagePreference::{self, RequireDynamic, RequireStatic};
68 pub(crate) fn calculate(tcx: TyCtxt<'_>) -> Dependencies {
73 let linkage = calculate_type(tcx, ty);
74 verify_ok(tcx, &linkage);
80 fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
83 if !sess.opts.output_types.should_codegen() {
87 let preferred_linkage = match ty {
88 // Generating a dylib without `-C prefer-dynamic` means that we're going
89 // to try to eagerly statically link all dependencies. This is normally
90 // done for end-product dylibs, not intermediate products.
92 // Treat cdylibs similarly. If `-C prefer-dynamic` is set, the caller may
93 // be code-size conscious, but without it, it makes sense to statically
95 CrateType::Dylib | CrateType::Cdylib if !sess.opts.cg.prefer_dynamic => Linkage::Static,
96 CrateType::Dylib | CrateType::Cdylib => Linkage::Dynamic,
98 // If the global prefer_dynamic switch is turned off, or the final
99 // executable will be statically linked, prefer static crate linkage.
100 CrateType::Executable if !sess.opts.cg.prefer_dynamic || sess.crt_static(Some(ty)) => {
103 CrateType::Executable => Linkage::Dynamic,
105 // proc-macro crates are mostly cdylibs, but we also need metadata.
106 CrateType::ProcMacro => Linkage::Static,
108 // No linkage happens with rlibs, we just needed the metadata (which we
109 // got long ago), so don't bother with anything.
110 CrateType::Rlib => Linkage::NotLinked,
112 // staticlibs must have all static dependencies.
113 CrateType::Staticlib => Linkage::Static,
116 match preferred_linkage {
117 // If the crate is not linked, there are no link-time dependencies.
118 Linkage::NotLinked => return Vec::new(),
120 // Attempt static linkage first. For dylibs and executables, we may be
121 // able to retry below with dynamic linkage.
122 if let Some(v) = attempt_static(tcx) {
126 // Staticlibs and static executables must have all static dependencies.
127 // If any are not found, generate some nice pretty errors.
128 if ty == CrateType::Staticlib
129 || (ty == CrateType::Executable
130 && sess.crt_static(Some(ty))
131 && !sess.target.crt_static_allows_dylibs)
133 for &cnum in tcx.crates(()).iter() {
134 if tcx.dep_kind(cnum).macros_only() {
137 let src = tcx.used_crate_source(cnum);
138 if src.rlib.is_some() {
141 sess.emit_err(RlibRequired { crate_name: tcx.crate_name(cnum) });
146 Linkage::Dynamic | Linkage::IncludedFromDylib => {}
149 let mut formats = FxHashMap::default();
151 // Sweep all crates for found dylibs. Add all dylibs, as well as their
152 // dependencies, ensuring there are no conflicts. The only valid case for a
153 // dependency to be relied upon twice is for both cases to rely on a dylib.
154 for &cnum in tcx.crates(()).iter() {
155 if tcx.dep_kind(cnum).macros_only() {
158 let name = tcx.crate_name(cnum);
159 let src = tcx.used_crate_source(cnum);
160 if src.dylib.is_some() {
161 info!("adding dylib: {}", name);
162 add_library(tcx, cnum, RequireDynamic, &mut formats);
163 let deps = tcx.dylib_dependency_formats(cnum);
164 for &(depnum, style) in deps.iter() {
165 info!("adding {:?}: {}", style, tcx.crate_name(depnum));
166 add_library(tcx, depnum, style, &mut formats);
171 // Collect what we've got so far in the return vector.
172 let last_crate = tcx.crates(()).len();
173 let mut ret = (1..last_crate + 1)
174 .map(|cnum| match formats.get(&CrateNum::new(cnum)) {
175 Some(&RequireDynamic) => Linkage::Dynamic,
176 Some(&RequireStatic) => Linkage::IncludedFromDylib,
177 None => Linkage::NotLinked,
179 .collect::<Vec<_>>();
181 // Run through the dependency list again, and add any missing libraries as
184 // If the crate hasn't been included yet and it's not actually required
185 // (e.g., it's an allocator) then we skip it here as well.
186 for &cnum in tcx.crates(()).iter() {
187 let src = tcx.used_crate_source(cnum);
188 if src.dylib.is_none()
189 && !formats.contains_key(&cnum)
190 && tcx.dep_kind(cnum) == CrateDepKind::Explicit
192 assert!(src.rlib.is_some() || src.rmeta.is_some());
193 info!("adding staticlib: {}", tcx.crate_name(cnum));
194 add_library(tcx, cnum, RequireStatic, &mut formats);
195 ret[cnum.as_usize() - 1] = Linkage::Static;
199 // We've gotten this far because we're emitting some form of a final
200 // artifact which means that we may need to inject dependencies of some
203 // Things like allocators and panic runtimes may not have been activated
204 // quite yet, so do so here.
205 activate_injected_dep(CStore::from_tcx(tcx).injected_panic_runtime(), &mut ret, &|cnum| {
206 tcx.is_panic_runtime(cnum)
209 // When dylib B links to dylib A, then when using B we must also link to A.
210 // It could be the case, however, that the rlib for A is present (hence we
211 // found metadata), but the dylib for A has since been removed.
213 // For situations like this, we perform one last pass over the dependencies,
214 // making sure that everything is available in the requested format.
215 for (cnum, kind) in ret.iter().enumerate() {
216 let cnum = CrateNum::new(cnum + 1);
217 let src = tcx.used_crate_source(cnum);
219 Linkage::NotLinked | Linkage::IncludedFromDylib => {}
220 Linkage::Static if src.rlib.is_some() => continue,
221 Linkage::Dynamic if src.dylib.is_some() => continue,
223 let kind = match kind {
224 Linkage::Static => "rlib",
227 let crate_name = tcx.crate_name(cnum);
228 if crate_name.as_str().starts_with("rustc_") {
229 sess.emit_err(RustcLibRequired { crate_name, kind });
231 sess.emit_err(LibRequired { crate_name, kind });
243 link: LinkagePreference,
244 m: &mut FxHashMap<CrateNum, LinkagePreference>,
248 // If the linkages differ, then we'd have two copies of the library
249 // if we continued linking. If the linkages are both static, then we
250 // would also have two copies of the library (static from two
251 // different locations).
253 // This error is probably a little obscure, but I imagine that it
254 // can be refined over time.
255 if link2 != link || link == RequireStatic {
256 tcx.sess.emit_err(CrateDepMultiple { crate_name: tcx.crate_name(cnum) });
260 m.insert(cnum, link);
265 fn attempt_static(tcx: TyCtxt<'_>) -> Option<DependencyList> {
266 let all_crates_available_as_rlib = tcx
271 if tcx.dep_kind(cnum).macros_only() {
274 Some(tcx.used_crate_source(cnum).rlib.is_some())
276 .all(|is_rlib| is_rlib);
277 if !all_crates_available_as_rlib {
281 // All crates are available in an rlib format, so we're just going to link
282 // everything in explicitly so long as it's actually required.
286 .map(|&cnum| match tcx.dep_kind(cnum) {
287 CrateDepKind::Explicit => Linkage::Static,
288 CrateDepKind::MacrosOnly | CrateDepKind::Implicit => Linkage::NotLinked,
290 .collect::<Vec<_>>();
292 // Our allocator/panic runtime may not have been linked above if it wasn't
293 // explicitly linked, which is the case for any injected dependency. Handle
294 // that here and activate them.
295 activate_injected_dep(CStore::from_tcx(tcx).injected_panic_runtime(), &mut ret, &|cnum| {
296 tcx.is_panic_runtime(cnum)
302 // Given a list of how to link upstream dependencies so far, ensure that an
303 // injected dependency is activated. This will not do anything if one was
304 // transitively included already (e.g., via a dylib or explicitly so).
306 // If an injected dependency was not found then we're guaranteed the
307 // metadata::creader module has injected that dependency (not listed as
308 // a required dependency) in one of the session's field. If this field is not
309 // set then this compilation doesn't actually need the dependency and we can
310 // also skip this step entirely.
311 fn activate_injected_dep(
312 injected: Option<CrateNum>,
313 list: &mut DependencyList,
314 replaces_injected: &dyn Fn(CrateNum) -> bool,
316 for (i, slot) in list.iter().enumerate() {
317 let cnum = CrateNum::new(i + 1);
318 if !replaces_injected(cnum) {
321 if *slot != Linkage::NotLinked {
325 if let Some(injected) = injected {
326 let idx = injected.as_usize() - 1;
327 assert_eq!(list[idx], Linkage::NotLinked);
328 list[idx] = Linkage::Static;
332 // After the linkage for a crate has been determined we need to verify that
333 // there's only going to be one allocator in the output.
334 fn verify_ok(tcx: TyCtxt<'_>, list: &[Linkage]) {
335 let sess = &tcx.sess;
339 let mut panic_runtime = None;
340 for (i, linkage) in list.iter().enumerate() {
341 if let Linkage::NotLinked = *linkage {
344 let cnum = CrateNum::new(i + 1);
346 if tcx.is_panic_runtime(cnum) {
347 if let Some((prev, _)) = panic_runtime {
348 let prev_name = tcx.crate_name(prev);
349 let cur_name = tcx.crate_name(cnum);
350 sess.emit_err(TwoPanicRuntimes { prev_name, cur_name });
352 panic_runtime = Some((
354 tcx.required_panic_strategy(cnum).unwrap_or_else(|| {
355 bug!("cannot determine panic strategy of a panic runtime");
361 // If we found a panic runtime, then we know by this point that it's the
362 // only one, but we perform validation here that all the panic strategy
363 // compilation modes for the whole DAG are valid.
364 if let Some((runtime_cnum, found_strategy)) = panic_runtime {
365 let desired_strategy = sess.panic_strategy();
367 // First up, validate that our selected panic runtime is indeed exactly
368 // our same strategy.
369 if found_strategy != desired_strategy {
370 sess.emit_err(BadPanicStrategy {
371 runtime: tcx.crate_name(runtime_cnum),
372 strategy: desired_strategy,
376 // Next up, verify that all other crates are compatible with this panic
377 // strategy. If the dep isn't linked, we ignore it, and if our strategy
378 // is abort then it's compatible with everything. Otherwise all crates'
379 // panic strategy must match our own.
380 for (i, linkage) in list.iter().enumerate() {
381 if let Linkage::NotLinked = *linkage {
384 let cnum = CrateNum::new(i + 1);
385 if cnum == runtime_cnum || tcx.is_compiler_builtins(cnum) {
389 if let Some(found_strategy) = tcx.required_panic_strategy(cnum) && desired_strategy != found_strategy {
390 sess.emit_err(RequiredPanicStrategy {
391 crate_name: tcx.crate_name(cnum),
396 let found_drop_strategy = tcx.panic_in_drop_strategy(cnum);
397 if tcx.sess.opts.unstable_opts.panic_in_drop != found_drop_strategy {
398 sess.emit_err(IncompatiblePanicInDropStrategy {
399 crate_name: tcx.crate_name(cnum),
400 found_strategy: found_drop_strategy,
401 desired_strategy: tcx.sess.opts.unstable_opts.panic_in_drop,