diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs index dd20e5d7430d..83766f31148b 100644 --- a/compiler/rustc_mir_dataflow/src/value_analysis.rs +++ b/compiler/rustc_mir_dataflow/src/value_analysis.rs @@ -758,7 +758,9 @@ impl Map { self.value_count += 1; } - if let Some(ref_ty) = ty.builtin_deref(true) && let ty::Slice(..) = ref_ty.ty.kind() { + if let ty::Ref(_, ref_ty, _) | ty::RawPtr(ty::TypeAndMut { ty: ref_ty, .. }) = ty.kind() + && let ty::Slice(..) = ref_ty.kind() + { assert!(self.places[place].value_index.is_none(), "slices are not scalars"); // Prepend new child to the linked list. diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.32bit.panic-abort.diff new file mode 100644 index 000000000000..b9b46f16a8b7 --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.32bit.panic-abort.diff @@ -0,0 +1,119 @@ +- // MIR for `main` before ConstProp ++ // MIR for `main` after ConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); +- _7 = AlignOf([bool; 0]); +- _6 = _7 as *mut [bool; 0] (Transmute); ++ _7 = const 1_usize; ++ _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); +- _8 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer)); +- _5 = NonNull::<[bool; 0]> { pointer: _8 }; ++ _8 = const {0x1 as *const [bool; 0]}; ++ _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); +- _4 = Unique::<[bool; 0]> { pointer: move _5, _marker: const PhantomData::<[bool; 0]> }; ++ _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); +- _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); ++ _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); +- _2 = Box::<[bool]>(_3, const std::alloc::Global); ++ _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); +- _1 = A { foo: move _2 }; ++ _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind unreachable]; + } + + bb1: { + StorageDead(_1); + return; + } ++ } ++ ++ alloc11 (size: 8, align: 4) { ++ 01 00 00 00 00 00 00 00 │ ........ ++ } ++ ++ alloc10 (size: 8, align: 4) { ++ 01 00 00 00 00 00 00 00 │ ........ ++ } ++ ++ alloc7 (size: 8, align: 4) { ++ 01 00 00 00 00 00 00 00 │ ........ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.32bit.panic-unwind.diff new file mode 100644 index 000000000000..93b18f23e61a --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.32bit.panic-unwind.diff @@ -0,0 +1,123 @@ +- // MIR for `main` before ConstProp ++ // MIR for `main` after ConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); +- _7 = AlignOf([bool; 0]); +- _6 = _7 as *mut [bool; 0] (Transmute); ++ _7 = const 1_usize; ++ _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); +- _8 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer)); +- _5 = NonNull::<[bool; 0]> { pointer: _8 }; ++ _8 = const {0x1 as *const [bool; 0]}; ++ _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); +- _4 = Unique::<[bool; 0]> { pointer: move _5, _marker: const PhantomData::<[bool; 0]> }; ++ _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); +- _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); ++ _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); +- _2 = Box::<[bool]>(_3, const std::alloc::Global); ++ _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); +- _1 = A { foo: move _2 }; ++ _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind: bb2]; + } + + bb1: { + StorageDead(_1); + return; + } + + bb2 (cleanup): { + resume; + } ++ } ++ ++ alloc11 (size: 8, align: 4) { ++ 01 00 00 00 00 00 00 00 │ ........ ++ } ++ ++ alloc10 (size: 8, align: 4) { ++ 01 00 00 00 00 00 00 00 │ ........ ++ } ++ ++ alloc7 (size: 8, align: 4) { ++ 01 00 00 00 00 00 00 00 │ ........ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.64bit.panic-abort.diff new file mode 100644 index 000000000000..3d3af62856bd --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.64bit.panic-abort.diff @@ -0,0 +1,119 @@ +- // MIR for `main` before ConstProp ++ // MIR for `main` after ConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); +- _7 = AlignOf([bool; 0]); +- _6 = _7 as *mut [bool; 0] (Transmute); ++ _7 = const 1_usize; ++ _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); +- _8 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer)); +- _5 = NonNull::<[bool; 0]> { pointer: _8 }; ++ _8 = const {0x1 as *const [bool; 0]}; ++ _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); +- _4 = Unique::<[bool; 0]> { pointer: move _5, _marker: const PhantomData::<[bool; 0]> }; ++ _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); +- _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); ++ _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); +- _2 = Box::<[bool]>(_3, const std::alloc::Global); ++ _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); +- _1 = A { foo: move _2 }; ++ _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind unreachable]; + } + + bb1: { + StorageDead(_1); + return; + } ++ } ++ ++ alloc11 (size: 16, align: 8) { ++ 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ ++ } ++ ++ alloc10 (size: 16, align: 8) { ++ 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ ++ } ++ ++ alloc7 (size: 16, align: 8) { ++ 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.64bit.panic-unwind.diff new file mode 100644 index 000000000000..1933f9bafb36 --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.ConstProp.64bit.panic-unwind.diff @@ -0,0 +1,123 @@ +- // MIR for `main` before ConstProp ++ // MIR for `main` after ConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); +- _7 = AlignOf([bool; 0]); +- _6 = _7 as *mut [bool; 0] (Transmute); ++ _7 = const 1_usize; ++ _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); +- _8 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer)); +- _5 = NonNull::<[bool; 0]> { pointer: _8 }; ++ _8 = const {0x1 as *const [bool; 0]}; ++ _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); +- _4 = Unique::<[bool; 0]> { pointer: move _5, _marker: const PhantomData::<[bool; 0]> }; ++ _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); +- _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); ++ _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); +- _2 = Box::<[bool]>(_3, const std::alloc::Global); ++ _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); +- _1 = A { foo: move _2 }; ++ _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind: bb2]; + } + + bb1: { + StorageDead(_1); + return; + } + + bb2 (cleanup): { + resume; + } ++ } ++ ++ alloc11 (size: 16, align: 8) { ++ 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ ++ } ++ ++ alloc10 (size: 16, align: 8) { ++ 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ ++ } ++ ++ alloc7 (size: 16, align: 8) { ++ 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff new file mode 100644 index 000000000000..7862c23da809 --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff @@ -0,0 +1,111 @@ +- // MIR for `main` before DataflowConstProp ++ // MIR for `main` after DataflowConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); + _8 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); + _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); + _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind unreachable]; + } + + bb1: { + StorageDead(_1); + return; + } + } + + alloc11 (size: 8, align: 4) { + 01 00 00 00 00 00 00 00 │ ........ + } + + alloc10 (size: 8, align: 4) { + 01 00 00 00 00 00 00 00 │ ........ + } + + alloc7 (size: 8, align: 4) { + 01 00 00 00 00 00 00 00 │ ........ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff new file mode 100644 index 000000000000..bd4150ebb452 --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff @@ -0,0 +1,115 @@ +- // MIR for `main` before DataflowConstProp ++ // MIR for `main` after DataflowConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); + _8 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); + _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); + _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind: bb2]; + } + + bb1: { + StorageDead(_1); + return; + } + + bb2 (cleanup): { + resume; + } + } + + alloc11 (size: 8, align: 4) { + 01 00 00 00 00 00 00 00 │ ........ + } + + alloc10 (size: 8, align: 4) { + 01 00 00 00 00 00 00 00 │ ........ + } + + alloc7 (size: 8, align: 4) { + 01 00 00 00 00 00 00 00 │ ........ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff new file mode 100644 index 000000000000..312fc7b7a82b --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff @@ -0,0 +1,111 @@ +- // MIR for `main` before DataflowConstProp ++ // MIR for `main` after DataflowConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); + _8 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); + _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); + _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind unreachable]; + } + + bb1: { + StorageDead(_1); + return; + } + } + + alloc11 (size: 16, align: 8) { + 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + + alloc10 (size: 16, align: 8) { + 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + + alloc7 (size: 16, align: 8) { + 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff new file mode 100644 index 000000000000..3227d8b84353 --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff @@ -0,0 +1,115 @@ +- // MIR for `main` before DataflowConstProp ++ // MIR for `main` after DataflowConstProp + + fn main() -> () { + let mut _0: (); + let _1: A; + let mut _2: std::boxed::Box<[bool]>; + scope 1 { + debug a => _1; + } + scope 2 (inlined as Default>::default) { + let _3: std::ptr::Unique<[bool]>; + let mut _4: std::ptr::Unique<[bool; 0]>; + scope 3 { + debug ptr => _3; + } + scope 4 (inlined Unique::<[bool; 0]>::dangling) { + let mut _5: std::ptr::NonNull<[bool; 0]>; + scope 5 (inlined NonNull::<[bool; 0]>::dangling) { + let mut _7: usize; + scope 6 { + let _6: *mut [bool; 0]; + scope 7 { + debug ptr => _6; + scope 11 (inlined NonNull::<[bool; 0]>::new_unchecked) { + debug ptr => _6; + let mut _8: *const [bool; 0]; + scope 12 { + scope 13 (inlined NonNull::::new_unchecked::runtime::<[bool; 0]>) { + debug ptr => _6; + scope 14 (inlined ptr::mut_ptr::::is_null) { + debug self => _6; + let mut _9: *mut u8; + scope 15 { + scope 16 (inlined ptr::mut_ptr::::is_null::runtime_impl) { + debug ptr => _9; + scope 17 (inlined ptr::mut_ptr::::addr) { + debug self => _9; + scope 18 { + scope 19 (inlined ptr::mut_ptr::::cast::<()>) { + debug self => _9; + } + } + } + } + } + } + } + } + } + } + scope 8 (inlined align_of::<[bool; 0]>) { + } + scope 9 (inlined invalid_mut::<[bool; 0]>) { + debug addr => _7; + scope 10 { + } + } + } + } + } + } + + bb0: { + StorageLive(_1); + StorageLive(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; + StorageDead(_7); + StorageLive(_8); + StorageLive(_9); + _8 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; + StorageDead(_9); + StorageDead(_8); + StorageDead(_6); + _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }}; + StorageDead(_5); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc7, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; + StorageDead(_4); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc10, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); + StorageDead(_3); + _1 = A { foo: const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: alloc11, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }; + StorageDead(_2); + _0 = const (); + drop(_1) -> [return: bb1, unwind: bb2]; + } + + bb1: { + StorageDead(_1); + return; + } + + bb2 (cleanup): { + resume; + } + } + + alloc11 (size: 16, align: 8) { + 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + + alloc10 (size: 16, align: 8) { + 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + + alloc7 (size: 16, align: 8) { + 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │ ................ + } + diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.rs b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.rs new file mode 100644 index 000000000000..dfeccd3eb94e --- /dev/null +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.rs @@ -0,0 +1,17 @@ +// unit-test: DataflowConstProp +// compile-flags: -Zmir-enable-passes=+ConstProp,+Inline +// ignore-debug assertions change the output MIR +// EMIT_MIR_FOR_EACH_BIT_WIDTH +// EMIT_MIR_FOR_EACH_PANIC_STRATEGY + +struct A { + foo: Box<[bool]>, +} + +// EMIT_MIR default_boxed_slice.main.ConstProp.diff +// EMIT_MIR default_boxed_slice.main.DataflowConstProp.diff +fn main() { + // ConstProp will create a constant of type `Box<[bool]>`. + // Verify that `DataflowConstProp` does not ICE trying to dereference it directly. + let a: A = A { foo: Box::default() }; +}