mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2025-01-20 15:03:31 +08:00
Checkpoint for Stu
This commit is contained in:
Steve Chamberlain
parent
9d19b85b6a
commit
195e46ea0b
@ -115,6 +115,7 @@ c1-*-*) gdb_target=convex ;;
|
|||||||
c2-*-*) gdb_target=convex ;;
|
c2-*-*) gdb_target=convex ;;
|
||||||
|
|
||||||
h8300-*-*) gdb_target=h8300hms ;;
|
h8300-*-*) gdb_target=h8300hms ;;
|
||||||
|
h8500-*-*) gdb_target=h8500hms ;;
|
||||||
|
|
||||||
hppa*-*-bsd) gdb_target=hppabsd ;;
|
hppa*-*-bsd) gdb_target=hppabsd ;;
|
||||||
hppa*-*-hpux) gdb_target=hppahpux ;;
|
hppa*-*-hpux) gdb_target=hppahpux ;;
|
||||||
|
|||||||
802
gdb/h8500-tdep.c
Normal file
802
gdb/h8500-tdep.c
Normal file
@ -0,0 +1,802 @@
|
|||||||
|
/* Target-machine dependent code for Hitachi H8/500, for GDB.
|
||||||
|
Copyright (C) 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||||
|
|
||||||
|
/*
|
||||||
|
Contributed by Steve Chamberlain
|
||||||
|
sac@cygnus.com
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "defs.h"
|
||||||
|
#include "frame.h"
|
||||||
|
#include "obstack.h"
|
||||||
|
#include "symtab.h"
|
||||||
|
#include "gdbtypes.h"
|
||||||
|
#include "gdbcmd.h"
|
||||||
|
#include "dis-asm.h"
|
||||||
|
#include "../opcodes/h8500-opc.h"
|
||||||
|
;
|
||||||
|
#undef NUM_REGS
|
||||||
|
#define NUM_REGS 11
|
||||||
|
|
||||||
|
#define UNSIGNED_SHORT(X) ((X) & 0xffff)
|
||||||
|
|
||||||
|
|
||||||
|
/* Shape of an H8/500 frame :
|
||||||
|
|
||||||
|
|
||||||
|
arg-n
|
||||||
|
..
|
||||||
|
arg-2
|
||||||
|
arg-1
|
||||||
|
return address <2 or 4 bytes>
|
||||||
|
old fp <2 bytes>
|
||||||
|
auto-n
|
||||||
|
..
|
||||||
|
auto-1
|
||||||
|
saved registers
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
/* an easy to debug H8 stack frame looks like:
|
||||||
|
0x6df6 push r6
|
||||||
|
0x0d76 mov.w r7,r6
|
||||||
|
0x6dfn push reg
|
||||||
|
0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
|
||||||
|
0x1957 sub.w r5,sp
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define IS_PUSH(x) ((x & 0xff00)==0x6d00)
|
||||||
|
#define IS_LINK_8(x) ((x) == 0x17)
|
||||||
|
#define IS_LINK_16(x) ((x) == 0x1f)
|
||||||
|
#define IS_MOVE_FP(x) (x == 0x0d76)
|
||||||
|
#define IS_MOV_SP_FP(x) (x == 0x0d76)
|
||||||
|
#define IS_SUB2_SP(x) (x==0x1b87)
|
||||||
|
#define IS_MOVK_R5(x) (x==0x7905)
|
||||||
|
#define IS_SUB_R5SP(x) (x==0x1957)
|
||||||
|
|
||||||
|
#define LINK_8 0x17
|
||||||
|
#define LINK_16 0x1f
|
||||||
|
|
||||||
|
int minimum_mode = 1;
|
||||||
|
CORE_ADDR examine_prologue ();
|
||||||
|
|
||||||
|
void frame_find_saved_regs ();
|
||||||
|
CORE_ADDR
|
||||||
|
h8500_skip_prologue (start_pc)
|
||||||
|
CORE_ADDR start_pc;
|
||||||
|
|
||||||
|
{
|
||||||
|
short int w;
|
||||||
|
|
||||||
|
|
||||||
|
w = read_memory_integer (start_pc, 1);
|
||||||
|
if (w == LINK_8)
|
||||||
|
{
|
||||||
|
start_pc ++;
|
||||||
|
w = read_memory_integer (start_pc,1);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (w == LINK_16)
|
||||||
|
{
|
||||||
|
start_pc +=2;
|
||||||
|
w = read_memory_integer (start_pc,2);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Skip past a move to FP */
|
||||||
|
if (IS_MOVE_FP (w))
|
||||||
|
{
|
||||||
|
start_pc += 2;
|
||||||
|
w = read_memory_short (start_pc);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Skip the stack adjust */
|
||||||
|
|
||||||
|
if (IS_MOVK_R5 (w))
|
||||||
|
{
|
||||||
|
start_pc += 2;
|
||||||
|
w = read_memory_short (start_pc);
|
||||||
|
}
|
||||||
|
if (IS_SUB_R5SP (w))
|
||||||
|
{
|
||||||
|
start_pc += 2;
|
||||||
|
w = read_memory_short (start_pc);
|
||||||
|
}
|
||||||
|
while (IS_SUB2_SP (w))
|
||||||
|
{
|
||||||
|
start_pc += 2;
|
||||||
|
w = read_memory_short (start_pc);
|
||||||
|
}
|
||||||
|
|
||||||
|
return start_pc;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
print_insn (memaddr, stream)
|
||||||
|
CORE_ADDR memaddr;
|
||||||
|
FILE *stream;
|
||||||
|
{
|
||||||
|
/* Nothing is bigger than 8 bytes */
|
||||||
|
char data[8];
|
||||||
|
disassemble_info info;
|
||||||
|
read_memory (memaddr, data, sizeof (data));
|
||||||
|
GDB_INIT_DISASSEMBLE_INFO(info, stream);
|
||||||
|
return print_insn_h8500 (memaddr, data, &info);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Given a GDB frame, determine the address of the calling function's frame.
|
||||||
|
This will be used to create a new GDB frame struct, and then
|
||||||
|
INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
|
||||||
|
|
||||||
|
For us, the frame address is its stack pointer value, so we look up
|
||||||
|
the function prologue to determine the caller's sp value, and return it. */
|
||||||
|
|
||||||
|
FRAME_ADDR
|
||||||
|
FRAME_CHAIN (thisframe)
|
||||||
|
FRAME thisframe;
|
||||||
|
{
|
||||||
|
static int loopcount;
|
||||||
|
static int prevr;
|
||||||
|
if (!inside_entry_file ((thisframe)->pc))
|
||||||
|
{
|
||||||
|
int v = read_memory_integer ((thisframe)->frame, PTR_SIZE) ;
|
||||||
|
|
||||||
|
/* Detect loops in the stack */
|
||||||
|
if (v == prevr) loopcount++;
|
||||||
|
else loopcount = 0;
|
||||||
|
v = prevr;
|
||||||
|
if (loopcount > 5) return 0;
|
||||||
|
}
|
||||||
|
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
|
||||||
|
ways in the stack frame. sp is even more special:
|
||||||
|
the address we return for it IS the sp for the next frame.
|
||||||
|
|
||||||
|
We cache the result of doing this in the frame_cache_obstack, since
|
||||||
|
it is fairly expensive. */
|
||||||
|
#if 0
|
||||||
|
|
||||||
|
void
|
||||||
|
frame_find_saved_regs (fi, fsr)
|
||||||
|
struct frame_info *fi;
|
||||||
|
struct frame_saved_regs *fsr;
|
||||||
|
{
|
||||||
|
register CORE_ADDR next_addr;
|
||||||
|
register CORE_ADDR *saved_regs;
|
||||||
|
register int regnum;
|
||||||
|
register struct frame_saved_regs *cache_fsr;
|
||||||
|
extern struct obstack frame_cache_obstack;
|
||||||
|
CORE_ADDR ip;
|
||||||
|
struct symtab_and_line sal;
|
||||||
|
CORE_ADDR limit;
|
||||||
|
|
||||||
|
if (!fi->fsr)
|
||||||
|
{
|
||||||
|
cache_fsr = (struct frame_saved_regs *)
|
||||||
|
obstack_alloc (&frame_cache_obstack,
|
||||||
|
sizeof (struct frame_saved_regs));
|
||||||
|
bzero (cache_fsr, sizeof (struct frame_saved_regs));
|
||||||
|
|
||||||
|
fi->fsr = cache_fsr;
|
||||||
|
|
||||||
|
/* Find the start and end of the function prologue. If the PC
|
||||||
|
is in the function prologue, we only consider the part that
|
||||||
|
has executed already. */
|
||||||
|
|
||||||
|
ip = get_pc_function_start (fi->pc);
|
||||||
|
sal = find_pc_line (ip, 0);
|
||||||
|
limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
|
||||||
|
|
||||||
|
/* This will fill in fields in *fi as well as in cache_fsr. */
|
||||||
|
examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (fsr)
|
||||||
|
*fsr = *fi->fsr;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* 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;
|
||||||
|
char *pword1;
|
||||||
|
{
|
||||||
|
if (addr < lim + 8)
|
||||||
|
{
|
||||||
|
read_memory (addr, pword1, 1);
|
||||||
|
read_memory (addr, pword1 + 1, 1);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Examine the prologue of a function. `ip' points to the first instruction.
|
||||||
|
`limit' is the limit of the prologue (e.g. the addr of the first
|
||||||
|
linenumber, or perhaps the program counter if we're stepping through).
|
||||||
|
`frame_sp' is the stack pointer value in use in this frame.
|
||||||
|
`fsr' is a pointer to a frame_saved_regs structure into which we put
|
||||||
|
info about the registers saved by this frame.
|
||||||
|
`fi' is a struct frame_info pointer; we fill in various fields in it
|
||||||
|
to reflect the offsets of the arg pointer and the locals pointer. */
|
||||||
|
#if 0
|
||||||
|
static CORE_ADDR
|
||||||
|
examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
|
||||||
|
register CORE_ADDR ip;
|
||||||
|
register CORE_ADDR limit;
|
||||||
|
FRAME_ADDR after_prolog_fp;
|
||||||
|
struct frame_saved_regs *fsr;
|
||||||
|
struct frame_info *fi;
|
||||||
|
{
|
||||||
|
register CORE_ADDR next_ip;
|
||||||
|
int r;
|
||||||
|
int i;
|
||||||
|
int have_fp = 0;
|
||||||
|
|
||||||
|
register int src;
|
||||||
|
register struct pic_prologue_code *pcode;
|
||||||
|
char insn[2];
|
||||||
|
int size, offset;
|
||||||
|
unsigned int reg_save_depth = 2; /* Number of things pushed onto
|
||||||
|
stack, starts at 2, 'cause the
|
||||||
|
PC is already there */
|
||||||
|
|
||||||
|
unsigned int auto_depth = 0; /* Number of bytes of autos */
|
||||||
|
|
||||||
|
char in_frame[8]; /* One for each reg */
|
||||||
|
|
||||||
|
memset (in_frame, 1, 8);
|
||||||
|
for (r = 0; r < 8; r++)
|
||||||
|
{
|
||||||
|
fsr->regs[r] = 0;
|
||||||
|
}
|
||||||
|
if (after_prolog_fp == 0)
|
||||||
|
{
|
||||||
|
after_prolog_fp = read_register (SP_REGNUM);
|
||||||
|
}
|
||||||
|
if (ip == 0 || ip & ~0xffffff)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
ok = NEXT_PROLOGUE_INSN (ip, limit, &insn[0]);
|
||||||
|
|
||||||
|
/* Skip over any fp push instructions */
|
||||||
|
fsr->regs[6] = after_prolog_fp;
|
||||||
|
|
||||||
|
if (ok && IS_LINK_8 (insn[0]))
|
||||||
|
{
|
||||||
|
ip++;
|
||||||
|
|
||||||
|
in_frame[6] = reg_save_depth;
|
||||||
|
reg_save_depth += 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
|
||||||
|
|
||||||
|
/* Is this a move into the fp */
|
||||||
|
if (next_ip && IS_MOV_SP_FP (insn_word))
|
||||||
|
{
|
||||||
|
ip = next_ip;
|
||||||
|
next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
|
||||||
|
have_fp = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Skip over any stack adjustment, happens either with a number of
|
||||||
|
sub#2,sp or a mov #x,r5 sub r5,sp */
|
||||||
|
|
||||||
|
if (next_ip && IS_SUB2_SP (insn_word))
|
||||||
|
{
|
||||||
|
while (next_ip && IS_SUB2_SP (insn_word))
|
||||||
|
{
|
||||||
|
auto_depth += 2;
|
||||||
|
ip = next_ip;
|
||||||
|
next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (next_ip && IS_MOVK_R5 (insn_word))
|
||||||
|
{
|
||||||
|
ip = next_ip;
|
||||||
|
next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
|
||||||
|
auto_depth += insn_word;
|
||||||
|
|
||||||
|
next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word);
|
||||||
|
auto_depth += insn_word;
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* Work out which regs are stored where */
|
||||||
|
while (next_ip && IS_PUSH (insn_word))
|
||||||
|
{
|
||||||
|
ip = next_ip;
|
||||||
|
next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
|
||||||
|
fsr->regs[r] = after_prolog_fp + auto_depth;
|
||||||
|
auto_depth += 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* The args are always reffed based from the stack pointer */
|
||||||
|
fi->args_pointer = after_prolog_fp;
|
||||||
|
/* Locals are always reffed based from the fp */
|
||||||
|
fi->locals_pointer = after_prolog_fp;
|
||||||
|
/* The PC is at a known place */
|
||||||
|
fi->from_pc = read_memory_short (after_prolog_fp + 2);
|
||||||
|
|
||||||
|
/* Rememeber any others too */
|
||||||
|
in_frame[PC_REGNUM] = 0;
|
||||||
|
|
||||||
|
if (have_fp)
|
||||||
|
/* We keep the old FP in the SP spot */
|
||||||
|
fsr->regs[SP_REGNUM] = (read_memory_short (fsr->regs[6]));
|
||||||
|
else
|
||||||
|
fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
|
||||||
|
|
||||||
|
return (ip);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
#if 0
|
||||||
|
void
|
||||||
|
init_extra_frame_info (fromleaf, fi)
|
||||||
|
int fromleaf;
|
||||||
|
struct frame_info *fi;
|
||||||
|
{
|
||||||
|
fi->fsr = 0; /* Not yet allocated */
|
||||||
|
fi->args_pointer = 0; /* Unknown */
|
||||||
|
fi->locals_pointer = 0; /* Unknown */
|
||||||
|
fi->from_pc = 0;
|
||||||
|
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Return the saved PC from this frame. */
|
||||||
|
|
||||||
|
CORE_ADDR
|
||||||
|
frame_saved_pc (frame)
|
||||||
|
FRAME frame;
|
||||||
|
{
|
||||||
|
return read_memory_integer ((frame)->frame + 2, PTR_SIZE);
|
||||||
|
}
|
||||||
|
|
||||||
|
CORE_ADDR
|
||||||
|
frame_locals_address (fi)
|
||||||
|
struct frame_info *fi;
|
||||||
|
{
|
||||||
|
return fi->frame;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Return the address of the argument block for the frame
|
||||||
|
described by FI. Returns 0 if the address is unknown. */
|
||||||
|
|
||||||
|
CORE_ADDR
|
||||||
|
frame_args_address (fi)
|
||||||
|
struct frame_info *fi;
|
||||||
|
{
|
||||||
|
return fi->frame + PTR_SIZE; /* Skip the PC */
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
h8300_pop_frame ()
|
||||||
|
{
|
||||||
|
unsigned regnum;
|
||||||
|
struct frame_saved_regs fsr;
|
||||||
|
struct frame_info *fi;
|
||||||
|
|
||||||
|
FRAME frame = get_current_frame ();
|
||||||
|
|
||||||
|
fi = get_frame_info (frame);
|
||||||
|
get_frame_saved_regs (fi, &fsr);
|
||||||
|
|
||||||
|
for (regnum = 0; regnum < 8; regnum++)
|
||||||
|
{
|
||||||
|
if (fsr.regs[regnum])
|
||||||
|
{
|
||||||
|
write_register (regnum, read_memory_short (fsr.regs[regnum]));
|
||||||
|
}
|
||||||
|
|
||||||
|
flush_cached_frames ();
|
||||||
|
set_current_frame (create_new_frame (read_register (FP_REGNUM),
|
||||||
|
read_pc ()));
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
print_register_hook (regno)
|
||||||
|
{
|
||||||
|
if (regno == CCR_REGNUM)
|
||||||
|
{
|
||||||
|
/* CCR register */
|
||||||
|
|
||||||
|
int C, Z, N, V;
|
||||||
|
unsigned char b[2];
|
||||||
|
unsigned char l;
|
||||||
|
|
||||||
|
read_relative_register_raw_bytes (regno, b);
|
||||||
|
l = b[1];
|
||||||
|
printf ("\t");
|
||||||
|
printf ("I-%d - ", (l & 0x80) != 0);
|
||||||
|
N = (l & 0x8) != 0;
|
||||||
|
Z = (l & 0x4) != 0;
|
||||||
|
V = (l & 0x2) != 0;
|
||||||
|
C = (l & 0x1) != 0;
|
||||||
|
printf ("N-%d ", N);
|
||||||
|
printf ("Z-%d ", Z);
|
||||||
|
printf ("V-%d ", V);
|
||||||
|
printf ("C-%d ", C);
|
||||||
|
if ((C | Z) == 0)
|
||||||
|
printf ("u> ");
|
||||||
|
if ((C | Z) == 1)
|
||||||
|
printf ("u<= ");
|
||||||
|
if ((C == 0))
|
||||||
|
printf ("u>= ");
|
||||||
|
if (C == 1)
|
||||||
|
printf ("u< ");
|
||||||
|
if (Z == 0)
|
||||||
|
printf ("!= ");
|
||||||
|
if (Z == 1)
|
||||||
|
printf ("== ");
|
||||||
|
if ((N ^ V) == 0)
|
||||||
|
printf (">= ");
|
||||||
|
if ((N ^ V) == 1)
|
||||||
|
printf ("< ");
|
||||||
|
if ((Z | (N ^ V)) == 0)
|
||||||
|
printf ("> ");
|
||||||
|
if ((Z | (N ^ V)) == 1)
|
||||||
|
printf ("<= ");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#if 0
|
||||||
|
register_byte (N)
|
||||||
|
{
|
||||||
|
return reginfo[N].offset;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
register_raw_size (N)
|
||||||
|
{
|
||||||
|
if (N <= R7) return 2;
|
||||||
|
return 4;
|
||||||
|
}
|
||||||
|
|
||||||
|
register_virtual_size (N)
|
||||||
|
{
|
||||||
|
if (N <= R7) return 2;
|
||||||
|
return 4;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
register_convert_to_raw (regnum, from, to)
|
||||||
|
int regnum;
|
||||||
|
char *from;
|
||||||
|
char *to;
|
||||||
|
{
|
||||||
|
switch (regnum)
|
||||||
|
{
|
||||||
|
case PR0:
|
||||||
|
case PR1:
|
||||||
|
case PR2:
|
||||||
|
case PR3:
|
||||||
|
case PR4:
|
||||||
|
case PR5:
|
||||||
|
case PR6:
|
||||||
|
case PR7:
|
||||||
|
case PC_REGNUM:
|
||||||
|
to[0] = 0;
|
||||||
|
to[1] = from[1];
|
||||||
|
to[2] = from[2];
|
||||||
|
to[3] = from[3];
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
to[0] = from[0];
|
||||||
|
to[1] = from[1];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
register_convert_to_virtual (regnum, from, to)
|
||||||
|
int regnum;
|
||||||
|
char *from;
|
||||||
|
char *to;
|
||||||
|
{
|
||||||
|
switch (regnum)
|
||||||
|
{
|
||||||
|
case PR0:
|
||||||
|
case PR1:
|
||||||
|
case PR2:
|
||||||
|
case PR3:
|
||||||
|
case PR4:
|
||||||
|
case PR5:
|
||||||
|
case PR6:
|
||||||
|
case PR7:
|
||||||
|
case PC_REGNUM:
|
||||||
|
to[0] = 0;
|
||||||
|
to[1] = from[1];
|
||||||
|
to[2] = from[2];
|
||||||
|
to[3] = from[3];
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
to[0] = from[0];
|
||||||
|
to[1] = from[1];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct type *
|
||||||
|
register_virtual_type (N)
|
||||||
|
{
|
||||||
|
switch (N)
|
||||||
|
{
|
||||||
|
/* Although these are actually word size registers, we treat them
|
||||||
|
like longs so that we can deal with any implicit segmentation */
|
||||||
|
case PR0:
|
||||||
|
case PR1:
|
||||||
|
case PR2:
|
||||||
|
case PR3:
|
||||||
|
case PR4:
|
||||||
|
case PR5:
|
||||||
|
case PR6:
|
||||||
|
case PR7:
|
||||||
|
case PC_REGNUM:
|
||||||
|
return builtin_type_unsigned_long;
|
||||||
|
case SEG_C:
|
||||||
|
case SEG_E:
|
||||||
|
case SEG_D:
|
||||||
|
case SEG_T:
|
||||||
|
return builtin_type_unsigned_char;
|
||||||
|
case R0:
|
||||||
|
case R1:
|
||||||
|
case R2:
|
||||||
|
case R3:
|
||||||
|
case R4:
|
||||||
|
case R5:
|
||||||
|
case R6:
|
||||||
|
case R7:
|
||||||
|
case CCR_REGNUM:
|
||||||
|
return builtin_type_unsigned_short;
|
||||||
|
|
||||||
|
|
||||||
|
default:
|
||||||
|
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.
|
||||||
|
This includes special registers such as pc and fp saved in special
|
||||||
|
ways in the stack frame. sp is even more special:
|
||||||
|
the address we return for it IS the sp for the next frame. */
|
||||||
|
|
||||||
|
void
|
||||||
|
frame_find_saved_regs (frame_info, frame_saved_regs)
|
||||||
|
struct frame_info *frame_info;
|
||||||
|
struct frame_saved_regs *frame_saved_regs;
|
||||||
|
|
||||||
|
{
|
||||||
|
register int regnum;
|
||||||
|
register int regmask;
|
||||||
|
register CORE_ADDR next_addr;
|
||||||
|
register CORE_ADDR pc;
|
||||||
|
unsigned char thebyte;
|
||||||
|
|
||||||
|
bzero (frame_saved_regs, sizeof *frame_saved_regs);
|
||||||
|
|
||||||
|
if ((frame_info)->pc >= (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 4
|
||||||
|
&& (frame_info)->pc <= (frame_info)->frame)
|
||||||
|
{
|
||||||
|
next_addr = (frame_info)->frame;
|
||||||
|
pc = (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 4;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
pc = get_pc_function_start ((frame_info)->pc);
|
||||||
|
/* Verify we have a link a6 instruction next;
|
||||||
|
if not we lose. If we win, find the address above the saved
|
||||||
|
regs using the amount of storage from the link instruction.
|
||||||
|
*/
|
||||||
|
|
||||||
|
thebyte = read_memory_integer(pc, 1);
|
||||||
|
if (0x1f == thebyte)
|
||||||
|
next_addr = (frame_info)->frame + read_memory_integer (pc += 1, 2), pc += 2;
|
||||||
|
else if (0x17 == thebyte)
|
||||||
|
next_addr = (frame_info)->frame + read_memory_integer (pc += 1, 1), pc += 1;
|
||||||
|
else
|
||||||
|
goto lose;
|
||||||
|
#if 0
|
||||||
|
fixme steve
|
||||||
|
/* If have an add:g.waddal #-n, sp next, adjust next_addr. */
|
||||||
|
if ((0x0c0177777 & read_memory_integer (pc, 2)) == 0157774)
|
||||||
|
next_addr += read_memory_integer (pc += 2, 4), pc += 4;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
thebyte = read_memory_integer(pc, 1);
|
||||||
|
if (thebyte == 0x12) {
|
||||||
|
/* Got stm */
|
||||||
|
pc++;
|
||||||
|
regmask = read_memory_integer(pc,1);
|
||||||
|
pc++;
|
||||||
|
for (regnum = 0; regnum < 8; regnum ++, regmask >>=1)
|
||||||
|
{
|
||||||
|
if (regmask & 1)
|
||||||
|
{
|
||||||
|
(frame_saved_regs)->regs[regnum] = (next_addr += 2) - 2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
thebyte = read_memory_integer(pc, 1);
|
||||||
|
}
|
||||||
|
/* Maybe got a load of pushes */
|
||||||
|
while (thebyte == 0xbf) {
|
||||||
|
pc++;
|
||||||
|
regnum = read_memory_integer(pc,1) & 0x7;
|
||||||
|
pc++;
|
||||||
|
(frame_saved_regs)->regs[regnum] = (next_addr += 2) - 2;
|
||||||
|
thebyte = read_memory_integer(pc, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
lose:;
|
||||||
|
|
||||||
|
/* Remember the address of the frame pointer */
|
||||||
|
(frame_saved_regs)->regs[FP_REGNUM] = (frame_info)->frame;
|
||||||
|
|
||||||
|
/* This is where the old sp is hidden */
|
||||||
|
(frame_saved_regs)->regs[SP_REGNUM] = (frame_info)->frame;
|
||||||
|
|
||||||
|
/* And the PC - remember the pushed FP is always two bytes long */
|
||||||
|
(frame_saved_regs)->regs[PC_REGNUM] = (frame_info)->frame + 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
saved_pc_after_call(frame)
|
||||||
|
{
|
||||||
|
int x;
|
||||||
|
int a = read_register(SP_REGNUM);
|
||||||
|
x = read_memory_integer (a, PTR_SIZE);
|
||||||
|
return x;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* Nonzero if instruction at PC is a return instruction. */
|
||||||
|
|
||||||
|
about_to_return(pc)
|
||||||
|
{
|
||||||
|
int b1 = read_memory_integer(pc,1);
|
||||||
|
|
||||||
|
switch (b1)
|
||||||
|
{
|
||||||
|
case 0x14: /* rtd #8 */
|
||||||
|
case 0x1c: /* rtd #16 */
|
||||||
|
case 0x19: /* rts */
|
||||||
|
case 0x1a: /* rte */
|
||||||
|
return 1;
|
||||||
|
case 0x11:
|
||||||
|
{
|
||||||
|
int b2 = read_memory_integer(pc+1,1);
|
||||||
|
switch (b2)
|
||||||
|
{
|
||||||
|
case 0x18: /* prts */
|
||||||
|
case 0x14: /* prtd #8 */
|
||||||
|
case 0x16: /* prtd #16 */
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
h8500_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)
|
||||||
|
{
|
||||||
|
minimum_mode = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
minimum_mode = 1;
|
||||||
|
}
|
||||||
|
_initialize_gdbtypes ();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
struct cmd_list_element *setmemorylist;
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
segmented_command (args, from_tty)
|
||||||
|
char *args;
|
||||||
|
int from_tty;
|
||||||
|
{
|
||||||
|
h8500_set_pointer_size (32);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
unsegmented_command (args, from_tty)
|
||||||
|
char *args;
|
||||||
|
int from_tty;
|
||||||
|
{
|
||||||
|
h8500_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_h8500_tdep ()
|
||||||
|
{
|
||||||
|
/* Sanitity check a few things */
|
||||||
|
if (FP_REGNUM != GPR6
|
||||||
|
|| SP_REGNUM != GPR7
|
||||||
|
|| CCR_REGNUM != GCCR
|
||||||
|
|| PC_REGNUM != GPC
|
||||||
|
|| SEG_C != GSEGC
|
||||||
|
|| SEG_D != GSEGD
|
||||||
|
|| SEG_E != GSEGE
|
||||||
|
|| SEG_T != GSEGT
|
||||||
|
|| PR0 != GPR0
|
||||||
|
|| PR1 != GPR1
|
||||||
|
|| PR2 != GPR2
|
||||||
|
|| PR3 != GPR3
|
||||||
|
|| PR4 != GPR4
|
||||||
|
|| PR5 != GPR5
|
||||||
|
|| PR6 != GPR6
|
||||||
|
|| PR7 != GPR7)
|
||||||
|
abort ();
|
||||||
|
|
||||||
|
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);
|
||||||
|
|
||||||
|
}
|
||||||
293
gdb/tm-h8500.h
Normal file
293
gdb/tm-h8500.h
Normal file
@ -0,0 +1,293 @@
|
|||||||
|
/* Parameters for execution on a H8/500 series machine.
|
||||||
|
Copyright (C) 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||||
|
|
||||||
|
/* Contributed by Steve Chamberlain sac@cygnus.com */
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#define IEEE_FLOAT 1
|
||||||
|
|
||||||
|
/* Define the bit, byte, and word ordering of the machine. */
|
||||||
|
|
||||||
|
#define TARGET_BYTE_ORDER BIG_ENDIAN
|
||||||
|
|
||||||
|
#undef TARGET_INT_BIT
|
||||||
|
#define TARGET_INT_BIT 16
|
||||||
|
|
||||||
|
#undef TARGET_PTR_BIT
|
||||||
|
#define TARGET_PTR_BIT (minimum_mode ? 16 : 32)
|
||||||
|
|
||||||
|
|
||||||
|
/* Offset from address of function to start of its code.
|
||||||
|
Zero on most machines. */
|
||||||
|
|
||||||
|
#define FUNCTION_START_OFFSET 0
|
||||||
|
|
||||||
|
/* Advance PC across any function entry prologue instructions
|
||||||
|
to reach some "real" code. */
|
||||||
|
|
||||||
|
#define SKIP_PROLOGUE(ip) {(ip) = h8500_skip_prologue(ip);}
|
||||||
|
extern CORE_ADDR h8500_skip_prologue ();
|
||||||
|
|
||||||
|
|
||||||
|
/* Immediately after a function call, return the saved pc.
|
||||||
|
Can't always go through the frames for this because on some machines
|
||||||
|
the new frame is not set up until the new function executes
|
||||||
|
some instructions. */
|
||||||
|
|
||||||
|
#define SAVED_PC_AFTER_CALL(frame) saved_pc_after_call(frame)
|
||||||
|
|
||||||
|
|
||||||
|
/* Stack grows downward. */
|
||||||
|
|
||||||
|
#define INNER_THAN <
|
||||||
|
|
||||||
|
/* Illegal instruction - used by the simulator for breakpoint
|
||||||
|
detection */
|
||||||
|
#define BREAKPOINT {0x0b}
|
||||||
|
|
||||||
|
|
||||||
|
/* If your kernel resets the pc after the trap happens you may need to
|
||||||
|
define this before including this file. */
|
||||||
|
|
||||||
|
#define DECR_PC_AFTER_BREAK 0
|
||||||
|
|
||||||
|
|
||||||
|
/* Nonzero if instruction at PC is a return instruction. */
|
||||||
|
|
||||||
|
#define ABOUT_TO_RETURN(pc) about_to_return(pc)
|
||||||
|
|
||||||
|
/* Return 1 if P points to an invalid floating point value. */
|
||||||
|
|
||||||
|
#define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */
|
||||||
|
|
||||||
|
/* Say how long registers are. */
|
||||||
|
|
||||||
|
#define REGISTER_TYPE unsigned long
|
||||||
|
|
||||||
|
/* Say how much memory is needed to store a copy of the register set */
|
||||||
|
|
||||||
|
#define REGISTER_BYTES ((NUM_REGS)*4)
|
||||||
|
|
||||||
|
/* Index within `registers' of the first byte of the space for
|
||||||
|
register N. */
|
||||||
|
|
||||||
|
#define REGISTER_BYTE(N) ((N)*4)
|
||||||
|
|
||||||
|
/* Number of bytes of storage in the actual machine representation
|
||||||
|
for register N. */
|
||||||
|
|
||||||
|
#define REGISTER_RAW_SIZE(N) register_raw_size(N)
|
||||||
|
|
||||||
|
#define REGISTER_VIRTUAL_SIZE(N) register_virtual_size(N)
|
||||||
|
|
||||||
|
/* Largest value REGISTER_RAW_SIZE can have. */
|
||||||
|
|
||||||
|
#define MAX_REGISTER_RAW_SIZE 4
|
||||||
|
|
||||||
|
/* Largest value REGISTER_VIRTUAL_SIZE can have. */
|
||||||
|
|
||||||
|
#define MAX_REGISTER_VIRTUAL_SIZE 4
|
||||||
|
|
||||||
|
/* Nonzero if register N requires conversion
|
||||||
|
from raw format to virtual format. */
|
||||||
|
|
||||||
|
#define REGISTER_CONVERTIBLE(N) 1
|
||||||
|
|
||||||
|
/* Convert data from raw format for register REGNUM
|
||||||
|
to virtual format for register REGNUM. */
|
||||||
|
|
||||||
|
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
|
||||||
|
register_convert_to_virtual(REGNUM, FROM, TO)
|
||||||
|
|
||||||
|
/* Convert data from virtual format for register REGNUM
|
||||||
|
to raw format for register REGNUM. */
|
||||||
|
|
||||||
|
#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
|
||||||
|
register_convert_to_raw(REGNUM, FROM, TO)
|
||||||
|
|
||||||
|
/* Return the GDB type object for the "standard" data type
|
||||||
|
of data in register N. */
|
||||||
|
struct type *register_virtual_type();
|
||||||
|
|
||||||
|
#define REGISTER_VIRTUAL_TYPE(N) register_virtual_type(N)
|
||||||
|
|
||||||
|
|
||||||
|
/* Initializer for an array of names of registers.
|
||||||
|
Entries beyond the first NUM_REGS are ignored. */
|
||||||
|
|
||||||
|
#define REGISTER_NAMES \
|
||||||
|
{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
|
||||||
|
"pr0", "pr1","pr2","pr3","pr4","pr5","pr6","pr7", \
|
||||||
|
"ccr","pc", \
|
||||||
|
"cp","dp","ep","tp" }
|
||||||
|
|
||||||
|
/* Register numbers of various important registers.
|
||||||
|
Note that some of these values are "real" register numbers,
|
||||||
|
and correspond to the general registers of the machine,
|
||||||
|
and some are "phony" register numbers which are too large
|
||||||
|
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 R0 0
|
||||||
|
#define R1 1
|
||||||
|
#define R2 2
|
||||||
|
#define R3 3
|
||||||
|
#define R4 4
|
||||||
|
#define R5 5
|
||||||
|
#define R6 6
|
||||||
|
#define R7 7
|
||||||
|
|
||||||
|
#define PR0 8 /* R0-R7 with seg prefixed */
|
||||||
|
#define PR1 9
|
||||||
|
#define PR2 10
|
||||||
|
#define PR3 11
|
||||||
|
#define PR4 12
|
||||||
|
#define PR5 13
|
||||||
|
#define PR6 14
|
||||||
|
#define PR7 15
|
||||||
|
|
||||||
|
#define SP_REGNUM PR7 /* Contains address of top of stack */
|
||||||
|
#define FP_REGNUM PR6 /* Contains address of executing stack frame */
|
||||||
|
|
||||||
|
#define CCR_REGNUM 16 /* Contains processor status */
|
||||||
|
#define PC_REGNUM 17 /* Contains program counter */
|
||||||
|
|
||||||
|
#define SEG_C 18 /* Segment registers */
|
||||||
|
#define SEG_D 19
|
||||||
|
#define SEG_E 20
|
||||||
|
#define SEG_T 21
|
||||||
|
|
||||||
|
#define NUM_REGS 22
|
||||||
|
|
||||||
|
#define PTR_SIZE (minimum_mode ? 2: 4)
|
||||||
|
#define PTR_MASK (minimum_mode ? 0x0000ffff : 0x00ffffff)
|
||||||
|
|
||||||
|
/* 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) \
|
||||||
|
{ write_register (0, (ADDR)); abort(); }*/
|
||||||
|
|
||||||
|
/* Extract from an array REGBUF containing the (raw) register state
|
||||||
|
a function return value of type TYPE, and copy that, in virtual format,
|
||||||
|
into VALBUF. */
|
||||||
|
|
||||||
|
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
|
||||||
|
bcopy ((char *)(REGBUF), 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. */
|
||||||
|
|
||||||
|
|
||||||
|
#define STORE_RETURN_VALUE(TYPE,VALBUF) \
|
||||||
|
write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
|
||||||
|
|
||||||
|
|
||||||
|
/* Extract from an array REGBUF containing the (raw) register state
|
||||||
|
the address in which a function should return its structure value,
|
||||||
|
as a CORE_ADDR (or an expression that can be used as one). */
|
||||||
|
|
||||||
|
#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(CORE_ADDR *)(REGBUF))
|
||||||
|
|
||||||
|
|
||||||
|
/* Define other aspects of the stack frame. */
|
||||||
|
|
||||||
|
/* A macro that tells us whether the function invocation represented
|
||||||
|
by FI does not have a frame on the stack associated with it. If it
|
||||||
|
does not, FRAMELESS is set to 1, else 0. */
|
||||||
|
#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
|
||||||
|
(FRAMELESS) = frameless_look_for_prologue(FI)
|
||||||
|
|
||||||
|
/* Any function with a frame looks like this
|
||||||
|
SECOND ARG
|
||||||
|
FIRST ARG
|
||||||
|
RET PC
|
||||||
|
SAVED R2
|
||||||
|
SAVED R3
|
||||||
|
SAVED FP <-FP POINTS HERE
|
||||||
|
LOCALS0
|
||||||
|
LOCALS1 <-SP POINTS HERE
|
||||||
|
|
||||||
|
*/
|
||||||
|
#define FRAME_SAVED_PC(FRAME) frame_saved_pc(FRAME)
|
||||||
|
|
||||||
|
#define FRAME_ARGS_ADDRESS(fi) frame_args_address(fi)
|
||||||
|
|
||||||
|
#define FRAME_LOCALS_ADDRESS(fi) frame_locals_address(fi);
|
||||||
|
|
||||||
|
/* Set VAL to the number of args passed to frame described by FI.
|
||||||
|
Can set VAL to -1, meaning no way to tell. */
|
||||||
|
|
||||||
|
/* We can't tell how many args there are
|
||||||
|
now that the C compiler delays popping them. */
|
||||||
|
|
||||||
|
#define FRAME_NUM_ARGS(val,fi) (val = -1)
|
||||||
|
|
||||||
|
/* Return number of bytes at start of arglist that are not really args. */
|
||||||
|
|
||||||
|
#define FRAME_ARGS_SKIP 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
|
||||||
|
ways in the stack frame. sp is even more special:
|
||||||
|
the address we return for it IS the sp for the next frame. */
|
||||||
|
|
||||||
|
#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
|
||||||
|
frame_find_saved_regs(frame_info, &(frame_saved_regs))
|
||||||
|
|
||||||
|
|
||||||
|
/* Push an empty stack frame, to record the current PC, etc. */
|
||||||
|
|
||||||
|
/*#define PUSH_DUMMY_FRAME { h8300_push_dummy_frame (); }*/
|
||||||
|
|
||||||
|
/* Discard from the stack the innermost frame, restoring all registers. */
|
||||||
|
|
||||||
|
#define POP_FRAME { h8300_pop_frame (); }
|
||||||
|
|
||||||
|
#define SHORT_INT_MAX 32767
|
||||||
|
#define SHORT_INT_MIN -32768
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#define BEFORE_MAIN_LOOP_HOOK \
|
||||||
|
hms_before_main_loop();
|
||||||
|
|
||||||
|
|
||||||
|
#define NAMES_HAVE_UNDERSCORE
|
||||||
|
|
||||||
|
typedef unsigned short INSN_WORD;
|
||||||
|
|
||||||
|
#define ADDR_BITS_REMOVE(addr) ((addr) & 0xffffff)
|
||||||
|
#define ADDR_BITS_SET(addr) (((addr)))
|
||||||
|
|
||||||
|
#define read_memory_short(x) (read_memory_integer(x,2) & 0xffff)
|
||||||
|
#define DONT_USE_REMOTE
|
||||||
|
|
||||||
|
|
||||||
|
#define PRINT_REGISTER_HOOK(regno) print_register_hook(regno)
|
||||||
|
|
||||||
|
|
||||||
|
int minimum_mode;
|
||||||
|
|
||||||
|
#define CALL_DUMMY_LENGTH 10
|
||||||
Loading…
Reference in New Issue
Block a user