bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #98957 - RalfJung:zst-are-different, r=lcnr,oli-obk

Browse source 
don't allow ZST in ScalarInt

There are several indications that we should not ZST as a ScalarInt:
- We had two ways to have ZST valtrees, either an empty `Branch` or a `Leaf` with a ZST in it.
  `ValTree::zst()` used the former, but the latter could possibly arise as well.
- Likewise, the interpreter had `Immediate::Uninit` and `Immediate::Scalar(Scalar::ZST)`.
- LLVM codegen already had to special-case ZST ScalarInt.

So I propose we stop using ScalarInt to represent ZST (which are clearly not integers). Instead, we can add new ZST variants to those types that did not have other variants which could be used for this purpose.

Based on https://github.com/rust-lang/rust/pull/98831. Only the commits starting from "don't allow ZST in ScalarInt" are new.

r? `@oli-obk`
This commit is contained in:
bors 2022-07-09 17:16:00 +00:00
commit f893495e3d
139 changed files with 312 additions and 291 deletions
Download patch file Download diff file Expand all files Collapse all files

1
compiler/rustc_codegen_cranelift/src/constant.rs
View file

@ -167,6 +167,7 @@ pub(crate) fn codegen_const_value<'tcx>(
} }
match const_val { match const_val {
ConstValue::ZeroSized => unreachable!(), // we already handles ZST above
ConstValue::Scalar(x) => match x { ConstValue::Scalar(x) => match x {
Scalar::Int(int) => { Scalar::Int(int) => {
if fx.clif_type(layout.ty).is_some() { if fx.clif_type(layout.ty).is_some() {

9
compiler/rustc_codegen_gcc/src/common.rs
View file

@ -9,7 +9,6 @@ use rustc_codegen_ssa::traits::{
StaticMethods, StaticMethods,
}; };
use rustc_middle::mir::Mutability; use rustc_middle::mir::Mutability;
use rustc_middle::ty::ScalarInt;
use rustc_middle::ty::layout::{TyAndLayout, LayoutOf}; use rustc_middle::ty::layout::{TyAndLayout, LayoutOf};
use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar}; use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
use rustc_target::abi::{self, HasDataLayout, Pointer, Size}; use rustc_target::abi::{self, HasDataLayout, Pointer, Size};
@ -159,13 +158,13 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
None None
} }
fn zst_to_backend(&self, _ty: Type<'gcc>) -> RValue<'gcc> {
self.const_undef(self.type_ix(0))
}
fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Type<'gcc>) -> RValue<'gcc> { fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Type<'gcc>) -> RValue<'gcc> {
let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() }; let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() };
match cv { match cv {
Scalar::Int(ScalarInt::ZST) => {
assert_eq!(0, layout.size(self).bytes());
self.const_undef(self.type_ix(0))
}
Scalar::Int(int) => { Scalar::Int(int) => {
let data = int.assert_bits(layout.size(self)); let data = int.assert_bits(layout.size(self));

9
compiler/rustc_codegen_llvm/src/common.rs
View file

@ -13,7 +13,6 @@ use rustc_codegen_ssa::traits::*;
use rustc_middle::bug; use rustc_middle::bug;
use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar}; use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
use rustc_middle::ty::layout::{LayoutOf, TyAndLayout}; use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
use rustc_middle::ty::ScalarInt;
use rustc_target::abi::{self, AddressSpace, HasDataLayout, Pointer, Size}; use rustc_target::abi::{self, AddressSpace, HasDataLayout, Pointer, Size};
use libc::{c_char, c_uint}; use libc::{c_char, c_uint};
@ -223,13 +222,13 @@ impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
}) })
} }
fn zst_to_backend(&self, _llty: &'ll Type) -> &'ll Value {
self.const_undef(self.type_ix(0))
}
fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, llty: &'ll Type) -> &'ll Value { fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, llty: &'ll Type) -> &'ll Value {
let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() }; let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() };
match cv { match cv {
Scalar::Int(ScalarInt::ZST) => {
assert_eq!(0, layout.size(self).bytes());
self.const_undef(self.type_ix(0))
}
Scalar::Int(int) => { Scalar::Int(int) => {
let data = int.assert_bits(layout.size(self)); let data = int.assert_bits(layout.size(self));
let llval = self.const_uint_big(self.type_ix(bitsize), data); let llval = self.const_uint_big(self.type_ix(bitsize), data);

4
compiler/rustc_codegen_ssa/src/mir/operand.rs
View file

@ -84,6 +84,10 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
let llval = bx.scalar_to_backend(x, scalar, bx.immediate_backend_type(layout)); let llval = bx.scalar_to_backend(x, scalar, bx.immediate_backend_type(layout));
OperandValue::Immediate(llval) OperandValue::Immediate(llval)
} }
ConstValue::ZeroSized => {
let llval = bx.zst_to_backend(bx.immediate_backend_type(layout));
OperandValue::Immediate(llval)
}
ConstValue::Slice { data, start, end } => { ConstValue::Slice { data, start, end } => {
let Abi::ScalarPair(a_scalar, _) = layout.abi else { let Abi::ScalarPair(a_scalar, _) = layout.abi else {
bug!("from_const: invalid ScalarPair layout: {:#?}", layout); bug!("from_const: invalid ScalarPair layout: {:#?}", layout);

1
compiler/rustc_codegen_ssa/src/traits/consts.rs
View file

@ -29,6 +29,7 @@ pub trait ConstMethods<'tcx>: BackendTypes {
fn const_data_from_alloc(&self, alloc: ConstAllocation<'tcx>) -> Self::Value; fn const_data_from_alloc(&self, alloc: ConstAllocation<'tcx>) -> Self::Value;
fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, llty: Self::Type) -> Self::Value; fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, llty: Self::Type) -> Self::Value;
fn zst_to_backend(&self, llty: Self::Type) -> Self::Value;
fn from_const_alloc( fn from_const_alloc(
&self, &self,
layout: TyAndLayout<'tcx>, layout: TyAndLayout<'tcx>,

4
compiler/rustc_const_eval/src/const_eval/eval_queries.rs
View file

@ -2,7 +2,7 @@ use super::{CompileTimeEvalContext, CompileTimeInterpreter, ConstEvalErr};
use crate::interpret::eval_nullary_intrinsic; use crate::interpret::eval_nullary_intrinsic;
use crate::interpret::{ use crate::interpret::{
intern_const_alloc_recursive, Allocation, ConstAlloc, ConstValue, CtfeValidationMode, GlobalId, intern_const_alloc_recursive, Allocation, ConstAlloc, ConstValue, CtfeValidationMode, GlobalId,
Immediate, InternKind, InterpCx, InterpResult, MPlaceTy, MemoryKind, OpTy, RefTracking, Scalar, Immediate, InternKind, InterpCx, InterpResult, MPlaceTy, MemoryKind, OpTy, RefTracking,
ScalarMaybeUninit, StackPopCleanup, ScalarMaybeUninit, StackPopCleanup,
}; };
@ -157,7 +157,7 @@ pub(super) fn op_to_const<'tcx>(
"this MPlaceTy must come from a validated constant, thus we can assume the \ "this MPlaceTy must come from a validated constant, thus we can assume the \
alignment is correct", alignment is correct",
); );
ConstValue::Scalar(Scalar::ZST) ConstValue::ZeroSized
} }
} }
}; };

8
compiler/rustc_const_eval/src/const_eval/valtrees.rs
View file

@ -272,7 +272,7 @@ pub fn valtree_to_const_value<'tcx>(
match ty.kind() { match ty.kind() {
ty::FnDef(..) => { ty::FnDef(..) => {
assert!(valtree.unwrap_branch().is_empty()); assert!(valtree.unwrap_branch().is_empty());
ConstValue::Scalar(Scalar::ZST) ConstValue::ZeroSized
} }
ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Char => match valtree { ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Char => match valtree {
ty::ValTree::Leaf(scalar_int) => ConstValue::Scalar(Scalar::Int(scalar_int)), ty::ValTree::Leaf(scalar_int) => ConstValue::Scalar(Scalar::Int(scalar_int)),
@ -344,11 +344,7 @@ fn valtree_into_mplace<'tcx>(
match ty.kind() { match ty.kind() {
ty::FnDef(_, _) => { ty::FnDef(_, _) => {
ecx.write_immediate( ecx.write_immediate(Immediate::Uninit, &place.into()).unwrap();
Immediate::Scalar(ScalarMaybeUninit::Scalar(Scalar::ZST)),
&place.into(),
)
.unwrap();
} }
ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Char => { ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Char => {
let scalar_int = valtree.unwrap_leaf(); let scalar_int = valtree.unwrap_leaf();

13
compiler/rustc_const_eval/src/interpret/operand.rs
View file

@ -297,8 +297,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let Some(alloc) = self.get_place_alloc(mplace)? else { let Some(alloc) = self.get_place_alloc(mplace)? else {
return Ok(Some(ImmTy { return Ok(Some(ImmTy {
// zero-sized type // zero-sized type can be left uninit
imm: Scalar::ZST.into(), imm: Immediate::Uninit,
layout: mplace.layout, layout: mplace.layout,
})); }));
}; };
@ -441,8 +441,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// This makes several assumptions about what layouts we will encounter; we match what // This makes several assumptions about what layouts we will encounter; we match what
// codegen does as good as we can (see `extract_field` in `rustc_codegen_ssa/src/mir/operand.rs`). // codegen does as good as we can (see `extract_field` in `rustc_codegen_ssa/src/mir/operand.rs`).
let field_val: Immediate<_> = match (*base, base.layout.abi) { let field_val: Immediate<_> = match (*base, base.layout.abi) {
// the field contains no information // the field contains no information, can be left uninit
_ if field_layout.is_zst() => Scalar::ZST.into(), _ if field_layout.is_zst() => Immediate::Uninit,
// the field covers the entire type // the field covers the entire type
_ if field_layout.size == base.layout.size => { _ if field_layout.size == base.layout.size => {
assert!(match (base.layout.abi, field_layout.abi) { assert!(match (base.layout.abi, field_layout.abi) {
@ -553,8 +553,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> { ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> {
let layout = self.layout_of_local(frame, local, layout)?; let layout = self.layout_of_local(frame, local, layout)?;
let op = if layout.is_zst() { let op = if layout.is_zst() {
// Do not read from ZST, they might not be initialized // Bypass `access_local` (helps in ConstProp)
Operand::Immediate(Scalar::ZST.into()) Operand::Immediate(Immediate::Uninit)
} else { } else {
*M::access_local(frame, local)? *M::access_local(frame, local)?
}; };
@ -709,6 +709,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
Operand::Indirect(MemPlace::from_ptr(ptr.into())) Operand::Indirect(MemPlace::from_ptr(ptr.into()))
} }
ConstValue::Scalar(x) => Operand::Immediate(tag_scalar(x)?.into()), ConstValue::Scalar(x) => Operand::Immediate(tag_scalar(x)?.into()),
ConstValue::ZeroSized => Operand::Immediate(Immediate::Uninit),
ConstValue::Slice { data, start, end } => { ConstValue::Slice { data, start, end } => {
// We rely on mutability being set correctly in `data` to prevent writes // We rely on mutability being set correctly in `data` to prevent writes
// where none should happen. // where none should happen.

1
compiler/rustc_middle/src/lib.rs
View file

@ -59,6 +59,7 @@
#![feature(drain_filter)] #![feature(drain_filter)]
#![feature(intra_doc_pointers)] #![feature(intra_doc_pointers)]
#![feature(yeet_expr)] #![feature(yeet_expr)]
#![feature(const_option)]
#![recursion_limit = "512"] #![recursion_limit = "512"]
#![allow(rustc::potential_query_instability)] #![allow(rustc::potential_query_instability)]

14
compiler/rustc_middle/src/mir/interpret/value.rs
View file

@ -29,11 +29,14 @@ pub struct ConstAlloc<'tcx> {
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable, Hash)] #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable, Hash)]
#[derive(HashStable)] #[derive(HashStable)]
pub enum ConstValue<'tcx> { pub enum ConstValue<'tcx> {
/// Used only for types with `layout::abi::Scalar` ABI and ZSTs. /// Used only for types with `layout::abi::Scalar` ABI.
/// ///
/// Not using the enum `Value` to encode that this must not be `Uninit`. /// Not using the enum `Value` to encode that this must not be `Uninit`.
Scalar(Scalar), Scalar(Scalar),
/// Only used for ZSTs.
ZeroSized,
/// Used only for `&[u8]` and `&str` /// Used only for `&[u8]` and `&str`
Slice { data: ConstAllocation<'tcx>, start: usize, end: usize }, Slice { data: ConstAllocation<'tcx>, start: usize, end: usize },
@ -55,6 +58,7 @@ impl<'a, 'tcx> Lift<'tcx> for ConstValue<'a> {
fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<ConstValue<'tcx>> { fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<ConstValue<'tcx>> {
Some(match self { Some(match self {
ConstValue::Scalar(s) => ConstValue::Scalar(s), ConstValue::Scalar(s) => ConstValue::Scalar(s),
ConstValue::ZeroSized => ConstValue::ZeroSized,
ConstValue::Slice { data, start, end } => { ConstValue::Slice { data, start, end } => {
ConstValue::Slice { data: tcx.lift(data)?, start, end } ConstValue::Slice { data: tcx.lift(data)?, start, end }
} }
@ -69,7 +73,7 @@ impl<'tcx> ConstValue<'tcx> {
#[inline] #[inline]
pub fn try_to_scalar(&self) -> Option<Scalar<AllocId>> { pub fn try_to_scalar(&self) -> Option<Scalar<AllocId>> {
match *self { match *self {
ConstValue::ByRef { .. } | ConstValue::Slice { .. } => None, ConstValue::ByRef { .. } | ConstValue::Slice { .. } | ConstValue::ZeroSized => None,
ConstValue::Scalar(val) => Some(val), ConstValue::Scalar(val) => Some(val),
} }
} }
@ -111,10 +115,6 @@ impl<'tcx> ConstValue<'tcx> {
pub fn from_machine_usize(i: u64, cx: &impl HasDataLayout) -> Self { pub fn from_machine_usize(i: u64, cx: &impl HasDataLayout) -> Self {
ConstValue::Scalar(Scalar::from_machine_usize(i, cx)) ConstValue::Scalar(Scalar::from_machine_usize(i, cx))
} }
pub fn zst() -> Self {
Self::Scalar(Scalar::ZST)
}
} }
/// A `Scalar` represents an immediate, primitive value existing outside of a /// A `Scalar` represents an immediate, primitive value existing outside of a
@ -194,8 +194,6 @@ impl<Tag> From<ScalarInt> for Scalar<Tag> {
} }
impl<Tag> Scalar<Tag> { impl<Tag> Scalar<Tag> {
pub const ZST: Self = Scalar::Int(ScalarInt::ZST);
#[inline(always)] #[inline(always)]
pub fn from_pointer(ptr: Pointer<Tag>, cx: &impl HasDataLayout) -> Self { pub fn from_pointer(ptr: Pointer<Tag>, cx: &impl HasDataLayout) -> Self {
Scalar::Ptr(ptr, u8::try_from(cx.pointer_size().bytes()).unwrap()) Scalar::Ptr(ptr, u8::try_from(cx.pointer_size().bytes()).unwrap())

11
compiler/rustc_middle/src/mir/mod.rs
View file

@ -1711,7 +1711,7 @@ impl<'tcx> Operand<'tcx> {
Operand::Constant(Box::new(Constant { Operand::Constant(Box::new(Constant {
span, span,
user_ty: None, user_ty: None,
literal: ConstantKind::Val(ConstValue::zst(), ty), literal: ConstantKind::Val(ConstValue::ZeroSized, ty),
})) }))
} }
@ -2196,7 +2196,7 @@ impl<'tcx> ConstantKind<'tcx> {
#[inline] #[inline]
pub fn zero_sized(ty: Ty<'tcx>) -> Self { pub fn zero_sized(ty: Ty<'tcx>) -> Self {
let cv = ConstValue::Scalar(Scalar::ZST); let cv = ConstValue::ZeroSized;
Self::Val(cv, ty) Self::Val(cv, ty)
} }
@ -2772,6 +2772,13 @@ fn pretty_print_const_value<'tcx>(
fmt.write_str(&cx.into_buffer())?; fmt.write_str(&cx.into_buffer())?;
return Ok(()); return Ok(());
} }
(ConstValue::ZeroSized, ty::FnDef(d, s)) => {
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
cx.print_alloc_ids = true;
let cx = cx.print_value_path(*d, s)?;
fmt.write_str(&cx.into_buffer())?;
return Ok(());
}
// FIXME(oli-obk): also pretty print arrays and other aggregate constants by reading // FIXME(oli-obk): also pretty print arrays and other aggregate constants by reading
// their fields instead of just dumping the memory. // their fields instead of just dumping the memory.
_ => {} _ => {}

3
compiler/rustc_middle/src/mir/pretty.rs
View file

@ -448,7 +448,9 @@ impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
self.push(&format!("+ user_ty: {:?}", user_ty)); self.push(&format!("+ user_ty: {:?}", user_ty));
} }
// FIXME: this is a poor version of `pretty_print_const_value`.
let fmt_val = |val: &ConstValue<'tcx>| match val { let fmt_val = |val: &ConstValue<'tcx>| match val {
ConstValue::ZeroSized => format!("<ZST>"),
ConstValue::Scalar(s) => format!("Scalar({:?})", s), ConstValue::Scalar(s) => format!("Scalar({:?})", s),
ConstValue::Slice { .. } => format!("Slice(..)"), ConstValue::Slice { .. } => format!("Slice(..)"),
ConstValue::ByRef { .. } => format!("ByRef(..)"), ConstValue::ByRef { .. } => format!("ByRef(..)"),
@ -679,6 +681,7 @@ pub fn write_allocations<'tcx>(
ConstValue::Scalar(interpret::Scalar::Int { .. }) => { ConstValue::Scalar(interpret::Scalar::Int { .. }) => {
Either::Left(Either::Right(std::iter::empty())) Either::Left(Either::Right(std::iter::empty()))
} }
ConstValue::ZeroSized => Either::Left(Either::Right(std::iter::empty())),
ConstValue::ByRef { alloc, .. } | ConstValue::Slice { data: alloc, .. } => { ConstValue::ByRef { alloc, .. } | ConstValue::Slice { data: alloc, .. } => {
Either::Right(alloc_ids_from_alloc(alloc)) Either::Right(alloc_ids_from_alloc(alloc))
} }

10
compiler/rustc_middle/src/thir.rs
View file

@ -419,6 +419,10 @@ pub enum ExprKind<'tcx> {
lit: ty::ScalarInt, lit: ty::ScalarInt,
user_ty: Option<Canonical<'tcx, UserType<'tcx>>>, user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
}, },
/// A literal of a ZST type.
ZstLiteral {
user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
},
/// Associated constants and named constants /// Associated constants and named constants
NamedConst { NamedConst {
def_id: DefId, def_id: DefId,
@ -454,12 +458,6 @@ pub enum ExprKind<'tcx> {
}, },
} }
impl<'tcx> ExprKind<'tcx> {
pub fn zero_sized_literal(user_ty: Option<Canonical<'tcx, UserType<'tcx>>>) -> Self {
ExprKind::NonHirLiteral { lit: ty::ScalarInt::ZST, user_ty }
}
}
/// Represents the association of a field identifier and an expression. /// Represents the association of a field identifier and an expression.
/// ///
/// This is used in struct constructors. /// This is used in struct constructors.

1
compiler/rustc_middle/src/thir/visit.rs
View file

@ -129,6 +129,7 @@ pub fn walk_expr<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, expr: &Exp
Closure { closure_id: _, substs: _, upvars: _, movability: _, fake_reads: _ } => {} Closure { closure_id: _, substs: _, upvars: _, movability: _, fake_reads: _ } => {}
Literal { lit: _, neg: _ } => {} Literal { lit: _, neg: _ } => {}
NonHirLiteral { lit: _, user_ty: _ } => {} NonHirLiteral { lit: _, user_ty: _ } => {}
ZstLiteral { user_ty: _ } => {}
NamedConst { def_id: _, substs: _, user_ty: _ } => {} NamedConst { def_id: _, substs: _, user_ty: _ } => {}
ConstParam { param: _, def_id: _ } => {} ConstParam { param: _, def_id: _ } => {}
StaticRef { alloc_id: _, ty: _, def_id: _ } => {} StaticRef { alloc_id: _, ty: _, def_id: _ } => {}

46
compiler/rustc_middle/src/ty/consts/int.rs
View file

@ -4,6 +4,7 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use rustc_target::abi::Size; use rustc_target::abi::Size;
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
use std::fmt; use std::fmt;
use std::num::NonZeroU8;
use crate::ty::TyCtxt; use crate::ty::TyCtxt;
@ -123,7 +124,7 @@ pub struct ScalarInt {
/// The first `size` bytes of `data` are the value. /// The first `size` bytes of `data` are the value.
/// Do not try to read less or more bytes than that. The remaining bytes must be 0. /// Do not try to read less or more bytes than that. The remaining bytes must be 0.
data: u128, data: u128,
size: u8, size: NonZeroU8,
} }
// Cannot derive these, as the derives take references to the fields, and we // Cannot derive these, as the derives take references to the fields, and we
@ -135,33 +136,31 @@ impl<CTX> crate::ty::HashStable<CTX> for ScalarInt {
// Since `Self` is a packed struct, that would create a possibly unaligned reference, // Since `Self` is a packed struct, that would create a possibly unaligned reference,
// which is UB. // which is UB.
{ self.data }.hash_stable(hcx, hasher); { self.data }.hash_stable(hcx, hasher);
self.size.hash_stable(hcx, hasher); self.size.get().hash_stable(hcx, hasher);
} }
} }
impl<S: Encoder> Encodable<S> for ScalarInt { impl<S: Encoder> Encodable<S> for ScalarInt {
fn encode(&self, s: &mut S) { fn encode(&self, s: &mut S) {
s.emit_u128(self.data); s.emit_u128(self.data);
s.emit_u8(self.size); s.emit_u8(self.size.get());
} }
} }
impl<D: Decoder> Decodable<D> for ScalarInt { impl<D: Decoder> Decodable<D> for ScalarInt {
fn decode(d: &mut D) -> ScalarInt { fn decode(d: &mut D) -> ScalarInt {
ScalarInt { data: d.read_u128(), size: d.read_u8() } ScalarInt { data: d.read_u128(), size: NonZeroU8::new(d.read_u8()).unwrap() }
} }
} }
impl ScalarInt { impl ScalarInt {
pub const TRUE: ScalarInt = ScalarInt { data: 1_u128, size: 1 }; pub const TRUE: ScalarInt = ScalarInt { data: 1_u128, size: NonZeroU8::new(1).unwrap() };
pub const FALSE: ScalarInt = ScalarInt { data: 0_u128, size: 1 }; pub const FALSE: ScalarInt = ScalarInt { data: 0_u128, size: NonZeroU8::new(1).unwrap() };
pub const ZST: ScalarInt = ScalarInt { data: 0_u128, size: 0 };
#[inline] #[inline]
pub fn size(self) -> Size { pub fn size(self) -> Size {
Size::from_bytes(self.size) Size::from_bytes(self.size.get())
} }
/// Make sure the `data` fits in `size`. /// Make sure the `data` fits in `size`.
@ -185,7 +184,7 @@ impl ScalarInt {
#[inline] #[inline]
pub fn null(size: Size) -> Self { pub fn null(size: Size) -> Self {
Self { data: 0, size: size.bytes() as u8 } Self { data: 0, size: NonZeroU8::new(size.bytes() as u8).unwrap() }
} }
#[inline] #[inline]
@ -197,7 +196,7 @@ impl ScalarInt {
pub fn try_from_uint(i: impl Into<u128>, size: Size) -> Option<Self> { pub fn try_from_uint(i: impl Into<u128>, size: Size) -> Option<Self> {
let data = i.into(); let data = i.into();
if size.truncate(data) == data { if size.truncate(data) == data {
Some(Self { data, size: size.bytes() as u8 }) Some(Self { data, size: NonZeroU8::new(size.bytes() as u8).unwrap() })
} else { } else {
None None
} }
@ -209,7 +208,7 @@ impl ScalarInt {
// `into` performed sign extension, we have to truncate // `into` performed sign extension, we have to truncate
let truncated = size.truncate(i as u128); let truncated = size.truncate(i as u128);
if size.sign_extend(truncated) as i128 == i { if size.sign_extend(truncated) as i128 == i {
Some(Self { data: truncated, size: size.bytes() as u8 }) Some(Self { data: truncated, size: NonZeroU8::new(size.bytes() as u8).unwrap() })
} else { } else {
None None
} }
@ -225,7 +224,7 @@ impl ScalarInt {
#[inline] #[inline]
pub fn to_bits(self, target_size: Size) -> Result<u128, Size> { pub fn to_bits(self, target_size: Size) -> Result<u128, Size> {
assert_ne!(target_size.bytes(), 0, "you should never look at the bits of a ZST"); assert_ne!(target_size.bytes(), 0, "you should never look at the bits of a ZST");
if target_size.bytes() == u64::from(self.size) { if target_size.bytes() == u64::from(self.size.get()) {
self.check_data(); self.check_data();
Ok(self.data) Ok(self.data)
} else { } else {
@ -339,7 +338,7 @@ macro_rules! from {
fn from(u: $ty) -> Self { fn from(u: $ty) -> Self {
Self { Self {
data: u128::from(u), data: u128::from(u),
size: std::mem::size_of::<$ty>() as u8, size: NonZeroU8::new(std::mem::size_of::<$ty>() as u8).unwrap(),
} }
} }
} }
@ -382,7 +381,7 @@ impl TryFrom<ScalarInt> for bool {
impl From<char> for ScalarInt { impl From<char> for ScalarInt {
#[inline] #[inline]
fn from(c: char) -> Self { fn from(c: char) -> Self {
Self { data: c as u128, size: std::mem::size_of::<char>() as u8 } Self { data: c as u128, size: NonZeroU8::new(std::mem::size_of::<char>() as u8).unwrap() }
} }
} }
@ -409,7 +408,7 @@ impl From<Single> for ScalarInt {
#[inline] #[inline]
fn from(f: Single) -> Self { fn from(f: Single) -> Self {
// We trust apfloat to give us properly truncated data. // We trust apfloat to give us properly truncated data.
Self { data: f.to_bits(), size: 4 } Self { data: f.to_bits(), size: NonZeroU8::new((Single::BITS / 8) as u8).unwrap() }
} }
} }
@ -425,7 +424,7 @@ impl From<Double> for ScalarInt {
#[inline] #[inline]
fn from(f: Double) -> Self { fn from(f: Double) -> Self {
// We trust apfloat to give us properly truncated data. // We trust apfloat to give us properly truncated data.
Self { data: f.to_bits(), size: 8 } Self { data: f.to_bits(), size: NonZeroU8::new((Double::BITS / 8) as u8).unwrap() }
} }
} }
@ -439,13 +438,8 @@ impl TryFrom<ScalarInt> for Double {
impl fmt::Debug for ScalarInt { impl fmt::Debug for ScalarInt {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.size == 0 { // Dispatch to LowerHex below.
self.check_data(); write!(f, "0x{:x}", self)
write!(f, "<ZST>")
} else {
// Dispatch to LowerHex below.
write!(f, "0x{:x}", self)
}
} }
} }
@ -463,7 +457,7 @@ impl fmt::LowerHex for ScalarInt {
// would thus borrow `self.data`. Since `Self` // would thus borrow `self.data`. Since `Self`
// is a packed struct, that would create a possibly unaligned reference, which // is a packed struct, that would create a possibly unaligned reference, which
// is UB. // is UB.
write!(f, "{:01$x}", { self.data }, self.size as usize * 2) write!(f, "{:01$x}", { self.data }, self.size.get() as usize * 2)
} }
} }
@ -477,7 +471,7 @@ impl fmt::UpperHex for ScalarInt {
// would thus borrow `self.data`. Since `Self` // would thus borrow `self.data`. Since `Self`
// is a packed struct, that would create a possibly unaligned reference, which // is a packed struct, that would create a possibly unaligned reference, which
// is UB. // is UB.
write!(f, "{:01$X}", { self.data }, self.size as usize * 2) write!(f, "{:01$X}", { self.data }, self.size.get() as usize * 2)
} }
} }

4
compiler/rustc_middle/src/ty/print/pretty.rs
View file

@ -1355,10 +1355,6 @@ pub trait PrettyPrinter<'tcx>:
" as ", " as ",
)?; )?;
} }
// For function type zsts just printing the path is enough
ty::FnDef(d, s) if int == ScalarInt::ZST => {
p!(print_value_path(*d, s))
}
// Nontrivial types with scalar bit representation // Nontrivial types with scalar bit representation
_ => { _ => {
let print = |mut this: Self| { let print = |mut this: Self| {

13
compiler/rustc_mir_build/src/build/expr/as_constant.rs
View file

@ -49,11 +49,22 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
inferred_ty: ty, inferred_ty: ty,
}) })
}); });
let literal = ConstantKind::Val(ConstValue::Scalar(Scalar::Int(lit)), ty); let literal = ConstantKind::Val(ConstValue::Scalar(Scalar::Int(lit)), ty);
Constant { span, user_ty: user_ty, literal } Constant { span, user_ty: user_ty, literal }
} }
ExprKind::ZstLiteral { user_ty } => {
let user_ty = user_ty.map(|user_ty| {
this.canonical_user_type_annotations.push(CanonicalUserTypeAnnotation {
span,
user_ty,
inferred_ty: ty,
})
});
let literal = ConstantKind::Val(ConstValue::ZeroSized, ty);
Constant { span, user_ty: user_ty, literal }
}
ExprKind::NamedConst { def_id, substs, user_ty } => { ExprKind::NamedConst { def_id, substs, user_ty } => {
let user_ty = user_ty.map(|user_ty| { let user_ty = user_ty.map(|user_ty| {
this.canonical_user_type_annotations.push(CanonicalUserTypeAnnotation { this.canonical_user_type_annotations.push(CanonicalUserTypeAnnotation {

1
compiler/rustc_mir_build/src/build/expr/as_place.rs
View file

@ -603,6 +603,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
| ExprKind::Literal { .. } | ExprKind::Literal { .. }
| ExprKind::NamedConst { .. } | ExprKind::NamedConst { .. }
| ExprKind::NonHirLiteral { .. } | ExprKind::NonHirLiteral { .. }
| ExprKind::ZstLiteral { .. }
| ExprKind::ConstParam { .. } | ExprKind::ConstParam { .. }
| ExprKind::ConstBlock { .. } | ExprKind::ConstBlock { .. }
| ExprKind::StaticRef { .. } | ExprKind::StaticRef { .. }

1
compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
View file

@ -415,6 +415,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
ExprKind::Literal { .. } ExprKind::Literal { .. }
| ExprKind::NamedConst { .. } | ExprKind::NamedConst { .. }
| ExprKind::NonHirLiteral { .. } | ExprKind::NonHirLiteral { .. }
| ExprKind::ZstLiteral { .. }
| ExprKind::ConstParam { .. } | ExprKind::ConstParam { .. }
| ExprKind::ConstBlock { .. } | ExprKind::ConstBlock { .. }
| ExprKind::StaticRef { .. } => { | ExprKind::StaticRef { .. } => {

1
compiler/rustc_mir_build/src/build/expr/category.rs
View file

@ -72,6 +72,7 @@ impl Category {
ExprKind::ConstBlock { .. } ExprKind::ConstBlock { .. }
| ExprKind::Literal { .. } | ExprKind::Literal { .. }
| ExprKind::NonHirLiteral { .. } | ExprKind::NonHirLiteral { .. }
| ExprKind::ZstLiteral { .. }
| ExprKind::ConstParam { .. } | ExprKind::ConstParam { .. }
| ExprKind::StaticRef { .. } | ExprKind::StaticRef { .. }
| ExprKind::NamedConst { .. } => Some(Category::Constant), | ExprKind::NamedConst { .. } => Some(Category::Constant),

1
compiler/rustc_mir_build/src/build/expr/into.rs
View file

@ -559,6 +559,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
| ExprKind::Literal { .. } | ExprKind::Literal { .. }
| ExprKind::NamedConst { .. } | ExprKind::NamedConst { .. }
| ExprKind::NonHirLiteral { .. } | ExprKind::NonHirLiteral { .. }
| ExprKind::ZstLiteral { .. }
| ExprKind::ConstParam { .. } | ExprKind::ConstParam { .. }
| ExprKind::ThreadLocalRef(_) | ExprKind::ThreadLocalRef(_)
| ExprKind::StaticRef { .. } => { | ExprKind::StaticRef { .. } => {

1
compiler/rustc_mir_build/src/check_unsafety.rs
View file

@ -307,6 +307,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
| ExprKind::Literal { .. } | ExprKind::Literal { .. }
| ExprKind::NamedConst { .. } | ExprKind::NamedConst { .. }
| ExprKind::NonHirLiteral { .. } | ExprKind::NonHirLiteral { .. }
| ExprKind::ZstLiteral { .. }
| ExprKind::ConstParam { .. } | ExprKind::ConstParam { .. }
| ExprKind::ConstBlock { .. } | ExprKind::ConstBlock { .. }
| ExprKind::Deref { .. } | ExprKind::Deref { .. }

4
compiler/rustc_mir_build/src/thir/cx/expr.rs
View file

@ -799,7 +799,7 @@ impl<'tcx> Cx<'tcx> {
} }
}; };
let ty = self.tcx().mk_fn_def(def_id, substs); let ty = self.tcx().mk_fn_def(def_id, substs);
Expr { temp_lifetime, ty, span, kind: ExprKind::zero_sized_literal(user_ty) } Expr { temp_lifetime, ty, span, kind: ExprKind::ZstLiteral { user_ty } }
} }
fn convert_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) -> ArmId { fn convert_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) -> ArmId {
@ -828,7 +828,7 @@ impl<'tcx> Cx<'tcx> {
| Res::Def(DefKind::Ctor(_, CtorKind::Fn), _) | Res::Def(DefKind::Ctor(_, CtorKind::Fn), _)
| Res::SelfCtor(_) => { | Res::SelfCtor(_) => {
let user_ty = self.user_substs_applied_to_res(expr.hir_id, res); let user_ty = self.user_substs_applied_to_res(expr.hir_id, res);
ExprKind::zero_sized_literal(user_ty) ExprKind::ZstLiteral { user_ty }
} }
Res::Def(DefKind::ConstParam, def_id) => { Res::Def(DefKind::ConstParam, def_id) => {

4
compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
View file

@ -451,6 +451,10 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
let val = ty::ValTree::from_scalar_int(lit); let val = ty::ValTree::from_scalar_int(lit);
self.nodes.push(Node::Leaf(ty::Const::from_value(self.tcx, val, node.ty))) self.nodes.push(Node::Leaf(ty::Const::from_value(self.tcx, val, node.ty)))
} }
&ExprKind::ZstLiteral { user_ty: _ } => {
let val = ty::ValTree::zst();
self.nodes.push(Node::Leaf(ty::Const::from_value(self.tcx, val, node.ty)))
}
&ExprKind::NamedConst { def_id, substs, user_ty: _ } => { &ExprKind::NamedConst { def_id, substs, user_ty: _ } => {
let uneval = ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs); let uneval = ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs);

2
src/test/mir-opt/array_index_is_temporary.main.SimplifyCfg-elaborate-drops.after.32bit.mir
View file

@ -39,7 +39,7 @@ fn main() -> () {
_5 = foo(move _6) -> bb1; // scope 4 at $DIR/array-index-is-temporary.rs:16:21: 16:27 _5 = foo(move _6) -> bb1; // scope 4 at $DIR/array-index-is-temporary.rs:16:21: 16:27
// mir::Constant // mir::Constant
// + span: $DIR/array-index-is-temporary.rs:16:21: 16:24 // + span: $DIR/array-index-is-temporary.rs:16:21: 16:24
// + literal: Const { ty: unsafe fn(*mut usize) -> u32 {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(*mut usize) -> u32 {foo}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/array_index_is_temporary.main.SimplifyCfg-elaborate-drops.after.64bit.mir
View file

@ -39,7 +39,7 @@ fn main() -> () {
_5 = foo(move _6) -> bb1; // scope 4 at $DIR/array-index-is-temporary.rs:16:21: 16:27 _5 = foo(move _6) -> bb1; // scope 4 at $DIR/array-index-is-temporary.rs:16:21: 16:27
// mir::Constant // mir::Constant
// + span: $DIR/array-index-is-temporary.rs:16:21: 16:24 // + span: $DIR/array-index-is-temporary.rs:16:21: 16:24
// + literal: Const { ty: unsafe fn(*mut usize) -> u32 {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(*mut usize) -> u32 {foo}, val: Value(<ZST>) }
} }
bb1: { bb1: {

6
src/test/mir-opt/box_expr.main.ElaborateDrops.before.mir
View file

@ -22,7 +22,7 @@ fn main() -> () {
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/box_expr.rs:7:13: 7:25 _4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/box_expr.rs:7:13: 7:25
// mir::Constant // mir::Constant
// + span: $DIR/box_expr.rs:7:13: 7:25 // + span: $DIR/box_expr.rs:7:13: 7:25
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -31,7 +31,7 @@ fn main() -> () {
(*_5) = S::new() -> [return: bb2, unwind: bb8]; // scope 0 at $DIR/box_expr.rs:7:17: 7:25 (*_5) = S::new() -> [return: bb2, unwind: bb8]; // scope 0 at $DIR/box_expr.rs:7:17: 7:25
// mir::Constant // mir::Constant
// + span: $DIR/box_expr.rs:7:17: 7:23 // + span: $DIR/box_expr.rs:7:17: 7:23
// + literal: Const { ty: fn() -> S {S::new}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> S {S::new}, val: Value(<ZST>) }
} }
bb2: { bb2: {
@ -47,7 +47,7 @@ fn main() -> () {
_6 = std::mem::drop::<Box<S>>(move _7) -> [return: bb4, unwind: bb6]; // scope 1 at $DIR/box_expr.rs:8:5: 8:12 _6 = std::mem::drop::<Box<S>>(move _7) -> [return: bb4, unwind: bb6]; // scope 1 at $DIR/box_expr.rs:8:5: 8:12
// mir::Constant // mir::Constant
// + span: $DIR/box_expr.rs:8:5: 8:9 // + span: $DIR/box_expr.rs:8:5: 8:9
// + literal: Const { ty: fn(Box<S>) {std::mem::drop::<Box<S>>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(Box<S>) {std::mem::drop::<Box<S>>}, val: Value(<ZST>) }
} }
bb4: { bb4: {

6
src/test/mir-opt/combine_clone_of_primitives.{impl#0}-clone.InstCombine.diff
View file

@ -24,7 +24,7 @@
_2 = <T as Clone>::clone(move _3) -> bb1; // scope 0 at $DIR/combine_clone_of_primitives.rs:8:5: 8:9 _2 = <T as Clone>::clone(move _3) -> bb1; // scope 0 at $DIR/combine_clone_of_primitives.rs:8:5: 8:9
// mir::Constant // mir::Constant
// + span: $DIR/combine_clone_of_primitives.rs:8:5: 8:9 // + span: $DIR/combine_clone_of_primitives.rs:8:5: 8:9
// + literal: Const { ty: for<'r> fn(&'r T) -> T {<T as Clone>::clone}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r T) -> T {<T as Clone>::clone}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -37,7 +37,7 @@
- _5 = <u64 as Clone>::clone(move _6) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11 - _5 = <u64 as Clone>::clone(move _6) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11
- // mir::Constant - // mir::Constant
- // + span: $DIR/combine_clone_of_primitives.rs:9:5: 9:11 - // + span: $DIR/combine_clone_of_primitives.rs:9:5: 9:11
- // + literal: Const { ty: for<'r> fn(&'r u64) -> u64 {<u64 as Clone>::clone}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> fn(&'r u64) -> u64 {<u64 as Clone>::clone}, val: Value(<ZST>) }
+ _6 = _7; // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11 + _6 = _7; // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11
+ _5 = (*_6); // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11 + _5 = (*_6); // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11
+ goto -> bb2; // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11 + goto -> bb2; // scope 0 at $DIR/combine_clone_of_primitives.rs:9:5: 9:11
@ -53,7 +53,7 @@
- _8 = <[f32; 3] as Clone>::clone(move _9) -> [return: bb3, unwind: bb4]; // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16 - _8 = <[f32; 3] as Clone>::clone(move _9) -> [return: bb3, unwind: bb4]; // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16
- // mir::Constant - // mir::Constant
- // + span: $DIR/combine_clone_of_primitives.rs:10:5: 10:16 - // + span: $DIR/combine_clone_of_primitives.rs:10:5: 10:16
- // + literal: Const { ty: for<'r> fn(&'r [f32; 3]) -> [f32; 3] {<[f32; 3] as Clone>::clone}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> fn(&'r [f32; 3]) -> [f32; 3] {<[f32; 3] as Clone>::clone}, val: Value(<ZST>) }
+ _9 = _10; // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16 + _9 = _10; // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16
+ _8 = (*_9); // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16 + _8 = (*_9); // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16
+ goto -> bb3; // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16 + goto -> bb3; // scope 0 at $DIR/combine_clone_of_primitives.rs:10:5: 10:16

2
src/test/mir-opt/const_promotion_extern_static.BAR.PromoteTemps.diff
View file

@ -33,7 +33,7 @@
_0 = core::slice::<impl [&i32]>::as_ptr(move _1) -> [return: bb1, unwind: bb2]; // scope 0 at $DIR/const-promotion-extern-static.rs:9:31: 9:44 _0 = core::slice::<impl [&i32]>::as_ptr(move _1) -> [return: bb1, unwind: bb2]; // scope 0 at $DIR/const-promotion-extern-static.rs:9:31: 9:44
// mir::Constant // mir::Constant
// + span: $DIR/const-promotion-extern-static.rs:9:36: 9:42 // + span: $DIR/const-promotion-extern-static.rs:9:36: 9:42
// + literal: Const { ty: for<'r> fn(&'r [&i32]) -> *const &i32 {core::slice::<impl [&i32]>::as_ptr}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r [&i32]) -> *const &i32 {core::slice::<impl [&i32]>::as_ptr}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_promotion_extern_static.FOO.PromoteTemps.diff
View file

@ -35,7 +35,7 @@
_0 = core::slice::<impl [&i32]>::as_ptr(move _1) -> [return: bb1, unwind: bb2]; // scope 0 at $DIR/const-promotion-extern-static.rs:13:31: 13:55 _0 = core::slice::<impl [&i32]>::as_ptr(move _1) -> [return: bb1, unwind: bb2]; // scope 0 at $DIR/const-promotion-extern-static.rs:13:31: 13:55
// mir::Constant // mir::Constant
// + span: $DIR/const-promotion-extern-static.rs:13:47: 13:53 // + span: $DIR/const-promotion-extern-static.rs:13:47: 13:53
// + literal: Const { ty: for<'r> fn(&'r [&i32]) -> *const &i32 {core::slice::<impl [&i32]>::as_ptr}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r [&i32]) -> *const &i32 {core::slice::<impl [&i32]>::as_ptr}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_prop/boxes.main.ConstProp.diff
View file

@ -32,7 +32,7 @@
+ _6 = alloc::alloc::exchange_malloc(const 4_usize, const 4_usize) -> bb1; // scope 2 at $DIR/boxes.rs:12:14: 12:22 + _6 = alloc::alloc::exchange_malloc(const 4_usize, const 4_usize) -> bb1; // scope 2 at $DIR/boxes.rs:12:14: 12:22
// mir::Constant // mir::Constant
// + span: $DIR/boxes.rs:12:14: 12:22 // + span: $DIR/boxes.rs:12:14: 12:22
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_prop/const_prop_fails_gracefully.main.ConstProp.diff
View file

@ -30,7 +30,7 @@
_4 = read(move _5) -> bb1; // scope 1 at $DIR/const_prop_fails_gracefully.rs:8:5: 8:12 _4 = read(move _5) -> bb1; // scope 1 at $DIR/const_prop_fails_gracefully.rs:8:5: 8:12
// mir::Constant // mir::Constant
// + span: $DIR/const_prop_fails_gracefully.rs:8:5: 8:9 // + span: $DIR/const_prop_fails_gracefully.rs:8:5: 8:9
// + literal: Const { ty: fn(usize) {read}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(usize) {read}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_prop/control_flow_simplification.hello.ConstProp.diff
View file

@ -19,7 +19,7 @@
_2 = begin_panic::<&str>(const "explicit panic"); // scope 0 at $SRC_DIR/std/src/panic.rs:LL:COL _2 = begin_panic::<&str>(const "explicit panic"); // scope 0 at $SRC_DIR/std/src/panic.rs:LL:COL
// mir::Constant // mir::Constant
// + span: $SRC_DIR/std/src/panic.rs:LL:COL // + span: $SRC_DIR/std/src/panic.rs:LL:COL
// + literal: Const { ty: fn(&str) -> ! {begin_panic::<&str>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(&str) -> ! {begin_panic::<&str>}, val: Value(<ZST>) }
// mir::Constant // mir::Constant
// + span: $SRC_DIR/std/src/panic.rs:LL:COL // + span: $SRC_DIR/std/src/panic.rs:LL:COL
// + literal: Const { ty: &str, val: Value(Slice(..)) } // + literal: Const { ty: &str, val: Value(Slice(..)) }

2
src/test/mir-opt/const_prop/issue_66971.main.ConstProp.diff
View file

@ -20,7 +20,7 @@
_1 = encode(move _2) -> bb1; // scope 0 at $DIR/issue-66971.rs:16:5: 16:23 _1 = encode(move _2) -> bb1; // scope 0 at $DIR/issue-66971.rs:16:5: 16:23
// mir::Constant // mir::Constant
// + span: $DIR/issue-66971.rs:16:5: 16:11 // + span: $DIR/issue-66971.rs:16:5: 16:11
// + literal: Const { ty: fn(((), u8, u8)) {encode}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(((), u8, u8)) {encode}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_prop/issue_67019.main.ConstProp.diff
View file

@ -21,7 +21,7 @@
_1 = test(move _2) -> bb1; // scope 0 at $DIR/issue-67019.rs:11:5: 11:20 _1 = test(move _2) -> bb1; // scope 0 at $DIR/issue-67019.rs:11:5: 11:20
// mir::Constant // mir::Constant
// + span: $DIR/issue-67019.rs:11:5: 11:9 // + span: $DIR/issue-67019.rs:11:5: 11:9
// + literal: Const { ty: fn(((u8, u8),)) {test}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(((u8, u8),)) {test}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.ConstProp.diff
View file

@ -17,7 +17,7 @@
_1 = foo() -> bb1; // scope 0 at $DIR/mutable_variable_aggregate_partial_read.rs:5:29: 5:34 _1 = foo() -> bb1; // scope 0 at $DIR/mutable_variable_aggregate_partial_read.rs:5:29: 5:34
// mir::Constant // mir::Constant
// + span: $DIR/mutable_variable_aggregate_partial_read.rs:5:29: 5:32 // + span: $DIR/mutable_variable_aggregate_partial_read.rs:5:29: 5:32
// + literal: Const { ty: fn() -> (i32, i32) {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> (i32, i32) {foo}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_prop/mutable_variable_unprop_assign.main.ConstProp.diff
View file

@ -26,7 +26,7 @@
_1 = foo() -> bb1; // scope 0 at $DIR/mutable_variable_unprop_assign.rs:5:13: 5:18 _1 = foo() -> bb1; // scope 0 at $DIR/mutable_variable_unprop_assign.rs:5:13: 5:18
// mir::Constant // mir::Constant
// + span: $DIR/mutable_variable_unprop_assign.rs:5:13: 5:16 // + span: $DIR/mutable_variable_unprop_assign.rs:5:13: 5:16
// + literal: Const { ty: fn() -> i32 {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> i32 {foo}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/const_prop/reify_fn_ptr.main.ConstProp.diff
View file

@ -16,7 +16,7 @@
_3 = main as fn() (Pointer(ReifyFnPointer)); // scope 0 at $DIR/reify_fn_ptr.rs:4:13: 4:17 _3 = main as fn() (Pointer(ReifyFnPointer)); // scope 0 at $DIR/reify_fn_ptr.rs:4:13: 4:17
// mir::Constant // mir::Constant
// + span: $DIR/reify_fn_ptr.rs:4:13: 4:17 // + span: $DIR/reify_fn_ptr.rs:4:13: 4:17
// + literal: Const { ty: fn() {main}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {main}, val: Value(<ZST>) }
_2 = move _3 as usize (PointerExposeAddress); // scope 0 at $DIR/reify_fn_ptr.rs:4:13: 4:26 _2 = move _3 as usize (PointerExposeAddress); // scope 0 at $DIR/reify_fn_ptr.rs:4:13: 4:26
StorageDead(_3); // scope 0 at $DIR/reify_fn_ptr.rs:4:25: 4:26 StorageDead(_3); // scope 0 at $DIR/reify_fn_ptr.rs:4:25: 4:26
_1 = move _2 as *const fn() (PointerFromExposedAddress); // scope 0 at $DIR/reify_fn_ptr.rs:4:13: 4:41 _1 = move _2 as *const fn() (PointerFromExposedAddress); // scope 0 at $DIR/reify_fn_ptr.rs:4:13: 4:41

2
src/test/mir-opt/const_prop/scalar_literal_propagation.main.ConstProp.diff
View file

@ -21,7 +21,7 @@
+ _2 = consume(const 1_u32) -> bb1; // scope 1 at $DIR/scalar_literal_propagation.rs:4:5: 4:15 + _2 = consume(const 1_u32) -> bb1; // scope 1 at $DIR/scalar_literal_propagation.rs:4:5: 4:15
// mir::Constant // mir::Constant
// + span: $DIR/scalar_literal_propagation.rs:4:5: 4:12 // + span: $DIR/scalar_literal_propagation.rs:4:5: 4:12
// + literal: Const { ty: fn(u32) {consume}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(u32) {consume}, val: Value(<ZST>) }
} }
bb1: { bb1: {

4
src/test/mir-opt/const_prop/switch_int.main.ConstProp.diff
View file

@ -16,14 +16,14 @@
_0 = foo(const -1_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:9:14: 9:21 _0 = foo(const -1_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:9:14: 9:21
// mir::Constant // mir::Constant
// + span: $DIR/switch_int.rs:9:14: 9:17 // + span: $DIR/switch_int.rs:9:14: 9:17
// + literal: Const { ty: fn(i32) {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(i32) {foo}, val: Value(<ZST>) }
} }
bb2: { bb2: {
_0 = foo(const 0_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:8:14: 8:20 _0 = foo(const 0_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:8:14: 8:20
// mir::Constant // mir::Constant
// + span: $DIR/switch_int.rs:8:14: 8:17 // + span: $DIR/switch_int.rs:8:14: 8:17
// + literal: Const { ty: fn(i32) {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(i32) {foo}, val: Value(<ZST>) }
} }
bb3: { bb3: {

4
src/test/mir-opt/const_prop/switch_int.main.SimplifyConstCondition-after-const-prop.diff
View file

@ -16,14 +16,14 @@
_0 = foo(const -1_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:9:14: 9:21 _0 = foo(const -1_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:9:14: 9:21
// mir::Constant // mir::Constant
// + span: $DIR/switch_int.rs:9:14: 9:17 // + span: $DIR/switch_int.rs:9:14: 9:17
// + literal: Const { ty: fn(i32) {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(i32) {foo}, val: Value(<ZST>) }
} }
bb2: { bb2: {
_0 = foo(const 0_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:8:14: 8:20 _0 = foo(const 0_i32) -> bb3; // scope 0 at $DIR/switch_int.rs:8:14: 8:20
// mir::Constant // mir::Constant
// + span: $DIR/switch_int.rs:8:14: 8:17 // + span: $DIR/switch_int.rs:8:14: 8:17
// + literal: Const { ty: fn(i32) {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(i32) {foo}, val: Value(<ZST>) }
} }
bb3: { bb3: {

2
src/test/mir-opt/const_prop/tuple_literal_propagation.main.ConstProp.diff
View file

@ -22,7 +22,7 @@
_2 = consume(move _3) -> bb1; // scope 1 at $DIR/tuple_literal_propagation.rs:5:5: 5:15 _2 = consume(move _3) -> bb1; // scope 1 at $DIR/tuple_literal_propagation.rs:5:5: 5:15
// mir::Constant // mir::Constant
// + span: $DIR/tuple_literal_propagation.rs:5:5: 5:12 // + span: $DIR/tuple_literal_propagation.rs:5:5: 5:12
// + literal: Const { ty: fn((u32, u32)) {consume}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn((u32, u32)) {consume}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.diff
View file

@ -28,7 +28,7 @@
_5 = cond() -> bb2; // scope 0 at $DIR/cycle.rs:12:11: 12:17 _5 = cond() -> bb2; // scope 0 at $DIR/cycle.rs:12:11: 12:17
// mir::Constant // mir::Constant
// + span: $DIR/cycle.rs:12:11: 12:15 // + span: $DIR/cycle.rs:12:11: 12:15
// + literal: Const { ty: fn() -> bool {cond}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> bool {cond}, val: Value(<ZST>) }
} }
bb2: { bb2: {

2
src/test/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.diff
View file

@ -27,7 +27,7 @@
+ _2 = transmute::<&str, &[u8]>(move _8) -> bb12; // scope 2 at $SRC_DIR/core/src/str/mod.rs:LL:COL + _2 = transmute::<&str, &[u8]>(move _8) -> bb12; // scope 2 at $SRC_DIR/core/src/str/mod.rs:LL:COL
// mir::Constant // mir::Constant
// + span: $SRC_DIR/core/src/str/mod.rs:LL:COL // + span: $SRC_DIR/core/src/str/mod.rs:LL:COL
// + literal: Const { ty: unsafe extern "rust-intrinsic" fn(&str) -> &[u8] {transmute::<&str, &[u8]>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(&str) -> &[u8] {transmute::<&str, &[u8]>}, val: Value(<ZST>) }
} }
bb1: { bb1: {

6
src/test/mir-opt/derefer_complex_case.main.Derefer.diff
View file

@ -36,7 +36,7 @@
_1 = <&[i32; 2] as IntoIterator>::into_iter(move _2) -> bb1; // scope 0 at $DIR/derefer_complex_case.rs:4:17: 4:26 _1 = <&[i32; 2] as IntoIterator>::into_iter(move _2) -> bb1; // scope 0 at $DIR/derefer_complex_case.rs:4:17: 4:26
// mir::Constant // mir::Constant
// + span: $DIR/derefer_complex_case.rs:4:17: 4:26 // + span: $DIR/derefer_complex_case.rs:4:17: 4:26
// + literal: Const { ty: fn(&[i32; 2]) -> <&[i32; 2] as IntoIterator>::IntoIter {<&[i32; 2] as IntoIterator>::into_iter}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(&[i32; 2]) -> <&[i32; 2] as IntoIterator>::IntoIter {<&[i32; 2] as IntoIterator>::into_iter}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -56,7 +56,7 @@
_7 = <std::slice::Iter<i32> as Iterator>::next(move _8) -> bb3; // scope 1 at $DIR/derefer_complex_case.rs:4:17: 4:26 _7 = <std::slice::Iter<i32> as Iterator>::next(move _8) -> bb3; // scope 1 at $DIR/derefer_complex_case.rs:4:17: 4:26
// mir::Constant // mir::Constant
// + span: $DIR/derefer_complex_case.rs:4:17: 4:26 // + span: $DIR/derefer_complex_case.rs:4:17: 4:26
// + literal: Const { ty: for<'r> fn(&'r mut std::slice::Iter<i32>) -> Option<<std::slice::Iter<i32> as Iterator>::Item> {<std::slice::Iter<i32> as Iterator>::next}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r mut std::slice::Iter<i32>) -> Option<<std::slice::Iter<i32> as Iterator>::Item> {<std::slice::Iter<i32> as Iterator>::next}, val: Value(<ZST>) }
} }
bb3: { bb3: {
@ -77,7 +77,7 @@
_6 = std::mem::drop::<i32>(move _13) -> bb7; // scope 2 at $DIR/derefer_complex_case.rs:4:29: 4:38 _6 = std::mem::drop::<i32>(move _13) -> bb7; // scope 2 at $DIR/derefer_complex_case.rs:4:29: 4:38
// mir::Constant // mir::Constant
// + span: $DIR/derefer_complex_case.rs:4:29: 4:33 // + span: $DIR/derefer_complex_case.rs:4:29: 4:33
// + literal: Const { ty: fn(i32) {std::mem::drop::<i32>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(i32) {std::mem::drop::<i32>}, val: Value(<ZST>) }
} }
bb5: { bb5: {

6
src/test/mir-opt/derefer_inline_test.main.Derefer.diff
View file

@ -19,7 +19,7 @@
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 1 at $DIR/derefer_inline_test.rs:10:5: 10:12 _4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 1 at $DIR/derefer_inline_test.rs:10:5: 10:12
// mir::Constant // mir::Constant
// + span: $DIR/derefer_inline_test.rs:10:5: 10:12 // + span: $DIR/derefer_inline_test.rs:10:5: 10:12
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -28,7 +28,7 @@
(*_5) = f() -> [return: bb2, unwind: bb5]; // scope 0 at $DIR/derefer_inline_test.rs:10:9: 10:12 (*_5) = f() -> [return: bb2, unwind: bb5]; // scope 0 at $DIR/derefer_inline_test.rs:10:9: 10:12
// mir::Constant // mir::Constant
// + span: $DIR/derefer_inline_test.rs:10:9: 10:10 // + span: $DIR/derefer_inline_test.rs:10:9: 10:10
// + literal: Const { ty: fn() -> Box<u32> {f}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> Box<u32> {f}, val: Value(<ZST>) }
} }
bb2: { bb2: {
@ -59,7 +59,7 @@
_6 = alloc::alloc::box_free::<Box<u32>, std::alloc::Global>(move (_5.0: std::ptr::Unique<std::boxed::Box<u32>>), move (_5.1: std::alloc::Global)) -> bb6; // scope 0 at $DIR/derefer_inline_test.rs:10:11: 10:12 _6 = alloc::alloc::box_free::<Box<u32>, std::alloc::Global>(move (_5.0: std::ptr::Unique<std::boxed::Box<u32>>), move (_5.1: std::alloc::Global)) -> bb6; // scope 0 at $DIR/derefer_inline_test.rs:10:11: 10:12
// mir::Constant // mir::Constant
// + span: $DIR/derefer_inline_test.rs:10:11: 10:12 // + span: $DIR/derefer_inline_test.rs:10:11: 10:12
// + literal: Const { ty: unsafe fn(Unique<Box<u32>>, std::alloc::Global) {alloc::alloc::box_free::<Box<u32>, std::alloc::Global>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(Unique<Box<u32>>, std::alloc::Global) {alloc::alloc::box_free::<Box<u32>, std::alloc::Global>}, val: Value(<ZST>) }
} }
bb8 (cleanup): { bb8 (cleanup): {

4
src/test/mir-opt/derefer_terminator_test.main.Derefer.diff
View file

@ -33,7 +33,7 @@
_1 = foo() -> bb1; // scope 0 at $DIR/derefer_terminator_test.rs:3:13: 3:18 _1 = foo() -> bb1; // scope 0 at $DIR/derefer_terminator_test.rs:3:13: 3:18
// mir::Constant // mir::Constant
// + span: $DIR/derefer_terminator_test.rs:3:13: 3:16 // + span: $DIR/derefer_terminator_test.rs:3:13: 3:16
// + literal: Const { ty: fn() -> bool {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> bool {foo}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -41,7 +41,7 @@
_2 = foo() -> bb2; // scope 1 at $DIR/derefer_terminator_test.rs:4:13: 4:18 _2 = foo() -> bb2; // scope 1 at $DIR/derefer_terminator_test.rs:4:13: 4:18
// mir::Constant // mir::Constant
// + span: $DIR/derefer_terminator_test.rs:4:13: 4:16 // + span: $DIR/derefer_terminator_test.rs:4:13: 4:16
// + literal: Const { ty: fn() -> bool {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> bool {foo}, val: Value(<ZST>) }
} }
bb2: { bb2: {

6
src/test/mir-opt/dest-prop/branch.main.DestinationPropagation.diff
View file

@ -19,7 +19,7 @@
_1 = val() -> bb1; // scope 0 at $DIR/branch.rs:13:13: 13:18 _1 = val() -> bb1; // scope 0 at $DIR/branch.rs:13:13: 13:18
// mir::Constant // mir::Constant
// + span: $DIR/branch.rs:13:13: 13:16 // + span: $DIR/branch.rs:13:13: 13:16
// + literal: Const { ty: fn() -> i32 {val}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> i32 {val}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -28,7 +28,7 @@
_3 = cond() -> bb2; // scope 1 at $DIR/branch.rs:15:16: 15:22 _3 = cond() -> bb2; // scope 1 at $DIR/branch.rs:15:16: 15:22
// mir::Constant // mir::Constant
// + span: $DIR/branch.rs:15:16: 15:20 // + span: $DIR/branch.rs:15:16: 15:20
// + literal: Const { ty: fn() -> bool {cond}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> bool {cond}, val: Value(<ZST>) }
} }
bb2: { bb2: {
@ -45,7 +45,7 @@
_4 = val() -> bb5; // scope 1 at $DIR/branch.rs:18:9: 18:14 _4 = val() -> bb5; // scope 1 at $DIR/branch.rs:18:9: 18:14
// mir::Constant // mir::Constant
// + span: $DIR/branch.rs:18:9: 18:12 // + span: $DIR/branch.rs:18:9: 18:12
// + literal: Const { ty: fn() -> i32 {val}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> i32 {val}, val: Value(<ZST>) }
} }
bb5: { bb5: {

2
src/test/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.diff
View file

@ -14,7 +14,7 @@
_2 = dummy(move _3) -> bb1; // scope 0 at $DIR/copy_propagation_arg.rs:16:5: 16:13 _2 = dummy(move _3) -> bb1; // scope 0 at $DIR/copy_propagation_arg.rs:16:5: 16:13
// mir::Constant // mir::Constant
// + span: $DIR/copy_propagation_arg.rs:16:5: 16:10 // + span: $DIR/copy_propagation_arg.rs:16:5: 16:10
// + literal: Const { ty: fn(u8) -> u8 {dummy}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(u8) -> u8 {dummy}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.diff
View file

@ -14,7 +14,7 @@
_2 = dummy(move _3) -> bb1; // scope 0 at $DIR/copy_propagation_arg.rs:11:9: 11:17 _2 = dummy(move _3) -> bb1; // scope 0 at $DIR/copy_propagation_arg.rs:11:9: 11:17
// mir::Constant // mir::Constant
// + span: $DIR/copy_propagation_arg.rs:11:9: 11:14 // + span: $DIR/copy_propagation_arg.rs:11:9: 11:14
// + literal: Const { ty: fn(u8) -> u8 {dummy}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(u8) -> u8 {dummy}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/dest-prop/cycle.main.DestinationPropagation.diff
View file

@ -27,7 +27,7 @@
_1 = val() -> bb1; // scope 0 at $DIR/cycle.rs:9:17: 9:22 _1 = val() -> bb1; // scope 0 at $DIR/cycle.rs:9:17: 9:22
// mir::Constant // mir::Constant
// + span: $DIR/cycle.rs:9:17: 9:20 // + span: $DIR/cycle.rs:9:17: 9:20
// + literal: Const { ty: fn() -> i32 {val}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> i32 {val}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/dest-prop/union.main.DestinationPropagation.diff
View file

@ -22,7 +22,7 @@
_2 = val() -> bb1; // scope 0 at $DIR/union.rs:13:23: 13:28 _2 = val() -> bb1; // scope 0 at $DIR/union.rs:13:23: 13:28
// mir::Constant // mir::Constant
// + span: $DIR/union.rs:13:23: 13:26 // + span: $DIR/union.rs:13:23: 13:26
// + literal: Const { ty: fn() -> u32 {val}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> u32 {val}, val: Value(<ZST>) }
} }
bb1: { bb1: {

8
src/test/mir-opt/funky_arms.float_to_exponential_common.ConstProp.diff
View file

@ -41,7 +41,7 @@
_4 = Formatter::sign_plus(move _5) -> bb1; // scope 0 at $DIR/funky_arms.rs:15:22: 15:37 _4 = Formatter::sign_plus(move _5) -> bb1; // scope 0 at $DIR/funky_arms.rs:15:22: 15:37
// mir::Constant // mir::Constant
// + span: $DIR/funky_arms.rs:15:26: 15:35 // + span: $DIR/funky_arms.rs:15:26: 15:35
// + literal: Const { ty: for<'r> fn(&'r Formatter) -> bool {Formatter::sign_plus}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r Formatter) -> bool {Formatter::sign_plus}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -69,7 +69,7 @@
_7 = Formatter::precision(move _8) -> bb5; // scope 3 at $DIR/funky_arms.rs:24:30: 24:45 _7 = Formatter::precision(move _8) -> bb5; // scope 3 at $DIR/funky_arms.rs:24:30: 24:45
// mir::Constant // mir::Constant
// + span: $DIR/funky_arms.rs:24:34: 24:43 // + span: $DIR/funky_arms.rs:24:34: 24:43
// + literal: Const { ty: for<'r> fn(&'r Formatter) -> Option<usize> {Formatter::precision}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r Formatter) -> Option<usize> {Formatter::precision}, val: Value(<ZST>) }
} }
bb5: { bb5: {
@ -100,7 +100,7 @@
_0 = float_to_exponential_common_exact::<T>(move _11, move _12, move _13, move _14, move _17) -> bb7; // scope 3 at $DIR/funky_arms.rs:26:9: 26:87 _0 = float_to_exponential_common_exact::<T>(move _11, move _12, move _13, move _14, move _17) -> bb7; // scope 3 at $DIR/funky_arms.rs:26:9: 26:87
// mir::Constant // mir::Constant
// + span: $DIR/funky_arms.rs:26:9: 26:42 // + span: $DIR/funky_arms.rs:26:9: 26:42
// + literal: Const { ty: for<'r, 's, 't0> fn(&'r mut Formatter<'s>, &'t0 T, Sign, u32, bool) -> Result<(), std::fmt::Error> {float_to_exponential_common_exact::<T>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r, 's, 't0> fn(&'r mut Formatter<'s>, &'t0 T, Sign, u32, bool) -> Result<(), std::fmt::Error> {float_to_exponential_common_exact::<T>}, val: Value(<ZST>) }
} }
bb7: { bb7: {
@ -125,7 +125,7 @@
_0 = float_to_exponential_common_shortest::<T>(move _18, move _19, move _20, move _21) -> bb9; // scope 2 at $DIR/funky_arms.rs:28:9: 28:68 _0 = float_to_exponential_common_shortest::<T>(move _18, move _19, move _20, move _21) -> bb9; // scope 2 at $DIR/funky_arms.rs:28:9: 28:68
// mir::Constant // mir::Constant
// + span: $DIR/funky_arms.rs:28:9: 28:45 // + span: $DIR/funky_arms.rs:28:9: 28:45
// + literal: Const { ty: for<'r, 's, 't0> fn(&'r mut Formatter<'s>, &'t0 T, Sign, bool) -> Result<(), std::fmt::Error> {float_to_exponential_common_shortest::<T>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r, 's, 't0> fn(&'r mut Formatter<'s>, &'t0 T, Sign, bool) -> Result<(), std::fmt::Error> {float_to_exponential_common_shortest::<T>}, val: Value(<ZST>) }
} }
bb9: { bb9: {

4
src/test/mir-opt/generator_storage_dead_unwind.main-{closure#0}.StateTransform.before.mir
View file

@ -41,7 +41,7 @@ yields ()
_7 = take::<Foo>(move _8) -> [return: bb2, unwind: bb9]; // scope 2 at $DIR/generator-storage-dead-unwind.rs:26:9: 26:16 _7 = take::<Foo>(move _8) -> [return: bb2, unwind: bb9]; // scope 2 at $DIR/generator-storage-dead-unwind.rs:26:9: 26:16
// mir::Constant // mir::Constant
// + span: $DIR/generator-storage-dead-unwind.rs:26:9: 26:13 // + span: $DIR/generator-storage-dead-unwind.rs:26:9: 26:13
// + literal: Const { ty: fn(Foo) {take::<Foo>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(Foo) {take::<Foo>}, val: Value(<ZST>) }
} }
bb2: { bb2: {
@ -53,7 +53,7 @@ yields ()
_9 = take::<Bar>(move _10) -> [return: bb3, unwind: bb8]; // scope 2 at $DIR/generator-storage-dead-unwind.rs:27:9: 27:16 _9 = take::<Bar>(move _10) -> [return: bb3, unwind: bb8]; // scope 2 at $DIR/generator-storage-dead-unwind.rs:27:9: 27:16
// mir::Constant // mir::Constant
// + span: $DIR/generator-storage-dead-unwind.rs:27:9: 27:13 // + span: $DIR/generator-storage-dead-unwind.rs:27:9: 27:13
// + literal: Const { ty: fn(Bar) {take::<Bar>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(Bar) {take::<Bar>}, val: Value(<ZST>) }
} }
bb3: { bb3: {

2
src/test/mir-opt/generator_tiny.main-{closure#0}.generator_resume.0.mir
View file

@ -61,7 +61,7 @@ fn main::{closure#0}(_1: Pin<&mut [generator@$DIR/generator-tiny.rs:19:16: 19:24
_8 = callee() -> bb4; // scope 1 at $DIR/generator-tiny.rs:23:13: 23:21 _8 = callee() -> bb4; // scope 1 at $DIR/generator-tiny.rs:23:13: 23:21
// mir::Constant // mir::Constant
// + span: $DIR/generator-tiny.rs:23:13: 23:19 // + span: $DIR/generator-tiny.rs:23:13: 23:19
// + literal: Const { ty: fn() {callee}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {callee}, val: Value(<ZST>) }
} }
bb4: { bb4: {

2
src/test/mir-opt/inline/caller_with_trivial_bound.foo.Inline.diff
View file

@ -13,7 +13,7 @@
_1 = bar::<T>() -> bb1; // scope 0 at $DIR/caller-with-trivial-bound.rs:20:51: 20:61 _1 = bar::<T>() -> bb1; // scope 0 at $DIR/caller-with-trivial-bound.rs:20:51: 20:61
// mir::Constant // mir::Constant
// + span: $DIR/caller-with-trivial-bound.rs:20:51: 20:59 // + span: $DIR/caller-with-trivial-bound.rs:20:51: 20:59
// + literal: Const { ty: fn() -> <IntFactory as Factory<T>>::Item {bar::<T>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> <IntFactory as Factory<T>>::Item {bar::<T>}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/inline/cycle.f.Inline.diff
View file

@ -17,7 +17,7 @@
_2 = <impl Fn() as Fn<()>>::call(move _3, move _4) -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/cycle.rs:6:5: 6:8 _2 = <impl Fn() as Fn<()>>::call(move _3, move _4) -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/cycle.rs:6:5: 6:8
// mir::Constant // mir::Constant
// + span: $DIR/cycle.rs:6:5: 6:6 // + span: $DIR/cycle.rs:6:5: 6:6
// + literal: Const { ty: for<'r> extern "rust-call" fn(&'r impl Fn(), ()) -> <impl Fn() as FnOnce<()>>::Output {<impl Fn() as Fn<()>>::call}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> extern "rust-call" fn(&'r impl Fn(), ()) -> <impl Fn() as FnOnce<()>>::Output {<impl Fn() as Fn<()>>::call}, val: Value(<ZST>) }
} }
bb1: { bb1: {

9
src/test/mir-opt/inline/cycle.g.Inline.diff
View file

@ -5,11 +5,11 @@
let mut _0: (); // return place in scope 0 at $DIR/cycle.rs:11:8: 11:8 let mut _0: (); // return place in scope 0 at $DIR/cycle.rs:11:8: 11:8
let _1: (); // in scope 0 at $DIR/cycle.rs:12:5: 12:12 let _1: (); // in scope 0 at $DIR/cycle.rs:12:5: 12:12
+ let mut _2: fn() {main}; // in scope 0 at $DIR/cycle.rs:12:5: 12:12 + let mut _2: fn() {main}; // in scope 0 at $DIR/cycle.rs:12:5: 12:12
+ let mut _5: (); // in scope 0 at $DIR/cycle.rs:6:5: 6:8
+ scope 1 (inlined f::<fn() {main}>) { // at $DIR/cycle.rs:12:5: 12:12 + scope 1 (inlined f::<fn() {main}>) { // at $DIR/cycle.rs:12:5: 12:12
+ debug g => _2; // in scope 1 at $DIR/cycle.rs:5:6: 5:7 + debug g => _2; // in scope 1 at $DIR/cycle.rs:5:6: 5:7
+ let _3: (); // in scope 1 at $DIR/cycle.rs:6:5: 6:8 + let _3: (); // in scope 1 at $DIR/cycle.rs:6:5: 6:8
+ let mut _4: &fn() {main}; // in scope 1 at $DIR/cycle.rs:6:5: 6:6 + let mut _4: &fn() {main}; // in scope 1 at $DIR/cycle.rs:6:5: 6:6
+ let mut _5: (); // in scope 1 at $DIR/cycle.rs:6:5: 6:8
+ scope 2 (inlined <fn() {main} as Fn<()>>::call - shim(fn() {main})) { // at $DIR/cycle.rs:6:5: 6:8 + scope 2 (inlined <fn() {main} as Fn<()>>::call - shim(fn() {main})) { // at $DIR/cycle.rs:6:5: 6:8
+ } + }
+ } + }
@ -21,15 +21,14 @@
+ _2 = main; // scope 0 at $DIR/cycle.rs:12:5: 12:12 + _2 = main; // scope 0 at $DIR/cycle.rs:12:5: 12:12
// mir::Constant // mir::Constant
- // + span: $DIR/cycle.rs:12:5: 12:6 - // + span: $DIR/cycle.rs:12:5: 12:6
- // + literal: Const { ty: fn(fn() {main}) {f::<fn() {main}>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn(fn() {main}) {f::<fn() {main}>}, val: Value(<ZST>) }
- // mir::Constant - // mir::Constant
// + span: $DIR/cycle.rs:12:7: 12:11 // + span: $DIR/cycle.rs:12:7: 12:11
// + literal: Const { ty: fn() {main}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {main}, val: Value(<ZST>) }
+ StorageLive(_3); // scope 1 at $DIR/cycle.rs:6:5: 6:8 + StorageLive(_3); // scope 1 at $DIR/cycle.rs:6:5: 6:8
+ StorageLive(_4); // scope 1 at $DIR/cycle.rs:6:5: 6:6 + StorageLive(_4); // scope 1 at $DIR/cycle.rs:6:5: 6:6
+ _4 = &_2; // scope 1 at $DIR/cycle.rs:6:5: 6:6 + _4 = &_2; // scope 1 at $DIR/cycle.rs:6:5: 6:6
+ StorageLive(_5); // scope 1 at $DIR/cycle.rs:6:5: 6:8 + StorageLive(_5); // scope 1 at $DIR/cycle.rs:6:5: 6:8
+ _5 = const (); // scope 1 at $DIR/cycle.rs:6:5: 6:8
+ _3 = move (*_4)() -> [return: bb4, unwind: bb2]; // scope 2 at $SRC_DIR/core/src/ops/function.rs:LL:COL + _3 = move (*_4)() -> [return: bb4, unwind: bb2]; // scope 2 at $SRC_DIR/core/src/ops/function.rs:LL:COL
} }
@ -49,7 +48,7 @@
+ } + }
+ +
+ bb4: { + bb4: {
+ StorageDead(_5); // scope 1 at $DIR/cycle.rs:6:5: 6:8 + StorageDead(_5); // scope 1 at $DIR/cycle.rs:6:7: 6:8
+ StorageDead(_4); // scope 1 at $DIR/cycle.rs:6:7: 6:8 + StorageDead(_4); // scope 1 at $DIR/cycle.rs:6:7: 6:8
+ StorageDead(_3); // scope 1 at $DIR/cycle.rs:6:8: 6:9 + StorageDead(_3); // scope 1 at $DIR/cycle.rs:6:8: 6:9
+ drop(_2) -> bb1; // scope 1 at $DIR/cycle.rs:7:1: 7:2 + drop(_2) -> bb1; // scope 1 at $DIR/cycle.rs:7:1: 7:2

9
src/test/mir-opt/inline/cycle.main.Inline.diff
View file

@ -5,11 +5,11 @@
let mut _0: (); // return place in scope 0 at $DIR/cycle.rs:16:11: 16:11 let mut _0: (); // return place in scope 0 at $DIR/cycle.rs:16:11: 16:11
let _1: (); // in scope 0 at $DIR/cycle.rs:17:5: 17:9 let _1: (); // in scope 0 at $DIR/cycle.rs:17:5: 17:9
+ let mut _2: fn() {g}; // in scope 0 at $DIR/cycle.rs:17:5: 17:9 + let mut _2: fn() {g}; // in scope 0 at $DIR/cycle.rs:17:5: 17:9
+ let mut _5: (); // in scope 0 at $DIR/cycle.rs:6:5: 6:8
+ scope 1 (inlined f::<fn() {g}>) { // at $DIR/cycle.rs:17:5: 17:9 + scope 1 (inlined f::<fn() {g}>) { // at $DIR/cycle.rs:17:5: 17:9
+ debug g => _2; // in scope 1 at $DIR/cycle.rs:5:6: 5:7 + debug g => _2; // in scope 1 at $DIR/cycle.rs:5:6: 5:7
+ let _3: (); // in scope 1 at $DIR/cycle.rs:6:5: 6:8 + let _3: (); // in scope 1 at $DIR/cycle.rs:6:5: 6:8
+ let mut _4: &fn() {g}; // in scope 1 at $DIR/cycle.rs:6:5: 6:6 + let mut _4: &fn() {g}; // in scope 1 at $DIR/cycle.rs:6:5: 6:6
+ let mut _5: (); // in scope 1 at $DIR/cycle.rs:6:5: 6:8
+ scope 2 (inlined <fn() {g} as Fn<()>>::call - shim(fn() {g})) { // at $DIR/cycle.rs:6:5: 6:8 + scope 2 (inlined <fn() {g} as Fn<()>>::call - shim(fn() {g})) { // at $DIR/cycle.rs:6:5: 6:8
+ scope 3 (inlined g) { // at $SRC_DIR/core/src/ops/function.rs:LL:COL + scope 3 (inlined g) { // at $SRC_DIR/core/src/ops/function.rs:LL:COL
+ let mut _6: fn() {main}; // in scope 3 at $DIR/cycle.rs:12:5: 12:12 + let mut _6: fn() {main}; // in scope 3 at $DIR/cycle.rs:12:5: 12:12
@ -31,15 +31,14 @@
+ _2 = g; // scope 0 at $DIR/cycle.rs:17:5: 17:9 + _2 = g; // scope 0 at $DIR/cycle.rs:17:5: 17:9
// mir::Constant // mir::Constant
- // + span: $DIR/cycle.rs:17:5: 17:6 - // + span: $DIR/cycle.rs:17:5: 17:6
- // + literal: Const { ty: fn(fn() {g}) {f::<fn() {g}>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn(fn() {g}) {f::<fn() {g}>}, val: Value(<ZST>) }
- // mir::Constant - // mir::Constant
// + span: $DIR/cycle.rs:17:7: 17:8 // + span: $DIR/cycle.rs:17:7: 17:8
// + literal: Const { ty: fn() {g}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {g}, val: Value(<ZST>) }
+ StorageLive(_3); // scope 1 at $DIR/cycle.rs:6:5: 6:8 + StorageLive(_3); // scope 1 at $DIR/cycle.rs:6:5: 6:8
+ StorageLive(_4); // scope 1 at $DIR/cycle.rs:6:5: 6:6 + StorageLive(_4); // scope 1 at $DIR/cycle.rs:6:5: 6:6
+ _4 = &_2; // scope 1 at $DIR/cycle.rs:6:5: 6:6 + _4 = &_2; // scope 1 at $DIR/cycle.rs:6:5: 6:6
+ StorageLive(_5); // scope 1 at $DIR/cycle.rs:6:5: 6:8 + StorageLive(_5); // scope 1 at $DIR/cycle.rs:6:5: 6:8
+ _5 = const (); // scope 1 at $DIR/cycle.rs:6:5: 6:8
+ StorageLive(_6); // scope 3 at $DIR/cycle.rs:12:5: 12:12 + StorageLive(_6); // scope 3 at $DIR/cycle.rs:12:5: 12:12
+ StorageLive(_7); // scope 4 at $DIR/cycle.rs:6:5: 6:8 + StorageLive(_7); // scope 4 at $DIR/cycle.rs:6:5: 6:8
+ StorageLive(_8); // scope 4 at $DIR/cycle.rs:6:5: 6:6 + StorageLive(_8); // scope 4 at $DIR/cycle.rs:6:5: 6:6
@ -66,7 +65,7 @@
+ StorageDead(_8); // scope 4 at $DIR/cycle.rs:6:7: 6:8 + StorageDead(_8); // scope 4 at $DIR/cycle.rs:6:7: 6:8
+ StorageDead(_7); // scope 4 at $DIR/cycle.rs:6:8: 6:9 + StorageDead(_7); // scope 4 at $DIR/cycle.rs:6:8: 6:9
+ StorageDead(_6); // scope 3 at $DIR/cycle.rs:12:5: 12:12 + StorageDead(_6); // scope 3 at $DIR/cycle.rs:12:5: 12:12
+ StorageDead(_5); // scope 1 at $DIR/cycle.rs:6:5: 6:8 + StorageDead(_5); // scope 1 at $DIR/cycle.rs:6:7: 6:8
+ StorageDead(_4); // scope 1 at $DIR/cycle.rs:6:7: 6:8 + StorageDead(_4); // scope 1 at $DIR/cycle.rs:6:7: 6:8
+ StorageDead(_3); // scope 1 at $DIR/cycle.rs:6:8: 6:9 + StorageDead(_3); // scope 1 at $DIR/cycle.rs:6:8: 6:9
+ drop(_2) -> bb1; // scope 1 at $DIR/cycle.rs:7:1: 7:2 + drop(_2) -> bb1; // scope 1 at $DIR/cycle.rs:7:1: 7:2

6
src/test/mir-opt/inline/dyn_trait.get_query.Inline.diff
View file

@ -28,7 +28,7 @@
// mir::Constant // mir::Constant
// + span: $DIR/dyn-trait.rs:33:13: 33:21 // + span: $DIR/dyn-trait.rs:33:13: 33:21
// + user_ty: UserType(0) // + user_ty: UserType(0)
// + literal: Const { ty: for<'r> fn(&'r T) -> &'r <Q as Query>::C {<Q as Query>::cache::<T>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r T) -> &'r <Q as Query>::C {<Q as Query>::cache::<T>}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -46,9 +46,9 @@
+ _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(move _7) -> bb2; // scope 3 at $DIR/dyn-trait.rs:21:5: 21:22 + _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(move _7) -> bb2; // scope 3 at $DIR/dyn-trait.rs:21:5: 21:22
// mir::Constant // mir::Constant
- // + span: $DIR/dyn-trait.rs:34:5: 34:22 - // + span: $DIR/dyn-trait.rs:34:5: 34:22
- // + literal: Const { ty: for<'r> fn(&'r <Q as Query>::C) {try_execute_query::<<Q as Query>::C>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> fn(&'r <Q as Query>::C) {try_execute_query::<<Q as Query>::C>}, val: Value(<ZST>) }
+ // + span: $DIR/dyn-trait.rs:21:7: 21:20 + // + span: $DIR/dyn-trait.rs:21:7: 21:20
+ // + literal: Const { ty: for<'r> fn(&'r dyn Cache<V = <Q as Query>::V>) {<dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache}, val: Value(Scalar(<ZST>)) } + // + literal: Const { ty: for<'r> fn(&'r dyn Cache<V = <Q as Query>::V>) {<dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache}, val: Value(<ZST>) }
} }
bb2: { bb2: {

2
src/test/mir-opt/inline/dyn_trait.mk_cycle.Inline.diff
View file

@ -12,7 +12,7 @@
_0 = <dyn Cache<V = V> as Cache>::store_nocache(move _2) -> bb1; // scope 0 at $DIR/dyn-trait.rs:21:5: 21:22 _0 = <dyn Cache<V = V> as Cache>::store_nocache(move _2) -> bb1; // scope 0 at $DIR/dyn-trait.rs:21:5: 21:22
// mir::Constant // mir::Constant
// + span: $DIR/dyn-trait.rs:21:7: 21:20 // + span: $DIR/dyn-trait.rs:21:7: 21:20
// + literal: Const { ty: for<'r> fn(&'r dyn Cache<V = V>) {<dyn Cache<V = V> as Cache>::store_nocache}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r dyn Cache<V = V>) {<dyn Cache<V = V> as Cache>::store_nocache}, val: Value(<ZST>) }
} }
bb1: { bb1: {

4
src/test/mir-opt/inline/dyn_trait.try_execute_query.Inline.diff
View file

@ -23,9 +23,9 @@
+ _0 = <dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache(move _4) -> bb1; // scope 1 at $DIR/dyn-trait.rs:21:5: 21:22 + _0 = <dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache(move _4) -> bb1; // scope 1 at $DIR/dyn-trait.rs:21:5: 21:22
// mir::Constant // mir::Constant
- // + span: $DIR/dyn-trait.rs:27:5: 27:13 - // + span: $DIR/dyn-trait.rs:27:5: 27:13
- // + literal: Const { ty: for<'r> fn(&'r (dyn Cache<V = <C as Cache>::V> + 'r)) {mk_cycle::<<C as Cache>::V>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> fn(&'r (dyn Cache<V = <C as Cache>::V> + 'r)) {mk_cycle::<<C as Cache>::V>}, val: Value(<ZST>) }
+ // + span: $DIR/dyn-trait.rs:21:7: 21:20 + // + span: $DIR/dyn-trait.rs:21:7: 21:20
+ // + literal: Const { ty: for<'r> fn(&'r dyn Cache<V = <C as Cache>::V>) {<dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache}, val: Value(Scalar(<ZST>)) } + // + literal: Const { ty: for<'r> fn(&'r dyn Cache<V = <C as Cache>::V>) {<dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/inline/inline_any_operand.bar.Inline.after.mir
View file

@ -21,7 +21,7 @@ fn bar() -> bool {
_1 = foo; // scope 0 at $DIR/inline-any-operand.rs:11:13: 11:16 _1 = foo; // scope 0 at $DIR/inline-any-operand.rs:11:13: 11:16
// mir::Constant // mir::Constant
// + span: $DIR/inline-any-operand.rs:11:13: 11:16 // + span: $DIR/inline-any-operand.rs:11:13: 11:16
// + literal: Const { ty: fn(i32, i32) -> bool {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(i32, i32) -> bool {foo}, val: Value(<ZST>) }
StorageLive(_2); // scope 1 at $DIR/inline-any-operand.rs:12:5: 12:6 StorageLive(_2); // scope 1 at $DIR/inline-any-operand.rs:12:5: 12:6
_2 = _1; // scope 1 at $DIR/inline-any-operand.rs:12:5: 12:6 _2 = _1; // scope 1 at $DIR/inline-any-operand.rs:12:5: 12:6
StorageLive(_3); // scope 1 at $DIR/inline-any-operand.rs:12:5: 12:13 StorageLive(_3); // scope 1 at $DIR/inline-any-operand.rs:12:5: 12:13

2
src/test/mir-opt/inline/inline_compatibility.inlined_no_sanitize.Inline.diff
View file

@ -12,7 +12,7 @@
- _1 = no_sanitize() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:24:5: 24:18 - _1 = no_sanitize() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:24:5: 24:18
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-compatibility.rs:24:5: 24:16 - // + span: $DIR/inline-compatibility.rs:24:5: 24:16
- // + literal: Const { ty: unsafe fn() {no_sanitize}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: unsafe fn() {no_sanitize}, val: Value(<ZST>) }
- } - }
- -
- bb1: { - bb1: {

2
src/test/mir-opt/inline/inline_compatibility.inlined_target_feature.Inline.diff
View file

@ -12,7 +12,7 @@
- _1 = target_feature() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:13:5: 13:21 - _1 = target_feature() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:13:5: 13:21
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-compatibility.rs:13:5: 13:19 - // + span: $DIR/inline-compatibility.rs:13:5: 13:19
- // + literal: Const { ty: unsafe fn() {target_feature}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: unsafe fn() {target_feature}, val: Value(<ZST>) }
- } - }
- -
- bb1: { - bb1: {

2
src/test/mir-opt/inline/inline_compatibility.not_inlined_c_variadic.Inline.diff
View file

@ -13,7 +13,7 @@
_1 = sum(const 4_u32, const 4_u32, const 30_u32, const 200_u32, const 1000_u32) -> bb1; // scope 0 at $DIR/inline-compatibility.rs:42:13: 42:52 _1 = sum(const 4_u32, const 4_u32, const 30_u32, const 200_u32, const 1000_u32) -> bb1; // scope 0 at $DIR/inline-compatibility.rs:42:13: 42:52
// mir::Constant // mir::Constant
// + span: $DIR/inline-compatibility.rs:42:13: 42:16 // + span: $DIR/inline-compatibility.rs:42:13: 42:16
// + literal: Const { ty: unsafe extern "C" fn(u32, ...) -> u32 {sum}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe extern "C" fn(u32, ...) -> u32 {sum}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/inline/inline_compatibility.not_inlined_no_sanitize.Inline.diff
View file

@ -10,7 +10,7 @@
_1 = no_sanitize() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:29:5: 29:18 _1 = no_sanitize() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:29:5: 29:18
// mir::Constant // mir::Constant
// + span: $DIR/inline-compatibility.rs:29:5: 29:16 // + span: $DIR/inline-compatibility.rs:29:5: 29:16
// + literal: Const { ty: unsafe fn() {no_sanitize}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn() {no_sanitize}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/inline/inline_compatibility.not_inlined_target_feature.Inline.diff
View file

@ -10,7 +10,7 @@
_1 = target_feature() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:18:5: 18:21 _1 = target_feature() -> bb1; // scope 0 at $DIR/inline-compatibility.rs:18:5: 18:21
// mir::Constant // mir::Constant
// + span: $DIR/inline-compatibility.rs:18:5: 18:19 // + span: $DIR/inline-compatibility.rs:18:5: 18:19
// + literal: Const { ty: unsafe fn() {target_feature}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn() {target_feature}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/inline/inline_cycle.one.Inline.diff
View file

@ -18,7 +18,7 @@
// mir::Constant // mir::Constant
- // + span: $DIR/inline-cycle.rs:14:5: 14:22 - // + span: $DIR/inline-cycle.rs:14:5: 14:22
+ // + span: $DIR/inline-cycle.rs:36:9: 36:26 + // + span: $DIR/inline-cycle.rs:36:9: 36:26
// + literal: Const { ty: fn() {<C as Call>::call}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {<C as Call>::call}, val: Value(<ZST>) }
} }
bb1: { bb1: {

11
src/test/mir-opt/inline/inline_cycle.two.Inline.diff
View file

@ -5,11 +5,11 @@
let mut _0: (); // return place in scope 0 at $DIR/inline-cycle.rs:48:10: 48:10 let mut _0: (); // return place in scope 0 at $DIR/inline-cycle.rs:48:10: 48:10
let _1: (); // in scope 0 at $DIR/inline-cycle.rs:49:5: 49:12 let _1: (); // in scope 0 at $DIR/inline-cycle.rs:49:5: 49:12
+ let mut _2: fn() {f}; // in scope 0 at $DIR/inline-cycle.rs:49:5: 49:12 + let mut _2: fn() {f}; // in scope 0 at $DIR/inline-cycle.rs:49:5: 49:12
+ let mut _5: (); // in scope 0 at $DIR/inline-cycle.rs:54:5: 54:8
+ scope 1 (inlined call::<fn() {f}>) { // at $DIR/inline-cycle.rs:49:5: 49:12 + scope 1 (inlined call::<fn() {f}>) { // at $DIR/inline-cycle.rs:49:5: 49:12
+ debug f => _2; // in scope 1 at $DIR/inline-cycle.rs:53:22: 53:23 + debug f => _2; // in scope 1 at $DIR/inline-cycle.rs:53:22: 53:23
+ let _3: (); // in scope 1 at $DIR/inline-cycle.rs:54:5: 54:8 + let _3: (); // in scope 1 at $DIR/inline-cycle.rs:54:5: 54:8
+ let mut _4: fn() {f}; // in scope 1 at $DIR/inline-cycle.rs:54:5: 54:6 + let mut _4: fn() {f}; // in scope 1 at $DIR/inline-cycle.rs:54:5: 54:6
+ let mut _5: (); // in scope 1 at $DIR/inline-cycle.rs:54:5: 54:8
+ scope 2 (inlined <fn() {f} as FnOnce<()>>::call_once - shim(fn() {f})) { // at $DIR/inline-cycle.rs:54:5: 54:8 + scope 2 (inlined <fn() {f} as FnOnce<()>>::call_once - shim(fn() {f})) { // at $DIR/inline-cycle.rs:54:5: 54:8
+ scope 3 (inlined f) { // at $SRC_DIR/core/src/ops/function.rs:LL:COL + scope 3 (inlined f) { // at $SRC_DIR/core/src/ops/function.rs:LL:COL
+ let _6: (); // in scope 3 at $DIR/inline-cycle.rs:59:5: 59:12 + let _6: (); // in scope 3 at $DIR/inline-cycle.rs:59:5: 59:12
@ -25,26 +25,25 @@
// mir::Constant // mir::Constant
- // + span: $DIR/inline-cycle.rs:49:5: 49:9 - // + span: $DIR/inline-cycle.rs:49:5: 49:9
+ // + span: $DIR/inline-cycle.rs:49:10: 49:11 + // + span: $DIR/inline-cycle.rs:49:10: 49:11
+ // + literal: Const { ty: fn() {f}, val: Value(Scalar(<ZST>)) } + // + literal: Const { ty: fn() {f}, val: Value(<ZST>) }
+ StorageLive(_3); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:8 + StorageLive(_3); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:8
+ StorageLive(_4); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:6 + StorageLive(_4); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:6
+ _4 = move _2; // scope 1 at $DIR/inline-cycle.rs:54:5: 54:6 + _4 = move _2; // scope 1 at $DIR/inline-cycle.rs:54:5: 54:6
+ StorageLive(_5); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:8 + StorageLive(_5); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:8
+ _5 = const (); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:8
+ StorageLive(_6); // scope 3 at $DIR/inline-cycle.rs:59:5: 59:12 + StorageLive(_6); // scope 3 at $DIR/inline-cycle.rs:59:5: 59:12
+ _6 = call::<fn() {f}>(f) -> bb1; // scope 3 at $DIR/inline-cycle.rs:59:5: 59:12 + _6 = call::<fn() {f}>(f) -> bb1; // scope 3 at $DIR/inline-cycle.rs:59:5: 59:12
+ // mir::Constant + // mir::Constant
+ // + span: $DIR/inline-cycle.rs:59:5: 59:9 + // + span: $DIR/inline-cycle.rs:59:5: 59:9
// + literal: Const { ty: fn(fn() {f}) {call::<fn() {f}>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(fn() {f}) {call::<fn() {f}>}, val: Value(<ZST>) }
// mir::Constant // mir::Constant
- // + span: $DIR/inline-cycle.rs:49:10: 49:11 - // + span: $DIR/inline-cycle.rs:49:10: 49:11
+ // + span: $DIR/inline-cycle.rs:59:10: 59:11 + // + span: $DIR/inline-cycle.rs:59:10: 59:11
// + literal: Const { ty: fn() {f}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {f}, val: Value(<ZST>) }
} }
bb1: { bb1: {
+ StorageDead(_6); // scope 3 at $DIR/inline-cycle.rs:59:12: 59:13 + StorageDead(_6); // scope 3 at $DIR/inline-cycle.rs:59:12: 59:13
+ StorageDead(_5); // scope 1 at $DIR/inline-cycle.rs:54:5: 54:8 + StorageDead(_5); // scope 1 at $DIR/inline-cycle.rs:54:7: 54:8
+ StorageDead(_4); // scope 1 at $DIR/inline-cycle.rs:54:7: 54:8 + StorageDead(_4); // scope 1 at $DIR/inline-cycle.rs:54:7: 54:8
+ StorageDead(_3); // scope 1 at $DIR/inline-cycle.rs:54:8: 54:9 + StorageDead(_3); // scope 1 at $DIR/inline-cycle.rs:54:8: 54:9
+ StorageDead(_2); // scope 0 at $DIR/inline-cycle.rs:49:5: 49:12 + StorageDead(_2); // scope 0 at $DIR/inline-cycle.rs:49:5: 49:12

2
src/test/mir-opt/inline/inline_cycle_generic.main.Inline.diff
View file

@ -20,7 +20,7 @@
// mir::Constant // mir::Constant
- // + span: $DIR/inline-cycle-generic.rs:9:5: 9:22 - // + span: $DIR/inline-cycle-generic.rs:9:5: 9:22
+ // + span: $DIR/inline-cycle-generic.rs:31:9: 31:26 + // + span: $DIR/inline-cycle-generic.rs:31:9: 31:26
// + literal: Const { ty: fn() {<C as Call>::call}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {<C as Call>::call}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/inline/inline_diverging.f.Inline.diff
View file

@ -13,7 +13,7 @@
- _2 = sleep(); // scope 0 at $DIR/inline-diverging.rs:8:5: 8:12 - _2 = sleep(); // scope 0 at $DIR/inline-diverging.rs:8:5: 8:12
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-diverging.rs:8:5: 8:10 - // + span: $DIR/inline-diverging.rs:8:5: 8:10
- // + literal: Const { ty: fn() -> ! {sleep}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() -> ! {sleep}, val: Value(<ZST>) }
+ goto -> bb1; // scope 0 at $DIR/inline-diverging.rs:8:5: 8:12 + goto -> bb1; // scope 0 at $DIR/inline-diverging.rs:8:5: 8:12
+ } + }
+ +

4
src/test/mir-opt/inline/inline_diverging.g.Inline.diff
View file

@ -38,9 +38,9 @@
+ _7 = begin_panic::<&str>(const "explicit panic"); // scope 1 at $SRC_DIR/std/src/panic.rs:LL:COL + _7 = begin_panic::<&str>(const "explicit panic"); // scope 1 at $SRC_DIR/std/src/panic.rs:LL:COL
// mir::Constant // mir::Constant
- // + span: $DIR/inline-diverging.rs:16:9: 16:14 - // + span: $DIR/inline-diverging.rs:16:9: 16:14
- // + literal: Const { ty: fn() -> ! {panic}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() -> ! {panic}, val: Value(<ZST>) }
+ // + span: $SRC_DIR/std/src/panic.rs:LL:COL + // + span: $SRC_DIR/std/src/panic.rs:LL:COL
+ // + literal: Const { ty: fn(&str) -> ! {begin_panic::<&str>}, val: Value(Scalar(<ZST>)) } + // + literal: Const { ty: fn(&str) -> ! {begin_panic::<&str>}, val: Value(<ZST>) }
+ // mir::Constant + // mir::Constant
+ // + span: $SRC_DIR/std/src/panic.rs:LL:COL + // + span: $SRC_DIR/std/src/panic.rs:LL:COL
+ // + literal: Const { ty: &str, val: Value(Slice(..)) } + // + literal: Const { ty: &str, val: Value(Slice(..)) }

21
src/test/mir-opt/inline/inline_diverging.h.Inline.diff
View file

@ -5,20 +5,20 @@
let mut _0: (); // return place in scope 0 at $DIR/inline-diverging.rs:21:12: 21:12 let mut _0: (); // return place in scope 0 at $DIR/inline-diverging.rs:21:12: 21:12
let _1: (!, !); // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 let _1: (!, !); // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22
+ let mut _2: fn() -> ! {sleep}; // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 + let mut _2: fn() -> ! {sleep}; // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22
+ let mut _9: (); // in scope 0 at $DIR/inline-diverging.rs:27:13: 27:16
+ let mut _10: (); // in scope 0 at $DIR/inline-diverging.rs:28:13: 28:16
+ scope 1 (inlined call_twice::<!, fn() -> ! {sleep}>) { // at $DIR/inline-diverging.rs:22:5: 22:22 + scope 1 (inlined call_twice::<!, fn() -> ! {sleep}>) { // at $DIR/inline-diverging.rs:22:5: 22:22
+ debug f => _2; // in scope 1 at $DIR/inline-diverging.rs:26:36: 26:37 + debug f => _2; // in scope 1 at $DIR/inline-diverging.rs:26:36: 26:37
+ let _3: !; // in scope 1 at $DIR/inline-diverging.rs:27:9: 27:10 + let _3: !; // in scope 1 at $DIR/inline-diverging.rs:27:9: 27:10
+ let mut _4: &fn() -> ! {sleep}; // in scope 1 at $DIR/inline-diverging.rs:27:13: 27:14 + let mut _4: &fn() -> ! {sleep}; // in scope 1 at $DIR/inline-diverging.rs:27:13: 27:14
+ let mut _6: &fn() -> ! {sleep}; // in scope 1 at $DIR/inline-diverging.rs:28:13: 28:14 + let mut _5: (); // in scope 1 at $DIR/inline-diverging.rs:27:13: 27:16
+ let mut _7: !; // in scope 1 at $DIR/inline-diverging.rs:29:6: 29:7 + let mut _7: &fn() -> ! {sleep}; // in scope 1 at $DIR/inline-diverging.rs:28:13: 28:14
+ let mut _8: !; // in scope 1 at $DIR/inline-diverging.rs:29:9: 29:10 + let mut _8: (); // in scope 1 at $DIR/inline-diverging.rs:28:13: 28:16
+ let mut _9: !; // in scope 1 at $DIR/inline-diverging.rs:29:6: 29:7
+ let mut _10: !; // in scope 1 at $DIR/inline-diverging.rs:29:9: 29:10
+ scope 2 { + scope 2 {
+ debug a => _3; // in scope 2 at $DIR/inline-diverging.rs:27:9: 27:10 + debug a => _3; // in scope 2 at $DIR/inline-diverging.rs:27:9: 27:10
+ let _5: !; // in scope 2 at $DIR/inline-diverging.rs:28:9: 28:10 + let _6: !; // in scope 2 at $DIR/inline-diverging.rs:28:9: 28:10
+ scope 3 { + scope 3 {
+ debug b => _5; // in scope 3 at $DIR/inline-diverging.rs:28:9: 28:10 + debug b => _6; // in scope 3 at $DIR/inline-diverging.rs:28:9: 28:10
+ } + }
+ scope 6 (inlined <fn() -> ! {sleep} as Fn<()>>::call - shim(fn() -> ! {sleep})) { // at $DIR/inline-diverging.rs:28:13: 28:16 + scope 6 (inlined <fn() -> ! {sleep} as Fn<()>>::call - shim(fn() -> ! {sleep})) { // at $DIR/inline-diverging.rs:28:13: 28:16
+ scope 7 (inlined sleep) { // at $SRC_DIR/core/src/ops/function.rs:LL:COL + scope 7 (inlined sleep) { // at $SRC_DIR/core/src/ops/function.rs:LL:COL
@ -38,15 +38,14 @@
+ _2 = sleep; // scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 + _2 = sleep; // scope 0 at $DIR/inline-diverging.rs:22:5: 22:22
// mir::Constant // mir::Constant
- // + span: $DIR/inline-diverging.rs:22:5: 22:15 - // + span: $DIR/inline-diverging.rs:22:5: 22:15
- // + literal: Const { ty: fn(fn() -> ! {sleep}) -> (!, !) {call_twice::<!, fn() -> ! {sleep}>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn(fn() -> ! {sleep}) -> (!, !) {call_twice::<!, fn() -> ! {sleep}>}, val: Value(<ZST>) }
- // mir::Constant - // mir::Constant
// + span: $DIR/inline-diverging.rs:22:16: 22:21 // + span: $DIR/inline-diverging.rs:22:16: 22:21
// + literal: Const { ty: fn() -> ! {sleep}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> ! {sleep}, val: Value(<ZST>) }
+ StorageLive(_3); // scope 1 at $DIR/inline-diverging.rs:27:9: 27:10 + StorageLive(_3); // scope 1 at $DIR/inline-diverging.rs:27:9: 27:10
+ StorageLive(_4); // scope 1 at $DIR/inline-diverging.rs:27:13: 27:14 + StorageLive(_4); // scope 1 at $DIR/inline-diverging.rs:27:13: 27:14
+ _4 = &_2; // scope 1 at $DIR/inline-diverging.rs:27:13: 27:14 + _4 = &_2; // scope 1 at $DIR/inline-diverging.rs:27:13: 27:14
+ StorageLive(_9); // scope 1 at $DIR/inline-diverging.rs:27:13: 27:16 + StorageLive(_5); // scope 1 at $DIR/inline-diverging.rs:27:13: 27:16
+ _9 = const (); // scope 1 at $DIR/inline-diverging.rs:27:13: 27:16
+ goto -> bb1; // scope 5 at $DIR/inline-diverging.rs:39:5: 39:12 + goto -> bb1; // scope 5 at $DIR/inline-diverging.rs:39:5: 39:12
+ } + }
+ +

6
src/test/mir-opt/inline/inline_generator.main.Inline.diff
View file

@ -43,7 +43,7 @@
- _4 = g() -> bb1; // scope 0 at $DIR/inline-generator.rs:9:28: 9:31 - _4 = g() -> bb1; // scope 0 at $DIR/inline-generator.rs:9:28: 9:31
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-generator.rs:9:28: 9:29 - // + span: $DIR/inline-generator.rs:9:28: 9:29
- // + literal: Const { ty: fn() -> impl Generator<bool> {g}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() -> impl Generator<bool> {g}, val: Value(<ZST>) }
- } - }
- -
- bb1: { - bb1: {
@ -54,7 +54,7 @@
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-generator.rs:9:14: 9:22 - // + span: $DIR/inline-generator.rs:9:14: 9:22
- // + user_ty: UserType(0) - // + user_ty: UserType(0)
- // + literal: Const { ty: fn(&mut [generator@$DIR/inline-generator.rs:15:5: 15:8]) -> Pin<&mut [generator@$DIR/inline-generator.rs:15:5: 15:8]> {Pin::<&mut [generator@$DIR/inline-generator.rs:15:5: 15:8]>::new}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn(&mut [generator@$DIR/inline-generator.rs:15:5: 15:8]) -> Pin<&mut [generator@$DIR/inline-generator.rs:15:5: 15:8]> {Pin::<&mut [generator@$DIR/inline-generator.rs:15:5: 15:8]>::new}, val: Value(<ZST>) }
- } - }
- -
- bb2: { - bb2: {
@ -70,7 +70,7 @@
- _1 = <[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::resume(move _2, const false) -> [return: bb3, unwind: bb4]; // scope 0 at $DIR/inline-generator.rs:9:14: 9:46 - _1 = <[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::resume(move _2, const false) -> [return: bb3, unwind: bb4]; // scope 0 at $DIR/inline-generator.rs:9:14: 9:46
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-generator.rs:9:33: 9:39 - // + span: $DIR/inline-generator.rs:9:33: 9:39
- // + literal: Const { ty: for<'r> fn(Pin<&'r mut [generator@$DIR/inline-generator.rs:15:5: 15:8]>, bool) -> GeneratorState<<[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::Yield, <[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::Return> {<[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::resume}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> fn(Pin<&'r mut [generator@$DIR/inline-generator.rs:15:5: 15:8]>, bool) -> GeneratorState<<[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::Yield, <[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::Return> {<[generator@$DIR/inline-generator.rs:15:5: 15:8] as Generator<bool>>::resume}, val: Value(<ZST>) }
+ StorageLive(_7); // scope 0 at $DIR/inline-generator.rs:9:14: 9:46 + StorageLive(_7); // scope 0 at $DIR/inline-generator.rs:9:14: 9:46
+ _7 = const false; // scope 0 at $DIR/inline-generator.rs:9:14: 9:46 + _7 = const false; // scope 0 at $DIR/inline-generator.rs:9:14: 9:46
+ StorageLive(_10); // scope 0 at $DIR/inline-generator.rs:9:14: 9:46 + StorageLive(_10); // scope 0 at $DIR/inline-generator.rs:9:14: 9:46

6
src/test/mir-opt/inline/inline_instruction_set.default.Inline.diff
View file

@ -14,7 +14,7 @@
_1 = instruction_set_a32() -> bb1; // scope 0 at $DIR/inline-instruction-set.rs:51:5: 51:26 _1 = instruction_set_a32() -> bb1; // scope 0 at $DIR/inline-instruction-set.rs:51:5: 51:26
// mir::Constant // mir::Constant
// + span: $DIR/inline-instruction-set.rs:51:5: 51:24 // + span: $DIR/inline-instruction-set.rs:51:5: 51:24
// + literal: Const { ty: fn() {instruction_set_a32}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {instruction_set_a32}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -23,7 +23,7 @@
_2 = instruction_set_t32() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:52:5: 52:26 _2 = instruction_set_t32() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:52:5: 52:26
// mir::Constant // mir::Constant
// + span: $DIR/inline-instruction-set.rs:52:5: 52:24 // + span: $DIR/inline-instruction-set.rs:52:5: 52:24
// + literal: Const { ty: fn() {instruction_set_t32}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {instruction_set_t32}, val: Value(<ZST>) }
} }
bb2: { bb2: {
@ -32,7 +32,7 @@
- _3 = instruction_set_default() -> bb3; // scope 0 at $DIR/inline-instruction-set.rs:53:5: 53:30 - _3 = instruction_set_default() -> bb3; // scope 0 at $DIR/inline-instruction-set.rs:53:5: 53:30
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-instruction-set.rs:53:5: 53:28 - // + span: $DIR/inline-instruction-set.rs:53:5: 53:28
- // + literal: Const { ty: fn() {instruction_set_default}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() {instruction_set_default}, val: Value(<ZST>) }
- } - }
- -
- bb3: { - bb3: {

6
src/test/mir-opt/inline/inline_instruction_set.t32.Inline.diff
View file

@ -14,7 +14,7 @@
_1 = instruction_set_a32() -> bb1; // scope 0 at $DIR/inline-instruction-set.rs:42:5: 42:26 _1 = instruction_set_a32() -> bb1; // scope 0 at $DIR/inline-instruction-set.rs:42:5: 42:26
// mir::Constant // mir::Constant
// + span: $DIR/inline-instruction-set.rs:42:5: 42:24 // + span: $DIR/inline-instruction-set.rs:42:5: 42:24
// + literal: Const { ty: fn() {instruction_set_a32}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {instruction_set_a32}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -23,7 +23,7 @@
- _2 = instruction_set_t32() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:43:5: 43:26 - _2 = instruction_set_t32() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:43:5: 43:26
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-instruction-set.rs:43:5: 43:24 - // + span: $DIR/inline-instruction-set.rs:43:5: 43:24
- // + literal: Const { ty: fn() {instruction_set_t32}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() {instruction_set_t32}, val: Value(<ZST>) }
- } - }
- -
- bb2: { - bb2: {
@ -33,7 +33,7 @@
+ _3 = instruction_set_default() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:46:5: 46:30 + _3 = instruction_set_default() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:46:5: 46:30
// mir::Constant // mir::Constant
// + span: $DIR/inline-instruction-set.rs:46:5: 46:28 // + span: $DIR/inline-instruction-set.rs:46:5: 46:28
// + literal: Const { ty: fn() {instruction_set_default}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {instruction_set_default}, val: Value(<ZST>) }
} }
- bb3: { - bb3: {

6
src/test/mir-opt/inline/inline_into_box_place.main.Inline.32bit.diff
View file

@ -28,7 +28,7 @@
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/inline-into-box-place.rs:8:29: 8:43 _4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/inline-into-box-place.rs:8:29: 8:43
// mir::Constant // mir::Constant
// + span: $DIR/inline-into-box-place.rs:8:29: 8:43 // + span: $DIR/inline-into-box-place.rs:8:29: 8:43
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -44,7 +44,7 @@
// mir::Constant // mir::Constant
- // + span: $DIR/inline-into-box-place.rs:8:33: 8:41 - // + span: $DIR/inline-into-box-place.rs:8:33: 8:41
- // + user_ty: UserType(1) - // + user_ty: UserType(1)
- // + literal: Const { ty: fn() -> Vec<u32> {Vec::<u32>::new}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() -> Vec<u32> {Vec::<u32>::new}, val: Value(<ZST>) }
- } - }
- -
- bb2: { - bb2: {
@ -75,7 +75,7 @@
- _6 = alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>(move (_5.0: std::ptr::Unique<std::vec::Vec<u32>>), move (_5.1: std::alloc::Global)) -> bb5; // scope 0 at $DIR/inline-into-box-place.rs:8:42: 8:43 - _6 = alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>(move (_5.0: std::ptr::Unique<std::vec::Vec<u32>>), move (_5.1: std::alloc::Global)) -> bb5; // scope 0 at $DIR/inline-into-box-place.rs:8:42: 8:43
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-into-box-place.rs:8:42: 8:43 - // + span: $DIR/inline-into-box-place.rs:8:42: 8:43
- // + literal: Const { ty: unsafe fn(Unique<Vec<u32>>, std::alloc::Global) {alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: unsafe fn(Unique<Vec<u32>>, std::alloc::Global) {alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>}, val: Value(<ZST>) }
- } - }
- -
- bb5 (cleanup): { - bb5 (cleanup): {

6
src/test/mir-opt/inline/inline_into_box_place.main.Inline.64bit.diff
View file

@ -28,7 +28,7 @@
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/inline-into-box-place.rs:8:29: 8:43 _4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 2 at $DIR/inline-into-box-place.rs:8:29: 8:43
// mir::Constant // mir::Constant
// + span: $DIR/inline-into-box-place.rs:8:29: 8:43 // + span: $DIR/inline-into-box-place.rs:8:29: 8:43
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -44,7 +44,7 @@
// mir::Constant // mir::Constant
- // + span: $DIR/inline-into-box-place.rs:8:33: 8:41 - // + span: $DIR/inline-into-box-place.rs:8:33: 8:41
- // + user_ty: UserType(1) - // + user_ty: UserType(1)
- // + literal: Const { ty: fn() -> Vec<u32> {Vec::<u32>::new}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() -> Vec<u32> {Vec::<u32>::new}, val: Value(<ZST>) }
- } - }
- -
- bb2: { - bb2: {
@ -75,7 +75,7 @@
- _6 = alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>(move (_5.0: std::ptr::Unique<std::vec::Vec<u32>>), move (_5.1: std::alloc::Global)) -> bb5; // scope 0 at $DIR/inline-into-box-place.rs:8:42: 8:43 - _6 = alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>(move (_5.0: std::ptr::Unique<std::vec::Vec<u32>>), move (_5.1: std::alloc::Global)) -> bb5; // scope 0 at $DIR/inline-into-box-place.rs:8:42: 8:43
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-into-box-place.rs:8:42: 8:43 - // + span: $DIR/inline-into-box-place.rs:8:42: 8:43
- // + literal: Const { ty: unsafe fn(Unique<Vec<u32>>, std::alloc::Global) {alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: unsafe fn(Unique<Vec<u32>>, std::alloc::Global) {alloc::alloc::box_free::<Vec<u32>, std::alloc::Global>}, val: Value(<ZST>) }
- } - }
- -
- bb5 (cleanup): { - bb5 (cleanup): {

8
src/test/mir-opt/inline/inline_options.main.Inline.after.mir
View file

@ -15,7 +15,7 @@ fn main() -> () {
_1 = not_inlined() -> bb1; // scope 0 at $DIR/inline-options.rs:9:5: 9:18 _1 = not_inlined() -> bb1; // scope 0 at $DIR/inline-options.rs:9:5: 9:18
// mir::Constant // mir::Constant
// + span: $DIR/inline-options.rs:9:5: 9:16 // + span: $DIR/inline-options.rs:9:5: 9:16
// + literal: Const { ty: fn() {not_inlined}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {not_inlined}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -25,7 +25,7 @@ fn main() -> () {
_3 = g() -> bb2; // scope 1 at $DIR/inline-options.rs:16:23: 16:26 _3 = g() -> bb2; // scope 1 at $DIR/inline-options.rs:16:23: 16:26
// mir::Constant // mir::Constant
// + span: $DIR/inline-options.rs:16:23: 16:24 // + span: $DIR/inline-options.rs:16:23: 16:24
// + literal: Const { ty: fn() {g}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {g}, val: Value(<ZST>) }
} }
bb2: { bb2: {
@ -34,7 +34,7 @@ fn main() -> () {
_4 = g() -> bb3; // scope 1 at $DIR/inline-options.rs:16:28: 16:31 _4 = g() -> bb3; // scope 1 at $DIR/inline-options.rs:16:28: 16:31
// mir::Constant // mir::Constant
// + span: $DIR/inline-options.rs:16:28: 16:29 // + span: $DIR/inline-options.rs:16:28: 16:29
// + literal: Const { ty: fn() {g}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {g}, val: Value(<ZST>) }
} }
bb3: { bb3: {
@ -43,7 +43,7 @@ fn main() -> () {
_5 = g() -> bb4; // scope 1 at $DIR/inline-options.rs:16:33: 16:36 _5 = g() -> bb4; // scope 1 at $DIR/inline-options.rs:16:33: 16:36
// mir::Constant // mir::Constant
// + span: $DIR/inline-options.rs:16:33: 16:34 // + span: $DIR/inline-options.rs:16:33: 16:34
// + literal: Const { ty: fn() {g}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() {g}, val: Value(<ZST>) }
} }
bb4: { bb4: {

2
src/test/mir-opt/inline/inline_retag.bar.Inline.after.mir
View file

@ -27,7 +27,7 @@ fn bar() -> bool {
_1 = foo; // scope 0 at $DIR/inline-retag.rs:11:13: 11:16 _1 = foo; // scope 0 at $DIR/inline-retag.rs:11:13: 11:16
// mir::Constant // mir::Constant
// + span: $DIR/inline-retag.rs:11:13: 11:16 // + span: $DIR/inline-retag.rs:11:13: 11:16
// + literal: Const { ty: for<'r, 's> fn(&'r i32, &'s i32) -> bool {foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r, 's> fn(&'r i32, &'s i32) -> bool {foo}, val: Value(<ZST>) }
StorageLive(_2); // scope 1 at $DIR/inline-retag.rs:12:5: 12:6 StorageLive(_2); // scope 1 at $DIR/inline-retag.rs:12:5: 12:6
_2 = _1; // scope 1 at $DIR/inline-retag.rs:12:5: 12:6 _2 = _1; // scope 1 at $DIR/inline-retag.rs:12:5: 12:6
StorageLive(_3); // scope 1 at $DIR/inline-retag.rs:12:7: 12:9 StorageLive(_3); // scope 1 at $DIR/inline-retag.rs:12:7: 12:9

2
src/test/mir-opt/inline/inline_shims.clone.Inline.diff
View file

@ -14,7 +14,7 @@
- _0 = <fn(A, B) as Clone>::clone(move _2) -> bb1; // scope 0 at $DIR/inline-shims.rs:6:5: 6:14 - _0 = <fn(A, B) as Clone>::clone(move _2) -> bb1; // scope 0 at $DIR/inline-shims.rs:6:5: 6:14
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-shims.rs:6:7: 6:12 - // + span: $DIR/inline-shims.rs:6:7: 6:12
- // + literal: Const { ty: for<'r> fn(&'r fn(A, B)) -> fn(A, B) {<fn(A, B) as Clone>::clone}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> fn(&'r fn(A, B)) -> fn(A, B) {<fn(A, B) as Clone>::clone}, val: Value(<ZST>) }
- } - }
- -
- bb1: { - bb1: {

4
src/test/mir-opt/inline/inline_shims.drop.Inline.diff
View file

@ -24,7 +24,7 @@
_3 = std::ptr::drop_in_place::<Vec<A>>(move _4) -> bb1; // scope 1 at $DIR/inline-shims.rs:11:14: 11:40 _3 = std::ptr::drop_in_place::<Vec<A>>(move _4) -> bb1; // scope 1 at $DIR/inline-shims.rs:11:14: 11:40
// mir::Constant // mir::Constant
// + span: $DIR/inline-shims.rs:11:14: 11:37 // + span: $DIR/inline-shims.rs:11:14: 11:37
// + literal: Const { ty: unsafe fn(*mut Vec<A>) {std::ptr::drop_in_place::<Vec<A>>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(*mut Vec<A>) {std::ptr::drop_in_place::<Vec<A>>}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -35,7 +35,7 @@
- _0 = std::ptr::drop_in_place::<Option<B>>(move _5) -> bb2; // scope 2 at $DIR/inline-shims.rs:12:14: 12:40 - _0 = std::ptr::drop_in_place::<Option<B>>(move _5) -> bb2; // scope 2 at $DIR/inline-shims.rs:12:14: 12:40
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-shims.rs:12:14: 12:37 - // + span: $DIR/inline-shims.rs:12:14: 12:37
- // + literal: Const { ty: unsafe fn(*mut Option<B>) {std::ptr::drop_in_place::<Option<B>>}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: unsafe fn(*mut Option<B>) {std::ptr::drop_in_place::<Option<B>>}, val: Value(<ZST>) }
+ StorageLive(_6); // scope 2 at $DIR/inline-shims.rs:12:14: 12:40 + StorageLive(_6); // scope 2 at $DIR/inline-shims.rs:12:14: 12:40
+ StorageLive(_7); // scope 2 at $DIR/inline-shims.rs:12:14: 12:40 + StorageLive(_7); // scope 2 at $DIR/inline-shims.rs:12:14: 12:40
+ _6 = discriminant((*_5)); // scope 3 at $SRC_DIR/core/src/ptr/mod.rs:LL:COL + _6 = discriminant((*_5)); // scope 3 at $SRC_DIR/core/src/ptr/mod.rs:LL:COL

2
src/test/mir-opt/inline/inline_specialization.main.Inline.diff
View file

@ -15,7 +15,7 @@
- _1 = <Vec<()> as Foo>::bar() -> bb1; // scope 0 at $DIR/inline-specialization.rs:5:13: 5:38 - _1 = <Vec<()> as Foo>::bar() -> bb1; // scope 0 at $DIR/inline-specialization.rs:5:13: 5:38
- // mir::Constant - // mir::Constant
- // + span: $DIR/inline-specialization.rs:5:13: 5:36 - // + span: $DIR/inline-specialization.rs:5:13: 5:36
- // + literal: Const { ty: fn() -> u32 {<Vec<()> as Foo>::bar}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: fn() -> u32 {<Vec<()> as Foo>::bar}, val: Value(<ZST>) }
- } - }
- -
- bb1: { - bb1: {

2
src/test/mir-opt/inline/inline_trait_method.test.Inline.after.mir
View file

@ -11,7 +11,7 @@ fn test(_1: &dyn X) -> u32 {
_0 = <dyn X as X>::y(move _2) -> bb1; // scope 0 at $DIR/inline-trait-method.rs:9:5: 9:10 _0 = <dyn X as X>::y(move _2) -> bb1; // scope 0 at $DIR/inline-trait-method.rs:9:5: 9:10
// mir::Constant // mir::Constant
// + span: $DIR/inline-trait-method.rs:9:7: 9:8 // + span: $DIR/inline-trait-method.rs:9:7: 9:8
// + literal: Const { ty: for<'r> fn(&'r dyn X) -> u32 {<dyn X as X>::y}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r dyn X) -> u32 {<dyn X as X>::y}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/inline/inline_trait_method_2.test2.Inline.after.mir
View file

@ -21,7 +21,7 @@ fn test2(_1: &dyn X) -> bool {
_0 = <dyn X as X>::y(move _4) -> bb1; // scope 1 at $DIR/inline-trait-method_2.rs:10:5: 10:10 _0 = <dyn X as X>::y(move _4) -> bb1; // scope 1 at $DIR/inline-trait-method_2.rs:10:5: 10:10
// mir::Constant // mir::Constant
// + span: $DIR/inline-trait-method_2.rs:10:7: 10:8 // + span: $DIR/inline-trait-method_2.rs:10:7: 10:8
// + literal: Const { ty: for<'r> fn(&'r dyn X) -> bool {<dyn X as X>::y}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r> fn(&'r dyn X) -> bool {<dyn X as X>::y}, val: Value(<ZST>) }
} }
bb1: { bb1: {

4
src/test/mir-opt/inline/issue_78442.bar.Inline.diff
View file

@ -19,7 +19,7 @@
+ _4 = hide_foo() -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:15 + _4 = hide_foo() -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:15
// mir::Constant // mir::Constant
// + span: $DIR/issue-78442.rs:11:5: 11:13 // + span: $DIR/issue-78442.rs:11:5: 11:13
// + literal: Const { ty: fn() -> impl Fn() {hide_foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> impl Fn() {hide_foo}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -29,7 +29,7 @@
- _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:17 - _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:17
- // mir::Constant - // mir::Constant
- // + span: $DIR/issue-78442.rs:11:5: 11:15 - // + span: $DIR/issue-78442.rs:11:5: 11:15
- // + literal: Const { ty: for<'r> extern "rust-call" fn(&'r fn() {foo}, ()) -> <fn() {foo} as FnOnce<()>>::Output {<fn() {foo} as Fn<()>>::call}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> extern "rust-call" fn(&'r fn() {foo}, ()) -> <fn() {foo} as FnOnce<()>>::Output {<fn() {foo} as Fn<()>>::call}, val: Value(<ZST>) }
+ _2 = move (*_3)() -> [return: bb5, unwind: bb3]; // scope 1 at $SRC_DIR/core/src/ops/function.rs:LL:COL + _2 = move (*_3)() -> [return: bb5, unwind: bb3]; // scope 1 at $SRC_DIR/core/src/ops/function.rs:LL:COL
} }

6
src/test/mir-opt/inline/issue_78442.bar.RevealAll.diff
View file

@ -18,7 +18,7 @@
_4 = hide_foo() -> [return: bb1, unwind: bb4]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:15 _4 = hide_foo() -> [return: bb1, unwind: bb4]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:15
// mir::Constant // mir::Constant
// + span: $DIR/issue-78442.rs:11:5: 11:13 // + span: $DIR/issue-78442.rs:11:5: 11:13
// + literal: Const { ty: fn() -> impl Fn() {hide_foo}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> impl Fn() {hide_foo}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -29,8 +29,8 @@
+ _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:17 + _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/issue-78442.rs:11:5: 11:17
// mir::Constant // mir::Constant
// + span: $DIR/issue-78442.rs:11:5: 11:15 // + span: $DIR/issue-78442.rs:11:5: 11:15
- // + literal: Const { ty: for<'r> extern "rust-call" fn(&'r impl Fn(), ()) -> <impl Fn() as FnOnce<()>>::Output {<impl Fn() as Fn<()>>::call}, val: Value(Scalar(<ZST>)) } - // + literal: Const { ty: for<'r> extern "rust-call" fn(&'r impl Fn(), ()) -> <impl Fn() as FnOnce<()>>::Output {<impl Fn() as Fn<()>>::call}, val: Value(<ZST>) }
+ // + literal: Const { ty: for<'r> extern "rust-call" fn(&'r fn() {foo}, ()) -> <fn() {foo} as FnOnce<()>>::Output {<fn() {foo} as Fn<()>>::call}, val: Value(Scalar(<ZST>)) } + // + literal: Const { ty: for<'r> extern "rust-call" fn(&'r fn() {foo}, ()) -> <fn() {foo} as FnOnce<()>>::Output {<fn() {foo} as Fn<()>>::call}, val: Value(<ZST>) }
} }
bb2: { bb2: {

2
src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
View file

@ -22,7 +22,7 @@
_2 = bar() -> [return: bb3, unwind: bb6]; // scope 0 at /the/src/instrument_coverage.rs:12:12: 12:17 _2 = bar() -> [return: bb3, unwind: bb6]; // scope 0 at /the/src/instrument_coverage.rs:12:12: 12:17
// mir::Constant // mir::Constant
// + span: /the/src/instrument_coverage.rs:12:12: 12:15 // + span: /the/src/instrument_coverage.rs:12:12: 12:15
// + literal: Const { ty: fn() -> bool {bar}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> bool {bar}, val: Value(<ZST>) }
} }
bb3: { bb3: {

4
src/test/mir-opt/issue_41110.main.ElaborateDrops.after.mir
View file

@ -23,7 +23,7 @@ fn main() -> () {
_3 = S::id(move _4) -> [return: bb1, unwind: bb4]; // scope 0 at $DIR/issue-41110.rs:8:21: 8:27 _3 = S::id(move _4) -> [return: bb1, unwind: bb4]; // scope 0 at $DIR/issue-41110.rs:8:21: 8:27
// mir::Constant // mir::Constant
// + span: $DIR/issue-41110.rs:8:23: 8:25 // + span: $DIR/issue-41110.rs:8:23: 8:25
// + literal: Const { ty: fn(S) -> S {S::id}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(S) -> S {S::id}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -32,7 +32,7 @@ fn main() -> () {
_1 = S::other(move _2, move _3) -> [return: bb2, unwind: bb3]; // scope 0 at $DIR/issue-41110.rs:8:13: 8:28 _1 = S::other(move _2, move _3) -> [return: bb2, unwind: bb3]; // scope 0 at $DIR/issue-41110.rs:8:13: 8:28
// mir::Constant // mir::Constant
// + span: $DIR/issue-41110.rs:8:15: 8:20 // + span: $DIR/issue-41110.rs:8:15: 8:20
// + literal: Const { ty: fn(S, S) {S::other}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(S, S) {S::other}, val: Value(<ZST>) }
} }
bb2: { bb2: {

2
src/test/mir-opt/issue_41110.test.ElaborateDrops.after.mir
View file

@ -28,7 +28,7 @@ fn test() -> () {
_3 = std::mem::drop::<S>(move _4) -> [return: bb1, unwind: bb7]; // scope 2 at $DIR/issue-41110.rs:17:5: 17:12 _3 = std::mem::drop::<S>(move _4) -> [return: bb1, unwind: bb7]; // scope 2 at $DIR/issue-41110.rs:17:5: 17:12
// mir::Constant // mir::Constant
// + span: $DIR/issue-41110.rs:17:5: 17:9 // + span: $DIR/issue-41110.rs:17:5: 17:9
// + literal: Const { ty: fn(S) {std::mem::drop::<S>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(S) {std::mem::drop::<S>}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/issue_41888.main.ElaborateDrops.after.mir
View file

@ -29,7 +29,7 @@ fn main() -> () {
_2 = cond() -> [return: bb1, unwind: bb11]; // scope 1 at $DIR/issue-41888.rs:8:8: 8:14 _2 = cond() -> [return: bb1, unwind: bb11]; // scope 1 at $DIR/issue-41888.rs:8:8: 8:14
// mir::Constant // mir::Constant
// + span: $DIR/issue-41888.rs:8:8: 8:12 // + span: $DIR/issue-41888.rs:8:8: 8:12
// + literal: Const { ty: fn() -> bool {cond}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> bool {cond}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/issue_49232.main.mir_map.0.mir
View file

@ -59,7 +59,7 @@ fn main() -> () {
_5 = std::mem::drop::<&i32>(move _6) -> [return: bb9, unwind: bb11]; // scope 1 at $DIR/issue-49232.rs:13:9: 13:22 _5 = std::mem::drop::<&i32>(move _6) -> [return: bb9, unwind: bb11]; // scope 1 at $DIR/issue-49232.rs:13:9: 13:22
// mir::Constant // mir::Constant
// + span: $DIR/issue-49232.rs:13:9: 13:13 // + span: $DIR/issue-49232.rs:13:9: 13:13
// + literal: Const { ty: fn(&i32) {std::mem::drop::<&i32>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(&i32) {std::mem::drop::<&i32>}, val: Value(<ZST>) }
} }
bb9: { bb9: {

6
src/test/mir-opt/issue_62289.test.ElaborateDrops.before.mir
View file

@ -34,7 +34,7 @@ fn test() -> Option<Box<u32>> {
_4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 1 at $DIR/issue-62289.rs:9:10: 9:21 _4 = alloc::alloc::exchange_malloc(move _2, move _3) -> bb1; // scope 1 at $DIR/issue-62289.rs:9:10: 9:21
// mir::Constant // mir::Constant
// + span: $DIR/issue-62289.rs:9:10: 9:21 // + span: $DIR/issue-62289.rs:9:10: 9:21
// + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe fn(usize, usize) -> *mut u8 {alloc::alloc::exchange_malloc}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -46,7 +46,7 @@ fn test() -> Option<Box<u32>> {
_6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb12]; // scope 0 at $DIR/issue-62289.rs:9:15: 9:20 _6 = <Option<u32> as Try>::branch(move _7) -> [return: bb2, unwind: bb12]; // scope 0 at $DIR/issue-62289.rs:9:15: 9:20
// mir::Constant // mir::Constant
// + span: $DIR/issue-62289.rs:9:15: 9:20 // + span: $DIR/issue-62289.rs:9:15: 9:20
// + literal: Const { ty: fn(Option<u32>) -> ControlFlow<<Option<u32> as Try>::Residual, <Option<u32> as Try>::Output> {<Option<u32> as Try>::branch}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(Option<u32>) -> ControlFlow<<Option<u32> as Try>::Residual, <Option<u32> as Try>::Output> {<Option<u32> as Try>::branch}, val: Value(<ZST>) }
} }
bb2: { bb2: {
@ -76,7 +76,7 @@ fn test() -> Option<Box<u32>> {
_0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12]; // scope 3 at $DIR/issue-62289.rs:9:15: 9:20 _0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12]; // scope 3 at $DIR/issue-62289.rs:9:15: 9:20
// mir::Constant // mir::Constant
// + span: $DIR/issue-62289.rs:9:19: 9:20 // + span: $DIR/issue-62289.rs:9:19: 9:20
// + literal: Const { ty: fn(Option<Infallible>) -> Option<Box<u32>> {<Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(Option<Infallible>) -> Option<Box<u32>> {<Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual}, val: Value(<ZST>) }
} }
bb6: { bb6: {

2
src/test/mir-opt/issue_72181.main.mir_map.0.32bit.mir
View file

@ -25,7 +25,7 @@ fn main() -> () {
_1 = std::mem::size_of::<Foo>() -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/issue-72181.rs:24:13: 24:34 _1 = std::mem::size_of::<Foo>() -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/issue-72181.rs:24:13: 24:34
// mir::Constant // mir::Constant
// + span: $DIR/issue-72181.rs:24:13: 24:32 // + span: $DIR/issue-72181.rs:24:13: 24:32
// + literal: Const { ty: fn() -> usize {std::mem::size_of::<Foo>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> usize {std::mem::size_of::<Foo>}, val: Value(<ZST>) }
} }
bb1: { bb1: {

2
src/test/mir-opt/issue_72181.main.mir_map.0.64bit.mir
View file

@ -25,7 +25,7 @@ fn main() -> () {
_1 = std::mem::size_of::<Foo>() -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/issue-72181.rs:24:13: 24:34 _1 = std::mem::size_of::<Foo>() -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/issue-72181.rs:24:13: 24:34
// mir::Constant // mir::Constant
// + span: $DIR/issue-72181.rs:24:13: 24:32 // + span: $DIR/issue-72181.rs:24:13: 24:32
// + literal: Const { ty: fn() -> usize {std::mem::size_of::<Foo>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn() -> usize {std::mem::size_of::<Foo>}, val: Value(<ZST>) }
} }
bb1: { bb1: {

4
src/test/mir-opt/issue_72181_1.main.mir_map.0.mir
View file

@ -24,7 +24,7 @@ fn main() -> () {
_2 = transmute::<(), Void>(move _3) -> bb4; // scope 2 at $DIR/issue-72181-1.rs:17:9: 17:44 _2 = transmute::<(), Void>(move _3) -> bb4; // scope 2 at $DIR/issue-72181-1.rs:17:9: 17:44
// mir::Constant // mir::Constant
// + span: $DIR/issue-72181-1.rs:17:9: 17:40 // + span: $DIR/issue-72181-1.rs:17:9: 17:40
// + literal: Const { ty: unsafe extern "rust-intrinsic" fn(()) -> Void {transmute::<(), Void>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(()) -> Void {transmute::<(), Void>}, val: Value(<ZST>) }
} }
bb1: { bb1: {
@ -37,7 +37,7 @@ fn main() -> () {
_4 = f(move _5) -> bb4; // scope 1 at $DIR/issue-72181-1.rs:20:5: 20:9 _4 = f(move _5) -> bb4; // scope 1 at $DIR/issue-72181-1.rs:20:5: 20:9
// mir::Constant // mir::Constant
// + span: $DIR/issue-72181-1.rs:20:5: 20:6 // + span: $DIR/issue-72181-1.rs:20:5: 20:6
// + literal: Const { ty: fn(Void) -> ! {f}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: fn(Void) -> ! {f}, val: Value(<ZST>) }
} }
bb2: { bb2: {

2
src/test/mir-opt/issue_73223.main.PreCodegen.32bit.diff
View file

@ -98,7 +98,7 @@
_14 = core::panicking::assert_failed::<i32, i32>(const core::panicking::AssertKind::Eq, move _15, move _17, move _19); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _14 = core::panicking::assert_failed::<i32, i32>(const core::panicking::AssertKind::Eq, move _15, move _17, move _19); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL
// mir::Constant // mir::Constant
// + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL
// + literal: Const { ty: for<'r, 's, 't0> fn(core::panicking::AssertKind, &'r i32, &'s i32, Option<Arguments<'t0>>) -> ! {core::panicking::assert_failed::<i32, i32>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r, 's, 't0> fn(core::panicking::AssertKind, &'r i32, &'s i32, Option<Arguments<'t0>>) -> ! {core::panicking::assert_failed::<i32, i32>}, val: Value(<ZST>) }
// mir::Constant // mir::Constant
// + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL
// + literal: Const { ty: core::panicking::AssertKind, val: Value(Scalar(0x00)) } // + literal: Const { ty: core::panicking::AssertKind, val: Value(Scalar(0x00)) }

2
src/test/mir-opt/issue_73223.main.PreCodegen.64bit.diff
View file

@ -98,7 +98,7 @@
_14 = core::panicking::assert_failed::<i32, i32>(const core::panicking::AssertKind::Eq, move _15, move _17, move _19); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _14 = core::panicking::assert_failed::<i32, i32>(const core::panicking::AssertKind::Eq, move _15, move _17, move _19); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL
// mir::Constant // mir::Constant
// + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL
// + literal: Const { ty: for<'r, 's, 't0> fn(core::panicking::AssertKind, &'r i32, &'s i32, Option<Arguments<'t0>>) -> ! {core::panicking::assert_failed::<i32, i32>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r, 's, 't0> fn(core::panicking::AssertKind, &'r i32, &'s i32, Option<Arguments<'t0>>) -> ! {core::panicking::assert_failed::<i32, i32>}, val: Value(<ZST>) }
// mir::Constant // mir::Constant
// + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL
// + literal: Const { ty: core::panicking::AssertKind, val: Value(Scalar(0x00)) } // + literal: Const { ty: core::panicking::AssertKind, val: Value(Scalar(0x00)) }

2
src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.32bit.diff
View file

@ -135,7 +135,7 @@
_21 = core::panicking::assert_failed::<i32, i32>(const core::panicking::AssertKind::Eq, move _23, move _25, move _27); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _21 = core::panicking::assert_failed::<i32, i32>(const core::panicking::AssertKind::Eq, move _23, move _25, move _27); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL
// mir::Constant // mir::Constant
// + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL
// + literal: Const { ty: for<'r, 's, 't0> fn(core::panicking::AssertKind, &'r i32, &'s i32, Option<Arguments<'t0>>) -> ! {core::panicking::assert_failed::<i32, i32>}, val: Value(Scalar(<ZST>)) } // + literal: Const { ty: for<'r, 's, 't0> fn(core::panicking::AssertKind, &'r i32, &'s i32, Option<Arguments<'t0>>) -> ! {core::panicking::assert_failed::<i32, i32>}, val: Value(<ZST>) }
// mir::Constant // mir::Constant
// + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL
// + literal: Const { ty: core::panicking::AssertKind, val: Value(Scalar(0x00)) } // + literal: Const { ty: core::panicking::AssertKind, val: Value(Scalar(0x00)) }

Some files were not shown because too many files have changed in this diff Show more