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