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, int bpp)
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);
143 /* swap bytes only on big endian systems */
144 volatile uint16_t endian_check_var = 0x1234;
145 if (*(volatile uint8_t *)&endian_check_var != 0x12)
148 for (i = 0; i < height; i++)
150 uint8_t *line_data = (uint8_t *)data + stride * i;
151 /* swap bytes only for 16, 24 and 32 bpp for now */
155 for (j = 0; j < stride; j++)
158 ((line_data[j] & 0x80) >> 7) |
159 ((line_data[j] & 0x40) >> 5) |
160 ((line_data[j] & 0x20) >> 3) |
161 ((line_data[j] & 0x10) >> 1) |
162 ((line_data[j] & 0x08) << 1) |
163 ((line_data[j] & 0x04) << 3) |
164 ((line_data[j] & 0x02) << 5) |
165 ((line_data[j] & 0x01) << 7);
169 for (j = 0; j < stride; j++)
171 line_data[j] = (line_data[j] >> 4) | (line_data[j] << 4);
175 for (j = 0; j + 2 <= stride; j += 2)
177 char t1 = line_data[j + 0];
178 char t2 = line_data[j + 1];
180 line_data[j + 1] = t1;
181 line_data[j + 0] = t2;
185 for (j = 0; j + 3 <= stride; j += 3)
187 char t1 = line_data[j + 0];
188 char t2 = line_data[j + 1];
189 char t3 = line_data[j + 2];
191 line_data[j + 2] = t1;
192 line_data[j + 1] = t2;
193 line_data[j + 0] = t3;
197 for (j = 0; j + 4 <= stride; j += 4)
199 char t1 = line_data[j + 0];
200 char t2 = line_data[j + 1];
201 char t3 = line_data[j + 2];
202 char t4 = line_data[j + 3];
204 line_data[j + 3] = t1;
205 line_data[j + 2] = t2;
206 line_data[j + 1] = t3;
207 line_data[j + 0] = t4;
216 #define N_LEADING_PROTECTED 10
217 #define N_TRAILING_PROTECTED 10
227 #if defined(HAVE_MPROTECT) && defined(HAVE_GETPAGESIZE) && defined(HAVE_SYS_MMAN_H)
229 /* This is apparently necessary on at least OS X */
230 #ifndef MAP_ANONYMOUS
231 #define MAP_ANONYMOUS MAP_ANON
235 fence_malloc (uint32_t len)
237 unsigned long page_size = getpagesize();
238 unsigned long page_mask = page_size - 1;
239 uint32_t n_payload_bytes = (len + page_mask) & ~page_mask;
241 (page_size * (N_LEADING_PROTECTED + N_TRAILING_PROTECTED + 2) +
242 n_payload_bytes) & ~page_mask;
243 uint8_t *initial_page;
244 uint8_t *leading_protected;
245 uint8_t *trailing_protected;
249 addr = mmap (NULL, n_bytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
252 if (addr == MAP_FAILED)
254 printf ("mmap failed on %u %u\n", len, n_bytes);
258 initial_page = (uint8_t *)(((unsigned long)addr + page_mask) & ~page_mask);
259 leading_protected = initial_page + page_size;
260 payload = leading_protected + N_LEADING_PROTECTED * page_size;
261 trailing_protected = payload + n_payload_bytes;
263 ((info_t *)initial_page)->addr = addr;
264 ((info_t *)initial_page)->len = len;
265 ((info_t *)initial_page)->trailing = trailing_protected;
266 ((info_t *)initial_page)->n_bytes = n_bytes;
268 if ((mprotect (leading_protected, N_LEADING_PROTECTED * page_size,
270 (mprotect (trailing_protected, N_TRAILING_PROTECTED * page_size,
273 munmap (addr, n_bytes);
281 fence_free (void *data)
283 uint32_t page_size = getpagesize();
284 uint8_t *payload = data;
285 uint8_t *leading_protected = payload - N_LEADING_PROTECTED * page_size;
286 uint8_t *initial_page = leading_protected - page_size;
287 info_t *info = (info_t *)initial_page;
289 munmap (info->addr, info->n_bytes);
295 fence_malloc (uint32_t len)
301 fence_free (void *data)
309 make_random_bytes (int n_bytes)
311 uint8_t *bytes = fence_malloc (n_bytes);
317 for (i = 0; i < n_bytes; ++i)
318 bytes[i] = lcg_rand () & 0xff;
324 * A function, which can be used as a core part of the test programs,
325 * intended to detect various problems with the help of fuzzing input
326 * to pixman API (according to some templates, aka "smart" fuzzing).
327 * Some general information about such testing can be found here:
328 * http://en.wikipedia.org/wiki/Fuzz_testing
330 * It may help detecting:
331 * - crashes on bad handling of valid or reasonably invalid input to
333 * - deviations from the behavior of older pixman releases.
334 * - deviations from the behavior of the same pixman release, but
335 * configured in a different way (for example with SIMD optimizations
336 * disabled), or running on a different OS or hardware.
338 * The test is performed by calling a callback function a huge number
339 * of times. The callback function is expected to run some snippet of
340 * pixman code with pseudorandom variations to the data feeded to
341 * pixman API. A result of running each callback function should be
342 * some deterministic value which depends on test number (test number
343 * can be used as a seed for PRNG). When 'verbose' argument is nonzero,
344 * callback function is expected to print to stdout some information
345 * about what it does.
347 * Return values from many small tests are accumulated together and
348 * used as final checksum, which can be compared to some expected
349 * value. Running the tests not individually, but in a batch helps
350 * to reduce process start overhead and also allows to parallelize
351 * testing and utilize multiple CPU cores.
353 * The resulting executable can be run without any arguments. In
354 * this case it runs a batch of tests starting from 1 and up to
355 * 'default_number_of_iterations'. The resulting checksum is
356 * compared with 'expected_checksum' and FAIL or PASS verdict
357 * depends on the result of this comparison.
359 * If the executable is run with 2 numbers provided as command line
360 * arguments, they specify the starting and ending numbers for a test
363 * If the executable is run with only one number provided as a command
364 * line argument, then this number is used to call the callback function
365 * once, and also with verbose flag set.
368 fuzzer_test_main (const char *test_name,
369 int default_number_of_iterations,
370 uint32_t expected_checksum,
371 uint32_t (*test_function)(int testnum, int verbose),
375 int i, n1 = 1, n2 = 0;
376 uint32_t checksum = 0;
377 int verbose = getenv ("VERBOSE") != NULL;
385 printf ("invalid test range\n");
392 checksum = test_function (n2, 1);
393 printf ("%d: checksum=%08X\n", n2, checksum);
399 n2 = default_number_of_iterations;
403 #pragma omp parallel for reduction(+:checksum) default(none) \
404 shared(n1, n2, test_function, verbose)
406 for (i = n1; i <= n2; i++)
408 uint32_t crc = test_function (i, 0);
410 printf ("%d: %08X\n", i, crc);
414 if (n1 == 1 && n2 == default_number_of_iterations)
416 if (checksum == expected_checksum)
418 printf ("%s test passed (checksum=%08X)\n",
419 test_name, checksum);
423 printf ("%s test failed! (checksum=%08X, expected %08X)\n",
424 test_name, checksum, expected_checksum);
430 printf ("%d-%d: checksum=%08X\n", n1, n2, checksum);
436 /* Try to obtain current time in seconds */
440 #ifdef HAVE_GETTIMEOFDAY
443 gettimeofday (&tv, NULL);
444 return (double)((int64_t)tv.tv_sec * 1000000 + tv.tv_usec) / 1000000.;
446 return (double)clock() / (double)CLOCKS_PER_SEC;
450 static const char *global_msg;
455 printf ("%s\n", global_msg);
460 fail_after (int seconds, const char *msg)
462 #ifdef HAVE_SIGACTION
464 struct sigaction action;
468 memset (&action, 0, sizeof (action));
469 action.sa_handler = on_alarm;
473 sigaction (SIGALRM, &action, NULL);
479 enable_fp_exceptions (void)
482 #ifdef HAVE_FEENABLEEXCEPT
483 /* Note: we don't enable the FE_INEXACT trap because
484 * that happens quite commonly. It is possible that
485 * over- and underflow should similarly be considered
486 * okay, but for now the test suite passes with them
487 * enabled, and it's useful to know if they start
490 feenableexcept (FE_DIVBYZERO |
499 aligned_malloc (size_t align, size_t size)
503 #ifdef HAVE_POSIX_MEMALIGN
504 if (posix_memalign (&result, align, size) != 0)
507 result = malloc (size);
513 #define CONVERT_15(c, is_rgb) \
515 ((((c) >> 3) & 0x001f) | \
516 (((c) >> 6) & 0x03e0) | \
517 (((c) >> 9) & 0x7c00)) : \
518 (((((c) >> 16) & 0xff) * 153 + \
519 (((c) >> 8) & 0xff) * 301 + \
520 (((c) ) & 0xff) * 58) >> 2))
523 initialize_palette (pixman_indexed_t *palette, uint32_t depth, int is_rgb)
526 uint32_t mask = (1 << depth) - 1;
528 for (i = 0; i < 32768; ++i)
529 palette->ent[i] = lcg_rand() & mask;
531 memset (palette->rgba, 0, sizeof (palette->rgba));
533 for (i = 0; i < mask + 1; ++i)
539 /* We filled the rgb->index map with random numbers, but we
540 * do need the ability to round trip, that is if some indexed
541 * color expands to an argb24, then the 15 bit version of that
542 * color must map back to the index. Anything else, we don't
543 * care about too much.
550 i15 = CONVERT_15 (rgba24, is_rgb);
552 old_idx = palette->ent[i15];
553 if (CONVERT_15 (palette->rgba[old_idx], is_rgb) == i15)
559 palette->rgba[i] = rgba24;
560 palette->ent[i15] = i;
563 for (i = 0; i < mask + 1; ++i)
565 assert (palette->ent[CONVERT_15 (palette->rgba[i], is_rgb)] == i);