testcases/stdio.h

   1 #ifdef STANDALONE
   2
   3 #define RS232IN_DATA (*(volatile unsigned *) 0xFF000004)
   4 #define RS232IN_TAG  (*(volatile unsigned *) 0xFF000008)
   5 #define TSC          (*(volatile unsigned *) 0xFF00000C)
   6 #define SER_OUTBUSY() (*(volatile unsigned *)0xFF000000 != 0)
   7 #define SER_OUT(data) (*(volatile unsigned *)0xFF000000 = (data))
   8
   9 #define BUF_SIZE 1024 // must be a power of two
  10
  11 char _serial_buffer[BUF_SIZE];
  12 unsigned _serial_buffer_wp;
  13 unsigned _serial_buffer_rp;
  14
  15 void check_serial_input(void)
  16 {
  17         static unsigned last_serial_tag;
  18
  19         unsigned char tag = RS232IN_TAG;
  20         if (tag != last_serial_tag) {
  21                 _serial_buffer[_serial_buffer_wp++] = RS232IN_DATA;
  22                 _serial_buffer_wp &= BUF_SIZE-1;
  23                 last_serial_tag = tag;
  24                 if (_serial_buffer_wp == _serial_buffer_rp) {
  25                         while (SER_OUTBUSY());
  26                         SER_OUT('<');
  27                         while (SER_OUTBUSY());
  28                         SER_OUT('#');
  29                         while (SER_OUTBUSY());
  30                         SER_OUT('>');
  31                 }
  32         }
  33 }
  34
  35 static int _column = 0;
  36 int putchar(unsigned ch)
  37 {
  38     if (ch == '\n') {
  39         putchar('\r');
  40         _column = -1;
  41     } else if (ch == '\t') {
  42         do
  43             putchar(' ');
  44         while (_column & 7);
  45         return 1;
  46     }
  47
  48     check_serial_input();
  49     while (SER_OUTBUSY())
  50         check_serial_input();
  51     SER_OUT(ch);
  52     ++_column;
  53
  54     return 1;
  55 }
  56
  57 int getchar(void)
  58 {
  59     unsigned char tag, ch;
  60
  61     do
  62         check_serial_input();
  63     while (_serial_buffer_wp == _serial_buffer_rp);
  64
  65     ch = _serial_buffer[_serial_buffer_rp++];
  66     _serial_buffer_rp &= BUF_SIZE-1;
  67
  68     // Local echo
  69     putchar(ch);
  70
  71     if (ch == '\r')
  72         ch = '\n';
  73
  74     return ch;
  75 }
  76
  77 int puts(char *s)
  78 {
  79     int n = 0;
  80     while (*s)
  81         putchar(*s++), ++n;
  82
  83     putchar('\n');
  84
  85     return n;
  86 }
  87
  88
  89 int printf(char *fmt, ...);
  90
  91 int exit(int v)
  92 {
  93     asm("li $2, 0x87654321");
  94     asm("mtlo $2");
  95     asm(".word 0x48000000");
  96
  97     printf("THE END\n");
  98     for (;;);
  99 }
 100
 101 #endif
 102
 103 #include <stdarg.h>
 104
 105 /* Division-free integer printing */
 106 static void put_unsigned(unsigned n)
 107 {
 108     // (unsigned)-1 == 4294967295
 109     static unsigned powers10[] = {
 110         1000000000,
 111         100000000,
 112         10000000,
 113         1000000,
 114         100000,
 115         10000,
 116         1000,
 117         100,
 118         10,
 119         1,
 120         0
 121     };
 122     unsigned *p;
 123     unsigned leading_zero = 1;
 124
 125     if (!n) {
 126         putchar('0');
 127         return;
 128     }
 129
 130     for (p = powers10; *p; ++p) {
 131         unsigned scale = *p;
 132         unsigned i, t;
 133
 134         for (i = 0; n >= scale; ++i, n -= scale)
 135             ;
 136         if (i != 0 || !leading_zero) {
 137             putchar('0' + i);
 138             leading_zero = 0;
 139         }
 140     }
 141 }
 142
 143 /* Hokey printf substitute */
 144 int printf(char *fmt, ...)
 145 {
 146     va_list ap;
 147     va_start(ap, fmt);
 148
 149     for (;; ++fmt)
 150         switch (*fmt) {
 151         case '\0':
 152             va_end(ap);
 153             return 1; // XXX return val incorrect
 154         case '%':
 155             switch (*++fmt) {
 156             case 'd': {
 157                 int value = va_arg(ap, int);
 158                 if (value < 0)
 159                     putchar('-'), value = -value;
 160                 put_unsigned((unsigned) value);
 161                 break;
 162             }
 163             case 'c': {
 164                 char c = va_arg(ap, int);
 165                 putchar(c);
 166                 break;
 167             }
 168             case 's': {
 169                 char *s = va_arg(ap, char *);
 170                 while (*s)
 171                     putchar(*s++);
 172                 break;
 173             }
 174             default:
 175                 putchar(*fmt);
 176                 break;
 177             }
 178             break;
 179
 180         default:
 181             putchar(*fmt);
 182             break;
 183         }
 184 }
 185
 186 static char _lookahead = ' ';
 187
 188 static void _next(void)
 189 {
 190     _lookahead = getchar();
 191 }
 192
 193 static _skip_ws(void)
 194 {
 195     while (_lookahead == ' ' ||
 196            _lookahead == '\t' ||
 197            _lookahead == '\r' ||
 198            _lookahead == '\n')
 199         _next();
 200 }
 201
 202 static _skip_line(void)
 203 {
 204     while (_lookahead != '\n')
 205         _next();
 206 }
 207
 208 int scanf_hack(char *fmt, int *v)
 209 {
 210     static int next = 2;
 211
 212     *v = next;
 213
 214     next = 34;
 215 }
 216
 217 int scanf(char *fmt, ...)
 218 {
 219     int n = 0;
 220     va_list ap;
 221     va_start(ap, fmt);
 222
 223     for (;; ++fmt)
 224         switch (*fmt) {
 225         case '\0':
 226             va_end(ap);
 227             return n;
 228         case '%':
 229             switch (*++fmt) {
 230             case 'd': {
 231
 232                 int neg = 0;
 233                 int value = 0;
 234
 235                 _skip_ws();
 236                 if (_lookahead == '-')
 237                     neg = 1, _next();
 238
 239                 while ('0' <= _lookahead && _lookahead <= '9') {
 240                     value = value * 10 + _lookahead - '0';
 241                     _next();
 242                 }
 243
 244                 if (neg)
 245                     value = -value;
 246                 *va_arg(ap, int *) = value;
 247                 ++n;
 248                 break;
 249             }
 250
 251             default:
 252                 continue;
 253             }
 254             break;
 255
 256         case ' ':
 257             _skip_ws();
 258             break;
 259
 260         default:
 261             if (*fmt == _lookahead)
 262                 break;
 263             else {
 264                 _skip_line();
 265                 return n;
 266             }
 267         }
 268 }
 269
 270 int strlen(char *s)
 271 {
 272     int n;
 273
 274     for (n = 0; *s; ++n, ++s)
 275         ;
 276
 277     return n;
 278 }
 279
 280 int abs(int v) { return v < 0 ? -v : v; }
 281
 282 int atoi(char *s)
 283 {
 284     int neg = 0;
 285     int value = 0;
 286
 287     while (*s && (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r'))
 288         ++s;
 289
 290     if (*s == '-')
 291         neg = 1, ++s;
 292
 293     while ('0' <= *s && *s <= '9') {
 294         value = value * 10 + _lookahead - '0';
 295         ++s;
 296     }
 297
 298     if (neg)
 299         value = -value;
 300
 301     return value;
 302 }
 303
 304 typedef char *FILE;
 305
 306 FILE *fopen(char *name, char *mode)
 307 {
 308     static FILE f =
 309 "#include <stdio.h>\n"
 310 "#define X(s) (!(s&3)-((s&3)==2))\n"
 311 "#define W while\n"
 312 "char Z[82][82],A,B,f,g=26;z(q){return atoi(q);}m(d,l){return\n"
 313 "Z[   B       +    X      (   f     +\n"
 314 "3) * d+l *X(f+ 2 )][ A+X ( f ) * d +\n"
 315 "l* X           (     f     + 3 ) ] ;}int\n"
 316 "h= 0;D(p,s)char*s; {W(h>>3<p>> 3 ) {putchar('\\t'\n"
 317 ");           h =       (       h   +8\n"
 318 ")&~7 ;}W(h < p ){putchar(' ');++h; }(void)printf(\n"
 319 "\"%s\"   ,   s                 )     ;h+=strlen(s);}main(x,a)char **a; {\n"
 320 "# define P(x) (x?(5-(x))*(6-(x ))/2:11)\n"
 321 "int b; { char b[256],i,  j=0;  FILE*F;F=fopen(x-1?a[1]:\"buzzard.c\",\"r\");W(\n"
 322 "fgets( b ,256 ,F)){for(i=0;b[ i];++ i)\n"
 323 "Z[j][i ] =( b [     i   ]     ==' '?1:2*(b[i]==(x>2?*a[2]:'\\\\')));++j;}fclose\n"
 324 "(F);}A   =4 ; B = 3 ; f = 1;x >3? A=z(a[3]),B=z(a[4]):0;b='\\n';do{if(b=='\\n'\n"
 325 "){int y ,     s , d , p   , q       ,i;for\n"
 326 "(y=-11; y<= 11;++ y){ for(s = 1 ,d=0;s+3;s-=2){for\n"
 327 "(;d!=2    +       3   * s     ;     d+=s){\n"
 328 "if(m(d,0) !=1 ){p=P (d) ;if (abs( y )\n"
 329 "   <p&&   !   m       (       d   , 0 )||abs(y)>p)break;for\n"
 330 "(i  =-p;i<p;++i)D(g+i*2,\"--\");D(0,\"-\");break;}if(d==5)continue;\n"
 331 "p=P(d+1);q=P(d);if\n"
 332 "(abs(y)         >q)continue;if \n"
 333 "(abs(y)         <p)D(g-s*(2*p+1),\"|\");else if(m(d,s)){if\n"
 334 "(abs(y)         <=p)for(i=(s==1?-q:p);i!=(s==1?-p:q);\n"
 335 "(abs(y)         ),++i)D(g+2*i+(s==-1),\"--\");}else if\n"
 336 "(abs(y)         ==p)D(g-s*(2*p+1),\"|\");else D(g-\n"
 337 "(abs(y)         *s*2),(s==1)^(y>0)?\"\\\\\":\"/\");}d-=s;}puts(\n"
 338 "\"\");h=0;}}f+=(b=='r')-(b=='l');f&=3;if(b=='f'){if(!m(1,0))continue;\n"
 339 "A+=X(f);B+=X(f-1);}}W((b=getchar())!=-1&&m(0,0)==1);return 0;}\n"
 340 ;
 341
 342     return &f;
 343 }
 344
 345 #define NULL ((void *) 0)
 346
 347 int fclose(FILE *f) {}
 348 char *fgets(char *str, int size, FILE *f)
 349 {
 350     char *s = str;
 351     char *fp = *f;
 352
 353     if (!*fp)
 354         return NULL;
 355
 356     while (1 < size && *fp) {
 357         *s++ = *fp++;
 358         --size;
 359         if (fp[-1] == '\n')
 360             break;
 361     }
 362
 363     if (s != str && size)
 364         *s = '\0';
 365
 366     *f = fp;
 367     return str;
 368 }
 369
 370 unsigned __pre_main_t0;
 371
 372 void __pre_main(void)
 373 {
 374     __pre_main_t0 = TSC;
 375 }
 376
 377 void __post_main(void)
 378 {
 379     printf("Program spent %d cycles in main\n", TSC - __pre_main_t0);
 380 }
 381
 382 extern char _end[];
 383
 384
 385 void *__sbrk_p = _end;
 386
 387 void *malloc(unsigned size)
 388 {
 389     void *res = __sbrk_p;
 390
 391     __sbrk_p += size;
 392 }
 393
 394 void memset(void *d, char v, unsigned size)
 395 {
 396     char *cp = (char *) d;
 397
 398     while ((unsigned) cp & 3 && size)
 399         *cp++ = v, --size;
 400
 401     unsigned *up = (unsigned *) cp;
 402     unsigned vvvv = v * 0x1010101;
 403     while (size > 32) {
 404         up[0] = vvvv;
 405         up[1] = vvvv;
 406         up[2] = vvvv;
 407         up[3] = vvvv;
 408         up[4] = vvvv;
 409         up[5] = vvvv;
 410         up[6] = vvvv;
 411         up[7] = vvvv;
 412         up += 8;
 413         size -= 32;
 414     }
 415
 416     cp = (char *) up;
 417     while (size)
 418         *cp++ = v, --size;
 419 }
 420
 421 // Modern GCCs provide these builtin, but ours is a bit stale
 422
 423
 424 static inline int  __builtin_rdhwr(int k)
 425 {
 426     int r;
 427
 428     asm(".set push;"
 429         ".set mips32r2;"
 430         "rdhwr %0,$%1;"
 431         ".set pop" : "=r" (r) : "i" (k));
 432
 433     return r;
 434 }
 435
 436 typedef unsigned size_t;
 437
 438 static inline void __builtin_flush_icache(void *location, size_t len)
 439 {
 440     const int SYNCI_Step = 1;
 441     unsigned inc = __builtin_rdhwr(SYNCI_Step);
 442     void *end = location + len;
 443
 444     for (location = (void *) ((unsigned) location & ~(inc - 1));
 445          location < end;
 446          location += inc) {
 447             asm(".set push;"
 448                 ".set mips32r2;"
 449                 "synci %0;"
 450                 ".set pop" :: "m" (* (char *) location));
 451     }
 452 }