sdcc/support/regression/tests/gcc-torture-execute-memset-2.c

   1 /*
   2 memset-2.c from the execute part of the gcc torture tests.
   3 */
   4
   5 #include <testfwk.h>
   6
   7 /* Copyright (C) 2002  Free Software Foundation.
   8
   9    Test memset with various combinations of pointer alignments and constant
  10    lengths to make sure any optimizations in the compiler are correct.
  11
  12    Written by Roger Sayle, April 22, 2002.  */
  13
  14 #ifndef MAX_OFFSET
  15 #define MAX_OFFSET (sizeof (long long))
  16 #endif
  17
  18 #ifndef MAX_COPY
  19 #define MAX_COPY 15
  20 #endif
  21
  22 #ifndef MAX_EXTRA
  23 #define MAX_EXTRA (sizeof (long long))
  24 #endif
  25
  26 #define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA)
  27
  28 #if 0 // TODO: Enable when SDCC supports long double!
  29 static union {
  30   char buf[MAX_LENGTH];
  31   long long align_int;
  32   long double align_fp;
  33 } u;
  34
  35 char A = 'A';
  36
  37 void reset ()
  38 {
  39   int i;
  40
  41   for (i = 0; i < MAX_LENGTH; i++)
  42     u.buf[i] = 'a';
  43 }
  44
  45 void check (int off, int len, int ch)
  46 {
  47   char *q;
  48   int i;
  49
  50   q = u.buf;
  51   for (i = 0; i < off; i++, q++)
  52     if (*q != 'a')
  53       abort ();
  54
  55   for (i = 0; i < len; i++, q++)
  56     if (*q != ch)
  57       abort ();
  58
  59   for (i = 0; i < MAX_EXTRA; i++, q++)
  60     if (*q != 'a')
  61       abort ();
  62 }
  63 #endif
  64 void
  65 testTortureExecute (void)
  66 {
  67 #if 0
  68   int off;
  69   char *p;
  70
  71   /* len == 1 */
  72   for (off = 0; off < MAX_OFFSET; off++)
  73     {
  74       reset ();
  75
  76       p = memset (u.buf + off, '\0', 1);
  77       if (p != u.buf + off) abort ();
  78       check (off, 1, '\0');
  79
  80       p = memset (u.buf + off, A, 1);
  81       if (p != u.buf + off) abort ();
  82       check (off, 1, 'A');
  83
  84       p = memset (u.buf + off, 'B', 1);
  85       if (p != u.buf + off) abort ();
  86       check (off, 1, 'B');
  87     }
  88
  89   /* len == 2 */
  90   for (off = 0; off < MAX_OFFSET; off++)
  91     {
  92       reset ();
  93
  94       p = memset (u.buf + off, '\0', 2);
  95       if (p != u.buf + off) abort ();
  96       check (off, 2, '\0');
  97
  98       p = memset (u.buf + off, A, 2);
  99       if (p != u.buf + off) abort ();
 100       check (off, 2, 'A');
 101
 102       p = memset (u.buf + off, 'B', 2);
 103       if (p != u.buf + off) abort ();
 104       check (off, 2, 'B');
 105     }
 106
 107   /* len == 3 */
 108   for (off = 0; off < MAX_OFFSET; off++)
 109     {
 110       reset ();
 111
 112       p = memset (u.buf + off, '\0', 3);
 113       if (p != u.buf + off) abort ();
 114       check (off, 3, '\0');
 115
 116       p = memset (u.buf + off, A, 3);
 117       if (p != u.buf + off) abort ();
 118       check (off, 3, 'A');
 119
 120       p = memset (u.buf + off, 'B', 3);
 121       if (p != u.buf + off) abort ();
 122       check (off, 3, 'B');
 123     }
 124
 125   /* len == 4 */
 126   for (off = 0; off < MAX_OFFSET; off++)
 127     {
 128       reset ();
 129
 130       p = memset (u.buf + off, '\0', 4);
 131       if (p != u.buf + off) abort ();
 132       check (off, 4, '\0');
 133
 134       p = memset (u.buf + off, A, 4);
 135       if (p != u.buf + off) abort ();
 136       check (off, 4, 'A');
 137
 138       p = memset (u.buf + off, 'B', 4);
 139       if (p != u.buf + off) abort ();
 140       check (off, 4, 'B');
 141     }
 142
 143   /* len == 5 */
 144   for (off = 0; off < MAX_OFFSET; off++)
 145     {
 146       reset ();
 147
 148       p = memset (u.buf + off, '\0', 5);
 149       if (p != u.buf + off) abort ();
 150       check (off, 5, '\0');
 151
 152       p = memset (u.buf + off, A, 5);
 153       if (p != u.buf + off) abort ();
 154       check (off, 5, 'A');
 155
 156       p = memset (u.buf + off, 'B', 5);
 157       if (p != u.buf + off) abort ();
 158       check (off, 5, 'B');
 159     }
 160
 161   /* len == 6 */
 162   for (off = 0; off < MAX_OFFSET; off++)
 163     {
 164       reset ();
 165
 166       p = memset (u.buf + off, '\0', 6);
 167       if (p != u.buf + off) abort ();
 168       check (off, 6, '\0');
 169
 170       p = memset (u.buf + off, A, 6);
 171       if (p != u.buf + off) abort ();
 172       check (off, 6, 'A');
 173
 174       p = memset (u.buf + off, 'B', 6);
 175       if (p != u.buf + off) abort ();
 176       check (off, 6, 'B');
 177     }
 178
 179   /* len == 7 */
 180   for (off = 0; off < MAX_OFFSET; off++)
 181     {
 182       reset ();
 183
 184       p = memset (u.buf + off, '\0', 7);
 185       if (p != u.buf + off) abort ();
 186       check (off, 7, '\0');
 187
 188       p = memset (u.buf + off, A, 7);
 189       if (p != u.buf + off) abort ();
 190       check (off, 7, 'A');
 191
 192       p = memset (u.buf + off, 'B', 7);
 193       if (p != u.buf + off) abort ();
 194       check (off, 7, 'B');
 195     }
 196
 197   /* len == 8 */
 198   for (off = 0; off < MAX_OFFSET; off++)
 199     {
 200       reset ();
 201
 202       p = memset (u.buf + off, '\0', 8);
 203       if (p != u.buf + off) abort ();
 204       check (off, 8, '\0');
 205
 206       p = memset (u.buf + off, A, 8);
 207       if (p != u.buf + off) abort ();
 208       check (off, 8, 'A');
 209
 210       p = memset (u.buf + off, 'B', 8);
 211       if (p != u.buf + off) abort ();
 212       check (off, 8, 'B');
 213     }
 214
 215   /* len == 9 */
 216   for (off = 0; off < MAX_OFFSET; off++)
 217     {
 218       reset ();
 219
 220       p = memset (u.buf + off, '\0', 9);
 221       if (p != u.buf + off) abort ();
 222       check (off, 9, '\0');
 223
 224       p = memset (u.buf + off, A, 9);
 225       if (p != u.buf + off) abort ();
 226       check (off, 9, 'A');
 227
 228       p = memset (u.buf + off, 'B', 9);
 229       if (p != u.buf + off) abort ();
 230       check (off, 9, 'B');
 231     }
 232
 233   /* len == 10 */
 234   for (off = 0; off < MAX_OFFSET; off++)
 235     {
 236       reset ();
 237
 238       p = memset (u.buf + off, '\0', 10);
 239       if (p != u.buf + off) abort ();
 240       check (off, 10, '\0');
 241
 242       p = memset (u.buf + off, A, 10);
 243       if (p != u.buf + off) abort ();
 244       check (off, 10, 'A');
 245
 246       p = memset (u.buf + off, 'B', 10);
 247       if (p != u.buf + off) abort ();
 248       check (off, 10, 'B');
 249     }
 250
 251   /* len == 11 */
 252   for (off = 0; off < MAX_OFFSET; off++)
 253     {
 254       reset ();
 255
 256       p = memset (u.buf + off, '\0', 11);
 257       if (p != u.buf + off) abort ();
 258       check (off, 11, '\0');
 259
 260       p = memset (u.buf + off, A, 11);
 261       if (p != u.buf + off) abort ();
 262       check (off, 11, 'A');
 263
 264       p = memset (u.buf + off, 'B', 11);
 265       if (p != u.buf + off) abort ();
 266       check (off, 11, 'B');
 267     }
 268
 269   /* len == 12 */
 270   for (off = 0; off < MAX_OFFSET; off++)
 271     {
 272       reset ();
 273
 274       p = memset (u.buf + off, '\0', 12);
 275       if (p != u.buf + off) abort ();
 276       check (off, 12, '\0');
 277
 278       p = memset (u.buf + off, A, 12);
 279       if (p != u.buf + off) abort ();
 280       check (off, 12, 'A');
 281
 282       p = memset (u.buf + off, 'B', 12);
 283       if (p != u.buf + off) abort ();
 284       check (off, 12, 'B');
 285     }
 286
 287   /* len == 13 */
 288   for (off = 0; off < MAX_OFFSET; off++)
 289     {
 290       reset ();
 291
 292       p = memset (u.buf + off, '\0', 13);
 293       if (p != u.buf + off) abort ();
 294       check (off, 13, '\0');
 295
 296       p = memset (u.buf + off, A, 13);
 297       if (p != u.buf + off) abort ();
 298       check (off, 13, 'A');
 299
 300       p = memset (u.buf + off, 'B', 13);
 301       if (p != u.buf + off) abort ();
 302       check (off, 13, 'B');
 303     }
 304
 305   /* len == 14 */
 306   for (off = 0; off < MAX_OFFSET; off++)
 307     {
 308       reset ();
 309
 310       p = memset (u.buf + off, '\0', 14);
 311       if (p != u.buf + off) abort ();
 312       check (off, 14, '\0');
 313
 314       p = memset (u.buf + off, A, 14);
 315       if (p != u.buf + off) abort ();
 316       check (off, 14, 'A');
 317
 318       p = memset (u.buf + off, 'B', 14);
 319       if (p != u.buf + off) abort ();
 320       check (off, 14, 'B');
 321     }
 322
 323   /* len == 15 */
 324   for (off = 0; off < MAX_OFFSET; off++)
 325     {
 326       reset ();
 327
 328       p = memset (u.buf + off, '\0', 15);
 329       if (p != u.buf + off) abort ();
 330       check (off, 15, '\0');
 331
 332       p = memset (u.buf + off, A, 15);
 333       if (p != u.buf + off) abort ();
 334       check (off, 15, 'A');
 335
 336       p = memset (u.buf + off, 'B', 15);
 337       if (p != u.buf + off) abort ();
 338       check (off, 15, 'B');
 339     }
 340 #endif
 341   return;
 342 }
 343