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