Automatic date update in version.in
[external/binutils.git] / gdb / i386-fbsd-tdep.c
1 /* Target-dependent code for FreeBSD/i386.
2
3    Copyright (C) 2003-2019 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 "arch-utils.h"
22 #include "gdbcore.h"
23 #include "osabi.h"
24 #include "regcache.h"
25 #include "regset.h"
26 #include "i386-fbsd-tdep.h"
27 #include "common/x86-xstate.h"
28
29 #include "i386-tdep.h"
30 #include "i387-tdep.h"
31 #include "fbsd-tdep.h"
32 #include "solib-svr4.h"
33
34 /* Support for signal handlers.  */
35
36 /* Return whether THIS_FRAME corresponds to a FreeBSD sigtramp
37    routine.  */
38
39 /* FreeBSD/i386 supports three different signal trampolines, one for
40    versions before 4.0, a second for 4.x, and a third for 5.0 and
41    later.  To complicate matters, FreeBSD/i386 binaries running under
42    an amd64 kernel use a different set of trampolines.  These
43    trampolines differ from the i386 kernel trampolines in that they
44    omit a middle section that conditionally restores %gs.  */
45
46 static const gdb_byte i386fbsd_sigtramp_start[] =
47 {
48   0x8d, 0x44, 0x24, 0x20,       /* lea     SIGF_UC(%esp),%eax */
49   0x50                          /* pushl   %eax */
50 };
51
52 static const gdb_byte i386fbsd_sigtramp_middle[] =
53 {
54   0xf7, 0x40, 0x54, 0x00, 0x00, 0x02, 0x00,
55                                 /* testl   $PSL_VM,UC_EFLAGS(%eax) */
56   0x75, 0x03,                   /* jne     +3 */
57   0x8e, 0x68, 0x14              /* mov     UC_GS(%eax),%gs */
58 };
59
60 static const gdb_byte i386fbsd_sigtramp_end[] =
61 {
62   0xb8, 0xa1, 0x01, 0x00, 0x00, /* movl   $SYS_sigreturn,%eax */
63   0x50,                 /* pushl   %eax */
64   0xcd, 0x80                    /* int     $0x80 */
65 };
66
67 static const gdb_byte i386fbsd_freebsd4_sigtramp_start[] =
68 {
69   0x8d, 0x44, 0x24, 0x14,       /* lea     SIGF_UC4(%esp),%eax */
70   0x50                          /* pushl   %eax */
71 };
72
73 static const gdb_byte i386fbsd_freebsd4_sigtramp_middle[] =
74 {
75   0xf7, 0x40, 0x54, 0x00, 0x00, 0x02, 0x00,
76                                 /* testl   $PSL_VM,UC4_EFLAGS(%eax) */
77   0x75, 0x03,                   /* jne     +3 */
78   0x8e, 0x68, 0x14              /* mov     UC4_GS(%eax),%gs */
79 };
80
81 static const gdb_byte i386fbsd_freebsd4_sigtramp_end[] =
82 {
83   0xb8, 0x58, 0x01, 0x00, 0x00, /* movl    $344,%eax */
84   0x50,                 /* pushl   %eax */
85   0xcd, 0x80                    /* int     $0x80 */
86 };
87
88 static const gdb_byte i386fbsd_osigtramp_start[] =
89 {
90   0x8d, 0x44, 0x24, 0x14,       /* lea     SIGF_SC(%esp),%eax */
91   0x50                          /* pushl   %eax */
92 };
93
94 static const gdb_byte i386fbsd_osigtramp_middle[] =
95 {
96   0xf7, 0x40, 0x18, 0x00, 0x00, 0x02, 0x00,
97                                 /* testl   $PSL_VM,SC_PS(%eax) */
98   0x75, 0x03,                   /* jne     +3 */
99   0x8e, 0x68, 0x44              /* mov     SC_GS(%eax),%gs */
100 };
101
102 static const gdb_byte i386fbsd_osigtramp_end[] =
103 {
104   0xb8, 0x67, 0x00, 0x00, 0x00, /* movl    $103,%eax */
105   0x50,                 /* pushl   %eax */
106   0xcd, 0x80                    /* int     $0x80 */
107 };
108
109 /* The three different trampolines are all the same size.  */
110 gdb_static_assert (sizeof i386fbsd_sigtramp_start
111                    == sizeof i386fbsd_freebsd4_sigtramp_start);
112 gdb_static_assert (sizeof i386fbsd_sigtramp_start
113                    == sizeof i386fbsd_osigtramp_start);
114 gdb_static_assert (sizeof i386fbsd_sigtramp_middle
115                    == sizeof i386fbsd_freebsd4_sigtramp_middle);
116 gdb_static_assert (sizeof i386fbsd_sigtramp_middle
117                    == sizeof i386fbsd_osigtramp_middle);
118 gdb_static_assert (sizeof i386fbsd_sigtramp_end
119                    == sizeof i386fbsd_freebsd4_sigtramp_end);
120 gdb_static_assert (sizeof i386fbsd_sigtramp_end
121                    == sizeof i386fbsd_osigtramp_end);
122
123 /* We assume that the middle is the largest chunk below.  */
124 gdb_static_assert (sizeof i386fbsd_sigtramp_middle
125                    > sizeof i386fbsd_sigtramp_start);
126 gdb_static_assert (sizeof i386fbsd_sigtramp_middle
127                    > sizeof i386fbsd_sigtramp_end);
128
129 static int
130 i386fbsd_sigtramp_p (struct frame_info *this_frame)
131 {
132   CORE_ADDR pc = get_frame_pc (this_frame);
133   gdb_byte buf[sizeof i386fbsd_sigtramp_middle];
134   const gdb_byte *middle, *end;
135
136   /* Look for a matching start.  */
137   if (!safe_frame_unwind_memory (this_frame, pc, buf,
138                                  sizeof i386fbsd_sigtramp_start))
139     return 0;
140   if (memcmp (buf, i386fbsd_sigtramp_start, sizeof i386fbsd_sigtramp_start)
141       == 0)
142     {
143       middle = i386fbsd_sigtramp_middle;
144       end = i386fbsd_sigtramp_end;
145     }
146   else if (memcmp (buf, i386fbsd_freebsd4_sigtramp_start,
147                    sizeof i386fbsd_freebsd4_sigtramp_start) == 0)
148     {
149       middle = i386fbsd_freebsd4_sigtramp_middle;
150       end = i386fbsd_freebsd4_sigtramp_end;
151     }
152   else if (memcmp (buf, i386fbsd_osigtramp_start,
153                    sizeof i386fbsd_osigtramp_start) == 0)
154     {
155       middle = i386fbsd_osigtramp_middle;
156       end = i386fbsd_osigtramp_end;
157     }
158   else
159     return 0;
160
161   /* Since the end is shorter than the middle, check for a matching end
162      next.  */
163   pc += sizeof i386fbsd_sigtramp_start;
164   if (!safe_frame_unwind_memory (this_frame, pc, buf,
165                                  sizeof i386fbsd_sigtramp_end))
166     return 0;
167   if (memcmp (buf, end, sizeof i386fbsd_sigtramp_end) == 0)
168     return 1;
169
170   /* If the end didn't match, check for a matching middle.  */
171   if (!safe_frame_unwind_memory (this_frame, pc, buf,
172                                  sizeof i386fbsd_sigtramp_middle))
173     return 0;
174   if (memcmp (buf, middle, sizeof i386fbsd_sigtramp_middle) != 0)
175     return 0;
176
177   /* The middle matched, check for a matching end.  */
178   pc += sizeof i386fbsd_sigtramp_middle;
179   if (!safe_frame_unwind_memory (this_frame, pc, buf,
180                                  sizeof i386fbsd_sigtramp_end))
181     return 0;
182   if (memcmp (buf, end, sizeof i386fbsd_sigtramp_end) != 0)
183     return 0;
184
185   return 1;
186 }
187
188 /* FreeBSD 3.0-RELEASE or later.  */
189
190 /* From <machine/reg.h>.  */
191 static int i386fbsd_r_reg_offset[] =
192 {
193   9 * 4, 8 * 4, 7 * 4, 6 * 4,   /* %eax, %ecx, %edx, %ebx */
194   15 * 4, 4 * 4,                /* %esp, %ebp */
195   3 * 4, 2 * 4,                 /* %esi, %edi */
196   12 * 4, 14 * 4,               /* %eip, %eflags */
197   13 * 4, 16 * 4,               /* %cs, %ss */
198   1 * 4, 0 * 4, -1, -1          /* %ds, %es, %fs, %gs */
199 };
200
201 /* Sigtramp routine location.  */
202 CORE_ADDR i386fbsd_sigtramp_start_addr;
203 CORE_ADDR i386fbsd_sigtramp_end_addr;
204
205 /* From <machine/signal.h>.  */
206 int i386fbsd_sc_reg_offset[] =
207 {
208   8 + 14 * 4,                   /* %eax */
209   8 + 13 * 4,                   /* %ecx */
210   8 + 12 * 4,                   /* %edx */
211   8 + 11 * 4,                   /* %ebx */
212   8 + 0 * 4,                    /* %esp */
213   8 + 1 * 4,                    /* %ebp */
214   8 + 10 * 4,                   /* %esi */
215   8 + 9 * 4,                    /* %edi */
216   8 + 3 * 4,                    /* %eip */
217   8 + 4 * 4,                    /* %eflags */
218   8 + 7 * 4,                    /* %cs */
219   8 + 8 * 4,                    /* %ss */
220   8 + 6 * 4,                    /* %ds */
221   8 + 5 * 4,                    /* %es */
222   8 + 15 * 4,                   /* %fs */
223   8 + 16 * 4                    /* %gs */
224 };
225
226 /* Get XSAVE extended state xcr0 from core dump.  */
227
228 uint64_t
229 i386fbsd_core_read_xcr0 (bfd *abfd)
230 {
231   asection *xstate = bfd_get_section_by_name (abfd, ".reg-xstate");
232   uint64_t xcr0;
233
234   if (xstate)
235     {
236       size_t size = bfd_section_size (abfd, xstate);
237
238       /* Check extended state size.  */
239       if (size < X86_XSTATE_AVX_SIZE)
240         xcr0 = X86_XSTATE_SSE_MASK;
241       else
242         {
243           char contents[8];
244
245           if (! bfd_get_section_contents (abfd, xstate, contents,
246                                           I386_FBSD_XSAVE_XCR0_OFFSET,
247                                           8))
248             {
249               warning (_("Couldn't read `xcr0' bytes from "
250                          "`.reg-xstate' section in core file."));
251               return X86_XSTATE_SSE_MASK;
252             }
253
254           xcr0 = bfd_get_64 (abfd, contents);
255         }
256     }
257   else
258     xcr0 = X86_XSTATE_SSE_MASK;
259
260   return xcr0;
261 }
262
263 /* Implement the core_read_description gdbarch method.  */
264
265 static const struct target_desc *
266 i386fbsd_core_read_description (struct gdbarch *gdbarch,
267                                 struct target_ops *target,
268                                 bfd *abfd)
269 {
270   return i386_target_description (i386fbsd_core_read_xcr0 (abfd));
271 }
272
273 /* Similar to i386_supply_fpregset, but use XSAVE extended state.  */
274
275 static void
276 i386fbsd_supply_xstateregset (const struct regset *regset,
277                               struct regcache *regcache, int regnum,
278                               const void *xstateregs, size_t len)
279 {
280   i387_supply_xsave (regcache, regnum, xstateregs);
281 }
282
283 /* Similar to i386_collect_fpregset, but use XSAVE extended state.  */
284
285 static void
286 i386fbsd_collect_xstateregset (const struct regset *regset,
287                                const struct regcache *regcache,
288                                int regnum, void *xstateregs, size_t len)
289 {
290   i387_collect_xsave (regcache, regnum, xstateregs, 1);
291 }
292
293 /* Register set definitions.  */
294
295 static const struct regset i386fbsd_xstateregset =
296   {
297     NULL,
298     i386fbsd_supply_xstateregset,
299     i386fbsd_collect_xstateregset
300   };
301
302 /* Iterate over core file register note sections.  */
303
304 static void
305 i386fbsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
306                                        iterate_over_regset_sections_cb *cb,
307                                        void *cb_data,
308                                        const struct regcache *regcache)
309 {
310   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
311
312   cb (".reg", tdep->sizeof_gregset, tdep->sizeof_gregset, &i386_gregset, NULL,
313       cb_data);
314   cb (".reg2", tdep->sizeof_fpregset, tdep->sizeof_fpregset, &i386_fpregset,
315       NULL, cb_data);
316
317   if (tdep->xcr0 & X86_XSTATE_AVX)
318     cb (".reg-xstate", X86_XSTATE_SIZE (tdep->xcr0),
319         X86_XSTATE_SIZE (tdep->xcr0), &i386fbsd_xstateregset,
320         "XSAVE extended state", cb_data);
321 }
322
323 static void
324 i386fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
325 {
326   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
327
328   /* Obviously FreeBSD is BSD-based.  */
329   i386bsd_init_abi (info, gdbarch);
330
331   /* FreeBSD has a different `struct reg', and reserves some space for
332      its FPU emulator in `struct fpreg'.  */
333   tdep->gregset_reg_offset = i386fbsd_r_reg_offset;
334   tdep->gregset_num_regs = ARRAY_SIZE (i386fbsd_r_reg_offset);
335   tdep->sizeof_gregset = 18 * 4;
336   tdep->sizeof_fpregset = 176;
337
338   /* FreeBSD uses -freg-struct-return by default.  */
339   tdep->struct_return = reg_struct_return;
340
341   tdep->sigtramp_p = i386fbsd_sigtramp_p;
342
343   /* FreeBSD uses a different memory layout.  */
344   tdep->sigtramp_start = i386fbsd_sigtramp_start_addr;
345   tdep->sigtramp_end = i386fbsd_sigtramp_end_addr;
346
347   /* FreeBSD has a more complete `struct sigcontext'.  */
348   tdep->sc_reg_offset = i386fbsd_sc_reg_offset;
349   tdep->sc_num_regs = ARRAY_SIZE (i386fbsd_sc_reg_offset);
350
351   i386_elf_init_abi (info, gdbarch);
352
353   /* FreeBSD uses SVR4-style shared libraries.  */
354   set_solib_svr4_fetch_link_map_offsets
355     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
356 }
357
358 /* FreeBSD 4.0-RELEASE or later.  */
359
360 /* From <machine/reg.h>.  */
361 static int i386fbsd4_r_reg_offset[] =
362 {
363   10 * 4, 9 * 4, 8 * 4, 7 * 4,  /* %eax, %ecx, %edx, %ebx */
364   16 * 4, 5 * 4,                /* %esp, %ebp */
365   4 * 4, 3 * 4,                 /* %esi, %edi */
366   13 * 4, 15 * 4,               /* %eip, %eflags */
367   14 * 4, 17 * 4,               /* %cs, %ss */
368   2 * 4, 1 * 4, 0 * 4, 18 * 4   /* %ds, %es, %fs, %gs */
369 };
370
371 /* From <machine/signal.h>.  */
372 int i386fbsd4_sc_reg_offset[] =
373 {
374   20 + 11 * 4,                  /* %eax */
375   20 + 10 * 4,                  /* %ecx */
376   20 + 9 * 4,                   /* %edx */
377   20 + 8 * 4,                   /* %ebx */
378   20 + 17 * 4,                  /* %esp */
379   20 + 6 * 4,                   /* %ebp */
380   20 + 5 * 4,                   /* %esi */
381   20 + 4 * 4,                   /* %edi */
382   20 + 14 * 4,                  /* %eip */
383   20 + 16 * 4,                  /* %eflags */
384   20 + 15 * 4,                  /* %cs */
385   20 + 18 * 4,                  /* %ss */
386   20 + 3 * 4,                   /* %ds */
387   20 + 2 * 4,                   /* %es */
388   20 + 1 * 4,                   /* %fs */
389   20 + 0 * 4                    /* %gs */
390 };
391
392 static void
393 i386fbsd4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
394 {
395   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
396
397   /* Generic FreeBSD support. */
398   fbsd_init_abi (info, gdbarch);
399
400   /* Inherit stuff from older releases.  We assume that FreeBSD
401      4.0-RELEASE always uses ELF.  */
402   i386fbsd_init_abi (info, gdbarch);
403
404   /* FreeBSD 4.0 introduced a new `struct reg'.  */
405   tdep->gregset_reg_offset = i386fbsd4_r_reg_offset;
406   tdep->gregset_num_regs = ARRAY_SIZE (i386fbsd4_r_reg_offset);
407   tdep->sizeof_gregset = 19 * 4;
408
409   /* FreeBSD 4.0 introduced a new `struct sigcontext'.  */
410   tdep->sc_reg_offset = i386fbsd4_sc_reg_offset;
411   tdep->sc_num_regs = ARRAY_SIZE (i386fbsd4_sc_reg_offset);
412
413   tdep->xsave_xcr0_offset = I386_FBSD_XSAVE_XCR0_OFFSET;
414
415   /* Iterate over core file register note sections.  */
416   set_gdbarch_iterate_over_regset_sections
417     (gdbarch, i386fbsd_iterate_over_regset_sections);
418
419   set_gdbarch_core_read_description (gdbarch,
420                                      i386fbsd_core_read_description);
421 }
422
423 void
424 _initialize_i386fbsd_tdep (void)
425 {
426   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_FREEBSD,
427                           i386fbsd4_init_abi);
428 }