nsz Git - libfirm/blob - ir/be/test/rtsopt.c

   1 #include <math.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5
   6 /* transform info memcpy(test + strlen(test), "ab", 2), gcc(+), icc(-) */
   7 char *test_strcat(void) {
   8         static char test[10] = "ab";
   9         return strcat(test, "bc");
  10 }
  11
  12 /* evaluate, gcc(+), icc(-) */
  13 char *test_strchr(void) {
  14         return strchr("abc", 'b');
  15 }
  16
  17 /* evaluate, gcc(+), icc(-) */
  18 char *test_strrchr(void) {
  19         return strrchr("abc", 'b');
  20 }
  21
  22 /* evaluate into 0, gcc(+) , icc(-)*/
  23 int test_strcmp1(const char *s) {
  24         return strcmp(s, s);
  25 }
  26
  27 /* transform info -(*s), gcc(+), icc(-) */
  28 int test_strcmp2(const char *s) {
  29         return strcmp("", s);
  30 }
  31
  32 /* transform info *s, gcc(+), icc(-) */
  33 int test_strcmp3(const char *s) {
  34         return strcmp(s, "");
  35 }
  36
  37 /* evaluate, gcc(+), icc(-)      */
  38 int test_strcmp4(void) {
  39         return strcmp("ab", "cd");
  40 }
  41
  42 /* evaluate into 0, gcc(+), icc(-) */
  43 int test_strncmp1(const char *s, int len) {
  44         return strncmp(s, s, len);
  45 }
  46
  47 /* transform info -(*s), gcc(+), icc(-) */
  48 int test_strncmp2(const char *s) {
  49         return strncmp("", s, 1);
  50 }
  51
  52 /* transform info *s, gcc(+), icc(-) */
  53 int test_strncmp3(const char *s) {
  54         return strncmp(s, "", 1);
  55 }
  56
  57 /* evaluate, gcc(+) */
  58 int test_strncmp4(void) {
  59         return strncmp("ab", "cd", 2);
  60 }
  61
  62 /* transform into *s = '\0', s, gcc(+), icc(-) */
  63 char *test_strcpy1(char *s) {
  64         return strcpy(s, "");
  65 }
  66
  67 /* transform into memcpy(s, c, len(c)+1), gcc(+), icc(-) */
  68 char *test_strcpy2(char *s) {
  69         return strcpy(s, "ab");
  70 }
  71
  72 /* evaluate, gcc(+), icc(+) */
  73 int test_strlen(void) {
  74         return strlen("ab");
  75 }
  76
  77 /* transform into d, gcc(+), icc(+) */
  78 void *test_memcpy1(void *d, void *s) {
  79         return memcpy(d, s, 0);
  80 }
  81
  82 /* transform into *(char *)d = *(char *)s, d, gcc(+), icc(+) */
  83 void *test_memcpy2(void *d, void *s) {
  84         return memcpy(d, s, 1);
  85 }
  86
  87 /* transform into *(short *)d = *(short *)s, d, gcc(+), icc(+) */
  88 void *test_memcpy3(short *d, short *s) {
  89         return memcpy(d, s, 2);
  90 }
  91
  92 /* transform into *(int *)d = *(int *)s, d, gcc(+), icc(+) */
  93 void *test_memcpy4(int *d, int *s) {
  94         return memcpy(d, s, 4);
  95 }
  96
  97 /* transform into *(long long *)d = *(long long *)s, d, gcc(+), icc(+) */
  98 void *test_memcpy5(long long *d, long long *s) {
  99         return memcpy(d, s, 8);
 100 }
 101
 102 /* transform into d, gcc(+), icc(+) */
 103 void *test_memset1(void *d, int C) {
 104         return memset(d, C, 0);
 105 }
 106
 107 /* transform into *(char *)d = (char)C, d, gcc(+), icc(+) */
 108 void *test_memset2(void *d, int C) {
 109         return memset(d, C, 1);
 110 }
 111
 112 /* transform into *(short *)d = (short)((char)C * 0x0101), d, gcc(+), icc(+) */
 113 void *test_memset3(short *d, int C) {
 114         return memset(d, C, 2);
 115 }
 116
 117 /* transform into *(int *)d = (int)((char)C * 0x01010101), d, gcc(+), icc(+) */
 118 void *test_memset4(int *d, int C) {
 119         return memset(d, C, 4);
 120 }
 121
 122 /* transform into *(long long *)d = (long long)((char)C) * 0x0101010101010101, d, gcc(+), icc(+) */
 123 void *test_memset5(long long *d, int C) {
 124         return memset(d, C, 8);
 125 }
 126
 127 /* evaluate into 1.0, gcc(+), icc(-) */
 128 double test_pow1(double a) {
 129         return pow(1.0, a);
 130 }
 131
 132 /* evaluate into 1.0, gcc(+), icc(+) */
 133 double test_pow2(double a) {
 134         return pow(a, 0.0);
 135 }
 136
 137 /* transform into sqrt(a), gcc(-), icc(+) */
 138 double test_pow3(double a) {
 139         return pow(a, 0.5);
 140 }
 141
 142 /* evaluate into a, gcc(+), icc(+) */
 143 double test_pow4(double a) {
 144         return pow(a, 1.0);
 145 }
 146
 147 /* evaluate into 1.0/a. gcc(+), icc(+) */
 148 double test_pow5(double a) {
 149         return pow(a, -1.0);
 150 }
 151
 152 /* transform into putchar, gcc(+), icc(-) */
 153 void test_printf1() {
 154         printf("\n");
 155 }
 156
 157 /* transform into putchar(c), gcc(+), icc(+) */
 158 void test_printf2(char c) {
 159         printf("%c", c);
 160 }
 161
 162 /* transform into puts(s), gcc(+), icc(-) */
 163 void test_printf3(char *s) {
 164         printf("%s\n", s);
 165 }
 166
 167 /* transform into fwrite(s,strlen(s),f), gcc(+) OR fputs(s, f), icc(+) */
 168 void test_fprintf1(FILE *f) {
 169         fprintf(f, "ab");
 170 }
 171
 172 /* transform into fputc(c,f), gcc(+), icc(+) */
 173 void test_fprintf2(FILE *f, char c) {
 174         fprintf(f, "%c", c);
 175 }
 176
 177 /* transform into fputs(s,file), gcc(+), icc(+) */
 178 void test_fprintf3(FILE *f, char *s) {
 179         fprintf(f, "%s", s);
 180 }
 181
 182 /* transform into memcpy(d,s,strlen(s)+1,1), gcc(+), icc(-) */
 183 void test_sprintf1(char *d) {
 184         sprintf(d, "ab");
 185 }
 186
 187 /* transform into d[0] = c; d[1] = '\0';, gcc(-), icc(-) */
 188 void test_sprintf2(char *d, char c) {
 189         sprintf(d, "%c", c);
 190 }
 191
 192 /* transform into memcpy(d, s, strlen(s)+1, 1)), gcc(-), icc(-) */
 193 void test_sprintf3(char *d, char *s) {
 194         sprintf("%s", s);
 195 }
 196
 197 /* transform fwrite(s,1,strlen(s),F), gcc(+), icc(-) */
 198 void test_fputs(FILE *f) {
 199         fputs("abs", f);
 200 }
 201
 202 /* evaluate to 0, gcc(-), icc(-) */
 203 int test_fwrite1(FILE *f, char *s, int l) {
 204         return fwrite(s, 0, l, f);
 205 }
 206
 207 /* evaluate to 0, gcc(-), icc(-) */
 208 int test_fwrite2(FILE *f, char *s, int l) {
 209         return fwrite(s, l, 0, f);
 210 }
 211
 212 /* transform into fputc(s[0],F) if this is usefull ..., gcc(-), icc(-) */
 213 int test_fwrite3(FILE *f, char *s, int l) {
 214         return fwrite(s,1,1,f);
 215 }
 216
 217 /* transform into cos(x), gcc(+), icc(-) */
 218 double test_cos(double x) {
 219         return cos(-x);
 220 }
 221
 222 /* transform into cosf(x), gcc(+), icc(-) */
 223 float test_cosf(float x) {
 224         return cosf(-x);
 225 }
 226
 227 /* transform into cosl(x), gcc(+), icc(-) */
 228 long double test_cosl(long double x) {
 229         return cosl(-x);
 230 }
 231
 232 /* evaluate into 0.0, gcc(+), icc(+) */
 233 double test_sqrt1() {
 234         return sqrt(0.0);
 235 }
 236
 237 /* evaluate into 1.0, gcc(+), icc(+) */
 238 double test_sqrt2() {
 239         return sqrt(1.0);
 240 }
 241
 242 /* evaluate, gcc(+), icc(+) */
 243 double test_sqrt3() {
 244         return sqrt(7.345);
 245 }
 246
 247 /* transform exit(3) into a return 3, gcc(-), icc(-) */
 248 int main() {
 249         exit(3);
 250         return 0;
 251 }