projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
rotate gdb/ChangeLog
[deliverable/binutils-gdb.git] / gdb / fbsd-tdep.c
CommitLineData
a904c024
AA		 1/* Target-dependent code for FreeBSD, architecture-independent.
2
e2882c85 3 Copyright (C) 2002-2018 Free Software Foundation, Inc.
a904c024
AA		 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"
82372b2f 21#include "auxv.h"
a904c024
AA		 22#include "gdbcore.h"
23#include "inferior.h"
24#include "regcache.h"
25#include "regset.h"
26#include "gdbthread.h"
e6cdd38e 27#include "xml-syscall.h"
57c2a98a
JB		 28#include <sys/socket.h>
29#include <arpa/inet.h>
a904c024 30
a904c024
AA		 31#include "elf-bfd.h"
32#include "fbsd-tdep.h"
33
e61667ef
RS		 34/* This enum is derived from FreeBSD's <sys/signal.h>. */
35
36enum
37 {
38 FREEBSD_SIGHUP = 1,
39 FREEBSD_SIGINT = 2,
40 FREEBSD_SIGQUIT = 3,
41 FREEBSD_SIGILL = 4,
42 FREEBSD_SIGTRAP = 5,
43 FREEBSD_SIGABRT = 6,
44 FREEBSD_SIGEMT = 7,
45 FREEBSD_SIGFPE = 8,
46 FREEBSD_SIGKILL = 9,
47 FREEBSD_SIGBUS = 10,
48 FREEBSD_SIGSEGV = 11,
49 FREEBSD_SIGSYS = 12,
50 FREEBSD_SIGPIPE = 13,
51 FREEBSD_SIGALRM = 14,
52 FREEBSD_SIGTERM = 15,
53 FREEBSD_SIGURG = 16,
54 FREEBSD_SIGSTOP = 17,
55 FREEBSD_SIGTSTP = 18,
56 FREEBSD_SIGCONT = 19,
57 FREEBSD_SIGCHLD = 20,
58 FREEBSD_SIGTTIN = 21,
59 FREEBSD_SIGTTOU = 22,
60 FREEBSD_SIGIO = 23,
61 FREEBSD_SIGXCPU = 24,
62 FREEBSD_SIGXFSZ = 25,
63 FREEBSD_SIGVTALRM = 26,
64 FREEBSD_SIGPROF = 27,
65 FREEBSD_SIGWINCH = 28,
66 FREEBSD_SIGINFO = 29,
67 FREEBSD_SIGUSR1 = 30,
68 FREEBSD_SIGUSR2 = 31,
69 FREEBSD_SIGTHR = 32,
70 FREEBSD_SIGLIBRT = 33,
71 FREEBSD_SIGRTMIN = 65,
72 FREEBSD_SIGRTMAX = 126,
73 };
a904c024 74
4b654465
JB		 75/* FreeBSD kernels 12.0 and later include a copy of the
76 'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
77 operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
78 The constants below define the offset of field members and flags in
79 this structure used by methods in this file. Note that the
80 'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
81 containing the size of the structure. */
82
83#define LWPINFO_OFFSET 0x4
84
85/* Offsets in ptrace_lwpinfo. */
86#define LWPINFO_PL_FLAGS 0x8
87#define LWPINFO64_PL_SIGINFO 0x30
88#define LWPINFO32_PL_SIGINFO 0x2c
89
90/* Flags in pl_flags. */
91#define PL_FLAG_SI 0x20 /* siginfo is valid */
92
93/* Sizes of siginfo_t. */
94#define SIZE64_SIGINFO_T 80
95#define SIZE32_SIGINFO_T 64
96
d2176225
JB		 97/* Offsets in data structure used in NT_FREEBSD_PROCSTAT_VMMAP core
98 dump notes. See <sys/user.h> for the definition of struct
99 kinfo_vmentry. This data structure should have the same layout on
57c2a98a
JB		 100 all architectures.
101
102 Note that FreeBSD 7.0 used an older version of this structure
103 (struct kinfo_ovmentry), but the NT_FREEBSD_PROCSTAT_VMMAP core
104 dump note wasn't introduced until FreeBSD 9.2. As a result, the
105 core dump note has always used the 7.1 and later structure
106 format. */
d2176225
JB		 107
108#define KVE_STRUCTSIZE 0x0
109#define KVE_START 0x8
110#define KVE_END 0x10
111#define KVE_OFFSET 0x18
112#define KVE_FLAGS 0x2c
906b4aac 113#define KVE_PROTECTION 0x38
d2176225
JB		 114#define KVE_PATH 0x88
115
116/* Flags in the 'kve_protection' field in struct kinfo_vmentry. These
117 match the KVME_PROT_* constants in <sys/user.h>. */
118
119#define KINFO_VME_PROT_READ 0x00000001
120#define KINFO_VME_PROT_WRITE 0x00000002
121#define KINFO_VME_PROT_EXEC 0x00000004
122
123/* Flags in the 'kve_flags' field in struct kinfo_vmentry. These
124 match the KVME_FLAG_* constants in <sys/user.h>. */
125
126#define KINFO_VME_FLAG_COW 0x00000001
127#define KINFO_VME_FLAG_NEEDS_COPY 0x00000002
128#define KINFO_VME_FLAG_NOCOREDUMP 0x00000004
129#define KINFO_VME_FLAG_SUPER 0x00000008
130#define KINFO_VME_FLAG_GROWS_UP 0x00000010
131#define KINFO_VME_FLAG_GROWS_DOWN 0x00000020
132
133/* Offsets in data structure used in NT_FREEBSD_PROCSTAT_FILES core
134 dump notes. See <sys/user.h> for the definition of struct
135 kinfo_file. This data structure should have the same layout on all
57c2a98a
JB		 136 architectures.
137
138 Note that FreeBSD 7.0 used an older version of this structure
139 (struct kinfo_ofile), but the NT_FREEBSD_PROCSTAT_FILES core dump
140 note wasn't introduced until FreeBSD 9.2. As a result, the core
141 dump note has always used the 7.1 and later structure format. */
d2176225
JB		 142
143#define KF_STRUCTSIZE 0x0
144#define KF_TYPE 0x4
145#define KF_FD 0x8
57c2a98a
JB		 146#define KF_FLAGS 0x10
147#define KF_OFFSET 0x18
148#define KF_VNODE_TYPE 0x20
149#define KF_SOCK_DOMAIN 0x24
150#define KF_SOCK_TYPE 0x28
151#define KF_SOCK_PROTOCOL 0x2c
152#define KF_SA_LOCAL 0x30
153#define KF_SA_PEER 0xb0
d2176225
JB		 154#define KF_PATH 0x170
155
156/* Constants for the 'kf_type' field in struct kinfo_file. These
157 match the KF_TYPE_* constants in <sys/user.h>. */
158
159#define KINFO_FILE_TYPE_VNODE 1
57c2a98a
JB		 160#define KINFO_FILE_TYPE_SOCKET 2
161#define KINFO_FILE_TYPE_PIPE 3
162#define KINFO_FILE_TYPE_FIFO 4
163#define KINFO_FILE_TYPE_KQUEUE 5
164#define KINFO_FILE_TYPE_CRYPTO 6
165#define KINFO_FILE_TYPE_MQUEUE 7
166#define KINFO_FILE_TYPE_SHM 8
167#define KINFO_FILE_TYPE_SEM 9
168#define KINFO_FILE_TYPE_PTS 10
169#define KINFO_FILE_TYPE_PROCDESC 11
d2176225
JB		 170
171/* Special values for the 'kf_fd' field in struct kinfo_file. These
172 match the KF_FD_TYPE_* constants in <sys/user.h>. */
173
174#define KINFO_FILE_FD_TYPE_CWD -1
57c2a98a
JB		 175#define KINFO_FILE_FD_TYPE_ROOT -2
176#define KINFO_FILE_FD_TYPE_JAIL -3
177#define KINFO_FILE_FD_TYPE_TRACE -4
d2176225 178#define KINFO_FILE_FD_TYPE_TEXT -5
57c2a98a
JB		 179#define KINFO_FILE_FD_TYPE_CTTY -6
180
181/* Flags in the 'kf_flags' field in struct kinfo_file. These match
182 the KF_FLAG_* constants in <sys/user.h>. */
183
184#define KINFO_FILE_FLAG_READ 0x00000001
185#define KINFO_FILE_FLAG_WRITE 0x00000002
186#define KINFO_FILE_FLAG_APPEND 0x00000004
187#define KINFO_FILE_FLAG_ASYNC 0x00000008
188#define KINFO_FILE_FLAG_FSYNC 0x00000010
189#define KINFO_FILE_FLAG_NONBLOCK 0x00000020
190#define KINFO_FILE_FLAG_DIRECT 0x00000040
191#define KINFO_FILE_FLAG_HASLOCK 0x00000080
192#define KINFO_FILE_FLAG_EXEC 0x00004000
193
194/* Constants for the 'kf_vnode_type' field in struct kinfo_file.
195 These match the KF_VTYPE_* constants in <sys/user.h>. */
196
197#define KINFO_FILE_VTYPE_VREG 1
198#define KINFO_FILE_VTYPE_VDIR 2
199#define KINFO_FILE_VTYPE_VCHR 4
200#define KINFO_FILE_VTYPE_VLNK 5
201#define KINFO_FILE_VTYPE_VSOCK 6
202#define KINFO_FILE_VTYPE_VFIFO 7
203
204/* Constants for socket address families. These match AF_* constants
205 in <sys/socket.h>. */
206
207#define FBSD_AF_UNIX 1
208#define FBSD_AF_INET 2
209#define FBSD_AF_INET6 28
210
211/* Constants for socket types. These match SOCK_* constants in
212 <sys/socket.h>. */
213
214#define FBSD_SOCK_STREAM 1
215#define FBSD_SOCK_DGRAM 2
216#define FBSD_SOCK_SEQPACKET 5
217
218/* Constants for IP protocols. These match IPPROTO_* constants in
219 <netinet/in.h>. */
220
221#define FBSD_IPPROTO_ICMP 1
222#define FBSD_IPPROTO_TCP 6
223#define FBSD_IPPROTO_UDP 17
224#define FBSD_IPPROTO_SCTP 132
225
226/* Socket address structures. These have the same layout on all
227 FreeBSD architectures. In addition, multibyte fields such as IP
228 addresses are always stored in network byte order. */
229
230struct fbsd_sockaddr_in
231{
232 uint8_t sin_len;
233 uint8_t sin_family;
234 uint8_t sin_port[2];
235 uint8_t sin_addr[4];
236 char sin_zero[8];
237};
238
239struct fbsd_sockaddr_in6
240{
241 uint8_t sin6_len;
242 uint8_t sin6_family;
243 uint8_t sin6_port[2];
244 uint32_t sin6_flowinfo;
245 uint8_t sin6_addr[16];
246 uint32_t sin6_scope_id;
247};
248
249struct fbsd_sockaddr_un
250{
251 uint8_t sun_len;
252 uint8_t sun_family;
253 char sun_path[104];
254};
d2176225
JB		 255
256/* Number of 32-bit words in a signal set. This matches _SIG_WORDS in
257 <sys/_sigset.h> and is the same value on all architectures. */
258
259#define SIG_WORDS 4
260
261/* Offsets in data structure used in NT_FREEBSD_PROCSTAT_PROC core
262 dump notes. See <sys/user.h> for the definition of struct
263 kinfo_proc. This data structure has different layouts on different
264 architectures mostly due to ILP32 vs LP64. However, FreeBSD/i386
265 uses a 32-bit time_t while all other architectures use a 64-bit
266 time_t.
267
268 The core dump note actually contains one kinfo_proc structure for
269 each thread, but all of the process-wide data can be obtained from
270 the first structure. One result of this note's format is that some
271 of the process-wide status available in the native target method
272 from the kern.proc.pid.<pid> sysctl such as ki_stat and ki_siglist
273 is not available from a core dump. Instead, the per-thread data
274 structures contain the value of these fields for individual
275 threads. */
276
277struct kinfo_proc_layout
278{
279 /* Offsets of struct kinfo_proc members. */
280 int ki_layout;
281 int ki_pid;
282 int ki_ppid;
283 int ki_pgid;
284 int ki_tpgid;
285 int ki_sid;
286 int ki_tdev_freebsd11;
287 int ki_sigignore;
288 int ki_sigcatch;
289 int ki_uid;
290 int ki_ruid;
291 int ki_svuid;
292 int ki_rgid;
293 int ki_svgid;
294 int ki_ngroups;
295 int ki_groups;
296 int ki_size;
297 int ki_rssize;
298 int ki_tsize;
299 int ki_dsize;
300 int ki_ssize;
301 int ki_start;
302 int ki_nice;
303 int ki_comm;
304 int ki_tdev;
305 int ki_rusage;
306 int ki_rusage_ch;
307
308 /* Offsets of struct rusage members. */
309 int ru_utime;
310 int ru_stime;
311 int ru_maxrss;
312 int ru_minflt;
313 int ru_majflt;
314};
315
316const struct kinfo_proc_layout kinfo_proc_layout_32 =
317 {
318 .ki_layout = 0x4,
319 .ki_pid = 0x28,
320 .ki_ppid = 0x2c,
321 .ki_pgid = 0x30,
322 .ki_tpgid = 0x34,
323 .ki_sid = 0x38,
324 .ki_tdev_freebsd11 = 0x44,
325 .ki_sigignore = 0x68,
326 .ki_sigcatch = 0x78,
327 .ki_uid = 0x88,
328 .ki_ruid = 0x8c,
329 .ki_svuid = 0x90,
330 .ki_rgid = 0x94,
331 .ki_svgid = 0x98,
332 .ki_ngroups = 0x9c,
333 .ki_groups = 0xa0,
334 .ki_size = 0xe0,
335 .ki_rssize = 0xe4,
336 .ki_tsize = 0xec,
337 .ki_dsize = 0xf0,
338 .ki_ssize = 0xf4,
339 .ki_start = 0x118,
340 .ki_nice = 0x145,
341 .ki_comm = 0x17f,
342 .ki_tdev = 0x1f0,
343 .ki_rusage = 0x220,
344 .ki_rusage_ch = 0x278,
345
346 .ru_utime = 0x0,
347 .ru_stime = 0x10,
348 .ru_maxrss = 0x20,
349 .ru_minflt = 0x30,
350 .ru_majflt = 0x34,
351 };
352
353const struct kinfo_proc_layout kinfo_proc_layout_i386 =
354 {
355 .ki_layout = 0x4,
356 .ki_pid = 0x28,
357 .ki_ppid = 0x2c,
358 .ki_pgid = 0x30,
359 .ki_tpgid = 0x34,
360 .ki_sid = 0x38,
361 .ki_tdev_freebsd11 = 0x44,
362 .ki_sigignore = 0x68,
363 .ki_sigcatch = 0x78,
364 .ki_uid = 0x88,
365 .ki_ruid = 0x8c,
366 .ki_svuid = 0x90,
367 .ki_rgid = 0x94,
368 .ki_svgid = 0x98,
369 .ki_ngroups = 0x9c,
370 .ki_groups = 0xa0,
371 .ki_size = 0xe0,
372 .ki_rssize = 0xe4,
373 .ki_tsize = 0xec,
374 .ki_dsize = 0xf0,
375 .ki_ssize = 0xf4,
376 .ki_start = 0x118,
377 .ki_nice = 0x135,
378 .ki_comm = 0x16f,
379 .ki_tdev = 0x1e0,
380 .ki_rusage = 0x210,
381 .ki_rusage_ch = 0x258,
382
383 .ru_utime = 0x0,
384 .ru_stime = 0x8,
385 .ru_maxrss = 0x10,
386 .ru_minflt = 0x20,
387 .ru_majflt = 0x24,
388 };
389
390const struct kinfo_proc_layout kinfo_proc_layout_64 =
391 {
392 .ki_layout = 0x4,
393 .ki_pid = 0x48,
394 .ki_ppid = 0x4c,
395 .ki_pgid = 0x50,
396 .ki_tpgid = 0x54,
397 .ki_sid = 0x58,
398 .ki_tdev_freebsd11 = 0x64,
399 .ki_sigignore = 0x88,
400 .ki_sigcatch = 0x98,
401 .ki_uid = 0xa8,
402 .ki_ruid = 0xac,
403 .ki_svuid = 0xb0,
404 .ki_rgid = 0xb4,
405 .ki_svgid = 0xb8,
406 .ki_ngroups = 0xbc,
407 .ki_groups = 0xc0,
408 .ki_size = 0x100,
409 .ki_rssize = 0x108,
410 .ki_tsize = 0x118,
411 .ki_dsize = 0x120,
412 .ki_ssize = 0x128,
413 .ki_start = 0x150,
414 .ki_nice = 0x185,
415 .ki_comm = 0x1bf,
416 .ki_tdev = 0x230,
417 .ki_rusage = 0x260,
418 .ki_rusage_ch = 0x2f0,
419
420 .ru_utime = 0x0,
421 .ru_stime = 0x10,
422 .ru_maxrss = 0x20,
423 .ru_minflt = 0x40,
424 .ru_majflt = 0x48,
425 };
426
762c974a
JB		 427static struct gdbarch_data *fbsd_gdbarch_data_handle;
428
429struct fbsd_gdbarch_data
430 {
431 struct type *siginfo_type;
432 };
433
434static void *
435init_fbsd_gdbarch_data (struct gdbarch *gdbarch)
436{
437 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct fbsd_gdbarch_data);
438}
439
440static struct fbsd_gdbarch_data *
441get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
442{
443 return ((struct fbsd_gdbarch_data *)
444 gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
445}
446
79117428
JB		 447/* This is how we want PTIDs from core files to be printed. */
448
7a114964 449static const char *
79117428
JB		 450fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
451{
452 static char buf[80];
453
e38504b3 454 if (ptid.lwp () != 0)
79117428 455 {
e38504b3 456 xsnprintf (buf, sizeof buf, "LWP %ld", ptid.lwp ());
79117428
JB		 457 return buf;
458 }
459
460 return normal_pid_to_str (ptid);
461}
462
463/* Extract the name assigned to a thread from a core. Returns the
464 string in a static buffer. */
465
466static const char *
467fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
468{
469 static char buf[80];
470 struct bfd_section *section;
471 bfd_size_type size;
79117428 472
e38504b3 473 if (thr->ptid.lwp () != 0)
79117428
JB		 474 {
475 /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
476 whose contents are defined by a "struct thrmisc" declared in
477 <sys/procfs.h> on FreeBSD. The per-thread name is stored as
478 a null-terminated string as the first member of the
479 structure. Rather than define the full structure here, just
480 extract the null-terminated name from the start of the
481 note. */
2af9fc44
JB		 482 thread_section_name section_name (".thrmisc", thr->ptid);
483
484 section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
79117428
JB		 485 if (section != NULL && bfd_section_size (core_bfd, section) > 0)
486 {
487 /* Truncate the name if it is longer than "buf". */
488 size = bfd_section_size (core_bfd, section);
489 if (size > sizeof buf - 1)
490 size = sizeof buf - 1;
491 if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
492 size)
493 && buf[0] != '\0')
494 {
495 buf[size] = '\0';
496
497 /* Note that each thread will report the process command
498 as its thread name instead of an empty name if a name
499 has not been set explicitly. Return a NULL name in
500 that case. */
501 if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
502 return buf;
503 }
504 }
505 }
506
507 return NULL;
508}
509
4b654465
JB		 510/* Implement the "core_xfer_siginfo" gdbarch method. */
511
512static LONGEST
513fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
514 ULONGEST offset, ULONGEST len)
515{
516 size_t siginfo_size;
517
a181c0bf 518 if (gdbarch_long_bit (gdbarch) == 32)
4b654465
JB		 519 siginfo_size = SIZE32_SIGINFO_T;
520 else
521 siginfo_size = SIZE64_SIGINFO_T;
522 if (offset > siginfo_size)
523 return -1;
524
525 thread_section_name section_name (".note.freebsdcore.lwpinfo", inferior_ptid);
526 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
527 if (section == NULL)
528 return -1;
529
530 gdb_byte buf[4];
531 if (!bfd_get_section_contents (core_bfd, section, buf,
532 LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4))
533 return -1;
534
535 int pl_flags = extract_signed_integer (buf, 4, gdbarch_byte_order (gdbarch));
536 if (!(pl_flags & PL_FLAG_SI))
537 return -1;
538
539 if (offset + len > siginfo_size)
540 len = siginfo_size - offset;
541
542 ULONGEST siginfo_offset;
a181c0bf 543 if (gdbarch_long_bit (gdbarch) == 32)
4b654465
JB		 544 siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO;
545 else
546 siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO;
547
548 if (!bfd_get_section_contents (core_bfd, section, readbuf,
549 siginfo_offset + offset, len))
550 return -1;
551
552 return len;
553}
554
a904c024
AA		 555static int
556find_signalled_thread (struct thread_info *info, void *data)
557{
558 if (info->suspend.stop_signal != GDB_SIGNAL_0
e99b03dc 559 && info->ptid.pid () == inferior_ptid.pid ())
a904c024
AA		 560 return 1;
561
562 return 0;
563}
564
20a0aab3
JB		 565/* Structure for passing information from
566 fbsd_collect_thread_registers via an iterator to
567 fbsd_collect_regset_section_cb. */
a904c024
AA		 568
569struct fbsd_collect_regset_section_cb_data
570{
571 const struct regcache *regcache;
572 bfd *obfd;
573 char *note_data;
574 int *note_size;
20a0aab3
JB		 575 unsigned long lwp;
576 enum gdb_signal stop_signal;
577 int abort_iteration;
a904c024
AA		 578};
579
580static void
a616bb94
AH		 581fbsd_collect_regset_section_cb (const char *sect_name, int supply_size,
582 int collect_size, const struct regset *regset,
a904c024
AA		 583 const char *human_name, void *cb_data)
584{
585 char *buf;
7567e115
SM		 586 struct fbsd_collect_regset_section_cb_data *data
587 = (struct fbsd_collect_regset_section_cb_data *) cb_data;
a904c024 588
20a0aab3
JB		 589 if (data->abort_iteration)
590 return;
591
a904c024
AA		 592 gdb_assert (regset->collect_regset);
593
a616bb94
AH		 594 buf = (char *) xmalloc (collect_size);
595 regset->collect_regset (regset, data->regcache, -1, buf, collect_size);
a904c024
AA		 596
597 /* PRSTATUS still needs to be treated specially. */
598 if (strcmp (sect_name, ".reg") == 0)
599 data->note_data = (char *) elfcore_write_prstatus
20a0aab3
JB		 600 (data->obfd, data->note_data, data->note_size, data->lwp,
601 gdb_signal_to_host (data->stop_signal), buf);
a904c024
AA		 602 else
603 data->note_data = (char *) elfcore_write_register_note
604 (data->obfd, data->note_data, data->note_size,
a616bb94 605 sect_name, buf, collect_size);
a904c024 606 xfree (buf);
20a0aab3
JB		 607
608 if (data->note_data == NULL)
609 data->abort_iteration = 1;
610}
611
612/* Records the thread's register state for the corefile note
613 section. */
614
615static char *
616fbsd_collect_thread_registers (const struct regcache *regcache,
617 ptid_t ptid, bfd *obfd,
618 char *note_data, int *note_size,
619 enum gdb_signal stop_signal)
620{
ac7936df 621 struct gdbarch *gdbarch = regcache->arch ();
20a0aab3
JB		 622 struct fbsd_collect_regset_section_cb_data data;
623
624 data.regcache = regcache;
625 data.obfd = obfd;
626 data.note_data = note_data;
627 data.note_size = note_size;
628 data.stop_signal = stop_signal;
629 data.abort_iteration = 0;
e38504b3 630 data.lwp = ptid.lwp ();
20a0aab3
JB		 631
632 gdbarch_iterate_over_regset_sections (gdbarch,
633 fbsd_collect_regset_section_cb,
634 &data, regcache);
635 return data.note_data;
636}
637
638struct fbsd_corefile_thread_data
639{
640 struct gdbarch *gdbarch;
641 bfd *obfd;
642 char *note_data;
643 int *note_size;
644 enum gdb_signal stop_signal;
645};
646
647/* Records the thread's register state for the corefile note
648 section. */
649
650static void
651fbsd_corefile_thread (struct thread_info *info,
652 struct fbsd_corefile_thread_data *args)
653{
20a0aab3
JB		 654 struct regcache *regcache;
655
656 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
657
20a0aab3 658 target_fetch_registers (regcache, -1);
20a0aab3
JB		 659
660 args->note_data = fbsd_collect_thread_registers
661 (regcache, info->ptid, args->obfd, args->note_data,
662 args->note_size, args->stop_signal);
a904c024
AA		 663}
664
739ab2e9
SS		 665/* Return a byte_vector containing the contents of a core dump note
666 for the target object of type OBJECT. If STRUCTSIZE is non-zero,
667 the data is prefixed with a 32-bit integer size to match the format
668 used in FreeBSD NT_PROCSTAT_* notes. */
669
670static gdb::optional<gdb::byte_vector>
671fbsd_make_note_desc (enum target_object object, uint32_t structsize)
672{
673 gdb::optional<gdb::byte_vector> buf =
674 target_read_alloc (current_top_target (), object, NULL);
675 if (!buf || buf->empty ())
676 return {};
677
678 if (structsize == 0)
679 return buf;
680
681 gdb::byte_vector desc (sizeof (structsize) + buf->size ());
682 memcpy (desc.data (), &structsize, sizeof (structsize));
683 memcpy (desc.data () + sizeof (structsize), buf->data (), buf->size ());
684 return desc;
685}
686
a904c024
AA		 687/* Create appropriate note sections for a corefile, returning them in
688 allocated memory. */
689
690static char *
691fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
692{
20a0aab3
JB		 693 struct fbsd_corefile_thread_data thread_args;
694 char *note_data = NULL;
a904c024 695 Elf_Internal_Ehdr *i_ehdrp;
08036331 696 struct thread_info *curr_thr, *signalled_thr;
a904c024
AA		 697
698 /* Put a "FreeBSD" label in the ELF header. */
699 i_ehdrp = elf_elfheader (obfd);
700 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
701
702 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));
703
a904c024
AA		 704 if (get_exec_file (0))
705 {
706 const char *fname = lbasename (get_exec_file (0));
707 char *psargs = xstrdup (fname);
708
709 if (get_inferior_args ())
710 psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
711 (char *) NULL);
712
713 note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
714 fname, psargs);
715 }
716
20a0aab3
JB		 717 /* Thread register information. */
718 TRY
719 {
720 update_thread_list ();
721 }
722 CATCH (e, RETURN_MASK_ERROR)
723 {
724 exception_print (gdb_stderr, e);
725 }
726 END_CATCH
727
728 /* Like the kernel, prefer dumping the signalled thread first.
729 "First thread" is what tools use to infer the signalled thread.
730 In case there's more than one signalled thread, prefer the
731 current thread, if it is signalled. */
732 curr_thr = inferior_thread ();
733 if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
734 signalled_thr = curr_thr;
735 else
736 {
737 signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
738 if (signalled_thr == NULL)
739 signalled_thr = curr_thr;
740 }
741
742 thread_args.gdbarch = gdbarch;
743 thread_args.obfd = obfd;
744 thread_args.note_data = note_data;
745 thread_args.note_size = note_size;
746 thread_args.stop_signal = signalled_thr->suspend.stop_signal;
747
748 fbsd_corefile_thread (signalled_thr, &thread_args);
08036331 749 for (thread_info *thr : current_inferior ()->non_exited_threads ())
20a0aab3
JB		 750 {
751 if (thr == signalled_thr)
752 continue;
20a0aab3
JB		 753
754 fbsd_corefile_thread (thr, &thread_args);
755 }
756
757 note_data = thread_args.note_data;
758
739ab2e9
SS		 759 /* Auxiliary vector. */
760 uint32_t structsize = gdbarch_ptr_bit (gdbarch) / 4; /* Elf_Auxinfo */
761 gdb::optional<gdb::byte_vector> note_desc =
762 fbsd_make_note_desc (TARGET_OBJECT_AUXV, structsize);
763 if (note_desc && !note_desc->empty ())
764 {
765 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
766 NT_FREEBSD_PROCSTAT_AUXV,
767 note_desc->data (), note_desc->size ());
768 if (!note_data)
769 return NULL;
770 }
771
772 /* Virtual memory mappings. */
773 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP, 0);
774 if (note_desc && !note_desc->empty ())
775 {
776 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
777 NT_FREEBSD_PROCSTAT_VMMAP,
778 note_desc->data (), note_desc->size ());
779 if (!note_data)
780 return NULL;
781 }
782
783 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS, 0);
784 if (note_desc && !note_desc->empty ())
785 {
786 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
787 NT_FREEBSD_PROCSTAT_PSSTRINGS,
788 note_desc->data (), note_desc->size ());
789 if (!note_data)
790 return NULL;
791 }
792
a904c024
AA		 793 return note_data;
794}
795
57c2a98a
JB		 796/* Helper function to generate the file descriptor description for a
797 single open file in 'info proc files'. */
798
799static const char *
800fbsd_file_fd (int kf_fd)
801{
802 switch (kf_fd)
803 {
804 case KINFO_FILE_FD_TYPE_CWD:
805 return "cwd";
806 case KINFO_FILE_FD_TYPE_ROOT:
807 return "root";
808 case KINFO_FILE_FD_TYPE_JAIL:
809 return "jail";
810 case KINFO_FILE_FD_TYPE_TRACE:
811 return "trace";
812 case KINFO_FILE_FD_TYPE_TEXT:
813 return "text";
814 case KINFO_FILE_FD_TYPE_CTTY:
815 return "ctty";
816 default:
817 return int_string (kf_fd, 10, 1, 0, 0);
818 }
819}
820
821/* Helper function to generate the file type for a single open file in
822 'info proc files'. */
823
824static const char *
825fbsd_file_type (int kf_type, int kf_vnode_type)
826{
827 switch (kf_type)
828 {
829 case KINFO_FILE_TYPE_VNODE:
830 switch (kf_vnode_type)
831 {
832 case KINFO_FILE_VTYPE_VREG:
833 return "file";
834 case KINFO_FILE_VTYPE_VDIR:
835 return "dir";
836 case KINFO_FILE_VTYPE_VCHR:
837 return "chr";
838 case KINFO_FILE_VTYPE_VLNK:
839 return "link";
840 case KINFO_FILE_VTYPE_VSOCK:
841 return "socket";
842 case KINFO_FILE_VTYPE_VFIFO:
843 return "fifo";
844 default:
845 {
846 char *str = get_print_cell ();
847
848 xsnprintf (str, PRINT_CELL_SIZE, "vn:%d", kf_vnode_type);
849 return str;
850 }
851 }
852 case KINFO_FILE_TYPE_SOCKET:
853 return "socket";
854 case KINFO_FILE_TYPE_PIPE:
855 return "pipe";
856 case KINFO_FILE_TYPE_FIFO:
857 return "fifo";
858 case KINFO_FILE_TYPE_KQUEUE:
859 return "kqueue";
860 case KINFO_FILE_TYPE_CRYPTO:
861 return "crypto";
862 case KINFO_FILE_TYPE_MQUEUE:
863 return "mqueue";
864 case KINFO_FILE_TYPE_SHM:
865 return "shm";
866 case KINFO_FILE_TYPE_SEM:
867 return "sem";
868 case KINFO_FILE_TYPE_PTS:
869 return "pts";
870 case KINFO_FILE_TYPE_PROCDESC:
871 return "proc";
872 default:
873 return int_string (kf_type, 10, 1, 0, 0);
874 }
875}
876
877/* Helper function to generate the file flags for a single open file in
878 'info proc files'. */
879
880static const char *
881fbsd_file_flags (int kf_flags)
882{
883 static char file_flags[10];
884
885 file_flags[0] = (kf_flags & KINFO_FILE_FLAG_READ) ? 'r' : '-';
886 file_flags[1] = (kf_flags & KINFO_FILE_FLAG_WRITE) ? 'w' : '-';
887 file_flags[2] = (kf_flags & KINFO_FILE_FLAG_EXEC) ? 'x' : '-';
888 file_flags[3] = (kf_flags & KINFO_FILE_FLAG_APPEND) ? 'a' : '-';
889 file_flags[4] = (kf_flags & KINFO_FILE_FLAG_ASYNC) ? 's' : '-';
890 file_flags[5] = (kf_flags & KINFO_FILE_FLAG_FSYNC) ? 'f' : '-';
891 file_flags[6] = (kf_flags & KINFO_FILE_FLAG_NONBLOCK) ? 'n' : '-';
892 file_flags[7] = (kf_flags & KINFO_FILE_FLAG_DIRECT) ? 'd' : '-';
893 file_flags[8] = (kf_flags & KINFO_FILE_FLAG_HASLOCK) ? 'l' : '-';
894 file_flags[9] = '\0';
895
896 return file_flags;
897}
898
899/* Helper function to generate the name of an IP protocol. */
900
901static const char *
902fbsd_ipproto (int protocol)
903{
904 switch (protocol)
905 {
906 case FBSD_IPPROTO_ICMP:
907 return "icmp";
908 case FBSD_IPPROTO_TCP:
909 return "tcp";
910 case FBSD_IPPROTO_UDP:
911 return "udp";
912 case FBSD_IPPROTO_SCTP:
913 return "sctp";
914 default:
915 {
916 char *str = get_print_cell ();
917
918 xsnprintf (str, PRINT_CELL_SIZE, "ip<%d>", protocol);
919 return str;
920 }
921 }
922}
923
924/* Helper function to print out an IPv4 socket address. */
925
926static void
927fbsd_print_sockaddr_in (const void *sockaddr)
928{
929 const struct fbsd_sockaddr_in *sin =
930 reinterpret_cast<const struct fbsd_sockaddr_in *> (sockaddr);
931 char buf[INET_ADDRSTRLEN];
932
07147793 933 if (inet_ntop (AF_INET, sin->sin_addr, buf, sizeof buf) == nullptr)
57c2a98a
JB		 934 error (_("Failed to format IPv4 address"));
935 printf_filtered ("%s:%u", buf,
936 (sin->sin_port[0] << 8) | sin->sin_port[1]);
937}
938
939/* Helper function to print out an IPv6 socket address. */
940
941static void
942fbsd_print_sockaddr_in6 (const void *sockaddr)
943{
944 const struct fbsd_sockaddr_in6 *sin6 =
945 reinterpret_cast<const struct fbsd_sockaddr_in6 *> (sockaddr);
946 char buf[INET6_ADDRSTRLEN];
947
07147793 948 if (inet_ntop (AF_INET6, sin6->sin6_addr, buf, sizeof buf) == nullptr)
57c2a98a
JB		 949 error (_("Failed to format IPv6 address"));
950 printf_filtered ("%s.%u", buf,
951 (sin6->sin6_port[0] << 8) | sin6->sin6_port[1]);
952}
953
954/* See fbsd-tdep.h. */
955
956void
957fbsd_info_proc_files_header ()
958{
959 printf_filtered (_("Open files:\n\n"));
960 printf_filtered (" %6s %6s %10s %9s %s\n",
961 "FD", "Type", "Offset", "Flags ", "Name");
962}
963
964/* See fbsd-tdep.h. */
965
966void
967fbsd_info_proc_files_entry (int kf_type, int kf_fd, int kf_flags,
968 LONGEST kf_offset, int kf_vnode_type,
969 int kf_sock_domain, int kf_sock_type,
970 int kf_sock_protocol, const void *kf_sa_local,
971 const void *kf_sa_peer, const void *kf_path)
972{
973 printf_filtered (" %6s %6s %10s %8s ",
974 fbsd_file_fd (kf_fd),
975 fbsd_file_type (kf_type, kf_vnode_type),
976 kf_offset > -1 ? hex_string (kf_offset) : "-",
977 fbsd_file_flags (kf_flags));
978 if (kf_type == KINFO_FILE_TYPE_SOCKET)
979 {
980 switch (kf_sock_domain)
981 {
982 case FBSD_AF_UNIX:
983 {
984 switch (kf_sock_type)
985 {
986 case FBSD_SOCK_STREAM:
987 printf_filtered ("unix stream:");
988 break;
989 case FBSD_SOCK_DGRAM:
990 printf_filtered ("unix dgram:");
991 break;
992 case FBSD_SOCK_SEQPACKET:
993 printf_filtered ("unix seqpacket:");
994 break;
995 default:
996 printf_filtered ("unix <%d>:", kf_sock_type);
997 break;
998 }
999
1000 /* For local sockets, print out the first non-nul path
1001 rather than both paths. */
1002 const struct fbsd_sockaddr_un *sun
1003 = reinterpret_cast<const struct fbsd_sockaddr_un *> (kf_sa_local);
1004 if (sun->sun_path[0] == 0)
1005 sun = reinterpret_cast<const struct fbsd_sockaddr_un *>
1006 (kf_sa_peer);
1007 printf_filtered ("%s", sun->sun_path);
1008 break;
1009 }
1010 case FBSD_AF_INET:
1011 printf_filtered ("%s4 ", fbsd_ipproto (kf_sock_protocol));
1012 fbsd_print_sockaddr_in (kf_sa_local);
1013 printf_filtered (" -> ");
1014 fbsd_print_sockaddr_in (kf_sa_peer);
1015 break;
1016 case FBSD_AF_INET6:
1017 printf_filtered ("%s6 ", fbsd_ipproto (kf_sock_protocol));
1018 fbsd_print_sockaddr_in6 (kf_sa_local);
1019 printf_filtered (" -> ");
1020 fbsd_print_sockaddr_in6 (kf_sa_peer);
1021 break;
1022 }
1023 }
1024 else
1025 printf_filtered ("%s", reinterpret_cast<const char *> (kf_path));
1026 printf_filtered ("\n");
1027}
1028
1029/* Implement "info proc files" for a corefile. */
1030
1031static void
1032fbsd_core_info_proc_files (struct gdbarch *gdbarch)
1033{
1034 asection *section
1035 = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
1036 if (section == NULL)
1037 {
1038 warning (_("unable to find open files in core file"));
1039 return;
1040 }
1041
1042 size_t note_size = bfd_get_section_size (section);
1043 if (note_size < 4)
1044 error (_("malformed core note - too short for header"));
1045
1046 gdb::def_vector<unsigned char> contents (note_size);
1047 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1048 0, note_size))
1049 error (_("could not get core note contents"));
1050
1051 unsigned char *descdata = contents.data ();
1052 unsigned char *descend = descdata + note_size;
1053
1054 /* Skip over the structure size. */
1055 descdata += 4;
1056
1057 fbsd_info_proc_files_header ();
1058
1059 while (descdata + KF_PATH < descend)
1060 {
1061 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
1062 if (structsize < KF_PATH)
1063 error (_("malformed core note - file structure too small"));
1064
1065 LONGEST type = bfd_get_signed_32 (core_bfd, descdata + KF_TYPE);
1066 LONGEST fd = bfd_get_signed_32 (core_bfd, descdata + KF_FD);
1067 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KF_FLAGS);
1068 LONGEST offset = bfd_get_signed_64 (core_bfd, descdata + KF_OFFSET);
1069 LONGEST vnode_type = bfd_get_signed_32 (core_bfd,
1070 descdata + KF_VNODE_TYPE);
1071 LONGEST sock_domain = bfd_get_signed_32 (core_bfd,
1072 descdata + KF_SOCK_DOMAIN);
1073 LONGEST sock_type = bfd_get_signed_32 (core_bfd, descdata + KF_SOCK_TYPE);
1074 LONGEST sock_protocol = bfd_get_signed_32 (core_bfd,
1075 descdata + KF_SOCK_PROTOCOL);
1076 fbsd_info_proc_files_entry (type, fd, flags, offset, vnode_type,
1077 sock_domain, sock_type, sock_protocol,
1078 descdata + KF_SA_LOCAL, descdata + KF_SA_PEER,
1079 descdata + KF_PATH);
1080
1081 descdata += structsize;
1082 }
1083}
1084
d2176225
JB		 1085/* Helper function to generate mappings flags for a single VM map
1086 entry in 'info proc mappings'. */
1087
6f3b1098 1088static const char *
d2176225
JB		 1089fbsd_vm_map_entry_flags (int kve_flags, int kve_protection)
1090{
1091 static char vm_flags[9];
1092
1093 vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-';
1094 vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-';
1095 vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-';
1096 vm_flags[3] = ' ';
1097 vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-';
1098 vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-';
1099 vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-';
1100 vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U'
1101 : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-';
1102 vm_flags[8] = '\0';
1103
1104 return vm_flags;
1105}
1106
6f3b1098
JB		 1107/* See fbsd-tdep.h. */
1108
1109void
1110fbsd_info_proc_mappings_header (int addr_bit)
1111{
1112 printf_filtered (_("Mapped address spaces:\n\n"));
1113 if (addr_bit == 64)
1114 {
1115 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1116 "Start Addr",
1117 " End Addr",
1118 " Size", " Offset", "Flags ", "File");
1119 }
1120 else
1121 {
1122 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1123 "Start Addr",
1124 " End Addr",
1125 " Size", " Offset", "Flags ", "File");
1126 }
1127}
1128
1129/* See fbsd-tdep.h. */
1130
1131void
1132fbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start,
1133 ULONGEST kve_end, ULONGEST kve_offset,
1134 int kve_flags, int kve_protection,
1135 const void *kve_path)
1136{
1137 if (addr_bit == 64)
1138 {
1139 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1140 hex_string (kve_start),
1141 hex_string (kve_end),
1142 hex_string (kve_end - kve_start),
1143 hex_string (kve_offset),
1144 fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1145 reinterpret_cast<const char *> (kve_path));
1146 }
1147 else
1148 {
1149 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1150 hex_string (kve_start),
1151 hex_string (kve_end),
1152 hex_string (kve_end - kve_start),
1153 hex_string (kve_offset),
1154 fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1155 reinterpret_cast<const char *> (kve_path));
1156 }
1157}
1158
d2176225
JB		 1159/* Implement "info proc mappings" for a corefile. */
1160
1161static void
1162fbsd_core_info_proc_mappings (struct gdbarch *gdbarch)
1163{
1164 asection *section;
1165 unsigned char *descdata, *descend;
1166 size_t note_size;
1167
1168 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.vmmap");
1169 if (section == NULL)
1170 {
1171 warning (_("unable to find mappings in core file"));
1172 return;
1173 }
1174
1175 note_size = bfd_get_section_size (section);
1176 if (note_size < 4)
1177 error (_("malformed core note - too short for header"));
1178
1179 gdb::def_vector<unsigned char> contents (note_size);
1180 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1181 0, note_size))
1182 error (_("could not get core note contents"));
1183
1184 descdata = contents.data ();
1185 descend = descdata + note_size;
1186
1187 /* Skip over the structure size. */
1188 descdata += 4;
1189
6f3b1098 1190 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch));
d2176225
JB		 1191 while (descdata + KVE_PATH < descend)
1192 {
6f3b1098 1193 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KVE_STRUCTSIZE);
d2176225
JB		 1194 if (structsize < KVE_PATH)
1195 error (_("malformed core note - vmmap entry too small"));
1196
6f3b1098
JB		 1197 ULONGEST start = bfd_get_64 (core_bfd, descdata + KVE_START);
1198 ULONGEST end = bfd_get_64 (core_bfd, descdata + KVE_END);
1199 ULONGEST offset = bfd_get_64 (core_bfd, descdata + KVE_OFFSET);
1200 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KVE_FLAGS);
1201 LONGEST prot = bfd_get_signed_32 (core_bfd, descdata + KVE_PROTECTION);
1202 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch), start, end,
1203 offset, flags, prot, descdata + KVE_PATH);
d2176225
JB		 1204
1205 descdata += structsize;
1206 }
1207}
1208
1209/* Fetch the pathname of a vnode for a single file descriptor from the
1210 file table core note. */
1211
1212static gdb::unique_xmalloc_ptr<char>
1213fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd)
1214{
1215 asection *section;
1216 unsigned char *descdata, *descend;
1217 size_t note_size;
1218
1219 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
1220 if (section == NULL)
1221 return nullptr;
1222
1223 note_size = bfd_get_section_size (section);
1224 if (note_size < 4)
1225 error (_("malformed core note - too short for header"));
1226
1227 gdb::def_vector<unsigned char> contents (note_size);
1228 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1229 0, note_size))
1230 error (_("could not get core note contents"));
1231
1232 descdata = contents.data ();
1233 descend = descdata + note_size;
1234
1235 /* Skip over the structure size. */
1236 descdata += 4;
1237
9f235e09 1238 while (descdata + KF_PATH < descend)
d2176225
JB		 1239 {
1240 ULONGEST structsize;
1241
1242 structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
9f235e09
JB		 1243 if (structsize < KF_PATH)
1244 error (_("malformed core note - file structure too small"));
d2176225
JB		 1245
1246 if (bfd_get_32 (core_bfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE
1247 && bfd_get_signed_32 (core_bfd, descdata + KF_FD) == fd)
1248 {
1249 char *path = (char *) descdata + KF_PATH;
1250 return gdb::unique_xmalloc_ptr<char> (xstrdup (path));
1251 }
1252
1253 descdata += structsize;
1254 }
1255 return nullptr;
1256}
1257
1258/* Helper function to read a struct timeval. */
1259
1260static void
1261fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data,
1262 LONGEST &sec, ULONGEST &usec)
1263{
1264 if (gdbarch_addr_bit (gdbarch) == 64)
1265 {
1266 sec = bfd_get_signed_64 (core_bfd, data);
1267 usec = bfd_get_64 (core_bfd, data + 8);
1268 }
1269 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1270 {
1271 sec = bfd_get_signed_32 (core_bfd, data);
1272 usec = bfd_get_32 (core_bfd, data + 4);
1273 }
1274 else
1275 {
1276 sec = bfd_get_signed_64 (core_bfd, data);
1277 usec = bfd_get_32 (core_bfd, data + 8);
1278 }
1279}
1280
1281/* Print out the contents of a signal set. */
1282
1283static void
1284fbsd_print_sigset (const char *descr, unsigned char *sigset)
1285{
1286 printf_filtered ("%s: ", descr);
1287 for (int i = 0; i < SIG_WORDS; i++)
1288 printf_filtered ("%08x ",
1289 (unsigned int) bfd_get_32 (core_bfd, sigset + i * 4));
1290 printf_filtered ("\n");
1291}
1292
1293/* Implement "info proc status" for a corefile. */
1294
1295static void
1296fbsd_core_info_proc_status (struct gdbarch *gdbarch)
1297{
1298 const struct kinfo_proc_layout *kp;
1299 asection *section;
d2176225
JB		 1300 unsigned char *descdata;
1301 int addr_bit, long_bit;
1302 size_t note_size;
1303 ULONGEST value;
1304 LONGEST sec;
1305
1306 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.proc");
1307 if (section == NULL)
1308 {
1309 warning (_("unable to find process info in core file"));
1310 return;
1311 }
1312
1313 addr_bit = gdbarch_addr_bit (gdbarch);
1314 if (addr_bit == 64)
1315 kp = &kinfo_proc_layout_64;
1316 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1317 kp = &kinfo_proc_layout_i386;
1318 else
1319 kp = &kinfo_proc_layout_32;
1320 long_bit = gdbarch_long_bit (gdbarch);
1321
1322 /*
1323 * Ensure that the note is large enough for all of the fields fetched
1324 * by this function. In particular, the note must contain the 32-bit
1325 * structure size, then it must be long enough to access the last
1326 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1327 */
1328 note_size = bfd_get_section_size (section);
1329 if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt
1330 + long_bit / TARGET_CHAR_BIT))
1331 error (_("malformed core note - too short"));
1332
1333 gdb::def_vector<unsigned char> contents (note_size);
1334 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1335 0, note_size))
1336 error (_("could not get core note contents"));
1337
1338 descdata = contents.data ();
1339
1340 /* Skip over the structure size. */
1341 descdata += 4;
1342
1343 /* Verify 'ki_layout' is 0. */
1344 if (bfd_get_32 (core_bfd, descdata + kp->ki_layout) != 0)
1345 {
1346 warning (_("unsupported process information in core file"));
1347 return;
1348 }
1349
1350 printf_filtered ("Name: %.19s\n", descdata + kp->ki_comm);
1351 printf_filtered ("Process ID: %s\n",
1352 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pid)));
1353 printf_filtered ("Parent process: %s\n",
1354 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ppid)));
1355 printf_filtered ("Process group: %s\n",
1356 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pgid)));
1357 printf_filtered ("Session id: %s\n",
1358 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_sid)));
1359
1360 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
1361 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
1362 kernels the 64-bit 'ki_tdev' field is in a reserved section of
1363 the structure that is cleared to zero. Assume that a zero value
1364 in ki_tdev indicates a core dump from an older kernel and use the
1365 value in 'ki_tdev_freebsd11' instead. */
1366 value = bfd_get_64 (core_bfd, descdata + kp->ki_tdev);
1367 if (value == 0)
1368 value = bfd_get_32 (core_bfd, descdata + kp->ki_tdev_freebsd11);
1369 printf_filtered ("TTY: %s\n", pulongest (value));
1370 printf_filtered ("TTY owner process group: %s\n",
1371 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_tpgid)));
1372 printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
1373 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ruid)),
1374 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_uid)),
1375 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svuid)));
1376 printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
1377 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_rgid)),
1378 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_groups)),
1379 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svgid)));
1380 printf_filtered ("Groups: ");
1381 uint16_t ngroups = bfd_get_16 (core_bfd, descdata + kp->ki_ngroups);
1382 for (int i = 0; i < ngroups; i++)
1383 printf_filtered ("%s ",
1384 pulongest (bfd_get_32 (core_bfd,
1385 descdata + kp->ki_groups + i * 4)));
1386 printf_filtered ("\n");
1387 value = bfd_get (long_bit, core_bfd,
1388 descdata + kp->ki_rusage + kp->ru_minflt);
1389 printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value));
1390 value = bfd_get (long_bit, core_bfd,
1391 descdata + kp->ki_rusage_ch + kp->ru_minflt);
1392 printf_filtered ("Minor faults, children: %s\n", pulongest (value));
1393 value = bfd_get (long_bit, core_bfd,
1394 descdata + kp->ki_rusage + kp->ru_majflt);
1395 printf_filtered ("Major faults (memory page faults): %s\n",
1396 pulongest (value));
1397 value = bfd_get (long_bit, core_bfd,
1398 descdata + kp->ki_rusage_ch + kp->ru_majflt);
1399 printf_filtered ("Major faults, children: %s\n", pulongest (value));
1400 fbsd_core_fetch_timeval (gdbarch,
1401 descdata + kp->ki_rusage + kp->ru_utime,
1402 sec, value);
1403 printf_filtered ("utime: %s.%06d\n", plongest (sec), (int) value);
1404 fbsd_core_fetch_timeval (gdbarch,
1405 descdata + kp->ki_rusage + kp->ru_stime,
1406 sec, value);
1407 printf_filtered ("stime: %s.%06d\n", plongest (sec), (int) value);
1408 fbsd_core_fetch_timeval (gdbarch,
1409 descdata + kp->ki_rusage_ch + kp->ru_utime,
1410 sec, value);
1411 printf_filtered ("utime, children: %s.%06d\n", plongest (sec), (int) value);
1412 fbsd_core_fetch_timeval (gdbarch,
1413 descdata + kp->ki_rusage_ch + kp->ru_stime,
1414 sec, value);
1415 printf_filtered ("stime, children: %s.%06d\n", plongest (sec), (int) value);
1416 printf_filtered ("'nice' value: %d\n",
1417 bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice));
1418 fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value);
1419 printf_filtered ("Start time: %s.%06d\n", plongest (sec), (int) value);
1420 printf_filtered ("Virtual memory size: %s kB\n",
1421 pulongest (bfd_get (addr_bit, core_bfd,
1422 descdata + kp->ki_size) / 1024));
1423 printf_filtered ("Data size: %s pages\n",
1424 pulongest (bfd_get (addr_bit, core_bfd,
1425 descdata + kp->ki_dsize)));
1426 printf_filtered ("Stack size: %s pages\n",
1427 pulongest (bfd_get (addr_bit, core_bfd,
1428 descdata + kp->ki_ssize)));
1429 printf_filtered ("Text size: %s pages\n",
1430 pulongest (bfd_get (addr_bit, core_bfd,
1431 descdata + kp->ki_tsize)));
1432 printf_filtered ("Resident set size: %s pages\n",
1433 pulongest (bfd_get (addr_bit, core_bfd,
1434 descdata + kp->ki_rssize)));
1435 printf_filtered ("Maximum RSS: %s pages\n",
1436 pulongest (bfd_get (long_bit, core_bfd,
1437 descdata + kp->ki_rusage
1438 + kp->ru_maxrss)));
1439 fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore);
1440 fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch);
1441}
1442
1443/* Implement the "core_info_proc" gdbarch method. */
1444
1445static void
1446fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args,
1447 enum info_proc_what what)
1448{
1449 bool do_cmdline = false;
1450 bool do_cwd = false;
1451 bool do_exe = false;
57c2a98a 1452 bool do_files = false;
d2176225
JB		 1453 bool do_mappings = false;
1454 bool do_status = false;
1455 int pid;
1456
1457 switch (what)
1458 {
1459 case IP_MINIMAL:
1460 do_cmdline = true;
1461 do_cwd = true;
1462 do_exe = true;
1463 break;
1464 case IP_MAPPINGS:
1465 do_mappings = true;
1466 break;
1467 case IP_STATUS:
1468 case IP_STAT:
1469 do_status = true;
1470 break;
1471 case IP_CMDLINE:
1472 do_cmdline = true;
1473 break;
1474 case IP_EXE:
1475 do_exe = true;
1476 break;
1477 case IP_CWD:
1478 do_cwd = true;
1479 break;
57c2a98a
JB		 1480 case IP_FILES:
1481 do_files = true;
1482 break;
d2176225
JB		 1483 case IP_ALL:
1484 do_cmdline = true;
1485 do_cwd = true;
1486 do_exe = true;
57c2a98a 1487 do_files = true;
d2176225
JB		 1488 do_mappings = true;
1489 do_status = true;
1490 break;
1491 default:
1492 return;
1493 }
1494
1495 pid = bfd_core_file_pid (core_bfd);
1496 if (pid != 0)
1497 printf_filtered (_("process %d\n"), pid);
1498
1499 if (do_cmdline)
1500 {
1501 const char *cmdline;
1502
1503 cmdline = bfd_core_file_failing_command (core_bfd);
1504 if (cmdline)
1505 printf_filtered ("cmdline = '%s'\n", cmdline);
1506 else
1507 warning (_("Command line unavailable"));
1508 }
1509 if (do_cwd)
1510 {
1511 gdb::unique_xmalloc_ptr<char> cwd =
1512 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD);
1513 if (cwd)
1514 printf_filtered ("cwd = '%s'\n", cwd.get ());
1515 else
1516 warning (_("unable to read current working directory"));
1517 }
1518 if (do_exe)
1519 {
1520 gdb::unique_xmalloc_ptr<char> exe =
1521 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT);
1522 if (exe)
1523 printf_filtered ("exe = '%s'\n", exe.get ());
1524 else
1525 warning (_("unable to read executable path name"));
1526 }
57c2a98a
JB		 1527 if (do_files)
1528 fbsd_core_info_proc_files (gdbarch);
d2176225
JB		 1529 if (do_mappings)
1530 fbsd_core_info_proc_mappings (gdbarch);
1531 if (do_status)
1532 fbsd_core_info_proc_status (gdbarch);
1533}
1534
82372b2f
JB		 1535/* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1536
1537static void
1538fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
1539 CORE_ADDR type, CORE_ADDR val)
1540{
fd2b4de5
JB		 1541 const char *name = "???";
1542 const char *description = "";
1543 enum auxv_format format = AUXV_FORMAT_HEX;
82372b2f
JB		 1544
1545 switch (type)
1546 {
fd2b4de5
JB		 1547 case AT_NULL:
1548 case AT_IGNORE:
1549 case AT_EXECFD:
1550 case AT_PHDR:
1551 case AT_PHENT:
1552 case AT_PHNUM:
1553 case AT_PAGESZ:
1554 case AT_BASE:
1555 case AT_FLAGS:
1556 case AT_ENTRY:
1557 case AT_NOTELF:
1558 case AT_UID:
1559 case AT_EUID:
1560 case AT_GID:
1561 case AT_EGID:
1562 default_print_auxv_entry (gdbarch, file, type, val);
1563 return;
82372b2f
JB		 1564#define _TAGNAME(tag) #tag
1565#define TAGNAME(tag) _TAGNAME(AT_##tag)
1566#define TAG(tag, text, kind) \
1567 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1568 TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
1569 TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
1570 TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
1571 TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
1572 TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
1573 TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
1574 TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
1575 TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
1576 TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
12c4bd7f
JB		 1577 TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX);
1578 TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX);
d7ded98f 1579 TAG (HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
82372b2f
JB		 1580 }
1581
1582 fprint_auxv_entry (file, name, description, format, type, val);
1583}
1584
762c974a
JB		 1585/* Implement the "get_siginfo_type" gdbarch method. */
1586
1587static struct type *
1588fbsd_get_siginfo_type (struct gdbarch *gdbarch)
1589{
1590 struct fbsd_gdbarch_data *fbsd_gdbarch_data;
1591 struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
1592 struct type *uid_type, *pid_type;
1593 struct type *sigval_type, *reason_type;
1594 struct type *siginfo_type;
1595 struct type *type;
1596
1597 fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
1598 if (fbsd_gdbarch_data->siginfo_type != NULL)
1599 return fbsd_gdbarch_data->siginfo_type;
1600
1601 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
1602 0, "int");
1603 int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
1604 uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1605 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
1606 0, "long");
1607 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
1608
1609 /* union sigval */
1610 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1611 TYPE_NAME (sigval_type) = xstrdup ("sigval");
1612 append_composite_type_field (sigval_type, "sival_int", int_type);
1613 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
1614
1615 /* __pid_t */
1616 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
77b7c781 1617 TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
762c974a
JB		 1618 TYPE_TARGET_TYPE (pid_type) = int32_type;
1619 TYPE_TARGET_STUB (pid_type) = 1;
1620
1621 /* __uid_t */
1622 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
77b7c781
UW		 1623 TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
1624 "__uid_t");
762c974a
JB		 1625 TYPE_TARGET_TYPE (uid_type) = uint32_type;
1626 TYPE_TARGET_STUB (uid_type) = 1;
1627
1628 /* _reason */
1629 reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1630
1631 /* _fault */
1632 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1633 append_composite_type_field (type, "si_trapno", int_type);
1634 append_composite_type_field (reason_type, "_fault", type);
1635
1636 /* _timer */
1637 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1638 append_composite_type_field (type, "si_timerid", int_type);
1639 append_composite_type_field (type, "si_overrun", int_type);
1640 append_composite_type_field (reason_type, "_timer", type);
1641
1642 /* _mesgq */
1643 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1644 append_composite_type_field (type, "si_mqd", int_type);
1645 append_composite_type_field (reason_type, "_mesgq", type);
1646
1647 /* _poll */
1648 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1649 append_composite_type_field (type, "si_band", long_type);
1650 append_composite_type_field (reason_type, "_poll", type);
1651
1652 /* __spare__ */
1653 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1654 append_composite_type_field (type, "__spare1__", long_type);
1655 append_composite_type_field (type, "__spare2__",
1656 init_vector_type (int_type, 7));
1657 append_composite_type_field (reason_type, "__spare__", type);
1658
1659 /* struct siginfo */
1660 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1661 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
1662 append_composite_type_field (siginfo_type, "si_signo", int_type);
1663 append_composite_type_field (siginfo_type, "si_errno", int_type);
1664 append_composite_type_field (siginfo_type, "si_code", int_type);
1665 append_composite_type_field (siginfo_type, "si_pid", pid_type);
1666 append_composite_type_field (siginfo_type, "si_uid", uid_type);
1667 append_composite_type_field (siginfo_type, "si_status", int_type);
1668 append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
1669 append_composite_type_field (siginfo_type, "si_value", sigval_type);
1670 append_composite_type_field (siginfo_type, "_reason", reason_type);
1671
1672 fbsd_gdbarch_data->siginfo_type = siginfo_type;
1673
1674 return siginfo_type;
1675}
1676
e61667ef
RS		 1677/* Implement the "gdb_signal_from_target" gdbarch method. */
1678
1679static enum gdb_signal
1680fbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1681{
1682 switch (signal)
1683 {
1684 case 0:
1685 return GDB_SIGNAL_0;
1686
1687 case FREEBSD_SIGHUP:
1688 return GDB_SIGNAL_HUP;
1689
1690 case FREEBSD_SIGINT:
1691 return GDB_SIGNAL_INT;
1692
1693 case FREEBSD_SIGQUIT:
1694 return GDB_SIGNAL_QUIT;
1695
1696 case FREEBSD_SIGILL:
1697 return GDB_SIGNAL_ILL;
1698
1699 case FREEBSD_SIGTRAP:
1700 return GDB_SIGNAL_TRAP;
1701
1702 case FREEBSD_SIGABRT:
1703 return GDB_SIGNAL_ABRT;
1704
1705 case FREEBSD_SIGEMT:
1706 return GDB_SIGNAL_EMT;
1707
1708 case FREEBSD_SIGFPE:
1709 return GDB_SIGNAL_FPE;
1710
1711 case FREEBSD_SIGKILL:
1712 return GDB_SIGNAL_KILL;
1713
1714 case FREEBSD_SIGBUS:
1715 return GDB_SIGNAL_BUS;
1716
1717 case FREEBSD_SIGSEGV:
1718 return GDB_SIGNAL_SEGV;
1719
1720 case FREEBSD_SIGSYS:
1721 return GDB_SIGNAL_SYS;
1722
1723 case FREEBSD_SIGPIPE:
1724 return GDB_SIGNAL_PIPE;
1725
1726 case FREEBSD_SIGALRM:
1727 return GDB_SIGNAL_ALRM;
1728
1729 case FREEBSD_SIGTERM:
1730 return GDB_SIGNAL_TERM;
1731
1732 case FREEBSD_SIGURG:
1733 return GDB_SIGNAL_URG;
1734
1735 case FREEBSD_SIGSTOP:
1736 return GDB_SIGNAL_STOP;
1737
1738 case FREEBSD_SIGTSTP:
1739 return GDB_SIGNAL_TSTP;
1740
1741 case FREEBSD_SIGCONT:
1742 return GDB_SIGNAL_CONT;
1743
1744 case FREEBSD_SIGCHLD:
1745 return GDB_SIGNAL_CHLD;
1746
1747 case FREEBSD_SIGTTIN:
1748 return GDB_SIGNAL_TTIN;
1749
1750 case FREEBSD_SIGTTOU:
1751 return GDB_SIGNAL_TTOU;
1752
1753 case FREEBSD_SIGIO:
1754 return GDB_SIGNAL_IO;
1755
1756 case FREEBSD_SIGXCPU:
1757 return GDB_SIGNAL_XCPU;
1758
1759 case FREEBSD_SIGXFSZ:
1760 return GDB_SIGNAL_XFSZ;
1761
1762 case FREEBSD_SIGVTALRM:
1763 return GDB_SIGNAL_VTALRM;
1764
1765 case FREEBSD_SIGPROF:
1766 return GDB_SIGNAL_PROF;
1767
1768 case FREEBSD_SIGWINCH:
1769 return GDB_SIGNAL_WINCH;
1770
1771 case FREEBSD_SIGINFO:
1772 return GDB_SIGNAL_INFO;
1773
1774 case FREEBSD_SIGUSR1:
1775 return GDB_SIGNAL_USR1;
1776
1777 case FREEBSD_SIGUSR2:
1778 return GDB_SIGNAL_USR2;
1779
1780 /* SIGTHR is the same as SIGLWP on FreeBSD. */
1781 case FREEBSD_SIGTHR:
1782 return GDB_SIGNAL_LWP;
1783
1784 case FREEBSD_SIGLIBRT:
1785 return GDB_SIGNAL_LIBRT;
1786 }
1787
1788 if (signal >= FREEBSD_SIGRTMIN && signal <= FREEBSD_SIGRTMAX)
1789 {
1790 int offset = signal - FREEBSD_SIGRTMIN;
1791
1792 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_65 + offset);
1793 }
1794
1795 return GDB_SIGNAL_UNKNOWN;
1796}
1797
1798/* Implement the "gdb_signal_to_target" gdbarch method. */
1799
1800static int
1801fbsd_gdb_signal_to_target (struct gdbarch *gdbarch,
1802 enum gdb_signal signal)
1803{
1804 switch (signal)
1805 {
1806 case GDB_SIGNAL_0:
1807 return 0;
1808
1809 case GDB_SIGNAL_HUP:
1810 return FREEBSD_SIGHUP;
1811
1812 case GDB_SIGNAL_INT:
1813 return FREEBSD_SIGINT;
1814
1815 case GDB_SIGNAL_QUIT:
1816 return FREEBSD_SIGQUIT;
1817
1818 case GDB_SIGNAL_ILL:
1819 return FREEBSD_SIGILL;
1820
1821 case GDB_SIGNAL_TRAP:
1822 return FREEBSD_SIGTRAP;
1823
1824 case GDB_SIGNAL_ABRT:
1825 return FREEBSD_SIGABRT;
1826
1827 case GDB_SIGNAL_EMT:
1828 return FREEBSD_SIGEMT;
1829
1830 case GDB_SIGNAL_FPE:
1831 return FREEBSD_SIGFPE;
1832
1833 case GDB_SIGNAL_KILL:
1834 return FREEBSD_SIGKILL;
1835
1836 case GDB_SIGNAL_BUS:
1837 return FREEBSD_SIGBUS;
1838
1839 case GDB_SIGNAL_SEGV:
1840 return FREEBSD_SIGSEGV;
1841
1842 case GDB_SIGNAL_SYS:
1843 return FREEBSD_SIGSYS;
1844
1845 case GDB_SIGNAL_PIPE:
1846 return FREEBSD_SIGPIPE;
1847
1848 case GDB_SIGNAL_ALRM:
1849 return FREEBSD_SIGALRM;
1850
1851 case GDB_SIGNAL_TERM:
1852 return FREEBSD_SIGTERM;
1853
1854 case GDB_SIGNAL_URG:
1855 return FREEBSD_SIGURG;
1856
1857 case GDB_SIGNAL_STOP:
1858 return FREEBSD_SIGSTOP;
1859
1860 case GDB_SIGNAL_TSTP:
1861 return FREEBSD_SIGTSTP;
1862
1863 case GDB_SIGNAL_CONT:
1864 return FREEBSD_SIGCONT;
1865
1866 case GDB_SIGNAL_CHLD:
1867 return FREEBSD_SIGCHLD;
1868
1869 case GDB_SIGNAL_TTIN:
1870 return FREEBSD_SIGTTIN;
1871
1872 case GDB_SIGNAL_TTOU:
1873 return FREEBSD_SIGTTOU;
1874
1875 case GDB_SIGNAL_IO:
1876 return FREEBSD_SIGIO;
1877
1878 case GDB_SIGNAL_XCPU:
1879 return FREEBSD_SIGXCPU;
1880
1881 case GDB_SIGNAL_XFSZ:
1882 return FREEBSD_SIGXFSZ;
1883
1884 case GDB_SIGNAL_VTALRM:
1885 return FREEBSD_SIGVTALRM;
1886
1887 case GDB_SIGNAL_PROF:
1888 return FREEBSD_SIGPROF;
1889
1890 case GDB_SIGNAL_WINCH:
1891 return FREEBSD_SIGWINCH;
1892
1893 case GDB_SIGNAL_INFO:
1894 return FREEBSD_SIGINFO;
1895
1896 case GDB_SIGNAL_USR1:
1897 return FREEBSD_SIGUSR1;
1898
1899 case GDB_SIGNAL_USR2:
1900 return FREEBSD_SIGUSR2;
1901
1902 case GDB_SIGNAL_LWP:
1903 return FREEBSD_SIGTHR;
1904
1905 case GDB_SIGNAL_LIBRT:
1906 return FREEBSD_SIGLIBRT;
1907 }
1908
1909 if (signal >= GDB_SIGNAL_REALTIME_65
1910 && signal <= GDB_SIGNAL_REALTIME_126)
1911 {
1912 int offset = signal - GDB_SIGNAL_REALTIME_65;
1913
1914 return FREEBSD_SIGRTMIN + offset;
1915 }
1916
1917 return -1;
1918}
1919
e6cdd38e
JB		 1920/* Implement the "get_syscall_number" gdbarch method. */
1921
1922static LONGEST
00431a78 1923fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
e6cdd38e
JB		 1924{
1925
1926 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1927 native targets fetch the system call number from the
1928 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1929 However, system call catching requires this function to be
1930 set. */
1931
1932 internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
1933}
1934
1736a7bd 1935/* To be called from GDB_OSABI_FREEBSD handlers. */
a904c024
AA		 1936
1937void
1938fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1939{
79117428
JB		 1940 set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
1941 set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
4b654465 1942 set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
a904c024 1943 set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
d2176225 1944 set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc);
82372b2f 1945 set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
762c974a 1946 set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
e61667ef
RS		 1947 set_gdbarch_gdb_signal_from_target (gdbarch, fbsd_gdb_signal_from_target);
1948 set_gdbarch_gdb_signal_to_target (gdbarch, fbsd_gdb_signal_to_target);
e6cdd38e
JB		 1949
1950 /* `catch syscall' */
1951 set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
1952 set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
a904c024 1953}
762c974a 1954
762c974a
JB		 1955void
1956_initialize_fbsd_tdep (void)
1957{
1958 fbsd_gdbarch_data_handle =
1959 gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
1960}
GDB Binutils - Deliverables
This page took 0.441949 seconds and 4 git commands to generate.