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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [mn10300-linux-tdep.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2
 
3
   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "gdbcore.h"
23
#include "gdb_string.h"
24
#include "regcache.h"
25
#include "mn10300-tdep.h"
26
#include "gdb_assert.h"
27
#include "bfd.h"
28
#include "elf-bfd.h"
29
#include "osabi.h"
30
#include "regset.h"
31
#include "solib-svr4.h"
32
#include "frame.h"
33
#include "trad-frame.h"
34
#include "tramp-frame.h"
35
 
36
#include <stdlib.h>
37
 
38
/* Transliterated from <asm-mn10300/elf.h>...  */
39
#define MN10300_ELF_NGREG 28
40
#define MN10300_ELF_NFPREG 32
41
 
42
typedef gdb_byte   mn10300_elf_greg_t[4];
43
typedef mn10300_elf_greg_t mn10300_elf_gregset_t[MN10300_ELF_NGREG];
44
 
45
typedef gdb_byte   mn10300_elf_fpreg_t[4];
46
typedef struct
47
{
48
  mn10300_elf_fpreg_t fpregs[MN10300_ELF_NFPREG];
49
  gdb_byte    fpcr[4];
50
} mn10300_elf_fpregset_t;
51
 
52
/* elf_gregset_t register indices stolen from include/asm-mn10300/ptrace.h.  */
53
#define MN10300_ELF_GREGSET_T_REG_INDEX_A3      0
54
#define MN10300_ELF_GREGSET_T_REG_INDEX_A2      1
55
#define MN10300_ELF_GREGSET_T_REG_INDEX_D3      2
56
#define MN10300_ELF_GREGSET_T_REG_INDEX_D2      3
57
#define MN10300_ELF_GREGSET_T_REG_INDEX_MCVF    4
58
#define MN10300_ELF_GREGSET_T_REG_INDEX_MCRL    5
59
#define MN10300_ELF_GREGSET_T_REG_INDEX_MCRH    6
60
#define MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ    7
61
#define MN10300_ELF_GREGSET_T_REG_INDEX_E1      8
62
#define MN10300_ELF_GREGSET_T_REG_INDEX_E0      9
63
#define MN10300_ELF_GREGSET_T_REG_INDEX_E7      10
64
#define MN10300_ELF_GREGSET_T_REG_INDEX_E6      11
65
#define MN10300_ELF_GREGSET_T_REG_INDEX_E5      12
66
#define MN10300_ELF_GREGSET_T_REG_INDEX_E4      13
67
#define MN10300_ELF_GREGSET_T_REG_INDEX_E3      14
68
#define MN10300_ELF_GREGSET_T_REG_INDEX_E2      15
69
#define MN10300_ELF_GREGSET_T_REG_INDEX_SP      16
70
#define MN10300_ELF_GREGSET_T_REG_INDEX_LAR     17
71
#define MN10300_ELF_GREGSET_T_REG_INDEX_LIR     18
72
#define MN10300_ELF_GREGSET_T_REG_INDEX_MDR     19
73
#define MN10300_ELF_GREGSET_T_REG_INDEX_A1      20
74
#define MN10300_ELF_GREGSET_T_REG_INDEX_A0      21
75
#define MN10300_ELF_GREGSET_T_REG_INDEX_D1      22
76
#define MN10300_ELF_GREGSET_T_REG_INDEX_D0      23
77
#define MN10300_ELF_GREGSET_T_REG_INDEX_ORIG_D0 24
78
#define MN10300_ELF_GREGSET_T_REG_INDEX_EPSW    25
79
#define MN10300_ELF_GREGSET_T_REG_INDEX_PC      26
80
 
81
/* New gdbarch API for corefile registers.
82
   Given a section name and size, create a struct reg object
83
   with a supply_register and a collect_register method.  */
84
 
85
/* Copy register value of REGNUM from regset to regcache.
86
   If REGNUM is -1, do this for all gp registers in regset.  */
87
 
88
static void
89
am33_supply_gregset_method (const struct regset *regset,
90
                            struct regcache *regcache,
91
                            int regnum, const void *gregs, size_t len)
92
{
93
  char zerobuf[MAX_REGISTER_SIZE];
94
  const mn10300_elf_greg_t *regp = (const mn10300_elf_greg_t *) gregs;
95
  int i;
96
 
97
  gdb_assert (len == sizeof (mn10300_elf_gregset_t));
98
 
99
  switch (regnum) {
100
  case E_D0_REGNUM:
101
    regcache_raw_supply (regcache, E_D0_REGNUM,
102
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D0));
103
    break;
104
  case E_D1_REGNUM:
105
    regcache_raw_supply (regcache, E_D1_REGNUM,
106
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D1));
107
    break;
108
  case E_D2_REGNUM:
109
    regcache_raw_supply (regcache, E_D2_REGNUM,
110
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D2));
111
    break;
112
  case E_D3_REGNUM:
113
    regcache_raw_supply (regcache, E_D3_REGNUM,
114
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D3));
115
    break;
116
  case E_A0_REGNUM:
117
    regcache_raw_supply (regcache, E_A0_REGNUM,
118
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A0));
119
    break;
120
  case E_A1_REGNUM:
121
    regcache_raw_supply (regcache, E_A1_REGNUM,
122
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A1));
123
    break;
124
  case E_A2_REGNUM:
125
    regcache_raw_supply (regcache, E_A2_REGNUM,
126
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A2));
127
    break;
128
  case E_A3_REGNUM:
129
    regcache_raw_supply (regcache, E_A3_REGNUM,
130
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A3));
131
    break;
132
  case E_SP_REGNUM:
133
    regcache_raw_supply (regcache, E_SP_REGNUM,
134
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_SP));
135
    break;
136
  case E_PC_REGNUM:
137
    regcache_raw_supply (regcache, E_PC_REGNUM,
138
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_PC));
139
    break;
140
  case E_MDR_REGNUM:
141
    regcache_raw_supply (regcache, E_MDR_REGNUM,
142
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDR));
143
    break;
144
  case E_PSW_REGNUM:
145
    regcache_raw_supply (regcache, E_PSW_REGNUM,
146
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_EPSW));
147
    break;
148
  case E_LIR_REGNUM:
149
    regcache_raw_supply (regcache, E_LIR_REGNUM,
150
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LIR));
151
    break;
152
  case E_LAR_REGNUM:
153
    regcache_raw_supply (regcache, E_LAR_REGNUM,
154
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LAR));
155
    break;
156
  case E_MDRQ_REGNUM:
157
    regcache_raw_supply (regcache, E_MDRQ_REGNUM,
158
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ));
159
    break;
160
  case E_E0_REGNUM:
161
    regcache_raw_supply (regcache, E_E0_REGNUM,
162
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E0));
163
    break;
164
  case E_E1_REGNUM:
165
    regcache_raw_supply (regcache, E_E1_REGNUM,
166
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E1));
167
    break;
168
  case E_E2_REGNUM:
169
    regcache_raw_supply (regcache, E_E2_REGNUM,
170
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E2));
171
    break;
172
  case E_E3_REGNUM:
173
    regcache_raw_supply (regcache, E_E3_REGNUM,
174
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E3));
175
    break;
176
  case E_E4_REGNUM:
177
    regcache_raw_supply (regcache, E_E4_REGNUM,
178
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E4));
179
    break;
180
  case E_E5_REGNUM:
181
    regcache_raw_supply (regcache, E_E5_REGNUM,
182
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E5));
183
    break;
184
  case E_E6_REGNUM:
185
    regcache_raw_supply (regcache, E_E6_REGNUM,
186
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E6));
187
    break;
188
  case E_E7_REGNUM:
189
    regcache_raw_supply (regcache, E_E7_REGNUM,
190
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E7));
191
    break;
192
 
193
    /* ssp, msp, and usp are inaccessible.  */
194
  case E_E8_REGNUM:
195
    memset (zerobuf, 0, MAX_REGISTER_SIZE);
196
    regcache_raw_supply (regcache, E_E8_REGNUM, zerobuf);
197
    break;
198
  case E_E9_REGNUM:
199
    memset (zerobuf, 0, MAX_REGISTER_SIZE);
200
    regcache_raw_supply (regcache, E_E9_REGNUM, zerobuf);
201
    break;
202
  case E_E10_REGNUM:
203
    memset (zerobuf, 0, MAX_REGISTER_SIZE);
204
    regcache_raw_supply (regcache, E_E10_REGNUM, zerobuf);
205
 
206
    break;
207
  case E_MCRH_REGNUM:
208
    regcache_raw_supply (regcache, E_MCRH_REGNUM,
209
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRH));
210
    break;
211
  case E_MCRL_REGNUM:
212
    regcache_raw_supply (regcache, E_MCRL_REGNUM,
213
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRL));
214
    break;
215
  case E_MCVF_REGNUM:
216
    regcache_raw_supply (regcache, E_MCVF_REGNUM,
217
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCVF));
218
    break;
219
  case E_FPCR_REGNUM:
220
    /* FPCR is numbered among the GP regs, but handled as an FP reg.
221
       Do nothing.  */
222
    break;
223
  case E_FPCR_REGNUM + 1:
224
    /* The two unused registers beyond fpcr are inaccessible.  */
225
    memset (zerobuf, 0, MAX_REGISTER_SIZE);
226
    regcache_raw_supply (regcache, E_FPCR_REGNUM + 1, zerobuf);
227
    break;
228
  case E_FPCR_REGNUM + 2:
229
    memset (zerobuf, 0, MAX_REGISTER_SIZE);
230
    regcache_raw_supply (regcache, E_FPCR_REGNUM + 2, zerobuf);
231
    break;
232
  default:      /* An error, obviously, but should we error out?  */
233
    break;
234
  case -1:
235
    for (i = 0; i < MN10300_ELF_NGREG; i++)
236
      am33_supply_gregset_method (regset, regcache, i, gregs, len);
237
    break;
238
  }
239
  return;
240
}
241
 
242
/* Copy fp register value of REGNUM from regset to regcache.
243
   If REGNUM is -1, do this for all fp registers in regset. */
244
 
245
static void
246
am33_supply_fpregset_method (const struct regset *regset,
247
                             struct regcache *regcache,
248
                             int regnum, const void *fpregs, size_t len)
249
{
250
  const mn10300_elf_fpregset_t *fpregset = fpregs;
251
 
252
  gdb_assert (len == sizeof (mn10300_elf_fpregset_t));
253
 
254
  if (regnum == -1)
255
    {
256
      int i;
257
 
258
      for (i = 0; i < MN10300_ELF_NFPREG; i++)
259
        am33_supply_fpregset_method (regset, regcache,
260
                                     E_FS0_REGNUM + i, fpregs, len);
261
      am33_supply_fpregset_method (regset, regcache,
262
                                   E_FPCR_REGNUM, fpregs, len);
263
    }
264
  else if (regnum == E_FPCR_REGNUM)
265
    regcache_raw_supply (regcache, E_FPCR_REGNUM,
266
                         &fpregset->fpcr);
267
  else if (E_FS0_REGNUM <= regnum && regnum < E_FS0_REGNUM + MN10300_ELF_NFPREG)
268
    regcache_raw_supply (regcache, regnum,
269
                         &fpregset->fpregs[regnum - E_FS0_REGNUM]);
270
 
271
  return;
272
}
273
 
274
/* Copy register values from regcache to regset.  */
275
 
276
static void
277
am33_collect_gregset_method (const struct regset *regset,
278
                             const struct regcache *regcache,
279
                             int regnum, void *gregs, size_t len)
280
{
281
  mn10300_elf_gregset_t *regp = gregs;
282
  int i;
283
 
284
  gdb_assert (len == sizeof (mn10300_elf_gregset_t));
285
 
286
  switch (regnum) {
287
  case E_D0_REGNUM:
288
    regcache_raw_collect (regcache, E_D0_REGNUM,
289
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D0));
290
    break;
291
  case E_D1_REGNUM:
292
    regcache_raw_collect (regcache, E_D1_REGNUM,
293
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D1));
294
    break;
295
  case E_D2_REGNUM:
296
    regcache_raw_collect (regcache, E_D2_REGNUM,
297
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D2));
298
    break;
299
  case E_D3_REGNUM:
300
    regcache_raw_collect (regcache, E_D3_REGNUM,
301
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_D3));
302
    break;
303
  case E_A0_REGNUM:
304
    regcache_raw_collect (regcache, E_A0_REGNUM,
305
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A0));
306
    break;
307
  case E_A1_REGNUM:
308
    regcache_raw_collect (regcache, E_A1_REGNUM,
309
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A1));
310
    break;
311
  case E_A2_REGNUM:
312
    regcache_raw_collect (regcache, E_A2_REGNUM,
313
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A2));
314
    break;
315
  case E_A3_REGNUM:
316
    regcache_raw_collect (regcache, E_A3_REGNUM,
317
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_A3));
318
    break;
319
  case E_SP_REGNUM:
320
    regcache_raw_collect (regcache, E_SP_REGNUM,
321
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_SP));
322
    break;
323
  case E_PC_REGNUM:
324
    regcache_raw_collect (regcache, E_PC_REGNUM,
325
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_PC));
326
    break;
327
  case E_MDR_REGNUM:
328
    regcache_raw_collect (regcache, E_MDR_REGNUM,
329
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDR));
330
    break;
331
  case E_PSW_REGNUM:
332
    regcache_raw_collect (regcache, E_PSW_REGNUM,
333
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_EPSW));
334
    break;
335
  case E_LIR_REGNUM:
336
    regcache_raw_collect (regcache, E_LIR_REGNUM,
337
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LIR));
338
    break;
339
  case E_LAR_REGNUM:
340
    regcache_raw_collect (regcache, E_LAR_REGNUM,
341
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_LAR));
342
    break;
343
  case E_MDRQ_REGNUM:
344
    regcache_raw_collect (regcache, E_MDRQ_REGNUM,
345
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MDRQ));
346
    break;
347
  case E_E0_REGNUM:
348
    regcache_raw_collect (regcache, E_E0_REGNUM,
349
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E0));
350
    break;
351
  case E_E1_REGNUM:
352
    regcache_raw_collect (regcache, E_E1_REGNUM,
353
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E1));
354
    break;
355
  case E_E2_REGNUM:
356
    regcache_raw_collect (regcache, E_E2_REGNUM,
357
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E2));
358
    break;
359
  case E_E3_REGNUM:
360
    regcache_raw_collect (regcache, E_E3_REGNUM,
361
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E3));
362
    break;
363
  case E_E4_REGNUM:
364
    regcache_raw_collect (regcache, E_E4_REGNUM,
365
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E4));
366
    break;
367
  case E_E5_REGNUM:
368
    regcache_raw_collect (regcache, E_E5_REGNUM,
369
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E5));
370
    break;
371
  case E_E6_REGNUM:
372
    regcache_raw_collect (regcache, E_E6_REGNUM,
373
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E6));
374
    break;
375
  case E_E7_REGNUM:
376
    regcache_raw_collect (regcache, E_E7_REGNUM,
377
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_E7));
378
    break;
379
 
380
    /* ssp, msp, and usp are inaccessible.  */
381
  case E_E8_REGNUM:
382
    /* The gregset struct has noplace to put this: do nothing.  */
383
    break;
384
  case E_E9_REGNUM:
385
    /* The gregset struct has noplace to put this: do nothing.  */
386
    break;
387
  case E_E10_REGNUM:
388
    /* The gregset struct has noplace to put this: do nothing.  */
389
    break;
390
  case E_MCRH_REGNUM:
391
    regcache_raw_collect (regcache, E_MCRH_REGNUM,
392
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRH));
393
    break;
394
  case E_MCRL_REGNUM:
395
    regcache_raw_collect (regcache, E_MCRL_REGNUM,
396
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCRL));
397
    break;
398
  case E_MCVF_REGNUM:
399
    regcache_raw_collect (regcache, E_MCVF_REGNUM,
400
                         (regp + MN10300_ELF_GREGSET_T_REG_INDEX_MCVF));
401
    break;
402
  case E_FPCR_REGNUM:
403
    /* FPCR is numbered among the GP regs, but handled as an FP reg.
404
       Do nothing.  */
405
    break;
406
  case E_FPCR_REGNUM + 1:
407
    /* The gregset struct has noplace to put this: do nothing.  */
408
    break;
409
  case E_FPCR_REGNUM + 2:
410
    /* The gregset struct has noplace to put this: do nothing.  */
411
    break;
412
  default:      /* An error, obviously, but should we error out?  */
413
    break;
414
  case -1:
415
    for (i = 0; i < MN10300_ELF_NGREG; i++)
416
      am33_collect_gregset_method (regset, regcache, i, gregs, len);
417
    break;
418
  }
419
  return;
420
}
421
 
422
/* Copy fp register values from regcache to regset.  */
423
 
424
static void
425
am33_collect_fpregset_method (const struct regset *regset,
426
                              const struct regcache *regcache,
427
                              int regnum, void *fpregs, size_t len)
428
{
429
  mn10300_elf_fpregset_t *fpregset = fpregs;
430
 
431
  gdb_assert (len == sizeof (mn10300_elf_fpregset_t));
432
 
433
  if (regnum == -1)
434
    {
435
      int i;
436
      for (i = 0; i < MN10300_ELF_NFPREG; i++)
437
        am33_collect_fpregset_method (regset, regcache, E_FS0_REGNUM + i,
438
                                      fpregs, len);
439
      am33_collect_fpregset_method (regset, regcache,
440
                                    E_FPCR_REGNUM, fpregs, len);
441
    }
442
  else if (regnum == E_FPCR_REGNUM)
443
    regcache_raw_collect (regcache, E_FPCR_REGNUM,
444
                          &fpregset->fpcr);
445
  else if (E_FS0_REGNUM <= regnum
446
           && regnum < E_FS0_REGNUM + MN10300_ELF_NFPREG)
447
    regcache_raw_collect (regcache, regnum,
448
                          &fpregset->fpregs[regnum - E_FS0_REGNUM]);
449
 
450
  return;
451
}
452
 
453
/* Create a struct regset from a corefile register section.  */
454
 
455
static const struct regset *
456
am33_regset_from_core_section (struct gdbarch *gdbarch,
457
                               const char *sect_name,
458
                               size_t sect_size)
459
{
460
  /* We will call regset_alloc, and pass the names of the supply and
461
     collect methods.  */
462
 
463
  if (sect_size == sizeof (mn10300_elf_fpregset_t))
464
    return regset_alloc (gdbarch,
465
                         am33_supply_fpregset_method,
466
                         am33_collect_fpregset_method);
467
  else
468
    return regset_alloc (gdbarch,
469
                         am33_supply_gregset_method,
470
                         am33_collect_gregset_method);
471
}
472
 
473
static void
474
am33_linux_sigframe_cache_init (const struct tramp_frame *self,
475
                                struct frame_info *next_frame,
476
                                struct trad_frame_cache *this_cache,
477
                                CORE_ADDR func);
478
 
479
static const struct tramp_frame am33_linux_sigframe = {
480
  SIGTRAMP_FRAME,
481
  1,
482
  {
483
    /* mov     119,d0 */
484
    { 0x2c, -1 },
485
    { 0x77, -1 },
486
    { 0x00, -1 },
487
    /* syscall 0 */
488
    { 0xf0, -1 },
489
    { 0xe0, -1 },
490
    { TRAMP_SENTINEL_INSN, -1 }
491
  },
492
  am33_linux_sigframe_cache_init
493
};
494
 
495
static const struct tramp_frame am33_linux_rt_sigframe = {
496
  SIGTRAMP_FRAME,
497
  1,
498
  {
499
    /* mov     173,d0 */
500
    { 0x2c, -1 },
501
    { 0xad, -1 },
502
    { 0x00, -1 },
503
    /* syscall 0 */
504
    { 0xf0, -1 },
505
    { 0xe0, -1 },
506
    { TRAMP_SENTINEL_INSN, -1 }
507
  },
508
  am33_linux_sigframe_cache_init
509
};
510
 
511
/* Relevant struct definitions for signal handling...
512
 
513
From arch/mn10300/kernel/sigframe.h:
514
 
515
struct sigframe
516
{
517
        void (*pretcode)(void);
518
        int sig;
519
        struct sigcontext *psc;
520
        struct sigcontext sc;
521
        struct fpucontext fpuctx;
522
        unsigned long extramask[_NSIG_WORDS-1];
523
        char retcode[8];
524
};
525
 
526
struct rt_sigframe
527
{
528
        void (*pretcode)(void);
529
        int sig;
530
        struct siginfo *pinfo;
531
        void *puc;
532
        struct siginfo info;
533
        struct ucontext uc;
534
        struct fpucontext fpuctx;
535
        char retcode[8];
536
};
537
 
538
From include/asm-mn10300/ucontext.h:
539
 
540
struct ucontext {
541
        unsigned long     uc_flags;
542
        struct ucontext  *uc_link;
543
        stack_t           uc_stack;
544
        struct sigcontext uc_mcontext;
545
        sigset_t          uc_sigmask;
546
};
547
 
548
From include/asm-mn10300/sigcontext.h:
549
 
550
struct fpucontext {
551
        unsigned long   fs[32];
552
        unsigned long   fpcr;
553
};
554
 
555
struct sigcontext {
556
        unsigned long   d0;
557
        unsigned long   d1;
558
        unsigned long   d2;
559
        unsigned long   d3;
560
        unsigned long   a0;
561
        unsigned long   a1;
562
        unsigned long   a2;
563
        unsigned long   a3;
564
        unsigned long   e0;
565
        unsigned long   e1;
566
        unsigned long   e2;
567
        unsigned long   e3;
568
        unsigned long   e4;
569
        unsigned long   e5;
570
        unsigned long   e6;
571
        unsigned long   e7;
572
        unsigned long   lar;
573
        unsigned long   lir;
574
        unsigned long   mdr;
575
        unsigned long   mcvf;
576
        unsigned long   mcrl;
577
        unsigned long   mcrh;
578
        unsigned long   mdrq;
579
        unsigned long   sp;
580
        unsigned long   epsw;
581
        unsigned long   pc;
582
        struct fpucontext *fpucontext;
583
        unsigned long   oldmask;
584
}; */
585
 
586
 
587
#define AM33_SIGCONTEXT_D0 0
588
#define AM33_SIGCONTEXT_D1 4
589
#define AM33_SIGCONTEXT_D2 8
590
#define AM33_SIGCONTEXT_D3 12
591
#define AM33_SIGCONTEXT_A0 16
592
#define AM33_SIGCONTEXT_A1 20
593
#define AM33_SIGCONTEXT_A2 24
594
#define AM33_SIGCONTEXT_A3 28
595
#define AM33_SIGCONTEXT_E0 32
596
#define AM33_SIGCONTEXT_E1 36
597
#define AM33_SIGCONTEXT_E2 40
598
#define AM33_SIGCONTEXT_E3 44
599
#define AM33_SIGCONTEXT_E4 48
600
#define AM33_SIGCONTEXT_E5 52
601
#define AM33_SIGCONTEXT_E6 56
602
#define AM33_SIGCONTEXT_E7 60
603
#define AM33_SIGCONTEXT_LAR 64
604
#define AM33_SIGCONTEXT_LIR 68
605
#define AM33_SIGCONTEXT_MDR 72
606
#define AM33_SIGCONTEXT_MCVF 76
607
#define AM33_SIGCONTEXT_MCRL 80
608
#define AM33_SIGCONTEXT_MCRH 84
609
#define AM33_SIGCONTEXT_MDRQ 88
610
#define AM33_SIGCONTEXT_SP 92
611
#define AM33_SIGCONTEXT_EPSW 96
612
#define AM33_SIGCONTEXT_PC 100
613
#define AM33_SIGCONTEXT_FPUCONTEXT 104
614
 
615
 
616
static void
617
am33_linux_sigframe_cache_init (const struct tramp_frame *self,
618
                                struct frame_info *next_frame,
619
                                struct trad_frame_cache *this_cache,
620
                                CORE_ADDR func)
621
{
622
  CORE_ADDR sc_base, fpubase;
623
  int i;
624
 
625
  sc_base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
626
  if (self == &am33_linux_sigframe)
627
    {
628
      sc_base += 8;
629
      sc_base = get_frame_memory_unsigned (next_frame, sc_base, 4);
630
    }
631
  else
632
    {
633
      sc_base += 12;
634
      sc_base = get_frame_memory_unsigned (next_frame, sc_base, 4);
635
      sc_base += 20;
636
    }
637
 
638
  trad_frame_set_reg_addr (this_cache, E_D0_REGNUM,
639
                           sc_base + AM33_SIGCONTEXT_D0);
640
  trad_frame_set_reg_addr (this_cache, E_D1_REGNUM,
641
                           sc_base + AM33_SIGCONTEXT_D1);
642
  trad_frame_set_reg_addr (this_cache, E_D2_REGNUM,
643
                           sc_base + AM33_SIGCONTEXT_D2);
644
  trad_frame_set_reg_addr (this_cache, E_D3_REGNUM,
645
                           sc_base + AM33_SIGCONTEXT_D3);
646
 
647
  trad_frame_set_reg_addr (this_cache, E_A0_REGNUM,
648
                           sc_base + AM33_SIGCONTEXT_A0);
649
  trad_frame_set_reg_addr (this_cache, E_A1_REGNUM,
650
                           sc_base + AM33_SIGCONTEXT_A1);
651
  trad_frame_set_reg_addr (this_cache, E_A2_REGNUM,
652
                           sc_base + AM33_SIGCONTEXT_A2);
653
  trad_frame_set_reg_addr (this_cache, E_A3_REGNUM,
654
                           sc_base + AM33_SIGCONTEXT_A3);
655
 
656
  trad_frame_set_reg_addr (this_cache, E_E0_REGNUM,
657
                           sc_base + AM33_SIGCONTEXT_E0);
658
  trad_frame_set_reg_addr (this_cache, E_E1_REGNUM,
659
                           sc_base + AM33_SIGCONTEXT_E1);
660
  trad_frame_set_reg_addr (this_cache, E_E2_REGNUM,
661
                           sc_base + AM33_SIGCONTEXT_E2);
662
  trad_frame_set_reg_addr (this_cache, E_E3_REGNUM,
663
                           sc_base + AM33_SIGCONTEXT_E3);
664
  trad_frame_set_reg_addr (this_cache, E_E4_REGNUM,
665
                           sc_base + AM33_SIGCONTEXT_E4);
666
  trad_frame_set_reg_addr (this_cache, E_E5_REGNUM,
667
                           sc_base + AM33_SIGCONTEXT_E5);
668
  trad_frame_set_reg_addr (this_cache, E_E6_REGNUM,
669
                           sc_base + AM33_SIGCONTEXT_E6);
670
  trad_frame_set_reg_addr (this_cache, E_E7_REGNUM,
671
                           sc_base + AM33_SIGCONTEXT_E7);
672
 
673
  trad_frame_set_reg_addr (this_cache, E_LAR_REGNUM,
674
                           sc_base + AM33_SIGCONTEXT_LAR);
675
  trad_frame_set_reg_addr (this_cache, E_LIR_REGNUM,
676
                           sc_base + AM33_SIGCONTEXT_LIR);
677
  trad_frame_set_reg_addr (this_cache, E_MDR_REGNUM,
678
                           sc_base + AM33_SIGCONTEXT_MDR);
679
  trad_frame_set_reg_addr (this_cache, E_MCVF_REGNUM,
680
                           sc_base + AM33_SIGCONTEXT_MCVF);
681
  trad_frame_set_reg_addr (this_cache, E_MCRL_REGNUM,
682
                           sc_base + AM33_SIGCONTEXT_MCRL);
683
  trad_frame_set_reg_addr (this_cache, E_MDRQ_REGNUM,
684
                           sc_base + AM33_SIGCONTEXT_MDRQ);
685
 
686
  trad_frame_set_reg_addr (this_cache, E_SP_REGNUM,
687
                           sc_base + AM33_SIGCONTEXT_SP);
688
  trad_frame_set_reg_addr (this_cache, E_PSW_REGNUM,
689
                           sc_base + AM33_SIGCONTEXT_EPSW);
690
  trad_frame_set_reg_addr (this_cache, E_PC_REGNUM,
691
                           sc_base + AM33_SIGCONTEXT_PC);
692
 
693
  fpubase = get_frame_memory_unsigned (next_frame,
694
                                       sc_base + AM33_SIGCONTEXT_FPUCONTEXT, 4);
695
  if (fpubase)
696
    {
697
      for (i = 0; i < 32; i++)
698
        {
699
          trad_frame_set_reg_addr (this_cache, E_FS0_REGNUM + i,
700
                                   fpubase + 4 * i);
701
        }
702
      trad_frame_set_reg_addr (this_cache, E_FPCR_REGNUM, fpubase + 4 * 32);
703
    }
704
 
705
  trad_frame_set_id (this_cache, frame_id_build (sc_base, func));
706
}
707
 
708
/* AM33 GNU/Linux osabi has been recognized.
709
   Now's our chance to register our corefile handling.  */
710
 
711
static void
712
am33_linux_init_osabi (struct gdbarch_info gdbinfo, struct gdbarch *gdbarch)
713
{
714
  set_gdbarch_regset_from_core_section (gdbarch,
715
                                        am33_regset_from_core_section);
716
  set_solib_svr4_fetch_link_map_offsets
717
    (gdbarch, svr4_ilp32_fetch_link_map_offsets);
718
 
719
  tramp_frame_prepend_unwinder (gdbarch, &am33_linux_sigframe);
720
  tramp_frame_prepend_unwinder (gdbarch, &am33_linux_rt_sigframe);
721
}
722
 
723
void
724
_initialize_mn10300_linux_tdep (void)
725
{
726
  gdbarch_register_osabi (bfd_arch_mn10300, 0,
727
                          GDB_OSABI_LINUX, am33_linux_init_osabi);
728
}
729
 

powered by: WebSVN 2.1.0

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