sim/m32c/syscalls.c

   1 /* syscalls.c --- implement system calls for the M32C simulator.
   2
   3 Copyright (C) 2005-2018 Free Software Foundation, Inc.
   4 Contributed by Red Hat, Inc.
   5
   6 This file is part of the GNU simulators.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <sys/time.h>
  27
  28 #include "gdb/callback.h"
  29
  30 #include "cpu.h"
  31 #include "mem.h"
  32 #include "syscalls.h"
  33
  34 #include "syscall.h"
  35
  36 /* The current syscall callbacks we're using.  */
  37 static struct host_callback_struct *callbacks;
  38
  39 void
  40 set_callbacks (struct host_callback_struct *cb)
  41 {
  42   callbacks = cb;
  43 }
  44
  45
  46 /* A16 ABI: arg1 in r1l (QI) or r1 (HI) or stack
  47             arg2 in r2 (HI) or stack
  48             arg3..N on stack
  49             padding: none
  50
  51    A24 ABI: arg1 in r0l (QI) or r0 (HI) or stack
  52             arg2..N on stack
  53             padding: qi->hi
  54
  55    return value in r0l (QI) r0 (HI) r2r0 (SI)
  56      structs: pointer pushed on stack last
  57
  58 */
  59
  60 int argp, stackp;
  61
  62 static int
  63 arg (int bytes)
  64 {
  65   int rv = 0;
  66   argp++;
  67   if (A16)
  68     {
  69       switch (argp)
  70         {
  71         case 1:
  72           if (bytes == 1)
  73             return get_reg (r1l);
  74           if (bytes == 2)
  75             return get_reg (r1);
  76           break;
  77         case 2:
  78           if (bytes == 2)
  79             return get_reg (r2);
  80           break;
  81         }
  82     }
  83   else
  84     {
  85       switch (argp)
  86         {
  87         case 1:
  88           if (bytes == 1)
  89             return get_reg (r0l);
  90           if (bytes == 2)
  91             return get_reg (r0);
  92           break;
  93         }
  94     }
  95   if (bytes == 0)
  96     bytes = 2;
  97   switch (bytes)
  98     {
  99     case 1:
 100       rv = mem_get_qi (get_reg (sp) + stackp);
 101       if (A24)
 102         stackp++;
 103       break;
 104     case 2:
 105       rv = mem_get_hi (get_reg (sp) + stackp);
 106       break;
 107     case 3:
 108       rv = mem_get_psi (get_reg (sp) + stackp);
 109       if (A24)
 110         stackp++;
 111       break;
 112     case 4:
 113       rv = mem_get_si (get_reg (sp) + stackp);
 114       break;
 115     }
 116   stackp += bytes;
 117   return rv;
 118 }
 119
 120 static void
 121 read_target (char *buffer, int address, int count, int asciiz)
 122 {
 123   char byte;
 124   while (count > 0)
 125     {
 126       byte = mem_get_qi (address++);
 127       *buffer++ = byte;
 128       if (asciiz && (byte == 0))
 129         return;
 130       count--;
 131     }
 132 }
 133
 134 static void
 135 write_target (char *buffer, int address, int count, int asciiz)
 136 {
 137   char byte;
 138   while (count > 0)
 139     {
 140       byte = *buffer++;
 141       mem_put_qi (address++, byte);
 142       if (asciiz && (byte == 0))
 143         return;
 144       count--;
 145     }
 146 }
 147
 148 #define PTRSZ (A16 ? 2 : 3)
 149
 150 static char *callnames[] = {
 151   "SYS_zero",
 152   "SYS_exit",
 153   "SYS_open",
 154   "SYS_close",
 155   "SYS_read",
 156   "SYS_write",
 157   "SYS_lseek",
 158   "SYS_unlink",
 159   "SYS_getpid",
 160   "SYS_kill",
 161   "SYS_fstat",
 162   "SYS_sbrk",
 163   "SYS_argvlen",
 164   "SYS_argv",
 165   "SYS_chdir",
 166   "SYS_stat",
 167   "SYS_chmod",
 168   "SYS_utime",
 169   "SYS_time",
 170   "SYS_gettimeofday",
 171   "SYS_times",
 172   "SYS_link"
 173 };
 174
 175 void
 176 m32c_syscall (int id)
 177 {
 178   static char buf[256];
 179   int rv;
 180
 181   argp = 0;
 182   stackp = A16 ? 3 : 4;
 183   if (trace)
 184     printf ("\033[31m/* SYSCALL(%d) = %s */\033[0m\n", id, callnames[id]);
 185   switch (id)
 186     {
 187     case SYS_exit:
 188       {
 189         int ec = arg (2);
 190         if (verbose)
 191           printf ("[exit %d]\n", ec);
 192         step_result = M32C_MAKE_EXITED (ec);
 193       }
 194       break;
 195
 196     case SYS_open:
 197       {
 198         int path = arg (PTRSZ);
 199         int oflags = arg (2);
 200         int cflags = arg (2);
 201
 202         read_target (buf, path, 256, 1);
 203         if (trace)
 204           printf ("open(\"%s\",0x%x,%#o) = ", buf, oflags, cflags);
 205
 206         if (callbacks)
 207           /* The callback vector ignores CFLAGS.  */
 208           rv = callbacks->open (callbacks, buf, oflags);
 209         else
 210           {
 211             int h_oflags = 0;
 212
 213             if (oflags & 0x0001)
 214               h_oflags |= O_WRONLY;
 215             if (oflags & 0x0002)
 216               h_oflags |= O_RDWR;
 217             if (oflags & 0x0200)
 218               h_oflags |= O_CREAT;
 219             if (oflags & 0x0008)
 220               h_oflags |= O_APPEND;
 221             if (oflags & 0x0400)
 222               h_oflags |= O_TRUNC;
 223             rv = open (buf, h_oflags, cflags);
 224           }
 225         if (trace)
 226           printf ("%d\n", rv);
 227         put_reg (r0, rv);
 228       }
 229       break;
 230
 231     case SYS_close:
 232       {
 233         int fd = arg (2);
 234
 235         if (callbacks)
 236           rv = callbacks->close (callbacks, fd);
 237         else if (fd > 2)
 238           rv = close (fd);
 239         else
 240           rv = 0;
 241         if (trace)
 242           printf ("close(%d) = %d\n", fd, rv);
 243         put_reg (r0, rv);
 244       }
 245       break;
 246
 247     case SYS_read:
 248       {
 249         int fd = arg (2);
 250         int addr = arg (PTRSZ);
 251         int count = arg (2);
 252
 253         if (count > sizeof (buf))
 254           count = sizeof (buf);
 255         if (callbacks)
 256           rv = callbacks->read (callbacks, fd, buf, count);
 257         else
 258           rv = read (fd, buf, count);
 259         if (trace)
 260           printf ("read(%d,%d) = %d\n", fd, count, rv);
 261         if (rv > 0)
 262           write_target (buf, addr, rv, 0);
 263         put_reg (r0, rv);
 264       }
 265       break;
 266
 267     case SYS_write:
 268       {
 269         int fd = arg (2);
 270         int addr = arg (PTRSZ);
 271         int count = arg (2);
 272
 273         if (count > sizeof (buf))
 274           count = sizeof (buf);
 275         if (trace)
 276           printf ("write(%d,0x%x,%d)\n", fd, addr, count);
 277         read_target (buf, addr, count, 0);
 278         if (trace)
 279           fflush (stdout);
 280         if (callbacks)
 281           rv = callbacks->write (callbacks, fd, buf, count);
 282         else
 283           rv = write (fd, buf, count);
 284         if (trace)
 285           printf ("write(%d,%d) = %d\n", fd, count, rv);
 286         put_reg (r0, rv);
 287       }
 288       break;
 289
 290     case SYS_getpid:
 291       put_reg (r0, 42);
 292       break;
 293
 294     case SYS_gettimeofday:
 295       {
 296         int tvaddr = arg (PTRSZ);
 297         struct timeval tv;
 298
 299         rv = gettimeofday (&tv, 0);
 300         if (trace)
 301           printf ("gettimeofday: %ld sec %ld usec to 0x%x\n", tv.tv_sec,
 302                   tv.tv_usec, tvaddr);
 303         mem_put_si (tvaddr, tv.tv_sec);
 304         mem_put_si (tvaddr + 4, tv.tv_usec);
 305         put_reg (r0, rv);
 306       }
 307       break;
 308
 309     case SYS_kill:
 310       {
 311         int pid = arg (2);
 312         int sig = arg (2);
 313         if (pid == 42)
 314           {
 315             if (verbose)
 316               printf ("[signal %d]\n", sig);
 317             step_result = M32C_MAKE_STOPPED (sig);
 318           }
 319       }
 320       break;
 321
 322     case 11:
 323       {
 324         int heaptop_arg = arg (PTRSZ);
 325         if (trace)
 326           printf ("sbrk: heap top set to %x\n", heaptop_arg);
 327         heaptop = heaptop_arg;
 328         if (heapbottom == 0)
 329           heapbottom = heaptop_arg;
 330       }
 331       break;
 332
 333     }
 334 }