[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"
#define UNSIGNED_SHORT(X) ((X) & 0xffff)

/* an easy to debug H8 stack frame looks like:
0x6df2	push	r2
0x6df3	push	r3
0x6df6	push	r6
0x	mov.w	r7,r6
	subs	stuff,sp  mov.w #x,r5
	                  subs  r5,sp

 */

#define IS_PUSH(x) ((x & 0xff00)==0x6d00)
#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)
CORE_ADDR examine_prologue();

void   frame_find_saved_regs ();
CORE_ADDR h8300_skip_prologue(start_pc)
CORE_ADDR start_pc;

{

  /* Skip past all push insns */
  short int w;
  
  w = read_memory_short(start_pc);
  while (IS_PUSH(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);
    }

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

/* We will find two sorts of prologue, framefull and non framefull:
   
   push   r2
   push   r3
   push   fp
   mov    sp,fp
   stack_ad
 
   and
   push   x
   push   y
   stack_ad

*/

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[NUM_REGS];      /* One for each reg */
  
  memset(in_frame, 1, NUM_REGS);
  
  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 push instructions, and remember where they were saved */


  while (next_ip && IS_PUSH(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;
      ip +=4;
      
    }
  }


  /* The args are always reffed based from the stack pointer */
  fi->args_pointer =  after_prolog_fp - auto_depth;
  /* 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 + reg_save_depth-2 );
  

  /* Rememeber any others too */

  in_frame[PC_REGNUM] = 0;
  
  for (r = 0; r < NUM_REGS; r++) 
  {
    if (in_frame[r] != 1) 
    {
      fsr->regs[r] = after_prolog_fp + reg_save_depth - in_frame[r] -2;
    }
    else
    {
      fsr->regs[r] = 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 + reg_save_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 < NUM_REGS; 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()));
  
  }

}
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
	20	/*
	21	Contributed by Steve Chamberlain
	22	sac@cygnus.com
	23	*/
	24
400943fb	25	#include "defs.h"
1f46923f SC	26	#include "frame.h"
	27	#include "obstack.h"
	28	#include "symtab.h"
	29	#define UNSIGNED_SHORT(X) ((X) & 0xffff)
400943fb SC	30
	31	/* an easy to debug H8 stack frame looks like:
	32	0x6df2 push r2
	33	0x6df3 push r3
	34	0x6df6 push r6
	35	0x mov.w r7,r6
	36	subs stuff,sp mov.w #x,r5
	37	subs r5,sp
	38
	39	*/
1f46923f	40
400943fb	41	#define IS_PUSH(x) ((x & 0xff00)==0x6d00)
1f46923f SC	42	#define IS_MOVE_FP(x) (x == 0x0d76)
	43	#define IS_MOV_SP_FP(x) (x == 0x0d76)
	44	#define IS_SUB2_SP(x) (x==0x1b87)
	45	#define IS_MOVK_R5(x) (x==0x7905)
	46	CORE_ADDR examine_prologue();
	47
	48	void frame_find_saved_regs ();
400943fb SC	49	CORE_ADDR h8300_skip_prologue(start_pc)
400943fb SC	50	CORE_ADDR start_pc;
0a8f9d31	51
0a8f9d31	52	{
1f46923f	53
400943fb SC	54	/* Skip past all push insns */
400943fb SC	55	short int w;
0a8f9d31	56
96743d3c	57	w = read_memory_short(start_pc);
400943fb SC	58	while (IS_PUSH(w))
	59	{
	60	start_pc+=2;
96743d3c	61	w = read_memory_short(start_pc);
400943fb	62	}
0a8f9d31	63
1f46923f SC	64	/* Skip past a move to FP */
	65	if (IS_MOVE_FP(w)) {
	66	start_pc +=2 ;
96743d3c	67	w = read_memory_short(start_pc);
1f46923f SC	68	}
	69
	70	return start_pc;
0a8f9d31 SC	71
	72	}
	73
1f46923f	74
400943fb SC	75	int
	76	print_insn(memaddr, stream)
	77	CORE_ADDR memaddr;
	78	FILE *stream;
0a8f9d31	79	{
400943fb SC	80	/* Nothing is bigger than 8 bytes */
	81	char data[8];
	82	read_memory (memaddr, data, sizeof(data));
1f46923f	83	return print_insn_h8300(memaddr, data, stream);
0a8f9d31	84	}
400943fb SC	85
400943fb SC	86
1f46923f SC	87	/* Given a GDB frame, determine the address of the calling function's frame.
	88	This will be used to create a new GDB frame struct, and then
	89	INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
	90
	91	For us, the frame address is its stack pointer value, so we look up
	92	the function prologue to determine the caller's sp value, and return it. */
	93
	94	FRAME_ADDR
	95	FRAME_CHAIN (thisframe)
	96	FRAME thisframe;
	97	{
	98
	99	frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
	100	return thisframe->fsr->regs[SP_REGNUM];
	101	}
	102
400943fb	103
1f46923f SC	104
	105	/* Put here the code to store, into a struct frame_saved_regs,
	106	the addresses of the saved registers of frame described by FRAME_INFO.
	107	This includes special registers such as pc and fp saved in special
	108	ways in the stack frame. sp is even more special:
	109	the address we return for it IS the sp for the next frame.
	110
	111	We cache the result of doing this in the frame_cache_obstack, since
	112	it is fairly expensive. */
	113
	114	void
	115	frame_find_saved_regs (fi, fsr)
	116	struct frame_info *fi;
	117	struct frame_saved_regs *fsr;
	118	{
	119	register CORE_ADDR next_addr;
	120	register CORE_ADDR *saved_regs;
	121	register int regnum;
	122	register struct frame_saved_regs *cache_fsr;
	123	extern struct obstack frame_cache_obstack;
	124	CORE_ADDR ip;
	125	struct symtab_and_line sal;
	126	CORE_ADDR limit;
	127
	128	if (!fi->fsr)
	129	{
	130	cache_fsr = (struct frame_saved_regs *)
	131	obstack_alloc (&frame_cache_obstack,
	132	sizeof (struct frame_saved_regs));
	133	bzero (cache_fsr, sizeof (struct frame_saved_regs));
	134	fi->fsr = cache_fsr;
	135
	136	/* Find the start and end of the function prologue. If the PC
	137	is in the function prologue, we only consider the part that
	138	has executed already. */
	139
	140	ip = get_pc_function_start (fi->pc);
	141	sal = find_pc_line (ip, 0);
	142	limit = (sal.end && sal.end < fi->pc) ? sal.end: fi->pc;
	143
	144	/* This will fill in fields in fi as well as in cache_fsr. /
	145	examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
	146	}
	147
	148	if (fsr)
	149	fsr = fi->fsr;
	150	}
400943fb	151
1f46923f SC	152
	153	/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
	154	is not the address of a valid instruction, the address of the next
	155	instruction beyond ADDR otherwise. *PWORD1 receives the first word
	156	of the instruction.*/
	157
	158
	159	CORE_ADDR
	160	NEXT_PROLOGUE_INSN(addr, lim, pword1)
	161	CORE_ADDR addr;
	162	CORE_ADDR lim;
	163	short *pword1;
	164	{
	165	if (addr < lim+8)
	166	{
	167	read_memory (addr, pword1, sizeof(*pword1));
	168	SWAP_TARGET_AND_HOST (pword1, sizeof (short));
	169	return addr + 2;
	170	}
	171
	172	return 0;
	173
	174	}
	175
	176	/* Examine the prologue of a function. `ip' points to the first instruction.
	177	`limit' is the limit of the prologue (e.g. the addr of the first
	178	linenumber, or perhaps the program counter if we're stepping through).
	179	`frame_sp' is the stack pointer value in use in this frame.
	180	`fsr' is a pointer to a frame_saved_regs structure into which we put
	181	info about the registers saved by this frame.
	182	`fi' is a struct frame_info pointer; we fill in various fields in it
	183	to reflect the offsets of the arg pointer and the locals pointer. */
	184
	185	/* We will find two sorts of prologue, framefull and non framefull:
	186
	187	push r2
	188	push r3
	189	push fp
	190	mov sp,fp
	191	stack_ad
	192
	193	and
	194	push x
	195	push y
	196	stack_ad
	197
	198	*/
	199
	200	static CORE_ADDR
	201	examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
	202	register CORE_ADDR ip;
	203	register CORE_ADDR limit;
	204	FRAME_ADDR after_prolog_fp;
	205	struct frame_saved_regs *fsr;
	206	struct frame_info *fi;
	207	{
	208	register CORE_ADDR next_ip;
	209	int r;
	210	int i;
	211	int have_fp = 0;
	212
	213	register int src;
	214	register struct pic_prologue_code *pcode;
	215	INSN_WORD insn_word;
216	int size, offset;
217	unsigned int reg_save_depth = 2; /* Number of things pushed onto
218	stack, starts at 2, 'cause the
219	PC is already there */
220
221	unsigned int auto_depth = 0; /* Number of bytes of autos */
222
223	char in_frame[NUM_REGS]; /* One for each reg */
224
225	memset(in_frame, 1, NUM_REGS);
226
227	if (after_prolog_fp == 0) {
228	after_prolog_fp = read_register(SP_REGNUM);
229	}
230	if (ip == 0 \|\| ip & ~0xffff) return 0;
231
232	next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
233
234	/* Skip over any push instructions, and remember where they were saved */
235
236
237	while (next_ip && IS_PUSH(insn_word))
238	{
239	ip = next_ip;
240	in_frame[insn_word & 0x7] = reg_save_depth;
241	next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
242	reg_save_depth +=2;
243
244	}
245
246
247	/* Is this a move into the fp */
248	if (next_ip && IS_MOV_SP_FP(insn_word))
249	{
250	ip = next_ip;
251	next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
252	have_fp = 1;
253
254	}
255
256
257	/* Skip over any stack adjustment, happens either with a number of
258	sub#2,sp or a mov #x,r5 sub r5,sp */
259
260
261	if (next_ip && IS_SUB2_SP(insn_word))
262	{
263	while (next_ip && IS_SUB2_SP(insn_word))
264	{
265	auto_depth +=2 ;
266	ip = next_ip;
267	next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
268	}
269	}
270	else
271	{
272	if (next_ip && IS_MOVK_R5(insn_word))
273	{
274	ip = next_ip;
275	next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
276	auto_depth += insn_word;
277	ip +=4;
278
279	}
280	}
281
282
283
284	/* The args are always reffed based from the stack pointer */
285	fi->args_pointer = after_prolog_fp - auto_depth;
286	/* Locals are always reffed based from the fp */
287	fi->locals_pointer = after_prolog_fp ;
288	/* The PC is at a known place */
96743d3c	289	fi->from_pc = read_memory_short(after_prolog_fp + reg_save_depth-2 );
1f46923f SC	290
	291
	292	/* Rememeber any others too */
	293
	294	in_frame[PC_REGNUM] = 0;
	295
	296	for (r = 0; r < NUM_REGS; r++)
	297	{
	298	if (in_frame[r] != 1)
	299	{
	300	fsr->regs[r] = after_prolog_fp + reg_save_depth - in_frame[r] -2;
	301	}
	302	else
	303	{
	304	fsr->regs[r] = 0;
	305	}
	306	}
	307	if (have_fp)
	308	/* We keep the old FP in the SP spot */
96743d3c	309	fsr->regs[SP_REGNUM] = (read_memory_short(fsr->regs[6])) ;
1f46923f SC	310	else
	311	fsr->regs[SP_REGNUM] = after_prolog_fp + reg_save_depth;
	312
	313	return (ip);
	314	}
	315
	316	void
	317	init_extra_frame_info (fromleaf, fi)
	318	int fromleaf;
	319	struct frame_info *fi;
	320	{
	321	fi->fsr = 0; /* Not yet allocated */
	322	fi->args_pointer = 0; /* Unknown */
	323	fi->locals_pointer = 0; /* Unknown */
	324	fi->from_pc = 0;
	325
	326	}
	327	/* Return the saved PC from this frame.
	328
	329	If the frame has a memory copy of SRP_REGNUM, use that. If not,
	330	just use the register SRP_REGNUM itself. */
	331
	332	CORE_ADDR
	333	frame_saved_pc (frame)
	334	FRAME frame;
	335
	336	{
	337	return frame->from_pc;
	338	}
	339
	340
	341	CORE_ADDR
	342	frame_locals_address (fi)
	343	struct frame_info *fi;
	344	{
	345	if (!fi->locals_pointer)
	346	{
	347	struct frame_saved_regs ignore;
	348	get_frame_saved_regs(fi, &ignore);
	349
	350	}
	351	return fi->locals_pointer;
	352	}
	353
	354	/* Return the address of the argument block for the frame
	355	described by FI. Returns 0 if the address is unknown. */
	356
	357	CORE_ADDR
	358	frame_args_address (fi)
	359	struct frame_info *fi;
	360	{
	361	if (!fi->args_pointer)
	362	{
	363	struct frame_saved_regs ignore;
	364	get_frame_saved_regs(fi, &ignore);
	365
	366	}
	367
	368	return fi->args_pointer;
	369	}
	370
	371
	372	void h8300_pop_frame()
	373	{
374	unsigned regnum;
375	struct frame_saved_regs fsr;
376	struct frame_info *fi;
377
378	FRAME frame = get_current_frame();
379	fi = get_frame_info(frame);
380	get_frame_saved_regs(fi, &fsr);
381
382	for (regnum = 0; regnum < NUM_REGS; regnum ++)
383	{
384	if(fsr.regs[regnum])
385	{
96743d3c	386	write_register(regnum, read_memory_short (fsr.regs[regnum]));
1f46923f SC	387	}
	388
	389	flush_cached_frames();
	390	set_current_frame(create_new_frame(read_register(FP_REGNUM),
	391	read_pc()));
	392
	393	}
	394
	395	}