benchmarks/common/syscalls.c

   1 // See LICENSE for license details.
   2
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include <stdarg.h>
   6 #include <stdio.h>
   7 #include <limits.h>
   8 #include "util.h"
   9
  10 #define SYS_write 64
  11 #define SYS_exit 93
  12 #define SYS_stats 1234
  13
  14 #undef strcmp
  15
  16 extern volatile uint64_t tohost;
  17 extern volatile uint64_t fromhost;
  18
  19 static uintptr_t handle_frontend_syscall(uintptr_t which, uint64_t arg0, uint64_t arg1, uint64_t arg2)
  20 {
  21   volatile uint64_t magic_mem[8] __attribute__((aligned(64)));
  22   magic_mem[0] = which;
  23   magic_mem[1] = arg0;
  24   magic_mem[2] = arg1;
  25   magic_mem[3] = arg2;
  26   __sync_synchronize();
  27
  28   tohost = (uintptr_t)magic_mem;
  29   while (fromhost == 0)
  30     ;
  31   fromhost = 0;
  32
  33   __sync_synchronize();
  34   return magic_mem[0];
  35 }
  36
  37 #define NUM_COUNTERS 2
  38 static uintptr_t counters[NUM_COUNTERS];
  39 static char* counter_names[NUM_COUNTERS];
  40
  41 static int handle_stats(int enable)
  42 {
  43   int i = 0;
  44 #define READ_CTR(name) do { \
  45     while (i >= NUM_COUNTERS) ; \
  46     uintptr_t csr = read_csr(name); \
  47     if (!enable) { csr -= counters[i]; counter_names[i] = #name; } \
  48     counters[i++] = csr; \
  49   } while (0)
  50
  51   READ_CTR(mcycle);
  52   READ_CTR(minstret);
  53
  54 #undef READ_CTR
  55   return 0;
  56 }
  57
  58 void __attribute__((noreturn)) tohost_exit(uintptr_t code)
  59 {
  60   tohost = (code << 1) | 1;
  61   while (1);
  62 }
  63
  64 uintptr_t handle_trap(uintptr_t cause, uintptr_t epc, uintptr_t regs[32])
  65 {
  66   if (cause != CAUSE_MACHINE_ECALL)
  67     tohost_exit(1337);
  68   else if (regs[17] == SYS_exit)
  69     tohost_exit(regs[10]);
  70   else if (regs[17] == SYS_stats)
  71     regs[10] = handle_stats(regs[10]);
  72   else
  73     regs[10] = handle_frontend_syscall(regs[17], regs[10], regs[11], regs[12]);
  74
  75   return epc + ((*(unsigned short*)epc & 3) == 3 ? 4 : 2);
  76 }
  77
  78 static uintptr_t syscall(uintptr_t num, uintptr_t arg0, uintptr_t arg1, uintptr_t arg2)
  79 {
  80   register uintptr_t a7 asm("a7") = num;
  81   register uintptr_t a0 asm("a0") = arg0;
  82   register uintptr_t a1 asm("a1") = arg1;
  83   register uintptr_t a2 asm("a2") = arg2;
  84   asm volatile ("scall" : "+r"(a0) : "r"(a1), "r"(a2), "r"(a7));
  85   return a0;
  86 }
  87
  88 void exit(int code)
  89 {
  90   syscall(SYS_exit, code, 0, 0);
  91   while (1);
  92 }
  93
  94 void setStats(int enable)
  95 {
  96   syscall(SYS_stats, enable, 0, 0);
  97 }
  98
  99 void printstr(const char* s)
 100 {
 101   syscall(SYS_write, 1, (uintptr_t)s, strlen(s));
 102 }
 103
 104 void __attribute__((weak)) thread_entry(int cid, int nc)
 105 {
 106   // multi-threaded programs override this function.
 107   // for the case of single-threaded programs, only let core 0 proceed.
 108   while (cid != 0);
 109 }
 110
 111 int __attribute__((weak)) main(int argc, char** argv)
 112 {
 113   // single-threaded programs override this function.
 114   printstr("Implement main(), foo!\n");
 115   return -1;
 116 }
 117
 118 static void init_tls()
 119 {
 120   register void* thread_pointer asm("tp");
 121   extern char _tls_data;
 122   extern __thread char _tdata_begin, _tdata_end, _tbss_end;
 123   size_t tdata_size = &_tdata_end - &_tdata_begin;
 124   memcpy(thread_pointer, &_tls_data, tdata_size);
 125   size_t tbss_size = &_tbss_end - &_tdata_end;
 126   memset(thread_pointer + tdata_size, 0, tbss_size);
 127 }
 128
 129 void _init(int cid, int nc)
 130 {
 131   init_tls();
 132   thread_entry(cid, nc);
 133
 134   // only single-threaded programs should ever get here.
 135   int ret = main(0, 0);
 136
 137   char buf[NUM_COUNTERS * 32] __attribute__((aligned(64)));
 138   char* pbuf = buf;
 139   for (int i = 0; i < NUM_COUNTERS; i++)
 140     if (counters[i])
 141       pbuf += sprintf(pbuf, "%s = %d\n", counter_names[i], counters[i]);
 142   if (pbuf != buf)
 143     printstr(buf);
 144
 145   exit(ret);
 146 }
 147
 148 #undef putchar
 149 int putchar(int ch)
 150 {
 151   static __thread char buf[64] __attribute__((aligned(64)));
 152   static __thread int buflen = 0;
 153
 154   buf[buflen++] = ch;
 155
 156   if (ch == '\n' || buflen == sizeof(buf))
 157   {
 158     syscall(SYS_write, 1, (uintptr_t)buf, buflen);
 159     buflen = 0;
 160   }
 161
 162   return 0;
 163 }
 164
 165 void printhex(uint64_t x)
 166 {
 167   char str[17];
 168   int i;
 169   for (i = 0; i < 16; i++)
 170   {
 171     str[15-i] = (x & 0xF) + ((x & 0xF) < 10 ? '0' : 'a'-10);
 172     x >>= 4;
 173   }
 174   str[16] = 0;
 175
 176   printstr(str);
 177 }
 178
 179 static inline void printnum(void (*putch)(int, void**), void **putdat,
 180                     unsigned long long num, unsigned base, int width, int padc)
 181 {
 182   unsigned digs[sizeof(num)*CHAR_BIT];
 183   int pos = 0;
 184
 185   while (1)
 186   {
 187     digs[pos++] = num % base;
 188     if (num < base)
 189       break;
 190     num /= base;
 191   }
 192
 193   while (width-- > pos)
 194     putch(padc, putdat);
 195
 196   while (pos-- > 0)
 197     putch(digs[pos] + (digs[pos] >= 10 ? 'a' - 10 : '0'), putdat);
 198 }
 199
 200 static unsigned long long getuint(va_list *ap, int lflag)
 201 {
 202   if (lflag >= 2)
 203     return va_arg(*ap, unsigned long long);
 204   else if (lflag)
 205     return va_arg(*ap, unsigned long);
 206   else
 207     return va_arg(*ap, unsigned int);
 208 }
 209
 210 static long long getint(va_list *ap, int lflag)
 211 {
 212   if (lflag >= 2)
 213     return va_arg(*ap, long long);
 214   else if (lflag)
 215     return va_arg(*ap, long);
 216   else
 217     return va_arg(*ap, int);
 218 }
 219
 220 static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_list ap)
 221 {
 222   register const char* p;
 223   const char* last_fmt;
 224   register int ch, err;
 225   unsigned long long num;
 226   int base, lflag, width, precision, altflag;
 227   char padc;
 228
 229   while (1) {
 230     while ((ch = *(unsigned char *) fmt) != '%') {
 231       if (ch == '\0')
 232         return;
 233       fmt++;
 234       putch(ch, putdat);
 235     }
 236     fmt++;
 237
 238     // Process a %-escape sequence
 239     last_fmt = fmt;
 240     padc = ' ';
 241     width = -1;
 242     precision = -1;
 243     lflag = 0;
 244     altflag = 0;
 245   reswitch:
 246     switch (ch = *(unsigned char *) fmt++) {
 247
 248     // flag to pad on the right
 249     case '-':
 250       padc = '-';
 251       goto reswitch;
 252
 253     // flag to pad with 0's instead of spaces
 254     case '0':
 255       padc = '0';
 256       goto reswitch;
 257
 258     // width field
 259     case '1':
 260     case '2':
 261     case '3':
 262     case '4':
 263     case '5':
 264     case '6':
 265     case '7':
 266     case '8':
 267     case '9':
 268       for (precision = 0; ; ++fmt) {
 269         precision = precision * 10 + ch - '0';
 270         ch = *fmt;
 271         if (ch < '0' || ch > '9')
 272           break;
 273       }
 274       goto process_precision;
 275
 276     case '*':
 277       precision = va_arg(ap, int);
 278       goto process_precision;
 279
 280     case '.':
 281       if (width < 0)
 282         width = 0;
 283       goto reswitch;
 284
 285     case '#':
 286       altflag = 1;
 287       goto reswitch;
 288
 289     process_precision:
 290       if (width < 0)
 291         width = precision, precision = -1;
 292       goto reswitch;
 293
 294     // long flag (doubled for long long)
 295     case 'l':
 296       lflag++;
 297       goto reswitch;
 298
 299     // character
 300     case 'c':
 301       putch(va_arg(ap, int), putdat);
 302       break;
 303
 304     // string
 305     case 's':
 306       if ((p = va_arg(ap, char *)) == NULL)
 307         p = "(null)";
 308       if (width > 0 && padc != '-')
 309         for (width -= strnlen(p, precision); width > 0; width--)
 310           putch(padc, putdat);
 311       for (; (ch = *p) != '\0' && (precision < 0 || --precision >= 0); width--) {
 312         putch(ch, putdat);
 313         p++;
 314       }
 315       for (; width > 0; width--)
 316         putch(' ', putdat);
 317       break;
 318
 319     // (signed) decimal
 320     case 'd':
 321       num = getint(&ap, lflag);
 322       if ((long long) num < 0) {
 323         putch('-', putdat);
 324         num = -(long long) num;
 325       }
 326       base = 10;
 327       goto signed_number;
 328
 329     // unsigned decimal
 330     case 'u':
 331       base = 10;
 332       goto unsigned_number;
 333
 334     // (unsigned) octal
 335     case 'o':
 336       // should do something with padding so it's always 3 octits
 337       base = 8;
 338       goto unsigned_number;
 339
 340     // pointer
 341     case 'p':
 342       static_assert(sizeof(long) == sizeof(void*));
 343       lflag = 1;
 344       putch('0', putdat);
 345       putch('x', putdat);
 346       /* fall through to 'x' */
 347
 348     // (unsigned) hexadecimal
 349     case 'x':
 350       base = 16;
 351     unsigned_number:
 352       num = getuint(&ap, lflag);
 353     signed_number:
 354       printnum(putch, putdat, num, base, width, padc);
 355       break;
 356
 357     // escaped '%' character
 358     case '%':
 359       putch(ch, putdat);
 360       break;
 361
 362     // unrecognized escape sequence - just print it literally
 363     default:
 364       putch('%', putdat);
 365       fmt = last_fmt;
 366       break;
 367     }
 368   }
 369 }
 370
 371 int printf(const char* fmt, ...)
 372 {
 373   va_list ap;
 374   va_start(ap, fmt);
 375
 376   vprintfmt((void*)putchar, 0, fmt, ap);
 377
 378   va_end(ap);
 379   return 0; // incorrect return value, but who cares, anyway?
 380 }
 381
 382 int sprintf(char* str, const char* fmt, ...)
 383 {
 384   va_list ap;
 385   char* str0 = str;
 386   va_start(ap, fmt);
 387
 388   void sprintf_putch(int ch, void** data)
 389   {
 390     char** pstr = (char**)data;
 391     **pstr = ch;
 392     (*pstr)++;
 393   }
 394
 395   vprintfmt(sprintf_putch, (void**)&str, fmt, ap);
 396   *str = 0;
 397
 398   va_end(ap);
 399   return str - str0;
 400 }
 401
 402 void* memcpy(void* dest, const void* src, size_t len)
 403 {
 404   if ((((uintptr_t)dest | (uintptr_t)src | len) & (sizeof(uintptr_t)-1)) == 0) {
 405     const uintptr_t* s = src;
 406     uintptr_t *d = dest;
 407     while (d < (uintptr_t*)(dest + len))
 408       *d++ = *s++;
 409   } else {
 410     const char* s = src;
 411     char *d = dest;
 412     while (d < (char*)(dest + len))
 413       *d++ = *s++;
 414   }
 415   return dest;
 416 }
 417
 418 void* memset(void* dest, int byte, size_t len)
 419 {
 420   if ((((uintptr_t)dest | len) & (sizeof(uintptr_t)-1)) == 0) {
 421     uintptr_t word = byte & 0xFF;
 422     word |= word << 8;
 423     word |= word << 16;
 424     word |= word << 16 << 16;
 425
 426     uintptr_t *d = dest;
 427     while (d < (uintptr_t*)(dest + len))
 428       *d++ = word;
 429   } else {
 430     char *d = dest;
 431     while (d < (char*)(dest + len))
 432       *d++ = byte;
 433   }
 434   return dest;
 435 }
 436
 437 size_t strlen(const char *s)
 438 {
 439   const char *p = s;
 440   while (*p)
 441     p++;
 442   return p - s;
 443 }
 444
 445 size_t strnlen(const char *s, size_t n)
 446 {
 447   const char *p = s;
 448   while (n-- && *p)
 449     p++;
 450   return p - s;
 451 }
 452
 453 int strcmp(const char* s1, const char* s2)
 454 {
 455   unsigned char c1, c2;
 456
 457   do {
 458     c1 = *s1++;
 459     c2 = *s2++;
 460   } while (c1 != 0 && c1 == c2);
 461
 462   return c1 - c2;
 463 }
 464
 465 char* strcpy(char* dest, const char* src)
 466 {
 467   char* d = dest;
 468   while ((*d++ = *src++))
 469     ;
 470   return dest;
 471 }
 472
 473 long atol(const char* str)
 474 {
 475   long res = 0;
 476   int sign = 0;
 477
 478   while (*str == ' ')
 479     str++;
 480
 481   if (*str == '-' || *str == '+') {
 482     sign = *str == '-';
 483     str++;
 484   }
 485
 486   while (*str) {
 487     res *= 10;
 488     res += *str++ - '0';
 489   }
 490
 491   return sign ? -res : res;
 492 }