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

/* ARC target-dependent stuff.
   Copyright (C) 1995 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.  */

#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "gdbcore.h"
#include "target.h"
#include "floatformat.h"
#include "symtab.h"

static void codestream_read PARAMS ((unsigned int *, int));
static void codestream_seek PARAMS ((int));
static unsigned int codestream_fill PARAMS ((int));

#define CODESTREAM_BUFSIZ 16 
static CORE_ADDR codestream_next_addr;
static CORE_ADDR codestream_addr;
static unsigned int codestream_buf[CODESTREAM_BUFSIZ];
static int codestream_off;
static int codestream_cnt;

#define codestream_tell() (codestream_addr + codestream_off)
#define codestream_peek() (codestream_cnt == 0 ? \
			   codestream_fill(1): codestream_buf[codestream_off])
#define codestream_get() (codestream_cnt-- == 0 ? \
			 codestream_fill(0) : codestream_buf[codestream_off++])
#define OPMASK	0xf8000000

static unsigned int 
codestream_fill (peek_flag)
    int peek_flag;
{
  codestream_addr = codestream_next_addr;
  codestream_next_addr += CODESTREAM_BUFSIZ;
  codestream_off = 0;
  codestream_cnt = CODESTREAM_BUFSIZ;
  read_memory (codestream_addr, (char *) codestream_buf, CODESTREAM_BUFSIZ);
  
  if (peek_flag)
    return (codestream_peek());
  else
    return (codestream_get());
}

static void
codestream_seek (place)
    int place;
{
  codestream_next_addr = place / CODESTREAM_BUFSIZ;
  codestream_next_addr *= CODESTREAM_BUFSIZ;
  codestream_cnt = 0;
  codestream_fill (1);
  while (codestream_tell() != place)
    codestream_get ();
}

static void
codestream_read (buf, count)
     unsigned int *buf;
     int count;
{
  unsigned int *p;
  int i;
  p = buf;
  for (i = 0; i < count; i++)
    *p++ = codestream_get ();
}

/*
 * find & return amound a local space allocated, and advance codestream to
 * first register push (if any)
 * if entry sequence doesn't make sense, return -1, and leave 
 * codestream pointer random
 */

static long
arc_get_frame_setup (pc)
     int pc;
{
  unsigned int insn, n;

  codestream_seek (pc);
  insn = codestream_get ();

  if (insn & OPMASK == 0x10000000)		/* st fp,[sp] */
    {	
      insn = codestream_get ();
      if (insn & OPMASK != 0x10000000)	        /* st blink,[sp,4] */
	{
	  if (insn & OPMASK != 0x60000000)      /* for leaf, no st blink */
	    return -1;
	}
      else if (codestream_get () & OPMASK != 0x60000000)    /* mov fp,sp */
	return (-1);

      /* check for stack adjustment sub sp,nnn,sp */
      insn = codestream_peek ();
      if (insn & OPMASK == 0x50000000)
	{
	  n = (insn & 0x000001ff ); 
          codestream_get ();

	  /* this sequence is used to get the address of the return
	   * buffer for a function that returns a structure
	   */
	  insn = codestream_peek ();
	  if (insn & OPMASK == 0x60000000)
	    codestream_get ();

	  return n;
	}
      else
	{
	  return (0);
	}
    }
  return (-1);
}

/* return pc of first real instruction */
CORE_ADDR
skip_prologue (pc)
     int pc;
{
  unsigned int insn;
  int i;
  CORE_ADDR pos;
  
  if (arc_get_frame_setup (pc) < 0)
    return (pc);
  
  /* skip over register saves */
  for (i = 0; i < 10; i++)
    {
      insn = codestream_peek ();
      if (insn & OPMASK != 0x10000000)       /* break if not st inst */
	break;
      codestream_get ();
    }
     
  codestream_seek (pos);
  return (codestream_tell ());
}

/* Return number of args passed to a frame.
   Can return -1, meaning no way to tell.  */
int
frame_num_args (fi)
     struct frame_info *fi;
{
#if 1
  return -1;
#else
  /* This loses because not only might the compiler not be popping the
     args right after the function call, it might be popping args from both
     this call and a previous one, and we would say there are more args
     than there really are.  Is it true for ARC */

  int retpc;						
  unsigned char op;					
  struct frame_info *pfi;

  int frameless;

  FRAMELESS_FUNCTION_INVOCATION (fi, frameless);
  if (frameless)
    /* In the absence of a frame pointer, GDB doesn't get correct values
       for nameless arguments.  Return -1, so it doesn't print any
       nameless arguments.  */
    return -1;

  pfi = get_prev_frame_info (fi);			
  if (pfi == 0)
    {
      /* Note:  this can happen if we are looking at the frame for
	 main, because FRAME_CHAIN_VALID won't let us go into
	 start.  If we have debugging symbols, that's not really
	 a big deal; it just means it will only show as many arguments
	 to main as are declared.  */
      return -1;
    }
  else
    {
      retpc = pfi->pc;					
      op = read_memory_integer (retpc, 1);			
      if (op == 0x59)					
	/* pop %ecx */			       
	return 1;				
	}
      else
	{
	  return 0;
	}
    }
#endif
}

/*
 * parse the first few instructions of the function to see
 * what registers were stored.
 *
 * The startup sequence can be at the start of the function.
 * 'st fp,[sp], st blink,[sp+4], mov fp,sp' 
 *
 * Local space is allocated just below by sub sp,nnn,sp
 * Next, the registers used by this function are stored.
 */

void
frame_find_saved_regs (fip, fsrp)
     struct frame_info *fip;
     struct frame_saved_regs *fsrp;
{
  long locals;
  unsigned int insn;
  CORE_ADDR dummy_bottom;
  CORE_ADDR adr;
  int i, regnum, offset;
  
  memset (fsrp, 0, sizeof *fsrp);
  
  /* if frame is the end of a dummy, compute where the
   * beginning would be
   */
  dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH;
  
  /* check if the PC is in the stack, in a dummy frame */
  if (dummy_bottom <= fip->pc && fip->pc <= fip->frame) 
    {
      /* all regs were saved by push_call_dummy () */
      adr = fip->frame;
      for (i = 0; i < NUM_REGS; i++) 
	{
	  adr -= REGISTER_RAW_SIZE (i);
	  fsrp->regs[i] = adr;
	}
      return;
    }
  
  locals = arc_get_frame_setup (get_pc_function_start (fip->pc));
  
  if (locals >= 0) 
    {
      adr = fip->frame - locals;
      for (i = 0; i < 10; i++) 
	{
	  insn = codestream_get ();
	  if (insn & 0xffff8000 != 0x100d8000)
	    break;
          regnum = (insn & 0x00007c00) >> 9;
	  offset = (insn << 23) >> 23;
	  fsrp->regs[regnum] = adr + offset;
	}
    }
  
  fsrp->regs[PC_REGNUM] = fip->frame + 4;
  fsrp->regs[FP_REGNUM] = fip->frame;
}

void
push_dummy_frame ()
{
  CORE_ADDR sp = read_register (SP_REGNUM);
  int regnum;
  char regbuf[MAX_REGISTER_RAW_SIZE];

  read_register_gen (PC_REGNUM, regbuf);
  write_memory (sp+4, regbuf, REGISTER_SIZE);
  read_register_gen (FP_REGNUM, regbuf);
  write_memory (sp, regbuf, REGISTER_SIZE);
  write_register (FP_REGNUM, sp);
  for (regnum = 0; regnum < NUM_REGS; regnum++)
    {
      read_register_gen (regnum, regbuf);
      sp = push_bytes (sp, regbuf, REGISTER_RAW_SIZE (regnum));
    }
  sp += (2*REGISTER_SIZE);
  write_register (SP_REGNUM, sp);
}

void
pop_frame ()
{
  struct frame_info *frame = get_current_frame ();
  CORE_ADDR fp;
  int regnum;
  struct frame_saved_regs fsr;
  char regbuf[MAX_REGISTER_RAW_SIZE];
  
  fp = FRAME_FP (frame);
  get_frame_saved_regs (frame, &fsr);
  for (regnum = 0; regnum < NUM_REGS; regnum++) 
    {
      CORE_ADDR adr;
      adr = fsr.regs[regnum];
      if (adr)
	{
	  read_memory (adr, regbuf, REGISTER_RAW_SIZE (regnum));
	  write_register_bytes (REGISTER_BYTE (regnum), regbuf,
				REGISTER_RAW_SIZE (regnum));
	}
    }
  write_register (FP_REGNUM, read_memory_integer (fp, 4));
  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
  write_register (SP_REGNUM, fp + 8);
  flush_cached_frames ();
}

#ifdef GET_LONGJMP_TARGET
/* Figure out where the longjmp will land.  Slurp the args out of the stack.
   We expect the first arg to be a pointer to the jmp_buf structure from which
   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
   This routine returns true on success. */

int
get_longjmp_target(pc)
     CORE_ADDR *pc;
{
  char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
  CORE_ADDR sp, jb_addr;

  sp = read_register (SP_REGNUM);

  if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
			  buf,
			  TARGET_PTR_BIT / TARGET_CHAR_BIT))
    return 0;

  jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);

  if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
			  TARGET_PTR_BIT / TARGET_CHAR_BIT))
    return 0;

  *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);

  return 1;
}
#endif /* GET_LONGJMP_TARGET */

void
_initialize_arc_tdep ()
{
  tm_print_insn = arc_get_disassembler (bfd_mach_arc_host);
}
Commit	Line	Data
249abc98 KH	1	/* ARC target-dependent stuff.
	2	Copyright (C) 1995 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	#include "defs.h"
	21	#include "frame.h"
	22	#include "inferior.h"
	23	#include "gdbcore.h"
	24	#include "target.h"
	25	#include "floatformat.h"
	26	#include "symtab.h"
	27
	28	static void codestream_read PARAMS ((unsigned int *, int));
	29	static void codestream_seek PARAMS ((int));
	30	static unsigned int codestream_fill PARAMS ((int));
	31
	32	#define CODESTREAM_BUFSIZ 16
	33	static CORE_ADDR codestream_next_addr;
	34	static CORE_ADDR codestream_addr;
	35	static unsigned int codestream_buf[CODESTREAM_BUFSIZ];
	36	static int codestream_off;
	37	static int codestream_cnt;
	38
	39	#define codestream_tell() (codestream_addr + codestream_off)
	40	#define codestream_peek() (codestream_cnt == 0 ? \
	41	codestream_fill(1): codestream_buf[codestream_off])
	42	#define codestream_get() (codestream_cnt-- == 0 ? \
	43	codestream_fill(0) : codestream_buf[codestream_off++])
	44	#define OPMASK 0xf8000000
	45
	46	static unsigned int
	47	codestream_fill (peek_flag)
	48	int peek_flag;
	49	{
	50	codestream_addr = codestream_next_addr;
	51	codestream_next_addr += CODESTREAM_BUFSIZ;
	52	codestream_off = 0;
	53	codestream_cnt = CODESTREAM_BUFSIZ;
	54	read_memory (codestream_addr, (char *) codestream_buf, CODESTREAM_BUFSIZ);
	55
	56	if (peek_flag)
	57	return (codestream_peek());
	58	else
	59	return (codestream_get());
	60	}
	61
	62	static void
	63	codestream_seek (place)
	64	int place;
65	{
66	codestream_next_addr = place / CODESTREAM_BUFSIZ;
67	codestream_next_addr *= CODESTREAM_BUFSIZ;
68	codestream_cnt = 0;
69	codestream_fill (1);
70	while (codestream_tell() != place)
71	codestream_get ();
72	}
73
74	static void
75	codestream_read (buf, count)
76	unsigned int *buf;
77	int count;
78	{
79	unsigned int *p;
80	int i;
81	p = buf;
82	for (i = 0; i < count; i++)
83	*p++ = codestream_get ();
84	}
85
86	/*
87	* find & return amound a local space allocated, and advance codestream to
88	* first register push (if any)
89	* if entry sequence doesn't make sense, return -1, and leave
90	* codestream pointer random
91	*/
92
93	static long
94	arc_get_frame_setup (pc)
95	int pc;
96	{
97	unsigned int insn, n;
98
99	codestream_seek (pc);
100	insn = codestream_get ();
101
102	if (insn & OPMASK == 0x10000000) /* st fp,[sp] */
103	{
104	insn = codestream_get ();
105	if (insn & OPMASK != 0x10000000) /* st blink,[sp,4] */
106	{
107	if (insn & OPMASK != 0x60000000) /* for leaf, no st blink */
108	return -1;
109	}
110	else if (codestream_get () & OPMASK != 0x60000000) /* mov fp,sp */
111	return (-1);
112
113	/* check for stack adjustment sub sp,nnn,sp */
114	insn = codestream_peek ();
115	if (insn & OPMASK == 0x50000000)
116	{
117	n = (insn & 0x000001ff );
118	codestream_get ();
119
120	/* this sequence is used to get the address of the return
121	* buffer for a function that returns a structure
122	*/
123	insn = codestream_peek ();
124	if (insn & OPMASK == 0x60000000)
125	codestream_get ();
126
127	return n;
128	}
129	else
130	{
131	return (0);
132	}
133	}
134	return (-1);
135	}
136
137	/* return pc of first real instruction */
138	CORE_ADDR
139	skip_prologue (pc)
140	int pc;
141	{
142	unsigned int insn;
143	int i;
144	CORE_ADDR pos;
145
146	if (arc_get_frame_setup (pc) < 0)
147	return (pc);
148
149	/* skip over register saves */
150	for (i = 0; i < 10; i++)
151	{
152	insn = codestream_peek ();
153	if (insn & OPMASK != 0x10000000) /* break if not st inst */
154	break;
155	codestream_get ();
156	}
157
158	codestream_seek (pos);
159	return (codestream_tell ());
160	}
161
162	/* Return number of args passed to a frame.
163	Can return -1, meaning no way to tell. */
164	int
165	frame_num_args (fi)
166	struct frame_info *fi;
167	{
168	#if 1
169	return -1;
170	#else
171	/* This loses because not only might the compiler not be popping the
172	args right after the function call, it might be popping args from both
173	this call and a previous one, and we would say there are more args
174	than there really are. Is it true for ARC */
175
176	int retpc;
177	unsigned char op;
178	struct frame_info *pfi;
179
180	int frameless;
181
182	FRAMELESS_FUNCTION_INVOCATION (fi, frameless);
183	if (frameless)
184	/* In the absence of a frame pointer, GDB doesn't get correct values
185	for nameless arguments. Return -1, so it doesn't print any
186	nameless arguments. */
187	return -1;
188
189	pfi = get_prev_frame_info (fi);
190	if (pfi == 0)
191	{
192	/* Note: this can happen if we are looking at the frame for
193	main, because FRAME_CHAIN_VALID won't let us go into
194	start. If we have debugging symbols, that's not really
195	a big deal; it just means it will only show as many arguments
196	to main as are declared. */
197	return -1;
198	}
199	else
200	{
201	retpc = pfi->pc;
202	op = read_memory_integer (retpc, 1);
203	if (op == 0x59)
204	/* pop %ecx */
205	return 1;
206	}
207	else
208	{
209	return 0;
210	}
211	}
212	#endif
213	}
214
215	/*
216	* parse the first few instructions of the function to see
217	* what registers were stored.
218	*
219	* The startup sequence can be at the start of the function.
220	* 'st fp,[sp], st blink,[sp+4], mov fp,sp'
221	*
222	* Local space is allocated just below by sub sp,nnn,sp
223	* Next, the registers used by this function are stored.
224	*/
225
226	void
227	frame_find_saved_regs (fip, fsrp)
228	struct frame_info *fip;
229	struct frame_saved_regs *fsrp;
230	{
231	long locals;
232	unsigned int insn;
233	CORE_ADDR dummy_bottom;
234	CORE_ADDR adr;
235	int i, regnum, offset;
236
237	memset (fsrp, 0, sizeof *fsrp);
238
239	/* if frame is the end of a dummy, compute where the
240	* beginning would be
241	*/
242	dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH;
243
244	/* check if the PC is in the stack, in a dummy frame */
245	if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
246	{
247	/* all regs were saved by push_call_dummy () */
248	adr = fip->frame;
249	for (i = 0; i < NUM_REGS; i++)
250	{
251	adr -= REGISTER_RAW_SIZE (i);
252	fsrp->regs[i] = adr;
253	}
254	return;
255	}
256
257	locals = arc_get_frame_setup (get_pc_function_start (fip->pc));
258
259	if (locals >= 0)
260	{
261	adr = fip->frame - locals;
262	for (i = 0; i < 10; i++)
263	{
264	insn = codestream_get ();
265	if (insn & 0xffff8000 != 0x100d8000)
266	break;
267	regnum = (insn & 0x00007c00) >> 9;
268	offset = (insn << 23) >> 23;
269	fsrp->regs[regnum] = adr + offset;
270	}
271	}
272
273	fsrp->regs[PC_REGNUM] = fip->frame + 4;
274	fsrp->regs[FP_REGNUM] = fip->frame;
275	}
276
277	void
278	push_dummy_frame ()
279	{
280	CORE_ADDR sp = read_register (SP_REGNUM);
281	int regnum;
282	char regbuf[MAX_REGISTER_RAW_SIZE];
283
284	read_register_gen (PC_REGNUM, regbuf);
285	write_memory (sp+4, regbuf, REGISTER_SIZE);
286	read_register_gen (FP_REGNUM, regbuf);
287	write_memory (sp, regbuf, REGISTER_SIZE);
288	write_register (FP_REGNUM, sp);
289	for (regnum = 0; regnum < NUM_REGS; regnum++)
290	{
291	read_register_gen (regnum, regbuf);
292	sp = push_bytes (sp, regbuf, REGISTER_RAW_SIZE (regnum));
293	}
294	sp += (2*REGISTER_SIZE);
295	write_register (SP_REGNUM, sp);
296	}
297
298	void
299	pop_frame ()
300	{
301	struct frame_info *frame = get_current_frame ();
302	CORE_ADDR fp;
303	int regnum;
304	struct frame_saved_regs fsr;
305	char regbuf[MAX_REGISTER_RAW_SIZE];
306
307	fp = FRAME_FP (frame);
308	get_frame_saved_regs (frame, &fsr);
309	for (regnum = 0; regnum < NUM_REGS; regnum++)
310	{
311	CORE_ADDR adr;
312	adr = fsr.regs[regnum];
313	if (adr)
314	{
315	read_memory (adr, regbuf, REGISTER_RAW_SIZE (regnum));
316	write_register_bytes (REGISTER_BYTE (regnum), regbuf,
317	REGISTER_RAW_SIZE (regnum));
318	}
319	}
320	write_register (FP_REGNUM, read_memory_integer (fp, 4));
321	write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
322	write_register (SP_REGNUM, fp + 8);
323	flush_cached_frames ();
324	}
325
326	#ifdef GET_LONGJMP_TARGET
327	/* Figure out where the longjmp will land. Slurp the args out of the stack.
328	We expect the first arg to be a pointer to the jmp_buf structure from which
329	we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
330	This routine returns true on success. */
331
332	int
333	get_longjmp_target(pc)
334	CORE_ADDR *pc;
335	{
336	char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
337	CORE_ADDR sp, jb_addr;
338
339	sp = read_register (SP_REGNUM);
340
341	if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
342	buf,
343	TARGET_PTR_BIT / TARGET_CHAR_BIT))
344	return 0;
345
346	jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
347
348	if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
349	TARGET_PTR_BIT / TARGET_CHAR_BIT))
350	return 0;
351
352	*pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
353
354	return 1;
355	}
356	#endif /* GET_LONGJMP_TARGET */
357
9c4ecee6 SS	358	void
9c4ecee6 SS	359	_initialize_arc_tdep ()
249abc98	360	{
abed6bc2	361	tm_print_insn = arc_get_disassembler (bfd_mach_arc_host);
249abc98	362	}