| /* syscalls.c - non-trap system calls for D10V |
| * |
| * This file contains system calls that cannot be implemented with |
| * a simple "trap 15" instruction. The ones that can are in trap.S. |
| */ |
| |
| #include <_ansi.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <errno.h> |
| #undef errno |
| |
| void _exit (int n); /* in trap.S */ |
| |
| extern int _write (int fd, const void *ptr, size_t len); |
| |
| int errno; |
| |
| register char *stack_ptr asm ("sp"); |
| |
| caddr_t |
| _sbrk (int incr) |
| { |
| extern char end; /* Defined by the linker */ |
| static char *heap_end; |
| char *prev_heap_end; |
| char *sp = (char *)stack_ptr; |
| |
| if (heap_end == 0) |
| { |
| heap_end = (char *)((((unsigned short) &end) + 7) & ~7); |
| } |
| prev_heap_end = heap_end; |
| if (heap_end + incr > sp) |
| { |
| _write (2, "Heap and stack collision\n", sizeof ("Heap and stack collision\n")-1); |
| abort (); |
| } |
| heap_end += incr; |
| if ((unsigned short)heap_end > 0xbfff |
| || (heap_end < prev_heap_end && incr > 0) |
| || (heap_end < (char *)((((unsigned short) &end) + 7) & ~7))) |
| { |
| _write (2, "Too much memory was allocated\n", sizeof ("Too much memory was allocated\n")-1); |
| abort (); |
| } |
| |
| return (caddr_t) prev_heap_end; |
| } |
| |
| int |
| _fstat (int file, |
| struct stat *st) |
| { |
| st->st_mode = S_IFCHR; |
| return 0; |
| } |
| |
| int |
| _unlink () |
| { |
| errno = ENOSYS; |
| return -1; |
| } |
| |
| int |
| _isatty (int fd) |
| { |
| return 1; |
| } |
| |
| void |
| _raise () |
| { |
| } |
| |
| /* If this library is compiled with -mint32, provide conversion functions for |
| the system call traps. */ |
| |
| #if __INT__==32 |
| extern short _read16 (short fd, void *ptr, short len); |
| int |
| _read (int fd, void *ptr, size_t len) |
| { |
| return _read16 ((short)fd, ptr, (short)len); |
| } |
| |
| extern short _write16 (short fd, const void *ptr, short len); |
| int |
| _write (int fd, const void *ptr, size_t len) |
| { |
| return _write16 ((short)fd, ptr, (short)len); |
| } |
| |
| extern short _lseek16 (short fd, long offset, short whence); |
| int |
| _lseek (int fd, off_t offset, int whence) |
| { |
| return _lseek16 ((short)fd, offset, (short)whence); |
| } |
| |
| extern short _close16 (short fd); |
| int |
| _close (int fd) |
| { |
| return _close16 ((short)fd); |
| } |
| |
| extern short _open16 (const char *name, short flags, short mode); |
| int |
| _open (const char *name, int flags, mode_t mode) |
| { |
| return _open16 (name, (short)flags, (short)mode); |
| } |
| |
| extern short _creat16 (const char *name, mode_t mode); |
| int |
| _creat (const char *name, mode_t mode) |
| { |
| return _creat16 (name, mode); |
| } |
| |
| extern void _exit16 (short status); |
| void |
| _exit (int status) |
| { |
| _exit16 ((short)status); |
| } |
| |
| extern short _stat16 (const char *name, struct stat *stat_pkt); |
| int |
| _stat (const char *name, struct stat *stat_pkt) |
| { |
| return _stat16 (name, stat_pkt); |
| } |
| |
| extern short _chmod16 (const char *name, short mode); |
| int |
| _chmod (const char *name, mode_t mode) |
| { |
| return _chmod16 (name, (short)mode); |
| } |
| |
| extern short _chown16 (const char *name, short uid, short gid); |
| int |
| _chown (const char *name, uid_t uid, gid_t gid) |
| { |
| return _chown16 (name, (short)uid, (short)gid); |
| } |
| |
| extern short _fork16 (void); |
| int |
| _fork (void) |
| { |
| return _fork16 (); |
| } |
| |
| extern short _wait16 (short *status); |
| int |
| _wait (int *status) |
| { |
| if (status) |
| { |
| short status16; |
| short ret = _wait16 (&status16); |
| if (ret >= 0) |
| *status = status16; |
| return ret; |
| } |
| else |
| return _wait16 ((short *)0); |
| } |
| |
| extern short _execve16 (const char *filename, const char *argv [], const char *envp[]); |
| int |
| _execve (const char *filename, const char *argv [], const char *envp[]) |
| { |
| return _execve16 (filename, argv, envp); |
| } |
| |
| extern short _execv16 (const char *filename, const char *argv []); |
| int |
| _execv (const char *filename, const char *argv []) |
| { |
| return _execv16 (filename, argv); |
| } |
| |
| extern short _pipe16 (short fds[]); |
| int |
| _pipe (int fds[]) |
| { |
| short fds16[2]; |
| short ret = _pipe16 (fds16); |
| if (ret >= 0) |
| { |
| fds[0] = fds16[0]; |
| fds[1] = fds16[1]; |
| } |
| |
| return ret; |
| } |
| |
| extern short _getpid16 (void); |
| int |
| _getpid (void) |
| { |
| return _getpid16 (); |
| } |
| |
| extern short _kill16 (short pid, short sig); |
| int |
| _kill (int pid, int sig) |
| { |
| return _kill16 ((short)pid, (short)sig); |
| } |
| #endif |