gdb/fbsd-tdep.c

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