Auto merge of #132756 - workingjubilee:rollup-bed2akn, r=workingjubilee

Rollup of 10 pull requests
Successful merges:
- #130586 (Set "symbol name" in raw-dylib import libraries to the decorated name)
- #131913 (Add `{ignore,needs}-{rustc,std}-debug-assertions` directive support)
- #132095 (Fix#131977 parens mangled in shared mut static lint suggestion)
- #132131 ([StableMIR] API to retrieve definitions from crates)
- #132639 (core: move intrinsics.rs into intrinsics folder)
- #132696 (Compile `test_num_f128` conditionally on `reliable_f128_math` config)
- #132737 (bootstrap: Print better message if lock pid isn't available)
- #132739 (Fix `librustdoc/scrape_examples.rs` formatting)
- #132740 (Update test for LLVM 20's new vector splat syntax)
- #132741 (Update mips64 data layout to match LLVM 20 change)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_codegen_gcc/src/archive.rs

@@ -2,6 +2,7 @@ use std::path::Path;
 
 use rustc_codegen_ssa::back::archive::{
 ArArchiveBuilder,ArchiveBuilder,ArchiveBuilderBuilder,DEFAULT_OBJECT_READER,
+ImportLibraryItem,
 };
 use rustc_session::Session;
 
@@ -16,7 +17,7 @@ impl ArchiveBuilderBuilder for ArArchiveBuilderBuilder {
 &self,
 _sess:&Session,
 _lib_name:&str,
-_import_name_and_ordinal_vector:Vec<(String,Option<u16>)>,
+_items:Vec<ImportLibraryItem>,
 _output_path:&Path,
 ){
 unimplemented!("creating dll imports is not yet supported");

compiler/rustc_codegen_llvm/src/callee.rs

@@ -44,6 +44,22 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t
 let llfn = if tcx.sess.target.arch == "x86"
  && letSome(dllimport) = crate::common::get_dllimport(tcx, instance_def_id, sym)
 {
+// When calling functions in generated import libraries, MSVC needs
+// the fully decorated name (as would have been in the declaring
+// object file), but MinGW wants the name as exported (as would be
+// in the def file) which may be missing decorations.
+let mingw_gnu_toolchain = common::is_mingw_gnu_toolchain(&tcx.sess.target);
+let llfn = cx.declare_fn(
+&common::i686_decorated_name(
+ dllimport,
+ mingw_gnu_toolchain,
+true,
+ !mingw_gnu_toolchain,
+),
+ fn_abi,
+Some(instance),
+);
+
 // Fix for https://github.com/rust-lang/rust/issues/104453
 // On x86 Windows, LLVM uses 'L' as the prefix for any private
 // global symbols, so when we create an undecorated function symbol
@@ -55,15 +71,6 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t
 // LLVM will prefix the name with `__imp_`. Ideally, we'd like the
 // existing logic below to set the Storage Class, but it has an
 // exemption for MinGW for backwards compatibility.
-let llfn = cx.declare_fn(
-&common::i686_decorated_name(
- dllimport,
- common::is_mingw_gnu_toolchain(&tcx.sess.target),
-true,
-),
- fn_abi,
-Some(instance),
-);
 unsafe{
  llvm::LLVMSetDLLStorageClass(llfn, llvm::DLLStorageClass::DllImport);
 }

compiler/rustc_codegen_llvm/src/consts.rs

@@ -194,16 +194,10 @@ fn check_and_apply_linkage<'ll, 'tcx>(
 unsafe{ llvm::LLVMSetInitializer(g2, g1)};
  g2
 }elseif cx.tcx.sess.target.arch == "x86"
+ && common::is_mingw_gnu_toolchain(&cx.tcx.sess.target)
  && letSome(dllimport) = crate::common::get_dllimport(cx.tcx, def_id, sym)
 {
- cx.declare_global(
-&common::i686_decorated_name(
- dllimport,
- common::is_mingw_gnu_toolchain(&cx.tcx.sess.target),
-true,
-),
- llty,
-)
+ cx.declare_global(&common::i686_decorated_name(dllimport,true,true,false), llty)
 }else{
 // Generate an external declaration.
 // FIXME(nagisa): investigate whether it can be changed into define_global

compiler/rustc_codegen_llvm/src/context.rs

@@ -154,6 +154,11 @@ pub(crate) unsafe fn create_module<'ll>(
 // See https://github.com/llvm/llvm-project/pull/106951
  target_data_layout = target_data_layout.replace("-i128:128","");
 }
+if sess.target.arch.starts_with("mips64"){
+// LLVM 20 updates the mips64 layout to correctly align 128 bit integers to 128 bit.
+// See https://github.com/llvm/llvm-project/pull/112084
+ target_data_layout = target_data_layout.replace("-i128:128","");
+}
 }
 
 // Ensure the data-layout values hardcoded remain the defaults.

compiler/rustc_codegen_ssa/src/back/archive.rs

@@ -26,6 +26,35 @@ use crate::errors::{
 DlltoolFailImportLibrary,ErrorCallingDllTool,ErrorCreatingImportLibrary,ErrorWritingDEFFile,
 };
 
+/// An item to be included in an import library.
+/// This is a slimmed down version of `COFFShortExport` from `ar-archive-writer`.
+pubstructImportLibraryItem{
+/// The name to be exported.
+pubname:String,
+/// The ordinal to be exported, if any.
+pubordinal:Option<u16>,
+/// The original, decorated name if `name` is not decorated.
+pubsymbol_name:Option<String>,
+/// True if this is a data export, false if it is a function export.
+pubis_data:bool,
+}
+
+implFrom<ImportLibraryItem>forCOFFShortExport{
+fnfrom(item:ImportLibraryItem) -> Self{
+COFFShortExport{
+name: item.name,
+ext_name:None,
+symbol_name: item.symbol_name,
+alias_target:None,
+ordinal: item.ordinal.unwrap_or(0),
+noname: item.ordinal.is_some(),
+data: item.is_data,
+private:false,
+constant:false,
+}
+}
+}
+
 pubtraitArchiveBuilderBuilder{
 fnnew_archive_builder<'a>(&self,sess:&'aSession) -> Box<dynArchiveBuilder + 'a>;
 
@@ -38,7 +67,7 @@ pub trait ArchiveBuilderBuilder {
 &self,
 sess:&Session,
 lib_name:&str,
-import_name_and_ordinal_vector:Vec<(String,Option<u16>)>,
+items:Vec<ImportLibraryItem>,
 output_path:&Path,
 ){
 if common::is_mingw_gnu_toolchain(&sess.target){
@@ -47,21 +76,16 @@ pub trait ArchiveBuilderBuilder {
 // that loaded but crashed with an AV upon calling one of the imported
 // functions. Therefore, use binutils to create the import library instead,
 // by writing a .DEF file to the temp dir and calling binutils's dlltool.
-create_mingw_dll_import_lib(
- sess,
- lib_name,
- import_name_and_ordinal_vector,
- output_path,
-);
+create_mingw_dll_import_lib(sess, lib_name, items, output_path);
 }else{
 trace!("creating import library");
 trace!(" dll_name {:#?}", lib_name);
 trace!(" output_path {}", output_path.display());
 trace!(
 " import names: {}",
-import_name_and_ordinal_vector
+items
 .iter()
-.map(|(name,_ordinal)| name.clone())
+.map(|ImportLibraryItem{name,.. }| name.clone())
 .collect::<Vec<_>>()
 .join(", "),
 );
@@ -79,20 +103,7 @@ pub trait ArchiveBuilderBuilder {
 .emit_fatal(ErrorCreatingImportLibrary{ lib_name,error: error.to_string()}),
 };
 
-let exports = import_name_and_ordinal_vector
-.iter()
-.map(|(name, ordinal)| COFFShortExport{
-name: name.to_string(),
-ext_name:None,
-symbol_name:None,
-alias_target:None,
-ordinal: ordinal.unwrap_or(0),
-noname: ordinal.is_some(),
-data:false,
-private:false,
-constant:false,
-})
-.collect::<Vec<_>>();
+let exports = items.into_iter().map(Into::into).collect::<Vec<_>>();
 let machine = match&*sess.target.arch{
 "x86_64" => MachineTypes::AMD64,
 "x86" => MachineTypes::I386,
@@ -160,16 +171,16 @@ pub trait ArchiveBuilderBuilder {
 fncreate_mingw_dll_import_lib(
 sess:&Session,
 lib_name:&str,
-import_name_and_ordinal_vector:Vec<(String,Option<u16>)>,
+items:Vec<ImportLibraryItem>,
 output_path:&Path,
 ){
 let def_file_path = output_path.with_extension("def");
 
 let def_file_content = format!(
 "EXPORTS\n{}",
-import_name_and_ordinal_vector
+items
 .into_iter()
-.map(|(name, ordinal)| {
+.map(|ImportLibraryItem{name, ordinal, .. }| {
 match ordinal {
 Some(n) => format!("{name} @{n} NONAME"),
 None => name,

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -45,7 +45,7 @@ use rustc_target::spec::{
 use tempfile::BuilderasTempFileBuilder;
 use tracing::{debug, info, warn};
 
-usesuper::archive::{ArchiveBuilder,ArchiveBuilderBuilder};
+usesuper::archive::{ArchiveBuilder,ArchiveBuilderBuilder,ImportLibraryItem};
 usesuper::command::Command;
 usesuper::linker::{self,Linker};
 usesuper::metadata::{MetadataPosition, create_wrapper_file};
@@ -495,24 +495,43 @@ fn create_dll_import_libs<'a>(
 
 let mingw_gnu_toolchain = common::is_mingw_gnu_toolchain(&sess.target);
 
-letimport_name_and_ordinal_vector:Vec<(String,Option<u16>)> = raw_dylib_imports
+letitems:Vec<ImportLibraryItem> = raw_dylib_imports
 .iter()
 .map(|import:&DllImport| {
 if sess.target.arch == "x86"{
-(
- common::i686_decorated_name(import, mingw_gnu_toolchain,false),
- import.ordinal(),
-)
+ImportLibraryItem{
+name: common::i686_decorated_name(
+ import,
+ mingw_gnu_toolchain,
+false,
+false,
+),
+ordinal: import.ordinal(),
+symbol_name: import.is_missing_decorations().then(|| {
+ common::i686_decorated_name(
+ import,
+ mingw_gnu_toolchain,
+false,
+true,
+)
+}),
+is_data: !import.is_fn,
+}
 }else{
-(import.name.to_string(), import.ordinal())
+ImportLibraryItem{
+name: import.name.to_string(),
+ordinal: import.ordinal(),
+symbol_name:None,
+is_data: !import.is_fn,
+}
 }
 })
 .collect();
 
  archive_builder_builder.create_dll_import_lib(
  sess,
 &raw_dylib_name,
-import_name_and_ordinal_vector,
+items,
 &output_path,
 );
 

compiler/rustc_codegen_ssa/src/common.rs

@@ -187,12 +187,15 @@ pub fn i686_decorated_name(
 dll_import:&DllImport,
 mingw:bool,
 disable_name_mangling:bool,
+force_fully_decorated:bool,
 ) -> String{
 let name = dll_import.name.as_str();
 
-let(add_prefix, add_suffix) = match dll_import.import_name_type{
-Some(PeImportNameType::NoPrefix) => (false,true),
-Some(PeImportNameType::Undecorated) => (false,false),
+let(add_prefix, add_suffix) = match(force_fully_decorated, dll_import.import_name_type){
+// No prefix is a bit weird, in that LLVM/ar_archive_writer won't emit it, so we will
+// ignore `force_fully_decorated` and always partially decorate it.
+(_,Some(PeImportNameType::NoPrefix)) => (false,true),
+(false,Some(PeImportNameType::Undecorated)) => (false,false),
  _ => (true,true),
 };
 

compiler/rustc_lint/src/static_mut_refs.rs

@@ -3,8 +3,8 @@ use rustc_hir::{Expr, Stmt};
 use rustc_middle::ty::{Mutability,TyKind};
 use rustc_session::lint::FutureIncompatibilityReason;
 use rustc_session::{declare_lint, declare_lint_pass};
-use rustc_span::Span;
 use rustc_span::edition::Edition;
+use rustc_span::{BytePos,Span};
 
 usecrate::lints::{MutRefSugg,RefOfMutStatic};
 usecrate::{LateContext,LateLintPass,LintContext};
@@ -71,13 +71,24 @@ impl<'tcx> LateLintPass<'tcx> for StaticMutRefs {
 ifmatches!(borrow_kind, hir::BorrowKind::Ref)
  && letSome(err_span) = path_is_static_mut(ex, err_span) =>
 {
-emit_static_mut_refs(
- cx,
- err_span,
- err_span.with_hi(ex.span.lo()),
- m,
- !expr.span.from_expansion(),
-);
+let source_map = cx.sess().source_map();
+let snippet = source_map.span_to_snippet(err_span);
+
+let sugg_span = ifletOk(snippet) = snippet {
+// ( ( &IDENT ) )
+// ~~~~ exclude these from the suggestion span to avoid unmatching parens
+let exclude_n_bytes:u32 = snippet
+.chars()
+.take_while(|ch| ch.is_whitespace() || *ch == '(')
+.map(|ch| ch.len_utf8()asu32)
+.sum();
+
+ err_span.with_lo(err_span.lo() + BytePos(exclude_n_bytes)).with_hi(ex.span.lo())
+}else{
+ err_span.with_hi(ex.span.lo())
+};
+
+emit_static_mut_refs(cx, err_span, sugg_span, m, !expr.span.from_expansion());
 }
  hir::ExprKind::MethodCall(_, e, _, _)
 ifletSome(err_span) = path_is_static_mut(e, expr.span)

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -384,6 +384,7 @@ provide! { tcx, def_id, other, cdata,
  crate_hash => { cdata.root.header.hash }
  crate_host_hash => { cdata.host_hash }
  crate_name => { cdata.root.header.name }
+ num_extern_def_ids => { cdata.num_def_ids()}
 
  extra_filename => { cdata.root.extra_filename.clone()}
 

compiler/rustc_middle/src/query/mod.rs

@@ -1844,6 +1844,16 @@ rustc_queries! {
  desc { |tcx| "computing crate imported by `{}`", tcx.def_path_str(def_id)}
 }
 
+/// Gets the number of definitions in a foreign crate.
+///
+/// This allows external tools to iterate over all definitions in a foreign crate.
+///
+/// This should never be used for the local crate, instead use `iter_local_def_id`.
+ query num_extern_def_ids(_:CrateNum) -> usize{
+ desc {"fetching the number of definitions in a crate"}
+ separate_provide_extern
+}
+
  query lib_features(_:CrateNum) -> &'tcx LibFeatures{
  desc {"calculating the lib features defined in a crate"}
  separate_provide_extern