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>(
 ifletSome(msg_from_user) = custom_msg {
  cx.dcx()
 .emit_err(errors::EnvNotDefinedWithUserMessage{ span, msg_from_user })
+}elseifletSome(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),
+})
 }elseifis_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")
 }
+
+constKNOWN_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",
+];
+
+fnfind_similar_cargo_var(var:&str) -> Option<&'staticstr>{
+if !var.starts_with("CARGO_"){
+returnNone;
+}
+
+let lookup_len = var.chars().count();
+let max_dist = std::cmp::max(lookup_len,3) / 3;
+letmut best_match = None;
+letmut best_distance = usize::MAX;
+
+for&known_var inKNOWN_CARGO_VARS{
+ifletSome(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::{
 usecrate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 usecrate::llvm::{self,DiagnosticInfo};
 usecrate::type_::llvm_type_ptr;
-usecrate::{LlvmCodegenBackend,ModuleLlvm, base, common, llvm_util};
+usecrate::{LlvmCodegenBackend,ModuleLlvm,SimpleCx,base, common, llvm_util};
 
 pub(crate)fnllvm_err<'a>(dcx:DiagCtxtHandle<'_>,err:LlvmError<'a>) -> ! {
 match llvm::last_error(){
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
 None
 };
 
+fnhandle_offload<'ll>(cx:&'llSimpleCx<'_>,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
+letmut new_param_types = Vec::with_capacity(old_param_count asusize + 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 in0..9{
+let name = format!("kernel_{num}");
+ifletSome(kernel) = cx.get_function(&name){
+handle_offload(&cx, kernel);
+}
+}
+}
+
 letmut 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>(
 letmut memtransfer_types = vec![];
 letmut 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 in0..9{
 let kernel = cx.get_function(&format!("kernel_{num}"));
 ifletSome(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
 // Operations on functions
 pub(crate)fnLLVMSetFunctionCallConv(Fn:&Value,CC:c_uint);
+pub(crate)fnLLVMAddFunction<'a>(
+Mod:&'aModule,
+Name:*constc_char,
+FunctionTy:&'aType,
+) -> &'aValue;
 pub(crate)fnLLVMDeleteFunction(Fn:&Value);
 
 // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
 ) -> &Attribute;
 
 // Operations on functions
+pub(crate)fnLLVMRustOffloadMapper<'a>(M:&'aModule,Fn:&'aValue,Fn:&'aValue);
 pub(crate)fnLLVMRustGetOrInsertFunction<'a>(
 M:&'aModule,
 Name:*constc_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 asc_uint)}
 }
 
+pub(crate)fnadd_func(&self,name:&str,ty:&'llType) -> &'llValue{
+let name = SmallCStr::new(name);
+unsafe{ llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty)}
+}
+
 pub(crate)fnfunc_params_types(&self,ty:&'llType) -> Vec<&'llType>{
 unsafe{
 let n_args = llvm::LLVMCountParamTypes(ty)asusize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
 pubtarget_arch:String,
 pubtarget_is_like_darwin:bool,
 pubtarget_is_like_aix:bool,
+pubtarget_is_like_gpu:bool,
 pubsplit_debuginfo: rustc_target::spec::SplitDebuginfo,
 pubsplit_dwarf_kind: rustc_session::config::SplitDwarfKind,
 pubpointer_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,

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>(
 ifletSome(msg_from_user) = custom_msg {
  cx.dcx()
 .emit_err(errors::EnvNotDefinedWithUserMessage{ span, msg_from_user })
+}elseifletSome(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),
+})
 }elseifis_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")
 }
+
+constKNOWN_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",
+];
+
+fnfind_similar_cargo_var(var:&str) -> Option<&'staticstr>{
+if !var.starts_with("CARGO_"){
+returnNone;
+}
+
+let lookup_len = var.chars().count();
+let max_dist = std::cmp::max(lookup_len,3) / 3;
+letmut best_match = None;
+letmut best_distance = usize::MAX;
+
+for&known_var inKNOWN_CARGO_VARS{
+ifletSome(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::{
 usecrate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 usecrate::llvm::{self,DiagnosticInfo};
 usecrate::type_::llvm_type_ptr;
-usecrate::{LlvmCodegenBackend,ModuleLlvm, base, common, llvm_util};
+usecrate::{LlvmCodegenBackend,ModuleLlvm,SimpleCx,base, common, llvm_util};
 
 pub(crate)fnllvm_err<'a>(dcx:DiagCtxtHandle<'_>,err:LlvmError<'a>) -> ! {
 match llvm::last_error(){
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
 None
 };
 
+fnhandle_offload<'ll>(cx:&'llSimpleCx<'_>,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
+letmut new_param_types = Vec::with_capacity(old_param_count asusize + 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 in0..9{
+let name = format!("kernel_{num}");
+ifletSome(kernel) = cx.get_function(&name){
+handle_offload(&cx, kernel);
+}
+}
+}
+
 letmut 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>(
 letmut memtransfer_types = vec![];
 letmut 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 in0..9{
 let kernel = cx.get_function(&format!("kernel_{num}"));
 ifletSome(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
 // Operations on functions
 pub(crate)fnLLVMSetFunctionCallConv(Fn:&Value,CC:c_uint);
+pub(crate)fnLLVMAddFunction<'a>(
+Mod:&'aModule,
+Name:*constc_char,
+FunctionTy:&'aType,
+) -> &'aValue;
 pub(crate)fnLLVMDeleteFunction(Fn:&Value);
 
 // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
 ) -> &Attribute;
 
 // Operations on functions
+pub(crate)fnLLVMRustOffloadMapper<'a>(M:&'aModule,Fn:&'aValue,Fn:&'aValue);
 pub(crate)fnLLVMRustGetOrInsertFunction<'a>(
 M:&'aModule,
 Name:*constc_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 asc_uint)}
 }
 
+pub(crate)fnadd_func(&self,name:&str,ty:&'llType) -> &'llValue{
+let name = SmallCStr::new(name);
+unsafe{ llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty)}
+}
+
 pub(crate)fnfunc_params_types(&self,ty:&'llType) -> Vec<&'llType>{
 unsafe{
 let n_args = llvm::LLVMCountParamTypes(ty)asusize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
 pubtarget_arch:String,
 pubtarget_is_like_darwin:bool,
 pubtarget_is_like_aix:bool,
+pubtarget_is_like_gpu:bool,
 pubsplit_debuginfo: rustc_target::spec::SplitDebuginfo,
 pubsplit_dwarf_kind: rustc_session::config::SplitDwarfKind,
 pubpointer_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,

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>(
 ifletSome(msg_from_user) = custom_msg {
  cx.dcx()
 .emit_err(errors::EnvNotDefinedWithUserMessage{ span, msg_from_user })
+}elseifletSome(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),
+})
 }elseifis_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")
 }
+
+constKNOWN_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",
+];
+
+fnfind_similar_cargo_var(var:&str) -> Option<&'staticstr>{
+if !var.starts_with("CARGO_"){
+returnNone;
+}
+
+let lookup_len = var.chars().count();
+let max_dist = std::cmp::max(lookup_len,3) / 3;
+letmut best_match = None;
+letmut best_distance = usize::MAX;
+
+for&known_var inKNOWN_CARGO_VARS{
+ifletSome(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::{
 usecrate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 usecrate::llvm::{self,DiagnosticInfo};
 usecrate::type_::llvm_type_ptr;
-usecrate::{LlvmCodegenBackend,ModuleLlvm, base, common, llvm_util};
+usecrate::{LlvmCodegenBackend,ModuleLlvm,SimpleCx,base, common, llvm_util};
 
 pub(crate)fnllvm_err<'a>(dcx:DiagCtxtHandle<'_>,err:LlvmError<'a>) -> ! {
 match llvm::last_error(){
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
 None
 };
 
+fnhandle_offload<'ll>(cx:&'llSimpleCx<'_>,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
+letmut new_param_types = Vec::with_capacity(old_param_count asusize + 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 in0..9{
+let name = format!("kernel_{num}");
+ifletSome(kernel) = cx.get_function(&name){
+handle_offload(&cx, kernel);
+}
+}
+}
+
 letmut 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>(
 letmut memtransfer_types = vec![];
 letmut 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 in0..9{
 let kernel = cx.get_function(&format!("kernel_{num}"));
 ifletSome(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
 // Operations on functions
 pub(crate)fnLLVMSetFunctionCallConv(Fn:&Value,CC:c_uint);
+pub(crate)fnLLVMAddFunction<'a>(
+Mod:&'aModule,
+Name:*constc_char,
+FunctionTy:&'aType,
+) -> &'aValue;
 pub(crate)fnLLVMDeleteFunction(Fn:&Value);
 
 // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
 ) -> &Attribute;
 
 // Operations on functions
+pub(crate)fnLLVMRustOffloadMapper<'a>(M:&'aModule,Fn:&'aValue,Fn:&'aValue);
 pub(crate)fnLLVMRustGetOrInsertFunction<'a>(
 M:&'aModule,
 Name:*constc_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 asc_uint)}
 }
 
+pub(crate)fnadd_func(&self,name:&str,ty:&'llType) -> &'llValue{
+let name = SmallCStr::new(name);
+unsafe{ llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty)}
+}
+
 pub(crate)fnfunc_params_types(&self,ty:&'llType) -> Vec<&'llType>{
 unsafe{
 let n_args = llvm::LLVMCountParamTypes(ty)asusize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
 pubtarget_arch:String,
 pubtarget_is_like_darwin:bool,
 pubtarget_is_like_aix:bool,
+pubtarget_is_like_gpu:bool,
 pubsplit_debuginfo: rustc_target::spec::SplitDebuginfo,
 pubsplit_dwarf_kind: rustc_session::config::SplitDwarfKind,
 pubpointer_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,

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>(
 ifletSome(msg_from_user) = custom_msg {
  cx.dcx()
 .emit_err(errors::EnvNotDefinedWithUserMessage{ span, msg_from_user })
+}elseifletSome(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),
+})
 }elseifis_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")
 }
+
+constKNOWN_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",
+];
+
+fnfind_similar_cargo_var(var:&str) -> Option<&'staticstr>{
+if !var.starts_with("CARGO_"){
+returnNone;
+}
+
+let lookup_len = var.chars().count();
+let max_dist = std::cmp::max(lookup_len,3) / 3;
+letmut best_match = None;
+letmut best_distance = usize::MAX;
+
+for&known_var inKNOWN_CARGO_VARS{
+ifletSome(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::{
 usecrate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 usecrate::llvm::{self,DiagnosticInfo};
 usecrate::type_::llvm_type_ptr;
-usecrate::{LlvmCodegenBackend,ModuleLlvm, base, common, llvm_util};
+usecrate::{LlvmCodegenBackend,ModuleLlvm,SimpleCx,base, common, llvm_util};
 
 pub(crate)fnllvm_err<'a>(dcx:DiagCtxtHandle<'_>,err:LlvmError<'a>) -> ! {
 match llvm::last_error(){
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
 None
 };
 
+fnhandle_offload<'ll>(cx:&'llSimpleCx<'_>,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
+letmut new_param_types = Vec::with_capacity(old_param_count asusize + 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 in0..9{
+let name = format!("kernel_{num}");
+ifletSome(kernel) = cx.get_function(&name){
+handle_offload(&cx, kernel);
+}
+}
+}
+
 letmut 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>(
 letmut memtransfer_types = vec![];
 letmut 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 in0..9{
 let kernel = cx.get_function(&format!("kernel_{num}"));
 ifletSome(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
 // Operations on functions
 pub(crate)fnLLVMSetFunctionCallConv(Fn:&Value,CC:c_uint);
+pub(crate)fnLLVMAddFunction<'a>(
+Mod:&'aModule,
+Name:*constc_char,
+FunctionTy:&'aType,
+) -> &'aValue;
 pub(crate)fnLLVMDeleteFunction(Fn:&Value);
 
 // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
 ) -> &Attribute;
 
 // Operations on functions
+pub(crate)fnLLVMRustOffloadMapper<'a>(M:&'aModule,Fn:&'aValue,Fn:&'aValue);
 pub(crate)fnLLVMRustGetOrInsertFunction<'a>(
 M:&'aModule,
 Name:*constc_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 asc_uint)}
 }
 
+pub(crate)fnadd_func(&self,name:&str,ty:&'llType) -> &'llValue{
+let name = SmallCStr::new(name);
+unsafe{ llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty)}
+}
+
 pub(crate)fnfunc_params_types(&self,ty:&'llType) -> Vec<&'llType>{
 unsafe{
 let n_args = llvm::LLVMCountParamTypes(ty)asusize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
 pubtarget_arch:String,
 pubtarget_is_like_darwin:bool,
 pubtarget_is_like_aix:bool,
+pubtarget_is_like_gpu:bool,
 pubsplit_debuginfo: rustc_target::spec::SplitDebuginfo,
 pubsplit_dwarf_kind: rustc_session::config::SplitDwarfKind,
 pubpointer_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,

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>(
 ifletSome(msg_from_user) = custom_msg {
  cx.dcx()
 .emit_err(errors::EnvNotDefinedWithUserMessage{ span, msg_from_user })
+}elseifletSome(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),
+})
 }elseifis_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")
 }
+
+constKNOWN_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",
+];
+
+fnfind_similar_cargo_var(var:&str) -> Option<&'staticstr>{
+if !var.starts_with("CARGO_"){
+returnNone;
+}
+
+let lookup_len = var.chars().count();
+let max_dist = std::cmp::max(lookup_len,3) / 3;
+letmut best_match = None;
+letmut best_distance = usize::MAX;
+
+for&known_var inKNOWN_CARGO_VARS{
+ifletSome(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::{
 usecrate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 usecrate::llvm::{self,DiagnosticInfo};
 usecrate::type_::llvm_type_ptr;
-usecrate::{LlvmCodegenBackend,ModuleLlvm, base, common, llvm_util};
+usecrate::{LlvmCodegenBackend,ModuleLlvm,SimpleCx,base, common, llvm_util};
 
 pub(crate)fnllvm_err<'a>(dcx:DiagCtxtHandle<'_>,err:LlvmError<'a>) -> ! {
 match llvm::last_error(){
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
 None
 };
 
+fnhandle_offload<'ll>(cx:&'llSimpleCx<'_>,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
+letmut new_param_types = Vec::with_capacity(old_param_count asusize + 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 in0..9{
+let name = format!("kernel_{num}");
+ifletSome(kernel) = cx.get_function(&name){
+handle_offload(&cx, kernel);
+}
+}
+}
+
 letmut 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>(
 letmut memtransfer_types = vec![];
 letmut 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 in0..9{
 let kernel = cx.get_function(&format!("kernel_{num}"));
 ifletSome(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
 // Operations on functions
 pub(crate)fnLLVMSetFunctionCallConv(Fn:&Value,CC:c_uint);
+pub(crate)fnLLVMAddFunction<'a>(
+Mod:&'aModule,
+Name:*constc_char,
+FunctionTy:&'aType,
+) -> &'aValue;
 pub(crate)fnLLVMDeleteFunction(Fn:&Value);
 
 // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
 ) -> &Attribute;
 
 // Operations on functions
+pub(crate)fnLLVMRustOffloadMapper<'a>(M:&'aModule,Fn:&'aValue,Fn:&'aValue);
 pub(crate)fnLLVMRustGetOrInsertFunction<'a>(
 M:&'aModule,
 Name:*constc_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 asc_uint)}
 }
 
+pub(crate)fnadd_func(&self,name:&str,ty:&'llType) -> &'llValue{
+let name = SmallCStr::new(name);
+unsafe{ llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty)}
+}
+
 pub(crate)fnfunc_params_types(&self,ty:&'llType) -> Vec<&'llType>{
 unsafe{
 let n_args = llvm::LLVMCountParamTypes(ty)asusize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
 pubtarget_arch:String,
 pubtarget_is_like_darwin:bool,
 pubtarget_is_like_aix:bool,
+pubtarget_is_like_gpu:bool,
 pubsplit_debuginfo: rustc_target::spec::SplitDebuginfo,
 pubsplit_dwarf_kind: rustc_session::config::SplitDwarfKind,
 pubpointer_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,

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>(
 ifletSome(msg_from_user) = custom_msg {
  cx.dcx()
 .emit_err(errors::EnvNotDefinedWithUserMessage{ span, msg_from_user })
+}elseifletSome(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),
+})
 }elseifis_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")
 }
+
+constKNOWN_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",
+];
+
+fnfind_similar_cargo_var(var:&str) -> Option<&'staticstr>{
+if !var.starts_with("CARGO_"){
+returnNone;
+}
+
+let lookup_len = var.chars().count();
+let max_dist = std::cmp::max(lookup_len,3) / 3;
+letmut best_match = None;
+letmut best_distance = usize::MAX;
+
+for&known_var inKNOWN_CARGO_VARS{
+ifletSome(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::{
 usecrate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 usecrate::llvm::{self,DiagnosticInfo};
 usecrate::type_::llvm_type_ptr;
-usecrate::{LlvmCodegenBackend,ModuleLlvm, base, common, llvm_util};
+usecrate::{LlvmCodegenBackend,ModuleLlvm,SimpleCx,base, common, llvm_util};
 
 pub(crate)fnllvm_err<'a>(dcx:DiagCtxtHandle<'_>,err:LlvmError<'a>) -> ! {
 match llvm::last_error(){
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
 None
 };
 
+fnhandle_offload<'ll>(cx:&'llSimpleCx<'_>,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
+letmut new_param_types = Vec::with_capacity(old_param_count asusize + 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 in0..9{
+let name = format!("kernel_{num}");
+ifletSome(kernel) = cx.get_function(&name){
+handle_offload(&cx, kernel);
+}
+}
+}
+
 letmut 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>(
 letmut memtransfer_types = vec![];
 letmut 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 in0..9{
 let kernel = cx.get_function(&format!("kernel_{num}"));
 ifletSome(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
 // Operations on functions
 pub(crate)fnLLVMSetFunctionCallConv(Fn:&Value,CC:c_uint);
+pub(crate)fnLLVMAddFunction<'a>(
+Mod:&'aModule,
+Name:*constc_char,
+FunctionTy:&'aType,
+) -> &'aValue;
 pub(crate)fnLLVMDeleteFunction(Fn:&Value);
 
 // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
 ) -> &Attribute;
 
 // Operations on functions
+pub(crate)fnLLVMRustOffloadMapper<'a>(M:&'aModule,Fn:&'aValue,Fn:&'aValue);
 pub(crate)fnLLVMRustGetOrInsertFunction<'a>(
 M:&'aModule,
 Name:*constc_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 asc_uint)}
 }
 
+pub(crate)fnadd_func(&self,name:&str,ty:&'llType) -> &'llValue{
+let name = SmallCStr::new(name);
+unsafe{ llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty)}
+}
+
 pub(crate)fnfunc_params_types(&self,ty:&'llType) -> Vec<&'llType>{
 unsafe{
 let n_args = llvm::LLVMCountParamTypes(ty)asusize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
 pubtarget_arch:String,
 pubtarget_is_like_darwin:bool,
 pubtarget_is_like_aix:bool,
+pubtarget_is_like_gpu:bool,
 pubsplit_debuginfo: rustc_target::spec::SplitDebuginfo,
 pubsplit_dwarf_kind: rustc_session::config::SplitDwarfKind,
 pubpointer_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,

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>(
 ifletSome(msg_from_user) = custom_msg {
  cx.dcx()
 .emit_err(errors::EnvNotDefinedWithUserMessage{ span, msg_from_user })
+}elseifletSome(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),
+})
 }elseifis_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")
 }
+
+constKNOWN_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",
+];
+
+fnfind_similar_cargo_var(var:&str) -> Option<&'staticstr>{
+if !var.starts_with("CARGO_"){
+returnNone;
+}
+
+let lookup_len = var.chars().count();
+let max_dist = std::cmp::max(lookup_len,3) / 3;
+letmut best_match = None;
+letmut best_distance = usize::MAX;
+
+for&known_var inKNOWN_CARGO_VARS{
+ifletSome(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::{
 usecrate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 usecrate::llvm::{self,DiagnosticInfo};
 usecrate::type_::llvm_type_ptr;
-usecrate::{LlvmCodegenBackend,ModuleLlvm, base, common, llvm_util};
+usecrate::{LlvmCodegenBackend,ModuleLlvm,SimpleCx,base, common, llvm_util};
 
 pub(crate)fnllvm_err<'a>(dcx:DiagCtxtHandle<'_>,err:LlvmError<'a>) -> ! {
 match llvm::last_error(){
@@ -645,6 +645,74 @@ pub(crate) unsafe fn llvm_optimize(
 None
 };
 
+fnhandle_offload<'ll>(cx:&'llSimpleCx<'_>,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
+letmut new_param_types = Vec::with_capacity(old_param_count asusize + 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 in0..9{
+let name = format!("kernel_{num}");
+ifletSome(kernel) = cx.get_function(&name){
+handle_offload(&cx, kernel);
+}
+}
+}
+
 letmut 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>(
 letmut memtransfer_types = vec![];
 letmut 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 in0..9{
 let kernel = cx.get_function(&format!("kernel_{num}"));
 ifletSome(kernel) = kernel {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1127,6 +1127,11 @@ unsafe extern "C" {
 
 // Operations on functions
 pub(crate)fnLLVMSetFunctionCallConv(Fn:&Value,CC:c_uint);
+pub(crate)fnLLVMAddFunction<'a>(
+Mod:&'aModule,
+Name:*constc_char,
+FunctionTy:&'aType,
+) -> &'aValue;
 pub(crate)fnLLVMDeleteFunction(Fn:&Value);
 
 // Operations about llvm intrinsics
@@ -2017,6 +2022,7 @@ unsafe extern "C" {
 ) -> &Attribute;
 
 // Operations on functions
+pub(crate)fnLLVMRustOffloadMapper<'a>(M:&'aModule,Fn:&'aValue,Fn:&'aValue);
 pub(crate)fnLLVMRustGetOrInsertFunction<'a>(
 M:&'aModule,
 Name:*constc_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 asc_uint)}
 }
 
+pub(crate)fnadd_func(&self,name:&str,ty:&'llType) -> &'llValue{
+let name = SmallCStr::new(name);
+unsafe{ llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty)}
+}
+
 pub(crate)fnfunc_params_types(&self,ty:&'llType) -> Vec<&'llType>{
 unsafe{
 let n_args = llvm::LLVMCountParamTypes(ty)asusize;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
 pubtarget_arch:String,
 pubtarget_is_like_darwin:bool,
 pubtarget_is_like_aix:bool,
+pubtarget_is_like_gpu:bool,
 pubsplit_debuginfo: rustc_target::spec::SplitDebuginfo,
 pubsplit_dwarf_kind: rustc_session::config::SplitDwarfKind,
 pubpointer_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,