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