compiler/rustc_interface/src/util.rs

   1 use libloading::Library;
   2 use rustc_ast as ast;
   3 use rustc_codegen_ssa::traits::CodegenBackend;
   4 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
   5 #[cfg(parallel_compiler)]
   6 use rustc_data_structures::jobserver;
   7 use rustc_data_structures::sync::Lrc;
   8 use rustc_errors::registry::Registry;
   9 #[cfg(parallel_compiler)]
  10 use rustc_middle::ty::tls;
  11 use rustc_parse::validate_attr;
  12 #[cfg(parallel_compiler)]
  13 use rustc_query_impl::QueryCtxt;
  14 use rustc_session as session;
  15 use rustc_session::config::CheckCfg;
  16 use rustc_session::config::{self, CrateType};
  17 use rustc_session::config::{ErrorOutputType, Input, OutputFilenames};
  18 use rustc_session::lint::{self, BuiltinLintDiagnostics, LintBuffer};
  19 use rustc_session::parse::CrateConfig;
  20 use rustc_session::{early_error, filesearch, output, DiagnosticOutput, Session};
  21 use rustc_span::edition::Edition;
  22 use rustc_span::lev_distance::find_best_match_for_name;
  23 use rustc_span::source_map::FileLoader;
  24 use rustc_span::symbol::{sym, Symbol};
  25 use std::env;
  26 use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
  27 use std::lazy::SyncOnceCell;
  28 use std::mem;
  29 #[cfg(not(parallel_compiler))]
  30 use std::panic;
  31 use std::path::{Path, PathBuf};
  32 use std::sync::atomic::{AtomicBool, Ordering};
  33 use std::thread;
  34 use tracing::info;
  35
  36 /// Function pointer type that constructs a new CodegenBackend.
  37 pub type MakeBackendFn = fn() -> Box<dyn CodegenBackend>;
  38
  39 /// Adds `target_feature = "..."` cfgs for a variety of platform
  40 /// specific features (SSE, NEON etc.).
  41 ///
  42 /// This is performed by checking whether a set of permitted features
  43 /// is available on the target machine, by querying LLVM.
  44 pub fn add_configuration(
  45     cfg: &mut CrateConfig,
  46     sess: &mut Session,
  47     codegen_backend: &dyn CodegenBackend,
  48 ) {
  49     let tf = sym::target_feature;
  50
  51     let target_features = codegen_backend.target_features(sess);
  52     sess.target_features.extend(target_features.iter().cloned());
  53
  54     cfg.extend(target_features.into_iter().map(|feat| (tf, Some(feat))));
  55
  56     if sess.crt_static(None) {
  57         cfg.insert((tf, Some(sym::crt_dash_static)));
  58     }
  59 }
  60
  61 pub fn create_session(
  62     sopts: config::Options,
  63     cfg: FxHashSet<(String, Option<String>)>,
  64     check_cfg: CheckCfg,
  65     diagnostic_output: DiagnosticOutput,
  66     file_loader: Option<Box<dyn FileLoader + Send + Sync + 'static>>,
  67     input_path: Option<PathBuf>,
  68     lint_caps: FxHashMap<lint::LintId, lint::Level>,
  69     make_codegen_backend: Option<
  70         Box<dyn FnOnce(&config::Options) -> Box<dyn CodegenBackend> + Send>,
  71     >,
  72     descriptions: Registry,
  73 ) -> (Lrc<Session>, Lrc<Box<dyn CodegenBackend>>) {
  74     let codegen_backend = if let Some(make_codegen_backend) = make_codegen_backend {
  75         make_codegen_backend(&sopts)
  76     } else {
  77         get_codegen_backend(
  78             &sopts.maybe_sysroot,
  79             sopts.debugging_opts.codegen_backend.as_ref().map(|name| &name[..]),
  80         )
  81     };
  82
  83     // target_override is documented to be called before init(), so this is okay
  84     let target_override = codegen_backend.target_override(&sopts);
  85
  86     let bundle = match rustc_errors::fluent_bundle(
  87         sopts.maybe_sysroot.clone(),
  88         sysroot_candidates(),
  89         sopts.debugging_opts.translate_lang.clone(),
  90         sopts.debugging_opts.translate_additional_ftl.as_deref(),
  91         sopts.debugging_opts.translate_directionality_markers,
  92     ) {
  93         Ok(bundle) => bundle,
  94         Err(e) => {
  95             early_error(sopts.error_format, &format!("failed to load fluent bundle: {e}"));
  96         }
  97     };
  98
  99     let mut sess = session::build_session(
 100         sopts,
 101         input_path,
 102         bundle,
 103         descriptions,
 104         diagnostic_output,
 105         lint_caps,
 106         file_loader,
 107         target_override,
 108     );
 109
 110     codegen_backend.init(&sess);
 111
 112     let mut cfg = config::build_configuration(&sess, config::to_crate_config(cfg));
 113     add_configuration(&mut cfg, &mut sess, &*codegen_backend);
 114
 115     let mut check_cfg = config::to_crate_check_config(check_cfg);
 116     check_cfg.fill_well_known();
 117     check_cfg.fill_actual(&cfg);
 118
 119     sess.parse_sess.config = cfg;
 120     sess.parse_sess.check_config = check_cfg;
 121
 122     (Lrc::new(sess), Lrc::new(codegen_backend))
 123 }
 124
 125 const STACK_SIZE: usize = 8 * 1024 * 1024;
 126
 127 fn get_stack_size() -> Option<usize> {
 128     // FIXME: Hacks on hacks. If the env is trying to override the stack size
 129     // then *don't* set it explicitly.
 130     env::var_os("RUST_MIN_STACK").is_none().then_some(STACK_SIZE)
 131 }
 132
 133 /// Like a `thread::Builder::spawn` followed by a `join()`, but avoids the need
 134 /// for `'static` bounds.
 135 #[cfg(not(parallel_compiler))]
 136 fn scoped_thread<F: FnOnce() -> R + Send, R: Send>(cfg: thread::Builder, f: F) -> R {
 137     // SAFETY: join() is called immediately, so any closure captures are still
 138     // alive.
 139     match unsafe { cfg.spawn_unchecked(f) }.unwrap().join() {
 140         Ok(v) => v,
 141         Err(e) => panic::resume_unwind(e),
 142     }
 143 }
 144
 145 #[cfg(not(parallel_compiler))]
 146 pub fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
 147     edition: Edition,
 148     _threads: usize,
 149     f: F,
 150 ) -> R {
 151     let mut cfg = thread::Builder::new().name("rustc".to_string());
 152
 153     if let Some(size) = get_stack_size() {
 154         cfg = cfg.stack_size(size);
 155     }
 156
 157     let main_handler = move || rustc_span::create_session_globals_then(edition, f);
 158
 159     scoped_thread(cfg, main_handler)
 160 }
 161
 162 /// Creates a new thread and forwards information in thread locals to it.
 163 /// The new thread runs the deadlock handler.
 164 /// Must only be called when a deadlock is about to happen.
 165 #[cfg(parallel_compiler)]
 166 unsafe fn handle_deadlock() {
 167     let registry = rustc_rayon_core::Registry::current();
 168
 169     let context = tls::get_tlv();
 170     assert!(context != 0);
 171     rustc_data_structures::sync::assert_sync::<tls::ImplicitCtxt<'_, '_>>();
 172     let icx: &tls::ImplicitCtxt<'_, '_> = &*(context as *const tls::ImplicitCtxt<'_, '_>);
 173
 174     let session_globals = rustc_span::with_session_globals(|sg| sg as *const _);
 175     let session_globals = &*session_globals;
 176     thread::spawn(move || {
 177         tls::enter_context(icx, |_| {
 178             rustc_span::set_session_globals_then(session_globals, || {
 179                 tls::with(|tcx| QueryCtxt::from_tcx(tcx).deadlock(&registry))
 180             })
 181         });
 182     });
 183 }
 184
 185 #[cfg(parallel_compiler)]
 186 pub fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
 187     edition: Edition,
 188     threads: usize,
 189     f: F,
 190 ) -> R {
 191     let mut config = rayon::ThreadPoolBuilder::new()
 192         .thread_name(|_| "rustc".to_string())
 193         .acquire_thread_handler(jobserver::acquire_thread)
 194         .release_thread_handler(jobserver::release_thread)
 195         .num_threads(threads)
 196         .deadlock_handler(|| unsafe { handle_deadlock() });
 197
 198     if let Some(size) = get_stack_size() {
 199         config = config.stack_size(size);
 200     }
 201
 202     let with_pool = move |pool: &rayon::ThreadPool| pool.install(f);
 203
 204     rustc_span::create_session_globals_then(edition, || {
 205         rustc_span::with_session_globals(|session_globals| {
 206             // The main handler runs for each Rayon worker thread and sets up
 207             // the thread local rustc uses. `session_globals` is captured and set
 208             // on the new threads.
 209             let main_handler = move |thread: rayon::ThreadBuilder| {
 210                 rustc_span::set_session_globals_then(session_globals, || thread.run())
 211             };
 212
 213             config.build_scoped(main_handler, with_pool).unwrap()
 214         })
 215     })
 216 }
 217
 218 fn load_backend_from_dylib(path: &Path) -> MakeBackendFn {
 219     let lib = unsafe { Library::new(path) }.unwrap_or_else(|err| {
 220         let err = format!("couldn't load codegen backend {:?}: {}", path, err);
 221         early_error(ErrorOutputType::default(), &err);
 222     });
 223
 224     let backend_sym = unsafe { lib.get::<MakeBackendFn>(b"__rustc_codegen_backend") }
 225         .unwrap_or_else(|e| {
 226             let err = format!("couldn't load codegen backend: {}", e);
 227             early_error(ErrorOutputType::default(), &err);
 228         });
 229
 230     // Intentionally leak the dynamic library. We can't ever unload it
 231     // since the library can make things that will live arbitrarily long.
 232     let backend_sym = unsafe { backend_sym.into_raw() };
 233     mem::forget(lib);
 234
 235     *backend_sym
 236 }
 237
 238 /// Get the codegen backend based on the name and specified sysroot.
 239 ///
 240 /// A name of `None` indicates that the default backend should be used.
 241 pub fn get_codegen_backend(
 242     maybe_sysroot: &Option<PathBuf>,
 243     backend_name: Option<&str>,
 244 ) -> Box<dyn CodegenBackend> {
 245     static LOAD: SyncOnceCell<unsafe fn() -> Box<dyn CodegenBackend>> = SyncOnceCell::new();
 246
 247     let load = LOAD.get_or_init(|| {
 248         let default_codegen_backend = option_env!("CFG_DEFAULT_CODEGEN_BACKEND").unwrap_or("llvm");
 249
 250         match backend_name.unwrap_or(default_codegen_backend) {
 251             filename if filename.contains('.') => load_backend_from_dylib(filename.as_ref()),
 252             #[cfg(feature = "llvm")]
 253             "llvm" => rustc_codegen_llvm::LlvmCodegenBackend::new,
 254             backend_name => get_codegen_sysroot(maybe_sysroot, backend_name),
 255         }
 256     });
 257
 258     // SAFETY: In case of a builtin codegen backend this is safe. In case of an external codegen
 259     // backend we hope that the backend links against the same rustc_driver version. If this is not
 260     // the case, we get UB.
 261     unsafe { load() }
 262 }
 263
 264 // This is used for rustdoc, but it uses similar machinery to codegen backend
 265 // loading, so we leave the code here. It is potentially useful for other tools
 266 // that want to invoke the rustc binary while linking to rustc as well.
 267 pub fn rustc_path<'a>() -> Option<&'a Path> {
 268     static RUSTC_PATH: SyncOnceCell<Option<PathBuf>> = SyncOnceCell::new();
 269
 270     const BIN_PATH: &str = env!("RUSTC_INSTALL_BINDIR");
 271
 272     RUSTC_PATH.get_or_init(|| get_rustc_path_inner(BIN_PATH)).as_ref().map(|v| &**v)
 273 }
 274
 275 fn get_rustc_path_inner(bin_path: &str) -> Option<PathBuf> {
 276     sysroot_candidates().iter().find_map(|sysroot| {
 277         let candidate = sysroot.join(bin_path).join(if cfg!(target_os = "windows") {
 278             "rustc.exe"
 279         } else {
 280             "rustc"
 281         });
 282         candidate.exists().then_some(candidate)
 283     })
 284 }
 285
 286 fn sysroot_candidates() -> Vec<PathBuf> {
 287     let target = session::config::host_triple();
 288     let mut sysroot_candidates = vec![filesearch::get_or_default_sysroot()];
 289     let path = current_dll_path().and_then(|s| s.canonicalize().ok());
 290     if let Some(dll) = path {
 291         // use `parent` twice to chop off the file name and then also the
 292         // directory containing the dll which should be either `lib` or `bin`.
 293         if let Some(path) = dll.parent().and_then(|p| p.parent()) {
 294             // The original `path` pointed at the `rustc_driver` crate's dll.
 295             // Now that dll should only be in one of two locations. The first is
 296             // in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
 297             // other is the target's libdir, for example
 298             // `$sysroot/lib/rustlib/$target/lib/*.dll`.
 299             //
 300             // We don't know which, so let's assume that if our `path` above
 301             // ends in `$target` we *could* be in the target libdir, and always
 302             // assume that we may be in the main libdir.
 303             sysroot_candidates.push(path.to_owned());
 304
 305             if path.ends_with(target) {
 306                 sysroot_candidates.extend(
 307                     path.parent() // chop off `$target`
 308                         .and_then(|p| p.parent()) // chop off `rustlib`
 309                         .and_then(|p| p.parent()) // chop off `lib`
 310                         .map(|s| s.to_owned()),
 311                 );
 312             }
 313         }
 314     }
 315
 316     return sysroot_candidates;
 317
 318     #[cfg(unix)]
 319     fn current_dll_path() -> Option<PathBuf> {
 320         use std::ffi::{CStr, OsStr};
 321         use std::os::unix::prelude::*;
 322
 323         unsafe {
 324             let addr = current_dll_path as usize as *mut _;
 325             let mut info = mem::zeroed();
 326             if libc::dladdr(addr, &mut info) == 0 {
 327                 info!("dladdr failed");
 328                 return None;
 329             }
 330             if info.dli_fname.is_null() {
 331                 info!("dladdr returned null pointer");
 332                 return None;
 333             }
 334             let bytes = CStr::from_ptr(info.dli_fname).to_bytes();
 335             let os = OsStr::from_bytes(bytes);
 336             Some(PathBuf::from(os))
 337         }
 338     }
 339
 340     #[cfg(windows)]
 341     fn current_dll_path() -> Option<PathBuf> {
 342         use std::ffi::OsString;
 343         use std::io;
 344         use std::os::windows::prelude::*;
 345         use std::ptr;
 346
 347         use winapi::um::libloaderapi::{
 348             GetModuleFileNameW, GetModuleHandleExW, GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
 349         };
 350
 351         unsafe {
 352             let mut module = ptr::null_mut();
 353             let r = GetModuleHandleExW(
 354                 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
 355                 current_dll_path as usize as *mut _,
 356                 &mut module,
 357             );
 358             if r == 0 {
 359                 info!("GetModuleHandleExW failed: {}", io::Error::last_os_error());
 360                 return None;
 361             }
 362             let mut space = Vec::with_capacity(1024);
 363             let r = GetModuleFileNameW(module, space.as_mut_ptr(), space.capacity() as u32);
 364             if r == 0 {
 365                 info!("GetModuleFileNameW failed: {}", io::Error::last_os_error());
 366                 return None;
 367             }
 368             let r = r as usize;
 369             if r >= space.capacity() {
 370                 info!("our buffer was too small? {}", io::Error::last_os_error());
 371                 return None;
 372             }
 373             space.set_len(r);
 374             let os = OsString::from_wide(&space);
 375             Some(PathBuf::from(os))
 376         }
 377     }
 378 }
 379
 380 fn get_codegen_sysroot(maybe_sysroot: &Option<PathBuf>, backend_name: &str) -> MakeBackendFn {
 381     // For now we only allow this function to be called once as it'll dlopen a
 382     // few things, which seems to work best if we only do that once. In
 383     // general this assertion never trips due to the once guard in `get_codegen_backend`,
 384     // but there's a few manual calls to this function in this file we protect
 385     // against.
 386     static LOADED: AtomicBool = AtomicBool::new(false);
 387     assert!(
 388         !LOADED.fetch_or(true, Ordering::SeqCst),
 389         "cannot load the default codegen backend twice"
 390     );
 391
 392     let target = session::config::host_triple();
 393     let sysroot_candidates = sysroot_candidates();
 394
 395     let sysroot = maybe_sysroot
 396         .iter()
 397         .chain(sysroot_candidates.iter())
 398         .map(|sysroot| {
 399             filesearch::make_target_lib_path(sysroot, target).with_file_name("codegen-backends")
 400         })
 401         .find(|f| {
 402             info!("codegen backend candidate: {}", f.display());
 403             f.exists()
 404         });
 405     let sysroot = sysroot.unwrap_or_else(|| {
 406         let candidates = sysroot_candidates
 407             .iter()
 408             .map(|p| p.display().to_string())
 409             .collect::<Vec<_>>()
 410             .join("\n* ");
 411         let err = format!(
 412             "failed to find a `codegen-backends` folder \
 413                            in the sysroot candidates:\n* {}",
 414             candidates
 415         );
 416         early_error(ErrorOutputType::default(), &err);
 417     });
 418     info!("probing {} for a codegen backend", sysroot.display());
 419
 420     let d = sysroot.read_dir().unwrap_or_else(|e| {
 421         let err = format!(
 422             "failed to load default codegen backend, couldn't \
 423                            read `{}`: {}",
 424             sysroot.display(),
 425             e
 426         );
 427         early_error(ErrorOutputType::default(), &err);
 428     });
 429
 430     let mut file: Option<PathBuf> = None;
 431
 432     let expected_names = &[
 433         format!("rustc_codegen_{}-{}", backend_name, release_str().expect("CFG_RELEASE")),
 434         format!("rustc_codegen_{}", backend_name),
 435     ];
 436     for entry in d.filter_map(|e| e.ok()) {
 437         let path = entry.path();
 438         let Some(filename) = path.file_name().and_then(|s| s.to_str()) else { continue };
 439         if !(filename.starts_with(DLL_PREFIX) && filename.ends_with(DLL_SUFFIX)) {
 440             continue;
 441         }
 442         let name = &filename[DLL_PREFIX.len()..filename.len() - DLL_SUFFIX.len()];
 443         if !expected_names.iter().any(|expected| expected == name) {
 444             continue;
 445         }
 446         if let Some(ref prev) = file {
 447             let err = format!(
 448                 "duplicate codegen backends found\n\
 449                                first:  {}\n\
 450                                second: {}\n\
 451             ",
 452                 prev.display(),
 453                 path.display()
 454             );
 455             early_error(ErrorOutputType::default(), &err);
 456         }
 457         file = Some(path.clone());
 458     }
 459
 460     match file {
 461         Some(ref s) => load_backend_from_dylib(s),
 462         None => {
 463             let err = format!("unsupported builtin codegen backend `{}`", backend_name);
 464             early_error(ErrorOutputType::default(), &err);
 465         }
 466     }
 467 }
 468
 469 pub(crate) fn check_attr_crate_type(
 470     sess: &Session,
 471     attrs: &[ast::Attribute],
 472     lint_buffer: &mut LintBuffer,
 473 ) {
 474     // Unconditionally collect crate types from attributes to make them used
 475     for a in attrs.iter() {
 476         if a.has_name(sym::crate_type) {
 477             if let Some(n) = a.value_str() {
 478                 if categorize_crate_type(n).is_some() {
 479                     return;
 480                 }
 481
 482                 if let ast::MetaItemKind::NameValue(spanned) = a.meta_kind().unwrap() {
 483                     let span = spanned.span;
 484                     let lev_candidate = find_best_match_for_name(
 485                         &CRATE_TYPES.iter().map(|(k, _)| *k).collect::<Vec<_>>(),
 486                         n,
 487                         None,
 488                     );
 489                     if let Some(candidate) = lev_candidate {
 490                         lint_buffer.buffer_lint_with_diagnostic(
 491                             lint::builtin::UNKNOWN_CRATE_TYPES,
 492                             ast::CRATE_NODE_ID,
 493                             span,
 494                             "invalid `crate_type` value",
 495                             BuiltinLintDiagnostics::UnknownCrateTypes(
 496                                 span,
 497                                 "did you mean".to_string(),
 498                                 format!("\"{}\"", candidate),
 499                             ),
 500                         );
 501                     } else {
 502                         lint_buffer.buffer_lint(
 503                             lint::builtin::UNKNOWN_CRATE_TYPES,
 504                             ast::CRATE_NODE_ID,
 505                             span,
 506                             "invalid `crate_type` value",
 507                         );
 508                     }
 509                 }
 510             } else {
 511                 // This is here mainly to check for using a macro, such as
 512                 // #![crate_type = foo!()]. That is not supported since the
 513                 // crate type needs to be known very early in compilation long
 514                 // before expansion. Otherwise, validation would normally be
 515                 // caught in AstValidator (via `check_builtin_attribute`), but
 516                 // by the time that runs the macro is expanded, and it doesn't
 517                 // give an error.
 518                 validate_attr::emit_fatal_malformed_builtin_attribute(
 519                     &sess.parse_sess,
 520                     a,
 521                     sym::crate_type,
 522                 );
 523             }
 524         }
 525     }
 526 }
 527
 528 const CRATE_TYPES: &[(Symbol, CrateType)] = &[
 529     (sym::rlib, CrateType::Rlib),
 530     (sym::dylib, CrateType::Dylib),
 531     (sym::cdylib, CrateType::Cdylib),
 532     (sym::lib, config::default_lib_output()),
 533     (sym::staticlib, CrateType::Staticlib),
 534     (sym::proc_dash_macro, CrateType::ProcMacro),
 535     (sym::bin, CrateType::Executable),
 536 ];
 537
 538 fn categorize_crate_type(s: Symbol) -> Option<CrateType> {
 539     Some(CRATE_TYPES.iter().find(|(key, _)| *key == s)?.1)
 540 }
 541
 542 pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<CrateType> {
 543     // Unconditionally collect crate types from attributes to make them used
 544     let attr_types: Vec<CrateType> = attrs
 545         .iter()
 546         .filter_map(|a| {
 547             if a.has_name(sym::crate_type) {
 548                 match a.value_str() {
 549                     Some(s) => categorize_crate_type(s),
 550                     _ => None,
 551                 }
 552             } else {
 553                 None
 554             }
 555         })
 556         .collect();
 557
 558     // If we're generating a test executable, then ignore all other output
 559     // styles at all other locations
 560     if session.opts.test {
 561         return vec![CrateType::Executable];
 562     }
 563
 564     // Only check command line flags if present. If no types are specified by
 565     // command line, then reuse the empty `base` Vec to hold the types that
 566     // will be found in crate attributes.
 567     let mut base = session.opts.crate_types.clone();
 568     if base.is_empty() {
 569         base.extend(attr_types);
 570         if base.is_empty() {
 571             base.push(output::default_output_for_target(session));
 572         } else {
 573             base.sort();
 574             base.dedup();
 575         }
 576     }
 577
 578     base.retain(|crate_type| {
 579         let res = !output::invalid_output_for_target(session, *crate_type);
 580
 581         if !res {
 582             session.warn(&format!(
 583                 "dropping unsupported crate type `{}` for target `{}`",
 584                 *crate_type, session.opts.target_triple
 585             ));
 586         }
 587
 588         res
 589     });
 590
 591     base
 592 }
 593
 594 pub fn build_output_filenames(
 595     input: &Input,
 596     odir: &Option<PathBuf>,
 597     ofile: &Option<PathBuf>,
 598     temps_dir: &Option<PathBuf>,
 599     attrs: &[ast::Attribute],
 600     sess: &Session,
 601 ) -> OutputFilenames {
 602     match *ofile {
 603         None => {
 604             // "-" as input file will cause the parser to read from stdin so we
 605             // have to make up a name
 606             // We want to toss everything after the final '.'
 607             let dirpath = (*odir).as_ref().cloned().unwrap_or_default();
 608
 609             // If a crate name is present, we use it as the link name
 610             let stem = sess
 611                 .opts
 612                 .crate_name
 613                 .clone()
 614                 .or_else(|| rustc_attr::find_crate_name(sess, attrs).map(|n| n.to_string()))
 615                 .unwrap_or_else(|| input.filestem().to_owned());
 616
 617             OutputFilenames::new(
 618                 dirpath,
 619                 stem,
 620                 None,
 621                 temps_dir.clone(),
 622                 sess.opts.cg.extra_filename.clone(),
 623                 sess.opts.output_types.clone(),
 624             )
 625         }
 626
 627         Some(ref out_file) => {
 628             let unnamed_output_types =
 629                 sess.opts.output_types.values().filter(|a| a.is_none()).count();
 630             let ofile = if unnamed_output_types > 1 {
 631                 sess.warn(
 632                     "due to multiple output types requested, the explicitly specified \
 633                      output file name will be adapted for each output type",
 634                 );
 635                 None
 636             } else {
 637                 if !sess.opts.cg.extra_filename.is_empty() {
 638                     sess.warn("ignoring -C extra-filename flag due to -o flag");
 639                 }
 640                 Some(out_file.clone())
 641             };
 642             if *odir != None {
 643                 sess.warn("ignoring --out-dir flag due to -o flag");
 644             }
 645
 646             OutputFilenames::new(
 647                 out_file.parent().unwrap_or_else(|| Path::new("")).to_path_buf(),
 648                 out_file.file_stem().unwrap_or_default().to_str().unwrap().to_string(),
 649                 ofile,
 650                 temps_dir.clone(),
 651                 sess.opts.cg.extra_filename.clone(),
 652                 sess.opts.output_types.clone(),
 653             )
 654         }
 655     }
 656 }
 657
 658 #[cfg(not(target_os = "linux"))]
 659 pub fn non_durable_rename(src: &Path, dst: &Path) -> std::io::Result<()> {
 660     std::fs::rename(src, dst)
 661 }
 662
 663 /// This function attempts to bypass the auto_da_alloc heuristic implemented by some filesystems
 664 /// such as btrfs and ext4. When renaming over a file that already exists then they will "helpfully"
 665 /// write back the source file before committing the rename in case a developer forgot some of
 666 /// the fsyncs in the open/write/fsync(file)/rename/fsync(dir) dance for atomic file updates.
 667 ///
 668 /// To avoid triggering this heuristic we delete the destination first, if it exists.
 669 /// The cost of an extra syscall is much lower than getting descheduled for the sync IO.
 670 #[cfg(target_os = "linux")]
 671 pub fn non_durable_rename(src: &Path, dst: &Path) -> std::io::Result<()> {
 672     let _ = std::fs::remove_file(dst);
 673     std::fs::rename(src, dst)
 674 }
 675
 676 /// Returns a version string such as "1.46.0 (04488afe3 2020-08-24)"
 677 pub fn version_str() -> Option<&'static str> {
 678     option_env!("CFG_VERSION")
 679 }
 680
 681 /// Returns a version string such as "0.12.0-dev".
 682 pub fn release_str() -> Option<&'static str> {
 683     option_env!("CFG_RELEASE")
 684 }
 685
 686 /// Returns the full SHA1 hash of HEAD of the Git repo from which rustc was built.
 687 pub fn commit_hash_str() -> Option<&'static str> {
 688     option_env!("CFG_VER_HASH")
 689 }
 690
 691 /// Returns the "commit date" of HEAD of the Git repo from which rustc was built as a static string.
 692 pub fn commit_date_str() -> Option<&'static str> {
 693     option_env!("CFG_VER_DATE")
 694 }