+Fri Mar 21 13:36:20 1997 Andrew Cagney <cagney@kremvax.cygnus.com>
+
+ * run.c (string.h, strings.h, stdlib.h): Include.
+
+ * sim-events.c (sim_events_tick): Recent cleanup failed to return
+ 0 when nothing pending.
+
+ * run.c (sim_size, sim_trace): Plicate GCC - these two functions
+ will soon be going away.
+ (getopt): Plicate GCC.
+
+ * sim-endian.c (sim-io.h): Plicate GCC.
+ * sim-bits.c (sim-io.h): Ditto.
+ * sim-n-bits.h (ROTn): Ditto.
+
+ * sim-io.c (sim_io_error): Correct check for NULL.
+
+ * sim-assert.h (SIM_FILTER_PATH): Separate out the code filtering
+ the __FILE__.
+ * sim-events.c: Use SIM_FILTER_PATH to filter out the filename
+ path.
+
+Wed Mar 19 01:12:06 1997 Andrew Cagney <cagney@kremvax.cygnus.com>
+
+ * aclocal.m4 (SIM_AC_OPTION_*: Move so that they are outside of
+ SIM_AC_COMMON - SIM_AC_COMMON was gobling arguments.
+
Tue Mar 18 20:48:12 1997 Andrew Cagney <cagney@kremvax.cygnus.com>
* sim-alu.h: Include sim-xcat.h.
/* run front end support for all the simulators.
- Copyright (C) 1992, 1993 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993 1994, 1995, 1996 Free Software Foundation, Inc.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+/* Steve Chamberlain sac@cygnus.com,
+ and others at Cygnus. */
-/* Steve Chamberlain
- sac@cygnus.com */
+#include "config.h"
+#include "tconfig.h"
#include <signal.h>
#include <stdio.h>
+#ifdef __STDC__
+#include <stdarg.h>
+#else
#include <varargs.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
+#include "libiberty.h"
#include "bfd.h"
-#include "remote-sim.h"
#include "callback.h"
-#ifndef SIGQUIT
-#define SIGQUIT SIGTERM
-#endif
+#include "remote-sim.h"
-void usage();
+static void usage PARAMS ((void));
extern int optind;
extern char *optarg;
int target_byte_order;
extern host_callback default_callback;
+
+static char *myname;
+
+
+/* NOTE: sim_size() and sim_trace() are going away */
+extern void sim_size PARAMS ((int i));
+extern int sim_trace PARAMS ((SIM_DESC sd));
+
+extern int getopt ();
+
+
int
main (ac, av)
int ac;
int i;
int verbose = 0;
int trace = 0;
- char *name = "";
+ char *name;
+ static char *no_args[2];
+ char **sim_argv = &no_args[0];
+ char **prog_args;
enum sim_stop reason;
int sigrc;
+ SIM_DESC sd;
+
+ myname = av[0] + strlen (av[0]);
+ while (myname > av[0] && myname[-1] != '/')
+ --myname;
- while ((i = getopt (ac, av, "m:p:s:tv")) != EOF)
+ /* The first element of sim_open's argv is the program name. */
+ no_args[0] = av[0];
+
+ /* FIXME: This is currently being rewritten to have each simulator
+ do all argv processing. */
+
+#ifdef SIM_H8300 /* FIXME: quick hack */
+ while ((i = getopt (ac, av, "a:c:m:p:s:htv")) != EOF)
+#else
+ while ((i = getopt (ac, av, "a:c:m:p:s:tv")) != EOF)
+#endif
switch (i)
{
+ case 'a':
+ /* FIXME: Temporary hack. */
+ {
+ int len = strlen (av[0]) + strlen (optarg);
+ char *argbuf = (char *) alloca (len + 2);
+ sprintf (argbuf, "%s %s", av[0], optarg);
+ sim_argv = buildargv (argbuf);
+ }
+ break;
+#ifdef SIM_HAVE_SIMCACHE
+ case 'c':
+ sim_set_simcache_size (atoi (optarg));
+ break;
+#endif
case 'm':
+ /* FIXME: Rename to sim_set_mem_size. */
sim_size (atoi (optarg));
break;
+#ifdef SIM_HAVE_PROFILE
case 'p':
sim_set_profile (atoi (optarg));
break;
case 's':
sim_set_profile_size (atoi (optarg));
break;
+#endif
case 't':
trace = 1;
+ /* FIXME: need to allow specification of what to trace. */
+ /* sim_set_trace (1); */
break;
case 'v':
+ /* Things that are printed with -v are the kinds of things that
+ gcc -v prints. This is not meant to include detailed tracing
+ or debugging information, just summaries. */
verbose = 1;
+ /* sim_set_verbose (1); */
break;
+ /* FIXME: Quick hack, to be replaced by more general facility. */
+#ifdef SIM_H8300
+ case 'h':
+ set_h8300h (1);
+ break;
+#endif
default:
- usage();
+ usage ();
}
+
ac -= optind;
av += optind;
- if (ac != 1)
- usage();
-
name = *av;
+ prog_args = av + 1;
if (verbose)
{
- printf ("run %s\n", name);
+ printf ("%s %s\n", myname, name);
}
exec_bfd = abfd = bfd_openr (name, 0);
if (!abfd)
{
- fprintf (stderr, "run: can't open %s: %s\n",
- name, bfd_errmsg(bfd_get_error()));
+ fprintf (stderr, "%s: can't open %s: %s\n",
+ myname, name, bfd_errmsg (bfd_get_error ()));
exit (1);
}
if (!bfd_check_format (abfd, bfd_object))
{
- fprintf (stderr, "run: can't load %s: %s\n",
- name, bfd_errmsg(bfd_get_error()));
+ fprintf (stderr, "%s: can't load %s: %s\n",
+ myname, name, bfd_errmsg (bfd_get_error ()));
exit (1);
}
- sim_set_callbacks (&default_callback);
+ /* This must be set before sim_open is called, because gdb assumes that
+ the simulator endianness is known immediately after the sim_open call. */
+ target_byte_order = bfd_big_endian (abfd) ? 4321 : 1234;
+
+ sim_set_callbacks (NULL, &default_callback);
default_callback.init (&default_callback);
/* Ensure that any run-time initialisation that needs to be
performed by the simulator can occur. */
- sim_open(NULL);
+ sd = sim_open (sim_argv);
for (s = abfd->sections; s; s = s->next)
- if (abfd && (s->flags & SEC_LOAD))
{
- unsigned char *buffer = (unsigned char *)malloc ((size_t)(bfd_section_size (abfd, s)));
- if (buffer != NULL)
- {
- bfd_get_section_contents (abfd,
- s,
- buffer,
- 0,
- bfd_section_size (abfd, s));
- sim_write (s->vma, buffer, bfd_section_size (abfd, s));
- }
- else
- {
- fprintf (stderr, "run: failed to allocate section buffer: %s\n",
- bfd_errmsg(bfd_get_error()));
- exit (1);
- }
+ if (s->flags & SEC_LOAD)
+ {
+ unsigned char *buffer = (unsigned char *)malloc ((size_t)(bfd_section_size (abfd, s)));
+ if (buffer != NULL)
+ {
+ bfd_get_section_contents (abfd,
+ s,
+ buffer,
+ 0,
+ bfd_section_size (abfd, s));
+ sim_write (sd, s->vma, buffer, bfd_section_size (abfd, s));
+ /* FIXME: How come we don't free buffer? */
+ }
+ else
+ {
+ fprintf (stderr, "%s: failed to allocate section buffer: %s\n",
+ myname, bfd_errmsg (bfd_get_error ()));
+ exit (1);
+ }
+ }
}
start_address = bfd_get_start_address (abfd);
- sim_create_inferior (start_address, NULL, NULL);
-
- target_byte_order = bfd_big_endian (abfd) ? 4321 : 1234;
+ sim_create_inferior (sd, start_address, prog_args, NULL);
if (trace)
{
int done = 0;
while (!done)
{
- done = sim_trace ();
+ done = sim_trace (sd);
}
}
else
{
- sim_resume (0, 0);
+ sim_resume (sd, 0, 0);
}
if (verbose)
- sim_info (0);
+ sim_info (sd, 0);
- sim_stop_reason (&reason, &sigrc);
+ sim_stop_reason (sd, &reason, &sigrc);
- sim_close(0);
+ sim_close (sd, 0);
+ /* If reason is sim_exited, then sigrc holds the exit code which we want
+ to return. If reason is sim_stopped or sim_signalled, then sigrc holds
+ the signal that the simulator received; we want to return that to
+ indicate failure. */
+
+#ifdef SIM_H8300 /* FIXME: Ugh. grep for SLEEP in compile.c */
+ if (sigrc == SIGILL)
+ abort ();
+ sigrc = 0;
+#else
/* Why did we stop? */
switch (reason)
{
case sim_signalled:
case sim_stopped:
- fprintf (stderr, "program stopped with signal %d.\n", sigrc);
+ if (sigrc != 0)
+ fprintf (stderr, "program stopped with signal %d.\n", sigrc);
break;
case sim_exited:
break;
}
+#endif
- /* If reason is sim_exited, then sigrc holds the exit code which we want
- to return. If reason is sim_stopped or sim_signalled, then sigrc holds
- the signal that the simulator received; we want to return that to
- indicate failure. */
return sigrc;
}
-void
-usage()
+static void
+usage ()
{
- fprintf (stderr, "usage: run [-tv][-m size] program\n");
+ fprintf (stderr, "Usage: %s [options] program [program args]\n", myname);
+ fprintf (stderr, "Options:\n");
+ fprintf (stderr, "-a args Pass `args' to simulator.\n");
+#ifdef SIM_HAVE_SIMCACHE
+ fprintf (stderr, "-c size Set simulator cache size to `size'.\n");
+#endif
+#ifdef SIM_H8300
+ fprintf (stderr, "-h Executable is for h8/300h or h8/300s.\n");
+#endif
+ fprintf (stderr, "-m size Set memory size of simulator, in bytes.\n");
+#ifdef SIM_HAVE_PROFILE
+ fprintf (stderr, "-p freq Set profiling frequency.\n");
+ fprintf (stderr, "-s size Set profiling size.\n");
+#endif
+ fprintf (stderr, "-t Perform instruction tracing.\n");
+ fprintf (stderr, " Note: Very few simulators support tracing.\n");
+ fprintf (stderr, "-v Verbose output.\n");
+ fprintf (stderr, "\n");
+ fprintf (stderr, "program args Arguments to pass to simulated program.\n");
+ fprintf (stderr, " Note: Very few simulators support this.\n");
exit (1);
}
-
-
#ifndef _SIM_ASSERT_H_
#define _SIM_ASSERT_H_
-# if defined (WITH_ASSERT)
+#define SIM_FILTER_PATH(FILE, PATH) \
+do \
+ { \
+ /* strip leading path */ \
+ const char *p = (PATH); \
+ (FILE) = p; \
+ while (*p != '\0' && *p != ':') \
+ { \
+ if (*p == '/') \
+ (FILE) = p; \
+ p++; \
+ } \
+ } \
+while (0)
+
+/* The subtle difference between SIM_ASSERT and ASSERT is that
+ SIM_ASSERT passes `sd' to sim_io_error for the SIM_DESC,
+ ASSERT passes NULL. */
+
+#if defined (WITH_ASSERT)
#define SIM_ASSERT(EXPRESSION) \
-do { \
- if (WITH_ASSERT) { \
- if (!(EXPRESSION)) { \
- /* strip leading path */ \
- const char *file = __FILE__; \
- const char *p = file; \
- while (*p != '\0' && *p != ':') { \
- if (*p == '/') \
- file = p; \
- p++; \
+do \
+ { \
+ if (WITH_ASSERT) \
+ { \
+ if (!(EXPRESSION)) \
+ { \
+ /* report the failure */ \
+ const char *file; \
+ SIM_FILTER_PATH(file, __FILE__); \
+ sim_io_error (sd, "%s:%d: assertion failed - %s", \
+ file, __LINE__, #EXPRESSION); \
+ } \
} \
- /* report the failure */ \
- sim_io_error (sd, "%s:%d: assertion failed - %s", \
- file, __LINE__, #EXPRESSION); \
- } \
} \
-} while (0)
+while (0)
#else
#define SIM_ASSERT(EXPRESSION) do { /*nothing*/; } while (0)
#endif
#if defined (WITH_ASSERT)
#define ASSERT(EXPRESSION) \
-do { \
- if (WITH_ASSERT) { \
- if (!(EXPRESSION)) { \
- /* strip leading path */ \
- const char *file = __FILE__; \
- const char *p = file; \
- while (*p != '\0' && *p != ':') { \
- if (*p == '/') \
- file = p; \
- p++; \
+do \
+ { \
+ if (WITH_ASSERT) \
+ { \
+ if (!(EXPRESSION)) \
+ { \
+ /* report the failure */ \
+ const char *file; \
+ SIM_FILTER_PATH(file, __FILE__); \
+ sim_io_error (NULL, "%s:%d: assertion failed - %s", \
+ file, __LINE__, #EXPRESSION); \
+ } \
} \
- /* report the failure */ \
- sim_io_error (NULL, "%s:%d: assertion failed - %s", \
- file, __LINE__, #EXPRESSION); \
- } \
} \
-} while (0)
+while (0)
#else
#define ASSERT(EXPRESSION) do { /*nothing*/; } while (0)
#endif
#ifndef _SIM_IO_C_
#define _SIM_IO_C_
-#include "engine.h"
+#include "sim-state.h"
/* See the file include/callbacks.h for a description */
INLINE_SIM_IO(int)
-sim_io_init(engine *system)
+sim_io_init(SIM_DESC sd)
{
- return system->callback->init (system->callback);
+ return sd->callback->init (sd->callback);
}
INLINE_SIM_IO(int)
-sim_io_shutdown(engine *system)
+sim_io_shutdown(SIM_DESC sd)
{
- return system->callback->shutdown (system->callback);
+ return sd->callback->shutdown (sd->callback);
}
INLINE_SIM_IO(int)
-sim_io_unlink(engine *system,
+sim_io_unlink(SIM_DESC sd,
const char *f1)
{
- return system->callback->unlink (system->callback, f1);
+ return sd->callback->unlink (sd->callback, f1);
}
INLINE_SIM_IO(long)
-sim_io_time(engine *system,
+sim_io_time(SIM_DESC sd,
long *t)
{
- return system->callback->time (system->callback, t);
+ return sd->callback->time (sd->callback, t);
}
INLINE_SIM_IO(int)
-sim_io_system(engine *system, const char *s)
+sim_io_system(SIM_DESC sd, const char *s)
{
- return system->callback->system (system->callback, s);
+ return sd->callback->system (sd->callback, s);
}
INLINE_SIM_IO(int)
-sim_io_rename(engine *system,
+sim_io_rename(SIM_DESC sd,
const char *f1,
const char *f2)
{
- return system->callback->rename (system->callback, f1, f2);
+ return sd->callback->rename (sd->callback, f1, f2);
}
INLINE_SIM_IO(int)
-sim_io_write_stdout(engine *system,
+sim_io_write_stdout(SIM_DESC sd,
const char *buf,
int len)
{
switch (CURRENT_STDIO) {
case DO_USE_STDIO:
- return system->callback->write_stdout (system->callback, buf, len);
+ return sd->callback->write_stdout (sd->callback, buf, len);
break;
case DONT_USE_STDIO:
- return system->callback->write (system->callback, 1, buf, len);
+ return sd->callback->write (sd->callback, 1, buf, len);
break;
default:
- sim_io_error (system, "sim_io_write_stdout: unaccounted switch\n");
+ sim_io_error (sd, "sim_io_write_stdout: unaccounted switch\n");
break;
}
return 0;
}
-INLINE_SIM_IO(int)
-sim_io_flush_stdout(engine *system)
+INLINE_SIM_IO(void)
+sim_io_flush_stdout(SIM_DESC sd)
{
switch (CURRENT_STDIO) {
case DO_USE_STDIO:
- return system->callback->flush_stdout (system->callback);
+ sd->callback->flush_stdout (sd->callback);
break;
case DONT_USE_STDIO:
break;
default:
- sim_io_error (system, "sim_io_flush_stdout: unaccounted switch\n");
+ sim_io_error (sd, "sim_io_flush_stdout: unaccounted switch\n");
break;
}
}
INLINE_SIM_IO(int)
-sim_io_write_stderr(engine *system,
+sim_io_write_stderr(SIM_DESC sd,
const char *buf,
int len)
{
switch (CURRENT_STDIO) {
case DO_USE_STDIO:
- return system->callback->write_stderr (system->callback, buf, len);
+ return sd->callback->write_stderr (sd->callback, buf, len);
break;
case DONT_USE_STDIO:
- return system->callback->write (system->callback, 2, buf, len);
+ return sd->callback->write (sd->callback, 2, buf, len);
break;
default:
- sim_io_error (system, "sim_io_write_stderr: unaccounted switch\n");
+ sim_io_error (sd, "sim_io_write_stderr: unaccounted switch\n");
break;
}
return 0;
}
-INLINE_SIM_IO(int)
-sim_io_flush_stderr(engine *system)
+INLINE_SIM_IO(void)
+sim_io_flush_stderr(SIM_DESC sd)
{
switch (CURRENT_STDIO) {
case DO_USE_STDIO:
- return system->callback->flush_stderr (system->callback);
+ sd->callback->flush_stderr (sd->callback);
break;
case DONT_USE_STDIO:
break;
default:
- sim_io_error (system, "sim_io_flush_stderr: unaccounted switch\n");
+ sim_io_error (sd, "sim_io_flush_stderr: unaccounted switch\n");
break;
}
}
INLINE_SIM_IO(int)
-sim_io_write(engine *system,
+sim_io_write(SIM_DESC sd,
int fd,
const char *buf,
int len)
{
- return system->callback->write (system->callback, fd, buf, len);
+ return sd->callback->write (sd->callback, fd, buf, len);
}
INLINE_SIM_IO(int)
-sim_io_read_stdin(engine *system,
+sim_io_read_stdin(SIM_DESC sd,
char *buf,
int len)
{
switch (CURRENT_STDIO) {
case DO_USE_STDIO:
- return system->callback->read_stdin (system->callback, buf, len);
+ return sd->callback->read_stdin (sd->callback, buf, len);
break;
case DONT_USE_STDIO:
- return system->callback->read (system->callback, 0, buf, len);
+ return sd->callback->read (sd->callback, 0, buf, len);
break;
default:
- sim_io_error (system, "sim_io_read_stdin: unaccounted switch\n");
+ sim_io_error (sd, "sim_io_read_stdin: unaccounted switch\n");
break;
}
return 0;
INLINE_SIM_IO(int)
-sim_io_read(engine *system, int fd,
+sim_io_read(SIM_DESC sd, int fd,
char *buf,
int len)
{
- return system->callback->read(system->callback, fd, buf, len);
+ return sd->callback->read (sd->callback, fd, buf, len);
}
INLINE_SIM_IO(int)
-sim_io_open(engine *system,
+sim_io_open(SIM_DESC sd,
const char *name,
int flags)
{
- return system->callback->open (system->callback, name, flags);
+ return sd->callback->open (sd->callback, name, flags);
}
INLINE_SIM_IO(int)
-sim_io_lseek(engine *system,
+sim_io_lseek(SIM_DESC sd,
int fd,
long off,
int way)
{
- return system->callback->lseek (system->callback, fd, off, way);
+ return sd->callback->lseek (sd->callback, fd, off, way);
}
INLINE_SIM_IO(int)
-sim_io_isatty(engine *system,
+sim_io_isatty(SIM_DESC sd,
int fd)
{
- return system->callback->isatty (system->callback, fd);
+ return sd->callback->isatty (sd->callback, fd);
}
INLINE_SIM_IO(int)
-sim_io_get_errno(engine *system)
+sim_io_get_errno(SIM_DESC sd)
{
- return system->callback->get_errno (system->callback);
+ return sd->callback->get_errno (sd->callback);
}
INLINE_SIM_IO(int)
-sim_io_close(engine *system,
+sim_io_close(SIM_DESC sd,
int fd)
{
- return system->callback->close (system->callback, fd);
+ return sd->callback->close (sd->callback, fd);
}
INLINE_SIM_IO(void)
-sim_io_printf(engine *system,
+sim_io_printf(SIM_DESC sd,
const char *fmt,
...)
{
va_list ap;
va_start(ap, fmt);
- system->callback->vprintf_filtered (system->callback, fmt, ap);
+ sd->callback->vprintf_filtered (sd->callback, fmt, ap);
va_end(ap);
}
INLINE_SIM_IO(void)
-sim_io_vprintf(engine *system,
+sim_io_vprintf(SIM_DESC sd,
const char *fmt,
va_list ap)
{
- system->callback->vprintf_filtered (system->callback, fmt, ap);
+ sd->callback->vprintf_filtered (sd->callback, fmt, ap);
}
INLINE_SIM_IO(void)
-sim_io_eprintf(engine *system,
+sim_io_eprintf(SIM_DESC sd,
const char *fmt,
...)
{
va_list ap;
va_start(ap, fmt);
- system->callback->evprintf_filtered (system->callback, fmt, ap);
+ sd->callback->evprintf_filtered (sd->callback, fmt, ap);
va_end(ap);
}
INLINE_SIM_IO(void)
-sim_io_evprintf(engine *system,
+sim_io_evprintf(SIM_DESC sd,
const char *fmt,
va_list ap)
{
- system->callback->evprintf_filtered (system->callback, fmt, ap);
+ sd->callback->evprintf_filtered (sd->callback, fmt, ap);
}
INLINE_SIM_IO(void)
-sim_io_error(engine *system,
+sim_io_error(SIM_DESC sd,
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);
+ if (sd == NULL || sd->callback == NULL) {
+ va_list ap;
+ va_start(ap, fmt);
+ vfprintf (stderr, fmt, ap);
+ va_end(ap);
+ abort ();
+ }
+ else {
+ va_list ap;
+ va_start(ap, fmt);
+ sd->callback->evprintf_filtered (sd->callback, fmt, ap);
+ va_end(ap);
+ sd->callback->error (sd->callback, "");
+ }
}
-
-
#endif
projects / binutils-gdb.git / commitdiff