1 // run-pass
2 #![allow(dead_code)]
3
4 use std::mem::{size_of, align_of};
5
6 #[repr(i8)]
7 enum Ei8 {
8 Ai8 = 0,
9 Bi8 = 1
10 }
11
12 #[repr(u8)]
13 enum Eu8 {
14 Au8 = 0,
15 Bu8 = 1
16 }
17
18 #[repr(i16)]
19 enum Ei16 {
20 Ai16 = 0,
21 Bi16 = 1
22 }
23
24 #[repr(u16)]
25 enum Eu16 {
26 Au16 = 0,
27 Bu16 = 1
28 }
29
30 #[repr(i32)]
31 enum Ei32 {
32 Ai32 = 0,
33 Bi32 = 1
34 }
35
36 #[repr(u32)]
37 enum Eu32 {
38 Au32 = 0,
39 Bu32 = 1
40 }
41
42 #[repr(i64)]
43 enum Ei64 {
44 Ai64 = 0,
45 Bi64 = 1
46 }
47
48 #[repr(u64)]
49 enum Eu64 {
50 Au64 = 0,
51 Bu64 = 1
52 }
53
54 #[repr(isize)]
55 enum Eint {
56 Aint = 0,
57 Bint = 1
58 }
59
60 #[repr(usize)]
61 enum Euint {
62 Auint = 0,
63 Buint = 1
64 }
65
66 #[repr(u8)]
67 enum Eu8NonCLike<T> {
68 _None,
69 _Some(T),
70 }
71
72 #[repr(i64)]
73 enum Ei64NonCLike<T> {
74 _None,
75 _Some(T),
76 }
77
78 #[repr(u64)]
79 enum Eu64NonCLike<T> {
80 _None,
81 _Some(T),
82 }
83
main()84 pub fn main() {
85 assert_eq!(size_of::<Ei8>(), 1);
86 assert_eq!(size_of::<Eu8>(), 1);
87 assert_eq!(size_of::<Ei16>(), 2);
88 assert_eq!(size_of::<Eu16>(), 2);
89 assert_eq!(size_of::<Ei32>(), 4);
90 assert_eq!(size_of::<Eu32>(), 4);
91 assert_eq!(size_of::<Ei64>(), 8);
92 assert_eq!(size_of::<Eu64>(), 8);
93 assert_eq!(size_of::<Eint>(), size_of::<isize>());
94 assert_eq!(size_of::<Euint>(), size_of::<usize>());
95 assert_eq!(size_of::<Eu8NonCLike<()>>(), 1);
96 assert_eq!(size_of::<Ei64NonCLike<()>>(), 8);
97 assert_eq!(size_of::<Eu64NonCLike<()>>(), 8);
98 let u8_expected_size = round_up(9, align_of::<Eu64NonCLike<u8>>());
99 assert_eq!(size_of::<Eu64NonCLike<u8>>(), u8_expected_size);
100 let array_expected_size = round_up(28, align_of::<Eu64NonCLike<[u32; 5]>>());
101 assert_eq!(size_of::<Eu64NonCLike<[u32; 5]>>(), array_expected_size);
102 assert_eq!(size_of::<Eu64NonCLike<[u32; 6]>>(), 32);
103
104 assert_eq!(align_of::<Eu32>(), align_of::<u32>());
105 assert_eq!(align_of::<Eu64NonCLike<u8>>(), align_of::<u64>());
106 }
107
108 // Rounds x up to the next multiple of a
round_up(x: usize, a: usize) -> usize109 fn round_up(x: usize, a: usize) -> usize {
110 ((x + (a - 1)) / a) * a
111 }
112