gcc/testsuite/gcc.c-torture/execute/memset-3.c

   1 /* Copyright (C) 2002  Free Software Foundation.
   2
   3    Test memset with various combinations of constant pointer alignments and
   4    lengths to make sure any optimizations in the compiler are correct.
   5
   6    Written by Roger Sayle, July 22, 2002.  */
   7
   8 #include <string.h>
   9
  10 void abort (void);
  11 void exit (int);
  12
  13 #ifndef MAX_OFFSET
  14 #define MAX_OFFSET (sizeof (long long))
  15 #endif
  16
  17 #ifndef MAX_COPY
  18 #define MAX_COPY 15
  19 #endif
  20
  21 #ifndef MAX_EXTRA
  22 #define MAX_EXTRA (sizeof (long long))
  23 #endif
  24
  25 #define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA)
  26
  27 static union {
  28   char buf[MAX_LENGTH];
  29   long long align_int;
  30   long double align_fp;
  31 } u;
  32
  33 char A = 'A';
  34
  35 void reset ()
  36 {
  37   int i;
  38
  39   for (i = 0; i < MAX_LENGTH; i++)
  40     u.buf[i] = 'a';
  41 }
  42
  43 void check (int off, int len, int ch)
  44 {
  45   char *q;
  46   int i;
  47
  48   q = u.buf;
  49   for (i = 0; i < off; i++, q++)
  50     if (*q != 'a')
  51       abort ();
  52
  53   for (i = 0; i < len; i++, q++)
  54     if (*q != ch)
  55       abort ();
  56
  57   for (i = 0; i < MAX_EXTRA; i++, q++)
  58     if (*q != 'a')
  59       abort ();
  60 }
  61
  62 int main ()
  63 {
  64   int len;
  65   char *p;
  66
  67   /* off == 0 */
  68   for (len = 0; len < MAX_COPY; len++)
  69     {
  70       reset ();
  71
  72       p = memset (u.buf, '\0', len);
  73       if (p != u.buf) abort ();
  74       check (0, len, '\0');
  75
  76       p = memset (u.buf, A, len);
  77       if (p != u.buf) abort ();
  78       check (0, len, 'A');
  79
  80       p = memset (u.buf, 'B', len);
  81       if (p != u.buf) abort ();
  82       check (0, len, 'B');
  83     }
  84
  85   /* off == 1 */
  86   for (len = 0; len < MAX_COPY; len++)
  87     {
  88       reset ();
  89
  90       p = memset (u.buf+1, '\0', len);
  91       if (p != u.buf+1) abort ();
  92       check (1, len, '\0');
  93
  94       p = memset (u.buf+1, A, len);
  95       if (p != u.buf+1) abort ();
  96       check (1, len, 'A');
  97
  98       p = memset (u.buf+1, 'B', len);
  99       if (p != u.buf+1) abort ();
 100       check (1, len, 'B');
 101     }
 102
 103   /* off == 2 */
 104   for (len = 0; len < MAX_COPY; len++)
 105     {
 106       reset ();
 107
 108       p = memset (u.buf+2, '\0', len);
 109       if (p != u.buf+2) abort ();
 110       check (2, len, '\0');
 111
 112       p = memset (u.buf+2, A, len);
 113       if (p != u.buf+2) abort ();
 114       check (2, len, 'A');
 115
 116       p = memset (u.buf+2, 'B', len);
 117       if (p != u.buf+2) abort ();
 118       check (2, len, 'B');
 119     }
 120
 121   /* off == 3 */
 122   for (len = 0; len < MAX_COPY; len++)
 123     {
 124       reset ();
 125
 126       p = memset (u.buf+3, '\0', len);
 127       if (p != u.buf+3) abort ();
 128       check (3, len, '\0');
 129
 130       p = memset (u.buf+3, A, len);
 131       if (p != u.buf+3) abort ();
 132       check (3, len, 'A');
 133
 134       p = memset (u.buf+3, 'B', len);
 135       if (p != u.buf+3) abort ();
 136       check (3, len, 'B');
 137     }
 138
 139   /* off == 4 */
 140   for (len = 0; len < MAX_COPY; len++)
 141     {
 142       reset ();
 143
 144       p = memset (u.buf+4, '\0', len);
 145       if (p != u.buf+4) abort ();
 146       check (4, len, '\0');
 147
 148       p = memset (u.buf+4, A, len);
 149       if (p != u.buf+4) abort ();
 150       check (4, len, 'A');
 151
 152       p = memset (u.buf+4, 'B', len);
 153       if (p != u.buf+4) abort ();
 154       check (4, len, 'B');
 155     }
 156
 157   /* off == 5 */
 158   for (len = 0; len < MAX_COPY; len++)
 159     {
 160       reset ();
 161
 162       p = memset (u.buf+5, '\0', len);
 163       if (p != u.buf+5) abort ();
 164       check (5, len, '\0');
 165
 166       p = memset (u.buf+5, A, len);
 167       if (p != u.buf+5) abort ();
 168       check (5, len, 'A');
 169
 170       p = memset (u.buf+5, 'B', len);
 171       if (p != u.buf+5) abort ();
 172       check (5, len, 'B');
 173     }
 174
 175   /* off == 6 */
 176   for (len = 0; len < MAX_COPY; len++)
 177     {
 178       reset ();
 179
 180       p = memset (u.buf+6, '\0', len);
 181       if (p != u.buf+6) abort ();
 182       check (6, len, '\0');
 183
 184       p = memset (u.buf+6, A, len);
 185       if (p != u.buf+6) abort ();
 186       check (6, len, 'A');
 187
 188       p = memset (u.buf+6, 'B', len);
 189       if (p != u.buf+6) abort ();
 190       check (6, len, 'B');
 191     }
 192
 193   /* off == 7 */
 194   for (len = 0; len < MAX_COPY; len++)
 195     {
 196       reset ();
 197
 198       p = memset (u.buf+7, '\0', len);
 199       if (p != u.buf+7) abort ();
 200       check (7, len, '\0');
 201
 202       p = memset (u.buf+7, A, len);
 203       if (p != u.buf+7) abort ();
 204       check (7, len, 'A');
 205
 206       p = memset (u.buf+7, 'B', len);
 207       if (p != u.buf+7) abort ();
 208       check (7, len, 'B');
 209     }
 210
 211   exit (0);
 212 }
 213