]>
Commit | Line | Data |
---|---|---|
b7449926 | 1 | // run-pass |
0531ce1d | 2 | |
1a4d82fc | 3 | #![feature(intrinsics)] |
2b03887a | 4 | #![feature(rustc_attrs)] |
223e47cc LB |
5 | |
6 | mod rusti { | |
1a4d82fc | 7 | extern "rust-intrinsic" { |
2b03887a | 8 | #[rustc_safe_intrinsic] |
92a42be0 | 9 | pub fn ctpop<T>(x: T) -> T; |
2b03887a | 10 | #[rustc_safe_intrinsic] |
92a42be0 | 11 | pub fn ctlz<T>(x: T) -> T; |
041b39d2 | 12 | pub fn ctlz_nonzero<T>(x: T) -> T; |
2b03887a | 13 | #[rustc_safe_intrinsic] |
92a42be0 | 14 | pub fn cttz<T>(x: T) -> T; |
041b39d2 | 15 | pub fn cttz_nonzero<T>(x: T) -> T; |
2b03887a | 16 | #[rustc_safe_intrinsic] |
92a42be0 | 17 | pub fn bswap<T>(x: T) -> T; |
2b03887a | 18 | #[rustc_safe_intrinsic] |
0531ce1d | 19 | pub fn bitreverse<T>(x: T) -> T; |
223e47cc LB |
20 | } |
21 | } | |
22 | ||
23 | pub fn main() { | |
0731742a XL |
24 | use rusti::*; |
25 | ||
26 | assert_eq!(ctpop(0u8), 0); assert_eq!(ctpop(0i8), 0); | |
27 | assert_eq!(ctpop(0u16), 0); assert_eq!(ctpop(0i16), 0); | |
28 | assert_eq!(ctpop(0u32), 0); assert_eq!(ctpop(0i32), 0); | |
29 | assert_eq!(ctpop(0u64), 0); assert_eq!(ctpop(0i64), 0); | |
30 | assert_eq!(ctpop(0u128), 0); assert_eq!(ctpop(0i128), 0); | |
31 | ||
32 | assert_eq!(ctpop(1u8), 1); assert_eq!(ctpop(1i8), 1); | |
33 | assert_eq!(ctpop(1u16), 1); assert_eq!(ctpop(1i16), 1); | |
34 | assert_eq!(ctpop(1u32), 1); assert_eq!(ctpop(1i32), 1); | |
35 | assert_eq!(ctpop(1u64), 1); assert_eq!(ctpop(1i64), 1); | |
36 | assert_eq!(ctpop(1u128), 1); assert_eq!(ctpop(1i128), 1); | |
37 | ||
38 | assert_eq!(ctpop(10u8), 2); assert_eq!(ctpop(10i8), 2); | |
39 | assert_eq!(ctpop(10u16), 2); assert_eq!(ctpop(10i16), 2); | |
40 | assert_eq!(ctpop(10u32), 2); assert_eq!(ctpop(10i32), 2); | |
41 | assert_eq!(ctpop(10u64), 2); assert_eq!(ctpop(10i64), 2); | |
42 | assert_eq!(ctpop(10u128), 2); assert_eq!(ctpop(10i128), 2); | |
43 | ||
44 | assert_eq!(ctpop(100u8), 3); assert_eq!(ctpop(100i8), 3); | |
45 | assert_eq!(ctpop(100u16), 3); assert_eq!(ctpop(100i16), 3); | |
46 | assert_eq!(ctpop(100u32), 3); assert_eq!(ctpop(100i32), 3); | |
47 | assert_eq!(ctpop(100u64), 3); assert_eq!(ctpop(100i64), 3); | |
48 | assert_eq!(ctpop(100u128), 3); assert_eq!(ctpop(100i128), 3); | |
49 | ||
50 | assert_eq!(ctpop(-1i8 as u8), 8); assert_eq!(ctpop(-1i8), 8); | |
51 | assert_eq!(ctpop(-1i16 as u16), 16); assert_eq!(ctpop(-1i16), 16); | |
52 | assert_eq!(ctpop(-1i32 as u32), 32); assert_eq!(ctpop(-1i32), 32); | |
53 | assert_eq!(ctpop(-1i64 as u64), 64); assert_eq!(ctpop(-1i64), 64); | |
54 | assert_eq!(ctpop(-1i128 as u128), 128); assert_eq!(ctpop(-1i128), 128); | |
55 | ||
56 | assert_eq!(ctlz(0u8), 8); assert_eq!(ctlz(0i8), 8); | |
57 | assert_eq!(ctlz(0u16), 16); assert_eq!(ctlz(0i16), 16); | |
58 | assert_eq!(ctlz(0u32), 32); assert_eq!(ctlz(0i32), 32); | |
59 | assert_eq!(ctlz(0u64), 64); assert_eq!(ctlz(0i64), 64); | |
60 | assert_eq!(ctlz(0u128), 128); assert_eq!(ctlz(0i128), 128); | |
61 | ||
62 | assert_eq!(ctlz(1u8), 7); assert_eq!(ctlz(1i8), 7); | |
63 | assert_eq!(ctlz(1u16), 15); assert_eq!(ctlz(1i16), 15); | |
64 | assert_eq!(ctlz(1u32), 31); assert_eq!(ctlz(1i32), 31); | |
65 | assert_eq!(ctlz(1u64), 63); assert_eq!(ctlz(1i64), 63); | |
66 | assert_eq!(ctlz(1u128), 127); assert_eq!(ctlz(1i128), 127); | |
67 | ||
68 | assert_eq!(ctlz(10u8), 4); assert_eq!(ctlz(10i8), 4); | |
69 | assert_eq!(ctlz(10u16), 12); assert_eq!(ctlz(10i16), 12); | |
70 | assert_eq!(ctlz(10u32), 28); assert_eq!(ctlz(10i32), 28); | |
71 | assert_eq!(ctlz(10u64), 60); assert_eq!(ctlz(10i64), 60); | |
72 | assert_eq!(ctlz(10u128), 124); assert_eq!(ctlz(10i128), 124); | |
73 | ||
74 | assert_eq!(ctlz(100u8), 1); assert_eq!(ctlz(100i8), 1); | |
75 | assert_eq!(ctlz(100u16), 9); assert_eq!(ctlz(100i16), 9); | |
76 | assert_eq!(ctlz(100u32), 25); assert_eq!(ctlz(100i32), 25); | |
77 | assert_eq!(ctlz(100u64), 57); assert_eq!(ctlz(100i64), 57); | |
78 | assert_eq!(ctlz(100u128), 121); assert_eq!(ctlz(100i128), 121); | |
92a42be0 | 79 | |
0731742a | 80 | unsafe { |
041b39d2 XL |
81 | assert_eq!(ctlz_nonzero(1u8), 7); assert_eq!(ctlz_nonzero(1i8), 7); |
82 | assert_eq!(ctlz_nonzero(1u16), 15); assert_eq!(ctlz_nonzero(1i16), 15); | |
83 | assert_eq!(ctlz_nonzero(1u32), 31); assert_eq!(ctlz_nonzero(1i32), 31); | |
84 | assert_eq!(ctlz_nonzero(1u64), 63); assert_eq!(ctlz_nonzero(1i64), 63); | |
0531ce1d | 85 | assert_eq!(ctlz_nonzero(1u128), 127); assert_eq!(ctlz_nonzero(1i128), 127); |
041b39d2 XL |
86 | |
87 | assert_eq!(ctlz_nonzero(10u8), 4); assert_eq!(ctlz_nonzero(10i8), 4); | |
88 | assert_eq!(ctlz_nonzero(10u16), 12); assert_eq!(ctlz_nonzero(10i16), 12); | |
89 | assert_eq!(ctlz_nonzero(10u32), 28); assert_eq!(ctlz_nonzero(10i32), 28); | |
90 | assert_eq!(ctlz_nonzero(10u64), 60); assert_eq!(ctlz_nonzero(10i64), 60); | |
0531ce1d | 91 | assert_eq!(ctlz_nonzero(10u128), 124); assert_eq!(ctlz_nonzero(10i128), 124); |
041b39d2 XL |
92 | |
93 | assert_eq!(ctlz_nonzero(100u8), 1); assert_eq!(ctlz_nonzero(100i8), 1); | |
94 | assert_eq!(ctlz_nonzero(100u16), 9); assert_eq!(ctlz_nonzero(100i16), 9); | |
95 | assert_eq!(ctlz_nonzero(100u32), 25); assert_eq!(ctlz_nonzero(100i32), 25); | |
96 | assert_eq!(ctlz_nonzero(100u64), 57); assert_eq!(ctlz_nonzero(100i64), 57); | |
0531ce1d | 97 | assert_eq!(ctlz_nonzero(100u128), 121); assert_eq!(ctlz_nonzero(100i128), 121); |
0731742a | 98 | } |
041b39d2 | 99 | |
0731742a XL |
100 | assert_eq!(cttz(-1i8 as u8), 0); assert_eq!(cttz(-1i8), 0); |
101 | assert_eq!(cttz(-1i16 as u16), 0); assert_eq!(cttz(-1i16), 0); | |
102 | assert_eq!(cttz(-1i32 as u32), 0); assert_eq!(cttz(-1i32), 0); | |
103 | assert_eq!(cttz(-1i64 as u64), 0); assert_eq!(cttz(-1i64), 0); | |
104 | assert_eq!(cttz(-1i128 as u128), 0); assert_eq!(cttz(-1i128), 0); | |
105 | ||
106 | assert_eq!(cttz(0u8), 8); assert_eq!(cttz(0i8), 8); | |
107 | assert_eq!(cttz(0u16), 16); assert_eq!(cttz(0i16), 16); | |
108 | assert_eq!(cttz(0u32), 32); assert_eq!(cttz(0i32), 32); | |
109 | assert_eq!(cttz(0u64), 64); assert_eq!(cttz(0i64), 64); | |
110 | assert_eq!(cttz(0u128), 128); assert_eq!(cttz(0i128), 128); | |
111 | ||
112 | assert_eq!(cttz(1u8), 0); assert_eq!(cttz(1i8), 0); | |
113 | assert_eq!(cttz(1u16), 0); assert_eq!(cttz(1i16), 0); | |
114 | assert_eq!(cttz(1u32), 0); assert_eq!(cttz(1i32), 0); | |
115 | assert_eq!(cttz(1u64), 0); assert_eq!(cttz(1i64), 0); | |
116 | assert_eq!(cttz(1u128), 0); assert_eq!(cttz(1i128), 0); | |
117 | ||
118 | assert_eq!(cttz(10u8), 1); assert_eq!(cttz(10i8), 1); | |
119 | assert_eq!(cttz(10u16), 1); assert_eq!(cttz(10i16), 1); | |
120 | assert_eq!(cttz(10u32), 1); assert_eq!(cttz(10i32), 1); | |
121 | assert_eq!(cttz(10u64), 1); assert_eq!(cttz(10i64), 1); | |
122 | assert_eq!(cttz(10u128), 1); assert_eq!(cttz(10i128), 1); | |
123 | ||
124 | assert_eq!(cttz(100u8), 2); assert_eq!(cttz(100i8), 2); | |
125 | assert_eq!(cttz(100u16), 2); assert_eq!(cttz(100i16), 2); | |
126 | assert_eq!(cttz(100u32), 2); assert_eq!(cttz(100i32), 2); | |
127 | assert_eq!(cttz(100u64), 2); assert_eq!(cttz(100i64), 2); | |
128 | assert_eq!(cttz(100u128), 2); assert_eq!(cttz(100i128), 2); | |
92a42be0 | 129 | |
0731742a | 130 | unsafe { |
041b39d2 XL |
131 | assert_eq!(cttz_nonzero(-1i8 as u8), 0); assert_eq!(cttz_nonzero(-1i8), 0); |
132 | assert_eq!(cttz_nonzero(-1i16 as u16), 0); assert_eq!(cttz_nonzero(-1i16), 0); | |
133 | assert_eq!(cttz_nonzero(-1i32 as u32), 0); assert_eq!(cttz_nonzero(-1i32), 0); | |
134 | assert_eq!(cttz_nonzero(-1i64 as u64), 0); assert_eq!(cttz_nonzero(-1i64), 0); | |
0531ce1d | 135 | assert_eq!(cttz_nonzero(-1i128 as u128), 0); assert_eq!(cttz_nonzero(-1i128), 0); |
041b39d2 XL |
136 | |
137 | assert_eq!(cttz_nonzero(1u8), 0); assert_eq!(cttz_nonzero(1i8), 0); | |
138 | assert_eq!(cttz_nonzero(1u16), 0); assert_eq!(cttz_nonzero(1i16), 0); | |
139 | assert_eq!(cttz_nonzero(1u32), 0); assert_eq!(cttz_nonzero(1i32), 0); | |
140 | assert_eq!(cttz_nonzero(1u64), 0); assert_eq!(cttz_nonzero(1i64), 0); | |
0531ce1d | 141 | assert_eq!(cttz_nonzero(1u128), 0); assert_eq!(cttz_nonzero(1i128), 0); |
041b39d2 XL |
142 | |
143 | assert_eq!(cttz_nonzero(10u8), 1); assert_eq!(cttz_nonzero(10i8), 1); | |
144 | assert_eq!(cttz_nonzero(10u16), 1); assert_eq!(cttz_nonzero(10i16), 1); | |
145 | assert_eq!(cttz_nonzero(10u32), 1); assert_eq!(cttz_nonzero(10i32), 1); | |
146 | assert_eq!(cttz_nonzero(10u64), 1); assert_eq!(cttz_nonzero(10i64), 1); | |
0531ce1d | 147 | assert_eq!(cttz_nonzero(10u128), 1); assert_eq!(cttz_nonzero(10i128), 1); |
041b39d2 XL |
148 | |
149 | assert_eq!(cttz_nonzero(100u8), 2); assert_eq!(cttz_nonzero(100i8), 2); | |
150 | assert_eq!(cttz_nonzero(100u16), 2); assert_eq!(cttz_nonzero(100i16), 2); | |
151 | assert_eq!(cttz_nonzero(100u32), 2); assert_eq!(cttz_nonzero(100i32), 2); | |
152 | assert_eq!(cttz_nonzero(100u64), 2); assert_eq!(cttz_nonzero(100i64), 2); | |
0531ce1d | 153 | assert_eq!(cttz_nonzero(100u128), 2); assert_eq!(cttz_nonzero(100i128), 2); |
223e47cc | 154 | } |
0731742a XL |
155 | |
156 | assert_eq!(bswap(0x0Au8), 0x0A); // no-op | |
157 | assert_eq!(bswap(0x0Ai8), 0x0A); // no-op | |
158 | assert_eq!(bswap(0x0A0Bu16), 0x0B0A); | |
159 | assert_eq!(bswap(0x0A0Bi16), 0x0B0A); | |
160 | assert_eq!(bswap(0x0ABBCC0Du32), 0x0DCCBB0A); | |
161 | assert_eq!(bswap(0x0ABBCC0Di32), 0x0DCCBB0A); | |
162 | assert_eq!(bswap(0x0122334455667708u64), 0x0877665544332201); | |
163 | assert_eq!(bswap(0x0122334455667708i64), 0x0877665544332201); | |
164 | assert_eq!(bswap(0x0122334455667708u128), 0x08776655443322010000000000000000); | |
165 | assert_eq!(bswap(0x0122334455667708i128), 0x08776655443322010000000000000000); | |
166 | ||
167 | assert_eq!(bitreverse(0x0Au8), 0x50); | |
168 | assert_eq!(bitreverse(0x0Ai8), 0x50); | |
169 | assert_eq!(bitreverse(0x0A0Cu16), 0x3050); | |
170 | assert_eq!(bitreverse(0x0A0Ci16), 0x3050); | |
171 | assert_eq!(bitreverse(0x0ABBCC0Eu32), 0x7033DD50); | |
172 | assert_eq!(bitreverse(0x0ABBCC0Ei32), 0x7033DD50); | |
173 | assert_eq!(bitreverse(0x0122334455667708u64), 0x10EE66AA22CC4480); | |
174 | assert_eq!(bitreverse(0x0122334455667708i64), 0x10EE66AA22CC4480); | |
175 | assert_eq!(bitreverse(0x0122334455667708u128), 0x10EE66AA22CC44800000000000000000); | |
176 | assert_eq!(bitreverse(0x0122334455667708i128), 0x10EE66AA22CC44800000000000000000); | |
223e47cc | 177 | } |