2 // revisions: mirunsafeck thirunsafeck
3 // [thirunsafeck]compile-flags: -Z thir-unsafeck
6 #![allow(non_snake_case)]
8 use std::mem::{size_of, size_of_val, align_of, align_of_val};
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] };
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);
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);
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);
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);
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);
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);
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);
115 hybrid::check_hybrid();
119 use std::mem::{size_of, align_of};
122 #[derive(Copy, Clone)]
140 #[repr(C, packed(2))]
146 #[repr(C, packed(2))]
152 #[repr(C, packed(2))]
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);
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);