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