ac24299636
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()
}
}
```
110 lines
2.2 KiB
Rust
110 lines
2.2 KiB
Rust
// skip-filecheck
|
|
#![feature(custom_mir, core_intrinsics)]
|
|
|
|
extern crate core;
|
|
use core::intrinsics::mir::*;
|
|
|
|
union U {
|
|
a: i32,
|
|
b: u32,
|
|
}
|
|
|
|
// EMIT_MIR projections.unions.built.after.mir
|
|
#[custom_mir(dialect = "built")]
|
|
fn unions(u: U) -> i32 {
|
|
mir! {
|
|
{
|
|
RET = u.a;
|
|
Return()
|
|
}
|
|
}
|
|
}
|
|
|
|
// EMIT_MIR projections.tuples.built.after.mir
|
|
#[custom_mir(dialect = "analysis", phase = "post-cleanup")]
|
|
fn tuples(i: (u32, i32)) -> (u32, i32) {
|
|
mir! {
|
|
type RET = (u32, i32);
|
|
{
|
|
RET.0 = i.0;
|
|
RET.1 = i.1;
|
|
Return()
|
|
}
|
|
}
|
|
}
|
|
|
|
// EMIT_MIR projections.unwrap.built.after.mir
|
|
#[custom_mir(dialect = "built")]
|
|
fn unwrap(opt: Option<i32>) -> i32 {
|
|
mir! {
|
|
{
|
|
RET = Field(Variant(opt, 1), 0);
|
|
Return()
|
|
}
|
|
}
|
|
}
|
|
|
|
// EMIT_MIR projections.unwrap_deref.built.after.mir
|
|
#[custom_mir(dialect = "built")]
|
|
fn unwrap_deref(opt: Option<&i32>) -> i32 {
|
|
mir! {
|
|
{
|
|
RET = *Field::<&i32>(Variant(opt, 1), 0);
|
|
Return()
|
|
}
|
|
}
|
|
}
|
|
|
|
// EMIT_MIR projections.set.built.after.mir
|
|
#[custom_mir(dialect = "built")]
|
|
fn set(opt: &mut Option<i32>) {
|
|
mir! {
|
|
{
|
|
place!(Field(Variant(*opt, 1), 0)) = 10;
|
|
Return()
|
|
}
|
|
}
|
|
}
|
|
|
|
// EMIT_MIR projections.simple_index.built.after.mir
|
|
#[custom_mir(dialect = "built")]
|
|
fn simple_index(a: [i32; 10], b: &[i32]) -> i32 {
|
|
mir! {
|
|
{
|
|
let temp = 3;
|
|
RET = a[temp];
|
|
RET = (*b)[temp];
|
|
Return()
|
|
}
|
|
}
|
|
}
|
|
|
|
// EMIT_MIR projections.copy_for_deref.built.after.mir
|
|
#[custom_mir(dialect = "runtime", phase = "initial")]
|
|
fn copy_for_deref(x: (&i32, i32)) -> i32 {
|
|
mir! {
|
|
let temp: &i32;
|
|
{
|
|
temp = CopyForDeref(x.0);
|
|
RET = *temp;
|
|
Return()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
assert_eq!(unions(U { a: 5 }), 5);
|
|
assert_eq!(tuples((5, 6)), (5, 6));
|
|
|
|
assert_eq!(unwrap(Some(5)), 5);
|
|
assert_eq!(unwrap_deref(Some(&5)), 5);
|
|
let mut o = Some(5);
|
|
set(&mut o);
|
|
assert_eq!(o, Some(10));
|
|
|
|
assert_eq!(simple_index([0; 10], &[0; 10]), 0);
|
|
|
|
let one = 1;
|
|
assert_eq!(copy_for_deref((&one, one)), 1);
|
|
}
|