tests/boundtest.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4
   5 #define NB_ITS 1000000
   6 //#define NB_ITS 1
   7 #define TAB_SIZE 100
   8
   9 int tab[TAB_SIZE];
  10 int ret_sum;
  11 char tab3[256];
  12
  13 int test1(void)
  14 {
  15     int i, sum = 0;
  16     for(i=0;i<TAB_SIZE;i++) {
  17         sum += tab[i];
  18     }
  19     return sum;
  20 }
  21
  22 /* error */
  23 int test2(void)
  24 {
  25     int i, sum = 0;
  26     for(i=0;i<TAB_SIZE + 1;i++) {
  27         sum += tab[i];
  28     }
  29     return sum;
  30 }
  31
  32 /* actually, profiling test */
  33 int test3(void)
  34 {
  35     int sum;
  36     int i, it;
  37
  38     sum = 0;
  39     for(it=0;it<NB_ITS;it++) {
  40         for(i=0;i<TAB_SIZE;i++) {
  41             sum += tab[i];
  42         }
  43     }
  44     return sum;
  45 }
  46
  47 /* ok */
  48 int test4(void)
  49 {
  50     int i, sum = 0;
  51     int *tab4;
  52
  53     tab4 = malloc(20 * sizeof(int));
  54     for(i=0;i<20;i++) {
  55         sum += tab4[i];
  56     }
  57     free(tab4);
  58
  59     return sum;
  60 }
  61
  62 /* error */
  63 int test5(void)
  64 {
  65     int i, sum = 0;
  66     int *tab4;
  67
  68     tab4 = malloc(20 * sizeof(int));
  69     for(i=0;i<21;i++) {
  70         sum += tab4[i];
  71     }
  72     free(tab4);
  73
  74     return sum;
  75 }
  76
  77 /* error */
  78 int test6(void)
  79 {
  80     int i, sum = 0;
  81     int *tab4;
  82
  83     tab4 = malloc(20 * sizeof(int));
  84     free(tab4);
  85     for(i=0;i<21;i++) {
  86         sum += tab4[i];
  87     }
  88
  89     return sum;
  90 }
  91
  92 /* error */
  93 int test7(void)
  94 {
  95     int i, sum = 0;
  96     int *p;
  97
  98     for(i=0;i<TAB_SIZE + 1;i++) {
  99         p = &tab[i];
 100         if (i == TAB_SIZE)
 101             printf("i=%d %x\n", i, p);
 102         sum += *p;
 103     }
 104     return sum;
 105 }
 106
 107 /* ok */
 108 int test8(void)
 109 {
 110     int i, sum = 0;
 111     int tab[10];
 112
 113     for(i=0;i<10;i++) {
 114         sum += tab[i];
 115     }
 116     return sum;
 117 }
 118
 119 /* error */
 120 int test9(void)
 121 {
 122     int i, sum = 0;
 123     char tab[10];
 124
 125     for(i=0;i<11;i++) {
 126         sum += tab[i];
 127     }
 128     return sum;
 129 }
 130
 131 /* ok */
 132 int test10(void)
 133 {
 134     char tab[10];
 135     char tab1[10];
 136
 137     memset(tab, 0, 10);
 138     memcpy(tab, tab1, 10);
 139     memmove(tab, tab1, 10);
 140     return 0;
 141 }
 142
 143 /* error */
 144 int test11(void)
 145 {
 146     char tab[10];
 147
 148     memset(tab, 0, 11);
 149     return 0;
 150 }
 151
 152 /* error */
 153 int test12(void)
 154 {
 155     void *ptr;
 156     ptr = malloc(10);
 157     free(ptr);
 158     free(ptr);
 159     return 0;
 160 }
 161
 162 /* error */
 163 int test13(void)
 164 {
 165     char pad1 = 0;
 166     char tab[10];
 167     char pad2 = 0;
 168     memset(tab, 'a', sizeof(tab));
 169     return strlen(tab);
 170 }
 171
 172 #if defined __i386__ || defined __x86_64__
 173 #define allocf(x)
 174 #else
 175 #define alloca(x) malloc(x)
 176 #define allocf(x) free(x)
 177 #endif
 178
 179 int test14(void)
 180 {
 181     char *p = alloca(TAB_SIZE);
 182     size_t ret;
 183     memset(p, 'a', TAB_SIZE);
 184     p[TAB_SIZE-1] = 0;
 185     ret = strlen(p);
 186     allocf(p);
 187     return ret;
 188 }
 189
 190 /* error */
 191 int test15(void)
 192 {
 193     char *p = alloca(TAB_SIZE-1);
 194     size_t ret;
 195     memset(p, 'a', TAB_SIZE);
 196     p[TAB_SIZE-1] = 0;
 197     ret = strlen(p);
 198     allocf(p);
 199     return ret;
 200 }
 201
 202 /* ok */
 203 int test16()
 204 {
 205     char *demo = "This is only a test.";
 206     char *p;
 207
 208     p = alloca(16);
 209     strcpy(p,"12345678901234");
 210     allocf(p);
 211
 212     /* Test alloca embedded in a larger expression */
 213     printf("alloca : %s : %s\n", p, strcpy(alloca(strlen(demo)+1),demo) );
 214
 215     return 0;
 216 }
 217
 218 /* error */
 219 int test17()
 220 {
 221     char *demo = "This is only a test.";
 222     char *p;
 223
 224     p = alloca(16);
 225     strcpy(p,"12345678901234");
 226     allocf(p);
 227
 228     /* Test alloca embedded in a larger expression */
 229     printf("alloca : %s : %s\n", p, strcpy(alloca(strlen(demo)),demo) );
 230
 231     return 0;
 232 }
 233
 234 int test18(void)
 235 {
 236     int i, sum = 0, n = TAB_SIZE;
 237     int tab[n];
 238     for(i=0;i<TAB_SIZE+1;i++) {
 239         sum += tab[i];
 240     }
 241     return sum;
 242 }
 243
 244 int (*table_test[])(void) = {
 245     test1,
 246     test2,
 247     test3,
 248     test4,
 249     test5,
 250     test6,
 251     test7,
 252     test8,
 253     test9,
 254     test10,
 255     test11,
 256     test12,
 257     test13,
 258     test14,
 259     test15,
 260     test16,
 261     test17,
 262     test18
 263 };
 264
 265 int main(int argc, char **argv)
 266 {
 267     int i;
 268     char *cp;
 269     int index;
 270     int (*ftest)(void);
 271     int index_max = sizeof(table_test)/sizeof(table_test[0]);
 272
 273     /* check bounds checking main arg */
 274     for (i = 0; i < argc; i++) {
 275         cp = argv[i];
 276         while (*cp) {
 277             cp++;
 278         }
 279     }
 280
 281     if (argc < 2) {
 282         printf(
 283             "test TCC bound checking system\n"
 284             "usage: boundtest N\n"
 285             "  1 <= N <= %d\n", index_max);
 286         exit(1);
 287     }
 288
 289     index = 0;
 290     if (argc >= 2)
 291         index = atoi(argv[1]) - 1;
 292
 293     if ((index < 0) || (index >= index_max)) {
 294         printf("N is outside of the valid range (%d)\n", index);
 295         exit(2);
 296     }
 297
 298     /* well, we also use bounds on this ! */
 299     ftest = table_test[index];
 300     ftest();
 301
 302     return 0;
 303 }
 304
 305 /*
 306  * without bound   0.77 s
 307  * with bounds    4.73
 308  */