old-cross-binutils/gdb/remote-z8k.c

361 lines
7.6 KiB
C
Raw Normal View History

/* Remote debugging interface for Zilog Z8000 simulator
1993-02-04 17:24:10 +00:00
Copyright 1992,1993 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by Steve Chamberlain
(sac@cygnus.com).
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
#include "inferior.h"
#include "wait.h"
#include "value.h"
#include <string.h>
#include <ctype.h>
#include <fcntl.h>
#include <signal.h>
#include <setjmp.h>
#include <errno.h>
#include "terminal.h"
#include "target.h"
#include "gdbcore.h"
1993-02-04 18:05:30 +00:00
#include "../sim/z8k/sim.h"
/* External data declarations */
1993-02-05 18:07:09 +00:00
extern int stop_soon_quietly; /* for wait_for_inferior */
/* Forward data declarations */
/*extern struct target_ops sim_ops; /* Forward declaration */
1993-02-05 18:07:09 +00:00
void sim_store_register ();
void sim_set_oc ();
int inferior_pid;
int
sim_write_inferior_memory (memaddr, myaddr, len)
CORE_ADDR memaddr;
unsigned char *myaddr;
int len;
{
1993-02-05 18:07:09 +00:00
sim_write (memaddr, myaddr, len);
1993-02-04 00:17:25 +00:00
return 1;
}
1993-02-04 00:17:25 +00:00
static void
1993-02-05 18:07:09 +00:00
store_register (regno)
int regno;
{
1993-02-05 18:07:09 +00:00
if (regno == -1)
{
for (regno = 0; regno < 16; regno++)
{
store_register (regno);
}
}
else
1993-02-04 17:24:10 +00:00
{
1993-02-05 18:07:09 +00:00
sim_store_register (regno, read_register (regno));
1993-02-04 17:24:10 +00:00
}
}
void
1993-02-05 18:07:09 +00:00
sim_kill (arg, from_tty)
char *arg;
int from_tty;
{
}
/*
1993-02-05 18:07:09 +00:00
* Download a file specified in 'args', to the sim.
*/
static void
sasassim_load (args, fromtty)
1993-02-05 18:07:09 +00:00
char *args;
int fromtty;
{
1993-02-05 18:07:09 +00:00
bfd *abfd;
asection *s;
1993-02-05 18:07:09 +00:00
inferior_pid = 0;
abfd = bfd_openr (args, "coff-z8k");
1993-02-05 18:07:09 +00:00
if (!abfd)
{
printf_filtered ("Unable to open file %s\n", args);
return;
}
1993-02-05 18:07:09 +00:00
if (bfd_check_format (abfd, bfd_object) == 0)
{
printf_filtered ("File is not an object file\n");
return;
}
s = abfd->sections;
1993-02-05 18:07:09 +00:00
while (s != (asection *) NULL)
{
1993-02-05 18:07:09 +00:00
if (s->flags & SEC_LOAD)
{
int i;
int delta = 4096;
char *buffer = xmalloc (delta);
printf_filtered ("%s\t: 0x%4x .. 0x%4x ",
s->name, s->vma, s->vma + s->_raw_size);
for (i = 0; i < s->_raw_size; i += delta)
{
int sub_delta = delta;
if (sub_delta > s->_raw_size - i)
sub_delta = s->_raw_size - i;
bfd_get_section_contents (abfd, s, buffer, i, sub_delta);
sim_write_inferior_memory (s->vma + i, buffer, sub_delta);
printf_filtered ("*");
gdb_flush (gdb_stdout);
1993-02-05 18:07:09 +00:00
}
printf_filtered ("\n");
free (buffer);
}
s = s->next;
}
1993-02-05 18:07:09 +00:00
sim_set_pc (abfd->start_address);
}
/* This is called not only when we first attach, but also when the
user types "run" after having attached. */
1993-02-04 00:17:25 +00:00
static void
sim_create_inferior (execfile, args, env)
char *execfile;
char *args;
char **env;
{
int entry_pt;
if (args && *args)
1993-02-05 18:07:09 +00:00
error ("Can't pass arguments to remote sim process.");
if (execfile == 0 || exec_bfd == 0)
1993-02-05 18:07:09 +00:00
error ("No exec file specified");
entry_pt = (int) bfd_get_start_address (exec_bfd);
1993-02-05 18:07:09 +00:00
sim_kill (NULL, NULL);
sim_clear_breakpoints ();
init_wait_for_inferior ();
1993-02-04 00:17:25 +00:00
insert_breakpoints ();
proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
}
#if 0
static void
sim_open (name, from_tty)
char *name;
int from_tty;
{
1993-02-05 18:07:09 +00:00
if (name == 0)
{
name = "";
}
/* Clear any break points */
1993-02-05 18:07:09 +00:00
sim_clear_breakpoints ();
push_target (&sim_ops);
1993-02-05 18:07:09 +00:00
target_fetch_registers (-1);
1993-02-05 18:07:09 +00:00
printf_filtered ("Connected to the Z8000 Simulator.\n");
}
/* Close out all files and local state before this target loses control. */
static void
sim_close (quitting)
int quitting;
{
1993-02-05 18:07:09 +00:00
sim_clear_breakpoints ();
}
/* Terminate the open connection to the remote debugger.
Use this when you want to detach and do something else
with your gdb. */
1993-02-04 00:17:25 +00:00
static void
1993-02-05 18:07:09 +00:00
sim_detach (args, from_tty)
char *args;
int from_tty;
{
1993-02-05 18:07:09 +00:00
sim_clear_breakpoints ();
pop_target (); /* calls sim_close to do the real work */
if (from_tty)
1993-02-05 18:07:09 +00:00
printf_filtered ("Ending remote %s debugging\n", target_shortname);
}
#endif
1993-02-05 18:07:09 +00:00
/* Tell the remote machine to resume. */
/* Wait until the remote machine stops, then return,
storing status in STATUS just as `wait' would. */
#if 0
/* See remote-sim.c for how this is done now. */
int
* breakpoint.c (breakpoint_thread_match break_command_1): Thread-specific breakpoint support. * breakpoint.h (struct breakpoint): Add thread id field. * fork-child.c (fork_inferior): Move call to init_thread_list() back a bit so that init_trace_fun can do thread functions. * hppa-tdep.c (restore_pc_queue): Add pid to call to target_wait. * hppab-nat.c (child_resume): Handle default pid. * hppah-nat.c (child_resume): Handle default pid. * i386lynx-nat.c (child_wait): New arg pid. * inflow.c (kill_command): Reset thread list. * infptrace.c (child_resume): Handle default pid. * infrun.c: Thread-specific breakpoint support. * inftarg.c (child_wait): Add pid arg. * osfsolib.c (solib_create_inferior_hook): Add pid to call to target_resume. * procfs.c: Multi-thread support. * remote-bug.c (bug_wait): Add pid arg. * remote-hms.c (hms_wait): Add pid arg. * remote-mips.c (mips_wait): Add pid arg. * remote-mon.c (monitor_wait): Add pid arg. * remote-nindy.c (nindy_wait): Add pid arg. * remote-sim.c (gdbsim_wait): Add pid arg. * remote-udi.c (udi_wait): Add pid arg. * remote-vx.c (vx_wait): Add pid arg. * remote-z8k.c (sim_wait): Add pid arg. * remote.c (remote_wait): Add pid arg. * solib.c (solib_create_inferior_hook): Add pid to call to target_resume. * target.h (struct target_ops): Add pid arg to to_wait and to_notice_signals. * thread.c (valid_thread_id): New func to validate thread #s. * (pid_to_thread_id): New func to do the obvious. * thread.h: Prototypes for above. * coff-solib.c (coff_solib_add): Use nameoffset field to locate filename.
1993-10-16 06:42:02 +00:00
sim_wait (pid, status)
int pid;
WAITTYPE *status;
{
sim_stop_reason (&reason, &sigrc);
return inferior_pid;
}
#endif
/* Get ready to modify the registers array. On machines which store
individual registers, this doesn't need to do anything. On machines
which store all the registers in one fell swoop, this makes sure
that registers contains all the registers from the program being
debugged. */
1993-02-04 00:17:25 +00:00
static void
sim_prepare_to_store ()
{
/* Do nothing, since we can store individual regs */
}
static void
1993-02-05 18:07:09 +00:00
fetch_register (regno)
int regno;
{
1993-02-05 18:07:09 +00:00
if (regno == -1)
{
for (regno = 0; regno < 16; regno++)
fetch_register (regno);
}
else
{
char buf[MAX_REGISTER_RAW_SIZE];
sim_fetch_register (regno, buf);
supply_register (regno, buf);
}
}
/* Write a word WORD into remote address ADDR.
This goes through the data cache. */
void
sim_store_word (addr, word)
CORE_ADDR addr;
int word;
{
/* dcache_poke (addr, word);*/
}
int
1993-02-05 18:07:09 +00:00
sim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
CORE_ADDR memaddr;
char *myaddr;
int len;
int write;
1993-02-05 18:07:09 +00:00
struct target_ops *target; /* ignored */
{
if (write)
1993-02-05 18:07:09 +00:00
{
sim_write (memaddr, myaddr, len);
}
else
{
sim_read (memaddr, myaddr, len);
}
return len;
}
void
sim_files_info ()
{
1993-02-04 17:24:10 +00:00
char *file = "nothing";
1993-02-05 18:07:09 +00:00
1993-02-04 17:24:10 +00:00
if (exec_bfd)
1993-02-05 18:07:09 +00:00
file = bfd_get_filename (exec_bfd);
1993-02-04 17:24:10 +00:00
1993-02-05 18:07:09 +00:00
printf_filtered ("\tAttached to %s running on the z8k simulator\n", file);
}
/* This routine is run as a hook, just before the main command loop is
entered. If gdb is configured for the H8, but has not had its
target specified yet, this will loop prompting the user to do so.
*/
#if 0
void
sim_before_main_loop ()
{
push_target (&sim_ops);
}
/* Clear the sims notion of what the break points are */
1993-02-04 00:17:25 +00:00
static void
1993-02-05 18:07:09 +00:00
sim_mourn ()
{
sim_clear_breakpoints ();
unpush_target (&sim_ops);
generic_mourn_inferior ();
}
#endif
1993-02-05 18:07:09 +00:00
static void
Sun Aug 1 22:58:18 1993 Stu Grossman (grossman at cygnus.com) * Makefile.in (CLIBS): Reorder to make Lynx ld happy. * (HFILES): New file thread.h. * (OBS): New file thread.c. * configure.in: Host config for Lynx/386. * fork-child.c (fork_inferior): Call init_thread_list(). * infrun.c (resume): Add pid to invocation of target_resume(). * (wait_for_inferior): Pay attention to pid from target_wait(). Multi-threading code now uses this to determine what to do. * inftarg.c (child_wait): Conditionalize based on CHILD_WAIT macro. Use target_pid_to_str() macro throughout when printing pid. * inferior.h (child_resume): Add pid to prototype. * hppab-nat.c hppah-nat.c infptrace.c (child_resume): Pass in pid as argument, instead of using inferior_pid. * procfs.c (procfs_resume): Pass in pid as argument. Ignored for now. Use target_pid_to_str() macro throughout for printing process id. * remote-adapt.c (adapt_resume): Pass in pid as argument. * remote-eb.c (eb_resume): Pass in pid as argument. * remote-es.c (es1800_resume): Pass in pid as argument. * remote-hms.c (hms_resume): Pass in pid as argument. * remote-mips.c (mips_resume): Pass in pid as argument. * remote-mm.c (mm_resume): Pass in pid as argument. * remote-monitor.c (monitor_resume): Pass in pid as argument. * remote-nindy.c (nindy_resume): Pass in pid as argument. * remote-sa.sparc.c (remote_resume): Pass in pid as argument. * remote-sim.c (rem_resume): Pass in pid as argument. * remote-sp64sim.c (simif_resume): Pass in pid as argument. * remote-st.c (st2000_resume): Pass in pid as argument. * remote-udi.c (udi_resume): Pass in pid as argument. * remote-vx.c (vx_resume): Pass in pid as argument. * remote-z8k.c (rem_resume): Pass in pid as argument. * remote.c (remote_resume): Pass in pid as argument. * solib.c (solid_create_inferior_hook): Pass inferior_pid to target_resume(). * target.c (normal_pid_to_str): New routine to print out process ID normally. * target.h (struct target_ops): Add pid to prototype at to_resume(). (target_resume): Add pid argument. * (target_pid_to_str): Default definition for normal type pids. * thread.c, thread.c: New modules for multi thread/process control.
1993-08-02 06:25:36 +00:00
rem_resume (pid, a, b)
int pid;
1993-02-05 18:07:09 +00:00
int a;
enum target_signal siggnal;
{
sim_resume (a, target_signal_to_host (siggnal));
}
/* Define the target subroutine names */
#if 0
1993-02-05 18:07:09 +00:00
struct target_ops sim_ops =
{
"sim", "Remote SIM monitor",
"Use the Z8000 simulator",
1993-02-05 18:07:09 +00:00
sim_open, sim_close,
0, sim_detach, rem_resume, sim_wait, /* attach */
fetch_register, store_register,
sim_prepare_to_store,
1993-02-05 18:07:09 +00:00
sim_xfer_inferior_memory,
sim_files_info,
1993-02-05 18:07:09 +00:00
0, 0, /* Breakpoints */
0, 0, 0, 0, 0, /* Terminal handling */
sim_kill, /* FIXME, kill */
1993-02-05 18:07:09 +00:00
sim_load,
0, /* lookup_symbol */
1993-02-05 18:07:09 +00:00
sim_create_inferior, /* create_inferior */
sim_mourn, /* mourn_inferior FIXME */
0, /* can_run */
0, /* notice_signals */
process_stratum, 0, /* next */
1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1993-02-05 18:07:09 +00:00
0, 0, /* Section pointers */
OPS_MAGIC, /* Always the last thing */
};
/***********************************************************************/
void
_initialize_remote_sim ()
{
add_target (&sim_ops);
1993-02-05 18:07:09 +00:00
}
#endif