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

   1 /* Copyright (C) 2002  Free Software Foundation.
   2
   3    Test memset with various combinations of pointer alignments and constant
   4    lengths to make sure any optimizations in the compiler are correct.
   5
   6    Written by Roger Sayle, April 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 off;
  65   char *p;
  66
  67   /* len == 1 */
  68   for (off = 0; off < MAX_OFFSET; off++)
  69     {
  70       reset ();
  71
  72       p = memset (u.buf + off, '\0', 1);
  73       if (p != u.buf + off) abort ();
  74       check (off, 1, '\0');
  75
  76       p = memset (u.buf + off, A, 1);
  77       if (p != u.buf + off) abort ();
  78       check (off, 1, 'A');
  79
  80       p = memset (u.buf + off, 'B', 1);
  81       if (p != u.buf + off) abort ();
  82       check (off, 1, 'B');
  83     }
  84
  85   /* len == 2 */
  86   for (off = 0; off < MAX_OFFSET; off++)
  87     {
  88       reset ();
  89
  90       p = memset (u.buf + off, '\0', 2);
  91       if (p != u.buf + off) abort ();
  92       check (off, 2, '\0');
  93
  94       p = memset (u.buf + off, A, 2);
  95       if (p != u.buf + off) abort ();
  96       check (off, 2, 'A');
  97
  98       p = memset (u.buf + off, 'B', 2);
  99       if (p != u.buf + off) abort ();
 100       check (off, 2, 'B');
 101     }
 102
 103   /* len == 3 */
 104   for (off = 0; off < MAX_OFFSET; off++)
 105     {
 106       reset ();
 107
 108       p = memset (u.buf + off, '\0', 3);
 109       if (p != u.buf + off) abort ();
 110       check (off, 3, '\0');
 111
 112       p = memset (u.buf + off, A, 3);
 113       if (p != u.buf + off) abort ();
 114       check (off, 3, 'A');
 115
 116       p = memset (u.buf + off, 'B', 3);
 117       if (p != u.buf + off) abort ();
 118       check (off, 3, 'B');
 119     }
 120
 121   /* len == 4 */
 122   for (off = 0; off < MAX_OFFSET; off++)
 123     {
 124       reset ();
 125
 126       p = memset (u.buf + off, '\0', 4);
 127       if (p != u.buf + off) abort ();
 128       check (off, 4, '\0');
 129
 130       p = memset (u.buf + off, A, 4);
 131       if (p != u.buf + off) abort ();
 132       check (off, 4, 'A');
 133
 134       p = memset (u.buf + off, 'B', 4);
 135       if (p != u.buf + off) abort ();
 136       check (off, 4, 'B');
 137     }
 138
 139   /* len == 5 */
 140   for (off = 0; off < MAX_OFFSET; off++)
 141     {
 142       reset ();
 143
 144       p = memset (u.buf + off, '\0', 5);
 145       if (p != u.buf + off) abort ();
 146       check (off, 5, '\0');
 147
 148       p = memset (u.buf + off, A, 5);
 149       if (p != u.buf + off) abort ();
 150       check (off, 5, 'A');
 151
 152       p = memset (u.buf + off, 'B', 5);
 153       if (p != u.buf + off) abort ();
 154       check (off, 5, 'B');
 155     }
 156
 157   /* len == 6 */
 158   for (off = 0; off < MAX_OFFSET; off++)
 159     {
 160       reset ();
 161
 162       p = memset (u.buf + off, '\0', 6);
 163       if (p != u.buf + off) abort ();
 164       check (off, 6, '\0');
 165
 166       p = memset (u.buf + off, A, 6);
 167       if (p != u.buf + off) abort ();
 168       check (off, 6, 'A');
 169
 170       p = memset (u.buf + off, 'B', 6);
 171       if (p != u.buf + off) abort ();
 172       check (off, 6, 'B');
 173     }
 174
 175   /* len == 7 */
 176   for (off = 0; off < MAX_OFFSET; off++)
 177     {
 178       reset ();
 179
 180       p = memset (u.buf + off, '\0', 7);
 181       if (p != u.buf + off) abort ();
 182       check (off, 7, '\0');
 183
 184       p = memset (u.buf + off, A, 7);
 185       if (p != u.buf + off) abort ();
 186       check (off, 7, 'A');
 187
 188       p = memset (u.buf + off, 'B', 7);
 189       if (p != u.buf + off) abort ();
 190       check (off, 7, 'B');
 191     }
 192
 193   /* len == 8 */
 194   for (off = 0; off < MAX_OFFSET; off++)
 195     {
 196       reset ();
 197
 198       p = memset (u.buf + off, '\0', 8);
 199       if (p != u.buf + off) abort ();
 200       check (off, 8, '\0');
 201
 202       p = memset (u.buf + off, A, 8);
 203       if (p != u.buf + off) abort ();
 204       check (off, 8, 'A');
 205
 206       p = memset (u.buf + off, 'B', 8);
 207       if (p != u.buf + off) abort ();
 208       check (off, 8, 'B');
 209     }
 210
 211   /* len == 9 */
 212   for (off = 0; off < MAX_OFFSET; off++)
 213     {
 214       reset ();
 215
 216       p = memset (u.buf + off, '\0', 9);
 217       if (p != u.buf + off) abort ();
 218       check (off, 9, '\0');
 219
 220       p = memset (u.buf + off, A, 9);
 221       if (p != u.buf + off) abort ();
 222       check (off, 9, 'A');
 223
 224       p = memset (u.buf + off, 'B', 9);
 225       if (p != u.buf + off) abort ();
 226       check (off, 9, 'B');
 227     }
 228
 229   /* len == 10 */
 230   for (off = 0; off < MAX_OFFSET; off++)
 231     {
 232       reset ();
 233
 234       p = memset (u.buf + off, '\0', 10);
 235       if (p != u.buf + off) abort ();
 236       check (off, 10, '\0');
 237
 238       p = memset (u.buf + off, A, 10);
 239       if (p != u.buf + off) abort ();
 240       check (off, 10, 'A');
 241
 242       p = memset (u.buf + off, 'B', 10);
 243       if (p != u.buf + off) abort ();
 244       check (off, 10, 'B');
 245     }
 246
 247   /* len == 11 */
 248   for (off = 0; off < MAX_OFFSET; off++)
 249     {
 250       reset ();
 251
 252       p = memset (u.buf + off, '\0', 11);
 253       if (p != u.buf + off) abort ();
 254       check (off, 11, '\0');
 255
 256       p = memset (u.buf + off, A, 11);
 257       if (p != u.buf + off) abort ();
 258       check (off, 11, 'A');
 259
 260       p = memset (u.buf + off, 'B', 11);
 261       if (p != u.buf + off) abort ();
 262       check (off, 11, 'B');
 263     }
 264
 265   /* len == 12 */
 266   for (off = 0; off < MAX_OFFSET; off++)
 267     {
 268       reset ();
 269
 270       p = memset (u.buf + off, '\0', 12);
 271       if (p != u.buf + off) abort ();
 272       check (off, 12, '\0');
 273
 274       p = memset (u.buf + off, A, 12);
 275       if (p != u.buf + off) abort ();
 276       check (off, 12, 'A');
 277
 278       p = memset (u.buf + off, 'B', 12);
 279       if (p != u.buf + off) abort ();
 280       check (off, 12, 'B');
 281     }
 282
 283   /* len == 13 */
 284   for (off = 0; off < MAX_OFFSET; off++)
 285     {
 286       reset ();
 287
 288       p = memset (u.buf + off, '\0', 13);
 289       if (p != u.buf + off) abort ();
 290       check (off, 13, '\0');
 291
 292       p = memset (u.buf + off, A, 13);
 293       if (p != u.buf + off) abort ();
 294       check (off, 13, 'A');
 295
 296       p = memset (u.buf + off, 'B', 13);
 297       if (p != u.buf + off) abort ();
 298       check (off, 13, 'B');
 299     }
 300
 301   /* len == 14 */
 302   for (off = 0; off < MAX_OFFSET; off++)
 303     {
 304       reset ();
 305
 306       p = memset (u.buf + off, '\0', 14);
 307       if (p != u.buf + off) abort ();
 308       check (off, 14, '\0');
 309
 310       p = memset (u.buf + off, A, 14);
 311       if (p != u.buf + off) abort ();
 312       check (off, 14, 'A');
 313
 314       p = memset (u.buf + off, 'B', 14);
 315       if (p != u.buf + off) abort ();
 316       check (off, 14, 'B');
 317     }
 318
 319   /* len == 15 */
 320   for (off = 0; off < MAX_OFFSET; off++)
 321     {
 322       reset ();
 323
 324       p = memset (u.buf + off, '\0', 15);
 325       if (p != u.buf + off) abort ();
 326       check (off, 15, '\0');
 327
 328       p = memset (u.buf + off, A, 15);
 329       if (p != u.buf + off) abort ();
 330       check (off, 15, 'A');
 331
 332       p = memset (u.buf + off, 'B', 15);
 333       if (p != u.buf + off) abort ();
 334       check (off, 15, 'B');
 335     }
 336
 337   exit (0);
 338 }
 339