]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - sim/m32r/traps-linux.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
sim: split sim-signal.h include out
[thirdparty/binutils-gdb.git] / sim / m32r / traps-linux.c
... / ...
CommitLineData
1/* m32r exception, interrupt, and trap (EIT) support
2 Copyright (C) 1998-2021 Free Software Foundation, Inc.
3 Contributed by Renesas.
4
5 This file is part of GDB, the GNU debugger.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20/* This must come before any other includes. */
21#include "defs.h"
22
23#include "portability.h"
24#include "sim-main.h"
25#include "sim-signal.h"
26#include "sim-syscall.h"
27#include "syscall.h"
28#include "targ-vals.h"
29#include <dirent.h>
30#include <errno.h>
31#include <fcntl.h>
32#include <time.h>
33#include <unistd.h>
34#include <utime.h>
35#include <sys/mman.h>
36#include <sys/poll.h>
37#include <sys/resource.h>
38#include <sys/sysinfo.h>
39#include <sys/stat.h>
40#include <sys/time.h>
41#include <sys/timeb.h>
42#include <sys/timex.h>
43#include <sys/types.h>
44#include <sys/uio.h>
45#include <sys/utsname.h>
46#include <sys/vfs.h>
47#include <linux/sysctl.h>
48#include <linux/types.h>
49#include <linux/unistd.h>
50
51#define TRAP_ELF_SYSCALL 0
52#define TRAP_LINUX_SYSCALL 2
53#define TRAP_FLUSH_CACHE 12
54
55/* The semantic code invokes this for invalid (unrecognized) instructions. */
56
57SEM_PC
58sim_engine_invalid_insn (SIM_CPU *current_cpu, IADDR cia, SEM_PC vpc)
59{
60 SIM_DESC sd = CPU_STATE (current_cpu);
61
62#if 0
63 if (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)
64 {
65 h_bsm_set (current_cpu, h_sm_get (current_cpu));
66 h_bie_set (current_cpu, h_ie_get (current_cpu));
67 h_bcond_set (current_cpu, h_cond_get (current_cpu));
68 /* sm not changed */
69 h_ie_set (current_cpu, 0);
70 h_cond_set (current_cpu, 0);
71
72 h_bpc_set (current_cpu, cia);
73
74 sim_engine_restart (CPU_STATE (current_cpu), current_cpu, NULL,
75 EIT_RSVD_INSN_ADDR);
76 }
77 else
78#endif
79 sim_engine_halt (sd, current_cpu, NULL, cia, sim_stopped, SIM_SIGILL);
80 return vpc;
81}
82
83/* Process an address exception. */
84
85void
86m32r_core_signal (SIM_DESC sd, SIM_CPU *current_cpu, sim_cia cia,
87 unsigned int map, int nr_bytes, address_word addr,
88 transfer_type transfer, sim_core_signals sig)
89{
90 if (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)
91 {
92 m32rbf_h_cr_set (current_cpu, H_CR_BBPC,
93 m32rbf_h_cr_get (current_cpu, H_CR_BPC));
94 if (MACH_NUM (CPU_MACH (current_cpu)) == MACH_M32R)
95 {
96 m32rbf_h_bpsw_set (current_cpu, m32rbf_h_psw_get (current_cpu));
97 /* sm not changed */
98 m32rbf_h_psw_set (current_cpu, m32rbf_h_psw_get (current_cpu) & 0x80);
99 }
100 else if (MACH_NUM (CPU_MACH (current_cpu)) == MACH_M32RX)
101 {
102 m32rxf_h_bpsw_set (current_cpu, m32rxf_h_psw_get (current_cpu));
103 /* sm not changed */
104 m32rxf_h_psw_set (current_cpu, m32rxf_h_psw_get (current_cpu) & 0x80);
105 }
106 else
107 {
108 m32r2f_h_bpsw_set (current_cpu, m32r2f_h_psw_get (current_cpu));
109 /* sm not changed */
110 m32r2f_h_psw_set (current_cpu, m32r2f_h_psw_get (current_cpu) & 0x80);
111 }
112 m32rbf_h_cr_set (current_cpu, H_CR_BPC, cia);
113
114 sim_engine_restart (CPU_STATE (current_cpu), current_cpu, NULL,
115 EIT_ADDR_EXCP_ADDR);
116 }
117 else
118 sim_core_signal (sd, current_cpu, cia, map, nr_bytes, addr,
119 transfer, sig);
120}
121\f
122/* Translate target's address to host's address. */
123
124static void *
125t2h_addr (host_callback *cb, struct cb_syscall *sc,
126 unsigned long taddr)
127{
128 void *addr;
129 SIM_DESC sd = (SIM_DESC) sc->p1;
130 SIM_CPU *cpu = (SIM_CPU *) sc->p2;
131
132 if (taddr == 0)
133 return NULL;
134
135 return sim_core_trans_addr (sd, cpu, read_map, taddr);
136}
137
138static unsigned int
139conv_endian (unsigned int tvalue)
140{
141 unsigned int hvalue;
142 unsigned int t1, t2, t3, t4;
143
144 if (HOST_BYTE_ORDER == BFD_ENDIAN_LITTLE)
145 {
146 t1 = tvalue & 0xff000000;
147 t2 = tvalue & 0x00ff0000;
148 t3 = tvalue & 0x0000ff00;
149 t4 = tvalue & 0x000000ff;
150
151 hvalue = t1 >> 24;
152 hvalue += t2 >> 8;
153 hvalue += t3 << 8;
154 hvalue += t4 << 24;
155 }
156 else
157 hvalue = tvalue;
158
159 return hvalue;
160}
161
162static unsigned short
163conv_endian16 (unsigned short tvalue)
164{
165 unsigned short hvalue;
166 unsigned short t1, t2;
167
168 if (HOST_BYTE_ORDER == BFD_ENDIAN_LITTLE)
169 {
170 t1 = tvalue & 0xff00;
171 t2 = tvalue & 0x00ff;
172
173 hvalue = t1 >> 8;
174 hvalue += t2 << 8;
175 }
176 else
177 hvalue = tvalue;
178
179 return hvalue;
180}
181
182static void
183translate_endian(void *addr, size_t size)
184{
185 unsigned int *p = (unsigned int *) addr;
186 int i;
187
188 for (i = 0; i <= size - 4; i += 4,p++)
189 *p = conv_endian(*p);
190
191 if (i <= size - 2)
192 *((unsigned short *) p) = conv_endian16(*((unsigned short *) p));
193}
194
195/* Trap support.
196 The result is the pc address to continue at.
197 Preprocessing like saving the various registers has already been done. */
198
199USI
200m32r_trap (SIM_CPU *current_cpu, PCADDR pc, int num)
201{
202 SIM_DESC sd = CPU_STATE (current_cpu);
203 host_callback *cb = STATE_CALLBACK (sd);
204
205 switch (num)
206 {
207 case TRAP_ELF_SYSCALL :
208 {
209 long result, result2;
210 int errcode;
211
212 sim_syscall_multi (current_cpu,
213 m32rbf_h_gr_get (current_cpu, 0),
214 m32rbf_h_gr_get (current_cpu, 1),
215 m32rbf_h_gr_get (current_cpu, 2),
216 m32rbf_h_gr_get (current_cpu, 3),
217 m32rbf_h_gr_get (current_cpu, 4),
218 &result, &result2, &errcode);
219
220 m32rbf_h_gr_set (current_cpu, 2, errcode);
221 m32rbf_h_gr_set (current_cpu, 0, result);
222 m32rbf_h_gr_set (current_cpu, 1, result2);
223 break;
224 }
225
226 case TRAP_LINUX_SYSCALL :
227 {
228 CB_SYSCALL s;
229 unsigned int func, arg1, arg2, arg3, arg4, arg5, arg6, arg7;
230 int result, result2, errcode;
231
232 if (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)
233 {
234 /* The new pc is the trap vector entry.
235 We assume there's a branch there to some handler.
236 Use cr5 as EVB (EIT Vector Base) register. */
237 USI new_pc = m32rbf_h_cr_get (current_cpu, 5) + 0x40 + num * 4;
238 return new_pc;
239 }
240
241 func = m32rbf_h_gr_get (current_cpu, 7);
242 arg1 = m32rbf_h_gr_get (current_cpu, 0);
243 arg2 = m32rbf_h_gr_get (current_cpu, 1);
244 arg3 = m32rbf_h_gr_get (current_cpu, 2);
245 arg4 = m32rbf_h_gr_get (current_cpu, 3);
246 arg5 = m32rbf_h_gr_get (current_cpu, 4);
247 arg6 = m32rbf_h_gr_get (current_cpu, 5);
248 arg7 = m32rbf_h_gr_get (current_cpu, 6);
249
250 CB_SYSCALL_INIT (&s);
251 s.func = func;
252 s.arg1 = arg1;
253 s.arg2 = arg2;
254 s.arg3 = arg3;
255
256 s.p1 = (PTR) sd;
257 s.p2 = (PTR) current_cpu;
258 s.read_mem = sim_syscall_read_mem;
259 s.write_mem = sim_syscall_write_mem;
260
261 result = 0;
262 result2 = 0;
263 errcode = 0;
264
265 switch (func)
266 {
267 case __NR_exit:
268 sim_engine_halt (sd, current_cpu, NULL, pc, sim_exited, arg1);
269 break;
270
271 case __NR_read:
272 result = read(arg1, t2h_addr(cb, &s, arg2), arg3);
273 errcode = errno;
274 break;
275
276 case __NR_write:
277 result = write(arg1, t2h_addr(cb, &s, arg2), arg3);
278 errcode = errno;
279 break;
280
281 case __NR_open:
282 result = open((char *) t2h_addr(cb, &s, arg1), arg2, arg3);
283 errcode = errno;
284 break;
285
286 case __NR_close:
287 result = close(arg1);
288 errcode = errno;
289 break;
290
291 case __NR_creat:
292 result = creat((char *) t2h_addr(cb, &s, arg1), arg2);
293 errcode = errno;
294 break;
295
296 case __NR_link:
297 result = link((char *) t2h_addr(cb, &s, arg1),
298 (char *) t2h_addr(cb, &s, arg2));
299 errcode = errno;
300 break;
301
302 case __NR_unlink:
303 result = unlink((char *) t2h_addr(cb, &s, arg1));
304 errcode = errno;
305 break;
306
307 case __NR_chdir:
308 result = chdir((char *) t2h_addr(cb, &s, arg1));
309 errcode = errno;
310 break;
311
312 case __NR_time:
313 {
314 time_t t;
315
316 if (arg1 == 0)
317 {
318 result = (int) time(NULL);
319 errcode = errno;
320 }
321 else
322 {
323 result = (int) time(&t);
324 errcode = errno;
325
326 if (result != 0)
327 break;
328
329 translate_endian((void *) &t, sizeof(t));
330 if ((s.write_mem) (cb, &s, arg1, (char *) &t, sizeof(t)) != sizeof(t))
331 {
332 result = -1;
333 errcode = EINVAL;
334 }
335 }
336 }
337 break;
338
339 case __NR_mknod:
340 result = mknod((char *) t2h_addr(cb, &s, arg1),
341 (mode_t) arg2, (dev_t) arg3);
342 errcode = errno;
343 break;
344
345 case __NR_chmod:
346 result = chmod((char *) t2h_addr(cb, &s, arg1), (mode_t) arg2);
347 errcode = errno;
348 break;
349
350 case __NR_lchown32:
351 case __NR_lchown:
352 result = lchown((char *) t2h_addr(cb, &s, arg1),
353 (uid_t) arg2, (gid_t) arg3);
354 errcode = errno;
355 break;
356
357 case __NR_lseek:
358 result = (int) lseek(arg1, (off_t) arg2, arg3);
359 errcode = errno;
360 break;
361
362 case __NR_getpid:
363 result = getpid();
364 errcode = errno;
365 break;
366
367 case __NR_getuid32:
368 case __NR_getuid:
369 result = getuid();
370 errcode = errno;
371 break;
372
373 case __NR_utime:
374 {
375 struct utimbuf buf;
376
377 if (arg2 == 0)
378 {
379 result = utime((char *) t2h_addr(cb, &s, arg1), NULL);
380 errcode = errno;
381 }
382 else
383 {
384 buf = *((struct utimbuf *) t2h_addr(cb, &s, arg2));
385 translate_endian((void *) &buf, sizeof(buf));
386 result = utime((char *) t2h_addr(cb, &s, arg1), &buf);
387 errcode = errno;
388 }
389 }
390 break;
391
392 case __NR_access:
393 result = access((char *) t2h_addr(cb, &s, arg1), arg2);
394 errcode = errno;
395 break;
396
397 case __NR_ftime:
398 {
399 struct timeb t;
400
401 result = ftime(&t);
402 errcode = errno;
403
404 if (result != 0)
405 break;
406
407 t.time = conv_endian(t.time);
408 t.millitm = conv_endian16(t.millitm);
409 t.timezone = conv_endian16(t.timezone);
410 t.dstflag = conv_endian16(t.dstflag);
411 if ((s.write_mem) (cb, &s, arg1, (char *) &t, sizeof(t))
412 != sizeof(t))
413 {
414 result = -1;
415 errcode = EINVAL;
416 }
417 }
418
419 case __NR_sync:
420 sync();
421 result = 0;
422 break;
423
424 case __NR_rename:
425 result = rename((char *) t2h_addr(cb, &s, arg1),
426 (char *) t2h_addr(cb, &s, arg2));
427 errcode = errno;
428 break;
429
430 case __NR_mkdir:
431 result = mkdir((char *) t2h_addr(cb, &s, arg1), arg2);
432 errcode = errno;
433 break;
434
435 case __NR_rmdir:
436 result = rmdir((char *) t2h_addr(cb, &s, arg1));
437 errcode = errno;
438 break;
439
440 case __NR_dup:
441 result = dup(arg1);
442 errcode = errno;
443 break;
444
445 case __NR_brk:
446 result = brk((void *) arg1);
447 errcode = errno;
448 //result = arg1;
449 break;
450
451 case __NR_getgid32:
452 case __NR_getgid:
453 result = getgid();
454 errcode = errno;
455 break;
456
457 case __NR_geteuid32:
458 case __NR_geteuid:
459 result = geteuid();
460 errcode = errno;
461 break;
462
463 case __NR_getegid32:
464 case __NR_getegid:
465 result = getegid();
466 errcode = errno;
467 break;
468
469 case __NR_ioctl:
470 result = ioctl(arg1, arg2, arg3);
471 errcode = errno;
472 break;
473
474 case __NR_fcntl:
475 result = fcntl(arg1, arg2, arg3);
476 errcode = errno;
477 break;
478
479 case __NR_dup2:
480 result = dup2(arg1, arg2);
481 errcode = errno;
482 break;
483
484 case __NR_getppid:
485 result = getppid();
486 errcode = errno;
487 break;
488
489 case __NR_getpgrp:
490 result = getpgrp();
491 errcode = errno;
492 break;
493
494 case __NR_getrlimit:
495 {
496 struct rlimit rlim;
497
498 result = getrlimit(arg1, &rlim);
499 errcode = errno;
500
501 if (result != 0)
502 break;
503
504 translate_endian((void *) &rlim, sizeof(rlim));
505 if ((s.write_mem) (cb, &s, arg2, (char *) &rlim, sizeof(rlim))
506 != sizeof(rlim))
507 {
508 result = -1;
509 errcode = EINVAL;
510 }
511 }
512 break;
513
514 case __NR_getrusage:
515 {
516 struct rusage usage;
517
518 result = getrusage(arg1, &usage);
519 errcode = errno;
520
521 if (result != 0)
522 break;
523
524 translate_endian((void *) &usage, sizeof(usage));
525 if ((s.write_mem) (cb, &s, arg2, (char *) &usage, sizeof(usage))
526 != sizeof(usage))
527 {
528 result = -1;
529 errcode = EINVAL;
530 }
531 }
532 break;
533
534 case __NR_gettimeofday:
535 {
536 struct timeval tv;
537 struct timezone tz;
538
539 result = gettimeofday(&tv, &tz);
540 errcode = errno;
541
542 if (result != 0)
543 break;
544
545 translate_endian((void *) &tv, sizeof(tv));
546 if ((s.write_mem) (cb, &s, arg1, (char *) &tv, sizeof(tv))
547 != sizeof(tv))
548 {
549 result = -1;
550 errcode = EINVAL;
551 }
552
553 translate_endian((void *) &tz, sizeof(tz));
554 if ((s.write_mem) (cb, &s, arg2, (char *) &tz, sizeof(tz))
555 != sizeof(tz))
556 {
557 result = -1;
558 errcode = EINVAL;
559 }
560 }
561 break;
562
563 case __NR_getgroups32:
564 case __NR_getgroups:
565 {
566 gid_t *list;
567
568 if (arg1 > 0)
569 list = (gid_t *) malloc(arg1 * sizeof(gid_t));
570
571 result = getgroups(arg1, list);
572 errcode = errno;
573
574 if (result != 0)
575 break;
576
577 translate_endian((void *) list, arg1 * sizeof(gid_t));
578 if (arg1 > 0)
579 if ((s.write_mem) (cb, &s, arg2, (char *) list, arg1 * sizeof(gid_t))
580 != arg1 * sizeof(gid_t))
581 {
582 result = -1;
583 errcode = EINVAL;
584 }
585 }
586 break;
587
588 case __NR_select:
589 {
590 int n;
591 fd_set readfds;
592 fd_set *treadfdsp;
593 fd_set *hreadfdsp;
594 fd_set writefds;
595 fd_set *twritefdsp;
596 fd_set *hwritefdsp;
597 fd_set exceptfds;
598 fd_set *texceptfdsp;
599 fd_set *hexceptfdsp;
600 struct timeval *ttimeoutp;
601 struct timeval timeout;
602
603 n = arg1;
604
605 treadfdsp = (fd_set *) arg2;
606 if (treadfdsp != NULL)
607 {
608 readfds = *((fd_set *) t2h_addr(cb, &s, (unsigned int) treadfdsp));
609 translate_endian((void *) &readfds, sizeof(readfds));
610 hreadfdsp = &readfds;
611 }
612 else
613 hreadfdsp = NULL;
614
615 twritefdsp = (fd_set *) arg3;
616 if (twritefdsp != NULL)
617 {
618 writefds = *((fd_set *) t2h_addr(cb, &s, (unsigned int) twritefdsp));
619 translate_endian((void *) &writefds, sizeof(writefds));
620 hwritefdsp = &writefds;
621 }
622 else
623 hwritefdsp = NULL;
624
625 texceptfdsp = (fd_set *) arg4;
626 if (texceptfdsp != NULL)
627 {
628 exceptfds = *((fd_set *) t2h_addr(cb, &s, (unsigned int) texceptfdsp));
629 translate_endian((void *) &exceptfds, sizeof(exceptfds));
630 hexceptfdsp = &exceptfds;
631 }
632 else
633 hexceptfdsp = NULL;
634
635 ttimeoutp = (struct timeval *) arg5;
636 timeout = *((struct timeval *) t2h_addr(cb, &s, (unsigned int) ttimeoutp));
637 translate_endian((void *) &timeout, sizeof(timeout));
638
639 result = select(n, hreadfdsp, hwritefdsp, hexceptfdsp, &timeout);
640 errcode = errno;
641
642 if (result != 0)
643 break;
644
645 if (treadfdsp != NULL)
646 {
647 translate_endian((void *) &readfds, sizeof(readfds));
648 if ((s.write_mem) (cb, &s, (unsigned long) treadfdsp,
649 (char *) &readfds, sizeof(readfds)) != sizeof(readfds))
650 {
651 result = -1;
652 errcode = EINVAL;
653 }
654 }
655
656 if (twritefdsp != NULL)
657 {
658 translate_endian((void *) &writefds, sizeof(writefds));
659 if ((s.write_mem) (cb, &s, (unsigned long) twritefdsp,
660 (char *) &writefds, sizeof(writefds)) != sizeof(writefds))
661 {
662 result = -1;
663 errcode = EINVAL;
664 }
665 }
666
667 if (texceptfdsp != NULL)
668 {
669 translate_endian((void *) &exceptfds, sizeof(exceptfds));
670 if ((s.write_mem) (cb, &s, (unsigned long) texceptfdsp,
671 (char *) &exceptfds, sizeof(exceptfds)) != sizeof(exceptfds))
672 {
673 result = -1;
674 errcode = EINVAL;
675 }
676 }
677
678 translate_endian((void *) &timeout, sizeof(timeout));
679 if ((s.write_mem) (cb, &s, (unsigned long) ttimeoutp,
680 (char *) &timeout, sizeof(timeout)) != sizeof(timeout))
681 {
682 result = -1;
683 errcode = EINVAL;
684 }
685 }
686 break;
687
688 case __NR_symlink:
689 result = symlink((char *) t2h_addr(cb, &s, arg1),
690 (char *) t2h_addr(cb, &s, arg2));
691 errcode = errno;
692 break;
693
694 case __NR_readlink:
695 result = readlink((char *) t2h_addr(cb, &s, arg1),
696 (char *) t2h_addr(cb, &s, arg2),
697 arg3);
698 errcode = errno;
699 break;
700
701 case __NR_readdir:
702 result = (int) readdir((DIR *) t2h_addr(cb, &s, arg1));
703 errcode = errno;
704 break;
705
706#if 0
707 case __NR_mmap:
708 {
709 result = (int) mmap((void *) t2h_addr(cb, &s, arg1),
710 arg2, arg3, arg4, arg5, arg6);
711 errcode = errno;
712
713 if (errno == 0)
714 {
715 sim_core_attach (sd, NULL,
716 0, access_read_write_exec, 0,
717 result, arg2, 0, NULL, NULL);
718 }
719 }
720 break;
721#endif
722 case __NR_mmap2:
723 {
724 void *addr;
725 size_t len;
726 int prot, flags, fildes;
727 off_t off;
728
729 addr = (void *) t2h_addr(cb, &s, arg1);
730 len = arg2;
731 prot = arg3;
732 flags = arg4;
733 fildes = arg5;
734 off = arg6 << 12;
735
736 result = (int) mmap(addr, len, prot, flags, fildes, off);
737 errcode = errno;
738 if (result != -1)
739 {
740 char c;
741 if (sim_core_read_buffer (sd, NULL, read_map, &c, result, 1) == 0)
742 sim_core_attach (sd, NULL,
743 0, access_read_write_exec, 0,
744 result, len, 0, NULL, NULL);
745 }
746 }
747 break;
748
749 case __NR_mmap:
750 {
751 void *addr;
752 size_t len;
753 int prot, flags, fildes;
754 off_t off;
755
756 addr = *((void **) t2h_addr(cb, &s, arg1));
757 len = *((size_t *) t2h_addr(cb, &s, arg1 + 4));
758 prot = *((int *) t2h_addr(cb, &s, arg1 + 8));
759 flags = *((int *) t2h_addr(cb, &s, arg1 + 12));
760 fildes = *((int *) t2h_addr(cb, &s, arg1 + 16));
761 off = *((off_t *) t2h_addr(cb, &s, arg1 + 20));
762
763 addr = (void *) conv_endian((unsigned int) addr);
764 len = conv_endian(len);
765 prot = conv_endian(prot);
766 flags = conv_endian(flags);
767 fildes = conv_endian(fildes);
768 off = conv_endian(off);
769
770 //addr = (void *) t2h_addr(cb, &s, (unsigned int) addr);
771 result = (int) mmap(addr, len, prot, flags, fildes, off);
772 errcode = errno;
773
774 //if (errno == 0)
775 if (result != -1)
776 {
777 char c;
778 if (sim_core_read_buffer (sd, NULL, read_map, &c, result, 1) == 0)
779 sim_core_attach (sd, NULL,
780 0, access_read_write_exec, 0,
781 result, len, 0, NULL, NULL);
782 }
783 }
784 break;
785
786 case __NR_munmap:
787 {
788 result = munmap((void *)arg1, arg2);
789 errcode = errno;
790 if (result != -1)
791 {
792 sim_core_detach (sd, NULL, 0, arg2, result);
793 }
794 }
795 break;
796
797 case __NR_truncate:
798 result = truncate((char *) t2h_addr(cb, &s, arg1), arg2);
799 errcode = errno;
800 break;
801
802 case __NR_ftruncate:
803 result = ftruncate(arg1, arg2);
804 errcode = errno;
805 break;
806
807 case __NR_fchmod:
808 result = fchmod(arg1, arg2);
809 errcode = errno;
810 break;
811
812 case __NR_fchown32:
813 case __NR_fchown:
814 result = fchown(arg1, arg2, arg3);
815 errcode = errno;
816 break;
817
818 case __NR_statfs:
819 {
820 struct statfs statbuf;
821
822 result = statfs((char *) t2h_addr(cb, &s, arg1), &statbuf);
823 errcode = errno;
824
825 if (result != 0)
826 break;
827
828 translate_endian((void *) &statbuf, sizeof(statbuf));
829 if ((s.write_mem) (cb, &s, arg2, (char *) &statbuf, sizeof(statbuf))
830 != sizeof(statbuf))
831 {
832 result = -1;
833 errcode = EINVAL;
834 }
835 }
836 break;
837
838 case __NR_fstatfs:
839 {
840 struct statfs statbuf;
841
842 result = fstatfs(arg1, &statbuf);
843 errcode = errno;
844
845 if (result != 0)
846 break;
847
848 translate_endian((void *) &statbuf, sizeof(statbuf));
849 if ((s.write_mem) (cb, &s, arg2, (char *) &statbuf, sizeof(statbuf))
850 != sizeof(statbuf))
851 {
852 result = -1;
853 errcode = EINVAL;
854 }
855 }
856 break;
857
858 case __NR_syslog:
859 result = syslog(arg1, (char *) t2h_addr(cb, &s, arg2));
860 errcode = errno;
861 break;
862
863 case __NR_setitimer:
864 {
865 struct itimerval value, ovalue;
866
867 value = *((struct itimerval *) t2h_addr(cb, &s, arg2));
868 translate_endian((void *) &value, sizeof(value));
869
870 if (arg2 == 0)
871 {
872 result = setitimer(arg1, &value, NULL);
873 errcode = errno;
874 }
875 else
876 {
877 result = setitimer(arg1, &value, &ovalue);
878 errcode = errno;
879
880 if (result != 0)
881 break;
882
883 translate_endian((void *) &ovalue, sizeof(ovalue));
884 if ((s.write_mem) (cb, &s, arg3, (char *) &ovalue, sizeof(ovalue))
885 != sizeof(ovalue))
886 {
887 result = -1;
888 errcode = EINVAL;
889 }
890 }
891 }
892 break;
893
894 case __NR_getitimer:
895 {
896 struct itimerval value;
897
898 result = getitimer(arg1, &value);
899 errcode = errno;
900
901 if (result != 0)
902 break;
903
904 translate_endian((void *) &value, sizeof(value));
905 if ((s.write_mem) (cb, &s, arg2, (char *) &value, sizeof(value))
906 != sizeof(value))
907 {
908 result = -1;
909 errcode = EINVAL;
910 }
911 }
912 break;
913
914 case __NR_stat:
915 {
916 char *buf;
917 int buflen;
918 struct stat statbuf;
919
920 result = stat((char *) t2h_addr(cb, &s, arg1), &statbuf);
921 errcode = errno;
922 if (result < 0)
923 break;
924
925 buflen = cb_host_to_target_stat (cb, NULL, NULL);
926 buf = xmalloc (buflen);
927 if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
928 {
929 /* The translation failed. This is due to an internal
930 host program error, not the target's fault. */
931 free (buf);
932 result = -1;
933 errcode = ENOSYS;
934 break;
935 }
936 if ((s.write_mem) (cb, &s, arg2, buf, buflen) != buflen)
937 {
938 free (buf);
939 result = -1;
940 errcode = EINVAL;
941 break;
942 }
943 free (buf);
944 }
945 break;
946
947 case __NR_lstat:
948 {
949 char *buf;
950 int buflen;
951 struct stat statbuf;
952
953 result = lstat((char *) t2h_addr(cb, &s, arg1), &statbuf);
954 errcode = errno;
955 if (result < 0)
956 break;
957
958 buflen = cb_host_to_target_stat (cb, NULL, NULL);
959 buf = xmalloc (buflen);
960 if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
961 {
962 /* The translation failed. This is due to an internal
963 host program error, not the target's fault. */
964 free (buf);
965 result = -1;
966 errcode = ENOSYS;
967 break;
968 }
969 if ((s.write_mem) (cb, &s, arg2, buf, buflen) != buflen)
970 {
971 free (buf);
972 result = -1;
973 errcode = EINVAL;
974 break;
975 }
976 free (buf);
977 }
978 break;
979
980 case __NR_fstat:
981 {
982 char *buf;
983 int buflen;
984 struct stat statbuf;
985
986 result = fstat(arg1, &statbuf);
987 errcode = errno;
988 if (result < 0)
989 break;
990
991 buflen = cb_host_to_target_stat (cb, NULL, NULL);
992 buf = xmalloc (buflen);
993 if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
994 {
995 /* The translation failed. This is due to an internal
996 host program error, not the target's fault. */
997 free (buf);
998 result = -1;
999 errcode = ENOSYS;
1000 break;
1001 }
1002 if ((s.write_mem) (cb, &s, arg2, buf, buflen) != buflen)
1003 {
1004 free (buf);
1005 result = -1;
1006 errcode = EINVAL;
1007 break;
1008 }
1009 free (buf);
1010 }
1011 break;
1012
1013 case __NR_sysinfo:
1014 {
1015 struct sysinfo info;
1016
1017 result = sysinfo(&info);
1018 errcode = errno;
1019
1020 if (result != 0)
1021 break;
1022
1023 info.uptime = conv_endian(info.uptime);
1024 info.loads[0] = conv_endian(info.loads[0]);
1025 info.loads[1] = conv_endian(info.loads[1]);
1026 info.loads[2] = conv_endian(info.loads[2]);
1027 info.totalram = conv_endian(info.totalram);
1028 info.freeram = conv_endian(info.freeram);
1029 info.sharedram = conv_endian(info.sharedram);
1030 info.bufferram = conv_endian(info.bufferram);
1031 info.totalswap = conv_endian(info.totalswap);
1032 info.freeswap = conv_endian(info.freeswap);
1033 info.procs = conv_endian16(info.procs);
1034#if LINUX_VERSION_CODE >= 0x20400
1035 info.totalhigh = conv_endian(info.totalhigh);
1036 info.freehigh = conv_endian(info.freehigh);
1037 info.mem_unit = conv_endian(info.mem_unit);
1038#endif
1039 if ((s.write_mem) (cb, &s, arg1, (char *) &info, sizeof(info))
1040 != sizeof(info))
1041 {
1042 result = -1;
1043 errcode = EINVAL;
1044 }
1045 }
1046 break;
1047
1048#if 0
1049 case __NR_ipc:
1050 {
1051 result = ipc(arg1, arg2, arg3, arg4,
1052 (void *) t2h_addr(cb, &s, arg5), arg6);
1053 errcode = errno;
1054 }
1055 break;
1056#endif
1057
1058 case __NR_fsync:
1059 result = fsync(arg1);
1060 errcode = errno;
1061 break;
1062
1063 case __NR_uname:
1064 /* utsname contains only arrays of char, so it is not necessary
1065 to translate endian. */
1066 result = uname((struct utsname *) t2h_addr(cb, &s, arg1));
1067 errcode = errno;
1068 break;
1069
1070 case __NR_adjtimex:
1071 {
1072 struct timex buf;
1073
1074 result = adjtimex(&buf);
1075 errcode = errno;
1076
1077 if (result != 0)
1078 break;
1079
1080 translate_endian((void *) &buf, sizeof(buf));
1081 if ((s.write_mem) (cb, &s, arg1, (char *) &buf, sizeof(buf))
1082 != sizeof(buf))
1083 {
1084 result = -1;
1085 errcode = EINVAL;
1086 }
1087 }
1088 break;
1089
1090 case __NR_mprotect:
1091 result = mprotect((void *) arg1, arg2, arg3);
1092 errcode = errno;
1093 break;
1094
1095 case __NR_fchdir:
1096 result = fchdir(arg1);
1097 errcode = errno;
1098 break;
1099
1100 case __NR_setfsuid32:
1101 case __NR_setfsuid:
1102 result = setfsuid(arg1);
1103 errcode = errno;
1104 break;
1105
1106 case __NR_setfsgid32:
1107 case __NR_setfsgid:
1108 result = setfsgid(arg1);
1109 errcode = errno;
1110 break;
1111
1112#if 0
1113 case __NR__llseek:
1114 {
1115 loff_t buf;
1116
1117 result = _llseek(arg1, arg2, arg3, &buf, arg5);
1118 errcode = errno;
1119
1120 if (result != 0)
1121 break;
1122
1123 translate_endian((void *) &buf, sizeof(buf));
1124 if ((s.write_mem) (cb, &s, t2h_addr(cb, &s, arg4),
1125 (char *) &buf, sizeof(buf)) != sizeof(buf))
1126 {
1127 result = -1;
1128 errcode = EINVAL;
1129 }
1130 }
1131 break;
1132
1133 case __NR_getdents:
1134 {
1135 struct dirent dir;
1136
1137 result = getdents(arg1, &dir, arg3);
1138 errcode = errno;
1139
1140 if (result != 0)
1141 break;
1142
1143 dir.d_ino = conv_endian(dir.d_ino);
1144 dir.d_off = conv_endian(dir.d_off);
1145 dir.d_reclen = conv_endian16(dir.d_reclen);
1146 if ((s.write_mem) (cb, &s, arg2, (char *) &dir, sizeof(dir))
1147 != sizeof(dir))
1148 {
1149 result = -1;
1150 errcode = EINVAL;
1151 }
1152 }
1153 break;
1154#endif
1155
1156 case __NR_flock:
1157 result = flock(arg1, arg2);
1158 errcode = errno;
1159 break;
1160
1161 case __NR_msync:
1162 result = msync((void *) arg1, arg2, arg3);
1163 errcode = errno;
1164 break;
1165
1166 case __NR_readv:
1167 {
1168 struct iovec vector;
1169
1170 vector = *((struct iovec *) t2h_addr(cb, &s, arg2));
1171 translate_endian((void *) &vector, sizeof(vector));
1172
1173 result = readv(arg1, &vector, arg3);
1174 errcode = errno;
1175 }
1176 break;
1177
1178 case __NR_writev:
1179 {
1180 struct iovec vector;
1181
1182 vector = *((struct iovec *) t2h_addr(cb, &s, arg2));
1183 translate_endian((void *) &vector, sizeof(vector));
1184
1185 result = writev(arg1, &vector, arg3);
1186 errcode = errno;
1187 }
1188 break;
1189
1190 case __NR_fdatasync:
1191 result = fdatasync(arg1);
1192 errcode = errno;
1193 break;
1194
1195 case __NR_mlock:
1196 result = mlock((void *) t2h_addr(cb, &s, arg1), arg2);
1197 errcode = errno;
1198 break;
1199
1200 case __NR_munlock:
1201 result = munlock((void *) t2h_addr(cb, &s, arg1), arg2);
1202 errcode = errno;
1203 break;
1204
1205 case __NR_nanosleep:
1206 {
1207 struct timespec req, rem;
1208
1209 req = *((struct timespec *) t2h_addr(cb, &s, arg2));
1210 translate_endian((void *) &req, sizeof(req));
1211
1212 result = nanosleep(&req, &rem);
1213 errcode = errno;
1214
1215 if (result != 0)
1216 break;
1217
1218 translate_endian((void *) &rem, sizeof(rem));
1219 if ((s.write_mem) (cb, &s, arg2, (char *) &rem, sizeof(rem))
1220 != sizeof(rem))
1221 {
1222 result = -1;
1223 errcode = EINVAL;
1224 }
1225 }
1226 break;
1227
1228 case __NR_mremap: /* FIXME */
1229 result = (int) mremap((void *) t2h_addr(cb, &s, arg1), arg2, arg3, arg4);
1230 errcode = errno;
1231 break;
1232
1233 case __NR_getresuid32:
1234 case __NR_getresuid:
1235 {
1236 uid_t ruid, euid, suid;
1237
1238 result = getresuid(&ruid, &euid, &suid);
1239 errcode = errno;
1240
1241 if (result != 0)
1242 break;
1243
1244 *((uid_t *) t2h_addr(cb, &s, arg1)) = conv_endian(ruid);
1245 *((uid_t *) t2h_addr(cb, &s, arg2)) = conv_endian(euid);
1246 *((uid_t *) t2h_addr(cb, &s, arg3)) = conv_endian(suid);
1247 }
1248 break;
1249
1250 case __NR_poll:
1251 {
1252 struct pollfd ufds;
1253
1254 ufds = *((struct pollfd *) t2h_addr(cb, &s, arg1));
1255 ufds.fd = conv_endian(ufds.fd);
1256 ufds.events = conv_endian16(ufds.events);
1257 ufds.revents = conv_endian16(ufds.revents);
1258
1259 result = poll(&ufds, arg2, arg3);
1260 errcode = errno;
1261 }
1262 break;
1263
1264 case __NR_getresgid32:
1265 case __NR_getresgid:
1266 {
1267 uid_t rgid, egid, sgid;
1268
1269 result = getresgid(&rgid, &egid, &sgid);
1270 errcode = errno;
1271
1272 if (result != 0)
1273 break;
1274
1275 *((uid_t *) t2h_addr(cb, &s, arg1)) = conv_endian(rgid);
1276 *((uid_t *) t2h_addr(cb, &s, arg2)) = conv_endian(egid);
1277 *((uid_t *) t2h_addr(cb, &s, arg3)) = conv_endian(sgid);
1278 }
1279 break;
1280
1281 case __NR_pread:
1282 result = pread(arg1, (void *) t2h_addr(cb, &s, arg2), arg3, arg4);
1283 errcode = errno;
1284 break;
1285
1286 case __NR_pwrite:
1287 result = pwrite(arg1, (void *) t2h_addr(cb, &s, arg2), arg3, arg4);
1288 errcode = errno;
1289 break;
1290
1291 case __NR_chown32:
1292 case __NR_chown:
1293 result = chown((char *) t2h_addr(cb, &s, arg1), arg2, arg3);
1294 errcode = errno;
1295 break;
1296
1297 case __NR_getcwd:
1298 result = (int) getcwd((char *) t2h_addr(cb, &s, arg1), arg2);
1299 errcode = errno;
1300 break;
1301
1302 case __NR_sendfile:
1303 {
1304 off_t offset;
1305
1306 offset = *((off_t *) t2h_addr(cb, &s, arg3));
1307 offset = conv_endian(offset);
1308
1309 result = sendfile(arg1, arg2, &offset, arg3);
1310 errcode = errno;
1311
1312 if (result != 0)
1313 break;
1314
1315 *((off_t *) t2h_addr(cb, &s, arg3)) = conv_endian(offset);
1316 }
1317 break;
1318
1319 default:
1320 result = -1;
1321 errcode = ENOSYS;
1322 break;
1323 }
1324
1325 if (result == -1)
1326 m32rbf_h_gr_set (current_cpu, 0, -errcode);
1327 else
1328 m32rbf_h_gr_set (current_cpu, 0, result);
1329 break;
1330 }
1331
1332 case TRAP_BREAKPOINT:
1333 sim_engine_halt (sd, current_cpu, NULL, pc,
1334 sim_stopped, SIM_SIGTRAP);
1335 break;
1336
1337 case TRAP_FLUSH_CACHE:
1338 /* Do nothing. */
1339 break;
1340
1341 default :
1342 {
1343 /* Use cr5 as EVB (EIT Vector Base) register. */
1344 USI new_pc = m32rbf_h_cr_get (current_cpu, 5) + 0x40 + num * 4;
1345 return new_pc;
1346 }
1347 }
1348
1349 /* Fake an "rte" insn. */
1350 /* FIXME: Should duplicate all of rte processing. */
1351 return (pc & -4) + 4;
1352}
A mirror of the official binutils-gdb repository