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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [hppa-linux-tdep.c] - Blame information for rev 461

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

Line No. Rev Author Line
1 227 jeremybenn
/* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
2
 
3
   Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010
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 "osabi.h"
24
#include "target.h"
25
#include "objfiles.h"
26
#include "solib-svr4.h"
27
#include "glibc-tdep.h"
28
#include "frame-unwind.h"
29
#include "trad-frame.h"
30
#include "dwarf2-frame.h"
31
#include "value.h"
32
#include "regset.h"
33
#include "regcache.h"
34
#include "hppa-tdep.h"
35
 
36
#include "elf/common.h"
37
 
38
/* Map DWARF DBX register numbers to GDB register numbers.  */
39
static int
40
hppa_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
41
{
42
  /* The general registers and the sar are the same in both sets.  */
43
  if (reg <= 32)
44
    return reg;
45
 
46
  /* fr4-fr31 (left and right halves) are mapped from 72.  */
47
  if (reg >= 72 && reg <= 72 + 28 * 2)
48
    return HPPA_FP4_REGNUM + (reg - 72);
49
 
50
  warning (_("Unmapped DWARF DBX Register #%d encountered."), reg);
51
  return -1;
52
}
53
 
54
static void
55
hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v)
56
{
57
  /* Probably this should be done by the kernel, but it isn't.  */
58
  regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3);
59
  regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3);
60
}
61
 
62
/* An instruction to match.  */
63
struct insn_pattern
64
{
65
  unsigned int data;            /* See if it matches this....  */
66
  unsigned int mask;            /* ... with this mask.  */
67
};
68
 
69
static struct insn_pattern hppa_sigtramp[] = {
70
  /* ldi 0, %r25 or ldi 1, %r25 */
71
  { 0x34190000, 0xfffffffd },
72
  /* ldi __NR_rt_sigreturn, %r20 */
73
  { 0x3414015a, 0xffffffff },
74
  /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
75
  { 0xe4008200, 0xffffffff },
76
  /* nop */
77
  { 0x08000240, 0xffffffff },
78
  { 0, 0 }
79
};
80
 
81
#define HPPA_MAX_INSN_PATTERN_LEN (4)
82
 
83
/* Return non-zero if the instructions at PC match the series
84
   described in PATTERN, or zero otherwise.  PATTERN is an array of
85
   'struct insn_pattern' objects, terminated by an entry whose mask is
86
   zero.
87
 
88
   When the match is successful, fill INSN[i] with what PATTERN[i]
89
   matched.  */
90
static int
91
insns_match_pattern (struct gdbarch *gdbarch, CORE_ADDR pc,
92
                     struct insn_pattern *pattern,
93
                     unsigned int *insn)
94
{
95
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
96
  int i;
97
  CORE_ADDR npc = pc;
98
 
99
  for (i = 0; pattern[i].mask; i++)
100
    {
101
      char buf[4];
102
 
103
      target_read_memory (npc, buf, 4);
104
      insn[i] = extract_unsigned_integer (buf, 4, byte_order);
105
      if ((insn[i] & pattern[i].mask) == pattern[i].data)
106
        npc += 4;
107
      else
108
        return 0;
109
    }
110
  return 1;
111
}
112
 
113
/* Signal frames.  */
114
 
115
/* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
116
 
117
   Unfortunately, because of various bugs and changes to the kernel,
118
   we have several cases to deal with.
119
 
120
   In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
121
   the beginning of the trampoline and struct rt_sigframe.
122
 
123
   In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
124
   the 4th word in the trampoline structure.  This is wrong, it should point
125
   at the 5th word.  This is fixed in 2.6.5-rc2-pa4.
126
 
127
   To detect these cases, we first take pc, align it to 64-bytes
128
   to get the beginning of the signal frame, and then check offsets 0, 4
129
   and 5 to see if we found the beginning of the trampoline.  This will
130
   tell us how to locate the sigcontext structure.
131
 
132
   Note that with a 2.4 64-bit kernel, the signal context is not properly
133
   passed back to userspace so the unwind will not work correctly.  */
134
static CORE_ADDR
135
hppa_linux_sigtramp_find_sigcontext (struct gdbarch *gdbarch, CORE_ADDR pc)
136
{
137
  unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
138
  int offs = 0;
139
  int try;
140
  /* offsets to try to find the trampoline */
141
  static int pcoffs[] = { 0, 4*4, 5*4 };
142
  /* offsets to the rt_sigframe structure */
143
  static int sfoffs[] = { 4*4, 10*4, 10*4 };
144
  CORE_ADDR sp;
145
 
146
  /* Most of the time, this will be correct.  The one case when this will
147
     fail is if the user defined an alternate stack, in which case the
148
     beginning of the stack will not be align_down (pc, 64).  */
149
  sp = align_down (pc, 64);
150
 
151
  /* rt_sigreturn trampoline:
152
     3419000x ldi 0, %r25 or ldi 1, %r25   (x = 0 or 2)
153
     3414015a ldi __NR_rt_sigreturn, %r20
154
     e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
155
     08000240 nop  */
156
 
157
  for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
158
    {
159
      if (insns_match_pattern (gdbarch, sp + pcoffs[try],
160
                               hppa_sigtramp, dummy))
161
        {
162
          offs = sfoffs[try];
163
          break;
164
        }
165
    }
166
 
167
  if (offs == 0)
168
    {
169
      if (insns_match_pattern (gdbarch, pc, hppa_sigtramp, dummy))
170
        {
171
          /* sigaltstack case: we have no way of knowing which offset to
172
             use in this case; default to new kernel handling. If this is
173
             wrong the unwinding will fail.  */
174
          try = 2;
175
          sp = pc - pcoffs[try];
176
        }
177
      else
178
      {
179
        return 0;
180
      }
181
    }
182
 
183
  /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
184
     a struct siginfo and a struct ucontext.  struct ucontext contains
185
     a struct sigcontext. Return an offset to this sigcontext here.  Too
186
     bad we cannot include system specific headers :-(.
187
     sizeof(struct siginfo) == 128
188
     offsetof(struct ucontext, uc_mcontext) == 24.  */
189
  return sp + sfoffs[try] + 128 + 24;
190
}
191
 
192
struct hppa_linux_sigtramp_unwind_cache
193
{
194
  CORE_ADDR base;
195
  struct trad_frame_saved_reg *saved_regs;
196
};
197
 
198
static struct hppa_linux_sigtramp_unwind_cache *
199
hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
200
                                        void **this_cache)
201
{
202
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
203
  struct hppa_linux_sigtramp_unwind_cache *info;
204
  CORE_ADDR pc, scptr;
205
  int i;
206
 
207
  if (*this_cache)
208
    return *this_cache;
209
 
210
  info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
211
  *this_cache = info;
212
  info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
213
 
214
  pc = get_frame_pc (this_frame);
215
  scptr = hppa_linux_sigtramp_find_sigcontext (gdbarch, pc);
216
 
217
  /* structure of struct sigcontext:
218
 
219
     struct sigcontext {
220
        unsigned long sc_flags;
221
        unsigned long sc_gr[32];
222
        unsigned long long sc_fr[32];
223
        unsigned long sc_iasq[2];
224
        unsigned long sc_iaoq[2];
225
        unsigned long sc_sar;           */
226
 
227
  /* Skip sc_flags.  */
228
  scptr += 4;
229
 
230
  /* GR[0] is the psw.  */
231
  info->saved_regs[HPPA_IPSW_REGNUM].addr = scptr;
232
  scptr += 4;
233
 
234
  /* General registers.  */
235
  for (i = 1; i < 32; i++)
236
    {
237
      info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
238
      scptr += 4;
239
    }
240
 
241
  /* Pad to long long boundary.  */
242
  scptr += 4;
243
 
244
  /* FP regs; FP0-3 are not restored.  */
245
  scptr += (8 * 4);
246
 
247
  for (i = 4; i < 32; i++)
248
    {
249
      info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
250
      scptr += 4;
251
      info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
252
      scptr += 4;
253
    }
254
 
255
  /* IASQ/IAOQ. */
256
  info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
257
  scptr += 4;
258
  info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
259
  scptr += 4;
260
 
261
  info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
262
  scptr += 4;
263
  info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
264
  scptr += 4;
265
 
266
  info->saved_regs[HPPA_SAR_REGNUM].addr = scptr;
267
 
268
  info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
269
 
270
  return info;
271
}
272
 
273
static void
274
hppa_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
275
                                   void **this_prologue_cache,
276
                                   struct frame_id *this_id)
277
{
278
  struct hppa_linux_sigtramp_unwind_cache *info
279
    = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
280
  *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
281
}
282
 
283
static struct value *
284
hppa_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
285
                                         void **this_prologue_cache,
286
                                         int regnum)
287
{
288
  struct hppa_linux_sigtramp_unwind_cache *info
289
    = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
290
  return hppa_frame_prev_register_helper (this_frame,
291
                                          info->saved_regs, regnum);
292
}
293
 
294
/* hppa-linux always uses "new-style" rt-signals.  The signal handler's return
295
   address should point to a signal trampoline on the stack.  The signal
296
   trampoline is embedded in a rt_sigframe structure that is aligned on
297
   the stack.  We take advantage of the fact that sp must be 64-byte aligned,
298
   and the trampoline is small, so by rounding down the trampoline address
299
   we can find the beginning of the struct rt_sigframe.  */
300
static int
301
hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
302
                                   struct frame_info *this_frame,
303
                                   void **this_prologue_cache)
304
{
305
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
306
  CORE_ADDR pc = get_frame_pc (this_frame);
307
 
308
  if (hppa_linux_sigtramp_find_sigcontext (gdbarch, pc))
309
    return 1;
310
 
311
  return 0;
312
}
313
 
314
static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
315
  SIGTRAMP_FRAME,
316
  hppa_linux_sigtramp_frame_this_id,
317
  hppa_linux_sigtramp_frame_prev_register,
318
  NULL,
319
  hppa_linux_sigtramp_frame_sniffer
320
};
321
 
322
/* Attempt to find (and return) the global pointer for the given
323
   function.
324
 
325
   This is a rather nasty bit of code searchs for the .dynamic section
326
   in the objfile corresponding to the pc of the function we're trying
327
   to call.  Once it finds the addresses at which the .dynamic section
328
   lives in the child process, it scans the Elf32_Dyn entries for a
329
   DT_PLTGOT tag.  If it finds one of these, the corresponding
330
   d_un.d_ptr value is the global pointer.  */
331
 
332
static CORE_ADDR
333
hppa_linux_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
334
{
335
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
336
  struct obj_section *faddr_sect;
337
  CORE_ADDR faddr;
338
 
339
  faddr = value_as_address (function);
340
 
341
  /* Is this a plabel? If so, dereference it to get the gp value.  */
342
  if (faddr & 2)
343
    {
344
      int status;
345
      char buf[4];
346
 
347
      faddr &= ~3;
348
 
349
      status = target_read_memory (faddr + 4, buf, sizeof (buf));
350
      if (status == 0)
351
        return extract_unsigned_integer (buf, sizeof (buf), byte_order);
352
    }
353
 
354
  /* If the address is in the plt section, then the real function hasn't
355
     yet been fixed up by the linker so we cannot determine the gp of
356
     that function.  */
357
  if (in_plt_section (faddr, NULL))
358
    return 0;
359
 
360
  faddr_sect = find_pc_section (faddr);
361
  if (faddr_sect != NULL)
362
    {
363
      struct obj_section *osect;
364
 
365
      ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
366
        {
367
          if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
368
            break;
369
        }
370
 
371
      if (osect < faddr_sect->objfile->sections_end)
372
        {
373
          CORE_ADDR addr, endaddr;
374
 
375
          addr = obj_section_addr (osect);
376
          endaddr = obj_section_endaddr (osect);
377
 
378
          while (addr < endaddr)
379
            {
380
              int status;
381
              LONGEST tag;
382
              char buf[4];
383
 
384
              status = target_read_memory (addr, buf, sizeof (buf));
385
              if (status != 0)
386
                break;
387
              tag = extract_signed_integer (buf, sizeof (buf), byte_order);
388
 
389
              if (tag == DT_PLTGOT)
390
                {
391
                  CORE_ADDR global_pointer;
392
 
393
                  status = target_read_memory (addr + 4, buf, sizeof (buf));
394
                  if (status != 0)
395
                    break;
396
                  global_pointer = extract_unsigned_integer (buf, sizeof (buf),
397
                                                             byte_order);
398
                  /* The payoff... */
399
                  return global_pointer;
400
                }
401
 
402
              if (tag == DT_NULL)
403
                break;
404
 
405
              addr += 8;
406
            }
407
        }
408
    }
409
  return 0;
410
}
411
 
412
/*
413
 * Registers saved in a coredump:
414
 * gr0..gr31
415
 * sr0..sr7
416
 * iaoq0..iaoq1
417
 * iasq0..iasq1
418
 * sar, iir, isr, ior, ipsw
419
 * cr0, cr24..cr31
420
 * cr8,9,12,13
421
 * cr10, cr15
422
 */
423
 
424
#define GR_REGNUM(_n)   (HPPA_R0_REGNUM+_n)
425
#define TR_REGNUM(_n)   (HPPA_TR0_REGNUM+_n)
426
static const int greg_map[] =
427
  {
428
    GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
429
    GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
430
    GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
431
    GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
432
    GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
433
    GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
434
    GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
435
    GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
436
 
437
    HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
438
    HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
439
 
440
    HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
441
    HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
442
 
443
    HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
444
    HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
445
 
446
    TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
447
    TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
448
 
449
    HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
450
    HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
451
  };
452
 
453
static void
454
hppa_linux_supply_regset (const struct regset *regset,
455
                          struct regcache *regcache,
456
                          int regnum, const void *regs, size_t len)
457
{
458
  struct gdbarch *arch = get_regcache_arch (regcache);
459
  struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
460
  const char *buf = regs;
461
  int i, offset;
462
 
463
  offset = 0;
464
  for (i = 0; i < ARRAY_SIZE (greg_map); i++)
465
    {
466
      if (regnum == greg_map[i] || regnum == -1)
467
        regcache_raw_supply (regcache, greg_map[i], buf + offset);
468
 
469
      offset += tdep->bytes_per_address;
470
    }
471
}
472
 
473
static void
474
hppa_linux_supply_fpregset (const struct regset *regset,
475
                            struct regcache *regcache,
476
                            int regnum, const void *regs, size_t len)
477
{
478
  const char *buf = regs;
479
  int i, offset;
480
 
481
  offset = 0;
482
  for (i = 0; i < 64; i++)
483
    {
484
      if (regnum == HPPA_FP0_REGNUM + i || regnum == -1)
485
        regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i,
486
                             buf + offset);
487
      offset += 4;
488
    }
489
}
490
 
491
/* HPPA Linux kernel register set.  */
492
static struct regset hppa_linux_regset =
493
{
494
  NULL,
495
  hppa_linux_supply_regset
496
};
497
 
498
static struct regset hppa_linux_fpregset =
499
{
500
  NULL,
501
  hppa_linux_supply_fpregset
502
};
503
 
504
static const struct regset *
505
hppa_linux_regset_from_core_section (struct gdbarch *gdbarch,
506
                                     const char *sect_name,
507
                                     size_t sect_size)
508
{
509
  if (strcmp (sect_name, ".reg") == 0)
510
    return &hppa_linux_regset;
511
  else if (strcmp (sect_name, ".reg2") == 0)
512
    return &hppa_linux_fpregset;
513
 
514
  return NULL;
515
}
516
 
517
 
518
/* Forward declarations.  */
519
extern initialize_file_ftype _initialize_hppa_linux_tdep;
520
 
521
static void
522
hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
523
{
524
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
525
 
526
  /* GNU/Linux is always ELF.  */
527
  tdep->is_elf = 1;
528
 
529
  tdep->find_global_pointer = hppa_linux_find_global_pointer;
530
 
531
  set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
532
 
533
  frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind);
534
 
535
  /* GNU/Linux uses SVR4-style shared libraries.  */
536
  set_solib_svr4_fetch_link_map_offsets
537
    (gdbarch, svr4_ilp32_fetch_link_map_offsets);
538
 
539
  tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
540
  set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
541
 
542
  /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
543
  set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
544
 
545
  /* On hppa-linux, currently, sizeof(long double) == 8.  There has been
546
     some discussions to support 128-bit long double, but it requires some
547
     more work in gcc and glibc first.  */
548
  set_gdbarch_long_double_bit (gdbarch, 64);
549
 
550
  set_gdbarch_regset_from_core_section
551
    (gdbarch, hppa_linux_regset_from_core_section);
552
 
553
  set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
554
 
555
  /* Enable TLS support.  */
556
  set_gdbarch_fetch_tls_load_module_address (gdbarch,
557
                                             svr4_fetch_objfile_link_map);
558
}
559
 
560
void
561
_initialize_hppa_linux_tdep (void)
562
{
563
  gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
564
  gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_LINUX, hppa_linux_init_abi);
565
}

powered by: WebSVN 2.1.0

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