GDB (xrefs)
/tmp/gdb-7.10/gdb/hppa-linux-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
2 
3  Copyright (C) 2004-2015 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 3 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, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "gdbcore.h"
22 #include "osabi.h"
23 #include "target.h"
24 #include "objfiles.h"
25 #include "solib-svr4.h"
26 #include "glibc-tdep.h"
27 #include "frame-unwind.h"
28 #include "trad-frame.h"
29 #include "dwarf2-frame.h"
30 #include "value.h"
31 #include "regset.h"
32 #include "regcache.h"
33 #include "hppa-tdep.h"
34 #include "linux-tdep.h"
35 #include "elf/common.h"
36 
37 /* Map DWARF DBX register numbers to GDB register numbers. */
38 static int
40 {
41  /* The general registers and the sar are the same in both sets. */
42  if (reg <= 32)
43  return reg;
44 
45  /* fr4-fr31 (left and right halves) are mapped from 72. */
46  if (reg >= 72 && reg <= 72 + 28 * 2)
47  return HPPA_FP4_REGNUM + (reg - 72);
48 
49  warning (_("Unmapped DWARF DBX Register #%d encountered."), reg);
50  return -1;
51 }
52 
53 static void
55 {
56  /* Probably this should be done by the kernel, but it isn't. */
59  HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3);
60 }
61 
62 /* An instruction to match. */
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
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  gdb_byte 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
136 {
137  unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
138  int offs = 0;
139  int attempt;
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 (attempt = 0; attempt < ARRAY_SIZE (pcoffs); attempt++)
158  {
159  if (insns_match_pattern (gdbarch, sp + pcoffs[attempt],
160  hppa_sigtramp, dummy))
161  {
162  offs = sfoffs[attempt];
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  attempt = 2;
175  sp = pc - pcoffs[attempt];
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[attempt] + 128 + 24;
190 }
191 
193 {
196 };
197 
198 static struct hppa_linux_sigtramp_unwind_cache *
200  void **this_cache)
201 {
202  struct gdbarch *gdbarch = get_frame_arch (this_frame);
204  CORE_ADDR pc, scptr;
205  int i;
206 
207  if (*this_cache)
208  return *this_cache;
209 
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
275  void **this_prologue_cache,
276  struct frame_id *this_id)
277 {
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 *
285  void **this_prologue_cache,
286  int regnum)
287 {
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
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 = {
319  NULL,
321 };
322 
323 /* Attempt to find (and return) the global pointer for the given
324  function.
325 
326  This is a rather nasty bit of code searchs for the .dynamic section
327  in the objfile corresponding to the pc of the function we're trying
328  to call. Once it finds the addresses at which the .dynamic section
329  lives in the child process, it scans the Elf32_Dyn entries for a
330  DT_PLTGOT tag. If it finds one of these, the corresponding
331  d_un.d_ptr value is the global pointer. */
332 
333 static CORE_ADDR
335  struct value *function)
336 {
337  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
338  struct obj_section *faddr_sect;
339  CORE_ADDR faddr;
340 
341  faddr = value_as_address (function);
342 
343  /* Is this a plabel? If so, dereference it to get the gp value. */
344  if (faddr & 2)
345  {
346  int status;
347  gdb_byte buf[4];
348 
349  faddr &= ~3;
350 
351  status = target_read_memory (faddr + 4, buf, sizeof (buf));
352  if (status == 0)
353  return extract_unsigned_integer (buf, sizeof (buf), byte_order);
354  }
355 
356  /* If the address is in the plt section, then the real function hasn't
357  yet been fixed up by the linker so we cannot determine the gp of
358  that function. */
359  if (in_plt_section (faddr))
360  return 0;
361 
362  faddr_sect = find_pc_section (faddr);
363  if (faddr_sect != NULL)
364  {
365  struct obj_section *osect;
366 
367  ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
368  {
369  if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
370  break;
371  }
372 
373  if (osect < faddr_sect->objfile->sections_end)
374  {
375  CORE_ADDR addr, endaddr;
376 
377  addr = obj_section_addr (osect);
378  endaddr = obj_section_endaddr (osect);
379 
380  while (addr < endaddr)
381  {
382  int status;
383  LONGEST tag;
384  gdb_byte buf[4];
385 
386  status = target_read_memory (addr, buf, sizeof (buf));
387  if (status != 0)
388  break;
389  tag = extract_signed_integer (buf, sizeof (buf), byte_order);
390 
391  if (tag == DT_PLTGOT)
392  {
393  CORE_ADDR global_pointer;
394 
395  status = target_read_memory (addr + 4, buf, sizeof (buf));
396  if (status != 0)
397  break;
398  global_pointer = extract_unsigned_integer (buf, sizeof (buf),
399  byte_order);
400  /* The payoff... */
401  return global_pointer;
402  }
403 
404  if (tag == DT_NULL)
405  break;
406 
407  addr += 8;
408  }
409  }
410  }
411  return 0;
412 }
413 
414 /*
415  * Registers saved in a coredump:
416  * gr0..gr31
417  * sr0..sr7
418  * iaoq0..iaoq1
419  * iasq0..iasq1
420  * sar, iir, isr, ior, ipsw
421  * cr0, cr24..cr31
422  * cr8,9,12,13
423  * cr10, cr15
424  */
425 
426 static const struct regcache_map_entry hppa_linux_gregmap[] =
427  {
428  { 32, HPPA_R0_REGNUM },
429  { 1, HPPA_SR4_REGNUM+1 },
430  { 1, HPPA_SR4_REGNUM+2 },
431  { 1, HPPA_SR4_REGNUM+3 },
432  { 1, HPPA_SR4_REGNUM+4 },
433  { 1, HPPA_SR4_REGNUM },
434  { 1, HPPA_SR4_REGNUM+5 },
435  { 1, HPPA_SR4_REGNUM+6 },
436  { 1, HPPA_SR4_REGNUM+7 },
437  { 1, HPPA_PCOQ_HEAD_REGNUM },
438  { 1, HPPA_PCOQ_TAIL_REGNUM },
439  { 1, HPPA_PCSQ_HEAD_REGNUM },
440  { 1, HPPA_PCSQ_TAIL_REGNUM },
441  { 1, HPPA_SAR_REGNUM },
442  { 1, HPPA_IIR_REGNUM },
443  { 1, HPPA_ISR_REGNUM },
444  { 1, HPPA_IOR_REGNUM },
445  { 1, HPPA_IPSW_REGNUM },
446  { 1, HPPA_RCR_REGNUM },
447  { 8, HPPA_TR0_REGNUM },
448  { 4, HPPA_PID0_REGNUM },
449  { 1, HPPA_CCR_REGNUM },
450  { 1, HPPA_EIEM_REGNUM },
451  { 0 }
452  };
453 
454 static const struct regcache_map_entry hppa_linux_fpregmap[] =
455  {
456  /* FIXME: Only works for 32-bit mode. In 64-bit mode there should
457  be 32 fpregs, 8 bytes each. */
458  { 64, HPPA_FP0_REGNUM, 4 },
459  { 0 }
460  };
461 
462 /* HPPA Linux kernel register set. */
463 static const struct regset hppa_linux_regset =
464 {
467 };
468 
469 static const struct regset hppa_linux_fpregset =
470 {
473 };
474 
475 static void
478  void *cb_data,
479  const struct regcache *regcache)
480 {
481  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
482 
483  cb (".reg", 80 * tdep->bytes_per_address, &hppa_linux_regset,
484  NULL, cb_data);
485  cb (".reg2", 64 * 4, &hppa_linux_fpregset, NULL, cb_data);
486 }
487 
488 
489 /* Forward declarations. */
491 
492 static void
494 {
495  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
496 
497  linux_init_abi (info, gdbarch);
498 
499  /* GNU/Linux is always ELF. */
500  tdep->is_elf = 1;
501 
503 
505 
506  frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind);
507 
508  /* GNU/Linux uses SVR4-style shared libraries. */
511 
514 
515  /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
517 
518  /* On hppa-linux, currently, sizeof(long double) == 8. There has been
519  some discussions to support 128-bit long double, but it requires some
520  more work in gcc and glibc first. */
521  set_gdbarch_long_double_bit (gdbarch, 64);
522 
525 
527 
528  /* Enable TLS support. */
531 }
532 
533 void
535 {
536  gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX,
538  gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w,
540 }
CORE_ADDR(* find_global_pointer)(struct gdbarch *, struct value *)
Definition: hppa-tdep.h:97
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static struct value * hppa_linux_sigtramp_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
bfd_vma CORE_ADDR
Definition: common-types.h:41
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
Definition: gdbarch.c:2822
static const struct regcache_map_entry hppa_linux_fpregmap[]
static int hppa_linux_sigtramp_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
initialize_file_ftype _initialize_hppa_linux_tdep
CORE_ADDR hppa_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)
Definition: hppa-tdep.c:2973
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3084
void warning(const char *fmt,...)
Definition: errors.c:26
int(* in_solib_call_trampoline)(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: hppa-tdep.h:102
CORE_ADDR glibc_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: glibc-tdep.c:38
static void hppa_linux_target_write_pc(struct regcache *regcache, CORE_ADDR v)
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype write_pc)
Definition: gdbarch.c:1802
unsigned int data
ULONGEST align_down(ULONGEST v, int n)
Definition: utils.c:2971
#define obj_section_endaddr(s)
Definition: objfiles.h:141
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition: regcache.c:1149
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: linux-tdep.c:2427
struct link_map_offsets * svr4_ilp32_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3149
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
#define _(String)
Definition: gdb_locale.h:40
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
Definition: gdbarch.c:2110
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
static CORE_ADDR hppa_linux_sigtramp_find_sigcontext(struct gdbarch *gdbarch, CORE_ADDR pc)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
struct value * hppa_frame_prev_register_helper(struct frame_info *this_frame, struct trad_frame_saved_reg saved_regs[], int regnum)
Definition: hppa-tdep.c:2795
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-svr4.c:1573
int hppa_in_solib_call_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: hppa-tdep.c:2945
#define obj_section_addr(s)
Definition: objfiles.h:135
Definition: regset.h:34
static int hppa_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static void hppa_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
void initialize_file_ftype(void)
Definition: defs.h:281
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
static CORE_ADDR hppa_linux_find_global_pointer(struct gdbarch *gdbarch, struct value *function)
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
Definition: solib-svr4.c:3108
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition: regcache.c:1162
unsigned int mask
#define HPPA_MAX_INSN_PATTERN_LEN
unsigned dummy
Definition: go32-nat.c:1071
int regnum
Definition: aarch64-tdep.c:69
void( iterate_over_regset_sections_cb)(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
Definition: gdbarch.h:98
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
static int insns_match_pattern(struct gdbarch *gdbarch, CORE_ADDR pc, struct insn_pattern *pattern, unsigned int *insn)
Definition: regdef.h:22
Definition: value.c:172
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
Definition: trad-frame.c:52
bfd_byte gdb_byte
Definition: common-types.h:38
struct trad_frame_saved_reg * saved_regs
static void hppa_linux_sigtramp_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct obj_section * sections_end
Definition: objfiles.h:386
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:539
struct objfile * objfile
Definition: objfiles.h:124
static struct hppa_linux_sigtramp_unwind_cache * hppa_linux_sigtramp_frame_unwind_cache(struct frame_info *this_frame, void **this_cache)
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
int bytes_per_address
Definition: hppa-tdep.h:89
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
Definition: gdbarch.c:3398
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:49
void set_gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
Definition: gdbarch.c:3101
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition: osabi.c:148
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
long long LONGEST
Definition: common-types.h:52
static void hppa_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
Definition: regcache.h:167
static const struct regcache_map_entry hppa_linux_gregmap[]