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"
/* External data declarations */
extern int stop_soon_quietly; /* for wait_for_inferior */
extern int stop_soon_quietly; /* for wait_for_inferior */
/* Forward data declarations */
extern struct target_ops sim_ops; /* Forward declaration */
void sim_store_register();
void sim_set_oc();
extern struct target_ops sim_ops; /* Forward declaration */
void sim_store_register ();
void sim_set_oc ();
int
sim_write_inferior_memory (memaddr, myaddr, len)
@ -50,93 +49,91 @@ sim_write_inferior_memory (memaddr, myaddr, len)
unsigned char *myaddr;
int len;
{
sim_write(memaddr, myaddr, len);
sim_write (memaddr, myaddr, len);
return 1;
}
static void
store_register(regno)
int regno;
store_register (regno)
int regno;
{
if (regno == -1)
{
for (regno = 0; regno < 16; regno++)
if (regno == -1)
{
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
sim_kill(arg,from_tty)
char *arg;
int from_tty;
sim_kill (arg, from_tty)
char *arg;
int from_tty;
{
}
/*
* Download a file specified in 'args', to the sim.
* Download a file specified in 'args', to the sim.
*/
static void
sim_load(args,fromtty)
char *args;
int fromtty;
sim_load (args, fromtty)
char *args;
int fromtty;
{
bfd *abfd;
bfd *abfd;
asection *s;
inferior_pid = 0;
abfd = bfd_openr(args,"coff-z8k");
inferior_pid = 0;
abfd = bfd_openr (args, "coff-z8k");
if (!abfd)
{
printf_filtered("Unable to open file %s\n", args);
return;
}
if (!abfd)
{
printf_filtered ("Unable to open file %s\n", args);
return;
}
if (bfd_check_format(abfd, bfd_object) ==0)
{
printf_filtered("File is not an object file\n");
return ;
}
if (bfd_check_format (abfd, bfd_object) == 0)
{
printf_filtered ("File is not an object file\n");
return;
}
s = abfd->sections;
while (s != (asection *)NULL)
{
if (s->flags & SEC_LOAD)
while (s != (asection *) NULL)
{
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 ;
if (s->flags & SEC_LOAD)
{
int i;
int delta = 4096;
char *buffer = xmalloc (delta);
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);
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 ("*");
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
@ -150,39 +147,37 @@ sim_create_inferior (execfile, args, env)
int entry_pt;
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)
error ("No exec file specified");
error ("No exec file specified");
entry_pt = (int) bfd_get_start_address (exec_bfd);
sim_kill(NULL,NULL);
sim_clear_breakpoints();
sim_kill (NULL, NULL);
sim_clear_breakpoints ();
init_wait_for_inferior ();
insert_breakpoints ();
proceed(entry_pt, -1, 0);
proceed (entry_pt, -1, 0);
}
static void
sim_open (name, from_tty)
char *name;
int from_tty;
{
if(name == 0)
{
name = "";
}
if (name == 0)
{
name = "";
}
/* Clear any break points */
sim_clear_breakpoints();
sim_clear_breakpoints ();
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. */
@ -191,26 +186,25 @@ static void
sim_close (quitting)
int quitting;
{
sim_clear_breakpoints();
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. */
static void
sim_detach (args,from_tty)
sim_detach (args, from_tty)
char *args;
int from_tty;
{
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. */
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. */
/* Wait until the remote machine stops, then return,
storing status in STATUS just as `wait' would. */
@ -219,11 +213,10 @@ int
sim_wait (status)
WAITTYPE *status;
{
*status = sim_stop_signal();
*status = sim_stop_signal ();
return 0;
}
/* 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
@ -236,21 +229,22 @@ sim_prepare_to_store ()
/* Do nothing, since we can store individual regs */
}
static void
fetch_register(regno)
int regno;
fetch_register (regno)
int regno;
{
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);
}
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.
@ -265,33 +259,34 @@ sim_store_word (addr, word)
}
int
sim_xfer_inferior_memory(memaddr, myaddr, len, write, target)
sim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
CORE_ADDR memaddr;
char *myaddr;
int len;
int write;
struct target_ops *target; /* ignored */
struct target_ops *target; /* ignored */
{
if (write)
{
sim_write(memaddr, myaddr, len);
{
sim_write (memaddr, myaddr, len);
}
else
{
sim_read(memaddr, myaddr, len);
}
return len;
}
else
{
sim_read (memaddr, myaddr, len);
}
return len;
}
void
sim_files_info ()
{
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
@ -305,62 +300,57 @@ sim_before_main_loop ()
push_target (&sim_ops);
}
/* Clear the sims notion of what the break points are */
static void
sim_mourn()
{
sim_clear_breakpoints();
sim_mourn ()
{
sim_clear_breakpoints ();
generic_mourn_inferior ();
}
static void rem_resume(a,b)
int a;
int b;
static void
rem_resume (a, b)
int a;
int b;
{
sim_resume(a,b);
sim_resume (a, b);
}
/* Define the target subroutine names */
struct target_ops sim_ops =
struct target_ops sim_ops =
{
"sim", "Remote SIM monitor",
"Use the Z8000 simulator",
sim_open, sim_close,
0, sim_detach, rem_resume, sim_wait, /* attach */
sim_open, sim_close,
0, sim_detach, rem_resume, sim_wait, /* attach */
fetch_register, store_register,
sim_prepare_to_store,
sim_xfer_inferior_memory,
sim_xfer_inferior_memory,
sim_files_info,
0, 0, /* Breakpoints */
0, 0, /* Breakpoints */
0, 0, 0, 0, 0, /* Terminal handling */
sim_kill, /* FIXME, kill */
sim_load,
sim_load,
0, /* lookup_symbol */
sim_create_inferior, /* create_inferior */
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 */
0,0, /* Section pointers */
0, 0, /* Section pointers */
OPS_MAGIC, /* Always the last thing */
};
/***********************************************************************/
void
_initialize_remote_sim ()
{
extern int sim_z8001_mode;
sim_z8001_mode = z8001_mode;
add_target (&sim_ops);
}

45
gdb/tm-z8k.h
View File

@ -1,5 +1,5 @@
/* 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.
@ -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
but do serve to get the desired values when passed to read_register. */
#define CCR_REGNUM 16 /* Contains processor status */
#define PC_REGNUM 17 /* Contains program counter */
#define CYCLES_REGNUM 18
#define INSTS_REGNUM 19
#define TIME_REGNUM 20
#define FP_REGNUM 21 /* Contains fp, whatever memory model */
#define SP_REGNUM 22 /* Conatins sp, whatever memory model */
#define CCR_REGNUM 16 /* Contains processor status */
#define PC_REGNUM 17 /* Contains program counter */
#define CYCLES_REGNUM 18
#define INSTS_REGNUM 19
#define TIME_REGNUM 20
#define FP_REGNUM 21 /* Contains fp, whatever memory model */
#define SP_REGNUM 22 /* Conatins sp, whatever memory model */
#define PTR_SIZE (BIG ? 4: 2)
#define PTR_MASK (BIG ? 0xff00ffff : 0x0000ffff)
/* Store the address of the place in which to copy the structure the
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
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) \
extract_return_value(TYPE,REGBUF,VALBUF)
bcopy(REGBUF + REGISTER_BYTE(2), VALBUF, TYPE_LENGTH(TYPE));
/* Write into appropriate registers a function return value
of type TYPE, given in virtual format. Assumes floats are passed
in d0/d1. */
of type TYPE, given in virtual format. */
#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
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
chain-pointer.
In the case of the 68000, the frame's nominal address
is the address of a 4-byte word containing the calling frame's address. */
In the case of the Z8000, the frame's nominal 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. */
@ -302,8 +301,6 @@ int z8001_mode;
#define NO_STD_REGS
#define PRINT_REGISTER_HOOK(regno) print_register_hook(regno)
@ -312,4 +309,6 @@ int z8001_mode;
#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.
Copyright (C) 1992 Free Software Foundation, Inc.
Copyright (C) 1992,1993 Free Software Foundation, Inc.
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
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/*
/*
Contributed by Steve Chamberlain
sac@cygnus.com
sac@cygnus.com
*/
#include "defs.h"
#include "frame.h"
#include "obstack.h"
#include "symtab.h"
#include "gdbcmd.h"
#include "gdbtypes.h"
/* Return the saved PC from this frame.
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
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))
@ -51,128 +50,129 @@ FRAME frame;
#define IS_SUB_SP(x) ((x & 0xffff) == 0x020f)
#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 */
static
CORE_ADDR
skip_adjust(pc, size)
CORE_ADDR pc;
int *size;
static CORE_ADDR
skip_adjust (pc, size)
CORE_ADDR pc;
int *size;
{
*size = 0;
if (IS_PUSH_FP(read_memory_short(pc))
&& IS_MOV_SP_FP(read_memory_short(pc+2)))
{
/* This is a function with an explict frame pointer */
pc += 4;
*size += 2; /* remember the frame pointer */
}
if (IS_PUSH_FP (read_memory_short (pc))
&& IS_MOV_SP_FP (read_memory_short (pc + 2)))
{
/* This is a function with an explict frame pointer */
pc += 4;
*size += 2; /* remember the frame pointer */
}
/* remember any stack adjustment */
if (IS_SUB_SP(read_memory_short(pc)))
{
*size += read_memory_short(pc+2);
pc += 4;
}
if (IS_SUB_SP (read_memory_short (pc)))
{
*size += read_memory_short (pc + 2);
pc += 4;
}
return pc;
}
int
examine_frame(pc, regs, sp)
CORE_ADDR pc;
struct frame_saved_regs *regs;
CORE_ADDR sp;
examine_frame (pc, regs, sp)
CORE_ADDR pc;
struct frame_saved_regs *regs;
CORE_ADDR sp;
{
int w = read_memory_short(pc);
int offset = 0;
int regno;
int w = read_memory_short (pc);
int offset = 0;
int regno;
for (regno = 0; regno < NUM_REGS; regno++)
regs->regs[regno] = 0;
for (regno = 0; regno < NUM_REGS; regno++)
regs->regs[regno] = 0;
while (IS_PUSHW(w) || IS_PUSHL(w))
while (IS_PUSHW (w) || IS_PUSHL (w))
{
/* 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) + 1] = offset +2;
regs->regs[(w & 0xf) + 1] = offset + 2;
offset += 4;
}
else {
else
{
regs->regs[w & 0xf] = offset;
offset += 2;
}
pc += 2;
w = read_memory_short(pc);
w = read_memory_short (pc);
}
if (IS_MOVE_FP(w))
{
/* We know the fp */
if (IS_MOVE_FP (w))
{
/* We know the fp */
}
else if (IS_SUB_SP(w))
{
/* Subtracting a value from the sp, so were in a function
which needs stack space for locals, but has no fp. We fake up
the values as if we had an fp */
regs->regs[FP_REGNUM] = sp;
}
else
{
/* This one didn't have an fp, we'll fake it up */
regs->regs[SP_REGNUM] = sp;
}
/* stack pointer contains address of next frame */
/* regs->regs[fp_regnum()] = fp;*/
}
else if (IS_SUB_SP (w))
{
/* Subtracting a value from the sp, so were in a function
which needs stack space for locals, but has no fp. We fake up
the values as if we had an fp */
regs->regs[FP_REGNUM] = sp;
}
else
{
/* This one didn't have an fp, we'll fake it up */
regs->regs[SP_REGNUM] = sp;
}
/* stack pointer contains address of next frame */
/* regs->regs[fp_regnum()] = fp;*/
regs->regs[SP_REGNUM] = sp;
return pc;
}
CORE_ADDR z8k_skip_prologue(start_pc)
CORE_ADDR start_pc;
CORE_ADDR
z8k_skip_prologue (start_pc)
CORE_ADDR start_pc;
{
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 x;
CORE_ADDR
addr_bits_remove (x)
CORE_ADDR x;
{
return x & PTR_MASK;
}
read_memory_pointer(x)
CORE_ADDR x;
read_memory_pointer (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_chain (thisframe)
FRAME thisframe;
{
if (thisframe->prev == 0)
{
/* This is the top of the stack, let's get the sp for real */
}
if (thisframe->prev == 0)
{
/* This is the top of the stack, let's get the sp for real */
}
if (!inside_entry_file ((thisframe)->pc))
{
return read_memory_pointer ((thisframe)->frame);
}
{
return read_memory_pointer ((thisframe)->frame);
}
return 0;
}
init_frame_pc() { abort(); }
init_frame_pc ()
{
abort ();
}
/* Put here the code to store, into a struct frame_saved_regs,
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:
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_saved_regs *frame_saved_regs;
{
CORE_ADDR pc;
int w;
bzero(frame_saved_regs, sizeof(*frame_saved_regs));
pc = get_pc_function_start(frame_info->pc);
CORE_ADDR pc;
int w;
bzero (frame_saved_regs, sizeof (*frame_saved_regs));
pc = get_pc_function_start (frame_info->pc);
/* wander down the instruction stream */
examine_frame(pc, frame_saved_regs, frame_info->frame);
examine_frame (pc, frame_saved_regs, frame_info->frame);
}
extract_return_value(valtype, regbuf, valbuf)
struct type *valtype;
char regbuf[REGISTER_BYTES];
char *valbuf;
{
bcopy(regbuf + REGISTER_BYTE(2), valbuf, TYPE_LENGTH(valtype));
void
z8k_push_dummy_frame ()
{
abort ();
}
void z8k_push_dummy_frame() { abort(); }
int print_insn(memaddr, stream)
CORE_ADDR memaddr;
FILE *stream;
int
print_insn (memaddr, stream)
CORE_ADDR memaddr;
FILE *stream;
{
char temp[20];
read_memory (memaddr, temp, 20);
if (BIG) {
return print_insn_z8001(memaddr, temp, stream);
}
else {
return print_insn_z8002(memaddr, temp, stream);
}
if (BIG)
{
return print_insn_z8001 (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
is not the address of a valid instruction, the address of the next
instruction beyond ADDR otherwise. *PWORD1 receives the first word
of the instruction.*/
CORE_ADDR
NEXT_PROLOGUE_INSN(addr, lim, pword1)
CORE_ADDR addr;
CORE_ADDR lim;
short *pword1;
NEXT_PROLOGUE_INSN (addr, lim, pword1)
CORE_ADDR addr;
CORE_ADDR lim;
short *pword1;
{
if (addr < lim+8)
{
read_memory (addr, pword1, sizeof(*pword1));
SWAP_TARGET_AND_HOST (pword1, sizeof (short));
return addr + 2;
}
if (addr < lim + 8)
{
read_memory (addr, pword1, sizeof (*pword1));
SWAP_TARGET_AND_HOST (pword1, sizeof (short));
return addr + 2;
}
return 0;
}
/* Put here the code to store, into a struct frame_saved_regs,
the addresses of the saved registers of frame described by FRAME_INFO.
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 adr;
int i;
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;
for (i = 0; i < 8; i++)
{
int word = read_memory_short(pc);
pc += 2 ;
if (IS_PUSHL(word)) {
fsrp->regs[word & 0xf] = adr;
fsrp->regs[(word & 0xf) + 1] = adr - 2;
adr -= 4;
}
else if (IS_PUSHW(word)) {
fsrp->regs[word & 0xf] = adr;
adr -= 2;
}
else
break;
}
{
adr = fip->frame - locals;
for (i = 0; i < 8; i++)
{
int word = read_memory_short (pc);
pc += 2;
if (IS_PUSHL (word))
{
fsrp->regs[word & 0xf] = adr;
fsrp->regs[(word & 0xf) + 1] = adr - 2;
adr -= 4;
}
else if (IS_PUSHW (word))
{
fsrp->regs[word & 0xf] = adr;
adr -= 2;
}
else
break;
}
}
}
fsrp->regs[PC_REGNUM] = fip->frame + 4;
fsrp->regs[FP_REGNUM] = fip->frame;
}
void
addr_bits_set() { abort(); }
addr_bits_set ()
{
abort ();
}
int
saved_pc_after_call()
{
return addr_bits_remove(read_memory_integer(read_register(SP_REGNUM), PTR_SIZE));
saved_pc_after_call ()
{
return addr_bits_remove (read_memory_integer (read_register (SP_REGNUM), PTR_SIZE));
}
void
print_register_hook(regno)
int regno;
print_register_hook (regno)
int regno;
{
if ((regno & 1)==0 && regno < 16)
{
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 & 1) == 0 && regno < 16)
{
unsigned short l[2];
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));
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)
{
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
register_convert_to_raw(regnum, to, from)
char *to;
char *from;
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];
to[0] = from[0];
to[1] = from[1];
to[2] = from[2];
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);
}