[babeltrace.git] / tests / test-bitfield.c

/*
 * test-bitfield.c
 *
 * Common Trace Format - bitfield test program
 *
 * Copyright February 2009 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#define _GNU_SOURCE
#include <ctf/bitfield.h>
#include <stdio.h>

unsigned int glob;

/*
 * This function is only declared to show the size of a bitfield write in
 * objdump.
 */
void fct(void)
{
	ctf_bitfield_write(&glob, 12, 15, 0x12345678);
}

/* Test array size, in bytes */
#define TEST_LEN 128
#define NR_TESTS 10

unsigned int srcrand;

#if defined(__i386) || defined(__x86_64)

static inline int fls(int x)
{
	int r;
	asm("bsrl %1,%0\n\t"
	    "cmovzl %2,%0"
	    : "=&r" (r) : "rm" (x), "rm" (-1));
	return r + 1;
}

#elif defined(__PPC__)

static __inline__ int fls(unsigned int x)
{
	int lz;

	asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
	return 32 - lz;
}

#else

static int fls(unsigned int x)
{
	int r = 32;

	if (!x)
		return 0;
	if (!(x & 0xFFFF0000U)) {
		x <<= 16;
		r -= 16;
	}
	if (!(x & 0xFF000000U)) {
		x <<= 8;
		r -= 8;
	}
	if (!(x & 0xF0000000U)) {
		x <<= 4;
		r -= 4;
	}
	if (!(x & 0xC0000000U)) {
		x <<= 2;
		r -= 2;
	}
	if (!(x & 0x80000000U)) {
		x <<= 1;
		r -= 1;
	}
	return r;
}

#endif

static void print_byte_array(const unsigned char *c, unsigned long len)
{
	unsigned long i;

	for (i = 0; i < len; i++) {
		printf("0x%X", c[i]);
		if (i != len - 1)
			printf(" ");
	}
	printf("\n");
}

static void init_byte_array(unsigned char *c,
			    unsigned long len,
			    unsigned char val)
{
	unsigned long i;

	for (i = 0; i < len; i++)
		c[i] = val;
}

int run_test_unsigned(void)
{
	unsigned int src, nrbits;
	union {
		unsigned char c[TEST_LEN];
		unsigned short s[TEST_LEN/sizeof(unsigned short)];
		unsigned int i[TEST_LEN/sizeof(unsigned int)];
		unsigned long l[TEST_LEN/sizeof(unsigned long)];
		unsigned long long ll[TEST_LEN/sizeof(unsigned long long)];
	} target;
	uint64_t readval;
	unsigned int s, l;
	int err = 0;

	printf("Running unsigned test with 0x%X\n", srcrand);

	src = srcrand;
	nrbits = fls(src);

	for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
		for (l = nrbits; l < (CHAR_BIT * TEST_LEN) - s; l++) {
			init_byte_array(target.c, TEST_LEN, 0xFF);
			ctf_bitfield_write(target.c, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 0);
			if (readval != src) {
				printf("Error (bytewise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0xFF);
			ctf_bitfield_write(target.s, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 0);
			if (readval != src) {
				printf("Error (shortwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0xFF);
			ctf_bitfield_write(target.i, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 0);
			if (readval != src) {
				printf("Error (intwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0xFF);
			ctf_bitfield_write(target.l, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 0);
			if (readval != src) {
				printf("Error (longwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0xFF);
			ctf_bitfield_write(target.ll, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 0);
			if (readval != src) {
				printf("Error (longlongwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}
		}
	}
	if (!err)
		printf("Success!\n");
	else
		printf("Failed!\n");
	return err;
}

int run_test_signed(void)
{
	int src, nrbits;
	union {
		char c[TEST_LEN];
		short s[TEST_LEN/sizeof(short)];
		int i[TEST_LEN/sizeof(int)];
		long l[TEST_LEN/sizeof(long)];
		long long ll[TEST_LEN/sizeof(long long)];
	} target;
	int64_t readval;
	unsigned int s, l;
	int err = 0;

	printf("Running signed test with 0x%X\n", srcrand);

	src = srcrand;
	if (src & 0x80000000U)
		nrbits = fls(~src) + 1;	/* Find least significant bit conveying sign */
	else
		nrbits = fls(src) + 1;	/* Keep sign at 0 */

	for (s = 0; s < 8 * TEST_LEN; s++) {
		for (l = nrbits; l < (8 * TEST_LEN) - s; l++) {
			init_byte_array(target.c, TEST_LEN, 0x0);
			ctf_bitfield_write(target.c, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 1);
			if (readval != src) {
				printf("Error (bytewise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0x0);
			ctf_bitfield_write(target.s, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 1);
			if (readval != src) {
				printf("Error (shortwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0x0);
			ctf_bitfield_write(target.i, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 1);
			if (readval != src) {
				printf("Error (intwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0x0);
			ctf_bitfield_write(target.l, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 1);
			if (readval != src) {
				printf("Error (longwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}

			init_byte_array(target.c, TEST_LEN, 0x0);
			ctf_bitfield_write(target.ll, s, l, src);
			readval = _ctf_bitfield_read_64(target.c, s, l, BYTE_ORDER, 1);
			if (readval != src) {
				printf("Error (longlongwise) src %lX read %llX shift %d len %d\n",
				       src, readval, s, l);
				print_byte_array(target.c, TEST_LEN);
				err = 1;
			}
		}
	}
	if (!err)
		printf("Success!\n");
	else
		printf("Failed!\n");
	return err;
}

int run_test(void)
{
	int err = 0;
	int i;

	srand(time(NULL));

	srcrand = 0;
	err |= run_test_unsigned();
	srcrand = 0;
	err |= run_test_signed();
	srcrand = 1;
	err |= run_test_unsigned();
	srcrand = ~0U;
	err |= run_test_unsigned();
	srcrand = -1;
	err |= run_test_signed();
	srcrand = (int)0x80000000U;
	err |= run_test_signed();

	for (i = 0; i < NR_TESTS; i++) {
		srcrand = rand();
		err |= run_test_unsigned();
		err |= run_test_signed();
	}
	return err;
}

int main(int argc, char **argv)
{
	unsigned long src;
	unsigned int shift, len;
	int ret;
	union {
		unsigned char c[8];
		unsigned short s[4];
		unsigned int i[2];
		unsigned long l[2];
		unsigned long long ll[1];
	} target;
	uint64_t readval;

	if (argc > 1)
		src = atoi(argv[1]);
	else
		src = 0x12345678;
	if (argc > 2)
		shift = atoi(argv[2]);
	else
		shift = 12;
	if (argc > 3)
		len = atoi(argv[3]);
	else
		len = 40;

	target.i[0] = 0xFFFFFFFF;
	target.i[1] = 0xFFFFFFFF;
	ctf_bitfield_write(target.c, shift, len, src);
	printf("bytewise\n");
	print_byte_array(target.c, 8);

	target.i[0] = 0xFFFFFFFF;
	target.i[1] = 0xFFFFFFFF;
	ctf_bitfield_write(target.s, shift, len, src);
	printf("shortwise\n");
	print_byte_array(target.c, 8);

	target.i[0] = 0xFFFFFFFF;
	target.i[1] = 0xFFFFFFFF;
	ctf_bitfield_write(target.i, shift, len, src);
	printf("intwise\n");
	print_byte_array(target.c, 8);

	target.i[0] = 0xFFFFFFFF;
	target.i[1] = 0xFFFFFFFF;
	ctf_bitfield_write(target.l, shift, len, src);
	printf("longwise\n");
	print_byte_array(target.c, 8);

	target.i[0] = 0xFFFFFFFF;
	target.i[1] = 0xFFFFFFFF;
	ctf_bitfield_write(target.ll, shift, len, src);
	printf("lluwise\n");
	print_byte_array(target.c, 8);

	readval = _ctf_bitfield_read_64(target.c, shift, len, BYTE_ORDER, 0);
	printf("read: %llX\n", readval);

	ret = run_test();

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