Auto merge of rust-lang#126563 - jieyouxu:rollup-7dbtmzk, r=jieyouxu

Rollup of 8 pull requests

Successful merges:

 - rust-lang#126178 (Weekly `cargo update`)
 - rust-lang#126192 (Various Redox OS fixes and add i686 Redox OS target)
 - rust-lang#126365 (Honor collapse_debuginfo for statics.)
 - rust-lang#126524 (bump few deps)
 - rust-lang#126536 (Remove unused `llvm_readobj.rs` in `run-make-support`)
 - rust-lang#126546 (std: move `sys_common::backtrace` to `sys`)
 - rust-lang#126560 (more ice tests)
 - rust-lang#126561 (`boxed_slice_into_iter`: tiny doc correction)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

Cargo.lock

@@ -36,7 +36,7 @@ use rustc_middle::ty::{
 };
 use rustc_session::config::{self, DebugInfo, Lto};
 use rustc_span::symbol::Symbol;
-use rustc_span::FileName;
+use rustc_span::{hygiene, FileName, DUMMY_SP};
 use rustc_span::{FileNameDisplayPreference, SourceFile};
 use rustc_symbol_mangling::typeid_for_trait_ref;
 use rustc_target::abi::{Align, Size};
@@ -1306,7 +1306,7 @@ pub fn build_global_var_di_node<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId, glo
     // We may want to remove the namespace scope if we're in an extern block (see
     // https://github.com/rust-lang/rust/pull/46457#issuecomment-351750952).
     let var_scope = get_namespace_for_item(cx, def_id);
-    let span = tcx.def_span(def_id);
+    let span = hygiene::walk_chain_collapsed(tcx.def_span(def_id), DUMMY_SP);
 
     let (file_metadata, line_number) = if !span.is_dummy() {
         let loc = cx.lookup_debug_loc(span.lo());

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -9,6 +9,10 @@ cfg_match! {
         mod linux;
         use linux as imp;
     }
+    cfg(target_os = "redox") => {
+        mod linux;
+        use linux as imp;
+    }
     cfg(unix) => {
         mod unix;
         use unix as imp;

compiler/rustc_data_structures/src/flock.rs

@@ -52,7 +52,7 @@ declare_lint! {
     /// Since Rust 1.80.0, boxed slices implement `IntoIterator`. However, to avoid
     /// breakage, `boxed_slice.into_iter()` in Rust 2015, 2018, and 2021 code will still
     /// behave as `(&boxed_slice).into_iter()`, returning an iterator over
-    /// references, just like in Rust 1.80.0 and earlier.
+    /// references, just like in Rust 1.79.0 and earlier.
     /// This only applies to the method call syntax `boxed_slice.into_iter()`, not to
     /// any other syntax such as `for _ in boxed_slice` or `IntoIterator::into_iter(boxed_slice)`.
     pub BOXED_SLICE_INTO_ITER,

compiler/rustc_lint/src/shadowed_into_iter.rs

@@ -1,4 +1,4 @@
-use crate::spec::{cvs, RelroLevel, TargetOptions};
+use crate::spec::{cvs, Cc, LinkerFlavor, Lld, RelroLevel, TargetOptions};
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
@@ -12,6 +12,8 @@ pub fn opts() -> TargetOptions {
         has_thread_local: true,
         crt_static_default: true,
         crt_static_respected: true,
+        crt_static_allows_dylibs: true,
+        late_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-lgcc"]),
         ..Default::default()
     }
 }

compiler/rustc_target/src/spec/base/redox.rs

@@ -1647,6 +1647,7 @@ supported_targets! {
     ("x86_64-unknown-l4re-uclibc", x86_64_unknown_l4re_uclibc),
 
     ("aarch64-unknown-redox", aarch64_unknown_redox),
+    ("i686-unknown-redox", i686_unknown_redox),
     ("x86_64-unknown-redox", x86_64_unknown_redox),
 
     ("i386-apple-ios", i386_apple_ios),

compiler/rustc_target/src/spec/mod.rs

@@ -0,0 +1,27 @@
+use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target};
+
+pub fn target() -> Target {
+    let mut base = base::redox::opts();
+    base.cpu = "pentiumpro".into();
+    base.plt_by_default = false;
+    base.max_atomic_width = Some(64);
+    base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]);
+    // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+    base.stack_probes = StackProbeType::Call;
+
+    Target {
+        llvm_target: "i686-unknown-redox".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: None,
+            tier: None,
+            host_tools: None,
+            std: None,
+        },
+        pointer_width: 32,
+        data_layout:
+            "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128"
+                .into(),
+        arch: "x86".into(),
+        options: base,
+    }
+}

compiler/rustc_target/src/spec/targets/i686_unknown_redox.rs

@@ -95,7 +95,7 @@ use crate::fmt;
 use crate::panic::UnwindSafe;
 use crate::sync::atomic::{AtomicU8, Ordering::Relaxed};
 use crate::sync::LazyLock;
-use crate::sys_common::backtrace::{lock, output_filename, set_image_base};
+use crate::sys::backtrace::{lock, output_filename, set_image_base};
 
 /// A captured OS thread stack backtrace.
 ///

library/std/src/backtrace.rs

@@ -429,7 +429,7 @@ impl<E> Report<E> {
     ///    1: rust_out::main::_doctest_main_src_error_rs_1158_0
     ///    2: rust_out::main
     ///    3: core::ops::function::FnOnce::call_once
-    ///    4: std::sys_common::backtrace::__rust_begin_short_backtrace
+    ///    4: std::sys::backtrace::__rust_begin_short_backtrace
     ///    5: std::rt::lang_start::{{closure}}
     ///    6: std::panicking::try
     ///    7: std::rt::lang_start_internal

library/std/src/error.rs

@@ -19,8 +19,8 @@ use crate::mem::{self, ManuallyDrop};
 use crate::process;
 use crate::sync::atomic::{AtomicBool, Ordering};
 use crate::sync::{PoisonError, RwLock};
+use crate::sys::backtrace;
 use crate::sys::stdio::panic_output;
-use crate::sys_common::backtrace;
 use crate::thread;
 
 #[cfg(not(test))]
@@ -655,7 +655,7 @@ pub fn begin_panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
 
     let loc = info.location().unwrap(); // The current implementation always returns Some
     let msg = info.message();
-    crate::sys_common::backtrace::__rust_end_short_backtrace(move || {
+    crate::sys::backtrace::__rust_end_short_backtrace(move || {
         if let Some(s) = msg.as_str() {
             rust_panic_with_hook(
                 &mut StaticStrPayload(s),
@@ -727,7 +727,7 @@ pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
     }
 
     let loc = Location::caller();
-    crate::sys_common::backtrace::__rust_end_short_backtrace(move || {
+    crate::sys::backtrace::__rust_end_short_backtrace(move || {
         rust_panic_with_hook(
             &mut Payload { inner: Some(msg) },
             loc,