[deliverable/binutils-gdb.git] / gdb / h8300-tdep.c

/* Target-machine dependent code for Hitachi H8/300, for GDB.
   Copyright (C) 1988, 1990, 1991 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 <dis-asm.h>
#undef NUM_REGS
#define NUM_REGS 11

#define UNSIGNED_SHORT(X) ((X) & 0xffff)

/* 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_PUSH_FP(x) (x == 0x6df6)
#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)
CORE_ADDR examine_prologue ();

void frame_find_saved_regs ();
CORE_ADDR 
h8300_skip_prologue (start_pc)
     CORE_ADDR start_pc;
{
  short int w;

  w = read_memory_unsigned_integer (start_pc, 2);
  /* Skip past all push insns */
  while (IS_PUSH_FP (w))
    {
      start_pc += 2;
      w = read_memory_unsigned_integer (start_pc, 2);
    }

  /* Skip past a move to FP */
  if (IS_MOVE_FP (w))
    {
      start_pc += 2;
      w = read_memory_unsigned_integer (start_pc, 2);
    }

  /* Skip the stack adjust */

  if (IS_MOVK_R5 (w))
    {
      start_pc += 2;
      w = read_memory_unsigned_integer (start_pc, 2);
    }
  if (IS_SUB_R5SP (w))
    {
      start_pc += 2;
      w = read_memory_unsigned_integer (start_pc, 2);
    }
  while (IS_SUB2_SP (w))
    {
      start_pc += 2;
      w = read_memory_unsigned_integer (start_pc, 2);
    }

  return start_pc;
}

int
print_insn (memaddr, stream)
     CORE_ADDR memaddr;
     FILE *stream;
{
  disassemble_info info;
  GDB_INIT_DISASSEMBLE_INFO(info, stream);
  if (HMODE)
    return print_insn_h8300h (memaddr, &info);
  else
    return print_insn_h8300 (memaddr, &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;
{
  frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
  return thisframe->fsr->regs[SP_REGNUM];
}

/* 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.  */

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;
}

/* 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;
     INSN_WORD *pword1;
{
  char buf[2];
  if (addr < lim + 8)
    {
      read_memory (addr, buf, 2);
      *pword1 = extract_signed_integer (buf, 2);

      return addr + 2;
    }
  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.  */

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;
  INSN_WORD insn_word;
  int size, offset;
  /* Number of things pushed onto stack, starts at 2/4, 'cause the
     PC is already there */
  unsigned int reg_save_depth = HMODE ? 4 : 2;

  unsigned int auto_depth = 0;	/* Number of bytes of autos */

  char in_frame[11];		/* One for each reg */

  memset (in_frame, 1, 11);
  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 & (HMODE ? ~0xffff : ~0xffff))
    return 0;

  next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);

  /* Skip over any fp push instructions */
  fsr->regs[6] = after_prolog_fp;
  while (next_ip && IS_PUSH_FP (insn_word))
    {
      ip = next_ip;

      in_frame[insn_word & 0x7] = reg_save_depth;
      next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
      reg_save_depth += 2;
    }

  /* 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_unsigned_integer (after_prolog_fp + 2, BINWORD);

  /* 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_unsigned_integer (fsr->regs[6], BINWORD);
  else
    fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;

  return (ip);
}

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;
}

/* Return the saved PC from this frame.

   If the frame has a memory copy of SRP_REGNUM, use that.  If not,
   just use the register SRP_REGNUM itself.  */

CORE_ADDR
frame_saved_pc (frame)
     FRAME frame;
{
  return frame->from_pc;
}

CORE_ADDR
frame_locals_address (fi)
     struct frame_info *fi;
{
  if (!fi->locals_pointer)
    {
      struct frame_saved_regs ignore;

      get_frame_saved_regs (fi, &ignore);

    }
  return fi->locals_pointer;
}

/* 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;
{
  if (!fi->args_pointer)
    {
      struct frame_saved_regs ignore;

      get_frame_saved_regs (fi, &ignore);

    }

  return fi->args_pointer;
}

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_integer(fsr.regs[regnum]), BINWORD);
	}

      flush_cached_frames ();
      set_current_frame (create_new_frame (read_register (FP_REGNUM),
					   read_pc ()));
    }
}

void
print_register_hook (regno)
{
  if (regno == 8)
    {
      /* 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);
      printf ("H-%d - ", (l & 0x20) != 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 ("<= ");
    }
}
Commit	Line	Data
1f46923f SC	1	/* Target-machine dependent code for Hitachi H8/300, for GDB.
	2	Copyright (C) 1988, 1990, 1991 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
ec25d19b	20	/*
1f46923f	21	Contributed by Steve Chamberlain
ec25d19b	22	sac@cygnus.com
1f46923f SC	23	*/
1f46923f SC	24
400943fb	25	#include "defs.h"
1f46923f SC	26	#include "frame.h"
	27	#include "obstack.h"
	28	#include "symtab.h"
df14b38b	29	#include <dis-asm.h>
256b4f37 SC	30	#undef NUM_REGS
	31	#define NUM_REGS 11
	32
1f46923f	33	#define UNSIGNED_SHORT(X) ((X) & 0xffff)
400943fb SC	34
400943fb SC	35	/* an easy to debug H8 stack frame looks like:
ec25d19b SC	36	0x6df6 push r6
	37	0x0d76 mov.w r7,r6
	38	0x6dfn push reg
	39	0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
	40	0x1957 sub.w r5,sp
400943fb SC	41
400943fb SC	42	*/
1f46923f	43
400943fb	44	#define IS_PUSH(x) ((x & 0xff00)==0x6d00)
ec25d19b	45	#define IS_PUSH_FP(x) (x == 0x6df6)
1f46923f SC	46	#define IS_MOVE_FP(x) (x == 0x0d76)
	47	#define IS_MOV_SP_FP(x) (x == 0x0d76)
	48	#define IS_SUB2_SP(x) (x==0x1b87)
	49	#define IS_MOVK_R5(x) (x==0x7905)
ec25d19b SC	50	#define IS_SUB_R5SP(x) (x==0x1957)
ec25d19b SC	51	CORE_ADDR examine_prologue ();
1f46923f	52
ec25d19b SC	53	void frame_find_saved_regs ();
	54	CORE_ADDR
	55	h8300_skip_prologue (start_pc)
	56	CORE_ADDR start_pc;
0a8f9d31	57	{
ec25d19b	58	short int w;
1f46923f	59
df14b38b	60	w = read_memory_unsigned_integer (start_pc, 2);
400943fb	61	/* Skip past all push insns */
ec25d19b SC	62	while (IS_PUSH_FP (w))
	63	{
	64	start_pc += 2;
df14b38b	65	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b	66	}
0a8f9d31	67
1f46923f	68	/* Skip past a move to FP */
ec25d19b SC	69	if (IS_MOVE_FP (w))
	70	{
	71	start_pc += 2;
df14b38b	72	w = read_memory_unsigned_integer (start_pc, 2);
1f46923f SC	73	}
1f46923f SC	74
ec25d19b	75	/* Skip the stack adjust */
0a8f9d31	76
ec25d19b SC	77	if (IS_MOVK_R5 (w))
	78	{
	79	start_pc += 2;
df14b38b	80	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b SC	81	}
	82	if (IS_SUB_R5SP (w))
	83	{
	84	start_pc += 2;
df14b38b	85	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b SC	86	}
	87	while (IS_SUB2_SP (w))
	88	{
	89	start_pc += 2;
df14b38b	90	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b SC	91	}
	92
	93	return start_pc;
ec25d19b	94	}
1f46923f	95
400943fb	96	int
ec25d19b SC	97	print_insn (memaddr, stream)
	98	CORE_ADDR memaddr;
	99	FILE *stream;
0a8f9d31	100	{
df14b38b SC	101	disassemble_info info;
df14b38b SC	102	GDB_INIT_DISASSEMBLE_INFO(info, stream);
d0414a11 DE	103	if (HMODE)
	104	return print_insn_h8300h (memaddr, &info);
	105	else
	106	return print_insn_h8300 (memaddr, &info);
0a8f9d31	107	}
ec25d19b	108
1f46923f SC	109	/* Given a GDB frame, determine the address of the calling function's frame.
	110	This will be used to create a new GDB frame struct, and then
	111	INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
	112
	113	For us, the frame address is its stack pointer value, so we look up
	114	the function prologue to determine the caller's sp value, and return it. */
	115
	116	FRAME_ADDR
	117	FRAME_CHAIN (thisframe)
	118	FRAME thisframe;
	119	{
1f46923f	120	frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
ec25d19b	121	return thisframe->fsr->regs[SP_REGNUM];
1f46923f SC	122	}
1f46923f SC	123
1f46923f SC	124	/* Put here the code to store, into a struct frame_saved_regs,
	125	the addresses of the saved registers of frame described by FRAME_INFO.
	126	This includes special registers such as pc and fp saved in special
	127	ways in the stack frame. sp is even more special:
	128	the address we return for it IS the sp for the next frame.
	129
	130	We cache the result of doing this in the frame_cache_obstack, since
	131	it is fairly expensive. */
	132
	133	void
	134	frame_find_saved_regs (fi, fsr)
	135	struct frame_info *fi;
	136	struct frame_saved_regs *fsr;
	137	{
	138	register CORE_ADDR next_addr;
	139	register CORE_ADDR *saved_regs;
	140	register int regnum;
	141	register struct frame_saved_regs *cache_fsr;
	142	extern struct obstack frame_cache_obstack;
	143	CORE_ADDR ip;
	144	struct symtab_and_line sal;
	145	CORE_ADDR limit;
	146
	147	if (!fi->fsr)
	148	{
	149	cache_fsr = (struct frame_saved_regs *)
ec25d19b SC	150	obstack_alloc (&frame_cache_obstack,
ec25d19b SC	151	sizeof (struct frame_saved_regs));
1f46923f	152	bzero (cache_fsr, sizeof (struct frame_saved_regs));
ec25d19b	153
1f46923f SC	154	fi->fsr = cache_fsr;
	155
	156	/* Find the start and end of the function prologue. If the PC
	157	is in the function prologue, we only consider the part that
	158	has executed already. */
ec25d19b	159
1f46923f SC	160	ip = get_pc_function_start (fi->pc);
1f46923f SC	161	sal = find_pc_line (ip, 0);
ec25d19b	162	limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
1f46923f SC	163
	164	/* This will fill in fields in fi as well as in cache_fsr. /
	165	examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
	166	}
	167
	168	if (fsr)
	169	fsr = fi->fsr;
	170	}
1f46923f SC	171
	172	/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
	173	is not the address of a valid instruction, the address of the next
	174	instruction beyond ADDR otherwise. *PWORD1 receives the first word
	175	of the instruction.*/
	176
1f46923f	177	CORE_ADDR
ec25d19b SC	178	NEXT_PROLOGUE_INSN (addr, lim, pword1)
	179	CORE_ADDR addr;
	180	CORE_ADDR lim;
58e49e21	181	INSN_WORD *pword1;
1f46923f	182	{
34df79fc	183	char buf[2];
ec25d19b SC	184	if (addr < lim + 8)
ec25d19b SC	185	{
34df79fc JK	186	read_memory (addr, buf, 2);
34df79fc JK	187	*pword1 = extract_signed_integer (buf, 2);
1f46923f	188
ec25d19b SC	189	return addr + 2;
ec25d19b SC	190	}
1f46923f	191	return 0;
1f46923f SC	192	}
	193
	194	/* Examine the prologue of a function. `ip' points to the first instruction.
ec25d19b	195	`limit' is the limit of the prologue (e.g. the addr of the first
1f46923f	196	linenumber, or perhaps the program counter if we're stepping through).
ec25d19b	197	`frame_sp' is the stack pointer value in use in this frame.
1f46923f	198	`fsr' is a pointer to a frame_saved_regs structure into which we put
ec25d19b	199	info about the registers saved by this frame.
1f46923f SC	200	`fi' is a struct frame_info pointer; we fill in various fields in it
	201	to reflect the offsets of the arg pointer and the locals pointer. */
	202
1f46923f SC	203	static CORE_ADDR
	204	examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
	205	register CORE_ADDR ip;
	206	register CORE_ADDR limit;
	207	FRAME_ADDR after_prolog_fp;
	208	struct frame_saved_regs *fsr;
	209	struct frame_info *fi;
	210	{
	211	register CORE_ADDR next_ip;
	212	int r;
	213	int i;
	214	int have_fp = 0;
1f46923f SC	215	register int src;
	216	register struct pic_prologue_code *pcode;
	217	INSN_WORD insn_word;
	218	int size, offset;
d0414a11 DE	219	/* Number of things pushed onto stack, starts at 2/4, 'cause the
	220	PC is already there */
	221	unsigned int reg_save_depth = HMODE ? 4 : 2;
1f46923f SC	222
1f46923f SC	223	unsigned int auto_depth = 0; /* Number of bytes of autos */
1f46923f	224
ddf30c37	225	char in_frame[11]; /* One for each reg */
1f46923f	226
ddf30c37	227	memset (in_frame, 1, 11);
256b4f37	228	for (r = 0; r < 8; r++)
ec25d19b SC	229	{
	230	fsr->regs[r] = 0;
	231	}
	232	if (after_prolog_fp == 0)
	233	{
	234	after_prolog_fp = read_register (SP_REGNUM);
	235	}
d0414a11	236	if (ip == 0 \|\| ip & (HMODE ? ~0xffff : ~0xffff))
ec25d19b	237	return 0;
1f46923f	238
ec25d19b	239	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
1f46923f	240
ec25d19b SC	241	/* Skip over any fp push instructions */
	242	fsr->regs[6] = after_prolog_fp;
	243	while (next_ip && IS_PUSH_FP (insn_word))
	244	{
	245	ip = next_ip;
1f46923f	246
ec25d19b SC	247	in_frame[insn_word & 0x7] = reg_save_depth;
	248	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	249	reg_save_depth += 2;
	250	}
1f46923f SC	251
1f46923f SC	252	/* Is this a move into the fp */
ec25d19b SC	253	if (next_ip && IS_MOV_SP_FP (insn_word))
	254	{
	255	ip = next_ip;
	256	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	257	have_fp = 1;
	258	}
1f46923f SC	259
	260	/* Skip over any stack adjustment, happens either with a number of
	261	sub#2,sp or a mov #x,r5 sub r5,sp */
	262
ec25d19b	263	if (next_ip && IS_SUB2_SP (insn_word))
1f46923f	264	{
ec25d19b SC	265	while (next_ip && IS_SUB2_SP (insn_word))
	266	{
	267	auto_depth += 2;
	268	ip = next_ip;
	269	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	270	}
1f46923f	271	}
ec25d19b SC	272	else
	273	{
	274	if (next_ip && IS_MOVK_R5 (insn_word))
	275	{
	276	ip = next_ip;
	277	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	278	auto_depth += insn_word;
	279
	280	next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word);
	281	auto_depth += insn_word;
ec25d19b SC	282	}
	283	}
	284	/* Work out which regs are stored where */
	285	while (next_ip && IS_PUSH (insn_word))
1f46923f SC	286	{
1f46923f SC	287	ip = next_ip;
ec25d19b SC	288	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	289	fsr->regs[r] = after_prolog_fp + auto_depth;
	290	auto_depth += 2;
1f46923f	291	}
1f46923f	292
1f46923f	293	/* The args are always reffed based from the stack pointer */
ec25d19b	294	fi->args_pointer = after_prolog_fp;
1f46923f	295	/* Locals are always reffed based from the fp */
ec25d19b	296	fi->locals_pointer = after_prolog_fp;
1f46923f	297	/* The PC is at a known place */
df14b38b	298	fi->from_pc = read_memory_unsigned_integer (after_prolog_fp + 2, BINWORD);
1f46923f SC	299
1f46923f SC	300	/* Rememeber any others too */
1f46923f	301	in_frame[PC_REGNUM] = 0;
ec25d19b SC	302
	303	if (have_fp)
	304	/* We keep the old FP in the SP spot */
b1d0b161	305	fsr->regs[SP_REGNUM] = read_memory_unsigned_integer (fsr->regs[6], BINWORD);
ec25d19b SC	306	else
	307	fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
	308
1f46923f SC	309	return (ip);
	310	}
	311
	312	void
	313	init_extra_frame_info (fromleaf, fi)
	314	int fromleaf;
	315	struct frame_info *fi;
	316	{
	317	fi->fsr = 0; /* Not yet allocated */
	318	fi->args_pointer = 0; /* Unknown */
	319	fi->locals_pointer = 0; /* Unknown */
	320	fi->from_pc = 0;
1f46923f	321	}
ec25d19b	322
1f46923f SC	323	/* Return the saved PC from this frame.
	324
	325	If the frame has a memory copy of SRP_REGNUM, use that. If not,
	326	just use the register SRP_REGNUM itself. */
	327
	328	CORE_ADDR
	329	frame_saved_pc (frame)
ec25d19b	330	FRAME frame;
1f46923f SC	331	{
	332	return frame->from_pc;
	333	}
	334
1f46923f SC	335	CORE_ADDR
	336	frame_locals_address (fi)
	337	struct frame_info *fi;
	338	{
ec25d19b SC	339	if (!fi->locals_pointer)
	340	{
	341	struct frame_saved_regs ignore;
	342
	343	get_frame_saved_regs (fi, &ignore);
1f46923f	344
ec25d19b	345	}
1f46923f SC	346	return fi->locals_pointer;
	347	}
	348
	349	/* Return the address of the argument block for the frame
	350	described by FI. Returns 0 if the address is unknown. */
	351
	352	CORE_ADDR
	353	frame_args_address (fi)
	354	struct frame_info *fi;
	355	{
ec25d19b SC	356	if (!fi->args_pointer)
	357	{
	358	struct frame_saved_regs ignore;
	359
	360	get_frame_saved_regs (fi, &ignore);
	361
	362	}
1f46923f	363
1f46923f SC	364	return fi->args_pointer;
	365	}
	366
ec25d19b SC	367	void
ec25d19b SC	368	h8300_pop_frame ()
1f46923f SC	369	{
	370	unsigned regnum;
	371	struct frame_saved_regs fsr;
	372	struct frame_info *fi;
	373
ec25d19b	374	FRAME frame = get_current_frame ();
1f46923f	375
ec25d19b SC	376	fi = get_frame_info (frame);
	377	get_frame_saved_regs (fi, &fsr);
	378
256b4f37	379	for (regnum = 0; regnum < 8; regnum++)
1f46923f	380	{
ec25d19b SC	381	if (fsr.regs[regnum])
ec25d19b SC	382	{
df14b38b	383	write_register (regnum, read_memory_integer(fsr.regs[regnum]), BINWORD);
ec25d19b SC	384	}
	385
	386	flush_cached_frames ();
	387	set_current_frame (create_new_frame (read_register (FP_REGNUM),
	388	read_pc ()));
1f46923f	389	}
1f46923f	390	}
ec25d19b SC	391
	392	void
	393	print_register_hook (regno)
	394	{
	395	if (regno == 8)
	396	{
	397	/* CCR register */
	398
	399	int C, Z, N, V;
	400	unsigned char b[2];
	401	unsigned char l;
	402
	403	read_relative_register_raw_bytes (regno, b);
	404	l = b[1];
	405	printf ("\t");
	406	printf ("I-%d - ", (l & 0x80) != 0);
	407	printf ("H-%d - ", (l & 0x20) != 0);
	408	N = (l & 0x8) != 0;
	409	Z = (l & 0x4) != 0;
	410	V = (l & 0x2) != 0;
	411	C = (l & 0x1) != 0;
	412	printf ("N-%d ", N);
	413	printf ("Z-%d ", Z);
	414	printf ("V-%d ", V);
	415	printf ("C-%d ", C);
	416	if ((C \| Z) == 0)
	417	printf ("u> ");
	418	if ((C \| Z) == 1)
	419	printf ("u<= ");
	420	if ((C == 0))
	421	printf ("u>= ");
	422	if (C == 1)
	423	printf ("u< ");
	424	if (Z == 0)
	425	printf ("!= ");
	426	if (Z == 1)
	427	printf ("== ");
	428	if ((N ^ V) == 0)
	429	printf (">= ");
	430	if ((N ^ V) == 1)
	431	printf ("< ");
	432	if ((Z \| (N ^ V)) == 0)
	433	printf ("> ");
	434	if ((Z \| (N ^ V)) == 1)
	435	printf ("<= ");
	436	}
	437	}