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