2023-06-08 02:18:34 -05:00
|
|
|
// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
|
2024-04-20 06:19:34 -05:00
|
|
|
//@ test-mir-pass: CopyProp
|
2023-01-20 13:34:46 -06:00
|
|
|
|
2024-04-07 13:33:18 -05:00
|
|
|
#![feature(custom_mir, core_intrinsics, freeze)]
|
2023-01-20 13:34:46 -06:00
|
|
|
#![allow(unused_assignments)]
|
|
|
|
|
extern crate core;
|
|
|
|
|
use core::intrinsics::mir::*;
|
2024-06-02 19:18:33 -05:00
|
|
|
use core::marker::Freeze;
|
2023-01-20 13:34:46 -06:00
|
|
|
|
2024-06-02 19:18:33 -05:00
|
|
|
fn opaque(_: impl Sized) -> bool {
|
|
|
|
|
true
|
|
|
|
|
}
|
2023-01-20 13:34:46 -06:00
|
|
|
|
|
|
|
|
fn cmp_ref(a: &u8, b: &u8) -> bool {
|
|
|
|
|
std::ptr::eq(a as *const u8, b as *const u8)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[custom_mir(dialect = "analysis", phase = "post-cleanup")]
|
2024-04-07 11:23:16 -05:00
|
|
|
fn compare_address() -> bool {
|
|
|
|
|
// CHECK-LABEL: fn compare_address(
|
|
|
|
|
// CHECK: bb0: {
|
|
|
|
|
// CHECK-NEXT: _1 = const 5_u8;
|
|
|
|
|
// CHECK-NEXT: _2 = &_1;
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _3 = copy _1;
|
2024-04-07 11:23:16 -05:00
|
|
|
// CHECK-NEXT: _4 = &_3;
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _0 = cmp_ref(copy _2, copy _4)
|
2024-04-07 11:23:16 -05:00
|
|
|
// CHECK: bb1: {
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _0 = opaque::<u8>(copy _3)
|
Reformat `mir!` macro invocations to use braces.
The `mir!` macro has multiple parts:
- An optional return type annotation.
- A sequence of zero or more local declarations.
- A mandatory starting anonymous basic block, which is brace-delimited.
- A sequence of zero of more additional named basic blocks.
Some `mir!` invocations use braces with a "block" style, like so:
```
mir! {
let _unit: ();
{
let non_copy = S(42);
let ptr = std::ptr::addr_of_mut!(non_copy);
// Inside `callee`, the first argument and `*ptr` are basically
// aliasing places!
Call(_unit = callee(Move(*ptr), ptr), ReturnTo(after_call), UnwindContinue())
}
after_call = {
Return()
}
}
```
Some invocations use parens with a "block" style, like so:
```
mir!(
let x: [i32; 2];
let one: i32;
{
x = [42, 43];
one = 1;
x = [one, 2];
RET = Move(x);
Return()
}
)
```
And some invocations uses parens with a "tighter" style, like so:
```
mir!({
SetDiscriminant(*b, 0);
Return()
})
```
This last style is generally used for cases where just the mandatory
starting basic block is present. Its braces are placed next to the
parens.
This commit changes all `mir!` invocations to use braces with a "block"
style. Why?
- Consistency is good.
- The contents of the invocation is a block of code, so it's odd to use
parens. They are more normally used for function-like macros.
- Most importantly, the next commit will enable rustfmt for
`tests/mir-opt/`. rustfmt is more aggressive about formatting macros
that use parens than macros that use braces. Without this commit's
changes, rustfmt would break a couple of `mir!` macro invocations that
use braces within `tests/mir-opt` by inserting an extraneous comma.
E.g.:
```
mir!(type RET = (i32, bool);, { // extraneous comma after ';'
RET.0 = 1;
RET.1 = true;
Return()
})
```
Switching those `mir!` invocations to use braces avoids that problem,
resulting in this, which is nicer to read as well as being valid
syntax:
```
mir! {
type RET = (i32, bool);
{
RET.0 = 1;
RET.1 = true;
Return()
}
}
```
2024-06-02 19:19:57 -05:00
|
|
|
mir! {
|
2023-01-20 13:34:46 -06:00
|
|
|
{
|
|
|
|
|
let a = 5_u8;
|
|
|
|
|
let r1 = &a;
|
|
|
|
|
let b = a;
|
|
|
|
|
// We cannot propagate the place `a`.
|
|
|
|
|
let r2 = &b;
|
2023-12-26 12:31:52 -06:00
|
|
|
Call(RET = cmp_ref(r1, r2), ReturnTo(next), UnwindContinue())
|
2023-01-20 13:34:46 -06:00
|
|
|
}
|
|
|
|
|
next = {
|
|
|
|
|
// But we can propagate the value `a`.
|
2023-12-26 12:31:52 -06:00
|
|
|
Call(RET = opaque(b), ReturnTo(ret), UnwindContinue())
|
2023-01-20 13:34:46 -06:00
|
|
|
}
|
|
|
|
|
ret = {
|
|
|
|
|
Return()
|
|
|
|
|
}
|
Reformat `mir!` macro invocations to use braces.
The `mir!` macro has multiple parts:
- An optional return type annotation.
- A sequence of zero or more local declarations.
- A mandatory starting anonymous basic block, which is brace-delimited.
- A sequence of zero of more additional named basic blocks.
Some `mir!` invocations use braces with a "block" style, like so:
```
mir! {
let _unit: ();
{
let non_copy = S(42);
let ptr = std::ptr::addr_of_mut!(non_copy);
// Inside `callee`, the first argument and `*ptr` are basically
// aliasing places!
Call(_unit = callee(Move(*ptr), ptr), ReturnTo(after_call), UnwindContinue())
}
after_call = {
Return()
}
}
```
Some invocations use parens with a "block" style, like so:
```
mir!(
let x: [i32; 2];
let one: i32;
{
x = [42, 43];
one = 1;
x = [one, 2];
RET = Move(x);
Return()
}
)
```
And some invocations uses parens with a "tighter" style, like so:
```
mir!({
SetDiscriminant(*b, 0);
Return()
})
```
This last style is generally used for cases where just the mandatory
starting basic block is present. Its braces are placed next to the
parens.
This commit changes all `mir!` invocations to use braces with a "block"
style. Why?
- Consistency is good.
- The contents of the invocation is a block of code, so it's odd to use
parens. They are more normally used for function-like macros.
- Most importantly, the next commit will enable rustfmt for
`tests/mir-opt/`. rustfmt is more aggressive about formatting macros
that use parens than macros that use braces. Without this commit's
changes, rustfmt would break a couple of `mir!` macro invocations that
use braces within `tests/mir-opt` by inserting an extraneous comma.
E.g.:
```
mir!(type RET = (i32, bool);, { // extraneous comma after ';'
RET.0 = 1;
RET.1 = true;
Return()
})
```
Switching those `mir!` invocations to use braces avoids that problem,
resulting in this, which is nicer to read as well as being valid
syntax:
```
mir! {
type RET = (i32, bool);
{
RET.0 = 1;
RET.1 = true;
Return()
}
}
```
2024-06-02 19:19:57 -05:00
|
|
|
}
|
2023-01-20 13:34:46 -06:00
|
|
|
}
|
|
|
|
|
|
2024-04-07 13:33:18 -05:00
|
|
|
/// Generic type `T` is `Freeze`, so shared borrows are immutable.
|
2024-04-07 11:23:16 -05:00
|
|
|
#[custom_mir(dialect = "analysis", phase = "post-cleanup")]
|
2024-04-07 13:33:18 -05:00
|
|
|
fn borrowed<T: Copy + Freeze>(x: T) -> bool {
|
2024-04-07 11:23:16 -05:00
|
|
|
// CHECK-LABEL: fn borrowed(
|
|
|
|
|
// CHECK: bb0: {
|
|
|
|
|
// CHECK-NEXT: _3 = &_1;
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _0 = opaque::<&T>(copy _3)
|
2024-04-07 11:23:16 -05:00
|
|
|
// CHECK: bb1: {
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _0 = opaque::<T>(copy _1)
|
Reformat `mir!` macro invocations to use braces.
The `mir!` macro has multiple parts:
- An optional return type annotation.
- A sequence of zero or more local declarations.
- A mandatory starting anonymous basic block, which is brace-delimited.
- A sequence of zero of more additional named basic blocks.
Some `mir!` invocations use braces with a "block" style, like so:
```
mir! {
let _unit: ();
{
let non_copy = S(42);
let ptr = std::ptr::addr_of_mut!(non_copy);
// Inside `callee`, the first argument and `*ptr` are basically
// aliasing places!
Call(_unit = callee(Move(*ptr), ptr), ReturnTo(after_call), UnwindContinue())
}
after_call = {
Return()
}
}
```
Some invocations use parens with a "block" style, like so:
```
mir!(
let x: [i32; 2];
let one: i32;
{
x = [42, 43];
one = 1;
x = [one, 2];
RET = Move(x);
Return()
}
)
```
And some invocations uses parens with a "tighter" style, like so:
```
mir!({
SetDiscriminant(*b, 0);
Return()
})
```
This last style is generally used for cases where just the mandatory
starting basic block is present. Its braces are placed next to the
parens.
This commit changes all `mir!` invocations to use braces with a "block"
style. Why?
- Consistency is good.
- The contents of the invocation is a block of code, so it's odd to use
parens. They are more normally used for function-like macros.
- Most importantly, the next commit will enable rustfmt for
`tests/mir-opt/`. rustfmt is more aggressive about formatting macros
that use parens than macros that use braces. Without this commit's
changes, rustfmt would break a couple of `mir!` macro invocations that
use braces within `tests/mir-opt` by inserting an extraneous comma.
E.g.:
```
mir!(type RET = (i32, bool);, { // extraneous comma after ';'
RET.0 = 1;
RET.1 = true;
Return()
})
```
Switching those `mir!` invocations to use braces avoids that problem,
resulting in this, which is nicer to read as well as being valid
syntax:
```
mir! {
type RET = (i32, bool);
{
RET.0 = 1;
RET.1 = true;
Return()
}
}
```
2024-06-02 19:19:57 -05:00
|
|
|
mir! {
|
2024-04-07 11:23:16 -05:00
|
|
|
{
|
|
|
|
|
let a = x;
|
|
|
|
|
let r1 = &x;
|
|
|
|
|
Call(RET = opaque(r1), ReturnTo(next), UnwindContinue())
|
|
|
|
|
}
|
|
|
|
|
next = {
|
|
|
|
|
Call(RET = opaque(a), ReturnTo(ret), UnwindContinue())
|
|
|
|
|
}
|
|
|
|
|
ret = {
|
|
|
|
|
Return()
|
|
|
|
|
}
|
Reformat `mir!` macro invocations to use braces.
The `mir!` macro has multiple parts:
- An optional return type annotation.
- A sequence of zero or more local declarations.
- A mandatory starting anonymous basic block, which is brace-delimited.
- A sequence of zero of more additional named basic blocks.
Some `mir!` invocations use braces with a "block" style, like so:
```
mir! {
let _unit: ();
{
let non_copy = S(42);
let ptr = std::ptr::addr_of_mut!(non_copy);
// Inside `callee`, the first argument and `*ptr` are basically
// aliasing places!
Call(_unit = callee(Move(*ptr), ptr), ReturnTo(after_call), UnwindContinue())
}
after_call = {
Return()
}
}
```
Some invocations use parens with a "block" style, like so:
```
mir!(
let x: [i32; 2];
let one: i32;
{
x = [42, 43];
one = 1;
x = [one, 2];
RET = Move(x);
Return()
}
)
```
And some invocations uses parens with a "tighter" style, like so:
```
mir!({
SetDiscriminant(*b, 0);
Return()
})
```
This last style is generally used for cases where just the mandatory
starting basic block is present. Its braces are placed next to the
parens.
This commit changes all `mir!` invocations to use braces with a "block"
style. Why?
- Consistency is good.
- The contents of the invocation is a block of code, so it's odd to use
parens. They are more normally used for function-like macros.
- Most importantly, the next commit will enable rustfmt for
`tests/mir-opt/`. rustfmt is more aggressive about formatting macros
that use parens than macros that use braces. Without this commit's
changes, rustfmt would break a couple of `mir!` macro invocations that
use braces within `tests/mir-opt` by inserting an extraneous comma.
E.g.:
```
mir!(type RET = (i32, bool);, { // extraneous comma after ';'
RET.0 = 1;
RET.1 = true;
Return()
})
```
Switching those `mir!` invocations to use braces avoids that problem,
resulting in this, which is nicer to read as well as being valid
syntax:
```
mir! {
type RET = (i32, bool);
{
RET.0 = 1;
RET.1 = true;
Return()
}
}
```
2024-06-02 19:19:57 -05:00
|
|
|
}
|
2024-04-07 11:23:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Generic type `T` is not known to be `Freeze`, so shared borrows may be mutable.
|
|
|
|
|
#[custom_mir(dialect = "analysis", phase = "post-cleanup")]
|
|
|
|
|
fn non_freeze<T: Copy>(x: T) -> bool {
|
|
|
|
|
// CHECK-LABEL: fn non_freeze(
|
|
|
|
|
// CHECK: bb0: {
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _2 = copy _1;
|
2024-04-07 11:23:16 -05:00
|
|
|
// CHECK-NEXT: _3 = &_1;
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _0 = opaque::<&T>(copy _3)
|
2024-04-07 11:23:16 -05:00
|
|
|
// CHECK: bb1: {
|
2024-08-18 17:51:53 -05:00
|
|
|
// CHECK-NEXT: _0 = opaque::<T>(copy _2)
|
Reformat `mir!` macro invocations to use braces.
The `mir!` macro has multiple parts:
- An optional return type annotation.
- A sequence of zero or more local declarations.
- A mandatory starting anonymous basic block, which is brace-delimited.
- A sequence of zero of more additional named basic blocks.
Some `mir!` invocations use braces with a "block" style, like so:
```
mir! {
let _unit: ();
{
let non_copy = S(42);
let ptr = std::ptr::addr_of_mut!(non_copy);
// Inside `callee`, the first argument and `*ptr` are basically
// aliasing places!
Call(_unit = callee(Move(*ptr), ptr), ReturnTo(after_call), UnwindContinue())
}
after_call = {
Return()
}
}
```
Some invocations use parens with a "block" style, like so:
```
mir!(
let x: [i32; 2];
let one: i32;
{
x = [42, 43];
one = 1;
x = [one, 2];
RET = Move(x);
Return()
}
)
```
And some invocations uses parens with a "tighter" style, like so:
```
mir!({
SetDiscriminant(*b, 0);
Return()
})
```
This last style is generally used for cases where just the mandatory
starting basic block is present. Its braces are placed next to the
parens.
This commit changes all `mir!` invocations to use braces with a "block"
style. Why?
- Consistency is good.
- The contents of the invocation is a block of code, so it's odd to use
parens. They are more normally used for function-like macros.
- Most importantly, the next commit will enable rustfmt for
`tests/mir-opt/`. rustfmt is more aggressive about formatting macros
that use parens than macros that use braces. Without this commit's
changes, rustfmt would break a couple of `mir!` macro invocations that
use braces within `tests/mir-opt` by inserting an extraneous comma.
E.g.:
```
mir!(type RET = (i32, bool);, { // extraneous comma after ';'
RET.0 = 1;
RET.1 = true;
Return()
})
```
Switching those `mir!` invocations to use braces avoids that problem,
resulting in this, which is nicer to read as well as being valid
syntax:
```
mir! {
type RET = (i32, bool);
{
RET.0 = 1;
RET.1 = true;
Return()
}
}
```
2024-06-02 19:19:57 -05:00
|
|
|
mir! {
|
2024-04-07 11:23:16 -05:00
|
|
|
{
|
|
|
|
|
let a = x;
|
|
|
|
|
let r1 = &x;
|
|
|
|
|
Call(RET = opaque(r1), ReturnTo(next), UnwindContinue())
|
|
|
|
|
}
|
|
|
|
|
next = {
|
|
|
|
|
Call(RET = opaque(a), ReturnTo(ret), UnwindContinue())
|
|
|
|
|
}
|
|
|
|
|
ret = {
|
|
|
|
|
Return()
|
|
|
|
|
}
|
Reformat `mir!` macro invocations to use braces.
The `mir!` macro has multiple parts:
- An optional return type annotation.
- A sequence of zero or more local declarations.
- A mandatory starting anonymous basic block, which is brace-delimited.
- A sequence of zero of more additional named basic blocks.
Some `mir!` invocations use braces with a "block" style, like so:
```
mir! {
let _unit: ();
{
let non_copy = S(42);
let ptr = std::ptr::addr_of_mut!(non_copy);
// Inside `callee`, the first argument and `*ptr` are basically
// aliasing places!
Call(_unit = callee(Move(*ptr), ptr), ReturnTo(after_call), UnwindContinue())
}
after_call = {
Return()
}
}
```
Some invocations use parens with a "block" style, like so:
```
mir!(
let x: [i32; 2];
let one: i32;
{
x = [42, 43];
one = 1;
x = [one, 2];
RET = Move(x);
Return()
}
)
```
And some invocations uses parens with a "tighter" style, like so:
```
mir!({
SetDiscriminant(*b, 0);
Return()
})
```
This last style is generally used for cases where just the mandatory
starting basic block is present. Its braces are placed next to the
parens.
This commit changes all `mir!` invocations to use braces with a "block"
style. Why?
- Consistency is good.
- The contents of the invocation is a block of code, so it's odd to use
parens. They are more normally used for function-like macros.
- Most importantly, the next commit will enable rustfmt for
`tests/mir-opt/`. rustfmt is more aggressive about formatting macros
that use parens than macros that use braces. Without this commit's
changes, rustfmt would break a couple of `mir!` macro invocations that
use braces within `tests/mir-opt` by inserting an extraneous comma.
E.g.:
```
mir!(type RET = (i32, bool);, { // extraneous comma after ';'
RET.0 = 1;
RET.1 = true;
Return()
})
```
Switching those `mir!` invocations to use braces avoids that problem,
resulting in this, which is nicer to read as well as being valid
syntax:
```
mir! {
type RET = (i32, bool);
{
RET.0 = 1;
RET.1 = true;
Return()
}
}
```
2024-06-02 19:19:57 -05:00
|
|
|
}
|
2024-04-07 11:23:16 -05:00
|
|
|
}
|
|
|
|
|
|
2023-01-20 13:34:46 -06:00
|
|
|
fn main() {
|
2024-04-07 11:23:16 -05:00
|
|
|
assert!(!compare_address());
|
|
|
|
|
non_freeze(5);
|
2023-01-20 13:34:46 -06:00
|
|
|
}
|
|
|
|
|
|
2024-04-07 11:23:16 -05:00
|
|
|
// EMIT_MIR borrowed_local.compare_address.CopyProp.diff
|
|
|
|
|
// EMIT_MIR borrowed_local.borrowed.CopyProp.diff
|
|
|
|
|
// EMIT_MIR borrowed_local.non_freeze.CopyProp.diff
|
