#include "server.h"
#include "bfd.h"
#include "callback.h"
#include "remote-sim.h"
extern int remote_debug;
extern host_callback default_callback;
static char my_registers[REGISTER_BYTES] __attribute__ ((aligned));
char * registers = my_registers;
int target_byte_order;
static SIM_DESC gdbsim_desc = 0;
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;
buffer = xmalloc (size);
lma = s->lma;
printf ("Loading section %s, size 0x%lx lma 0x%lx\n",
bfd_get_section_name (loadfile_bfd, s),
(unsigned long) size,
(unsigned long) lma);
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);
}
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);
}
for (nargs = 0; argv[nargs] != NULL; nargs++)
;
new_argv = alloca (sizeof (char *) * (nargs + 3));
for (nargs = 0; argv[nargs] != NULL; nargs++)
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;
default_callback.init (&default_callback);
gdbsim_desc = sim_open (SIM_OPEN_STANDALONE, &default_callback, abfd, argv);
if (gdbsim_desc == 0)
exit (1);
if (abfd)
if (sim_load (gdbsim_desc, program, NULL, 0) == SIM_RC_FAIL)
mygeneric_load (abfd);
sim_create_inferior (gdbsim_desc, abfd, argv, NULL);
sim_resume (gdbsim_desc, 1, 0);
return pid;
}
int
myattach (int pid)
{
return -1;
}
void
kill_inferior (void)
{
sim_close (gdbsim_desc, 0);
default_callback.shutdown (&default_callback);
}
static void
fetch_register (int regno)
{
sim_fetch_register (gdbsim_desc, regno, ®isters[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno));
}
void
fetch_inferior_registers (int regno)
{
if (regno == -1 || regno == 0)
for (regno = 0; regno < NUM_REGS ; regno++)
fetch_register (regno);
else
fetch_register (regno);
}
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));
}
int
mythread_alive (int pid)
{
return 1;
}
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:
if (remote_debug)
printf ("\nChild received signal = %x \n", sigrc);
fetch_inferior_registers (0);
*status = 'T';
return (unsigned char) sigrc;
}
}
void
myresume (int step, int signo)
{
sim_resume (gdbsim_desc, step, signo);
}
void
read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
sim_read (gdbsim_desc, memaddr, myaddr, len);
}
int
write_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
sim_write (gdbsim_desc, memaddr, myaddr, len);
return 0;
}
void
initialize_low (void)
{
}