nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-28 02:57:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #115705 - cjgillot:const-prop-aggregate, r=oli-obk

Browse Source 
Read from non-scalar constants and statics in dataflow const-prop

DataflowConstProp is designed to handle scalar values. When MIR features an assignment from a non-scalar constant, we need to manually decompose it into the custom state space.

This PR tweaks interpreter callbacks to allow reusing `eval_mir_constant` without having a stack frame to get a span from.

r? `@oli-obk`
cc `@jachris`
This commit is contained in:
bors 2023-09-12 09:02:27 +00:00
commit cc7a9d6972
26 changed files with 1072 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
compiler/rustc_const_eval/src/interpret/discriminant.rs
View File

@ -247,9 +247,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
&self,
layout: TyAndLayout<'tcx>,
variant: VariantIdx,
) -> InterpResult<'tcx, Scalar<M::Provenance>> {
) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
let discr_layout = self.layout_of(layout.ty.discriminant_ty(*self.tcx))?;
Ok(match layout.ty.discriminant_for_variant(*self.tcx, variant) {
let discr_value = match layout.ty.discriminant_for_variant(*self.tcx, variant) {
Some(discr) => {
// This type actually has discriminants.
assert_eq!(discr.ty, discr_layout.ty);
@ -260,6 +260,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
assert_eq!(variant.as_u32(), 0);
Scalar::from_uint(variant.as_u32(), discr_layout.size)
}
})
};
Ok(ImmTy::from_scalar(discr_value, discr_layout))
}
}

2
compiler/rustc_const_eval/src/interpret/intrinsics.rs
View File

@ -222,7 +222,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let place = self.deref_pointer(&args[0])?;
let variant = self.read_discriminant(&place)?;
let discr = self.discriminant_for_variant(place.layout, variant)?;
self.write_scalar(discr, dest)?;
self.write_immediate(*discr, dest)?;
}
sym::exact_div => {
let l = self.read_immediate(&args[0])?;

2
compiler/rustc_const_eval/src/interpret/step.rs
View File

@ -301,7 +301,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let op = self.eval_place_to_op(place, None)?;
let variant = self.read_discriminant(&op)?;
let discr = self.discriminant_for_variant(op.layout, variant)?;
self.write_scalar(discr, &dest)?;
self.write_immediate(*discr, &dest)?;
}
}

27
compiler/rustc_mir_dataflow/src/value_analysis.rs
View File

@ -532,7 +532,7 @@ impl<V: Clone + HasTop + HasBottom> State<V> {
/// places that are non-overlapping or identical.
///
/// The target place must have been flooded before calling this method.
fn insert_place_idx(&mut self, target: PlaceIndex, source: PlaceIndex, map: &Map) {
pub fn insert_place_idx(&mut self, target: PlaceIndex, source: PlaceIndex, map: &Map) {
let StateData::Reachable(values) = &mut self.0 else { return };
// If both places are tracked, we copy the value to the target.
@ -928,6 +928,31 @@ impl Map {
f(v)
}
}
/// Invoke a function on each value in the given place and all descendants.
pub fn for_each_projection_value<O>(
&self,
root: PlaceIndex,
value: O,
project: &mut impl FnMut(TrackElem, &O) -> Option<O>,
f: &mut impl FnMut(PlaceIndex, &O),
) {
// Fast path is there is nothing to do.
if self.inner_values[root].is_empty() {
return;
}
if self.places[root].value_index.is_some() {
f(root, &value)
}
for child in self.children(root) {
let elem = self.places[child].proj_elem.unwrap();
if let Some(value) = project(elem, &value) {
self.for_each_projection_value(child, value, project, f);
}
}
}
}
/// This is the information tracked for every [`PlaceIndex`] and is stored by [`Map`].

46
compiler/rustc_mir_transform/src/const_prop.rs
View File

@ -32,32 +32,30 @@ const MAX_ALLOC_LIMIT: u64 = 1024;
/// Macro for machine-specific `InterpError` without allocation.
/// (These will never be shown to the user, but they help diagnose ICEs.)
macro_rules! throw_machine_stop_str {
($($tt:tt)*) => {{
// We make a new local type for it. The type itself does not carry any information,
// but its vtable (for the `MachineStopType` trait) does.
#[derive(Debug)]
struct Zst;
// Printing this type shows the desired string.
impl std::fmt::Display for Zst {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, $($tt)*)
}
pub(crate) macro throw_machine_stop_str($($tt:tt)*) {{
// We make a new local type for it. The type itself does not carry any information,
// but its vtable (for the `MachineStopType` trait) does.
#[derive(Debug)]
struct Zst;
// Printing this type shows the desired string.
impl std::fmt::Display for Zst {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, $($tt)*)
}
}
impl rustc_middle::mir::interpret::MachineStopType for Zst {
fn diagnostic_message(&self) -> rustc_errors::DiagnosticMessage {
self.to_string().into()
}
impl rustc_middle::mir::interpret::MachineStopType for Zst {
fn diagnostic_message(&self) -> rustc_errors::DiagnosticMessage {
self.to_string().into()
}
fn add_args(
self: Box<Self>,
_: &mut dyn FnMut(std::borrow::Cow<'static, str>, rustc_errors::DiagnosticArgValue<'static>),
) {}
}
throw_machine_stop!(Zst)
}};
}
fn add_args(
self: Box<Self>,
_: &mut dyn FnMut(std::borrow::Cow<'static, str>, rustc_errors::DiagnosticArgValue<'static>),
) {}
}
throw_machine_stop!(Zst)
}}
pub struct ConstProp;

212
compiler/rustc_mir_transform/src/dataflow_const_prop.rs
View File

@ -3,17 +3,19 @@
//! Currently, this pass only propagates scalar values.
use rustc_const_eval::const_eval::CheckAlignment;
use rustc_const_eval::interpret::{ConstValue, ImmTy, Immediate, InterpCx, Scalar};
use rustc_const_eval::interpret::{ImmTy, Immediate, InterpCx, OpTy, Projectable};
use rustc_data_structures::fx::FxHashMap;
use rustc_hir::def::DefKind;
use rustc_middle::mir::interpret::{AllocId, ConstAllocation, ConstValue, InterpResult, Scalar};
use rustc_middle::mir::visit::{MutVisitor, NonMutatingUseContext, PlaceContext, Visitor};
use rustc_middle::mir::*;
use rustc_middle::ty::layout::TyAndLayout;
use rustc_middle::ty::{self, ScalarInt, Ty, TyCtxt};
use rustc_mir_dataflow::value_analysis::{
Map, State, TrackElem, ValueAnalysis, ValueAnalysisWrapper, ValueOrPlace,
Map, PlaceIndex, State, TrackElem, ValueAnalysis, ValueAnalysisWrapper, ValueOrPlace,
};
use rustc_mir_dataflow::{lattice::FlatSet, Analysis, Results, ResultsVisitor};
use rustc_span::def_id::DefId;
use rustc_span::DUMMY_SP;
use rustc_target::abi::{Align, FieldIdx, VariantIdx};
@ -77,7 +79,7 @@ struct ConstAnalysis<'a, 'tcx> {
}
impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
type Value = FlatSet<ScalarInt>;
type Value = FlatSet<Scalar>;
const NAME: &'static str = "ConstAnalysis";
@ -111,6 +113,18 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
state: &mut State<Self::Value>,
) {
match rvalue {
Rvalue::Use(operand) => {
state.flood(target.as_ref(), self.map());
if let Some(target) = self.map.find(target.as_ref()) {
self.assign_operand(state, target, operand);
}
}
Rvalue::CopyForDeref(rhs) => {
state.flood(target.as_ref(), self.map());
if let Some(target) = self.map.find(target.as_ref()) {
self.assign_operand(state, target, &Operand::Copy(*rhs));
}
}
Rvalue::Aggregate(kind, operands) => {
// If we assign `target = Enum::Variant#0(operand)`,
// we must make sure that all `target as Variant#i` are `Top`.
@ -138,8 +152,7 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
variant_target_idx,
TrackElem::Field(FieldIdx::from_usize(field_index)),
) {
let result = self.handle_operand(operand, state);
state.insert_idx(field, result, self.map());
self.assign_operand(state, field, operand);
}
}
}
@ -176,7 +189,7 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
if let Some(overflow_target) = overflow_target {
let overflow = match overflow {
FlatSet::Top => FlatSet::Top,
FlatSet::Elem(overflow) => FlatSet::Elem(overflow.into()),
FlatSet::Elem(overflow) => FlatSet::Elem(Scalar::from_bool(overflow)),
FlatSet::Bottom => FlatSet::Bottom,
};
// We have flooded `target` earlier.
@ -198,7 +211,7 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
&& let ty::Array(_, len) = operand_ty.ty.kind()
&& let Some(len) = ConstantKind::Ty(*len).eval(self.tcx, self.param_env).try_to_scalar_int()
{
state.insert_value_idx(target_len, FlatSet::Elem(len), self.map());
state.insert_value_idx(target_len, FlatSet::Elem(len.into()), self.map());
}
}
_ => self.super_assign(target, rvalue, state),
@ -216,7 +229,7 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
if let ty::Array(_, len) = place_ty.ty.kind() {
ConstantKind::Ty(*len)
.eval(self.tcx, self.param_env)
.try_to_scalar_int()
.try_to_scalar()
.map_or(FlatSet::Top, FlatSet::Elem)
} else if let [ProjectionElem::Deref] = place.projection[..] {
state.get_len(place.local.into(), self.map())
@ -257,9 +270,10 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
val
}
Rvalue::UnaryOp(op, operand) => match self.eval_operand(operand, state) {
FlatSet::Elem(value) => {
self.ecx.unary_op(*op, &value).map_or(FlatSet::Top, |val| self.wrap_immty(val))
}
FlatSet::Elem(value) => self
.ecx
.unary_op(*op, &value)
.map_or(FlatSet::Top, |val| self.wrap_immediate(*val)),
FlatSet::Bottom => FlatSet::Bottom,
FlatSet::Top => FlatSet::Top,
},
@ -275,7 +289,7 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
.bytes(),
_ => return ValueOrPlace::Value(FlatSet::Top),
};
ScalarInt::try_from_target_usize(val, self.tcx).map_or(FlatSet::Top, FlatSet::Elem)
FlatSet::Elem(Scalar::from_target_usize(val, &self.tcx))
}
Rvalue::Discriminant(place) => state.get_discr(place.as_ref(), self.map()),
_ => return self.super_rvalue(rvalue, state),
@ -291,7 +305,7 @@ impl<'tcx> ValueAnalysis<'tcx> for ConstAnalysis<'_, 'tcx> {
constant
.literal
.eval(self.tcx, self.param_env)
.try_to_scalar_int()
.try_to_scalar()
.map_or(FlatSet::Top, FlatSet::Elem)
}
@ -330,13 +344,98 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
}
}
/// The caller must have flooded `place`.
fn assign_operand(
&self,
state: &mut State<FlatSet<Scalar>>,
place: PlaceIndex,
operand: &Operand<'tcx>,
) {
match operand {
Operand::Copy(rhs) | Operand::Move(rhs) => {
if let Some(rhs) = self.map.find(rhs.as_ref()) {
state.insert_place_idx(place, rhs, &self.map);
} else if rhs.projection.first() == Some(&PlaceElem::Deref)
&& let FlatSet::Elem(pointer) = state.get(rhs.local.into(), &self.map)
&& let rhs_ty = self.local_decls[rhs.local].ty
&& let Ok(rhs_layout) = self.tcx.layout_of(self.param_env.and(rhs_ty))
{
let op = ImmTy::from_scalar(pointer, rhs_layout).into();
self.assign_constant(state, place, op, &rhs.projection);
}
}
Operand::Constant(box constant) => {
if let Ok(constant) = self.ecx.eval_mir_constant(&constant.literal, None, None) {
self.assign_constant(state, place, constant, &[]);
}
}
}
}
/// The caller must have flooded `place`.
///
/// Perform: `place = operand.projection`.
#[instrument(level = "trace", skip(self, state))]
fn assign_constant(
&self,
state: &mut State<FlatSet<Scalar>>,
place: PlaceIndex,
mut operand: OpTy<'tcx>,
projection: &[PlaceElem<'tcx>],
) -> Option<!> {
for &(mut proj_elem) in projection {
if let PlaceElem::Index(index) = proj_elem {
if let FlatSet::Elem(index) = state.get(index.into(), &self.map)
&& let Ok(offset) = index.to_target_usize(&self.tcx)
&& let Some(min_length) = offset.checked_add(1)
{
proj_elem = PlaceElem::ConstantIndex { offset, min_length, from_end: false };
} else {
return None;
}
}
operand = self.ecx.project(&operand, proj_elem).ok()?;
}
self.map.for_each_projection_value(
place,
operand,
&mut |elem, op| match elem {
TrackElem::Field(idx) => self.ecx.project_field(op, idx.as_usize()).ok(),
TrackElem::Variant(idx) => self.ecx.project_downcast(op, idx).ok(),
TrackElem::Discriminant => {
let variant = self.ecx.read_discriminant(op).ok()?;
let discr_value = self.ecx.discriminant_for_variant(op.layout, variant).ok()?;
Some(discr_value.into())
}
TrackElem::DerefLen => {
let op: OpTy<'_> = self.ecx.deref_pointer(op).ok()?.into();
let len_usize = op.len(&self.ecx).ok()?;
let layout =
self.tcx.layout_of(self.param_env.and(self.tcx.types.usize)).unwrap();
Some(ImmTy::from_uint(len_usize, layout).into())
}
},
&mut |place, op| {
if let Ok(imm) = self.ecx.read_immediate_raw(op)
&& let Some(imm) = imm.right()
{
let elem = self.wrap_immediate(*imm);
state.insert_value_idx(place, elem, &self.map);
}
},
);
None
}
fn binary_op(
&self,
state: &mut State<FlatSet<ScalarInt>>,
state: &mut State<FlatSet<Scalar>>,
op: BinOp,
left: &Operand<'tcx>,
right: &Operand<'tcx>,
) -> (FlatSet<ScalarInt>, FlatSet<bool>) {
) -> (FlatSet<Scalar>, FlatSet<bool>) {
let left = self.eval_operand(left, state);
let right = self.eval_operand(right, state);
@ -345,9 +444,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
// Both sides are known, do the actual computation.
(FlatSet::Elem(left), FlatSet::Elem(right)) => {
match self.ecx.overflowing_binary_op(op, &left, &right) {
Ok((Scalar::Int(val), overflow, _)) => {
(FlatSet::Elem(val), FlatSet::Elem(overflow))
}
Ok((val, overflow, _)) => (FlatSet::Elem(val), FlatSet::Elem(overflow)),
_ => (FlatSet::Top, FlatSet::Top),
}
}
@ -359,9 +456,6 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
}
let arg_scalar = const_arg.to_scalar();
let Ok(arg_scalar) = arg_scalar.try_to_int() else {
return (FlatSet::Top, FlatSet::Top);
};
let Ok(arg_value) = arg_scalar.to_bits(layout.size) else {
return (FlatSet::Top, FlatSet::Top);
};
@ -387,7 +481,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
fn eval_operand(
&self,
op: &Operand<'tcx>,
state: &mut State<FlatSet<ScalarInt>>,
state: &mut State<FlatSet<Scalar>>,
) -> FlatSet<ImmTy<'tcx>> {
let value = match self.handle_operand(op, state) {
ValueOrPlace::Value(value) => value,
@ -397,35 +491,30 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
FlatSet::Top => FlatSet::Top,
FlatSet::Elem(scalar) => {
let ty = op.ty(self.local_decls, self.tcx);
self.tcx
.layout_of(self.param_env.and(ty))
.map(|layout| FlatSet::Elem(ImmTy::from_scalar(scalar.into(), layout)))
.unwrap_or(FlatSet::Top)
self.tcx.layout_of(self.param_env.and(ty)).map_or(FlatSet::Top, |layout| {
FlatSet::Elem(ImmTy::from_scalar(scalar.into(), layout))
})
}
FlatSet::Bottom => FlatSet::Bottom,
}
}
fn eval_discriminant(&self, enum_ty: Ty<'tcx>, variant_index: VariantIdx) -> Option<ScalarInt> {
fn eval_discriminant(&self, enum_ty: Ty<'tcx>, variant_index: VariantIdx) -> Option<Scalar> {
if !enum_ty.is_enum() {
return None;
}
let discr = enum_ty.discriminant_for_variant(self.tcx, variant_index)?;
let discr_layout = self.tcx.layout_of(self.param_env.and(discr.ty)).ok()?;
let discr_value = ScalarInt::try_from_uint(discr.val, discr_layout.size)?;
Some(discr_value)
let enum_ty_layout = self.tcx.layout_of(self.param_env.and(enum_ty)).ok()?;
let discr_value = self.ecx.discriminant_for_variant(enum_ty_layout, variant_index).ok()?;
Some(discr_value.to_scalar())
}
fn wrap_immediate(&self, imm: Immediate) -> FlatSet<ScalarInt> {
fn wrap_immediate(&self, imm: Immediate) -> FlatSet<Scalar> {
match imm {
Immediate::Scalar(Scalar::Int(scalar)) => FlatSet::Elem(scalar),
Immediate::Scalar(scalar) => FlatSet::Elem(scalar),
Immediate::Uninit => FlatSet::Bottom,
_ => FlatSet::Top,
}
}
fn wrap_immty(&self, val: ImmTy<'tcx>) -> FlatSet<ScalarInt> {
self.wrap_immediate(*val)
}
}
struct CollectAndPatch<'tcx, 'locals> {
@ -464,7 +553,7 @@ impl<'mir, 'tcx>
ResultsVisitor<'mir, 'tcx, Results<'tcx, ValueAnalysisWrapper<ConstAnalysis<'_, 'tcx>>>>
for CollectAndPatch<'tcx, '_>
{
type FlowState = State<FlatSet<ScalarInt>>;
type FlowState = State<FlatSet<Scalar>>;
fn visit_statement_before_primary_effect(
&mut self,
@ -494,14 +583,10 @@ impl<'mir, 'tcx>
// Don't overwrite the assignment if it already uses a constant (to keep the span).
}
StatementKind::Assign(box (place, _)) => {
match state.get(place.as_ref(), &results.analysis.0.map) {
FlatSet::Top => (),
FlatSet::Elem(value) => {
self.assignments.insert(location, value);
}
FlatSet::Bottom => {
// This assignment is either unreachable, or an uninitialized value is assigned.
}
if let FlatSet::Elem(Scalar::Int(value)) =
state.get(place.as_ref(), &results.analysis.0.map)
{
self.assignments.insert(location, value);
}
}
_ => (),
@ -571,7 +656,7 @@ impl<'tcx> MutVisitor<'tcx> for CollectAndPatch<'tcx, '_> {
}
struct OperandCollector<'tcx, 'map, 'locals, 'a> {
state: &'a State<FlatSet<ScalarInt>>,
state: &'a State<FlatSet<Scalar>>,
visitor: &'a mut CollectAndPatch<'tcx, 'locals>,
map: &'map Map,
}
@ -579,7 +664,7 @@ struct OperandCollector<'tcx, 'map, 'locals, 'a> {
impl<'tcx> Visitor<'tcx> for OperandCollector<'tcx, '_, '_, '_> {
fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location) {
if let Some(place) = operand.place() {
if let FlatSet::Elem(value) = self.state.get(place.as_ref(), self.map) {
if let FlatSet::Elem(Scalar::Int(value)) = self.state.get(place.as_ref(), self.map) {
self.visitor.before_effect.insert((location, place), value);
} else if !place.projection.is_empty() {
// Try to propagate into `Index` projections.
@ -590,7 +675,7 @@ impl<'tcx> Visitor<'tcx> for OperandCollector<'tcx, '_, '_, '_> {
fn visit_local(&mut self, local: Local, ctxt: PlaceContext, location: Location) {
if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy | NonMutatingUseContext::Move) = ctxt
&& let FlatSet::Elem(value) = self.state.get(local.into(), self.map)
&& let FlatSet::Elem(Scalar::Int(value)) = self.state.get(local.into(), self.map)
{
self.visitor.before_effect.insert((location, local.into()), value);
}
@ -604,8 +689,11 @@ impl<'mir, 'tcx: 'mir> rustc_const_eval::interpret::Machine<'mir, 'tcx> for Dumm
type MemoryKind = !;
const PANIC_ON_ALLOC_FAIL: bool = true;
#[inline(always)]
fn enforce_alignment(_ecx: &InterpCx<'mir, 'tcx, Self>) -> CheckAlignment {
unimplemented!()
// We do not check for alignment to avoid having to carry an `Align`
// in `ConstValue::ByRef`.
CheckAlignment::No
}
fn enforce_validity(_ecx: &InterpCx<'mir, 'tcx, Self>, _layout: TyAndLayout<'tcx>) -> bool {
@ -620,6 +708,27 @@ impl<'mir, 'tcx: 'mir> rustc_const_eval::interpret::Machine<'mir, 'tcx> for Dumm
unimplemented!()
}
fn before_access_global(
_tcx: TyCtxt<'tcx>,
_machine: &Self,
_alloc_id: AllocId,
alloc: ConstAllocation<'tcx>,
_static_def_id: Option<DefId>,
is_write: bool,
) -> InterpResult<'tcx> {
if is_write {
crate::const_prop::throw_machine_stop_str!("can't write to global");
}
// If the static allocation is mutable, then we can't const prop it as its content
// might be different at runtime.
if alloc.inner().mutability.is_mut() {
crate::const_prop::throw_machine_stop_str!("can't access mutable globals in ConstProp");
}
Ok(())
}
fn find_mir_or_eval_fn(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_instance: ty::Instance<'tcx>,
@ -688,7 +797,8 @@ impl<'mir, 'tcx: 'mir> rustc_const_eval::interpret::Machine<'mir, 'tcx> for Dumm
_ecx: &'a InterpCx<'mir, 'tcx, Self>,
) -> &'a [rustc_const_eval::interpret::Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>]
{
unimplemented!()
// Return an empty stack instead of panicking, as `cur_span` uses it to evaluate constants.
&[]
}
fn stack_mut<'a>(

1
compiler/rustc_mir_transform/src/lib.rs
View File

@ -2,6 +2,7 @@
#![deny(rustc::untranslatable_diagnostic)]
#![deny(rustc::diagnostic_outside_of_impl)]
#![feature(box_patterns)]
#![feature(decl_macro)]
#![feature(is_sorted)]
#![feature(let_chains)]
#![feature(map_try_insert)]

63
tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff Normal file
View File

@ -0,0 +1,63 @@
- // MIR for `constant` before DataflowConstProp
+ // MIR for `constant` after DataflowConstProp
fn constant() -> () {
let mut _0: ();
let _1: E;
let mut _3: isize;
scope 1 {
debug e => _1;
let _2: i32;
let _4: i32;
let _5: i32;
scope 2 {
debug x => _2;
}
scope 3 {
debug x => _4;
}
scope 4 {
debug x => _5;
}
}
bb0: {
StorageLive(_1);
_1 = const _;
StorageLive(_2);
- _3 = discriminant(_1);
- switchInt(move _3) -> [0: bb3, 1: bb1, otherwise: bb2];
+ _3 = const 0_isize;
+ switchInt(const 0_isize) -> [0: bb3, 1: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_5);
_5 = ((_1 as V2).0: i32);
_2 = _5;
StorageDead(_5);
goto -> bb4;
}
bb2: {
unreachable;
}
bb3: {
StorageLive(_4);
- _4 = ((_1 as V1).0: i32);
- _2 = _4;
+ _4 = const 0_i32;
+ _2 = const 0_i32;
StorageDead(_4);
goto -> bb4;
}
bb4: {
_0 = const ();
StorageDead(_2);
StorageDead(_1);
return;
}
}

63
tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff Normal file
View File

@ -0,0 +1,63 @@
- // MIR for `constant` before DataflowConstProp
+ // MIR for `constant` after DataflowConstProp
fn constant() -> () {
let mut _0: ();
let _1: E;
let mut _3: isize;
scope 1 {
debug e => _1;
let _2: i32;
let _4: i32;
let _5: i32;
scope 2 {
debug x => _2;
}
scope 3 {
debug x => _4;
}
scope 4 {
debug x => _5;
}
}
bb0: {
StorageLive(_1);
_1 = const _;
StorageLive(_2);
- _3 = discriminant(_1);
- switchInt(move _3) -> [0: bb3, 1: bb1, otherwise: bb2];
+ _3 = const 0_isize;
+ switchInt(const 0_isize) -> [0: bb3, 1: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_5);
_5 = ((_1 as V2).0: i32);
_2 = _5;
StorageDead(_5);
goto -> bb4;
}
bb2: {
unreachable;
}
bb3: {
StorageLive(_4);
- _4 = ((_1 as V1).0: i32);
- _2 = _4;
+ _4 = const 0_i32;
+ _2 = const 0_i32;
StorageDead(_4);
goto -> bb4;
}
bb4: {
_0 = const ();
StorageDead(_2);
StorageDead(_1);
return;
}
}

0
tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.diff → tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff
View File

82
tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff Normal file
View File

@ -0,0 +1,82 @@
- // MIR for `multiple` before DataflowConstProp
+ // MIR for `multiple` after DataflowConstProp
fn multiple(_1: bool, _2: u8) -> () {
debug x => _1;
debug i => _2;
let mut _0: ();
let _3: std::option::Option<u8>;
let mut _4: bool;
let mut _5: u8;
let mut _7: isize;
scope 1 {
debug e => _3;
let _6: u8;
let _8: u8;
scope 2 {
debug x => _6;
let _9: u8;
scope 4 {
debug y => _9;
}
}
scope 3 {
debug i => _8;
}
}
bb0: {
StorageLive(_3);
StorageLive(_4);
_4 = _1;
switchInt(move _4) -> [0: bb2, otherwise: bb1];
}
bb1: {
StorageLive(_5);
_5 = _2;
_3 = Option::<u8>::Some(move _5);
StorageDead(_5);
goto -> bb3;
}
bb2: {
_3 = Option::<u8>::None;
goto -> bb3;
}
bb3: {
StorageDead(_4);
StorageLive(_6);
_7 = discriminant(_3);
switchInt(move _7) -> [0: bb4, 1: bb6, otherwise: bb5];
}
bb4: {
_6 = const 0_u8;
goto -> bb7;
}
bb5: {
unreachable;
}
bb6: {
StorageLive(_8);
_8 = ((_3 as Some).0: u8);
_6 = _8;
StorageDead(_8);
goto -> bb7;
}
bb7: {
StorageLive(_9);
_9 = _6;
_0 = const ();
StorageDead(_9);
StorageDead(_6);
StorageDead(_3);
return;
}
}

0
tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.diff → tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff
View File

26
tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff Normal file
View File

@ -0,0 +1,26 @@
- // MIR for `mutate_discriminant` before DataflowConstProp
+ // MIR for `mutate_discriminant` after DataflowConstProp
fn mutate_discriminant() -> u8 {
let mut _0: u8;
let mut _1: std::option::Option<NonZeroUsize>;
let mut _2: isize;
bb0: {
discriminant(_1) = 1;
(((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize;
_2 = discriminant(_1);
switchInt(_2) -> [0: bb1, otherwise: bb2];
}
bb1: {
_0 = const 1_u8;
return;
}
bb2: {
_0 = const 2_u8;
unreachable;
}
}

22
tests/mir-opt/dataflow-const-prop/enum.rs
View File

@ -1,9 +1,11 @@
// unit-test: DataflowConstProp
// EMIT_MIR_FOR_EACH_BIT_WIDTH
#![feature(custom_mir, core_intrinsics, rustc_attrs)]
use std::intrinsics::mir::*;
#[derive(Copy, Clone)]
enum E {
V1(i32),
V2(i32)
@ -15,6 +17,24 @@ fn simple() {
let x = match e { E::V1(x) => x, E::V2(x) => x };
}
// EMIT_MIR enum.constant.DataflowConstProp.diff
fn constant() {
const C: E = E::V1(0);
let e = C;
let x = match e { E::V1(x) => x, E::V2(x) => x };
}
// EMIT_MIR enum.statics.DataflowConstProp.diff
fn statics() {
static C: E = E::V1(0);
let e = C;
let x = match e { E::V1(x) => x, E::V2(x) => x };
static RC: &E = &E::V2(4);
let e = RC;
let x = match e { E::V1(x) => x, E::V2(x) => x };
}
#[rustc_layout_scalar_valid_range_start(1)]
#[rustc_nonnull_optimization_guaranteed]
struct NonZeroUsize(usize);
@ -63,6 +83,8 @@ fn multiple(x: bool, i: u8) {
fn main() {
simple();
constant();
statics();
mutate_discriminant();
multiple(false, 5);
}

0
tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.diff → tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff
View File

63
tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff Normal file
View File

@ -0,0 +1,63 @@
- // MIR for `simple` before DataflowConstProp
+ // MIR for `simple` after DataflowConstProp
fn simple() -> () {
let mut _0: ();
let _1: E;
let mut _3: isize;
scope 1 {
debug e => _1;
let _2: i32;
let _4: i32;
let _5: i32;
scope 2 {
debug x => _2;
}
scope 3 {
debug x => _4;
}
scope 4 {
debug x => _5;
}
}
bb0: {
StorageLive(_1);
_1 = E::V1(const 0_i32);
StorageLive(_2);
- _3 = discriminant(_1);
- switchInt(move _3) -> [0: bb3, 1: bb1, otherwise: bb2];
+ _3 = const 0_isize;
+ switchInt(const 0_isize) -> [0: bb3, 1: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_5);
_5 = ((_1 as V2).0: i32);
_2 = _5;
StorageDead(_5);
goto -> bb4;
}
bb2: {
unreachable;
}
bb3: {
StorageLive(_4);
- _4 = ((_1 as V1).0: i32);
- _2 = _4;
+ _4 = const 0_i32;
+ _2 = const 0_i32;
StorageDead(_4);
goto -> bb4;
}
bb4: {
_0 = const ();
StorageDead(_2);
StorageDead(_1);
return;
}
}

126
tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff Normal file
View File

@ -0,0 +1,126 @@
- // MIR for `statics` before DataflowConstProp
+ // MIR for `statics` after DataflowConstProp
fn statics() -> () {
let mut _0: ();
let _1: E;
let mut _2: &E;
let mut _4: isize;
let mut _8: &&E;
let mut _10: isize;
scope 1 {
debug e => _1;
let _3: i32;
let _5: i32;
let _6: i32;
scope 2 {
debug x => _3;
let _7: &E;
scope 5 {
debug e => _7;
let _9: &i32;
let _11: &i32;
let _12: &i32;
scope 6 {
debug x => _9;
}
scope 7 {
debug x => _11;
}
scope 8 {
debug x => _12;
}
}
}
scope 3 {
debug x => _5;
}
scope 4 {
debug x => _6;
}
}
bb0: {
StorageLive(_1);
StorageLive(_2);
_2 = const {alloc1: &E};
_1 = (*_2);
StorageDead(_2);
StorageLive(_3);
- _4 = discriminant(_1);
- switchInt(move _4) -> [0: bb3, 1: bb1, otherwise: bb2];
+ _4 = const 0_isize;
+ switchInt(const 0_isize) -> [0: bb3, 1: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_6);
_6 = ((_1 as V2).0: i32);
_3 = _6;
StorageDead(_6);
goto -> bb4;
}
bb2: {
unreachable;
}
bb3: {
StorageLive(_5);
- _5 = ((_1 as V1).0: i32);
- _3 = _5;
+ _5 = const 0_i32;
+ _3 = const 0_i32;
StorageDead(_5);
goto -> bb4;
}
bb4: {
StorageLive(_7);
StorageLive(_8);
_8 = const {alloc2: &&E};
_7 = (*_8);
StorageDead(_8);
StorageLive(_9);
_10 = discriminant((*_7));
switchInt(move _10) -> [0: bb6, 1: bb5, otherwise: bb2];
}
bb5: {
StorageLive(_12);
_12 = &(((*_7) as V2).0: i32);
_9 = &(*_12);
StorageDead(_12);
goto -> bb7;
}
bb6: {
StorageLive(_11);
_11 = &(((*_7) as V1).0: i32);
_9 = _11;
StorageDead(_11);
goto -> bb7;
}
bb7: {
_0 = const ();
StorageDead(_9);
StorageDead(_7);
StorageDead(_3);
StorageDead(_1);
return;
}
}
alloc2 (static: RC, size: 4, align: 4) {
╾─alloc14─╼ │ ╾──╼
}
alloc14 (size: 8, align: 4) {
01 00 00 00 04 00 00 00 │ ........
}
alloc1 (static: statics::C, size: 8, align: 4) {
00 00 00 00 00 00 00 00 │ ........
}

126
tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff Normal file
View File

@ -0,0 +1,126 @@
- // MIR for `statics` before DataflowConstProp
+ // MIR for `statics` after DataflowConstProp
fn statics() -> () {
let mut _0: ();
let _1: E;
let mut _2: &E;
let mut _4: isize;
let mut _8: &&E;
let mut _10: isize;
scope 1 {
debug e => _1;
let _3: i32;
let _5: i32;
let _6: i32;
scope 2 {
debug x => _3;
let _7: &E;
scope 5 {
debug e => _7;
let _9: &i32;
let _11: &i32;
let _12: &i32;
scope 6 {
debug x => _9;
}
scope 7 {
debug x => _11;
}
scope 8 {
debug x => _12;
}
}
}
scope 3 {
debug x => _5;
}
scope 4 {
debug x => _6;
}
}
bb0: {
StorageLive(_1);
StorageLive(_2);
_2 = const {alloc1: &E};
_1 = (*_2);
StorageDead(_2);
StorageLive(_3);
- _4 = discriminant(_1);
- switchInt(move _4) -> [0: bb3, 1: bb1, otherwise: bb2];
+ _4 = const 0_isize;
+ switchInt(const 0_isize) -> [0: bb3, 1: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_6);
_6 = ((_1 as V2).0: i32);
_3 = _6;
StorageDead(_6);
goto -> bb4;
}
bb2: {
unreachable;
}
bb3: {
StorageLive(_5);
- _5 = ((_1 as V1).0: i32);
- _3 = _5;
+ _5 = const 0_i32;
+ _3 = const 0_i32;
StorageDead(_5);
goto -> bb4;
}
bb4: {
StorageLive(_7);
StorageLive(_8);
_8 = const {alloc2: &&E};
_7 = (*_8);
StorageDead(_8);
StorageLive(_9);
_10 = discriminant((*_7));
switchInt(move _10) -> [0: bb6, 1: bb5, otherwise: bb2];
}
bb5: {
StorageLive(_12);
_12 = &(((*_7) as V2).0: i32);
_9 = &(*_12);
StorageDead(_12);
goto -> bb7;
}
bb6: {
StorageLive(_11);
_11 = &(((*_7) as V1).0: i32);
_9 = _11;
StorageDead(_11);
goto -> bb7;
}
bb7: {
_0 = const ();
StorageDead(_9);
StorageDead(_7);
StorageDead(_3);
StorageDead(_1);
return;
}
}
alloc2 (static: RC, size: 8, align: 8) {
╾───────alloc14───────╼ │ ╾──────╼
}
alloc14 (size: 8, align: 4) {
01 00 00 00 04 00 00 00 │ ........
}
alloc1 (static: statics::C, size: 8, align: 4) {
00 00 00 00 00 00 00 00 │ ........
}

7
tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff
View File

@ -55,11 +55,12 @@
_10 = const _;
StorageLive(_11);
_11 = const 1_usize;
_12 = Len((*_10));
- _12 = Len((*_10));
- _13 = Lt(_11, _12);
- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind unreachable];
+ _13 = Lt(const 1_usize, _12);
+ assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 1_usize) -> [success: bb2, unwind unreachable];
+ _12 = const 3_usize;
+ _13 = const true;
+ assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind unreachable];
}
bb2: {

7
tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff
View File

@ -55,11 +55,12 @@
_10 = const _;
StorageLive(_11);
_11 = const 1_usize;
_12 = Len((*_10));
- _12 = Len((*_10));
- _13 = Lt(_11, _12);
- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind continue];
+ _13 = Lt(const 1_usize, _12);
+ assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 1_usize) -> [success: bb2, unwind continue];
+ _12 = const 3_usize;
+ _13 = const true;
+ assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind continue];
}
bb2: {

7
tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff
View File

@ -55,11 +55,12 @@
_10 = const _;
StorageLive(_11);
_11 = const 1_usize;
_12 = Len((*_10));
- _12 = Len((*_10));
- _13 = Lt(_11, _12);
- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind unreachable];
+ _13 = Lt(const 1_usize, _12);
+ assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 1_usize) -> [success: bb2, unwind unreachable];
+ _12 = const 3_usize;
+ _13 = const true;
+ assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind unreachable];
}
bb2: {

7
tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff
View File

@ -55,11 +55,12 @@
_10 = const _;
StorageLive(_11);
_11 = const 1_usize;
_12 = Len((*_10));
- _12 = Len((*_10));
- _13 = Lt(_11, _12);
- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind continue];
+ _13 = Lt(const 1_usize, _12);
+ assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 1_usize) -> [success: bb2, unwind continue];
+ _12 = const 3_usize;
+ _13 = const true;
+ assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind continue];
}
bb2: {

129
tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff Normal file
View File

@ -0,0 +1,129 @@
- // MIR for `main` before DataflowConstProp
+ // MIR for `main` after DataflowConstProp
fn main() -> () {
let mut _0: ();
let mut _1: S;
let mut _3: i32;
let mut _5: i32;
let mut _6: i32;
let mut _11: BigStruct;
let mut _16: &&BigStruct;
let mut _17: &BigStruct;
let mut _18: &BigStruct;
let mut _19: &BigStruct;
let mut _20: &BigStruct;
let mut _21: &BigStruct;
scope 1 {
debug s => _1;
let _2: i32;
scope 2 {
debug a => _2;
let _4: i32;
scope 3 {
debug b => _4;
let _7: S;
let _8: u8;
let _9: f32;
let _10: S;
scope 4 {
debug a => _7;
debug b => _8;
debug c => _9;
debug d => _10;
let _12: S;
let _13: u8;
let _14: f32;
let _15: S;
scope 5 {
debug a => _12;
debug b => _13;
debug c => _14;
debug d => _15;
}
}
}
}
}
bb0: {
StorageLive(_1);
_1 = S(const 1_i32);
StorageLive(_2);
StorageLive(_3);
- _3 = (_1.0: i32);
- _2 = Add(move _3, const 2_i32);
+ _3 = const 1_i32;
+ _2 = const 3_i32;
StorageDead(_3);
(_1.0: i32) = const 3_i32;
StorageLive(_4);
StorageLive(_5);
- _5 = _2;
+ _5 = const 3_i32;
StorageLive(_6);
- _6 = (_1.0: i32);
- _4 = Add(move _5, move _6);
+ _6 = const 3_i32;
+ _4 = const 6_i32;
StorageDead(_6);
StorageDead(_5);
StorageLive(_11);
_11 = const _;
StorageLive(_7);
- _7 = (_11.0: S);
+ _7 = const S(1_i32);
StorageLive(_8);
- _8 = (_11.1: u8);
+ _8 = const 5_u8;
StorageLive(_9);
- _9 = (_11.2: f32);
+ _9 = const 7f32;
StorageLive(_10);
- _10 = (_11.3: S);
+ _10 = const S(13_i32);
StorageDead(_11);
StorageLive(_16);
_16 = const {alloc1: &&BigStruct};
_17 = deref_copy (*_16);
StorageLive(_12);
_18 = deref_copy (*_16);
- _12 = ((*_18).0: S);
+ _12 = const S(1_i32);
StorageLive(_13);
_19 = deref_copy (*_16);
- _13 = ((*_19).1: u8);
+ _13 = const 5_u8;
StorageLive(_14);
_20 = deref_copy (*_16);
- _14 = ((*_20).2: f32);
+ _14 = const 7f32;
StorageLive(_15);
_21 = deref_copy (*_16);
- _15 = ((*_21).3: S);
+ _15 = const S(13_i32);
StorageDead(_16);
_0 = const ();
StorageDead(_15);
StorageDead(_14);
StorageDead(_13);
StorageDead(_12);
StorageDead(_10);
StorageDead(_9);
StorageDead(_8);
StorageDead(_7);
StorageDead(_4);
StorageDead(_2);
StorageDead(_1);
return;
}
}
alloc1 (static: STAT, size: 4, align: 4) {
╾─alloc15─╼ │ ╾──╼
}
alloc15 (size: 16, align: 4) {
01 00 00 00 00 00 e0 40 0d 00 00 00 05 __ __ __ │ .......@.....░░░
}

129
tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff Normal file
View File

@ -0,0 +1,129 @@
- // MIR for `main` before DataflowConstProp
+ // MIR for `main` after DataflowConstProp
fn main() -> () {
let mut _0: ();
let mut _1: S;
let mut _3: i32;
let mut _5: i32;
let mut _6: i32;
let mut _11: BigStruct;
let mut _16: &&BigStruct;
let mut _17: &BigStruct;
let mut _18: &BigStruct;
let mut _19: &BigStruct;
let mut _20: &BigStruct;
let mut _21: &BigStruct;
scope 1 {
debug s => _1;
let _2: i32;
scope 2 {
debug a => _2;
let _4: i32;
scope 3 {
debug b => _4;
let _7: S;
let _8: u8;
let _9: f32;
let _10: S;
scope 4 {
debug a => _7;
debug b => _8;
debug c => _9;
debug d => _10;
let _12: S;
let _13: u8;
let _14: f32;
let _15: S;
scope 5 {
debug a => _12;
debug b => _13;
debug c => _14;
debug d => _15;
}
}
}
}
}
bb0: {
StorageLive(_1);
_1 = S(const 1_i32);
StorageLive(_2);
StorageLive(_3);
- _3 = (_1.0: i32);
- _2 = Add(move _3, const 2_i32);
+ _3 = const 1_i32;
+ _2 = const 3_i32;
StorageDead(_3);
(_1.0: i32) = const 3_i32;
StorageLive(_4);
StorageLive(_5);
- _5 = _2;
+ _5 = const 3_i32;
StorageLive(_6);
- _6 = (_1.0: i32);
- _4 = Add(move _5, move _6);
+ _6 = const 3_i32;
+ _4 = const 6_i32;
StorageDead(_6);
StorageDead(_5);
StorageLive(_11);
_11 = const _;
StorageLive(_7);
- _7 = (_11.0: S);
+ _7 = const S(1_i32);
StorageLive(_8);
- _8 = (_11.1: u8);
+ _8 = const 5_u8;
StorageLive(_9);
- _9 = (_11.2: f32);
+ _9 = const 7f32;
StorageLive(_10);
- _10 = (_11.3: S);
+ _10 = const S(13_i32);
StorageDead(_11);
StorageLive(_16);
_16 = const {alloc1: &&BigStruct};
_17 = deref_copy (*_16);
StorageLive(_12);
_18 = deref_copy (*_16);
- _12 = ((*_18).0: S);
+ _12 = const S(1_i32);
StorageLive(_13);
_19 = deref_copy (*_16);
- _13 = ((*_19).1: u8);
+ _13 = const 5_u8;
StorageLive(_14);
_20 = deref_copy (*_16);
- _14 = ((*_20).2: f32);
+ _14 = const 7f32;
StorageLive(_15);
_21 = deref_copy (*_16);
- _15 = ((*_21).3: S);
+ _15 = const S(13_i32);
StorageDead(_16);
_0 = const ();
StorageDead(_15);
StorageDead(_14);
StorageDead(_13);
StorageDead(_12);
StorageDead(_10);
StorageDead(_9);
StorageDead(_8);
StorageDead(_7);
StorageDead(_4);
StorageDead(_2);
StorageDead(_1);
return;
}
}
alloc1 (static: STAT, size: 8, align: 8) {
╾───────alloc15───────╼ │ ╾──────╼
}
alloc15 (size: 16, align: 4) {
01 00 00 00 00 00 e0 40 0d 00 00 00 05 __ __ __ │ .......@.....░░░
}

51
tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.diff
View File

@ -1,51 +0,0 @@
- // MIR for `main` before DataflowConstProp
+ // MIR for `main` after DataflowConstProp
fn main() -> () {
let mut _0: ();
let mut _1: S;
let mut _3: i32;
let mut _5: i32;
let mut _6: i32;
scope 1 {
debug s => _1;
let _2: i32;
scope 2 {
debug a => _2;
let _4: i32;
scope 3 {
debug b => _4;
}
}
}
bb0: {
StorageLive(_1);
_1 = S(const 1_i32);
StorageLive(_2);
StorageLive(_3);
- _3 = (_1.0: i32);
- _2 = Add(move _3, const 2_i32);
+ _3 = const 1_i32;
+ _2 = const 3_i32;
StorageDead(_3);
(_1.0: i32) = const 3_i32;
StorageLive(_4);
StorageLive(_5);
- _5 = _2;
+ _5 = const 3_i32;
StorageLive(_6);
- _6 = (_1.0: i32);
- _4 = Add(move _5, move _6);
+ _6 = const 3_i32;
+ _4 = const 6_i32;
StorageDead(_6);
StorageDead(_5);
_0 = const ();
StorageDead(_4);
StorageDead(_2);
StorageDead(_1);
return;
}
}

11
tests/mir-opt/dataflow-const-prop/struct.rs
View File

@ -1,11 +1,22 @@
// unit-test: DataflowConstProp
// EMIT_MIR_FOR_EACH_BIT_WIDTH
#[derive(Copy, Clone)]
struct S(i32);
#[derive(Copy, Clone)]
struct BigStruct(S, u8, f32, S);
// EMIT_MIR struct.main.DataflowConstProp.diff
fn main() {
let mut s = S(1);
let a = s.0 + 2;
s.0 = 3;
let b = a + s.0;
const VAL: BigStruct = BigStruct(S(1), 5, 7., S(13));
let BigStruct(a, b, c, d) = VAL;
static STAT: &BigStruct = &BigStruct(S(1), 5, 7., S(13));
let BigStruct(a, b, c, d) = *STAT;
}