]>
Commit | Line | Data |
---|---|---|
1a4d82fc | 1 | //! Validates all used crates and extern libraries and loads their metadata |
223e47cc | 2 | |
3dfed10e | 3 | use crate::locator::{CrateError, CrateLocator, CratePaths}; |
dfeec247 | 4 | use crate::rmeta::{CrateDep, CrateMetadata, CrateNumMap, CrateRoot, MetadataBlob}; |
92a42be0 | 5 | |
3dfed10e XL |
6 | use rustc_ast::expand::allocator::AllocatorKind; |
7 | use rustc_ast::{self as ast, *}; | |
6a06907d | 8 | use rustc_data_structures::fx::{FxHashMap, FxHashSet}; |
b7449926 | 9 | use rustc_data_structures::svh::Svh; |
60c5eb7d | 10 | use rustc_data_structures::sync::Lrc; |
dfeec247 | 11 | use rustc_expand::base::SyntaxExtension; |
6a06907d | 12 | use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, LOCAL_CRATE}; |
ba9703b0 | 13 | use rustc_hir::definitions::Definitions; |
60c5eb7d | 14 | use rustc_index::vec::IndexVec; |
ba9703b0 | 15 | use rustc_middle::ty::TyCtxt; |
f035d41b | 16 | use rustc_session::config::{self, CrateType, ExternLocation}; |
c295e0f8 XL |
17 | use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate}; |
18 | use rustc_session::cstore::{ExternCrateSource, MetadataLoaderDyn}; | |
04454e1e | 19 | use rustc_session::lint; |
ba9703b0 XL |
20 | use rustc_session::output::validate_crate_name; |
21 | use rustc_session::search_paths::PathKind; | |
136023e0 | 22 | use rustc_session::Session; |
dfeec247 XL |
23 | use rustc_span::edition::Edition; |
24 | use rustc_span::symbol::{sym, Symbol}; | |
25 | use rustc_span::{Span, DUMMY_SP}; | |
83c7162d | 26 | use rustc_target::spec::{PanicStrategy, TargetTriple}; |
dfeec247 | 27 | |
e1599b0c | 28 | use proc_macro::bridge::client::ProcMacro; |
3c0e092e | 29 | use std::ops::Fn; |
dfeec247 | 30 | use std::path::Path; |
5869c6ff | 31 | use std::{cmp, env}; |
3dfed10e | 32 | use tracing::{debug, info}; |
60c5eb7d XL |
33 | |
34 | #[derive(Clone)] | |
35 | pub struct CStore { | |
36 | metas: IndexVec<CrateNum, Option<Lrc<CrateMetadata>>>, | |
37 | injected_panic_runtime: Option<CrateNum>, | |
38 | /// This crate needs an allocator and either provides it itself, or finds it in a dependency. | |
39 | /// If the above is true, then this field denotes the kind of the found allocator. | |
40 | allocator_kind: Option<AllocatorKind>, | |
41 | /// This crate has a `#[global_allocator]` item. | |
42 | has_global_allocator: bool, | |
6a06907d XL |
43 | |
44 | /// This map is used to verify we get no hash conflicts between | |
45 | /// `StableCrateId` values. | |
c295e0f8 | 46 | pub(crate) stable_crate_ids: FxHashMap<StableCrateId, CrateNum>, |
cdc7bbd5 XL |
47 | |
48 | /// Unused externs of the crate | |
49 | unused_externs: Vec<Symbol>, | |
e9174d1e SL |
50 | } |
51 | ||
136023e0 XL |
52 | impl std::fmt::Debug for CStore { |
53 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { | |
54 | f.debug_struct("CStore").finish_non_exhaustive() | |
55 | } | |
56 | } | |
57 | ||
c30ab7b3 | 58 | pub struct CrateLoader<'a> { |
e74abb32 XL |
59 | // Immutable configuration. |
60 | sess: &'a Session, | |
17df50a5 | 61 | metadata_loader: Box<MetadataLoaderDyn>, |
476ff2be | 62 | local_crate_name: Symbol, |
e74abb32 XL |
63 | // Mutable output. |
64 | cstore: CStore, | |
f9f354fc | 65 | used_extern_options: FxHashSet<Symbol>, |
223e47cc LB |
66 | } |
67 | ||
60c5eb7d XL |
68 | pub enum LoadedMacro { |
69 | MacroDef(ast::Item, Edition), | |
70 | ProcMacro(SyntaxExtension), | |
71 | } | |
72 | ||
923072b8 | 73 | pub(crate) struct Library { |
60c5eb7d XL |
74 | pub source: CrateSource, |
75 | pub metadata: MetadataBlob, | |
1a4d82fc | 76 | } |
e9174d1e | 77 | |
a7813a04 | 78 | enum LoadResult { |
9e0c209e | 79 | Previous(CrateNum), |
c30ab7b3 | 80 | Loaded(Library), |
a7813a04 XL |
81 | } |
82 | ||
74b04a01 XL |
83 | /// A reference to `CrateMetadata` that can also give access to whole crate store when necessary. |
84 | #[derive(Clone, Copy)] | |
923072b8 | 85 | pub(crate) struct CrateMetadataRef<'a> { |
74b04a01 XL |
86 | pub cdata: &'a CrateMetadata, |
87 | pub cstore: &'a CStore, | |
88 | } | |
89 | ||
90 | impl std::ops::Deref for CrateMetadataRef<'_> { | |
91 | type Target = CrateMetadata; | |
92 | ||
93 | fn deref(&self) -> &Self::Target { | |
94 | self.cdata | |
95 | } | |
96 | } | |
97 | ||
3dfed10e XL |
98 | struct CrateDump<'a>(&'a CStore); |
99 | ||
100 | impl<'a> std::fmt::Debug for CrateDump<'a> { | |
101 | fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { | |
102 | writeln!(fmt, "resolved crates:")?; | |
a2a8927a XL |
103 | for (cnum, data) in self.0.iter_crate_data() { |
104 | writeln!(fmt, " name: {}", data.name())?; | |
105 | writeln!(fmt, " cnum: {}", cnum)?; | |
106 | writeln!(fmt, " hash: {}", data.hash())?; | |
107 | writeln!(fmt, " reqd: {:?}", data.dep_kind())?; | |
108 | let CrateSource { dylib, rlib, rmeta } = data.source(); | |
109 | if let Some(dylib) = dylib { | |
110 | writeln!(fmt, " dylib: {}", dylib.0.display())?; | |
111 | } | |
112 | if let Some(rlib) = rlib { | |
113 | writeln!(fmt, " rlib: {}", rlib.0.display())?; | |
114 | } | |
115 | if let Some(rmeta) = rmeta { | |
116 | writeln!(fmt, " rmeta: {}", rmeta.0.display())?; | |
117 | } | |
118 | } | |
119 | Ok(()) | |
3dfed10e | 120 | } |
60c5eb7d XL |
121 | } |
122 | ||
123 | impl CStore { | |
136023e0 XL |
124 | pub fn from_tcx(tcx: TyCtxt<'_>) -> &CStore { |
125 | tcx.cstore_untracked() | |
126 | .as_any() | |
127 | .downcast_ref::<CStore>() | |
128 | .expect("`tcx.cstore` is not a `CStore`") | |
60c5eb7d XL |
129 | } |
130 | ||
131 | fn alloc_new_crate_num(&mut self) -> CrateNum { | |
132 | self.metas.push(None); | |
133 | CrateNum::new(self.metas.len() - 1) | |
134 | } | |
135 | ||
923072b8 FG |
136 | pub fn has_crate_data(&self, cnum: CrateNum) -> bool { |
137 | self.metas[cnum].is_some() | |
138 | } | |
139 | ||
140 | pub(crate) fn get_crate_data(&self, cnum: CrateNum) -> CrateMetadataRef<'_> { | |
74b04a01 | 141 | let cdata = self.metas[cnum] |
dfeec247 | 142 | .as_ref() |
74b04a01 XL |
143 | .unwrap_or_else(|| panic!("Failed to get crate data for {:?}", cnum)); |
144 | CrateMetadataRef { cdata, cstore: self } | |
60c5eb7d XL |
145 | } |
146 | ||
147 | fn set_crate_data(&mut self, cnum: CrateNum, data: CrateMetadata) { | |
148 | assert!(self.metas[cnum].is_none(), "Overwriting crate metadata entry"); | |
149 | self.metas[cnum] = Some(Lrc::new(data)); | |
150 | } | |
151 | ||
923072b8 | 152 | pub(crate) fn iter_crate_data(&self) -> impl Iterator<Item = (CrateNum, &CrateMetadata)> { |
a2a8927a XL |
153 | self.metas |
154 | .iter_enumerated() | |
155 | .filter_map(|(cnum, data)| data.as_ref().map(|data| (cnum, &**data))) | |
60c5eb7d XL |
156 | } |
157 | ||
158 | fn push_dependencies_in_postorder(&self, deps: &mut Vec<CrateNum>, cnum: CrateNum) { | |
159 | if !deps.contains(&cnum) { | |
160 | let data = self.get_crate_data(cnum); | |
161 | for &dep in data.dependencies().iter() { | |
162 | if dep != cnum { | |
163 | self.push_dependencies_in_postorder(deps, dep); | |
164 | } | |
165 | } | |
166 | ||
167 | deps.push(cnum); | |
168 | } | |
169 | } | |
170 | ||
923072b8 | 171 | pub(crate) fn crate_dependencies_in_postorder(&self, cnum: CrateNum) -> Vec<CrateNum> { |
60c5eb7d XL |
172 | let mut deps = Vec::new(); |
173 | if cnum == LOCAL_CRATE { | |
a2a8927a XL |
174 | for (cnum, _) in self.iter_crate_data() { |
175 | self.push_dependencies_in_postorder(&mut deps, cnum); | |
176 | } | |
60c5eb7d XL |
177 | } else { |
178 | self.push_dependencies_in_postorder(&mut deps, cnum); | |
179 | } | |
180 | deps | |
181 | } | |
182 | ||
183 | fn crate_dependencies_in_reverse_postorder(&self, cnum: CrateNum) -> Vec<CrateNum> { | |
184 | let mut deps = self.crate_dependencies_in_postorder(cnum); | |
185 | deps.reverse(); | |
186 | deps | |
187 | } | |
188 | ||
923072b8 | 189 | pub(crate) fn injected_panic_runtime(&self) -> Option<CrateNum> { |
60c5eb7d XL |
190 | self.injected_panic_runtime |
191 | } | |
192 | ||
923072b8 | 193 | pub(crate) fn allocator_kind(&self) -> Option<AllocatorKind> { |
60c5eb7d XL |
194 | self.allocator_kind |
195 | } | |
196 | ||
923072b8 | 197 | pub(crate) fn has_global_allocator(&self) -> bool { |
60c5eb7d XL |
198 | self.has_global_allocator |
199 | } | |
cdc7bbd5 XL |
200 | |
201 | pub fn report_unused_deps(&self, tcx: TyCtxt<'_>) { | |
04454e1e FG |
202 | let json_unused_externs = tcx.sess.opts.json_unused_externs; |
203 | ||
cdc7bbd5 XL |
204 | // We put the check for the option before the lint_level_at_node call |
205 | // because the call mutates internal state and introducing it | |
206 | // leads to some ui tests failing. | |
04454e1e | 207 | if !json_unused_externs.is_enabled() { |
cdc7bbd5 XL |
208 | return; |
209 | } | |
210 | let level = tcx | |
211 | .lint_level_at_node(lint::builtin::UNUSED_CRATE_DEPENDENCIES, rustc_hir::CRATE_HIR_ID) | |
212 | .0; | |
213 | if level != lint::Level::Allow { | |
214 | let unused_externs = | |
215 | self.unused_externs.iter().map(|ident| ident.to_ident_string()).collect::<Vec<_>>(); | |
216 | let unused_externs = unused_externs.iter().map(String::as_str).collect::<Vec<&str>>(); | |
04454e1e FG |
217 | tcx.sess.parse_sess.span_diagnostic.emit_unused_externs( |
218 | level, | |
219 | json_unused_externs.is_loud(), | |
220 | &unused_externs, | |
221 | ); | |
cdc7bbd5 XL |
222 | } |
223 | } | |
60c5eb7d XL |
224 | } |
225 | ||
c30ab7b3 | 226 | impl<'a> CrateLoader<'a> { |
e74abb32 XL |
227 | pub fn new( |
228 | sess: &'a Session, | |
17df50a5 | 229 | metadata_loader: Box<MetadataLoaderDyn>, |
e74abb32 XL |
230 | local_crate_name: &str, |
231 | ) -> Self { | |
6a06907d | 232 | let mut stable_crate_ids = FxHashMap::default(); |
136023e0 | 233 | stable_crate_ids.insert(sess.local_stable_crate_id(), LOCAL_CRATE); |
6a06907d | 234 | |
c30ab7b3 | 235 | CrateLoader { |
3b2f2976 | 236 | sess, |
e74abb32 | 237 | metadata_loader, |
476ff2be | 238 | local_crate_name: Symbol::intern(local_crate_name), |
60c5eb7d XL |
239 | cstore: CStore { |
240 | // We add an empty entry for LOCAL_CRATE (which maps to zero) in | |
241 | // order to make array indices in `metas` match with the | |
242 | // corresponding `CrateNum`. This first entry will always remain | |
243 | // `None`. | |
244 | metas: IndexVec::from_elem_n(None, 1), | |
245 | injected_panic_runtime: None, | |
246 | allocator_kind: None, | |
247 | has_global_allocator: false, | |
6a06907d | 248 | stable_crate_ids, |
cdc7bbd5 | 249 | unused_externs: Vec::new(), |
dfeec247 | 250 | }, |
f9f354fc | 251 | used_extern_options: Default::default(), |
223e47cc | 252 | } |
223e47cc | 253 | } |
223e47cc | 254 | |
e74abb32 XL |
255 | pub fn cstore(&self) -> &CStore { |
256 | &self.cstore | |
257 | } | |
258 | ||
259 | pub fn into_cstore(self) -> CStore { | |
260 | self.cstore | |
261 | } | |
262 | ||
60c5eb7d | 263 | fn existing_match(&self, name: Symbol, hash: Option<Svh>, kind: PathKind) -> Option<CrateNum> { |
a2a8927a | 264 | for (cnum, data) in self.cstore.iter_crate_data() { |
dfeec247 | 265 | if data.name() != name { |
1b1a35ee | 266 | tracing::trace!("{} did not match {}", data.name(), name); |
a2a8927a | 267 | continue; |
dfeec247 | 268 | } |
223e47cc | 269 | |
1a4d82fc | 270 | match hash { |
a2a8927a | 271 | Some(hash) if hash == data.hash() => return Some(cnum), |
1b1a35ee XL |
272 | Some(hash) => { |
273 | debug!("actual hash {} did not match expected {}", hash, data.hash()); | |
a2a8927a | 274 | continue; |
1b1a35ee | 275 | } |
1a4d82fc JJ |
276 | None => {} |
277 | } | |
223e47cc | 278 | |
85aaf69f SL |
279 | // When the hash is None we're dealing with a top-level dependency |
280 | // in which case we may have a specification on the command line for | |
281 | // this library. Even though an upstream library may have loaded | |
282 | // something of the same name, we have to make sure it was loaded | |
283 | // from the exact same location as well. | |
1a4d82fc JJ |
284 | // |
285 | // We're also sure to compare *paths*, not actual byte slices. The | |
286 | // `source` stores paths which are normalized which may be different | |
287 | // from the strings on the command line. | |
74b04a01 | 288 | let source = self.cstore.get_crate_data(cnum).cdata.source(); |
a2a8927a | 289 | if let Some(entry) = self.sess.opts.externs.get(name.as_str()) { |
b7449926 | 290 | // Only use `--extern crate_name=path` here, not `--extern crate_name`. |
60c5eb7d XL |
291 | if let Some(mut files) = entry.files() { |
292 | if files.any(|l| { | |
5869c6ff XL |
293 | let l = l.canonicalized(); |
294 | source.dylib.as_ref().map(|(p, _)| p) == Some(l) | |
295 | || source.rlib.as_ref().map(|(p, _)| p) == Some(l) | |
296 | || source.rmeta.as_ref().map(|(p, _)| p) == Some(l) | |
60c5eb7d | 297 | }) { |
a2a8927a | 298 | return Some(cnum); |
60c5eb7d | 299 | } |
1a4d82fc | 300 | } |
a2a8927a | 301 | continue; |
85aaf69f SL |
302 | } |
303 | ||
304 | // Alright, so we've gotten this far which means that `data` has the | |
305 | // right name, we don't have a hash, and we don't have a --extern | |
306 | // pointing for ourselves. We're still not quite yet done because we | |
307 | // have to make sure that this crate was found in the crate lookup | |
308 | // path (this is a top-level dependency) as we don't want to | |
309 | // implicitly load anything inside the dependency lookup path. | |
dfeec247 XL |
310 | let prev_kind = source |
311 | .dylib | |
312 | .as_ref() | |
313 | .or(source.rlib.as_ref()) | |
314 | .or(source.rmeta.as_ref()) | |
315 | .expect("No sources for crate") | |
316 | .1; | |
60c5eb7d | 317 | if kind.matches(prev_kind) { |
a2a8927a | 318 | return Some(cnum); |
1b1a35ee XL |
319 | } else { |
320 | debug!( | |
321 | "failed to load existing crate {}; kind {:?} did not match prev_kind {:?}", | |
322 | name, kind, prev_kind | |
323 | ); | |
1a4d82fc | 324 | } |
a2a8927a XL |
325 | } |
326 | ||
327 | None | |
1a4d82fc | 328 | } |
223e47cc | 329 | |
923072b8 | 330 | fn verify_no_symbol_conflicts(&self, root: &CrateRoot) -> Result<(), CrateError> { |
54a0048b | 331 | // Check for (potential) conflicts with the local crate |
136023e0 | 332 | if self.sess.local_stable_crate_id() == root.stable_crate_id() { |
3dfed10e | 333 | return Err(CrateError::SymbolConflictsCurrent(root.name())); |
54a0048b SL |
334 | } |
335 | ||
54a0048b | 336 | // Check for conflicts with any crate loaded so far |
a2a8927a XL |
337 | for (_, other) in self.cstore.iter_crate_data() { |
338 | // Same stable crate id but different SVH | |
339 | if other.stable_crate_id() == root.stable_crate_id() && other.hash() != root.hash() { | |
340 | return Err(CrateError::SymbolConflictsOthers(root.name())); | |
54a0048b | 341 | } |
a2a8927a | 342 | } |
3dfed10e | 343 | |
a2a8927a | 344 | Ok(()) |
54a0048b SL |
345 | } |
346 | ||
6a06907d XL |
347 | fn verify_no_stable_crate_id_hash_conflicts( |
348 | &mut self, | |
923072b8 | 349 | root: &CrateRoot, |
6a06907d XL |
350 | cnum: CrateNum, |
351 | ) -> Result<(), CrateError> { | |
352 | if let Some(existing) = self.cstore.stable_crate_ids.insert(root.stable_crate_id(), cnum) { | |
353 | let crate_name0 = root.name(); | |
354 | let crate_name1 = self.cstore.get_crate_data(existing).name(); | |
355 | return Err(CrateError::StableCrateIdCollision(crate_name0, crate_name1)); | |
356 | } | |
357 | ||
358 | Ok(()) | |
359 | } | |
360 | ||
532ac7d7 XL |
361 | fn register_crate( |
362 | &mut self, | |
363 | host_lib: Option<Library>, | |
e74abb32 | 364 | root: Option<&CratePaths>, |
532ac7d7 | 365 | lib: Library, |
3dfed10e | 366 | dep_kind: CrateDepKind, |
dfeec247 | 367 | name: Symbol, |
3dfed10e | 368 | ) -> Result<CrateNum, CrateError> { |
e74abb32 XL |
369 | let _prof_timer = self.sess.prof.generic_activity("metadata_register_crate"); |
370 | ||
371 | let Library { source, metadata } = lib; | |
372 | let crate_root = metadata.get_root(); | |
60c5eb7d | 373 | let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash()); |
b039eaaf | 374 | |
dfeec247 | 375 | let private_dep = |
a2a8927a | 376 | self.sess.opts.externs.get(name.as_str()).map_or(false, |e| e.is_private_dep); |
48663c56 | 377 | |
223e47cc | 378 | // Claim this crate number and cache it |
94b46f34 | 379 | let cnum = self.cstore.alloc_new_crate_num(); |
1a4d82fc | 380 | |
3dfed10e XL |
381 | info!( |
382 | "register crate `{}` (cnum = {}. private_dep = {})", | |
383 | crate_root.name(), | |
384 | cnum, | |
385 | private_dep | |
386 | ); | |
387 | ||
e74abb32 | 388 | // Maintain a reference to the top most crate. |
1a4d82fc | 389 | // Stash paths for top-most crate locally if necessary. |
e74abb32 XL |
390 | let crate_paths; |
391 | let root = if let Some(root) = root { | |
392 | root | |
1a4d82fc | 393 | } else { |
60c5eb7d | 394 | crate_paths = CratePaths::new(crate_root.name(), source.clone()); |
e74abb32 | 395 | &crate_paths |
1a4d82fc | 396 | }; |
1a4d82fc | 397 | |
3dfed10e | 398 | let cnum_map = self.resolve_crate_deps(root, &crate_root, &metadata, cnum, dep_kind)?; |
1a4d82fc | 399 | |
60c5eb7d | 400 | let raw_proc_macros = if crate_root.is_proc_macro_crate() { |
e74abb32 XL |
401 | let temp_root; |
402 | let (dlsym_source, dlsym_root) = match &host_lib { | |
dfeec247 XL |
403 | Some(host_lib) => (&host_lib.source, { |
404 | temp_root = host_lib.metadata.get_root(); | |
405 | &temp_root | |
406 | }), | |
e74abb32 XL |
407 | None => (&source, &crate_root), |
408 | }; | |
409 | let dlsym_dylib = dlsym_source.dylib.as_ref().expect("no dylib for a proc-macro crate"); | |
136023e0 | 410 | Some(self.dlsym_proc_macros(&dlsym_dylib.0, dlsym_root.stable_crate_id())?) |
60c5eb7d XL |
411 | } else { |
412 | None | |
413 | }; | |
e1599b0c | 414 | |
cdc7bbd5 XL |
415 | // Perform some verification *after* resolve_crate_deps() above is |
416 | // known to have been successful. It seems that - in error cases - the | |
417 | // cstore can be in a temporarily invalid state between cnum allocation | |
418 | // and dependency resolution and the verification code would produce | |
419 | // ICEs in that case (see #83045). | |
420 | self.verify_no_symbol_conflicts(&crate_root)?; | |
421 | self.verify_no_stable_crate_id_hash_conflicts(&crate_root, cnum)?; | |
422 | ||
3dfed10e XL |
423 | let crate_metadata = CrateMetadata::new( |
424 | self.sess, | |
04454e1e | 425 | &self.cstore, |
3dfed10e XL |
426 | metadata, |
427 | crate_root, | |
428 | raw_proc_macros, | |
3b2f2976 | 429 | cnum, |
3dfed10e XL |
430 | cnum_map, |
431 | dep_kind, | |
432 | source, | |
433 | private_dep, | |
434 | host_hash, | |
dfeec247 | 435 | ); |
1a4d82fc | 436 | |
3dfed10e XL |
437 | self.cstore.set_crate_data(cnum, crate_metadata); |
438 | ||
439 | Ok(cnum) | |
1a4d82fc JJ |
440 | } |
441 | ||
dc9dc135 | 442 | fn load_proc_macro<'b>( |
e74abb32 | 443 | &self, |
60c5eb7d | 444 | locator: &mut CrateLocator<'b>, |
532ac7d7 | 445 | path_kind: PathKind, |
c295e0f8 | 446 | host_hash: Option<Svh>, |
3dfed10e | 447 | ) -> Result<Option<(LoadResult, Option<Library>)>, CrateError> |
532ac7d7 | 448 | where |
dc9dc135 | 449 | 'a: 'b, |
532ac7d7 | 450 | { |
60c5eb7d | 451 | // Use a new crate locator so trying to load a proc macro doesn't affect the error |
532ac7d7 | 452 | // message we emit |
60c5eb7d | 453 | let mut proc_macro_locator = locator.clone(); |
532ac7d7 XL |
454 | |
455 | // Try to load a proc macro | |
c295e0f8 | 456 | proc_macro_locator.is_proc_macro = true; |
532ac7d7 XL |
457 | |
458 | // Load the proc macro crate for the target | |
459 | let (locator, target_result) = if self.sess.opts.debugging_opts.dual_proc_macros { | |
460 | proc_macro_locator.reset(); | |
461 | let result = match self.load(&mut proc_macro_locator)? { | |
3dfed10e XL |
462 | Some(LoadResult::Previous(cnum)) => { |
463 | return Ok(Some((LoadResult::Previous(cnum), None))); | |
464 | } | |
465 | Some(LoadResult::Loaded(library)) => Some(LoadResult::Loaded(library)), | |
466 | None => return Ok(None), | |
532ac7d7 | 467 | }; |
c295e0f8 | 468 | locator.hash = host_hash; |
60c5eb7d | 469 | // Use the locator when looking for the host proc macro crate, as that is required |
532ac7d7 | 470 | // so we want it to affect the error message |
60c5eb7d | 471 | (locator, result) |
532ac7d7 XL |
472 | } else { |
473 | (&mut proc_macro_locator, None) | |
474 | }; | |
475 | ||
476 | // Load the proc macro crate for the host | |
477 | ||
478 | locator.reset(); | |
c295e0f8 | 479 | locator.is_proc_macro = true; |
532ac7d7 XL |
480 | locator.target = &self.sess.host; |
481 | locator.triple = TargetTriple::from_triple(config::host_triple()); | |
482 | locator.filesearch = self.sess.host_filesearch(path_kind); | |
483 | ||
5e7ed085 FG |
484 | let Some(host_result) = self.load(locator)? else { |
485 | return Ok(None); | |
3dfed10e | 486 | }; |
532ac7d7 | 487 | |
3dfed10e | 488 | Ok(Some(if self.sess.opts.debugging_opts.dual_proc_macros { |
532ac7d7 XL |
489 | let host_result = match host_result { |
490 | LoadResult::Previous(..) => { | |
491 | panic!("host and target proc macros must be loaded in lock-step") | |
492 | } | |
dfeec247 | 493 | LoadResult::Loaded(library) => library, |
532ac7d7 XL |
494 | }; |
495 | (target_result.unwrap(), Some(host_result)) | |
496 | } else { | |
497 | (host_result, None) | |
3dfed10e | 498 | })) |
532ac7d7 XL |
499 | } |
500 | ||
b7449926 XL |
501 | fn resolve_crate<'b>( |
502 | &'b mut self, | |
b7449926 | 503 | name: Symbol, |
b7449926 | 504 | span: Span, |
3dfed10e | 505 | dep_kind: CrateDepKind, |
a2a8927a | 506 | ) -> Option<CrateNum> { |
c295e0f8 | 507 | self.used_extern_options.insert(name); |
a2a8927a XL |
508 | match self.maybe_resolve_crate(name, dep_kind, None) { |
509 | Ok(cnum) => Some(cnum), | |
510 | Err(err) => { | |
511 | let missing_core = | |
512 | self.maybe_resolve_crate(sym::core, CrateDepKind::Explicit, None).is_err(); | |
513 | err.report(&self.sess, span, missing_core); | |
514 | None | |
515 | } | |
516 | } | |
e74abb32 XL |
517 | } |
518 | ||
519 | fn maybe_resolve_crate<'b>( | |
520 | &'b mut self, | |
521 | name: Symbol, | |
3dfed10e | 522 | mut dep_kind: CrateDepKind, |
e74abb32 | 523 | dep: Option<(&'b CratePaths, &'b CrateDep)>, |
3dfed10e | 524 | ) -> Result<CrateNum, CrateError> { |
e74abb32 | 525 | info!("resolving crate `{}`", name); |
3dfed10e XL |
526 | if !name.as_str().is_ascii() { |
527 | return Err(CrateError::NonAsciiName(name)); | |
528 | } | |
e74abb32 XL |
529 | let (root, hash, host_hash, extra_filename, path_kind) = match dep { |
530 | Some((root, dep)) => ( | |
531 | Some(root), | |
60c5eb7d XL |
532 | Some(dep.hash), |
533 | dep.host_hash, | |
e74abb32 | 534 | Some(&dep.extra_filename[..]), |
60c5eb7d | 535 | PathKind::Dependency, |
e74abb32 XL |
536 | ), |
537 | None => (None, None, None, None, PathKind::Crate), | |
538 | }; | |
476ff2be | 539 | let result = if let Some(cnum) = self.existing_match(name, hash, path_kind) { |
532ac7d7 | 540 | (LoadResult::Previous(cnum), None) |
476ff2be SL |
541 | } else { |
542 | info!("falling back to a load"); | |
60c5eb7d XL |
543 | let mut locator = CrateLocator::new( |
544 | self.sess, | |
17df50a5 | 545 | &*self.metadata_loader, |
60c5eb7d | 546 | name, |
48663c56 XL |
547 | hash, |
548 | extra_filename, | |
60c5eb7d XL |
549 | false, // is_host |
550 | path_kind, | |
60c5eb7d | 551 | ); |
476ff2be | 552 | |
3dfed10e XL |
553 | match self.load(&mut locator)? { |
554 | Some(res) => (res, None), | |
555 | None => { | |
556 | dep_kind = CrateDepKind::MacrosOnly; | |
c295e0f8 | 557 | match self.load_proc_macro(&mut locator, path_kind, host_hash)? { |
3dfed10e | 558 | Some(res) => res, |
c295e0f8 | 559 | None => return Err(locator.into_error(root.cloned())), |
3dfed10e XL |
560 | } |
561 | } | |
562 | } | |
92a42be0 SL |
563 | }; |
564 | ||
565 | match result { | |
532ac7d7 | 566 | (LoadResult::Previous(cnum), None) => { |
92a42be0 | 567 | let data = self.cstore.get_crate_data(cnum); |
60c5eb7d | 568 | if data.is_proc_macro_crate() { |
3dfed10e | 569 | dep_kind = CrateDepKind::MacrosOnly; |
e9174d1e | 570 | } |
60c5eb7d | 571 | data.update_dep_kind(|data_dep_kind| cmp::max(data_dep_kind, dep_kind)); |
e74abb32 | 572 | Ok(cnum) |
92a42be0 | 573 | } |
532ac7d7 | 574 | (LoadResult::Loaded(library), host_library) => { |
3dfed10e | 575 | self.register_crate(host_library, root, library, dep_kind, name) |
1a4d82fc | 576 | } |
dfeec247 | 577 | _ => panic!(), |
1a4d82fc JJ |
578 | } |
579 | } | |
580 | ||
3dfed10e | 581 | fn load(&self, locator: &mut CrateLocator<'_>) -> Result<Option<LoadResult>, CrateError> { |
5e7ed085 FG |
582 | let Some(library) = locator.maybe_load_library_crate()? else { |
583 | return Ok(None); | |
3dfed10e | 584 | }; |
a7813a04 XL |
585 | |
586 | // In the case that we're loading a crate, but not matching | |
587 | // against a hash, we could load a crate which has the same hash | |
588 | // as an already loaded crate. If this is the case prevent | |
589 | // duplicates by just using the first crate. | |
590 | // | |
591 | // Note that we only do this for target triple crates, though, as we | |
592 | // don't want to match a host crate against an equivalent target one | |
593 | // already loaded. | |
9e0c209e | 594 | let root = library.metadata.get_root(); |
136023e0 XL |
595 | // FIXME: why is this condition necessary? It was adding in #33625 but I |
596 | // don't know why and the original author doesn't remember ... | |
597 | let can_reuse_cratenum = | |
c295e0f8 | 598 | locator.triple == self.sess.opts.target_triple || locator.is_proc_macro; |
136023e0 | 599 | Ok(Some(if can_reuse_cratenum { |
a7813a04 | 600 | let mut result = LoadResult::Loaded(library); |
a2a8927a | 601 | for (cnum, data) in self.cstore.iter_crate_data() { |
60c5eb7d XL |
602 | if data.name() == root.name() && root.hash() == data.hash() { |
603 | assert!(locator.hash.is_none()); | |
9e0c209e | 604 | info!("load success, going to previous cnum: {}", cnum); |
a7813a04 | 605 | result = LoadResult::Previous(cnum); |
a2a8927a | 606 | break; |
a7813a04 | 607 | } |
a2a8927a | 608 | } |
3dfed10e | 609 | result |
a7813a04 | 610 | } else { |
3dfed10e XL |
611 | LoadResult::Loaded(library) |
612 | })) | |
a7813a04 XL |
613 | } |
614 | ||
60c5eb7d | 615 | fn update_extern_crate(&self, cnum: CrateNum, extern_crate: ExternCrate) { |
54a0048b | 616 | let cmeta = self.cstore.get_crate_data(cnum); |
60c5eb7d XL |
617 | if cmeta.update_extern_crate(extern_crate) { |
618 | // Propagate the extern crate info to dependencies if it was updated. | |
619 | let extern_crate = ExternCrate { dependency_of: cnum, ..extern_crate }; | |
620 | for &dep_cnum in cmeta.dependencies().iter() { | |
621 | self.update_extern_crate(dep_cnum, extern_crate); | |
622 | } | |
54a0048b SL |
623 | } |
624 | } | |
625 | ||
1a4d82fc | 626 | // Go through the crate metadata and load any crates that it references |
dfeec247 XL |
627 | fn resolve_crate_deps( |
628 | &mut self, | |
629 | root: &CratePaths, | |
923072b8 | 630 | crate_root: &CrateRoot, |
dfeec247 XL |
631 | metadata: &MetadataBlob, |
632 | krate: CrateNum, | |
3dfed10e XL |
633 | dep_kind: CrateDepKind, |
634 | ) -> Result<CrateNumMap, CrateError> { | |
1a4d82fc | 635 | debug!("resolving deps of external crate"); |
60c5eb7d | 636 | if crate_root.is_proc_macro_crate() { |
3dfed10e | 637 | return Ok(CrateNumMap::new()); |
476ff2be SL |
638 | } |
639 | ||
640 | // The map from crate numbers in the crate we're resolving to local crate numbers. | |
641 | // We map 0 and all other holes in the map to our parent crate. The "additional" | |
3157f602 | 642 | // self-dependencies should be harmless. |
3dfed10e XL |
643 | let deps = crate_root.decode_crate_deps(metadata); |
644 | let mut crate_num_map = CrateNumMap::with_capacity(1 + deps.len()); | |
645 | crate_num_map.push(krate); | |
646 | for dep in deps { | |
647 | info!( | |
648 | "resolving dep crate {} hash: `{}` extra filename: `{}`", | |
649 | dep.name, dep.hash, dep.extra_filename | |
650 | ); | |
651 | let dep_kind = match dep_kind { | |
652 | CrateDepKind::MacrosOnly => CrateDepKind::MacrosOnly, | |
653 | _ => dep.kind, | |
654 | }; | |
655 | let cnum = self.maybe_resolve_crate(dep.name, dep_kind, Some((root, &dep)))?; | |
656 | crate_num_map.push(cnum); | |
657 | } | |
658 | ||
659 | debug!("resolve_crate_deps: cnum_map for {:?} is {:?}", krate, crate_num_map); | |
660 | Ok(crate_num_map) | |
1a4d82fc JJ |
661 | } |
662 | ||
dfeec247 XL |
663 | fn dlsym_proc_macros( |
664 | &self, | |
665 | path: &Path, | |
136023e0 | 666 | stable_crate_id: StableCrateId, |
3dfed10e | 667 | ) -> Result<&'static [ProcMacro], CrateError> { |
c30ab7b3 SL |
668 | // Make sure the path contains a / or the linker will search for it. |
669 | let path = env::current_dir().unwrap().join(path); | |
a2a8927a XL |
670 | let lib = unsafe { libloading::Library::new(path) } |
671 | .map_err(|err| CrateError::DlOpen(err.to_string()))?; | |
c30ab7b3 | 672 | |
a2a8927a XL |
673 | let sym_name = self.sess.generate_proc_macro_decls_symbol(stable_crate_id); |
674 | let sym = unsafe { lib.get::<*const &[ProcMacro]>(sym_name.as_bytes()) } | |
675 | .map_err(|err| CrateError::DlSym(err.to_string()))?; | |
c30ab7b3 | 676 | |
c30ab7b3 SL |
677 | // Intentionally leak the dynamic library. We can't ever unload it |
678 | // since the library can make things that will live arbitrarily long. | |
a2a8927a | 679 | let sym = unsafe { sym.into_raw() }; |
e1599b0c | 680 | std::mem::forget(lib); |
a1dfa0c6 | 681 | |
a2a8927a | 682 | Ok(unsafe { **sym }) |
1a4d82fc JJ |
683 | } |
684 | ||
a7813a04 XL |
685 | fn inject_panic_runtime(&mut self, krate: &ast::Crate) { |
686 | // If we're only compiling an rlib, then there's no need to select a | |
687 | // panic runtime, so we just skip this section entirely. | |
f9f354fc | 688 | let any_non_rlib = self.sess.crate_types().iter().any(|ct| *ct != CrateType::Rlib); |
a7813a04 XL |
689 | if !any_non_rlib { |
690 | info!("panic runtime injection skipped, only generating rlib"); | |
dfeec247 | 691 | return; |
a7813a04 XL |
692 | } |
693 | ||
694 | // If we need a panic runtime, we try to find an existing one here. At | |
695 | // the same time we perform some general validation of the DAG we've got | |
696 | // going such as ensuring everything has a compatible panic strategy. | |
697 | // | |
698 | // The logic for finding the panic runtime here is pretty much the same | |
699 | // as the allocator case with the only addition that the panic strategy | |
700 | // compilation mode also comes into play. | |
c30ab7b3 | 701 | let desired_strategy = self.sess.panic_strategy(); |
a7813a04 | 702 | let mut runtime_found = false; |
3dfed10e XL |
703 | let mut needs_panic_runtime = |
704 | self.sess.contains_name(&krate.attrs, sym::needs_panic_runtime); | |
7cac9316 | 705 | |
a2a8927a | 706 | for (cnum, data) in self.cstore.iter_crate_data() { |
60c5eb7d XL |
707 | needs_panic_runtime = needs_panic_runtime || data.needs_panic_runtime(); |
708 | if data.is_panic_runtime() { | |
a7813a04 XL |
709 | // Inject a dependency from all #![needs_panic_runtime] to this |
710 | // #![panic_runtime] crate. | |
dfeec247 XL |
711 | self.inject_dependency_if(cnum, "a panic runtime", &|data| { |
712 | data.needs_panic_runtime() | |
713 | }); | |
3dfed10e | 714 | runtime_found = runtime_found || data.dep_kind() == CrateDepKind::Explicit; |
a7813a04 | 715 | } |
a2a8927a | 716 | } |
a7813a04 XL |
717 | |
718 | // If an explicitly linked and matching panic runtime was found, or if | |
719 | // we just don't need one at all, then we're done here and there's | |
720 | // nothing else to do. | |
721 | if !needs_panic_runtime || runtime_found { | |
dfeec247 | 722 | return; |
a7813a04 XL |
723 | } |
724 | ||
725 | // By this point we know that we (a) need a panic runtime and (b) no | |
726 | // panic runtime was explicitly linked. Here we just load an appropriate | |
727 | // default runtime for our panic strategy and then inject the | |
728 | // dependencies. | |
729 | // | |
730 | // We may resolve to an already loaded crate (as the crate may not have | |
731 | // been explicitly linked prior to this) and we may re-inject | |
732 | // dependencies again, but both of those situations are fine. | |
733 | // | |
734 | // Also note that we have yet to perform validation of the crate graph | |
735 | // in terms of everyone has a compatible panic runtime format, that's | |
736 | // performed later as part of the `dependency_format` module. | |
737 | let name = match desired_strategy { | |
3dfed10e XL |
738 | PanicStrategy::Unwind => sym::panic_unwind, |
739 | PanicStrategy::Abort => sym::panic_abort, | |
a7813a04 XL |
740 | }; |
741 | info!("panic runtime not found -- loading {}", name); | |
742 | ||
a2a8927a | 743 | let Some(cnum) = self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit) else { return; }; |
e74abb32 | 744 | let data = self.cstore.get_crate_data(cnum); |
a7813a04 XL |
745 | |
746 | // Sanity check the loaded crate to ensure it is indeed a panic runtime | |
747 | // and the panic strategy is indeed what we thought it was. | |
60c5eb7d | 748 | if !data.is_panic_runtime() { |
dfeec247 | 749 | self.sess.err(&format!("the crate `{}` is not a panic runtime", name)); |
a7813a04 | 750 | } |
60c5eb7d | 751 | if data.panic_strategy() != desired_strategy { |
dfeec247 XL |
752 | self.sess.err(&format!( |
753 | "the crate `{}` does not have the panic \ | |
a7813a04 | 754 | strategy `{}`", |
dfeec247 XL |
755 | name, |
756 | desired_strategy.desc() | |
757 | )); | |
a7813a04 XL |
758 | } |
759 | ||
60c5eb7d | 760 | self.cstore.injected_panic_runtime = Some(cnum); |
dfeec247 | 761 | self.inject_dependency_if(cnum, "a panic runtime", &|data| data.needs_panic_runtime()); |
8bb4bdeb XL |
762 | } |
763 | ||
fc512014 | 764 | fn inject_profiler_runtime(&mut self, krate: &ast::Crate) { |
94222f64 XL |
765 | if self.sess.opts.debugging_opts.no_profiler_runtime |
766 | || !(self.sess.instrument_coverage() | |
136023e0 | 767 | || self.sess.opts.debugging_opts.profile |
94222f64 | 768 | || self.sess.opts.cg.profile_generate.enabled()) |
ba9703b0 | 769 | { |
136023e0 XL |
770 | return; |
771 | } | |
041b39d2 | 772 | |
136023e0 | 773 | info!("loading profiler"); |
fc512014 | 774 | |
94222f64 | 775 | let name = Symbol::intern(&self.sess.opts.debugging_opts.profiler_runtime); |
136023e0 XL |
776 | if name == sym::profiler_builtins && self.sess.contains_name(&krate.attrs, sym::no_core) { |
777 | self.sess.err( | |
778 | "`profiler_builtins` crate (required by compiler options) \ | |
779 | is not compatible with crate attribute `#![no_core]`", | |
780 | ); | |
781 | } | |
041b39d2 | 782 | |
a2a8927a | 783 | let Some(cnum) = self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit) else { return; }; |
136023e0 XL |
784 | let data = self.cstore.get_crate_data(cnum); |
785 | ||
786 | // Sanity check the loaded crate to ensure it is indeed a profiler runtime | |
787 | if !data.is_profiler_runtime() { | |
788 | self.sess.err(&format!("the crate `{}` is not a profiler runtime", name)); | |
041b39d2 XL |
789 | } |
790 | } | |
791 | ||
60c5eb7d | 792 | fn inject_allocator_crate(&mut self, krate: &ast::Crate) { |
3dfed10e | 793 | self.cstore.has_global_allocator = match &*global_allocator_spans(&self.sess, krate) { |
416331ca | 794 | [span1, span2, ..] => { |
dfeec247 XL |
795 | self.sess |
796 | .struct_span_err(*span2, "cannot define multiple global allocators") | |
60c5eb7d | 797 | .span_label(*span2, "cannot define a new global allocator") |
74b04a01 | 798 | .span_label(*span1, "previous global allocator defined here") |
60c5eb7d | 799 | .emit(); |
416331ca XL |
800 | true |
801 | } | |
dfeec247 | 802 | spans => !spans.is_empty(), |
416331ca | 803 | }; |
041b39d2 XL |
804 | |
805 | // Check to see if we actually need an allocator. This desire comes | |
806 | // about through the `#![needs_allocator]` attribute and is typically | |
807 | // written down in liballoc. | |
a2a8927a XL |
808 | if !self.sess.contains_name(&krate.attrs, sym::needs_allocator) |
809 | && !self.cstore.iter_crate_data().any(|(_, data)| data.needs_allocator()) | |
810 | { | |
dfeec247 | 811 | return; |
041b39d2 | 812 | } |
e9174d1e | 813 | |
041b39d2 XL |
814 | // At this point we've determined that we need an allocator. Let's see |
815 | // if our compilation session actually needs an allocator based on what | |
816 | // we're emitting. | |
29967ef6 | 817 | let all_rlib = self.sess.crate_types().iter().all(|ct| matches!(*ct, CrateType::Rlib)); |
a1dfa0c6 | 818 | if all_rlib { |
dfeec247 | 819 | return; |
041b39d2 | 820 | } |
e9174d1e | 821 | |
041b39d2 XL |
822 | // Ok, we need an allocator. Not only that but we're actually going to |
823 | // create an artifact that needs one linked in. Let's go find the one | |
824 | // that we're going to link in. | |
e9174d1e | 825 | // |
041b39d2 XL |
826 | // First up we check for global allocators. Look at the crate graph here |
827 | // and see what's a global allocator, including if we ourselves are a | |
828 | // global allocator. | |
dfeec247 XL |
829 | let mut global_allocator = |
830 | self.cstore.has_global_allocator.then(|| Symbol::intern("this crate")); | |
a2a8927a XL |
831 | for (_, data) in self.cstore.iter_crate_data() { |
832 | if data.has_global_allocator() { | |
833 | match global_allocator { | |
5e7ed085 FG |
834 | Some(other_crate) => { |
835 | self.sess.err(&format!( | |
a2a8927a | 836 | "the `#[global_allocator]` in {} conflicts with global allocator in: {}", |
dfeec247 XL |
837 | other_crate, |
838 | data.name() | |
5e7ed085 FG |
839 | )); |
840 | } | |
a2a8927a | 841 | None => global_allocator = Some(data.name()), |
041b39d2 | 842 | } |
041b39d2 | 843 | } |
a2a8927a XL |
844 | } |
845 | ||
041b39d2 | 846 | if global_allocator.is_some() { |
60c5eb7d | 847 | self.cstore.allocator_kind = Some(AllocatorKind::Global); |
dfeec247 | 848 | return; |
041b39d2 | 849 | } |
e9174d1e | 850 | |
041b39d2 | 851 | // Ok we haven't found a global allocator but we still need an |
a1dfa0c6 XL |
852 | // allocator. At this point our allocator request is typically fulfilled |
853 | // by the standard library, denoted by the `#![default_lib_allocator]` | |
854 | // attribute. | |
a2a8927a XL |
855 | if !self.sess.contains_name(&krate.attrs, sym::default_lib_allocator) |
856 | && !self.cstore.iter_crate_data().any(|(_, data)| data.has_default_lib_allocator()) | |
857 | { | |
dfeec247 | 858 | self.sess.err( |
a2a8927a XL |
859 | "no global memory allocator found but one is required; link to std or add \ |
860 | `#[global_allocator]` to a static item that implements the GlobalAlloc trait", | |
dfeec247 | 861 | ); |
e9174d1e | 862 | } |
60c5eb7d | 863 | self.cstore.allocator_kind = Some(AllocatorKind::Default); |
e9174d1e SL |
864 | } |
865 | ||
dfeec247 XL |
866 | fn inject_dependency_if( |
867 | &self, | |
868 | krate: CrateNum, | |
869 | what: &str, | |
870 | needs_dep: &dyn Fn(&CrateMetadata) -> bool, | |
871 | ) { | |
a7813a04 XL |
872 | // don't perform this validation if the session has errors, as one of |
873 | // those errors may indicate a circular dependency which could cause | |
874 | // this to stack overflow. | |
5e7ed085 | 875 | if self.sess.has_errors().is_some() { |
dfeec247 | 876 | return; |
a7813a04 XL |
877 | } |
878 | ||
e9174d1e | 879 | // Before we inject any dependencies, make sure we don't inject a |
a7813a04 XL |
880 | // circular dependency by validating that this crate doesn't |
881 | // transitively depend on any crates satisfying `needs_dep`. | |
60c5eb7d | 882 | for dep in self.cstore.crate_dependencies_in_reverse_postorder(krate) { |
3157f602 XL |
883 | let data = self.cstore.get_crate_data(dep); |
884 | if needs_dep(&data) { | |
dfeec247 XL |
885 | self.sess.err(&format!( |
886 | "the crate `{}` cannot depend \ | |
3157f602 XL |
887 | on a crate that needs {}, but \ |
888 | it depends on `{}`", | |
dfeec247 XL |
889 | self.cstore.get_crate_data(krate).name(), |
890 | what, | |
891 | data.name() | |
892 | )); | |
3157f602 XL |
893 | } |
894 | } | |
a7813a04 XL |
895 | |
896 | // All crates satisfying `needs_dep` do not explicitly depend on the | |
897 | // crate provided for this compile, but in order for this compilation to | |
898 | // be successfully linked we need to inject a dependency (to order the | |
899 | // crates on the command line correctly). | |
a2a8927a XL |
900 | for (cnum, data) in self.cstore.iter_crate_data() { |
901 | if needs_dep(data) { | |
902 | info!("injecting a dep from {} to {}", cnum, krate); | |
903 | data.add_dependency(krate); | |
e9174d1e | 904 | } |
a2a8927a | 905 | } |
e9174d1e | 906 | } |
e9174d1e | 907 | |
f9f354fc XL |
908 | fn report_unused_deps(&mut self, krate: &ast::Crate) { |
909 | // Make a point span rather than covering the whole file | |
5e7ed085 | 910 | let span = krate.spans.inner_span.shrink_to_lo(); |
f9f354fc | 911 | // Complain about anything left over |
f035d41b XL |
912 | for (name, entry) in self.sess.opts.externs.iter() { |
913 | if let ExternLocation::FoundInLibrarySearchDirectories = entry.location { | |
914 | // Don't worry about pathless `--extern foo` sysroot references | |
915 | continue; | |
916 | } | |
04454e1e FG |
917 | if entry.nounused_dep { |
918 | // We're not worried about this one | |
919 | continue; | |
920 | } | |
cdc7bbd5 XL |
921 | let name_interned = Symbol::intern(name); |
922 | if self.used_extern_options.contains(&name_interned) { | |
6a06907d XL |
923 | continue; |
924 | } | |
925 | ||
926 | // Got a real unused --extern | |
04454e1e | 927 | if self.sess.opts.json_unused_externs.is_enabled() { |
cdc7bbd5 XL |
928 | self.cstore.unused_externs.push(name_interned); |
929 | continue; | |
930 | } | |
931 | ||
04454e1e | 932 | self.sess.parse_sess.buffer_lint( |
f9f354fc XL |
933 | lint::builtin::UNUSED_CRATE_DEPENDENCIES, |
934 | span, | |
935 | ast::CRATE_NODE_ID, | |
936 | &format!( | |
937 | "external crate `{}` unused in `{}`: remove the dependency or add `use {} as _;`", | |
938 | name, | |
939 | self.local_crate_name, | |
940 | name), | |
941 | ); | |
f9f354fc XL |
942 | } |
943 | } | |
944 | ||
b7449926 | 945 | pub fn postprocess(&mut self, krate: &ast::Crate) { |
fc512014 | 946 | self.inject_profiler_runtime(krate); |
041b39d2 | 947 | self.inject_allocator_crate(krate); |
c30ab7b3 | 948 | self.inject_panic_runtime(krate); |
c34b1796 | 949 | |
f9f354fc | 950 | self.report_unused_deps(krate); |
cdc7bbd5 XL |
951 | |
952 | info!("{:?}", CrateDump(&self.cstore)); | |
9e0c209e | 953 | } |
c34b1796 | 954 | |
b7449926 | 955 | pub fn process_extern_crate( |
e74abb32 XL |
956 | &mut self, |
957 | item: &ast::Item, | |
958 | definitions: &Definitions, | |
f035d41b | 959 | def_id: LocalDefId, |
a2a8927a | 960 | ) -> Option<CrateNum> { |
e74abb32 | 961 | match item.kind { |
0531ce1d | 962 | ast::ItemKind::ExternCrate(orig_name) => { |
dfeec247 XL |
963 | debug!( |
964 | "resolving extern crate stmt. ident: {} orig_name: {:?}", | |
965 | item.ident, orig_name | |
966 | ); | |
e74abb32 | 967 | let name = match orig_name { |
0531ce1d | 968 | Some(orig_name) => { |
a2a8927a | 969 | validate_crate_name(self.sess, orig_name.as_str(), Some(item.span)); |
0531ce1d | 970 | orig_name |
ff7c6d11 XL |
971 | } |
972 | None => item.ident.name, | |
973 | }; | |
3dfed10e XL |
974 | let dep_kind = if self.sess.contains_name(&item.attrs, sym::no_link) { |
975 | CrateDepKind::MacrosOnly | |
ff7c6d11 | 976 | } else { |
3dfed10e | 977 | CrateDepKind::Explicit |
ff7c6d11 XL |
978 | }; |
979 | ||
a2a8927a | 980 | let cnum = self.resolve_crate(name, item.span, dep_kind)?; |
476ff2be | 981 | |
ba9703b0 | 982 | let path_len = definitions.def_path(def_id).data.len(); |
83c7162d XL |
983 | self.update_extern_crate( |
984 | cnum, | |
985 | ExternCrate { | |
ba9703b0 | 986 | src: ExternCrateSource::Extern(def_id.to_def_id()), |
83c7162d XL |
987 | span: item.span, |
988 | path_len, | |
e74abb32 | 989 | dependency_of: LOCAL_CRATE, |
83c7162d | 990 | }, |
83c7162d | 991 | ); |
a2a8927a | 992 | Some(cnum) |
c30ab7b3 | 993 | } |
83c7162d | 994 | _ => bug!(), |
c34b1796 | 995 | } |
c34b1796 | 996 | } |
ff7c6d11 | 997 | |
a2a8927a XL |
998 | pub fn process_path_extern(&mut self, name: Symbol, span: Span) -> Option<CrateNum> { |
999 | let cnum = self.resolve_crate(name, span, CrateDepKind::Explicit)?; | |
83c7162d XL |
1000 | |
1001 | self.update_extern_crate( | |
1002 | cnum, | |
1003 | ExternCrate { | |
1004 | src: ExternCrateSource::Path, | |
1005 | span, | |
1006 | // to have the least priority in `update_extern_crate` | |
f035d41b | 1007 | path_len: usize::MAX, |
e74abb32 | 1008 | dependency_of: LOCAL_CRATE, |
83c7162d | 1009 | }, |
83c7162d XL |
1010 | ); |
1011 | ||
a2a8927a | 1012 | Some(cnum) |
83c7162d XL |
1013 | } |
1014 | ||
3dfed10e XL |
1015 | pub fn maybe_process_path_extern(&mut self, name: Symbol) -> Option<CrateNum> { |
1016 | self.maybe_resolve_crate(name, CrateDepKind::Explicit, None).ok() | |
1017 | } | |
1018 | } | |
1019 | ||
1020 | fn global_allocator_spans(sess: &Session, krate: &ast::Crate) -> Vec<Span> { | |
1021 | struct Finder<'a> { | |
1022 | sess: &'a Session, | |
1023 | name: Symbol, | |
1024 | spans: Vec<Span>, | |
1025 | } | |
1026 | impl<'ast, 'a> visit::Visitor<'ast> for Finder<'a> { | |
1027 | fn visit_item(&mut self, item: &'ast ast::Item) { | |
1028 | if item.ident.name == self.name | |
1029 | && self.sess.contains_name(&item.attrs, sym::rustc_std_internal_symbol) | |
1030 | { | |
1031 | self.spans.push(item.span); | |
1032 | } | |
1033 | visit::walk_item(self, item) | |
1034 | } | |
ff7c6d11 | 1035 | } |
3dfed10e XL |
1036 | |
1037 | let name = Symbol::intern(&AllocatorKind::Global.fn_name(sym::alloc)); | |
1038 | let mut f = Finder { sess, name, spans: Vec::new() }; | |
1039 | visit::walk_crate(&mut f, krate); | |
1040 | f.spans | |
c34b1796 | 1041 | } |