1/* Native support for the SGI Iris running IRIX version 5, for GDB.
2
3   Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4   1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
5
6   Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
7   and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
8   Implemented for Irix 4.x by Garrett A. Wollman.
9   Modified for Irix 5.x by Ian Lance Taylor.
10
11   This file is part of GDB.
12
13   This program is free software; you can redistribute it and/or modify
14   it under the terms of the GNU General Public License as published by
15   the Free Software Foundation; either version 2 of the License, or
16   (at your option) any later version.
17
18   This program is distributed in the hope that it will be useful,
19   but WITHOUT ANY WARRANTY; without even the implied warranty of
20   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21   GNU General Public License for more details.
22
23   You should have received a copy of the GNU General Public License
24   along with this program; if not, write to the Free Software
25   Foundation, Inc., 59 Temple Place - Suite 330,
26   Boston, MA 02111-1307, USA.  */
27
28#include "defs.h"
29#include "inferior.h"
30#include "gdbcore.h"
31#include "target.h"
32#include "regcache.h"
33
34#include "gdb_string.h"
35#include <sys/time.h>
36#include <sys/procfs.h>
37#include <setjmp.h>		/* For JB_XXX.  */
38
39/* Prototypes for supply_gregset etc. */
40#include "gregset.h"
41#include "mips-tdep.h"
42
43static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
44
45/* Size of elements in jmpbuf */
46
47#define JB_ELEMENT_SIZE 4
48
49/*
50 * See the comment in m68k-tdep.c regarding the utility of these functions.
51 *
52 * These definitions are from the MIPS SVR4 ABI, so they may work for
53 * any MIPS SVR4 target.
54 */
55
56void
57supply_gregset (gregset_t *gregsetp)
58{
59  int regi;
60  greg_t *regp = &(*gregsetp)[0];
61  int gregoff = sizeof (greg_t) - mips_isa_regsize (current_gdbarch);
62  static char zerobuf[32] = {0};
63
64  for (regi = 0; regi <= CTX_RA; regi++)
65    regcache_raw_supply (current_regcache, regi,
66			 (char *) (regp + regi) + gregoff);
67
68  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->pc,
69		       (char *) (regp + CTX_EPC) + gregoff);
70  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->hi,
71		       (char *) (regp + CTX_MDHI) + gregoff);
72  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->lo,
73		       (char *) (regp + CTX_MDLO) + gregoff);
74  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->cause,
75		       (char *) (regp + CTX_CAUSE) + gregoff);
76
77  /* Fill inaccessible registers with zero.  */
78  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->badvaddr, zerobuf);
79}
80
81void
82fill_gregset (gregset_t *gregsetp, int regno)
83{
84  int regi;
85  greg_t *regp = &(*gregsetp)[0];
86
87  /* Under Irix6, if GDB is built with N32 ABI and is debugging an O32
88     executable, we have to sign extend the registers to 64 bits before
89     filling in the gregset structure.  */
90
91  for (regi = 0; regi <= CTX_RA; regi++)
92    if ((regno == -1) || (regno == regi))
93      *(regp + regi) =
94	extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)],
95				register_size (current_gdbarch, regi));
96
97  if ((regno == -1) || (regno == PC_REGNUM))
98    *(regp + CTX_EPC) =
99      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->pc)],
100			      register_size (current_gdbarch, mips_regnum (current_gdbarch)->pc));
101
102  if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->cause))
103    *(regp + CTX_CAUSE) =
104      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->cause)],
105			      register_size (current_gdbarch, mips_regnum (current_gdbarch)->cause));
106
107  if ((regno == -1)
108      || (regno == mips_regnum (current_gdbarch)->hi))
109    *(regp + CTX_MDHI) =
110      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->hi)],
111			      register_size (current_gdbarch, mips_regnum (current_gdbarch)->hi));
112
113  if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->lo))
114    *(regp + CTX_MDLO) =
115      extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->lo)],
116			      register_size (current_gdbarch, mips_regnum (current_gdbarch)->lo));
117}
118
119/*
120 * Now we do the same thing for floating-point registers.
121 * We don't bother to condition on FP0_REGNUM since any
122 * reasonable MIPS configuration has an R3010 in it.
123 *
124 * Again, see the comments in m68k-tdep.c.
125 */
126
127void
128supply_fpregset (fpregset_t *fpregsetp)
129{
130  int regi;
131  static char zerobuf[32] = {0};
132
133  /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
134
135  for (regi = 0; regi < 32; regi++)
136    regcache_raw_supply (current_regcache, FP0_REGNUM + regi,
137			 (char *) &fpregsetp->fp_r.fp_regs[regi]);
138
139  regcache_raw_supply (current_regcache,
140		       mips_regnum (current_gdbarch)->fp_control_status,
141		       (char *) &fpregsetp->fp_csr);
142
143  /* FIXME: how can we supply FCRIR?  SGI doesn't tell us. */
144  regcache_raw_supply (current_regcache,
145		       mips_regnum (current_gdbarch)->fp_implementation_revision,
146		       zerobuf);
147}
148
149void
150fill_fpregset (fpregset_t *fpregsetp, int regno)
151{
152  int regi;
153  char *from, *to;
154
155  /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
156
157  for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
158    {
159      if ((regno == -1) || (regno == regi))
160	{
161	  from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
162	  to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
163	  memcpy (to, from, register_size (current_gdbarch, regi));
164	}
165    }
166
167  if ((regno == -1)
168      || (regno == mips_regnum (current_gdbarch)->fp_control_status))
169    fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->fp_control_status)];
170}
171
172
173/* Figure out where the longjmp will land.
174   We expect the first arg to be a pointer to the jmp_buf structure from which
175   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
176   This routine returns true on success. */
177
178int
179get_longjmp_target (CORE_ADDR *pc)
180{
181  char *buf;
182  CORE_ADDR jb_addr;
183
184  buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
185  jb_addr = read_register (A0_REGNUM);
186
187  if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
188			  TARGET_PTR_BIT / TARGET_CHAR_BIT))
189    return 0;
190
191  *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
192
193  return 1;
194}
195
196/* Provide registers to GDB from a core file.
197
198   CORE_REG_SECT points to an array of bytes, which were obtained from
199   a core file which BFD thinks might contain register contents.
200   CORE_REG_SIZE is its size.
201
202   Normally, WHICH says which register set corelow suspects this is:
203     0 --- the general-purpose register set
204     2 --- the floating-point register set
205   However, for Irix 5, WHICH isn't used.
206
207   REG_ADDR is also unused.  */
208
209static void
210fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
211		      int which, CORE_ADDR reg_addr)
212{
213  if (core_reg_size == deprecated_register_bytes ())
214    {
215      memcpy ((char *) deprecated_registers, core_reg_sect, core_reg_size);
216    }
217  else if (mips_isa_regsize (current_gdbarch) == 4 &&
218	   core_reg_size == (2 * mips_isa_regsize (current_gdbarch)) * NUM_REGS)
219    {
220      /* This is a core file from a N32 executable, 64 bits are saved
221         for all registers.  */
222      char *srcp = core_reg_sect;
223      char *dstp = deprecated_registers;
224      int regno;
225
226      for (regno = 0; regno < NUM_REGS; regno++)
227	{
228	  if (regno >= FP0_REGNUM && regno < (FP0_REGNUM + 32))
229	    {
230	      /* FIXME, this is wrong, N32 has 64 bit FP regs, but GDB
231	         currently assumes that they are 32 bit.  */
232	      *dstp++ = *srcp++;
233	      *dstp++ = *srcp++;
234	      *dstp++ = *srcp++;
235	      *dstp++ = *srcp++;
236	      if (register_size (current_gdbarch, regno) == 4)
237		{
238		  /* copying 4 bytes from eight bytes?
239		     I don't see how this can be right...  */
240		  srcp += 4;
241		}
242	      else
243		{
244		  /* copy all 8 bytes (sizeof(double)) */
245		  *dstp++ = *srcp++;
246		  *dstp++ = *srcp++;
247		  *dstp++ = *srcp++;
248		  *dstp++ = *srcp++;
249		}
250	    }
251	  else
252	    {
253	      srcp += 4;
254	      *dstp++ = *srcp++;
255	      *dstp++ = *srcp++;
256	      *dstp++ = *srcp++;
257	      *dstp++ = *srcp++;
258	    }
259	}
260    }
261  else
262    {
263      warning ("wrong size gregset struct in core file");
264      return;
265    }
266
267  deprecated_registers_fetched ();
268}
269
270/* Register that we are able to handle irix5 core file formats.
271   This really is bfd_target_unknown_flavour */
272
273static struct core_fns irix5_core_fns =
274{
275  bfd_target_unknown_flavour,		/* core_flavour */
276  default_check_format,			/* check_format */
277  default_core_sniffer,			/* core_sniffer */
278  fetch_core_registers,			/* core_read_registers */
279  NULL					/* next */
280};
281
282void
283_initialize_core_irix5 (void)
284{
285  deprecated_add_core_fns (&irix5_core_fns);
286}
287