[binutils.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
                [email protected]
 */

#include "defs.h"
#include "frame.h"
#include "obstack.h"
#include "symtab.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_short (start_pc);
  /* Skip past all push insns */
  while (IS_PUSH_FP (w))
    {
      start_pc += 2;
      w = read_memory_short (start_pc);
    }

  /* 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];

  read_memory (memaddr, data, sizeof (data));
  return print_insn_h8300 (memaddr, data, stream);
}

/* 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;
     short *pword1;
{
  if (addr < lim + 8)
    {
      read_memory (addr, pword1, sizeof (*pword1));
      SWAP_TARGET_AND_HOST (pword1, sizeof (short));

      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;
  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 & ~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_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);
}

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_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 == 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	[email protected]
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"
256b4f37 SC	29	#undef NUM_REGS
	30	#define NUM_REGS 11
	31
1f46923f	32	#define UNSIGNED_SHORT(X) ((X) & 0xffff)
400943fb SC	33
400943fb SC	34	/* an easy to debug H8 stack frame looks like:
ec25d19b SC	35	0x6df6 push r6
	36	0x0d76 mov.w r7,r6
	37	0x6dfn push reg
	38	0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
	39	0x1957 sub.w r5,sp
400943fb SC	40
400943fb SC	41	*/
1f46923f	42
400943fb	43	#define IS_PUSH(x) ((x & 0xff00)==0x6d00)
ec25d19b	44	#define IS_PUSH_FP(x) (x == 0x6df6)
1f46923f SC	45	#define IS_MOVE_FP(x) (x == 0x0d76)
	46	#define IS_MOV_SP_FP(x) (x == 0x0d76)
	47	#define IS_SUB2_SP(x) (x==0x1b87)
	48	#define IS_MOVK_R5(x) (x==0x7905)
ec25d19b SC	49	#define IS_SUB_R5SP(x) (x==0x1957)
ec25d19b SC	50	CORE_ADDR examine_prologue ();
1f46923f	51
ec25d19b SC	52	void frame_find_saved_regs ();
	53	CORE_ADDR
	54	h8300_skip_prologue (start_pc)
	55	CORE_ADDR start_pc;
0a8f9d31	56
0a8f9d31	57	{
ec25d19b	58	short int w;
1f46923f	59
ec25d19b	60	w = read_memory_short (start_pc);
400943fb	61	/* Skip past all push insns */
ec25d19b SC	62	while (IS_PUSH_FP (w))
	63	{
	64	start_pc += 2;
	65	w = read_memory_short (start_pc);
	66	}
0a8f9d31	67
1f46923f	68	/* Skip past a move to FP */
ec25d19b SC	69	if (IS_MOVE_FP (w))
	70	{
	71	start_pc += 2;
	72	w = read_memory_short (start_pc);
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;
	80	w = read_memory_short (start_pc);
	81	}
	82	if (IS_SUB_R5SP (w))
	83	{
	84	start_pc += 2;
	85	w = read_memory_short (start_pc);
	86	}
	87	while (IS_SUB2_SP (w))
	88	{
	89	start_pc += 2;
	90	w = read_memory_short (start_pc);
	91	}
	92
	93	return start_pc;
	94
	95	}
1f46923f	96
400943fb	97	int
ec25d19b SC	98	print_insn (memaddr, stream)
	99	CORE_ADDR memaddr;
	100	FILE *stream;
0a8f9d31	101	{
400943fb	102	/* Nothing is bigger than 8 bytes */
ec25d19b SC	103	char data[8];
	104
	105	read_memory (memaddr, data, sizeof (data));
	106	return print_insn_h8300 (memaddr, data, stream);
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	{
	120
	121	frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
ec25d19b	122	return thisframe->fsr->regs[SP_REGNUM];
1f46923f SC	123	}
1f46923f SC	124
1f46923f SC	125	/* Put here the code to store, into a struct frame_saved_regs,
	126	the addresses of the saved registers of frame described by FRAME_INFO.
	127	This includes special registers such as pc and fp saved in special
	128	ways in the stack frame. sp is even more special:
	129	the address we return for it IS the sp for the next frame.
	130
	131	We cache the result of doing this in the frame_cache_obstack, since
	132	it is fairly expensive. */
	133
	134	void
	135	frame_find_saved_regs (fi, fsr)
	136	struct frame_info *fi;
	137	struct frame_saved_regs *fsr;
	138	{
	139	register CORE_ADDR next_addr;
	140	register CORE_ADDR *saved_regs;
	141	register int regnum;
	142	register struct frame_saved_regs *cache_fsr;
	143	extern struct obstack frame_cache_obstack;
	144	CORE_ADDR ip;
	145	struct symtab_and_line sal;
	146	CORE_ADDR limit;
	147
	148	if (!fi->fsr)
	149	{
	150	cache_fsr = (struct frame_saved_regs *)
ec25d19b SC	151	obstack_alloc (&frame_cache_obstack,
ec25d19b SC	152	sizeof (struct frame_saved_regs));
1f46923f	153	bzero (cache_fsr, sizeof (struct frame_saved_regs));
ec25d19b	154
1f46923f SC	155	fi->fsr = cache_fsr;
	156
	157	/* Find the start and end of the function prologue. If the PC
	158	is in the function prologue, we only consider the part that
	159	has executed already. */
ec25d19b	160
1f46923f SC	161	ip = get_pc_function_start (fi->pc);
1f46923f SC	162	sal = find_pc_line (ip, 0);
ec25d19b	163	limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
1f46923f SC	164
	165	/* This will fill in fields in fi as well as in cache_fsr. /
	166	examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
	167	}
	168
	169	if (fsr)
	170	fsr = fi->fsr;
	171	}
1f46923f SC	172
	173	/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
	174	is not the address of a valid instruction, the address of the next
	175	instruction beyond ADDR otherwise. *PWORD1 receives the first word
	176	of the instruction.*/
	177
1f46923f	178	CORE_ADDR
ec25d19b SC	179	NEXT_PROLOGUE_INSN (addr, lim, pword1)
	180	CORE_ADDR addr;
	181	CORE_ADDR lim;
	182	short *pword1;
1f46923f	183	{
ec25d19b SC	184	if (addr < lim + 8)
	185	{
	186	read_memory (addr, pword1, sizeof (*pword1));
	187	SWAP_TARGET_AND_HOST (pword1, sizeof (short));
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;
ec25d19b	215
1f46923f SC	216	register int src;
	217	register struct pic_prologue_code *pcode;
	218	INSN_WORD insn_word;
	219	int size, offset;
ec25d19b	220	unsigned int reg_save_depth = 2; /* Number of things pushed onto
1f46923f SC	221	stack, starts at 2, 'cause the
	222	PC is already there */
	223
	224	unsigned int auto_depth = 0; /* Number of bytes of autos */
1f46923f	225
256b4f37	226	char in_frame[8]; /* One for each reg */
1f46923f	227
256b4f37 SC	228	memset (in_frame, 1, 8);
256b4f37 SC	229	for (r = 0; r < 8; r++)
ec25d19b SC	230	{
	231	fsr->regs[r] = 0;
	232	}
	233	if (after_prolog_fp == 0)
	234	{
	235	after_prolog_fp = read_register (SP_REGNUM);
	236	}
	237	if (ip == 0 \|\| ip & ~0xffff)
	238	return 0;
1f46923f	239
ec25d19b	240	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
1f46923f	241
ec25d19b SC	242	/* Skip over any fp push instructions */
	243	fsr->regs[6] = after_prolog_fp;
	244	while (next_ip && IS_PUSH_FP (insn_word))
	245	{
	246	ip = next_ip;
1f46923f	247
ec25d19b SC	248	in_frame[insn_word & 0x7] = reg_save_depth;
	249	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	250	reg_save_depth += 2;
	251	}
1f46923f SC	252
1f46923f SC	253	/* Is this a move into the fp */
ec25d19b SC	254	if (next_ip && IS_MOV_SP_FP (insn_word))
	255	{
	256	ip = next_ip;
	257	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	258	have_fp = 1;
	259	}
1f46923f SC	260
	261	/* Skip over any stack adjustment, happens either with a number of
	262	sub#2,sp or a mov #x,r5 sub r5,sp */
	263
ec25d19b	264	if (next_ip && IS_SUB2_SP (insn_word))
1f46923f	265	{
ec25d19b SC	266	while (next_ip && IS_SUB2_SP (insn_word))
	267	{
	268	auto_depth += 2;
	269	ip = next_ip;
	270	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	271	}
1f46923f	272	}
ec25d19b SC	273	else
	274	{
	275	if (next_ip && IS_MOVK_R5 (insn_word))
	276	{
	277	ip = next_ip;
	278	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	279	auto_depth += insn_word;
	280
	281	next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word);
	282	auto_depth += insn_word;
	283
	284	}
	285	}
	286	/* Work out which regs are stored where */
	287	while (next_ip && IS_PUSH (insn_word))
1f46923f SC	288	{
1f46923f SC	289	ip = next_ip;
ec25d19b SC	290	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	291	fsr->regs[r] = after_prolog_fp + auto_depth;
	292	auto_depth += 2;
1f46923f	293	}
1f46923f	294
1f46923f	295	/* The args are always reffed based from the stack pointer */
ec25d19b	296	fi->args_pointer = after_prolog_fp;
1f46923f	297	/* Locals are always reffed based from the fp */
ec25d19b	298	fi->locals_pointer = after_prolog_fp;
1f46923f	299	/* The PC is at a known place */
ec25d19b	300	fi->from_pc = read_memory_short (after_prolog_fp + 2);
1f46923f SC	301
1f46923f SC	302	/* Rememeber any others too */
1f46923f	303	in_frame[PC_REGNUM] = 0;
ec25d19b SC	304
	305	if (have_fp)
	306	/* We keep the old FP in the SP spot */
	307	fsr->regs[SP_REGNUM] = (read_memory_short (fsr->regs[6]));
	308	else
	309	fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
	310
1f46923f SC	311	return (ip);
	312	}
	313
	314	void
	315	init_extra_frame_info (fromleaf, fi)
	316	int fromleaf;
	317	struct frame_info *fi;
	318	{
	319	fi->fsr = 0; /* Not yet allocated */
	320	fi->args_pointer = 0; /* Unknown */
	321	fi->locals_pointer = 0; /* Unknown */
	322	fi->from_pc = 0;
ec25d19b	323
1f46923f	324	}
ec25d19b	325
1f46923f SC	326	/* Return the saved PC from this frame.
	327
	328	If the frame has a memory copy of SRP_REGNUM, use that. If not,
	329	just use the register SRP_REGNUM itself. */
	330
	331	CORE_ADDR
	332	frame_saved_pc (frame)
ec25d19b	333	FRAME frame;
1f46923f SC	334
	335	{
	336	return frame->from_pc;
	337	}
	338
1f46923f SC	339	CORE_ADDR
	340	frame_locals_address (fi)
	341	struct frame_info *fi;
	342	{
ec25d19b SC	343	if (!fi->locals_pointer)
	344	{
	345	struct frame_saved_regs ignore;
	346
	347	get_frame_saved_regs (fi, &ignore);
1f46923f	348
ec25d19b	349	}
1f46923f SC	350	return fi->locals_pointer;
	351	}
	352
	353	/* Return the address of the argument block for the frame
	354	described by FI. Returns 0 if the address is unknown. */
	355
	356	CORE_ADDR
	357	frame_args_address (fi)
	358	struct frame_info *fi;
	359	{
ec25d19b SC	360	if (!fi->args_pointer)
	361	{
	362	struct frame_saved_regs ignore;
	363
	364	get_frame_saved_regs (fi, &ignore);
	365
	366	}
1f46923f	367
1f46923f SC	368	return fi->args_pointer;
	369	}
	370
ec25d19b SC	371	void
ec25d19b SC	372	h8300_pop_frame ()
1f46923f SC	373	{
	374	unsigned regnum;
	375	struct frame_saved_regs fsr;
	376	struct frame_info *fi;
	377
ec25d19b	378	FRAME frame = get_current_frame ();
1f46923f	379
ec25d19b SC	380	fi = get_frame_info (frame);
	381	get_frame_saved_regs (fi, &fsr);
	382
256b4f37	383	for (regnum = 0; regnum < 8; regnum++)
1f46923f	384	{
ec25d19b SC	385	if (fsr.regs[regnum])
	386	{
	387	write_register (regnum, read_memory_short (fsr.regs[regnum]));
	388	}
	389
	390	flush_cached_frames ();
	391	set_current_frame (create_new_frame (read_register (FP_REGNUM),
	392	read_pc ()));
	393
1f46923f	394	}
1f46923f SC	395
1f46923f SC	396	}
ec25d19b SC	397
	398	void
	399	print_register_hook (regno)
	400	{
	401	if (regno == 8)
	402	{
	403	/* CCR register */
	404
	405	int C, Z, N, V;
	406	unsigned char b[2];
	407	unsigned char l;
	408
	409	read_relative_register_raw_bytes (regno, b);
	410	l = b[1];
	411	printf ("\t");
	412	printf ("I-%d - ", (l & 0x80) != 0);
	413	printf ("H-%d - ", (l & 0x20) != 0);
	414	N = (l & 0x8) != 0;
	415	Z = (l & 0x4) != 0;
	416	V = (l & 0x2) != 0;
	417	C = (l & 0x1) != 0;
	418	printf ("N-%d ", N);
	419	printf ("Z-%d ", Z);
	420	printf ("V-%d ", V);
	421	printf ("C-%d ", C);
	422	if ((C \| Z) == 0)
	423	printf ("u> ");
	424	if ((C \| Z) == 1)
	425	printf ("u<= ");
	426	if ((C == 0))
	427	printf ("u>= ");
	428	if (C == 1)
	429	printf ("u< ");
	430	if (Z == 0)
	431	printf ("!= ");
	432	if (Z == 1)
	433	printf ("== ");
	434	if ((N ^ V) == 0)
	435	printf (">= ");
	436	if ((N ^ V) == 1)
	437	printf ("< ");
	438	if ((Z \| (N ^ V)) == 0)
	439	printf ("> ");
	440	if ((Z \| (N ^ V)) == 1)
	441	printf ("<= ");
	442	}
	443	}