1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 2009-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
30 #include "gdbthread.h"
35 #include "solib-svr4.h"
37 #include "bfd-target.h"
42 #include "mach-o/external.h"
44 struct gdb_dyld_image_info
46 /* Base address (which corresponds to the Mach-O header). */
47 CORE_ADDR mach_header
;
48 /* Image file path. */
50 /* st.m_time of image file. */
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
60 /* Number of images. */
62 /* Image description. */
64 /* Notifier (function called when a library is added or removed). */
68 /* Current all_image_infos version. */
69 #define DYLD_VERSION_MIN 1
70 #define DYLD_VERSION_MAX 15
72 /* Per PSPACE specific data. */
75 /* Address of structure dyld_all_image_infos in inferior. */
76 CORE_ADDR all_image_addr
= 0;
78 /* Gdb copy of dyld_all_info_infos. */
79 struct gdb_dyld_all_image_infos all_image
{};
82 /* Per-program-space data key. */
83 static program_space_key
<darwin_info
> solib_darwin_pspace_data
;
85 /* Get the current darwin data. If none is found yet, add it now. This
86 function always returns a valid object. */
88 static struct darwin_info
*
89 get_darwin_info (void)
91 struct darwin_info
*info
;
93 info
= solib_darwin_pspace_data
.get (current_program_space
);
97 return solib_darwin_pspace_data
.emplace (current_program_space
);
100 /* Return non-zero if the version in dyld_all_image is known. */
103 darwin_dyld_version_ok (const struct darwin_info
*info
)
105 return info
->all_image
.version
>= DYLD_VERSION_MIN
106 && info
->all_image
.version
<= DYLD_VERSION_MAX
;
109 /* Read dyld_all_image from inferior. */
112 darwin_load_image_infos (struct darwin_info
*info
)
115 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
116 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
119 /* If the structure address is not known, don't continue. */
120 if (info
->all_image_addr
== 0)
123 /* The structure has 4 fields: version (4 bytes), count (4 bytes),
124 info (pointer) and notifier (pointer). */
125 len
= 4 + 4 + 2 * TYPE_LENGTH (ptr_type
);
126 gdb_assert (len
<= sizeof (buf
));
127 memset (&info
->all_image
, 0, sizeof (info
->all_image
));
129 /* Read structure raw bytes from target. */
130 if (target_read_memory (info
->all_image_addr
, buf
, len
))
133 /* Extract the fields. */
134 info
->all_image
.version
= extract_unsigned_integer (buf
, 4, byte_order
);
135 if (!darwin_dyld_version_ok (info
))
138 info
->all_image
.count
= extract_unsigned_integer (buf
+ 4, 4, byte_order
);
139 info
->all_image
.info
= extract_typed_address (buf
+ 8, ptr_type
);
140 info
->all_image
.notifier
= extract_typed_address
141 (buf
+ 8 + TYPE_LENGTH (ptr_type
), ptr_type
);
144 /* Link map info to include in an allocated so_list entry. */
146 struct lm_info_darwin
: public lm_info_base
148 /* The target location of lm. */
149 CORE_ADDR lm_addr
= 0;
152 /* Lookup the value for a specific symbol. */
155 lookup_symbol_from_bfd (bfd
*abfd
, const char *symname
)
158 asymbol
**symbol_table
;
159 unsigned int number_of_symbols
;
161 CORE_ADDR symaddr
= 0;
163 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
165 if (storage_needed
<= 0)
168 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
169 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
171 for (i
= 0; i
< number_of_symbols
; i
++)
173 asymbol
*sym
= symbol_table
[i
];
175 if (strcmp (sym
->name
, symname
) == 0
176 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
178 /* BFD symbols are section relative. */
179 symaddr
= sym
->value
+ sym
->section
->vma
;
183 xfree (symbol_table
);
188 /* Return program interpreter string. */
191 find_program_interpreter (void)
195 /* If we have an current exec_bfd, get the interpreter from the load
197 if (current_program_space
->exec_bfd ())
199 bfd_mach_o_load_command
*cmd
;
201 if (bfd_mach_o_lookup_command (current_program_space
->exec_bfd (),
202 BFD_MACH_O_LC_LOAD_DYLINKER
, &cmd
) == 1)
203 return cmd
->command
.dylinker
.name_str
;
206 /* If we didn't find it, read from memory.
211 /* Not used. I don't see how the main symbol file can be found: the
212 interpreter name is needed and it is known from the executable file.
213 Note that darwin-nat.c implements pid_to_exec_file. */
216 open_symbol_file_object (int from_tty
)
221 /* Build a list of currently loaded shared objects. See solib-svr4.c. */
223 static struct so_list
*
224 darwin_current_sos (void)
226 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
227 enum bfd_endian byte_order
= type_byte_order (ptr_type
);
228 int ptr_len
= TYPE_LENGTH (ptr_type
);
229 unsigned int image_info_size
;
230 struct so_list
*head
= NULL
;
231 struct so_list
*tail
= NULL
;
233 struct darwin_info
*info
= get_darwin_info ();
235 /* Be sure image infos are loaded. */
236 darwin_load_image_infos (info
);
238 if (!darwin_dyld_version_ok (info
))
241 image_info_size
= ptr_len
* 3;
243 /* Read infos for each solib.
244 The first entry was rumored to be the executable itself, but this is not
245 true when a large number of shared libraries are used (table expanded ?).
246 We now check all entries, but discard executable images. */
247 for (i
= 0; i
< info
->all_image
.count
; i
++)
249 CORE_ADDR iinfo
= info
->all_image
.info
+ i
* image_info_size
;
250 gdb_byte buf
[image_info_size
];
253 struct mach_o_header_external hdr
;
254 unsigned long hdr_val
;
256 /* Read image info from inferior. */
257 if (target_read_memory (iinfo
, buf
, image_info_size
))
260 load_addr
= extract_typed_address (buf
, ptr_type
);
261 path_addr
= extract_typed_address (buf
+ ptr_len
, ptr_type
);
263 /* Read Mach-O header from memory. */
264 if (target_read_memory (load_addr
, (gdb_byte
*) &hdr
, sizeof (hdr
) - 4))
266 /* Discard wrong magic numbers. Shouldn't happen. */
267 hdr_val
= extract_unsigned_integer
268 (hdr
.magic
, sizeof (hdr
.magic
), byte_order
);
269 if (hdr_val
!= BFD_MACH_O_MH_MAGIC
&& hdr_val
!= BFD_MACH_O_MH_MAGIC_64
)
271 /* Discard executable. Should happen only once. */
272 hdr_val
= extract_unsigned_integer
273 (hdr
.filetype
, sizeof (hdr
.filetype
), byte_order
);
274 if (hdr_val
== BFD_MACH_O_MH_EXECUTE
)
277 gdb::unique_xmalloc_ptr
<char> file_path
278 = target_read_string (path_addr
, SO_NAME_MAX_PATH_SIZE
- 1);
279 if (file_path
== nullptr)
282 /* Create and fill the new so_list element. */
283 gdb::unique_xmalloc_ptr
<struct so_list
> newobj (XCNEW (struct so_list
));
285 lm_info_darwin
*li
= new lm_info_darwin
;
286 newobj
->lm_info
= li
;
288 strncpy (newobj
->so_name
, file_path
.get (), SO_NAME_MAX_PATH_SIZE
- 1);
289 newobj
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
290 strcpy (newobj
->so_original_name
, newobj
->so_name
);
291 li
->lm_addr
= load_addr
;
294 head
= newobj
.get ();
296 tail
->next
= newobj
.get ();
297 tail
= newobj
.release ();
303 /* Check LOAD_ADDR points to a Mach-O executable header. Return LOAD_ADDR
304 in case of success, 0 in case of failure. */
307 darwin_validate_exec_header (CORE_ADDR load_addr
)
309 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
310 struct mach_o_header_external hdr
;
311 unsigned long hdr_val
;
313 /* Read Mach-O header from memory. */
314 if (target_read_memory (load_addr
, (gdb_byte
*) &hdr
, sizeof (hdr
) - 4))
317 /* Discard wrong magic numbers. Shouldn't happen. */
318 hdr_val
= extract_unsigned_integer
319 (hdr
.magic
, sizeof (hdr
.magic
), byte_order
);
320 if (hdr_val
!= BFD_MACH_O_MH_MAGIC
&& hdr_val
!= BFD_MACH_O_MH_MAGIC_64
)
323 /* Check executable. */
324 hdr_val
= extract_unsigned_integer
325 (hdr
.filetype
, sizeof (hdr
.filetype
), byte_order
);
326 if (hdr_val
== BFD_MACH_O_MH_EXECUTE
)
332 /* Get the load address of the executable using dyld list of images.
333 We assume that the dyld info are correct (which is wrong if the target
334 is stopped at the first instruction). */
337 darwin_read_exec_load_addr_from_dyld (struct darwin_info
*info
)
339 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
340 int ptr_len
= TYPE_LENGTH (ptr_type
);
341 unsigned int image_info_size
= ptr_len
* 3;
344 /* Read infos for each solib. One of them should be the executable. */
345 for (i
= 0; i
< info
->all_image
.count
; i
++)
347 CORE_ADDR iinfo
= info
->all_image
.info
+ i
* image_info_size
;
348 gdb_byte buf
[image_info_size
];
351 /* Read image info from inferior. */
352 if (target_read_memory (iinfo
, buf
, image_info_size
))
355 load_addr
= extract_typed_address (buf
, ptr_type
);
356 if (darwin_validate_exec_header (load_addr
) == load_addr
)
363 /* Get the load address of the executable when the PC is at the dyld
364 entry point using parameter passed by the kernel (at SP). */
367 darwin_read_exec_load_addr_at_init (struct darwin_info
*info
)
369 struct gdbarch
*gdbarch
= target_gdbarch ();
370 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
371 int addr_size
= gdbarch_addr_bit (gdbarch
) / 8;
372 ULONGEST load_ptr_addr
;
377 if (regcache_cooked_read_unsigned (get_current_regcache (),
378 gdbarch_sp_regnum (gdbarch
),
379 &load_ptr_addr
) != REG_VALID
)
382 /* Read value at SP (image load address). */
383 if (target_read_memory (load_ptr_addr
, buf
, addr_size
))
386 load_addr
= extract_unsigned_integer (buf
, addr_size
, byte_order
);
388 return darwin_validate_exec_header (load_addr
);
391 /* Return 1 if PC lies in the dynamic symbol resolution code of the
395 darwin_in_dynsym_resolve_code (CORE_ADDR pc
)
400 /* A wrapper for bfd_mach_o_fat_extract that handles reference
401 counting properly. This will either return NULL, or return a new
402 reference to a BFD. */
404 static gdb_bfd_ref_ptr
405 gdb_bfd_mach_o_fat_extract (bfd
*abfd
, bfd_format format
,
406 const bfd_arch_info_type
*arch
)
408 bfd
*result
= bfd_mach_o_fat_extract (abfd
, format
, arch
);
414 gdb_bfd_ref (result
);
416 gdb_bfd_mark_parent (result
, abfd
);
418 return gdb_bfd_ref_ptr (result
);
421 /* Return the BFD for the program interpreter. */
423 static gdb_bfd_ref_ptr
424 darwin_get_dyld_bfd ()
428 /* This method doesn't work with an attached process. */
429 if (current_inferior ()->attach_flag
)
432 /* Find the program interpreter. */
433 interp_name
= find_program_interpreter ();
437 /* Create a bfd for the interpreter. */
438 gdb_bfd_ref_ptr
dyld_bfd (gdb_bfd_open (interp_name
, gnutarget
));
439 if (dyld_bfd
!= NULL
)
442 (gdb_bfd_mach_o_fat_extract (dyld_bfd
.get (), bfd_object
,
443 gdbarch_bfd_arch_info (target_gdbarch ())));
449 /* Extract dyld_all_image_addr when the process was just created, assuming the
450 current PC is at the entry of the dynamic linker. */
453 darwin_solib_get_all_image_info_addr_at_init (struct darwin_info
*info
)
455 CORE_ADDR load_addr
= 0;
456 gdb_bfd_ref_ptr dyld_bfd
= darwin_get_dyld_bfd ();
458 if (dyld_bfd
== NULL
)
461 /* We find the dynamic linker's base address by examining
462 the current pc (which should point at the entry point for the
463 dynamic linker) and subtracting the offset of the entry point. */
464 load_addr
= (regcache_read_pc (get_current_regcache ())
465 - bfd_get_start_address (dyld_bfd
.get ()));
467 /* Now try to set a breakpoint in the dynamic linker. */
468 info
->all_image_addr
=
469 lookup_symbol_from_bfd (dyld_bfd
.get (), "_dyld_all_image_infos");
471 if (info
->all_image_addr
== 0)
474 info
->all_image_addr
+= load_addr
;
477 /* Extract dyld_all_image_addr reading it from
478 TARGET_OBJECT_DARWIN_DYLD_INFO. */
481 darwin_solib_read_all_image_info_addr (struct darwin_info
*info
)
485 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
488 if (TYPE_LENGTH (ptr_type
) > sizeof (buf
))
491 len
= target_read (current_inferior ()->top_target (),
492 TARGET_OBJECT_DARWIN_DYLD_INFO
,
493 NULL
, buf
, 0, TYPE_LENGTH (ptr_type
));
497 /* The use of BIG endian is intended, as BUF is a raw stream of bytes. This
498 makes the support of remote protocol easier. */
499 info
->all_image_addr
= extract_unsigned_integer (buf
, len
, BFD_ENDIAN_BIG
);
502 /* Shared library startup support. See documentation in solib-svr4.c. */
505 darwin_solib_create_inferior_hook (int from_tty
)
507 /* Everything below only makes sense if we have a running inferior. */
508 if (!target_has_execution ())
511 struct darwin_info
*info
= get_darwin_info ();
514 info
->all_image_addr
= 0;
516 darwin_solib_read_all_image_info_addr (info
);
518 if (info
->all_image_addr
== 0)
519 darwin_solib_get_all_image_info_addr_at_init (info
);
521 if (info
->all_image_addr
== 0)
524 darwin_load_image_infos (info
);
526 if (!darwin_dyld_version_ok (info
))
528 warning (_("unhandled dyld version (%d)"), info
->all_image
.version
);
532 if (info
->all_image
.count
!= 0)
534 /* Possible relocate the main executable (PIE). */
535 load_addr
= darwin_read_exec_load_addr_from_dyld (info
);
540 Do not break on the notifier if dyld is not initialized (deduced from
541 count == 0). In that case, dyld hasn't relocated itself and the
542 notifier may point to a wrong address. */
544 load_addr
= darwin_read_exec_load_addr_at_init (info
);
547 if (load_addr
!= 0 && current_program_space
->symfile_object_file
!= NULL
)
551 /* Find the base address of the executable. */
552 vmaddr
= bfd_mach_o_get_base_address (current_program_space
->exec_bfd ());
555 if (vmaddr
!= load_addr
)
556 objfile_rebase (current_program_space
->symfile_object_file
,
560 /* Set solib notifier (to reload list of shared libraries). */
561 CORE_ADDR notifier
= info
->all_image
.notifier
;
563 if (info
->all_image
.count
== 0)
565 /* Dyld hasn't yet relocated itself, so the notifier address may
566 be incorrect (as it has to be relocated). */
568 = bfd_get_start_address (current_program_space
->exec_bfd ());
573 gdb_bfd_ref_ptr dyld_bfd
= darwin_get_dyld_bfd ();
574 if (dyld_bfd
!= NULL
)
576 CORE_ADDR dyld_bfd_start_address
;
577 CORE_ADDR dyld_relocated_base_address
;
580 dyld_bfd_start_address
= bfd_get_start_address (dyld_bfd
.get());
582 /* We find the dynamic linker's base address by examining
583 the current pc (which should point at the entry point
584 for the dynamic linker) and subtracting the offset of
587 pc
= regcache_read_pc (get_current_regcache ());
588 dyld_relocated_base_address
= pc
- dyld_bfd_start_address
;
590 /* We get the proper notifier relocated address by
591 adding the dyld relocated base address to the current
592 notifier offset value. */
594 notifier
+= dyld_relocated_base_address
;
599 /* Add the breakpoint which is hit by dyld when the list of solib is
602 create_solib_event_breakpoint (target_gdbarch (), notifier
);
606 darwin_clear_solib (void)
608 struct darwin_info
*info
= get_darwin_info ();
610 info
->all_image_addr
= 0;
611 info
->all_image
.version
= 0;
615 darwin_free_so (struct so_list
*so
)
617 lm_info_darwin
*li
= (lm_info_darwin
*) so
->lm_info
;
622 /* The section table is built from bfd sections using bfd VMAs.
623 Relocate these VMAs according to solib info. */
626 darwin_relocate_section_addresses (struct so_list
*so
,
627 struct target_section
*sec
)
629 lm_info_darwin
*li
= (lm_info_darwin
*) so
->lm_info
;
631 sec
->addr
+= li
->lm_addr
;
632 sec
->endaddr
+= li
->lm_addr
;
634 /* Best effort to set addr_high/addr_low. This is used only by
635 'info sharedlibary'. */
636 if (so
->addr_high
== 0)
638 so
->addr_low
= sec
->addr
;
639 so
->addr_high
= sec
->endaddr
;
641 if (sec
->endaddr
> so
->addr_high
)
642 so
->addr_high
= sec
->endaddr
;
643 if (sec
->addr
< so
->addr_low
)
644 so
->addr_low
= sec
->addr
;
647 static gdb_bfd_ref_ptr
648 darwin_bfd_open (const char *pathname
)
652 /* Search for shared library file. */
653 gdb::unique_xmalloc_ptr
<char> found_pathname
654 = solib_find (pathname
, &found_file
);
655 if (found_pathname
== NULL
)
656 perror_with_name (pathname
);
658 /* Open bfd for shared library. */
659 gdb_bfd_ref_ptr
abfd (solib_bfd_fopen (found_pathname
.get (), found_file
));
662 (gdb_bfd_mach_o_fat_extract (abfd
.get (), bfd_object
,
663 gdbarch_bfd_arch_info (target_gdbarch ())));
665 error (_("`%s': not a shared-library: %s"),
666 bfd_get_filename (abfd
.get ()), bfd_errmsg (bfd_get_error ()));
668 /* The current filename for fat-binary BFDs is a name generated
669 by BFD, usually a string containing the name of the architecture.
670 Reset its value to the actual filename. */
671 bfd_set_filename (res
.get (), pathname
);
676 struct target_so_ops darwin_so_ops
;
678 void _initialize_darwin_solib ();
680 _initialize_darwin_solib ()
682 darwin_so_ops
.relocate_section_addresses
= darwin_relocate_section_addresses
;
683 darwin_so_ops
.free_so
= darwin_free_so
;
684 darwin_so_ops
.clear_solib
= darwin_clear_solib
;
685 darwin_so_ops
.solib_create_inferior_hook
= darwin_solib_create_inferior_hook
;
686 darwin_so_ops
.current_sos
= darwin_current_sos
;
687 darwin_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
688 darwin_so_ops
.in_dynsym_resolve_code
= darwin_in_dynsym_resolve_code
;
689 darwin_so_ops
.bfd_open
= darwin_bfd_open
;