bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #137231 - Urgau:rollup-heiq934, r=Urgau

Browse source 
Rollup of 9 pull requests

Successful merges:

 - #136750 (Make ub_check message clear that it's not an assert)
 - #137151 (Install more signal stack trace handlers)
 - #137167 (tests: Also gate `f16::erfc()` doctest with `reliable_f16_math` cfg)
 - #137195 (cg_clif: use exclusively ABI alignment)
 - #137202 (Enforce T: Hash for Interned<...>)
 - #137205 (Remove `std::os::wasi::fs::FileExt::tell`)
 - #137211 (don't ICE for alias-relate goals with error term)
 - #137214 (add last std diagnostic items for clippy)
 - #137221 (Remove scrutinee_hir_id from ExprKind::Match)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2025-02-18 18:04:32 +00:00
commit 827a0d638d
20 changed files with 134 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

7
compiler/rustc_codegen_cranelift/src/abi/comments.rs
View file

@ -65,7 +65,7 @@ pub(super) fn add_locals_header_comment(fx: &mut FunctionCx<'_, '_, '_>) {
if fx.clif_comments.enabled() {
fx.add_global_comment(String::new());
fx.add_global_comment(
"kind local ty size align (abi,pref)".to_string(),
"kind local ty size align (abi)".to_string(),
);
}
}
@ -84,14 +84,13 @@ pub(super) fn add_local_place_comments<'tcx>(
let (kind, extra) = place.debug_comment();
fx.add_global_comment(format!(
"{:<5} {:5} {:30} {:4}b {}, {}{}{}",
"{:<5} {:5} {:30} {:4}b {}{}{}",
kind,
format!("{:?}", local),
format!("{:?}", ty),
size.bytes(),
align.abi.bytes(),
align.pref.bytes(),
if extra.is_empty() { "" } else { " " },
if extra.is_empty() { "" } else { " " },
extra,
));
}

2
compiler/rustc_codegen_cranelift/src/constant.rs
View file

@ -272,7 +272,7 @@ fn data_id_for_static(
.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty))
.unwrap()
.align
.pref
.abi
.bytes();
let linkage = if import_linkage == rustc_middle::mir::mono::Linkage::ExternalWeak

5
compiler/rustc_data_structures/src/intern.rs
View file

@ -92,7 +92,10 @@ impl<'a, T: Ord> Ord for Interned<'a, T> {
}
}
impl<'a, T> Hash for Interned<'a, T> {
impl<'a, T> Hash for Interned<'a, T>
where
T: Hash,
{
#[inline]
fn hash<H: Hasher>(&self, s: &mut H) {
// Pointer hashing is sufficient, due to the uniqueness constraint.

50
compiler/rustc_driver_impl/src/signal_handler.rs
View file

@ -6,6 +6,15 @@ use std::{fmt, mem, ptr, slice};
use rustc_interface::util::{DEFAULT_STACK_SIZE, STACK_SIZE};
/// Signals that represent that we have a bug, and our prompt termination has
/// been ordered.
#[rustfmt::skip]
const KILL_SIGNALS: [(libc::c_int, &str); 3] = [
(libc::SIGILL, "SIGILL"),
(libc::SIGBUS, "SIGBUS"),
(libc::SIGSEGV, "SIGSEGV")
];
unsafe extern "C" {
fn backtrace_symbols_fd(buffer: *const *mut libc::c_void, size: libc::c_int, fd: libc::c_int);
}
@ -39,8 +48,19 @@ macro raw_errln($tokens:tt) {
/// # Safety
///
/// Caller must ensure that this function is not re-entered.
unsafe extern "C" fn print_stack_trace(_: libc::c_int) {
unsafe extern "C" fn print_stack_trace(signum: libc::c_int) {
const MAX_FRAMES: usize = 256;
let signame = {
let mut signame = "<unknown>";
for sig in KILL_SIGNALS {
if sig.0 == signum {
signame = sig.1;
}
}
signame
};
let stack = unsafe {
// Reserve data segment so we don't have to malloc in a signal handler, which might fail
// in incredibly undesirable and unexpected ways due to e.g. the allocator deadlocking
@ -54,7 +74,8 @@ unsafe extern "C" fn print_stack_trace(_: libc::c_int) {
};
// Just a stack trace is cryptic. Explain what we're doing.
raw_errln!("error: rustc interrupted by SIGSEGV, printing backtrace\n");
raw_errln!("error: rustc interrupted by {signame}, printing backtrace\n");
let mut written = 1;
let mut consumed = 0;
// Begin elaborating return addrs into symbols and writing them directly to stderr
@ -94,7 +115,7 @@ unsafe extern "C" fn print_stack_trace(_: libc::c_int) {
written += rem.len() + 1;
let random_depth = || 8 * 16; // chosen by random diceroll (2d20)
if cyclic || stack.len() > random_depth() {
if (cyclic || stack.len() > random_depth()) && signum == libc::SIGSEGV {
// technically speculation, but assert it with confidence anyway.
// rustc only arrived in this signal handler because bad things happened
// and this message is for explaining it's not the programmer's fault
@ -106,17 +127,22 @@ unsafe extern "C" fn print_stack_trace(_: libc::c_int) {
written += 1;
}
raw_errln!("note: we would appreciate a report at https://github.com/rust-lang/rust");
// get the current stack size WITHOUT blocking and double it
let new_size = STACK_SIZE.get().copied().unwrap_or(DEFAULT_STACK_SIZE) * 2;
raw_errln!("help: you can increase rustc's stack size by setting RUST_MIN_STACK={new_size}");
written += 2;
written += 1;
if signum == libc::SIGSEGV {
// get the current stack size WITHOUT blocking and double it
let new_size = STACK_SIZE.get().copied().unwrap_or(DEFAULT_STACK_SIZE) * 2;
raw_errln!(
"help: you can increase rustc's stack size by setting RUST_MIN_STACK={new_size}"
);
written += 1;
}
if written > 24 {
// We probably just scrolled the earlier "we got SIGSEGV" message off the terminal
raw_errln!("note: backtrace dumped due to SIGSEGV! resuming signal");
// We probably just scrolled the earlier "interrupted by {signame}" message off the terminal
raw_errln!("note: backtrace dumped due to {signame}! resuming signal");
};
}
/// When SIGSEGV is delivered to the process, print a stack trace and then exit.
/// When one of the KILL signals is delivered to the process, print a stack trace and then exit.
pub(super) fn install() {
unsafe {
let alt_stack_size: usize = min_sigstack_size() + 64 * 1024;
@ -129,7 +155,9 @@ pub(super) fn install() {
sa.sa_sigaction = print_stack_trace as libc::sighandler_t;
sa.sa_flags = libc::SA_NODEFER | libc::SA_RESETHAND | libc::SA_ONSTACK;
libc::sigemptyset(&mut sa.sa_mask);
libc::sigaction(libc::SIGSEGV, &sa, ptr::null_mut());
for (signum, _signame) in KILL_SIGNALS {
libc::sigaction(signum, &sa, ptr::null_mut());
}
}
}

1
compiler/rustc_middle/src/thir.rs
View file

@ -376,7 +376,6 @@ pub enum ExprKind<'tcx> {
/// A `match` expression.
Match {
scrutinee: ExprId,
scrutinee_hir_id: HirId,
arms: Box<[ArmId]>,
match_source: MatchSource,
},

1
compiler/rustc_mir_build/src/thir/cx/expr.rs
View file

@ -828,7 +828,6 @@ impl<'tcx> ThirBuildCx<'tcx> {
},
hir::ExprKind::Match(discr, arms, match_source) => ExprKind::Match {
scrutinee: self.mirror_expr(discr),
scrutinee_hir_id: discr.hir_id,
arms: arms.iter().map(|a| self.convert_arm(a)).collect(),
match_source,
},

2
compiler/rustc_mir_build/src/thir/pattern/check_match.rs
View file

@ -151,7 +151,7 @@ impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
}
return;
}
ExprKind::Match { scrutinee, scrutinee_hir_id: _, box ref arms, match_source } => {
ExprKind::Match { scrutinee, box ref arms, match_source } => {
self.check_match(scrutinee, arms, match_source, ex.span);
}
ExprKind::Let { box ref pat, expr } => {

12
compiler/rustc_next_trait_solver/src/solve/alias_relate.rs
View file

@ -34,7 +34,17 @@ where
) -> QueryResult<I> {
let cx = self.cx();
let Goal { param_env, predicate: (lhs, rhs, direction) } = goal;
debug_assert!(lhs.to_alias_term().is_some() || rhs.to_alias_term().is_some());
// Check that the alias-relate goal is reasonable. Writeback for
// `coroutine_stalled_predicates` can replace alias terms with
// `{type error}` if the alias still contains infer vars, so we also
// accept alias-relate goals where one of the terms is an error.
debug_assert!(
lhs.to_alias_term().is_some()
|| rhs.to_alias_term().is_some()
|| lhs.is_error()
|| rhs.is_error()
);
// Structurally normalize the lhs.
let lhs = if let Some(alias) = lhs.to_alias_term() {

13
compiler/rustc_resolve/src/imports.rs
View file

@ -182,6 +182,19 @@ pub(crate) struct ImportData<'ra> {
/// so we can use referential equality to compare them.
pub(crate) type Import<'ra> = Interned<'ra, ImportData<'ra>>;
// Allows us to use Interned without actually enforcing (via Hash/PartialEq/...) uniqueness of the
// contained data.
// FIXME: We may wish to actually have at least debug-level assertions that Interned's guarantees
// are upheld.
impl std::hash::Hash for ImportData<'_> {
fn hash<H>(&self, _: &mut H)
where
H: std::hash::Hasher,
{
unreachable!()
}
}
impl<'ra> ImportData<'ra> {
pub(crate) fn is_glob(&self) -> bool {
matches!(self.kind, ImportKind::Glob { .. })

26
compiler/rustc_resolve/src/lib.rs
View file

@ -589,6 +589,19 @@ struct ModuleData<'ra> {
#[rustc_pass_by_value]
struct Module<'ra>(Interned<'ra, ModuleData<'ra>>);
// Allows us to use Interned without actually enforcing (via Hash/PartialEq/...) uniqueness of the
// contained data.
// FIXME: We may wish to actually have at least debug-level assertions that Interned's guarantees
// are upheld.
impl std::hash::Hash for ModuleData<'_> {
fn hash<H>(&self, _: &mut H)
where
H: std::hash::Hasher,
{
unreachable!()
}
}
impl<'ra> ModuleData<'ra> {
fn new(
parent: Option<Module<'ra>>,
@ -739,6 +752,19 @@ struct NameBindingData<'ra> {
/// so we can use referential equality to compare them.
type NameBinding<'ra> = Interned<'ra, NameBindingData<'ra>>;
// Allows us to use Interned without actually enforcing (via Hash/PartialEq/...) uniqueness of the
// contained data.
// FIXME: We may wish to actually have at least debug-level assertions that Interned's guarantees
// are upheld.
impl std::hash::Hash for NameBindingData<'_> {
fn hash<H>(&self, _: &mut H)
where
H: std::hash::Hasher,
{
unreachable!()
}
}
trait ToNameBinding<'ra> {
fn to_name_binding(self, arenas: &'ra ResolverArenas<'ra>) -> NameBinding<'ra>;
}

7
compiler/rustc_span/src/symbol.rs
View file

@ -192,6 +192,7 @@ symbols! {
Capture,
Cell,
Center,
Child,
Cleanup,
Clone,
CoercePointee,
@ -336,6 +337,7 @@ symbols! {
SliceIter,
Some,
SpanCtxt,
Stdin,
String,
StructuralPartialEq,
SubdiagMessage,
@ -599,6 +601,9 @@ symbols! {
cfi,
cfi_encoding,
char,
char_is_ascii,
child_id,
child_kill,
client,
clippy,
clobber_abi,
@ -1468,6 +1473,7 @@ symbols! {
panic_2015,
panic_2021,
panic_abort,
panic_any,
panic_bounds_check,
panic_cannot_unwind,
panic_const_add_overflow,
@ -1573,6 +1579,7 @@ symbols! {
proc_macro_mod,
proc_macro_non_items,
proc_macro_path_invoc,
process_abort,
process_exit,
profiler_builtins,
profiler_runtime,

15
compiler/rustc_type_ir/src/inherent.rs
View file

@ -126,6 +126,10 @@ pub trait Ty<I: Interner<Ty = Self>>:
matches!(self.kind(), ty::Infer(ty::TyVar(_)))
}
fn is_ty_error(self) -> bool {
matches!(self.kind(), ty::Error(_))
}
fn is_floating_point(self) -> bool {
matches!(self.kind(), ty::Float(_) | ty::Infer(ty::FloatVar(_)))
}
@ -284,6 +288,10 @@ pub trait Const<I: Interner<Const = Self>>:
fn is_ct_var(self) -> bool {
matches!(self.kind(), ty::ConstKind::Infer(ty::InferConst::Var(_)))
}
fn is_ct_error(self) -> bool {
matches!(self.kind(), ty::ConstKind::Error(_))
}
}
pub trait ValueConst<I: Interner<ValueConst = Self>>: Copy + Debug + Hash + Eq {
@ -370,6 +378,13 @@ pub trait Term<I: Interner<Term = Self>>:
}
}
fn is_error(self) -> bool {
match self.kind() {
ty::TermKind::Ty(ty) => ty.is_ty_error(),
ty::TermKind::Const(ct) => ct.is_ct_error(),
}
}
fn to_alias_term(self) -> Option<ty::AliasTerm<I>> {
match self.kind() {
ty::TermKind::Ty(ty) => match ty.kind() {

1
library/core/src/char/methods.rs
View file

@ -1168,6 +1168,7 @@ impl char {
#[must_use]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[rustc_const_stable(feature = "const_char_is_ascii", since = "1.32.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "char_is_ascii")]
#[inline]
pub const fn is_ascii(&self) -> bool {
*self as u32 <= 0x7F

6
library/core/src/ub_checks.rs
View file

@ -65,9 +65,9 @@ macro_rules! assert_unsafe_precondition {
#[rustc_nounwind]
const fn precondition_check($($name:$ty),*) {
if !$e {
::core::panicking::panic_nounwind(
concat!("unsafe precondition(s) violated: ", $message)
);
::core::panicking::panic_nounwind(concat!("unsafe precondition(s) violated: ", $message,
"\n\nThis indicates a bug in the program. \
This Undefined Behavior check is optional, and cannot be relied on for safety."));
}
}

2
library/std/src/f16.rs
View file

@ -1321,12 +1321,14 @@ impl f16 {
/// ```
/// #![feature(f16)]
/// #![feature(float_erf)]
/// # #[cfg(reliable_f16_math)] {
/// let x: f16 = 0.123;
///
/// let one = x.erf() + x.erfc();
/// let abs_difference = (one - 1.0).abs();
///
/// assert!(abs_difference <= f16::EPSILON);
/// # }
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]

1
library/std/src/io/stdio.rs
View file

@ -239,6 +239,7 @@ fn handle_ebadf_lazy<T>(r: io::Result<T>, default: impl FnOnce() -> T) -> io::Re
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "Stdin")]
pub struct Stdin {
inner: &'static Mutex<BufReader<StdinRaw>>,
}

11
library/std/src/os/wasi/fs.rs
View file

@ -162,13 +162,6 @@ pub trait FileExt {
Ok(())
}
/// Returns the current position within the file.
///
/// This corresponds to the `fd_tell` syscall and is similar to
/// `seek` where you offset 0 bytes from the current position.
#[doc(alias = "fd_tell")]
fn tell(&self) -> io::Result<u64>;
/// Adjusts the flags associated with this file.
///
/// This corresponds to the `fd_fdstat_set_flags` syscall.
@ -240,10 +233,6 @@ impl FileExt for fs::File {
self.as_inner().as_inner().pwrite(bufs, offset)
}
fn tell(&self) -> io::Result<u64> {
self.as_inner().as_inner().tell()
}
fn fdstat_set_flags(&self, flags: u16) -> io::Result<()> {
self.as_inner().as_inner().set_flags(flags)
}

1
library/std/src/panic.rs
View file

@ -255,6 +255,7 @@ pub use crate::panicking::{set_hook, take_hook};
#[stable(feature = "panic_any", since = "1.51.0")]
#[inline]
#[track_caller]
#[cfg_attr(not(test), rustc_diagnostic_item = "panic_any")]
pub fn panic_any<M: 'static + Any + Send>(msg: M) -> ! {
crate::panicking::begin_panic(msg);
}

4
library/std/src/process.rs
View file

@ -217,6 +217,7 @@ use crate::{fmt, fs, str};
///
/// [`wait`]: Child::wait
#[stable(feature = "process", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "Child")]
pub struct Child {
pub(crate) handle: imp::Process,
@ -2115,6 +2116,7 @@ impl Child {
/// [`ErrorKind`]: io::ErrorKind
/// [`InvalidInput`]: io::ErrorKind::InvalidInput
#[stable(feature = "process", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "child_kill")]
pub fn kill(&mut self) -> io::Result<()> {
self.handle.kill()
}
@ -2135,6 +2137,7 @@ impl Child {
/// ```
#[must_use]
#[stable(feature = "process_id", since = "1.3.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "child_id")]
pub fn id(&self) -> u32 {
self.handle.id()
}
@ -2375,6 +2378,7 @@ pub fn exit(code: i32) -> ! {
/// [panic hook]: crate::panic::set_hook
#[stable(feature = "process_abort", since = "1.17.0")]
#[cold]
#[cfg_attr(not(test), rustc_diagnostic_item = "process_abort")]
pub fn abort() -> ! {
crate::sys::abort_internal();
}

2
src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr
View file

@ -1,6 +1,8 @@
thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
unsafe precondition(s) violated: ptr::swap_nonoverlapping requires that both pointer arguments are aligned and non-null and the specified memory ranges do not overlap
This indicates a bug in the program. This Undefined Behavior check is optional, and cannot be relied on for safety.
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
thread caused non-unwinding panic. aborting.