[thirdparty/binutils-gdb.git] / sim / m32c / syscalls.c

/* syscalls.c --- implement system calls for the M32C simulator.

Copyright (C) 2005 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.

This file is part of the GNU simulators.

The GNU simulators are free software; you can redistribute them and/or
modify them under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.

The GNU simulators are distributed in the hope that they will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with the GNU simulators; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA  */


#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>

#include "gdb/callback.h"

#include "cpu.h"
#include "mem.h"
#include "syscalls.h"

#include "../../libgloss/syscall.h"

/* The current syscall callbacks we're using.  */
static struct host_callback_struct *callbacks;

void
set_callbacks (struct host_callback_struct *cb)
{
  callbacks = cb;
}


/* A16 ABI: arg1 in r1l (QI) or r1 (HI) or stack
            arg2 in r2 (HI) or stack
	    arg3..N on stack
	    padding: none

   A24 ABI: arg1 in r0l (QI) or r0 (HI) or stack
	    arg2..N on stack
	    padding: qi->hi

   return value in r0l (QI) r0 (HI) r2r0 (SI)
     structs: pointer pushed on stack last

*/

int argp, stackp;

static int
arg (int bytes)
{
  int rv = 0;
  argp++;
  if (A16)
    {
      switch (argp)
	{
	case 1:
	  if (bytes == 1)
	    return get_reg (r1l);
	  if (bytes == 2)
	    return get_reg (r1);
	  break;
	case 2:
	  if (bytes == 2)
	    return get_reg (r2);
	  break;
	}
    }
  else
    {
      switch (argp)
	{
	case 1:
	  if (bytes == 1)
	    return get_reg (r0l);
	  if (bytes == 2)
	    return get_reg (r0);
	  break;
	}
    }
  if (bytes == 0)
    bytes = 2;
  switch (bytes)
    {
    case 1:
      rv = mem_get_qi (get_reg (sp) + stackp);
      if (A24)
	stackp++;
      break;
    case 2:
      rv = mem_get_hi (get_reg (sp) + stackp);
      break;
    case 3:
      rv = mem_get_psi (get_reg (sp) + stackp);
      if (A24)
	stackp++;
      break;
    case 4:
      rv = mem_get_si (get_reg (sp) + stackp);
      break;
    }
  stackp += bytes;
  return rv;
}

static void
read_target (char *buffer, int address, int count, int asciiz)
{
  char byte;
  while (count > 0)
    {
      byte = mem_get_qi (address++);
      *buffer++ = byte;
      if (asciiz && (byte == 0))
	return;
      count--;
    }
}

static void
write_target (char *buffer, int address, int count, int asciiz)
{
  char byte;
  while (count > 0)
    {
      byte = *buffer++;
      mem_put_qi (address++, byte);
      if (asciiz && (byte == 0))
	return;
      count--;
    }
}

#define PTRSZ (A16 ? 2 : 3)

static char *callnames[] = {
  "SYS_zero",
  "SYS_exit",
  "SYS_open",
  "SYS_close",
  "SYS_read",
  "SYS_write",
  "SYS_lseek",
  "SYS_unlink",
  "SYS_getpid",
  "SYS_kill",
  "SYS_fstat",
  "SYS_sbrk",
  "SYS_argvlen",
  "SYS_argv",
  "SYS_chdir",
  "SYS_stat",
  "SYS_chmod",
  "SYS_utime",
  "SYS_time",
  "SYS_gettimeofday",
  "SYS_times",
  "SYS_link"
};

void
m32c_syscall (int id)
{
  static char buf[256];
  int rv;

  argp = 0;
  stackp = A16 ? 3 : 4;
  if (trace)
    printf ("\033[31m/* SYSCALL(%d) = %s */\033[0m\n", id, callnames[id]);
  switch (id)
    {
    case SYS_exit:
      {
	int ec = arg (2);
	if (verbose)
	  printf ("[exit %d]\n", ec);
	step_result = M32C_MAKE_EXITED (ec);
      }
      break;

    case SYS_open:
      {
	int path = arg (PTRSZ);
	int oflags = arg (2);
	int cflags = arg (2);

	read_target (buf, path, 256, 1);
	if (trace)
	  printf ("open(\"%s\",0x%x,%#o) = ", buf, oflags, cflags);

	if (callbacks)
	  /* The callback vector ignores CFLAGS.  */
	  rv = callbacks->open (callbacks, buf, oflags);
	else
	  {
	    int h_oflags = 0;

	    if (oflags & 0x0001)
	      h_oflags |= O_WRONLY;
	    if (oflags & 0x0002)
	      h_oflags |= O_RDWR;
	    if (oflags & 0x0200)
	      h_oflags |= O_CREAT;
	    if (oflags & 0x0008)
	      h_oflags |= O_APPEND;
	    if (oflags & 0x0400)
	      h_oflags |= O_TRUNC;
	    rv = open (buf, h_oflags, cflags);
	  }
	if (trace)
	  printf ("%d\n", rv);
	put_reg (r0, rv);
      }
      break;

    case SYS_close:
      {
	int fd = arg (2);

	if (callbacks)
	  rv = callbacks->close (callbacks, fd);
	else if (fd > 2)
	  rv = close (fd);
	else
	  rv = 0;
	if (trace)
	  printf ("close(%d) = %d\n", fd, rv);
	put_reg (r0, rv);
      }
      break;

    case SYS_read:
      {
	int fd = arg (2);
	int addr = arg (PTRSZ);
	int count = arg (2);

	if (count > sizeof (buf))
	  count = sizeof (buf);
	if (callbacks)
	  rv = callbacks->read (callbacks, fd, buf, count);
	else
	  rv = read (fd, buf, count);
	if (trace)
	  printf ("read(%d,%d) = %d\n", fd, count, rv);
	if (rv > 0)
	  write_target (buf, addr, rv, 0);
	put_reg (r0, rv);
      }
      break;

    case SYS_write:
      {
	int fd = arg (2);
	int addr = arg (PTRSZ);
	int count = arg (2);

	if (count > sizeof (buf))
	  count = sizeof (buf);
	if (trace)
	  printf ("write(%d,0x%x,%d)\n", fd, addr, count);
	read_target (buf, addr, count, 0);
	if (trace)
	  fflush (stdout);
	if (callbacks)
	  rv = callbacks->write (callbacks, fd, buf, count);
	else
	  rv = write (fd, buf, count);
	if (trace)
	  printf ("write(%d,%d) = %d\n", fd, count, rv);
	put_reg (r0, rv);
      }
      break;

    case SYS_getpid:
      put_reg (r0, 42);
      break;

    case SYS_gettimeofday:
      {
	int tvaddr = arg (PTRSZ);
	struct timeval tv;

	rv = gettimeofday (&tv, 0);
	if (trace)
	  printf ("gettimeofday: %ld sec %ld usec to 0x%x\n", tv.tv_sec,
		  tv.tv_usec, tvaddr);
	mem_put_si (tvaddr, tv.tv_sec);
	mem_put_si (tvaddr + 4, tv.tv_usec);
	put_reg (r0, rv);
      }
      break;

    case SYS_kill:
      {
	int pid = arg (2);
	int sig = arg (2);
	if (pid == 42)
	  {
	    if (verbose)
	      printf ("[signal %d]\n", sig);
	    step_result = M32C_MAKE_STOPPED (sig);
	  }
      }
      break;

    case 11:
      {
	int heaptop_arg = arg (PTRSZ);
	if (trace)
	  printf ("sbrk: heap top set to %x\n", heaptop_arg);
	heaptop = heaptop_arg;
	if (heapbottom == 0)
	  heapbottom = heaptop_arg;
      }
      break;

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