memcheck/tests/freebsd/memalign.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <assert.h>
   4 #include "tests/malloc.h"
   5 #include <errno.h>
   6 #include "../../../config.h"
   7
   8
   9 int main (void)
  10 {
  11    int* p;
  12    int* piece;
  13    assert(sizeof(long int) == sizeof(void*));
  14
  15    p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1);
  16    assert(0 == (long)p % (1024 * 1024));
  17    piece = malloc(1024 * 1000); assert (piece);
  18    free (piece);
  19    free (p);
  20
  21    p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1);
  22    assert(0 == (long)p % (1024 * 1024));
  23    piece = malloc(1024 * 100); assert (piece);
  24    free (p);
  25    free (piece);
  26
  27    // there is a bug in FreeBSD memalign which causes
  28    // a SIGFPE division by zero when the alignment is zero
  29    // see https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=269688
  30    // that might ship in FreeBSD 13.2 / 14.0
  31    // for the moment disable this test
  32    //p = memalign(0, 100);
  33    //assert(!p);
  34    p = memalign(1, 100);
  35    assert(p && 0 == (long)p % 8);
  36    p = memalign(2, 100);
  37    assert(p && 0 == (long)p % 8);
  38    errno = 0;
  39    p = memalign(3, 100);
  40    assert(!p);
  41    assert(errno = EINVAL);
  42    p = memalign(4, 100);
  43    assert(p && 0 == (long)p % 8);
  44    errno = 0;
  45    p = memalign(5, 100);
  46    assert(!p);
  47    assert(errno = EINVAL);
  48    errno = 0;
  49    p = memalign(7, 100);
  50    assert(!p);
  51    assert(errno = EINVAL);
  52    p = memalign(8, 100);
  53    assert(p && 0 == (long)p % 8);
  54    errno = 0;
  55    p = memalign(9, 100);
  56    assert(!p);
  57    assert(errno = EINVAL);
  58    errno = 0;
  59    p = memalign(31, 100);
  60    assert(!p);
  61    assert(errno = EINVAL);
  62    p = memalign(32, 100);
  63    assert(p && 0 == (long)p % 32);
  64    errno = 0;
  65    p = memalign(33, 100);
  66    assert(!p);
  67    assert(errno = EINVAL);
  68    errno = 0;
  69    p = memalign(4095, 100);
  70    assert(!p);
  71    assert(errno = EINVAL);
  72    p = memalign(4096, 100);
  73    assert(p && 0 == (long)p % 4096);
  74    errno = 0;
  75    p = memalign(4097, 100);
  76    assert(!p);
  77    assert(errno = EINVAL);
  78    p = memalign(4 * 1024 * 1024, 100);
  79    assert(p && 0 == (long)p % (4 * 1024 * 1024));
  80    p = memalign(16 * 1024 * 1024, 100);
  81    assert(p && 0 == (long)p % (16 * 1024 * 1024));
  82 }