OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [sim/] [ppc/] [main.c] - Diff between revs 227 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 227 Rev 816
/*  This file is part of the program psim.
/*  This file is part of the program psim.
 
 
    Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
    Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
 
 
    This program is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    (at your option) any later version.
 
 
    This program is distributed in the hope that it will be useful,
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    GNU General Public License for more details.
 
 
    You should have received a copy of the GNU General Public License
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 
    */
    */
 
 
 
 
#include <stdarg.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdio.h>
#include <fcntl.h>
#include <fcntl.h>
 
 
#include <signal.h>
#include <signal.h>
 
 
#include "psim.h"
#include "psim.h"
#include "options.h"
#include "options.h"
#include "device.h" /* FIXME: psim should provide the interface */
#include "device.h" /* FIXME: psim should provide the interface */
#include "events.h" /* FIXME: psim should provide the interface */
#include "events.h" /* FIXME: psim should provide the interface */
 
 
#include "bfd.h"
#include "bfd.h"
#include "gdb/callback.h"
#include "gdb/callback.h"
#include "gdb/remote-sim.h"
#include "gdb/remote-sim.h"
 
 
#ifdef HAVE_STDLIB_H
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#include <stdlib.h>
#endif
#endif
 
 
#ifdef HAVE_UNISTD_H
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#include <unistd.h>
#endif
#endif
 
 
#ifdef HAVE_STRING_H
#ifdef HAVE_STRING_H
#include <string.h>
#include <string.h>
#else
#else
#ifdef HAVE_STRINGS_H
#ifdef HAVE_STRINGS_H
#include <strings.h>
#include <strings.h>
#endif
#endif
#endif
#endif
 
 
#include <errno.h>
#include <errno.h>
 
 
#if !defined(O_NDELAY) || !defined(F_GETFL) || !defined(F_SETFL)
#if !defined(O_NDELAY) || !defined(F_GETFL) || !defined(F_SETFL)
#undef WITH_STDIO
#undef WITH_STDIO
#define WITH_STDIO DO_USE_STDIO
#define WITH_STDIO DO_USE_STDIO
#endif
#endif
 
 
 
 
extern char **environ;
extern char **environ;
 
 
static psim *simulation = NULL;
static psim *simulation = NULL;
 
 
 
 
void
void
sim_io_poll_quit (void)
sim_io_poll_quit (void)
{
{
  /* nothing to do */
  /* nothing to do */
}
}
 
 
void
void
sim_io_printf_filtered(const char *msg, ...)
sim_io_printf_filtered(const char *msg, ...)
{
{
  va_list ap;
  va_list ap;
  va_start(ap, msg);
  va_start(ap, msg);
  vprintf(msg, ap);
  vprintf(msg, ap);
  va_end(ap);
  va_end(ap);
}
}
 
 
void
void
error (const char *msg, ...)
error (const char *msg, ...)
{
{
  va_list ap;
  va_list ap;
  va_start(ap, msg);
  va_start(ap, msg);
  vprintf(msg, ap);
  vprintf(msg, ap);
  printf("\n");
  printf("\n");
  va_end(ap);
  va_end(ap);
 
 
  /* any final clean up */
  /* any final clean up */
  if (ppc_trace[trace_print_info] && simulation != NULL)
  if (ppc_trace[trace_print_info] && simulation != NULL)
    psim_print_info (simulation, ppc_trace[trace_print_info]);
    psim_print_info (simulation, ppc_trace[trace_print_info]);
 
 
  exit (1);
  exit (1);
}
}
 
 
int
int
sim_io_write_stdout(const char *buf,
sim_io_write_stdout(const char *buf,
                    int sizeof_buf)
                    int sizeof_buf)
{
{
  switch (CURRENT_STDIO) {
  switch (CURRENT_STDIO) {
  case DO_USE_STDIO:
  case DO_USE_STDIO:
    {
    {
      int i;
      int i;
      for (i = 0; i < sizeof_buf; i++) {
      for (i = 0; i < sizeof_buf; i++) {
        putchar(buf[i]);
        putchar(buf[i]);
      }
      }
      return i;
      return i;
    }
    }
    break;
    break;
  case DONT_USE_STDIO:
  case DONT_USE_STDIO:
    return write(1, buf, sizeof_buf);
    return write(1, buf, sizeof_buf);
    break;
    break;
  default:
  default:
    error("sim_io_write_stdout: invalid switch\n");
    error("sim_io_write_stdout: invalid switch\n");
  }
  }
  return 0;
  return 0;
}
}
 
 
int
int
sim_io_write_stderr(const char *buf,
sim_io_write_stderr(const char *buf,
                    int sizeof_buf)
                    int sizeof_buf)
{
{
  switch (CURRENT_STDIO) {
  switch (CURRENT_STDIO) {
  case DO_USE_STDIO:
  case DO_USE_STDIO:
    {
    {
      int i;
      int i;
      for (i = 0; i < sizeof_buf; i++) {
      for (i = 0; i < sizeof_buf; i++) {
        fputc(buf[i], stderr);
        fputc(buf[i], stderr);
      }
      }
      return i;
      return i;
    }
    }
    break;
    break;
  case DONT_USE_STDIO:
  case DONT_USE_STDIO:
    return write(2, buf, sizeof_buf);
    return write(2, buf, sizeof_buf);
    break;
    break;
  default:
  default:
    error("sim_io_write_stdout: invalid switch\n");
    error("sim_io_write_stdout: invalid switch\n");
  }
  }
  return 0;
  return 0;
}
}
 
 
int
int
sim_io_read_stdin(char *buf,
sim_io_read_stdin(char *buf,
                  int sizeof_buf)
                  int sizeof_buf)
{
{
  switch (CURRENT_STDIO) {
  switch (CURRENT_STDIO) {
  case DO_USE_STDIO:
  case DO_USE_STDIO:
    if (sizeof_buf > 1) {
    if (sizeof_buf > 1) {
      if (fgets(buf, sizeof_buf, stdin) != NULL)
      if (fgets(buf, sizeof_buf, stdin) != NULL)
        return strlen(buf);
        return strlen(buf);
    }
    }
    else if (sizeof_buf == 1) {
    else if (sizeof_buf == 1) {
      char b[2];
      char b[2];
      if (fgets(b, sizeof(b), stdin) != NULL) {
      if (fgets(b, sizeof(b), stdin) != NULL) {
        memcpy(buf, b, strlen(b));
        memcpy(buf, b, strlen(b));
        return strlen(b);
        return strlen(b);
      }
      }
    }
    }
    else if (sizeof_buf == 0)
    else if (sizeof_buf == 0)
      return 0;
      return 0;
    return sim_io_eof;
    return sim_io_eof;
    break;
    break;
  case DONT_USE_STDIO:
  case DONT_USE_STDIO:
#if defined(O_NDELAY) && defined(F_GETFL) && defined(F_SETFL)
#if defined(O_NDELAY) && defined(F_GETFL) && defined(F_SETFL)
    {
    {
      /* check for input */
      /* check for input */
      int flags;
      int flags;
      int status;
      int status;
      int nr_read;
      int nr_read;
      int result;
      int result;
      /* get the old status */
      /* get the old status */
      flags = fcntl(0, F_GETFL, 0);
      flags = fcntl(0, F_GETFL, 0);
      if (flags == -1) {
      if (flags == -1) {
        perror("sim_io_read_stdin");
        perror("sim_io_read_stdin");
        return sim_io_eof;
        return sim_io_eof;
      }
      }
      /* temp, disable blocking IO */
      /* temp, disable blocking IO */
      status = fcntl(0, F_SETFL, flags | O_NDELAY);
      status = fcntl(0, F_SETFL, flags | O_NDELAY);
      if (status == -1) {
      if (status == -1) {
        perror("sim_io_read_stdin");
        perror("sim_io_read_stdin");
        return sim_io_eof;
        return sim_io_eof;
      }
      }
      /* try for input */
      /* try for input */
      nr_read = read(0, buf, sizeof_buf);
      nr_read = read(0, buf, sizeof_buf);
      if (nr_read > 0
      if (nr_read > 0
          || (nr_read == 0 && sizeof_buf == 0))
          || (nr_read == 0 && sizeof_buf == 0))
        result = nr_read;
        result = nr_read;
      else if (nr_read == 0)
      else if (nr_read == 0)
        result = sim_io_eof;
        result = sim_io_eof;
      else { /* nr_read < 0 */
      else { /* nr_read < 0 */
        if (errno == EAGAIN)
        if (errno == EAGAIN)
          result = sim_io_not_ready;
          result = sim_io_not_ready;
        else
        else
          result = sim_io_eof;
          result = sim_io_eof;
      }
      }
      /* return to regular vewing */
      /* return to regular vewing */
      status = fcntl(0, F_SETFL, flags);
      status = fcntl(0, F_SETFL, flags);
      if (status == -1) {
      if (status == -1) {
        perror("sim_io_read_stdin");
        perror("sim_io_read_stdin");
        return sim_io_eof;
        return sim_io_eof;
      }
      }
      return result;
      return result;
    }
    }
    break;
    break;
#endif
#endif
  default:
  default:
    error("sim_io_read_stdin: invalid switch\n");
    error("sim_io_read_stdin: invalid switch\n");
    break;
    break;
  }
  }
  return 0;
  return 0;
}
}
 
 
void
void
sim_io_flush_stdoutput(void)
sim_io_flush_stdoutput(void)
{
{
  switch (CURRENT_STDIO) {
  switch (CURRENT_STDIO) {
  case DO_USE_STDIO:
  case DO_USE_STDIO:
    fflush (stdout);
    fflush (stdout);
    break;
    break;
  case DONT_USE_STDIO:
  case DONT_USE_STDIO:
    break;
    break;
  default:
  default:
    error("sim_io_flush_stdoutput: invalid switch\n");
    error("sim_io_flush_stdoutput: invalid switch\n");
    break;
    break;
  }
  }
}
}
 
 
void
void
sim_io_error (SIM_DESC sd, const char *msg, ...)
sim_io_error (SIM_DESC sd, const char *msg, ...)
{
{
  va_list ap;
  va_list ap;
  va_start(ap, msg);
  va_start(ap, msg);
  vprintf(msg, ap);
  vprintf(msg, ap);
  printf("\n");
  printf("\n");
  va_end(ap);
  va_end(ap);
 
 
  /* any final clean up */
  /* any final clean up */
  if (ppc_trace[trace_print_info] && simulation != NULL)
  if (ppc_trace[trace_print_info] && simulation != NULL)
    psim_print_info (simulation, ppc_trace[trace_print_info]);
    psim_print_info (simulation, ppc_trace[trace_print_info]);
 
 
  exit (1);
  exit (1);
}
}
 
 
 
 
void *
void *
zalloc(long size)
zalloc(long size)
{
{
  void *memory = malloc(size);
  void *memory = malloc(size);
  if (memory == NULL)
  if (memory == NULL)
    error("zalloc failed\n");
    error("zalloc failed\n");
  memset(memory, 0, size);
  memset(memory, 0, size);
  return memory;
  return memory;
}
}
 
 
void
void
zfree(void *chunk)
zfree(void *chunk)
{
{
  free(chunk);
  free(chunk);
}
}
 
 
/* When a CNTRL-C occures, queue an event to shut down the simulation */
/* When a CNTRL-C occures, queue an event to shut down the simulation */
 
 
static RETSIGTYPE
static RETSIGTYPE
cntrl_c(int sig)
cntrl_c(int sig)
{
{
  psim_stop (simulation);
  psim_stop (simulation);
}
}
 
 
 
 
int
int
main(int argc, char **argv)
main(int argc, char **argv)
{
{
  const char *name_of_file;
  const char *name_of_file;
  char *arg_;
  char *arg_;
  psim_status status;
  psim_status status;
  device *root = psim_tree();
  device *root = psim_tree();
 
 
  /* parse the arguments */
  /* parse the arguments */
  argv = psim_options(root, argv + 1);
  argv = psim_options(root, argv + 1);
  if (argv[0] == NULL) {
  if (argv[0] == NULL) {
    if (ppc_trace[trace_opts]) {
    if (ppc_trace[trace_opts]) {
      print_options ();
      print_options ();
      return 0;
      return 0;
    } else {
    } else {
      psim_usage(0, 0);
      psim_usage(0, 0);
    }
    }
  }
  }
  name_of_file = argv[0];
  name_of_file = argv[0];
 
 
  if (ppc_trace[trace_opts])
  if (ppc_trace[trace_opts])
    print_options ();
    print_options ();
 
 
  /* create the simulator */
  /* create the simulator */
  simulation = psim_create(name_of_file, root);
  simulation = psim_create(name_of_file, root);
 
 
  /* fudge the environment so that _=prog-name */
  /* fudge the environment so that _=prog-name */
  arg_ = (char*)zalloc(strlen(argv[0]) + strlen("_=") + 1);
  arg_ = (char*)zalloc(strlen(argv[0]) + strlen("_=") + 1);
  strcpy(arg_, "_=");
  strcpy(arg_, "_=");
  strcat(arg_, argv[0]);
  strcat(arg_, argv[0]);
  putenv(arg_);
  putenv(arg_);
 
 
  /* initialize it */
  /* initialize it */
  psim_init(simulation);
  psim_init(simulation);
  psim_stack(simulation, argv, environ);
  psim_stack(simulation, argv, environ);
 
 
  {
  {
    RETSIGTYPE (*prev) ();
    RETSIGTYPE (*prev) ();
    prev = signal(SIGINT, cntrl_c);
    prev = signal(SIGINT, cntrl_c);
    psim_run(simulation);
    psim_run(simulation);
    signal(SIGINT, prev);
    signal(SIGINT, prev);
  }
  }
 
 
  /* any final clean up */
  /* any final clean up */
  if (ppc_trace[trace_print_info])
  if (ppc_trace[trace_print_info])
    psim_print_info (simulation, ppc_trace[trace_print_info]);
    psim_print_info (simulation, ppc_trace[trace_print_info]);
 
 
  /* why did we stop */
  /* why did we stop */
  status = psim_get_status(simulation);
  status = psim_get_status(simulation);
  switch (status.reason) {
  switch (status.reason) {
  case was_continuing:
  case was_continuing:
    error("psim: continuing while stopped!\n");
    error("psim: continuing while stopped!\n");
    return 0;
    return 0;
  case was_trap:
  case was_trap:
    error("psim: no trap insn\n");
    error("psim: no trap insn\n");
    return 0;
    return 0;
  case was_exited:
  case was_exited:
    return status.signal;
    return status.signal;
  case was_signalled:
  case was_signalled:
    printf ("%s: Caught signal %d at address 0x%lx\n",
    printf ("%s: Caught signal %d at address 0x%lx\n",
            name_of_file, (int)status.signal,
            name_of_file, (int)status.signal,
            (long)status.program_counter);
            (long)status.program_counter);
    return status.signal;
    return status.signal;
  default:
  default:
    error("unknown halt condition\n");
    error("unknown halt condition\n");
    return 0;
    return 0;
  }
  }
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.