tests/mir-opt/sroa.rs

   1 // unit-test: ScalarReplacementOfAggregates
   2 // compile-flags: -Cpanic=abort
   3 // no-prefer-dynamic
   4
   5 struct Tag(usize);
   6
   7 #[repr(C)]
   8 struct S(Tag, Tag, Tag);
   9
  10 impl Drop for Tag {
  11     #[inline(never)]
  12     fn drop(&mut self) {}
  13 }
  14
  15 pub fn dropping() {
  16     S(Tag(0), Tag(1), Tag(2)).1;
  17 }
  18
  19 pub fn enums(a: usize) -> usize {
  20     if let Some(a) = Some(a) { a } else { 0 }
  21 }
  22
  23 pub fn structs(a: f32) -> f32 {
  24     struct U {
  25         _foo: usize,
  26         a: f32,
  27     }
  28
  29     U { _foo: 0, a }.a
  30 }
  31
  32 pub fn unions(a: f32) -> u32 {
  33     union Repr {
  34         f: f32,
  35         u: u32,
  36     }
  37     unsafe { Repr { f: a }.u }
  38 }
  39
  40 #[derive(Copy, Clone)]
  41 struct Foo {
  42     a: u8,
  43     b: (),
  44     c: &'static str,
  45     d: Option<isize>,
  46 }
  47
  48 fn g() -> u32 {
  49     3
  50 }
  51
  52 pub fn flat() {
  53     let Foo { a, b, c, d } = Foo { a: 5, b: (), c: "a", d: Some(-4) };
  54     let _ = a;
  55     let _ = b;
  56     let _ = c;
  57     let _ = d;
  58 }
  59
  60 #[repr(C)]
  61 struct Escaping {
  62     a: u32,
  63     b: u32,
  64     c: u32,
  65 }
  66
  67 fn f(a: *const u32) {
  68     println!("{}", unsafe { *a.add(2) });
  69 }
  70
  71 pub fn escaping() {
  72     // Verify this struct is not flattened.
  73     f(&Escaping { a: 1, b: 2, c: g() }.a);
  74 }
  75
  76 fn copies(x: Foo) {
  77     let y = x;
  78     let t = y.a;
  79     let u = y.c;
  80     let z = y;
  81     let a = z.b;
  82 }
  83
  84 fn ref_copies(x: &Foo) {
  85     let y = *x;
  86     let t = y.a;
  87     let u = y.c;
  88 }
  89
  90 fn main() {
  91     dropping();
  92     enums(5);
  93     structs(5.);
  94     unions(5.);
  95     flat();
  96     escaping();
  97     copies(Foo { a: 5, b: (), c: "a", d: Some(-4) });
  98     ref_copies(&Foo { a: 5, b: (), c: "a", d: Some(-4) });
  99 }
 100
 101 // EMIT_MIR sroa.dropping.ScalarReplacementOfAggregates.diff
 102 // EMIT_MIR sroa.enums.ScalarReplacementOfAggregates.diff
 103 // EMIT_MIR sroa.structs.ScalarReplacementOfAggregates.diff
 104 // EMIT_MIR sroa.unions.ScalarReplacementOfAggregates.diff
 105 // EMIT_MIR sroa.flat.ScalarReplacementOfAggregates.diff
 106 // EMIT_MIR sroa.escaping.ScalarReplacementOfAggregates.diff
 107 // EMIT_MIR sroa.copies.ScalarReplacementOfAggregates.diff
 108 // EMIT_MIR sroa.ref_copies.ScalarReplacementOfAggregates.diff