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