[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 */
b1d0b161	306	fsr->regs[SP_REGNUM] = read_memory_unsigned_integer (fsr->regs[6], BINWORD);
ec25d19b SC	307	else
	308	fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
	309
1f46923f SC	310	return (ip);
	311	}
	312
	313	void
	314	init_extra_frame_info (fromleaf, fi)
	315	int fromleaf;
	316	struct frame_info *fi;
	317	{
	318	fi->fsr = 0; /* Not yet allocated */
	319	fi->args_pointer = 0; /* Unknown */
	320	fi->locals_pointer = 0; /* Unknown */
	321	fi->from_pc = 0;
ec25d19b	322
1f46923f	323	}
ec25d19b	324
1f46923f SC	325	/* Return the saved PC from this frame.
	326
	327	If the frame has a memory copy of SRP_REGNUM, use that. If not,
	328	just use the register SRP_REGNUM itself. */
	329
	330	CORE_ADDR
	331	frame_saved_pc (frame)
ec25d19b	332	FRAME frame;
1f46923f SC	333
	334	{
	335	return frame->from_pc;
	336	}
	337
1f46923f SC	338	CORE_ADDR
	339	frame_locals_address (fi)
	340	struct frame_info *fi;
	341	{
ec25d19b SC	342	if (!fi->locals_pointer)
	343	{
	344	struct frame_saved_regs ignore;
	345
	346	get_frame_saved_regs (fi, &ignore);
1f46923f	347
ec25d19b	348	}
1f46923f SC	349	return fi->locals_pointer;
	350	}
	351
	352	/* Return the address of the argument block for the frame
	353	described by FI. Returns 0 if the address is unknown. */
	354
	355	CORE_ADDR
	356	frame_args_address (fi)
	357	struct frame_info *fi;
	358	{
ec25d19b SC	359	if (!fi->args_pointer)
	360	{
	361	struct frame_saved_regs ignore;
	362
	363	get_frame_saved_regs (fi, &ignore);
	364
	365	}
1f46923f	366
1f46923f SC	367	return fi->args_pointer;
	368	}
	369
ec25d19b SC	370	void
ec25d19b SC	371	h8300_pop_frame ()
1f46923f SC	372	{
	373	unsigned regnum;
	374	struct frame_saved_regs fsr;
	375	struct frame_info *fi;
	376
ec25d19b	377	FRAME frame = get_current_frame ();
1f46923f	378
ec25d19b SC	379	fi = get_frame_info (frame);
	380	get_frame_saved_regs (fi, &fsr);
	381
256b4f37	382	for (regnum = 0; regnum < 8; regnum++)
1f46923f	383	{
ec25d19b SC	384	if (fsr.regs[regnum])
ec25d19b SC	385	{
df14b38b	386	write_register (regnum, read_memory_integer(fsr.regs[regnum]), BINWORD);
ec25d19b SC	387	}
	388
	389	flush_cached_frames ();
	390	set_current_frame (create_new_frame (read_register (FP_REGNUM),
	391	read_pc ()));
	392
1f46923f	393	}
1f46923f SC	394
1f46923f SC	395	}
ec25d19b SC	396
	397	void
	398	print_register_hook (regno)
	399	{
	400	if (regno == 8)
	401	{
	402	/* CCR register */
	403
	404	int C, Z, N, V;
	405	unsigned char b[2];
	406	unsigned char l;
	407
	408	read_relative_register_raw_bytes (regno, b);
	409	l = b[1];
	410	printf ("\t");
	411	printf ("I-%d - ", (l & 0x80) != 0);
	412	printf ("H-%d - ", (l & 0x20) != 0);
	413	N = (l & 0x8) != 0;
	414	Z = (l & 0x4) != 0;
	415	V = (l & 0x2) != 0;
	416	C = (l & 0x1) != 0;
	417	printf ("N-%d ", N);
	418	printf ("Z-%d ", Z);
	419	printf ("V-%d ", V);
	420	printf ("C-%d ", C);
	421	if ((C \| Z) == 0)
	422	printf ("u> ");
	423	if ((C \| Z) == 1)
	424	printf ("u<= ");
	425	if ((C == 0))
	426	printf ("u>= ");
	427	if (C == 1)
	428	printf ("u< ");
	429	if (Z == 0)
	430	printf ("!= ");
	431	if (Z == 1)
	432	printf ("== ");
	433	if ((N ^ V) == 0)
	434	printf (">= ");
	435	if ((N ^ V) == 1)
	436	printf ("< ");
	437	if ((Z \| (N ^ V)) == 0)
	438	printf ("> ");
	439	if ((Z \| (N ^ V)) == 1)
	440	printf ("<= ");
	441	}
	442	}