From a1dc394560c17e331e83239ee87ede93dfb34b5e Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Fri, 7 Mar 1997 09:15:56 +0000 Subject: [PATCH] New files: sim-io - interface to external IO sim-events - event queue management sim-core - hardware memory model (device support optional but comming soon). --- sim/common/.Sanitize | 10 +- sim/common/sim-core-n.h | 95 +++++++++++++ sim/common/sim-io.c | 290 ++++++++++++++++++++++++++++++++++++++++ sim/common/sim-io.h | 130 ++++++++++++++++++ 4 files changed, 524 insertions(+), 1 deletion(-) create mode 100644 sim/common/sim-core-n.h create mode 100644 sim/common/sim-io.c create mode 100644 sim/common/sim-io.h diff --git a/sim/common/.Sanitize b/sim/common/.Sanitize index b01e17866a..d5539d1fd6 100644 --- a/sim/common/.Sanitize +++ b/sim/common/.Sanitize @@ -38,15 +38,23 @@ run.c run.1 sim-alu.h sim-basics.h +sim-bits-n.h sim-bits.c sim-bits.h sim-config.h +sim-core-n.h +sim-core.c +sim-core.h sim-endian-n.h sim-endian.c sim-endian.h +sim-events.c +sim-events.h sim-inline.c -sim-types.h sim-inline.h +sim-io.c +sim-io.h +sim-types.h tconfig.in Things-to-lose: diff --git a/sim/common/sim-core-n.h b/sim/common/sim-core-n.h new file mode 100644 index 0000000000..1bcb7227bd --- /dev/null +++ b/sim/common/sim-core-n.h @@ -0,0 +1,95 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1997, Andrew Cagney + + This program is free software; you can redistribute it and/or modify + it 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. + + This program is distributed in the hope that it 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 this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + */ + + +#ifndef N +#error "N must be #defined" +#endif + +/* NOTE: see end of file for #undef of these macros */ +#define unsigned_N XCONCAT2(unsigned_,N) +#define T2H_N XCONCAT2(T2H_,N) +#define H2T_N XCONCAT2(H2T_,N) + +#define core_map_read_N XCONCAT2(core_map_read_,N) +#define core_map_write_N XCONCAT2(core_map_write_,N) + + +INLINE_SIM_CORE(unsigned_N) +core_map_read_N(engine *system, + core_maps map, + unsigned_word addr) +{ + core_mapping *mapping = core_map_find_mapping(system, map, + addr, + sizeof(unsigned_N), + 1); /*abort*/ +#if (WITH_DEVICES) + if (WITH_CALLBACK_MEMORY && mapping->device != NULL) { + unsigned_N data; + if (device_io_read_buffer(mapping->device, + &data, + mapping->space, + addr, + sizeof(unsigned_N)) != sizeof(unsigned_N)) + device_error(mapping->device, "internal error - core_read_N() - io_read_buffer should not fail"); + return T2H_N(data); + } + else +#endif + return T2H_N(*(unsigned_N*)core_translate(mapping, addr)); +} + + + +INLINE_SIM_CORE(void) +core_map_write_N(engine *system, + core_maps map, + unsigned_word addr, + unsigned_N val) +{ + core_mapping *mapping = core_map_find_mapping(system, map, + addr, + sizeof(unsigned_N), + 1); /*abort*/ +#if (WITH_DEVICES) + if (WITH_CALLBACK_MEMORY && mapping->device != NULL) { + unsigned_N data = H2T_N(val); + if (device_io_write_buffer(mapping->device, + &data, + mapping->space, + addr, + sizeof(unsigned_N), /* nr_bytes */ + processor, + cia) != sizeof(unsigned_N)) + device_error(mapping->device, "internal error - core_write_N() - io_write_buffer should not fail"); + } + else +#endif + *(unsigned_N*)core_translate(mapping, addr) = H2T_N(val); +} + + +/* NOTE: see start of file for #define of these macros */ +#undef unsigned_N +#undef T2H_N +#undef H2T_N +#undef core_map_read_N +#undef core_map_write_N diff --git a/sim/common/sim-io.c b/sim/common/sim-io.c new file mode 100644 index 0000000000..7d40ccf496 --- /dev/null +++ b/sim/common/sim-io.c @@ -0,0 +1,290 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1997, Andrew Cagney + + This program is free software; you can redistribute it and/or modify + it 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. + + This program is distributed in the hope that it 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 this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + */ + + +#ifndef _SIM_IO_C_ +#define _SIM_IO_C_ + +#include "engine.h" + +/* See the file include/callbacks.h for a description */ + + +INLINE_SIM_IO(int) +sim_io_init(engine *system) +{ + return system->callback->init (system->callback); +} + + +INLINE_SIM_IO(int) +sim_io_shutdown(engine *system) +{ + return system->callback->shutdown (system->callback); +} + + +INLINE_SIM_IO(int) +sim_io_unlink(engine *system, + const char *f1) +{ + return system->callback->unlink (system->callback, f1); +} + + +INLINE_SIM_IO(long) +sim_io_time(engine *system, + long *t) +{ + return system->callback->time (system->callback, t); +} + + +INLINE_SIM_IO(int) +sim_io_system(engine *system, const char *s) +{ + return system->callback->system (system->callback, s); +} + + +INLINE_SIM_IO(int) +sim_io_rename(engine *system, + const char *f1, + const char *f2) +{ + return system->callback->rename (system->callback, f1, f2); +} + + +INLINE_SIM_IO(int) +sim_io_write_stdout(engine *system, + const char *buf, + int len) +{ + switch (CURRENT_STDIO) { + case DO_USE_STDIO: + return system->callback->write_stdout (system->callback, buf, len); + break; + case DONT_USE_STDIO: + return system->callback->write (system->callback, 1, buf, len); + break; + default: + sim_io_error (system, "sim_io_write_stdout: unaccounted switch\n"); + break; + } + return 0; +} + + +INLINE_SIM_IO(int) +sim_io_flush_stdout(engine *system) +{ + switch (CURRENT_STDIO) { + case DO_USE_STDIO: + return system->callback->flush_stdout (system->callback); + break; + case DONT_USE_STDIO: + break; + default: + sim_io_error (system, "sim_io_flush_stdout: unaccounted switch\n"); + break; + } +} + + +INLINE_SIM_IO(int) +sim_io_write_stderr(engine *system, + const char *buf, + int len) +{ + switch (CURRENT_STDIO) { + case DO_USE_STDIO: + return system->callback->write_stderr (system->callback, buf, len); + break; + case DONT_USE_STDIO: + return system->callback->write (system->callback, 2, buf, len); + break; + default: + sim_io_error (system, "sim_io_write_stderr: unaccounted switch\n"); + break; + } + return 0; +} + + +INLINE_SIM_IO(int) +sim_io_flush_stderr(engine *system) +{ + switch (CURRENT_STDIO) { + case DO_USE_STDIO: + return system->callback->flush_stderr (system->callback); + break; + case DONT_USE_STDIO: + break; + default: + sim_io_error (system, "sim_io_flush_stderr: unaccounted switch\n"); + break; + } +} + + +INLINE_SIM_IO(int) +sim_io_write(engine *system, + int fd, + const char *buf, + int len) +{ + return system->callback->write (system->callback, fd, buf, len); +} + + +INLINE_SIM_IO(int) +sim_io_read_stdin(engine *system, + char *buf, + int len) +{ + switch (CURRENT_STDIO) { + case DO_USE_STDIO: + return system->callback->read_stdin (system->callback, buf, len); + break; + case DONT_USE_STDIO: + return system->callback->read (system->callback, 0, buf, len); + break; + default: + sim_io_error (system, "sim_io_read_stdin: unaccounted switch\n"); + break; + } + return 0; +} + + +INLINE_SIM_IO(int) +sim_io_read(engine *system, int fd, + char *buf, + int len) +{ + return system->callback->read(system->callback, fd, buf, len); +} + + +INLINE_SIM_IO(int) +sim_io_open(engine *system, + const char *name, + int flags) +{ + return system->callback->open (system->callback, name, flags); +} + + +INLINE_SIM_IO(int) +sim_io_lseek(engine *system, + int fd, + long off, + int way) +{ + return system->callback->lseek (system->callback, fd, off, way); +} + + +INLINE_SIM_IO(int) +sim_io_isatty(engine *system, + int fd) +{ + return system->callback->isatty (system->callback, fd); +} + + +INLINE_SIM_IO(int) +sim_io_get_errno(engine *system) +{ + return system->callback->get_errno (system->callback); +} + + +INLINE_SIM_IO(int) +sim_io_close(engine *system, + int fd) +{ + return system->callback->close (system->callback, fd); +} + + +INLINE_SIM_IO(void) +sim_io_printf(engine *system, + const char *fmt, + ...) +{ + va_list ap; + va_start(ap, fmt); + system->callback->vprintf_filtered (system->callback, fmt, ap); + va_end(ap); +} + + +INLINE_SIM_IO(void) +sim_io_vprintf(engine *system, + const char *fmt, + va_list ap) +{ + system->callback->vprintf_filtered (system->callback, fmt, ap); +} + + +INLINE_SIM_IO(void) +sim_io_eprintf(engine *system, + const char *fmt, + ...) +{ + va_list ap; + va_start(ap, fmt); + system->callback->evprintf_filtered (system->callback, fmt, ap); + va_end(ap); +} + + +INLINE_SIM_IO(void) +sim_io_evprintf(engine *system, + const char *fmt, + va_list ap) +{ + system->callback->evprintf_filtered (system->callback, fmt, ap); +} + + +INLINE_SIM_IO(void) +sim_io_error(engine *system, + const char *fmt, + ...) +{ + char buf[1000]; + va_list ap; + va_start(ap, fmt); + vsprintf(buf, fmt, ap); + va_end(ap); + + if (strlen(buf) >= sizeof(buf)) + abort(); + + system->callback->error (system->callback, "%s", buf); +} + + + +#endif diff --git a/sim/common/sim-io.h b/sim/common/sim-io.h new file mode 100644 index 0000000000..0ab3cb251e --- /dev/null +++ b/sim/common/sim-io.h @@ -0,0 +1,130 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1997, Andrew Cagney + + This program is free software; you can redistribute it and/or modify + it 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. + + This program is distributed in the hope that it 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 this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + */ + + +#ifndef _SIM_IO_H_ +#define _SIM_IO_H_ + + +/* See the file include/callbacks.h for a description */ + +INLINE_SIM_IO\ +(int) sim_io_init +(engine *system); + +INLINE_SIM_IO\ +(int) sim_io_shutdown +(engine *system); + +INLINE_SIM_IO\ +(int) sim_io_unlink +(engine *system, const char *); + +INLINE_SIM_IO\ +(long) sim_io_time +(engine *system, long *); + +INLINE_SIM_IO\ +(int) sim_io_system +(engine *system, const char *); + +INLINE_SIM_IO\ +(int) sim_io_rename +(engine *system, const char *, const char *); + +INLINE_SIM_IO\ +(int) sim_io_write_stdout +(engine *system, const char *, int); + +INLINE_SIM_IO\ +(int) sim_io_flush_stdout +(engine *system); + +INLINE_SIM_IO\ +(int) sim_io_write_stderr +(engine *system, const char *, int); + +INLINE_SIM_IO\ +(int) sim_io_flush_stderr +(engine *system); + +INLINE_SIM_IO\ +(int) sim_io_write +(engine *system, int, const char *, int); + +INLINE_SIM_IO\ +(int) sim_io_read_stdin +(engine *system, char *, int); + +INLINE_SIM_IO\ +(int) sim_io_read +(engine *system, int, char *, int); + +INLINE_SIM_IO\ +(int) sim_io_open +(engine *system, const char *, int); + +INLINE_SIM_IO\ +(int) sim_io_lseek +(engine *system, int, long, int); + +INLINE_SIM_IO\ +(int) sim_io_isatty +(engine *system, int); + +INLINE_SIM_IO\ +(int) sim_io_get_errno +(engine *system); + +INLINE_SIM_IO\ +(int) sim_io_close +(engine *system, int); + +INLINE_SIM_IO\ +(void) sim_io_printf +(engine *system, + const char *fmt, + ...) __attribute__ ((format (printf, 2, 3))); + +INLINE_SIM_IO\ +(void) sim_io_vprintf +(engine *system, + const char *fmt, + va_list ap); + +INLINE_SIM_IO\ +(void) sim_io_eprintf +(engine *system, + const char *fmt, + ...) __attribute__ ((format (printf, 2, 3))); + +INLINE_SIM_IO\ +(void) sim_io_evprintf +(engine *system, + const char *fmt, + va_list ap); + +INLINE_SIM_IO\ +(void) sim_io_error +(engine *system, + const char *fmt, + ...) __attribute__ ((format (printf, 2, 3))); + +#endif -- 2.34.1