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

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