Auto merge of rust-lang#147692 - matthiaskrgr:rollup-bqhlwyw, r=matthiaskrgr

Rollup of 12 pull requests Successful merges: - rust-lang#146187 (Unstably constify `ptr::drop_in_place` and related methods) - rust-lang#146503 (std: improve handling of timed condition variable waits on macOS) - rust-lang#147526 (Move computation of allocator shim contents to cg_ssa) - rust-lang#147630 (Bitset cleanups) - rust-lang#147638 (bpf: return results larger than one register indirectly) - rust-lang#147666 (Replace manual implementation with `carrying_mul_add`) - rust-lang#147669 (fix missing link to `std::char` in `std` docs) - rust-lang#147673 (pretty print u128 with display) - rust-lang#147677 (Fewer exceptions in `span()` on parsed attributes) - rust-lang#147680 (Fix ICE caused by associated_item_def_ids on wrong type in resolve diag) - rust-lang#147682 (convert `rustc_main` to the new attribute parsing infrastructure) - rust-lang#147683 (only check duplicates on old/unparsed attributes) r? `@ghost` `@rustbot` modify labels: rollup

Author: bors

compiler/rustc_ast/src/entry.rs

@@ -1,7 +1,5 @@
 use rustc_span::{Symbol, sym};
 
-use crate::attr::{self, AttributeExt};
-
 #[derive(Debug)]
 pub enum EntryPointType {
  /// This function is not an entrypoint.
@@ -30,11 +28,11 @@ pub enum EntryPointType {
 }
 
 pub fn entry_point_type(
- attrs: &[impl AttributeExt],
+ has_rustc_main: bool,
  at_root: bool,
  name: Option<Symbol>,
 ) -> EntryPointType {
- if attr::contains_name(attrs, sym::rustc_main) {
+ if has_rustc_main {
  EntryPointType::RustcMainAttr
  } else if let Some(name) = name
  && name == sym::main

compiler/rustc_ast/src/expand/allocator.rs

@@ -3,7 +3,9 @@ use rustc_span::{Symbol, sym};
 
 #[derive(Clone, Debug, Copy, Eq, PartialEq, HashStable_Generic)]
 pub enum AllocatorKind {
+ /// Use `#[global_allocator]` as global allocator.
  Global,
+ /// Use the default implementation in libstd as global allocator.
  Default,
 }
 
@@ -15,23 +17,22 @@ pub fn default_fn_name(base: Symbol) -> String {
  format!("__rdl_{base}")
 }
 
-pub fn alloc_error_handler_name(alloc_error_handler_kind: AllocatorKind) -> &'static str {
- match alloc_error_handler_kind {
- AllocatorKind::Global => "__rg_oom",
- AllocatorKind::Default => "__rdl_oom",
- }
-}
-
+pub const ALLOC_ERROR_HANDLER: Symbol = sym::alloc_error_handler;
 pub const NO_ALLOC_SHIM_IS_UNSTABLE: &str = "__rust_no_alloc_shim_is_unstable_v2";
 
+/// Argument or return type for methods in the allocator shim
+#[derive(Copy, Clone)]
 pub enum AllocatorTy {
  Layout,
+ Never,
  Ptr,
  ResultPtr,
  Unit,
  Usize,
 }
 
+/// A method that will be codegened in the allocator shim.
+#[derive(Copy, Clone)]
 pub struct AllocatorMethod {
  pub name: Symbol,
  pub inputs: &'static [AllocatorMethodInput],

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -1,9 +1,18 @@
 use super::prelude::*;
 use super::util::parse_single_integer;
 
-pub(crate) struct RustcLayoutScalarValidRangeStart;
+pub(crate) struct RustcMainParser;
 
-impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStart {
+impl<S: Stage> NoArgsAttributeParser<S> for RustcMainParser {
+ const PATH: &'static [Symbol] = &[sym::rustc_main];
+ const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+ const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+ const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcMain;
+}
+
+pub(crate) struct RustcLayoutScalarValidRangeStartParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStartParser {
  const PATH: &'static [Symbol] = &[sym::rustc_layout_scalar_valid_range_start];
  const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
  const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
@@ -16,9 +25,9 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStart {
  }
 }
 
-pub(crate) struct RustcLayoutScalarValidRangeEnd;
+pub(crate) struct RustcLayoutScalarValidRangeEndParser;
 
-impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeEnd {
+impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeEndParser {
  const PATH: &'static [Symbol] = &[sym::rustc_layout_scalar_valid_range_end];
  const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
  const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;

compiler/rustc_attr_parsing/src/context.rs

@@ -53,7 +53,7 @@ use crate::attributes::proc_macro_attrs::{
 use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
- RustcLayoutScalarValidRangeEnd, RustcLayoutScalarValidRangeStart,
+ RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser, RustcMainParser,
  RustcObjectLifetimeDefaultParser, RustcSimdMonomorphizeLaneLimitParser,
 };
 use crate::attributes::semantics::MayDangleParser;
@@ -197,8 +197,8 @@ attribute_parsers!(
  Single<RecursionLimitParser>,
  Single<RustcBuiltinMacroParser>,
  Single<RustcForceInlineParser>,
- Single<RustcLayoutScalarValidRangeEnd>,
- Single<RustcLayoutScalarValidRangeStart>,
+ Single<RustcLayoutScalarValidRangeEndParser>,
+ Single<RustcLayoutScalarValidRangeStartParser>,
  Single<RustcObjectLifetimeDefaultParser>,
  Single<RustcSimdMonomorphizeLaneLimitParser>,
  Single<SanitizeParser>,
@@ -238,6 +238,7 @@ attribute_parsers!(
  Single<WithoutArgs<ProcMacroParser>>,
  Single<WithoutArgs<PubTransparentParser>>,
  Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
+ Single<WithoutArgs<RustcMainParser>>,
  Single<WithoutArgs<SpecializationTraitParser>>,
  Single<WithoutArgs<StdInternalSymbolParser>>,
  Single<WithoutArgs<TrackCallerParser>>,

compiler/rustc_builtin_macros/src/alloc_error_handler.rs

@@ -1,3 +1,4 @@
+use rustc_ast::expand::allocator::{ALLOC_ERROR_HANDLER, global_fn_name};
 use rustc_ast::{
  self as ast, Fn, FnHeader, FnSig, Generics, ItemKind, Safety, Stmt, StmtKind, TyKind,
 };
@@ -55,7 +56,7 @@ pub(crate) fn expand(
 }
 
 // #[rustc_std_internal_symbol]
-// unsafe fn __rg_oom(size: usize, align: usize) -> ! {
+// unsafe fn __rust_alloc_error_handler(size: usize, align: usize) -> ! {
 // handler(core::alloc::Layout::from_size_align_unchecked(size, align))
 // }
 fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig_span: Span) -> Stmt {
@@ -84,7 +85,7 @@ fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig_span: Span
  let kind = ItemKind::Fn(Box::new(Fn {
  defaultness: ast::Defaultness::Final,
  sig,
- ident: Ident::from_str_and_span("__rg_oom", span),
+ ident: Ident::from_str_and_span(&global_fn_name(ALLOC_ERROR_HANDLER), span),
  generics: Generics::default(),
  contract: None,
  body,

compiler/rustc_builtin_macros/src/global_allocator.rs

@@ -151,7 +151,7 @@ impl AllocFnFactory<'_, '_> {
  self.cx.expr_ident(self.span, ident)
  }
 
- AllocatorTy::ResultPtr | AllocatorTy::Unit => {
+ AllocatorTy::Never | AllocatorTy::ResultPtr | AllocatorTy::Unit => {
  panic!("can't convert AllocatorTy to an argument")
  }
  }
@@ -163,7 +163,7 @@ impl AllocFnFactory<'_, '_> {
 
  AllocatorTy::Unit => self.cx.ty(self.span, TyKind::Tup(ThinVec::new())),
 
- AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
+ AllocatorTy::Layout | AllocatorTy::Never | AllocatorTy::Usize | AllocatorTy::Ptr => {
  panic!("can't convert `AllocatorTy` to an output")
  }
  }

compiler/rustc_builtin_macros/src/test_harness.rs

@@ -3,6 +3,7 @@
 use std::mem;
 
 use rustc_ast as ast;
+use rustc_ast::attr::contains_name;
 use rustc_ast::entry::EntryPointType;
 use rustc_ast::mut_visit::*;
 use rustc_ast::visit::Visitor;
@@ -172,9 +173,11 @@ impl<'a> Visitor<'a> for InnerItemLinter<'_> {
 
 fn entry_point_type(item: &ast::Item, at_root: bool) -> EntryPointType {
  match &item.kind {
- ast::ItemKind::Fn(fn_) => {
- rustc_ast::entry::entry_point_type(&item.attrs, at_root, Some(fn_.ident.name))
- }
+ ast::ItemKind::Fn(fn_) => rustc_ast::entry::entry_point_type(
+ contains_name(&item.attrs, sym::rustc_main),
+ at_root,
+ Some(fn_.ident.name),
+ ),
  _ => EntryPointType::None,
  }
 }

compiler/rustc_codegen_cranelift/src/allocator.rs

@@ -3,10 +3,9 @@
 
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use rustc_ast::expand::allocator::{
- ALLOCATOR_METHODS, AllocatorKind, AllocatorTy, NO_ALLOC_SHIM_IS_UNSTABLE,
- alloc_error_handler_name, default_fn_name, global_fn_name,
+ AllocatorMethod, AllocatorTy, NO_ALLOC_SHIM_IS_UNSTABLE, default_fn_name, global_fn_name,
 };
-use rustc_codegen_ssa::base::allocator_kind_for_codegen;
+use rustc_codegen_ssa::base::{allocator_kind_for_codegen, allocator_shim_contents};
 use rustc_session::config::OomStrategy;
 use rustc_symbol_mangling::mangle_internal_symbol;
 
@@ -15,75 +14,57 @@ use crate::prelude::*;
 /// Returns whether an allocator shim was created
 pub(crate) fn codegen(tcx: TyCtxt<'_>, module: &mut dyn Module) -> bool {
  let Some(kind) = allocator_kind_for_codegen(tcx) else { return false };
- codegen_inner(
- tcx,
- module,
- kind,
- tcx.alloc_error_handler_kind(()).unwrap(),
- tcx.sess.opts.unstable_opts.oom,
- );
+ let methods = allocator_shim_contents(tcx, kind);
+ codegen_inner(tcx, module, &methods, tcx.sess.opts.unstable_opts.oom);
  true
 }
 
 fn codegen_inner(
  tcx: TyCtxt<'_>,
  module: &mut dyn Module,
- kind: AllocatorKind,
- alloc_error_handler_kind: AllocatorKind,
+ methods: &[AllocatorMethod],
  oom_strategy: OomStrategy,
 ) {
  let usize_ty = module.target_config().pointer_type();
 
- if kind == AllocatorKind::Default {
- for method in ALLOCATOR_METHODS {
- let mut arg_tys = Vec::with_capacity(method.inputs.len());
- for input in method.inputs.iter() {
- match input.ty {
- AllocatorTy::Layout => {
- arg_tys.push(usize_ty); // size
- arg_tys.push(usize_ty); // align
- }
- AllocatorTy::Ptr => arg_tys.push(usize_ty),
- AllocatorTy::Usize => arg_tys.push(usize_ty),
+ for method in methods {
+ let mut arg_tys = Vec::with_capacity(method.inputs.len());
+ for input in method.inputs.iter() {
+ match input.ty {
+ AllocatorTy::Layout => {
+ arg_tys.push(usize_ty); // size
+ arg_tys.push(usize_ty); // align
+ }
+ AllocatorTy::Ptr => arg_tys.push(usize_ty),
+ AllocatorTy::Usize => arg_tys.push(usize_ty),
 
- AllocatorTy::ResultPtr | AllocatorTy::Unit => panic!("invalid allocator arg"),
+ AllocatorTy::Never | AllocatorTy::ResultPtr | AllocatorTy::Unit => {
+ panic!("invalid allocator arg")
  }
  }
- let output = match method.output {
- AllocatorTy::ResultPtr => Some(usize_ty),
- AllocatorTy::Unit => None,
+ }
+ let output = match method.output {
+ AllocatorTy::ResultPtr => Some(usize_ty),
+ AllocatorTy::Never | AllocatorTy::Unit => None,
 
-  AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
-  panic!("invalid allocator output")
-  }
-  };
+ AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
+ panic!("invalid allocator output")
+ }
+ };
 
- let sig = Signature {
- call_conv: module.target_config().default_call_conv,
- params: arg_tys.iter().cloned().map(AbiParam::new).collect(),
- returns: output.into_iter().map(AbiParam::new).collect(),
- };
- crate::common::create_wrapper_function(
- module,
- sig,
- &mangle_internal_symbol(tcx, &global_fn_name(method.name)),
- &mangle_internal_symbol(tcx, &default_fn_name(method.name)),
- );
- }
+ let sig = Signature {
+ call_conv: module.target_config().default_call_conv,
+ params: arg_tys.iter().cloned().map(AbiParam::new).collect(),
+ returns: output.into_iter().map(AbiParam::new).collect(),
+ };
+ crate::common::create_wrapper_function(
+ module,
+ sig,
+ &mangle_internal_symbol(tcx, &global_fn_name(method.name)),
+ &mangle_internal_symbol(tcx, &default_fn_name(method.name)),
+ );
  }
 
- let sig = Signature {
- call_conv: module.target_config().default_call_conv,
- params: vec![AbiParam::new(usize_ty), AbiParam::new(usize_ty)],
- returns: vec![],
- };
- crate::common::create_wrapper_function(
- module,
- sig,
- &mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
- &mangle_internal_symbol(tcx, alloc_error_handler_name(alloc_error_handler_kind)),
- );
-
  {
  let sig = Signature {
  call_conv: module.target_config().default_call_conv,

compiler/rustc_codegen_gcc/src/allocator.rs

@@ -2,8 +2,7 @@
 use gccjit::FnAttribute;
 use gccjit::{Context, FunctionType, RValue, ToRValue, Type};
 use rustc_ast::expand::allocator::{
- ALLOCATOR_METHODS, AllocatorKind, AllocatorTy, NO_ALLOC_SHIM_IS_UNSTABLE,
- alloc_error_handler_name, default_fn_name, global_fn_name,
+ AllocatorMethod, AllocatorTy, NO_ALLOC_SHIM_IS_UNSTABLE, default_fn_name, global_fn_name,
 };
 use rustc_middle::bug;
 use rustc_middle::ty::TyCtxt;
@@ -18,8 +17,7 @@ pub(crate) unsafe fn codegen(
  tcx: TyCtxt<'_>,
  mods: &mut GccContext,
  _module_name: &str,
- kind: AllocatorKind,
- alloc_error_handler_kind: AllocatorKind,
+ methods: &[AllocatorMethod],
 ) {
  let context = &mods.context;
  let usize = match tcx.sess.target.pointer_width {
@@ -31,45 +29,35 @@ pub(crate) unsafe fn codegen(
  let i8 = context.new_type::<i8>();
  let i8p = i8.make_pointer();
 
- if kind == AllocatorKind::Default {
- for method in ALLOCATOR_METHODS {
- let mut types = Vec::with_capacity(method.inputs.len());
- for input in method.inputs.iter() {
- match input.ty {
- AllocatorTy::Layout => {
- types.push(usize);
- types.push(usize);
- }
- AllocatorTy::Ptr => types.push(i8p),
- AllocatorTy::Usize => types.push(usize),
-
- AllocatorTy::ResultPtr | AllocatorTy::Unit => panic!("invalid allocator arg"),
+ for method in methods {
+ let mut types = Vec::with_capacity(method.inputs.len());
+ for input in method.inputs.iter() {
+ match input.ty {
+ AllocatorTy::Layout => {
+ types.push(usize);
+ types.push(usize);
  }
- }
- let output = match method.output {
- AllocatorTy::ResultPtr => Some(i8p),
- AllocatorTy::Unit => None,
+ AllocatorTy::Ptr => types.push(i8p),
+ AllocatorTy::Usize => types.push(usize),
 
- AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
- panic!("invalid allocator output")
+ AllocatorTy::Never | AllocatorTy::ResultPtr | AllocatorTy::Unit => {
+ panic!("invalid allocator arg")
  }
- };
- let from_name = mangle_internal_symbol(tcx, &global_fn_name(method.name));
- let to_name = mangle_internal_symbol(tcx, &default_fn_name(method.name));
-
- create_wrapper_function(tcx, context, &from_name, Some(&to_name), &types, output);
+ }
  }
- }
+ let output = match method.output {
+ AllocatorTy::ResultPtr => Some(i8p),
+ AllocatorTy::Never | AllocatorTy::Unit => None,
 
- // FIXME(bjorn3): Add noreturn attribute
- create_wrapper_function(
- tcx,
- context,
- &mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
- Some(&mangle_internal_symbol(tcx, alloc_error_handler_name(alloc_error_handler_kind))),
- &[usize, usize],
- None,
- );
+  AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
+  panic!("invalid allocator output")
+  }
+ };
+ let from_name = mangle_internal_symbol(tcx, &global_fn_name(method.name));
+ let to_name = mangle_internal_symbol(tcx, &default_fn_name(method.name));
+
+ create_wrapper_function(tcx, context, &from_name, Some(&to_name), &types, output);
+ }
 
  create_const_value_function(
  tcx,