gdb/ns32k-tdep.c

   1 /* Target dependent code for the NS32000, for GDB.
   2    Copyright 1986, 1988, 1991, 1992, 1994, 1995, 1998, 1999, 2000, 2001,
   3    2002, 2003 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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "gdbtypes.h"
  25 #include "gdbcore.h"
  26 #include "inferior.h"
  27 #include "regcache.h"
  28 #include "target.h"
  29 #include "arch-utils.h"
  30 #include "osabi.h"
  31
  32 #include "ns32k-tdep.h"
  33 #include "gdb_string.h"
  34
  35 static int sign_extend (int value, int bits);
  36 static CORE_ADDR ns32k_get_enter_addr (CORE_ADDR);
  37 static int ns32k_localcount (CORE_ADDR enter_pc);
  38 static void flip_bytes (void *, int);
  39
  40 static const char *
  41 ns32k_register_name_32082 (int regno)
  42 {
  43   static char *register_names[] =
  44   {
  45     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  46     "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
  47     "sp", "fp", "pc", "ps",
  48     "l0", "l1", "l2", "l3", "xx",
  49   };
  50
  51   if (regno < 0)
  52     return NULL;
  53   if (regno >= sizeof (register_names) / sizeof (*register_names))
  54     return NULL;
  55
  56   return (register_names[regno]);
  57 }
  58
  59 static const char *
  60 ns32k_register_name_32382 (int regno)
  61 {
  62   static char *register_names[] =
  63   {
  64     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  65     "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
  66     "sp", "fp", "pc", "ps",
  67     "fsr",
  68     "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", "xx",
  69   };
  70
  71   if (regno < 0)
  72     return NULL;
  73   if (regno >= sizeof (register_names) / sizeof (*register_names))
  74     return NULL;
  75
  76   return (register_names[regno]);
  77 }
  78
  79 static int
  80 ns32k_register_byte_32082 (int regno)
  81 {
  82   if (regno >= NS32K_LP0_REGNUM)
  83     return (NS32K_LP0_REGNUM * 4) + ((regno - NS32K_LP0_REGNUM) * 8);
  84
  85   return (regno * 4);
  86 }
  87
  88 static int
  89 ns32k_register_byte_32382 (int regno)
  90 {
  91   /* This is a bit yuk.  The even numbered double precision floating
  92      point long registers occupy the same space as the even:odd numbered
  93      single precision floating point registers, but the extra 32381 FPU
  94      registers are at the end.  Doing it this way is compatible for both
  95      32081 and 32381 equipped machines.  */
  96
  97   return ((regno < NS32K_LP0_REGNUM ? regno
  98            : (regno - NS32K_LP0_REGNUM) & 1 ? regno - 1
  99            : (regno - NS32K_LP0_REGNUM + FP0_REGNUM)) * 4);
 100 }
 101
 102 static int
 103 ns32k_register_raw_size (int regno)
 104 {
 105   /* All registers are 4 bytes, except for the doubled floating
 106      registers.  */
 107
 108   return ((regno >= NS32K_LP0_REGNUM) ? 8 : 4);
 109 }
 110
 111 static int
 112 ns32k_register_virtual_size (int regno)
 113 {
 114   return ((regno >= NS32K_LP0_REGNUM) ? 8 : 4);
 115 }
 116
 117 static struct type *
 118 ns32k_register_virtual_type (int regno)
 119 {
 120   if (regno < FP0_REGNUM)
 121     return (builtin_type_int);
 122
 123   if (regno < FP0_REGNUM + 8)
 124     return (builtin_type_float);
 125
 126   if (regno < NS32K_LP0_REGNUM)
 127     return (builtin_type_int);
 128
 129   return (builtin_type_double);
 130 }
 131
 132 /* Immediately after a function call, return the saved PC.  Can't
 133    always go through the frames for this because on some systems,
 134    the new frame is not set up until the new function executes some
 135    instructions.  */
 136
 137 static CORE_ADDR
 138 ns32k_saved_pc_after_call (struct frame_info *frame)
 139 {
 140   return (read_memory_integer (read_register (SP_REGNUM), 4));
 141 }
 142
 143 /* Advance PC across any function entry prologue instructions
 144    to reach some "real" code.  */
 145
 146 static CORE_ADDR
 147 umax_skip_prologue (CORE_ADDR pc)
 148 {
 149   register unsigned char op = read_memory_integer (pc, 1);
 150   if (op == 0x82)
 151     {
 152       op = read_memory_integer (pc + 2, 1);
 153       if ((op & 0x80) == 0)
 154         pc += 3;
 155       else if ((op & 0xc0) == 0x80)
 156         pc += 4;
 157       else
 158         pc += 6;
 159     }
 160   return pc;
 161 }
 162 \f
 163 static const unsigned char *
 164 ns32k_breakpoint_from_pc (CORE_ADDR *pcp, int *lenp)
 165 {
 166   static const unsigned char breakpoint_insn[] = { 0xf2 };
 167
 168   *lenp = sizeof (breakpoint_insn);
 169   return breakpoint_insn;
 170 }
 171
 172 /* Return number of args passed to a frame.
 173    Can return -1, meaning no way to tell.
 174    Encore's C compiler often reuses same area on stack for args,
 175    so this will often not work properly.  If the arg names
 176    are known, it's likely most of them will be printed. */
 177
 178 static int
 179 umax_frame_num_args (struct frame_info *fi)
 180 {
 181   int numargs;
 182   CORE_ADDR pc;
 183   CORE_ADDR enter_addr;
 184   unsigned int insn;
 185   unsigned int addr_mode;
 186   int width;
 187
 188   numargs = -1;
 189   enter_addr = ns32k_get_enter_addr (get_frame_pc (fi));
 190   if (enter_addr > 0)
 191     {
 192       pc = ((enter_addr == 1)
 193             ? DEPRECATED_SAVED_PC_AFTER_CALL (fi)
 194             : DEPRECATED_FRAME_SAVED_PC (fi));
 195       insn = read_memory_integer (pc, 2);
 196       addr_mode = (insn >> 11) & 0x1f;
 197       insn = insn & 0x7ff;
 198       if ((insn & 0x7fc) == 0x57c
 199           && addr_mode == 0x14) /* immediate */
 200         {
 201           if (insn == 0x57c)    /* adjspb */
 202             width = 1;
 203           else if (insn == 0x57d)       /* adjspw */
 204             width = 2;
 205           else if (insn == 0x57f)       /* adjspd */
 206             width = 4;
 207           else
 208             internal_error (__FILE__, __LINE__, "bad else");
 209           numargs = read_memory_integer (pc + 2, width);
 210           if (width > 1)
 211             flip_bytes (&numargs, width);
 212           numargs = -sign_extend (numargs, width * 8) / 4;
 213         }
 214     }
 215   return numargs;
 216 }
 217
 218 static int
 219 sign_extend (int value, int bits)
 220 {
 221   value = value & ((1 << bits) - 1);
 222   return (value & (1 << (bits - 1))
 223           ? value | (~((1 << bits) - 1))
 224           : value);
 225 }
 226
 227 static void
 228 flip_bytes (void *p, int count)
 229 {
 230   char tmp;
 231   char *ptr = 0;
 232
 233   while (count > 0)
 234     {
 235       tmp = *ptr;
 236       ptr[0] = ptr[count - 1];
 237       ptr[count - 1] = tmp;
 238       ptr++;
 239       count -= 2;
 240     }
 241 }
 242
 243 /* Return the number of locals in the current frame given a
 244    pc pointing to the enter instruction.  This is used by
 245    ns32k_frame_init_saved_regs.  */
 246
 247 static int
 248 ns32k_localcount (CORE_ADDR enter_pc)
 249 {
 250   unsigned char localtype;
 251   int localcount;
 252
 253   localtype = read_memory_integer (enter_pc + 2, 1);
 254   if ((localtype & 0x80) == 0)
 255     localcount = localtype;
 256   else if ((localtype & 0xc0) == 0x80)
 257     localcount = (((localtype & 0x3f) << 8)
 258                   | (read_memory_integer (enter_pc + 3, 1) & 0xff));
 259   else
 260     localcount = (((localtype & 0x3f) << 24)
 261                   | ((read_memory_integer (enter_pc + 3, 1) & 0xff) << 16)
 262                   | ((read_memory_integer (enter_pc + 4, 1) & 0xff) << 8)
 263                   | (read_memory_integer (enter_pc + 5, 1) & 0xff));
 264   return localcount;
 265 }
 266
 267
 268 /* Nonzero if instruction at PC is a return instruction.  */
 269
 270 static int
 271 ns32k_about_to_return (CORE_ADDR pc)
 272 {
 273   return (read_memory_integer (pc, 1) == 0x12);
 274 }
 275
 276 /* Get the address of the enter opcode for this function, if it is active.
 277    Returns positive address > 1 if pc is between enter/exit,
 278    1 if pc before enter or after exit, 0 otherwise. */
 279 static CORE_ADDR
 280 ns32k_get_enter_addr (CORE_ADDR pc)
 281 {
 282   CORE_ADDR enter_addr;
 283   unsigned char op;
 284
 285   if (pc == 0)
 286     return 0;
 287
 288   if (ns32k_about_to_return (pc))
 289     return 1;                   /* after exit */
 290
 291   enter_addr = get_pc_function_start (pc);
 292
 293   if (pc == enter_addr)
 294     return 1;                   /* before enter */
 295
 296   op = read_memory_integer (enter_addr, 1);
 297
 298   if (op != 0x82)
 299     return 0;                   /* function has no enter/exit */
 300
 301   return enter_addr;            /* pc is between enter and exit */
 302 }
 303
 304 static CORE_ADDR
 305 ns32k_frame_chain (struct frame_info *frame)
 306 {
 307   /* In the case of the NS32000 series, the frame's nominal address is the
 308      FP value, and that address is saved at the previous FP value as a
 309      4-byte word.  */
 310
 311   if (inside_entry_file (get_frame_pc (frame)))
 312     return 0;
 313
 314   return (read_memory_integer (get_frame_base (frame), 4));
 315 }
 316
 317
 318 static CORE_ADDR
 319 ns32k_sigtramp_saved_pc (struct frame_info *frame)
 320 {
 321   CORE_ADDR sigcontext_addr;
 322   char *buf;
 323   int ptrbytes = TYPE_LENGTH (builtin_type_void_func_ptr);
 324   int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
 325
 326   buf = alloca (ptrbytes);
 327   /* Get sigcontext address, it is the third parameter on the stack.  */
 328   if (get_next_frame (frame))
 329     sigcontext_addr = read_memory_typed_address
 330       (FRAME_ARGS_ADDRESS (get_next_frame (frame)) + FRAME_ARGS_SKIP + sigcontext_offs,
 331        builtin_type_void_data_ptr);
 332   else
 333     sigcontext_addr = read_memory_typed_address
 334       (read_register (SP_REGNUM) + sigcontext_offs, builtin_type_void_data_ptr);
 335
 336   /* Don't cause a memory_error when accessing sigcontext in case the stack
 337      layout has changed or the stack is corrupt.  */
 338   target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
 339   return extract_typed_address (buf, builtin_type_void_func_ptr);
 340 }
 341
 342 static CORE_ADDR
 343 ns32k_frame_saved_pc (struct frame_info *frame)
 344 {
 345   if ((get_frame_type (frame) == SIGTRAMP_FRAME))
 346     return (ns32k_sigtramp_saved_pc (frame)); /* XXXJRT */
 347
 348   return (read_memory_integer (get_frame_base (frame) + 4, 4));
 349 }
 350
 351 static CORE_ADDR
 352 ns32k_frame_args_address (struct frame_info *frame)
 353 {
 354   if (ns32k_get_enter_addr (get_frame_pc (frame)) > 1)
 355     return (get_frame_base (frame));
 356
 357   return (read_register (SP_REGNUM) - 4);
 358 }
 359
 360 /* Code to initialize the addresses of the saved registers of frame described
 361    by FRAME_INFO.  This includes special registers such as pc and fp saved in
 362    special ways in the stack frame.  sp is even more special: the address we
 363    return for it IS the sp for the next frame.  */
 364
 365 static void
 366 ns32k_frame_init_saved_regs (struct frame_info *frame)
 367 {
 368   int regmask, regnum;
 369   int localcount;
 370   CORE_ADDR enter_addr, next_addr;
 371
 372   if (get_frame_saved_regs (frame))
 373     return;
 374
 375   frame_saved_regs_zalloc (frame);
 376
 377   enter_addr = ns32k_get_enter_addr (get_frame_pc (frame));
 378   if (enter_addr > 1)
 379     {
 380       regmask = read_memory_integer (enter_addr + 1, 1) & 0xff;
 381       localcount = ns32k_localcount (enter_addr);
 382       next_addr = get_frame_base (frame) + localcount;
 383
 384       for (regnum = 0; regnum < 8; regnum++)
 385         {
 386           if (regmask & (1 << regnum))
 387             get_frame_saved_regs (frame)[regnum] = next_addr -= 4;
 388         }
 389
 390       get_frame_saved_regs (frame)[SP_REGNUM] = get_frame_base (frame) + 4;
 391       get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 4;
 392       get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = read_memory_integer (get_frame_base (frame), 4);
 393     }
 394   else if (enter_addr == 1)
 395     {
 396       CORE_ADDR sp = read_register (SP_REGNUM);
 397       get_frame_saved_regs (frame)[PC_REGNUM] = sp;
 398       get_frame_saved_regs (frame)[SP_REGNUM] = sp + 4;
 399     }
 400 }
 401
 402 static void
 403 ns32k_push_dummy_frame (void)
 404 {
 405   CORE_ADDR sp = read_register (SP_REGNUM);
 406   int regnum;
 407
 408   sp = push_word (sp, read_register (PC_REGNUM));
 409   sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM));
 410   write_register (DEPRECATED_FP_REGNUM, sp);
 411
 412   for (regnum = 0; regnum < 8; regnum++)
 413     sp = push_word (sp, read_register (regnum));
 414
 415   write_register (SP_REGNUM, sp);
 416 }
 417
 418 static void
 419 ns32k_pop_frame (void)
 420 {
 421   struct frame_info *frame = get_current_frame ();
 422   CORE_ADDR fp;
 423   int regnum;
 424
 425   fp = get_frame_base (frame);
 426   DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
 427
 428   for (regnum = 0; regnum < 8; regnum++)
 429     if (get_frame_saved_regs (frame)[regnum])
 430       write_register (regnum,
 431                       read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
 432
 433   write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4));
 434   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
 435   write_register (SP_REGNUM, fp + 8);
 436   flush_cached_frames ();
 437 }
 438 \f
 439 /* The NS32000 call dummy sequence:
 440
 441         enter   0xff,0                  82 ff 00
 442         jsr     @0x00010203             7f ae c0 01 02 03
 443         adjspd  0x69696969              7f a5 01 02 03 04
 444         bpt                             f2
 445
 446    It is 16 bytes long.  */
 447
 448 static LONGEST ns32k_call_dummy_words[] =
 449 {
 450   0x7f00ff82,
 451   0x0201c0ae,
 452   0x01a57f03,
 453   0xf2040302
 454 };
 455 static int sizeof_ns32k_call_dummy_words = sizeof (ns32k_call_dummy_words);
 456
 457 #define NS32K_CALL_DUMMY_ADDR         5
 458 #define NS32K_CALL_DUMMY_NARGS        11
 459
 460 static void
 461 ns32k_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 462                       struct value **args, struct type *type, int gcc_p)
 463 {
 464   int flipped;
 465
 466   flipped = fun | 0xc0000000;
 467   flip_bytes (&flipped, 4);
 468   store_unsigned_integer (dummy + NS32K_CALL_DUMMY_ADDR, 4, flipped);
 469
 470   flipped = - nargs * 4;
 471   flip_bytes (&flipped, 4);
 472   store_unsigned_integer (dummy + NS32K_CALL_DUMMY_NARGS, 4, flipped);
 473 }
 474 \f
 475 static void
 476 ns32k_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 477 {
 478   /* On this machine, this is a no-op (Encore Umax didn't use GCC).  */
 479 }
 480
 481 static void
 482 ns32k_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
 483 {
 484   memcpy (valbuf,
 485           regbuf + REGISTER_BYTE (TYPE_CODE (valtype) == TYPE_CODE_FLT ?
 486                                   FP0_REGNUM : 0), TYPE_LENGTH (valtype));
 487 }
 488
 489 static void
 490 ns32k_store_return_value (struct type *valtype, char *valbuf)
 491 {
 492   deprecated_write_register_bytes (TYPE_CODE (valtype) == TYPE_CODE_FLT
 493                                    ? FP0_REGNUM : 0, valbuf,
 494                                    TYPE_LENGTH (valtype));
 495 }
 496
 497 static CORE_ADDR
 498 ns32k_extract_struct_value_address (char *regbuf)
 499 {
 500   return (extract_unsigned_integer (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
 501 }
 502 \f
 503 void
 504 ns32k_gdbarch_init_32082 (struct gdbarch *gdbarch)
 505 {
 506   set_gdbarch_num_regs (gdbarch, NS32K_NUM_REGS_32082);
 507
 508   set_gdbarch_register_name (gdbarch, ns32k_register_name_32082);
 509   set_gdbarch_deprecated_register_bytes (gdbarch, NS32K_REGISTER_BYTES_32082);
 510   set_gdbarch_register_byte (gdbarch, ns32k_register_byte_32082);
 511 }
 512
 513 void
 514 ns32k_gdbarch_init_32382 (struct gdbarch *gdbarch)
 515 {
 516   set_gdbarch_num_regs (gdbarch, NS32K_NUM_REGS_32382);
 517
 518   set_gdbarch_register_name (gdbarch, ns32k_register_name_32382);
 519   set_gdbarch_deprecated_register_bytes (gdbarch, NS32K_REGISTER_BYTES_32382);
 520   set_gdbarch_register_byte (gdbarch, ns32k_register_byte_32382);
 521 }
 522
 523 /* Initialize the current architecture based on INFO.  If possible, re-use an
 524    architecture from ARCHES, which is a list of architectures already created
 525    during this debugging session.
 526
 527    Called e.g. at program startup, when reading a core file, and when reading
 528    a binary file.  */
 529
 530 static struct gdbarch *
 531 ns32k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 532 {
 533   struct gdbarch *gdbarch;
 534
 535   /* If there is already a candidate, use it.  */
 536   arches = gdbarch_list_lookup_by_info (arches, &info);
 537   if (arches != NULL)
 538     return arches->gdbarch;
 539
 540   gdbarch = gdbarch_alloc (&info, NULL);
 541
 542   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
 543      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
 544   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
 545
 546   /* Register info */
 547   ns32k_gdbarch_init_32082 (gdbarch);
 548   set_gdbarch_num_regs (gdbarch, NS32K_SP_REGNUM);
 549   set_gdbarch_num_regs (gdbarch, NS32K_FP_REGNUM);
 550   set_gdbarch_num_regs (gdbarch, NS32K_PC_REGNUM);
 551   set_gdbarch_num_regs (gdbarch, NS32K_PS_REGNUM);
 552
 553   set_gdbarch_deprecated_register_size (gdbarch, NS32K_REGISTER_SIZE);
 554   set_gdbarch_register_raw_size (gdbarch, ns32k_register_raw_size);
 555   set_gdbarch_deprecated_max_register_raw_size (gdbarch, NS32K_MAX_REGISTER_RAW_SIZE);
 556   set_gdbarch_register_virtual_size (gdbarch, ns32k_register_virtual_size);
 557   set_gdbarch_deprecated_max_register_virtual_size (gdbarch,
 558                                          NS32K_MAX_REGISTER_VIRTUAL_SIZE);
 559   set_gdbarch_register_virtual_type (gdbarch, ns32k_register_virtual_type);
 560
 561   /* Frame and stack info */
 562   set_gdbarch_skip_prologue (gdbarch, umax_skip_prologue);
 563   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, ns32k_saved_pc_after_call);
 564
 565   set_gdbarch_frame_num_args (gdbarch, umax_frame_num_args);
 566   set_gdbarch_frameless_function_invocation (gdbarch,
 567                                    generic_frameless_function_invocation_not);
 568
 569   set_gdbarch_deprecated_frame_chain (gdbarch, ns32k_frame_chain);
 570   set_gdbarch_deprecated_frame_saved_pc (gdbarch, ns32k_frame_saved_pc);
 571
 572   set_gdbarch_frame_args_address (gdbarch, ns32k_frame_args_address);
 573
 574   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, ns32k_frame_init_saved_regs);
 575
 576   set_gdbarch_frame_args_skip (gdbarch, 8);
 577
 578   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 579
 580   /* Return value info */
 581   set_gdbarch_deprecated_store_struct_return (gdbarch, ns32k_store_struct_return);
 582   set_gdbarch_deprecated_extract_return_value (gdbarch, ns32k_extract_return_value);
 583   set_gdbarch_deprecated_store_return_value (gdbarch, ns32k_store_return_value);
 584   set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
 585                                             ns32k_extract_struct_value_address);
 586
 587   /* Call dummy info */
 588   set_gdbarch_deprecated_push_dummy_frame (gdbarch, ns32k_push_dummy_frame);
 589   set_gdbarch_deprecated_pop_frame (gdbarch, ns32k_pop_frame);
 590   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
 591   set_gdbarch_deprecated_call_dummy_words (gdbarch, ns32k_call_dummy_words);
 592   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_ns32k_call_dummy_words);
 593   set_gdbarch_deprecated_fix_call_dummy (gdbarch, ns32k_fix_call_dummy);
 594   set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 3);
 595   set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 15);
 596   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
 597   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
 598
 599   /* Breakpoint info */
 600   set_gdbarch_decr_pc_after_break (gdbarch, 0);
 601   set_gdbarch_breakpoint_from_pc (gdbarch, ns32k_breakpoint_from_pc);
 602
 603   /* Misc info */
 604   set_gdbarch_function_start_offset (gdbarch, 0);
 605
 606   /* Should be using push_dummy_call.  */
 607   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
 608
 609   /* Hook in OS ABI-specific overrides, if they have been registered.  */
 610   gdbarch_init_osabi (info, gdbarch);
 611
 612   return (gdbarch);
 613 }
 614
 615 void
 616 _initialize_ns32k_tdep (void)
 617 {
 618   gdbarch_register (bfd_arch_ns32k, ns32k_gdbarch_init, NULL);
 619
 620   deprecated_tm_print_insn = print_insn_ns32k;
 621 }