GDB copyright headers update after running GDB's copyright.py script.
[external/binutils.git] / gdb / solib-darwin.c
1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
2
3    Copyright (C) 2009-2016 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 14
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
157 {
158   /* The target location of lm.  */
159   CORE_ADDR lm_addr;
160 };
161
162 struct darwin_so_list
163 {
164   /* Common field.  */
165   struct so_list sl;
166   /* Darwin specific data.  */
167   struct lm_info li;
168 };
169
170 /* Lookup the value for a specific symbol.  */
171
172 static CORE_ADDR
173 lookup_symbol_from_bfd (bfd *abfd, char *symname)
174 {
175   long storage_needed;
176   asymbol **symbol_table;
177   unsigned int number_of_symbols;
178   unsigned int i;
179   CORE_ADDR symaddr = 0;
180
181   storage_needed = bfd_get_symtab_upper_bound (abfd);
182
183   if (storage_needed <= 0)
184     return 0;
185
186   symbol_table = (asymbol **) xmalloc (storage_needed);
187   number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
188
189   for (i = 0; i < number_of_symbols; i++)
190     {
191       asymbol *sym = symbol_table[i];
192
193       if (strcmp (sym->name, symname) == 0
194           && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
195         {
196           /* BFD symbols are section relative.  */
197           symaddr = sym->value + sym->section->vma;
198           break;
199         }
200     }
201   xfree (symbol_table);
202
203   return symaddr;
204 }
205
206 /* Return program interpreter string.  */
207
208 static char *
209 find_program_interpreter (void)
210 {
211   char *buf = NULL;
212
213   /* If we have an exec_bfd, get the interpreter from the load commands.  */
214   if (exec_bfd)
215     {
216       bfd_mach_o_load_command *cmd;
217
218       if (bfd_mach_o_lookup_command (exec_bfd,
219                                      BFD_MACH_O_LC_LOAD_DYLINKER, &cmd) == 1)
220         return cmd->command.dylinker.name_str;
221     }
222
223   /* If we didn't find it, read from memory.
224      FIXME: todo.  */
225   return buf;
226 }
227
228 /*  Not used.  I don't see how the main symbol file can be found: the
229     interpreter name is needed and it is known from the executable file.
230     Note that darwin-nat.c implements pid_to_exec_file.  */
231
232 static int
233 open_symbol_file_object (void *from_ttyp)
234 {
235   return 0;
236 }
237
238 /* Build a list of currently loaded shared objects.  See solib-svr4.c.  */
239
240 static struct so_list *
241 darwin_current_sos (void)
242 {
243   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
244   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
245   int ptr_len = TYPE_LENGTH (ptr_type);
246   unsigned int image_info_size;
247   struct so_list *head = NULL;
248   struct so_list *tail = NULL;
249   int i;
250   struct darwin_info *info = get_darwin_info ();
251
252   /* Be sure image infos are loaded.  */
253   darwin_load_image_infos (info);
254
255   if (!darwin_dyld_version_ok (info))
256     return NULL;
257
258   image_info_size = ptr_len * 3;
259
260   /* Read infos for each solib.
261      The first entry was rumored to be the executable itself, but this is not
262      true when a large number of shared libraries are used (table expanded ?).
263      We now check all entries, but discard executable images.  */
264   for (i = 0; i < info->all_image.count; i++)
265     {
266       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
267       gdb_byte buf[image_info_size];
268       CORE_ADDR load_addr;
269       CORE_ADDR path_addr;
270       struct mach_o_header_external hdr;
271       unsigned long hdr_val;
272       char *file_path;
273       int errcode;
274       struct darwin_so_list *dnew;
275       struct so_list *newobj;
276       struct cleanup *old_chain;
277
278       /* Read image info from inferior.  */
279       if (target_read_memory (iinfo, buf, image_info_size))
280         break;
281
282       load_addr = extract_typed_address (buf, ptr_type);
283       path_addr = extract_typed_address (buf + ptr_len, ptr_type);
284
285       /* Read Mach-O header from memory.  */
286       if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
287         break;
288       /* Discard wrong magic numbers.  Shouldn't happen.  */
289       hdr_val = extract_unsigned_integer
290         (hdr.magic, sizeof (hdr.magic), byte_order);
291       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
292         continue;
293       /* Discard executable.  Should happen only once.  */
294       hdr_val = extract_unsigned_integer
295         (hdr.filetype, sizeof (hdr.filetype), byte_order);
296       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
297         continue;
298
299       target_read_string (path_addr, &file_path,
300                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
301       if (errcode)
302         break;
303
304       /* Create and fill the new so_list element.  */
305       dnew = XCNEW (struct darwin_so_list);
306       newobj = &dnew->sl;
307       old_chain = make_cleanup (xfree, dnew);
308
309       newobj->lm_info = &dnew->li;
310
311       strncpy (newobj->so_name, file_path, SO_NAME_MAX_PATH_SIZE - 1);
312       newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
313       strcpy (newobj->so_original_name, newobj->so_name);
314       xfree (file_path);
315       newobj->lm_info->lm_addr = load_addr;
316
317       if (head == NULL)
318         head = newobj;
319       else
320         tail->next = newobj;
321       tail = newobj;
322
323       discard_cleanups (old_chain);
324     }
325
326   return head;
327 }
328
329 /* Check LOAD_ADDR points to a Mach-O executable header.  Return LOAD_ADDR
330    in case of success, 0 in case of failure.  */
331
332 static CORE_ADDR
333 darwin_validate_exec_header (CORE_ADDR load_addr)
334 {
335   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
336   struct mach_o_header_external hdr;
337   unsigned long hdr_val;
338
339   /* Read Mach-O header from memory.  */
340   if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
341     return 0;
342
343   /* Discard wrong magic numbers.  Shouldn't happen.  */
344   hdr_val = extract_unsigned_integer
345     (hdr.magic, sizeof (hdr.magic), byte_order);
346   if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
347     return 0;
348
349   /* Check executable.  */
350   hdr_val = extract_unsigned_integer
351     (hdr.filetype, sizeof (hdr.filetype), byte_order);
352   if (hdr_val == BFD_MACH_O_MH_EXECUTE)
353     return load_addr;
354
355   return 0;
356 }
357
358 /* Get the load address of the executable using dyld list of images.
359    We assume that the dyld info are correct (which is wrong if the target
360    is stopped at the first instruction).  */
361
362 static CORE_ADDR
363 darwin_read_exec_load_addr_from_dyld (struct darwin_info *info)
364 {
365   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
366   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
367   int ptr_len = TYPE_LENGTH (ptr_type);
368   unsigned int image_info_size = ptr_len * 3;
369   int i;
370
371   /* Read infos for each solib.  One of them should be the executable.  */
372   for (i = 0; i < info->all_image.count; i++)
373     {
374       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
375       gdb_byte buf[image_info_size];
376       CORE_ADDR load_addr;
377
378       /* Read image info from inferior.  */
379       if (target_read_memory (iinfo, buf, image_info_size))
380         break;
381
382       load_addr = extract_typed_address (buf, ptr_type);
383       if (darwin_validate_exec_header (load_addr) == load_addr)
384         return load_addr;
385     }
386
387   return 0;
388 }
389
390 /* Get the load address of the executable when the PC is at the dyld
391    entry point using parameter passed by the kernel (at SP). */
392
393 static CORE_ADDR
394 darwin_read_exec_load_addr_at_init (struct darwin_info *info)
395 {
396   struct gdbarch *gdbarch = target_gdbarch ();
397   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
398   int addr_size = gdbarch_addr_bit (gdbarch) / 8;
399   ULONGEST load_ptr_addr;
400   ULONGEST load_addr;
401   gdb_byte buf[8];
402
403   /* Get SP.  */
404   if (regcache_cooked_read_unsigned (get_current_regcache (),
405                                      gdbarch_sp_regnum (gdbarch),
406                                      &load_ptr_addr) != REG_VALID)
407     return 0;
408
409   /* Read value at SP (image load address).  */
410   if (target_read_memory (load_ptr_addr, buf, addr_size))
411     return 0;
412
413   load_addr = extract_unsigned_integer (buf, addr_size, byte_order);
414
415   return darwin_validate_exec_header (load_addr);
416 }
417
418 /* Return 1 if PC lies in the dynamic symbol resolution code of the
419    run time loader.  */
420
421 static int
422 darwin_in_dynsym_resolve_code (CORE_ADDR pc)
423 {
424   return 0;
425 }
426
427
428 /* No special symbol handling.  */
429
430 static void
431 darwin_special_symbol_handling (void)
432 {
433 }
434
435 /* A wrapper for bfd_mach_o_fat_extract that handles reference
436    counting properly.  This will either return NULL, or return a new
437    reference to a BFD.  */
438
439 static bfd *
440 gdb_bfd_mach_o_fat_extract (bfd *abfd, bfd_format format,
441                             const bfd_arch_info_type *arch)
442 {
443   bfd *result = bfd_mach_o_fat_extract (abfd, format, arch);
444
445   if (result == NULL)
446     return NULL;
447
448   if (result == abfd)
449     gdb_bfd_ref (result);
450   else
451     gdb_bfd_mark_parent (result, abfd);
452
453   return result;
454 }
455
456 /* Extract dyld_all_image_addr when the process was just created, assuming the
457    current PC is at the entry of the dynamic linker.  */
458
459 static void
460 darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
461 {
462   char *interp_name;
463   CORE_ADDR load_addr = 0;
464   bfd *dyld_bfd = NULL;
465   struct cleanup *cleanup;
466
467   /* This method doesn't work with an attached process.  */
468   if (current_inferior ()->attach_flag)
469     return;
470
471   /* Find the program interpreter.  */
472   interp_name = find_program_interpreter ();
473   if (!interp_name)
474     return;
475
476   cleanup = make_cleanup (null_cleanup, NULL);
477
478   /* Create a bfd for the interpreter.  */
479   dyld_bfd = gdb_bfd_open (interp_name, gnutarget, -1);
480   if (dyld_bfd)
481     {
482       bfd *sub;
483
484       make_cleanup_bfd_unref (dyld_bfd);
485       sub = gdb_bfd_mach_o_fat_extract
486         (dyld_bfd, bfd_object, gdbarch_bfd_arch_info (target_gdbarch ()));
487       if (sub)
488         {
489           dyld_bfd = sub;
490           make_cleanup_bfd_unref (sub);
491         }
492       else
493         dyld_bfd = NULL;
494     }
495   if (!dyld_bfd)
496     {
497       do_cleanups (cleanup);
498       return;
499     }
500
501   /* We find the dynamic linker's base address by examining
502      the current pc (which should point at the entry point for the
503      dynamic linker) and subtracting the offset of the entry point.  */
504   load_addr = (regcache_read_pc (get_current_regcache ())
505                - bfd_get_start_address (dyld_bfd));
506
507   /* Now try to set a breakpoint in the dynamic linker.  */
508   info->all_image_addr =
509     lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos");
510
511   do_cleanups (cleanup);
512
513   if (info->all_image_addr == 0)
514     return;
515
516   info->all_image_addr += load_addr;
517 }
518
519 /* Extract dyld_all_image_addr reading it from
520    TARGET_OBJECT_DARWIN_DYLD_INFO.  */
521
522 static void
523 darwin_solib_read_all_image_info_addr (struct darwin_info *info)
524 {
525   gdb_byte buf[8];
526   LONGEST len;
527   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
528   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
529
530   /* Sanity check.  */
531   if (TYPE_LENGTH (ptr_type) > sizeof (buf))
532     return;
533
534   len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
535                      buf, 0, TYPE_LENGTH (ptr_type));
536   if (len <= 0)
537     return;
538
539   /* The use of BIG endian is intended, as BUF is a raw stream of bytes.  This
540       makes the support of remote protocol easier.  */
541   info->all_image_addr = extract_unsigned_integer (buf, len, BFD_ENDIAN_BIG);
542 }
543
544 /* Shared library startup support.  See documentation in solib-svr4.c.  */
545
546 static void
547 darwin_solib_create_inferior_hook (int from_tty)
548 {
549   struct darwin_info *info = get_darwin_info ();
550   CORE_ADDR load_addr;
551
552   info->all_image_addr = 0;
553
554   darwin_solib_read_all_image_info_addr (info);
555
556   if (info->all_image_addr == 0)
557     darwin_solib_get_all_image_info_addr_at_init (info);
558
559   if (info->all_image_addr == 0)
560     return;
561
562   darwin_load_image_infos (info);
563
564   if (!darwin_dyld_version_ok (info))
565     {
566       warning (_("unhandled dyld version (%d)"), info->all_image.version);
567       return;
568     }
569
570   /* Add the breakpoint which is hit by dyld when the list of solib is
571      modified.  */
572   create_solib_event_breakpoint (target_gdbarch (), info->all_image.notifier);
573
574   if (info->all_image.count != 0)
575     {
576       /* Possible relocate the main executable (PIE).  */
577       load_addr = darwin_read_exec_load_addr_from_dyld (info);
578     }
579   else
580     {
581       /* Possible issue:
582          Do not break on the notifier if dyld is not initialized (deduced from
583          count == 0).  In that case, dyld hasn't relocated itself and the
584          notifier may point to a wrong address.  */
585
586       load_addr = darwin_read_exec_load_addr_at_init (info);
587     }
588
589   if (load_addr != 0 && symfile_objfile != NULL)
590     {
591       CORE_ADDR vmaddr;
592
593       /* Find the base address of the executable.  */
594       vmaddr = bfd_mach_o_get_base_address (exec_bfd);
595
596       /* Relocate.  */
597       if (vmaddr != load_addr)
598         objfile_rebase (symfile_objfile, load_addr - vmaddr);
599     }
600 }
601
602 static void
603 darwin_clear_solib (void)
604 {
605   struct darwin_info *info = get_darwin_info ();
606
607   info->all_image_addr = 0;
608   info->all_image.version = 0;
609 }
610
611 static void
612 darwin_free_so (struct so_list *so)
613 {
614 }
615
616 /* The section table is built from bfd sections using bfd VMAs.
617    Relocate these VMAs according to solib info.  */
618
619 static void
620 darwin_relocate_section_addresses (struct so_list *so,
621                                    struct target_section *sec)
622 {
623   sec->addr += so->lm_info->lm_addr;
624   sec->endaddr += so->lm_info->lm_addr;
625
626   /* Best effort to set addr_high/addr_low.  This is used only by
627      'info sharedlibary'.  */
628   if (so->addr_high == 0)
629     {
630       so->addr_low = sec->addr;
631       so->addr_high = sec->endaddr;
632     }
633   if (sec->endaddr > so->addr_high)
634     so->addr_high = sec->endaddr;
635   if (sec->addr < so->addr_low)
636     so->addr_low = sec->addr;
637 }
638 \f
639 static struct block_symbol
640 darwin_lookup_lib_symbol (struct objfile *objfile,
641                           const char *name,
642                           const domain_enum domain)
643 {
644   return (struct block_symbol) {NULL, NULL};
645 }
646
647 static bfd *
648 darwin_bfd_open (char *pathname)
649 {
650   char *found_pathname;
651   int found_file;
652   bfd *abfd;
653   bfd *res;
654
655   /* Search for shared library file.  */
656   found_pathname = solib_find (pathname, &found_file);
657   if (found_pathname == NULL)
658     perror_with_name (pathname);
659
660   /* Open bfd for shared library.  */
661   abfd = solib_bfd_fopen (found_pathname, found_file);
662
663   res = gdb_bfd_mach_o_fat_extract (abfd, bfd_object,
664                                     gdbarch_bfd_arch_info (target_gdbarch ()));
665   if (!res)
666     {
667       make_cleanup_bfd_unref (abfd);
668       error (_("`%s': not a shared-library: %s"),
669              bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
670     }
671
672   /* The current filename for fat-binary BFDs is a name generated
673      by BFD, usually a string containing the name of the architecture.
674      Reset its value to the actual filename.  */
675   xfree (bfd_get_filename (res));
676   res->filename = xstrdup (pathname);
677
678   gdb_bfd_unref (abfd);
679   return res;
680 }
681
682 struct target_so_ops darwin_so_ops;
683
684 /* -Wmissing-prototypes */
685 extern initialize_file_ftype _initialize_darwin_solib;
686
687 void
688 _initialize_darwin_solib (void)
689 {
690   solib_darwin_pspace_data
691     = register_program_space_data_with_cleanup (NULL,
692                                                 darwin_pspace_data_cleanup);
693
694   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
695   darwin_so_ops.free_so = darwin_free_so;
696   darwin_so_ops.clear_solib = darwin_clear_solib;
697   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
698   darwin_so_ops.special_symbol_handling = darwin_special_symbol_handling;
699   darwin_so_ops.current_sos = darwin_current_sos;
700   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
701   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
702   darwin_so_ops.lookup_lib_global_symbol = darwin_lookup_lib_symbol;
703   darwin_so_ops.bfd_open = darwin_bfd_open;
704 }