GDB (xrefs)

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