What if we skip the projection loop in analyze altogether?

Author: scottmcm

compiler/rustc_codegen_ssa/src/mir/analyze.rs

@@ -1,13 +1,12 @@
 //! An analysis to determine which locals require allocas and
 //! which do not.
 
-use rustc_abi as abi;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::{self, DefLocation, Location, TerminatorKind, traversal};
-use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
+use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::{bug, span_bug};
 use tracing::debug;
 
@@ -135,74 +134,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'b, 'tcx>> LocalAnalyzer<'a, 'b, 'tcx, Bx>
                 self.visit_local(place_ref.local, mut_projection, location);
                 return;
             }
-
-            // Scan through to ensure the only projections are those which
-            // `FunctionCx::maybe_codegen_consume_direct` can handle.
-            let base_ty = self.fx.monomorphized_place_ty(mir::PlaceRef::from(place_ref.local));
-            let mut layout = self.fx.cx.layout_of(base_ty);
-            for elem in place_ref.projection {
-                if layout.is_zst() {
-                    // Any further projections must still be ZSTs, so we're good.
-                    break;
-                }
-
-                #[track_caller]
-                fn compatible_projection(src: TyAndLayout<'_>, tgt: TyAndLayout<'_>) -> bool {
-                    fn compatible_initness(a: abi::Scalar, b: abi::Scalar) -> bool {
-                        !a.is_uninit_valid() || b.is_uninit_valid()
-                    }
-
-                    use abi::BackendRepr::*;
-                    match (src.backend_repr, tgt.backend_repr) {
-                        _ if tgt.is_zst() => true,
-                        (Scalar(a), Scalar(b))
-                        | (SimdVector { element: a, .. }, SimdVector { element: b, .. }) => {
-                            compatible_initness(a, b)
-                        }
-                        (ScalarPair(a0, a1), Scalar(b)) => {
-                            compatible_initness(a0, b) && compatible_initness(a1, b)
-                        }
-                        (ScalarPair(a0, a1), ScalarPair(b0, b1)) => {
-                            compatible_initness(a0, b0) && compatible_initness(a1, b1)
-                        }
-                        _ => bug!("Mismatched layouts in analysis\nsrc: {src:?}\ntgt: {tgt:?}"),
-                    }
-                }
-
-                match *elem {
-                    mir::PlaceElem::Field(fidx, ..) => {
-                        let field_layout = layout.field(self.fx.cx, fidx.as_usize());
-                        if compatible_projection(layout, field_layout) {
-                            layout = field_layout;
-                            continue;
-                        }
-                    }
-                    mir::PlaceElem::Downcast(_, vidx) => {
-                        let variant_layout = layout.for_variant(self.fx.cx, vidx);
-                        if compatible_projection(layout, variant_layout) {
-                            layout = variant_layout;
-                            continue;
-                        }
-                    }
-
-                    mir::PlaceElem::Index(..)
-                    | mir::PlaceElem::ConstantIndex { .. }
-                    | mir::PlaceElem::Subslice { .. }
-                    | mir::PlaceElem::OpaqueCast(..)
-                    | mir::PlaceElem::UnwrapUnsafeBinder(..)
-                    | mir::PlaceElem::Subtype(..) => {}
-
-                    mir::PlaceElem::Deref => bug!("Deref after first position"),
-                }
-
-                // If the above didn't `continue`, we can't handle the projection.
-                self.locals[place_ref.local] = LocalKind::Memory;
-                return;
-            }
-            debug_assert!(
-                !self.fx.cx.is_backend_ref(layout),
-                "Post-projection {place_ref:?} layout should be non-Ref, but it's {layout:?}",
-            );
         }
 
         // Even with supported projections, we still need to have `visit_local`

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -371,7 +371,7 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
             self.val
         } else if field.size == layout.size {
             debug_assert_eq!(offset.bytes(), 0);
-            if downcast_variant.is_some() {
+            if downcast_variant.is_some() || self.layout.ty.is_union() {
                 fx.codegen_transmute_operand(bx, *self, field)
             } else {
                 self.val

tests/codegen/enum/enum-extract.rs

@@ -16,28 +16,20 @@ use std::mem::MaybeUninit;
 use std::num::NonZero;
 use std::ptr::NonNull;
 
-// This doesn't actually end up in an SSA value because `extract_field`
-// doesn't know how to do the equivalent of `!noundef` without a load.
 #[no_mangle]
 fn use_option_u32(x: Option<u32>) -> u32 {
     // CHECK-LABEL: @use_option_u32
-    // OPT-SAME: (i32 noundef range(i32 0, 2) %0, i32 %1)
+    // OPT-SAME: (i32 noundef range(i32 0, 2) %x.0, i32 %x.1)
 
     // CHECK-NOT: alloca
-    // CHECK: %x = alloca [8 x i8]
-    // CHECK-NOT: alloca
-    // CHECK: %[[X0:.+]] = load i32, ptr %x
-    // CHECK: %[[DISCR:.+]] = zext i32 %[[X0]] to i64
+    // CHECK: %[[DISCR:.+]] = zext i32 %x.0 to i64
     // CHECK: %[[IS_SOME:.+]] = trunc nuw i64 %[[DISCR]] to i1
     // OPT: %[[LIKELY:.+]] = call i1 @llvm.expect.i1(i1 %[[IS_SOME]], i1 true)
     // OPT: br i1 %[[LIKELY]], label %[[BLOCK:.+]],
     // DBG: br i1 %[[IS_SOME]], label %[[BLOCK:.+]],
 
     // CHECK: [[BLOCK]]:
-    // CHECK: %[[X1P:.+]] = getelementptr inbounds i8, ptr %x, i64 4
-    // CHECK: %[[X1:.+]] = load i32, ptr %[[X1P]]
-    // OPT-SAME: !noundef
-    // CHECK: ret i32 %[[X1]]
+    // CHECK: ret i32 %x.1
 
     if let Some(val) = x { val } else { unreachable!() }
 }

tests/codegen/intrinsics/cold_path3.rs

@@ -44,8 +44,8 @@ pub fn test(x: Option<u32>) {
         _ => path_a(),
     }
 
-    // CHECK-LABEL: @test({{.+}} %0, {{.+}} %1)
-    // CHECK: switch i32 %1, label %bb1 [
+    // CHECK-LABEL: @test({{.+}} %x.0, {{.+}} %x.1)
+    // CHECK: switch i32 %x.1, label %bb1 [
     // CHECK: i32 0, label %bb6
     // CHECK: i32 1, label %bb5
     // CHECK: i32 2, label %bb4
@@ -75,8 +75,8 @@ pub fn test2(x: Option<u32>) {
         }
     }
 
-    // CHECK-LABEL: @test2({{.+}} %0, {{.+}} %1)
-    // CHECK: switch i32 %1, label %bb1 [
+    // CHECK-LABEL: @test2({{.+}} %x.0, {{.+}} %x.1)
+    // CHECK: switch i32 %x.1, label %bb1 [
     // CHECK: i32 10, label %bb5
     // CHECK: i32 11, label %bb4
     // CHECK: i32 13, label %bb3

tests/codegen/range-loop.rs

@@ -14,7 +14,6 @@ pub fn call_for_zero_to_n(n: u32, f: fn(u32)) {
     // CHECK: start:
     // CHECK-NOT: alloca
     // CHECK: %[[IND:.+]] = alloca [4 x i8]
-    // CHECK-NEXT: %[[ALWAYS_SOME_OPTION:.+]] = alloca
     // CHECK-NOT: alloca
     // CHECK: store i32 0, ptr %[[IND]],
     // CHECK: br label %[[HEAD:.+]]
@@ -31,10 +30,7 @@ pub fn call_for_zero_to_n(n: u32, f: fn(u32)) {
     // CHECK: %[[T2:.+]] = load i32, ptr %[[IND]],
     // CHECK: %[[T3:.+]] = add nuw i32 %[[T2]], 1
     // CHECK: store i32 %[[T3]], ptr %[[IND]],
-
-    // CHECK: store i32 %[[T2]]
-    // CHECK: %[[T4:.+]] = load i32
-    // CHECK: call void %f(i32{{.+}}%[[T4]])
+    // CHECK: call void %f(i32{{.+}}%[[T2]])
 
     for i in 0..n {
         f(i);

tests/codegen/try_question_mark_nop.rs

@@ -12,18 +12,18 @@
 use std::ops::ControlFlow::{self, Break, Continue};
 use std::ptr::NonNull;
 
-// CHECK-LABEL: @option_nop_match_32({{.+}} %0, {{.+}} %1)
+// CHECK-LABEL: @option_nop_match_32({{.+}} %x.0, {{.+}} %x.1)
 #[no_mangle]
 pub fn option_nop_match_32(x: Option<u32>) -> Option<u32> {
     // CHECK: start:
-    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i32 %0 to i1
+    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i32 %x.0 to i1
 
-    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %0, i32 0
+    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %x.0, i32 0
     // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 [[SELECT]], 0
-    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 %1, 1
+    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 %x.1, 1
 
-    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %1, i32 undef
-    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 %0, 0
+    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %x.1, i32 undef
+    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 %x.0, 0
     // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 [[SELECT]], 1
 
     // CHECK-NEXT: ret { i32, i32 } [[REG3]]
@@ -33,12 +33,12 @@ pub fn option_nop_match_32(x: Option<u32>) -> Option<u32> {
     }
 }
 
-// CHECK-LABEL: @option_nop_traits_32({{.+}} %0, {{.+}} %1)
+// CHECK-LABEL: @option_nop_traits_32({{.+}} %x.0, {{.+}} %x.1)
 #[no_mangle]
 pub fn option_nop_traits_32(x: Option<u32>) -> Option<u32> {
     // CHECK: start:
-    // TWENTY-NEXT: %[[IS_SOME:.+]] = trunc nuw i32 %0 to i1
-    // TWENTY-NEXT: select i1 %[[IS_SOME]], i32 %1, i32 undef
+    // TWENTY-NEXT: %[[IS_SOME:.+]] = trunc nuw i32 %x.0 to i1
+    // TWENTY-NEXT: select i1 %[[IS_SOME]], i32 %x.1, i32 undef
     // CHECK-NEXT: insertvalue { i32, i32 }
     // CHECK-NEXT: insertvalue { i32, i32 }
     // CHECK-NEXT: ret { i32, i32 }
@@ -91,18 +91,18 @@ pub fn control_flow_nop_traits_32(x: ControlFlow<i32, u32>) -> ControlFlow<i32,
     try { x? }
 }
 
-// CHECK-LABEL: @option_nop_match_64({{.+}} %0, {{.+}} %1)
+// CHECK-LABEL: @option_nop_match_64({{.+}} %x.0, {{.+}} %x.1)
 #[no_mangle]
 pub fn option_nop_match_64(x: Option<u64>) -> Option<u64> {
     // CHECK: start:
-    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i64 %0 to i1
+    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i64 %x.0 to i1
 
-    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %0, i64 0
+    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %x.0, i64 0
     // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 [[SELECT]], 0
-    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 %1, 1
+    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 %x.1, 1
 
-    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %1, i64 undef
-    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 %0, 0
+    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %x.1, i64 undef
+    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 %x.0, 0
     // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 [[SELECT]], 1
 
     // CHECK-NEXT: ret { i64, i64 } [[REG3]]
@@ -112,12 +112,12 @@ pub fn option_nop_match_64(x: Option<u64>) -> Option<u64> {
     }
 }
 
-// CHECK-LABEL: @option_nop_traits_64({{.+}} %0, {{.+}} %1)
+// CHECK-LABEL: @option_nop_traits_64({{.+}} %x.0, {{.+}} %x.1)
 #[no_mangle]
 pub fn option_nop_traits_64(x: Option<u64>) -> Option<u64> {
     // CHECK: start:
-    // TWENTY-NEXT: %[[TRUNC:[0-9]+]] = trunc nuw i64 %0 to i1
-    // TWENTY-NEXT: %[[SEL:\.[0-9]+]] = select i1 %[[TRUNC]], i64 %1, i64 undef
+    // TWENTY-NEXT: %[[TRUNC:.+]] = trunc nuw i64 %x.0 to i1
+    // TWENTY-NEXT: %[[SEL:.+]] = select i1 %[[TRUNC]], i64 %x.1, i64 undef
     // CHECK-NEXT: insertvalue { i64, i64 }
     // CHECK-NEXT: insertvalue { i64, i64 }
     // CHECK-NEXT: ret { i64, i64 }

tests/codegen/union-abi.rs

@@ -137,20 +137,14 @@ pub fn test_CUnionU128(_: CUnionU128) {
 pub union UnionBool {
     b: bool,
 }
-// CHECK: define {{(dso_local )?}}noundef zeroext i1 @test_UnionBool(i8 %0)
+// CHECK: define {{(dso_local )?}}noundef zeroext i1 @test_UnionBool(i8 %b)
 #[no_mangle]
 pub fn test_UnionBool(b: UnionBool) -> bool {
     // Note the lack of `noundef` on the parameter, because (at least for now)
-    // all unions are allowed to be fully-uninitialized. We thus write it to
-    // memory and read it via `!noundef` when asserting validity.
+    // all unions are allowed to be fully-uninitialized.
 
     // CHECK-NOT: alloca
-    // CHECK: %b = alloca [1 x i8], align 1
-    // CHECK-NOT: alloca
-    // CHECK: store i8 %0, ptr %b, align 1
-    // CHECK: %[[WIDE:.+]] = load i8, ptr %b, align 1
-    // CHECK-SAME: !noundef
-    // CHECK: %[[BOOL:.+]] = trunc nuw i8 %[[WIDE]] to i1
+    // CHECK: %[[BOOL:.+]] = trunc nuw i8 %b to i1
     // CHECK: ret i1 %[[BOOL]]
 
     unsafe { b.b }