benchmarks/common/syscalls.c

   1 #include <stdint.h>
   2 #include <string.h>
   3 #include <stdarg.h>
   4 #include <stdio.h>
   5 #include <limits.h>
   6 #include <machine/syscall.h>
   7 #include "util.h"
   8
   9 #define SYS_stats 1234
  10
  11 // initialized in crt.S
  12 int have_vec;
  13
  14 static long handle_frontend_syscall(long which, long arg0, long arg1, long arg2)
  15 {
  16   volatile uint64_t magic_mem[8] __attribute__((aligned(64)));
  17   magic_mem[0] = which;
  18   magic_mem[1] = arg0;
  19   magic_mem[2] = arg1;
  20   magic_mem[3] = arg2;
  21   __sync_synchronize();
  22   write_csr(tohost, (long)magic_mem);
  23   while (swap_csr(fromhost, 0) == 0);
  24   return magic_mem[0];
  25 }
  26
  27 // In setStats, we might trap reading uarch-specific counters.
  28 // The trap handler will skip over the instruction and write 0,
  29 // but only if v0 is the destination register.
  30 #define read_csr_safe(reg) ({ register long __tmp asm("v0"); \
  31   asm volatile ("csrr %0, " #reg : "=r"(__tmp)); \
  32   __tmp; })
  33
  34 #define NUM_COUNTERS 18
  35 static long counters[NUM_COUNTERS];
  36 static char* counter_names[NUM_COUNTERS];
  37 static int handle_stats(int enable)
  38 {
  39   //use csrs to set stats register
  40   if(enable) {
  41     asm volatile (R"(
  42       addi v0, x0, 1
  43       csrrs v0, stats, v0
  44     )" : : : "v0");
  45   }
  46   int i = 0;
  47 #define READ_CTR(name) do { \
  48     while (i >= NUM_COUNTERS) ; \
  49     long csr = read_csr_safe(name); \
  50     if (!enable) { csr -= counters[i]; counter_names[i] = #name; } \
  51     counters[i++] = csr; \
  52   } while (0)
  53   READ_CTR(cycle);   READ_CTR(instret);
  54   READ_CTR(uarch0);  READ_CTR(uarch1);  READ_CTR(uarch2);  READ_CTR(uarch3);
  55   READ_CTR(uarch4);  READ_CTR(uarch5);  READ_CTR(uarch6);  READ_CTR(uarch7);
  56   READ_CTR(uarch8);  READ_CTR(uarch9);  READ_CTR(uarch10); READ_CTR(uarch11);
  57   READ_CTR(uarch12); READ_CTR(uarch13); READ_CTR(uarch14); READ_CTR(uarch15);
  58 #undef READ_CTR
  59   if(!enable) {
  60     asm volatile (R"(
  61       addi v0, x0, 1
  62       csrrc v0, stats, v0
  63     )" : : : "v0");
  64   }
  65   return 0;
  66 }
  67
  68 static void tohost_exit(int code)
  69 {
  70   write_csr(tohost, (code << 1) | 1);
  71   while (1);
  72 }
  73
  74 long handle_trap(long cause, long epc, long regs[32])
  75 {
  76   int csr_insn;
  77   asm volatile ("lw %0, 1f; j 2f; 1: csrr v0, stats; 2:" : "=r"(csr_insn));
  78   long sys_ret = 0;
  79
  80   if (cause == CAUSE_ILLEGAL_INSTRUCTION &&
  81       (*(int*)epc & csr_insn) == csr_insn)
  82     ;
  83   else if (cause != CAUSE_SYSCALL)
  84     tohost_exit(1337);
  85   else if (regs[16] == SYS_exit)
  86     tohost_exit(regs[18]);
  87   else if (regs[16] == SYS_stats)
  88     sys_ret = handle_stats(regs[18]);
  89   else
  90     sys_ret = handle_frontend_syscall(regs[16], regs[18], regs[19], regs[20]);
  91
  92   regs[16] = sys_ret;
  93   return epc+4;
  94 }
  95
  96 static long syscall(long num, long arg0, long arg1, long arg2)
  97 {
  98   register long v0 asm("v0") = num;
  99   register long a0 asm("a0") = arg0;
 100   register long a1 asm("a1") = arg1;
 101   register long a2 asm("a2") = arg2;
 102   asm volatile ("scall" : "+r"(v0) : "r"(a0), "r"(a1), "r"(a2) : "s0");
 103   return v0;
 104 }
 105
 106 void exit(int code)
 107 {
 108   syscall(SYS_exit, code, 0, 0);
 109 }
 110
 111 void setStats(int enable)
 112 {
 113   syscall(SYS_stats, enable, 0, 0);
 114 }
 115
 116 void printstr(const char* s)
 117 {
 118   syscall(SYS_write, 1, (long)s, strlen(s));
 119 }
 120
 121 void __attribute__((weak)) thread_entry(int cid, int nc)
 122 {
 123   // multi-threaded programs override this function.
 124   // for the case of single-threaded programs, only let core 0 proceed.
 125   while (cid != 0);
 126 }
 127
 128 int __attribute__((weak)) main(int argc, char** argv)
 129 {
 130   // single-threaded programs override this function.
 131   printstr("Implement main(), foo!\n");
 132   return -1;
 133 }
 134
 135 void _init(int cid, int nc)
 136 {
 137   thread_entry(cid, nc);
 138
 139   // only single-threaded programs should ever get here.
 140   int ret = main(0, 0);
 141
 142   char buf[NUM_COUNTERS * 32] __attribute__((aligned(64)));
 143   char* pbuf = buf;
 144   for (int i = 0; i < NUM_COUNTERS; i++)
 145     if (counters[i])
 146       pbuf += sprintf(pbuf, "%s = %d\n", counter_names[i], counters[i]);
 147   if (pbuf != buf)
 148     printstr(buf);
 149
 150   exit(ret);
 151 }
 152
 153 #undef putchar
 154 int putchar(int ch)
 155 {
 156   static __thread char buf[64] __attribute__((aligned(64)));
 157   static __thread int buflen = 0;
 158
 159   buf[buflen++] = ch;
 160
 161   if (ch == '\n' || buflen == sizeof(buf))
 162   {
 163     syscall(SYS_write, 1, (long)buf, buflen);
 164     buflen = 0;
 165   }
 166
 167   return 0;
 168 }
 169
 170 void printhex(uint64_t x)
 171 {
 172   char str[17];
 173   int i;
 174   for (i = 0; i < 16; i++)
 175   {
 176     str[15-i] = (x & 0xF) + ((x & 0xF) < 10 ? '0' : 'a'-10);
 177     x >>= 4;
 178   }
 179   str[16] = 0;
 180
 181   printstr(str);
 182 }
 183
 184 static inline void printnum(void (*putch)(int, void**), void **putdat,
 185                     unsigned long long num, unsigned base, int width, int padc)
 186 {
 187   unsigned digs[sizeof(num)*CHAR_BIT];
 188   int pos = 0;
 189
 190   while (1)
 191   {
 192     digs[pos++] = num % base;
 193     if (num < base)
 194       break;
 195     num /= base;
 196   }
 197
 198   while (width-- > pos)
 199     putch(padc, putdat);
 200
 201   while (pos-- > 0)
 202     putch(digs[pos] + (digs[pos] >= 10 ? 'a' - 10 : '0'), putdat);
 203 }
 204
 205 static unsigned long long getuint(va_list *ap, int lflag)
 206 {
 207   if (lflag >= 2)
 208     return va_arg(*ap, unsigned long long);
 209   else if (lflag)
 210     return va_arg(*ap, unsigned long);
 211   else
 212     return va_arg(*ap, unsigned int);
 213 }
 214
 215 static long long getint(va_list *ap, int lflag)
 216 {
 217   if (lflag >= 2)
 218     return va_arg(*ap, long long);
 219   else if (lflag)
 220     return va_arg(*ap, long);
 221   else
 222     return va_arg(*ap, int);
 223 }
 224
 225 static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_list ap)
 226 {
 227   register const char* p;
 228   const char* last_fmt;
 229   register int ch, err;
 230   unsigned long long num;
 231   int base, lflag, width, precision, altflag;
 232   char padc;
 233
 234   while (1) {
 235     while ((ch = *(unsigned char *) fmt) != '%') {
 236       if (ch == '\0')
 237         return;
 238       fmt++;
 239       putch(ch, putdat);
 240     }
 241     fmt++;
 242
 243     // Process a %-escape sequence
 244     last_fmt = fmt;
 245     padc = ' ';
 246     width = -1;
 247     precision = -1;
 248     lflag = 0;
 249     altflag = 0;
 250   reswitch:
 251     switch (ch = *(unsigned char *) fmt++) {
 252
 253     // flag to pad on the right
 254     case '-':
 255       padc = '-';
 256       goto reswitch;
 257
 258     // flag to pad with 0's instead of spaces
 259     case '0':
 260       padc = '0';
 261       goto reswitch;
 262
 263     // width field
 264     case '1':
 265     case '2':
 266     case '3':
 267     case '4':
 268     case '5':
 269     case '6':
 270     case '7':
 271     case '8':
 272     case '9':
 273       for (precision = 0; ; ++fmt) {
 274         precision = precision * 10 + ch - '0';
 275         ch = *fmt;
 276         if (ch < '0' || ch > '9')
 277           break;
 278       }
 279       goto process_precision;
 280
 281     case '*':
 282       precision = va_arg(ap, int);
 283       goto process_precision;
 284
 285     case '.':
 286       if (width < 0)
 287         width = 0;
 288       goto reswitch;
 289
 290     case '#':
 291       altflag = 1;
 292       goto reswitch;
 293
 294     process_precision:
 295       if (width < 0)
 296         width = precision, precision = -1;
 297       goto reswitch;
 298
 299     // long flag (doubled for long long)
 300     case 'l':
 301       lflag++;
 302       goto reswitch;
 303
 304     // character
 305     case 'c':
 306       putch(va_arg(ap, int), putdat);
 307       break;
 308
 309     // string
 310     case 's':
 311       if ((p = va_arg(ap, char *)) == NULL)
 312         p = "(null)";
 313       if (width > 0 && padc != '-')
 314         for (width -= strnlen(p, precision); width > 0; width--)
 315           putch(padc, putdat);
 316       for (; (ch = *p) != '\0' && (precision < 0 || --precision >= 0); width--) {
 317         putch(ch, putdat);
 318         p++;
 319       }
 320       for (; width > 0; width--)
 321         putch(' ', putdat);
 322       break;
 323
 324     // (signed) decimal
 325     case 'd':
 326       num = getint(&ap, lflag);
 327       if ((long long) num < 0) {
 328         putch('-', putdat);
 329         num = -(long long) num;
 330       }
 331       base = 10;
 332       goto signed_number;
 333
 334     // unsigned decimal
 335     case 'u':
 336       base = 10;
 337       goto unsigned_number;
 338
 339     // (unsigned) octal
 340     case 'o':
 341       // should do something with padding so it's always 3 octits
 342       base = 8;
 343       goto unsigned_number;
 344
 345     // pointer
 346     case 'p':
 347       static_assert(sizeof(long) == sizeof(void*));
 348       lflag = 1;
 349       putch('0', putdat);
 350       putch('x', putdat);
 351       /* fall through to 'x' */
 352
 353     // (unsigned) hexadecimal
 354     case 'x':
 355       base = 16;
 356     unsigned_number:
 357       num = getuint(&ap, lflag);
 358     signed_number:
 359       printnum(putch, putdat, num, base, width, padc);
 360       break;
 361
 362     // escaped '%' character
 363     case '%':
 364       putch(ch, putdat);
 365       break;
 366
 367     // unrecognized escape sequence - just print it literally
 368     default:
 369       putch('%', putdat);
 370       fmt = last_fmt;
 371       break;
 372     }
 373   }
 374 }
 375
 376 int printf(const char* fmt, ...)
 377 {
 378   va_list ap;
 379   va_start(ap, fmt);
 380
 381   vprintfmt((void*)putchar, 0, fmt, ap);
 382
 383   va_end(ap);
 384   return 0; // incorrect return value, but who cares, anyway?
 385 }
 386
 387 int sprintf(char* str, const char* fmt, ...)
 388 {
 389   va_list ap;
 390   char* str0 = str;
 391   va_start(ap, fmt);
 392
 393   void sprintf_putch(int ch, void** data)
 394   {
 395     char** pstr = (char**)data;
 396     **pstr = ch;
 397     (*pstr)++;
 398   }
 399
 400   vprintfmt(sprintf_putch, (void**)&str, fmt, ap);
 401   *str = 0;
 402
 403   va_end(ap);
 404   return str - str0;
 405 }