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

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