GDB (xrefs)
/tmp/gdb-7.10/gdb/solib-darwin.c
Go to the documentation of this file.
1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
2 
3  Copyright (C) 2009-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 
22 #include "symtab.h"
23 #include "bfd.h"
24 #include "symfile.h"
25 #include "objfiles.h"
26 #include "gdbcore.h"
27 #include "target.h"
28 #include "inferior.h"
29 #include "regcache.h"
30 #include "gdbthread.h"
31 #include "gdb_bfd.h"
32 
33 #include "solist.h"
34 #include "solib.h"
35 #include "solib-svr4.h"
36 
37 #include "bfd-target.h"
38 #include "elf-bfd.h"
39 #include "exec.h"
40 #include "auxv.h"
41 #include "mach-o.h"
42 #include "mach-o/external.h"
43 
45 {
46  /* Base address (which corresponds to the Mach-O header). */
48  /* Image file path. */
50  /* st.m_time of image file. */
51  unsigned long mtime;
52 };
53 
54 /* Content of inferior dyld_all_image_infos structure.
55  See /usr/include/mach-o/dyld_images.h for the documentation. */
57 {
58  /* Version (1). */
59  unsigned int version;
60  /* Number of images. */
61  unsigned int count;
62  /* Image description. */
64  /* Notifier (function called when a library is added or removed). */
66 };
67 
68 /* Current all_image_infos version. */
69 #define DYLD_VERSION_MIN 1
70 #define DYLD_VERSION_MAX 14
71 
72 /* Per PSPACE specific data. */
74 {
75  /* Address of structure dyld_all_image_infos in inferior. */
77 
78  /* Gdb copy of dyld_all_info_infos. */
80 };
81 
82 /* Per-program-space data key. */
83 static const struct program_space_data *solib_darwin_pspace_data;
84 
85 static void
86 darwin_pspace_data_cleanup (struct program_space *pspace, void *arg)
87 {
88  xfree (arg);
89 }
90 
91 /* Get the current darwin data. If none is found yet, add it now. This
92  function always returns a valid object. */
93 
94 static struct darwin_info *
96 {
97  struct darwin_info *info;
98 
99  info = program_space_data (current_program_space, solib_darwin_pspace_data);
100  if (info != NULL)
101  return info;
102 
103  info = XCNEW (struct darwin_info);
104  set_program_space_data (current_program_space,
106  return info;
107 }
108 
109 /* Return non-zero if the version in dyld_all_image is known. */
110 
111 static int
113 {
114  return info->all_image.version >= DYLD_VERSION_MIN
115  && info->all_image.version <= DYLD_VERSION_MAX;
116 }
117 
118 /* Read dyld_all_image from inferior. */
119 
120 static void
122 {
123  gdb_byte buf[24];
124  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
125  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
126  int len;
127 
128  /* If the structure address is not known, don't continue. */
129  if (info->all_image_addr == 0)
130  return;
131 
132  /* The structure has 4 fields: version (4 bytes), count (4 bytes),
133  info (pointer) and notifier (pointer). */
134  len = 4 + 4 + 2 * ptr_type->length;
135  gdb_assert (len <= sizeof (buf));
136  memset (&info->all_image, 0, sizeof (info->all_image));
137 
138  /* Read structure raw bytes from target. */
139  if (target_read_memory (info->all_image_addr, buf, len))
140  return;
141 
142  /* Extract the fields. */
143  info->all_image.version = extract_unsigned_integer (buf, 4, byte_order);
144  if (!darwin_dyld_version_ok (info))
145  return;
146 
147  info->all_image.count = extract_unsigned_integer (buf + 4, 4, byte_order);
148  info->all_image.info = extract_typed_address (buf + 8, ptr_type);
150  (buf + 8 + ptr_type->length, ptr_type);
151 }
152 
153 /* Link map info to include in an allocated so_list entry. */
154 
155 struct lm_info
156 {
157  /* The target location of lm. */
159 };
160 
162 {
163  /* Common field. */
164  struct so_list sl;
165  /* Darwin specific data. */
166  struct lm_info li;
167 };
168 
169 /* Lookup the value for a specific symbol. */
170 
171 static CORE_ADDR
172 lookup_symbol_from_bfd (bfd *abfd, char *symname)
173 {
174  long storage_needed;
175  asymbol **symbol_table;
176  unsigned int number_of_symbols;
177  unsigned int i;
178  CORE_ADDR symaddr = 0;
179 
180  storage_needed = bfd_get_symtab_upper_bound (abfd);
181 
182  if (storage_needed <= 0)
183  return 0;
184 
185  symbol_table = (asymbol **) xmalloc (storage_needed);
186  number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
187 
188  for (i = 0; i < number_of_symbols; i++)
189  {
190  asymbol *sym = symbol_table[i];
191 
192  if (strcmp (sym->name, symname) == 0
193  && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
194  {
195  /* BFD symbols are section relative. */
196  symaddr = sym->value + sym->section->vma;
197  break;
198  }
199  }
200  xfree (symbol_table);
201 
202  return symaddr;
203 }
204 
205 /* Return program interpreter string. */
206 
207 static char *
209 {
210  char *buf = NULL;
211 
212  /* If we have an exec_bfd, get the interpreter from the load commands. */
213  if (exec_bfd)
214  {
215  bfd_mach_o_load_command *cmd;
216 
217  if (bfd_mach_o_lookup_command (exec_bfd,
218  BFD_MACH_O_LC_LOAD_DYLINKER, &cmd) == 1)
219  return cmd->command.dylinker.name_str;
220  }
221 
222  /* If we didn't find it, read from memory.
223  FIXME: todo. */
224  return buf;
225 }
226 
227 /* Not used. I don't see how the main symbol file can be found: the
228  interpreter name is needed and it is known from the executable file.
229  Note that darwin-nat.c implements pid_to_exec_file. */
230 
231 static int
232 open_symbol_file_object (void *from_ttyp)
233 {
234  return 0;
235 }
236 
237 /* Build a list of currently loaded shared objects. See solib-svr4.c. */
238 
239 static struct so_list *
241 {
242  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
243  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
244  int ptr_len = TYPE_LENGTH (ptr_type);
245  unsigned int image_info_size;
246  struct so_list *head = NULL;
247  struct so_list *tail = NULL;
248  int i;
249  struct darwin_info *info = get_darwin_info ();
250 
251  /* Be sure image infos are loaded. */
253 
254  if (!darwin_dyld_version_ok (info))
255  return NULL;
256 
257  image_info_size = ptr_len * 3;
258 
259  /* Read infos for each solib.
260  The first entry was rumored to be the executable itself, but this is not
261  true when a large number of shared libraries are used (table expanded ?).
262  We now check all entries, but discard executable images. */
263  for (i = 0; i < info->all_image.count; i++)
264  {
265  CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
266  gdb_byte buf[image_info_size];
267  CORE_ADDR load_addr;
268  CORE_ADDR path_addr;
269  struct mach_o_header_external hdr;
270  unsigned long hdr_val;
271  char *file_path;
272  int errcode;
273  struct darwin_so_list *dnew;
274  struct so_list *newobj;
275  struct cleanup *old_chain;
276 
277  /* Read image info from inferior. */
278  if (target_read_memory (iinfo, buf, image_info_size))
279  break;
280 
281  load_addr = extract_typed_address (buf, ptr_type);
282  path_addr = extract_typed_address (buf + ptr_len, ptr_type);
283 
284  /* Read Mach-O header from memory. */
285  if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
286  break;
287  /* Discard wrong magic numbers. Shouldn't happen. */
288  hdr_val = extract_unsigned_integer
289  (hdr.magic, sizeof (hdr.magic), byte_order);
290  if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
291  continue;
292  /* Discard executable. Should happen only once. */
293  hdr_val = extract_unsigned_integer
294  (hdr.filetype, sizeof (hdr.filetype), byte_order);
295  if (hdr_val == BFD_MACH_O_MH_EXECUTE)
296  continue;
297 
298  target_read_string (path_addr, &file_path,
299  SO_NAME_MAX_PATH_SIZE - 1, &errcode);
300  if (errcode)
301  break;
302 
303  /* Create and fill the new so_list element. */
304  dnew = XCNEW (struct darwin_so_list);
305  newobj = &dnew->sl;
306  old_chain = make_cleanup (xfree, dnew);
307 
308  newobj->lm_info = &dnew->li;
309 
310  strncpy (newobj->so_name, file_path, SO_NAME_MAX_PATH_SIZE - 1);
311  newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
312  strcpy (newobj->so_original_name, newobj->so_name);
313  xfree (file_path);
314  newobj->lm_info->lm_addr = load_addr;
315 
316  if (head == NULL)
317  head = newobj;
318  else
319  tail->next = newobj;
320  tail = newobj;
321 
322  discard_cleanups (old_chain);
323  }
324 
325  return head;
326 }
327 
328 /* Get the load address of the executable. We assume that the dyld info are
329  correct. */
330 
331 static CORE_ADDR
333 {
334  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
335  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
336  int ptr_len = TYPE_LENGTH (ptr_type);
337  unsigned int image_info_size = ptr_len * 3;
338  int i;
339 
340  /* Read infos for each solib. One of them should be the executable. */
341  for (i = 0; i < info->all_image.count; i++)
342  {
343  CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
344  gdb_byte buf[image_info_size];
345  CORE_ADDR load_addr;
346  struct mach_o_header_external hdr;
347  unsigned long hdr_val;
348 
349  /* Read image info from inferior. */
350  if (target_read_memory (iinfo, buf, image_info_size))
351  break;
352 
353  load_addr = extract_typed_address (buf, ptr_type);
354 
355  /* Read Mach-O header from memory. */
356  if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
357  break;
358  /* Discard wrong magic numbers. Shouldn't happen. */
359  hdr_val = extract_unsigned_integer
360  (hdr.magic, sizeof (hdr.magic), byte_order);
361  if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
362  continue;
363  /* Check executable. */
364  hdr_val = extract_unsigned_integer
365  (hdr.filetype, sizeof (hdr.filetype), byte_order);
366  if (hdr_val == BFD_MACH_O_MH_EXECUTE)
367  return load_addr;
368  }
369 
370  return 0;
371 }
372 
373 /* Return 1 if PC lies in the dynamic symbol resolution code of the
374  run time loader. */
375 
376 static int
378 {
379  return 0;
380 }
381 
382 
383 /* No special symbol handling. */
384 
385 static void
387 {
388 }
389 
390 /* A wrapper for bfd_mach_o_fat_extract that handles reference
391  counting properly. This will either return NULL, or return a new
392  reference to a BFD. */
393 
394 static bfd *
395 gdb_bfd_mach_o_fat_extract (bfd *abfd, bfd_format format,
396  const bfd_arch_info_type *arch)
397 {
398  bfd *result = bfd_mach_o_fat_extract (abfd, format, arch);
399 
400  if (result == NULL)
401  return NULL;
402 
403  if (result == abfd)
404  gdb_bfd_ref (result);
405  else
406  gdb_bfd_mark_parent (result, abfd);
407 
408  return result;
409 }
410 
411 /* Extract dyld_all_image_addr when the process was just created, assuming the
412  current PC is at the entry of the dynamic linker. */
413 
414 static void
416 {
417  char *interp_name;
418  CORE_ADDR load_addr = 0;
419  bfd *dyld_bfd = NULL;
420  struct cleanup *cleanup;
421 
422  /* This method doesn't work with an attached process. */
423  if (current_inferior ()->attach_flag)
424  return;
425 
426  /* Find the program interpreter. */
427  interp_name = find_program_interpreter ();
428  if (!interp_name)
429  return;
430 
431  cleanup = make_cleanup (null_cleanup, NULL);
432 
433  /* Create a bfd for the interpreter. */
434  dyld_bfd = gdb_bfd_open (interp_name, gnutarget, -1);
435  if (dyld_bfd)
436  {
437  bfd *sub;
438 
439  make_cleanup_bfd_unref (dyld_bfd);
440  sub = gdb_bfd_mach_o_fat_extract (dyld_bfd, bfd_object,
442  if (sub)
443  {
444  dyld_bfd = sub;
446  }
447  else
448  dyld_bfd = NULL;
449  }
450  if (!dyld_bfd)
451  {
452  do_cleanups (cleanup);
453  return;
454  }
455 
456  /* We find the dynamic linker's base address by examining
457  the current pc (which should point at the entry point for the
458  dynamic linker) and subtracting the offset of the entry point. */
459  load_addr = (regcache_read_pc (get_current_regcache ())
460  - bfd_get_start_address (dyld_bfd));
461 
462  /* Now try to set a breakpoint in the dynamic linker. */
463  info->all_image_addr =
464  lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos");
465 
466  do_cleanups (cleanup);
467 
468  if (info->all_image_addr == 0)
469  return;
470 
471  info->all_image_addr += load_addr;
472 }
473 
474 /* Extract dyld_all_image_addr reading it from
475  TARGET_OBJECT_DARWIN_DYLD_INFO. */
476 
477 static void
479 {
480  gdb_byte buf[8 + 8 + 4];
481  LONGEST len;
482  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
483 
485  buf, 0, sizeof (buf));
486  if (len != sizeof (buf))
487  return;
488 
489  info->all_image_addr = extract_unsigned_integer (buf, 8, byte_order);
490 }
491 
492 /* Shared library startup support. See documentation in solib-svr4.c. */
493 
494 static void
496 {
497  struct darwin_info *info = get_darwin_info ();
498  CORE_ADDR load_addr;
499 
500  info->all_image_addr = 0;
501 
503 
504  if (info->all_image_addr == 0)
506 
507  if (info->all_image_addr == 0)
508  return;
509 
511 
512  if (!darwin_dyld_version_ok (info))
513  {
514  warning (_("unhandled dyld version (%d)"), info->all_image.version);
515  return;
516  }
517 
519 
520  /* Possible relocate the main executable (PIE). */
521  load_addr = darwin_read_exec_load_addr (info);
522  if (load_addr != 0 && symfile_objfile != NULL)
523  {
524  CORE_ADDR vmaddr;
525 
526  /* Find the base address of the executable. */
527  vmaddr = bfd_mach_o_get_base_address (exec_bfd);
528 
529  /* Relocate. */
530  if (vmaddr != load_addr)
531  objfile_rebase (symfile_objfile, load_addr - vmaddr);
532  }
533 }
534 
535 static void
537 {
538  struct darwin_info *info = get_darwin_info ();
539 
540  info->all_image_addr = 0;
541  info->all_image.version = 0;
542 }
543 
544 static void
546 {
547 }
548 
549 /* The section table is built from bfd sections using bfd VMAs.
550  Relocate these VMAs according to solib info. */
551 
552 static void
554  struct target_section *sec)
555 {
556  sec->addr += so->lm_info->lm_addr;
557  sec->endaddr += so->lm_info->lm_addr;
558 
559  /* Best effort to set addr_high/addr_low. This is used only by
560  'info sharedlibary'. */
561  if (so->addr_high == 0)
562  {
563  so->addr_low = sec->addr;
564  so->addr_high = sec->endaddr;
565  }
566  if (sec->endaddr > so->addr_high)
567  so->addr_high = sec->endaddr;
568  if (sec->addr < so->addr_low)
569  so->addr_low = sec->addr;
570 }
571 
572 static struct symbol *
574  const char *name,
575  const domain_enum domain)
576 {
577  return NULL;
578 }
579 
580 static bfd *
581 darwin_bfd_open (char *pathname)
582 {
583  char *found_pathname;
584  int found_file;
585  bfd *abfd;
586  bfd *res;
587 
588  /* Search for shared library file. */
589  found_pathname = solib_find (pathname, &found_file);
590  if (found_pathname == NULL)
591  perror_with_name (pathname);
592 
593  /* Open bfd for shared library. */
594  abfd = solib_bfd_fopen (found_pathname, found_file);
595 
596  res = gdb_bfd_mach_o_fat_extract (abfd, bfd_object,
598  if (!res)
599  {
600  make_cleanup_bfd_unref (abfd);
601  error (_("`%s': not a shared-library: %s"),
602  bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
603  }
604 
605  /* The current filename for fat-binary BFDs is a name generated
606  by BFD, usually a string containing the name of the architecture.
607  Reset its value to the actual filename. */
608  xfree (bfd_get_filename (res));
609  res->filename = xstrdup (pathname);
610 
611  gdb_bfd_unref (abfd);
612  return res;
613 }
614 
616 
617 /* -Wmissing-prototypes */
619 
620 void
622 {
624  = register_program_space_data_with_cleanup (NULL,
626 
637 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
struct symbol *(* lookup_lib_global_symbol)(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solist.h:140
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static int darwin_dyld_version_ok(const struct darwin_info *info)
Definition: solib-darwin.c:112
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:169
struct lm_info li
Definition: solib-darwin.c:166
bfd_vma CORE_ADDR
Definition: common-types.h:41
void gdb_bfd_mark_parent(bfd *child, bfd *parent)
Definition: gdb_bfd.c:743
unsigned long mtime
Definition: solib-darwin.c:51
void xfree(void *)
Definition: common-utils.c:97
struct so_list * next
Definition: solist.h:36
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7721
void warning(const char *fmt,...)
Definition: errors.c:26
static void darwin_solib_read_all_image_info_addr(struct darwin_info *info)
Definition: solib-darwin.c:478
enum domain_enum_tag domain_enum
static CORE_ADDR darwin_read_exec_load_addr(struct darwin_info *info)
Definition: solib-darwin.c:332
static const struct program_space_data * solib_darwin_pspace_data
Definition: solib-darwin.c:83
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
Definition: solist.h:84
void(* solib_create_inferior_hook)(int from_tty)
Definition: solist.h:101
struct so_list *(* current_sos)(void)
Definition: solist.h:116
bfd *(* bfd_open)(char *pathname)
Definition: solist.h:130
static bfd * darwin_bfd_open(char *pathname)
Definition: solib-darwin.c:581
static struct symbol * darwin_lookup_lib_symbol(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solib-darwin.c:573
bfd * solib_bfd_fopen(char *pathname, int fd)
Definition: solib.c:459
Definition: solist.h:30
static char * find_program_interpreter(void)
Definition: solib-darwin.c:208
CORE_ADDR all_image_addr
Definition: solib-darwin.c:76
#define SO_NAME_MAX_PATH_SIZE
Definition: solist.h:22
#define _(String)
Definition: gdb_locale.h:40
struct bfd * gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:320
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
int(* open_symbol_file_object)(void *from_ttyp)
Definition: solist.h:123
CORE_ADDR mach_header
Definition: solib-darwin.c:47
void gdb_bfd_ref(struct bfd *abfd)
Definition: gdb_bfd.c:439
struct lm_info * lm_info
Definition: solist.h:42
void null_cleanup(void *arg)
Definition: cleanups.c:295
void(* clear_solib)(void)
Definition: solist.h:98
char * solib_find(char *in_pathname, int *fd)
Definition: solib.c:419
const char *const name
Definition: aarch64-tdep.c:68
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
Definition: solist.h:127
static void darwin_free_so(struct so_list *so)
Definition: solib-darwin.c:545
#define DYLD_VERSION_MIN
Definition: solib-darwin.c:69
struct gdb_dyld_all_image_infos all_image
Definition: solib-darwin.c:79
char * gnutarget
Definition: corefile.c:437
struct target_ops current_target
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void initialize_file_ftype(void)
Definition: defs.h:281
#define exec_bfd
Definition: exec.h:32
static struct darwin_info * get_darwin_info(void)
Definition: solib-darwin.c:95
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:49
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
Definition: gdbtypes.h:749
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:52
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static void darwin_pspace_data_cleanup(struct program_space *pspace, void *arg)
Definition: solib-darwin.c:86
struct target_so_ops darwin_so_ops
Definition: solib-darwin.c:615
#define symfile_objfile
Definition: progspace.h:216
CORE_ADDR endaddr
Definition: target.h:2260
static struct so_list * darwin_current_sos(void)
Definition: solib-darwin.c:240
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
void * xmalloc(YYSIZE_T)
void(* special_symbol_handling)(void)
Definition: solist.h:107
CORE_ADDR addr
Definition: target.h:2259
const char * interp_name(struct interp *interp)
Definition: interps.c:273
bfd_byte gdb_byte
Definition: common-types.h:38
static void darwin_relocate_section_addresses(struct so_list *so, struct target_section *sec)
Definition: solib-darwin.c:553
unsigned length
Definition: gdbtypes.h:807
CORE_ADDR addr_low
Definition: solist.h:77
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
struct so_list sl
Definition: solib-darwin.c:164
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
static void darwin_load_image_infos(struct darwin_info *info)
Definition: solib-darwin.c:121
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1174
static void darwin_clear_solib(void)
Definition: solib-darwin.c:536
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
#define DYLD_VERSION_MAX
Definition: solib-darwin.c:70
void(* free_so)(struct so_list *so)
Definition: solist.h:89
static void darwin_solib_create_inferior_hook(int from_tty)
Definition: solib-darwin.c:495
CORE_ADDR lm_addr
Definition: nto-tdep.c:257
struct inferior * current_inferior(void)
Definition: inferior.c:57
struct program_space * current_program_space
Definition: progspace.c:35
static bfd * gdb_bfd_mach_o_fat_extract(bfd *abfd, bfd_format format, const bfd_arch_info_type *arch)
Definition: solib-darwin.c:395
Definition: symtab.h:703
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1590
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
CORE_ADDR addr_high
Definition: solist.h:77
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
static int darwin_in_dynsym_resolve_code(CORE_ADDR pc)
Definition: solib-darwin.c:377
static void darwin_solib_get_all_image_info_addr_at_init(struct darwin_info *info)
Definition: solib-darwin.c:415
static CORE_ADDR lookup_symbol_from_bfd(bfd *abfd, char *symname)
Definition: solib-darwin.c:172
int target_read_string(CORE_ADDR memaddr, char **string, int len, int *errnop)
Definition: target.c:915
initialize_file_ftype _initialize_darwin_solib
void error(const char *fmt,...)
Definition: errors.c:38
void objfile_rebase(struct objfile *objfile, CORE_ADDR slide)
Definition: objfiles.c:901
static int open_symbol_file_object(void *from_ttyp)
Definition: solib-darwin.c:232
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static void darwin_special_symbol_handling(void)
Definition: solib-darwin.c:386
__extension__ enum domain_enum_tag domain
Definition: symtab.h:730
const ULONGEST const LONGEST len
Definition: target.h:309