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       std::string psargs = fname;
 729
 730       const char *infargs = get_inferior_args ();
 731       if (infargs != NULL)
 732         psargs = psargs + " " + infargs;
 733
 734       note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
 735                                           fname, psargs.c_str ());
 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       TAG (BSDFLAGS, _("ELF BSD flags"), AUXV_FORMAT_HEX);
1601     }
1602
1603   fprint_auxv_entry (file, name, description, format, type, val);
1604 }
1605
1606 /* Implement the "get_siginfo_type" gdbarch method.  */
1607
1608 static struct type *
1609 fbsd_get_siginfo_type (struct gdbarch *gdbarch)
1610 {
1611   struct fbsd_gdbarch_data *fbsd_gdbarch_data;
1612   struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
1613   struct type *uid_type, *pid_type;
1614   struct type *sigval_type, *reason_type;
1615   struct type *siginfo_type;
1616   struct type *type;
1617
1618   fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
1619   if (fbsd_gdbarch_data->siginfo_type != NULL)
1620     return fbsd_gdbarch_data->siginfo_type;
1621
1622   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
1623                                 0, "int");
1624   int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
1625   uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1626   long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
1627                                  0, "long");
1628   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
1629
1630   /* union sigval */
1631   sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1632   sigval_type->set_name (xstrdup ("sigval"));
1633   append_composite_type_field (sigval_type, "sival_int", int_type);
1634   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
1635
1636   /* __pid_t */
1637   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1638                         TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
1639   TYPE_TARGET_TYPE (pid_type) = int32_type;
1640   TYPE_TARGET_STUB (pid_type) = 1;
1641
1642   /* __uid_t */
1643   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1644                         TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
1645                         "__uid_t");
1646   TYPE_TARGET_TYPE (uid_type) = uint32_type;
1647   TYPE_TARGET_STUB (uid_type) = 1;
1648
1649   /* _reason */
1650   reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1651
1652   /* _fault */
1653   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1654   append_composite_type_field (type, "si_trapno", int_type);
1655   append_composite_type_field (reason_type, "_fault", type);
1656
1657   /* _timer */
1658   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1659   append_composite_type_field (type, "si_timerid", int_type);
1660   append_composite_type_field (type, "si_overrun", int_type);
1661   append_composite_type_field (reason_type, "_timer", type);
1662
1663   /* _mesgq */
1664   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1665   append_composite_type_field (type, "si_mqd", int_type);
1666   append_composite_type_field (reason_type, "_mesgq", type);
1667
1668   /* _poll */
1669   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1670   append_composite_type_field (type, "si_band", long_type);
1671   append_composite_type_field (reason_type, "_poll", type);
1672
1673   /* __spare__ */
1674   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1675   append_composite_type_field (type, "__spare1__", long_type);
1676   append_composite_type_field (type, "__spare2__",
1677                                init_vector_type (int_type, 7));
1678   append_composite_type_field (reason_type, "__spare__", type);
1679
1680   /* struct siginfo */
1681   siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1682   siginfo_type->set_name (xstrdup ("siginfo"));
1683   append_composite_type_field (siginfo_type, "si_signo", int_type);
1684   append_composite_type_field (siginfo_type, "si_errno", int_type);
1685   append_composite_type_field (siginfo_type, "si_code", int_type);
1686   append_composite_type_field (siginfo_type, "si_pid", pid_type);
1687   append_composite_type_field (siginfo_type, "si_uid", uid_type);
1688   append_composite_type_field (siginfo_type, "si_status", int_type);
1689   append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
1690   append_composite_type_field (siginfo_type, "si_value", sigval_type);
1691   append_composite_type_field (siginfo_type, "_reason", reason_type);
1692
1693   fbsd_gdbarch_data->siginfo_type = siginfo_type;
1694
1695   return siginfo_type;
1696 }
1697
1698 /* Implement the "gdb_signal_from_target" gdbarch method.  */
1699
1700 static enum gdb_signal
1701 fbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1702 {
1703   switch (signal)
1704     {
1705     case 0:
1706       return GDB_SIGNAL_0;
1707
1708     case FREEBSD_SIGHUP:
1709       return GDB_SIGNAL_HUP;
1710
1711     case FREEBSD_SIGINT:
1712       return GDB_SIGNAL_INT;
1713
1714     case FREEBSD_SIGQUIT:
1715       return GDB_SIGNAL_QUIT;
1716
1717     case FREEBSD_SIGILL:
1718       return GDB_SIGNAL_ILL;
1719
1720     case FREEBSD_SIGTRAP:
1721       return GDB_SIGNAL_TRAP;
1722
1723     case FREEBSD_SIGABRT:
1724       return GDB_SIGNAL_ABRT;
1725
1726     case FREEBSD_SIGEMT:
1727       return GDB_SIGNAL_EMT;
1728
1729     case FREEBSD_SIGFPE:
1730       return GDB_SIGNAL_FPE;
1731
1732     case FREEBSD_SIGKILL:
1733       return GDB_SIGNAL_KILL;
1734
1735     case FREEBSD_SIGBUS:
1736       return GDB_SIGNAL_BUS;
1737
1738     case FREEBSD_SIGSEGV:
1739       return GDB_SIGNAL_SEGV;
1740
1741     case FREEBSD_SIGSYS:
1742       return GDB_SIGNAL_SYS;
1743
1744     case FREEBSD_SIGPIPE:
1745       return GDB_SIGNAL_PIPE;
1746
1747     case FREEBSD_SIGALRM:
1748       return GDB_SIGNAL_ALRM;
1749
1750     case FREEBSD_SIGTERM:
1751       return GDB_SIGNAL_TERM;
1752
1753     case FREEBSD_SIGURG:
1754       return GDB_SIGNAL_URG;
1755
1756     case FREEBSD_SIGSTOP:
1757       return GDB_SIGNAL_STOP;
1758
1759     case FREEBSD_SIGTSTP:
1760       return GDB_SIGNAL_TSTP;
1761
1762     case FREEBSD_SIGCONT:
1763       return GDB_SIGNAL_CONT;
1764
1765     case FREEBSD_SIGCHLD:
1766       return GDB_SIGNAL_CHLD;
1767
1768     case FREEBSD_SIGTTIN:
1769       return GDB_SIGNAL_TTIN;
1770
1771     case FREEBSD_SIGTTOU:
1772       return GDB_SIGNAL_TTOU;
1773
1774     case FREEBSD_SIGIO:
1775       return GDB_SIGNAL_IO;
1776
1777     case FREEBSD_SIGXCPU:
1778       return GDB_SIGNAL_XCPU;
1779
1780     case FREEBSD_SIGXFSZ:
1781       return GDB_SIGNAL_XFSZ;
1782
1783     case FREEBSD_SIGVTALRM:
1784       return GDB_SIGNAL_VTALRM;
1785
1786     case FREEBSD_SIGPROF:
1787       return GDB_SIGNAL_PROF;
1788
1789     case FREEBSD_SIGWINCH:
1790       return GDB_SIGNAL_WINCH;
1791
1792     case FREEBSD_SIGINFO:
1793       return GDB_SIGNAL_INFO;
1794
1795     case FREEBSD_SIGUSR1:
1796       return GDB_SIGNAL_USR1;
1797
1798     case FREEBSD_SIGUSR2:
1799       return GDB_SIGNAL_USR2;
1800
1801     /* SIGTHR is the same as SIGLWP on FreeBSD. */
1802     case FREEBSD_SIGTHR:
1803       return GDB_SIGNAL_LWP;
1804
1805     case FREEBSD_SIGLIBRT:
1806       return GDB_SIGNAL_LIBRT;
1807     }
1808
1809   if (signal >= FREEBSD_SIGRTMIN && signal <= FREEBSD_SIGRTMAX)
1810     {
1811       int offset = signal - FREEBSD_SIGRTMIN;
1812
1813       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_65 + offset);
1814     }
1815
1816   return GDB_SIGNAL_UNKNOWN;
1817 }
1818
1819 /* Implement the "gdb_signal_to_target" gdbarch method.  */
1820
1821 static int
1822 fbsd_gdb_signal_to_target (struct gdbarch *gdbarch,
1823                 enum gdb_signal signal)
1824 {
1825   switch (signal)
1826     {
1827     case GDB_SIGNAL_0:
1828       return 0;
1829
1830     case GDB_SIGNAL_HUP:
1831       return FREEBSD_SIGHUP;
1832
1833     case GDB_SIGNAL_INT:
1834       return FREEBSD_SIGINT;
1835
1836     case GDB_SIGNAL_QUIT:
1837       return FREEBSD_SIGQUIT;
1838
1839     case GDB_SIGNAL_ILL:
1840       return FREEBSD_SIGILL;
1841
1842     case GDB_SIGNAL_TRAP:
1843       return FREEBSD_SIGTRAP;
1844
1845     case GDB_SIGNAL_ABRT:
1846       return FREEBSD_SIGABRT;
1847
1848     case GDB_SIGNAL_EMT:
1849       return FREEBSD_SIGEMT;
1850
1851     case GDB_SIGNAL_FPE:
1852       return FREEBSD_SIGFPE;
1853
1854     case GDB_SIGNAL_KILL:
1855       return FREEBSD_SIGKILL;
1856
1857     case GDB_SIGNAL_BUS:
1858       return FREEBSD_SIGBUS;
1859
1860     case GDB_SIGNAL_SEGV:
1861       return FREEBSD_SIGSEGV;
1862
1863     case GDB_SIGNAL_SYS:
1864       return FREEBSD_SIGSYS;
1865
1866     case GDB_SIGNAL_PIPE:
1867       return FREEBSD_SIGPIPE;
1868
1869     case GDB_SIGNAL_ALRM:
1870       return FREEBSD_SIGALRM;
1871
1872     case GDB_SIGNAL_TERM:
1873       return FREEBSD_SIGTERM;
1874
1875     case GDB_SIGNAL_URG:
1876       return FREEBSD_SIGURG;
1877
1878     case GDB_SIGNAL_STOP:
1879       return FREEBSD_SIGSTOP;
1880
1881     case GDB_SIGNAL_TSTP:
1882       return FREEBSD_SIGTSTP;
1883
1884     case GDB_SIGNAL_CONT:
1885       return FREEBSD_SIGCONT;
1886
1887     case GDB_SIGNAL_CHLD:
1888       return FREEBSD_SIGCHLD;
1889
1890     case GDB_SIGNAL_TTIN:
1891       return FREEBSD_SIGTTIN;
1892
1893     case GDB_SIGNAL_TTOU:
1894       return FREEBSD_SIGTTOU;
1895
1896     case GDB_SIGNAL_IO:
1897       return FREEBSD_SIGIO;
1898
1899     case GDB_SIGNAL_XCPU:
1900       return FREEBSD_SIGXCPU;
1901
1902     case GDB_SIGNAL_XFSZ:
1903       return FREEBSD_SIGXFSZ;
1904
1905     case GDB_SIGNAL_VTALRM:
1906       return FREEBSD_SIGVTALRM;
1907
1908     case GDB_SIGNAL_PROF:
1909       return FREEBSD_SIGPROF;
1910
1911     case GDB_SIGNAL_WINCH:
1912       return FREEBSD_SIGWINCH;
1913
1914     case GDB_SIGNAL_INFO:
1915       return FREEBSD_SIGINFO;
1916
1917     case GDB_SIGNAL_USR1:
1918       return FREEBSD_SIGUSR1;
1919
1920     case GDB_SIGNAL_USR2:
1921       return FREEBSD_SIGUSR2;
1922
1923     case GDB_SIGNAL_LWP:
1924       return FREEBSD_SIGTHR;
1925
1926     case GDB_SIGNAL_LIBRT:
1927       return FREEBSD_SIGLIBRT;
1928     }
1929
1930   if (signal >= GDB_SIGNAL_REALTIME_65
1931       && signal <= GDB_SIGNAL_REALTIME_126)
1932     {
1933       int offset = signal - GDB_SIGNAL_REALTIME_65;
1934
1935       return FREEBSD_SIGRTMIN + offset;
1936     }
1937
1938   return -1;
1939 }
1940
1941 /* Implement the "get_syscall_number" gdbarch method.  */
1942
1943 static LONGEST
1944 fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
1945 {
1946
1947   /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1948      native targets fetch the system call number from the
1949      'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1950      However, system call catching requires this function to be
1951      set.  */
1952
1953   internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
1954 }
1955
1956 /* Read an integer symbol value from the current target.  */
1957
1958 static LONGEST
1959 fbsd_read_integer_by_name (struct gdbarch *gdbarch, const char *name)
1960 {
1961   bound_minimal_symbol ms = lookup_minimal_symbol (name, NULL, NULL);
1962   if (ms.minsym == NULL)
1963     error (_("Unable to resolve symbol '%s'"), name);
1964
1965   gdb_byte buf[4];
1966   if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), buf, sizeof buf) != 0)
1967     error (_("Unable to read value of '%s'"), name);
1968
1969   return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
1970 }
1971
1972 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1973    structure needed to determine the TLS index of an object file.  */
1974
1975 static void
1976 fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data)
1977 {
1978   try
1979     {
1980       /* Fetch offsets from debug symbols in rtld.  */
1981       struct symbol *obj_entry_sym
1982         = lookup_symbol_in_language ("Struct_Obj_Entry", NULL, STRUCT_DOMAIN,
1983                                      language_c, NULL).symbol;
1984       if (obj_entry_sym == NULL)
1985         error (_("Unable to find Struct_Obj_Entry symbol"));
1986       data->off_linkmap = lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym),
1987                                              "linkmap", 0).offset / 8;
1988       data->off_tlsindex = lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym),
1989                                               "tlsindex", 0).offset / 8;
1990       data->rtld_offsets_valid = true;
1991       return;
1992     }
1993   catch (const gdb_exception_error &e)
1994     {
1995       data->off_linkmap = -1;
1996     }
1997
1998   try
1999     {
2000       /* Fetch offsets from global variables in libthr.  Note that
2001          this does not work for single-threaded processes that are not
2002          linked against libthr.  */
2003       data->off_linkmap = fbsd_read_integer_by_name (gdbarch,
2004                                                      "_thread_off_linkmap");
2005       data->off_tlsindex = fbsd_read_integer_by_name (gdbarch,
2006                                                       "_thread_off_tlsindex");
2007       data->rtld_offsets_valid = true;
2008       return;
2009     }
2010   catch (const gdb_exception_error &e)
2011     {
2012       data->off_linkmap = -1;
2013     }
2014 }
2015
2016 /* Helper function to read the TLS index of an object file associated
2017    with a link map entry at LM_ADDR.  */
2018
2019 static LONGEST
2020 fbsd_get_tls_index (struct gdbarch *gdbarch, CORE_ADDR lm_addr)
2021 {
2022   struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space);
2023
2024   if (!data->rtld_offsets_valid)
2025     fbsd_fetch_rtld_offsets (gdbarch, data);
2026
2027   if (data->off_linkmap == -1)
2028     throw_error (TLS_GENERIC_ERROR,
2029                  _("Cannot fetch runtime linker structure offsets"));
2030
2031   /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
2032      pointer and then compute the offset of the tlsindex member.  */
2033   CORE_ADDR tlsindex_addr = lm_addr - data->off_linkmap + data->off_tlsindex;
2034
2035   gdb_byte buf[4];
2036   if (target_read_memory (tlsindex_addr, buf, sizeof buf) != 0)
2037     throw_error (TLS_GENERIC_ERROR,
2038                  _("Cannot find thread-local variables on this target"));
2039
2040   return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
2041 }
2042
2043 /* See fbsd-tdep.h.  */
2044
2045 CORE_ADDR
2046 fbsd_get_thread_local_address (struct gdbarch *gdbarch, CORE_ADDR dtv_addr,
2047                                CORE_ADDR lm_addr, CORE_ADDR offset)
2048 {
2049   LONGEST tls_index = fbsd_get_tls_index (gdbarch, lm_addr);
2050
2051   gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
2052   if (target_read_memory (dtv_addr, buf, sizeof buf) != 0)
2053     throw_error (TLS_GENERIC_ERROR,
2054                  _("Cannot find thread-local variables on this target"));
2055
2056   const struct builtin_type *builtin = builtin_type (gdbarch);
2057   CORE_ADDR addr = gdbarch_pointer_to_address (gdbarch,
2058                                                builtin->builtin_data_ptr, buf);
2059
2060   addr += (tls_index + 1) * TYPE_LENGTH (builtin->builtin_data_ptr);
2061   if (target_read_memory (addr, buf, sizeof buf) != 0)
2062     throw_error (TLS_GENERIC_ERROR,
2063                  _("Cannot find thread-local variables on this target"));
2064
2065   addr = gdbarch_pointer_to_address (gdbarch, builtin->builtin_data_ptr, buf);
2066   return addr + offset;
2067 }
2068
2069 /* To be called from GDB_OSABI_FREEBSD handlers. */
2070
2071 void
2072 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2073 {
2074   set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
2075   set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
2076   set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
2077   set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
2078   set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc);
2079   set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
2080   set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
2081   set_gdbarch_gdb_signal_from_target (gdbarch, fbsd_gdb_signal_from_target);
2082   set_gdbarch_gdb_signal_to_target (gdbarch, fbsd_gdb_signal_to_target);
2083
2084   /* `catch syscall' */
2085   set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
2086   set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
2087 }
2088
2089 void _initialize_fbsd_tdep ();
2090 void
2091 _initialize_fbsd_tdep ()
2092 {
2093   fbsd_gdbarch_data_handle =
2094     gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
2095 }