src/test/ui/union/union-packed.rs

   1 // run-pass
   2 // revisions: mirunsafeck thirunsafeck
   3 // [thirunsafeck]compile-flags: -Z thir-unsafeck
   4
   5 #![allow(dead_code)]
   6 #![allow(non_snake_case)]
   7
   8 use std::mem::{size_of, size_of_val, align_of, align_of_val};
   9
  10 struct S {
  11     a: u16,
  12     b: [u8; 3],
  13 }
  14
  15 #[repr(packed)]
  16 struct Sp1 {
  17     a: u16,
  18     b: [u8; 3],
  19 }
  20
  21 #[repr(packed(2))]
  22 struct Sp2 {
  23     a: u16,
  24     b: [u8; 3],
  25 }
  26
  27 union U {
  28     a: u16,
  29     b: [u8; 3],
  30 }
  31
  32 #[repr(packed)]
  33 union Up1 {
  34     a: u16,
  35     b: [u8; 3],
  36 }
  37
  38 #[repr(packed(2))]
  39 union Up2 {
  40     a: u16,
  41     b: [u8; 3],
  42 }
  43
  44 #[repr(C, packed(4))]
  45 union Up4c {
  46     a: u16,
  47     b: [u8; 3],
  48 }
  49
  50 const CS: S = S { a: 0, b: [0, 0, 0] };
  51 const CSP1: Sp1 = Sp1 { a: 0, b: [0, 0, 0] };
  52 const CSP2: Sp2 = Sp2 { a: 0, b: [0, 0, 0] };
  53 const CU: U = U { b: [0, 0, 0] };
  54 const CUP1: Up1 = Up1 { b: [0, 0, 0] };
  55 const CUP2: Up2 = Up2 { b: [0, 0, 0] };
  56 const CUP4C: Up4c = Up4c { b: [0, 0, 0] };
  57
  58 fn main() {
  59     let s = S { a: 0, b: [0, 0, 0] };
  60     assert_eq!(size_of::<S>(), 6);
  61     assert_eq!(size_of_val(&s), 6);
  62     assert_eq!(size_of_val(&CS), 6);
  63     assert_eq!(align_of::<S>(), 2);
  64     assert_eq!(align_of_val(&s), 2);
  65     assert_eq!(align_of_val(&CS), 2);
  66
  67     let sp1 = Sp1 { a: 0, b: [0, 0, 0] };
  68     assert_eq!(size_of::<Sp1>(), 5);
  69     assert_eq!(size_of_val(&sp1), 5);
  70     assert_eq!(size_of_val(&CSP1), 5);
  71     assert_eq!(align_of::<Sp1>(), 1);
  72     assert_eq!(align_of_val(&sp1), 1);
  73     assert_eq!(align_of_val(&CSP1), 1);
  74
  75     let sp2 = Sp2 { a: 0, b: [0, 0, 0] };
  76     assert_eq!(size_of::<Sp2>(), 6);
  77     assert_eq!(size_of_val(&sp2), 6);
  78     assert_eq!(size_of_val(&CSP2), 6);
  79     assert_eq!(align_of::<Sp2>(), 2);
  80     assert_eq!(align_of_val(&sp2), 2);
  81     assert_eq!(align_of_val(&CSP2), 2);
  82
  83     let u = U { b: [0, 0, 0] };
  84     assert_eq!(size_of::<U>(), 4);
  85     assert_eq!(size_of_val(&u), 4);
  86     assert_eq!(size_of_val(&CU), 4);
  87     assert_eq!(align_of::<U>(), 2);
  88     assert_eq!(align_of_val(&u), 2);
  89     assert_eq!(align_of_val(&CU), 2);
  90
  91     let Up1 = Up1 { b: [0, 0, 0] };
  92     assert_eq!(size_of::<Up1>(), 3);
  93     assert_eq!(size_of_val(&Up1), 3);
  94     assert_eq!(size_of_val(&CUP1), 3);
  95     assert_eq!(align_of::<Up1>(), 1);
  96     assert_eq!(align_of_val(&Up1), 1);
  97     assert_eq!(align_of_val(&CUP1), 1);
  98
  99     let up2 = Up2 { b: [0, 0, 0] };
 100     assert_eq!(size_of::<Up2>(), 4);
 101     assert_eq!(size_of_val(&up2), 4);
 102     assert_eq!(size_of_val(&CUP2), 4);
 103     assert_eq!(align_of::<Up2>(), 2);
 104     assert_eq!(align_of_val(&up2), 2);
 105     assert_eq!(align_of_val(&CUP2), 2);
 106
 107     let up4c = Up4c { b: [0, 0, 0] };
 108     assert_eq!(size_of::<Up4c>(), 4);
 109     assert_eq!(size_of_val(&up4c), 4);
 110     assert_eq!(size_of_val(&CUP4C), 4);
 111     assert_eq!(align_of::<Up4c>(), 2);
 112     assert_eq!(align_of_val(&up4c), 2);
 113     assert_eq!(align_of_val(&CUP4C), 2);
 114
 115     hybrid::check_hybrid();
 116 }
 117
 118 mod hybrid {
 119     use std::mem::{size_of, align_of};
 120
 121     #[repr(packed)]
 122     #[derive(Copy, Clone)]
 123     struct S1 {
 124         a: u16,
 125         b: u8,
 126     }
 127
 128     #[repr(packed)]
 129     union U {
 130         s: S1,
 131         c: u16,
 132     }
 133
 134     #[repr(packed)]
 135     struct S2 {
 136         d: u8,
 137         u: U,
 138     }
 139
 140     #[repr(C, packed(2))]
 141     struct S1C {
 142         a: u16,
 143         b: u8,
 144     }
 145
 146     #[repr(C, packed(2))]
 147     union UC {
 148         s: S1,
 149         c: u16,
 150     }
 151
 152     #[repr(C, packed(2))]
 153     struct S2C {
 154         d: u8,
 155         u: UC,
 156     }
 157
 158     pub fn check_hybrid() {
 159         assert_eq!(align_of::<S1>(), 1);
 160         assert_eq!(size_of::<S1>(), 3);
 161         assert_eq!(align_of::<U>(), 1);
 162         assert_eq!(size_of::<U>(), 3);
 163         assert_eq!(align_of::<S2>(), 1);
 164         assert_eq!(size_of::<S2>(), 4);
 165
 166         assert_eq!(align_of::<S1C>(), 2);
 167         assert_eq!(size_of::<S1C>(), 4);
 168         assert_eq!(align_of::<UC>(), 2);
 169         assert_eq!(size_of::<UC>(), 4);
 170         assert_eq!(align_of::<S2C>(), 2);
 171         assert_eq!(size_of::<S2C>(), 6);
 172     }
 173 }