Auto merge of #148624 - jhpratt:rollup-is5je9r, r=jhpratt

Rollup of 12 pull requests

Successful merges:

 - #145768 (Offload device)
 - #145992 (Stabilize `vec_deque_pop_if`)
 - #147416 (Early return if span is from expansion so we dont get empty span and ice later on)
 - #147808 (btree: cleanup difference, intersection, is_subset)
 - #148520 (style: Use binary literals instead of hex literals in doctests for `highest_one` and `lowest_one`)
 - #148559 (Add typo suggestion for a misspelt Cargo environment variable)
 - #148567 (Fix incorrect precedence caused by range expression)
 - #148570 (Fix mismatched brackets in generated .dir-locals.el)
 - #148575 (fix dev guide link in rustc_query_system/dep_graph/README.md)
 - #148578 (core docs: add notes about availability of `Atomic*::from_mut_slice`)
 - #148603 (Backport 1.91.1 relnotes to main)
 - #148609 (Sync str::rsplit_once example with str::split_once)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

RELEASES.md

@@ -1,3 +1,11 @@
+Version 1.91.1 (2025-11-10)
+===========================
+
+<a id="1.91.1"></a>
+
+- [Enable file locking support in illumos](https://github.com/rust-lang/rust/pull/148322). This fixes Cargo not locking the build directory on illumos.
+- [Fix `wasm_import_module` attribute cross-crate](https://github.com/rust-lang/rust/pull/148363). This fixes linker errors on WASM targets.
+
 Version 1.91.0 (2025-10-30)
 ==========================
 

compiler/rustc_builtin_macros/messages.ftl

@@ -156,6 +156,7 @@ builtin_macros_duplicate_macro_attribute = duplicated attribute
 
 builtin_macros_env_not_defined = environment variable `{$var}` not defined at compile time
     .cargo = Cargo sets build script variables at run time. Use `std::env::var({$var_expr})` instead
+    .cargo_typo = there is a similar Cargo environment variable: `{$suggested_var}`
     .custom = use `std::env::var({$var_expr})` to read the variable at run time
 
 builtin_macros_env_not_unicode = environment variable `{$var}` is not a valid Unicode string

compiler/rustc_builtin_macros/src/env.rs

@@ -10,6 +10,7 @@ use rustc_ast::token::{self, LitKind};
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{ExprKind, GenericArg, Mutability};
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
+use rustc_span::edit_distance::edit_distance;
 use rustc_span::{Ident, Span, Symbol, kw, sym};
 use thin_vec::thin_vec;
 
@@ -144,6 +145,12 @@ pub(crate) fn expand_env<'cx>(
                     if let Some(msg_from_user) = custom_msg {
                         cx.dcx()
                             .emit_err(errors::EnvNotDefinedWithUserMessage { span, msg_from_user })
+                    } else if let Some(suggested_var) = find_similar_cargo_var(var.as_str()) {
+                        cx.dcx().emit_err(errors::EnvNotDefined::CargoEnvVarTypo {
+                            span,
+                            var: *symbol,
+                            suggested_var: Symbol::intern(suggested_var),
+                        })
                     } else if is_cargo_env_var(var.as_str()) {
                         cx.dcx().emit_err(errors::EnvNotDefined::CargoEnvVar {
                             span,
@@ -176,3 +183,49 @@ fn is_cargo_env_var(var: &str) -> bool {
         || var.starts_with("DEP_")
         || matches!(var, "OUT_DIR" | "OPT_LEVEL" | "PROFILE" | "HOST" | "TARGET")
 }
+
+const KNOWN_CARGO_VARS: &[&str] = &[
+    // List of known Cargo environment variables that are set for crates (not build scripts, OUT_DIR etc).
+    // See: https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates
+    "CARGO_PKG_VERSION",
+    "CARGO_PKG_VERSION_MAJOR",
+    "CARGO_PKG_VERSION_MINOR",
+    "CARGO_PKG_VERSION_PATCH",
+    "CARGO_PKG_VERSION_PRE",
+    "CARGO_PKG_AUTHORS",
+    "CARGO_PKG_NAME",
+    "CARGO_PKG_DESCRIPTION",
+    "CARGO_PKG_HOMEPAGE",
+    "CARGO_PKG_REPOSITORY",
+    "CARGO_PKG_LICENSE",
+    "CARGO_PKG_LICENSE_FILE",
+    "CARGO_PKG_RUST_VERSION",
+    "CARGO_PKG_README",
+    "CARGO_MANIFEST_DIR",
+    "CARGO_MANIFEST_PATH",
+    "CARGO_CRATE_NAME",
+    "CARGO_BIN_NAME",
+    "CARGO_PRIMARY_PACKAGE",
+];
+
+fn find_similar_cargo_var(var: &str) -> Option<&'static str> {
+    if !var.starts_with("CARGO_") {
+        return None;
+    }
+
+    let lookup_len = var.chars().count();
+    let max_dist = std::cmp::max(lookup_len, 3) / 3;
+    let mut best_match = None;
+    let mut best_distance = usize::MAX;
+
+    for &known_var in KNOWN_CARGO_VARS {
+        if let Some(distance) = edit_distance(var, known_var, max_dist) {
+            if distance < best_distance {
+                best_distance = distance;
+                best_match = Some(known_var);
+            }
+        }
+    }
+
+    best_match
+}

compiler/rustc_builtin_macros/src/errors.rs

@@ -535,6 +535,14 @@ pub(crate) enum EnvNotDefined<'a> {
         var_expr: &'a rustc_ast::Expr,
     },
     #[diag(builtin_macros_env_not_defined)]
+    #[help(builtin_macros_cargo_typo)]
+    CargoEnvVarTypo {
+        #[primary_span]
+        span: Span,
+        var: Symbol,
+        suggested_var: Symbol,
+    },
+    #[diag(builtin_macros_env_not_defined)]
     #[help(builtin_macros_custom)]
     CustomEnvVar {
         #[primary_span]

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -616,7 +616,8 @@ pub(crate) fn run_pass_manager(
         write::llvm_optimize(cgcx, dcx, module, None, config, opt_level, opt_stage, stage);
     }
 
-    if enable_gpu && !thin {
+    // Here we only handle the GPU host (=cpu) code.
+    if enable_gpu && !thin && !cgcx.target_is_like_gpu {
         let cx =
             SimpleCx::new(module.module_llvm.llmod(), &module.module_llvm.llcx, cgcx.pointer_size);
         crate::builder::gpu_offload::handle_gpu_code(cgcx, &cx);

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -43,7 +43,7 @@ use crate::errors::{
 use crate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 use crate::llvm::{self, DiagnosticInfo};
 use crate::type_::llvm_type_ptr;
-use crate::{LlvmCodegenBackend, ModuleLlvm, base, common, llvm_util};
+use crate::{LlvmCodegenBackend, ModuleLlvm, SimpleCx, base, common, llvm_util};
 
 pub(crate) fn llvm_err<'a>(dcx: DiagCtxtHandle<'_>, err: LlvmError<'a>) -> ! {
     match llvm::last_error() {
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
         None
     };
 
+    fn handle_offload<'ll>(cx: &'ll SimpleCx<'_>, old_fn: &llvm::Value) {
+        let old_fn_ty = cx.get_type_of_global(old_fn);
+        let old_param_types = cx.func_params_types(old_fn_ty);
+        let old_param_count = old_param_types.len();
+        if old_param_count == 0 {
+            return;
+        }
+
+        let first_param = llvm::get_param(old_fn, 0);
+        let c_name = llvm::get_value_name(first_param);
+        let first_arg_name = str::from_utf8(&c_name).unwrap();
+        // We might call llvm_optimize (and thus this code) multiple times on the same IR,
+        // but we shouldn't add this helper ptr multiple times.
+        // FIXME(offload): This could break if the user calls his first argument `dyn_ptr`.
+        if first_arg_name == "dyn_ptr" {
+            return;
+        }
+
+        // Create the new parameter list, with ptr as the first argument
+        let mut new_param_types = Vec::with_capacity(old_param_count as usize + 1);
+        new_param_types.push(cx.type_ptr());
+        new_param_types.extend(old_param_types);
+
+        // Create the new function type
+        let ret_ty = unsafe { llvm::LLVMGetReturnType(old_fn_ty) };
+        let new_fn_ty = cx.type_func(&new_param_types, ret_ty);
+
+        // Create the new function, with a temporary .offload name to avoid a name collision.
+        let old_fn_name = String::from_utf8(llvm::get_value_name(old_fn)).unwrap();
+        let new_fn_name = format!("{}.offload", &old_fn_name);
+        let new_fn = cx.add_func(&new_fn_name, new_fn_ty);
+        let a0 = llvm::get_param(new_fn, 0);
+        llvm::set_value_name(a0, CString::new("dyn_ptr").unwrap().as_bytes());
+
+        // Here we map the old arguments to the new arguments, with an offset of 1 to make sure
+        // that we don't use the newly added `%dyn_ptr`.
+        unsafe {
+            llvm::LLVMRustOffloadMapper(cx.llmod(), old_fn, new_fn);
+        }
+
+        llvm::set_linkage(new_fn, llvm::get_linkage(old_fn));
+        llvm::set_visibility(new_fn, llvm::get_visibility(old_fn));
+
+        // Replace all uses of old_fn with new_fn (RAUW)
+        unsafe {
+            llvm::LLVMReplaceAllUsesWith(old_fn, new_fn);
+        }
+        let name = llvm::get_value_name(old_fn);
+        unsafe {
+            llvm::LLVMDeleteFunction(old_fn);
+        }
+        // Now we can re-use the old name, without name collision.
+        llvm::set_value_name(new_fn, &name);
+    }
+
+    if cgcx.target_is_like_gpu && config.offload.contains(&config::Offload::Enable) {
+        let cx =
+            SimpleCx::new(module.module_llvm.llmod(), module.module_llvm.llcx, cgcx.pointer_size);
+        // For now we only support up to 10 kernels named kernel_0 ... kernel_9, a follow-up PR is
+        // introducing a proper offload intrinsic to solve this limitation.
+        for num in 0..9 {
+            let name = format!("kernel_{num}");
+            if let Some(kernel) = cx.get_function(&name) {
+                handle_offload(&cx, kernel);
+            }
+        }
+    }
+
     let mut llvm_profiler = cgcx
         .prof
         .llvm_recording_enabled()

compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs

@@ -19,6 +19,9 @@ pub(crate) fn handle_gpu_code<'ll>(
     let mut memtransfer_types = vec![];
     let mut region_ids = vec![];
     let offload_entry_ty = TgtOffloadEntry::new_decl(&cx);
+    // This is a temporary hack, we only search for kernel_0 to kernel_9 functions.
+    // There is a draft PR in progress which will introduce a proper offload intrinsic to remove
+    // this limitation.
     for num in 0..9 {
         let kernel = cx.get_function(&format!("kernel_{num}"));
         if let Some(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
     // Operations on functions
     pub(crate) fn LLVMSetFunctionCallConv(Fn: &Value, CC: c_uint);
+    pub(crate) fn LLVMAddFunction<'a>(
+        Mod: &'a Module,
+        Name: *const c_char,
+        FunctionTy: &'a Type,
+    ) -> &'a Value;
     pub(crate) fn LLVMDeleteFunction(Fn: &Value);
 
     // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
     ) -> &Attribute;
 
     // Operations on functions
+    pub(crate) fn LLVMRustOffloadMapper<'a>(M: &'a Module, Fn: &'a Value, Fn: &'a Value);
     pub(crate) fn LLVMRustGetOrInsertFunction<'a>(
         M: &'a Module,
         Name: *const c_char,

compiler/rustc_codegen_llvm/src/type_.rs

@@ -68,6 +68,11 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         unsafe { llvm::LLVMVectorType(ty, len as c_uint) }
     }
 
+    pub(crate) fn add_func(&self, name: &str, ty: &'ll Type) -> &'ll Value {
+        let name = SmallCStr::new(name);
+        unsafe { llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty) }
+    }
+
     pub(crate) fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type> {
         unsafe {
             let n_args = llvm::LLVMCountParamTypes(ty) as usize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
     pub target_arch: String,
     pub target_is_like_darwin: bool,
     pub target_is_like_aix: bool,
+    pub target_is_like_gpu: bool,
     pub split_debuginfo: rustc_target::spec::SplitDebuginfo,
     pub split_dwarf_kind: rustc_session::config::SplitDwarfKind,
     pub pointer_size: Size,
@@ -1309,6 +1310,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         target_arch: tcx.sess.target.arch.to_string(),
         target_is_like_darwin: tcx.sess.target.is_like_darwin,
         target_is_like_aix: tcx.sess.target.is_like_aix,
+        target_is_like_gpu: tcx.sess.target.is_like_gpu,
         split_debuginfo: tcx.sess.split_debuginfo(),
         split_dwarf_kind: tcx.sess.opts.unstable_opts.split_dwarf_kind,
         parallel: backend.supports_parallel() && !sess.opts.unstable_opts.no_parallel_backend,