GDB (xrefs)
/tmp/gdb-7.10/gdb/amd64obsd-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for OpenBSD/amd64.
2 
3  Copyright (C) 2003-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 "frame.h"
22 #include "frame-unwind.h"
23 #include "gdbcore.h"
24 #include "symtab.h"
25 #include "objfiles.h"
26 #include "osabi.h"
27 #include "regcache.h"
28 #include "regset.h"
29 #include "target.h"
30 #include "trad-frame.h"
31 
32 #include "obsd-tdep.h"
33 #include "amd64-tdep.h"
34 #include "i387-tdep.h"
35 #include "solib-svr4.h"
36 #include "bsd-uthread.h"
37 
38 /* Support for core dumps. */
39 
40 static void
42  struct regcache *regcache, int regnum,
43  const void *regs, size_t len)
44 {
45  struct gdbarch *gdbarch = get_regcache_arch (regcache);
46  const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
47 
49 
50  i386_supply_gregset (regset, regcache, regnum, regs, tdep->sizeof_gregset);
51  amd64_supply_fxsave (regcache, regnum,
52  ((const gdb_byte *)regs) + tdep->sizeof_gregset);
53 }
54 
55 static const struct regset amd64obsd_combined_regset =
56  {
57  NULL, amd64obsd_supply_regset, NULL
58  };
59 
60 static void
63  void *cb_data,
64  const struct regcache *regcache)
65 {
66  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
67 
68  /* OpenBSD core dumps don't use seperate register sets for the
69  general-purpose and floating-point registers. */
70 
71  cb (".reg", tdep->sizeof_gregset + I387_SIZEOF_FXSAVE,
72  &amd64obsd_combined_regset, NULL, cb_data);
73 }
74 
75 
76 /* Support for signal handlers. */
77 
78 /* Default page size. */
79 static const int amd64obsd_page_size = 4096;
80 
81 /* Return whether THIS_FRAME corresponds to an OpenBSD sigtramp
82  routine. */
83 
84 static int
85 amd64obsd_sigtramp_p (struct frame_info *this_frame)
86 {
87  CORE_ADDR pc = get_frame_pc (this_frame);
88  CORE_ADDR start_pc = (pc & ~(amd64obsd_page_size - 1));
89  const gdb_byte osigreturn[] =
90  {
91  0x48, 0xc7, 0xc0,
92  0x67, 0x00, 0x00, 0x00, /* movq $SYS_sigreturn, %rax */
93  0xcd, 0x80 /* int $0x80 */
94  };
95  const gdb_byte sigreturn[] =
96  {
97  0x48, 0xc7, 0xc0,
98  0x67, 0x00, 0x00, 0x00, /* movq $SYS_sigreturn, %rax */
99  0x0f, 0x05 /* syscall */
100  };
101  size_t buflen = (sizeof sigreturn) + 1;
102  gdb_byte *buf;
103  const char *name;
104 
105  /* If the function has a valid symbol name, it isn't a
106  trampoline. */
107  find_pc_partial_function (pc, &name, NULL, NULL);
108  if (name != NULL)
109  return 0;
110 
111  /* If the function lives in a valid section (even without a starting
112  point) it isn't a trampoline. */
113  if (find_pc_section (pc) != NULL)
114  return 0;
115 
116  /* If we can't read the instructions at START_PC, return zero. */
117  buf = alloca ((sizeof sigreturn) + 1);
118  if (!safe_frame_unwind_memory (this_frame, start_pc + 6, buf, buflen))
119  return 0;
120 
121  /* Check for sigreturn(2). Depending on how the assembler encoded
122  the `movq %rsp, %rdi' instruction, the code starts at offset 6 or
123  7. OpenBSD 5.0 and later use the `syscall' instruction. Older
124  versions use `int $0x80'. Check for both. */
125  if (memcmp (buf, sigreturn, sizeof sigreturn)
126  && memcmp (buf + 1, sigreturn, sizeof sigreturn)
127  && memcmp (buf, osigreturn, sizeof osigreturn)
128  && memcmp (buf + 1, osigreturn, sizeof osigreturn))
129  return 0;
130 
131  return 1;
132 }
133 
134 /* Assuming THIS_FRAME is for a BSD sigtramp routine, return the
135  address of the associated sigcontext structure. */
136 
137 static CORE_ADDR
139 {
140  CORE_ADDR pc = get_frame_pc (this_frame);
141  ULONGEST offset = (pc & (amd64obsd_page_size - 1));
142 
143  /* The %rsp register points at `struct sigcontext' upon entry of a
144  signal trampoline. The relevant part of the trampoline is
145 
146  call *%rax
147  movq %rsp, %rdi
148  pushq %rdi
149  movq $SYS_sigreturn,%rax
150  int $0x80
151 
152  (see /usr/src/sys/arch/amd64/amd64/locore.S). The `pushq'
153  instruction clobbers %rsp, but its value is saved in `%rdi'. */
154 
155  if (offset > 5)
156  return get_frame_register_unsigned (this_frame, AMD64_RDI_REGNUM);
157  else
158  return get_frame_register_unsigned (this_frame, AMD64_RSP_REGNUM);
159 }
160 
161 /* OpenBSD 3.5 or later. */
162 
163 /* Mapping between the general-purpose registers in `struct reg'
164  format and GDB's register cache layout. */
165 
166 /* From <machine/reg.h>. */
168 {
169  14 * 8, /* %rax */
170  13 * 8, /* %rbx */
171  3 * 8, /* %rcx */
172  2 * 8, /* %rdx */
173  1 * 8, /* %rsi */
174  0 * 8, /* %rdi */
175  12 * 8, /* %rbp */
176  15 * 8, /* %rsp */
177  4 * 8, /* %r8 .. */
178  5 * 8,
179  6 * 8,
180  7 * 8,
181  8 * 8,
182  9 * 8,
183  10 * 8,
184  11 * 8, /* ... %r15 */
185  16 * 8, /* %rip */
186  17 * 8, /* %eflags */
187  18 * 8, /* %cs */
188  19 * 8, /* %ss */
189  20 * 8, /* %ds */
190  21 * 8, /* %es */
191  22 * 8, /* %fs */
192  23 * 8 /* %gs */
193 };
194 
195 /* From <machine/signal.h>. */
197 {
198  14 * 8, /* %rax */
199  13 * 8, /* %rbx */
200  3 * 8, /* %rcx */
201  2 * 8, /* %rdx */
202  1 * 8, /* %rsi */
203  0 * 8, /* %rdi */
204  12 * 8, /* %rbp */
205  24 * 8, /* %rsp */
206  4 * 8, /* %r8 ... */
207  5 * 8,
208  6 * 8,
209  7 * 8,
210  8 * 8,
211  9 * 8,
212  10 * 8,
213  11 * 8, /* ... %r15 */
214  21 * 8, /* %rip */
215  23 * 8, /* %eflags */
216  22 * 8, /* %cs */
217  25 * 8, /* %ss */
218  18 * 8, /* %ds */
219  17 * 8, /* %es */
220  16 * 8, /* %fs */
221  15 * 8 /* %gs */
222 };
223 
224 /* From /usr/src/lib/libpthread/arch/amd64/uthread_machdep.c. */
226 {
227  19 * 8, /* %rax */
228  16 * 8, /* %rbx */
229  18 * 8, /* %rcx */
230  17 * 8, /* %rdx */
231  14 * 8, /* %rsi */
232  13 * 8, /* %rdi */
233  15 * 8, /* %rbp */
234  -1, /* %rsp */
235  12 * 8, /* %r8 ... */
236  11 * 8,
237  10 * 8,
238  9 * 8,
239  8 * 8,
240  7 * 8,
241  6 * 8,
242  5 * 8, /* ... %r15 */
243  20 * 8, /* %rip */
244  4 * 8, /* %eflags */
245  21 * 8, /* %cs */
246  -1, /* %ss */
247  3 * 8, /* %ds */
248  2 * 8, /* %es */
249  1 * 8, /* %fs */
250  0 * 8 /* %gs */
251 };
252 
253 /* Offset within the thread structure where we can find the saved
254  stack pointer (%esp). */
255 #define AMD64OBSD_UTHREAD_RSP_OFFSET 400
256 
257 static void
259  int regnum, CORE_ADDR addr)
260 {
261  struct gdbarch *gdbarch = get_regcache_arch (regcache);
262  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
263  CORE_ADDR sp_addr = addr + AMD64OBSD_UTHREAD_RSP_OFFSET;
264  CORE_ADDR sp = 0;
265  gdb_byte buf[8];
266  int i;
267 
268  gdb_assert (regnum >= -1);
269 
270  if (regnum == -1 || regnum == AMD64_RSP_REGNUM)
271  {
272  int offset;
273 
274  /* Fetch stack pointer from thread structure. */
275  sp = read_memory_unsigned_integer (sp_addr, 8, byte_order);
276 
277  /* Adjust the stack pointer such that it looks as if we just
278  returned from _thread_machdep_switch. */
280  store_unsigned_integer (buf, 8, byte_order, sp + offset);
281  regcache_raw_supply (regcache, AMD64_RSP_REGNUM, buf);
282  }
283 
284  for (i = 0; i < ARRAY_SIZE (amd64obsd_uthread_reg_offset); i++)
285  {
286  if (amd64obsd_uthread_reg_offset[i] != -1
287  && (regnum == -1 || regnum == i))
288  {
289  /* Fetch stack pointer from thread structure (if we didn't
290  do so already). */
291  if (sp == 0)
292  sp = read_memory_unsigned_integer (sp_addr, 8, byte_order);
293 
294  /* Read the saved register from the stack frame. */
295  read_memory (sp + amd64obsd_uthread_reg_offset[i], buf, 8);
296  regcache_raw_supply (regcache, i, buf);
297  }
298  }
299 }
300 
301 static void
303  int regnum, CORE_ADDR addr)
304 {
305  struct gdbarch *gdbarch = get_regcache_arch (regcache);
306  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
307  CORE_ADDR sp_addr = addr + AMD64OBSD_UTHREAD_RSP_OFFSET;
308  CORE_ADDR sp = 0;
309  gdb_byte buf[8];
310  int i;
311 
312  gdb_assert (regnum >= -1);
313 
314  if (regnum == -1 || regnum == AMD64_RSP_REGNUM)
315  {
316  int offset;
317 
318  /* Calculate the stack pointer (frame pointer) that will be
319  stored into the thread structure. */
321  regcache_raw_collect (regcache, AMD64_RSP_REGNUM, buf);
322  sp = extract_unsigned_integer (buf, 8, byte_order) - offset;
323 
324  /* Store the stack pointer. */
325  write_memory_unsigned_integer (sp_addr, 8, byte_order, sp);
326 
327  /* The stack pointer was (potentially) modified. Make sure we
328  build a proper stack frame. */
329  regnum = -1;
330  }
331 
332  for (i = 0; i < ARRAY_SIZE (amd64obsd_uthread_reg_offset); i++)
333  {
334  if (amd64obsd_uthread_reg_offset[i] != -1
335  && (regnum == -1 || regnum == i))
336  {
337  /* Fetch stack pointer from thread structure (if we didn't
338  calculate it already). */
339  if (sp == 0)
340  sp = read_memory_unsigned_integer (sp_addr, 8, byte_order);
341 
342  /* Write the register into the stack frame. */
343  regcache_raw_collect (regcache, i, buf);
344  write_memory (sp + amd64obsd_uthread_reg_offset[i], buf, 8);
345  }
346  }
347 }
348 /* Kernel debugging support. */
349 
350 /* From <machine/frame.h>. Easy since `struct trapframe' matches
351  `struct sigcontext'. */
352 #define amd64obsd_tf_reg_offset amd64obsd_sc_reg_offset
353 
354 static struct trad_frame_cache *
355 amd64obsd_trapframe_cache (struct frame_info *this_frame, void **this_cache)
356 {
357  struct gdbarch *gdbarch = get_frame_arch (this_frame);
358  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
359  struct trad_frame_cache *cache;
360  CORE_ADDR func, sp, addr;
361  ULONGEST cs;
362  const char *name;
363  int i;
364 
365  if (*this_cache)
366  return *this_cache;
367 
368  cache = trad_frame_cache_zalloc (this_frame);
369  *this_cache = cache;
370 
371  func = get_frame_func (this_frame);
373 
374  find_pc_partial_function (func, &name, NULL, NULL);
375  if (name && startswith (name, "Xintr"))
376  addr = sp + 8; /* It's an interrupt frame. */
377  else
378  addr = sp;
379 
380  for (i = 0; i < ARRAY_SIZE (amd64obsd_tf_reg_offset); i++)
381  if (amd64obsd_tf_reg_offset[i] != -1)
382  trad_frame_set_reg_addr (cache, i, addr + amd64obsd_tf_reg_offset[i]);
383 
384  /* Read %cs from trap frame. */
386  cs = read_memory_unsigned_integer (addr, 8, byte_order);
387  if ((cs & I386_SEL_RPL) == I386_SEL_UPL)
388  {
389  /* Trap from user space; terminate backtrace. */
391  }
392  else
393  {
394  /* Construct the frame ID using the function start. */
395  trad_frame_set_id (cache, frame_id_build (sp + 16, func));
396  }
397 
398  return cache;
399 }
400 
401 static void
403  void **this_cache, struct frame_id *this_id)
404 {
405  struct trad_frame_cache *cache =
406  amd64obsd_trapframe_cache (this_frame, this_cache);
407 
408  trad_frame_get_id (cache, this_id);
409 }
410 
411 static struct value *
413  void **this_cache, int regnum)
414 {
415  struct trad_frame_cache *cache =
416  amd64obsd_trapframe_cache (this_frame, this_cache);
417 
418  return trad_frame_get_register (cache, this_frame, regnum);
419 }
420 
421 static int
423  struct frame_info *this_frame,
424  void **this_prologue_cache)
425 {
426  ULONGEST cs;
427  const char *name;
428 
429  /* Check Current Privilege Level and bail out if we're not executing
430  in kernel space. */
431  cs = get_frame_register_unsigned (this_frame, AMD64_CS_REGNUM);
432  if ((cs & I386_SEL_RPL) == I386_SEL_UPL)
433  return 0;
434 
435  find_pc_partial_function (get_frame_pc (this_frame), &name, NULL, NULL);
436  return (name && ((strcmp (name, "calltrap") == 0)
437  || (strcmp (name, "osyscall1") == 0)
438  || (strcmp (name, "Xsyscall") == 0)
439  || (startswith (name, "Xintr"))));
440 }
441 
442 static const struct frame_unwind amd64obsd_trapframe_unwind = {
443  /* FIXME: kettenis/20051219: This really is more like an interrupt
444  frame, but SIGTRAMP_FRAME would print <signal handler called>,
445  which really is not what we want here. */
446  NORMAL_FRAME,
450  NULL,
452 };
453 
454 
455 static void
457 {
458  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
459 
460  amd64_init_abi (info, gdbarch);
461  obsd_init_abi (info, gdbarch);
462 
463  /* Initialize general-purpose register set details. */
465  tdep->gregset_num_regs = ARRAY_SIZE (amd64obsd_r_reg_offset);
466  tdep->sizeof_gregset = 24 * 8;
467 
468  tdep->jb_pc_offset = 7 * 8;
469 
473  tdep->sc_num_regs = ARRAY_SIZE (amd64obsd_sc_reg_offset);
474 
475  /* OpenBSD provides a user-level threads implementation. */
478 
479  /* OpenBSD uses SVR4-style shared libraries. */
482 
483  /* Unwind kernel trap frames correctly. */
484  frame_unwind_prepend_unwinder (gdbarch, &amd64obsd_trapframe_unwind);
485 }
486 
487 /* Traditional (a.out) NetBSD-style core dumps. */
488 
489 static void
491 {
492  amd64obsd_init_abi (info, gdbarch);
493 
496 }
497 
498 
499 /* Provide a prototype to silence -Wmissing-prototypes. */
500 void _initialize_amd64obsd_tdep (void);
501 
502 void
504 {
505  /* The OpenBSD/amd64 native dependent code makes this assumption. */
507 
508  gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
510 
511  /* OpenBSD uses traditional (a.out) NetBSD-style core dumps. */
512  gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
514 }
static void amd64obsd_trapframe_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
void i386_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
Definition: i386-tdep.c:3730
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
int jb_pc_offset
Definition: i386-tdep.h:199
void trad_frame_set_reg_addr(struct trad_frame_cache *this_trad_cache, int regnum, CORE_ADDR addr)
Definition: trad-frame.c:119
#define I386_SEL_UPL
Definition: i386-tdep.h:365
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
struct link_map_offsets * svr4_lp64_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3180
int sc_num_regs
Definition: i386-tdep.h:216
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
Definition: corefile.c:412
void(* func)(char *)
static void amd64obsd_collect_uthread(const struct regcache *regcache, int regnum, CORE_ADDR addr)
void trad_frame_set_id(struct trad_frame_cache *this_trad_cache, struct frame_id this_id)
Definition: trad-frame.c:164
static void amd64obsd_core_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
struct m32c_reg * pc
Definition: m32c-tdep.c:111
static void amd64obsd_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs, size_t len)
CORE_ADDR(* sigcontext_addr)(struct frame_info *)
Definition: alpha-tdep.h:82
void bsd_uthread_set_collect_uthread(struct gdbarch *gdbarch, void(*collect_uthread)(const struct regcache *, int, CORE_ADDR))
Definition: bsd-uthread.c:79
static int amd64obsd_trapframe_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
void obsd_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: obsd-tdep.c:319
static int amd64obsd_sc_reg_offset[]
void frame_unwind_prepend_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:64
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
Definition: regset.h:34
void trad_frame_get_id(struct trad_frame_cache *this_trad_cache, struct frame_id *this_id)
Definition: trad-frame.c:171
static struct trad_frame_cache * amd64obsd_trapframe_cache(struct frame_info *this_frame, void **this_cache)
const char *const name
Definition: aarch64-tdep.c:68
int amd64obsd_r_reg_offset[]
void amd64_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
Definition: amd64-tdep.c:3173
#define amd64obsd_tf_reg_offset
static CORE_ADDR amd64obsd_sigcontext_addr(struct frame_info *this_frame)
int safe_frame_unwind_memory(struct frame_info *this_frame, CORE_ADDR addr, gdb_byte *buf, int len)
Definition: frame.c:2525
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define AMD64_NUM_GREGS
Definition: amd64-tdep.h:83
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
Definition: solib-svr4.c:3108
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
struct trad_frame_cache * trad_frame_cache_zalloc(struct frame_info *this_frame)
Definition: trad-frame.c:36
int regnum
Definition: aarch64-tdep.c:69
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
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
struct frame_info * this_frame
Definition: trad-frame.c:29
Definition: value.c:172
int * gregset_reg_offset
Definition: i386-tdep.h:59
#define I387_SIZEOF_FXSAVE
Definition: i387-tdep.h:112
struct frame_id this_id
Definition: trad-frame.c:32
bfd_byte gdb_byte
Definition: common-types.h:38
static int amd64obsd_uthread_reg_offset[]
#define I386_SEL_RPL
Definition: i386-tdep.h:364
int(* sigtramp_p)(struct frame_info *)
Definition: i386-tdep.h:209
static void amd64obsd_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
static struct value * amd64obsd_trapframe_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
static int amd64obsd_sigtramp_p(struct frame_info *this_frame)
void amd64_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: amd64-tdep.c:2937
int offset
Definition: agent.c:65
#define AMD64OBSD_UTHREAD_RSP_OFFSET
size_t sizeof_gregset
Definition: i386-tdep.h:61
struct m32c_reg regs[M32C_MAX_NUM_REGS]
Definition: m32c-tdep.c:105
void _initialize_amd64obsd_tdep(void)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
int * sc_reg_offset
Definition: i386-tdep.h:215
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
const struct frame_id outer_frame_id
Definition: frame.c:507
static void amd64obsd_supply_uthread(struct regcache *regcache, int regnum, CORE_ADDR addr)
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
Definition: gdbarch.c:3398
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
void bsd_uthread_set_supply_uthread(struct gdbarch *gdbarch, void(*supply_uthread)(struct regcache *, int, CORE_ADDR))
Definition: bsd-uthread.c:67
int gregset_num_regs
Definition: i386-tdep.h:60
struct value * trad_frame_get_register(struct trad_frame_cache *this_trad_cache, struct frame_info *this_frame, int regnum)
Definition: trad-frame.c:155
enum bfd_endian byte_order
Definition: gdbarch.c:128
static void amd64obsd_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
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
static const int amd64obsd_page_size
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
const ULONGEST const LONGEST len
Definition: target.h:309