[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);
  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;
     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[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 & ~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
0a8f9d31	58	{
ec25d19b	59	short int w;
1f46923f	60
df14b38b	61	w = read_memory_unsigned_integer (start_pc, 2);
400943fb	62	/* Skip past all push insns */
ec25d19b SC	63	while (IS_PUSH_FP (w))
	64	{
	65	start_pc += 2;
df14b38b	66	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b	67	}
0a8f9d31	68
1f46923f	69	/* Skip past a move to FP */
ec25d19b SC	70	if (IS_MOVE_FP (w))
	71	{
	72	start_pc += 2;
df14b38b	73	w = read_memory_unsigned_integer (start_pc, 2);
1f46923f SC	74	}
1f46923f SC	75
ec25d19b	76	/* Skip the stack adjust */
0a8f9d31	77
ec25d19b SC	78	if (IS_MOVK_R5 (w))
	79	{
	80	start_pc += 2;
df14b38b	81	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b SC	82	}
	83	if (IS_SUB_R5SP (w))
	84	{
	85	start_pc += 2;
df14b38b	86	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b SC	87	}
	88	while (IS_SUB2_SP (w))
	89	{
	90	start_pc += 2;
df14b38b	91	w = read_memory_unsigned_integer (start_pc, 2);
ec25d19b SC	92	}
	93
	94	return start_pc;
	95
	96	}
1f46923f	97
400943fb	98	int
ec25d19b SC	99	print_insn (memaddr, stream)
	100	CORE_ADDR memaddr;
	101	FILE *stream;
0a8f9d31	102	{
df14b38b SC	103	disassemble_info info;
	104	GDB_INIT_DISASSEMBLE_INFO(info, stream);
	105	return print_insn_h8300 (memaddr, &info);
0a8f9d31	106	}
ec25d19b	107
1f46923f SC	108	/* Given a GDB frame, determine the address of the calling function's frame.
	109	This will be used to create a new GDB frame struct, and then
	110	INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
	111
	112	For us, the frame address is its stack pointer value, so we look up
	113	the function prologue to determine the caller's sp value, and return it. */
	114
	115	FRAME_ADDR
	116	FRAME_CHAIN (thisframe)
	117	FRAME thisframe;
	118	{
	119
	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;
	181	short *pword1;
1f46923f	182	{
ec25d19b SC	183	if (addr < lim + 8)
	184	{
	185	read_memory (addr, pword1, sizeof (*pword1));
	186	SWAP_TARGET_AND_HOST (pword1, sizeof (short));
1f46923f	187
ec25d19b SC	188	return addr + 2;
ec25d19b SC	189	}
1f46923f	190	return 0;
1f46923f SC	191	}
	192
	193	/* Examine the prologue of a function. `ip' points to the first instruction.
ec25d19b	194	`limit' is the limit of the prologue (e.g. the addr of the first
1f46923f	195	linenumber, or perhaps the program counter if we're stepping through).
ec25d19b	196	`frame_sp' is the stack pointer value in use in this frame.
1f46923f	197	`fsr' is a pointer to a frame_saved_regs structure into which we put
ec25d19b	198	info about the registers saved by this frame.
1f46923f SC	199	`fi' is a struct frame_info pointer; we fill in various fields in it
	200	to reflect the offsets of the arg pointer and the locals pointer. */
	201
1f46923f SC	202	static CORE_ADDR
	203	examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
	204	register CORE_ADDR ip;
	205	register CORE_ADDR limit;
	206	FRAME_ADDR after_prolog_fp;
	207	struct frame_saved_regs *fsr;
	208	struct frame_info *fi;
	209	{
	210	register CORE_ADDR next_ip;
	211	int r;
	212	int i;
	213	int have_fp = 0;
ec25d19b	214
1f46923f SC	215	register int src;
	216	register struct pic_prologue_code *pcode;
	217	INSN_WORD insn_word;
	218	int size, offset;
ddf30c37	219	unsigned int reg_save_depth = 2; /* Number of things pushed onto
1f46923f SC	220	stack, starts at 2, 'cause the
	221	PC is already there */
	222
	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	}
	236	if (ip == 0 \|\| ip & ~0xffff)
	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;
	282
	283	}
	284	}
	285	/* Work out which regs are stored where */
	286	while (next_ip && IS_PUSH (insn_word))
1f46923f SC	287	{
1f46923f SC	288	ip = next_ip;
ec25d19b SC	289	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
	290	fsr->regs[r] = after_prolog_fp + auto_depth;
	291	auto_depth += 2;
1f46923f	292	}
1f46923f	293
1f46923f	294	/* The args are always reffed based from the stack pointer */
ec25d19b	295	fi->args_pointer = after_prolog_fp;
1f46923f	296	/* Locals are always reffed based from the fp */
ec25d19b	297	fi->locals_pointer = after_prolog_fp;
1f46923f	298	/* The PC is at a known place */
df14b38b	299	fi->from_pc = read_memory_unsigned_integer (after_prolog_fp + 2, BINWORD);
1f46923f SC	300
1f46923f SC	301	/* Rememeber any others too */
1f46923f	302	in_frame[PC_REGNUM] = 0;
ec25d19b SC	303
	304	if (have_fp)
	305	/* We keep the old FP in the SP spot */
df14b38b SC	306	fsr->regs[SP_REGNUM] = (read_memory_unsigned_integer
df14b38b SC	307	(fsr->regs[6]), BINWORD);
ec25d19b SC	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])
ec25d19b SC	386	{
df14b38b	387	write_register (regnum, read_memory_integer(fsr.regs[regnum]), BINWORD);
ec25d19b SC	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	}