gdb/fbsd-tdep.c

   1 /* Target-dependent code for FreeBSD, architecture-independent.
   2
   3    Copyright (C) 2002-2018 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 "xml-syscall.h"
  28
  29 #include "elf-bfd.h"
  30 #include "fbsd-tdep.h"
  31
  32
  33 /* FreeBSD kernels 12.0 and later include a copy of the
  34    'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
  35    operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
  36    The constants below define the offset of field members and flags in
  37    this structure used by methods in this file.  Note that the
  38    'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
  39    containing the size of the structure.  */
  40
  41 #define LWPINFO_OFFSET          0x4
  42
  43 /* Offsets in ptrace_lwpinfo.  */
  44 #define LWPINFO_PL_FLAGS        0x8
  45 #define LWPINFO64_PL_SIGINFO    0x30
  46 #define LWPINFO32_PL_SIGINFO    0x2c
  47
  48 /* Flags in pl_flags.  */
  49 #define PL_FLAG_SI      0x20    /* siginfo is valid */
  50
  51 /* Sizes of siginfo_t.  */
  52 #define SIZE64_SIGINFO_T        80
  53 #define SIZE32_SIGINFO_T        64
  54
  55 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_VMMAP core
  56    dump notes.  See <sys/user.h> for the definition of struct
  57    kinfo_vmentry.  This data structure should have the same layout on
  58    all architectures.  */
  59
  60 #define KVE_STRUCTSIZE          0x0
  61 #define KVE_START               0x8
  62 #define KVE_END                 0x10
  63 #define KVE_OFFSET              0x18
  64 #define KVE_FLAGS               0x2c
  65 #define KVE_PROTECTION          0x38
  66 #define KVE_PATH                0x88
  67
  68 /* Flags in the 'kve_protection' field in struct kinfo_vmentry.  These
  69    match the KVME_PROT_* constants in <sys/user.h>.  */
  70
  71 #define KINFO_VME_PROT_READ     0x00000001
  72 #define KINFO_VME_PROT_WRITE    0x00000002
  73 #define KINFO_VME_PROT_EXEC     0x00000004
  74
  75 /* Flags in the 'kve_flags' field in struct kinfo_vmentry.  These
  76    match the KVME_FLAG_* constants in <sys/user.h>.  */
  77
  78 #define KINFO_VME_FLAG_COW              0x00000001
  79 #define KINFO_VME_FLAG_NEEDS_COPY       0x00000002
  80 #define KINFO_VME_FLAG_NOCOREDUMP       0x00000004
  81 #define KINFO_VME_FLAG_SUPER            0x00000008
  82 #define KINFO_VME_FLAG_GROWS_UP         0x00000010
  83 #define KINFO_VME_FLAG_GROWS_DOWN       0x00000020
  84
  85 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_FILES core
  86    dump notes.  See <sys/user.h> for the definition of struct
  87    kinfo_file.  This data structure should have the same layout on all
  88    architectures.  */
  89
  90 #define KF_STRUCTSIZE           0x0
  91 #define KF_TYPE                 0x4
  92 #define KF_FD                   0x8
  93 #define KF_PATH                 0x170
  94
  95 /* Constants for the 'kf_type' field in struct kinfo_file.  These
  96    match the KF_TYPE_* constants in <sys/user.h>.  */
  97
  98 #define KINFO_FILE_TYPE_VNODE   1
  99
 100 /* Special values for the 'kf_fd' field in struct kinfo_file.  These
 101    match the KF_FD_TYPE_* constants in <sys/user.h>.  */
 102
 103 #define KINFO_FILE_FD_TYPE_CWD  -1
 104 #define KINFO_FILE_FD_TYPE_TEXT -5
 105
 106 /* Number of 32-bit words in a signal set.  This matches _SIG_WORDS in
 107    <sys/_sigset.h> and is the same value on all architectures.  */
 108
 109 #define SIG_WORDS               4
 110
 111 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_PROC core
 112    dump notes.  See <sys/user.h> for the definition of struct
 113    kinfo_proc.  This data structure has different layouts on different
 114    architectures mostly due to ILP32 vs LP64.  However, FreeBSD/i386
 115    uses a 32-bit time_t while all other architectures use a 64-bit
 116    time_t.
 117
 118    The core dump note actually contains one kinfo_proc structure for
 119    each thread, but all of the process-wide data can be obtained from
 120    the first structure.  One result of this note's format is that some
 121    of the process-wide status available in the native target method
 122    from the kern.proc.pid.<pid> sysctl such as ki_stat and ki_siglist
 123    is not available from a core dump.  Instead, the per-thread data
 124    structures contain the value of these fields for individual
 125    threads.  */
 126
 127 struct kinfo_proc_layout
 128 {
 129   /* Offsets of struct kinfo_proc members.  */
 130   int ki_layout;
 131   int ki_pid;
 132   int ki_ppid;
 133   int ki_pgid;
 134   int ki_tpgid;
 135   int ki_sid;
 136   int ki_tdev_freebsd11;
 137   int ki_sigignore;
 138   int ki_sigcatch;
 139   int ki_uid;
 140   int ki_ruid;
 141   int ki_svuid;
 142   int ki_rgid;
 143   int ki_svgid;
 144   int ki_ngroups;
 145   int ki_groups;
 146   int ki_size;
 147   int ki_rssize;
 148   int ki_tsize;
 149   int ki_dsize;
 150   int ki_ssize;
 151   int ki_start;
 152   int ki_nice;
 153   int ki_comm;
 154   int ki_tdev;
 155   int ki_rusage;
 156   int ki_rusage_ch;
 157
 158   /* Offsets of struct rusage members.  */
 159   int ru_utime;
 160   int ru_stime;
 161   int ru_maxrss;
 162   int ru_minflt;
 163   int ru_majflt;
 164 };
 165
 166 const struct kinfo_proc_layout kinfo_proc_layout_32 =
 167   {
 168     .ki_layout = 0x4,
 169     .ki_pid = 0x28,
 170     .ki_ppid = 0x2c,
 171     .ki_pgid = 0x30,
 172     .ki_tpgid = 0x34,
 173     .ki_sid = 0x38,
 174     .ki_tdev_freebsd11 = 0x44,
 175     .ki_sigignore = 0x68,
 176     .ki_sigcatch = 0x78,
 177     .ki_uid = 0x88,
 178     .ki_ruid = 0x8c,
 179     .ki_svuid = 0x90,
 180     .ki_rgid = 0x94,
 181     .ki_svgid = 0x98,
 182     .ki_ngroups = 0x9c,
 183     .ki_groups = 0xa0,
 184     .ki_size = 0xe0,
 185     .ki_rssize = 0xe4,
 186     .ki_tsize = 0xec,
 187     .ki_dsize = 0xf0,
 188     .ki_ssize = 0xf4,
 189     .ki_start = 0x118,
 190     .ki_nice = 0x145,
 191     .ki_comm = 0x17f,
 192     .ki_tdev = 0x1f0,
 193     .ki_rusage = 0x220,
 194     .ki_rusage_ch = 0x278,
 195
 196     .ru_utime = 0x0,
 197     .ru_stime = 0x10,
 198     .ru_maxrss = 0x20,
 199     .ru_minflt = 0x30,
 200     .ru_majflt = 0x34,
 201   };
 202
 203 const struct kinfo_proc_layout kinfo_proc_layout_i386 =
 204   {
 205     .ki_layout = 0x4,
 206     .ki_pid = 0x28,
 207     .ki_ppid = 0x2c,
 208     .ki_pgid = 0x30,
 209     .ki_tpgid = 0x34,
 210     .ki_sid = 0x38,
 211     .ki_tdev_freebsd11 = 0x44,
 212     .ki_sigignore = 0x68,
 213     .ki_sigcatch = 0x78,
 214     .ki_uid = 0x88,
 215     .ki_ruid = 0x8c,
 216     .ki_svuid = 0x90,
 217     .ki_rgid = 0x94,
 218     .ki_svgid = 0x98,
 219     .ki_ngroups = 0x9c,
 220     .ki_groups = 0xa0,
 221     .ki_size = 0xe0,
 222     .ki_rssize = 0xe4,
 223     .ki_tsize = 0xec,
 224     .ki_dsize = 0xf0,
 225     .ki_ssize = 0xf4,
 226     .ki_start = 0x118,
 227     .ki_nice = 0x135,
 228     .ki_comm = 0x16f,
 229     .ki_tdev = 0x1e0,
 230     .ki_rusage = 0x210,
 231     .ki_rusage_ch = 0x258,
 232
 233     .ru_utime = 0x0,
 234     .ru_stime = 0x8,
 235     .ru_maxrss = 0x10,
 236     .ru_minflt = 0x20,
 237     .ru_majflt = 0x24,
 238   };
 239
 240 const struct kinfo_proc_layout kinfo_proc_layout_64 =
 241   {
 242     .ki_layout = 0x4,
 243     .ki_pid = 0x48,
 244     .ki_ppid = 0x4c,
 245     .ki_pgid = 0x50,
 246     .ki_tpgid = 0x54,
 247     .ki_sid = 0x58,
 248     .ki_tdev_freebsd11 = 0x64,
 249     .ki_sigignore = 0x88,
 250     .ki_sigcatch = 0x98,
 251     .ki_uid = 0xa8,
 252     .ki_ruid = 0xac,
 253     .ki_svuid = 0xb0,
 254     .ki_rgid = 0xb4,
 255     .ki_svgid = 0xb8,
 256     .ki_ngroups = 0xbc,
 257     .ki_groups = 0xc0,
 258     .ki_size = 0x100,
 259     .ki_rssize = 0x108,
 260     .ki_tsize = 0x118,
 261     .ki_dsize = 0x120,
 262     .ki_ssize = 0x128,
 263     .ki_start = 0x150,
 264     .ki_nice = 0x185,
 265     .ki_comm = 0x1bf,
 266     .ki_tdev = 0x230,
 267     .ki_rusage = 0x260,
 268     .ki_rusage_ch = 0x2f0,
 269
 270     .ru_utime = 0x0,
 271     .ru_stime = 0x10,
 272     .ru_maxrss = 0x20,
 273     .ru_minflt = 0x40,
 274     .ru_majflt = 0x48,
 275   };
 276
 277 static struct gdbarch_data *fbsd_gdbarch_data_handle;
 278
 279 struct fbsd_gdbarch_data
 280   {
 281     struct type *siginfo_type;
 282   };
 283
 284 static void *
 285 init_fbsd_gdbarch_data (struct gdbarch *gdbarch)
 286 {
 287   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct fbsd_gdbarch_data);
 288 }
 289
 290 static struct fbsd_gdbarch_data *
 291 get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
 292 {
 293   return ((struct fbsd_gdbarch_data *)
 294           gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
 295 }
 296
 297 /* This is how we want PTIDs from core files to be printed.  */
 298
 299 static const char *
 300 fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
 301 {
 302   static char buf[80];
 303
 304   if (ptid_get_lwp (ptid) != 0)
 305     {
 306       xsnprintf (buf, sizeof buf, "LWP %ld", ptid_get_lwp (ptid));
 307       return buf;
 308     }
 309
 310   return normal_pid_to_str (ptid);
 311 }
 312
 313 /* Extract the name assigned to a thread from a core.  Returns the
 314    string in a static buffer.  */
 315
 316 static const char *
 317 fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
 318 {
 319   static char buf[80];
 320   struct bfd_section *section;
 321   bfd_size_type size;
 322
 323   if (ptid_get_lwp (thr->ptid) != 0)
 324     {
 325       /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
 326          whose contents are defined by a "struct thrmisc" declared in
 327          <sys/procfs.h> on FreeBSD.  The per-thread name is stored as
 328          a null-terminated string as the first member of the
 329          structure.  Rather than define the full structure here, just
 330          extract the null-terminated name from the start of the
 331          note.  */
 332       thread_section_name section_name (".thrmisc", thr->ptid);
 333
 334       section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
 335       if (section != NULL && bfd_section_size (core_bfd, section) > 0)
 336         {
 337           /* Truncate the name if it is longer than "buf".  */
 338           size = bfd_section_size (core_bfd, section);
 339           if (size > sizeof buf - 1)
 340             size = sizeof buf - 1;
 341           if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
 342                                         size)
 343               && buf[0] != '\0')
 344             {
 345               buf[size] = '\0';
 346
 347               /* Note that each thread will report the process command
 348                  as its thread name instead of an empty name if a name
 349                  has not been set explicitly.  Return a NULL name in
 350                  that case.  */
 351               if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
 352                 return buf;
 353             }
 354         }
 355     }
 356
 357   return NULL;
 358 }
 359
 360 /* Implement the "core_xfer_siginfo" gdbarch method.  */
 361
 362 static LONGEST
 363 fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
 364                         ULONGEST offset, ULONGEST len)
 365 {
 366   size_t siginfo_size;
 367
 368   if (gdbarch_long_bit (gdbarch) == 32)
 369     siginfo_size = SIZE32_SIGINFO_T;
 370   else
 371     siginfo_size = SIZE64_SIGINFO_T;
 372   if (offset > siginfo_size)
 373     return -1;
 374
 375   thread_section_name section_name (".note.freebsdcore.lwpinfo", inferior_ptid);
 376   asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
 377   if (section == NULL)
 378     return -1;
 379
 380   gdb_byte buf[4];
 381   if (!bfd_get_section_contents (core_bfd, section, buf,
 382                                  LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4))
 383     return -1;
 384
 385   int pl_flags = extract_signed_integer (buf, 4, gdbarch_byte_order (gdbarch));
 386   if (!(pl_flags & PL_FLAG_SI))
 387     return -1;
 388
 389   if (offset + len > siginfo_size)
 390     len = siginfo_size - offset;
 391
 392   ULONGEST siginfo_offset;
 393   if (gdbarch_long_bit (gdbarch) == 32)
 394     siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO;
 395   else
 396     siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO;
 397
 398   if (!bfd_get_section_contents (core_bfd, section, readbuf,
 399                                  siginfo_offset + offset, len))
 400     return -1;
 401
 402   return len;
 403 }
 404
 405 static int
 406 find_signalled_thread (struct thread_info *info, void *data)
 407 {
 408   if (info->suspend.stop_signal != GDB_SIGNAL_0
 409       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
 410     return 1;
 411
 412   return 0;
 413 }
 414
 415 /* Structure for passing information from
 416    fbsd_collect_thread_registers via an iterator to
 417    fbsd_collect_regset_section_cb. */
 418
 419 struct fbsd_collect_regset_section_cb_data
 420 {
 421   const struct regcache *regcache;
 422   bfd *obfd;
 423   char *note_data;
 424   int *note_size;
 425   unsigned long lwp;
 426   enum gdb_signal stop_signal;
 427   int abort_iteration;
 428 };
 429
 430 static void
 431 fbsd_collect_regset_section_cb (const char *sect_name, int size,
 432                                 const struct regset *regset,
 433                                 const char *human_name, void *cb_data)
 434 {
 435   char *buf;
 436   struct fbsd_collect_regset_section_cb_data *data
 437     = (struct fbsd_collect_regset_section_cb_data *) cb_data;
 438
 439   if (data->abort_iteration)
 440     return;
 441
 442   gdb_assert (regset->collect_regset);
 443
 444   buf = (char *) xmalloc (size);
 445   regset->collect_regset (regset, data->regcache, -1, buf, size);
 446
 447   /* PRSTATUS still needs to be treated specially.  */
 448   if (strcmp (sect_name, ".reg") == 0)
 449     data->note_data = (char *) elfcore_write_prstatus
 450       (data->obfd, data->note_data, data->note_size, data->lwp,
 451        gdb_signal_to_host (data->stop_signal), buf);
 452   else
 453     data->note_data = (char *) elfcore_write_register_note
 454       (data->obfd, data->note_data, data->note_size,
 455        sect_name, buf, size);
 456   xfree (buf);
 457
 458   if (data->note_data == NULL)
 459     data->abort_iteration = 1;
 460 }
 461
 462 /* Records the thread's register state for the corefile note
 463    section.  */
 464
 465 static char *
 466 fbsd_collect_thread_registers (const struct regcache *regcache,
 467                                ptid_t ptid, bfd *obfd,
 468                                char *note_data, int *note_size,
 469                                enum gdb_signal stop_signal)
 470 {
 471   struct gdbarch *gdbarch = regcache->arch ();
 472   struct fbsd_collect_regset_section_cb_data data;
 473
 474   data.regcache = regcache;
 475   data.obfd = obfd;
 476   data.note_data = note_data;
 477   data.note_size = note_size;
 478   data.stop_signal = stop_signal;
 479   data.abort_iteration = 0;
 480   data.lwp = ptid_get_lwp (ptid);
 481
 482   gdbarch_iterate_over_regset_sections (gdbarch,
 483                                         fbsd_collect_regset_section_cb,
 484                                         &data, regcache);
 485   return data.note_data;
 486 }
 487
 488 struct fbsd_corefile_thread_data
 489 {
 490   struct gdbarch *gdbarch;
 491   bfd *obfd;
 492   char *note_data;
 493   int *note_size;
 494   enum gdb_signal stop_signal;
 495 };
 496
 497 /* Records the thread's register state for the corefile note
 498    section.  */
 499
 500 static void
 501 fbsd_corefile_thread (struct thread_info *info,
 502                       struct fbsd_corefile_thread_data *args)
 503 {
 504   struct regcache *regcache;
 505
 506   regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
 507
 508   target_fetch_registers (regcache, -1);
 509
 510   args->note_data = fbsd_collect_thread_registers
 511     (regcache, info->ptid, args->obfd, args->note_data,
 512      args->note_size, args->stop_signal);
 513 }
 514
 515 /* Create appropriate note sections for a corefile, returning them in
 516    allocated memory.  */
 517
 518 static char *
 519 fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
 520 {
 521   struct fbsd_corefile_thread_data thread_args;
 522   char *note_data = NULL;
 523   Elf_Internal_Ehdr *i_ehdrp;
 524   struct thread_info *curr_thr, *signalled_thr, *thr;
 525
 526   /* Put a "FreeBSD" label in the ELF header.  */
 527   i_ehdrp = elf_elfheader (obfd);
 528   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
 529
 530   gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));
 531
 532   if (get_exec_file (0))
 533     {
 534       const char *fname = lbasename (get_exec_file (0));
 535       char *psargs = xstrdup (fname);
 536
 537       if (get_inferior_args ())
 538         psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
 539                            (char *) NULL);
 540
 541       note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
 542                                           fname, psargs);
 543     }
 544
 545   /* Thread register information.  */
 546   TRY
 547     {
 548       update_thread_list ();
 549     }
 550   CATCH (e, RETURN_MASK_ERROR)
 551     {
 552       exception_print (gdb_stderr, e);
 553     }
 554   END_CATCH
 555
 556   /* Like the kernel, prefer dumping the signalled thread first.
 557      "First thread" is what tools use to infer the signalled thread.
 558      In case there's more than one signalled thread, prefer the
 559      current thread, if it is signalled.  */
 560   curr_thr = inferior_thread ();
 561   if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
 562     signalled_thr = curr_thr;
 563   else
 564     {
 565       signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
 566       if (signalled_thr == NULL)
 567         signalled_thr = curr_thr;
 568     }
 569
 570   thread_args.gdbarch = gdbarch;
 571   thread_args.obfd = obfd;
 572   thread_args.note_data = note_data;
 573   thread_args.note_size = note_size;
 574   thread_args.stop_signal = signalled_thr->suspend.stop_signal;
 575
 576   fbsd_corefile_thread (signalled_thr, &thread_args);
 577   ALL_NON_EXITED_THREADS (thr)
 578     {
 579       if (thr == signalled_thr)
 580         continue;
 581       if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
 582         continue;
 583
 584       fbsd_corefile_thread (thr, &thread_args);
 585     }
 586
 587   note_data = thread_args.note_data;
 588
 589   return note_data;
 590 }
 591
 592 /* Helper function to generate mappings flags for a single VM map
 593    entry in 'info proc mappings'.  */
 594
 595 const char *
 596 fbsd_vm_map_entry_flags (int kve_flags, int kve_protection)
 597 {
 598   static char vm_flags[9];
 599
 600   vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-';
 601   vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-';
 602   vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-';
 603   vm_flags[3] = ' ';
 604   vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-';
 605   vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-';
 606   vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-';
 607   vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U'
 608     : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-';
 609   vm_flags[8] = '\0';
 610
 611   return vm_flags;
 612 }
 613
 614 /* Implement "info proc mappings" for a corefile.  */
 615
 616 static void
 617 fbsd_core_info_proc_mappings (struct gdbarch *gdbarch)
 618 {
 619   asection *section;
 620   unsigned char *descdata, *descend;
 621   size_t note_size;
 622
 623   section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.vmmap");
 624   if (section == NULL)
 625     {
 626       warning (_("unable to find mappings in core file"));
 627       return;
 628     }
 629
 630   note_size = bfd_get_section_size (section);
 631   if (note_size < 4)
 632     error (_("malformed core note - too short for header"));
 633
 634   gdb::def_vector<unsigned char> contents (note_size);
 635   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
 636                                  0, note_size))
 637     error (_("could not get core note contents"));
 638
 639   descdata = contents.data ();
 640   descend = descdata + note_size;
 641
 642   /* Skip over the structure size.  */
 643   descdata += 4;
 644
 645   printf_filtered (_("Mapped address spaces:\n\n"));
 646   if (gdbarch_addr_bit (gdbarch) == 64)
 647     {
 648       printf_filtered ("  %18s %18s %10s %10s %9s %s\n",
 649                        "Start Addr",
 650                        "  End Addr",
 651                        "      Size", "    Offset", "Flags  ", "File");
 652     }
 653   else
 654     {
 655       printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
 656                        "Start Addr",
 657                        "  End Addr",
 658                        "      Size", "    Offset", "Flags  ", "File");
 659     }
 660
 661   while (descdata + KVE_PATH < descend)
 662     {
 663       ULONGEST start, end, offset, flags, prot, structsize;
 664
 665       structsize = bfd_get_32 (core_bfd, descdata + KVE_STRUCTSIZE);
 666       if (structsize < KVE_PATH)
 667         error (_("malformed core note - vmmap entry too small"));
 668
 669       start = bfd_get_64 (core_bfd, descdata + KVE_START);
 670       end = bfd_get_64 (core_bfd, descdata + KVE_END);
 671       offset = bfd_get_64 (core_bfd, descdata + KVE_OFFSET);
 672       flags = bfd_get_32 (core_bfd, descdata + KVE_FLAGS);
 673       prot = bfd_get_32 (core_bfd, descdata + KVE_PROTECTION);
 674       if (gdbarch_addr_bit (gdbarch) == 64)
 675         {
 676           printf_filtered ("  %18s %18s %10s %10s %9s %s\n",
 677                            paddress (gdbarch, start),
 678                            paddress (gdbarch, end),
 679                            hex_string (end - start),
 680                            hex_string (offset),
 681                            fbsd_vm_map_entry_flags (flags, prot),
 682                            descdata + KVE_PATH);
 683         }
 684       else
 685         {
 686           printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
 687                            paddress (gdbarch, start),
 688                            paddress (gdbarch, end),
 689                            hex_string (end - start),
 690                            hex_string (offset),
 691                            fbsd_vm_map_entry_flags (flags, prot),
 692                            descdata + KVE_PATH);
 693         }
 694
 695       descdata += structsize;
 696     }
 697 }
 698
 699 /* Fetch the pathname of a vnode for a single file descriptor from the
 700    file table core note.  */
 701
 702 static gdb::unique_xmalloc_ptr<char>
 703 fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd)
 704 {
 705   asection *section;
 706   unsigned char *descdata, *descend;
 707   size_t note_size;
 708
 709   section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
 710   if (section == NULL)
 711     return nullptr;
 712
 713   note_size = bfd_get_section_size (section);
 714   if (note_size < 4)
 715     error (_("malformed core note - too short for header"));
 716
 717   gdb::def_vector<unsigned char> contents (note_size);
 718   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
 719                                  0, note_size))
 720     error (_("could not get core note contents"));
 721
 722   descdata = contents.data ();
 723   descend = descdata + note_size;
 724
 725   /* Skip over the structure size.  */
 726   descdata += 4;
 727
 728   while (descdata + KVE_PATH < descend)
 729     {
 730       ULONGEST structsize;
 731
 732       structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
 733       if (structsize < KVE_PATH)
 734         error (_("malformed core note - vmmap entry too small"));
 735
 736       if (bfd_get_32 (core_bfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE
 737           && bfd_get_signed_32 (core_bfd, descdata + KF_FD) == fd)
 738         {
 739           char *path = (char *) descdata + KF_PATH;
 740           return gdb::unique_xmalloc_ptr<char> (xstrdup (path));
 741         }
 742
 743       descdata += structsize;
 744     }
 745   return nullptr;
 746 }
 747
 748 /* Helper function to read a struct timeval.  */
 749
 750 static void
 751 fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data,
 752                          LONGEST &sec, ULONGEST &usec)
 753 {
 754   if (gdbarch_addr_bit (gdbarch) == 64)
 755     {
 756       sec = bfd_get_signed_64 (core_bfd, data);
 757       usec = bfd_get_64 (core_bfd, data + 8);
 758     }
 759   else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
 760     {
 761       sec = bfd_get_signed_32 (core_bfd, data);
 762       usec = bfd_get_32 (core_bfd, data + 4);
 763     }
 764   else
 765     {
 766       sec = bfd_get_signed_64 (core_bfd, data);
 767       usec = bfd_get_32 (core_bfd, data + 8);
 768     }
 769 }
 770
 771 /* Print out the contents of a signal set.  */
 772
 773 static void
 774 fbsd_print_sigset (const char *descr, unsigned char *sigset)
 775 {
 776   printf_filtered ("%s: ", descr);
 777   for (int i = 0; i < SIG_WORDS; i++)
 778     printf_filtered ("%08x ",
 779                      (unsigned int) bfd_get_32 (core_bfd, sigset + i * 4));
 780   printf_filtered ("\n");
 781 }
 782
 783 /* Implement "info proc status" for a corefile.  */
 784
 785 static void
 786 fbsd_core_info_proc_status (struct gdbarch *gdbarch)
 787 {
 788   const struct kinfo_proc_layout *kp;
 789   asection *section;
 790   const char *state;
 791   unsigned char *descdata;
 792   int addr_bit, long_bit;
 793   size_t note_size;
 794   ULONGEST value;
 795   LONGEST sec;
 796
 797   section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.proc");
 798   if (section == NULL)
 799     {
 800       warning (_("unable to find process info in core file"));
 801       return;
 802     }
 803
 804   addr_bit = gdbarch_addr_bit (gdbarch);
 805   if (addr_bit == 64)
 806     kp = &kinfo_proc_layout_64;
 807   else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
 808     kp = &kinfo_proc_layout_i386;
 809   else
 810     kp = &kinfo_proc_layout_32;
 811   long_bit = gdbarch_long_bit (gdbarch);
 812
 813   /*
 814    * Ensure that the note is large enough for all of the fields fetched
 815    * by this function.  In particular, the note must contain the 32-bit
 816    * structure size, then it must be long enough to access the last
 817    * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
 818    */
 819   note_size = bfd_get_section_size (section);
 820   if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt
 821                    + long_bit / TARGET_CHAR_BIT))
 822     error (_("malformed core note - too short"));
 823
 824   gdb::def_vector<unsigned char> contents (note_size);
 825   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
 826                                  0, note_size))
 827     error (_("could not get core note contents"));
 828
 829   descdata = contents.data ();
 830
 831   /* Skip over the structure size.  */
 832   descdata += 4;
 833
 834   /* Verify 'ki_layout' is 0.  */
 835   if (bfd_get_32 (core_bfd, descdata + kp->ki_layout) != 0)
 836     {
 837       warning (_("unsupported process information in core file"));
 838       return;
 839     }
 840
 841   printf_filtered ("Name: %.19s\n", descdata + kp->ki_comm);
 842   printf_filtered ("Process ID: %s\n",
 843                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pid)));
 844   printf_filtered ("Parent process: %s\n",
 845                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ppid)));
 846   printf_filtered ("Process group: %s\n",
 847                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pgid)));
 848   printf_filtered ("Session id: %s\n",
 849                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_sid)));
 850
 851   /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'.  Older
 852      kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'.  In older
 853      kernels the 64-bit 'ki_tdev' field is in a reserved section of
 854      the structure that is cleared to zero.  Assume that a zero value
 855      in ki_tdev indicates a core dump from an older kernel and use the
 856      value in 'ki_tdev_freebsd11' instead.  */
 857   value = bfd_get_64 (core_bfd, descdata + kp->ki_tdev);
 858   if (value == 0)
 859     value = bfd_get_32 (core_bfd, descdata + kp->ki_tdev_freebsd11);
 860   printf_filtered ("TTY: %s\n", pulongest (value));
 861   printf_filtered ("TTY owner process group: %s\n",
 862                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_tpgid)));
 863   printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
 864                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ruid)),
 865                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_uid)),
 866                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svuid)));
 867   printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
 868                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_rgid)),
 869                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_groups)),
 870                    pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svgid)));
 871   printf_filtered ("Groups: ");
 872   uint16_t ngroups = bfd_get_16 (core_bfd, descdata + kp->ki_ngroups);
 873   for (int i = 0; i < ngroups; i++)
 874     printf_filtered ("%s ",
 875                      pulongest (bfd_get_32 (core_bfd,
 876                                             descdata + kp->ki_groups + i * 4)));
 877   printf_filtered ("\n");
 878   value = bfd_get (long_bit, core_bfd,
 879                    descdata + kp->ki_rusage + kp->ru_minflt);
 880   printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value));
 881   value = bfd_get (long_bit, core_bfd,
 882                    descdata + kp->ki_rusage_ch + kp->ru_minflt);
 883   printf_filtered ("Minor faults, children: %s\n", pulongest (value));
 884   value = bfd_get (long_bit, core_bfd,
 885                    descdata + kp->ki_rusage + kp->ru_majflt);
 886   printf_filtered ("Major faults (memory page faults): %s\n",
 887                    pulongest (value));
 888   value = bfd_get (long_bit, core_bfd,
 889                    descdata + kp->ki_rusage_ch + kp->ru_majflt);
 890   printf_filtered ("Major faults, children: %s\n", pulongest (value));
 891   fbsd_core_fetch_timeval (gdbarch,
 892                            descdata + kp->ki_rusage + kp->ru_utime,
 893                            sec, value);
 894   printf_filtered ("utime: %s.%06d\n", plongest (sec), (int) value);
 895   fbsd_core_fetch_timeval (gdbarch,
 896                            descdata + kp->ki_rusage + kp->ru_stime,
 897                            sec, value);
 898   printf_filtered ("stime: %s.%06d\n", plongest (sec), (int) value);
 899   fbsd_core_fetch_timeval (gdbarch,
 900                            descdata + kp->ki_rusage_ch + kp->ru_utime,
 901                            sec, value);
 902   printf_filtered ("utime, children: %s.%06d\n", plongest (sec), (int) value);
 903   fbsd_core_fetch_timeval (gdbarch,
 904                            descdata + kp->ki_rusage_ch + kp->ru_stime,
 905                            sec, value);
 906   printf_filtered ("stime, children: %s.%06d\n", plongest (sec), (int) value);
 907   printf_filtered ("'nice' value: %d\n",
 908                    bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice));
 909   fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value);
 910   printf_filtered ("Start time: %s.%06d\n", plongest (sec), (int) value);
 911   printf_filtered ("Virtual memory size: %s kB\n",
 912                    pulongest (bfd_get (addr_bit, core_bfd,
 913                                        descdata + kp->ki_size) / 1024));
 914   printf_filtered ("Data size: %s pages\n",
 915                    pulongest (bfd_get (addr_bit, core_bfd,
 916                                        descdata + kp->ki_dsize)));
 917   printf_filtered ("Stack size: %s pages\n",
 918                    pulongest (bfd_get (addr_bit, core_bfd,
 919                                        descdata + kp->ki_ssize)));
 920   printf_filtered ("Text size: %s pages\n",
 921                    pulongest (bfd_get (addr_bit, core_bfd,
 922                                        descdata + kp->ki_tsize)));
 923   printf_filtered ("Resident set size: %s pages\n",
 924                    pulongest (bfd_get (addr_bit, core_bfd,
 925                                        descdata + kp->ki_rssize)));
 926   printf_filtered ("Maximum RSS: %s pages\n",
 927                    pulongest (bfd_get (long_bit, core_bfd,
 928                                        descdata + kp->ki_rusage
 929                                        + kp->ru_maxrss)));
 930   fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore);
 931   fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch);
 932 }
 933
 934 /* Implement the "core_info_proc" gdbarch method.  */
 935
 936 static void
 937 fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args,
 938                      enum info_proc_what what)
 939 {
 940   bool do_cmdline = false;
 941   bool do_cwd = false;
 942   bool do_exe = false;
 943   bool do_mappings = false;
 944   bool do_status = false;
 945   int pid;
 946
 947   switch (what)
 948     {
 949     case IP_MINIMAL:
 950       do_cmdline = true;
 951       do_cwd = true;
 952       do_exe = true;
 953       break;
 954     case IP_MAPPINGS:
 955       do_mappings = true;
 956       break;
 957     case IP_STATUS:
 958     case IP_STAT:
 959       do_status = true;
 960       break;
 961     case IP_CMDLINE:
 962       do_cmdline = true;
 963       break;
 964     case IP_EXE:
 965       do_exe = true;
 966       break;
 967     case IP_CWD:
 968       do_cwd = true;
 969       break;
 970     case IP_ALL:
 971       do_cmdline = true;
 972       do_cwd = true;
 973       do_exe = true;
 974       do_mappings = true;
 975       do_status = true;
 976       break;
 977     default:
 978       return;
 979     }
 980
 981   pid = bfd_core_file_pid (core_bfd);
 982   if (pid != 0)
 983     printf_filtered (_("process %d\n"), pid);
 984
 985   if (do_cmdline)
 986     {
 987       const char *cmdline;
 988
 989       cmdline = bfd_core_file_failing_command (core_bfd);
 990       if (cmdline)
 991         printf_filtered ("cmdline = '%s'\n", cmdline);
 992       else
 993         warning (_("Command line unavailable"));
 994     }
 995   if (do_cwd)
 996     {
 997       gdb::unique_xmalloc_ptr<char> cwd =
 998         fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD);
 999       if (cwd)
1000         printf_filtered ("cwd = '%s'\n", cwd.get ());
1001       else
1002         warning (_("unable to read current working directory"));
1003     }
1004   if (do_exe)
1005     {
1006       gdb::unique_xmalloc_ptr<char> exe =
1007         fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT);
1008       if (exe)
1009         printf_filtered ("exe = '%s'\n", exe.get ());
1010       else
1011         warning (_("unable to read executable path name"));
1012     }
1013   if (do_mappings)
1014     fbsd_core_info_proc_mappings (gdbarch);
1015   if (do_status)
1016     fbsd_core_info_proc_status (gdbarch);
1017 }
1018
1019 /* Print descriptions of FreeBSD-specific AUXV entries to FILE.  */
1020
1021 static void
1022 fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
1023                        CORE_ADDR type, CORE_ADDR val)
1024 {
1025   const char *name;
1026   const char *description;
1027   enum auxv_format format;
1028
1029   switch (type)
1030     {
1031 #define _TAGNAME(tag) #tag
1032 #define TAGNAME(tag) _TAGNAME(AT_##tag)
1033 #define TAG(tag, text, kind) \
1034       case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1035       TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
1036       TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
1037       TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
1038       TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
1039       TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
1040       TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
1041       TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
1042       TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
1043       TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
1044       TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX);
1045       TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX);
1046     default:
1047       default_print_auxv_entry (gdbarch, file, type, val);
1048       return;
1049     }
1050
1051   fprint_auxv_entry (file, name, description, format, type, val);
1052 }
1053
1054 /* Implement the "get_siginfo_type" gdbarch method.  */
1055
1056 static struct type *
1057 fbsd_get_siginfo_type (struct gdbarch *gdbarch)
1058 {
1059   struct fbsd_gdbarch_data *fbsd_gdbarch_data;
1060   struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
1061   struct type *uid_type, *pid_type;
1062   struct type *sigval_type, *reason_type;
1063   struct type *siginfo_type;
1064   struct type *type;
1065
1066   fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
1067   if (fbsd_gdbarch_data->siginfo_type != NULL)
1068     return fbsd_gdbarch_data->siginfo_type;
1069
1070   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
1071                                 0, "int");
1072   int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
1073   uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1074   long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
1075                                  0, "long");
1076   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
1077
1078   /* union sigval */
1079   sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1080   TYPE_NAME (sigval_type) = xstrdup ("sigval");
1081   append_composite_type_field (sigval_type, "sival_int", int_type);
1082   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
1083
1084   /* __pid_t */
1085   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1086                         TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
1087   TYPE_TARGET_TYPE (pid_type) = int32_type;
1088   TYPE_TARGET_STUB (pid_type) = 1;
1089
1090   /* __uid_t */
1091   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1092                         TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
1093                         "__uid_t");
1094   TYPE_TARGET_TYPE (uid_type) = uint32_type;
1095   TYPE_TARGET_STUB (uid_type) = 1;
1096
1097   /* _reason */
1098   reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1099
1100   /* _fault */
1101   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1102   append_composite_type_field (type, "si_trapno", int_type);
1103   append_composite_type_field (reason_type, "_fault", type);
1104
1105   /* _timer */
1106   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1107   append_composite_type_field (type, "si_timerid", int_type);
1108   append_composite_type_field (type, "si_overrun", int_type);
1109   append_composite_type_field (reason_type, "_timer", type);
1110
1111   /* _mesgq */
1112   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1113   append_composite_type_field (type, "si_mqd", int_type);
1114   append_composite_type_field (reason_type, "_mesgq", type);
1115
1116   /* _poll */
1117   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1118   append_composite_type_field (type, "si_band", long_type);
1119   append_composite_type_field (reason_type, "_poll", type);
1120
1121   /* __spare__ */
1122   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1123   append_composite_type_field (type, "__spare1__", long_type);
1124   append_composite_type_field (type, "__spare2__",
1125                                init_vector_type (int_type, 7));
1126   append_composite_type_field (reason_type, "__spare__", type);
1127
1128   /* struct siginfo */
1129   siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1130   TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
1131   append_composite_type_field (siginfo_type, "si_signo", int_type);
1132   append_composite_type_field (siginfo_type, "si_errno", int_type);
1133   append_composite_type_field (siginfo_type, "si_code", int_type);
1134   append_composite_type_field (siginfo_type, "si_pid", pid_type);
1135   append_composite_type_field (siginfo_type, "si_uid", uid_type);
1136   append_composite_type_field (siginfo_type, "si_status", int_type);
1137   append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
1138   append_composite_type_field (siginfo_type, "si_value", sigval_type);
1139   append_composite_type_field (siginfo_type, "_reason", reason_type);
1140
1141   fbsd_gdbarch_data->siginfo_type = siginfo_type;
1142
1143   return siginfo_type;
1144 }
1145
1146 /* Implement the "get_syscall_number" gdbarch method.  */
1147
1148 static LONGEST
1149 fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
1150 {
1151
1152   /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1153      native targets fetch the system call number from the
1154      'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1155      However, system call catching requires this function to be
1156      set.  */
1157
1158   internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
1159 }
1160
1161 /* To be called from GDB_OSABI_FREEBSD handlers. */
1162
1163 void
1164 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1165 {
1166   set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
1167   set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
1168   set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
1169   set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
1170   set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc);
1171   set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
1172   set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
1173
1174   /* `catch syscall' */
1175   set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
1176   set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
1177 }
1178
1179 void
1180 _initialize_fbsd_tdep (void)
1181 {
1182   fbsd_gdbarch_data_handle =
1183     gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
1184 }