gdb/netbsd-tdep.c

   1 /* Common target-dependent code for NetBSD systems.
   2
   3    Copyright (C) 2002-2022 Free Software Foundation, Inc.
   4
   5    Contributed by Wasabi Systems, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "auxv.h"
  24 #include "solib-svr4.h"
  25 #include "netbsd-tdep.h"
  26 #include "gdbarch.h"
  27 #include "objfiles.h"
  28 #include "xml-syscall.h"
  29
  30 /* Flags in the 'kve_protection' field in struct kinfo_vmentry.  These
  31    match the KVME_PROT_* constants in <sys/sysctl.h>.  */
  32
  33 #define KINFO_VME_PROT_READ     0x00000001
  34 #define KINFO_VME_PROT_WRITE    0x00000002
  35 #define KINFO_VME_PROT_EXEC     0x00000004
  36
  37 /* Flags in the 'kve_flags' field in struct kinfo_vmentry.  These
  38    match the KVME_FLAG_* constants in <sys/sysctl.h>.  */
  39
  40 #define KINFO_VME_FLAG_COW              0x00000001
  41 #define KINFO_VME_FLAG_NEEDS_COPY       0x00000002
  42 #define KINFO_VME_FLAG_NOCOREDUMP       0x00000004
  43 #define KINFO_VME_FLAG_PAGEABLE         0x00000008
  44 #define KINFO_VME_FLAG_GROWS_UP         0x00000010
  45 #define KINFO_VME_FLAG_GROWS_DOWN       0x00000020
  46
  47 /* FIXME: kettenis/20060115: We should really eliminate the next two
  48    functions completely.  */
  49
  50 struct link_map_offsets *
  51 nbsd_ilp32_solib_svr4_fetch_link_map_offsets (void)
  52 {
  53   return svr4_ilp32_fetch_link_map_offsets ();
  54 }
  55
  56 struct link_map_offsets *
  57 nbsd_lp64_solib_svr4_fetch_link_map_offsets (void)
  58 {
  59   return svr4_lp64_fetch_link_map_offsets ();
  60 }
  61
  62 int
  63 nbsd_pc_in_sigtramp (CORE_ADDR pc, const char *func_name)
  64 {
  65   /* Check for libc-provided signal trampoline.  All such trampolines
  66      have function names which begin with "__sigtramp".  */
  67
  68   return (func_name != NULL
  69           && startswith (func_name, "__sigtramp"));
  70 }
  71
  72 /* This enum is derived from NETBSD's <sys/signal.h>.  */
  73
  74 enum
  75   {
  76    NBSD_SIGHUP = 1,
  77    NBSD_SIGINT = 2,
  78    NBSD_SIGQUIT = 3,
  79    NBSD_SIGILL = 4,
  80    NBSD_SIGTRAP = 5,
  81    NBSD_SIGABRT = 6,
  82    NBSD_SIGEMT = 7,
  83    NBSD_SIGFPE = 8,
  84    NBSD_SIGKILL = 9,
  85    NBSD_SIGBUS = 10,
  86    NBSD_SIGSEGV = 11,
  87    NBSD_SIGSYS = 12,
  88    NBSD_SIGPIPE = 13,
  89    NBSD_SIGALRM = 14,
  90    NBSD_SIGTERM = 15,
  91    NBSD_SIGURG = 16,
  92    NBSD_SIGSTOP = 17,
  93    NBSD_SIGTSTP = 18,
  94    NBSD_SIGCONT = 19,
  95    NBSD_SIGCHLD = 20,
  96    NBSD_SIGTTIN = 21,
  97    NBSD_SIGTTOU = 22,
  98    NBSD_SIGIO = 23,
  99    NBSD_SIGXCPU = 24,
 100    NBSD_SIGXFSZ = 25,
 101    NBSD_SIGVTALRM = 26,
 102    NBSD_SIGPROF = 27,
 103    NBSD_SIGWINCH = 28,
 104    NBSD_SIGINFO = 29,
 105    NBSD_SIGUSR1 = 30,
 106    NBSD_SIGUSR2 = 31,
 107    NBSD_SIGPWR = 32,
 108    NBSD_SIGRTMIN = 33,
 109    NBSD_SIGRTMAX = 63,
 110   };
 111
 112 /* Implement the "gdb_signal_from_target" gdbarch method.  */
 113
 114 static enum gdb_signal
 115 nbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
 116 {
 117   switch (signal)
 118     {
 119     case 0:
 120       return GDB_SIGNAL_0;
 121
 122     case NBSD_SIGHUP:
 123       return GDB_SIGNAL_HUP;
 124
 125     case NBSD_SIGINT:
 126       return GDB_SIGNAL_INT;
 127
 128     case NBSD_SIGQUIT:
 129       return GDB_SIGNAL_QUIT;
 130
 131     case NBSD_SIGILL:
 132       return GDB_SIGNAL_ILL;
 133
 134     case NBSD_SIGTRAP:
 135       return GDB_SIGNAL_TRAP;
 136
 137     case NBSD_SIGABRT:
 138       return GDB_SIGNAL_ABRT;
 139
 140     case NBSD_SIGEMT:
 141       return GDB_SIGNAL_EMT;
 142
 143     case NBSD_SIGFPE:
 144       return GDB_SIGNAL_FPE;
 145
 146     case NBSD_SIGKILL:
 147       return GDB_SIGNAL_KILL;
 148
 149     case NBSD_SIGBUS:
 150       return GDB_SIGNAL_BUS;
 151
 152     case NBSD_SIGSEGV:
 153       return GDB_SIGNAL_SEGV;
 154
 155     case NBSD_SIGSYS:
 156       return GDB_SIGNAL_SYS;
 157
 158     case NBSD_SIGPIPE:
 159       return GDB_SIGNAL_PIPE;
 160
 161     case NBSD_SIGALRM:
 162       return GDB_SIGNAL_ALRM;
 163
 164     case NBSD_SIGTERM:
 165       return GDB_SIGNAL_TERM;
 166
 167     case NBSD_SIGURG:
 168       return GDB_SIGNAL_URG;
 169
 170     case NBSD_SIGSTOP:
 171       return GDB_SIGNAL_STOP;
 172
 173     case NBSD_SIGTSTP:
 174       return GDB_SIGNAL_TSTP;
 175
 176     case NBSD_SIGCONT:
 177       return GDB_SIGNAL_CONT;
 178
 179     case NBSD_SIGCHLD:
 180       return GDB_SIGNAL_CHLD;
 181
 182     case NBSD_SIGTTIN:
 183       return GDB_SIGNAL_TTIN;
 184
 185     case NBSD_SIGTTOU:
 186       return GDB_SIGNAL_TTOU;
 187
 188     case NBSD_SIGIO:
 189       return GDB_SIGNAL_IO;
 190
 191     case NBSD_SIGXCPU:
 192       return GDB_SIGNAL_XCPU;
 193
 194     case NBSD_SIGXFSZ:
 195       return GDB_SIGNAL_XFSZ;
 196
 197     case NBSD_SIGVTALRM:
 198       return GDB_SIGNAL_VTALRM;
 199
 200     case NBSD_SIGPROF:
 201       return GDB_SIGNAL_PROF;
 202
 203     case NBSD_SIGWINCH:
 204       return GDB_SIGNAL_WINCH;
 205
 206     case NBSD_SIGINFO:
 207       return GDB_SIGNAL_INFO;
 208
 209     case NBSD_SIGUSR1:
 210       return GDB_SIGNAL_USR1;
 211
 212     case NBSD_SIGUSR2:
 213       return GDB_SIGNAL_USR2;
 214
 215     case NBSD_SIGPWR:
 216       return GDB_SIGNAL_PWR;
 217
 218     /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
 219        therefore we have to handle them here.  */
 220     case NBSD_SIGRTMIN:
 221       return GDB_SIGNAL_REALTIME_33;
 222
 223     case NBSD_SIGRTMAX:
 224       return GDB_SIGNAL_REALTIME_63;
 225     }
 226
 227   if (signal >= NBSD_SIGRTMIN + 1 && signal <= NBSD_SIGRTMAX - 1)
 228     {
 229       int offset = signal - NBSD_SIGRTMIN + 1;
 230
 231       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_34 + offset);
 232     }
 233
 234   return GDB_SIGNAL_UNKNOWN;
 235 }
 236
 237 /* Implement the "gdb_signal_to_target" gdbarch method.  */
 238
 239 static int
 240 nbsd_gdb_signal_to_target (struct gdbarch *gdbarch,
 241                 enum gdb_signal signal)
 242 {
 243   switch (signal)
 244     {
 245     case GDB_SIGNAL_0:
 246       return 0;
 247
 248     case GDB_SIGNAL_HUP:
 249       return NBSD_SIGHUP;
 250
 251     case GDB_SIGNAL_INT:
 252       return NBSD_SIGINT;
 253
 254     case GDB_SIGNAL_QUIT:
 255       return NBSD_SIGQUIT;
 256
 257     case GDB_SIGNAL_ILL:
 258       return NBSD_SIGILL;
 259
 260     case GDB_SIGNAL_TRAP:
 261       return NBSD_SIGTRAP;
 262
 263     case GDB_SIGNAL_ABRT:
 264       return NBSD_SIGABRT;
 265
 266     case GDB_SIGNAL_EMT:
 267       return NBSD_SIGEMT;
 268
 269     case GDB_SIGNAL_FPE:
 270       return NBSD_SIGFPE;
 271
 272     case GDB_SIGNAL_KILL:
 273       return NBSD_SIGKILL;
 274
 275     case GDB_SIGNAL_BUS:
 276       return NBSD_SIGBUS;
 277
 278     case GDB_SIGNAL_SEGV:
 279       return NBSD_SIGSEGV;
 280
 281     case GDB_SIGNAL_SYS:
 282       return NBSD_SIGSYS;
 283
 284     case GDB_SIGNAL_PIPE:
 285       return NBSD_SIGPIPE;
 286
 287     case GDB_SIGNAL_ALRM:
 288       return NBSD_SIGALRM;
 289
 290     case GDB_SIGNAL_TERM:
 291       return NBSD_SIGTERM;
 292
 293     case GDB_SIGNAL_URG:
 294       return NBSD_SIGSTOP;
 295
 296     case GDB_SIGNAL_TSTP:
 297       return NBSD_SIGTSTP;
 298
 299     case GDB_SIGNAL_CONT:
 300       return NBSD_SIGCONT;
 301
 302     case GDB_SIGNAL_CHLD:
 303       return NBSD_SIGCHLD;
 304
 305     case GDB_SIGNAL_TTIN:
 306       return NBSD_SIGTTIN;
 307
 308     case GDB_SIGNAL_TTOU:
 309       return NBSD_SIGTTOU;
 310
 311     case GDB_SIGNAL_IO:
 312       return NBSD_SIGIO;
 313
 314     case GDB_SIGNAL_XCPU:
 315       return NBSD_SIGXCPU;
 316
 317     case GDB_SIGNAL_XFSZ:
 318       return NBSD_SIGXFSZ;
 319
 320     case GDB_SIGNAL_VTALRM:
 321       return NBSD_SIGVTALRM;
 322
 323     case GDB_SIGNAL_PROF:
 324       return NBSD_SIGPROF;
 325
 326     case GDB_SIGNAL_WINCH:
 327       return NBSD_SIGWINCH;
 328
 329     case GDB_SIGNAL_INFO:
 330       return NBSD_SIGINFO;
 331
 332     case GDB_SIGNAL_USR1:
 333       return NBSD_SIGUSR1;
 334
 335     case GDB_SIGNAL_USR2:
 336       return NBSD_SIGUSR2;
 337
 338     case GDB_SIGNAL_PWR:
 339       return NBSD_SIGPWR;
 340
 341     /* GDB_SIGNAL_REALTIME_33 is not continuous in <gdb/signals.def>,
 342        therefore we have to handle it here.  */
 343     case GDB_SIGNAL_REALTIME_33:
 344       return NBSD_SIGRTMIN;
 345
 346     /* Same comment applies to _64.  */
 347     case GDB_SIGNAL_REALTIME_63:
 348       return NBSD_SIGRTMAX;
 349     }
 350
 351   if (signal >= GDB_SIGNAL_REALTIME_34
 352       && signal <= GDB_SIGNAL_REALTIME_62)
 353     {
 354       int offset = signal - GDB_SIGNAL_REALTIME_32;
 355
 356       return NBSD_SIGRTMIN + 1 + offset;
 357     }
 358
 359   return -1;
 360 }
 361
 362 /* Shared library resolver handling.  */
 363
 364 static CORE_ADDR
 365 nbsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
 366 {
 367   struct bound_minimal_symbol msym;
 368
 369   msym = lookup_minimal_symbol ("_rtld_bind_start", NULL, NULL);
 370   if (msym.minsym && BMSYMBOL_VALUE_ADDRESS (msym) == pc)
 371     return frame_unwind_caller_pc (get_current_frame ());
 372   else
 373     return find_solib_trampoline_target (get_current_frame (), pc);
 374 }
 375
 376 static struct gdbarch_data *nbsd_gdbarch_data_handle;
 377
 378 struct nbsd_gdbarch_data
 379 {
 380   struct type *siginfo_type;
 381 };
 382
 383 static void *
 384 init_nbsd_gdbarch_data (struct gdbarch *gdbarch)
 385 {
 386   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct nbsd_gdbarch_data);
 387 }
 388
 389 static struct nbsd_gdbarch_data *
 390 get_nbsd_gdbarch_data (struct gdbarch *gdbarch)
 391 {
 392   return ((struct nbsd_gdbarch_data *)
 393           gdbarch_data (gdbarch, nbsd_gdbarch_data_handle));
 394 }
 395
 396 /* Implement the "get_siginfo_type" gdbarch method.  */
 397
 398 static struct type *
 399 nbsd_get_siginfo_type (struct gdbarch *gdbarch)
 400 {
 401   nbsd_gdbarch_data *nbsd_gdbarch_data = get_nbsd_gdbarch_data (gdbarch);
 402   if (nbsd_gdbarch_data->siginfo_type != NULL)
 403     return nbsd_gdbarch_data->siginfo_type;
 404
 405   type *char_type = builtin_type (gdbarch)->builtin_char;
 406   type *int_type = builtin_type (gdbarch)->builtin_int;
 407   type *long_type = builtin_type (gdbarch)->builtin_long;
 408
 409   type *void_ptr_type
 410     = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
 411
 412   type *int32_type = builtin_type (gdbarch)->builtin_int32;
 413   type *uint32_type = builtin_type (gdbarch)->builtin_uint32;
 414   type *uint64_type = builtin_type (gdbarch)->builtin_uint64;
 415
 416   bool lp64 = TYPE_LENGTH (void_ptr_type) == 8;
 417   size_t char_bits = gdbarch_addressable_memory_unit_size (gdbarch) * 8;
 418
 419   /* pid_t */
 420   type *pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 421                               TYPE_LENGTH (int32_type) * char_bits, "pid_t");
 422   TYPE_TARGET_TYPE (pid_type) = int32_type;
 423
 424   /* uid_t */
 425   type *uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 426                               TYPE_LENGTH (uint32_type) * char_bits, "uid_t");
 427   TYPE_TARGET_TYPE (uid_type) = uint32_type;
 428
 429   /* clock_t */
 430   type *clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 431                                 TYPE_LENGTH (int_type) * char_bits, "clock_t");
 432   TYPE_TARGET_TYPE (clock_type) = int_type;
 433
 434   /* lwpid_t */
 435   type *lwpid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 436                                 TYPE_LENGTH (int32_type) * char_bits,
 437                                 "lwpid_t");
 438   TYPE_TARGET_TYPE (lwpid_type) = int32_type;
 439
 440   /* union sigval */
 441   type *sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 442   sigval_type->set_name (gdbarch_obstack_strdup (gdbarch, "sigval"));
 443   append_composite_type_field (sigval_type, "sival_int", int_type);
 444   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
 445
 446   /* union _option */
 447   type *option_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 448   option_type->set_name (gdbarch_obstack_strdup (gdbarch, "_option"));
 449   append_composite_type_field (option_type, "_pe_other_pid", pid_type);
 450   append_composite_type_field (option_type, "_pe_lwp", lwpid_type);
 451
 452   /* union _reason */
 453   type *reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 454
 455   /* _rt */
 456   type *t = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 457   append_composite_type_field (t, "_pid", pid_type);
 458   append_composite_type_field (t, "_uid", uid_type);
 459   append_composite_type_field (t, "_value", sigval_type);
 460   append_composite_type_field (reason_type, "_rt", t);
 461
 462   /* _child */
 463   t = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 464   append_composite_type_field (t, "_pid", pid_type);
 465   append_composite_type_field (t, "_uid", uid_type);
 466   append_composite_type_field (t, "_status", int_type);
 467   append_composite_type_field (t, "_utime", clock_type);
 468   append_composite_type_field (t, "_stime", clock_type);
 469   append_composite_type_field (reason_type, "_child", t);
 470
 471   /* _fault */
 472   t = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 473   append_composite_type_field (t, "_addr", void_ptr_type);
 474   append_composite_type_field (t, "_trap", int_type);
 475   append_composite_type_field (t, "_trap2", int_type);
 476   append_composite_type_field (t, "_trap3", int_type);
 477   append_composite_type_field (reason_type, "_fault", t);
 478
 479   /* _poll */
 480   t = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 481   append_composite_type_field (t, "_band", long_type);
 482   append_composite_type_field (t, "_fd", int_type);
 483   append_composite_type_field (reason_type, "_poll", t);
 484
 485   /* _syscall */
 486   t = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 487   append_composite_type_field (t, "_sysnum", int_type);
 488   append_composite_type_field (t, "_retval",
 489                                init_vector_type (int_type, 2));
 490   append_composite_type_field (t, "_error", int_type);
 491   append_composite_type_field (t, "_args",
 492                                init_vector_type (uint64_type, 8));
 493   append_composite_type_field (reason_type, "_syscall", t);
 494
 495   /* _ptrace_state */
 496   t = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 497   append_composite_type_field (t, "_pe_report_event", int_type);
 498   append_composite_type_field (t, "_option", option_type);
 499   append_composite_type_field (reason_type, "_ptrace_state", t);
 500
 501   /* struct _ksiginfo */
 502   type *ksiginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 503   ksiginfo_type->set_name (gdbarch_obstack_strdup (gdbarch, "_ksiginfo"));
 504   append_composite_type_field (ksiginfo_type, "_signo", int_type);
 505   append_composite_type_field (ksiginfo_type, "_code", int_type);
 506   append_composite_type_field (ksiginfo_type, "_errno", int_type);
 507   if (lp64)
 508     append_composite_type_field (ksiginfo_type, "_pad", int_type);
 509   append_composite_type_field (ksiginfo_type, "_reason", reason_type);
 510
 511   /* union siginfo */
 512   type *siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 513   siginfo_type->set_name (gdbarch_obstack_strdup (gdbarch, "siginfo"));
 514   append_composite_type_field (siginfo_type, "si_pad",
 515                                init_vector_type (char_type, 128));
 516   append_composite_type_field (siginfo_type, "_info", ksiginfo_type);
 517
 518   nbsd_gdbarch_data->siginfo_type = siginfo_type;
 519
 520   return siginfo_type;
 521 }
 522
 523 /* See netbsd-tdep.h.  */
 524
 525 void
 526 nbsd_info_proc_mappings_header (int addr_bit)
 527 {
 528   gdb_printf (_("Mapped address spaces:\n\n"));
 529   if (addr_bit == 64)
 530     {
 531       gdb_printf ("  %18s %18s %10s %10s %9s %s\n",
 532                   "Start Addr",
 533                   "  End Addr",
 534                   "      Size", "    Offset", "Flags  ", "File");
 535     }
 536   else
 537     {
 538       gdb_printf ("\t%10s %10s %10s %10s %9s %s\n",
 539                   "Start Addr",
 540                   "  End Addr",
 541                   "      Size", "    Offset", "Flags  ", "File");
 542     }
 543 }
 544
 545 /* Helper function to generate mappings flags for a single VM map
 546    entry in 'info proc mappings'.  */
 547
 548 static const char *
 549 nbsd_vm_map_entry_flags (int kve_flags, int kve_protection)
 550 {
 551   static char vm_flags[9];
 552
 553   vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-';
 554   vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-';
 555   vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-';
 556   vm_flags[3] = ' ';
 557   vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-';
 558   vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-';
 559   vm_flags[6] = (kve_flags & KINFO_VME_FLAG_PAGEABLE) ? 'P' : '-';
 560   vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U'
 561     : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-';
 562   vm_flags[8] = '\0';
 563
 564   return vm_flags;
 565 }
 566
 567 void
 568 nbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start,
 569                                ULONGEST kve_end, ULONGEST kve_offset,
 570                                int kve_flags, int kve_protection,
 571                                const char *kve_path)
 572 {
 573   if (addr_bit == 64)
 574     {
 575       gdb_printf ("  %18s %18s %10s %10s %9s %s\n",
 576                   hex_string (kve_start),
 577                   hex_string (kve_end),
 578                   hex_string (kve_end - kve_start),
 579                   hex_string (kve_offset),
 580                   nbsd_vm_map_entry_flags (kve_flags, kve_protection),
 581                   kve_path);
 582     }
 583   else
 584     {
 585       gdb_printf ("\t%10s %10s %10s %10s %9s %s\n",
 586                   hex_string (kve_start),
 587                   hex_string (kve_end),
 588                   hex_string (kve_end - kve_start),
 589                   hex_string (kve_offset),
 590                   nbsd_vm_map_entry_flags (kve_flags, kve_protection),
 591                   kve_path);
 592     }
 593 }
 594
 595 /* Implement the "get_syscall_number" gdbarch method.  */
 596
 597 static LONGEST
 598 nbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
 599 {
 600
 601   /* NetBSD doesn't use gdbarch_get_syscall_number since NetBSD
 602      native targets fetch the system call number from the
 603      'si_sysnum' member of siginfo_t in nbsd_nat_target::wait.
 604      However, system call catching requires this function to be
 605      set.  */
 606
 607   internal_error (__FILE__, __LINE__, _("nbsd_get_sycall_number called"));
 608 }
 609
 610 /* See netbsd-tdep.h.  */
 611
 612 void
 613 nbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 614 {
 615   set_gdbarch_gdb_signal_from_target (gdbarch, nbsd_gdb_signal_from_target);
 616   set_gdbarch_gdb_signal_to_target (gdbarch, nbsd_gdb_signal_to_target);
 617   set_gdbarch_skip_solib_resolver (gdbarch, nbsd_skip_solib_resolver);
 618   set_gdbarch_auxv_parse (gdbarch, svr4_auxv_parse);
 619   set_gdbarch_get_siginfo_type (gdbarch, nbsd_get_siginfo_type);
 620
 621   /* `catch syscall' */
 622   set_xml_syscall_file_name (gdbarch, "syscalls/netbsd.xml");
 623   set_gdbarch_get_syscall_number (gdbarch, nbsd_get_syscall_number);
 624 }
 625
 626 void _initialize_nbsd_tdep ();
 627 void
 628 _initialize_nbsd_tdep ()
 629 {
 630   nbsd_gdbarch_data_handle
 631     = gdbarch_data_register_post_init (init_nbsd_gdbarch_data);
 632 }