]>
Commit | Line | Data |
---|---|---|
b7449926 | 1 | // run-pass |
136023e0 XL |
2 | // revisions: mirunsafeck thirunsafeck |
3 | // [thirunsafeck]compile-flags: -Z thir-unsafeck | |
4 | ||
0bf4aa26 | 5 | #![allow(dead_code)] |
b7449926 XL |
6 | #![allow(non_snake_case)] |
7 | ||
9e0c209e SL |
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)] | |
83c7162d XL |
16 | struct Sp1 { |
17 | a: u16, | |
18 | b: [u8; 3], | |
19 | } | |
20 | ||
21 | #[repr(packed(2))] | |
22 | struct Sp2 { | |
9e0c209e SL |
23 | a: u16, |
24 | b: [u8; 3], | |
25 | } | |
26 | ||
27 | union U { | |
28 | a: u16, | |
29 | b: [u8; 3], | |
30 | } | |
31 | ||
32 | #[repr(packed)] | |
83c7162d XL |
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 { | |
9e0c209e SL |
46 | a: u16, |
47 | b: [u8; 3], | |
48 | } | |
49 | ||
50 | const CS: S = S { a: 0, b: [0, 0, 0] }; | |
83c7162d XL |
51 | const CSP1: Sp1 = Sp1 { a: 0, b: [0, 0, 0] }; |
52 | const CSP2: Sp2 = Sp2 { a: 0, b: [0, 0, 0] }; | |
9e0c209e | 53 | const CU: U = U { b: [0, 0, 0] }; |
83c7162d XL |
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] }; | |
9e0c209e SL |
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 | ||
83c7162d XL |
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); | |
9e0c209e SL |
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 | ||
83c7162d XL |
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); | |
9e0c209e SL |
114 | |
115 | hybrid::check_hybrid(); | |
116 | } | |
117 | ||
118 | mod hybrid { | |
83c7162d | 119 | use std::mem::{size_of, align_of}; |
9e0c209e SL |
120 | |
121 | #[repr(packed)] | |
29967ef6 | 122 | #[derive(Copy, Clone)] |
9e0c209e SL |
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 | ||
83c7162d XL |
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 | ||
9e0c209e | 158 | pub fn check_hybrid() { |
83c7162d | 159 | assert_eq!(align_of::<S1>(), 1); |
9e0c209e | 160 | assert_eq!(size_of::<S1>(), 3); |
83c7162d | 161 | assert_eq!(align_of::<U>(), 1); |
9e0c209e | 162 | assert_eq!(size_of::<U>(), 3); |
83c7162d | 163 | assert_eq!(align_of::<S2>(), 1); |
9e0c209e | 164 | assert_eq!(size_of::<S2>(), 4); |
83c7162d XL |
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); | |
9e0c209e SL |
172 | } |
173 | } |