OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [irix4-nat.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* Native support for the SGI Iris running IRIX version 4, for GDB.
2
   Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2000,
3
   2001 Free Software Foundation, Inc.
4
   Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
5
   and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
6
   Implemented for Irix 4.x by Garrett A. Wollman.
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 2 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program; if not, write to the Free Software
22
   Foundation, Inc., 59 Temple Place - Suite 330,
23
   Boston, MA 02111-1307, USA.  */
24
 
25
#include "defs.h"
26
#include "inferior.h"
27
#include "gdbcore.h"
28
#include "regcache.h"
29
 
30
#include <sys/time.h>
31
#include <sys/procfs.h>
32
#include <setjmp.h>             /* For JB_XXX.  */
33
 
34
/* Prototypes for supply_gregset etc. */
35
#include "gregset.h"
36
 
37
/* Size of elements in jmpbuf */
38
 
39
#define JB_ELEMENT_SIZE 4
40
 
41
typedef unsigned int greg_t;    /* why isn't this defined? */
42
 
43
static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
44
 
45
/*
46
 * See the comment in m68k-tdep.c regarding the utility of these functions.
47
 */
48
 
49
void
50
supply_gregset (gregset_t *gregsetp)
51
{
52
  register int regi;
53
  register greg_t *regp = (greg_t *) (gregsetp->gp_regs);
54
  static char zerobuf[MAX_REGISTER_RAW_SIZE] =
55
  {0};
56
 
57
  /* FIXME: somewhere, there should be a #define for the meaning
58
     of this magic number 32; we should use that. */
59
  for (regi = 0; regi < 32; regi++)
60
    supply_register (regi, (char *) (regp + regi));
61
 
62
  supply_register (PC_REGNUM, (char *) &(gregsetp->gp_pc));
63
  supply_register (HI_REGNUM, (char *) &(gregsetp->gp_mdhi));
64
  supply_register (LO_REGNUM, (char *) &(gregsetp->gp_mdlo));
65
  supply_register (CAUSE_REGNUM, (char *) &(gregsetp->gp_cause));
66
 
67
  /* Fill inaccessible registers with zero.  */
68
  supply_register (BADVADDR_REGNUM, zerobuf);
69
}
70
 
71
void
72
fill_gregset (gregset_t *gregsetp, int regno)
73
{
74
  int regi;
75
  register greg_t *regp = (greg_t *) (gregsetp->gp_regs);
76
 
77
  /* same FIXME as above wrt 32 */
78
  for (regi = 0; regi < 32; regi++)
79
    if ((regno == -1) || (regno == regi))
80
      *(regp + regi) = *(greg_t *) & registers[REGISTER_BYTE (regi)];
81
 
82
  if ((regno == -1) || (regno == PC_REGNUM))
83
    gregsetp->gp_pc = *(greg_t *) & registers[REGISTER_BYTE (PC_REGNUM)];
84
 
85
  if ((regno == -1) || (regno == CAUSE_REGNUM))
86
    gregsetp->gp_cause = *(greg_t *) & registers[REGISTER_BYTE (CAUSE_REGNUM)];
87
 
88
  if ((regno == -1) || (regno == HI_REGNUM))
89
    gregsetp->gp_mdhi = *(greg_t *) & registers[REGISTER_BYTE (HI_REGNUM)];
90
 
91
  if ((regno == -1) || (regno == LO_REGNUM))
92
    gregsetp->gp_mdlo = *(greg_t *) & registers[REGISTER_BYTE (LO_REGNUM)];
93
}
94
 
95
/*
96
 * Now we do the same thing for floating-point registers.
97
 * We don't bother to condition on FP0_REGNUM since any
98
 * reasonable MIPS configuration has an R3010 in it.
99
 *
100
 * Again, see the comments in m68k-tdep.c.
101
 */
102
 
103
void
104
supply_fpregset (fpregset_t *fpregsetp)
105
{
106
  register int regi;
107
  static char zerobuf[MAX_REGISTER_RAW_SIZE] =
108
  {0};
109
 
110
  for (regi = 0; regi < 32; regi++)
111
    supply_register (FP0_REGNUM + regi,
112
                     (char *) &fpregsetp->fp_r.fp_regs[regi]);
113
 
114
  supply_register (FCRCS_REGNUM, (char *) &fpregsetp->fp_csr);
115
 
116
  /* FIXME: how can we supply FCRIR_REGNUM?  SGI doesn't tell us. */
117
  supply_register (FCRIR_REGNUM, zerobuf);
118
}
119
 
120
void
121
fill_fpregset (fpregset_t *fpregsetp, int regno)
122
{
123
  int regi;
124
  char *from, *to;
125
 
126
  for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
127
    {
128
      if ((regno == -1) || (regno == regi))
129
        {
130
          from = (char *) &registers[REGISTER_BYTE (regi)];
131
          to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
132
          memcpy (to, from, REGISTER_RAW_SIZE (regi));
133
        }
134
    }
135
 
136
  if ((regno == -1) || (regno == FCRCS_REGNUM))
137
    fpregsetp->fp_csr = *(unsigned *) &registers[REGISTER_BYTE (FCRCS_REGNUM)];
138
}
139
 
140
 
141
/* Figure out where the longjmp will land.
142
   We expect the first arg to be a pointer to the jmp_buf structure from which
143
   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
144
   This routine returns true on success. */
145
 
146
int
147
get_longjmp_target (CORE_ADDR *pc)
148
{
149
  char *buf;
150
  CORE_ADDR jb_addr;
151
 
152
  buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
153
  jb_addr = read_register (A0_REGNUM);
154
 
155
  if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
156
                          TARGET_PTR_BIT / TARGET_CHAR_BIT))
157
    return 0;
158
 
159
  *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
160
 
161
  return 1;
162
}
163
 
164
/* Provide registers to GDB from a core file.
165
 
166
   CORE_REG_SECT points to an array of bytes, which were obtained from
167
   a core file which BFD thinks might contain register contents.
168
   CORE_REG_SIZE is its size.
169
 
170
   Normally, WHICH says which register set corelow suspects this is:
171
 
172
     2 --- the floating-point register set
173
   However, for Irix 4, WHICH isn't used.
174
 
175
   REG_ADDR is also unused.  */
176
 
177
static void
178
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
179
                      int which, CORE_ADDR reg_addr)
180
{
181
  if (core_reg_size != REGISTER_BYTES)
182
    {
183
      warning ("wrong size gregset struct in core file");
184
      return;
185
    }
186
 
187
  memcpy ((char *) registers, core_reg_sect, core_reg_size);
188
}
189
 
190
 
191
/* Register that we are able to handle irix4 core file formats.
192
   FIXME: is this really bfd_target_unknown_flavour? */
193
 
194
static struct core_fns irix4_core_fns =
195
{
196
  bfd_target_unknown_flavour,           /* core_flavour */
197
  default_check_format,                 /* check_format */
198
  default_core_sniffer,                 /* core_sniffer */
199
  fetch_core_registers,                 /* core_read_registers */
200
  NULL                                  /* next */
201
};
202
 
203
void
204
_initialize_core_irix4 (void)
205
{
206
  add_core_fns (&irix4_core_fns);
207
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.