Merge commit '4f83a4258deb99f3288a7122c0d5a78200931c61' into subtree-update_cg_gcc_2025-04-25

compiler/rustc_codegen_gcc/rust-toolchain

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-04-17"
+channel = "nightly-2025-04-25"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]

compiler/rustc_codegen_gcc/src/asm.rs

@@ -165,10 +165,10 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
         let mut input_registers = vec![];
 
         for op in rust_operands {
-            if let InlineAsmOperandRef::In { reg, .. } = *op {
+            if let InlineAsmOperandRef::In { reg, .. } = *op
-                if let ConstraintOrRegister::Register(reg_name) = reg_to_gcc(reg) {
+                && let ConstraintOrRegister::Register(reg_name) = reg_to_gcc(reg)
-                    input_registers.push(reg_name);
+            {
-                }
+                input_registers.push(reg_name);
             }
         }
 

compiler/rustc_codegen_gcc/src/common.rs

@@ -33,12 +33,11 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
     }
 
     pub fn const_bitcast(&self, value: RValue<'gcc>, typ: Type<'gcc>) -> RValue<'gcc> {
-        if value.get_type() == self.bool_type.make_pointer() {
+        if value.get_type() == self.bool_type.make_pointer()
-            if let Some(pointee) = typ.get_pointee() {
+            && let Some(pointee) = typ.get_pointee()
-                if pointee.dyncast_vector().is_some() {
+            && pointee.dyncast_vector().is_some()
-                    panic!()
+        {
-                }
+            panic!()
-            }
         }
         // NOTE: since bitcast makes a value non-constant, don't bitcast if not necessary as some
         // SIMD builtins require a constant value.

compiler/rustc_codegen_gcc/src/consts.rs

@@ -242,10 +242,10 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let fn_attrs = self.tcx.codegen_fn_attrs(def_id);
 
         let global = if def_id.is_local() && !self.tcx.is_foreign_item(def_id) {
-            if let Some(global) = self.get_declared_value(sym) {
+            if let Some(global) = self.get_declared_value(sym)
-                if self.val_ty(global) != self.type_ptr_to(gcc_type) {
+                && self.val_ty(global) != self.type_ptr_to(gcc_type)
-                    span_bug!(self.tcx.def_span(def_id), "Conflicting types for static");
+            {
-                }
+                span_bug!(self.tcx.def_span(def_id), "Conflicting types for static");
             }
 
             let is_tls = fn_attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL);

compiler/rustc_codegen_gcc/src/debuginfo.rs

@@ -126,14 +126,15 @@ fn make_mir_scope<'gcc, 'tcx>(
         return;
     };
 
-    if let Some(ref vars) = *variables {
+    if let Some(ref vars) = *variables
-        if !vars.contains(scope) && scope_data.inlined.is_none() {
+        && !vars.contains(scope)
-            // Do not create a DIScope if there are no variables defined in this
+        && scope_data.inlined.is_none()
-            // MIR `SourceScope`, and it's not `inlined`, to avoid debuginfo bloat.
+    {
-            debug_context.scopes[scope] = parent_scope;
+        // Do not create a DIScope if there are no variables defined in this
-            instantiated.insert(scope);
+        // MIR `SourceScope`, and it's not `inlined`, to avoid debuginfo bloat.
-            return;
+        debug_context.scopes[scope] = parent_scope;
-        }
+        instantiated.insert(scope);
+        return;
     }
 
     let loc = cx.lookup_debug_loc(scope_data.span.lo());

compiler/rustc_codegen_gcc/src/gcc_util.rs

@@ -136,14 +136,12 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
         });
     features.extend(feats);
 
-    if diagnostics {
+    if diagnostics && let Some(f) = check_tied_features(sess, &featsmap) {
-        if let Some(f) = check_tied_features(sess, &featsmap) {
+        sess.dcx().emit_err(TargetFeatureDisableOrEnable {
-            sess.dcx().emit_err(TargetFeatureDisableOrEnable {
+            features: f,
-                features: f,
+            span: None,
-                span: None,
+            missing_features: None,
-                missing_features: None,
+        });
-            });
-        }
     }
 
     features

compiler/rustc_codegen_gcc/src/lib.rs

@@ -22,7 +22,7 @@
 #![warn(rust_2018_idioms)]
 #![warn(unused_lifetimes)]
 #![deny(clippy::pattern_type_mismatch)]
-#![allow(clippy::needless_lifetimes)]
+#![allow(clippy::needless_lifetimes, clippy::uninlined_format_args)]
 
 // Some "regular" crates we want to share with rustc
 extern crate object;

compiler/rustc_codegen_gcc/src/type_of.rs

@@ -102,10 +102,10 @@ fn uncached_gcc_type<'gcc, 'tcx>(
             let mut name = with_no_trimmed_paths!(layout.ty.to_string());
             if let (&ty::Adt(def, _), &Variants::Single { index }) =
                 (layout.ty.kind(), &layout.variants)
+                && def.is_enum()
+                && !def.variants().is_empty()
             {
-                if def.is_enum() && !def.variants().is_empty() {
+                write!(&mut name, "::{}", def.variant(index).name).unwrap();
-                    write!(&mut name, "::{}", def.variant(index).name).unwrap();
-                }
             }
             if let (&ty::Coroutine(_, _), &Variants::Single { index }) =
                 (layout.ty.kind(), &layout.variants)
@@ -264,10 +264,10 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
     }
 
     fn immediate_gcc_type<'gcc>(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc> {
-        if let BackendRepr::Scalar(ref scalar) = self.backend_repr {
+        if let BackendRepr::Scalar(ref scalar) = self.backend_repr
-            if scalar.is_bool() {
+            && scalar.is_bool()
-                return cx.type_i1();
+        {
-            }
+            return cx.type_i1();
         }
         self.gcc_type(cx)
     }

compiler/rustc_codegen_gcc/tests/lang_tests_common.rs

@@ -1,5 +1,7 @@
 //! The common code for `tests/lang_tests_*.rs`
 
+#![allow(clippy::uninlined_format_args)]
+
 use std::env::{self, current_dir};
 use std::path::{Path, PathBuf};
 use std::process::Command;

compiler/rustc_codegen_gcc/tests/run/ptr_cast.rs

@@ -5,6 +5,7 @@
 //   stdout: 10
 //     10
 //     42
+//     1
 
 #![feature(no_core)]
 #![no_std]
@@ -21,6 +22,8 @@ fn int_cast(a: u16, b: i16) -> (u8, u16, u32, usize, i8, i16, i32, isize, u8, u3
     )
 }
 
+static mut ONE: usize = 1;
+
 #[no_mangle]
 extern "C" fn main(argc: i32, _argv: *const *const u8) -> i32 {
     let (a, b, c, d, e, f, g, h, i, j) = int_cast(10, 42);
@@ -28,6 +31,10 @@ extern "C" fn main(argc: i32, _argv: *const *const u8) -> i32 {
         libc::printf(b"%d\n\0" as *const u8 as *const i8, c);
         libc::printf(b"%ld\n\0" as *const u8 as *const i8, d);
         libc::printf(b"%ld\n\0" as *const u8 as *const i8, j);
+
+        let ptr = ONE as *mut usize;
+        let value = ptr as usize;
+        libc::printf(b"%ld\n\0" as *const u8 as *const i8, value);
     }
     0
 }