269 lines
7.1 KiB
C
269 lines
7.1 KiB
C
/* Low level interface to simulators, for the remote server for GDB.
|
|
Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
|
|
Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
#include "server.h"
|
|
#include "bfd.h"
|
|
#include "callback.h" /* GDB simulator callback interface */
|
|
#include "remote-sim.h" /* GDB simulator interface */
|
|
|
|
extern int remote_debug;
|
|
|
|
extern host_callback default_callback; /* in sim/common/callback.c */
|
|
|
|
static char my_registers[REGISTER_BYTES] __attribute__ ((aligned));
|
|
char * registers = my_registers;
|
|
|
|
int target_byte_order; /* used by simulator */
|
|
|
|
/* We record the result of sim_open so we can pass it
|
|
back to the other sim_foo routines. */
|
|
static SIM_DESC gdbsim_desc = 0;
|
|
|
|
/* This version of "load" should be usable for any simulator that
|
|
does not support loading itself. */
|
|
|
|
static void
|
|
mygeneric_load (bfd *loadfile_bfd)
|
|
{
|
|
asection *s;
|
|
|
|
for (s = loadfile_bfd->sections; s; s = s->next)
|
|
{
|
|
if (s->flags & SEC_LOAD)
|
|
{
|
|
bfd_size_type size;
|
|
|
|
size = bfd_get_section_size_before_reloc (s);
|
|
if (size > 0)
|
|
{
|
|
char *buffer;
|
|
bfd_vma lma; /* use load address, not virtual address */
|
|
|
|
buffer = xmalloc (size);
|
|
lma = s->lma;
|
|
|
|
/* Is this really necessary? I guess it gives the user something
|
|
to look at during a long download. */
|
|
printf ("Loading section %s, size 0x%lx lma 0x%lx\n",
|
|
bfd_get_section_name (loadfile_bfd, s),
|
|
(unsigned long) size,
|
|
(unsigned long) lma); /* chops high 32 bits. FIXME!! */
|
|
|
|
bfd_get_section_contents (loadfile_bfd, s, buffer, 0, size);
|
|
|
|
write_inferior_memory (lma, buffer, size);
|
|
free (buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
printf ("Start address 0x%lx\n",
|
|
(unsigned long) loadfile_bfd->start_address);
|
|
|
|
/* We were doing this in remote-mips.c, I suspect it is right
|
|
for other targets too. */
|
|
/* write_pc (loadfile_bfd->start_address); *//* FIXME!! */
|
|
}
|
|
|
|
int
|
|
create_inferior (char *program, char **argv)
|
|
{
|
|
bfd *abfd;
|
|
int pid = 0;
|
|
char **new_argv;
|
|
int nargs;
|
|
|
|
abfd = bfd_openr (program, 0);
|
|
if (!abfd)
|
|
{
|
|
fprintf (stderr, "gdbserver: can't open %s: %s\n",
|
|
program, bfd_errmsg (bfd_get_error ()));
|
|
exit (1);
|
|
}
|
|
|
|
if (!bfd_check_format (abfd, bfd_object))
|
|
{
|
|
fprintf (stderr, "gdbserver: unknown load format for %s: %s\n",
|
|
program, bfd_errmsg (bfd_get_error ()));
|
|
exit (1);
|
|
}
|
|
|
|
/* Add "-E big" or "-E little" to the argument list depending on the
|
|
endianness of the program to be loaded. */
|
|
for (nargs = 0; argv[nargs] != NULL; nargs++) /* count the args */
|
|
;
|
|
new_argv = alloca (sizeof (char *) * (nargs + 3)); /* allocate new args */
|
|
for (nargs = 0; argv[nargs] != NULL; nargs++) /* copy old to new */
|
|
new_argv[nargs] = argv[nargs];
|
|
new_argv[nargs] = "-E";
|
|
new_argv[nargs + 1] = bfd_big_endian (abfd) ? "big" : "little";
|
|
new_argv[nargs + 2] = NULL;
|
|
argv = new_argv;
|
|
|
|
/* Create an instance of the simulator. */
|
|
default_callback.init (&default_callback);
|
|
gdbsim_desc = sim_open (SIM_OPEN_STANDALONE, &default_callback, abfd, argv);
|
|
if (gdbsim_desc == 0)
|
|
exit (1);
|
|
|
|
/* Load the program into the simulator. */
|
|
if (abfd)
|
|
if (sim_load (gdbsim_desc, program, NULL, 0) == SIM_RC_FAIL)
|
|
mygeneric_load (abfd);
|
|
|
|
/* Create an inferior process in the simulator. This initializes SP. */
|
|
sim_create_inferior (gdbsim_desc, abfd, argv, /* env */ NULL);
|
|
sim_resume (gdbsim_desc, 1, 0); /* execute one instr */
|
|
return pid;
|
|
}
|
|
|
|
/* Attaching is not supported. */
|
|
int
|
|
myattach (int pid)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
/* Kill the inferior process. Make us have no inferior. */
|
|
|
|
void
|
|
kill_inferior (void)
|
|
{
|
|
sim_close (gdbsim_desc, 0);
|
|
default_callback.shutdown (&default_callback);
|
|
}
|
|
|
|
/* Fetch one register. */
|
|
|
|
static void
|
|
fetch_register (int regno)
|
|
{
|
|
sim_fetch_register (gdbsim_desc, regno, ®isters[REGISTER_BYTE (regno)],
|
|
REGISTER_RAW_SIZE (regno));
|
|
}
|
|
|
|
/* Fetch all registers, or just one, from the child process. */
|
|
|
|
void
|
|
fetch_inferior_registers (int regno)
|
|
{
|
|
if (regno == -1 || regno == 0)
|
|
for (regno = 0; regno < NUM_REGS /*-NUM_FREGS*/ ; regno++)
|
|
fetch_register (regno);
|
|
else
|
|
fetch_register (regno);
|
|
}
|
|
|
|
/* Store our register values back into the inferior.
|
|
If REGNO is -1, do this for all registers.
|
|
Otherwise, REGNO specifies which register (so we can save time). */
|
|
|
|
void
|
|
store_inferior_registers (int regno)
|
|
{
|
|
if (regno == -1)
|
|
{
|
|
for (regno = 0; regno < NUM_REGS; regno++)
|
|
store_inferior_registers (regno);
|
|
}
|
|
else
|
|
sim_store_register (gdbsim_desc, regno, ®isters[REGISTER_BYTE (regno)],
|
|
REGISTER_RAW_SIZE (regno));
|
|
}
|
|
|
|
/* Return nonzero if the given thread is still alive. */
|
|
int
|
|
mythread_alive (int pid)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* Wait for process, returns status */
|
|
|
|
unsigned char
|
|
mywait (char *status)
|
|
{
|
|
int sigrc;
|
|
enum sim_stop reason;
|
|
|
|
sim_stop_reason (gdbsim_desc, &reason, &sigrc);
|
|
switch (reason)
|
|
{
|
|
case sim_exited:
|
|
if (remote_debug)
|
|
printf ("\nChild exited with retcode = %x \n", sigrc);
|
|
*status = 'W';
|
|
return sigrc;
|
|
|
|
#if 0
|
|
case sim_stopped:
|
|
if (remote_debug)
|
|
printf ("\nChild terminated with signal = %x \n", sigrc);
|
|
*status = 'X';
|
|
return sigrc;
|
|
#endif
|
|
|
|
default: /* should this be sim_signalled or sim_stopped? FIXME!! */
|
|
if (remote_debug)
|
|
printf ("\nChild received signal = %x \n", sigrc);
|
|
fetch_inferior_registers (0);
|
|
*status = 'T';
|
|
return (unsigned char) sigrc;
|
|
}
|
|
}
|
|
|
|
/* Resume execution of the inferior process.
|
|
If STEP is nonzero, single-step it.
|
|
If SIGNAL is nonzero, give it that signal. */
|
|
|
|
void
|
|
myresume (int step, int signo)
|
|
{
|
|
/* Should be using target_signal_to_host() or signal numbers in target.h
|
|
to convert GDB signal number to target signal number. */
|
|
sim_resume (gdbsim_desc, step, signo);
|
|
}
|
|
|
|
/* Copy LEN bytes from inferior's memory starting at MEMADDR
|
|
to debugger memory starting at MYADDR. */
|
|
|
|
void
|
|
read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
|
|
{
|
|
sim_read (gdbsim_desc, memaddr, myaddr, len);
|
|
}
|
|
|
|
/* Copy LEN bytes of data from debugger memory at MYADDR
|
|
to inferior's memory at MEMADDR.
|
|
On failure (cannot write the inferior)
|
|
returns the value of errno. */
|
|
|
|
int
|
|
write_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
|
|
{
|
|
sim_write (gdbsim_desc, memaddr, myaddr, len); /* should check for error. FIXME!! */
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
initialize_low (void)
|
|
{
|
|
}
|