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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [ns32knbsd-nat.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Functions specific to running gdb native on an ns32k running NetBSD
2
   Copyright 1989, 1992, 1993, 1994, 1996, 1998, 1999, 2000, 2001
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include <sys/types.h>
23
#include <sys/ptrace.h>
24
#include <machine/reg.h>
25
#include <machine/frame.h>
26
#include <machine/pcb.h>
27
 
28
#include "defs.h"
29
#include "inferior.h"
30
#include "target.h"
31
#include "gdbcore.h"
32
#include "regcache.h"
33
 
34
#define RF(dst, src) \
35
        memcpy(&registers[REGISTER_BYTE(dst)], &src, sizeof(src))
36
 
37
#define RS(src, dst) \
38
        memcpy(&dst, &registers[REGISTER_BYTE(src)], sizeof(dst))
39
 
40
void
41
fetch_inferior_registers (int regno)
42
{
43
  struct reg inferior_registers;
44
  struct fpreg inferior_fpregisters;
45
 
46
  ptrace (PT_GETREGS, PIDGET (inferior_ptid),
47
          (PTRACE_ARG3_TYPE) & inferior_registers, 0);
48
  ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
49
          (PTRACE_ARG3_TYPE) & inferior_fpregisters, 0);
50
 
51
  RF (R0_REGNUM + 0, inferior_registers.r_r0);
52
  RF (R0_REGNUM + 1, inferior_registers.r_r1);
53
  RF (R0_REGNUM + 2, inferior_registers.r_r2);
54
  RF (R0_REGNUM + 3, inferior_registers.r_r3);
55
  RF (R0_REGNUM + 4, inferior_registers.r_r4);
56
  RF (R0_REGNUM + 5, inferior_registers.r_r5);
57
  RF (R0_REGNUM + 6, inferior_registers.r_r6);
58
  RF (R0_REGNUM + 7, inferior_registers.r_r7);
59
 
60
  RF (SP_REGNUM, inferior_registers.r_sp);
61
  RF (FP_REGNUM, inferior_registers.r_fp);
62
  RF (PC_REGNUM, inferior_registers.r_pc);
63
  RF (PS_REGNUM, inferior_registers.r_psr);
64
 
65
  RF (FPS_REGNUM, inferior_fpregisters.r_fsr);
66
  RF (FP0_REGNUM + 0, inferior_fpregisters.r_freg[0]);
67
  RF (FP0_REGNUM + 2, inferior_fpregisters.r_freg[2]);
68
  RF (FP0_REGNUM + 4, inferior_fpregisters.r_freg[4]);
69
  RF (FP0_REGNUM + 6, inferior_fpregisters.r_freg[6]);
70
  RF (LP0_REGNUM + 1, inferior_fpregisters.r_freg[1]);
71
  RF (LP0_REGNUM + 3, inferior_fpregisters.r_freg[3]);
72
  RF (LP0_REGNUM + 5, inferior_fpregisters.r_freg[5]);
73
  RF (LP0_REGNUM + 7, inferior_fpregisters.r_freg[7]);
74
  registers_fetched ();
75
}
76
 
77
void
78
store_inferior_registers (int regno)
79
{
80
  struct reg inferior_registers;
81
  struct fpreg inferior_fpregisters;
82
 
83
  RS (R0_REGNUM + 0, inferior_registers.r_r0);
84
  RS (R0_REGNUM + 1, inferior_registers.r_r1);
85
  RS (R0_REGNUM + 2, inferior_registers.r_r2);
86
  RS (R0_REGNUM + 3, inferior_registers.r_r3);
87
  RS (R0_REGNUM + 4, inferior_registers.r_r4);
88
  RS (R0_REGNUM + 5, inferior_registers.r_r5);
89
  RS (R0_REGNUM + 6, inferior_registers.r_r6);
90
  RS (R0_REGNUM + 7, inferior_registers.r_r7);
91
 
92
  RS (SP_REGNUM, inferior_registers.r_sp);
93
  RS (FP_REGNUM, inferior_registers.r_fp);
94
  RS (PC_REGNUM, inferior_registers.r_pc);
95
  RS (PS_REGNUM, inferior_registers.r_psr);
96
 
97
  RS (FPS_REGNUM, inferior_fpregisters.r_fsr);
98
  RS (FP0_REGNUM + 0, inferior_fpregisters.r_freg[0]);
99
  RS (FP0_REGNUM + 2, inferior_fpregisters.r_freg[2]);
100
  RS (FP0_REGNUM + 4, inferior_fpregisters.r_freg[4]);
101
  RS (FP0_REGNUM + 6, inferior_fpregisters.r_freg[6]);
102
  RS (LP0_REGNUM + 1, inferior_fpregisters.r_freg[1]);
103
  RS (LP0_REGNUM + 3, inferior_fpregisters.r_freg[3]);
104
  RS (LP0_REGNUM + 5, inferior_fpregisters.r_freg[5]);
105
  RS (LP0_REGNUM + 7, inferior_fpregisters.r_freg[7]);
106
 
107
  ptrace (PT_SETREGS, PIDGET (inferior_ptid),
108
          (PTRACE_ARG3_TYPE) & inferior_registers, 0);
109
  ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
110
          (PTRACE_ARG3_TYPE) & inferior_fpregisters, 0);
111
}
112
 
113
 
114
/* XXX - Add this to machine/regs.h instead? */
115
struct coreregs
116
{
117
  struct reg intreg;
118
  struct fpreg freg;
119
};
120
 
121
/* Get registers from a core file.  REG_ADDR is unused.  */
122
static void
123
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
124
                      unsigned int reg_addr)
125
{
126
  struct coreregs *core_reg;
127
 
128
  core_reg = (struct coreregs *) core_reg_sect;
129
 
130
  /*
131
   * We have *all* registers
132
   * in the first core section.
133
   * Ignore which.
134
   */
135
 
136
  if (core_reg_size < sizeof (*core_reg))
137
    {
138
      fprintf_unfiltered (gdb_stderr, "Couldn't read regs from core file\n");
139
      return;
140
    }
141
 
142
  /* Integer registers */
143
  RF (R0_REGNUM + 0, core_reg->intreg.r_r0);
144
  RF (R0_REGNUM + 1, core_reg->intreg.r_r1);
145
  RF (R0_REGNUM + 2, core_reg->intreg.r_r2);
146
  RF (R0_REGNUM + 3, core_reg->intreg.r_r3);
147
  RF (R0_REGNUM + 4, core_reg->intreg.r_r4);
148
  RF (R0_REGNUM + 5, core_reg->intreg.r_r5);
149
  RF (R0_REGNUM + 6, core_reg->intreg.r_r6);
150
  RF (R0_REGNUM + 7, core_reg->intreg.r_r7);
151
 
152
  RF (SP_REGNUM, core_reg->intreg.r_sp);
153
  RF (FP_REGNUM, core_reg->intreg.r_fp);
154
  RF (PC_REGNUM, core_reg->intreg.r_pc);
155
  RF (PS_REGNUM, core_reg->intreg.r_psr);
156
 
157
  /* Floating point registers */
158
  RF (FPS_REGNUM, core_reg->freg.r_fsr);
159
  RF (FP0_REGNUM + 0, core_reg->freg.r_freg[0]);
160
  RF (FP0_REGNUM + 2, core_reg->freg.r_freg[2]);
161
  RF (FP0_REGNUM + 4, core_reg->freg.r_freg[4]);
162
  RF (FP0_REGNUM + 6, core_reg->freg.r_freg[6]);
163
  RF (LP0_REGNUM + 1, core_reg->freg.r_freg[1]);
164
  RF (LP0_REGNUM + 3, core_reg->freg.r_freg[3]);
165
  RF (LP0_REGNUM + 5, core_reg->freg.r_freg[5]);
166
  RF (LP0_REGNUM + 7, core_reg->freg.r_freg[7]);
167
  registers_fetched ();
168
}
169
 
170
/* Register that we are able to handle ns32knbsd core file formats.
171
   FIXME: is this really bfd_target_unknown_flavour? */
172
 
173
static struct core_fns nat_core_fns =
174
{
175
  bfd_target_unknown_flavour,           /* core_flavour */
176
  default_check_format,                 /* check_format */
177
  default_core_sniffer,                 /* core_sniffer */
178
  fetch_core_registers,                 /* core_read_registers */
179
  NULL                                  /* next */
180
};
181
 
182
void
183
_initialize_ns32knbsd_nat (void)
184
{
185
  add_core_fns (&nat_core_fns);
186
}
187
 
188
 
189
/*
190
 * kernel_u_size() is not helpful on NetBSD because
191
 * the "u" struct is NOT in the core dump file.
192
 */
193
 
194
#ifdef  FETCH_KCORE_REGISTERS
195
/*
196
 * Get registers from a kernel crash dump or live kernel.
197
 * Called by kcore-nbsd.c:get_kcore_registers().
198
 */
199
void
200
fetch_kcore_registers (struct pcb *pcb)
201
{
202
  struct switchframe sf;
203
  struct reg intreg;
204
  int dummy;
205
 
206
  /* Integer registers */
207
  if (target_read_memory ((CORE_ADDR) pcb->pcb_ksp, (char *) &sf, sizeof sf))
208
    error ("Cannot read integer registers.");
209
 
210
  /* We use the psr at kernel entry */
211
  if (target_read_memory ((CORE_ADDR) pcb->pcb_onstack, (char *) &intreg, sizeof intreg))
212
    error ("Cannot read processor status register.");
213
 
214
  dummy = 0;
215
  RF (R0_REGNUM + 0, dummy);
216
  RF (R0_REGNUM + 1, dummy);
217
  RF (R0_REGNUM + 2, dummy);
218
  RF (R0_REGNUM + 3, sf.sf_r3);
219
  RF (R0_REGNUM + 4, sf.sf_r4);
220
  RF (R0_REGNUM + 5, sf.sf_r5);
221
  RF (R0_REGNUM + 6, sf.sf_r6);
222
  RF (R0_REGNUM + 7, sf.sf_r7);
223
 
224
  dummy = pcb->pcb_kfp + 8;
225
  RF (SP_REGNUM, dummy);
226
  RF (FP_REGNUM, sf.sf_fp);
227
  RF (PC_REGNUM, sf.sf_pc);
228
  RF (PS_REGNUM, intreg.r_psr);
229
 
230
  /* Floating point registers */
231
  RF (FPS_REGNUM, pcb->pcb_fsr);
232
  RF (FP0_REGNUM + 0, pcb->pcb_freg[0]);
233
  RF (FP0_REGNUM + 2, pcb->pcb_freg[2]);
234
  RF (FP0_REGNUM + 4, pcb->pcb_freg[4]);
235
  RF (FP0_REGNUM + 6, pcb->pcb_freg[6]);
236
  RF (LP0_REGNUM + 1, pcb->pcb_freg[1]);
237
  RF (LP0_REGNUM + 3, pcb->pcb_freg[3]);
238
  RF (LP0_REGNUM + 5, pcb->pcb_freg[5]);
239
  RF (LP0_REGNUM + 7, pcb->pcb_freg[7]);
240
  registers_fetched ();
241
}
242
#endif /* FETCH_KCORE_REGISTERS */
243
 
244
void
245
clear_regs (void)
246
{
247
  double zero = 0.0;
248
  int null = 0;
249
 
250
  /* Integer registers */
251
  RF (R0_REGNUM + 0, null);
252
  RF (R0_REGNUM + 1, null);
253
  RF (R0_REGNUM + 2, null);
254
  RF (R0_REGNUM + 3, null);
255
  RF (R0_REGNUM + 4, null);
256
  RF (R0_REGNUM + 5, null);
257
  RF (R0_REGNUM + 6, null);
258
  RF (R0_REGNUM + 7, null);
259
 
260
  RF (SP_REGNUM, null);
261
  RF (FP_REGNUM, null);
262
  RF (PC_REGNUM, null);
263
  RF (PS_REGNUM, null);
264
 
265
  /* Floating point registers */
266
  RF (FPS_REGNUM, zero);
267
  RF (FP0_REGNUM + 0, zero);
268
  RF (FP0_REGNUM + 2, zero);
269
  RF (FP0_REGNUM + 4, zero);
270
  RF (FP0_REGNUM + 6, zero);
271
  RF (LP0_REGNUM + 0, zero);
272
  RF (LP0_REGNUM + 1, zero);
273
  RF (LP0_REGNUM + 2, zero);
274
  RF (LP0_REGNUM + 3, zero);
275
  return;
276
}
277
 
278
/* Return number of args passed to a frame.
279
   Can return -1, meaning no way to tell. */
280
 
281
int
282
frame_num_args (struct frame_info *fi)
283
{
284
  CORE_ADDR enter_addr;
285
  CORE_ADDR argp;
286
  int inst;
287
  int args;
288
  int i;
289
 
290
  if (read_memory_integer (fi->frame, 4) == 0 && fi->pc < 0x10000)
291
    {
292
      /* main is always called with three args */
293
      return (3);
294
    }
295
  enter_addr = ns32k_get_enter_addr (fi->pc);
296
  if (enter_addr = 0)
297
    return (-1);
298
  argp = enter_addr == 1 ? SAVED_PC_AFTER_CALL (fi) : FRAME_SAVED_PC (fi);
299
  for (i = 0; i < 16; i++)
300
    {
301
      /*
302
       * After a bsr gcc may emit the following instructions
303
       * to remove the arguments from the stack:
304
       *   cmpqd 0,tos        - to remove 4 bytes from the stack
305
       *   cmpd tos,tos       - to remove 8 bytes from the stack
306
       *   adjsp[bwd] -n      - to remove n bytes from the stack
307
       * Gcc sometimes delays emitting these instructions and
308
       * may even throw a branch between our feet.
309
       */
310
      inst = read_memory_integer (argp, 4);
311
      args = read_memory_integer (argp + 2, 4);
312
      if ((inst & 0xff) == 0xea)
313
        {                       /* br */
314
          args = ((inst >> 8) & 0xffffff) | (args << 24);
315
          if (args & 0x80)
316
            {
317
              if (args & 0x40)
318
                {
319
                  args = ntohl (args);
320
                }
321
              else
322
                {
323
                  args = ntohs (args & 0xffff);
324
                  if (args & 0x2000)
325
                    args |= 0xc000;
326
                }
327
            }
328
          else
329
            {
330
              args = args & 0xff;
331
              if (args & 0x40)
332
                args |= 0x80;
333
            }
334
          argp += args;
335
          continue;
336
        }
337
      if ((inst & 0xffff) == 0xb81f)    /* cmpqd 0,tos */
338
        return (1);
339
      else if ((inst & 0xffff) == 0xbdc7)       /* cmpd tos,tos */
340
        return (2);
341
      else if ((inst & 0xfffc) == 0xa57c)
342
        {                       /* adjsp[bwd] */
343
          switch (inst & 3)
344
            {
345
            case 0:
346
              args = ((args & 0xff) + 0x80);
347
              break;
348
            case 1:
349
              args = ((ntohs (args) & 0xffff) + 0x8000);
350
              break;
351
            case 3:
352
              args = -ntohl (args);
353
              break;
354
            default:
355
              return (-1);
356
            }
357
          if (args / 4 > 10 || (args & 3) != 0)
358
            continue;
359
          return (args / 4);
360
        }
361
      argp += 1;
362
    }
363
  return (-1);
364
}

powered by: WebSVN 2.1.0

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