Fix trace-collection.h: No such file or directory that build code with libbabeltrace
[babeltrace.git] / tests / test-bitfield.c
CommitLineData
6dc2ca62
MD
1/*
2 * test-bitfield.c
3 *
d79865b9 4 * BabelTrace - bitfield test program
6dc2ca62 5 *
de0ba614 6 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6dc2ca62
MD
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
9cb421e5 10 * the Free Software Foundation; under version 2 of the License.
6dc2ca62
MD
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22#define _GNU_SOURCE
d79865b9 23#include <babeltrace/bitfield.h>
47e0f2e2
MD
24#include <time.h>
25#include <stdlib.h>
6dc2ca62
MD
26#include <stdio.h>
27
28unsigned int glob;
29
30/*
31 * This function is only declared to show the size of a bitfield write in
32 * objdump.
33 */
34void fct(void)
35{
47e0f2e2 36 bt_bitfield_write(&glob, unsigned int, 12, 15, 0x12345678);
6dc2ca62
MD
37}
38
39/* Test array size, in bytes */
40#define TEST_LEN 128
41#define NR_TESTS 10
42
43unsigned int srcrand;
44
45#if defined(__i386) || defined(__x86_64)
46
47static inline int fls(int x)
48{
49 int r;
50 asm("bsrl %1,%0\n\t"
51 "cmovzl %2,%0"
52 : "=&r" (r) : "rm" (x), "rm" (-1));
53 return r + 1;
54}
55
56#elif defined(__PPC__)
57
58static __inline__ int fls(unsigned int x)
59{
60 int lz;
61
62 asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
63 return 32 - lz;
64}
65
66#else
67
68static int fls(unsigned int x)
69{
70 int r = 32;
71
72 if (!x)
73 return 0;
74 if (!(x & 0xFFFF0000U)) {
75 x <<= 16;
76 r -= 16;
77 }
78 if (!(x & 0xFF000000U)) {
79 x <<= 8;
80 r -= 8;
81 }
82 if (!(x & 0xF0000000U)) {
83 x <<= 4;
84 r -= 4;
85 }
86 if (!(x & 0xC0000000U)) {
87 x <<= 2;
88 r -= 2;
89 }
90 if (!(x & 0x80000000U)) {
91 x <<= 1;
92 r -= 1;
93 }
94 return r;
95}
96
97#endif
98
47e0f2e2
MD
99#define print_byte_array(c, len) \
100do { \
101 unsigned long i; \
102 \
103 for (i = 0; i < (len); i++) { \
104 printf("0x%X", (c)[i]); \
105 if (i != (len) - 1) \
106 printf(" "); \
107 } \
108 printf("\n"); \
109} while (0)
110
111#define init_byte_array(c, len, val) \
112do { \
113 unsigned long i; \
114 \
115 for (i = 0; i < (len); i++) \
116 (c)[i] = (val); \
117} while (0)
6dc2ca62
MD
118
119int run_test_unsigned(void)
120{
e6c404d1 121 unsigned int src, nrbits;
6dc2ca62
MD
122 union {
123 unsigned char c[TEST_LEN];
124 unsigned short s[TEST_LEN/sizeof(unsigned short)];
125 unsigned int i[TEST_LEN/sizeof(unsigned int)];
126 unsigned long l[TEST_LEN/sizeof(unsigned long)];
127 unsigned long long ll[TEST_LEN/sizeof(unsigned long long)];
128 } target;
380d60b1 129 unsigned long long readval;
6dc2ca62
MD
130 unsigned int s, l;
131 int err = 0;
132
133 printf("Running unsigned test with 0x%X\n", srcrand);
134
135 src = srcrand;
136 nrbits = fls(src);
137
138 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
139 for (l = nrbits; l < (CHAR_BIT * TEST_LEN) - s; l++) {
140 init_byte_array(target.c, TEST_LEN, 0xFF);
47e0f2e2
MD
141 bt_bitfield_write(target.c, unsigned char, s, l, src);
142 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
6dc2ca62 143 if (readval != src) {
e6c404d1 144 printf("Error (bytewise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
145 src, readval, s, l);
146 print_byte_array(target.c, TEST_LEN);
147 err = 1;
148 }
149
150 init_byte_array(target.c, TEST_LEN, 0xFF);
47e0f2e2
MD
151 bt_bitfield_write(target.s, unsigned short, s, l, src);
152 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
6dc2ca62 153 if (readval != src) {
e6c404d1 154 printf("Error (shortwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
155 src, readval, s, l);
156 print_byte_array(target.c, TEST_LEN);
157 err = 1;
158 }
159
160 init_byte_array(target.c, TEST_LEN, 0xFF);
47e0f2e2
MD
161 bt_bitfield_write(target.i, unsigned int, s, l, src);
162 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
6dc2ca62 163 if (readval != src) {
e6c404d1 164 printf("Error (intwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
165 src, readval, s, l);
166 print_byte_array(target.c, TEST_LEN);
167 err = 1;
168 }
169
170 init_byte_array(target.c, TEST_LEN, 0xFF);
47e0f2e2
MD
171 bt_bitfield_write(target.l, unsigned long, s, l, src);
172 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
6dc2ca62 173 if (readval != src) {
e6c404d1 174 printf("Error (longwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
175 src, readval, s, l);
176 print_byte_array(target.c, TEST_LEN);
177 err = 1;
178 }
179
180 init_byte_array(target.c, TEST_LEN, 0xFF);
47e0f2e2
MD
181 bt_bitfield_write(target.ll, unsigned long long, s, l, src);
182 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
6dc2ca62 183 if (readval != src) {
e6c404d1 184 printf("Error (longlongwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
185 src, readval, s, l);
186 print_byte_array(target.c, TEST_LEN);
187 err = 1;
188 }
189 }
190 }
191 if (!err)
192 printf("Success!\n");
193 else
194 printf("Failed!\n");
195 return err;
196}
197
198int run_test_signed(void)
199{
e6c404d1 200 int src, nrbits;
6dc2ca62 201 union {
47e0f2e2 202 signed char c[TEST_LEN];
6dc2ca62
MD
203 short s[TEST_LEN/sizeof(short)];
204 int i[TEST_LEN/sizeof(int)];
205 long l[TEST_LEN/sizeof(long)];
206 long long ll[TEST_LEN/sizeof(long long)];
207 } target;
380d60b1 208 long long readval;
6dc2ca62
MD
209 unsigned int s, l;
210 int err = 0;
211
212 printf("Running signed test with 0x%X\n", srcrand);
213
214 src = srcrand;
215 if (src & 0x80000000U)
216 nrbits = fls(~src) + 1; /* Find least significant bit conveying sign */
217 else
218 nrbits = fls(src) + 1; /* Keep sign at 0 */
219
220 for (s = 0; s < 8 * TEST_LEN; s++) {
221 for (l = nrbits; l < (8 * TEST_LEN) - s; l++) {
222 init_byte_array(target.c, TEST_LEN, 0x0);
47e0f2e2
MD
223 bt_bitfield_write(target.c, signed char, s, l, src);
224 bt_bitfield_read(target.c, signed char, s, l, &readval);
6dc2ca62 225 if (readval != src) {
e6c404d1 226 printf("Error (bytewise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
227 src, readval, s, l);
228 print_byte_array(target.c, TEST_LEN);
229 err = 1;
230 }
231
232 init_byte_array(target.c, TEST_LEN, 0x0);
47e0f2e2
MD
233 bt_bitfield_write(target.s, short, s, l, src);
234 bt_bitfield_read(target.c, signed char, s, l, &readval);
6dc2ca62 235 if (readval != src) {
e6c404d1 236 printf("Error (shortwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
237 src, readval, s, l);
238 print_byte_array(target.c, TEST_LEN);
239 err = 1;
240 }
241
242 init_byte_array(target.c, TEST_LEN, 0x0);
47e0f2e2
MD
243 bt_bitfield_write(target.i, int, s, l, src);
244 bt_bitfield_read(target.c, signed char, s, l, &readval);
6dc2ca62 245 if (readval != src) {
e6c404d1 246 printf("Error (intwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
247 src, readval, s, l);
248 print_byte_array(target.c, TEST_LEN);
249 err = 1;
250 }
251
252 init_byte_array(target.c, TEST_LEN, 0x0);
47e0f2e2
MD
253 bt_bitfield_write(target.l, long, s, l, src);
254 bt_bitfield_read(target.c, signed char, s, l, &readval);
6dc2ca62 255 if (readval != src) {
e6c404d1 256 printf("Error (longwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
257 src, readval, s, l);
258 print_byte_array(target.c, TEST_LEN);
259 err = 1;
260 }
261
262 init_byte_array(target.c, TEST_LEN, 0x0);
47e0f2e2
MD
263 bt_bitfield_write(target.ll, long long, s, l, src);
264 bt_bitfield_read(target.c, signed char, s, l, &readval);
6dc2ca62 265 if (readval != src) {
e6c404d1 266 printf("Error (longlongwise) src %X read %llX shift %d len %d\n",
6dc2ca62
MD
267 src, readval, s, l);
268 print_byte_array(target.c, TEST_LEN);
269 err = 1;
270 }
271 }
272 }
273 if (!err)
274 printf("Success!\n");
275 else
276 printf("Failed!\n");
277 return err;
278}
279
280int run_test(void)
281{
282 int err = 0;
283 int i;
284
285 srand(time(NULL));
286
287 srcrand = 0;
288 err |= run_test_unsigned();
289 srcrand = 0;
290 err |= run_test_signed();
291 srcrand = 1;
292 err |= run_test_unsigned();
293 srcrand = ~0U;
294 err |= run_test_unsigned();
295 srcrand = -1;
296 err |= run_test_signed();
297 srcrand = (int)0x80000000U;
298 err |= run_test_signed();
299
300 for (i = 0; i < NR_TESTS; i++) {
301 srcrand = rand();
302 err |= run_test_unsigned();
303 err |= run_test_signed();
304 }
305 return err;
306}
307
308int main(int argc, char **argv)
309{
310 unsigned long src;
311 unsigned int shift, len;
312 int ret;
313 union {
314 unsigned char c[8];
315 unsigned short s[4];
316 unsigned int i[2];
317 unsigned long l[2];
318 unsigned long long ll[1];
319 } target;
380d60b1 320 unsigned long long readval;
6dc2ca62
MD
321
322 if (argc > 1)
323 src = atoi(argv[1]);
324 else
325 src = 0x12345678;
326 if (argc > 2)
327 shift = atoi(argv[2]);
328 else
329 shift = 12;
330 if (argc > 3)
331 len = atoi(argv[3]);
332 else
333 len = 40;
334
335 target.i[0] = 0xFFFFFFFF;
336 target.i[1] = 0xFFFFFFFF;
47e0f2e2 337 bt_bitfield_write(target.c, unsigned char, shift, len, src);
6dc2ca62
MD
338 printf("bytewise\n");
339 print_byte_array(target.c, 8);
340
341 target.i[0] = 0xFFFFFFFF;
342 target.i[1] = 0xFFFFFFFF;
47e0f2e2 343 bt_bitfield_write(target.s, unsigned short, shift, len, src);
6dc2ca62
MD
344 printf("shortwise\n");
345 print_byte_array(target.c, 8);
346
347 target.i[0] = 0xFFFFFFFF;
348 target.i[1] = 0xFFFFFFFF;
47e0f2e2 349 bt_bitfield_write(target.i, unsigned int, shift, len, src);
6dc2ca62
MD
350 printf("intwise\n");
351 print_byte_array(target.c, 8);
352
353 target.i[0] = 0xFFFFFFFF;
354 target.i[1] = 0xFFFFFFFF;
47e0f2e2 355 bt_bitfield_write(target.l, unsigned long, shift, len, src);
6dc2ca62
MD
356 printf("longwise\n");
357 print_byte_array(target.c, 8);
358
359 target.i[0] = 0xFFFFFFFF;
360 target.i[1] = 0xFFFFFFFF;
47e0f2e2 361 bt_bitfield_write(target.ll, unsigned long long, shift, len, src);
6dc2ca62
MD
362 printf("lluwise\n");
363 print_byte_array(target.c, 8);
364
47e0f2e2 365 bt_bitfield_read(target.c, unsigned char, shift, len, &readval);
6dc2ca62
MD
366 printf("read: %llX\n", readval);
367
368 ret = run_test();
369
370 return ret;
371}
This page took 0.06215 seconds and 4 git commands to generate.