Auto merge of #147019 - Zalathar:rollup-boxzbmo, r=Zalathar

Rollup of 14 pull requests
Successful merges:
- #145067 (RawVecInner: add missing `unsafe` to unsafe fns)
- #145277 (Do not materialise X in [X; 0] when X is unsizing a const)
- #145973 (Add `std` support for `armv7a-vex-v5`)
- #146667 (Add an attribute to check the number of lanes in a SIMD vector after monomorphization)
- #146735 (unstably constify float mul_add methods)
- #146737 (f16_f128: enable some more tests in Miri)
- #146766 (Add attributes for #[global_allocator] functions)
- #146905 (llvm: update remarks support on LLVM 22)
- #146982 (Remove erroneous normalization step in `tests/run-make/linker-warning`)
- #147005 (Small string formatting cleanup)
- #147007 (Explicitly note `&[SocketAddr]` impl of `ToSocketAddrs`)
- #147008 (bootstrap.py: Respect build.jobs while building bootstrap tool)
- #147013 (rustdoc: Fix documentation for `--doctest-build-arg`)
- #147015 (Use `LLVMDisposeTargetMachine`)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -1,40 +1,4 @@
-use std::num::IntErrorKind;
-
-use rustc_hir::limit::Limit;
-
 usesuper::prelude::*;
-usecrate::session_diagnostics::LimitInvalid;
-
-impl<S:Stage>AcceptContext<'_,'_,S>{
-fnparse_limit_int(&self,nv:&NameValueParser) -> Option<Limit>{
-letSome(limit) = nv.value_as_str()else{
-self.expected_string_literal(nv.value_span,Some(nv.value_as_lit()));
-returnNone;
-};
-
-let error_str = match limit.as_str().parse(){
-Ok(i) => returnSome(Limit::new(i)),
-Err(e) => match e.kind(){
-IntErrorKind::PosOverflow => "`limit` is too large",
-IntErrorKind::Empty => "`limit` must be a non-negative integer",
-IntErrorKind::InvalidDigit => "not a valid integer",
-IntErrorKind::NegOverflow => {
-panic!(
-"`limit` should never negatively overflow since we're parsing into a usize and we'd get Empty instead"
-)
-}
-IntErrorKind::Zero => {
-panic!("zero is a valid `limit` so should have returned Ok() when parsing")
-}
- kind => panic!("unimplemented IntErrorKind variant: {:?}", kind),
-},
-};
-
-self.emit_err(LimitInvalid{span:self.attr_span,value_span: nv.value_span, error_str });
-
-None
-}
-}
 
 pub(crate)structCrateNameParser;
 

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -49,3 +49,21 @@ impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {
 Some(AttributeKind::RustcObjectLifetimeDefault)
 }
 }
+
+pub(crate)structRustcSimdMonomorphizeLaneLimitParser;
+
+impl<S:Stage>SingleAttributeParser<S>forRustcSimdMonomorphizeLaneLimitParser{
+constPATH:&[Symbol] = &[sym::rustc_simd_monomorphize_lane_limit];
+constATTRIBUTE_ORDER:AttributeOrder = AttributeOrder::KeepInnermost;
+constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Error;
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
+constTEMPLATE:AttributeTemplate = template!(NameValueStr:"N");
+
+fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
+letArgParser::NameValue(nv) = args else{
+ cx.expected_name_value(cx.attr_span,None);
+returnNone;
+};
+Some(AttributeKind::RustcSimdMonomorphizeLaneLimit(cx.parse_limit_int(nv)?))
+}
+}

compiler/rustc_attr_parsing/src/attributes/util.rs

@@ -1,11 +1,15 @@
+use std::num::IntErrorKind;
+
 use rustc_ast::LitKind;
 use rustc_ast::attr::AttributeExt;
 use rustc_feature::is_builtin_attr_name;
 use rustc_hir::RustcVersion;
+use rustc_hir::limit::Limit;
 use rustc_span::{Symbol, sym};
 
 usecrate::context::{AcceptContext,Stage};
-usecrate::parser::ArgParser;
+usecrate::parser::{ArgParser,NameValueParser};
+usecrate::session_diagnostics::LimitInvalid;
 
 /// Parse a rustc version number written inside string literal in an attribute,
 /// like appears in `since = "1.0.0"`. Suffixes like "-dev" and "-nightly" are
@@ -85,3 +89,34 @@ pub(crate) fn parse_single_integer<S: Stage>(
 };
 Some(num.0)
 }
+
+impl<S:Stage>AcceptContext<'_,'_,S>{
+pub(crate)fnparse_limit_int(&self,nv:&NameValueParser) -> Option<Limit>{
+letSome(limit) = nv.value_as_str()else{
+self.expected_string_literal(nv.value_span,Some(nv.value_as_lit()));
+returnNone;
+};
+
+let error_str = match limit.as_str().parse(){
+Ok(i) => returnSome(Limit::new(i)),
+Err(e) => match e.kind(){
+IntErrorKind::PosOverflow => "`limit` is too large",
+IntErrorKind::Empty => "`limit` must be a non-negative integer",
+IntErrorKind::InvalidDigit => "not a valid integer",
+IntErrorKind::NegOverflow => {
+panic!(
+"`limit` should never negatively overflow since we're parsing into a usize and we'd get Empty instead"
+)
+}
+IntErrorKind::Zero => {
+panic!("zero is a valid `limit` so should have returned Ok() when parsing")
+}
+ kind => panic!("unimplemented IntErrorKind variant: {:?}", kind),
+},
+};
+
+self.emit_err(LimitInvalid{span:self.attr_span,value_span: nv.value_span, error_str });
+
+None
+}
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -53,7 +53,7 @@ use crate::attributes::prototype::CustomMirParser;
 usecrate::attributes::repr::{AlignParser,AlignStaticParser,ReprParser};
 usecrate::attributes::rustc_internal::{
 RustcLayoutScalarValidRangeEnd,RustcLayoutScalarValidRangeStart,
-RustcObjectLifetimeDefaultParser,
+RustcObjectLifetimeDefaultParser,RustcSimdMonomorphizeLaneLimitParser,
 };
 usecrate::attributes::semantics::MayDangleParser;
 usecrate::attributes::stability::{
@@ -198,6 +198,7 @@ attribute_parsers!(
 Single<RustcLayoutScalarValidRangeEnd>,
 Single<RustcLayoutScalarValidRangeStart>,
 Single<RustcObjectLifetimeDefaultParser>,
+Single<RustcSimdMonomorphizeLaneLimitParser>,
 Single<SanitizeParser>,
 Single<ShouldPanicParser>,
 Single<SkipDuringMethodDispatchParser>,

compiler/rustc_builtin_macros/src/global_allocator.rs

@@ -85,7 +85,7 @@ impl AllocFnFactory<'_, '_> {
  body,
 define_opaque:None,
 }));
-let item = self.cx.item(self.span,self.attrs(), kind);
+let item = self.cx.item(self.span,self.attrs(method), kind);
 self.cx.stmt_item(self.ty_span, item)
 }
 
@@ -100,8 +100,18 @@ impl AllocFnFactory<'_, '_> {
 self.cx.expr_call(self.ty_span, method, args)
 }
 
-fnattrs(&self) -> AttrVec{
-thin_vec![self.cx.attr_word(sym::rustc_std_internal_symbol,self.span)]
+fnattrs(&self,method:&AllocatorMethod) -> AttrVec{
+let alloc_attr = match method.name{
+ sym::alloc => sym::rustc_allocator,
+ sym::dealloc => sym::rustc_deallocator,
+ sym::realloc => sym::rustc_reallocator,
+ sym::alloc_zeroed => sym::rustc_allocator_zeroed,
+ _ => unreachable!("Unknown allocator method!"),
+};
+thin_vec![
+self.cx.attr_word(sym::rustc_std_internal_symbol,self.span),
+self.cx.attr_word(alloc_attr,self.span)
+]
 }
 
 fnarg_ty(&self,input:&AllocatorMethodInput,args:&mutThinVec<Param>) -> Box<Expr>{

compiler/rustc_codegen_cranelift/src/common.rs

@@ -439,7 +439,10 @@ pub(crate) struct FullyMonomorphizedLayoutCx<'tcx>(pub(crate) TyCtxt<'tcx>);
 impl<'tcx>LayoutOfHelpers<'tcx>forFullyMonomorphizedLayoutCx<'tcx>{
 #[inline]
 fnhandle_layout_err(&self,err:LayoutError<'tcx>,span:Span,ty:Ty<'tcx>) -> ! {
-ifletLayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+ifletLayoutError::SizeOverflow(_)
+ | LayoutError::InvalidSimd{ .. }
+ | LayoutError::ReferencesError(_) = err
+{
 self.0.sess.dcx().span_fatal(span, err.to_string())
 }else{
 self.0
@@ -458,7 +461,9 @@ impl<'tcx> FnAbiOfHelpers<'tcx> for FullyMonomorphizedLayoutCx<'tcx> {
 span:Span,
 fn_abi_request:FnAbiRequest<'tcx>,
 ) -> ! {
-ifletFnAbiError::Layout(LayoutError::SizeOverflow(_)) = err {
+ifletFnAbiError::Layout(LayoutError::SizeOverflow(_) | LayoutError::InvalidSimd{ .. }) =
+ err
+{
 self.0.sess.dcx().emit_fatal(Spanned{ span,node: err })
 }else{
 match fn_abi_request {

compiler/rustc_codegen_cranelift/src/global_asm.rs

@@ -42,7 +42,10 @@ impl<'tcx> AsmCodegenMethods<'tcx> for GlobalAsmContext<'_, 'tcx> {
 impl<'tcx>LayoutOfHelpers<'tcx>forGlobalAsmContext<'_,'tcx>{
 #[inline]
 fnhandle_layout_err(&self,err:LayoutError<'tcx>,span:Span,ty:Ty<'tcx>) -> ! {
-ifletLayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+ifletLayoutError::SizeOverflow(_)
+ | LayoutError::InvalidSimd{ .. }
+ | LayoutError::ReferencesError(_) = err
+{
 self.tcx.sess.dcx().span_fatal(span, err.to_string())
 }else{
 self.tcx

compiler/rustc_codegen_gcc/src/context.rs

@@ -529,7 +529,10 @@ impl<'gcc, 'tcx> HasX86AbiOpt for CodegenCx<'gcc, 'tcx> {
 impl<'gcc,'tcx>LayoutOfHelpers<'tcx>forCodegenCx<'gcc,'tcx>{
 #[inline]
 fnhandle_layout_err(&self,err:LayoutError<'tcx>,span:Span,ty:Ty<'tcx>) -> ! {
-ifletLayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+ifletLayoutError::SizeOverflow(_)
+ | LayoutError::InvalidSimd{ .. }
+ | LayoutError::ReferencesError(_) = err
+{
 self.tcx.dcx().emit_fatal(respan(span, err.into_diagnostic()))
 }else{
 self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout{ span, ty, err })
@@ -545,7 +548,9 @@ impl<'gcc, 'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {
 span:Span,
 fn_abi_request:FnAbiRequest<'tcx>,
 ) -> ! {
-ifletFnAbiError::Layout(LayoutError::SizeOverflow(_)) = err {
+ifletFnAbiError::Layout(LayoutError::SizeOverflow(_) | LayoutError::InvalidSimd{ .. }) =
+ err
+{
 self.tcx.dcx().emit_fatal(respan(span, err))
 }else{
 match fn_abi_request {

compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs

@@ -95,8 +95,6 @@ impl Drop for OwnedTargetMachine {
 // SAFETY: constructing ensures we have a valid pointer created by
 // llvm::LLVMRustCreateTargetMachine OwnedTargetMachine is not copyable so there is no
 // double free or use after free.
-unsafe{
- llvm::LLVMRustDisposeTargetMachine(self.tm_unique.as_ptr());
-}
+unsafe{ llvm::LLVMDisposeTargetMachine(self.tm_unique)};
 }
 }

compiler/rustc_codegen_llvm/src/context.rs

@@ -1044,7 +1044,10 @@ impl<'tcx, 'll> HasTypingEnv<'tcx> for CodegenCx<'ll, 'tcx> {
 impl<'tcx>LayoutOfHelpers<'tcx>forCodegenCx<'_,'tcx>{
 #[inline]
 fnhandle_layout_err(&self,err:LayoutError<'tcx>,span:Span,ty:Ty<'tcx>) -> ! {
-ifletLayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+ifletLayoutError::SizeOverflow(_)
+ | LayoutError::ReferencesError(_)
+ | LayoutError::InvalidSimd{ .. } = err
+{
 self.tcx.dcx().emit_fatal(Spanned{ span,node: err.into_diagnostic()})
 }else{
 self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout{ span, ty, err })
@@ -1061,7 +1064,11 @@ impl<'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'_, 'tcx> {
 fn_abi_request:FnAbiRequest<'tcx>,
 ) -> ! {
 match err {
-FnAbiError::Layout(LayoutError::SizeOverflow(_) | LayoutError::Cycle(_)) => {
+FnAbiError::Layout(
+LayoutError::SizeOverflow(_)
+ | LayoutError::Cycle(_)
+ | LayoutError::InvalidSimd{ .. },
+) => {
 self.tcx.dcx().emit_fatal(Spanned{ span,node: err });
 }
  _ => match fn_abi_request {