Browse Source
* configure.tgt: Recognize the 68hc11. * m68hc11-tdep.c: New file for 68hc11 target. * config/m68hc11/m68hc11.mt: New file for 68hc11 port. * configure.tgt: When 68hc11, set gdb_multi_arch.binutils-2_11-branch
Andrew Cagney
26 years ago
4 changed files with 778 additions and 0 deletions
@ -0,0 +1,6 @@ |
|||||
|
# Target: Motorola 68HC11 processor |
||||
|
TDEPFILES= m68hc11-tdep.o |
||||
|
TM_FILE= tm-m68hc11.h |
||||
|
SIM_OBS= remote-sim.o |
||||
|
SIM= ../sim/m68hc11/libsim.a -lm |
||||
|
|
||||
@ -0,0 +1,754 @@ |
|||||
|
/* Target-dependent code for Motorola 68HC11
|
||||
|
Copyright (C) 1999, 2000 Free Software Foundation, Inc. |
||||
|
Contributed by Stephane Carrez, stcarrez@worldnet.fr |
||||
|
|
||||
|
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
||||
|
|
||||
|
#if 0 |
||||
|
/* FIXME: This is from tm-m68hc1.h */ |
||||
|
|
||||
|
#define GDB_TARGET_IS_M6811 |
||||
|
|
||||
|
/* Define the bit, byte, and word ordering of the machine. */ |
||||
|
|
||||
|
#define TARGET_BYTE_ORDER BIG_ENDIAN |
||||
|
|
||||
|
/* Offset from address of function to start of its code.
|
||||
|
Zero on most machines. */ |
||||
|
|
||||
|
#define FUNCTION_START_OFFSET 0 |
||||
|
|
||||
|
#ifdef __STDC__ /* Forward decls for prototypes */ |
||||
|
struct frame_info; |
||||
|
struct frame_saved_regs; |
||||
|
struct type; |
||||
|
struct value; |
||||
|
#endif |
||||
|
|
||||
|
/* Advance PC across any function entry prologue instructions
|
||||
|
to reach some "real" code. */ |
||||
|
|
||||
|
extern CORE_ADDR m68hc11_skip_prologue (); |
||||
|
#define SKIP_PROLOGUE(ip) \ |
||||
|
m68hc11_skip_prologue (ip) |
||||
|
|
||||
|
|
||||
|
/* Stack grows downward. */ |
||||
|
|
||||
|
#define INNER_THAN(lhs,rhs) ((lhs) < (rhs)) |
||||
|
|
||||
|
/* For a breakpoint, use "test". This is also the breakpoint
|
||||
|
instruction on the 68HC12. */ |
||||
|
#define BREAKPOINT {0x0} |
||||
|
|
||||
|
/* 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 |
||||
|
|
||||
|
extern char *m68hc11_register_names[]; |
||||
|
#define REGISTER_NAME(i) m68hc11_register_names[i] |
||||
|
|
||||
|
#define REGISTER_SIZE 2 |
||||
|
|
||||
|
/* 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 X_REGNUM 0 |
||||
|
#define D_REGNUM 1 |
||||
|
#define Y_REGNUM 2 |
||||
|
#define SP_REGNUM 3 |
||||
|
#define PC_REGNUM 4 |
||||
|
#define A_REGNUM 5 |
||||
|
#define B_REGNUM 6 |
||||
|
#define PSW_REGNUM 7 |
||||
|
#define Z_REGNUM 8 |
||||
|
#define FP_REGNUM 9 |
||||
|
#define TMP_REGNUM 10 |
||||
|
#define ZS_REGNUM 11 |
||||
|
#define XY_REGNUM 12 |
||||
|
#define ZD1_REGNUM 13 |
||||
|
#define ZD32_REGNUM (ZD1_REGNUM+31) |
||||
|
|
||||
|
#define NUM_REGS (ZD32_REGNUM+1) |
||||
|
|
||||
|
#include "opcode/m68hc11.h" |
||||
|
|
||||
|
/* Say how much memory is needed to store a copy of the register set */ |
||||
|
#define REGISTER_BYTES ((NUM_REGS)*2) |
||||
|
|
||||
|
/* Index within `registers' of the first byte of the space for
|
||||
|
register N. */ |
||||
|
|
||||
|
#define REGISTER_BYTE(N) ((N) * 2) |
||||
|
|
||||
|
/* Number of bytes of storage in the actual machine representation
|
||||
|
for register N. */ |
||||
|
|
||||
|
#define REGISTER_RAW_SIZE(N) (2) |
||||
|
|
||||
|
/* Number of bytes of storage in the program's representation
|
||||
|
for register N. */ |
||||
|
|
||||
|
#define REGISTER_VIRTUAL_SIZE(N) (2) |
||||
|
|
||||
|
/* Largest value REGISTER_RAW_SIZE can have. */ |
||||
|
|
||||
|
#define MAX_REGISTER_RAW_SIZE 8 |
||||
|
|
||||
|
/* Largest value REGISTER_VIRTUAL_SIZE can have. */ |
||||
|
|
||||
|
#define MAX_REGISTER_VIRTUAL_SIZE 8 |
||||
|
|
||||
|
/* Return the GDB type object for the "standard" data type
|
||||
|
of data in register N. */ |
||||
|
|
||||
|
#define REGISTER_VIRTUAL_TYPE(N) builtin_type_uint16 |
||||
|
|
||||
|
/* Store the address of the place in which to copy the structure the
|
||||
|
subroutine will return. This is called from call_function. |
||||
|
|
||||
|
We store structs through a pointer passed in D */ |
||||
|
|
||||
|
#define STORE_STRUCT_RETURN(ADDR, SP) \ |
||||
|
{ write_register (D_REGNUM, (ADDR)); } |
||||
|
|
||||
|
|
||||
|
/* Write into appropriate registers a function return value
|
||||
|
of type TYPE, given in virtual format. |
||||
|
|
||||
|
Things always get returned in D/X */ |
||||
|
|
||||
|
#define STORE_RETURN_VALUE(TYPE,VALBUF) \ |
||||
|
write_register_bytes (REGISTER_BYTE (D_REGNUM), 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.
|
||||
|
we keep a copy of the worked out return pc lying around, since it |
||||
|
is a useful bit of info */ |
||||
|
|
||||
|
#define EXTRA_FRAME_INFO \ |
||||
|
int frame_reg; \ |
||||
|
CORE_ADDR return_pc; \ |
||||
|
CORE_ADDR dummy; \ |
||||
|
int frameless; \ |
||||
|
int size; |
||||
|
|
||||
|
/* There's a mess in stack frame creation. See comments in blockframe.c
|
||||
|
near reference to INIT_FRAME_PC_FIRST. */ |
||||
|
|
||||
|
#define INIT_FRAME_PC(fromleaf, prev) /* nada */ |
||||
|
|
||||
|
#define INIT_FRAME_PC_FIRST(fromleaf, prev) \ |
||||
|
(prev)->pc = ((fromleaf) ? SAVED_PC_AFTER_CALL ((prev)->next) : \ |
||||
|
(prev)->next ? FRAME_SAVED_PC ((prev)->next) : read_pc ()); |
||||
|
|
||||
|
#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \ |
||||
|
m68hc11_init_extra_frame_info (fromleaf, fi) |
||||
|
|
||||
|
extern void m68hc11_init_extra_frame_info (int fromleaf, |
||||
|
struct frame_info * fi); |
||||
|
|
||||
|
/* 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_look_for_prologue (FI) |
||||
|
|
||||
|
#define FRAME_CHAIN(FRAME) m68hc11_frame_chain (FRAME) |
||||
|
#define FRAME_CHAIN_VALID(chain,frame) \ |
||||
|
((chain) != 0 && (frame) != 0) |
||||
|
#define FRAME_SAVED_PC(FRAME) ((FRAME)->return_pc) |
||||
|
#define FRAME_ARGS_ADDRESS(fi) (fi)->frame |
||||
|
#define FRAME_LOCALS_ADDRESS(fi) (fi)->frame |
||||
|
|
||||
|
#define SAVED_PC_AFTER_CALL(frame) m68hc11_saved_pc_after_call (frame) |
||||
|
|
||||
|
/* 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 */ |
||||
|
|
||||
|
#define FRAME_NUM_ARGS(fi) (-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) \ |
||||
|
m68hc11_frame_find_saved_regs (frame_info, &(frame_saved_regs)) |
||||
|
|
||||
|
extern void m68hc11_frame_find_saved_regs (struct frame_info *, |
||||
|
struct frame_saved_regs *); |
||||
|
|
||||
|
#define CALL_DUMMY { 0 } |
||||
|
#define PUSH_DUMMY_FRAME |
||||
|
#define CALL_DUMMY_START_OFFSET 0 |
||||
|
#define CALL_DUMMY_BREAKPOINT_OFFSET (0) |
||||
|
|
||||
|
extern CORE_ADDR m68hc11_call_dummy_address (void); |
||||
|
#define CALL_DUMMY_ADDRESS() m68hc11_call_dummy_address () |
||||
|
|
||||
|
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ |
||||
|
sp = m68hc11_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p) |
||||
|
|
||||
|
extern CORE_ADDR m68hc11_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, |
||||
|
int, struct value **, |
||||
|
struct type *, int); |
||||
|
#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \ |
||||
|
sp = m68hc11_push_arguments ((nargs), (args), (sp), \ |
||||
|
(struct_return), (struct_addr)) |
||||
|
extern CORE_ADDR m68hc11_push_arguments (int, struct value **, |
||||
|
CORE_ADDR, int, CORE_ADDR); |
||||
|
|
||||
|
|
||||
|
/* 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) \ |
||||
|
m68hc11_extract_return_value(TYPE, REGBUF, VALBUF) |
||||
|
extern void m68hc11_extract_return_value (struct type *, char *, char *); |
||||
|
|
||||
|
|
||||
|
/* Discard from the stack the innermost frame,
|
||||
|
restoring all saved registers. */ |
||||
|
#define POP_FRAME m68hc11_pop_frame(); |
||||
|
extern void m68hc11_pop_frame (void); |
||||
|
|
||||
|
|
||||
|
/* Number of bits in the appropriate type. */ |
||||
|
|
||||
|
#define TARGET_INT_BIT (2 * TARGET_CHAR_BIT) |
||||
|
#define TARGET_PTR_BIT (2 * TARGET_CHAR_BIT) |
||||
|
#define TARGET_DOUBLE_BIT (4 * TARGET_CHAR_BIT) |
||||
|
#define TARGET_LONG_DOUBLE_BIT (8 * TARGET_CHAR_BIT) |
||||
|
|
||||
|
#endif |
||||
|
|
||||
|
#include "defs.h" |
||||
|
#include "frame.h" |
||||
|
#include "obstack.h" |
||||
|
#include "symtab.h" |
||||
|
#include "gdbtypes.h" |
||||
|
#include "gdbcmd.h" |
||||
|
#include "gdbcore.h" |
||||
|
#include "gdb_string.h" |
||||
|
#include "value.h" |
||||
|
#include "inferior.h" |
||||
|
#include "dis-asm.h" |
||||
|
#include "symfile.h" |
||||
|
#include "objfiles.h" |
||||
|
|
||||
|
/* NOTE: This port is not finished. Several operations are not implemented
|
||||
|
and will raise an error. Most of these functions concern the calling |
||||
|
of a function by GDB itself (command 'call') and retrieving data pushed |
||||
|
on the stack. */ |
||||
|
|
||||
|
void m68hc11_frame_find_saved_regs (struct frame_info *fi, |
||||
|
struct frame_saved_regs *fsr); |
||||
|
static void m68hc11_pop_dummy_frame (struct frame_info *fi); |
||||
|
|
||||
|
/* Table of registers for 68HC11. This includes the hard registers
|
||||
|
and the pseudo hard registers used by GCC. */ |
||||
|
char* |
||||
|
m68hc11_register_names[] = |
||||
|
{ |
||||
|
"x", "d", "y", "sp", "pc", "a", "b", |
||||
|
"ccr", "z", "frame","tmp", "zs", "xy", |
||||
|
"ZD1", "ZD2", "ZD3", "ZD4", "ZD5", "ZD6", "ZD7", |
||||
|
"ZD8", "ZD9", "ZD10", "ZD11", "ZD12", "ZD13", "ZD14", |
||||
|
"ZD15", "ZD16", "ZD17", "ZD18", "ZD19", "ZD20", "ZD21", |
||||
|
"ZD22", "ZD23", "ZD24", "ZD25", "ZD26", "ZD27", "ZD28", |
||||
|
"ZD29", "ZD30", "ZD31", "ZD32" |
||||
|
}; |
||||
|
|
||||
|
static int reg_last = 32 * 2 + 6; |
||||
|
static int frame_index = 6; |
||||
|
|
||||
|
/* Raise an error for operations which are not yet provided. */ |
||||
|
static void |
||||
|
m68hc11_not_yet (const char *operation) |
||||
|
{ |
||||
|
error ("Operation '%s' is not yet implemented\n", operation); |
||||
|
} |
||||
|
|
||||
|
/* Immediately after a function call, return the saved pc before the frame
|
||||
|
is setup. For sun3's, we check for the common case of being inside of a |
||||
|
system call, and if so, we know that Sun pushes the call # on the stack |
||||
|
prior to doing the trap. */ |
||||
|
|
||||
|
CORE_ADDR |
||||
|
m68hc11_saved_pc_after_call (struct frame_info *frame) |
||||
|
{ |
||||
|
unsigned addr = frame->frame + 1 + 2; |
||||
|
|
||||
|
addr = read_register (SP_REGNUM) + 1; |
||||
|
addr &= 0x0ffff; |
||||
|
return read_memory_integer (addr, 2) & 0x0FFFF; |
||||
|
} |
||||
|
|
||||
|
/* Discard from the stack the innermost frame, restoring all saved
|
||||
|
registers. */ |
||||
|
|
||||
|
void |
||||
|
m68hc11_pop_frame () |
||||
|
{ |
||||
|
m68hc11_not_yet ("m68hc11_pop_frame"); |
||||
|
} |
||||
|
|
||||
|
/* Analyze the function prologue to find some information
|
||||
|
about the function: |
||||
|
- the PC of the first line (for m68hc11_skip_prologue) |
||||
|
- the offset of the previous frame saved address (from current frame) |
||||
|
- the soft registers which are pushed. */ |
||||
|
static void |
||||
|
m68hc11_guess_from_prologue (CORE_ADDR pc, CORE_ADDR* first_line, |
||||
|
int* frame_offset, int* pushed_regs) |
||||
|
{ |
||||
|
CORE_ADDR func_end; |
||||
|
unsigned char op0, op1, op2; |
||||
|
int add_sp_mode; |
||||
|
int sp_adjust; |
||||
|
int size; |
||||
|
int found_frame_point; |
||||
|
int found_load; |
||||
|
CORE_ADDR first_pc; |
||||
|
int reg_saved; |
||||
|
|
||||
|
first_pc = get_pc_function_start (pc); |
||||
|
size = 0; |
||||
|
|
||||
|
if (first_pc == 0) |
||||
|
{ |
||||
|
*frame_offset = 0; |
||||
|
*pushed_regs = 0; |
||||
|
*first_line = pc; |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
#define OP_PAGE2 (0x18) |
||||
|
#define OP_LDX (0xde) |
||||
|
#define OP_LDY (0xde) |
||||
|
#define OP_PSHX (0x3c) |
||||
|
#define OP_PSHY (0x3c) |
||||
|
#define OP_STS (0x9f) |
||||
|
#define OP_TSX (0x30) |
||||
|
#define OP_TSY (0x30) |
||||
|
#define OP_XGDX (0x8f) |
||||
|
#define OP_XGDY (0x8f) |
||||
|
#define OP_ADDD (0xc3) |
||||
|
#define OP_TXS (0x35) |
||||
|
#define OP_TYS (0x35) |
||||
|
|
||||
|
/* The 68hc11 stack is as follows:
|
||||
|
|
||||
|
|
||||
|
| | |
||||
|
+-----------+ |
||||
|
| | |
||||
|
| args | |
||||
|
| | |
||||
|
+-----------+ |
||||
|
| PC-return | |
||||
|
+-----------+ |
||||
|
| Old frame | |
||||
|
+-----------+ |
||||
|
| | |
||||
|
| Locals | |
||||
|
| | |
||||
|
+-----------+ <--- current frame |
||||
|
| | |
||||
|
|
||||
|
With most processors (like 68K) the previous frame can be computed |
||||
|
easily because it is always at a fixed offset (see link/unlink). |
||||
|
That is, locals are accessed with negative offsets, arguments are |
||||
|
accessed with positive ones. Since 68hc11 only supports offsets |
||||
|
in the range [0..255], the frame is defined at the bottom of |
||||
|
locals (see picture). |
||||
|
|
||||
|
The purpose of the analysis made here is to find out the size |
||||
|
of locals in this function. An alternative to this is to use |
||||
|
DWARF2 info. This would be better but I don't know how to |
||||
|
access dwarf2 debug from this function. |
||||
|
|
||||
|
Walk from the function entry point to the point where we save |
||||
|
the frame. While walking instructions, compute the size of bytes |
||||
|
which are pushed. This gives us the index to access the previous |
||||
|
frame. |
||||
|
|
||||
|
We limit the search to 128 bytes so that the algorithm is bounded |
||||
|
in case of random and wrong code. We also stop and abort if |
||||
|
we find an instruction which is not supposed to appear in the |
||||
|
prologue (as generated by gcc 2.95, 2.96). |
||||
|
*/ |
||||
|
pc = first_pc; |
||||
|
func_end = pc + 128; |
||||
|
add_sp_mode = 0; |
||||
|
found_frame_point = 0; |
||||
|
while (pc + 2 < func_end) |
||||
|
{ |
||||
|
op0 = read_memory_unsigned_integer (pc, 1); |
||||
|
op1 = read_memory_unsigned_integer (pc + 1, 1); |
||||
|
op2 = read_memory_unsigned_integer (pc + 2, 1); |
||||
|
|
||||
|
/* ldx *frame */ |
||||
|
if (op0 == OP_LDX && op1 == frame_index) |
||||
|
{ |
||||
|
pc += 2; |
||||
|
} |
||||
|
|
||||
|
/* ldy *frame */ |
||||
|
else if (op0 == OP_PAGE2 && op1 == OP_LDY && op2 == frame_index) |
||||
|
{ |
||||
|
pc += 3; |
||||
|
} |
||||
|
|
||||
|
/* pshx */ |
||||
|
else if (op0 == OP_PSHX) |
||||
|
{ |
||||
|
pc += 1; |
||||
|
size += 2; |
||||
|
} |
||||
|
|
||||
|
/* pshy */ |
||||
|
else if (op0 == OP_PAGE2 && op1 == OP_PSHX) |
||||
|
{ |
||||
|
pc += 2; |
||||
|
size += 2; |
||||
|
} |
||||
|
|
||||
|
/* sts *frame */ |
||||
|
else if (op0 == OP_STS && op1 == frame_index) |
||||
|
{ |
||||
|
found_frame_point = 1; |
||||
|
pc += 2; |
||||
|
break; |
||||
|
} |
||||
|
else if (op0 == OP_TSX && op1 == OP_XGDX) |
||||
|
{ |
||||
|
add_sp_mode = 1; |
||||
|
pc += 2; |
||||
|
} |
||||
|
else if (op0 == OP_PAGE2 && op1 == OP_TSY && op2 == OP_PAGE2) |
||||
|
{ |
||||
|
op0 = read_memory_unsigned_integer (pc + 3, 1); |
||||
|
if (op0 != OP_XGDY) |
||||
|
break; |
||||
|
|
||||
|
add_sp_mode = 2; |
||||
|
pc += 4; |
||||
|
} |
||||
|
else if (add_sp_mode && op0 == OP_ADDD) |
||||
|
{ |
||||
|
sp_adjust = read_memory_unsigned_integer (pc + 1, 2); |
||||
|
if (sp_adjust & 0x8000) |
||||
|
sp_adjust |= 0xffff0000L; |
||||
|
|
||||
|
sp_adjust = -sp_adjust; |
||||
|
add_sp_mode |= 4; |
||||
|
pc += 3; |
||||
|
} |
||||
|
else if (add_sp_mode == (1 | 4) && op0 == OP_XGDX |
||||
|
&& op1 == OP_TXS) |
||||
|
{ |
||||
|
size += sp_adjust; |
||||
|
pc += 2; |
||||
|
add_sp_mode = 0; |
||||
|
} |
||||
|
else if (add_sp_mode == (2 | 4) && op0 == OP_PAGE2 |
||||
|
&& op1 == OP_XGDY && op2 == OP_PAGE2) |
||||
|
{ |
||||
|
op0 = read_memory_unsigned_integer (pc + 3, 1); |
||||
|
if (op0 != OP_TYS) |
||||
|
break; |
||||
|
|
||||
|
size += sp_adjust; |
||||
|
pc += 4; |
||||
|
add_sp_mode = 0; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (found_frame_point == 0) |
||||
|
{ |
||||
|
*frame_offset = 0; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
*frame_offset = size; |
||||
|
} |
||||
|
|
||||
|
/* Now, look forward to see how many registers are pushed on the stack.
|
||||
|
We look only for soft registers so there must be a first LDX *REG |
||||
|
before a PSHX. */ |
||||
|
reg_saved = 0; |
||||
|
found_load = 0; |
||||
|
while (pc + 2 < func_end) |
||||
|
{ |
||||
|
op0 = read_memory_unsigned_integer (pc, 1); |
||||
|
op1 = read_memory_unsigned_integer (pc + 1, 1); |
||||
|
op2 = read_memory_unsigned_integer (pc + 2, 1); |
||||
|
if (op0 == OP_LDX && op1 > frame_index && op1 <= reg_last) |
||||
|
{ |
||||
|
found_load = 1; |
||||
|
pc += 2; |
||||
|
} |
||||
|
else if (op0 == OP_PAGE2 && op1 == OP_LDY |
||||
|
&& op2 > frame_index && op2 < reg_last) |
||||
|
{ |
||||
|
found_load = 1; |
||||
|
pc += 3; |
||||
|
} |
||||
|
else if (op0 == OP_PSHX) |
||||
|
{ |
||||
|
/* If there was no load, this is a push for a function call. */ |
||||
|
if (found_load == 0) |
||||
|
break; |
||||
|
|
||||
|
reg_saved += 2; |
||||
|
pc += 1; |
||||
|
found_load = 0; |
||||
|
} |
||||
|
else if (op0 == OP_PAGE2 && op1 == OP_PSHY) |
||||
|
{ |
||||
|
if (found_load == 0) |
||||
|
break; |
||||
|
|
||||
|
reg_saved += 2; |
||||
|
pc += 2; |
||||
|
found_load = 0; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
*pushed_regs = reg_saved; |
||||
|
*first_line = pc; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
CORE_ADDR |
||||
|
m68hc11_skip_prologue (CORE_ADDR pc) |
||||
|
{ |
||||
|
CORE_ADDR func_addr, func_end; |
||||
|
struct symtab_and_line sal; |
||||
|
int frame_offset; |
||||
|
int pushed_args; |
||||
|
|
||||
|
/* If we have line debugging information, then the end of the. */ |
||||
|
/* prologue should be the first assembly instruction of the
|
||||
|
first source line. */ |
||||
|
if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) |
||||
|
{ |
||||
|
sal = find_pc_line (func_addr, 0); |
||||
|
if (sal.end && sal.end < func_end) |
||||
|
return sal.end; |
||||
|
} |
||||
|
|
||||
|
m68hc11_guess_from_prologue (pc, &pc, &frame_offset, &pushed_args); |
||||
|
return pc; |
||||
|
} |
||||
|
|
||||
|
/* 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. |
||||
|
*/ |
||||
|
|
||||
|
CORE_ADDR |
||||
|
m68hc11_frame_chain (struct frame_info *frame) |
||||
|
{ |
||||
|
unsigned addr; |
||||
|
|
||||
|
if (frame->return_pc == 0 || inside_entry_file(frame->return_pc)) |
||||
|
return (CORE_ADDR)0; |
||||
|
|
||||
|
if (frame->frame == 0) |
||||
|
{ |
||||
|
return (CORE_ADDR) 0; |
||||
|
} |
||||
|
|
||||
|
addr = frame->frame + frame->size + 1 - 2; |
||||
|
addr = read_memory_unsigned_integer (addr, 2) & 0x0FFFF; |
||||
|
if (addr == 0) |
||||
|
{ |
||||
|
return (CORE_ADDR)0; |
||||
|
} |
||||
|
|
||||
|
return addr; |
||||
|
} |
||||
|
|
||||
|
/* 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 |
||||
|
m68hc11_frame_find_saved_regs (struct frame_info *fi, |
||||
|
struct frame_saved_regs *fsr) |
||||
|
{ |
||||
|
CORE_ADDR pc; |
||||
|
int saved; |
||||
|
|
||||
|
pc = fi->pc; |
||||
|
memset (fsr, 0, sizeof (*fsr)); |
||||
|
m68hc11_guess_from_prologue (pc, &pc, &fi->size, &saved); |
||||
|
} |
||||
|
|
||||
|
void |
||||
|
m68hc11_init_extra_frame_info (int fromleaf, struct frame_info *fi) |
||||
|
{ |
||||
|
unsigned addr; |
||||
|
struct frame_saved_regs dummy; |
||||
|
|
||||
|
m68hc11_frame_find_saved_regs (fi, &dummy); |
||||
|
|
||||
|
if (fromleaf) |
||||
|
{ |
||||
|
fi->return_pc = m68hc11_saved_pc_after_call (fi); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
addr = fi->frame + fi->size + 1; |
||||
|
fi->return_pc = read_memory_unsigned_integer (addr, 2) & 0x0ffff; |
||||
|
|
||||
|
#if 0 |
||||
|
printf ("Pc@0x%04x, FR 0x%04x, size %d, read ret @0x%04x -> 0x%04x\n", |
||||
|
fi->pc, |
||||
|
fi->frame, fi->size, |
||||
|
addr & 0x0ffff, |
||||
|
fi->return_pc); |
||||
|
#endif |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/* Same as 'info reg' but prints the registers in a different way. */ |
||||
|
static void |
||||
|
show_regs (char *args, int from_tty) |
||||
|
{ |
||||
|
int ccr = read_register (PSW_REGNUM); |
||||
|
int i; |
||||
|
|
||||
|
printf_filtered ("PC=%04x SP=%04x FP=%04x CCR=%02x %c%c%c%c%c%c%c%c\n", |
||||
|
read_register (PC_REGNUM), |
||||
|
read_register (SP_REGNUM), |
||||
|
read_register (FP_REGNUM), |
||||
|
ccr, |
||||
|
ccr & M6811_S_BIT ? 'S' : '-', |
||||
|
ccr & M6811_X_BIT ? 'X' : '-', |
||||
|
ccr & M6811_H_BIT ? 'H' : '-', |
||||
|
ccr & M6811_I_BIT ? 'I' : '-', |
||||
|
ccr & M6811_N_BIT ? 'N' : '-', |
||||
|
ccr & M6811_Z_BIT ? 'Z' : '-', |
||||
|
ccr & M6811_V_BIT ? 'V' : '-', |
||||
|
ccr & M6811_C_BIT ? 'C' : '-'); |
||||
|
|
||||
|
printf_filtered ("D=%04x IX=%04x IY=%04x\n", |
||||
|
read_register (D_REGNUM), |
||||
|
read_register (X_REGNUM), |
||||
|
read_register (Y_REGNUM)); |
||||
|
for (i = ZD1_REGNUM; i <= ZD32_REGNUM; i++) |
||||
|
{ |
||||
|
printf_filtered ("ZD%d=%04x", |
||||
|
i - ZD1_REGNUM + 1, |
||||
|
read_register (i)); |
||||
|
if (((i - ZD1_REGNUM) % 8) == 7) |
||||
|
printf_filtered ("\n"); |
||||
|
else |
||||
|
printf_filtered (" "); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
CORE_ADDR |
||||
|
m68hc11_fix_call_dummy (char *dummyname, |
||||
|
CORE_ADDR start_sp, |
||||
|
CORE_ADDR fun, |
||||
|
int nargs, |
||||
|
value_ptr *args, |
||||
|
struct type *type, |
||||
|
int gcc_p) |
||||
|
{ |
||||
|
m68hc11_not_yet ("m68hc11_fix_call_dummy"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
static void |
||||
|
m68hc11_pop_dummy_frame (struct frame_info *fi) |
||||
|
{ |
||||
|
m68hc11_not_yet ("m68hc11_pop_dummy_frame"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
CORE_ADDR |
||||
|
m68hc11_push_arguments (int nargs, |
||||
|
value_ptr *args, |
||||
|
CORE_ADDR sp, |
||||
|
int struct_return, |
||||
|
CORE_ADDR struct_addr) |
||||
|
{ |
||||
|
m68hc11_not_yet ("m68hc11_push_arguments"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
CORE_ADDR |
||||
|
m68hc11_call_dummy_address () |
||||
|
{ |
||||
|
m68hc11_not_yet ("m68hc11_call_dummy_address"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
/* Given a return value in `regbuf' with a type `valtype',
|
||||
|
extract and copy its value into `valbuf'. */ |
||||
|
|
||||
|
void |
||||
|
m68hc11_extract_return_value (struct type *valtype, |
||||
|
char *regbuf, |
||||
|
char *valbuf) |
||||
|
{ |
||||
|
m68hc11_not_yet ("m68hc11_extract_return_value"); |
||||
|
} |
||||
|
|
||||
|
void |
||||
|
_initialize_m68hc11_tdep () |
||||
|
{ |
||||
|
tm_print_insn = print_insn_m68hc11; |
||||
|
|
||||
|
add_com ("regs", class_vars, show_regs, "Print all registers"); |
||||
|
} |
||||
|
|
||||
Loading…
Reference in new issue