Handle FreeBSD-specific AT_EHDRFLAGS and AT_HWCAP auxiliary vector types.
[external/binutils.git] / gdb / fbsd-tdep.c
1 /* Target-dependent code for FreeBSD, architecture-independent.
2
3    Copyright (C) 2002-2017 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "auxv.h"
22 #include "gdbcore.h"
23 #include "inferior.h"
24 #include "regcache.h"
25 #include "regset.h"
26 #include "gdbthread.h"
27 #include "xml-syscall.h"
28
29 #include "elf-bfd.h"
30 #include "fbsd-tdep.h"
31
32
33 /* FreeBSD kernels 12.0 and later include a copy of the
34    'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
35    operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
36    The constants below define the offset of field members and flags in
37    this structure used by methods in this file.  Note that the
38    'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
39    containing the size of the structure.  */
40
41 #define LWPINFO_OFFSET          0x4
42
43 /* Offsets in ptrace_lwpinfo.  */
44 #define LWPINFO_PL_FLAGS        0x8
45 #define LWPINFO64_PL_SIGINFO    0x30
46 #define LWPINFO32_PL_SIGINFO    0x2c
47
48 /* Flags in pl_flags.  */
49 #define PL_FLAG_SI      0x20    /* siginfo is valid */
50
51 /* Sizes of siginfo_t.  */
52 #define SIZE64_SIGINFO_T        80
53 #define SIZE32_SIGINFO_T        64
54
55 static struct gdbarch_data *fbsd_gdbarch_data_handle;
56
57 struct fbsd_gdbarch_data
58   {
59     struct type *siginfo_type;
60   };
61
62 static void *
63 init_fbsd_gdbarch_data (struct gdbarch *gdbarch)
64 {
65   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct fbsd_gdbarch_data);
66 }
67
68 static struct fbsd_gdbarch_data *
69 get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
70 {
71   return ((struct fbsd_gdbarch_data *)
72           gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
73 }
74
75 /* This is how we want PTIDs from core files to be printed.  */
76
77 static const char *
78 fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
79 {
80   static char buf[80];
81
82   if (ptid_get_lwp (ptid) != 0)
83     {
84       xsnprintf (buf, sizeof buf, "LWP %ld", ptid_get_lwp (ptid));
85       return buf;
86     }
87
88   return normal_pid_to_str (ptid);
89 }
90
91 /* Extract the name assigned to a thread from a core.  Returns the
92    string in a static buffer.  */
93
94 static const char *
95 fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
96 {
97   static char buf[80];
98   struct bfd_section *section;
99   bfd_size_type size;
100
101   if (ptid_get_lwp (thr->ptid) != 0)
102     {
103       /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
104          whose contents are defined by a "struct thrmisc" declared in
105          <sys/procfs.h> on FreeBSD.  The per-thread name is stored as
106          a null-terminated string as the first member of the
107          structure.  Rather than define the full structure here, just
108          extract the null-terminated name from the start of the
109          note.  */
110       thread_section_name section_name (".thrmisc", thr->ptid);
111
112       section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
113       if (section != NULL && bfd_section_size (core_bfd, section) > 0)
114         {
115           /* Truncate the name if it is longer than "buf".  */
116           size = bfd_section_size (core_bfd, section);
117           if (size > sizeof buf - 1)
118             size = sizeof buf - 1;
119           if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
120                                         size)
121               && buf[0] != '\0')
122             {
123               buf[size] = '\0';
124
125               /* Note that each thread will report the process command
126                  as its thread name instead of an empty name if a name
127                  has not been set explicitly.  Return a NULL name in
128                  that case.  */
129               if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
130                 return buf;
131             }
132         }
133     }
134
135   return NULL;
136 }
137
138 /* Implement the "core_xfer_siginfo" gdbarch method.  */
139
140 static LONGEST
141 fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
142                         ULONGEST offset, ULONGEST len)
143 {
144   size_t siginfo_size;
145
146   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
147     siginfo_size = SIZE32_SIGINFO_T;
148   else
149     siginfo_size = SIZE64_SIGINFO_T;
150   if (offset > siginfo_size)
151     return -1;
152
153   thread_section_name section_name (".note.freebsdcore.lwpinfo", inferior_ptid);
154   asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
155   if (section == NULL)
156     return -1;
157
158   gdb_byte buf[4];
159   if (!bfd_get_section_contents (core_bfd, section, buf,
160                                  LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4))
161     return -1;
162
163   int pl_flags = extract_signed_integer (buf, 4, gdbarch_byte_order (gdbarch));
164   if (!(pl_flags & PL_FLAG_SI))
165     return -1;
166
167   if (offset + len > siginfo_size)
168     len = siginfo_size - offset;
169
170   ULONGEST siginfo_offset;
171   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
172     siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO;
173   else
174     siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO;
175
176   if (!bfd_get_section_contents (core_bfd, section, readbuf,
177                                  siginfo_offset + offset, len))
178     return -1;
179
180   return len;
181 }
182
183 static int
184 find_signalled_thread (struct thread_info *info, void *data)
185 {
186   if (info->suspend.stop_signal != GDB_SIGNAL_0
187       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
188     return 1;
189
190   return 0;
191 }
192
193 /* Structure for passing information from
194    fbsd_collect_thread_registers via an iterator to
195    fbsd_collect_regset_section_cb. */
196
197 struct fbsd_collect_regset_section_cb_data
198 {
199   const struct regcache *regcache;
200   bfd *obfd;
201   char *note_data;
202   int *note_size;
203   unsigned long lwp;
204   enum gdb_signal stop_signal;
205   int abort_iteration;
206 };
207
208 static void
209 fbsd_collect_regset_section_cb (const char *sect_name, int size,
210                                 const struct regset *regset,
211                                 const char *human_name, void *cb_data)
212 {
213   char *buf;
214   struct fbsd_collect_regset_section_cb_data *data
215     = (struct fbsd_collect_regset_section_cb_data *) cb_data;
216
217   if (data->abort_iteration)
218     return;
219
220   gdb_assert (regset->collect_regset);
221
222   buf = (char *) xmalloc (size);
223   regset->collect_regset (regset, data->regcache, -1, buf, size);
224
225   /* PRSTATUS still needs to be treated specially.  */
226   if (strcmp (sect_name, ".reg") == 0)
227     data->note_data = (char *) elfcore_write_prstatus
228       (data->obfd, data->note_data, data->note_size, data->lwp,
229        gdb_signal_to_host (data->stop_signal), buf);
230   else
231     data->note_data = (char *) elfcore_write_register_note
232       (data->obfd, data->note_data, data->note_size,
233        sect_name, buf, size);
234   xfree (buf);
235
236   if (data->note_data == NULL)
237     data->abort_iteration = 1;
238 }
239
240 /* Records the thread's register state for the corefile note
241    section.  */
242
243 static char *
244 fbsd_collect_thread_registers (const struct regcache *regcache,
245                                ptid_t ptid, bfd *obfd,
246                                char *note_data, int *note_size,
247                                enum gdb_signal stop_signal)
248 {
249   struct gdbarch *gdbarch = get_regcache_arch (regcache);
250   struct fbsd_collect_regset_section_cb_data data;
251
252   data.regcache = regcache;
253   data.obfd = obfd;
254   data.note_data = note_data;
255   data.note_size = note_size;
256   data.stop_signal = stop_signal;
257   data.abort_iteration = 0;
258   data.lwp = ptid_get_lwp (ptid);
259
260   gdbarch_iterate_over_regset_sections (gdbarch,
261                                         fbsd_collect_regset_section_cb,
262                                         &data, regcache);
263   return data.note_data;
264 }
265
266 struct fbsd_corefile_thread_data
267 {
268   struct gdbarch *gdbarch;
269   bfd *obfd;
270   char *note_data;
271   int *note_size;
272   enum gdb_signal stop_signal;
273 };
274
275 /* Records the thread's register state for the corefile note
276    section.  */
277
278 static void
279 fbsd_corefile_thread (struct thread_info *info,
280                       struct fbsd_corefile_thread_data *args)
281 {
282   struct regcache *regcache;
283
284   regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
285
286   target_fetch_registers (regcache, -1);
287
288   args->note_data = fbsd_collect_thread_registers
289     (regcache, info->ptid, args->obfd, args->note_data,
290      args->note_size, args->stop_signal);
291 }
292
293 /* Create appropriate note sections for a corefile, returning them in
294    allocated memory.  */
295
296 static char *
297 fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
298 {
299   struct fbsd_corefile_thread_data thread_args;
300   char *note_data = NULL;
301   Elf_Internal_Ehdr *i_ehdrp;
302   struct thread_info *curr_thr, *signalled_thr, *thr;
303
304   /* Put a "FreeBSD" label in the ELF header.  */
305   i_ehdrp = elf_elfheader (obfd);
306   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
307
308   gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));
309
310   if (get_exec_file (0))
311     {
312       const char *fname = lbasename (get_exec_file (0));
313       char *psargs = xstrdup (fname);
314
315       if (get_inferior_args ())
316         psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
317                            (char *) NULL);
318
319       note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
320                                           fname, psargs);
321     }
322
323   /* Thread register information.  */
324   TRY
325     {
326       update_thread_list ();
327     }
328   CATCH (e, RETURN_MASK_ERROR)
329     {
330       exception_print (gdb_stderr, e);
331     }
332   END_CATCH
333
334   /* Like the kernel, prefer dumping the signalled thread first.
335      "First thread" is what tools use to infer the signalled thread.
336      In case there's more than one signalled thread, prefer the
337      current thread, if it is signalled.  */
338   curr_thr = inferior_thread ();
339   if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
340     signalled_thr = curr_thr;
341   else
342     {
343       signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
344       if (signalled_thr == NULL)
345         signalled_thr = curr_thr;
346     }
347
348   thread_args.gdbarch = gdbarch;
349   thread_args.obfd = obfd;
350   thread_args.note_data = note_data;
351   thread_args.note_size = note_size;
352   thread_args.stop_signal = signalled_thr->suspend.stop_signal;
353
354   fbsd_corefile_thread (signalled_thr, &thread_args);
355   ALL_NON_EXITED_THREADS (thr)
356     {
357       if (thr == signalled_thr)
358         continue;
359       if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
360         continue;
361
362       fbsd_corefile_thread (thr, &thread_args);
363     }
364
365   note_data = thread_args.note_data;
366
367   return note_data;
368 }
369
370 /* Print descriptions of FreeBSD-specific AUXV entries to FILE.  */
371
372 static void
373 fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
374                        CORE_ADDR type, CORE_ADDR val)
375 {
376   const char *name;
377   const char *description;
378   enum auxv_format format;
379
380   switch (type)
381     {
382 #define _TAGNAME(tag) #tag
383 #define TAGNAME(tag) _TAGNAME(AT_##tag)
384 #define TAG(tag, text, kind) \
385       case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
386       TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
387       TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
388       TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
389       TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
390       TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
391       TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
392       TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
393       TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
394       TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
395       TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX);
396       TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX);
397     default:
398       default_print_auxv_entry (gdbarch, file, type, val);
399       return;
400     }
401
402   fprint_auxv_entry (file, name, description, format, type, val);
403 }
404
405 /* Implement the "get_siginfo_type" gdbarch method.  */
406
407 static struct type *
408 fbsd_get_siginfo_type (struct gdbarch *gdbarch)
409 {
410   struct fbsd_gdbarch_data *fbsd_gdbarch_data;
411   struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
412   struct type *uid_type, *pid_type;
413   struct type *sigval_type, *reason_type;
414   struct type *siginfo_type;
415   struct type *type;
416
417   fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
418   if (fbsd_gdbarch_data->siginfo_type != NULL)
419     return fbsd_gdbarch_data->siginfo_type;
420
421   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
422                                 0, "int");
423   int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
424   uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
425   long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
426                                  0, "long");
427   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
428
429   /* union sigval */
430   sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
431   TYPE_NAME (sigval_type) = xstrdup ("sigval");
432   append_composite_type_field (sigval_type, "sival_int", int_type);
433   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
434
435   /* __pid_t */
436   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
437                         TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
438   TYPE_TARGET_TYPE (pid_type) = int32_type;
439   TYPE_TARGET_STUB (pid_type) = 1;
440
441   /* __uid_t */
442   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
443                         TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
444                         "__uid_t");
445   TYPE_TARGET_TYPE (uid_type) = uint32_type;
446   TYPE_TARGET_STUB (uid_type) = 1;
447
448   /* _reason */
449   reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
450
451   /* _fault */
452   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
453   append_composite_type_field (type, "si_trapno", int_type);
454   append_composite_type_field (reason_type, "_fault", type);
455
456   /* _timer */
457   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
458   append_composite_type_field (type, "si_timerid", int_type);
459   append_composite_type_field (type, "si_overrun", int_type);
460   append_composite_type_field (reason_type, "_timer", type);
461
462   /* _mesgq */
463   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
464   append_composite_type_field (type, "si_mqd", int_type);
465   append_composite_type_field (reason_type, "_mesgq", type);
466
467   /* _poll */
468   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
469   append_composite_type_field (type, "si_band", long_type);
470   append_composite_type_field (reason_type, "_poll", type);
471
472   /* __spare__ */
473   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
474   append_composite_type_field (type, "__spare1__", long_type);
475   append_composite_type_field (type, "__spare2__",
476                                init_vector_type (int_type, 7));
477   append_composite_type_field (reason_type, "__spare__", type);
478
479   /* struct siginfo */
480   siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
481   TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
482   append_composite_type_field (siginfo_type, "si_signo", int_type);
483   append_composite_type_field (siginfo_type, "si_errno", int_type);
484   append_composite_type_field (siginfo_type, "si_code", int_type);
485   append_composite_type_field (siginfo_type, "si_pid", pid_type);
486   append_composite_type_field (siginfo_type, "si_uid", uid_type);
487   append_composite_type_field (siginfo_type, "si_status", int_type);
488   append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
489   append_composite_type_field (siginfo_type, "si_value", sigval_type);
490   append_composite_type_field (siginfo_type, "_reason", reason_type);
491
492   fbsd_gdbarch_data->siginfo_type = siginfo_type;
493
494   return siginfo_type;
495 }
496
497 /* Implement the "get_syscall_number" gdbarch method.  */
498
499 static LONGEST
500 fbsd_get_syscall_number (struct gdbarch *gdbarch,
501                          ptid_t ptid)
502 {
503
504   /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
505      native targets fetch the system call number from the
506      'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
507      However, system call catching requires this function to be
508      set.  */
509
510   internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
511 }
512
513 /* To be called from GDB_OSABI_FREEBSD handlers. */
514
515 void
516 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
517 {
518   set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
519   set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
520   set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
521   set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
522   set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
523   set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
524
525   /* `catch syscall' */
526   set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
527   set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
528 }
529
530 void
531 _initialize_fbsd_tdep (void)
532 {
533   fbsd_gdbarch_data_handle =
534     gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
535 }