modernc.org/ccgo/v3@v3.16.14/lib/testdata/gcc-9.1.0/gcc/testsuite/gcc.c-torture/execute/builtins/memset-chk.c (about)

     1  /* Copyright (C) 2004, 2005  Free Software Foundation.
     2  
     3     Ensure builtin __memset_chk performs correctly.  */
     4  
     5  extern void abort (void);
     6  typedef __SIZE_TYPE__ size_t;
     7  extern size_t strlen(const char *);
     8  extern void *memcpy (void *, const void *, size_t);
     9  extern void *memset (void *, int, size_t);
    10  extern int memcmp (const void *, const void *, size_t);
    11  
    12  #include "chk.h"
    13  
    14  char buffer[32];
    15  int argc = 1;
    16  volatile size_t l1 = 1;  /* prevent constant propagation to happen when whole program assumptions are made.  */
    17  volatile char *s3 = "FGH"; /* prevent constant propagation to happen when whole program assumptions are made.  */
    18  char *s4;
    19  
    20  void
    21  __attribute__((noinline))
    22  test1 (void)
    23  {
    24    memset_disallowed = 1;
    25    chk_calls = 0;
    26    memset (buffer, argc, 0);
    27    memset (buffer, argc, 1);
    28    memset (buffer, argc, 2);
    29    memset (buffer, argc, 3);
    30    memset (buffer, argc, 4);
    31    memset (buffer, argc, 5);
    32    memset (buffer, argc, 6);
    33    memset (buffer, argc, 7);
    34    memset (buffer, argc, 8);
    35    memset (buffer, argc, 9);
    36    memset (buffer, argc, 10);
    37    memset (buffer, argc, 11);
    38    memset (buffer, argc, 12);
    39    memset (buffer, argc, 13);
    40    memset (buffer, argc, 14);
    41    memset (buffer, argc, 15);
    42    memset (buffer, argc, 16);
    43    memset (buffer, argc, 17);
    44    memset_disallowed = 0;
    45    if (chk_calls)
    46      abort ();
    47  }
    48  
    49  /* Test whether compile time checking is done where it should
    50     and so is runtime object size checking.  */
    51  void
    52  __attribute__((noinline))
    53  test2 (void)
    54  {
    55    struct A { char buf1[10]; char buf2[10]; } a;
    56    char *r = l1 == 1 ? &a.buf1[5] : &a.buf2[4];
    57    char buf3[20];
    58    int i;
    59    size_t l;
    60  
    61    /* The following calls should do runtime checking
    62       - length is not known, but destination is.  */
    63    chk_calls = 0;
    64    memset (a.buf1 + 2, 'a', l1);
    65    memset (r, '\0', l1 + 1);
    66    r = l1 == 1 ? __builtin_alloca (4) : &a.buf2[7];
    67    memset (r, argc, l1 + 2);
    68    memset (r + 2, 'Q', l1);
    69    r = buf3;
    70    for (i = 0; i < 4; ++i)
    71      {
    72        if (i == l1 - 1)
    73  	r = &a.buf1[1];
    74        else if (i == l1)
    75  	r = &a.buf2[7];
    76        else if (i == l1 + 1)
    77  	r = &buf3[5];
    78        else if (i == l1 + 2)
    79  	r = &a.buf1[9];
    80      }
    81    memset (r, '\0', l1);
    82    if (chk_calls != 5)
    83      abort ();
    84  
    85    /* Following have known destination and known length,
    86       so if optimizing certainly shouldn't result in the checking
    87       variants.  */
    88    chk_calls = 0;
    89    memset (a.buf1 + 2, '\0', 1);
    90    memset (r, argc, 2);
    91    r = l1 == 1 ? __builtin_alloca (4) : &a.buf2[7];
    92    memset (r, 'N', 3);
    93    r = buf3;
    94    l = 4;
    95    for (i = 0; i < 4; ++i)
    96      {
    97        if (i == l1 - 1)
    98  	r = &a.buf1[1], l = 2;
    99        else if (i == l1)
   100  	r = &a.buf2[7], l = 3;
   101        else if (i == l1 + 1)
   102  	r = &buf3[5], l = 4;
   103        else if (i == l1 + 2)
   104  	r = &a.buf1[9], l = 1;
   105      }
   106    memset (r, 'H', 1);
   107    /* Here, l is known to be at most 4 and __builtin_object_size (&buf3[16], 0)
   108       is 4, so this doesn't need runtime checking.  */
   109    memset (&buf3[16], 'd', l);
   110    /* Neither length nor destination known.  Doesn't need runtime checking.  */
   111    memset (s4, 'a', l1);
   112    memset (s4 + 2, '\0', l1 + 2);
   113    /* Destination unknown.  */
   114    memset (s4 + 4, 'b', 2);
   115    memset (s4 + 6, '\0', 4);
   116    if (chk_calls)
   117      abort ();
   118    chk_calls = 0;
   119  }
   120  
   121  /* Test whether runtime and/or compile time checking catches
   122     buffer overflows.  */
   123  void
   124  __attribute__((noinline))
   125  test3 (void)
   126  {
   127    struct A { char buf1[10]; char buf2[10]; } a;
   128    char buf3[20];
   129  
   130    chk_fail_allowed = 1;
   131    /* Runtime checks.  */
   132    if (__builtin_setjmp (chk_fail_buf) == 0)
   133      {
   134        memset (&a.buf2[9], '\0', l1 + 1);
   135        abort ();
   136      }
   137    if (__builtin_setjmp (chk_fail_buf) == 0)
   138      {
   139        memset (&a.buf2[7], 'T', strlen (s3) + 1);
   140        abort ();
   141      }
   142    /* This should be detectable at compile time already.  */
   143    if (__builtin_setjmp (chk_fail_buf) == 0)
   144      {
   145        memset (&buf3[19], 'b', 2);
   146        abort ();
   147      }
   148    chk_fail_allowed = 0;
   149  }
   150  
   151  #ifndef MAX_OFFSET
   152  #define MAX_OFFSET (sizeof (long long))
   153  #endif
   154  
   155  #ifndef MAX_COPY
   156  #define MAX_COPY (10 * sizeof (long long))
   157  #define MAX_COPY2 15
   158  #else
   159  #define MAX_COPY2 MAX_COPY
   160  #endif
   161  
   162  #ifndef MAX_EXTRA
   163  #define MAX_EXTRA (sizeof (long long))
   164  #endif
   165  
   166  #define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA)
   167  #define MAX_LENGTH2 (MAX_OFFSET + MAX_COPY2 + MAX_EXTRA)
   168  
   169  static union {
   170    char buf[MAX_LENGTH];
   171    long long align_int;
   172    long double align_fp;
   173  } u;
   174  
   175  char A = 'A';
   176  
   177  void
   178  __attribute__((noinline))
   179  test4 (void)
   180  {
   181    int off, len, i;
   182    char *p, *q;
   183  
   184    for (off = 0; off < MAX_OFFSET; off++)
   185      for (len = 1; len < MAX_COPY; len++)
   186        {
   187  	for (i = 0; i < MAX_LENGTH; i++)
   188  	  u.buf[i] = 'a';
   189  
   190  	p = memset (u.buf + off, '\0', len);
   191  	if (p != u.buf + off)
   192  	  abort ();
   193  
   194  	q = u.buf;
   195  	for (i = 0; i < off; i++, q++)
   196  	  if (*q != 'a')
   197  	    abort ();
   198  
   199  	for (i = 0; i < len; i++, q++)
   200  	  if (*q != '\0')
   201  	    abort ();
   202  
   203  	for (i = 0; i < MAX_EXTRA; i++, q++)
   204  	  if (*q != 'a')
   205  	    abort ();
   206  
   207  	p = memset (u.buf + off, A, len);
   208  	if (p != u.buf + off)
   209  	  abort ();
   210  
   211  	q = u.buf;
   212  	for (i = 0; i < off; i++, q++)
   213  	  if (*q != 'a')
   214  	    abort ();
   215  
   216  	for (i = 0; i < len; i++, q++)
   217  	  if (*q != 'A')
   218  	    abort ();
   219  
   220  	for (i = 0; i < MAX_EXTRA; i++, q++)
   221  	  if (*q != 'a')
   222  	    abort ();
   223  
   224  	p = memset (u.buf + off, 'B', len);
   225  	if (p != u.buf + off)
   226  	  abort ();
   227  
   228  	q = u.buf;
   229  	for (i = 0; i < off; i++, q++)
   230  	  if (*q != 'a')
   231  	    abort ();
   232  
   233  	for (i = 0; i < len; i++, q++)
   234  	  if (*q != 'B')
   235  	    abort ();
   236  
   237  	for (i = 0; i < MAX_EXTRA; i++, q++)
   238  	  if (*q != 'a')
   239  	    abort ();
   240        }
   241  }
   242  
   243  static union {
   244    char buf[MAX_LENGTH2];
   245    long long align_int;
   246    long double align_fp;
   247  } u2;
   248  
   249  void reset ()
   250  {
   251    int i;
   252  
   253    for (i = 0; i < MAX_LENGTH2; i++)
   254      u2.buf[i] = 'a';
   255  }
   256  
   257  void check (int off, int len, int ch)
   258  {
   259    char *q;
   260    int i;
   261  
   262    q = u2.buf;
   263    for (i = 0; i < off; i++, q++)
   264      if (*q != 'a')
   265        abort ();
   266  
   267    for (i = 0; i < len; i++, q++)
   268      if (*q != ch)
   269        abort ();
   270  
   271    for (i = 0; i < MAX_EXTRA; i++, q++)
   272      if (*q != 'a')
   273        abort ();
   274  }
   275  
   276  void
   277  __attribute__((noinline))
   278  test5 (void)
   279  {
   280    int off;
   281    char *p;
   282  
   283    /* len == 1 */
   284    for (off = 0; off < MAX_OFFSET; off++)
   285      {
   286        reset ();
   287  
   288        p = memset (u2.buf + off, '\0', 1);
   289        if (p != u2.buf + off) abort ();
   290        check (off, 1, '\0');
   291  
   292        p = memset (u2.buf + off, A, 1);
   293        if (p != u2.buf + off) abort ();
   294        check (off, 1, 'A');
   295  
   296        p = memset (u2.buf + off, 'B', 1);
   297        if (p != u2.buf + off) abort ();
   298        check (off, 1, 'B');
   299      }
   300  
   301    /* len == 2 */
   302    for (off = 0; off < MAX_OFFSET; off++)
   303      {
   304        reset ();
   305  
   306        p = memset (u2.buf + off, '\0', 2);
   307        if (p != u2.buf + off) abort ();
   308        check (off, 2, '\0');
   309  
   310        p = memset (u2.buf + off, A, 2);
   311        if (p != u2.buf + off) abort ();
   312        check (off, 2, 'A');
   313  
   314        p = memset (u2.buf + off, 'B', 2);
   315        if (p != u2.buf + off) abort ();
   316        check (off, 2, 'B');
   317      }
   318  
   319    /* len == 3 */
   320    for (off = 0; off < MAX_OFFSET; off++)
   321      {
   322        reset ();
   323  
   324        p = memset (u2.buf + off, '\0', 3);
   325        if (p != u2.buf + off) abort ();
   326        check (off, 3, '\0');
   327  
   328        p = memset (u2.buf + off, A, 3);
   329        if (p != u2.buf + off) abort ();
   330        check (off, 3, 'A');
   331  
   332        p = memset (u2.buf + off, 'B', 3);
   333        if (p != u2.buf + off) abort ();
   334        check (off, 3, 'B');
   335      }
   336  
   337    /* len == 4 */
   338    for (off = 0; off < MAX_OFFSET; off++)
   339      {
   340        reset ();
   341  
   342        p = memset (u2.buf + off, '\0', 4);
   343        if (p != u2.buf + off) abort ();
   344        check (off, 4, '\0');
   345  
   346        p = memset (u2.buf + off, A, 4);
   347        if (p != u2.buf + off) abort ();
   348        check (off, 4, 'A');
   349  
   350        p = memset (u2.buf + off, 'B', 4);
   351        if (p != u2.buf + off) abort ();
   352        check (off, 4, 'B');
   353      }
   354  
   355    /* len == 5 */
   356    for (off = 0; off < MAX_OFFSET; off++)
   357      {
   358        reset ();
   359  
   360        p = memset (u2.buf + off, '\0', 5);
   361        if (p != u2.buf + off) abort ();
   362        check (off, 5, '\0');
   363  
   364        p = memset (u2.buf + off, A, 5);
   365        if (p != u2.buf + off) abort ();
   366        check (off, 5, 'A');
   367  
   368        p = memset (u2.buf + off, 'B', 5);
   369        if (p != u2.buf + off) abort ();
   370        check (off, 5, 'B');
   371      }
   372  
   373    /* len == 6 */
   374    for (off = 0; off < MAX_OFFSET; off++)
   375      {
   376        reset ();
   377  
   378        p = memset (u2.buf + off, '\0', 6);
   379        if (p != u2.buf + off) abort ();
   380        check (off, 6, '\0');
   381  
   382        p = memset (u2.buf + off, A, 6);
   383        if (p != u2.buf + off) abort ();
   384        check (off, 6, 'A');
   385  
   386        p = memset (u2.buf + off, 'B', 6);
   387        if (p != u2.buf + off) abort ();
   388        check (off, 6, 'B');
   389      }
   390  
   391    /* len == 7 */
   392    for (off = 0; off < MAX_OFFSET; off++)
   393      {
   394        reset ();
   395  
   396        p = memset (u2.buf + off, '\0', 7);
   397        if (p != u2.buf + off) abort ();
   398        check (off, 7, '\0');
   399  
   400        p = memset (u2.buf + off, A, 7);
   401        if (p != u2.buf + off) abort ();
   402        check (off, 7, 'A');
   403  
   404        p = memset (u2.buf + off, 'B', 7);
   405        if (p != u2.buf + off) abort ();
   406        check (off, 7, 'B');
   407      }
   408  
   409    /* len == 8 */
   410    for (off = 0; off < MAX_OFFSET; off++)
   411      {
   412        reset ();
   413  
   414        p = memset (u2.buf + off, '\0', 8);
   415        if (p != u2.buf + off) abort ();
   416        check (off, 8, '\0');
   417  
   418        p = memset (u2.buf + off, A, 8);
   419        if (p != u2.buf + off) abort ();
   420        check (off, 8, 'A');
   421  
   422        p = memset (u2.buf + off, 'B', 8);
   423        if (p != u2.buf + off) abort ();
   424        check (off, 8, 'B');
   425      }
   426  
   427    /* len == 9 */
   428    for (off = 0; off < MAX_OFFSET; off++)
   429      {
   430        reset ();
   431  
   432        p = memset (u2.buf + off, '\0', 9);
   433        if (p != u2.buf + off) abort ();
   434        check (off, 9, '\0');
   435  
   436        p = memset (u2.buf + off, A, 9);
   437        if (p != u2.buf + off) abort ();
   438        check (off, 9, 'A');
   439  
   440        p = memset (u2.buf + off, 'B', 9);
   441        if (p != u2.buf + off) abort ();
   442        check (off, 9, 'B');
   443      }
   444  
   445    /* len == 10 */
   446    for (off = 0; off < MAX_OFFSET; off++)
   447      {
   448        reset ();
   449  
   450        p = memset (u2.buf + off, '\0', 10);
   451        if (p != u2.buf + off) abort ();
   452        check (off, 10, '\0');
   453  
   454        p = memset (u2.buf + off, A, 10);
   455        if (p != u2.buf + off) abort ();
   456        check (off, 10, 'A');
   457  
   458        p = memset (u2.buf + off, 'B', 10);
   459        if (p != u2.buf + off) abort ();
   460        check (off, 10, 'B');
   461      }
   462  
   463    /* len == 11 */
   464    for (off = 0; off < MAX_OFFSET; off++)
   465      {
   466        reset ();
   467  
   468        p = memset (u2.buf + off, '\0', 11);
   469        if (p != u2.buf + off) abort ();
   470        check (off, 11, '\0');
   471  
   472        p = memset (u2.buf + off, A, 11);
   473        if (p != u2.buf + off) abort ();
   474        check (off, 11, 'A');
   475  
   476        p = memset (u2.buf + off, 'B', 11);
   477        if (p != u2.buf + off) abort ();
   478        check (off, 11, 'B');
   479      }
   480  
   481    /* len == 12 */
   482    for (off = 0; off < MAX_OFFSET; off++)
   483      {
   484        reset ();
   485  
   486        p = memset (u2.buf + off, '\0', 12);
   487        if (p != u2.buf + off) abort ();
   488        check (off, 12, '\0');
   489  
   490        p = memset (u2.buf + off, A, 12);
   491        if (p != u2.buf + off) abort ();
   492        check (off, 12, 'A');
   493  
   494        p = memset (u2.buf + off, 'B', 12);
   495        if (p != u2.buf + off) abort ();
   496        check (off, 12, 'B');
   497      }
   498  
   499    /* len == 13 */
   500    for (off = 0; off < MAX_OFFSET; off++)
   501      {
   502        reset ();
   503  
   504        p = memset (u2.buf + off, '\0', 13);
   505        if (p != u2.buf + off) abort ();
   506        check (off, 13, '\0');
   507  
   508        p = memset (u2.buf + off, A, 13);
   509        if (p != u2.buf + off) abort ();
   510        check (off, 13, 'A');
   511  
   512        p = memset (u2.buf + off, 'B', 13);
   513        if (p != u2.buf + off) abort ();
   514        check (off, 13, 'B');
   515      }
   516  
   517    /* len == 14 */
   518    for (off = 0; off < MAX_OFFSET; off++)
   519      {
   520        reset ();
   521  
   522        p = memset (u2.buf + off, '\0', 14);
   523        if (p != u2.buf + off) abort ();
   524        check (off, 14, '\0');
   525  
   526        p = memset (u2.buf + off, A, 14);
   527        if (p != u2.buf + off) abort ();
   528        check (off, 14, 'A');
   529  
   530        p = memset (u2.buf + off, 'B', 14);
   531        if (p != u2.buf + off) abort ();
   532        check (off, 14, 'B');
   533      }
   534  
   535    /* len == 15 */
   536    for (off = 0; off < MAX_OFFSET; off++)
   537      {
   538        reset ();
   539  
   540        p = memset (u2.buf + off, '\0', 15);
   541        if (p != u2.buf + off) abort ();
   542        check (off, 15, '\0');
   543  
   544        p = memset (u2.buf + off, A, 15);
   545        if (p != u2.buf + off) abort ();
   546        check (off, 15, 'A');
   547  
   548        p = memset (u2.buf + off, 'B', 15);
   549        if (p != u2.buf + off) abort ();
   550        check (off, 15, 'B');
   551      }
   552  }
   553  
   554  void
   555  __attribute__((noinline))
   556  test6 (void)
   557  {
   558    int len;
   559    char *p;
   560  
   561    /* off == 0 */
   562    for (len = 0; len < MAX_COPY2; len++)
   563      {
   564        reset ();
   565  
   566        p = memset (u2.buf, '\0', len);
   567        if (p != u2.buf) abort ();
   568        check (0, len, '\0');
   569  
   570        p = memset (u2.buf, A, len);
   571        if (p != u2.buf) abort ();
   572        check (0, len, 'A');
   573  
   574        p = memset (u2.buf, 'B', len);
   575        if (p != u2.buf) abort ();
   576        check (0, len, 'B');
   577      }
   578  
   579    /* off == 1 */
   580    for (len = 0; len < MAX_COPY2; len++)
   581      {
   582        reset ();
   583  
   584        p = memset (u2.buf+1, '\0', len);
   585        if (p != u2.buf+1) abort ();
   586        check (1, len, '\0');
   587  
   588        p = memset (u2.buf+1, A, len);
   589        if (p != u2.buf+1) abort ();
   590        check (1, len, 'A');
   591  
   592        p = memset (u2.buf+1, 'B', len);
   593        if (p != u2.buf+1) abort ();
   594        check (1, len, 'B');
   595      }
   596  
   597    /* off == 2 */
   598    for (len = 0; len < MAX_COPY2; len++)
   599      {
   600        reset ();
   601  
   602        p = memset (u2.buf+2, '\0', len);
   603        if (p != u2.buf+2) abort ();
   604        check (2, len, '\0');
   605  
   606        p = memset (u2.buf+2, A, len);
   607        if (p != u2.buf+2) abort ();
   608        check (2, len, 'A');
   609  
   610        p = memset (u2.buf+2, 'B', len);
   611        if (p != u2.buf+2) abort ();
   612        check (2, len, 'B');
   613      }
   614  
   615    /* off == 3 */
   616    for (len = 0; len < MAX_COPY2; len++)
   617      {
   618        reset ();
   619  
   620        p = memset (u2.buf+3, '\0', len);
   621        if (p != u2.buf+3) abort ();
   622        check (3, len, '\0');
   623  
   624        p = memset (u2.buf+3, A, len);
   625        if (p != u2.buf+3) abort ();
   626        check (3, len, 'A');
   627  
   628        p = memset (u2.buf+3, 'B', len);
   629        if (p != u2.buf+3) abort ();
   630        check (3, len, 'B');
   631      }
   632  
   633    /* off == 4 */
   634    for (len = 0; len < MAX_COPY2; len++)
   635      {
   636        reset ();
   637  
   638        p = memset (u2.buf+4, '\0', len);
   639        if (p != u2.buf+4) abort ();
   640        check (4, len, '\0');
   641  
   642        p = memset (u2.buf+4, A, len);
   643        if (p != u2.buf+4) abort ();
   644        check (4, len, 'A');
   645  
   646        p = memset (u2.buf+4, 'B', len);
   647        if (p != u2.buf+4) abort ();
   648        check (4, len, 'B');
   649      }
   650  
   651    /* off == 5 */
   652    for (len = 0; len < MAX_COPY2; len++)
   653      {
   654        reset ();
   655  
   656        p = memset (u2.buf+5, '\0', len);
   657        if (p != u2.buf+5) abort ();
   658        check (5, len, '\0');
   659  
   660        p = memset (u2.buf+5, A, len);
   661        if (p != u2.buf+5) abort ();
   662        check (5, len, 'A');
   663  
   664        p = memset (u2.buf+5, 'B', len);
   665        if (p != u2.buf+5) abort ();
   666        check (5, len, 'B');
   667      }
   668  
   669    /* off == 6 */
   670    for (len = 0; len < MAX_COPY2; len++)
   671      {
   672        reset ();
   673  
   674        p = memset (u2.buf+6, '\0', len);
   675        if (p != u2.buf+6) abort ();
   676        check (6, len, '\0');
   677  
   678        p = memset (u2.buf+6, A, len);
   679        if (p != u2.buf+6) abort ();
   680        check (6, len, 'A');
   681  
   682        p = memset (u2.buf+6, 'B', len);
   683        if (p != u2.buf+6) abort ();
   684        check (6, len, 'B');
   685      }
   686  
   687    /* off == 7 */
   688    for (len = 0; len < MAX_COPY2; len++)
   689      {
   690        reset ();
   691  
   692        p = memset (u2.buf+7, '\0', len);
   693        if (p != u2.buf+7) abort ();
   694        check (7, len, '\0');
   695  
   696        p = memset (u2.buf+7, A, len);
   697        if (p != u2.buf+7) abort ();
   698        check (7, len, 'A');
   699  
   700        p = memset (u2.buf+7, 'B', len);
   701        if (p != u2.buf+7) abort ();
   702        check (7, len, 'B');
   703      }
   704  }
   705  
   706  void
   707  main_test (void)
   708  {
   709  #ifndef __OPTIMIZE__
   710    /* Object size checking is only intended for -O[s123].  */
   711    return;
   712  #endif
   713    __asm ("" : "=r" (l1) : "0" (l1));
   714    s4 = buffer;
   715    test1 ();
   716    test2 ();
   717    test3 ();
   718    test4 ();
   719    test5 ();
   720    test6 ();
   721  }