gdb/fbsd-tdep.c

   1 /* Target-dependent code for FreeBSD, architecture-independent.
   2
   3    Copyright (C) 2002-2021 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "auxv.h"
  22 #include "gdbcore.h"
  23 #include "inferior.h"
  24 #include "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 /* 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
 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
 103    all architectures.
 104
 105    Note that FreeBSD 7.0 used an older version of this structure
 106    (struct kinfo_vmentry), but the NT_FREEBSD_PROCSTAT_VMMAP core
 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.  */
 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
 116 #define KVE_PROTECTION          0x38
 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
 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.  */
 145
 146 #define KF_STRUCTSIZE           0x0
 147 #define KF_TYPE                 0x4
 148 #define KF_FD                   0x8
 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
 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
 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
 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
 178 #define KINFO_FILE_FD_TYPE_ROOT -2
 179 #define KINFO_FILE_FD_TYPE_JAIL -3
 180 #define KINFO_FILE_FD_TYPE_TRACE -4
 181 #define KINFO_FILE_FD_TYPE_TEXT -5
 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
 233 struct 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
 242 struct 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
 252 struct fbsd_sockaddr_un
 253 {
 254   uint8_t sun_len;
 255   uint8_t sun_family;
 256   char sun_path[104];
 257 };
 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
 280 struct 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
 319 const 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
 356 const 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
 393 const 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
 430 static struct gdbarch_data *fbsd_gdbarch_data_handle;
 431
 432 struct fbsd_gdbarch_data
 433   {
 434     struct type *siginfo_type;
 435   };
 436
 437 static void *
 438 init_fbsd_gdbarch_data (struct gdbarch *gdbarch)
 439 {
 440   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct fbsd_gdbarch_data);
 441 }
 442
 443 static struct fbsd_gdbarch_data *
 444 get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
 445 {
 446   return ((struct fbsd_gdbarch_data *)
 447           gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
 448 }
 449
 450 struct fbsd_pspace_data
 451 {
 452   /* Offsets in the runtime linker's 'Obj_Entry' structure.  */
 453   LONGEST off_linkmap = 0;
 454   LONGEST off_tlsindex = 0;
 455   bool rtld_offsets_valid = false;
 456 };
 457
 458 /* Per-program-space data for FreeBSD architectures.  */
 459 static const struct program_space_key<fbsd_pspace_data>
 460   fbsd_pspace_data_handle;
 461
 462 static struct fbsd_pspace_data *
 463 get_fbsd_pspace_data (struct program_space *pspace)
 464 {
 465   struct fbsd_pspace_data *data;
 466
 467   data = fbsd_pspace_data_handle.get (pspace);
 468   if (data == NULL)
 469     data = fbsd_pspace_data_handle.emplace (pspace);
 470
 471   return data;
 472 }
 473
 474 /* This is how we want PTIDs from core files to be printed.  */
 475
 476 static std::string
 477 fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
 478 {
 479   if (ptid.lwp () != 0)
 480     return string_printf ("LWP %ld", ptid.lwp ());
 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
 488 static const char *
 489 fbsd_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;
 494
 495   if (thr->ptid.lwp () != 0)
 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.  */
 504       thread_section_name section_name (".thrmisc", thr->ptid);
 505
 506       section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
 507       if (section != NULL && bfd_section_size (section) > 0)
 508         {
 509           /* Truncate the name if it is longer than "buf".  */
 510           size = bfd_section_size (section);
 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
 532 /* Implement the "core_xfer_siginfo" gdbarch method.  */
 533
 534 static LONGEST
 535 fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
 536                         ULONGEST offset, ULONGEST len)
 537 {
 538   size_t siginfo_size;
 539
 540   if (gdbarch_long_bit (gdbarch) == 32)
 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;
 565   if (gdbarch_long_bit (gdbarch) == 32)
 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
 577 static int
 578 find_signalled_thread (struct thread_info *info, void *data)
 579 {
 580   if (info->suspend.stop_signal != GDB_SIGNAL_0
 581       && info->ptid.pid () == inferior_ptid.pid ())
 582     return 1;
 583
 584   return 0;
 585 }
 586
 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
 592 static gdb::optional<gdb::byte_vector>
 593 fbsd_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
 609 /* Create appropriate note sections for a corefile, returning them in
 610    allocated memory.  */
 611
 612 static gdb::unique_xmalloc_ptr<char>
 613 fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
 614 {
 615   gdb::unique_xmalloc_ptr<char> note_data;
 616   Elf_Internal_Ehdr *i_ehdrp;
 617   struct thread_info *curr_thr, *signalled_thr;
 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
 625   if (get_exec_file (0))
 626     {
 627       const char *fname = lbasename (get_exec_file (0));
 628       std::string psargs = fname;
 629
 630       const char *infargs = get_inferior_args ();
 631       if (infargs != NULL)
 632         psargs = psargs + " " + infargs;
 633
 634       note_data.reset (elfcore_write_prpsinfo (obfd, note_data.release (),
 635                                                note_size, fname,
 636                                                psargs.c_str ()));
 637     }
 638
 639   /* Thread register information.  */
 640   try
 641     {
 642       update_thread_list ();
 643     }
 644   catch (const gdb_exception_error &e)
 645     {
 646       exception_print (gdb_stderr, e);
 647     }
 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
 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);
 666   for (thread_info *thr : current_inferior ()->non_exited_threads ())
 667     {
 668       if (thr == signalled_thr)
 669         continue;
 670
 671       gcore_elf_build_thread_register_notes (gdbarch, thr, stop_signal,
 672                                              obfd, &note_data, note_size);
 673     }
 674
 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     {
 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 ()));
 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     {
 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 ()));
 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     {
 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 ()));
 711       if (!note_data)
 712         return NULL;
 713     }
 714
 715   return note_data;
 716 }
 717
 718 /* Helper function to generate the file descriptor description for a
 719    single open file in 'info proc files'.  */
 720
 721 static const char *
 722 fbsd_file_fd (int kf_fd)
 723 {
 724   switch (kf_fd)
 725     {
 726     case KINFO_FILE_FD_TYPE_CWD:
 727       return "cwd";
 728     case KINFO_FILE_FD_TYPE_ROOT:
 729       return "root";
 730     case KINFO_FILE_FD_TYPE_JAIL:
 731       return "jail";
 732     case KINFO_FILE_FD_TYPE_TRACE:
 733       return "trace";
 734     case KINFO_FILE_FD_TYPE_TEXT:
 735       return "text";
 736     case KINFO_FILE_FD_TYPE_CTTY:
 737       return "ctty";
 738     default:
 739       return int_string (kf_fd, 10, 1, 0, 0);
 740     }
 741 }
 742
 743 /* Helper function to generate the file type for a single open file in
 744    'info proc files'.  */
 745
 746 static const char *
 747 fbsd_file_type (int kf_type, int kf_vnode_type)
 748 {
 749   switch (kf_type)
 750     {
 751     case KINFO_FILE_TYPE_VNODE:
 752       switch (kf_vnode_type)
 753         {
 754         case KINFO_FILE_VTYPE_VREG:
 755           return "file";
 756         case KINFO_FILE_VTYPE_VDIR:
 757           return "dir";
 758         case KINFO_FILE_VTYPE_VCHR:
 759           return "chr";
 760         case KINFO_FILE_VTYPE_VLNK:
 761           return "link";
 762         case KINFO_FILE_VTYPE_VSOCK:
 763           return "socket";
 764         case KINFO_FILE_VTYPE_VFIFO:
 765           return "fifo";
 766         default:
 767           {
 768             char *str = get_print_cell ();
 769
 770             xsnprintf (str, PRINT_CELL_SIZE, "vn:%d", kf_vnode_type);
 771             return str;
 772           }
 773         }
 774     case KINFO_FILE_TYPE_SOCKET:
 775       return "socket";
 776     case KINFO_FILE_TYPE_PIPE:
 777       return "pipe";
 778     case KINFO_FILE_TYPE_FIFO:
 779       return "fifo";
 780     case KINFO_FILE_TYPE_KQUEUE:
 781       return "kqueue";
 782     case KINFO_FILE_TYPE_CRYPTO:
 783       return "crypto";
 784     case KINFO_FILE_TYPE_MQUEUE:
 785       return "mqueue";
 786     case KINFO_FILE_TYPE_SHM:
 787       return "shm";
 788     case KINFO_FILE_TYPE_SEM:
 789       return "sem";
 790     case KINFO_FILE_TYPE_PTS:
 791       return "pts";
 792     case KINFO_FILE_TYPE_PROCDESC:
 793       return "proc";
 794     default:
 795       return int_string (kf_type, 10, 1, 0, 0);
 796     }
 797 }
 798
 799 /* Helper function to generate the file flags for a single open file in
 800    'info proc files'.  */
 801
 802 static const char *
 803 fbsd_file_flags (int kf_flags)
 804 {
 805   static char file_flags[10];
 806
 807   file_flags[0] = (kf_flags & KINFO_FILE_FLAG_READ) ? 'r' : '-';
 808   file_flags[1] = (kf_flags & KINFO_FILE_FLAG_WRITE) ? 'w' : '-';
 809   file_flags[2] = (kf_flags & KINFO_FILE_FLAG_EXEC) ? 'x' : '-';
 810   file_flags[3] = (kf_flags & KINFO_FILE_FLAG_APPEND) ? 'a' : '-';
 811   file_flags[4] = (kf_flags & KINFO_FILE_FLAG_ASYNC) ? 's' : '-';
 812   file_flags[5] = (kf_flags & KINFO_FILE_FLAG_FSYNC) ? 'f' : '-';
 813   file_flags[6] = (kf_flags & KINFO_FILE_FLAG_NONBLOCK) ? 'n' : '-';
 814   file_flags[7] = (kf_flags & KINFO_FILE_FLAG_DIRECT) ? 'd' : '-';
 815   file_flags[8] = (kf_flags & KINFO_FILE_FLAG_HASLOCK) ? 'l' : '-';
 816   file_flags[9] = '\0';
 817
 818   return file_flags;
 819 }
 820
 821 /* Helper function to generate the name of an IP protocol.  */
 822
 823 static const char *
 824 fbsd_ipproto (int protocol)
 825 {
 826   switch (protocol)
 827     {
 828     case FBSD_IPPROTO_ICMP:
 829       return "icmp";
 830     case FBSD_IPPROTO_TCP:
 831       return "tcp";
 832     case FBSD_IPPROTO_UDP:
 833       return "udp";
 834     case FBSD_IPPROTO_SCTP:
 835       return "sctp";
 836     default:
 837       {
 838         char *str = get_print_cell ();
 839
 840         xsnprintf (str, PRINT_CELL_SIZE, "ip<%d>", protocol);
 841         return str;
 842       }
 843     }
 844 }
 845
 846 /* Helper function to print out an IPv4 socket address.  */
 847
 848 static void
 849 fbsd_print_sockaddr_in (const void *sockaddr)
 850 {
 851   const struct fbsd_sockaddr_in *sin =
 852     reinterpret_cast<const struct fbsd_sockaddr_in *> (sockaddr);
 853   char buf[INET_ADDRSTRLEN];
 854
 855   if (inet_ntop (AF_INET, sin->sin_addr, buf, sizeof buf) == nullptr)
 856     error (_("Failed to format IPv4 address"));
 857   printf_filtered ("%s:%u", buf,
 858                    (sin->sin_port[0] << 8) | sin->sin_port[1]);
 859 }
 860
 861 /* Helper function to print out an IPv6 socket address.  */
 862
 863 static void
 864 fbsd_print_sockaddr_in6 (const void *sockaddr)
 865 {
 866   const struct fbsd_sockaddr_in6 *sin6 =
 867     reinterpret_cast<const struct fbsd_sockaddr_in6 *> (sockaddr);
 868   char buf[INET6_ADDRSTRLEN];
 869
 870   if (inet_ntop (AF_INET6, sin6->sin6_addr, buf, sizeof buf) == nullptr)
 871     error (_("Failed to format IPv6 address"));
 872   printf_filtered ("%s.%u", buf,
 873                    (sin6->sin6_port[0] << 8) | sin6->sin6_port[1]);
 874 }
 875
 876 /* See fbsd-tdep.h.  */
 877
 878 void
 879 fbsd_info_proc_files_header ()
 880 {
 881   printf_filtered (_("Open files:\n\n"));
 882   printf_filtered ("  %6s %6s %10s %9s %s\n",
 883                    "FD", "Type", "Offset", "Flags  ", "Name");
 884 }
 885
 886 /* See fbsd-tdep.h.  */
 887
 888 void
 889 fbsd_info_proc_files_entry (int kf_type, int kf_fd, int kf_flags,
 890                             LONGEST kf_offset, int kf_vnode_type,
 891                             int kf_sock_domain, int kf_sock_type,
 892                             int kf_sock_protocol, const void *kf_sa_local,
 893                             const void *kf_sa_peer, const void *kf_path)
 894 {
 895   printf_filtered ("  %6s %6s %10s %8s ",
 896                    fbsd_file_fd (kf_fd),
 897                    fbsd_file_type (kf_type, kf_vnode_type),
 898                    kf_offset > -1 ? hex_string (kf_offset) : "-",
 899                    fbsd_file_flags (kf_flags));
 900   if (kf_type == KINFO_FILE_TYPE_SOCKET)
 901     {
 902       switch (kf_sock_domain)
 903         {
 904         case FBSD_AF_UNIX:
 905           {
 906             switch (kf_sock_type)
 907               {
 908               case FBSD_SOCK_STREAM:
 909                 printf_filtered ("unix stream:");
 910                 break;
 911               case FBSD_SOCK_DGRAM:
 912                 printf_filtered ("unix dgram:");
 913                 break;
 914               case FBSD_SOCK_SEQPACKET:
 915                 printf_filtered ("unix seqpacket:");
 916                 break;
 917               default:
 918                 printf_filtered ("unix <%d>:", kf_sock_type);
 919                 break;
 920               }
 921
 922             /* For local sockets, print out the first non-nul path
 923                rather than both paths.  */
 924             const struct fbsd_sockaddr_un *saddr_un
 925               = reinterpret_cast<const struct fbsd_sockaddr_un *> (kf_sa_local);
 926             if (saddr_un->sun_path[0] == 0)
 927               saddr_un = reinterpret_cast<const struct fbsd_sockaddr_un *>
 928                 (kf_sa_peer);
 929             printf_filtered ("%s", saddr_un->sun_path);
 930             break;
 931           }
 932         case FBSD_AF_INET:
 933           printf_filtered ("%s4 ", fbsd_ipproto (kf_sock_protocol));
 934           fbsd_print_sockaddr_in (kf_sa_local);
 935           printf_filtered (" -> ");
 936           fbsd_print_sockaddr_in (kf_sa_peer);
 937           break;
 938         case FBSD_AF_INET6:
 939           printf_filtered ("%s6 ", fbsd_ipproto (kf_sock_protocol));
 940           fbsd_print_sockaddr_in6 (kf_sa_local);
 941           printf_filtered (" -> ");
 942           fbsd_print_sockaddr_in6 (kf_sa_peer);
 943           break;
 944         }
 945     }
 946   else
 947     printf_filtered ("%s", reinterpret_cast<const char *> (kf_path));
 948   printf_filtered ("\n");
 949 }
 950
 951 /* Implement "info proc files" for a corefile.  */
 952
 953 static void
 954 fbsd_core_info_proc_files (struct gdbarch *gdbarch)
 955 {
 956   asection *section
 957     = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
 958   if (section == NULL)
 959     {
 960       warning (_("unable to find open files in core file"));
 961       return;
 962     }
 963
 964   size_t note_size = bfd_section_size (section);
 965   if (note_size < 4)
 966     error (_("malformed core note - too short for header"));
 967
 968   gdb::def_vector<unsigned char> contents (note_size);
 969   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
 970                                  0, note_size))
 971     error (_("could not get core note contents"));
 972
 973   unsigned char *descdata = contents.data ();
 974   unsigned char *descend = descdata + note_size;
 975
 976   /* Skip over the structure size.  */
 977   descdata += 4;
 978
 979   fbsd_info_proc_files_header ();
 980
 981   while (descdata + KF_PATH < descend)
 982     {
 983       ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
 984       if (structsize < KF_PATH)
 985         error (_("malformed core note - file structure too small"));
 986
 987       LONGEST type = bfd_get_signed_32 (core_bfd, descdata + KF_TYPE);
 988       LONGEST fd = bfd_get_signed_32 (core_bfd, descdata + KF_FD);
 989       LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KF_FLAGS);
 990       LONGEST offset = bfd_get_signed_64 (core_bfd, descdata + KF_OFFSET);
 991       LONGEST vnode_type = bfd_get_signed_32 (core_bfd,
 992                                               descdata + KF_VNODE_TYPE);
 993       LONGEST sock_domain = bfd_get_signed_32 (core_bfd,
 994                                                descdata + KF_SOCK_DOMAIN);
 995       LONGEST sock_type = bfd_get_signed_32 (core_bfd, descdata + KF_SOCK_TYPE);
 996       LONGEST sock_protocol = bfd_get_signed_32 (core_bfd,
 997                                                  descdata + KF_SOCK_PROTOCOL);
 998       fbsd_info_proc_files_entry (type, fd, flags, offset, vnode_type,
 999                                   sock_domain, sock_type, sock_protocol,
1000                                   descdata + KF_SA_LOCAL, descdata + KF_SA_PEER,
1001                                   descdata + KF_PATH);
1002
1003       descdata += structsize;
1004     }
1005 }
1006
1007 /* Helper function to generate mappings flags for a single VM map
1008    entry in 'info proc mappings'.  */
1009
1010 static const char *
1011 fbsd_vm_map_entry_flags (int kve_flags, int kve_protection)
1012 {
1013   static char vm_flags[9];
1014
1015   vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-';
1016   vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-';
1017   vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-';
1018   vm_flags[3] = ' ';
1019   vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-';
1020   vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-';
1021   vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-';
1022   vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U'
1023     : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-';
1024   vm_flags[8] = '\0';
1025
1026   return vm_flags;
1027 }
1028
1029 /* See fbsd-tdep.h.  */
1030
1031 void
1032 fbsd_info_proc_mappings_header (int addr_bit)
1033 {
1034   printf_filtered (_("Mapped address spaces:\n\n"));
1035   if (addr_bit == 64)
1036     {
1037       printf_filtered ("  %18s %18s %10s %10s %9s %s\n",
1038                        "Start Addr",
1039                        "  End Addr",
1040                        "      Size", "    Offset", "Flags  ", "File");
1041     }
1042   else
1043     {
1044       printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1045                        "Start Addr",
1046                        "  End Addr",
1047                        "      Size", "    Offset", "Flags  ", "File");
1048     }
1049 }
1050
1051 /* See fbsd-tdep.h.  */
1052
1053 void
1054 fbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start,
1055                                ULONGEST kve_end, ULONGEST kve_offset,
1056                                int kve_flags, int kve_protection,
1057                                const void *kve_path)
1058 {
1059   if (addr_bit == 64)
1060     {
1061       printf_filtered ("  %18s %18s %10s %10s %9s %s\n",
1062                        hex_string (kve_start),
1063                        hex_string (kve_end),
1064                        hex_string (kve_end - kve_start),
1065                        hex_string (kve_offset),
1066                        fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1067                        reinterpret_cast<const char *> (kve_path));
1068     }
1069   else
1070     {
1071       printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1072                        hex_string (kve_start),
1073                        hex_string (kve_end),
1074                        hex_string (kve_end - kve_start),
1075                        hex_string (kve_offset),
1076                        fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1077                        reinterpret_cast<const char *> (kve_path));
1078     }
1079 }
1080
1081 /* Implement "info proc mappings" for a corefile.  */
1082
1083 static void
1084 fbsd_core_info_proc_mappings (struct gdbarch *gdbarch)
1085 {
1086   asection *section;
1087   unsigned char *descdata, *descend;
1088   size_t note_size;
1089
1090   section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.vmmap");
1091   if (section == NULL)
1092     {
1093       warning (_("unable to find mappings in core file"));
1094       return;
1095     }
1096
1097   note_size = bfd_section_size (section);
1098   if (note_size < 4)
1099     error (_("malformed core note - too short for header"));
1100
1101   gdb::def_vector<unsigned char> contents (note_size);
1102   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1103                                  0, note_size))
1104     error (_("could not get core note contents"));
1105
1106   descdata = contents.data ();
1107   descend = descdata + note_size;
1108
1109   /* Skip over the structure size.  */
1110   descdata += 4;
1111
1112   fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch));
1113   while (descdata + KVE_PATH < descend)
1114     {
1115       ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KVE_STRUCTSIZE);
1116       if (structsize < KVE_PATH)
1117         error (_("malformed core note - vmmap entry too small"));
1118
1119       ULONGEST start = bfd_get_64 (core_bfd, descdata + KVE_START);
1120       ULONGEST end = bfd_get_64 (core_bfd, descdata + KVE_END);
1121       ULONGEST offset = bfd_get_64 (core_bfd, descdata + KVE_OFFSET);
1122       LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KVE_FLAGS);
1123       LONGEST prot = bfd_get_signed_32 (core_bfd, descdata + KVE_PROTECTION);
1124       fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch), start, end,
1125                                      offset, flags, prot, descdata + KVE_PATH);
1126
1127       descdata += structsize;
1128     }
1129 }
1130
1131 /* Fetch the pathname of a vnode for a single file descriptor from the
1132    file table core note.  */
1133
1134 static gdb::unique_xmalloc_ptr<char>
1135 fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd)
1136 {
1137   asection *section;
1138   unsigned char *descdata, *descend;
1139   size_t note_size;
1140
1141   section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
1142   if (section == NULL)
1143     return nullptr;
1144
1145   note_size = bfd_section_size (section);
1146   if (note_size < 4)
1147     error (_("malformed core note - too short for header"));
1148
1149   gdb::def_vector<unsigned char> contents (note_size);
1150   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1151                                  0, note_size))
1152     error (_("could not get core note contents"));
1153
1154   descdata = contents.data ();
1155   descend = descdata + note_size;
1156
1157   /* Skip over the structure size.  */
1158   descdata += 4;
1159
1160   while (descdata + KF_PATH < descend)
1161     {
1162       ULONGEST structsize;
1163
1164       structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
1165       if (structsize < KF_PATH)
1166         error (_("malformed core note - file structure too small"));
1167
1168       if (bfd_get_32 (core_bfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE
1169           && bfd_get_signed_32 (core_bfd, descdata + KF_FD) == fd)
1170         {
1171           char *path = (char *) descdata + KF_PATH;
1172           return make_unique_xstrdup (path);
1173         }
1174
1175       descdata += structsize;
1176     }
1177   return nullptr;
1178 }
1179
1180 /* Helper function to read a struct timeval.  */
1181
1182 static void
1183 fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data,
1184                          LONGEST &sec, ULONGEST &usec)
1185 {
1186   if (gdbarch_addr_bit (gdbarch) == 64)
1187     {
1188       sec = bfd_get_signed_64 (core_bfd, data);
1189       usec = bfd_get_64 (core_bfd, data + 8);
1190     }
1191   else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1192     {
1193       sec = bfd_get_signed_32 (core_bfd, data);
1194       usec = bfd_get_32 (core_bfd, data + 4);
1195     }
1196   else
1197     {
1198       sec = bfd_get_signed_64 (core_bfd, data);
1199       usec = bfd_get_32 (core_bfd, data + 8);
1200     }
1201 }
1202
1203 /* Print out the contents of a signal set.  */
1204
1205 static void
1206 fbsd_print_sigset (const char *descr, unsigned char *sigset)
1207 {
1208   printf_filtered ("%s: ", descr);
1209   for (int i = 0; i < SIG_WORDS; i++)
1210     printf_filtered ("%08x ",
1211                      (unsigned int) bfd_get_32 (core_bfd, sigset + i * 4));
1212   printf_filtered ("\n");
1213 }
1214
1215 /* Implement "info proc status" for a corefile.  */
1216
1217 static void
1218 fbsd_core_info_proc_status (struct gdbarch *gdbarch)
1219 {
1220   const struct kinfo_proc_layout *kp;
1221   asection *section;
1222   unsigned char *descdata;
1223   int addr_bit, long_bit;
1224   size_t note_size;
1225   ULONGEST value;
1226   LONGEST sec;
1227
1228   section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.proc");
1229   if (section == NULL)
1230     {
1231       warning (_("unable to find process info in core file"));
1232       return;
1233     }
1234
1235   addr_bit = gdbarch_addr_bit (gdbarch);
1236   if (addr_bit == 64)
1237     kp = &kinfo_proc_layout_64;
1238   else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1239     kp = &kinfo_proc_layout_i386;
1240   else
1241     kp = &kinfo_proc_layout_32;
1242   long_bit = gdbarch_long_bit (gdbarch);
1243
1244   /*
1245    * Ensure that the note is large enough for all of the fields fetched
1246    * by this function.  In particular, the note must contain the 32-bit
1247    * structure size, then it must be long enough to access the last
1248    * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1249    */
1250   note_size = bfd_section_size (section);
1251   if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt
1252                    + long_bit / TARGET_CHAR_BIT))
1253     error (_("malformed core note - too short"));
1254
1255   gdb::def_vector<unsigned char> contents (note_size);
1256   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1257                                  0, note_size))
1258     error (_("could not get core note contents"));
1259
1260   descdata = contents.data ();
1261
1262   /* Skip over the structure size.  */
1263   descdata += 4;
1264
1265   /* Verify 'ki_layout' is 0.  */
1266   if (bfd_get_32 (core_bfd, descdata + kp->ki_layout) != 0)
1267     {
1268       warning (_("unsupported process information in core file"));
1269       return;
1270     }
1271
1272   printf_filtered ("Name: %.19s\n", descdata + kp->ki_comm);
1273   printf_filtered ("Process ID: %s\n",
1274                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pid)));
1275   printf_filtered ("Parent process: %s\n",
1276                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ppid)));
1277   printf_filtered ("Process group: %s\n",
1278                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pgid)));
1279   printf_filtered ("Session id: %s\n",
1280                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_sid)));
1281
1282   /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'.  Older
1283      kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'.  In older
1284      kernels the 64-bit 'ki_tdev' field is in a reserved section of
1285      the structure that is cleared to zero.  Assume that a zero value
1286      in ki_tdev indicates a core dump from an older kernel and use the
1287      value in 'ki_tdev_freebsd11' instead.  */
1288   value = bfd_get_64 (core_bfd, descdata + kp->ki_tdev);
1289   if (value == 0)
1290     value = bfd_get_32 (core_bfd, descdata + kp->ki_tdev_freebsd11);
1291   printf_filtered ("TTY: %s\n", pulongest (value));
1292   printf_filtered ("TTY owner process group: %s\n",
1293                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_tpgid)));
1294   printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
1295                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ruid)),
1296                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_uid)),
1297                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svuid)));
1298   printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
1299                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_rgid)),
1300                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_groups)),
1301                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svgid)));
1302   printf_filtered ("Groups: ");
1303   uint16_t ngroups = bfd_get_16 (core_bfd, descdata + kp->ki_ngroups);
1304   for (int i = 0; i < ngroups; i++)
1305     printf_filtered ("%s ",
1306                      pulongest (bfd_get_32 (core_bfd,
1307                                             descdata + kp->ki_groups + i * 4)));
1308   printf_filtered ("\n");
1309   value = bfd_get (long_bit, core_bfd,
1310                    descdata + kp->ki_rusage + kp->ru_minflt);
1311   printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value));
1312   value = bfd_get (long_bit, core_bfd,
1313                    descdata + kp->ki_rusage_ch + kp->ru_minflt);
1314   printf_filtered ("Minor faults, children: %s\n", pulongest (value));
1315   value = bfd_get (long_bit, core_bfd,
1316                    descdata + kp->ki_rusage + kp->ru_majflt);
1317   printf_filtered ("Major faults (memory page faults): %s\n",
1318                    pulongest (value));
1319   value = bfd_get (long_bit, core_bfd,
1320                    descdata + kp->ki_rusage_ch + kp->ru_majflt);
1321   printf_filtered ("Major faults, children: %s\n", pulongest (value));
1322   fbsd_core_fetch_timeval (gdbarch,
1323                            descdata + kp->ki_rusage + kp->ru_utime,
1324                            sec, value);
1325   printf_filtered ("utime: %s.%06d\n", plongest (sec), (int) value);
1326   fbsd_core_fetch_timeval (gdbarch,
1327                            descdata + kp->ki_rusage + kp->ru_stime,
1328                            sec, value);
1329   printf_filtered ("stime: %s.%06d\n", plongest (sec), (int) value);
1330   fbsd_core_fetch_timeval (gdbarch,
1331                            descdata + kp->ki_rusage_ch + kp->ru_utime,
1332                            sec, value);
1333   printf_filtered ("utime, children: %s.%06d\n", plongest (sec), (int) value);
1334   fbsd_core_fetch_timeval (gdbarch,
1335                            descdata + kp->ki_rusage_ch + kp->ru_stime,
1336                            sec, value);
1337   printf_filtered ("stime, children: %s.%06d\n", plongest (sec), (int) value);
1338   printf_filtered ("'nice' value: %d\n",
1339                    (int) bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice));
1340   fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value);
1341   printf_filtered ("Start time: %s.%06d\n", plongest (sec), (int) value);
1342   printf_filtered ("Virtual memory size: %s kB\n",
1343                    pulongest (bfd_get (addr_bit, core_bfd,
1344                                        descdata + kp->ki_size) / 1024));
1345   printf_filtered ("Data size: %s pages\n",
1346                    pulongest (bfd_get (addr_bit, core_bfd,
1347                                        descdata + kp->ki_dsize)));
1348   printf_filtered ("Stack size: %s pages\n",
1349                    pulongest (bfd_get (addr_bit, core_bfd,
1350                                        descdata + kp->ki_ssize)));
1351   printf_filtered ("Text size: %s pages\n",
1352                    pulongest (bfd_get (addr_bit, core_bfd,
1353                                        descdata + kp->ki_tsize)));
1354   printf_filtered ("Resident set size: %s pages\n",
1355                    pulongest (bfd_get (addr_bit, core_bfd,
1356                                        descdata + kp->ki_rssize)));
1357   printf_filtered ("Maximum RSS: %s pages\n",
1358                    pulongest (bfd_get (long_bit, core_bfd,
1359                                        descdata + kp->ki_rusage
1360                                        + kp->ru_maxrss)));
1361   fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore);
1362   fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch);
1363 }
1364
1365 /* Implement the "core_info_proc" gdbarch method.  */
1366
1367 static void
1368 fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args,
1369                      enum info_proc_what what)
1370 {
1371   bool do_cmdline = false;
1372   bool do_cwd = false;
1373   bool do_exe = false;
1374   bool do_files = false;
1375   bool do_mappings = false;
1376   bool do_status = false;
1377   int pid;
1378
1379   switch (what)
1380     {
1381     case IP_MINIMAL:
1382       do_cmdline = true;
1383       do_cwd = true;
1384       do_exe = true;
1385       break;
1386     case IP_MAPPINGS:
1387       do_mappings = true;
1388       break;
1389     case IP_STATUS:
1390     case IP_STAT:
1391       do_status = true;
1392       break;
1393     case IP_CMDLINE:
1394       do_cmdline = true;
1395       break;
1396     case IP_EXE:
1397       do_exe = true;
1398       break;
1399     case IP_CWD:
1400       do_cwd = true;
1401       break;
1402     case IP_FILES:
1403       do_files = true;
1404       break;
1405     case IP_ALL:
1406       do_cmdline = true;
1407       do_cwd = true;
1408       do_exe = true;
1409       do_files = true;
1410       do_mappings = true;
1411       do_status = true;
1412       break;
1413     default:
1414       return;
1415     }
1416
1417   pid = bfd_core_file_pid (core_bfd);
1418   if (pid != 0)
1419     printf_filtered (_("process %d\n"), pid);
1420
1421   if (do_cmdline)
1422     {
1423       const char *cmdline;
1424
1425       cmdline = bfd_core_file_failing_command (core_bfd);
1426       if (cmdline)
1427         printf_filtered ("cmdline = '%s'\n", cmdline);
1428       else
1429         warning (_("Command line unavailable"));
1430     }
1431   if (do_cwd)
1432     {
1433       gdb::unique_xmalloc_ptr<char> cwd =
1434         fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD);
1435       if (cwd)
1436         printf_filtered ("cwd = '%s'\n", cwd.get ());
1437       else
1438         warning (_("unable to read current working directory"));
1439     }
1440   if (do_exe)
1441     {
1442       gdb::unique_xmalloc_ptr<char> exe =
1443         fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT);
1444       if (exe)
1445         printf_filtered ("exe = '%s'\n", exe.get ());
1446       else
1447         warning (_("unable to read executable path name"));
1448     }
1449   if (do_files)
1450     fbsd_core_info_proc_files (gdbarch);
1451   if (do_mappings)
1452     fbsd_core_info_proc_mappings (gdbarch);
1453   if (do_status)
1454     fbsd_core_info_proc_status (gdbarch);
1455 }
1456
1457 /* Print descriptions of FreeBSD-specific AUXV entries to FILE.  */
1458
1459 static void
1460 fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
1461                        CORE_ADDR type, CORE_ADDR val)
1462 {
1463   const char *name = "???";
1464   const char *description = "";
1465   enum auxv_format format = AUXV_FORMAT_HEX;
1466
1467   switch (type)
1468     {
1469     case AT_NULL:
1470     case AT_IGNORE:
1471     case AT_EXECFD:
1472     case AT_PHDR:
1473     case AT_PHENT:
1474     case AT_PHNUM:
1475     case AT_PAGESZ:
1476     case AT_BASE:
1477     case AT_FLAGS:
1478     case AT_ENTRY:
1479     case AT_NOTELF:
1480     case AT_UID:
1481     case AT_EUID:
1482     case AT_GID:
1483     case AT_EGID:
1484       default_print_auxv_entry (gdbarch, file, type, val);
1485       return;
1486 #define _TAGNAME(tag) #tag
1487 #define TAGNAME(tag) _TAGNAME(AT_##tag)
1488 #define TAG(tag, text, kind) \
1489       case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1490       TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
1491       TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
1492       TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
1493       TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
1494       TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
1495       TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
1496       TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
1497       TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
1498       TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
1499       TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX);
1500       TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX);
1501       TAG (HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
1502       TAG (BSDFLAGS, _("ELF BSD flags"), AUXV_FORMAT_HEX);
1503       TAG (ARGC, _("Argument count"), AUXV_FORMAT_DEC);
1504       TAG (ARGV, _("Argument vector"), AUXV_FORMAT_HEX);
1505       TAG (ENVC, _("Environment count"), AUXV_FORMAT_DEC);
1506       TAG (ENVV, _("Environment vector"), AUXV_FORMAT_HEX);
1507       TAG (PS_STRINGS, _("Pointer to ps_strings"), AUXV_FORMAT_HEX);
1508     }
1509
1510   fprint_auxv_entry (file, name, description, format, type, val);
1511 }
1512
1513 /* Implement the "get_siginfo_type" gdbarch method.  */
1514
1515 static struct type *
1516 fbsd_get_siginfo_type (struct gdbarch *gdbarch)
1517 {
1518   struct fbsd_gdbarch_data *fbsd_gdbarch_data;
1519   struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
1520   struct type *uid_type, *pid_type;
1521   struct type *sigval_type, *reason_type;
1522   struct type *siginfo_type;
1523   struct type *type;
1524
1525   fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
1526   if (fbsd_gdbarch_data->siginfo_type != NULL)
1527     return fbsd_gdbarch_data->siginfo_type;
1528
1529   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
1530                                 0, "int");
1531   int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
1532   uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1533   long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
1534                                  0, "long");
1535   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
1536
1537   /* union sigval */
1538   sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1539   sigval_type->set_name (xstrdup ("sigval"));
1540   append_composite_type_field (sigval_type, "sival_int", int_type);
1541   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
1542
1543   /* __pid_t */
1544   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1545                         TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
1546   TYPE_TARGET_TYPE (pid_type) = int32_type;
1547   pid_type->set_target_is_stub (true);
1548
1549   /* __uid_t */
1550   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1551                         TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
1552                         "__uid_t");
1553   TYPE_TARGET_TYPE (uid_type) = uint32_type;
1554   pid_type->set_target_is_stub (true);
1555
1556   /* _reason */
1557   reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1558
1559   /* _fault */
1560   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1561   append_composite_type_field (type, "si_trapno", int_type);
1562   append_composite_type_field (reason_type, "_fault", type);
1563
1564   /* _timer */
1565   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1566   append_composite_type_field (type, "si_timerid", int_type);
1567   append_composite_type_field (type, "si_overrun", int_type);
1568   append_composite_type_field (reason_type, "_timer", type);
1569
1570   /* _mesgq */
1571   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1572   append_composite_type_field (type, "si_mqd", int_type);
1573   append_composite_type_field (reason_type, "_mesgq", type);
1574
1575   /* _poll */
1576   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1577   append_composite_type_field (type, "si_band", long_type);
1578   append_composite_type_field (reason_type, "_poll", type);
1579
1580   /* __spare__ */
1581   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1582   append_composite_type_field (type, "__spare1__", long_type);
1583   append_composite_type_field (type, "__spare2__",
1584                                init_vector_type (int_type, 7));
1585   append_composite_type_field (reason_type, "__spare__", type);
1586
1587   /* struct siginfo */
1588   siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1589   siginfo_type->set_name (xstrdup ("siginfo"));
1590   append_composite_type_field (siginfo_type, "si_signo", int_type);
1591   append_composite_type_field (siginfo_type, "si_errno", int_type);
1592   append_composite_type_field (siginfo_type, "si_code", int_type);
1593   append_composite_type_field (siginfo_type, "si_pid", pid_type);
1594   append_composite_type_field (siginfo_type, "si_uid", uid_type);
1595   append_composite_type_field (siginfo_type, "si_status", int_type);
1596   append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
1597   append_composite_type_field (siginfo_type, "si_value", sigval_type);
1598   append_composite_type_field (siginfo_type, "_reason", reason_type);
1599
1600   fbsd_gdbarch_data->siginfo_type = siginfo_type;
1601
1602   return siginfo_type;
1603 }
1604
1605 /* Implement the "gdb_signal_from_target" gdbarch method.  */
1606
1607 static enum gdb_signal
1608 fbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1609 {
1610   switch (signal)
1611     {
1612     case 0:
1613       return GDB_SIGNAL_0;
1614
1615     case FREEBSD_SIGHUP:
1616       return GDB_SIGNAL_HUP;
1617
1618     case FREEBSD_SIGINT:
1619       return GDB_SIGNAL_INT;
1620
1621     case FREEBSD_SIGQUIT:
1622       return GDB_SIGNAL_QUIT;
1623
1624     case FREEBSD_SIGILL:
1625       return GDB_SIGNAL_ILL;
1626
1627     case FREEBSD_SIGTRAP:
1628       return GDB_SIGNAL_TRAP;
1629
1630     case FREEBSD_SIGABRT:
1631       return GDB_SIGNAL_ABRT;
1632
1633     case FREEBSD_SIGEMT:
1634       return GDB_SIGNAL_EMT;
1635
1636     case FREEBSD_SIGFPE:
1637       return GDB_SIGNAL_FPE;
1638
1639     case FREEBSD_SIGKILL:
1640       return GDB_SIGNAL_KILL;
1641
1642     case FREEBSD_SIGBUS:
1643       return GDB_SIGNAL_BUS;
1644
1645     case FREEBSD_SIGSEGV:
1646       return GDB_SIGNAL_SEGV;
1647
1648     case FREEBSD_SIGSYS:
1649       return GDB_SIGNAL_SYS;
1650
1651     case FREEBSD_SIGPIPE:
1652       return GDB_SIGNAL_PIPE;
1653
1654     case FREEBSD_SIGALRM:
1655       return GDB_SIGNAL_ALRM;
1656
1657     case FREEBSD_SIGTERM:
1658       return GDB_SIGNAL_TERM;
1659
1660     case FREEBSD_SIGURG:
1661       return GDB_SIGNAL_URG;
1662
1663     case FREEBSD_SIGSTOP:
1664       return GDB_SIGNAL_STOP;
1665
1666     case FREEBSD_SIGTSTP:
1667       return GDB_SIGNAL_TSTP;
1668
1669     case FREEBSD_SIGCONT:
1670       return GDB_SIGNAL_CONT;
1671
1672     case FREEBSD_SIGCHLD:
1673       return GDB_SIGNAL_CHLD;
1674
1675     case FREEBSD_SIGTTIN:
1676       return GDB_SIGNAL_TTIN;
1677
1678     case FREEBSD_SIGTTOU:
1679       return GDB_SIGNAL_TTOU;
1680
1681     case FREEBSD_SIGIO:
1682       return GDB_SIGNAL_IO;
1683
1684     case FREEBSD_SIGXCPU:
1685       return GDB_SIGNAL_XCPU;
1686
1687     case FREEBSD_SIGXFSZ:
1688       return GDB_SIGNAL_XFSZ;
1689
1690     case FREEBSD_SIGVTALRM:
1691       return GDB_SIGNAL_VTALRM;
1692
1693     case FREEBSD_SIGPROF:
1694       return GDB_SIGNAL_PROF;
1695
1696     case FREEBSD_SIGWINCH:
1697       return GDB_SIGNAL_WINCH;
1698
1699     case FREEBSD_SIGINFO:
1700       return GDB_SIGNAL_INFO;
1701
1702     case FREEBSD_SIGUSR1:
1703       return GDB_SIGNAL_USR1;
1704
1705     case FREEBSD_SIGUSR2:
1706       return GDB_SIGNAL_USR2;
1707
1708     /* SIGTHR is the same as SIGLWP on FreeBSD. */
1709     case FREEBSD_SIGTHR:
1710       return GDB_SIGNAL_LWP;
1711
1712     case FREEBSD_SIGLIBRT:
1713       return GDB_SIGNAL_LIBRT;
1714     }
1715
1716   if (signal >= FREEBSD_SIGRTMIN && signal <= FREEBSD_SIGRTMAX)
1717     {
1718       int offset = signal - FREEBSD_SIGRTMIN;
1719
1720       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_65 + offset);
1721     }
1722
1723   return GDB_SIGNAL_UNKNOWN;
1724 }
1725
1726 /* Implement the "gdb_signal_to_target" gdbarch method.  */
1727
1728 static int
1729 fbsd_gdb_signal_to_target (struct gdbarch *gdbarch,
1730                 enum gdb_signal signal)
1731 {
1732   switch (signal)
1733     {
1734     case GDB_SIGNAL_0:
1735       return 0;
1736
1737     case GDB_SIGNAL_HUP:
1738       return FREEBSD_SIGHUP;
1739
1740     case GDB_SIGNAL_INT:
1741       return FREEBSD_SIGINT;
1742
1743     case GDB_SIGNAL_QUIT:
1744       return FREEBSD_SIGQUIT;
1745
1746     case GDB_SIGNAL_ILL:
1747       return FREEBSD_SIGILL;
1748
1749     case GDB_SIGNAL_TRAP:
1750       return FREEBSD_SIGTRAP;
1751
1752     case GDB_SIGNAL_ABRT:
1753       return FREEBSD_SIGABRT;
1754
1755     case GDB_SIGNAL_EMT:
1756       return FREEBSD_SIGEMT;
1757
1758     case GDB_SIGNAL_FPE:
1759       return FREEBSD_SIGFPE;
1760
1761     case GDB_SIGNAL_KILL:
1762       return FREEBSD_SIGKILL;
1763
1764     case GDB_SIGNAL_BUS:
1765       return FREEBSD_SIGBUS;
1766
1767     case GDB_SIGNAL_SEGV:
1768       return FREEBSD_SIGSEGV;
1769
1770     case GDB_SIGNAL_SYS:
1771       return FREEBSD_SIGSYS;
1772
1773     case GDB_SIGNAL_PIPE:
1774       return FREEBSD_SIGPIPE;
1775
1776     case GDB_SIGNAL_ALRM:
1777       return FREEBSD_SIGALRM;
1778
1779     case GDB_SIGNAL_TERM:
1780       return FREEBSD_SIGTERM;
1781
1782     case GDB_SIGNAL_URG:
1783       return FREEBSD_SIGURG;
1784
1785     case GDB_SIGNAL_STOP:
1786       return FREEBSD_SIGSTOP;
1787
1788     case GDB_SIGNAL_TSTP:
1789       return FREEBSD_SIGTSTP;
1790
1791     case GDB_SIGNAL_CONT:
1792       return FREEBSD_SIGCONT;
1793
1794     case GDB_SIGNAL_CHLD:
1795       return FREEBSD_SIGCHLD;
1796
1797     case GDB_SIGNAL_TTIN:
1798       return FREEBSD_SIGTTIN;
1799
1800     case GDB_SIGNAL_TTOU:
1801       return FREEBSD_SIGTTOU;
1802
1803     case GDB_SIGNAL_IO:
1804       return FREEBSD_SIGIO;
1805
1806     case GDB_SIGNAL_XCPU:
1807       return FREEBSD_SIGXCPU;
1808
1809     case GDB_SIGNAL_XFSZ:
1810       return FREEBSD_SIGXFSZ;
1811
1812     case GDB_SIGNAL_VTALRM:
1813       return FREEBSD_SIGVTALRM;
1814
1815     case GDB_SIGNAL_PROF:
1816       return FREEBSD_SIGPROF;
1817
1818     case GDB_SIGNAL_WINCH:
1819       return FREEBSD_SIGWINCH;
1820
1821     case GDB_SIGNAL_INFO:
1822       return FREEBSD_SIGINFO;
1823
1824     case GDB_SIGNAL_USR1:
1825       return FREEBSD_SIGUSR1;
1826
1827     case GDB_SIGNAL_USR2:
1828       return FREEBSD_SIGUSR2;
1829
1830     case GDB_SIGNAL_LWP:
1831       return FREEBSD_SIGTHR;
1832
1833     case GDB_SIGNAL_LIBRT:
1834       return FREEBSD_SIGLIBRT;
1835     }
1836
1837   if (signal >= GDB_SIGNAL_REALTIME_65
1838       && signal <= GDB_SIGNAL_REALTIME_126)
1839     {
1840       int offset = signal - GDB_SIGNAL_REALTIME_65;
1841
1842       return FREEBSD_SIGRTMIN + offset;
1843     }
1844
1845   return -1;
1846 }
1847
1848 /* Implement the "get_syscall_number" gdbarch method.  */
1849
1850 static LONGEST
1851 fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
1852 {
1853
1854   /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1855      native targets fetch the system call number from the
1856      'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1857      However, system call catching requires this function to be
1858      set.  */
1859
1860   internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
1861 }
1862
1863 /* Read an integer symbol value from the current target.  */
1864
1865 static LONGEST
1866 fbsd_read_integer_by_name (struct gdbarch *gdbarch, const char *name)
1867 {
1868   bound_minimal_symbol ms = lookup_minimal_symbol (name, NULL, NULL);
1869   if (ms.minsym == NULL)
1870     error (_("Unable to resolve symbol '%s'"), name);
1871
1872   gdb_byte buf[4];
1873   if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), buf, sizeof buf) != 0)
1874     error (_("Unable to read value of '%s'"), name);
1875
1876   return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
1877 }
1878
1879 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1880    structure needed to determine the TLS index of an object file.  */
1881
1882 static void
1883 fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data)
1884 {
1885   try
1886     {
1887       /* Fetch offsets from debug symbols in rtld.  */
1888       struct symbol *obj_entry_sym
1889         = lookup_symbol_in_language ("Struct_Obj_Entry", NULL, STRUCT_DOMAIN,
1890                                      language_c, NULL).symbol;
1891       if (obj_entry_sym == NULL)
1892         error (_("Unable to find Struct_Obj_Entry symbol"));
1893       data->off_linkmap = lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym),
1894                                              "linkmap", 0).offset / 8;
1895       data->off_tlsindex = lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym),
1896                                               "tlsindex", 0).offset / 8;
1897       data->rtld_offsets_valid = true;
1898       return;
1899     }
1900   catch (const gdb_exception_error &e)
1901     {
1902       data->off_linkmap = -1;
1903     }
1904
1905   try
1906     {
1907       /* Fetch offsets from global variables in libthr.  Note that
1908          this does not work for single-threaded processes that are not
1909          linked against libthr.  */
1910       data->off_linkmap = fbsd_read_integer_by_name (gdbarch,
1911                                                      "_thread_off_linkmap");
1912       data->off_tlsindex = fbsd_read_integer_by_name (gdbarch,
1913                                                       "_thread_off_tlsindex");
1914       data->rtld_offsets_valid = true;
1915       return;
1916     }
1917   catch (const gdb_exception_error &e)
1918     {
1919       data->off_linkmap = -1;
1920     }
1921 }
1922
1923 /* Helper function to read the TLS index of an object file associated
1924    with a link map entry at LM_ADDR.  */
1925
1926 static LONGEST
1927 fbsd_get_tls_index (struct gdbarch *gdbarch, CORE_ADDR lm_addr)
1928 {
1929   struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space);
1930
1931   if (!data->rtld_offsets_valid)
1932     fbsd_fetch_rtld_offsets (gdbarch, data);
1933
1934   if (data->off_linkmap == -1)
1935     throw_error (TLS_GENERIC_ERROR,
1936                  _("Cannot fetch runtime linker structure offsets"));
1937
1938   /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
1939      pointer and then compute the offset of the tlsindex member.  */
1940   CORE_ADDR tlsindex_addr = lm_addr - data->off_linkmap + data->off_tlsindex;
1941
1942   gdb_byte buf[4];
1943   if (target_read_memory (tlsindex_addr, buf, sizeof buf) != 0)
1944     throw_error (TLS_GENERIC_ERROR,
1945                  _("Cannot find thread-local variables on this target"));
1946
1947   return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
1948 }
1949
1950 /* See fbsd-tdep.h.  */
1951
1952 CORE_ADDR
1953 fbsd_get_thread_local_address (struct gdbarch *gdbarch, CORE_ADDR dtv_addr,
1954                                CORE_ADDR lm_addr, CORE_ADDR offset)
1955 {
1956   LONGEST tls_index = fbsd_get_tls_index (gdbarch, lm_addr);
1957
1958   gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
1959   if (target_read_memory (dtv_addr, buf, sizeof buf) != 0)
1960     throw_error (TLS_GENERIC_ERROR,
1961                  _("Cannot find thread-local variables on this target"));
1962
1963   const struct builtin_type *builtin = builtin_type (gdbarch);
1964   CORE_ADDR addr = gdbarch_pointer_to_address (gdbarch,
1965                                                builtin->builtin_data_ptr, buf);
1966
1967   addr += (tls_index + 1) * TYPE_LENGTH (builtin->builtin_data_ptr);
1968   if (target_read_memory (addr, buf, sizeof buf) != 0)
1969     throw_error (TLS_GENERIC_ERROR,
1970                  _("Cannot find thread-local variables on this target"));
1971
1972   addr = gdbarch_pointer_to_address (gdbarch, builtin->builtin_data_ptr, buf);
1973   return addr + offset;
1974 }
1975
1976 /* See fbsd-tdep.h.  */
1977
1978 CORE_ADDR
1979 fbsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
1980 {
1981   struct bound_minimal_symbol msym = lookup_bound_minimal_symbol ("_rtld_bind");
1982   if (msym.minsym != nullptr && BMSYMBOL_VALUE_ADDRESS (msym) == pc)
1983     return frame_unwind_caller_pc (get_current_frame ());
1984
1985   return 0;
1986 }
1987
1988 /* To be called from GDB_OSABI_FREEBSD handlers. */
1989
1990 void
1991 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1992 {
1993   set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
1994   set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
1995   set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
1996   set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
1997   set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc);
1998   set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
1999   set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
2000   set_gdbarch_gdb_signal_from_target (gdbarch, fbsd_gdb_signal_from_target);
2001   set_gdbarch_gdb_signal_to_target (gdbarch, fbsd_gdb_signal_to_target);
2002   set_gdbarch_skip_solib_resolver (gdbarch, fbsd_skip_solib_resolver);
2003
2004   /* `catch syscall' */
2005   set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
2006   set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
2007 }
2008
2009 void _initialize_fbsd_tdep ();
2010 void
2011 _initialize_fbsd_tdep ()
2012 {
2013   fbsd_gdbarch_data_handle =
2014     gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
2015 }