URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [sim/] [rx/] [gdb-if.c] - Blame information for rev 613

Go to most recent revision | 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"
 
/* 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, 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;
    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;
    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, "off") == 0)
        verbose = 0;
      else
        printf ("The 'sim verbose' command expects 'on' 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_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [sim/] [rx/] [gdb-if.c] - Blame information for rev 613

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