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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [sim/] [rx/] [gdb-if.c] - Blame information for rev 841

Details | Compare with Previous | View Log


/* gdb-if.c -- sim interface to GDB.
 
Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
 
This file is part of the GNU simulators.
 
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 3 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, see <http://www.gnu.org/licenses/>.  */
 
#include <stdio.h>
#include <assert.h>
#include <signal.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
 
#include "ansidecl.h"
#include "gdb/callback.h"
#include "gdb/remote-sim.h"
#include "gdb/signals.h"
#include "gdb/sim-rx.h"
 
#include "cpu.h"
#include "mem.h"
#include "load.h"
#include "syscalls.h"
#include "err.h"
#include "trace.h"
 
/* Ideally, we'd wrap up all the minisim's data structures in an
   object and pass that around.  However, neither GDB nor run needs
   that ability.
 
   So we just have one instance, that lives in global variables, and
   each time we open it, we re-initialize it.  */
struct sim_state
{
  const char *message;
};
 
static struct sim_state the_minisim = {
  "This is the sole rx minisim instance.  See libsim.a's global variables."
};
 
static int open;
 
SIM_DESC
sim_open (SIM_OPEN_KIND kind,
          struct host_callback_struct *callback,
          struct bfd *abfd, char **argv)
{
  if (open)
    fprintf (stderr, "rx minisim: re-opened sim\n");
 
  /* The 'run' interface doesn't use this function, so we don't care
     about KIND; it's always SIM_OPEN_DEBUG.  */
  if (kind != SIM_OPEN_DEBUG)
    fprintf (stderr, "rx minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",
             kind);
 
  set_callbacks (callback);
 
  /* We don't expect any command-line arguments.  */
 
  init_mem ();
  init_regs ();
  execution_error_init_debugger ();
 
  sim_disasm_init (abfd);
  open = 1;
  return &the_minisim;
}
 
static void
check_desc (SIM_DESC sd)
{
  if (sd != &the_minisim)
    fprintf (stderr, "rx minisim: desc != &the_minisim\n");
}
 
void
sim_close (SIM_DESC sd, int quitting)
{
  check_desc (sd);
 
  /* Not much to do.  At least free up our memory.  */
  init_mem ();
 
  open = 0;
}
 
static bfd *
open_objfile (const char *filename)
{
  bfd *prog = bfd_openr (filename, 0);
 
  if (!prog)
    {
      fprintf (stderr, "Can't read %s\n", filename);
      return 0;
    }
 
  if (!bfd_check_format (prog, bfd_object))
    {
      fprintf (stderr, "%s not a rx program\n", filename);
      return 0;
    }
 
  return prog;
}
 
static struct swap_list
{
  bfd_vma start, end;
  struct swap_list *next;
} *swap_list = NULL;
 
static void
free_swap_list (void)
{
  while (swap_list)
    {
      struct swap_list *next = swap_list->next;
      free (swap_list);
      swap_list = next;
    }
}
 
/* When running in big endian mode, we must do an additional
   byte swap of memory areas used to hold instructions.  See
   the comment preceding rx_load in load.c to see why this is
   so.
 
   Construct a list of memory areas that must be byte swapped.
   This list will be consulted when either reading or writing
   memory.  */
 
static void
build_swap_list (struct bfd *abfd)
{
  asection *s;
  free_swap_list ();
 
  /* Nothing to do when in little endian mode.  */
  if (!rx_big_endian)
    return;
 
  for (s = abfd->sections; s; s = s->next)
    {
      if ((s->flags & SEC_LOAD) && (s->flags & SEC_CODE))
        {
          struct swap_list *sl;
          bfd_size_type size;
 
          size = bfd_get_section_size (s);
          if (size <= 0)
            continue;
 
          sl = malloc (sizeof (struct swap_list));
          assert (sl != NULL);
          sl->next = swap_list;
          sl->start = bfd_section_lma (abfd, s);
          sl->end = sl->start + size;
          swap_list = sl;
        }
    }
}
 
static int
addr_in_swap_list (bfd_vma addr)
{
  struct swap_list *s;
 
  for (s = swap_list; s; s = s->next)
    {
      if (s->start <= addr && addr < s->end)
        return 1;
    }
  return 0;
}
 
SIM_RC
sim_load (SIM_DESC sd, char *prog, struct bfd *abfd, int from_tty)
{
  check_desc (sd);
 
  if (!abfd)
    abfd = open_objfile (prog);
  if (!abfd)
    return SIM_RC_FAIL;
 
  rx_load (abfd);
  build_swap_list (abfd);
 
  return SIM_RC_OK;
}
 
SIM_RC
sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **env)
{
  check_desc (sd);
 
  if (abfd)
    {
      rx_load (abfd);
      build_swap_list (abfd);
    }
 
  return SIM_RC_OK;
}
 
int
sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
{
  int i;
 
  check_desc (sd);
 
  if (mem == 0)
    return 0;
 
  execution_error_clear_last_error ();
 
  for (i = 0; i < length; i++)
    {
      bfd_vma addr = mem + i;
      int do_swap = addr_in_swap_list (addr);
      buf[i] = mem_get_qi (addr ^ (do_swap ? 3 : 0));
 
      if (execution_error_get_last_error () != SIM_ERR_NONE)
        return i;
    }
 
  return length;
}
 
int
sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length)
{
  int i;
 
  check_desc (sd);
 
  execution_error_clear_last_error ();
 
  for (i = 0; i < length; i++)
    {
      bfd_vma addr = mem + i;
      int do_swap = addr_in_swap_list (addr);
      mem_put_qi (addr ^ (do_swap ? 3 : 0), buf[i]);
 
      if (execution_error_get_last_error () != SIM_ERR_NONE)
        return i;
    }
 
  return length;
}
 
/* Read the LENGTH bytes at BUF as an little-endian value.  */
static DI
get_le (unsigned char *buf, int length)
{
  DI acc = 0;
  while (--length >= 0)
    acc = (acc << 8) + buf[length];
 
  return acc;
}
 
/* Read the LENGTH bytes at BUF as a big-endian value.  */
static DI
get_be (unsigned char *buf, int length)
{
  DI acc = 0;
  while (length-- > 0)
    acc = (acc << 8) + *buf++;
 
  return acc;
}
 
/* Store VAL as a little-endian value in the LENGTH bytes at BUF.  */
static void
put_le (unsigned char *buf, int length, DI val)
{
  int i;
 
  for (i = 0; i < length; i++)
    {
      buf[i] = val & 0xff;
      val >>= 8;
    }
}
 
/* Store VAL as a big-endian value in the LENGTH bytes at BUF.  */
static void
put_be (unsigned char *buf, int length, DI val)
{
  int i;
 
  for (i = length-1; i >= 0; i--)
    {
      buf[i] = val & 0xff;
      val >>= 8;
    }
}
 
 
static int
check_regno (enum sim_rx_regnum regno)
{
  return 0 <= regno && regno < sim_rx_num_regs;
}
 
static size_t
reg_size (enum sim_rx_regnum regno)
{
  size_t size;
 
  switch (regno)
    {
    case sim_rx_r0_regnum:
      size = sizeof (regs.r[0]);
      break;
    case sim_rx_r1_regnum:
      size = sizeof (regs.r[1]);
      break;
    case sim_rx_r2_regnum:
      size = sizeof (regs.r[2]);
      break;
    case sim_rx_r3_regnum:
      size = sizeof (regs.r[3]);
      break;
    case sim_rx_r4_regnum:
      size = sizeof (regs.r[4]);
      break;
    case sim_rx_r5_regnum:
      size = sizeof (regs.r[5]);
      break;
    case sim_rx_r6_regnum:
      size = sizeof (regs.r[6]);
      break;
    case sim_rx_r7_regnum:
      size = sizeof (regs.r[7]);
      break;
    case sim_rx_r8_regnum:
      size = sizeof (regs.r[8]);
      break;
    case sim_rx_r9_regnum:
      size = sizeof (regs.r[9]);
      break;
    case sim_rx_r10_regnum:
      size = sizeof (regs.r[10]);
      break;
    case sim_rx_r11_regnum:
      size = sizeof (regs.r[11]);
      break;
    case sim_rx_r12_regnum:
      size = sizeof (regs.r[12]);
      break;
    case sim_rx_r13_regnum:
      size = sizeof (regs.r[13]);
      break;
    case sim_rx_r14_regnum:
      size = sizeof (regs.r[14]);
      break;
    case sim_rx_r15_regnum:
      size = sizeof (regs.r[15]);
      break;
    case sim_rx_isp_regnum:
      size = sizeof (regs.r_isp);
      break;
    case sim_rx_usp_regnum:
      size = sizeof (regs.r_usp);
      break;
    case sim_rx_intb_regnum:
      size = sizeof (regs.r_intb);
      break;
    case sim_rx_pc_regnum:
      size = sizeof (regs.r_pc);
      break;
    case sim_rx_ps_regnum:
      size = sizeof (regs.r_psw);
      break;
    case sim_rx_bpc_regnum:
      size = sizeof (regs.r_bpc);
      break;
    case sim_rx_bpsw_regnum:
      size = sizeof (regs.r_bpsw);
      break;
    case sim_rx_fintv_regnum:
      size = sizeof (regs.r_fintv);
      break;
    case sim_rx_fpsw_regnum:
      size = sizeof (regs.r_fpsw);
      break;
    case sim_rx_acc_regnum:
      size = sizeof (regs.r_acc);
      break;
    default:
      size = 0;
      break;
    }
  return size;
}
 
int
sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
{
  size_t size;
  DI val;
 
  check_desc (sd);
 
  if (!check_regno (regno))
    return 0;
 
  size = reg_size (regno);
 
  if (length != size)
    return 0;
 
  switch (regno)
    {
    case sim_rx_r0_regnum:
      val = get_reg (0);
      break;
    case sim_rx_r1_regnum:
      val = get_reg (1);
      break;
    case sim_rx_r2_regnum:
      val = get_reg (2);
      break;
    case sim_rx_r3_regnum:
      val = get_reg (3);
      break;
    case sim_rx_r4_regnum:
      val = get_reg (4);
      break;
    case sim_rx_r5_regnum:
      val = get_reg (5);
      break;
    case sim_rx_r6_regnum:
      val = get_reg (6);
      break;
    case sim_rx_r7_regnum:
      val = get_reg (7);
      break;
    case sim_rx_r8_regnum:
      val = get_reg (8);
      break;
    case sim_rx_r9_regnum:
      val = get_reg (9);
      break;
    case sim_rx_r10_regnum:
      val = get_reg (10);
      break;
    case sim_rx_r11_regnum:
      val = get_reg (11);
      break;
    case sim_rx_r12_regnum:
      val = get_reg (12);
      break;
    case sim_rx_r13_regnum:
      val = get_reg (13);
      break;
    case sim_rx_r14_regnum:
      val = get_reg (14);
      break;
    case sim_rx_r15_regnum:
      val = get_reg (15);
      break;
    case sim_rx_isp_regnum:
      val = get_reg (isp);
      break;
    case sim_rx_usp_regnum:
      val = get_reg (usp);
      break;
    case sim_rx_intb_regnum:
      val = get_reg (intb);
      break;
    case sim_rx_pc_regnum:
      val = get_reg (pc);
      break;
    case sim_rx_ps_regnum:
      val = get_reg (psw);
      break;
    case sim_rx_bpc_regnum:
      val = get_reg (bpc);
      break;
    case sim_rx_bpsw_regnum:
      val = get_reg (bpsw);
      break;
    case sim_rx_fintv_regnum:
      val = get_reg (fintv);
      break;
    case sim_rx_fpsw_regnum:
      val = get_reg (fpsw);
      break;
    case sim_rx_acc_regnum:
      val = ((DI) get_reg (acchi) << 32) | get_reg (acclo);
      break;
    default:
      fprintf (stderr, "rx minisim: unrecognized register number: %d\n",
               regno);
      return -1;
    }
 
  if (rx_big_endian)
    put_be (buf, length, val);
  else
    put_le (buf, length, val);
 
  return size;
}
 
int
sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
{
  size_t size;
  DI val;
 
  check_desc (sd);
 
  if (!check_regno (regno))
    return 0;
 
  size = reg_size (regno);
 
  if (length != size)
    return 0;
 
  if (rx_big_endian)
    val = get_be (buf, length);
  else
    val = get_le (buf, length);
 
  switch (regno)
    {
    case sim_rx_r0_regnum:
      put_reg (0, val);
      break;
    case sim_rx_r1_regnum:
      put_reg (1, val);
      break;
    case sim_rx_r2_regnum:
      put_reg (2, val);
      break;
    case sim_rx_r3_regnum:
      put_reg (3, val);
      break;
    case sim_rx_r4_regnum:
      put_reg (4, val);
      break;
    case sim_rx_r5_regnum:
      put_reg (5, val);
      break;
    case sim_rx_r6_regnum:
      put_reg (6, val);
      break;
    case sim_rx_r7_regnum:
      put_reg (7, val);
      break;
    case sim_rx_r8_regnum:
      put_reg (8, val);
      break;
    case sim_rx_r9_regnum:
      put_reg (9, val);
      break;
    case sim_rx_r10_regnum:
      put_reg (10, val);
      break;
    case sim_rx_r11_regnum:
      put_reg (11, val);
      break;
    case sim_rx_r12_regnum:
      put_reg (12, val);
      break;
    case sim_rx_r13_regnum:
      put_reg (13, val);
      break;
    case sim_rx_r14_regnum:
      put_reg (14, val);
      break;
    case sim_rx_r15_regnum:
      put_reg (15, val);
      break;
    case sim_rx_isp_regnum:
      put_reg (isp, val);
      break;
    case sim_rx_usp_regnum:
      put_reg (usp, val);
      break;
    case sim_rx_intb_regnum:
      put_reg (intb, val);
      break;
    case sim_rx_pc_regnum:
      put_reg (pc, val);
      break;
    case sim_rx_ps_regnum:
      put_reg (psw, val);
      break;
    case sim_rx_bpc_regnum:
      put_reg (bpc, val);
      break;
    case sim_rx_bpsw_regnum:
      put_reg (bpsw, val);
      break;
    case sim_rx_fintv_regnum:
      put_reg (fintv, val);
      break;
    case sim_rx_fpsw_regnum:
      put_reg (fpsw, val);
      break;
    default:
      fprintf (stderr, "rx minisim: unrecognized register number: %d\n",
               regno);
      return -1;
    }
 
  return size;
}
 
void
sim_info (SIM_DESC sd, int verbose)
{
  check_desc (sd);
 
  printf ("The rx minisim doesn't collect any statistics.\n");
}
 
static volatile int stop;
static enum sim_stop reason;
int siggnal;
 
 
/* Given a signal number used by the RX bsp (that is, newlib),
   return a host signal number.  (Oddly, the gdb/sim interface uses
   host signal numbers...)  */
int
rx_signal_to_host (int rx)
{
  switch (rx)
    {
    case 4:
#ifdef SIGILL
      return SIGILL;
#else
      return SIGSEGV;
#endif
 
    case 5:
      return SIGTRAP;
 
    case 10:
#ifdef SIGBUS
      return SIGBUS;
#else
      return SIGSEGV;
#endif
 
    case 11:
      return SIGSEGV;
 
    case 24:
#ifdef SIGXCPU
      return SIGXCPU;
#else
      break;
#endif
 
    case 2:
      return SIGINT;
 
    case 8:
#ifdef SIGFPE
      return SIGFPE;
#else
      break;
#endif
 
    case 6:
      return SIGABRT;
    }
 
  return 0;
}
 
 
/* Take a step return code RC and set up the variables consulted by
   sim_stop_reason appropriately.  */
void
handle_step (int rc)
{
  if (execution_error_get_last_error () != SIM_ERR_NONE)
    {
      reason = sim_stopped;
      siggnal = TARGET_SIGNAL_SEGV;
    }
  if (RX_STEPPED (rc) || RX_HIT_BREAK (rc))
    {
      reason = sim_stopped;
      siggnal = TARGET_SIGNAL_TRAP;
    }
  else if (RX_STOPPED (rc))
    {
      reason = sim_stopped;
      siggnal = rx_signal_to_host (RX_STOP_SIG (rc));
    }
  else
    {
      assert (RX_EXITED (rc));
      reason = sim_exited;
      siggnal = RX_EXIT_STATUS (rc);
    }
}
 
 
void
sim_resume (SIM_DESC sd, int step, int sig_to_deliver)
{
  check_desc (sd);
 
  if (sig_to_deliver != 0)
    {
      fprintf (stderr,
               "Warning: the rx minisim does not implement "
               "signal delivery yet.\n" "Resuming with no signal.\n");
    }
 
  execution_error_clear_last_error ();
 
  if (step)
    handle_step (decode_opcode ());
  else
    {
      /* We don't clear 'stop' here, because then we would miss
         interrupts that arrived on the way here.  Instead, we clear
         the flag in sim_stop_reason, after GDB has disabled the
         interrupt signal handler.  */
      for (;;)
        {
          if (stop)
            {
              stop = 0;
              reason = sim_stopped;
              siggnal = TARGET_SIGNAL_INT;
              break;
            }
 
          int rc = decode_opcode ();
 
          if (execution_error_get_last_error () != SIM_ERR_NONE)
            {
              reason = sim_stopped;
              siggnal = TARGET_SIGNAL_SEGV;
              break;
            }
 
          if (!RX_STEPPED (rc))
            {
              handle_step (rc);
              break;
            }
        }
    }
}
 
int
sim_stop (SIM_DESC sd)
{
  stop = 1;
 
  return 1;
}
 
void
sim_stop_reason (SIM_DESC sd, enum sim_stop *reason_p, int *sigrc_p)
{
  check_desc (sd);
 
  *reason_p = reason;
  *sigrc_p = siggnal;
}
 
void
sim_do_command (SIM_DESC sd, char *cmd)
{
  check_desc (sd);
 
  char *p = cmd;
 
  /* Skip leading whitespace.  */
  while (isspace (*p))
    p++;
 
  /* Find the extent of the command word.  */
  for (p = cmd; *p; p++)
    if (isspace (*p))
      break;
 
  /* Null-terminate the command word, and record the start of any
     further arguments.  */
  char *args;
  if (*p)
    {
      *p = '\0';
      args = p + 1;
      while (isspace (*args))
        args++;
    }
  else
    args = p;
 
  if (strcmp (cmd, "trace") == 0)
    {
      if (strcmp (args, "on") == 0)
        trace = 1;
      else if (strcmp (args, "off") == 0)
        trace = 0;
      else
        printf ("The 'sim trace' command expects 'on' or 'off' "
                "as an argument.\n");
    }
  else if (strcmp (cmd, "verbose") == 0)
    {
      if (strcmp (args, "on") == 0)
        verbose = 1;
      else if (strcmp (args, "noisy") == 0)
        verbose = 2;
      else if (strcmp (args, "off") == 0)
        verbose = 0;
      else
        printf ("The 'sim verbose' command expects 'on', 'noisy', or 'off'"
                " as an argument.\n");
    }
  else
    printf ("The 'sim' command expects either 'trace' or 'verbose'"
            " as a subcommand.\n");
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [sim/] [rx/] [gdb-if.c] - Blame information for rev 841

Line No.	Rev	Author	Line
1	330	jeremybenn	`/* gdb-if.c -- sim interface to GDB.`
2
3			`Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.`
4			`Contributed by Red Hat, Inc.`
5
6			`This file is part of the GNU simulators.`
7
8			`This program is free software; you can redistribute it and/or modify`
9			`it under the terms of the GNU General Public License as published by`
10			`the Free Software Foundation; either version 3 of the License, or`
11			`(at your option) any later version.`
12
13			`This program is distributed in the hope that it will be useful,`
14			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`You should have received a copy of the GNU General Public License`
19			`along with this program. If not, see <http://www.gnu.org/licenses/>. */`
20
21			`#include <stdio.h>`
22			`#include <assert.h>`
23			`#include <signal.h>`
24			`#include <string.h>`
25			`#include <ctype.h>`
26			`#include <stdlib.h>`
27
28			`#include "ansidecl.h"`
29			`#include "gdb/callback.h"`
30			`#include "gdb/remote-sim.h"`
31			`#include "gdb/signals.h"`
32			`#include "gdb/sim-rx.h"`
33
34			`#include "cpu.h"`
35			`#include "mem.h"`
36			`#include "load.h"`
37			`#include "syscalls.h"`
38			`#include "err.h"`
39			`#include "trace.h"`
40
41			`/* Ideally, we'd wrap up all the minisim's data structures in an`
42			`object and pass that around. However, neither GDB nor run needs`
43			`that ability.`
44
45			`So we just have one instance, that lives in global variables, and`
46			`each time we open it, we re-initialize it. */`
47			`struct sim_state`
48			`{`
49			`const char *message;`
50			`};`
51
52			`static struct sim_state the_minisim = {`
53			`"This is the sole rx minisim instance. See libsim.a's global variables."`
54			`};`
55
56			`static int open;`
57
58			`SIM_DESC`
59			`sim_open (SIM_OPEN_KIND kind,`
60			`struct host_callback_struct *callback,`
61			`struct bfd abfd, char *argv)`
62			`{`
63			`if (open)`
64			`fprintf (stderr, "rx minisim: re-opened sim\n");`
65
66			`/* The 'run' interface doesn't use this function, so we don't care`
67			`about KIND; it's always SIM_OPEN_DEBUG. */`
68			`if (kind != SIM_OPEN_DEBUG)`
69			`fprintf (stderr, "rx minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",`
70			`kind);`
71
72			`set_callbacks (callback);`
73
74			`/* We don't expect any command-line arguments. */`
75
76			`init_mem ();`
77			`init_regs ();`
78			`execution_error_init_debugger ();`
79
80			`sim_disasm_init (abfd);`
81			`open = 1;`
82			`return &the_minisim;`
83			`}`
84
85			`static void`
86			`check_desc (SIM_DESC sd)`
87			`{`
88			`if (sd != &the_minisim)`
89			`fprintf (stderr, "rx minisim: desc != &the_minisim\n");`
90			`}`
91
92			`void`
93			`sim_close (SIM_DESC sd, int quitting)`
94			`{`
95			`check_desc (sd);`
96
97			`/* Not much to do. At least free up our memory. */`
98			`init_mem ();`
99
100			`open = 0;`
101			`}`
102
103			`static bfd *`
104			`open_objfile (const char *filename)`
105			`{`
106			`bfd *prog = bfd_openr (filename, 0);`
107
108			`if (!prog)`
109			`{`
110			`fprintf (stderr, "Can't read %s\n", filename);`
111			`return 0;`
112			`}`
113
114			`if (!bfd_check_format (prog, bfd_object))`
115			`{`
116			`fprintf (stderr, "%s not a rx program\n", filename);`
117			`return 0;`
118			`}`
119
120			`return prog;`
121			`}`
122
123			`static struct swap_list`
124			`{`
125			`bfd_vma start, end;`
126			`struct swap_list *next;`
127			`} *swap_list = NULL;`
128
129			`static void`
130			`free_swap_list (void)`
131			`{`
132			`while (swap_list)`
133			`{`
134			`struct swap_list *next = swap_list->next;`
135			`free (swap_list);`
136			`swap_list = next;`
137			`}`
138			`}`
139
140			`/* When running in big endian mode, we must do an additional`
141			`byte swap of memory areas used to hold instructions. See`
142			`the comment preceding rx_load in load.c to see why this is`
143			`so.`
144
145			`Construct a list of memory areas that must be byte swapped.`
146			`This list will be consulted when either reading or writing`
147			`memory. */`
148
149			`static void`
150			`build_swap_list (struct bfd *abfd)`
151			`{`
152			`asection *s;`
153			`free_swap_list ();`
154
155			`/* Nothing to do when in little endian mode. */`
156			`if (!rx_big_endian)`
157			`return;`
158
159			`for (s = abfd->sections; s; s = s->next)`
160			`{`
161			`if ((s->flags & SEC_LOAD) && (s->flags & SEC_CODE))`
162			`{`
163			`struct swap_list *sl;`
164			`bfd_size_type size;`
165
166			`size = bfd_get_section_size (s);`
167			`if (size <= 0)`
168			`continue;`
169
170			`sl = malloc (sizeof (struct swap_list));`
171			`assert (sl != NULL);`
172			`sl->next = swap_list;`
173			`sl->start = bfd_section_lma (abfd, s);`
174			`sl->end = sl->start + size;`
175			`swap_list = sl;`
176			`}`
177			`}`
178			`}`
179
180			`static int`
181			`addr_in_swap_list (bfd_vma addr)`
182			`{`
183			`struct swap_list *s;`
184
185			`for (s = swap_list; s; s = s->next)`
186			`{`
187			`if (s->start <= addr && addr < s->end)`
188			`return 1;`
189			`}`
190			`return 0;`
191			`}`
192
193			`SIM_RC`
194			`sim_load (SIM_DESC sd, char prog, struct bfd abfd, int from_tty)`
195			`{`
196			`check_desc (sd);`
197
198			`if (!abfd)`
199			`abfd = open_objfile (prog);`
200			`if (!abfd)`
201			`return SIM_RC_FAIL;`
202
203			`rx_load (abfd);`
204			`build_swap_list (abfd);`
205
206			`return SIM_RC_OK;`
207			`}`
208
209			`SIM_RC`
210			`sim_create_inferior (SIM_DESC sd, struct bfd abfd, char argv, char *env)`
211			`{`
212			`check_desc (sd);`
213
214			`if (abfd)`
215			`{`
216			`rx_load (abfd);`
217			`build_swap_list (abfd);`
218			`}`
219
220			`return SIM_RC_OK;`
221			`}`
222
223			`int`
224			`sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)`
225			`{`
226			`int i;`
227
228			`check_desc (sd);`
229
230			`if (mem == 0)`
231			`return 0;`
232
233			`execution_error_clear_last_error ();`
234
235			`for (i = 0; i < length; i++)`
236			`{`
237			`bfd_vma addr = mem + i;`
238			`int do_swap = addr_in_swap_list (addr);`
239			`buf[i] = mem_get_qi (addr ^ (do_swap ? 3 : 0));`
240
241			`if (execution_error_get_last_error () != SIM_ERR_NONE)`
242			`return i;`
243			`}`
244
245			`return length;`
246			`}`
247
248			`int`
249			`sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length)`
250			`{`
251			`int i;`
252
253			`check_desc (sd);`
254
255			`execution_error_clear_last_error ();`
256
257			`for (i = 0; i < length; i++)`
258			`{`
259			`bfd_vma addr = mem + i;`
260			`int do_swap = addr_in_swap_list (addr);`
261			`mem_put_qi (addr ^ (do_swap ? 3 : 0), buf[i]);`
262
263			`if (execution_error_get_last_error () != SIM_ERR_NONE)`
264			`return i;`
265			`}`
266
267			`return length;`
268			`}`
269
270			`/* Read the LENGTH bytes at BUF as an little-endian value. */`
271			`static DI`
272			`get_le (unsigned char *buf, int length)`
273			`{`
274			`DI acc = 0;`
275			`while (--length >= 0)`
276			`acc = (acc << 8) + buf[length];`
277
278			`return acc;`
279			`}`
280
281			`/* Read the LENGTH bytes at BUF as a big-endian value. */`
282			`static DI`
283			`get_be (unsigned char *buf, int length)`
284			`{`
285			`DI acc = 0;`
286			`while (length-- > 0)`
287			`acc = (acc << 8) + *buf++;`
288
289			`return acc;`
290			`}`
291
292			`/* Store VAL as a little-endian value in the LENGTH bytes at BUF. */`
293			`static void`
294			`put_le (unsigned char *buf, int length, DI val)`
295			`{`
296			`int i;`
297
298			`for (i = 0; i < length; i++)`
299			`{`
300			`buf[i] = val & 0xff;`
301			`val >>= 8;`
302			`}`
303			`}`
304
305			`/* Store VAL as a big-endian value in the LENGTH bytes at BUF. */`
306			`static void`
307			`put_be (unsigned char *buf, int length, DI val)`
308			`{`
309			`int i;`
310
311			`for (i = length-1; i >= 0; i--)`
312			`{`
313			`buf[i] = val & 0xff;`
314			`val >>= 8;`
315			`}`
316			`}`
317
318
319			`static int`
320			`check_regno (enum sim_rx_regnum regno)`
321			`{`
322			`return 0 <= regno && regno < sim_rx_num_regs;`
323			`}`
324
325			`static size_t`
326			`reg_size (enum sim_rx_regnum regno)`
327			`{`
328			`size_t size;`
329
330			`switch (regno)`
331			`{`
332			`case sim_rx_r0_regnum:`
333			`size = sizeof (regs.r[0]);`
334			`break;`
335			`case sim_rx_r1_regnum:`
336			`size = sizeof (regs.r[1]);`
337			`break;`
338			`case sim_rx_r2_regnum:`
339			`size = sizeof (regs.r[2]);`
340			`break;`
341			`case sim_rx_r3_regnum:`
342			`size = sizeof (regs.r[3]);`
343			`break;`
344			`case sim_rx_r4_regnum:`
345			`size = sizeof (regs.r[4]);`
346			`break;`
347			`case sim_rx_r5_regnum:`
348			`size = sizeof (regs.r[5]);`
349			`break;`
350			`case sim_rx_r6_regnum:`
351			`size = sizeof (regs.r[6]);`
352			`break;`
353			`case sim_rx_r7_regnum:`
354			`size = sizeof (regs.r[7]);`
355			`break;`
356			`case sim_rx_r8_regnum:`
357			`size = sizeof (regs.r[8]);`
358			`break;`
359			`case sim_rx_r9_regnum:`
360			`size = sizeof (regs.r[9]);`
361			`break;`
362			`case sim_rx_r10_regnum:`
363			`size = sizeof (regs.r[10]);`
364			`break;`
365			`case sim_rx_r11_regnum:`
366			`size = sizeof (regs.r[11]);`
367			`break;`
368			`case sim_rx_r12_regnum:`
369			`size = sizeof (regs.r[12]);`
370			`break;`
371			`case sim_rx_r13_regnum:`
372			`size = sizeof (regs.r[13]);`
373			`break;`
374			`case sim_rx_r14_regnum:`
375			`size = sizeof (regs.r[14]);`
376			`break;`
377			`case sim_rx_r15_regnum:`
378			`size = sizeof (regs.r[15]);`
379			`break;`
380			`case sim_rx_isp_regnum:`
381			`size = sizeof (regs.r_isp);`
382			`break;`
383			`case sim_rx_usp_regnum:`
384			`size = sizeof (regs.r_usp);`
385			`break;`
386			`case sim_rx_intb_regnum:`
387			`size = sizeof (regs.r_intb);`
388			`break;`
389			`case sim_rx_pc_regnum:`
390			`size = sizeof (regs.r_pc);`
391			`break;`
392			`case sim_rx_ps_regnum:`
393			`size = sizeof (regs.r_psw);`
394			`break;`
395			`case sim_rx_bpc_regnum:`
396			`size = sizeof (regs.r_bpc);`
397			`break;`
398			`case sim_rx_bpsw_regnum:`
399			`size = sizeof (regs.r_bpsw);`
400			`break;`
401			`case sim_rx_fintv_regnum:`
402			`size = sizeof (regs.r_fintv);`
403			`break;`
404			`case sim_rx_fpsw_regnum:`
405			`size = sizeof (regs.r_fpsw);`
406			`break;`
407			`case sim_rx_acc_regnum:`
408			`size = sizeof (regs.r_acc);`
409			`break;`
410			`default:`
411			`size = 0;`
412			`break;`
413			`}`
414			`return size;`
415			`}`
416
417			`int`
418			`sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)`
419			`{`
420			`size_t size;`
421			`DI val;`
422
423			`check_desc (sd);`
424
425			`if (!check_regno (regno))`
426			`return 0;`
427
428			`size = reg_size (regno);`
429
430			`if (length != size)`
431			`return 0;`
432
433			`switch (regno)`
434			`{`
435			`case sim_rx_r0_regnum:`
436			`val = get_reg (0);`
437			`break;`
438			`case sim_rx_r1_regnum:`
439			`val = get_reg (1);`
440			`break;`
441			`case sim_rx_r2_regnum:`
442			`val = get_reg (2);`
443			`break;`
444			`case sim_rx_r3_regnum:`
445			`val = get_reg (3);`
446			`break;`
447			`case sim_rx_r4_regnum:`
448			`val = get_reg (4);`
449			`break;`
450			`case sim_rx_r5_regnum:`
451			`val = get_reg (5);`
452			`break;`
453			`case sim_rx_r6_regnum:`
454			`val = get_reg (6);`
455			`break;`
456			`case sim_rx_r7_regnum:`
457			`val = get_reg (7);`
458			`break;`
459			`case sim_rx_r8_regnum:`
460			`val = get_reg (8);`
461			`break;`
462			`case sim_rx_r9_regnum:`
463			`val = get_reg (9);`
464			`break;`
465			`case sim_rx_r10_regnum:`
466			`val = get_reg (10);`
467			`break;`
468			`case sim_rx_r11_regnum:`
469			`val = get_reg (11);`
470			`break;`
471			`case sim_rx_r12_regnum:`
472			`val = get_reg (12);`
473			`break;`
474			`case sim_rx_r13_regnum:`
475			`val = get_reg (13);`
476			`break;`
477			`case sim_rx_r14_regnum:`
478			`val = get_reg (14);`
479			`break;`
480			`case sim_rx_r15_regnum:`
481			`val = get_reg (15);`
482			`break;`
483			`case sim_rx_isp_regnum:`
484			`val = get_reg (isp);`
485			`break;`
486			`case sim_rx_usp_regnum:`
487			`val = get_reg (usp);`
488			`break;`
489			`case sim_rx_intb_regnum:`
490			`val = get_reg (intb);`
491			`break;`
492			`case sim_rx_pc_regnum:`
493			`val = get_reg (pc);`
494			`break;`
495			`case sim_rx_ps_regnum:`
496			`val = get_reg (psw);`
497			`break;`
498			`case sim_rx_bpc_regnum:`
499			`val = get_reg (bpc);`
500			`break;`
501			`case sim_rx_bpsw_regnum:`
502			`val = get_reg (bpsw);`
503			`break;`
504			`case sim_rx_fintv_regnum:`
505			`val = get_reg (fintv);`
506			`break;`
507			`case sim_rx_fpsw_regnum:`
508			`val = get_reg (fpsw);`
509			`break;`
510			`case sim_rx_acc_regnum:`
511			`val = ((DI) get_reg (acchi) << 32) \| get_reg (acclo);`
512			`break;`
513			`default:`
514			`fprintf (stderr, "rx minisim: unrecognized register number: %d\n",`
515			`regno);`
516			`return -1;`
517			`}`
518
519			`if (rx_big_endian)`
520			`put_be (buf, length, val);`
521			`else`
522			`put_le (buf, length, val);`
523
524			`return size;`
525			`}`
526
527			`int`
528			`sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)`
529			`{`
530			`size_t size;`
531			`DI val;`
532
533			`check_desc (sd);`
534
535			`if (!check_regno (regno))`
536			`return 0;`
537
538			`size = reg_size (regno);`
539
540			`if (length != size)`
541			`return 0;`
542
543			`if (rx_big_endian)`
544			`val = get_be (buf, length);`
545			`else`
546			`val = get_le (buf, length);`
547
548			`switch (regno)`
549			`{`
550			`case sim_rx_r0_regnum:`
551			`put_reg (0, val);`
552			`break;`
553			`case sim_rx_r1_regnum:`
554			`put_reg (1, val);`
555			`break;`
556			`case sim_rx_r2_regnum:`
557			`put_reg (2, val);`
558			`break;`
559			`case sim_rx_r3_regnum:`
560			`put_reg (3, val);`
561			`break;`
562			`case sim_rx_r4_regnum:`
563			`put_reg (4, val);`
564			`break;`
565			`case sim_rx_r5_regnum:`
566			`put_reg (5, val);`
567			`break;`
568			`case sim_rx_r6_regnum:`
569			`put_reg (6, val);`
570			`break;`
571			`case sim_rx_r7_regnum:`
572			`put_reg (7, val);`
573			`break;`
574			`case sim_rx_r8_regnum:`
575			`put_reg (8, val);`
576			`break;`
577			`case sim_rx_r9_regnum:`
578			`put_reg (9, val);`
579			`break;`
580			`case sim_rx_r10_regnum:`
581			`put_reg (10, val);`
582			`break;`
583			`case sim_rx_r11_regnum:`
584			`put_reg (11, val);`
585			`break;`
586			`case sim_rx_r12_regnum:`
587			`put_reg (12, val);`
588			`break;`
589			`case sim_rx_r13_regnum:`
590			`put_reg (13, val);`
591			`break;`
592			`case sim_rx_r14_regnum:`
593			`put_reg (14, val);`
594			`break;`
595			`case sim_rx_r15_regnum:`
596			`put_reg (15, val);`
597			`break;`
598			`case sim_rx_isp_regnum:`
599			`put_reg (isp, val);`
600			`break;`
601			`case sim_rx_usp_regnum:`
602			`put_reg (usp, val);`
603			`break;`
604			`case sim_rx_intb_regnum:`
605			`put_reg (intb, val);`
606			`break;`
607			`case sim_rx_pc_regnum:`
608			`put_reg (pc, val);`
609			`break;`
610			`case sim_rx_ps_regnum:`
611			`put_reg (psw, val);`
612			`break;`
613			`case sim_rx_bpc_regnum:`
614			`put_reg (bpc, val);`
615			`break;`
616			`case sim_rx_bpsw_regnum:`
617			`put_reg (bpsw, val);`
618			`break;`
619			`case sim_rx_fintv_regnum:`
620			`put_reg (fintv, val);`
621			`break;`
622			`case sim_rx_fpsw_regnum:`
623			`put_reg (fpsw, val);`
624			`break;`
625			`default:`
626			`fprintf (stderr, "rx minisim: unrecognized register number: %d\n",`
627			`regno);`
628			`return -1;`
629			`}`
630
631			`return size;`
632			`}`
633
634			`void`
635			`sim_info (SIM_DESC sd, int verbose)`
636			`{`
637			`check_desc (sd);`
638
639			`printf ("The rx minisim doesn't collect any statistics.\n");`
640			`}`
641
642			`static volatile int stop;`
643			`static enum sim_stop reason;`
644			`int siggnal;`
645
646
647			`/* Given a signal number used by the RX bsp (that is, newlib),`
648			`return a host signal number. (Oddly, the gdb/sim interface uses`
649			`host signal numbers...) */`
650			`int`
651			`rx_signal_to_host (int rx)`
652			`{`
653			`switch (rx)`
654			`{`
655			`case 4:`
656			`#ifdef SIGILL`
657			`return SIGILL;`
658			`#else`
659			`return SIGSEGV;`
660			`#endif`
661
662			`case 5:`
663			`return SIGTRAP;`
664
665			`case 10:`
666			`#ifdef SIGBUS`
667			`return SIGBUS;`
668			`#else`
669			`return SIGSEGV;`
670			`#endif`
671
672			`case 11:`
673			`return SIGSEGV;`
674
675			`case 24:`
676			`#ifdef SIGXCPU`
677			`return SIGXCPU;`
678			`#else`
679			`break;`
680			`#endif`
681
682			`case 2:`
683			`return SIGINT;`
684
685			`case 8:`
686			`#ifdef SIGFPE`
687			`return SIGFPE;`
688			`#else`
689			`break;`
690			`#endif`
691
692			`case 6:`
693			`return SIGABRT;`
694			`}`
695
696			`return 0;`
697			`}`
698
699
700			`/* Take a step return code RC and set up the variables consulted by`
701			`sim_stop_reason appropriately. */`
702			`void`
703			`handle_step (int rc)`
704			`{`
705			`if (execution_error_get_last_error () != SIM_ERR_NONE)`
706			`{`
707			`reason = sim_stopped;`
708			`siggnal = TARGET_SIGNAL_SEGV;`
709			`}`
710			`if (RX_STEPPED (rc) \|\| RX_HIT_BREAK (rc))`
711			`{`
712			`reason = sim_stopped;`
713			`siggnal = TARGET_SIGNAL_TRAP;`
714			`}`
715			`else if (RX_STOPPED (rc))`
716			`{`
717			`reason = sim_stopped;`
718			`siggnal = rx_signal_to_host (RX_STOP_SIG (rc));`
719			`}`
720			`else`
721			`{`
722			`assert (RX_EXITED (rc));`
723			`reason = sim_exited;`
724			`siggnal = RX_EXIT_STATUS (rc);`
725			`}`
726			`}`
727
728
729			`void`
730			`sim_resume (SIM_DESC sd, int step, int sig_to_deliver)`
731			`{`
732			`check_desc (sd);`
733
734			`if (sig_to_deliver != 0)`
735			`{`
736			`fprintf (stderr,`
737			`"Warning: the rx minisim does not implement "`
738			`"signal delivery yet.\n" "Resuming with no signal.\n");`
739			`}`
740
741			`execution_error_clear_last_error ();`
742
743			`if (step)`
744			`handle_step (decode_opcode ());`
745			`else`
746			`{`
747			`/* We don't clear 'stop' here, because then we would miss`
748			`interrupts that arrived on the way here. Instead, we clear`
749			`the flag in sim_stop_reason, after GDB has disabled the`
750			`interrupt signal handler. */`
751			`for (;;)`
752			`{`
753			`if (stop)`
754			`{`
755			`stop = 0;`
756			`reason = sim_stopped;`
757			`siggnal = TARGET_SIGNAL_INT;`
758			`break;`
759			`}`
760
761			`int rc = decode_opcode ();`
762
763			`if (execution_error_get_last_error () != SIM_ERR_NONE)`
764			`{`
765			`reason = sim_stopped;`
766			`siggnal = TARGET_SIGNAL_SEGV;`
767			`break;`
768			`}`
769
770			`if (!RX_STEPPED (rc))`
771			`{`
772			`handle_step (rc);`
773			`break;`
774			`}`
775			`}`
776			`}`
777			`}`
778
779			`int`
780			`sim_stop (SIM_DESC sd)`
781			`{`
782			`stop = 1;`
783
784			`return 1;`
785			`}`
786
787			`void`
788			`sim_stop_reason (SIM_DESC sd, enum sim_stop reason_p, int sigrc_p)`
789			`{`
790			`check_desc (sd);`
791
792			`*reason_p = reason;`
793			`*sigrc_p = siggnal;`
794			`}`
795
796			`void`
797			`sim_do_command (SIM_DESC sd, char *cmd)`
798			`{`
799			`check_desc (sd);`
800
801			`char *p = cmd;`
802
803			`/* Skip leading whitespace. */`
804			`while (isspace (*p))`
805			`p++;`
806
807			`/* Find the extent of the command word. */`
808			`for (p = cmd; *p; p++)`
809			`if (isspace (*p))`
810			`break;`
811
812			`/* Null-terminate the command word, and record the start of any`
813			`further arguments. */`
814			`char *args;`
815			`if (*p)`
816			`{`
817			`*p = '\0';`
818			`args = p + 1;`
819			`while (isspace (*args))`
820			`args++;`
821			`}`
822			`else`
823			`args = p;`
824
825			`if (strcmp (cmd, "trace") == 0)`
826			`{`
827			`if (strcmp (args, "on") == 0)`
828			`trace = 1;`
829			`else if (strcmp (args, "off") == 0)`
830			`trace = 0;`
831			`else`
832			`printf ("The 'sim trace' command expects 'on' or 'off' "`
833			`"as an argument.\n");`
834			`}`
835			`else if (strcmp (cmd, "verbose") == 0)`
836			`{`
837			`if (strcmp (args, "on") == 0)`
838			`verbose = 1;`
839			`else if (strcmp (args, "noisy") == 0)`
840			`verbose = 2;`
841			`else if (strcmp (args, "off") == 0)`
842			`verbose = 0;`
843			`else`
844			`printf ("The 'sim verbose' command expects 'on', 'noisy', or 'off'"`
845			`" as an argument.\n");`
846			`}`
847			`else`
848			`printf ("The 'sim' command expects either 'trace' or 'verbose'"`
849			`" as a subcommand.\n");`
850			`}`