gdb/fbsd-tdep.c

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