OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Some spit and polish

This commit is contained in:
Steve Chamberlain 1993-02-05 18:07:09 +00:00
parent 3fa4d3e31e
commit e4ebb8e5e6
3 changed files with 413 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

268
gdb/remote-z8k.c
View File

@ -35,14 +35,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "../sim/z8k/sim.h" #include "../sim/z8k/sim.h"
/* External data declarations */ /* External data declarations */
extern int stop_soon_quietly; /* for wait_for_inferior */ extern int stop_soon_quietly; /* for wait_for_inferior */
/* Forward data declarations */ /* Forward data declarations */
extern struct target_ops sim_ops; /* Forward declaration */ extern struct target_ops sim_ops; /* Forward declaration */
void sim_store_register();
void sim_set_oc();
void sim_store_register ();
void sim_set_oc ();
int int
sim_write_inferior_memory (memaddr, myaddr, len) sim_write_inferior_memory (memaddr, myaddr, len)
@ -50,93 +49,91 @@ sim_write_inferior_memory (memaddr, myaddr, len)
unsigned char *myaddr; unsigned char *myaddr;
int len; int len;
{ {
sim_write(memaddr, myaddr, len); sim_write (memaddr, myaddr, len);
return 1; return 1;
} }
static void static void
store_register(regno) store_register (regno)
int regno; int regno;
{ {
if (regno == -1) if (regno == -1)
{
for (regno = 0; regno < 16; regno++)
{ {
store_register(regno); for (regno = 0; regno < 16; regno++)
{
store_register (regno);
}
}
else
{
sim_store_register (regno, read_register (regno));
} }
}
else
{
sim_store_register(regno,read_register(regno));
}
} }
void void
sim_kill(arg,from_tty) sim_kill (arg, from_tty)
char *arg; char *arg;
int from_tty; int from_tty;
{ {
} }
/* /*
* Download a file specified in 'args', to the sim. * Download a file specified in 'args', to the sim.
*/ */
static void static void
sim_load(args,fromtty) sim_load (args, fromtty)
char *args; char *args;
int fromtty; int fromtty;
{ {
bfd *abfd; bfd *abfd;
asection *s; asection *s;
inferior_pid = 0; inferior_pid = 0;
abfd = bfd_openr(args,"coff-z8k"); abfd = bfd_openr (args, "coff-z8k");
if (!abfd) if (!abfd)
{ {
printf_filtered("Unable to open file %s\n", args); printf_filtered ("Unable to open file %s\n", args);
return; return;
} }
if (bfd_check_format(abfd, bfd_object) ==0) if (bfd_check_format (abfd, bfd_object) == 0)
{ {
printf_filtered("File is not an object file\n"); printf_filtered ("File is not an object file\n");
return ; return;
} }
s = abfd->sections; s = abfd->sections;
while (s != (asection *)NULL) while (s != (asection *) NULL)
{
if (s->flags & SEC_LOAD)
{ {
int i; if (s->flags & SEC_LOAD)
int delta = 4096; {
char *buffer = xmalloc(delta); int i;
printf_filtered("%s\t: 0x%4x .. 0x%4x ", int delta = 4096;
s->name, s->vma, s->vma + s->_raw_size); char *buffer = xmalloc (delta);
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); printf_filtered ("%s\t: 0x%4x .. 0x%4x ",
sim_write_inferior_memory(s->vma + i, buffer, sub_delta); s->name, s->vma, s->vma + s->_raw_size);
printf_filtered("*"); for (i = 0; i < s->_raw_size; i += delta)
fflush(stdout); {
} int sub_delta = delta;
printf_filtered( "\n");
free(buffer); 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 ("*");
fflush (stdout);
}
printf_filtered ("\n");
free (buffer);
}
s = s->next;
} }
s = s->next;
}
sim_set_pc(abfd->start_address); sim_set_pc (abfd->start_address);
} }
/* This is called not only when we first attach, but also when the /* This is called not only when we first attach, but also when the
@ -150,39 +147,37 @@ sim_create_inferior (execfile, args, env)
int entry_pt; int entry_pt;
if (args && *args) if (args && *args)
error ("Can't pass arguments to remote sim process."); error ("Can't pass arguments to remote sim process.");
if (execfile == 0 || exec_bfd == 0) if (execfile == 0 || exec_bfd == 0)
error ("No exec file specified"); error ("No exec file specified");
entry_pt = (int) bfd_get_start_address (exec_bfd); entry_pt = (int) bfd_get_start_address (exec_bfd);
sim_kill(NULL,NULL); sim_kill (NULL, NULL);
sim_clear_breakpoints(); sim_clear_breakpoints ();
init_wait_for_inferior (); init_wait_for_inferior ();
insert_breakpoints (); insert_breakpoints ();
proceed(entry_pt, -1, 0); proceed (entry_pt, -1, 0);
} }
static void static void
sim_open (name, from_tty) sim_open (name, from_tty)
char *name; char *name;
int from_tty; int from_tty;
{ {
if(name == 0) if (name == 0)
{ {
name = ""; name = "";
} }
/* Clear any break points */ /* Clear any break points */
sim_clear_breakpoints(); sim_clear_breakpoints ();
push_target (&sim_ops); push_target (&sim_ops);
target_fetch_registers(-1); target_fetch_registers (-1);
printf_filtered("Connected to the Z8000 Simulator.\n"); printf_filtered ("Connected to the Z8000 Simulator.\n");
} }
/* Close out all files and local state before this target loses control. */ /* Close out all files and local state before this target loses control. */
@ -191,26 +186,25 @@ static void
sim_close (quitting) sim_close (quitting)
int quitting; int quitting;
{ {
sim_clear_breakpoints(); sim_clear_breakpoints ();
} }
/* Terminate the open connection to the remote debugger. /* Terminate the open connection to the remote debugger.
Use this when you want to detach and do something else Use this when you want to detach and do something else
with your gdb. */ with your gdb. */
static void static void
sim_detach (args,from_tty) sim_detach (args, from_tty)
char *args; char *args;
int from_tty; int from_tty;
{ {
sim_clear_breakpoints(); sim_clear_breakpoints ();
pop_target(); /* calls sim_close to do the real work */
if (from_tty)
printf_filtered ("Ending remote %s debugging\n", target_shortname);
}
/* Tell the remote machine to resume. */
pop_target (); /* calls sim_close to do the real work */
if (from_tty)
printf_filtered ("Ending remote %s debugging\n", target_shortname);
}
/* Tell the remote machine to resume. */
/* Wait until the remote machine stops, then return, /* Wait until the remote machine stops, then return,
storing status in STATUS just as `wait' would. */ storing status in STATUS just as `wait' would. */
@ -219,11 +213,10 @@ int
sim_wait (status) sim_wait (status)
WAITTYPE *status; WAITTYPE *status;
{ {
*status = sim_stop_signal(); *status = sim_stop_signal ();
return 0; return 0;
} }
/* Get ready to modify the registers array. On machines which store /* Get ready to modify the registers array. On machines which store
individual registers, this doesn't need to do anything. On machines individual registers, this doesn't need to do anything. On machines
which store all the registers in one fell swoop, this makes sure which store all the registers in one fell swoop, this makes sure
@ -236,21 +229,22 @@ sim_prepare_to_store ()
/* Do nothing, since we can store individual regs */ /* Do nothing, since we can store individual regs */
} }
static void static void
fetch_register(regno) fetch_register (regno)
int regno; int regno;
{ {
if (regno == -1) if (regno == -1)
{ {
for (regno = 0; regno < 16; regno++) for (regno = 0; regno < 16; regno++)
fetch_register(regno); fetch_register (regno);
} }
else { else
char buf[MAX_REGISTER_RAW_SIZE]; {
sim_fetch_register(regno, buf); char buf[MAX_REGISTER_RAW_SIZE];
supply_register(regno, buf);
} sim_fetch_register (regno, buf);
supply_register (regno, buf);
}
} }
/* Write a word WORD into remote address ADDR. /* Write a word WORD into remote address ADDR.
@ -265,33 +259,34 @@ sim_store_word (addr, word)
} }
int int
sim_xfer_inferior_memory(memaddr, myaddr, len, write, target) sim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
CORE_ADDR memaddr; CORE_ADDR memaddr;
char *myaddr; char *myaddr;
int len; int len;
int write; int write;
struct target_ops *target; /* ignored */ struct target_ops *target; /* ignored */
{ {
if (write) if (write)
{ {
sim_write(memaddr, myaddr, len); sim_write (memaddr, myaddr, len);
} }
else else
{ {
sim_read(memaddr, myaddr, len); sim_read (memaddr, myaddr, len);
} }
return len; return len;
} }
void void
sim_files_info () sim_files_info ()
{ {
char *file = "nothing"; char *file = "nothing";
if (exec_bfd)
file = bfd_get_filename(exec_bfd);
printf_filtered("\tAttached to %s running on the z8k simulator\n",file); if (exec_bfd)
file = bfd_get_filename (exec_bfd);
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 /* This routine is run as a hook, just before the main command loop is
@ -305,62 +300,57 @@ sim_before_main_loop ()
push_target (&sim_ops); push_target (&sim_ops);
} }
/* Clear the sims notion of what the break points are */ /* Clear the sims notion of what the break points are */
static void static void
sim_mourn() sim_mourn ()
{ {
sim_clear_breakpoints(); sim_clear_breakpoints ();
generic_mourn_inferior (); generic_mourn_inferior ();
} }
static void rem_resume(a,b) static void
int a; rem_resume (a, b)
int b; int a;
int b;
{ {
sim_resume(a,b); sim_resume (a, b);
} }
/* Define the target subroutine names */ /* Define the target subroutine names */
struct target_ops sim_ops = struct target_ops sim_ops =
{ {
"sim", "Remote SIM monitor", "sim", "Remote SIM monitor",
"Use the Z8000 simulator", "Use the Z8000 simulator",
sim_open, sim_close, sim_open, sim_close,
0, sim_detach, rem_resume, sim_wait, /* attach */ 0, sim_detach, rem_resume, sim_wait, /* attach */
fetch_register, store_register, fetch_register, store_register,
sim_prepare_to_store, sim_prepare_to_store,
sim_xfer_inferior_memory, sim_xfer_inferior_memory,
sim_files_info, sim_files_info,
0, 0, /* Breakpoints */ 0, 0, /* Breakpoints */
0, 0, 0, 0, 0, /* Terminal handling */ 0, 0, 0, 0, 0, /* Terminal handling */
sim_kill, /* FIXME, kill */ sim_kill, /* FIXME, kill */
sim_load, sim_load,
0, /* lookup_symbol */ 0, /* lookup_symbol */
sim_create_inferior, /* create_inferior */ sim_create_inferior, /* create_inferior */
sim_mourn, /* mourn_inferior FIXME */ sim_mourn, /* mourn_inferior FIXME */
0, /* can_run */ 0, /* can_run */
0, /* notice_signals */ 0, /* notice_signals */
process_stratum, 0, /* next */ process_stratum, 0, /* next */
1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */ 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
0,0, /* Section pointers */ 0, 0, /* Section pointers */
OPS_MAGIC, /* Always the last thing */ OPS_MAGIC, /* Always the last thing */
}; };
/***********************************************************************/ /***********************************************************************/
void void
_initialize_remote_sim () _initialize_remote_sim ()
{ {
extern int sim_z8001_mode; extern int sim_z8001_mode;
sim_z8001_mode = z8001_mode; sim_z8001_mode = z8001_mode;
add_target (&sim_ops); add_target (&sim_ops);
} }

45
gdb/tm-z8k.h
View File

@ -1,5 +1,5 @@
/* Parameters for execution on a z8000 series machine. /* Parameters for execution on a z8000 series machine.
Copyright 1992 Free Software Foundation, Inc. Copyright 1992,1993 Free Software Foundation, Inc.
This file is part of GDB. This file is part of GDB.
@ -148,26 +148,23 @@ extern CORE_ADDR mz8k_skip_prologue PARAMS ((CORE_ADDR ip));
to be actual register numbers as far as the user is concerned to be actual register numbers as far as the user is concerned
but do serve to get the desired values when passed to read_register. */ but do serve to get the desired values when passed to read_register. */
#define CCR_REGNUM 16 /* Contains processor status */ #define CCR_REGNUM 16 /* Contains processor status */
#define PC_REGNUM 17 /* Contains program counter */ #define PC_REGNUM 17 /* Contains program counter */
#define CYCLES_REGNUM 18 #define CYCLES_REGNUM 18
#define INSTS_REGNUM 19 #define INSTS_REGNUM 19
#define TIME_REGNUM 20 #define TIME_REGNUM 20
#define FP_REGNUM 21 /* Contains fp, whatever memory model */ #define FP_REGNUM 21 /* Contains fp, whatever memory model */
#define SP_REGNUM 22 /* Conatins sp, whatever memory model */ #define SP_REGNUM 22 /* Conatins sp, whatever memory model */
#define PTR_SIZE (BIG ? 4: 2) #define PTR_SIZE (BIG ? 4: 2)
#define PTR_MASK (BIG ? 0xff00ffff : 0x0000ffff) #define PTR_MASK (BIG ? 0xff00ffff : 0x0000ffff)
/* Store the address of the place in which to copy the structure the /* Store the address of the place in which to copy the structure the
subroutine will return. This is called from call_function. */ subroutine will return. This is called from call_function. */
#define STORE_STRUCT_RETURN(ADDR, SP) store_struct_return(ADDR,SP) #define STORE_STRUCT_RETURN(ADDR, SP) abort();
/* Extract from an array REGBUF containing the (raw) register state /* Extract from an array REGBUF containing the (raw) register state
a function return value of type TYPE, and copy that, in virtual format, a function return value of type TYPE, and copy that, in virtual format,
@ -176,13 +173,12 @@ extern CORE_ADDR mz8k_skip_prologue PARAMS ((CORE_ADDR ip));
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
extract_return_value(TYPE,REGBUF,VALBUF) bcopy(REGBUF + REGISTER_BYTE(2), VALBUF, TYPE_LENGTH(TYPE));
/* Write into appropriate registers a function return value /* Write into appropriate registers a function return value
of type TYPE, given in virtual format. Assumes floats are passed of type TYPE, given in virtual format. */
in d0/d1. */
#define STORE_RETURN_VALUE(TYPE,VALBUF) store_return_value(TYPE,VALBUF); #define STORE_RETURN_VALUE(TYPE,VALBUF) abort();
/* Extract from an array REGBUF containing the (raw) register state /* Extract from an array REGBUF containing the (raw) register state
the address in which a function should return its structure value, the address in which a function should return its structure value,
@ -195,10 +191,13 @@ extern CORE_ADDR mz8k_skip_prologue PARAMS ((CORE_ADDR ip));
/* FRAME_CHAIN takes a frame's nominal address and produces the frame's /* FRAME_CHAIN takes a frame's nominal address and produces the frame's
chain-pointer. chain-pointer.
In the case of the 68000, the frame's nominal address In the case of the Z8000, the frame's nominal address
is the address of a 4-byte word containing the calling frame's address. */ is the address of a ptr sized byte word containing the calling
frame's address. */
#define FRAME_CHAIN(thisframe) frame_chain(thisframe);
#define FRAME_CHAIN(thisframe) frame_chain(thisframe)
/* Define other aspects of the stack frame. */ /* Define other aspects of the stack frame. */
@ -302,8 +301,6 @@ int z8001_mode;
#define NO_STD_REGS #define NO_STD_REGS
#define PRINT_REGISTER_HOOK(regno) print_register_hook(regno) #define PRINT_REGISTER_HOOK(regno) print_register_hook(regno)
@ -312,4 +309,6 @@ int z8001_mode;
#define NAMES_HAVE_UNDERSCORE #define NAMES_HAVE_UNDERSCORE
#define ADDITIONAL_OPTIONS {"z8001",no_argument,&z8001_mode, 1},
#define INIT_EXTRA_SYMTAB_INFO \
z8k_set_pointer_size(objfile->obfd->arch_info->bits_per_address);

461
gdb/z8k-tdep.c
View File

@ -1,5 +1,5 @@
/* Target-machine dependent code for Zilog Z8000, for GDB. /* Target-machine dependent code for Zilog Z8000, for GDB.
Copyright (C) 1992 Free Software Foundation, Inc. Copyright (C) 1992,1993 Free Software Foundation, Inc.
This file is part of GDB. This file is part of GDB.
@ -17,19 +17,18 @@ You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* /*
Contributed by Steve Chamberlain Contributed by Steve Chamberlain
sac@cygnus.com sac@cygnus.com
*/ */
#include "defs.h" #include "defs.h"
#include "frame.h" #include "frame.h"
#include "obstack.h" #include "obstack.h"
#include "symtab.h" #include "symtab.h"
#include "gdbcmd.h"
#include "gdbtypes.h" #include "gdbtypes.h"
/* Return the saved PC from this frame. /* Return the saved PC from this frame.
If the frame has a memory copy of SRP_REGNUM, use that. If not, If the frame has a memory copy of SRP_REGNUM, use that. If not,
@ -37,9 +36,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
CORE_ADDR CORE_ADDR
frame_saved_pc (frame) frame_saved_pc (frame)
FRAME frame; FRAME frame;
{ {
return ( read_memory_pointer(frame->frame+(BIG ? 4 : 2))); return (read_memory_pointer (frame->frame + (BIG ? 4 : 2)));
} }
#define IS_PUSHL(x) (BIG ? ((x & 0xfff0) == 0x91e0):((x & 0xfff0) == 0x91F0)) #define IS_PUSHL(x) (BIG ? ((x & 0xfff0) == 0x91e0):((x & 0xfff0) == 0x91F0))
@ -51,128 +50,129 @@ FRAME frame;
#define IS_SUB_SP(x) ((x & 0xffff) == 0x020f) #define IS_SUB_SP(x) ((x & 0xffff) == 0x020f)
#define IS_PUSH_FP(x) (BIG ? (x == 0x93ea) : (x == 0x93fa)) #define IS_PUSH_FP(x) (BIG ? (x == 0x93ea) : (x == 0x93fa))
/* work out how much local space is on the stack and
/* work out how much local space is on the stack and
return the pc pointing to the first push */ return the pc pointing to the first push */
static static CORE_ADDR
CORE_ADDR skip_adjust (pc, size)
skip_adjust(pc, size) CORE_ADDR pc;
CORE_ADDR pc; int *size;
int *size;
{ {
*size = 0; *size = 0;
if (IS_PUSH_FP(read_memory_short(pc)) if (IS_PUSH_FP (read_memory_short (pc))
&& IS_MOV_SP_FP(read_memory_short(pc+2))) && IS_MOV_SP_FP (read_memory_short (pc + 2)))
{ {
/* This is a function with an explict frame pointer */ /* This is a function with an explict frame pointer */
pc += 4; pc += 4;
*size += 2; /* remember the frame pointer */ *size += 2; /* remember the frame pointer */
} }
/* remember any stack adjustment */ /* remember any stack adjustment */
if (IS_SUB_SP(read_memory_short(pc))) if (IS_SUB_SP (read_memory_short (pc)))
{ {
*size += read_memory_short(pc+2); *size += read_memory_short (pc + 2);
pc += 4; pc += 4;
} }
return pc; return pc;
} }
int int
examine_frame(pc, regs, sp) examine_frame (pc, regs, sp)
CORE_ADDR pc; CORE_ADDR pc;
struct frame_saved_regs *regs; struct frame_saved_regs *regs;
CORE_ADDR sp; CORE_ADDR sp;
{ {
int w = read_memory_short(pc); int w = read_memory_short (pc);
int offset = 0; int offset = 0;
int regno; int regno;
for (regno = 0; regno < NUM_REGS; regno++)
regs->regs[regno] = 0;
while (IS_PUSHW (w) || IS_PUSHL (w))
for (regno = 0; regno < NUM_REGS; regno++)
regs->regs[regno] = 0;
while (IS_PUSHW(w) || IS_PUSHL(w))
{ {
/* work out which register is being pushed to where */ /* work out which register is being pushed to where */
if (IS_PUSHL(w)) if (IS_PUSHL (w))
{ {
regs->regs[w & 0xf] = offset; regs->regs[w & 0xf] = offset;
regs->regs[(w & 0xf) + 1] = offset +2; regs->regs[(w & 0xf) + 1] = offset + 2;
offset += 4; offset += 4;
} }
else { else
{
regs->regs[w & 0xf] = offset; regs->regs[w & 0xf] = offset;
offset += 2; offset += 2;
} }
pc += 2; pc += 2;
w = read_memory_short(pc); w = read_memory_short (pc);
} }
if (IS_MOVE_FP(w)) if (IS_MOVE_FP (w))
{ {
/* We know the fp */ /* We know the fp */
} }
else if (IS_SUB_SP(w)) else if (IS_SUB_SP (w))
{ {
/* Subtracting a value from the sp, so were in a function /* Subtracting a value from the sp, so were in a function
which needs stack space for locals, but has no fp. We fake up which needs stack space for locals, but has no fp. We fake up
the values as if we had an fp */ the values as if we had an fp */
regs->regs[FP_REGNUM] = sp; regs->regs[FP_REGNUM] = sp;
} }
else else
{ {
/* This one didn't have an fp, we'll fake it up */ /* This one didn't have an fp, we'll fake it up */
regs->regs[SP_REGNUM] = sp; regs->regs[SP_REGNUM] = sp;
} }
/* stack pointer contains address of next frame */ /* stack pointer contains address of next frame */
/* regs->regs[fp_regnum()] = fp;*/ /* regs->regs[fp_regnum()] = fp;*/
regs->regs[SP_REGNUM] = sp; regs->regs[SP_REGNUM] = sp;
return pc; return pc;
} }
CORE_ADDR z8k_skip_prologue(start_pc) CORE_ADDR
CORE_ADDR start_pc; z8k_skip_prologue (start_pc)
CORE_ADDR start_pc;
{ {
struct frame_saved_regs dummy; struct frame_saved_regs dummy;
return examine_frame(start_pc, &dummy, 0);
return examine_frame (start_pc, &dummy, 0);
} }
CORE_ADDR addr_bits_remove(x) CORE_ADDR
CORE_ADDR x; addr_bits_remove (x)
CORE_ADDR x;
{ {
return x & PTR_MASK; return x & PTR_MASK;
} }
read_memory_pointer(x) read_memory_pointer (x)
CORE_ADDR x; CORE_ADDR x;
{ {
return read_memory_integer(ADDR_BITS_REMOVE(x), BIG ? 4 : 2); return read_memory_integer (ADDR_BITS_REMOVE (x), BIG ? 4 : 2);
} }
FRAME_ADDR FRAME_ADDR
frame_chain (thisframe) frame_chain (thisframe)
FRAME thisframe; FRAME thisframe;
{ {
if (thisframe->prev == 0) if (thisframe->prev == 0)
{ {
/* This is the top of the stack, let's get the sp for real */ /* This is the top of the stack, let's get the sp for real */
} }
if (!inside_entry_file ((thisframe)->pc)) if (!inside_entry_file ((thisframe)->pc))
{ {
return read_memory_pointer ((thisframe)->frame); return read_memory_pointer ((thisframe)->frame);
} }
return 0; return 0;
} }
init_frame_pc() { abort(); } init_frame_pc ()
{
abort ();
}
/* Put here the code to store, into a struct frame_saved_regs, /* Put here the code to store, into a struct frame_saved_regs,
the addresses of the saved registers of frame described by FRAME_INFO. the addresses of the saved registers of frame described by FRAME_INFO.
@ -180,79 +180,70 @@ init_frame_pc() { abort(); }
ways in the stack frame. sp is even more special: ways in the stack frame. sp is even more special:
the address we return for it IS the sp for the next frame. */ the address we return for it IS the sp for the next frame. */
void get_frame_saved_regs(frame_info, frame_saved_regs) void
get_frame_saved_regs (frame_info, frame_saved_regs)
struct frame_info *frame_info; struct frame_info *frame_info;
struct frame_saved_regs *frame_saved_regs; struct frame_saved_regs *frame_saved_regs;
{ {
CORE_ADDR pc; CORE_ADDR pc;
int w; int w;
bzero(frame_saved_regs, sizeof(*frame_saved_regs));
pc = get_pc_function_start(frame_info->pc); bzero (frame_saved_regs, sizeof (*frame_saved_regs));
pc = get_pc_function_start (frame_info->pc);
/* wander down the instruction stream */ /* wander down the instruction stream */
examine_frame(pc, frame_saved_regs, frame_info->frame); examine_frame (pc, frame_saved_regs, frame_info->frame);
} }
void
extract_return_value(valtype, regbuf, valbuf) z8k_push_dummy_frame ()
struct type *valtype; {
char regbuf[REGISTER_BYTES]; abort ();
char *valbuf;
{
bcopy(regbuf + REGISTER_BYTE(2), valbuf, TYPE_LENGTH(valtype));
} }
void z8k_push_dummy_frame() { abort(); }
int print_insn(memaddr, stream) int
CORE_ADDR memaddr; print_insn (memaddr, stream)
FILE *stream; CORE_ADDR memaddr;
FILE *stream;
{ {
char temp[20]; char temp[20];
read_memory (memaddr, temp, 20); read_memory (memaddr, temp, 20);
if (BIG) { if (BIG)
return print_insn_z8001(memaddr, temp, stream); {
} return print_insn_z8001 (memaddr, temp, stream);
else { }
return print_insn_z8002(memaddr, temp, stream); else
} {
return print_insn_z8002 (memaddr, temp, stream);
}
} }
void
store_return_value()
{
abort();
}
void
store_struct_return() { abort(); }
/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
is not the address of a valid instruction, the address of the next is not the address of a valid instruction, the address of the next
instruction beyond ADDR otherwise. *PWORD1 receives the first word instruction beyond ADDR otherwise. *PWORD1 receives the first word
of the instruction.*/ of the instruction.*/
CORE_ADDR CORE_ADDR
NEXT_PROLOGUE_INSN(addr, lim, pword1) NEXT_PROLOGUE_INSN (addr, lim, pword1)
CORE_ADDR addr; CORE_ADDR addr;
CORE_ADDR lim; CORE_ADDR lim;
short *pword1; short *pword1;
{ {
if (addr < lim+8) if (addr < lim + 8)
{ {
read_memory (addr, pword1, sizeof(*pword1)); read_memory (addr, pword1, sizeof (*pword1));
SWAP_TARGET_AND_HOST (pword1, sizeof (short)); SWAP_TARGET_AND_HOST (pword1, sizeof (short));
return addr + 2;
} return addr + 2;
}
return 0; return 0;
} }
/* Put here the code to store, into a struct frame_saved_regs, /* Put here the code to store, into a struct frame_saved_regs,
the addresses of the saved registers of frame described by FRAME_INFO. the addresses of the saved registers of frame described by FRAME_INFO.
This includes special registers such as pc and fp saved in special This includes special registers such as pc and fp saved in special
@ -271,108 +262,180 @@ frame_find_saved_regs (fip, fsrp)
CORE_ADDR pc; CORE_ADDR pc;
CORE_ADDR adr; CORE_ADDR adr;
int i; int i;
memset (fsrp, 0, sizeof *fsrp); memset (fsrp, 0, sizeof *fsrp);
pc = skip_adjust(get_pc_function_start (fip->pc), &locals); pc = skip_adjust (get_pc_function_start (fip->pc), &locals);
{ {
adr = fip->frame - locals; adr = fip->frame - locals;
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
{ {
int word = read_memory_short(pc); int word = read_memory_short (pc);
pc += 2 ;
if (IS_PUSHL(word)) { pc += 2;
fsrp->regs[word & 0xf] = adr; if (IS_PUSHL (word))
fsrp->regs[(word & 0xf) + 1] = adr - 2; {
adr -= 4; fsrp->regs[word & 0xf] = adr;
} fsrp->regs[(word & 0xf) + 1] = adr - 2;
else if (IS_PUSHW(word)) { adr -= 4;
fsrp->regs[word & 0xf] = adr; }
adr -= 2; else if (IS_PUSHW (word))
} {
else fsrp->regs[word & 0xf] = adr;
break; adr -= 2;
} }
else
break;
}
}
}
fsrp->regs[PC_REGNUM] = fip->frame + 4; fsrp->regs[PC_REGNUM] = fip->frame + 4;
fsrp->regs[FP_REGNUM] = fip->frame; fsrp->regs[FP_REGNUM] = fip->frame;
} }
void void
addr_bits_set() { abort(); } addr_bits_set ()
{
abort ();
}
int int
saved_pc_after_call() saved_pc_after_call ()
{ {
return addr_bits_remove(read_memory_integer(read_register(SP_REGNUM), PTR_SIZE)); return addr_bits_remove (read_memory_integer (read_register (SP_REGNUM), PTR_SIZE));
} }
void void
print_register_hook(regno) print_register_hook (regno)
int regno; int regno;
{ {
if ((regno & 1)==0 && regno < 16) if ((regno & 1) == 0 && regno < 16)
{ {
unsigned short l[2]; unsigned short l[2];
read_relative_register_raw_bytes(regno, (char *)(l+0));
read_relative_register_raw_bytes(regno+1, (char *)(l+1));
printf("\t");
printf("%04x%04x", l[0],l[1]);
}
if ((regno & 3)== 0 && regno < 16) read_relative_register_raw_bytes (regno, (char *) (l + 0));
{ read_relative_register_raw_bytes (regno + 1, (char *) (l + 1));
unsigned short l[4]; printf ("\t");
read_relative_register_raw_bytes(regno, l+0); printf ("%04x%04x", l[0], l[1]);
read_relative_register_raw_bytes(regno+1, l+1);
read_relative_register_raw_bytes(regno+2, l+2);
read_relative_register_raw_bytes(regno+3, l+3);
printf("\t");
printf("%04x%04x%04x%04x", l[0],l[1],l[2],l[3]);
}
if (regno == 15)
{
unsigned short rval;
int i;
read_relative_register_raw_bytes(regno, (char *)(&rval));
printf("\n");
for (i = 0; i < 10; i+=2) {
printf("(sp+%d=%04x)",i, read_memory_short(rval+i));
} }
}
}
if ((regno & 3) == 0 && regno < 16)
{
unsigned short l[4];
read_relative_register_raw_bytes (regno, l + 0);
read_relative_register_raw_bytes (regno + 1, l + 1);
read_relative_register_raw_bytes (regno + 2, l + 2);
read_relative_register_raw_bytes (regno + 3, l + 3);
printf ("\t");
printf ("%04x%04x%04x%04x", l[0], l[1], l[2], l[3]);
}
if (regno == 15)
{
unsigned short rval;
int i;
read_relative_register_raw_bytes (regno, (char *) (&rval));
printf ("\n");
for (i = 0; i < 10; i += 2)
{
printf ("(sp+%d=%04x)", i, read_memory_short (rval + i));
}
}
void
register_convert_to_virtual(regnum, from, to)
unsigned char *from;
unsigned char *to;
{
to[0] = from[0];
to[1] = from[1];
to[2] = from[2];
to[3] = from[3];
} }
void void
register_convert_to_raw(regnum, to, from) register_convert_to_virtual (regnum, from, to)
char *to; unsigned char *from;
char *from; unsigned char *to;
{ {
to[0] = from[0]; to[0] = from[0];
to[1] = from[1]; to[1] = from[1];
to[2] = from[2]; to[2] = from[2];
to[3] = from[3]; to[3] = from[3];
} }
void
register_convert_to_raw (regnum, to, from)
char *to;
char *from;
{
to[0] = from[0];
to[1] = from[1];
to[2] = from[2];
to[3] = from[3];
}
void
z8k_pop_frame ()
{
}
void z8k_pop_frame() { } struct cmd_list_element *setmemorylist;
void
z8k_set_pointer_size (newsize)
int newsize;
{
static int oldsize = 0;
if (oldsize != newsize)
{
printf ("pointer size set to %d bits\n", newsize);
oldsize = newsize;
if (newsize == 32)
{
BIG = 1;
}
else
{
BIG = 0;
}
_initialize_gdbtypes ();
}
}
static void
segmented_command (args, from_tty)
char *args;
int from_tty;
{
z8k_set_pointer_size (16);
}
static void
unsegmented_command (args, from_tty)
char *args;
int from_tty;
{
z8k_set_pointer_size (16);
}
static void
set_memory (args, from_tty)
char *args;
int from_tty;
{
printf ("\"set memory\" must be followed by the name of a memory subcommand.\n");
help_list (setmemorylist, "set memory ", -1, stdout);
}
_initialize_z8ktdep ()
{
add_prefix_cmd ("memory", no_class, set_memory,
"set the memory model", &setmemorylist, "set memory ", 0,
&setlist);
add_cmd ("segmented", class_support, segmented_command,
"Set segmented memory model.", &setmemorylist);
add_cmd ("unsegmented", class_support, unsegmented_command,
"Set unsegmented memory model.", &setmemorylist);
}