1use std::path::PathBuf;
2use std::result;
3use std::sync::Arc;
4
5use rustc_ast::{LitKind, MetaItemKind, token};
6use rustc_codegen_ssa::traits::CodegenBackend;
7use rustc_data_structures::fx::{FxHashMap, FxHashSet};
8use rustc_data_structures::jobserver::{self, Proxy};
9use rustc_data_structures::stable_hasher::StableHasher;
10use rustc_errors::registry::Registry;
11use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
12use rustc_lint::LintStore;
13use rustc_middle::ty;
14use rustc_middle::ty::CurrentGcx;
15use rustc_middle::util::Providers;
16use rustc_parse::new_parser_from_source_str;
17use rustc_parse::parser::attr::AllowLeadingUnsafe;
18use rustc_query_impl::QueryCtxt;
19use rustc_query_system::query::print_query_stack;
20use rustc_session::config::{self, Cfg, CheckCfg, ExpectedValues, Input, OutFileName};
21use rustc_session::parse::ParseSess;
22use rustc_session::{CompilerIO, EarlyDiagCtxt, Session, lint};
23use rustc_span::source_map::{FileLoader, RealFileLoader, SourceMapInputs};
24use rustc_span::{FileName, sym};
25use tracing::trace;
26
27use crate::util;
28
29pub type Result<T> = result::Result<T, ErrorGuaranteed>;
30
31pub struct Compiler {
39 pub sess: Session,
40 pub codegen_backend: Box<dyn CodegenBackend>,
41 pub(crate) override_queries: Option<fn(&Session, &mut Providers)>,
42
43 pub(crate) current_gcx: CurrentGcx,
45
46 pub(crate) jobserver_proxy: Arc<Proxy>,
48}
49
50pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
52 cfgs.into_iter()
53 .map(|s| {
54 let psess = ParseSess::with_fatal_emitter(
55 vec![crate::DEFAULT_LOCALE_RESOURCE, rustc_parse::DEFAULT_LOCALE_RESOURCE],
56 format!("this error occurred on the command line: `--cfg={s}`"),
57 );
58 let filename = FileName::cfg_spec_source_code(&s);
59
60 macro_rules! error {
61 ($reason: expr) => {
62 #[allow(rustc::untranslatable_diagnostic)]
63 #[allow(rustc::diagnostic_outside_of_impl)]
64 dcx.fatal(format!(
65 concat!("invalid `--cfg` argument: `{}` (", $reason, ")"),
66 s
67 ));
68 };
69 }
70
71 match new_parser_from_source_str(&psess, filename, s.to_string()) {
72 Ok(mut parser) => match parser.parse_meta_item(AllowLeadingUnsafe::No) {
73 Ok(meta_item) if parser.token == token::Eof => {
74 if meta_item.path.segments.len() != 1 {
75 error!("argument key must be an identifier");
76 }
77 match &meta_item.kind {
78 MetaItemKind::List(..) => {}
79 MetaItemKind::NameValue(lit) if !lit.kind.is_str() => {
80 error!("argument value must be a string");
81 }
82 MetaItemKind::NameValue(..) | MetaItemKind::Word => {
83 let ident = meta_item.ident().expect("multi-segment cfg key");
84 return (ident.name, meta_item.value_str());
85 }
86 }
87 }
88 Ok(..) => {}
89 Err(err) => err.cancel(),
90 },
91 Err(errs) => errs.into_iter().for_each(|err| err.cancel()),
92 }
93
94 if s.contains('=') && !s.contains("=\"") && !s.ends_with('"') {
97 error!(concat!(
98 r#"expected `key` or `key="value"`, ensure escaping is appropriate"#,
99 r#" for your shell, try 'key="value"' or key=\"value\""#
100 ));
101 } else {
102 error!(r#"expected `key` or `key="value"`"#);
103 }
104 })
105 .collect::<Cfg>()
106}
107
108pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> CheckCfg {
110 let exhaustive_names = !specs.is_empty();
113 let exhaustive_values = !specs.is_empty();
114 let mut check_cfg = CheckCfg { exhaustive_names, exhaustive_values, ..CheckCfg::default() };
115
116 for s in specs {
117 let psess = ParseSess::with_fatal_emitter(
118 vec![crate::DEFAULT_LOCALE_RESOURCE, rustc_parse::DEFAULT_LOCALE_RESOURCE],
119 format!("this error occurred on the command line: `--check-cfg={s}`"),
120 );
121 let filename = FileName::cfg_spec_source_code(&s);
122
123 const VISIT: &str =
124 "visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details";
125
126 macro_rules! error {
127 ($reason:expr) => {
128 #[allow(rustc::untranslatable_diagnostic)]
129 #[allow(rustc::diagnostic_outside_of_impl)]
130 {
131 let mut diag =
132 dcx.struct_fatal(format!("invalid `--check-cfg` argument: `{s}`"));
133 diag.note($reason);
134 diag.note(VISIT);
135 diag.emit()
136 }
137 };
138 (in $arg:expr, $reason:expr) => {
139 #[allow(rustc::untranslatable_diagnostic)]
140 #[allow(rustc::diagnostic_outside_of_impl)]
141 {
142 let mut diag =
143 dcx.struct_fatal(format!("invalid `--check-cfg` argument: `{s}`"));
144
145 let pparg = rustc_ast_pretty::pprust::meta_list_item_to_string($arg);
146 if let Some(lit) = $arg.lit() {
147 let (lit_kind_article, lit_kind_descr) = {
148 let lit_kind = lit.as_token_lit().kind;
149 (lit_kind.article(), lit_kind.descr())
150 };
151 diag.note(format!(
152 "`{pparg}` is {lit_kind_article} {lit_kind_descr} literal"
153 ));
154 } else {
155 diag.note(format!("`{pparg}` is invalid"));
156 }
157
158 diag.note($reason);
159 diag.note(VISIT);
160 diag.emit()
161 }
162 };
163 }
164
165 let expected_error = || -> ! {
166 error!("expected `cfg(name, values(\"value1\", \"value2\", ... \"valueN\"))`")
167 };
168
169 let mut parser = match new_parser_from_source_str(&psess, filename, s.to_string()) {
170 Ok(parser) => parser,
171 Err(errs) => {
172 errs.into_iter().for_each(|err| err.cancel());
173 expected_error();
174 }
175 };
176
177 let meta_item = match parser.parse_meta_item(AllowLeadingUnsafe::No) {
178 Ok(meta_item) if parser.token == token::Eof => meta_item,
179 Ok(..) => expected_error(),
180 Err(err) => {
181 err.cancel();
182 expected_error();
183 }
184 };
185
186 let Some(args) = meta_item.meta_item_list() else {
187 expected_error();
188 };
189
190 if !meta_item.has_name(sym::cfg) {
191 expected_error();
192 }
193
194 let mut names = Vec::new();
195 let mut values: FxHashSet<_> = Default::default();
196
197 let mut any_specified = false;
198 let mut values_specified = false;
199 let mut values_any_specified = false;
200
201 for arg in args {
202 if arg.is_word()
203 && let Some(ident) = arg.ident()
204 {
205 if values_specified {
206 error!("`cfg()` names cannot be after values");
207 }
208 names.push(ident);
209 } else if let Some(boolean) = arg.boolean_literal() {
210 if values_specified {
211 error!("`cfg()` names cannot be after values");
212 }
213 names.push(rustc_span::Ident::new(
214 if boolean { rustc_span::kw::True } else { rustc_span::kw::False },
215 arg.span(),
216 ));
217 } else if arg.has_name(sym::any)
218 && let Some(args) = arg.meta_item_list()
219 {
220 if any_specified {
221 error!("`any()` cannot be specified multiple times");
222 }
223 any_specified = true;
224 if !args.is_empty() {
225 error!(in arg, "`any()` takes no argument");
226 }
227 } else if arg.has_name(sym::values)
228 && let Some(args) = arg.meta_item_list()
229 {
230 if names.is_empty() {
231 error!("`values()` cannot be specified before the names");
232 } else if values_specified {
233 error!("`values()` cannot be specified multiple times");
234 }
235 values_specified = true;
236
237 for arg in args {
238 if let Some(LitKind::Str(s, _)) = arg.lit().map(|lit| &lit.kind) {
239 values.insert(Some(*s));
240 } else if arg.has_name(sym::any)
241 && let Some(args) = arg.meta_item_list()
242 {
243 if values_any_specified {
244 error!(in arg, "`any()` in `values()` cannot be specified multiple times");
245 }
246 values_any_specified = true;
247 if !args.is_empty() {
248 error!(in arg, "`any()` in `values()` takes no argument");
249 }
250 } else if arg.has_name(sym::none)
251 && let Some(args) = arg.meta_item_list()
252 {
253 values.insert(None);
254 if !args.is_empty() {
255 error!(in arg, "`none()` in `values()` takes no argument");
256 }
257 } else {
258 error!(in arg, "`values()` arguments must be string literals, `none()` or `any()`");
259 }
260 }
261 } else {
262 error!(in arg, "`cfg()` arguments must be simple identifiers, `any()` or `values(...)`");
263 }
264 }
265
266 if !values_specified && !any_specified {
267 values.insert(None);
270 } else if !values.is_empty() && values_any_specified {
271 error!(
272 "`values()` arguments cannot specify string literals and `any()` at the same time"
273 );
274 }
275
276 if any_specified {
277 if names.is_empty() && values.is_empty() && !values_specified && !values_any_specified {
278 check_cfg.exhaustive_names = false;
279 } else {
280 error!("`cfg(any())` can only be provided in isolation");
281 }
282 } else {
283 for name in names {
284 check_cfg
285 .expecteds
286 .entry(name.name)
287 .and_modify(|v| match v {
288 ExpectedValues::Some(v) if !values_any_specified => {
289 v.extend(values.clone())
290 }
291 ExpectedValues::Some(_) => *v = ExpectedValues::Any,
292 ExpectedValues::Any => {}
293 })
294 .or_insert_with(|| {
295 if values_any_specified {
296 ExpectedValues::Any
297 } else {
298 ExpectedValues::Some(values.clone())
299 }
300 });
301 }
302 }
303 }
304
305 check_cfg
306}
307
308pub struct Config {
310 pub opts: config::Options,
312
313 pub crate_cfg: Vec<String>,
315 pub crate_check_cfg: Vec<String>,
316
317 pub input: Input,
318 pub output_dir: Option<PathBuf>,
319 pub output_file: Option<OutFileName>,
320 pub ice_file: Option<PathBuf>,
321 pub file_loader: Option<Box<dyn FileLoader + Send + Sync>>,
327 pub locale_resources: Vec<&'static str>,
330
331 pub lint_caps: FxHashMap<lint::LintId, lint::Level>,
332
333 pub psess_created: Option<Box<dyn FnOnce(&mut ParseSess) + Send>>,
335
336 pub hash_untracked_state: Option<Box<dyn FnOnce(&Session, &mut StableHasher) + Send>>,
341
342 pub register_lints: Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>>,
348
349 pub override_queries: Option<fn(&Session, &mut Providers)>,
352
353 pub extra_symbols: Vec<&'static str>,
356
357 pub make_codegen_backend:
364 Option<Box<dyn FnOnce(&config::Options) -> Box<dyn CodegenBackend> + Send>>,
365
366 pub registry: Registry,
368
369 pub using_internal_features: &'static std::sync::atomic::AtomicBool,
373
374 pub expanded_args: Vec<String>,
379}
380
381pub(crate) fn initialize_checked_jobserver(early_dcx: &EarlyDiagCtxt) {
383 jobserver::initialize_checked(|err| {
384 #[allow(rustc::untranslatable_diagnostic)]
385 #[allow(rustc::diagnostic_outside_of_impl)]
386 early_dcx
387 .early_struct_warn(err)
388 .with_note("the build environment is likely misconfigured")
389 .emit()
390 });
391}
392
393#[allow(rustc::bad_opt_access)]
395pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Send) -> R {
396 trace!("run_compiler");
397
398 rustc_data_structures::sync::set_dyn_thread_safe_mode(config.opts.unstable_opts.threads > 1);
400
401 let early_dcx = EarlyDiagCtxt::new(config.opts.error_format);
403 initialize_checked_jobserver(&early_dcx);
404
405 crate::callbacks::setup_callbacks();
406
407 let target = config::build_target_config(
408 &early_dcx,
409 &config.opts.target_triple,
410 config.opts.sysroot.path(),
411 );
412 let file_loader = config.file_loader.unwrap_or_else(|| Box::new(RealFileLoader));
413 let path_mapping = config.opts.file_path_mapping();
414 let hash_kind = config.opts.unstable_opts.src_hash_algorithm(&target);
415 let checksum_hash_kind = config.opts.unstable_opts.checksum_hash_algorithm();
416
417 util::run_in_thread_pool_with_globals(
418 &early_dcx,
419 config.opts.edition,
420 config.opts.unstable_opts.threads,
421 &config.extra_symbols,
422 SourceMapInputs { file_loader, path_mapping, hash_kind, checksum_hash_kind },
423 |current_gcx, jobserver_proxy| {
424 let early_dcx = EarlyDiagCtxt::new(config.opts.error_format);
427
428 let codegen_backend = match config.make_codegen_backend {
429 None => util::get_codegen_backend(
430 &early_dcx,
431 &config.opts.sysroot,
432 config.opts.unstable_opts.codegen_backend.as_deref(),
433 &target,
434 ),
435 Some(make_codegen_backend) => {
436 make_codegen_backend(&config.opts)
439 }
440 };
441
442 let temps_dir = config.opts.unstable_opts.temps_dir.as_deref().map(PathBuf::from);
443
444 let bundle = match rustc_errors::fluent_bundle(
445 &config.opts.sysroot.all_paths().collect::<Vec<_>>(),
446 config.opts.unstable_opts.translate_lang.clone(),
447 config.opts.unstable_opts.translate_additional_ftl.as_deref(),
448 config.opts.unstable_opts.translate_directionality_markers,
449 ) {
450 Ok(bundle) => bundle,
451 Err(e) => {
452 #[allow(rustc::untranslatable_diagnostic)]
454 early_dcx.early_fatal(format!("failed to load fluent bundle: {e}"))
455 }
456 };
457
458 let mut locale_resources = config.locale_resources;
459 locale_resources.push(codegen_backend.locale_resource());
460
461 let mut sess = rustc_session::build_session(
462 config.opts,
463 CompilerIO {
464 input: config.input,
465 output_dir: config.output_dir,
466 output_file: config.output_file,
467 temps_dir,
468 },
469 bundle,
470 config.registry,
471 locale_resources,
472 config.lint_caps,
473 target,
474 util::rustc_version_str().unwrap_or("unknown"),
475 config.ice_file,
476 config.using_internal_features,
477 config.expanded_args,
478 );
479
480 codegen_backend.init(&sess);
481
482 let cfg = parse_cfg(sess.dcx(), config.crate_cfg);
483 let mut cfg = config::build_configuration(&sess, cfg);
484 util::add_configuration(&mut cfg, &mut sess, &*codegen_backend);
485 sess.psess.config = cfg;
486
487 let mut check_cfg = parse_check_cfg(sess.dcx(), config.crate_check_cfg);
488 check_cfg.fill_well_known(&sess.target);
489 sess.psess.check_config = check_cfg;
490
491 if let Some(psess_created) = config.psess_created {
492 psess_created(&mut sess.psess);
493 }
494
495 if let Some(hash_untracked_state) = config.hash_untracked_state {
496 let mut hasher = StableHasher::new();
497 hash_untracked_state(&sess, &mut hasher);
498 sess.opts.untracked_state_hash = hasher.finish()
499 }
500
501 let mut lint_store = rustc_lint::new_lint_store(sess.enable_internal_lints());
505 if let Some(register_lints) = config.register_lints.as_deref() {
506 register_lints(&sess, &mut lint_store);
507 }
508 sess.lint_store = Some(Arc::new(lint_store));
509
510 util::check_abi_required_features(&sess);
511
512 let compiler = Compiler {
513 sess,
514 codegen_backend,
515 override_queries: config.override_queries,
516 current_gcx,
517 jobserver_proxy,
518 };
519
520 let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| f(&compiler)));
526
527 compiler.sess.finish_diagnostics();
528
529 if res.is_ok() {
537 compiler.sess.dcx().abort_if_errors();
538 }
539
540 compiler.sess.dcx().flush_delayed();
545
546 let res = match res {
547 Ok(res) => res,
548 Err(err) => std::panic::resume_unwind(err),
550 };
551
552 let prof = compiler.sess.prof.clone();
553 prof.generic_activity("drop_compiler").run(move || drop(compiler));
554
555 res
556 },
557 )
558}
559
560pub fn try_print_query_stack(
561 dcx: DiagCtxtHandle<'_>,
562 limit_frames: Option<usize>,
563 file: Option<std::fs::File>,
564) {
565 eprintln!("query stack during panic:");
566
567 let all_frames = ty::tls::with_context_opt(|icx| {
571 if let Some(icx) = icx {
572 ty::print::with_no_queries!(print_query_stack(
573 QueryCtxt::new(icx.tcx),
574 icx.query,
575 dcx,
576 limit_frames,
577 file,
578 ))
579 } else {
580 0
581 }
582 });
583
584 if let Some(limit_frames) = limit_frames
585 && all_frames > limit_frames
586 {
587 eprintln!(
588 "... and {} other queries... use `env RUST_BACKTRACE=1` to see the full query stack",
589 all_frames - limit_frames
590 );
591 } else {
592 eprintln!("end of query stack");
593 }
594}