6 #ifdef HAVE_GETTIMEOFDAY
16 #ifdef HAVE_SYS_MMAN_H
29 /*----------------------------------------------------------------------------*\
30 * CRC-32 version 2.0.0 by Craig Bruce, 2006-04-29.
32 * This program generates the CRC-32 values for the files named in the
33 * command-line arguments. These are the same CRC-32 values used by GZIP,
34 * PKZIP, and ZMODEM. The Crc32_ComputeBuf () can also be detached and
37 * THIS PROGRAM IS PUBLIC-DOMAIN SOFTWARE.
39 * Based on the byte-oriented implementation "File Verification Using CRC"
40 * by Mark R. Nelson in Dr. Dobb's Journal, May 1992, pp. 64-67.
42 * v1.0.0: original release.
43 * v1.0.1: fixed printf formats.
44 * v1.0.2: fixed something else.
45 * v1.0.3: replaced CRC constant table by generator function.
46 * v1.0.4: reformatted code, made ANSI C. 1994-12-05.
47 * v2.0.0: rewrote to use memory buffer & static table, 2006-04-29.
48 \*----------------------------------------------------------------------------*/
50 /*----------------------------------------------------------------------------*\
52 * Crc32_ComputeBuf () - computes the CRC-32 value of a memory buffer
54 * Computes or accumulates the CRC-32 value for a memory buffer.
55 * The 'inCrc32' gives a previously accumulated CRC-32 value to allow
56 * a CRC to be generated for multiple sequential buffer-fuls of data.
57 * The 'inCrc32' for the first buffer must be zero.
59 * inCrc32 - accumulated CRC-32 value, must be 0 on first call
60 * buf - buffer to compute CRC-32 value for
61 * bufLen - number of bytes in buffer
63 * crc32 - computed CRC-32 value
65 * (no errors are possible)
66 \*----------------------------------------------------------------------------*/
69 compute_crc32 (uint32_t in_crc32,
73 static const uint32_t crc_table[256] = {
74 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
75 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
76 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
77 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
78 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
79 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
80 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
81 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
82 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
83 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
84 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
85 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
86 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
87 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
88 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
89 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
90 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
91 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
92 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
93 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
94 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
95 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
96 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
97 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
98 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
99 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
100 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
101 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
102 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
103 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
104 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
105 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
106 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
107 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
108 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
109 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
110 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
111 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
112 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
113 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
114 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
115 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
116 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
120 unsigned char * byte_buf;
123 /* accumulate crc32 for buffer */
124 crc32 = in_crc32 ^ 0xFFFFFFFF;
125 byte_buf = (unsigned char*) buf;
127 for (i = 0; i < buf_len; i++)
128 crc32 = (crc32 >> 8) ^ crc_table[(crc32 ^ byte_buf[i]) & 0xFF];
130 return (crc32 ^ 0xFFFFFFFF);
133 /* perform endian conversion of pixel data
136 image_endian_swap (pixman_image_t *img)
138 int stride = pixman_image_get_stride (img);
139 uint32_t *data = pixman_image_get_data (img);
140 int height = pixman_image_get_height (img);
141 int bpp = PIXMAN_FORMAT_BPP (pixman_image_get_format (img));
144 /* swap bytes only on big endian systems */
145 volatile uint16_t endian_check_var = 0x1234;
146 if (*(volatile uint8_t *)&endian_check_var != 0x12)
152 for (i = 0; i < height; i++)
154 uint8_t *line_data = (uint8_t *)data + stride * i;
159 for (j = 0; j < stride; j++)
162 ((line_data[j] & 0x80) >> 7) |
163 ((line_data[j] & 0x40) >> 5) |
164 ((line_data[j] & 0x20) >> 3) |
165 ((line_data[j] & 0x10) >> 1) |
166 ((line_data[j] & 0x08) << 1) |
167 ((line_data[j] & 0x04) << 3) |
168 ((line_data[j] & 0x02) << 5) |
169 ((line_data[j] & 0x01) << 7);
173 for (j = 0; j < stride; j++)
175 line_data[j] = (line_data[j] >> 4) | (line_data[j] << 4);
179 for (j = 0; j + 2 <= stride; j += 2)
181 char t1 = line_data[j + 0];
182 char t2 = line_data[j + 1];
184 line_data[j + 1] = t1;
185 line_data[j + 0] = t2;
189 for (j = 0; j + 3 <= stride; j += 3)
191 char t1 = line_data[j + 0];
192 char t2 = line_data[j + 1];
193 char t3 = line_data[j + 2];
195 line_data[j + 2] = t1;
196 line_data[j + 1] = t2;
197 line_data[j + 0] = t3;
201 for (j = 0; j + 4 <= stride; j += 4)
203 char t1 = line_data[j + 0];
204 char t2 = line_data[j + 1];
205 char t3 = line_data[j + 2];
206 char t4 = line_data[j + 3];
208 line_data[j + 3] = t1;
209 line_data[j + 2] = t2;
210 line_data[j + 1] = t3;
211 line_data[j + 0] = t4;
221 #define N_LEADING_PROTECTED 10
222 #define N_TRAILING_PROTECTED 10
232 #if defined(HAVE_MPROTECT) && defined(HAVE_GETPAGESIZE) && defined(HAVE_SYS_MMAN_H)
234 /* This is apparently necessary on at least OS X */
235 #ifndef MAP_ANONYMOUS
236 #define MAP_ANONYMOUS MAP_ANON
240 fence_malloc (int64_t len)
242 unsigned long page_size = getpagesize();
243 unsigned long page_mask = page_size - 1;
244 uint32_t n_payload_bytes = (len + page_mask) & ~page_mask;
246 (page_size * (N_LEADING_PROTECTED + N_TRAILING_PROTECTED + 2) +
247 n_payload_bytes) & ~page_mask;
248 uint8_t *initial_page;
249 uint8_t *leading_protected;
250 uint8_t *trailing_protected;
257 addr = mmap (NULL, n_bytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
260 if (addr == MAP_FAILED)
262 printf ("mmap failed on %lld %u\n", (long long int)len, n_bytes);
266 initial_page = (uint8_t *)(((unsigned long)addr + page_mask) & ~page_mask);
267 leading_protected = initial_page + page_size;
268 payload = leading_protected + N_LEADING_PROTECTED * page_size;
269 trailing_protected = payload + n_payload_bytes;
271 ((info_t *)initial_page)->addr = addr;
272 ((info_t *)initial_page)->len = len;
273 ((info_t *)initial_page)->trailing = trailing_protected;
274 ((info_t *)initial_page)->n_bytes = n_bytes;
276 if ((mprotect (leading_protected, N_LEADING_PROTECTED * page_size,
278 (mprotect (trailing_protected, N_TRAILING_PROTECTED * page_size,
281 munmap (addr, n_bytes);
289 fence_free (void *data)
291 uint32_t page_size = getpagesize();
292 uint8_t *payload = data;
293 uint8_t *leading_protected = payload - N_LEADING_PROTECTED * page_size;
294 uint8_t *initial_page = leading_protected - page_size;
295 info_t *info = (info_t *)initial_page;
297 munmap (info->addr, info->n_bytes);
303 fence_malloc (int64_t len)
309 fence_free (void *data)
317 make_random_bytes (int n_bytes)
319 uint8_t *bytes = fence_malloc (n_bytes);
325 for (i = 0; i < n_bytes; ++i)
326 bytes[i] = lcg_rand () & 0xff;
332 * A function, which can be used as a core part of the test programs,
333 * intended to detect various problems with the help of fuzzing input
334 * to pixman API (according to some templates, aka "smart" fuzzing).
335 * Some general information about such testing can be found here:
336 * http://en.wikipedia.org/wiki/Fuzz_testing
338 * It may help detecting:
339 * - crashes on bad handling of valid or reasonably invalid input to
341 * - deviations from the behavior of older pixman releases.
342 * - deviations from the behavior of the same pixman release, but
343 * configured in a different way (for example with SIMD optimizations
344 * disabled), or running on a different OS or hardware.
346 * The test is performed by calling a callback function a huge number
347 * of times. The callback function is expected to run some snippet of
348 * pixman code with pseudorandom variations to the data feeded to
349 * pixman API. A result of running each callback function should be
350 * some deterministic value which depends on test number (test number
351 * can be used as a seed for PRNG). When 'verbose' argument is nonzero,
352 * callback function is expected to print to stdout some information
353 * about what it does.
355 * Return values from many small tests are accumulated together and
356 * used as final checksum, which can be compared to some expected
357 * value. Running the tests not individually, but in a batch helps
358 * to reduce process start overhead and also allows to parallelize
359 * testing and utilize multiple CPU cores.
361 * The resulting executable can be run without any arguments. In
362 * this case it runs a batch of tests starting from 1 and up to
363 * 'default_number_of_iterations'. The resulting checksum is
364 * compared with 'expected_checksum' and FAIL or PASS verdict
365 * depends on the result of this comparison.
367 * If the executable is run with 2 numbers provided as command line
368 * arguments, they specify the starting and ending numbers for a test
371 * If the executable is run with only one number provided as a command
372 * line argument, then this number is used to call the callback function
373 * once, and also with verbose flag set.
376 fuzzer_test_main (const char *test_name,
377 int default_number_of_iterations,
378 uint32_t expected_checksum,
379 uint32_t (*test_function)(int testnum, int verbose),
383 int i, n1 = 1, n2 = 0;
384 uint32_t checksum = 0;
385 int verbose = getenv ("VERBOSE") != NULL;
393 printf ("invalid test range\n");
400 checksum = test_function (n2, 1);
401 printf ("%d: checksum=%08X\n", n2, checksum);
407 n2 = default_number_of_iterations;
411 #pragma omp parallel for reduction(+:checksum) default(none) \
412 shared(n1, n2, test_function, verbose)
414 for (i = n1; i <= n2; i++)
416 uint32_t crc = test_function (i, 0);
418 printf ("%d: %08X\n", i, crc);
422 if (n1 == 1 && n2 == default_number_of_iterations)
424 if (checksum == expected_checksum)
426 printf ("%s test passed (checksum=%08X)\n",
427 test_name, checksum);
431 printf ("%s test failed! (checksum=%08X, expected %08X)\n",
432 test_name, checksum, expected_checksum);
438 printf ("%d-%d: checksum=%08X\n", n1, n2, checksum);
444 /* Try to obtain current time in seconds */
448 #ifdef HAVE_GETTIMEOFDAY
451 gettimeofday (&tv, NULL);
452 return (double)((int64_t)tv.tv_sec * 1000000 + tv.tv_usec) / 1000000.;
454 return (double)clock() / (double)CLOCKS_PER_SEC;
459 get_random_seed (void)
461 double d = gettime();
463 lcg_srand (*(uint32_t *)&d);
465 return lcg_rand_u32 ();
468 static const char *global_msg;
473 printf ("%s\n", global_msg);
478 fail_after (int seconds, const char *msg)
480 #ifdef HAVE_SIGACTION
482 struct sigaction action;
486 memset (&action, 0, sizeof (action));
487 action.sa_handler = on_alarm;
491 sigaction (SIGALRM, &action, NULL);
497 enable_fp_exceptions (void)
500 #ifdef HAVE_FEENABLEEXCEPT
501 /* Note: we don't enable the FE_INEXACT trap because
502 * that happens quite commonly. It is possible that
503 * over- and underflow should similarly be considered
504 * okay, but for now the test suite passes with them
505 * enabled, and it's useful to know if they start
508 feenableexcept (FE_DIVBYZERO |
517 aligned_malloc (size_t align, size_t size)
521 #ifdef HAVE_POSIX_MEMALIGN
522 if (posix_memalign (&result, align, size) != 0)
525 result = malloc (size);
531 #define CONVERT_15(c, is_rgb) \
533 ((((c) >> 3) & 0x001f) | \
534 (((c) >> 6) & 0x03e0) | \
535 (((c) >> 9) & 0x7c00)) : \
536 (((((c) >> 16) & 0xff) * 153 + \
537 (((c) >> 8) & 0xff) * 301 + \
538 (((c) ) & 0xff) * 58) >> 2))
541 initialize_palette (pixman_indexed_t *palette, uint32_t depth, int is_rgb)
544 uint32_t mask = (1 << depth) - 1;
546 for (i = 0; i < 32768; ++i)
547 palette->ent[i] = lcg_rand() & mask;
549 memset (palette->rgba, 0, sizeof (palette->rgba));
551 for (i = 0; i < mask + 1; ++i)
557 /* We filled the rgb->index map with random numbers, but we
558 * do need the ability to round trip, that is if some indexed
559 * color expands to an argb24, then the 15 bit version of that
560 * color must map back to the index. Anything else, we don't
561 * care about too much.
568 i15 = CONVERT_15 (rgba24, is_rgb);
570 old_idx = palette->ent[i15];
571 if (CONVERT_15 (palette->rgba[old_idx], is_rgb) == i15)
577 palette->rgba[i] = rgba24;
578 palette->ent[i15] = i;
581 for (i = 0; i < mask + 1; ++i)
583 assert (palette->ent[CONVERT_15 (palette->rgba[i], is_rgb)] == i);