gdb/mips-tdep.c

   1 /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
   2
   3    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   5
   6    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   7    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place - Suite 330,
  24    Boston, MA 02111-1307, USA.  */
  25
  26 #include "defs.h"
  27 #include "gdb_string.h"
  28 #include "frame.h"
  29 #include "inferior.h"
  30 #include "symtab.h"
  31 #include "value.h"
  32 #include "gdbcmd.h"
  33 #include "language.h"
  34 #include "gdbcore.h"
  35 #include "symfile.h"
  36 #include "objfiles.h"
  37 #include "gdbtypes.h"
  38 #include "target.h"
  39 #include "arch-utils.h"
  40 #include "regcache.h"
  41 #include "osabi.h"
  42
  43 #include "opcode/mips.h"
  44 #include "elf/mips.h"
  45 #include "elf-bfd.h"
  46 #include "symcat.h"
  47
  48 /* A useful bit in the CP0 status register (PS_REGNUM).  */
  49 /* This bit is set if we are emulating 32-bit FPRs on a 64-bit chip.  */
  50 #define ST0_FR (1 << 26)
  51
  52 /* The sizes of floating point registers.  */
  53
  54 enum
  55 {
  56   MIPS_FPU_SINGLE_REGSIZE = 4,
  57   MIPS_FPU_DOUBLE_REGSIZE = 8
  58 };
  59
  60 /* All the possible MIPS ABIs. */
  61
  62 enum mips_abi
  63   {
  64     MIPS_ABI_UNKNOWN = 0,
  65     MIPS_ABI_N32,
  66     MIPS_ABI_O32,
  67     MIPS_ABI_N64,
  68     MIPS_ABI_O64,
  69     MIPS_ABI_EABI32,
  70     MIPS_ABI_EABI64,
  71     MIPS_ABI_LAST
  72   };
  73
  74 static const char *mips_abi_string;
  75
  76 static const char *mips_abi_strings[] = {
  77   "auto",
  78   "n32",
  79   "o32",
  80   "n64",
  81   "o64",
  82   "eabi32",
  83   "eabi64",
  84   NULL
  85 };
  86
  87 struct frame_extra_info
  88   {
  89     mips_extra_func_info_t proc_desc;
  90     int num_args;
  91   };
  92
  93 /* Various MIPS ISA options (related to stack analysis) can be
  94    overridden dynamically.  Establish an enum/array for managing
  95    them. */
  96
  97 static const char size_auto[] = "auto";
  98 static const char size_32[] = "32";
  99 static const char size_64[] = "64";
 100
 101 static const char *size_enums[] = {
 102   size_auto,
 103   size_32,
 104   size_64,
 105   0
 106 };
 107
 108 /* Some MIPS boards don't support floating point while others only
 109    support single-precision floating-point operations.  See also
 110    FP_REGISTER_DOUBLE. */
 111
 112 enum mips_fpu_type
 113   {
 114     MIPS_FPU_DOUBLE,            /* Full double precision floating point.  */
 115     MIPS_FPU_SINGLE,            /* Single precision floating point (R4650).  */
 116     MIPS_FPU_NONE               /* No floating point.  */
 117   };
 118
 119 #ifndef MIPS_DEFAULT_FPU_TYPE
 120 #define MIPS_DEFAULT_FPU_TYPE MIPS_FPU_DOUBLE
 121 #endif
 122 static int mips_fpu_type_auto = 1;
 123 static enum mips_fpu_type mips_fpu_type = MIPS_DEFAULT_FPU_TYPE;
 124
 125 static int mips_debug = 0;
 126
 127 /* MIPS specific per-architecture information */
 128 struct gdbarch_tdep
 129   {
 130     /* from the elf header */
 131     int elf_flags;
 132
 133     /* mips options */
 134     enum mips_abi mips_abi;
 135     enum mips_abi found_abi;
 136     enum mips_fpu_type mips_fpu_type;
 137     int mips_last_arg_regnum;
 138     int mips_last_fp_arg_regnum;
 139     int mips_default_saved_regsize;
 140     int mips_fp_register_double;
 141     int mips_default_stack_argsize;
 142     int gdb_target_is_mips64;
 143     int default_mask_address_p;
 144
 145     enum gdb_osabi osabi;
 146   };
 147
 148 #define MIPS_EABI (gdbarch_tdep (current_gdbarch)->mips_abi == MIPS_ABI_EABI32 \
 149                    || gdbarch_tdep (current_gdbarch)->mips_abi == MIPS_ABI_EABI64)
 150
 151 #define MIPS_LAST_FP_ARG_REGNUM (gdbarch_tdep (current_gdbarch)->mips_last_fp_arg_regnum)
 152
 153 #define MIPS_LAST_ARG_REGNUM (gdbarch_tdep (current_gdbarch)->mips_last_arg_regnum)
 154
 155 #define MIPS_FPU_TYPE (gdbarch_tdep (current_gdbarch)->mips_fpu_type)
 156
 157 /* Return the currently configured (or set) saved register size. */
 158
 159 #define MIPS_DEFAULT_SAVED_REGSIZE (gdbarch_tdep (current_gdbarch)->mips_default_saved_regsize)
 160
 161 static const char *mips_saved_regsize_string = size_auto;
 162
 163 #define MIPS_SAVED_REGSIZE (mips_saved_regsize())
 164
 165 static unsigned int
 166 mips_saved_regsize (void)
 167 {
 168   if (mips_saved_regsize_string == size_auto)
 169     return MIPS_DEFAULT_SAVED_REGSIZE;
 170   else if (mips_saved_regsize_string == size_64)
 171     return 8;
 172   else /* if (mips_saved_regsize_string == size_32) */
 173     return 4;
 174 }
 175
 176 /* XFER a value from the big/little/left end of the register.
 177    Depending on the size of the value it might occupy the entire
 178    register or just part of it.  Make an allowance for this, aligning
 179    things accordingly.  */
 180
 181 static void
 182 mips_xfer_register (struct regcache *regcache, int reg_num, int length,
 183                     enum bfd_endian endian, bfd_byte *in, const bfd_byte *out,
 184                     int buf_offset)
 185 {
 186   bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
 187   int reg_offset = 0;
 188   /* Need to transfer the left or right part of the register, based on
 189      the targets byte order.  */
 190   switch (endian)
 191     {
 192     case BFD_ENDIAN_BIG:
 193       reg_offset = REGISTER_RAW_SIZE (reg_num) - length;
 194       break;
 195     case BFD_ENDIAN_LITTLE:
 196       reg_offset = 0;
 197       break;
 198     case BFD_ENDIAN_UNKNOWN: /* Indicates no alignment.  */
 199       reg_offset = 0;
 200       break;
 201     default:
 202       internal_error (__FILE__, __LINE__, "bad switch");
 203     }
 204   if (mips_debug)
 205     fprintf_unfiltered (gdb_stderr,
 206                         "xfer $%d, reg offset %d, buf offset %d, length %d, ",
 207                         reg_num, reg_offset, buf_offset, length);
 208   if (mips_debug && out != NULL)
 209     {
 210       int i;
 211       fprintf_unfiltered (gdb_stdlog, "out ");
 212       for (i = 0; i < length; i++)
 213         fprintf_unfiltered (gdb_stdlog, "%02x", out[buf_offset + i]);
 214     }
 215   if (in != NULL)
 216     regcache_raw_read_part (regcache, reg_num, reg_offset, length, in + buf_offset);
 217   if (out != NULL)
 218     regcache_raw_write_part (regcache, reg_num, reg_offset, length, out + buf_offset);
 219   if (mips_debug && in != NULL)
 220     {
 221       int i;
 222       fprintf_unfiltered (gdb_stdlog, "in ");
 223       for (i = 0; i < length; i++)
 224         fprintf_unfiltered (gdb_stdlog, "%02x", in[buf_offset + i]);
 225     }
 226   if (mips_debug)
 227     fprintf_unfiltered (gdb_stdlog, "\n");
 228 }
 229
 230 /* Determine if a MIPS3 or later cpu is operating in MIPS{1,2} FPU
 231    compatiblity mode.  A return value of 1 means that we have
 232    physical 64-bit registers, but should treat them as 32-bit registers.  */
 233
 234 static int
 235 mips2_fp_compat (void)
 236 {
 237   /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
 238      meaningful.  */
 239   if (REGISTER_RAW_SIZE (FP0_REGNUM) == 4)
 240     return 0;
 241
 242 #if 0
 243   /* FIXME drow 2002-03-10: This is disabled until we can do it consistently,
 244      in all the places we deal with FP registers.  PR gdb/413.  */
 245   /* Otherwise check the FR bit in the status register - it controls
 246      the FP compatiblity mode.  If it is clear we are in compatibility
 247      mode.  */
 248   if ((read_register (PS_REGNUM) & ST0_FR) == 0)
 249     return 1;
 250 #endif
 251
 252   return 0;
 253 }
 254
 255 /* Indicate that the ABI makes use of double-precision registers
 256    provided by the FPU (rather than combining pairs of registers to
 257    form double-precision values).  Do not use "TARGET_IS_MIPS64" to
 258    determine if the ABI is using double-precision registers.  See also
 259    MIPS_FPU_TYPE. */
 260 #define FP_REGISTER_DOUBLE (gdbarch_tdep (current_gdbarch)->mips_fp_register_double)
 261
 262 /* The amount of space reserved on the stack for registers. This is
 263    different to MIPS_SAVED_REGSIZE as it determines the alignment of
 264    data allocated after the registers have run out. */
 265
 266 #define MIPS_DEFAULT_STACK_ARGSIZE (gdbarch_tdep (current_gdbarch)->mips_default_stack_argsize)
 267
 268 #define MIPS_STACK_ARGSIZE (mips_stack_argsize ())
 269
 270 static const char *mips_stack_argsize_string = size_auto;
 271
 272 static unsigned int
 273 mips_stack_argsize (void)
 274 {
 275   if (mips_stack_argsize_string == size_auto)
 276     return MIPS_DEFAULT_STACK_ARGSIZE;
 277   else if (mips_stack_argsize_string == size_64)
 278     return 8;
 279   else /* if (mips_stack_argsize_string == size_32) */
 280     return 4;
 281 }
 282
 283 #define GDB_TARGET_IS_MIPS64 (gdbarch_tdep (current_gdbarch)->gdb_target_is_mips64 + 0)
 284
 285 #define MIPS_DEFAULT_MASK_ADDRESS_P (gdbarch_tdep (current_gdbarch)->default_mask_address_p)
 286
 287 #define VM_MIN_ADDRESS (CORE_ADDR)0x400000
 288
 289 int gdb_print_insn_mips (bfd_vma, disassemble_info *);
 290
 291 static void mips_print_register (int, int);
 292
 293 static mips_extra_func_info_t
 294 heuristic_proc_desc (CORE_ADDR, CORE_ADDR, struct frame_info *, int);
 295
 296 static CORE_ADDR heuristic_proc_start (CORE_ADDR);
 297
 298 static CORE_ADDR read_next_frame_reg (struct frame_info *, int);
 299
 300 int mips_set_processor_type (char *);
 301
 302 static void mips_show_processor_type_command (char *, int);
 303
 304 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element *);
 305
 306 static mips_extra_func_info_t
 307 find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame, int cur_frame);
 308
 309 static CORE_ADDR after_prologue (CORE_ADDR pc,
 310                                  mips_extra_func_info_t proc_desc);
 311
 312 static void mips_read_fp_register_single (int regno, char *rare_buffer);
 313 static void mips_read_fp_register_double (int regno, char *rare_buffer);
 314
 315 static struct type *mips_float_register_type (void);
 316 static struct type *mips_double_register_type (void);
 317
 318 /* This value is the model of MIPS in use.  It is derived from the value
 319    of the PrID register.  */
 320
 321 char *mips_processor_type;
 322
 323 char *tmp_mips_processor_type;
 324
 325 /* The list of available "set mips " and "show mips " commands */
 326
 327 static struct cmd_list_element *setmipscmdlist = NULL;
 328 static struct cmd_list_element *showmipscmdlist = NULL;
 329
 330 /* A set of original names, to be used when restoring back to generic
 331    registers from a specific set.  */
 332
 333 char *mips_generic_reg_names[] = MIPS_REGISTER_NAMES;
 334 char **mips_processor_reg_names = mips_generic_reg_names;
 335
 336 const char *
 337 mips_register_name (int i)
 338 {
 339   return mips_processor_reg_names[i];
 340 }
 341 /* *INDENT-OFF* */
 342 /* Names of IDT R3041 registers.  */
 343
 344 char *mips_r3041_reg_names[] = {
 345         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 346         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 347         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 348         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 349         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 350         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 351         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 352         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 353         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 354         "fsr",  "fir",  "fp",   "",
 355         "",     "",     "bus",  "ccfg", "",     "",     "",     "",
 356         "",     "",     "port", "cmp",  "",     "",     "epc",  "prid",
 357 };
 358
 359 /* Names of IDT R3051 registers.  */
 360
 361 char *mips_r3051_reg_names[] = {
 362         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 363         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 364         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 365         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 366         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 367         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 368         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 369         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 370         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 371         "fsr",  "fir",  "fp",   "",
 372         "inx",  "rand", "elo",  "",     "ctxt", "",     "",     "",
 373         "",     "",     "ehi",  "",     "",     "",     "epc",  "prid",
 374 };
 375
 376 /* Names of IDT R3081 registers.  */
 377
 378 char *mips_r3081_reg_names[] = {
 379         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 380         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 381         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 382         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 383         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 384         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 385         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 386         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 387         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 388         "fsr",  "fir",  "fp",   "",
 389         "inx",  "rand", "elo",  "cfg",  "ctxt", "",     "",     "",
 390         "",     "",     "ehi",  "",     "",     "",     "epc",  "prid",
 391 };
 392
 393 /* Names of LSI 33k registers.  */
 394
 395 char *mips_lsi33k_reg_names[] = {
 396         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 397         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 398         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 399         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 400         "epc",  "hi",   "lo",   "sr",   "cause","badvaddr",
 401         "dcic", "bpc",  "bda",  "",     "",     "",     "",      "",
 402         "",     "",     "",     "",     "",     "",     "",      "",
 403         "",     "",     "",     "",     "",     "",     "",      "",
 404         "",     "",     "",     "",     "",     "",     "",      "",
 405         "",     "",     "",     "",
 406         "",     "",     "",     "",     "",     "",     "",      "",
 407         "",     "",     "",     "",     "",     "",     "",      "",
 408 };
 409
 410 struct {
 411   char *name;
 412   char **regnames;
 413 } mips_processor_type_table[] = {
 414   { "generic", mips_generic_reg_names },
 415   { "r3041", mips_r3041_reg_names },
 416   { "r3051", mips_r3051_reg_names },
 417   { "r3071", mips_r3081_reg_names },
 418   { "r3081", mips_r3081_reg_names },
 419   { "lsi33k", mips_lsi33k_reg_names },
 420   { NULL, NULL }
 421 };
 422 /* *INDENT-ON* */
 423
 424
 425
 426
 427 /* Table to translate MIPS16 register field to actual register number.  */
 428 static int mips16_to_32_reg[8] =
 429 {16, 17, 2, 3, 4, 5, 6, 7};
 430
 431 /* Heuristic_proc_start may hunt through the text section for a long
 432    time across a 2400 baud serial line.  Allows the user to limit this
 433    search.  */
 434
 435 static unsigned int heuristic_fence_post = 0;
 436
 437 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)   /* least address */
 438 #define PROC_HIGH_ADDR(proc) ((proc)->high_addr)        /* upper address bound */
 439 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
 440 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
 441 #define PROC_FRAME_ADJUST(proc)  ((proc)->frame_adjust)
 442 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
 443 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
 444 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
 445 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
 446 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
 447 /* FIXME drow/2002-06-10: If a pointer on the host is bigger than a long,
 448    this will corrupt pdr.iline.  Fortunately we don't use it.  */
 449 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
 450 #define _PROC_MAGIC_ 0x0F0F0F0F
 451 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
 452 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
 453
 454 struct linked_proc_info
 455   {
 456     struct mips_extra_func_info info;
 457     struct linked_proc_info *next;
 458   }
 459  *linked_proc_desc_table = NULL;
 460
 461 void
 462 mips_print_extra_frame_info (struct frame_info *fi)
 463 {
 464   if (fi
 465       && fi->extra_info
 466       && fi->extra_info->proc_desc
 467       && fi->extra_info->proc_desc->pdr.framereg < NUM_REGS)
 468     printf_filtered (" frame pointer is at %s+%s\n",
 469                      REGISTER_NAME (fi->extra_info->proc_desc->pdr.framereg),
 470                      paddr_d (fi->extra_info->proc_desc->pdr.frameoffset));
 471 }
 472
 473 /* Number of bytes of storage in the actual machine representation for
 474    register N.  NOTE: This indirectly defines the register size
 475    transfered by the GDB protocol. */
 476
 477 static int mips64_transfers_32bit_regs_p = 0;
 478
 479 static int
 480 mips_register_raw_size (int reg_nr)
 481 {
 482   if (mips64_transfers_32bit_regs_p)
 483     return REGISTER_VIRTUAL_SIZE (reg_nr);
 484   else if (reg_nr >= FP0_REGNUM && reg_nr < FP0_REGNUM + 32
 485            && FP_REGISTER_DOUBLE)
 486     /* For MIPS_ABI_N32 (for example) we need 8 byte floating point
 487        registers.  */
 488     return 8;
 489   else
 490     return MIPS_REGSIZE;
 491 }
 492
 493 /* Convert between RAW and VIRTUAL registers.  The RAW register size
 494    defines the remote-gdb packet. */
 495
 496 static int
 497 mips_register_convertible (int reg_nr)
 498 {
 499   if (mips64_transfers_32bit_regs_p)
 500     return 0;
 501   else
 502     return (REGISTER_RAW_SIZE (reg_nr) > REGISTER_VIRTUAL_SIZE (reg_nr));
 503 }
 504
 505 static void
 506 mips_register_convert_to_virtual (int n, struct type *virtual_type,
 507                                   char *raw_buf, char *virt_buf)
 508 {
 509   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 510     memcpy (virt_buf,
 511             raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 512             TYPE_LENGTH (virtual_type));
 513   else
 514     memcpy (virt_buf,
 515             raw_buf,
 516             TYPE_LENGTH (virtual_type));
 517 }
 518
 519 static void
 520 mips_register_convert_to_raw (struct type *virtual_type, int n,
 521                               char *virt_buf, char *raw_buf)
 522 {
 523   memset (raw_buf, 0, REGISTER_RAW_SIZE (n));
 524   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 525     memcpy (raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 526             virt_buf,
 527             TYPE_LENGTH (virtual_type));
 528   else
 529     memcpy (raw_buf,
 530             virt_buf,
 531             TYPE_LENGTH (virtual_type));
 532 }
 533
 534 void
 535 mips_register_convert_to_type (int regnum, struct type *type, char *buffer)
 536 {
 537   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 538       && REGISTER_RAW_SIZE (regnum) == 4
 539       && (regnum) >= FP0_REGNUM && (regnum) < FP0_REGNUM + 32
 540       && TYPE_CODE(type) == TYPE_CODE_FLT
 541       && TYPE_LENGTH(type) == 8)
 542     {
 543       char temp[4];
 544       memcpy (temp, ((char *)(buffer))+4, 4);
 545       memcpy (((char *)(buffer))+4, (buffer), 4);
 546       memcpy (((char *)(buffer)), temp, 4);
 547     }
 548 }
 549
 550 void
 551 mips_register_convert_from_type (int regnum, struct type *type, char *buffer)
 552 {
 553 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 554     && REGISTER_RAW_SIZE (regnum) == 4
 555     && (regnum) >= FP0_REGNUM && (regnum) < FP0_REGNUM + 32
 556     && TYPE_CODE(type) == TYPE_CODE_FLT
 557     && TYPE_LENGTH(type) == 8)
 558   {
 559     char temp[4];
 560     memcpy (temp, ((char *)(buffer))+4, 4);
 561     memcpy (((char *)(buffer))+4, (buffer), 4);
 562     memcpy (((char *)(buffer)), temp, 4);
 563   }
 564 }
 565
 566 /* Return the GDB type object for the "standard" data type
 567    of data in register REG.
 568
 569    Note: kevinb/2002-08-01: The definition below should faithfully
 570    reproduce the behavior of each of the REGISTER_VIRTUAL_TYPE
 571    definitions found in config/mips/tm-*.h.  I'm concerned about
 572    the ``FCRCS_REGNUM <= reg && reg <= LAST_EMBED_REGNUM'' clause
 573    though.  In some cases FP_REGNUM is in this range, and I doubt
 574    that this code is correct for the 64-bit case.  */
 575
 576 static struct type *
 577 mips_register_virtual_type (int reg)
 578 {
 579   if (FP0_REGNUM <= reg && reg < FP0_REGNUM + 32)
 580     {
 581       /* Floating point registers...  */
 582       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 583         return builtin_type_ieee_double_big;
 584       else
 585         return builtin_type_ieee_double_little;
 586     }
 587   else if (reg == PS_REGNUM /* CR */)
 588     return builtin_type_uint32;
 589   else if (FCRCS_REGNUM <= reg && reg <= LAST_EMBED_REGNUM)
 590     return builtin_type_uint32;
 591   else
 592     {
 593       /* Everything else...
 594          Return type appropriate for width of register.  */
 595       if (MIPS_REGSIZE == TYPE_LENGTH (builtin_type_uint64))
 596         return builtin_type_uint64;
 597       else
 598         return builtin_type_uint32;
 599     }
 600 }
 601
 602 /* TARGET_READ_SP -- Remove useless bits from the stack pointer.  */
 603
 604 static CORE_ADDR
 605 mips_read_sp (void)
 606 {
 607   return ADDR_BITS_REMOVE (read_register (SP_REGNUM));
 608 }
 609
 610 /* Should the upper word of 64-bit addresses be zeroed? */
 611 enum auto_boolean mask_address_var = AUTO_BOOLEAN_AUTO;
 612
 613 static int
 614 mips_mask_address_p (void)
 615 {
 616   switch (mask_address_var)
 617     {
 618     case AUTO_BOOLEAN_TRUE:
 619       return 1;
 620     case AUTO_BOOLEAN_FALSE:
 621       return 0;
 622       break;
 623     case AUTO_BOOLEAN_AUTO:
 624       return MIPS_DEFAULT_MASK_ADDRESS_P;
 625     default:
 626       internal_error (__FILE__, __LINE__,
 627                       "mips_mask_address_p: bad switch");
 628       return -1;
 629     }
 630 }
 631
 632 static void
 633 show_mask_address (char *cmd, int from_tty, struct cmd_list_element *c)
 634 {
 635   switch (mask_address_var)
 636     {
 637     case AUTO_BOOLEAN_TRUE:
 638       printf_filtered ("The 32 bit mips address mask is enabled\n");
 639       break;
 640     case AUTO_BOOLEAN_FALSE:
 641       printf_filtered ("The 32 bit mips address mask is disabled\n");
 642       break;
 643     case AUTO_BOOLEAN_AUTO:
 644       printf_filtered ("The 32 bit address mask is set automatically.  Currently %s\n",
 645                        mips_mask_address_p () ? "enabled" : "disabled");
 646       break;
 647     default:
 648       internal_error (__FILE__, __LINE__,
 649                       "show_mask_address: bad switch");
 650       break;
 651     }
 652 }
 653
 654 /* Should call_function allocate stack space for a struct return?  */
 655
 656 static int
 657 mips_eabi_use_struct_convention (int gcc_p, struct type *type)
 658 {
 659   return (TYPE_LENGTH (type) > 2 * MIPS_SAVED_REGSIZE);
 660 }
 661
 662 static int
 663 mips_n32n64_use_struct_convention (int gcc_p, struct type *type)
 664 {
 665   return (TYPE_LENGTH (type) > 2 * MIPS_SAVED_REGSIZE);
 666 }
 667
 668 static int
 669 mips_o32_use_struct_convention (int gcc_p, struct type *type)
 670 {
 671   return 1;     /* Structures are returned by ref in extra arg0.  */
 672 }
 673
 674 /* Should call_function pass struct by reference?
 675    For each architecture, structs are passed either by
 676    value or by reference, depending on their size.  */
 677
 678 static int
 679 mips_eabi_reg_struct_has_addr (int gcc_p, struct type *type)
 680 {
 681   enum type_code typecode = TYPE_CODE (check_typedef (type));
 682   int len = TYPE_LENGTH (check_typedef (type));
 683
 684   if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
 685     return (len > MIPS_SAVED_REGSIZE);
 686
 687   return 0;
 688 }
 689
 690 static int
 691 mips_n32n64_reg_struct_has_addr (int gcc_p, struct type *type)
 692 {
 693   return 0;     /* Assumption: N32/N64 never passes struct by ref.  */
 694 }
 695
 696 static int
 697 mips_o32_reg_struct_has_addr (int gcc_p, struct type *type)
 698 {
 699   return 0;     /* Assumption: O32/O64 never passes struct by ref.  */
 700 }
 701
 702 /* Tell if the program counter value in MEMADDR is in a MIPS16 function.  */
 703
 704 static int
 705 pc_is_mips16 (bfd_vma memaddr)
 706 {
 707   struct minimal_symbol *sym;
 708
 709   /* If bit 0 of the address is set, assume this is a MIPS16 address. */
 710   if (IS_MIPS16_ADDR (memaddr))
 711     return 1;
 712
 713   /* A flag indicating that this is a MIPS16 function is stored by elfread.c in
 714      the high bit of the info field.  Use this to decide if the function is
 715      MIPS16 or normal MIPS.  */
 716   sym = lookup_minimal_symbol_by_pc (memaddr);
 717   if (sym)
 718     return MSYMBOL_IS_SPECIAL (sym);
 719   else
 720     return 0;
 721 }
 722
 723 /* ELF_MAKE_MSYMBOL_SPECIAL tests whether an ELF symbol is "special",
 724    i.e. refers to a 16-bit function, and sets a "special" bit in a
 725    minimal symbol to mark it as a 16-bit function.  */
 726
 727 static void
 728 mips_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 729 {
 730   if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_MIPS16)
 731     {
 732       MSYMBOL_INFO (msym) = (char *)
 733         (((long) MSYMBOL_INFO (msym)) | 0x80000000);
 734       SYMBOL_VALUE_ADDRESS (msym) |= 1;
 735     }
 736 }
 737
 738 /* MSYMBOL_IS_SPECIAL tests the "special" bit in a minimal symbol.  */
 739
 740 int
 741 mips_msymbol_is_special (struct minimal_symbol *msym)
 742 {
 743   return (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0);
 744 }
 745
 746 /* MSYMBOL_SIZE returns the size of the minimal symbol, i.e.  the
 747    "info" field with the "special" bit masked out.  */
 748
 749 long
 750 mips_msymbol_size (struct minimal_symbol *msym)
 751 {
 752   return ((long) MSYMBOL_INFO (msym) & 0x7fffffff);
 753 }
 754
 755 /* MIPS believes that the PC has a sign extended value.  Perhaphs the
 756    all registers should be sign extended for simplicity? */
 757
 758 static CORE_ADDR
 759 mips_read_pc (ptid_t ptid)
 760 {
 761   return read_signed_register_pid (PC_REGNUM, ptid);
 762 }
 763
 764 /* This returns the PC of the first inst after the prologue.  If we can't
 765    find the prologue, then return 0.  */
 766
 767 static CORE_ADDR
 768 after_prologue (CORE_ADDR pc,
 769                 mips_extra_func_info_t proc_desc)
 770 {
 771   struct symtab_and_line sal;
 772   CORE_ADDR func_addr, func_end;
 773
 774   /* Pass cur_frame == 0 to find_proc_desc.  We should not attempt
 775      to read the stack pointer from the current machine state, because
 776      the current machine state has nothing to do with the information
 777      we need from the proc_desc; and the process may or may not exist
 778      right now.  */
 779   if (!proc_desc)
 780     proc_desc = find_proc_desc (pc, NULL, 0);
 781
 782   if (proc_desc)
 783     {
 784       /* If function is frameless, then we need to do it the hard way.  I
 785          strongly suspect that frameless always means prologueless... */
 786       if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
 787           && PROC_FRAME_OFFSET (proc_desc) == 0)
 788         return 0;
 789     }
 790
 791   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 792     return 0;                   /* Unknown */
 793
 794   sal = find_pc_line (func_addr, 0);
 795
 796   if (sal.end < func_end)
 797     return sal.end;
 798
 799   /* The line after the prologue is after the end of the function.  In this
 800      case, tell the caller to find the prologue the hard way.  */
 801
 802   return 0;
 803 }
 804
 805 /* Decode a MIPS32 instruction that saves a register in the stack, and
 806    set the appropriate bit in the general register mask or float register mask
 807    to indicate which register is saved.  This is a helper function
 808    for mips_find_saved_regs.  */
 809
 810 static void
 811 mips32_decode_reg_save (t_inst inst, unsigned long *gen_mask,
 812                         unsigned long *float_mask)
 813 {
 814   int reg;
 815
 816   if ((inst & 0xffe00000) == 0xafa00000         /* sw reg,n($sp) */
 817       || (inst & 0xffe00000) == 0xafc00000      /* sw reg,n($r30) */
 818       || (inst & 0xffe00000) == 0xffa00000)     /* sd reg,n($sp) */
 819     {
 820       /* It might be possible to use the instruction to
 821          find the offset, rather than the code below which
 822          is based on things being in a certain order in the
 823          frame, but figuring out what the instruction's offset
 824          is relative to might be a little tricky.  */
 825       reg = (inst & 0x001f0000) >> 16;
 826       *gen_mask |= (1 << reg);
 827     }
 828   else if ((inst & 0xffe00000) == 0xe7a00000    /* swc1 freg,n($sp) */
 829            || (inst & 0xffe00000) == 0xe7c00000         /* swc1 freg,n($r30) */
 830            || (inst & 0xffe00000) == 0xf7a00000)        /* sdc1 freg,n($sp) */
 831
 832     {
 833       reg = ((inst & 0x001f0000) >> 16);
 834       *float_mask |= (1 << reg);
 835     }
 836 }
 837
 838 /* Decode a MIPS16 instruction that saves a register in the stack, and
 839    set the appropriate bit in the general register or float register mask
 840    to indicate which register is saved.  This is a helper function
 841    for mips_find_saved_regs.  */
 842
 843 static void
 844 mips16_decode_reg_save (t_inst inst, unsigned long *gen_mask)
 845 {
 846   if ((inst & 0xf800) == 0xd000)        /* sw reg,n($sp) */
 847     {
 848       int reg = mips16_to_32_reg[(inst & 0x700) >> 8];
 849       *gen_mask |= (1 << reg);
 850     }
 851   else if ((inst & 0xff00) == 0xf900)   /* sd reg,n($sp) */
 852     {
 853       int reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
 854       *gen_mask |= (1 << reg);
 855     }
 856   else if ((inst & 0xff00) == 0x6200    /* sw $ra,n($sp) */
 857            || (inst & 0xff00) == 0xfa00)        /* sd $ra,n($sp) */
 858     *gen_mask |= (1 << RA_REGNUM);
 859 }
 860
 861
 862 /* Fetch and return instruction from the specified location.  If the PC
 863    is odd, assume it's a MIPS16 instruction; otherwise MIPS32.  */
 864
 865 static t_inst
 866 mips_fetch_instruction (CORE_ADDR addr)
 867 {
 868   char buf[MIPS_INSTLEN];
 869   int instlen;
 870   int status;
 871
 872   if (pc_is_mips16 (addr))
 873     {
 874       instlen = MIPS16_INSTLEN;
 875       addr = UNMAKE_MIPS16_ADDR (addr);
 876     }
 877   else
 878     instlen = MIPS_INSTLEN;
 879   status = read_memory_nobpt (addr, buf, instlen);
 880   if (status)
 881     memory_error (status, addr);
 882   return extract_unsigned_integer (buf, instlen);
 883 }
 884
 885
 886 /* These the fields of 32 bit mips instructions */
 887 #define mips32_op(x) (x >> 26)
 888 #define itype_op(x) (x >> 26)
 889 #define itype_rs(x) ((x >> 21) & 0x1f)
 890 #define itype_rt(x) ((x >> 16) & 0x1f)
 891 #define itype_immediate(x) (x & 0xffff)
 892
 893 #define jtype_op(x) (x >> 26)
 894 #define jtype_target(x) (x & 0x03ffffff)
 895
 896 #define rtype_op(x) (x >> 26)
 897 #define rtype_rs(x) ((x >> 21) & 0x1f)
 898 #define rtype_rt(x) ((x >> 16) & 0x1f)
 899 #define rtype_rd(x) ((x >> 11) & 0x1f)
 900 #define rtype_shamt(x) ((x >> 6) & 0x1f)
 901 #define rtype_funct(x) (x & 0x3f)
 902
 903 static CORE_ADDR
 904 mips32_relative_offset (unsigned long inst)
 905 {
 906   long x;
 907   x = itype_immediate (inst);
 908   if (x & 0x8000)               /* sign bit set */
 909     {
 910       x |= 0xffff0000;          /* sign extension */
 911     }
 912   x = x << 2;
 913   return x;
 914 }
 915
 916 /* Determine whate to set a single step breakpoint while considering
 917    branch prediction */
 918 CORE_ADDR
 919 mips32_next_pc (CORE_ADDR pc)
 920 {
 921   unsigned long inst;
 922   int op;
 923   inst = mips_fetch_instruction (pc);
 924   if ((inst & 0xe0000000) != 0) /* Not a special, jump or branch instruction */
 925     {
 926       if (itype_op (inst) >> 2 == 5)
 927                                 /* BEQL, BNEL, BLEZL, BGTZL: bits 0101xx */
 928         {
 929           op = (itype_op (inst) & 0x03);
 930           switch (op)
 931             {
 932             case 0:             /* BEQL */
 933               goto equal_branch;
 934             case 1:             /* BNEL */
 935               goto neq_branch;
 936             case 2:             /* BLEZL */
 937               goto less_branch;
 938             case 3:             /* BGTZ */
 939               goto greater_branch;
 940             default:
 941               pc += 4;
 942             }
 943         }
 944       else if (itype_op (inst) == 17 && itype_rs (inst) == 8)
 945                                 /* BC1F, BC1FL, BC1T, BC1TL: 010001 01000 */
 946         {
 947           int tf = itype_rt (inst) & 0x01;
 948           int cnum = itype_rt (inst) >> 2;
 949           int fcrcs = read_signed_register (FCRCS_REGNUM);
 950           int cond = ((fcrcs >> 24) & 0x0e) | ((fcrcs >> 23) & 0x01);
 951
 952           if (((cond >> cnum) & 0x01) == tf)
 953             pc += mips32_relative_offset (inst) + 4;
 954           else
 955             pc += 8;
 956         }
 957       else
 958         pc += 4;                /* Not a branch, next instruction is easy */
 959     }
 960   else
 961     {                           /* This gets way messy */
 962
 963       /* Further subdivide into SPECIAL, REGIMM and other */
 964       switch (op = itype_op (inst) & 0x07)      /* extract bits 28,27,26 */
 965         {
 966         case 0:         /* SPECIAL */
 967           op = rtype_funct (inst);
 968           switch (op)
 969             {
 970             case 8:             /* JR */
 971             case 9:             /* JALR */
 972               /* Set PC to that address */
 973               pc = read_signed_register (rtype_rs (inst));
 974               break;
 975             default:
 976               pc += 4;
 977             }
 978
 979           break;        /* end SPECIAL */
 980         case 1:         /* REGIMM */
 981           {
 982             op = itype_rt (inst);       /* branch condition */
 983             switch (op)
 984               {
 985               case 0:           /* BLTZ */
 986               case 2:           /* BLTZL */
 987               case 16:          /* BLTZAL */
 988               case 18:          /* BLTZALL */
 989               less_branch:
 990                 if (read_signed_register (itype_rs (inst)) < 0)
 991                   pc += mips32_relative_offset (inst) + 4;
 992                 else
 993                   pc += 8;      /* after the delay slot */
 994                 break;
 995               case 1:           /* BGEZ */
 996               case 3:           /* BGEZL */
 997               case 17:          /* BGEZAL */
 998               case 19:          /* BGEZALL */
 999               greater_equal_branch:
1000                 if (read_signed_register (itype_rs (inst)) >= 0)
1001                   pc += mips32_relative_offset (inst) + 4;
1002                 else
1003                   pc += 8;      /* after the delay slot */
1004                 break;
1005                 /* All of the other instructions in the REGIMM category */
1006               default:
1007                 pc += 4;
1008               }
1009           }
1010           break;        /* end REGIMM */
1011         case 2:         /* J */
1012         case 3:         /* JAL */
1013           {
1014             unsigned long reg;
1015             reg = jtype_target (inst) << 2;
1016             /* Upper four bits get never changed... */
1017             pc = reg + ((pc + 4) & 0xf0000000);
1018           }
1019           break;
1020           /* FIXME case JALX : */
1021           {
1022             unsigned long reg;
1023             reg = jtype_target (inst) << 2;
1024             pc = reg + ((pc + 4) & 0xf0000000) + 1;     /* yes, +1 */
1025             /* Add 1 to indicate 16 bit mode - Invert ISA mode */
1026           }
1027           break;                /* The new PC will be alternate mode */
1028         case 4:         /* BEQ, BEQL */
1029         equal_branch:
1030           if (read_signed_register (itype_rs (inst)) ==
1031               read_signed_register (itype_rt (inst)))
1032             pc += mips32_relative_offset (inst) + 4;
1033           else
1034             pc += 8;
1035           break;
1036         case 5:         /* BNE, BNEL */
1037         neq_branch:
1038           if (read_signed_register (itype_rs (inst)) !=
1039               read_signed_register (itype_rt (inst)))
1040             pc += mips32_relative_offset (inst) + 4;
1041           else
1042             pc += 8;
1043           break;
1044         case 6:         /* BLEZ, BLEZL */
1045         less_zero_branch:
1046           if (read_signed_register (itype_rs (inst) <= 0))
1047             pc += mips32_relative_offset (inst) + 4;
1048           else
1049             pc += 8;
1050           break;
1051         case 7:
1052         default:
1053         greater_branch: /* BGTZ, BGTZL */
1054           if (read_signed_register (itype_rs (inst) > 0))
1055             pc += mips32_relative_offset (inst) + 4;
1056           else
1057             pc += 8;
1058           break;
1059         }                       /* switch */
1060     }                           /* else */
1061   return pc;
1062 }                               /* mips32_next_pc */
1063
1064 /* Decoding the next place to set a breakpoint is irregular for the
1065    mips 16 variant, but fortunately, there fewer instructions. We have to cope
1066    ith extensions for 16 bit instructions and a pair of actual 32 bit instructions.
1067    We dont want to set a single step instruction on the extend instruction
1068    either.
1069  */
1070
1071 /* Lots of mips16 instruction formats */
1072 /* Predicting jumps requires itype,ritype,i8type
1073    and their extensions      extItype,extritype,extI8type
1074  */
1075 enum mips16_inst_fmts
1076 {
1077   itype,                        /* 0  immediate 5,10 */
1078   ritype,                       /* 1   5,3,8 */
1079   rrtype,                       /* 2   5,3,3,5 */
1080   rritype,                      /* 3   5,3,3,5 */
1081   rrrtype,                      /* 4   5,3,3,3,2 */
1082   rriatype,                     /* 5   5,3,3,1,4 */
1083   shifttype,                    /* 6   5,3,3,3,2 */
1084   i8type,                       /* 7   5,3,8 */
1085   i8movtype,                    /* 8   5,3,3,5 */
1086   i8mov32rtype,                 /* 9   5,3,5,3 */
1087   i64type,                      /* 10  5,3,8 */
1088   ri64type,                     /* 11  5,3,3,5 */
1089   jalxtype,                     /* 12  5,1,5,5,16 - a 32 bit instruction */
1090   exiItype,                     /* 13  5,6,5,5,1,1,1,1,1,1,5 */
1091   extRitype,                    /* 14  5,6,5,5,3,1,1,1,5 */
1092   extRRItype,                   /* 15  5,5,5,5,3,3,5 */
1093   extRRIAtype,                  /* 16  5,7,4,5,3,3,1,4 */
1094   EXTshifttype,                 /* 17  5,5,1,1,1,1,1,1,5,3,3,1,1,1,2 */
1095   extI8type,                    /* 18  5,6,5,5,3,1,1,1,5 */
1096   extI64type,                   /* 19  5,6,5,5,3,1,1,1,5 */
1097   extRi64type,                  /* 20  5,6,5,5,3,3,5 */
1098   extshift64type                /* 21  5,5,1,1,1,1,1,1,5,1,1,1,3,5 */
1099 };
1100 /* I am heaping all the fields of the formats into one structure and
1101    then, only the fields which are involved in instruction extension */
1102 struct upk_mips16
1103   {
1104     CORE_ADDR offset;
1105     unsigned int regx;          /* Function in i8 type */
1106     unsigned int regy;
1107   };
1108
1109
1110 /* The EXT-I, EXT-ri nad EXT-I8 instructions all have the same format
1111    for the bits which make up the immediatate extension.  */
1112
1113 static CORE_ADDR
1114 extended_offset (unsigned int extension)
1115 {
1116   CORE_ADDR value;
1117   value = (extension >> 21) & 0x3f;     /* * extract 15:11 */
1118   value = value << 6;
1119   value |= (extension >> 16) & 0x1f;    /* extrace 10:5 */
1120   value = value << 5;
1121   value |= extension & 0x01f;   /* extract 4:0 */
1122   return value;
1123 }
1124
1125 /* Only call this function if you know that this is an extendable
1126    instruction, It wont malfunction, but why make excess remote memory references?
1127    If the immediate operands get sign extended or somthing, do it after
1128    the extension is performed.
1129  */
1130 /* FIXME: Every one of these cases needs to worry about sign extension
1131    when the offset is to be used in relative addressing */
1132
1133
1134 static unsigned int
1135 fetch_mips_16 (CORE_ADDR pc)
1136 {
1137   char buf[8];
1138   pc &= 0xfffffffe;             /* clear the low order bit */
1139   target_read_memory (pc, buf, 2);
1140   return extract_unsigned_integer (buf, 2);
1141 }
1142
1143 static void
1144 unpack_mips16 (CORE_ADDR pc,
1145                unsigned int extension,
1146                unsigned int inst,
1147                enum mips16_inst_fmts insn_format,
1148                struct upk_mips16 *upk)
1149 {
1150   CORE_ADDR offset;
1151   int regx;
1152   int regy;
1153   switch (insn_format)
1154     {
1155     case itype:
1156       {
1157         CORE_ADDR value;
1158         if (extension)
1159           {
1160             value = extended_offset (extension);
1161             value = value << 11;        /* rom for the original value */
1162             value |= inst & 0x7ff;              /* eleven bits from instruction */
1163           }
1164         else
1165           {
1166             value = inst & 0x7ff;
1167             /* FIXME : Consider sign extension */
1168           }
1169         offset = value;
1170         regx = -1;
1171         regy = -1;
1172       }
1173       break;
1174     case ritype:
1175     case i8type:
1176       {                         /* A register identifier and an offset */
1177         /* Most of the fields are the same as I type but the
1178            immediate value is of a different length */
1179         CORE_ADDR value;
1180         if (extension)
1181           {
1182             value = extended_offset (extension);
1183             value = value << 8; /* from the original instruction */
1184             value |= inst & 0xff;       /* eleven bits from instruction */
1185             regx = (extension >> 8) & 0x07;     /* or i8 funct */
1186             if (value & 0x4000) /* test the sign bit , bit 26 */
1187               {
1188                 value &= ~0x3fff;       /* remove the sign bit */
1189                 value = -value;
1190               }
1191           }
1192         else
1193           {
1194             value = inst & 0xff;        /* 8 bits */
1195             regx = (inst >> 8) & 0x07;  /* or i8 funct */
1196             /* FIXME: Do sign extension , this format needs it */
1197             if (value & 0x80)   /* THIS CONFUSES ME */
1198               {
1199                 value &= 0xef;  /* remove the sign bit */
1200                 value = -value;
1201               }
1202           }
1203         offset = value;
1204         regy = -1;
1205         break;
1206       }
1207     case jalxtype:
1208       {
1209         unsigned long value;
1210         unsigned int nexthalf;
1211         value = ((inst & 0x1f) << 5) | ((inst >> 5) & 0x1f);
1212         value = value << 16;
1213         nexthalf = mips_fetch_instruction (pc + 2);     /* low bit still set */
1214         value |= nexthalf;
1215         offset = value;
1216         regx = -1;
1217         regy = -1;
1218         break;
1219       }
1220     default:
1221       internal_error (__FILE__, __LINE__,
1222                       "bad switch");
1223     }
1224   upk->offset = offset;
1225   upk->regx = regx;
1226   upk->regy = regy;
1227 }
1228
1229
1230 static CORE_ADDR
1231 add_offset_16 (CORE_ADDR pc, int offset)
1232 {
1233   return ((offset << 2) | ((pc + 2) & (0xf0000000)));
1234 }
1235
1236 static CORE_ADDR
1237 extended_mips16_next_pc (CORE_ADDR pc,
1238                          unsigned int extension,
1239                          unsigned int insn)
1240 {
1241   int op = (insn >> 11);
1242   switch (op)
1243     {
1244     case 2:             /* Branch */
1245       {
1246         CORE_ADDR offset;
1247         struct upk_mips16 upk;
1248         unpack_mips16 (pc, extension, insn, itype, &upk);
1249         offset = upk.offset;
1250         if (offset & 0x800)
1251           {
1252             offset &= 0xeff;
1253             offset = -offset;
1254           }
1255         pc += (offset << 1) + 2;
1256         break;
1257       }
1258     case 3:             /* JAL , JALX - Watch out, these are 32 bit instruction */
1259       {
1260         struct upk_mips16 upk;
1261         unpack_mips16 (pc, extension, insn, jalxtype, &upk);
1262         pc = add_offset_16 (pc, upk.offset);
1263         if ((insn >> 10) & 0x01)        /* Exchange mode */
1264           pc = pc & ~0x01;      /* Clear low bit, indicate 32 bit mode */
1265         else
1266           pc |= 0x01;
1267         break;
1268       }
1269     case 4:             /* beqz */
1270       {
1271         struct upk_mips16 upk;
1272         int reg;
1273         unpack_mips16 (pc, extension, insn, ritype, &upk);
1274         reg = read_signed_register (upk.regx);
1275         if (reg == 0)
1276           pc += (upk.offset << 1) + 2;
1277         else
1278           pc += 2;
1279         break;
1280       }
1281     case 5:             /* bnez */
1282       {
1283         struct upk_mips16 upk;
1284         int reg;
1285         unpack_mips16 (pc, extension, insn, ritype, &upk);
1286         reg = read_signed_register (upk.regx);
1287         if (reg != 0)
1288           pc += (upk.offset << 1) + 2;
1289         else
1290           pc += 2;
1291         break;
1292       }
1293     case 12:            /* I8 Formats btez btnez */
1294       {
1295         struct upk_mips16 upk;
1296         int reg;
1297         unpack_mips16 (pc, extension, insn, i8type, &upk);
1298         /* upk.regx contains the opcode */
1299         reg = read_signed_register (24);        /* Test register is 24 */
1300         if (((upk.regx == 0) && (reg == 0))     /* BTEZ */
1301             || ((upk.regx == 1) && (reg != 0))) /* BTNEZ */
1302           /* pc = add_offset_16(pc,upk.offset) ; */
1303           pc += (upk.offset << 1) + 2;
1304         else
1305           pc += 2;
1306         break;
1307       }
1308     case 29:            /* RR Formats JR, JALR, JALR-RA */
1309       {
1310         struct upk_mips16 upk;
1311         /* upk.fmt = rrtype; */
1312         op = insn & 0x1f;
1313         if (op == 0)
1314           {
1315             int reg;
1316             upk.regx = (insn >> 8) & 0x07;
1317             upk.regy = (insn >> 5) & 0x07;
1318             switch (upk.regy)
1319               {
1320               case 0:
1321                 reg = upk.regx;
1322                 break;
1323               case 1:
1324                 reg = 31;
1325                 break;  /* Function return instruction */
1326               case 2:
1327                 reg = upk.regx;
1328                 break;
1329               default:
1330                 reg = 31;
1331                 break;  /* BOGUS Guess */
1332               }
1333             pc = read_signed_register (reg);
1334           }
1335         else
1336           pc += 2;
1337         break;
1338       }
1339     case 30:
1340       /* This is an instruction extension.  Fetch the real instruction
1341          (which follows the extension) and decode things based on
1342          that. */
1343       {
1344         pc += 2;
1345         pc = extended_mips16_next_pc (pc, insn, fetch_mips_16 (pc));
1346         break;
1347       }
1348     default:
1349       {
1350         pc += 2;
1351         break;
1352       }
1353     }
1354   return pc;
1355 }
1356
1357 CORE_ADDR
1358 mips16_next_pc (CORE_ADDR pc)
1359 {
1360   unsigned int insn = fetch_mips_16 (pc);
1361   return extended_mips16_next_pc (pc, 0, insn);
1362 }
1363
1364 /* The mips_next_pc function supports single_step when the remote
1365    target monitor or stub is not developed enough to do a single_step.
1366    It works by decoding the current instruction and predicting where a
1367    branch will go. This isnt hard because all the data is available.
1368    The MIPS32 and MIPS16 variants are quite different */
1369 CORE_ADDR
1370 mips_next_pc (CORE_ADDR pc)
1371 {
1372   if (pc & 0x01)
1373     return mips16_next_pc (pc);
1374   else
1375     return mips32_next_pc (pc);
1376 }
1377
1378 /* Guaranteed to set fci->saved_regs to some values (it never leaves it
1379    NULL).
1380
1381    Note: kevinb/2002-08-09: The only caller of this function is (and
1382    should remain) mips_frame_init_saved_regs().  In fact,
1383    aside from calling mips_find_saved_regs(), mips_frame_init_saved_regs()
1384    does nothing more than set frame->saved_regs[SP_REGNUM].  These two
1385    functions should really be combined and now that there is only one
1386    caller, it should be straightforward.  (Watch out for multiple returns
1387    though.)  */
1388
1389 static void
1390 mips_find_saved_regs (struct frame_info *fci)
1391 {
1392   int ireg;
1393   CORE_ADDR reg_position;
1394   /* r0 bit means kernel trap */
1395   int kernel_trap;
1396   /* What registers have been saved?  Bitmasks.  */
1397   unsigned long gen_mask, float_mask;
1398   mips_extra_func_info_t proc_desc;
1399   t_inst inst;
1400
1401   frame_saved_regs_zalloc (fci);
1402
1403   /* If it is the frame for sigtramp, the saved registers are located
1404      in a sigcontext structure somewhere on the stack.
1405      If the stack layout for sigtramp changes we might have to change these
1406      constants and the companion fixup_sigtramp in mdebugread.c  */
1407 #ifndef SIGFRAME_BASE
1408 /* To satisfy alignment restrictions, sigcontext is located 4 bytes
1409    above the sigtramp frame.  */
1410 #define SIGFRAME_BASE           MIPS_REGSIZE
1411 /* FIXME!  Are these correct?? */
1412 #define SIGFRAME_PC_OFF         (SIGFRAME_BASE + 2 * MIPS_REGSIZE)
1413 #define SIGFRAME_REGSAVE_OFF    (SIGFRAME_BASE + 3 * MIPS_REGSIZE)
1414 #define SIGFRAME_FPREGSAVE_OFF  \
1415         (SIGFRAME_REGSAVE_OFF + MIPS_NUMREGS * MIPS_REGSIZE + 3 * MIPS_REGSIZE)
1416 #endif
1417 #ifndef SIGFRAME_REG_SIZE
1418 /* FIXME!  Is this correct?? */
1419 #define SIGFRAME_REG_SIZE       MIPS_REGSIZE
1420 #endif
1421   if (fci->signal_handler_caller)
1422     {
1423       for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
1424         {
1425           reg_position = fci->frame + SIGFRAME_REGSAVE_OFF
1426             + ireg * SIGFRAME_REG_SIZE;
1427           fci->saved_regs[ireg] = reg_position;
1428         }
1429       for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
1430         {
1431           reg_position = fci->frame + SIGFRAME_FPREGSAVE_OFF
1432             + ireg * SIGFRAME_REG_SIZE;
1433           fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
1434         }
1435       fci->saved_regs[PC_REGNUM] = fci->frame + SIGFRAME_PC_OFF;
1436       return;
1437     }
1438
1439   proc_desc = fci->extra_info->proc_desc;
1440   if (proc_desc == NULL)
1441     /* I'm not sure how/whether this can happen.  Normally when we can't
1442        find a proc_desc, we "synthesize" one using heuristic_proc_desc
1443        and set the saved_regs right away.  */
1444     return;
1445
1446   kernel_trap = PROC_REG_MASK (proc_desc) & 1;
1447   gen_mask = kernel_trap ? 0xFFFFFFFF : PROC_REG_MASK (proc_desc);
1448   float_mask = kernel_trap ? 0xFFFFFFFF : PROC_FREG_MASK (proc_desc);
1449
1450   if (                          /* In any frame other than the innermost or a frame interrupted by
1451                                    a signal, we assume that all registers have been saved.
1452                                    This assumes that all register saves in a function happen before
1453                                    the first function call.  */
1454        (fci->next == NULL || fci->next->signal_handler_caller)
1455
1456   /* In a dummy frame we know exactly where things are saved.  */
1457        && !PROC_DESC_IS_DUMMY (proc_desc)
1458
1459   /* Don't bother unless we are inside a function prologue.  Outside the
1460      prologue, we know where everything is. */
1461
1462        && in_prologue (fci->pc, PROC_LOW_ADDR (proc_desc))
1463
1464   /* Not sure exactly what kernel_trap means, but if it means
1465      the kernel saves the registers without a prologue doing it,
1466      we better not examine the prologue to see whether registers
1467      have been saved yet.  */
1468        && !kernel_trap)
1469     {
1470       /* We need to figure out whether the registers that the proc_desc
1471          claims are saved have been saved yet.  */
1472
1473       CORE_ADDR addr;
1474
1475       /* Bitmasks; set if we have found a save for the register.  */
1476       unsigned long gen_save_found = 0;
1477       unsigned long float_save_found = 0;
1478       int instlen;
1479
1480       /* If the address is odd, assume this is MIPS16 code.  */
1481       addr = PROC_LOW_ADDR (proc_desc);
1482       instlen = pc_is_mips16 (addr) ? MIPS16_INSTLEN : MIPS_INSTLEN;
1483
1484       /* Scan through this function's instructions preceding the current
1485          PC, and look for those that save registers.  */
1486       while (addr < fci->pc)
1487         {
1488           inst = mips_fetch_instruction (addr);
1489           if (pc_is_mips16 (addr))
1490             mips16_decode_reg_save (inst, &gen_save_found);
1491           else
1492             mips32_decode_reg_save (inst, &gen_save_found, &float_save_found);
1493           addr += instlen;
1494         }
1495       gen_mask = gen_save_found;
1496       float_mask = float_save_found;
1497     }
1498
1499   /* Fill in the offsets for the registers which gen_mask says
1500      were saved.  */
1501   reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
1502   for (ireg = MIPS_NUMREGS - 1; gen_mask; --ireg, gen_mask <<= 1)
1503     if (gen_mask & 0x80000000)
1504       {
1505         fci->saved_regs[ireg] = reg_position;
1506         reg_position -= MIPS_SAVED_REGSIZE;
1507       }
1508
1509   /* The MIPS16 entry instruction saves $s0 and $s1 in the reverse order
1510      of that normally used by gcc.  Therefore, we have to fetch the first
1511      instruction of the function, and if it's an entry instruction that
1512      saves $s0 or $s1, correct their saved addresses.  */
1513   if (pc_is_mips16 (PROC_LOW_ADDR (proc_desc)))
1514     {
1515       inst = mips_fetch_instruction (PROC_LOW_ADDR (proc_desc));
1516       if ((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)         /* entry */
1517         {
1518           int reg;
1519           int sreg_count = (inst >> 6) & 3;
1520
1521           /* Check if the ra register was pushed on the stack.  */
1522           reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
1523           if (inst & 0x20)
1524             reg_position -= MIPS_SAVED_REGSIZE;
1525
1526           /* Check if the s0 and s1 registers were pushed on the stack.  */
1527           for (reg = 16; reg < sreg_count + 16; reg++)
1528             {
1529               fci->saved_regs[reg] = reg_position;
1530               reg_position -= MIPS_SAVED_REGSIZE;
1531             }
1532         }
1533     }
1534
1535   /* Fill in the offsets for the registers which float_mask says
1536      were saved.  */
1537   reg_position = fci->frame + PROC_FREG_OFFSET (proc_desc);
1538
1539   /* Apparently, the freg_offset gives the offset to the first 64 bit
1540      saved.
1541
1542      When the ABI specifies 64 bit saved registers, the FREG_OFFSET
1543      designates the first saved 64 bit register.
1544
1545      When the ABI specifies 32 bit saved registers, the ``64 bit saved
1546      DOUBLE'' consists of two adjacent 32 bit registers, Hence
1547      FREG_OFFSET, designates the address of the lower register of the
1548      register pair.  Adjust the offset so that it designates the upper
1549      register of the pair -- i.e., the address of the first saved 32
1550      bit register.  */
1551
1552   if (MIPS_SAVED_REGSIZE == 4)
1553     reg_position += MIPS_SAVED_REGSIZE;
1554
1555   /* Fill in the offsets for the float registers which float_mask says
1556      were saved.  */
1557   for (ireg = MIPS_NUMREGS - 1; float_mask; --ireg, float_mask <<= 1)
1558     if (float_mask & 0x80000000)
1559       {
1560         fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
1561         reg_position -= MIPS_SAVED_REGSIZE;
1562       }
1563
1564   fci->saved_regs[PC_REGNUM] = fci->saved_regs[RA_REGNUM];
1565 }
1566
1567 /* Set up the 'saved_regs' array.  This is a data structure containing
1568    the addresses on the stack where each register has been saved, for
1569    each stack frame.  Registers that have not been saved will have
1570    zero here.  The stack pointer register is special:  rather than the
1571    address where the stack register has been saved, saved_regs[SP_REGNUM]
1572    will have the actual value of the previous frame's stack register.  */
1573
1574 static void
1575 mips_frame_init_saved_regs (struct frame_info *frame)
1576 {
1577   if (frame->saved_regs == NULL)
1578     {
1579       mips_find_saved_regs (frame);
1580     }
1581   frame->saved_regs[SP_REGNUM] = frame->frame;
1582 }
1583
1584 static CORE_ADDR
1585 read_next_frame_reg (struct frame_info *fi, int regno)
1586 {
1587   for (; fi; fi = fi->next)
1588     {
1589       /* We have to get the saved sp from the sigcontext
1590          if it is a signal handler frame.  */
1591       if (regno == SP_REGNUM && !fi->signal_handler_caller)
1592         return fi->frame;
1593       else
1594         {
1595           if (fi->saved_regs == NULL)
1596             FRAME_INIT_SAVED_REGS (fi);
1597           if (fi->saved_regs[regno])
1598             return read_memory_integer (ADDR_BITS_REMOVE (fi->saved_regs[regno]), MIPS_SAVED_REGSIZE);
1599         }
1600     }
1601   return read_signed_register (regno);
1602 }
1603
1604 /* mips_addr_bits_remove - remove useless address bits  */
1605
1606 static CORE_ADDR
1607 mips_addr_bits_remove (CORE_ADDR addr)
1608 {
1609   if (GDB_TARGET_IS_MIPS64)
1610     {
1611       if (mips_mask_address_p () && (addr >> 32 == (CORE_ADDR) 0xffffffff))
1612         {
1613           /* This hack is a work-around for existing boards using
1614              PMON, the simulator, and any other 64-bit targets that
1615              doesn't have true 64-bit addressing.  On these targets,
1616              the upper 32 bits of addresses are ignored by the
1617              hardware.  Thus, the PC or SP are likely to have been
1618              sign extended to all 1s by instruction sequences that
1619              load 32-bit addresses.  For example, a typical piece of
1620              code that loads an address is this:
1621                  lui $r2, <upper 16 bits>
1622                  ori $r2, <lower 16 bits>
1623              But the lui sign-extends the value such that the upper 32
1624              bits may be all 1s.  The workaround is simply to mask off
1625              these bits.  In the future, gcc may be changed to support
1626              true 64-bit addressing, and this masking will have to be
1627              disabled.  */
1628           addr &= (CORE_ADDR) 0xffffffff;
1629         }
1630     }
1631   else if (mips_mask_address_p ())
1632     {
1633       /* FIXME: This is wrong!  mips_addr_bits_remove() shouldn't be
1634          masking off bits, instead, the actual target should be asking
1635          for the address to be converted to a valid pointer. */
1636       /* Even when GDB is configured for some 32-bit targets
1637          (e.g. mips-elf), BFD is configured to handle 64-bit targets,
1638          so CORE_ADDR is 64 bits.  So we still have to mask off
1639          useless bits from addresses.  */
1640       addr &= (CORE_ADDR) 0xffffffff;
1641     }
1642   return addr;
1643 }
1644
1645 /* mips_software_single_step() is called just before we want to resume
1646    the inferior, if we want to single-step it but there is no hardware
1647    or kernel single-step support (MIPS on GNU/Linux for example).  We find
1648    the target of the coming instruction and breakpoint it.
1649
1650    single_step is also called just after the inferior stops.  If we had
1651    set up a simulated single-step, we undo our damage.  */
1652
1653 void
1654 mips_software_single_step (enum target_signal sig, int insert_breakpoints_p)
1655 {
1656   static CORE_ADDR next_pc;
1657   typedef char binsn_quantum[BREAKPOINT_MAX];
1658   static binsn_quantum break_mem;
1659   CORE_ADDR pc;
1660
1661   if (insert_breakpoints_p)
1662     {
1663       pc = read_register (PC_REGNUM);
1664       next_pc = mips_next_pc (pc);
1665
1666       target_insert_breakpoint (next_pc, break_mem);
1667     }
1668   else
1669     target_remove_breakpoint (next_pc, break_mem);
1670 }
1671
1672 static void
1673 mips_init_frame_pc_first (int fromleaf, struct frame_info *prev)
1674 {
1675   CORE_ADDR pc, tmp;
1676
1677   pc = ((fromleaf) ? SAVED_PC_AFTER_CALL (prev->next) :
1678         prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
1679   tmp = mips_skip_stub (pc);
1680   prev->pc = tmp ? tmp : pc;
1681 }
1682
1683
1684 static CORE_ADDR
1685 mips_frame_saved_pc (struct frame_info *frame)
1686 {
1687   CORE_ADDR saved_pc;
1688   mips_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
1689   /* We have to get the saved pc from the sigcontext
1690      if it is a signal handler frame.  */
1691   int pcreg = frame->signal_handler_caller ? PC_REGNUM
1692   : (proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM);
1693
1694   if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))
1695     saved_pc = read_memory_integer (frame->frame - MIPS_SAVED_REGSIZE, MIPS_SAVED_REGSIZE);
1696   else
1697     saved_pc = read_next_frame_reg (frame, pcreg);
1698
1699   return ADDR_BITS_REMOVE (saved_pc);
1700 }
1701
1702 static struct mips_extra_func_info temp_proc_desc;
1703 static CORE_ADDR temp_saved_regs[NUM_REGS];
1704
1705 /* Set a register's saved stack address in temp_saved_regs.  If an address
1706    has already been set for this register, do nothing; this way we will
1707    only recognize the first save of a given register in a function prologue.
1708    This is a helper function for mips{16,32}_heuristic_proc_desc.  */
1709
1710 static void
1711 set_reg_offset (int regno, CORE_ADDR offset)
1712 {
1713   if (temp_saved_regs[regno] == 0)
1714     temp_saved_regs[regno] = offset;
1715 }
1716
1717
1718 /* Test whether the PC points to the return instruction at the
1719    end of a function. */
1720
1721 static int
1722 mips_about_to_return (CORE_ADDR pc)
1723 {
1724   if (pc_is_mips16 (pc))
1725     /* This mips16 case isn't necessarily reliable.  Sometimes the compiler
1726        generates a "jr $ra"; other times it generates code to load
1727        the return address from the stack to an accessible register (such
1728        as $a3), then a "jr" using that register.  This second case
1729        is almost impossible to distinguish from an indirect jump
1730        used for switch statements, so we don't even try.  */
1731     return mips_fetch_instruction (pc) == 0xe820;       /* jr $ra */
1732   else
1733     return mips_fetch_instruction (pc) == 0x3e00008;    /* jr $ra */
1734 }
1735
1736
1737 /* This fencepost looks highly suspicious to me.  Removing it also
1738    seems suspicious as it could affect remote debugging across serial
1739    lines.  */
1740
1741 static CORE_ADDR
1742 heuristic_proc_start (CORE_ADDR pc)
1743 {
1744   CORE_ADDR start_pc;
1745   CORE_ADDR fence;
1746   int instlen;
1747   int seen_adjsp = 0;
1748
1749   pc = ADDR_BITS_REMOVE (pc);
1750   start_pc = pc;
1751   fence = start_pc - heuristic_fence_post;
1752   if (start_pc == 0)
1753     return 0;
1754
1755   if (heuristic_fence_post == UINT_MAX
1756       || fence < VM_MIN_ADDRESS)
1757     fence = VM_MIN_ADDRESS;
1758
1759   instlen = pc_is_mips16 (pc) ? MIPS16_INSTLEN : MIPS_INSTLEN;
1760
1761   /* search back for previous return */
1762   for (start_pc -= instlen;; start_pc -= instlen)
1763     if (start_pc < fence)
1764       {
1765         /* It's not clear to me why we reach this point when
1766            stop_soon_quietly, but with this test, at least we
1767            don't print out warnings for every child forked (eg, on
1768            decstation).  22apr93 rich@cygnus.com.  */
1769         if (!stop_soon_quietly)
1770           {
1771             static int blurb_printed = 0;
1772
1773             warning ("Warning: GDB can't find the start of the function at 0x%s.",
1774                      paddr_nz (pc));
1775
1776             if (!blurb_printed)
1777               {
1778                 /* This actually happens frequently in embedded
1779                    development, when you first connect to a board
1780                    and your stack pointer and pc are nowhere in
1781                    particular.  This message needs to give people
1782                    in that situation enough information to
1783                    determine that it's no big deal.  */
1784                 printf_filtered ("\n\
1785     GDB is unable to find the start of the function at 0x%s\n\
1786 and thus can't determine the size of that function's stack frame.\n\
1787 This means that GDB may be unable to access that stack frame, or\n\
1788 the frames below it.\n\
1789     This problem is most likely caused by an invalid program counter or\n\
1790 stack pointer.\n\
1791     However, if you think GDB should simply search farther back\n\
1792 from 0x%s for code which looks like the beginning of a\n\
1793 function, you can increase the range of the search using the `set\n\
1794 heuristic-fence-post' command.\n",
1795                                  paddr_nz (pc), paddr_nz (pc));
1796                 blurb_printed = 1;
1797               }
1798           }
1799
1800         return 0;
1801       }
1802     else if (pc_is_mips16 (start_pc))
1803       {
1804         unsigned short inst;
1805
1806         /* On MIPS16, any one of the following is likely to be the
1807            start of a function:
1808            entry
1809            addiu sp,-n
1810            daddiu sp,-n
1811            extend -n followed by 'addiu sp,+n' or 'daddiu sp,+n'  */
1812         inst = mips_fetch_instruction (start_pc);
1813         if (((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)      /* entry */
1814             || (inst & 0xff80) == 0x6380        /* addiu sp,-n */
1815             || (inst & 0xff80) == 0xfb80        /* daddiu sp,-n */
1816             || ((inst & 0xf810) == 0xf010 && seen_adjsp))       /* extend -n */
1817           break;
1818         else if ((inst & 0xff00) == 0x6300      /* addiu sp */
1819                  || (inst & 0xff00) == 0xfb00)  /* daddiu sp */
1820           seen_adjsp = 1;
1821         else
1822           seen_adjsp = 0;
1823       }
1824     else if (mips_about_to_return (start_pc))
1825       {
1826         start_pc += 2 * MIPS_INSTLEN;   /* skip return, and its delay slot */
1827         break;
1828       }
1829
1830   return start_pc;
1831 }
1832
1833 /* Fetch the immediate value from a MIPS16 instruction.
1834    If the previous instruction was an EXTEND, use it to extend
1835    the upper bits of the immediate value.  This is a helper function
1836    for mips16_heuristic_proc_desc.  */
1837
1838 static int
1839 mips16_get_imm (unsigned short prev_inst,       /* previous instruction */
1840                 unsigned short inst,    /* current instruction */
1841                 int nbits,              /* number of bits in imm field */
1842                 int scale,              /* scale factor to be applied to imm */
1843                 int is_signed)          /* is the imm field signed? */
1844 {
1845   int offset;
1846
1847   if ((prev_inst & 0xf800) == 0xf000)   /* prev instruction was EXTEND? */
1848     {
1849       offset = ((prev_inst & 0x1f) << 11) | (prev_inst & 0x7e0);
1850       if (offset & 0x8000)      /* check for negative extend */
1851         offset = 0 - (0x10000 - (offset & 0xffff));
1852       return offset | (inst & 0x1f);
1853     }
1854   else
1855     {
1856       int max_imm = 1 << nbits;
1857       int mask = max_imm - 1;
1858       int sign_bit = max_imm >> 1;
1859
1860       offset = inst & mask;
1861       if (is_signed && (offset & sign_bit))
1862         offset = 0 - (max_imm - offset);
1863       return offset * scale;
1864     }
1865 }
1866
1867
1868 /* Fill in values in temp_proc_desc based on the MIPS16 instruction
1869    stream from start_pc to limit_pc.  */
1870
1871 static void
1872 mips16_heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
1873                             struct frame_info *next_frame, CORE_ADDR sp)
1874 {
1875   CORE_ADDR cur_pc;
1876   CORE_ADDR frame_addr = 0;     /* Value of $r17, used as frame pointer */
1877   unsigned short prev_inst = 0; /* saved copy of previous instruction */
1878   unsigned inst = 0;            /* current instruction */
1879   unsigned entry_inst = 0;      /* the entry instruction */
1880   int reg, offset;
1881
1882   PROC_FRAME_OFFSET (&temp_proc_desc) = 0;      /* size of stack frame */
1883   PROC_FRAME_ADJUST (&temp_proc_desc) = 0;      /* offset of FP from SP */
1884
1885   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS16_INSTLEN)
1886     {
1887       /* Save the previous instruction.  If it's an EXTEND, we'll extract
1888          the immediate offset extension from it in mips16_get_imm.  */
1889       prev_inst = inst;
1890
1891       /* Fetch and decode the instruction.   */
1892       inst = (unsigned short) mips_fetch_instruction (cur_pc);
1893       if ((inst & 0xff00) == 0x6300     /* addiu sp */
1894           || (inst & 0xff00) == 0xfb00)         /* daddiu sp */
1895         {
1896           offset = mips16_get_imm (prev_inst, inst, 8, 8, 1);
1897           if (offset < 0)       /* negative stack adjustment? */
1898             PROC_FRAME_OFFSET (&temp_proc_desc) -= offset;
1899           else
1900             /* Exit loop if a positive stack adjustment is found, which
1901                usually means that the stack cleanup code in the function
1902                epilogue is reached.  */
1903             break;
1904         }
1905       else if ((inst & 0xf800) == 0xd000)       /* sw reg,n($sp) */
1906         {
1907           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1908           reg = mips16_to_32_reg[(inst & 0x700) >> 8];
1909           PROC_REG_MASK (&temp_proc_desc) |= (1 << reg);
1910           set_reg_offset (reg, sp + offset);
1911         }
1912       else if ((inst & 0xff00) == 0xf900)       /* sd reg,n($sp) */
1913         {
1914           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
1915           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1916           PROC_REG_MASK (&temp_proc_desc) |= (1 << reg);
1917           set_reg_offset (reg, sp + offset);
1918         }
1919       else if ((inst & 0xff00) == 0x6200)       /* sw $ra,n($sp) */
1920         {
1921           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1922           PROC_REG_MASK (&temp_proc_desc) |= (1 << RA_REGNUM);
1923           set_reg_offset (RA_REGNUM, sp + offset);
1924         }
1925       else if ((inst & 0xff00) == 0xfa00)       /* sd $ra,n($sp) */
1926         {
1927           offset = mips16_get_imm (prev_inst, inst, 8, 8, 0);
1928           PROC_REG_MASK (&temp_proc_desc) |= (1 << RA_REGNUM);
1929           set_reg_offset (RA_REGNUM, sp + offset);
1930         }
1931       else if (inst == 0x673d)  /* move $s1, $sp */
1932         {
1933           frame_addr = sp;
1934           PROC_FRAME_REG (&temp_proc_desc) = 17;
1935         }
1936       else if ((inst & 0xff00) == 0x0100)       /* addiu $s1,sp,n */
1937         {
1938           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1939           frame_addr = sp + offset;
1940           PROC_FRAME_REG (&temp_proc_desc) = 17;
1941           PROC_FRAME_ADJUST (&temp_proc_desc) = offset;
1942         }
1943       else if ((inst & 0xFF00) == 0xd900)       /* sw reg,offset($s1) */
1944         {
1945           offset = mips16_get_imm (prev_inst, inst, 5, 4, 0);
1946           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1947           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1948           set_reg_offset (reg, frame_addr + offset);
1949         }
1950       else if ((inst & 0xFF00) == 0x7900)       /* sd reg,offset($s1) */
1951         {
1952           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
1953           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1954           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1955           set_reg_offset (reg, frame_addr + offset);
1956         }
1957       else if ((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)    /* entry */
1958         entry_inst = inst;      /* save for later processing */
1959       else if ((inst & 0xf800) == 0x1800)       /* jal(x) */
1960         cur_pc += MIPS16_INSTLEN;       /* 32-bit instruction */
1961     }
1962
1963   /* The entry instruction is typically the first instruction in a function,
1964      and it stores registers at offsets relative to the value of the old SP
1965      (before the prologue).  But the value of the sp parameter to this
1966      function is the new SP (after the prologue has been executed).  So we
1967      can't calculate those offsets until we've seen the entire prologue,
1968      and can calculate what the old SP must have been. */
1969   if (entry_inst != 0)
1970     {
1971       int areg_count = (entry_inst >> 8) & 7;
1972       int sreg_count = (entry_inst >> 6) & 3;
1973
1974       /* The entry instruction always subtracts 32 from the SP.  */
1975       PROC_FRAME_OFFSET (&temp_proc_desc) += 32;
1976
1977       /* Now we can calculate what the SP must have been at the
1978          start of the function prologue.  */
1979       sp += PROC_FRAME_OFFSET (&temp_proc_desc);
1980
1981       /* Check if a0-a3 were saved in the caller's argument save area.  */
1982       for (reg = 4, offset = 0; reg < areg_count + 4; reg++)
1983         {
1984           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1985           set_reg_offset (reg, sp + offset);
1986           offset += MIPS_SAVED_REGSIZE;
1987         }
1988
1989       /* Check if the ra register was pushed on the stack.  */
1990       offset = -4;
1991       if (entry_inst & 0x20)
1992         {
1993           PROC_REG_MASK (&temp_proc_desc) |= 1 << RA_REGNUM;
1994           set_reg_offset (RA_REGNUM, sp + offset);
1995           offset -= MIPS_SAVED_REGSIZE;
1996         }
1997
1998       /* Check if the s0 and s1 registers were pushed on the stack.  */
1999       for (reg = 16; reg < sreg_count + 16; reg++)
2000         {
2001           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2002           set_reg_offset (reg, sp + offset);
2003           offset -= MIPS_SAVED_REGSIZE;
2004         }
2005     }
2006 }
2007
2008 static void
2009 mips32_heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
2010                             struct frame_info *next_frame, CORE_ADDR sp)
2011 {
2012   CORE_ADDR cur_pc;
2013   CORE_ADDR frame_addr = 0;     /* Value of $r30. Used by gcc for frame-pointer */
2014 restart:
2015   memset (temp_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
2016   PROC_FRAME_OFFSET (&temp_proc_desc) = 0;
2017   PROC_FRAME_ADJUST (&temp_proc_desc) = 0;      /* offset of FP from SP */
2018   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS_INSTLEN)
2019     {
2020       unsigned long inst, high_word, low_word;
2021       int reg;
2022
2023       /* Fetch the instruction.   */
2024       inst = (unsigned long) mips_fetch_instruction (cur_pc);
2025
2026       /* Save some code by pre-extracting some useful fields.  */
2027       high_word = (inst >> 16) & 0xffff;
2028       low_word = inst & 0xffff;
2029       reg = high_word & 0x1f;
2030
2031       if (high_word == 0x27bd   /* addiu $sp,$sp,-i */
2032           || high_word == 0x23bd        /* addi $sp,$sp,-i */
2033           || high_word == 0x67bd)       /* daddiu $sp,$sp,-i */
2034         {
2035           if (low_word & 0x8000)        /* negative stack adjustment? */
2036             PROC_FRAME_OFFSET (&temp_proc_desc) += 0x10000 - low_word;
2037           else
2038             /* Exit loop if a positive stack adjustment is found, which
2039                usually means that the stack cleanup code in the function
2040                epilogue is reached.  */
2041             break;
2042         }
2043       else if ((high_word & 0xFFE0) == 0xafa0)  /* sw reg,offset($sp) */
2044         {
2045           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2046           set_reg_offset (reg, sp + low_word);
2047         }
2048       else if ((high_word & 0xFFE0) == 0xffa0)  /* sd reg,offset($sp) */
2049         {
2050           /* Irix 6.2 N32 ABI uses sd instructions for saving $gp and $ra,
2051              but the register size used is only 32 bits. Make the address
2052              for the saved register point to the lower 32 bits.  */
2053           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2054           set_reg_offset (reg, sp + low_word + 8 - MIPS_REGSIZE);
2055         }
2056       else if (high_word == 0x27be)     /* addiu $30,$sp,size */
2057         {
2058           /* Old gcc frame, r30 is virtual frame pointer.  */
2059           if ((long) low_word != PROC_FRAME_OFFSET (&temp_proc_desc))
2060             frame_addr = sp + low_word;
2061           else if (PROC_FRAME_REG (&temp_proc_desc) == SP_REGNUM)
2062             {
2063               unsigned alloca_adjust;
2064               PROC_FRAME_REG (&temp_proc_desc) = 30;
2065               frame_addr = read_next_frame_reg (next_frame, 30);
2066               alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
2067               if (alloca_adjust > 0)
2068                 {
2069                   /* FP > SP + frame_size. This may be because
2070                    * of an alloca or somethings similar.
2071                    * Fix sp to "pre-alloca" value, and try again.
2072                    */
2073                   sp += alloca_adjust;
2074                   goto restart;
2075                 }
2076             }
2077         }
2078       /* move $30,$sp.  With different versions of gas this will be either
2079          `addu $30,$sp,$zero' or `or $30,$sp,$zero' or `daddu 30,sp,$0'.
2080          Accept any one of these.  */
2081       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
2082         {
2083           /* New gcc frame, virtual frame pointer is at r30 + frame_size.  */
2084           if (PROC_FRAME_REG (&temp_proc_desc) == SP_REGNUM)
2085             {
2086               unsigned alloca_adjust;
2087               PROC_FRAME_REG (&temp_proc_desc) = 30;
2088               frame_addr = read_next_frame_reg (next_frame, 30);
2089               alloca_adjust = (unsigned) (frame_addr - sp);
2090               if (alloca_adjust > 0)
2091                 {
2092                   /* FP > SP + frame_size. This may be because
2093                    * of an alloca or somethings similar.
2094                    * Fix sp to "pre-alloca" value, and try again.
2095                    */
2096                   sp += alloca_adjust;
2097                   goto restart;
2098                 }
2099             }
2100         }
2101       else if ((high_word & 0xFFE0) == 0xafc0)  /* sw reg,offset($30) */
2102         {
2103           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2104           set_reg_offset (reg, frame_addr + low_word);
2105         }
2106     }
2107 }
2108
2109 static mips_extra_func_info_t
2110 heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
2111                      struct frame_info *next_frame, int cur_frame)
2112 {
2113   CORE_ADDR sp;
2114
2115   if (cur_frame)
2116     sp = read_next_frame_reg (next_frame, SP_REGNUM);
2117   else
2118     sp = 0;
2119
2120   if (start_pc == 0)
2121     return NULL;
2122   memset (&temp_proc_desc, '\0', sizeof (temp_proc_desc));
2123   memset (&temp_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
2124   PROC_LOW_ADDR (&temp_proc_desc) = start_pc;
2125   PROC_FRAME_REG (&temp_proc_desc) = SP_REGNUM;
2126   PROC_PC_REG (&temp_proc_desc) = RA_REGNUM;
2127
2128   if (start_pc + 200 < limit_pc)
2129     limit_pc = start_pc + 200;
2130   if (pc_is_mips16 (start_pc))
2131     mips16_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp);
2132   else
2133     mips32_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp);
2134   return &temp_proc_desc;
2135 }
2136
2137 struct mips_objfile_private
2138 {
2139   bfd_size_type size;
2140   char *contents;
2141 };
2142
2143 /* Global used to communicate between non_heuristic_proc_desc and
2144    compare_pdr_entries within qsort ().  */
2145 static bfd *the_bfd;
2146
2147 static int
2148 compare_pdr_entries (const void *a, const void *b)
2149 {
2150   CORE_ADDR lhs = bfd_get_32 (the_bfd, (bfd_byte *) a);
2151   CORE_ADDR rhs = bfd_get_32 (the_bfd, (bfd_byte *) b);
2152
2153   if (lhs < rhs)
2154     return -1;
2155   else if (lhs == rhs)
2156     return 0;
2157   else
2158     return 1;
2159 }
2160
2161 static mips_extra_func_info_t
2162 non_heuristic_proc_desc (CORE_ADDR pc, CORE_ADDR *addrptr)
2163 {
2164   CORE_ADDR startaddr;
2165   mips_extra_func_info_t proc_desc;
2166   struct block *b = block_for_pc (pc);
2167   struct symbol *sym;
2168   struct obj_section *sec;
2169   struct mips_objfile_private *priv;
2170
2171   if (PC_IN_CALL_DUMMY (pc, 0, 0))
2172     return NULL;
2173
2174   find_pc_partial_function (pc, NULL, &startaddr, NULL);
2175   if (addrptr)
2176     *addrptr = startaddr;
2177
2178   priv = NULL;
2179
2180   sec = find_pc_section (pc);
2181   if (sec != NULL)
2182     {
2183       priv = (struct mips_objfile_private *) sec->objfile->obj_private;
2184
2185       /* Search the ".pdr" section generated by GAS.  This includes most of
2186          the information normally found in ECOFF PDRs.  */
2187
2188       the_bfd = sec->objfile->obfd;
2189       if (priv == NULL
2190           && (the_bfd->format == bfd_object
2191               && bfd_get_flavour (the_bfd) == bfd_target_elf_flavour
2192               && elf_elfheader (the_bfd)->e_ident[EI_CLASS] == ELFCLASS64))
2193         {
2194           /* Right now GAS only outputs the address as a four-byte sequence.
2195              This means that we should not bother with this method on 64-bit
2196              targets (until that is fixed).  */
2197
2198           priv = obstack_alloc (& sec->objfile->psymbol_obstack,
2199                                 sizeof (struct mips_objfile_private));
2200           priv->size = 0;
2201           sec->objfile->obj_private = priv;
2202         }
2203       else if (priv == NULL)
2204         {
2205           asection *bfdsec;
2206
2207           priv = obstack_alloc (& sec->objfile->psymbol_obstack,
2208                                 sizeof (struct mips_objfile_private));
2209
2210           bfdsec = bfd_get_section_by_name (sec->objfile->obfd, ".pdr");
2211           if (bfdsec != NULL)
2212             {
2213               priv->size = bfd_section_size (sec->objfile->obfd, bfdsec);
2214               priv->contents = obstack_alloc (& sec->objfile->psymbol_obstack,
2215                                               priv->size);
2216               bfd_get_section_contents (sec->objfile->obfd, bfdsec,
2217                                         priv->contents, 0, priv->size);
2218
2219               /* In general, the .pdr section is sorted.  However, in the
2220                  presence of multiple code sections (and other corner cases)
2221                  it can become unsorted.  Sort it so that we can use a faster
2222                  binary search.  */
2223               qsort (priv->contents, priv->size / 32, 32, compare_pdr_entries);
2224             }
2225           else
2226             priv->size = 0;
2227
2228           sec->objfile->obj_private = priv;
2229         }
2230       the_bfd = NULL;
2231
2232       if (priv->size != 0)
2233         {
2234           int low, mid, high;
2235           char *ptr;
2236
2237           low = 0;
2238           high = priv->size / 32;
2239
2240           do
2241             {
2242               CORE_ADDR pdr_pc;
2243
2244               mid = (low + high) / 2;
2245
2246               ptr = priv->contents + mid * 32;
2247               pdr_pc = bfd_get_signed_32 (sec->objfile->obfd, ptr);
2248               pdr_pc += ANOFFSET (sec->objfile->section_offsets,
2249                                   SECT_OFF_TEXT (sec->objfile));
2250               if (pdr_pc == startaddr)
2251                 break;
2252               if (pdr_pc > startaddr)
2253                 high = mid;
2254               else
2255                 low = mid + 1;
2256             }
2257           while (low != high);
2258
2259           if (low != high)
2260             {
2261               struct symbol *sym = find_pc_function (pc);
2262
2263               /* Fill in what we need of the proc_desc.  */
2264               proc_desc = (mips_extra_func_info_t)
2265                 obstack_alloc (&sec->objfile->psymbol_obstack,
2266                                sizeof (struct mips_extra_func_info));
2267               PROC_LOW_ADDR (proc_desc) = startaddr;
2268
2269               /* Only used for dummy frames.  */
2270               PROC_HIGH_ADDR (proc_desc) = 0;
2271
2272               PROC_FRAME_OFFSET (proc_desc)
2273                 = bfd_get_32 (sec->objfile->obfd, ptr + 20);
2274               PROC_FRAME_REG (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2275                                                        ptr + 24);
2276               PROC_FRAME_ADJUST (proc_desc) = 0;
2277               PROC_REG_MASK (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2278                                                       ptr + 4);
2279               PROC_FREG_MASK (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2280                                                        ptr + 12);
2281               PROC_REG_OFFSET (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2282                                                         ptr + 8);
2283               PROC_FREG_OFFSET (proc_desc)
2284                 = bfd_get_32 (sec->objfile->obfd, ptr + 16);
2285               PROC_PC_REG (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2286                                                     ptr + 28);
2287               proc_desc->pdr.isym = (long) sym;
2288
2289               return proc_desc;
2290             }
2291         }
2292     }
2293
2294   if (b == NULL)
2295     return NULL;
2296
2297   if (startaddr > BLOCK_START (b))
2298     {
2299       /* This is the "pathological" case referred to in a comment in
2300          print_frame_info.  It might be better to move this check into
2301          symbol reading.  */
2302       return NULL;
2303     }
2304
2305   sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, 0, NULL);
2306
2307   /* If we never found a PDR for this function in symbol reading, then
2308      examine prologues to find the information.  */
2309   if (sym)
2310     {
2311       proc_desc = (mips_extra_func_info_t) SYMBOL_VALUE (sym);
2312       if (PROC_FRAME_REG (proc_desc) == -1)
2313         return NULL;
2314       else
2315         return proc_desc;
2316     }
2317   else
2318     return NULL;
2319 }
2320
2321
2322 static mips_extra_func_info_t
2323 find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame, int cur_frame)
2324 {
2325   mips_extra_func_info_t proc_desc;
2326   CORE_ADDR startaddr;
2327
2328   proc_desc = non_heuristic_proc_desc (pc, &startaddr);
2329
2330   if (proc_desc)
2331     {
2332       /* IF this is the topmost frame AND
2333        * (this proc does not have debugging information OR
2334        * the PC is in the procedure prologue)
2335        * THEN create a "heuristic" proc_desc (by analyzing
2336        * the actual code) to replace the "official" proc_desc.
2337        */
2338       if (next_frame == NULL)
2339         {
2340           struct symtab_and_line val;
2341           struct symbol *proc_symbol =
2342             PROC_DESC_IS_DUMMY (proc_desc) ? 0 : PROC_SYMBOL (proc_desc);
2343
2344           if (proc_symbol)
2345             {
2346               val = find_pc_line (BLOCK_START
2347                                   (SYMBOL_BLOCK_VALUE (proc_symbol)),
2348                                   0);
2349               val.pc = val.end ? val.end : pc;
2350             }
2351           if (!proc_symbol || pc < val.pc)
2352             {
2353               mips_extra_func_info_t found_heuristic =
2354                 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
2355                                      pc, next_frame, cur_frame);
2356               if (found_heuristic)
2357                 proc_desc = found_heuristic;
2358             }
2359         }
2360     }
2361   else
2362     {
2363       /* Is linked_proc_desc_table really necessary?  It only seems to be used
2364          by procedure call dummys.  However, the procedures being called ought
2365          to have their own proc_descs, and even if they don't,
2366          heuristic_proc_desc knows how to create them! */
2367
2368       register struct linked_proc_info *link;
2369
2370       for (link = linked_proc_desc_table; link; link = link->next)
2371         if (PROC_LOW_ADDR (&link->info) <= pc
2372             && PROC_HIGH_ADDR (&link->info) > pc)
2373           return &link->info;
2374
2375       if (startaddr == 0)
2376         startaddr = heuristic_proc_start (pc);
2377
2378       proc_desc =
2379         heuristic_proc_desc (startaddr, pc, next_frame, cur_frame);
2380     }
2381   return proc_desc;
2382 }
2383
2384 static CORE_ADDR
2385 get_frame_pointer (struct frame_info *frame,
2386                    mips_extra_func_info_t proc_desc)
2387 {
2388   return ADDR_BITS_REMOVE (read_next_frame_reg (frame,
2389                                                 PROC_FRAME_REG (proc_desc)) +
2390                            PROC_FRAME_OFFSET (proc_desc) -
2391                            PROC_FRAME_ADJUST (proc_desc));
2392 }
2393
2394 mips_extra_func_info_t cached_proc_desc;
2395
2396 static CORE_ADDR
2397 mips_frame_chain (struct frame_info *frame)
2398 {
2399   mips_extra_func_info_t proc_desc;
2400   CORE_ADDR tmp;
2401   CORE_ADDR saved_pc = FRAME_SAVED_PC (frame);
2402
2403   if (saved_pc == 0 || inside_entry_file (saved_pc))
2404     return 0;
2405
2406   /* Check if the PC is inside a call stub.  If it is, fetch the
2407      PC of the caller of that stub.  */
2408   if ((tmp = mips_skip_stub (saved_pc)) != 0)
2409     saved_pc = tmp;
2410
2411   /* Look up the procedure descriptor for this PC.  */
2412   proc_desc = find_proc_desc (saved_pc, frame, 1);
2413   if (!proc_desc)
2414     return 0;
2415
2416   cached_proc_desc = proc_desc;
2417
2418   /* If no frame pointer and frame size is zero, we must be at end
2419      of stack (or otherwise hosed).  If we don't check frame size,
2420      we loop forever if we see a zero size frame.  */
2421   if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
2422       && PROC_FRAME_OFFSET (proc_desc) == 0
2423       /* The previous frame from a sigtramp frame might be frameless
2424          and have frame size zero.  */
2425       && !frame->signal_handler_caller
2426       /* Check if this is a call dummy frame.  */
2427       && frame->pc != CALL_DUMMY_ADDRESS ())
2428     return 0;
2429   else
2430     return get_frame_pointer (frame, proc_desc);
2431 }
2432
2433 static void
2434 mips_init_extra_frame_info (int fromleaf, struct frame_info *fci)
2435 {
2436   int regnum;
2437
2438   /* Use proc_desc calculated in frame_chain */
2439   mips_extra_func_info_t proc_desc =
2440     fci->next ? cached_proc_desc : find_proc_desc (fci->pc, fci->next, 1);
2441
2442   fci->extra_info = (struct frame_extra_info *)
2443     frame_obstack_alloc (sizeof (struct frame_extra_info));
2444
2445   fci->saved_regs = NULL;
2446   fci->extra_info->proc_desc =
2447     proc_desc == &temp_proc_desc ? 0 : proc_desc;
2448   if (proc_desc)
2449     {
2450       /* Fixup frame-pointer - only needed for top frame */
2451       /* This may not be quite right, if proc has a real frame register.
2452          Get the value of the frame relative sp, procedure might have been
2453          interrupted by a signal at it's very start.  */
2454       if (fci->pc == PROC_LOW_ADDR (proc_desc)
2455           && !PROC_DESC_IS_DUMMY (proc_desc))
2456         fci->frame = read_next_frame_reg (fci->next, SP_REGNUM);
2457       else
2458         fci->frame = get_frame_pointer (fci->next, proc_desc);
2459
2460       if (proc_desc == &temp_proc_desc)
2461         {
2462           char *name;
2463
2464           /* Do not set the saved registers for a sigtramp frame,
2465              mips_find_saved_registers will do that for us.
2466              We can't use fci->signal_handler_caller, it is not yet set.  */
2467           find_pc_partial_function (fci->pc, &name,
2468                                     (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
2469           if (!PC_IN_SIGTRAMP (fci->pc, name))
2470             {
2471               frame_saved_regs_zalloc (fci);
2472               memcpy (fci->saved_regs, temp_saved_regs, SIZEOF_FRAME_SAVED_REGS);
2473               fci->saved_regs[PC_REGNUM]
2474                 = fci->saved_regs[RA_REGNUM];
2475               /* Set value of previous frame's stack pointer.  Remember that
2476                  saved_regs[SP_REGNUM] is special in that it contains the
2477                  value of the stack pointer register.  The other saved_regs
2478                  values are addresses (in the inferior) at which a given
2479                  register's value may be found.  */
2480               fci->saved_regs[SP_REGNUM] = fci->frame;
2481             }
2482         }
2483
2484       /* hack: if argument regs are saved, guess these contain args */
2485       /* assume we can't tell how many args for now */
2486       fci->extra_info->num_args = -1;
2487       for (regnum = MIPS_LAST_ARG_REGNUM; regnum >= A0_REGNUM; regnum--)
2488         {
2489           if (PROC_REG_MASK (proc_desc) & (1 << regnum))
2490             {
2491               fci->extra_info->num_args = regnum - A0_REGNUM + 1;
2492               break;
2493             }
2494         }
2495     }
2496 }
2497
2498 /* MIPS stack frames are almost impenetrable.  When execution stops,
2499    we basically have to look at symbol information for the function
2500    that we stopped in, which tells us *which* register (if any) is
2501    the base of the frame pointer, and what offset from that register
2502    the frame itself is at.
2503
2504    This presents a problem when trying to examine a stack in memory
2505    (that isn't executing at the moment), using the "frame" command.  We
2506    don't have a PC, nor do we have any registers except SP.
2507
2508    This routine takes two arguments, SP and PC, and tries to make the
2509    cached frames look as if these two arguments defined a frame on the
2510    cache.  This allows the rest of info frame to extract the important
2511    arguments without difficulty.  */
2512
2513 struct frame_info *
2514 setup_arbitrary_frame (int argc, CORE_ADDR *argv)
2515 {
2516   if (argc != 2)
2517     error ("MIPS frame specifications require two arguments: sp and pc");
2518
2519   return create_new_frame (argv[0], argv[1]);
2520 }
2521
2522 /* According to the current ABI, should the type be passed in a
2523    floating-point register (assuming that there is space)?  When there
2524    is no FPU, FP are not even considered as possibile candidates for
2525    FP registers and, consequently this returns false - forces FP
2526    arguments into integer registers. */
2527
2528 static int
2529 fp_register_arg_p (enum type_code typecode, struct type *arg_type)
2530 {
2531   return ((typecode == TYPE_CODE_FLT
2532            || (MIPS_EABI
2533                && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
2534                && TYPE_NFIELDS (arg_type) == 1
2535                && TYPE_CODE (TYPE_FIELD_TYPE (arg_type, 0)) == TYPE_CODE_FLT))
2536           && MIPS_FPU_TYPE != MIPS_FPU_NONE);
2537 }
2538
2539 /* On o32, argument passing in GPRs depends on the alignment of the type being
2540    passed.  Return 1 if this type must be aligned to a doubleword boundary. */
2541
2542 static int
2543 mips_type_needs_double_align (struct type *type)
2544 {
2545   enum type_code typecode = TYPE_CODE (type);
2546
2547   if (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)
2548     return 1;
2549   else if (typecode == TYPE_CODE_STRUCT)
2550     {
2551       if (TYPE_NFIELDS (type) < 1)
2552         return 0;
2553       return mips_type_needs_double_align (TYPE_FIELD_TYPE (type, 0));
2554     }
2555   else if (typecode == TYPE_CODE_UNION)
2556     {
2557       int i, n;
2558
2559       n = TYPE_NFIELDS (type);
2560       for (i = 0; i < n; i++)
2561         if (mips_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
2562           return 1;
2563       return 0;
2564     }
2565   return 0;
2566 }
2567
2568 /* Macros to round N up or down to the next A boundary;
2569    A must be a power of two.  */
2570
2571 #define ROUND_DOWN(n,a) ((n) & ~((a)-1))
2572 #define ROUND_UP(n,a) (((n)+(a)-1) & ~((a)-1))
2573
2574 static CORE_ADDR
2575 mips_eabi_push_arguments (int nargs,
2576                           struct value **args,
2577                           CORE_ADDR sp,
2578                           int struct_return,
2579                           CORE_ADDR struct_addr)
2580 {
2581   int argreg;
2582   int float_argreg;
2583   int argnum;
2584   int len = 0;
2585   int stack_offset = 0;
2586
2587   /* First ensure that the stack and structure return address (if any)
2588      are properly aligned.  The stack has to be at least 64-bit
2589      aligned even on 32-bit machines, because doubles must be 64-bit
2590      aligned.  For n32 and n64, stack frames need to be 128-bit
2591      aligned, so we round to this widest known alignment.  */
2592
2593   sp = ROUND_DOWN (sp, 16);
2594   struct_addr = ROUND_DOWN (struct_addr, 16);
2595
2596   /* Now make space on the stack for the args.  We allocate more
2597      than necessary for EABI, because the first few arguments are
2598      passed in registers, but that's OK.  */
2599   for (argnum = 0; argnum < nargs; argnum++)
2600     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
2601                      MIPS_STACK_ARGSIZE);
2602   sp -= ROUND_UP (len, 16);
2603
2604   if (mips_debug)
2605     fprintf_unfiltered (gdb_stdlog,
2606                         "mips_eabi_push_arguments: sp=0x%s allocated %d\n",
2607                         paddr_nz (sp), ROUND_UP (len, 16));
2608
2609   /* Initialize the integer and float register pointers.  */
2610   argreg = A0_REGNUM;
2611   float_argreg = FPA0_REGNUM;
2612
2613   /* The struct_return pointer occupies the first parameter-passing reg.  */
2614   if (struct_return)
2615     {
2616       if (mips_debug)
2617         fprintf_unfiltered (gdb_stdlog,
2618                             "mips_eabi_push_arguments: struct_return reg=%d 0x%s\n",
2619                             argreg, paddr_nz (struct_addr));
2620       write_register (argreg++, struct_addr);
2621     }
2622
2623   /* Now load as many as possible of the first arguments into
2624      registers, and push the rest onto the stack.  Loop thru args
2625      from first to last.  */
2626   for (argnum = 0; argnum < nargs; argnum++)
2627     {
2628       char *val;
2629       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
2630       struct value *arg = args[argnum];
2631       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
2632       int len = TYPE_LENGTH (arg_type);
2633       enum type_code typecode = TYPE_CODE (arg_type);
2634
2635       if (mips_debug)
2636         fprintf_unfiltered (gdb_stdlog,
2637                             "mips_eabi_push_arguments: %d len=%d type=%d",
2638                             argnum + 1, len, (int) typecode);
2639
2640       /* The EABI passes structures that do not fit in a register by
2641          reference.  */
2642       if (len > MIPS_SAVED_REGSIZE
2643           && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
2644         {
2645           store_address (valbuf, MIPS_SAVED_REGSIZE, VALUE_ADDRESS (arg));
2646           typecode = TYPE_CODE_PTR;
2647           len = MIPS_SAVED_REGSIZE;
2648           val = valbuf;
2649           if (mips_debug)
2650             fprintf_unfiltered (gdb_stdlog, " push");
2651         }
2652       else
2653         val = (char *) VALUE_CONTENTS (arg);
2654
2655       /* 32-bit ABIs always start floating point arguments in an
2656          even-numbered floating point register.  Round the FP register
2657          up before the check to see if there are any FP registers
2658          left.  Non MIPS_EABI targets also pass the FP in the integer
2659          registers so also round up normal registers.  */
2660       if (!FP_REGISTER_DOUBLE
2661           && fp_register_arg_p (typecode, arg_type))
2662         {
2663           if ((float_argreg & 1))
2664             float_argreg++;
2665         }
2666
2667       /* Floating point arguments passed in registers have to be
2668          treated specially.  On 32-bit architectures, doubles
2669          are passed in register pairs; the even register gets
2670          the low word, and the odd register gets the high word.
2671          On non-EABI processors, the first two floating point arguments are
2672          also copied to general registers, because MIPS16 functions
2673          don't use float registers for arguments.  This duplication of
2674          arguments in general registers can't hurt non-MIPS16 functions
2675          because those registers are normally skipped.  */
2676       /* MIPS_EABI squeezes a struct that contains a single floating
2677          point value into an FP register instead of pushing it onto the
2678          stack.  */
2679       if (fp_register_arg_p (typecode, arg_type)
2680           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
2681         {
2682           if (!FP_REGISTER_DOUBLE && len == 8)
2683             {
2684               int low_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
2685               unsigned long regval;
2686
2687               /* Write the low word of the double to the even register(s).  */
2688               regval = extract_unsigned_integer (val + low_offset, 4);
2689               if (mips_debug)
2690                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2691                                     float_argreg, phex (regval, 4));
2692               write_register (float_argreg++, regval);
2693
2694               /* Write the high word of the double to the odd register(s).  */
2695               regval = extract_unsigned_integer (val + 4 - low_offset, 4);
2696               if (mips_debug)
2697                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2698                                     float_argreg, phex (regval, 4));
2699               write_register (float_argreg++, regval);
2700             }
2701           else
2702             {
2703               /* This is a floating point value that fits entirely
2704                  in a single register.  */
2705               /* On 32 bit ABI's the float_argreg is further adjusted
2706                  above to ensure that it is even register aligned.  */
2707               LONGEST regval = extract_unsigned_integer (val, len);
2708               if (mips_debug)
2709                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2710                                     float_argreg, phex (regval, len));
2711               write_register (float_argreg++, regval);
2712             }
2713         }
2714       else
2715         {
2716           /* Copy the argument to general registers or the stack in
2717              register-sized pieces.  Large arguments are split between
2718              registers and stack.  */
2719           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
2720              are treated specially: Irix cc passes them in registers
2721              where gcc sometimes puts them on the stack.  For maximum
2722              compatibility, we will put them in both places.  */
2723           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
2724                                   (len % MIPS_SAVED_REGSIZE != 0));
2725
2726           /* Note: Floating-point values that didn't fit into an FP
2727              register are only written to memory.  */
2728           while (len > 0)
2729             {
2730               /* Remember if the argument was written to the stack.  */
2731               int stack_used_p = 0;
2732               int partial_len =
2733                 len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
2734
2735               if (mips_debug)
2736                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
2737                                     partial_len);
2738
2739               /* Write this portion of the argument to the stack.  */
2740               if (argreg > MIPS_LAST_ARG_REGNUM
2741                   || odd_sized_struct
2742                   || fp_register_arg_p (typecode, arg_type))
2743                 {
2744                   /* Should shorter than int integer values be
2745                      promoted to int before being stored? */
2746                   int longword_offset = 0;
2747                   CORE_ADDR addr;
2748                   stack_used_p = 1;
2749                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2750                     {
2751                       if (MIPS_STACK_ARGSIZE == 8 &&
2752                           (typecode == TYPE_CODE_INT ||
2753                            typecode == TYPE_CODE_PTR ||
2754                            typecode == TYPE_CODE_FLT) && len <= 4)
2755                         longword_offset = MIPS_STACK_ARGSIZE - len;
2756                       else if ((typecode == TYPE_CODE_STRUCT ||
2757                                 typecode == TYPE_CODE_UNION) &&
2758                                TYPE_LENGTH (arg_type) < MIPS_STACK_ARGSIZE)
2759                         longword_offset = MIPS_STACK_ARGSIZE - len;
2760                     }
2761
2762                   if (mips_debug)
2763                     {
2764                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
2765                                           paddr_nz (stack_offset));
2766                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
2767                                           paddr_nz (longword_offset));
2768                     }
2769
2770                   addr = sp + stack_offset + longword_offset;
2771
2772                   if (mips_debug)
2773                     {
2774                       int i;
2775                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
2776                                           paddr_nz (addr));
2777                       for (i = 0; i < partial_len; i++)
2778                         {
2779                           fprintf_unfiltered (gdb_stdlog, "%02x",
2780                                               val[i] & 0xff);
2781                         }
2782                     }
2783                   write_memory (addr, val, partial_len);
2784                 }
2785
2786               /* Note!!! This is NOT an else clause.  Odd sized
2787                  structs may go thru BOTH paths.  Floating point
2788                  arguments will not.  */
2789               /* Write this portion of the argument to a general
2790                  purpose register.  */
2791               if (argreg <= MIPS_LAST_ARG_REGNUM
2792                   && !fp_register_arg_p (typecode, arg_type))
2793                 {
2794                   LONGEST regval = extract_unsigned_integer (val, partial_len);
2795
2796                   if (mips_debug)
2797                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
2798                                       argreg,
2799                                       phex (regval, MIPS_SAVED_REGSIZE));
2800                   write_register (argreg, regval);
2801                   argreg++;
2802                 }
2803
2804               len -= partial_len;
2805               val += partial_len;
2806
2807               /* Compute the the offset into the stack at which we
2808                  will copy the next parameter.
2809
2810                  In the new EABI (and the NABI32), the stack_offset
2811                  only needs to be adjusted when it has been used.  */
2812
2813               if (stack_used_p)
2814                 stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
2815             }
2816         }
2817       if (mips_debug)
2818         fprintf_unfiltered (gdb_stdlog, "\n");
2819     }
2820
2821   /* Return adjusted stack pointer.  */
2822   return sp;
2823 }
2824
2825 /* N32/N64 version of push_arguments.  */
2826
2827 static CORE_ADDR
2828 mips_n32n64_push_arguments (int nargs,
2829                             struct value **args,
2830                             CORE_ADDR sp,
2831                             int struct_return,
2832                             CORE_ADDR struct_addr)
2833 {
2834   int argreg;
2835   int float_argreg;
2836   int argnum;
2837   int len = 0;
2838   int stack_offset = 0;
2839
2840   /* First ensure that the stack and structure return address (if any)
2841      are properly aligned.  The stack has to be at least 64-bit
2842      aligned even on 32-bit machines, because doubles must be 64-bit
2843      aligned.  For n32 and n64, stack frames need to be 128-bit
2844      aligned, so we round to this widest known alignment.  */
2845
2846   sp = ROUND_DOWN (sp, 16);
2847   struct_addr = ROUND_DOWN (struct_addr, 16);
2848
2849   /* Now make space on the stack for the args.  */
2850   for (argnum = 0; argnum < nargs; argnum++)
2851     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
2852                      MIPS_STACK_ARGSIZE);
2853   sp -= ROUND_UP (len, 16);
2854
2855   if (mips_debug)
2856     fprintf_unfiltered (gdb_stdlog,
2857                         "mips_n32n64_push_arguments: sp=0x%s allocated %d\n",
2858                         paddr_nz (sp), ROUND_UP (len, 16));
2859
2860   /* Initialize the integer and float register pointers.  */
2861   argreg = A0_REGNUM;
2862   float_argreg = FPA0_REGNUM;
2863
2864   /* The struct_return pointer occupies the first parameter-passing reg.  */
2865   if (struct_return)
2866     {
2867       if (mips_debug)
2868         fprintf_unfiltered (gdb_stdlog,
2869                             "mips_n32n64_push_arguments: struct_return reg=%d 0x%s\n",
2870                             argreg, paddr_nz (struct_addr));
2871       write_register (argreg++, struct_addr);
2872     }
2873
2874   /* Now load as many as possible of the first arguments into
2875      registers, and push the rest onto the stack.  Loop thru args
2876      from first to last.  */
2877   for (argnum = 0; argnum < nargs; argnum++)
2878     {
2879       char *val;
2880       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
2881       struct value *arg = args[argnum];
2882       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
2883       int len = TYPE_LENGTH (arg_type);
2884       enum type_code typecode = TYPE_CODE (arg_type);
2885
2886       if (mips_debug)
2887         fprintf_unfiltered (gdb_stdlog,
2888                             "mips_n32n64_push_arguments: %d len=%d type=%d",
2889                             argnum + 1, len, (int) typecode);
2890
2891       val = (char *) VALUE_CONTENTS (arg);
2892
2893       if (fp_register_arg_p (typecode, arg_type)
2894           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
2895         {
2896           /* This is a floating point value that fits entirely
2897              in a single register.  */
2898           /* On 32 bit ABI's the float_argreg is further adjusted
2899              above to ensure that it is even register aligned.  */
2900           LONGEST regval = extract_unsigned_integer (val, len);
2901           if (mips_debug)
2902             fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2903                                 float_argreg, phex (regval, len));
2904           write_register (float_argreg++, regval);
2905
2906           if (mips_debug)
2907             fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
2908                                 argreg, phex (regval, len));
2909           write_register (argreg, regval);
2910           argreg += 1;
2911         }
2912       else
2913         {
2914           /* Copy the argument to general registers or the stack in
2915              register-sized pieces.  Large arguments are split between
2916              registers and stack.  */
2917           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
2918              are treated specially: Irix cc passes them in registers
2919              where gcc sometimes puts them on the stack.  For maximum
2920              compatibility, we will put them in both places.  */
2921           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
2922                                   (len % MIPS_SAVED_REGSIZE != 0));
2923           /* Note: Floating-point values that didn't fit into an FP
2924              register are only written to memory.  */
2925           while (len > 0)
2926             {
2927               /* Rememer if the argument was written to the stack.  */
2928               int stack_used_p = 0;
2929               int partial_len = len < MIPS_SAVED_REGSIZE ?
2930                 len : MIPS_SAVED_REGSIZE;
2931
2932               if (mips_debug)
2933                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
2934                                     partial_len);
2935
2936               /* Write this portion of the argument to the stack.  */
2937               if (argreg > MIPS_LAST_ARG_REGNUM
2938                   || odd_sized_struct
2939                   || fp_register_arg_p (typecode, arg_type))
2940                 {
2941                   /* Should shorter than int integer values be
2942                      promoted to int before being stored? */
2943                   int longword_offset = 0;
2944                   CORE_ADDR addr;
2945                   stack_used_p = 1;
2946                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2947                     {
2948                       if (MIPS_STACK_ARGSIZE == 8 &&
2949                           (typecode == TYPE_CODE_INT ||
2950                            typecode == TYPE_CODE_PTR ||
2951                            typecode == TYPE_CODE_FLT) && len <= 4)
2952                         longword_offset = MIPS_STACK_ARGSIZE - len;
2953                       else if ((typecode == TYPE_CODE_STRUCT ||
2954                                 typecode == TYPE_CODE_UNION) &&
2955                                TYPE_LENGTH (arg_type) < MIPS_STACK_ARGSIZE)
2956                         longword_offset = MIPS_STACK_ARGSIZE - len;
2957                     }
2958
2959                   if (mips_debug)
2960                     {
2961                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
2962                                           paddr_nz (stack_offset));
2963                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
2964                                           paddr_nz (longword_offset));
2965                     }
2966
2967                   addr = sp + stack_offset + longword_offset;
2968
2969                   if (mips_debug)
2970                     {
2971                       int i;
2972                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
2973                                           paddr_nz (addr));
2974                       for (i = 0; i < partial_len; i++)
2975                         {
2976                           fprintf_unfiltered (gdb_stdlog, "%02x",
2977                                               val[i] & 0xff);
2978                         }
2979                     }
2980                   write_memory (addr, val, partial_len);
2981                 }
2982
2983               /* Note!!! This is NOT an else clause.  Odd sized
2984                  structs may go thru BOTH paths.  Floating point
2985                  arguments will not.  */
2986               /* Write this portion of the argument to a general
2987                  purpose register.  */
2988               if (argreg <= MIPS_LAST_ARG_REGNUM
2989                   && !fp_register_arg_p (typecode, arg_type))
2990                 {
2991                   LONGEST regval = extract_unsigned_integer (val, partial_len);
2992
2993                   /* A non-floating-point argument being passed in a
2994                      general register.  If a struct or union, and if
2995                      the remaining length is smaller than the register
2996                      size, we have to adjust the register value on
2997                      big endian targets.
2998
2999                      It does not seem to be necessary to do the
3000                      same for integral types.
3001
3002                      cagney/2001-07-23: gdb/179: Also, GCC, when
3003                      outputting LE O32 with sizeof (struct) <
3004                      MIPS_SAVED_REGSIZE, generates a left shift as
3005                      part of storing the argument in a register a
3006                      register (the left shift isn't generated when
3007                      sizeof (struct) >= MIPS_SAVED_REGSIZE).  Since it
3008                      is quite possible that this is GCC contradicting
3009                      the LE/O32 ABI, GDB has not been adjusted to
3010                      accommodate this.  Either someone needs to
3011                      demonstrate that the LE/O32 ABI specifies such a
3012                      left shift OR this new ABI gets identified as
3013                      such and GDB gets tweaked accordingly.  */
3014
3015                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3016                       && partial_len < MIPS_SAVED_REGSIZE
3017                       && (typecode == TYPE_CODE_STRUCT ||
3018                           typecode == TYPE_CODE_UNION))
3019                     regval <<= ((MIPS_SAVED_REGSIZE - partial_len) *
3020                                 TARGET_CHAR_BIT);
3021
3022                   if (mips_debug)
3023                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
3024                                       argreg,
3025                                       phex (regval, MIPS_SAVED_REGSIZE));
3026                   write_register (argreg, regval);
3027                   argreg++;
3028                 }
3029
3030               len -= partial_len;
3031               val += partial_len;
3032
3033               /* Compute the the offset into the stack at which we
3034                  will copy the next parameter.
3035
3036                  In N32 (N64?), the stack_offset only needs to be
3037                  adjusted when it has been used.  */
3038
3039               if (stack_used_p)
3040                 stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
3041             }
3042         }
3043       if (mips_debug)
3044         fprintf_unfiltered (gdb_stdlog, "\n");
3045     }
3046
3047   /* Return adjusted stack pointer.  */
3048   return sp;
3049 }
3050
3051 /* O32 version of push_arguments.  */
3052
3053 static CORE_ADDR
3054 mips_o32_push_arguments (int nargs,
3055                          struct value **args,
3056                          CORE_ADDR sp,
3057                          int struct_return,
3058                          CORE_ADDR struct_addr)
3059 {
3060   int argreg;
3061   int float_argreg;
3062   int argnum;
3063   int len = 0;
3064   int stack_offset = 0;
3065
3066   /* First ensure that the stack and structure return address (if any)
3067      are properly aligned.  The stack has to be at least 64-bit
3068      aligned even on 32-bit machines, because doubles must be 64-bit
3069      aligned.  For n32 and n64, stack frames need to be 128-bit
3070      aligned, so we round to this widest known alignment.  */
3071
3072   sp = ROUND_DOWN (sp, 16);
3073   struct_addr = ROUND_DOWN (struct_addr, 16);
3074
3075   /* Now make space on the stack for the args.  */
3076   for (argnum = 0; argnum < nargs; argnum++)
3077     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
3078                      MIPS_STACK_ARGSIZE);
3079   sp -= ROUND_UP (len, 16);
3080
3081   if (mips_debug)
3082     fprintf_unfiltered (gdb_stdlog,
3083                         "mips_o32_push_arguments: sp=0x%s allocated %d\n",
3084                         paddr_nz (sp), ROUND_UP (len, 16));
3085
3086   /* Initialize the integer and float register pointers.  */
3087   argreg = A0_REGNUM;
3088   float_argreg = FPA0_REGNUM;
3089
3090   /* The struct_return pointer occupies the first parameter-passing reg.  */
3091   if (struct_return)
3092     {
3093       if (mips_debug)
3094         fprintf_unfiltered (gdb_stdlog,
3095                             "mips_o32_push_arguments: struct_return reg=%d 0x%s\n",
3096                             argreg, paddr_nz (struct_addr));
3097       write_register (argreg++, struct_addr);
3098       stack_offset += MIPS_STACK_ARGSIZE;
3099     }
3100
3101   /* Now load as many as possible of the first arguments into
3102      registers, and push the rest onto the stack.  Loop thru args
3103      from first to last.  */
3104   for (argnum = 0; argnum < nargs; argnum++)
3105     {
3106       char *val;
3107       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
3108       struct value *arg = args[argnum];
3109       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
3110       int len = TYPE_LENGTH (arg_type);
3111       enum type_code typecode = TYPE_CODE (arg_type);
3112
3113       if (mips_debug)
3114         fprintf_unfiltered (gdb_stdlog,
3115                             "mips_o32_push_arguments: %d len=%d type=%d",
3116                             argnum + 1, len, (int) typecode);
3117
3118       val = (char *) VALUE_CONTENTS (arg);
3119
3120       /* 32-bit ABIs always start floating point arguments in an
3121          even-numbered floating point register.  Round the FP register
3122          up before the check to see if there are any FP registers
3123          left.  O32/O64 targets also pass the FP in the integer
3124          registers so also round up normal registers.  */
3125       if (!FP_REGISTER_DOUBLE
3126           && fp_register_arg_p (typecode, arg_type))
3127         {
3128           if ((float_argreg & 1))
3129             float_argreg++;
3130         }
3131
3132       /* Floating point arguments passed in registers have to be
3133          treated specially.  On 32-bit architectures, doubles
3134          are passed in register pairs; the even register gets
3135          the low word, and the odd register gets the high word.
3136          On O32/O64, the first two floating point arguments are
3137          also copied to general registers, because MIPS16 functions
3138          don't use float registers for arguments.  This duplication of
3139          arguments in general registers can't hurt non-MIPS16 functions
3140          because those registers are normally skipped.  */
3141
3142       if (fp_register_arg_p (typecode, arg_type)
3143           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
3144         {
3145           if (!FP_REGISTER_DOUBLE && len == 8)
3146             {
3147               int low_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
3148               unsigned long regval;
3149
3150               /* Write the low word of the double to the even register(s).  */
3151               regval = extract_unsigned_integer (val + low_offset, 4);
3152               if (mips_debug)
3153                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3154                                     float_argreg, phex (regval, 4));
3155               write_register (float_argreg++, regval);
3156               if (mips_debug)
3157                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3158                                     argreg, phex (regval, 4));
3159               write_register (argreg++, regval);
3160
3161               /* Write the high word of the double to the odd register(s).  */
3162               regval = extract_unsigned_integer (val + 4 - low_offset, 4);
3163               if (mips_debug)
3164                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3165                                     float_argreg, phex (regval, 4));
3166               write_register (float_argreg++, regval);
3167
3168               if (mips_debug)
3169                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3170                                     argreg, phex (regval, 4));
3171               write_register (argreg++, regval);
3172             }
3173           else
3174             {
3175               /* This is a floating point value that fits entirely
3176                  in a single register.  */
3177               /* On 32 bit ABI's the float_argreg is further adjusted
3178                  above to ensure that it is even register aligned.  */
3179               LONGEST regval = extract_unsigned_integer (val, len);
3180               if (mips_debug)
3181                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3182                                     float_argreg, phex (regval, len));
3183               write_register (float_argreg++, regval);
3184               /* CAGNEY: 32 bit MIPS ABI's always reserve two FP
3185                  registers for each argument.  The below is (my
3186                  guess) to ensure that the corresponding integer
3187                  register has reserved the same space.  */
3188               if (mips_debug)
3189                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3190                                     argreg, phex (regval, len));
3191               write_register (argreg, regval);
3192               argreg += FP_REGISTER_DOUBLE ? 1 : 2;
3193             }
3194           /* Reserve space for the FP register.  */
3195           stack_offset += ROUND_UP (len, MIPS_STACK_ARGSIZE);
3196         }
3197       else
3198         {
3199           /* Copy the argument to general registers or the stack in
3200              register-sized pieces.  Large arguments are split between
3201              registers and stack.  */
3202           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
3203              are treated specially: Irix cc passes them in registers
3204              where gcc sometimes puts them on the stack.  For maximum
3205              compatibility, we will put them in both places.  */
3206           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
3207                                   (len % MIPS_SAVED_REGSIZE != 0));
3208           /* Structures should be aligned to eight bytes (even arg registers)
3209              on MIPS_ABI_O32, if their first member has double precision.  */
3210           if (MIPS_SAVED_REGSIZE < 8
3211               && mips_type_needs_double_align (arg_type))
3212             {
3213               if ((argreg & 1))
3214                 argreg++;
3215             }
3216           /* Note: Floating-point values that didn't fit into an FP
3217              register are only written to memory.  */
3218           while (len > 0)
3219             {
3220               /* Remember if the argument was written to the stack.  */
3221               int stack_used_p = 0;
3222               int partial_len =
3223                 len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
3224
3225               if (mips_debug)
3226                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
3227                                     partial_len);
3228
3229               /* Write this portion of the argument to the stack.  */
3230               if (argreg > MIPS_LAST_ARG_REGNUM
3231                   || odd_sized_struct
3232                   || fp_register_arg_p (typecode, arg_type))
3233                 {
3234                   /* Should shorter than int integer values be
3235                      promoted to int before being stored? */
3236                   int longword_offset = 0;
3237                   CORE_ADDR addr;
3238                   stack_used_p = 1;
3239                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3240                     {
3241                       if (MIPS_STACK_ARGSIZE == 8 &&
3242                           (typecode == TYPE_CODE_INT ||
3243                            typecode == TYPE_CODE_PTR ||
3244                            typecode == TYPE_CODE_FLT) && len <= 4)
3245                         longword_offset = MIPS_STACK_ARGSIZE - len;
3246                     }
3247
3248                   if (mips_debug)
3249                     {
3250                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
3251                                           paddr_nz (stack_offset));
3252                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
3253                                           paddr_nz (longword_offset));
3254                     }
3255
3256                   addr = sp + stack_offset + longword_offset;
3257
3258                   if (mips_debug)
3259                     {
3260                       int i;
3261                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
3262                                           paddr_nz (addr));
3263                       for (i = 0; i < partial_len; i++)
3264                         {
3265                           fprintf_unfiltered (gdb_stdlog, "%02x",
3266                                               val[i] & 0xff);
3267                         }
3268                     }
3269                   write_memory (addr, val, partial_len);
3270                 }
3271
3272               /* Note!!! This is NOT an else clause.  Odd sized
3273                  structs may go thru BOTH paths.  Floating point
3274                  arguments will not.  */
3275               /* Write this portion of the argument to a general
3276                  purpose register.  */
3277               if (argreg <= MIPS_LAST_ARG_REGNUM
3278                   && !fp_register_arg_p (typecode, arg_type))
3279                 {
3280                   LONGEST regval = extract_signed_integer (val, partial_len);
3281                   /* Value may need to be sign extended, because
3282                      MIPS_REGSIZE != MIPS_SAVED_REGSIZE.  */
3283
3284                   /* A non-floating-point argument being passed in a
3285                      general register.  If a struct or union, and if
3286                      the remaining length is smaller than the register
3287                      size, we have to adjust the register value on
3288                      big endian targets.
3289
3290                      It does not seem to be necessary to do the
3291                      same for integral types.
3292
3293                      Also don't do this adjustment on O64 binaries.
3294
3295                      cagney/2001-07-23: gdb/179: Also, GCC, when
3296                      outputting LE O32 with sizeof (struct) <
3297                      MIPS_SAVED_REGSIZE, generates a left shift as
3298                      part of storing the argument in a register a
3299                      register (the left shift isn't generated when
3300                      sizeof (struct) >= MIPS_SAVED_REGSIZE).  Since it
3301                      is quite possible that this is GCC contradicting
3302                      the LE/O32 ABI, GDB has not been adjusted to
3303                      accommodate this.  Either someone needs to
3304                      demonstrate that the LE/O32 ABI specifies such a
3305                      left shift OR this new ABI gets identified as
3306                      such and GDB gets tweaked accordingly.  */
3307
3308                   if (MIPS_SAVED_REGSIZE < 8
3309                       && TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3310                       && partial_len < MIPS_SAVED_REGSIZE
3311                       && (typecode == TYPE_CODE_STRUCT ||
3312                           typecode == TYPE_CODE_UNION))
3313                     regval <<= ((MIPS_SAVED_REGSIZE - partial_len) *
3314                                 TARGET_CHAR_BIT);
3315
3316                   if (mips_debug)
3317                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
3318                                       argreg,
3319                                       phex (regval, MIPS_SAVED_REGSIZE));
3320                   write_register (argreg, regval);
3321                   argreg++;
3322
3323                   /* Prevent subsequent floating point arguments from
3324                      being passed in floating point registers.  */
3325                   float_argreg = MIPS_LAST_FP_ARG_REGNUM + 1;
3326                 }
3327
3328               len -= partial_len;
3329               val += partial_len;
3330
3331               /* Compute the the offset into the stack at which we
3332                  will copy the next parameter.
3333
3334                  In older ABIs, the caller reserved space for
3335                  registers that contained arguments.  This was loosely
3336                  refered to as their "home".  Consequently, space is
3337                  always allocated.  */
3338
3339               stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
3340             }
3341         }
3342       if (mips_debug)
3343         fprintf_unfiltered (gdb_stdlog, "\n");
3344     }
3345
3346   /* Return adjusted stack pointer.  */
3347   return sp;
3348 }
3349
3350 /* O64 version of push_arguments.  */
3351
3352 static CORE_ADDR
3353 mips_o64_push_arguments (int nargs,
3354                          struct value **args,
3355                          CORE_ADDR sp,
3356                          int struct_return,
3357                          CORE_ADDR struct_addr)
3358 {
3359   int argreg;
3360   int float_argreg;
3361   int argnum;
3362   int len = 0;
3363   int stack_offset = 0;
3364
3365   /* First ensure that the stack and structure return address (if any)
3366      are properly aligned.  The stack has to be at least 64-bit
3367      aligned even on 32-bit machines, because doubles must be 64-bit
3368      aligned.  For n32 and n64, stack frames need to be 128-bit
3369      aligned, so we round to this widest known alignment.  */
3370
3371   sp = ROUND_DOWN (sp, 16);
3372   struct_addr = ROUND_DOWN (struct_addr, 16);
3373
3374   /* Now make space on the stack for the args.  */
3375   for (argnum = 0; argnum < nargs; argnum++)
3376     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
3377                      MIPS_STACK_ARGSIZE);
3378   sp -= ROUND_UP (len, 16);
3379
3380   if (mips_debug)
3381     fprintf_unfiltered (gdb_stdlog,
3382                         "mips_o64_push_arguments: sp=0x%s allocated %d\n",
3383                         paddr_nz (sp), ROUND_UP (len, 16));
3384
3385   /* Initialize the integer and float register pointers.  */
3386   argreg = A0_REGNUM;
3387   float_argreg = FPA0_REGNUM;
3388
3389   /* The struct_return pointer occupies the first parameter-passing reg.  */
3390   if (struct_return)
3391     {
3392       if (mips_debug)
3393         fprintf_unfiltered (gdb_stdlog,
3394                             "mips_o64_push_arguments: struct_return reg=%d 0x%s\n",
3395                             argreg, paddr_nz (struct_addr));
3396       write_register (argreg++, struct_addr);
3397       stack_offset += MIPS_STACK_ARGSIZE;
3398     }
3399
3400   /* Now load as many as possible of the first arguments into
3401      registers, and push the rest onto the stack.  Loop thru args
3402      from first to last.  */
3403   for (argnum = 0; argnum < nargs; argnum++)
3404     {
3405       char *val;
3406       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
3407       struct value *arg = args[argnum];
3408       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
3409       int len = TYPE_LENGTH (arg_type);
3410       enum type_code typecode = TYPE_CODE (arg_type);
3411
3412       if (mips_debug)
3413         fprintf_unfiltered (gdb_stdlog,
3414                             "mips_o64_push_arguments: %d len=%d type=%d",
3415                             argnum + 1, len, (int) typecode);
3416
3417       val = (char *) VALUE_CONTENTS (arg);
3418
3419       /* 32-bit ABIs always start floating point arguments in an
3420          even-numbered floating point register.  Round the FP register
3421          up before the check to see if there are any FP registers
3422          left.  O32/O64 targets also pass the FP in the integer
3423          registers so also round up normal registers.  */
3424       if (!FP_REGISTER_DOUBLE
3425           && fp_register_arg_p (typecode, arg_type))
3426         {
3427           if ((float_argreg & 1))
3428             float_argreg++;
3429         }
3430
3431       /* Floating point arguments passed in registers have to be
3432          treated specially.  On 32-bit architectures, doubles
3433          are passed in register pairs; the even register gets
3434          the low word, and the odd register gets the high word.
3435          On O32/O64, the first two floating point arguments are
3436          also copied to general registers, because MIPS16 functions
3437          don't use float registers for arguments.  This duplication of
3438          arguments in general registers can't hurt non-MIPS16 functions
3439          because those registers are normally skipped.  */
3440
3441       if (fp_register_arg_p (typecode, arg_type)
3442           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
3443         {
3444           if (!FP_REGISTER_DOUBLE && len == 8)
3445             {
3446               int low_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
3447               unsigned long regval;
3448
3449               /* Write the low word of the double to the even register(s).  */
3450               regval = extract_unsigned_integer (val + low_offset, 4);
3451               if (mips_debug)
3452                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3453                                     float_argreg, phex (regval, 4));
3454               write_register (float_argreg++, regval);
3455               if (mips_debug)
3456                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3457                                     argreg, phex (regval, 4));
3458               write_register (argreg++, regval);
3459
3460               /* Write the high word of the double to the odd register(s).  */
3461               regval = extract_unsigned_integer (val + 4 - low_offset, 4);
3462               if (mips_debug)
3463                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3464                                     float_argreg, phex (regval, 4));
3465               write_register (float_argreg++, regval);
3466
3467               if (mips_debug)
3468                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3469                                     argreg, phex (regval, 4));
3470               write_register (argreg++, regval);
3471             }
3472           else
3473             {
3474               /* This is a floating point value that fits entirely
3475                  in a single register.  */
3476               /* On 32 bit ABI's the float_argreg is further adjusted
3477                  above to ensure that it is even register aligned.  */
3478               LONGEST regval = extract_unsigned_integer (val, len);
3479               if (mips_debug)
3480                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3481                                     float_argreg, phex (regval, len));
3482               write_register (float_argreg++, regval);
3483               /* CAGNEY: 32 bit MIPS ABI's always reserve two FP
3484                  registers for each argument.  The below is (my
3485                  guess) to ensure that the corresponding integer
3486                  register has reserved the same space.  */
3487               if (mips_debug)
3488                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3489                                     argreg, phex (regval, len));
3490               write_register (argreg, regval);
3491               argreg += FP_REGISTER_DOUBLE ? 1 : 2;
3492             }
3493           /* Reserve space for the FP register.  */
3494           stack_offset += ROUND_UP (len, MIPS_STACK_ARGSIZE);
3495         }
3496       else
3497         {
3498           /* Copy the argument to general registers or the stack in
3499              register-sized pieces.  Large arguments are split between
3500              registers and stack.  */
3501           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
3502              are treated specially: Irix cc passes them in registers
3503              where gcc sometimes puts them on the stack.  For maximum
3504              compatibility, we will put them in both places.  */
3505           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
3506                                   (len % MIPS_SAVED_REGSIZE != 0));
3507           /* Structures should be aligned to eight bytes (even arg registers)
3508              on MIPS_ABI_O32, if their first member has double precision.  */
3509           if (MIPS_SAVED_REGSIZE < 8
3510               && mips_type_needs_double_align (arg_type))
3511             {
3512               if ((argreg & 1))
3513                 argreg++;
3514             }
3515           /* Note: Floating-point values that didn't fit into an FP
3516              register are only written to memory.  */
3517           while (len > 0)
3518             {
3519               /* Remember if the argument was written to the stack.  */
3520               int stack_used_p = 0;
3521               int partial_len =
3522                 len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
3523
3524               if (mips_debug)
3525                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
3526                                     partial_len);
3527
3528               /* Write this portion of the argument to the stack.  */
3529               if (argreg > MIPS_LAST_ARG_REGNUM
3530                   || odd_sized_struct
3531                   || fp_register_arg_p (typecode, arg_type))
3532                 {
3533                   /* Should shorter than int integer values be
3534                      promoted to int before being stored? */
3535                   int longword_offset = 0;
3536                   CORE_ADDR addr;
3537                   stack_used_p = 1;
3538                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3539                     {
3540                       if (MIPS_STACK_ARGSIZE == 8 &&
3541                           (typecode == TYPE_CODE_INT ||
3542                            typecode == TYPE_CODE_PTR ||
3543                            typecode == TYPE_CODE_FLT) && len <= 4)
3544                         longword_offset = MIPS_STACK_ARGSIZE - len;
3545                     }
3546
3547                   if (mips_debug)
3548                     {
3549                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
3550                                           paddr_nz (stack_offset));
3551                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
3552                                           paddr_nz (longword_offset));
3553                     }
3554
3555                   addr = sp + stack_offset + longword_offset;
3556
3557                   if (mips_debug)
3558                     {
3559                       int i;
3560                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
3561                                           paddr_nz (addr));
3562                       for (i = 0; i < partial_len; i++)
3563                         {
3564                           fprintf_unfiltered (gdb_stdlog, "%02x",
3565                                               val[i] & 0xff);
3566                         }
3567                     }
3568                   write_memory (addr, val, partial_len);
3569                 }
3570
3571               /* Note!!! This is NOT an else clause.  Odd sized
3572                  structs may go thru BOTH paths.  Floating point
3573                  arguments will not.  */
3574               /* Write this portion of the argument to a general
3575                  purpose register.  */
3576               if (argreg <= MIPS_LAST_ARG_REGNUM
3577                   && !fp_register_arg_p (typecode, arg_type))
3578                 {
3579                   LONGEST regval = extract_signed_integer (val, partial_len);
3580                   /* Value may need to be sign extended, because
3581                      MIPS_REGSIZE != MIPS_SAVED_REGSIZE.  */
3582
3583                   /* A non-floating-point argument being passed in a
3584                      general register.  If a struct or union, and if
3585                      the remaining length is smaller than the register
3586                      size, we have to adjust the register value on
3587                      big endian targets.
3588
3589                      It does not seem to be necessary to do the
3590                      same for integral types.
3591
3592                      Also don't do this adjustment on O64 binaries.
3593
3594                      cagney/2001-07-23: gdb/179: Also, GCC, when
3595                      outputting LE O32 with sizeof (struct) <
3596                      MIPS_SAVED_REGSIZE, generates a left shift as
3597                      part of storing the argument in a register a
3598                      register (the left shift isn't generated when
3599                      sizeof (struct) >= MIPS_SAVED_REGSIZE).  Since it
3600                      is quite possible that this is GCC contradicting
3601                      the LE/O32 ABI, GDB has not been adjusted to
3602                      accommodate this.  Either someone needs to
3603                      demonstrate that the LE/O32 ABI specifies such a
3604                      left shift OR this new ABI gets identified as
3605                      such and GDB gets tweaked accordingly.  */
3606
3607                   if (MIPS_SAVED_REGSIZE < 8
3608                       && TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3609                       && partial_len < MIPS_SAVED_REGSIZE
3610                       && (typecode == TYPE_CODE_STRUCT ||
3611                           typecode == TYPE_CODE_UNION))
3612                     regval <<= ((MIPS_SAVED_REGSIZE - partial_len) *
3613                                 TARGET_CHAR_BIT);
3614
3615                   if (mips_debug)
3616                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
3617                                       argreg,
3618                                       phex (regval, MIPS_SAVED_REGSIZE));
3619                   write_register (argreg, regval);
3620                   argreg++;
3621
3622                   /* Prevent subsequent floating point arguments from
3623                      being passed in floating point registers.  */
3624                   float_argreg = MIPS_LAST_FP_ARG_REGNUM + 1;
3625                 }
3626
3627               len -= partial_len;
3628               val += partial_len;
3629
3630               /* Compute the the offset into the stack at which we
3631                  will copy the next parameter.
3632
3633                  In older ABIs, the caller reserved space for
3634                  registers that contained arguments.  This was loosely
3635                  refered to as their "home".  Consequently, space is
3636                  always allocated.  */
3637
3638               stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
3639             }
3640         }
3641       if (mips_debug)
3642         fprintf_unfiltered (gdb_stdlog, "\n");
3643     }
3644
3645   /* Return adjusted stack pointer.  */
3646   return sp;
3647 }
3648
3649 static CORE_ADDR
3650 mips_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
3651 {
3652   /* Set the return address register to point to the entry
3653      point of the program, where a breakpoint lies in wait.  */
3654   write_register (RA_REGNUM, CALL_DUMMY_ADDRESS ());
3655   return sp;
3656 }
3657
3658 static void
3659 mips_push_register (CORE_ADDR * sp, int regno)
3660 {
3661   char *buffer = alloca (MAX_REGISTER_RAW_SIZE);
3662   int regsize;
3663   int offset;
3664   if (MIPS_SAVED_REGSIZE < REGISTER_RAW_SIZE (regno))
3665     {
3666       regsize = MIPS_SAVED_REGSIZE;
3667       offset = (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3668                 ? REGISTER_RAW_SIZE (regno) - MIPS_SAVED_REGSIZE
3669                 : 0);
3670     }
3671   else
3672     {
3673       regsize = REGISTER_RAW_SIZE (regno);
3674       offset = 0;
3675     }
3676   *sp -= regsize;
3677   read_register_gen (regno, buffer);
3678   write_memory (*sp, buffer + offset, regsize);
3679 }
3680
3681 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<(MIPS_NUMREGS-1). */
3682 #define MASK(i,j) (((1 << ((j)+1))-1) ^ ((1 << (i))-1))
3683
3684 static void
3685 mips_push_dummy_frame (void)
3686 {
3687   int ireg;
3688   struct linked_proc_info *link = (struct linked_proc_info *)
3689   xmalloc (sizeof (struct linked_proc_info));
3690   mips_extra_func_info_t proc_desc = &link->info;
3691   CORE_ADDR sp = ADDR_BITS_REMOVE (read_signed_register (SP_REGNUM));
3692   CORE_ADDR old_sp = sp;
3693   link->next = linked_proc_desc_table;
3694   linked_proc_desc_table = link;
3695
3696 /* FIXME!   are these correct ? */
3697 #define PUSH_FP_REGNUM 16       /* must be a register preserved across calls */
3698 #define GEN_REG_SAVE_MASK MASK(1,16)|MASK(24,28)|(1<<(MIPS_NUMREGS-1))
3699 #define FLOAT_REG_SAVE_MASK MASK(0,19)
3700 #define FLOAT_SINGLE_REG_SAVE_MASK \
3701   ((1<<18)|(1<<16)|(1<<14)|(1<<12)|(1<<10)|(1<<8)|(1<<6)|(1<<4)|(1<<2)|(1<<0))
3702   /*
3703    * The registers we must save are all those not preserved across
3704    * procedure calls. Dest_Reg (see tm-mips.h) must also be saved.
3705    * In addition, we must save the PC, PUSH_FP_REGNUM, MMLO/-HI
3706    * and FP Control/Status registers.
3707    *
3708    *
3709    * Dummy frame layout:
3710    *  (high memory)
3711    *    Saved PC
3712    *    Saved MMHI, MMLO, FPC_CSR
3713    *    Saved R31
3714    *    Saved R28
3715    *    ...
3716    *    Saved R1
3717    *    Saved D18 (i.e. F19, F18)
3718    *    ...
3719    *    Saved D0 (i.e. F1, F0)
3720    *    Argument build area and stack arguments written via mips_push_arguments
3721    *  (low memory)
3722    */
3723
3724   /* Save special registers (PC, MMHI, MMLO, FPC_CSR) */
3725   PROC_FRAME_REG (proc_desc) = PUSH_FP_REGNUM;
3726   PROC_FRAME_OFFSET (proc_desc) = 0;
3727   PROC_FRAME_ADJUST (proc_desc) = 0;
3728   mips_push_register (&sp, PC_REGNUM);
3729   mips_push_register (&sp, HI_REGNUM);
3730   mips_push_register (&sp, LO_REGNUM);
3731   mips_push_register (&sp, MIPS_FPU_TYPE == MIPS_FPU_NONE ? 0 : FCRCS_REGNUM);
3732
3733   /* Save general CPU registers */
3734   PROC_REG_MASK (proc_desc) = GEN_REG_SAVE_MASK;
3735   /* PROC_REG_OFFSET is the offset of the first saved register from FP.  */
3736   PROC_REG_OFFSET (proc_desc) = sp - old_sp - MIPS_SAVED_REGSIZE;
3737   for (ireg = 32; --ireg >= 0;)
3738     if (PROC_REG_MASK (proc_desc) & (1 << ireg))
3739       mips_push_register (&sp, ireg);
3740
3741   /* Save floating point registers starting with high order word */
3742   PROC_FREG_MASK (proc_desc) =
3743     MIPS_FPU_TYPE == MIPS_FPU_DOUBLE ? FLOAT_REG_SAVE_MASK
3744     : MIPS_FPU_TYPE == MIPS_FPU_SINGLE ? FLOAT_SINGLE_REG_SAVE_MASK : 0;
3745   /* PROC_FREG_OFFSET is the offset of the first saved *double* register
3746      from FP.  */
3747   PROC_FREG_OFFSET (proc_desc) = sp - old_sp - 8;
3748   for (ireg = 32; --ireg >= 0;)
3749     if (PROC_FREG_MASK (proc_desc) & (1 << ireg))
3750       mips_push_register (&sp, ireg + FP0_REGNUM);
3751
3752   /* Update the frame pointer for the call dummy and the stack pointer.
3753      Set the procedure's starting and ending addresses to point to the
3754      call dummy address at the entry point.  */
3755   write_register (PUSH_FP_REGNUM, old_sp);
3756   write_register (SP_REGNUM, sp);
3757   PROC_LOW_ADDR (proc_desc) = CALL_DUMMY_ADDRESS ();
3758   PROC_HIGH_ADDR (proc_desc) = CALL_DUMMY_ADDRESS () + 4;
3759   SET_PROC_DESC_IS_DUMMY (proc_desc);
3760   PROC_PC_REG (proc_desc) = RA_REGNUM;
3761 }
3762
3763 static void
3764 mips_pop_frame (void)
3765 {
3766   register int regnum;
3767   struct frame_info *frame = get_current_frame ();
3768   CORE_ADDR new_sp = FRAME_FP (frame);
3769
3770   mips_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
3771
3772   write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
3773   if (frame->saved_regs == NULL)
3774     FRAME_INIT_SAVED_REGS (frame);
3775   for (regnum = 0; regnum < NUM_REGS; regnum++)
3776     {
3777       if (regnum != SP_REGNUM && regnum != PC_REGNUM
3778           && frame->saved_regs[regnum])
3779         write_register (regnum,
3780                         read_memory_integer (frame->saved_regs[regnum],
3781                                              MIPS_SAVED_REGSIZE));
3782     }
3783
3784   write_register (SP_REGNUM, new_sp);
3785   flush_cached_frames ();
3786
3787   if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))
3788     {
3789       struct linked_proc_info *pi_ptr, *prev_ptr;
3790
3791       for (pi_ptr = linked_proc_desc_table, prev_ptr = NULL;
3792            pi_ptr != NULL;
3793            prev_ptr = pi_ptr, pi_ptr = pi_ptr->next)
3794         {
3795           if (&pi_ptr->info == proc_desc)
3796             break;
3797         }
3798
3799       if (pi_ptr == NULL)
3800         error ("Can't locate dummy extra frame info\n");
3801
3802       if (prev_ptr != NULL)
3803         prev_ptr->next = pi_ptr->next;
3804       else
3805         linked_proc_desc_table = pi_ptr->next;
3806
3807       xfree (pi_ptr);
3808
3809       write_register (HI_REGNUM,
3810                       read_memory_integer (new_sp - 2 * MIPS_SAVED_REGSIZE,
3811                                            MIPS_SAVED_REGSIZE));
3812       write_register (LO_REGNUM,
3813                       read_memory_integer (new_sp - 3 * MIPS_SAVED_REGSIZE,
3814                                            MIPS_SAVED_REGSIZE));
3815       if (MIPS_FPU_TYPE != MIPS_FPU_NONE)
3816         write_register (FCRCS_REGNUM,
3817                         read_memory_integer (new_sp - 4 * MIPS_SAVED_REGSIZE,
3818                                              MIPS_SAVED_REGSIZE));
3819     }
3820 }
3821
3822 static void
3823 mips_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
3824                      struct value **args, struct type *type, int gcc_p)
3825 {
3826   write_register(T9_REGNUM, fun);
3827 }
3828
3829 /* Floating point register management.
3830
3831    Background: MIPS1 & 2 fp registers are 32 bits wide.  To support
3832    64bit operations, these early MIPS cpus treat fp register pairs
3833    (f0,f1) as a single register (d0).  Later MIPS cpu's have 64 bit fp
3834    registers and offer a compatibility mode that emulates the MIPS2 fp
3835    model.  When operating in MIPS2 fp compat mode, later cpu's split
3836    double precision floats into two 32-bit chunks and store them in
3837    consecutive fp regs.  To display 64-bit floats stored in this
3838    fashion, we have to combine 32 bits from f0 and 32 bits from f1.
3839    Throw in user-configurable endianness and you have a real mess.
3840
3841    The way this works is:
3842      - If we are in 32-bit mode or on a 32-bit processor, then a 64-bit
3843        double-precision value will be split across two logical registers.
3844        The lower-numbered logical register will hold the low-order bits,
3845        regardless of the processor's endianness.
3846      - If we are on a 64-bit processor, and we are looking for a
3847        single-precision value, it will be in the low ordered bits
3848        of a 64-bit GPR (after mfc1, for example) or a 64-bit register
3849        save slot in memory.
3850      - If we are in 64-bit mode, everything is straightforward.
3851
3852    Note that this code only deals with "live" registers at the top of the
3853    stack.  We will attempt to deal with saved registers later, when
3854    the raw/cooked register interface is in place. (We need a general
3855    interface that can deal with dynamic saved register sizes -- fp
3856    regs could be 32 bits wide in one frame and 64 on the frame above
3857    and below).  */
3858
3859 static struct type *
3860 mips_float_register_type (void)
3861 {
3862   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3863     return builtin_type_ieee_single_big;
3864   else
3865     return builtin_type_ieee_single_little;
3866 }
3867
3868 static struct type *
3869 mips_double_register_type (void)
3870 {
3871   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3872     return builtin_type_ieee_double_big;
3873   else
3874     return builtin_type_ieee_double_little;
3875 }
3876
3877 /* Copy a 32-bit single-precision value from the current frame
3878    into rare_buffer.  */
3879
3880 static void
3881 mips_read_fp_register_single (int regno, char *rare_buffer)
3882 {
3883   int raw_size = REGISTER_RAW_SIZE (regno);
3884   char *raw_buffer = alloca (raw_size);
3885
3886   if (!frame_register_read (selected_frame, regno, raw_buffer))
3887     error ("can't read register %d (%s)", regno, REGISTER_NAME (regno));
3888   if (raw_size == 8)
3889     {
3890       /* We have a 64-bit value for this register.  Find the low-order
3891          32 bits.  */
3892       int offset;
3893
3894       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3895         offset = 4;
3896       else
3897         offset = 0;
3898
3899       memcpy (rare_buffer, raw_buffer + offset, 4);
3900     }
3901   else
3902     {
3903       memcpy (rare_buffer, raw_buffer, 4);
3904     }
3905 }
3906
3907 /* Copy a 64-bit double-precision value from the current frame into
3908    rare_buffer.  This may include getting half of it from the next
3909    register.  */
3910
3911 static void
3912 mips_read_fp_register_double (int regno, char *rare_buffer)
3913 {
3914   int raw_size = REGISTER_RAW_SIZE (regno);
3915
3916   if (raw_size == 8 && !mips2_fp_compat ())
3917     {
3918       /* We have a 64-bit value for this register, and we should use
3919          all 64 bits.  */
3920       if (!frame_register_read (selected_frame, regno, rare_buffer))
3921         error ("can't read register %d (%s)", regno, REGISTER_NAME (regno));
3922     }
3923   else
3924     {
3925       if ((regno - FP0_REGNUM) & 1)
3926         internal_error (__FILE__, __LINE__,
3927                         "mips_read_fp_register_double: bad access to "
3928                         "odd-numbered FP register");
3929
3930       /* mips_read_fp_register_single will find the correct 32 bits from
3931          each register.  */
3932       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3933         {
3934           mips_read_fp_register_single (regno, rare_buffer + 4);
3935           mips_read_fp_register_single (regno + 1, rare_buffer);
3936         }
3937       else
3938         {
3939           mips_read_fp_register_single (regno, rare_buffer);
3940           mips_read_fp_register_single (regno + 1, rare_buffer + 4);
3941         }
3942     }
3943 }
3944
3945 static void
3946 mips_print_register (int regnum, int all)
3947 {
3948   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
3949
3950   /* Get the data in raw format.  */
3951   if (!frame_register_read (selected_frame, regnum, raw_buffer))
3952     {
3953       printf_filtered ("%s: [Invalid]", REGISTER_NAME (regnum));
3954       return;
3955     }
3956
3957   /* If we have a actual 32-bit floating point register (or we are in
3958      32-bit compatibility mode), and the register is even-numbered,
3959      also print it as a double (spanning two registers).  */
3960   if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT
3961       && (REGISTER_RAW_SIZE (regnum) == 4
3962           || mips2_fp_compat ())
3963       && !((regnum - FP0_REGNUM) & 1))
3964     {
3965       char *dbuffer = alloca (2 * MAX_REGISTER_RAW_SIZE);
3966
3967       mips_read_fp_register_double (regnum, dbuffer);
3968
3969       printf_filtered ("(d%d: ", regnum - FP0_REGNUM);
3970       val_print (mips_double_register_type (), dbuffer, 0, 0,
3971                  gdb_stdout, 0, 1, 0, Val_pretty_default);
3972       printf_filtered ("); ");
3973     }
3974   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
3975
3976   /* The problem with printing numeric register names (r26, etc.) is that
3977      the user can't use them on input.  Probably the best solution is to
3978      fix it so that either the numeric or the funky (a2, etc.) names
3979      are accepted on input.  */
3980   if (regnum < MIPS_NUMREGS)
3981     printf_filtered ("(r%d): ", regnum);
3982   else
3983     printf_filtered (": ");
3984
3985   /* If virtual format is floating, print it that way.  */
3986   if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
3987     if (REGISTER_RAW_SIZE (regnum) == 8 && !mips2_fp_compat ())
3988       {
3989         /* We have a meaningful 64-bit value in this register.  Show
3990            it as a 32-bit float and a 64-bit double.  */
3991         int offset = 4 * (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG);
3992
3993         printf_filtered (" (float) ");
3994         val_print (mips_float_register_type (), raw_buffer + offset, 0, 0,
3995                    gdb_stdout, 0, 1, 0, Val_pretty_default);
3996         printf_filtered (", (double) ");
3997         val_print (mips_double_register_type (), raw_buffer, 0, 0,
3998                    gdb_stdout, 0, 1, 0, Val_pretty_default);
3999       }
4000     else
4001       val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
4002                  gdb_stdout, 0, 1, 0, Val_pretty_default);
4003   /* Else print as integer in hex.  */
4004   else
4005     {
4006       int offset;
4007
4008       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
4009         offset = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
4010       else
4011         offset = 0;
4012
4013       print_scalar_formatted (raw_buffer + offset,
4014                               REGISTER_VIRTUAL_TYPE (regnum),
4015                               'x', 0, gdb_stdout);
4016     }
4017 }
4018
4019 /* Replacement for generic do_registers_info.
4020    Print regs in pretty columns.  */
4021
4022 static int
4023 do_fp_register_row (int regnum)
4024 {                               /* do values for FP (float) regs */
4025   char *raw_buffer;
4026   double doub, flt1, flt2;      /* doubles extracted from raw hex data */
4027   int inv1, inv2, inv3;
4028
4029   raw_buffer = (char *) alloca (2 * REGISTER_RAW_SIZE (FP0_REGNUM));
4030
4031   if (REGISTER_RAW_SIZE (regnum) == 4 || mips2_fp_compat ())
4032     {
4033       /* 4-byte registers: we can fit two registers per row.  */
4034       /* Also print every pair of 4-byte regs as an 8-byte double.  */
4035       mips_read_fp_register_single (regnum, raw_buffer);
4036       flt1 = unpack_double (mips_float_register_type (), raw_buffer, &inv1);
4037
4038       mips_read_fp_register_single (regnum + 1, raw_buffer);
4039       flt2 = unpack_double (mips_float_register_type (), raw_buffer, &inv2);
4040
4041       mips_read_fp_register_double (regnum, raw_buffer);
4042       doub = unpack_double (mips_double_register_type (), raw_buffer, &inv3);
4043
4044       printf_filtered (" %-5s", REGISTER_NAME (regnum));
4045       if (inv1)
4046         printf_filtered (": <invalid float>");
4047       else
4048         printf_filtered ("%-17.9g", flt1);
4049
4050       printf_filtered (" %-5s", REGISTER_NAME (regnum + 1));
4051       if (inv2)
4052         printf_filtered (": <invalid float>");
4053       else
4054         printf_filtered ("%-17.9g", flt2);
4055
4056       printf_filtered (" dbl: ");
4057       if (inv3)
4058         printf_filtered ("<invalid double>");
4059       else
4060         printf_filtered ("%-24.17g", doub);
4061       printf_filtered ("\n");
4062
4063       /* may want to do hex display here (future enhancement) */
4064       regnum += 2;
4065     }
4066   else
4067     {
4068       /* Eight byte registers: print each one as float AND as double.  */
4069       mips_read_fp_register_single (regnum, raw_buffer);
4070       flt1 = unpack_double (mips_double_register_type (), raw_buffer, &inv1);
4071
4072       mips_read_fp_register_double (regnum, raw_buffer);
4073       doub = unpack_double (mips_double_register_type (), raw_buffer, &inv3);
4074
4075       printf_filtered (" %-5s: ", REGISTER_NAME (regnum));
4076       if (inv1)
4077         printf_filtered ("<invalid float>");
4078       else
4079         printf_filtered ("flt: %-17.9g", flt1);
4080
4081       printf_filtered (" dbl: ");
4082       if (inv3)
4083         printf_filtered ("<invalid double>");
4084       else
4085         printf_filtered ("%-24.17g", doub);
4086
4087       printf_filtered ("\n");
4088       /* may want to do hex display here (future enhancement) */
4089       regnum++;
4090     }
4091   return regnum;
4092 }
4093
4094 /* Print a row's worth of GP (int) registers, with name labels above */
4095
4096 static int
4097 do_gp_register_row (int regnum)
4098 {
4099   /* do values for GP (int) regs */
4100   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
4101   int ncols = (MIPS_REGSIZE == 8 ? 4 : 8);      /* display cols per row */
4102   int col, byte;
4103   int start_regnum = regnum;
4104   int numregs = NUM_REGS;
4105
4106
4107   /* For GP registers, we print a separate row of names above the vals */
4108   printf_filtered ("     ");
4109   for (col = 0; col < ncols && regnum < numregs; regnum++)
4110     {
4111       if (*REGISTER_NAME (regnum) == '\0')
4112         continue;               /* unused register */
4113       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4114         break;                  /* end the row: reached FP register */
4115       printf_filtered (MIPS_REGSIZE == 8 ? "%17s" : "%9s",
4116                        REGISTER_NAME (regnum));
4117       col++;
4118     }
4119   printf_filtered (start_regnum < MIPS_NUMREGS ? "\n R%-4d" : "\n      ",
4120                    start_regnum);       /* print the R0 to R31 names */
4121
4122   regnum = start_regnum;        /* go back to start of row */
4123   /* now print the values in hex, 4 or 8 to the row */
4124   for (col = 0; col < ncols && regnum < numregs; regnum++)
4125     {
4126       if (*REGISTER_NAME (regnum) == '\0')
4127         continue;               /* unused register */
4128       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4129         break;                  /* end row: reached FP register */
4130       /* OK: get the data in raw format.  */
4131       if (!frame_register_read (selected_frame, regnum, raw_buffer))
4132         error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
4133       /* pad small registers */
4134       for (byte = 0; byte < (MIPS_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
4135         printf_filtered ("  ");
4136       /* Now print the register value in hex, endian order. */
4137       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
4138         for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
4139              byte < REGISTER_RAW_SIZE (regnum);
4140              byte++)
4141           printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
4142       else
4143         for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
4144              byte >= 0;
4145              byte--)
4146           printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
4147       printf_filtered (" ");
4148       col++;
4149     }
4150   if (col > 0)                  /* ie. if we actually printed anything... */
4151     printf_filtered ("\n");
4152
4153   return regnum;
4154 }
4155
4156 /* MIPS_DO_REGISTERS_INFO(): called by "info register" command */
4157
4158 static void
4159 mips_do_registers_info (int regnum, int fpregs)
4160 {
4161   if (regnum != -1)             /* do one specified register */
4162     {
4163       if (*(REGISTER_NAME (regnum)) == '\0')
4164         error ("Not a valid register for the current processor type");
4165
4166       mips_print_register (regnum, 0);
4167       printf_filtered ("\n");
4168     }
4169   else
4170     /* do all (or most) registers */
4171     {
4172       regnum = 0;
4173       while (regnum < NUM_REGS)
4174         {
4175           if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4176             if (fpregs)         /* true for "INFO ALL-REGISTERS" command */
4177               regnum = do_fp_register_row (regnum);     /* FP regs */
4178             else
4179               regnum += MIPS_NUMREGS;   /* skip floating point regs */
4180           else
4181             regnum = do_gp_register_row (regnum);       /* GP (int) regs */
4182         }
4183     }
4184 }
4185
4186 /* Is this a branch with a delay slot?  */
4187
4188 static int is_delayed (unsigned long);
4189
4190 static int
4191 is_delayed (unsigned long insn)
4192 {
4193   int i;
4194   for (i = 0; i < NUMOPCODES; ++i)
4195     if (mips_opcodes[i].pinfo != INSN_MACRO
4196         && (insn & mips_opcodes[i].mask) == mips_opcodes[i].match)
4197       break;
4198   return (i < NUMOPCODES
4199           && (mips_opcodes[i].pinfo & (INSN_UNCOND_BRANCH_DELAY
4200                                        | INSN_COND_BRANCH_DELAY
4201                                        | INSN_COND_BRANCH_LIKELY)));
4202 }
4203
4204 int
4205 mips_step_skips_delay (CORE_ADDR pc)
4206 {
4207   char buf[MIPS_INSTLEN];
4208
4209   /* There is no branch delay slot on MIPS16.  */
4210   if (pc_is_mips16 (pc))
4211     return 0;
4212
4213   if (target_read_memory (pc, buf, MIPS_INSTLEN) != 0)
4214     /* If error reading memory, guess that it is not a delayed branch.  */
4215     return 0;
4216   return is_delayed ((unsigned long) extract_unsigned_integer (buf, MIPS_INSTLEN));
4217 }
4218
4219
4220 /* Skip the PC past function prologue instructions (32-bit version).
4221    This is a helper function for mips_skip_prologue.  */
4222
4223 static CORE_ADDR
4224 mips32_skip_prologue (CORE_ADDR pc)
4225 {
4226   t_inst inst;
4227   CORE_ADDR end_pc;
4228   int seen_sp_adjust = 0;
4229   int load_immediate_bytes = 0;
4230
4231   /* Skip the typical prologue instructions. These are the stack adjustment
4232      instruction and the instructions that save registers on the stack
4233      or in the gcc frame.  */
4234   for (end_pc = pc + 100; pc < end_pc; pc += MIPS_INSTLEN)
4235     {
4236       unsigned long high_word;
4237
4238       inst = mips_fetch_instruction (pc);
4239       high_word = (inst >> 16) & 0xffff;
4240
4241       if (high_word == 0x27bd   /* addiu $sp,$sp,offset */
4242           || high_word == 0x67bd)       /* daddiu $sp,$sp,offset */
4243         seen_sp_adjust = 1;
4244       else if (inst == 0x03a1e823 ||    /* subu $sp,$sp,$at */
4245                inst == 0x03a8e823)      /* subu $sp,$sp,$t0 */
4246         seen_sp_adjust = 1;
4247       else if (((inst & 0xFFE00000) == 0xAFA00000       /* sw reg,n($sp) */
4248                 || (inst & 0xFFE00000) == 0xFFA00000)   /* sd reg,n($sp) */
4249                && (inst & 0x001F0000))  /* reg != $zero */
4250         continue;
4251
4252       else if ((inst & 0xFFE00000) == 0xE7A00000)       /* swc1 freg,n($sp) */
4253         continue;
4254       else if ((inst & 0xF3E00000) == 0xA3C00000 && (inst & 0x001F0000))
4255         /* sx reg,n($s8) */
4256         continue;               /* reg != $zero */
4257
4258       /* move $s8,$sp.  With different versions of gas this will be either
4259          `addu $s8,$sp,$zero' or `or $s8,$sp,$zero' or `daddu s8,sp,$0'.
4260          Accept any one of these.  */
4261       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
4262         continue;
4263
4264       else if ((inst & 0xFF9F07FF) == 0x00800021)       /* move reg,$a0-$a3 */
4265         continue;
4266       else if (high_word == 0x3c1c)     /* lui $gp,n */
4267         continue;
4268       else if (high_word == 0x279c)     /* addiu $gp,$gp,n */
4269         continue;
4270       else if (inst == 0x0399e021       /* addu $gp,$gp,$t9 */
4271                || inst == 0x033ce021)   /* addu $gp,$t9,$gp */
4272         continue;
4273       /* The following instructions load $at or $t0 with an immediate
4274          value in preparation for a stack adjustment via
4275          subu $sp,$sp,[$at,$t0]. These instructions could also initialize
4276          a local variable, so we accept them only before a stack adjustment
4277          instruction was seen.  */
4278       else if (!seen_sp_adjust)
4279         {
4280           if (high_word == 0x3c01 ||    /* lui $at,n */
4281               high_word == 0x3c08)      /* lui $t0,n */
4282             {
4283               load_immediate_bytes += MIPS_INSTLEN;     /* FIXME!! */
4284               continue;
4285             }
4286           else if (high_word == 0x3421 ||       /* ori $at,$at,n */
4287                    high_word == 0x3508 ||       /* ori $t0,$t0,n */
4288                    high_word == 0x3401 ||       /* ori $at,$zero,n */
4289                    high_word == 0x3408)         /* ori $t0,$zero,n */
4290             {
4291               load_immediate_bytes += MIPS_INSTLEN;     /* FIXME!! */
4292               continue;
4293             }
4294           else
4295             break;
4296         }
4297       else
4298         break;
4299     }
4300
4301   /* In a frameless function, we might have incorrectly
4302      skipped some load immediate instructions. Undo the skipping
4303      if the load immediate was not followed by a stack adjustment.  */
4304   if (load_immediate_bytes && !seen_sp_adjust)
4305     pc -= load_immediate_bytes;
4306   return pc;
4307 }
4308
4309 /* Skip the PC past function prologue instructions (16-bit version).
4310    This is a helper function for mips_skip_prologue.  */
4311
4312 static CORE_ADDR
4313 mips16_skip_prologue (CORE_ADDR pc)
4314 {
4315   CORE_ADDR end_pc;
4316   int extend_bytes = 0;
4317   int prev_extend_bytes;
4318
4319   /* Table of instructions likely to be found in a function prologue.  */
4320   static struct
4321     {
4322       unsigned short inst;
4323       unsigned short mask;
4324     }
4325   table[] =
4326   {
4327     {
4328       0x6300, 0xff00
4329     }
4330     ,                           /* addiu $sp,offset */
4331     {
4332       0xfb00, 0xff00
4333     }
4334     ,                           /* daddiu $sp,offset */
4335     {
4336       0xd000, 0xf800
4337     }
4338     ,                           /* sw reg,n($sp) */
4339     {
4340       0xf900, 0xff00
4341     }
4342     ,                           /* sd reg,n($sp) */
4343     {
4344       0x6200, 0xff00
4345     }
4346     ,                           /* sw $ra,n($sp) */
4347     {
4348       0xfa00, 0xff00
4349     }
4350     ,                           /* sd $ra,n($sp) */
4351     {
4352       0x673d, 0xffff
4353     }
4354     ,                           /* move $s1,sp */
4355     {
4356       0xd980, 0xff80
4357     }
4358     ,                           /* sw $a0-$a3,n($s1) */
4359     {
4360       0x6704, 0xff1c
4361     }
4362     ,                           /* move reg,$a0-$a3 */
4363     {
4364       0xe809, 0xf81f
4365     }
4366     ,                           /* entry pseudo-op */
4367     {
4368       0x0100, 0xff00
4369     }
4370     ,                           /* addiu $s1,$sp,n */
4371     {
4372       0, 0
4373     }                           /* end of table marker */
4374   };
4375
4376   /* Skip the typical prologue instructions. These are the stack adjustment
4377      instruction and the instructions that save registers on the stack
4378      or in the gcc frame.  */
4379   for (end_pc = pc + 100; pc < end_pc; pc += MIPS16_INSTLEN)
4380     {
4381       unsigned short inst;
4382       int i;
4383
4384       inst = mips_fetch_instruction (pc);
4385
4386       /* Normally we ignore an extend instruction.  However, if it is
4387          not followed by a valid prologue instruction, we must adjust
4388          the pc back over the extend so that it won't be considered
4389          part of the prologue.  */
4390       if ((inst & 0xf800) == 0xf000)    /* extend */
4391         {
4392           extend_bytes = MIPS16_INSTLEN;
4393           continue;
4394         }
4395       prev_extend_bytes = extend_bytes;
4396       extend_bytes = 0;
4397
4398       /* Check for other valid prologue instructions besides extend.  */
4399       for (i = 0; table[i].mask != 0; i++)
4400         if ((inst & table[i].mask) == table[i].inst)    /* found, get out */
4401           break;
4402       if (table[i].mask != 0)   /* it was in table? */
4403         continue;               /* ignore it */
4404       else
4405         /* non-prologue */
4406         {
4407           /* Return the current pc, adjusted backwards by 2 if
4408              the previous instruction was an extend.  */
4409           return pc - prev_extend_bytes;
4410         }
4411     }
4412   return pc;
4413 }
4414
4415 /* To skip prologues, I use this predicate.  Returns either PC itself
4416    if the code at PC does not look like a function prologue; otherwise
4417    returns an address that (if we're lucky) follows the prologue.  If
4418    LENIENT, then we must skip everything which is involved in setting
4419    up the frame (it's OK to skip more, just so long as we don't skip
4420    anything which might clobber the registers which are being saved.
4421    We must skip more in the case where part of the prologue is in the
4422    delay slot of a non-prologue instruction).  */
4423
4424 static CORE_ADDR
4425 mips_skip_prologue (CORE_ADDR pc)
4426 {
4427   /* See if we can determine the end of the prologue via the symbol table.
4428      If so, then return either PC, or the PC after the prologue, whichever
4429      is greater.  */
4430
4431   CORE_ADDR post_prologue_pc = after_prologue (pc, NULL);
4432
4433   if (post_prologue_pc != 0)
4434     return max (pc, post_prologue_pc);
4435
4436   /* Can't determine prologue from the symbol table, need to examine
4437      instructions.  */
4438
4439   if (pc_is_mips16 (pc))
4440     return mips16_skip_prologue (pc);
4441   else
4442     return mips32_skip_prologue (pc);
4443 }
4444
4445 /* Determine how a return value is stored within the MIPS register
4446    file, given the return type `valtype'. */
4447
4448 struct return_value_word
4449 {
4450   int len;
4451   int reg;
4452   int reg_offset;
4453   int buf_offset;
4454 };
4455
4456 static void
4457 return_value_location (struct type *valtype,
4458                        struct return_value_word *hi,
4459                        struct return_value_word *lo)
4460 {
4461   int len = TYPE_LENGTH (valtype);
4462
4463   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
4464       && ((MIPS_FPU_TYPE == MIPS_FPU_DOUBLE && (len == 4 || len == 8))
4465           || (MIPS_FPU_TYPE == MIPS_FPU_SINGLE && len == 4)))
4466     {
4467       if (!FP_REGISTER_DOUBLE && len == 8)
4468         {
4469           /* We need to break a 64bit float in two 32 bit halves and
4470              spread them across a floating-point register pair. */
4471           lo->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
4472           hi->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 0 : 4;
4473           lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4474                              && REGISTER_RAW_SIZE (FP0_REGNUM) == 8)
4475                             ? 4 : 0);
4476           hi->reg_offset = lo->reg_offset;
4477           lo->reg = FP0_REGNUM + 0;
4478           hi->reg = FP0_REGNUM + 1;
4479           lo->len = 4;
4480           hi->len = 4;
4481         }
4482       else
4483         {
4484           /* The floating point value fits in a single floating-point
4485              register. */
4486           lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4487                              && REGISTER_RAW_SIZE (FP0_REGNUM) == 8
4488                              && len == 4)
4489                             ? 4 : 0);
4490           lo->reg = FP0_REGNUM;
4491           lo->len = len;
4492           lo->buf_offset = 0;
4493           hi->len = 0;
4494           hi->reg_offset = 0;
4495           hi->buf_offset = 0;
4496           hi->reg = 0;
4497         }
4498     }
4499   else
4500     {
4501       /* Locate a result possibly spread across two registers. */
4502       int regnum = 2;
4503       lo->reg = regnum + 0;
4504       hi->reg = regnum + 1;
4505       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4506           && len < MIPS_SAVED_REGSIZE)
4507         {
4508           /* "un-left-justify" the value in the low register */
4509           lo->reg_offset = MIPS_SAVED_REGSIZE - len;
4510           lo->len = len;
4511           hi->reg_offset = 0;
4512           hi->len = 0;
4513         }
4514       else if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4515                && len > MIPS_SAVED_REGSIZE      /* odd-size structs */
4516                && len < MIPS_SAVED_REGSIZE * 2
4517                && (TYPE_CODE (valtype) == TYPE_CODE_STRUCT ||
4518                    TYPE_CODE (valtype) == TYPE_CODE_UNION))
4519         {
4520           /* "un-left-justify" the value spread across two registers. */
4521           lo->reg_offset = 2 * MIPS_SAVED_REGSIZE - len;
4522           lo->len = MIPS_SAVED_REGSIZE - lo->reg_offset;
4523           hi->reg_offset = 0;
4524           hi->len = len - lo->len;
4525         }
4526       else
4527         {
4528           /* Only perform a partial copy of the second register. */
4529           lo->reg_offset = 0;
4530           hi->reg_offset = 0;
4531           if (len > MIPS_SAVED_REGSIZE)
4532             {
4533               lo->len = MIPS_SAVED_REGSIZE;
4534               hi->len = len - MIPS_SAVED_REGSIZE;
4535             }
4536           else
4537             {
4538               lo->len = len;
4539               hi->len = 0;
4540             }
4541         }
4542       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4543           && REGISTER_RAW_SIZE (regnum) == 8
4544           && MIPS_SAVED_REGSIZE == 4)
4545         {
4546           /* Account for the fact that only the least-signficant part
4547              of the register is being used */
4548           lo->reg_offset += 4;
4549           hi->reg_offset += 4;
4550         }
4551       lo->buf_offset = 0;
4552       hi->buf_offset = lo->len;
4553     }
4554 }
4555
4556 /* Given a return value in `regbuf' with a type `valtype', extract and
4557    copy its value into `valbuf'. */
4558
4559 static void
4560 mips_eabi_extract_return_value (struct type *valtype,
4561                                 char regbuf[REGISTER_BYTES],
4562                                 char *valbuf)
4563 {
4564   struct return_value_word lo;
4565   struct return_value_word hi;
4566   return_value_location (valtype, &hi, &lo);
4567
4568   memcpy (valbuf + lo.buf_offset,
4569           regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
4570           lo.len);
4571
4572   if (hi.len > 0)
4573     memcpy (valbuf + hi.buf_offset,
4574             regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
4575             hi.len);
4576 }
4577
4578 static void
4579 mips_o64_extract_return_value (struct type *valtype,
4580                                char regbuf[REGISTER_BYTES],
4581                                char *valbuf)
4582 {
4583   struct return_value_word lo;
4584   struct return_value_word hi;
4585   return_value_location (valtype, &hi, &lo);
4586
4587   memcpy (valbuf + lo.buf_offset,
4588           regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
4589           lo.len);
4590
4591   if (hi.len > 0)
4592     memcpy (valbuf + hi.buf_offset,
4593             regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
4594             hi.len);
4595 }
4596
4597 /* Given a return value in `valbuf' with a type `valtype', write it's
4598    value into the appropriate register. */
4599
4600 static void
4601 mips_eabi_store_return_value (struct type *valtype, char *valbuf)
4602 {
4603   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
4604   struct return_value_word lo;
4605   struct return_value_word hi;
4606   return_value_location (valtype, &hi, &lo);
4607
4608   memset (raw_buffer, 0, sizeof (raw_buffer));
4609   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
4610   write_register_bytes (REGISTER_BYTE (lo.reg),
4611                         raw_buffer,
4612                         REGISTER_RAW_SIZE (lo.reg));
4613
4614   if (hi.len > 0)
4615     {
4616       memset (raw_buffer, 0, sizeof (raw_buffer));
4617       memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
4618       write_register_bytes (REGISTER_BYTE (hi.reg),
4619                             raw_buffer,
4620                             REGISTER_RAW_SIZE (hi.reg));
4621     }
4622 }
4623
4624 static void
4625 mips_o64_store_return_value (struct type *valtype, char *valbuf)
4626 {
4627   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
4628   struct return_value_word lo;
4629   struct return_value_word hi;
4630   return_value_location (valtype, &hi, &lo);
4631
4632   memset (raw_buffer, 0, sizeof (raw_buffer));
4633   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
4634   write_register_bytes (REGISTER_BYTE (lo.reg),
4635                         raw_buffer,
4636                         REGISTER_RAW_SIZE (lo.reg));
4637
4638   if (hi.len > 0)
4639     {
4640       memset (raw_buffer, 0, sizeof (raw_buffer));
4641       memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
4642       write_register_bytes (REGISTER_BYTE (hi.reg),
4643                             raw_buffer,
4644                             REGISTER_RAW_SIZE (hi.reg));
4645     }
4646 }
4647
4648 /* O32 ABI stuff.  */
4649
4650 static void
4651 mips_o32_xfer_return_value (struct type *type,
4652                             struct regcache *regcache,
4653                             bfd_byte *in, const bfd_byte *out)
4654 {
4655   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
4656   if (TYPE_CODE (type) == TYPE_CODE_FLT
4657       && TYPE_LENGTH (type) == 4
4658       && tdep->mips_fpu_type != MIPS_FPU_NONE)
4659     {
4660       /* A single-precision floating-point value.  It fits in the
4661          least significant part of FP0.  */
4662       if (mips_debug)
4663         fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
4664       mips_xfer_register (regcache, FP0_REGNUM, TYPE_LENGTH (type),
4665                           TARGET_BYTE_ORDER, in, out, 0);
4666     }
4667   else if (TYPE_CODE (type) == TYPE_CODE_FLT
4668            && TYPE_LENGTH (type) == 8
4669            && tdep->mips_fpu_type != MIPS_FPU_NONE)
4670     {
4671       /* A double-precision floating-point value.  It fits in the
4672          least significant part of FP0/FP1 but with byte ordering
4673          based on the target (???).  */
4674       if (mips_debug)
4675         fprintf_unfiltered (gdb_stderr, "Return float in $fp0/$fp1\n");
4676       switch (TARGET_BYTE_ORDER)
4677         {
4678         case BFD_ENDIAN_LITTLE:
4679           mips_xfer_register (regcache, FP0_REGNUM + 0, 4,
4680                               TARGET_BYTE_ORDER, in, out, 0);
4681           mips_xfer_register (regcache, FP0_REGNUM + 1, 4,
4682                               TARGET_BYTE_ORDER, in, out, 4);
4683           break;
4684         case BFD_ENDIAN_BIG:
4685           mips_xfer_register (regcache, FP0_REGNUM + 1, 4,
4686                               TARGET_BYTE_ORDER, in, out, 0);
4687           mips_xfer_register (regcache, FP0_REGNUM + 0, 4,
4688                               TARGET_BYTE_ORDER, in, out, 4);
4689           break;
4690         default:
4691           internal_error (__FILE__, __LINE__, "bad switch");
4692         }
4693     }
4694 #if 0
4695   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4696            && TYPE_NFIELDS (type) <= 2
4697            && TYPE_NFIELDS (type) >= 1
4698            && ((TYPE_NFIELDS (type) == 1
4699                 && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4700                     == TYPE_CODE_FLT))
4701                || (TYPE_NFIELDS (type) == 2
4702                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4703                        == TYPE_CODE_FLT)
4704                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 1))
4705                        == TYPE_CODE_FLT)))
4706            && tdep->mips_fpu_type != MIPS_FPU_NONE)
4707     {
4708       /* A struct that contains one or two floats.  Each value is part
4709          in the least significant part of their floating point
4710          register..  */
4711       bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
4712       int regnum;
4713       int field;
4714       for (field = 0, regnum = FP0_REGNUM;
4715            field < TYPE_NFIELDS (type);
4716            field++, regnum += 2)
4717         {
4718           int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
4719                         / TARGET_CHAR_BIT);
4720           if (mips_debug)
4721             fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n", offset);
4722           mips_xfer_register (regcache, regnum, TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
4723                               TARGET_BYTE_ORDER, in, out, offset);
4724         }
4725     }
4726 #endif
4727 #if 0
4728   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4729            || TYPE_CODE (type) == TYPE_CODE_UNION)
4730     {
4731       /* A structure or union.  Extract the left justified value,
4732          regardless of the byte order.  I.e. DO NOT USE
4733          mips_xfer_lower.  */
4734       int offset;
4735       int regnum;
4736       for (offset = 0, regnum = V0_REGNUM;
4737            offset < TYPE_LENGTH (type);
4738            offset += REGISTER_RAW_SIZE (regnum), regnum++)
4739         {
4740           int xfer = REGISTER_RAW_SIZE (regnum);
4741           if (offset + xfer > TYPE_LENGTH (type))
4742             xfer = TYPE_LENGTH (type) - offset;
4743           if (mips_debug)
4744             fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
4745                                 offset, xfer, regnum);
4746           mips_xfer_register (regcache, regnum, xfer, BFD_ENDIAN_UNKNOWN,
4747                               in, out, offset);
4748         }
4749     }
4750 #endif
4751   else
4752     {
4753       /* A scalar extract each part but least-significant-byte
4754          justified.  o32 thinks registers are 4 byte, regardless of
4755          the ISA.  mips_stack_argsize controls this.  */
4756       int offset;
4757       int regnum;
4758       for (offset = 0, regnum = V0_REGNUM;
4759            offset < TYPE_LENGTH (type);
4760            offset += mips_stack_argsize (), regnum++)
4761         {
4762           int xfer = mips_stack_argsize ();
4763           int pos = 0;
4764           if (offset + xfer > TYPE_LENGTH (type))
4765             xfer = TYPE_LENGTH (type) - offset;
4766           if (mips_debug)
4767             fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
4768                                 offset, xfer, regnum);
4769           mips_xfer_register (regcache, regnum, xfer, TARGET_BYTE_ORDER,
4770                               in, out, offset);
4771         }
4772     }
4773 }
4774
4775 static void
4776 mips_o32_extract_return_value (struct type *type,
4777                                struct regcache *regcache,
4778                                char *valbuf)
4779 {
4780   mips_o32_xfer_return_value (type, regcache, valbuf, NULL);
4781 }
4782
4783 static void
4784 mips_o32_store_return_value (struct type *type, char *valbuf)
4785 {
4786   mips_o32_xfer_return_value (type, current_regcache, NULL, valbuf);
4787 }
4788
4789 /* N32/N44 ABI stuff.  */
4790
4791 static void
4792 mips_n32n64_xfer_return_value (struct type *type,
4793                                struct regcache *regcache,
4794                                bfd_byte *in, const bfd_byte *out)
4795 {
4796   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
4797   if (TYPE_CODE (type) == TYPE_CODE_FLT
4798       && tdep->mips_fpu_type != MIPS_FPU_NONE)
4799     {
4800       /* A floating-point value belongs in the least significant part
4801          of FP0.  */
4802       if (mips_debug)
4803         fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
4804       mips_xfer_register (regcache, FP0_REGNUM, TYPE_LENGTH (type),
4805                           TARGET_BYTE_ORDER, in, out, 0);
4806     }
4807   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4808            && TYPE_NFIELDS (type) <= 2
4809            && TYPE_NFIELDS (type) >= 1
4810            && ((TYPE_NFIELDS (type) == 1
4811                 && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4812                     == TYPE_CODE_FLT))
4813                || (TYPE_NFIELDS (type) == 2
4814                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4815                        == TYPE_CODE_FLT)
4816                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 1))
4817                        == TYPE_CODE_FLT)))
4818            && tdep->mips_fpu_type != MIPS_FPU_NONE)
4819     {
4820       /* A struct that contains one or two floats.  Each value is part
4821          in the least significant part of their floating point
4822          register..  */
4823       bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
4824       int regnum;
4825       int field;
4826       for (field = 0, regnum = FP0_REGNUM;
4827            field < TYPE_NFIELDS (type);
4828            field++, regnum += 2)
4829         {
4830           int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
4831                         / TARGET_CHAR_BIT);
4832           if (mips_debug)
4833             fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n", offset);
4834           mips_xfer_register (regcache, regnum, TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
4835                               TARGET_BYTE_ORDER, in, out, offset);
4836         }
4837     }
4838   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4839            || TYPE_CODE (type) == TYPE_CODE_UNION)
4840     {
4841       /* A structure or union.  Extract the left justified value,
4842          regardless of the byte order.  I.e. DO NOT USE
4843          mips_xfer_lower.  */
4844       int offset;
4845       int regnum;
4846       for (offset = 0, regnum = V0_REGNUM;
4847            offset < TYPE_LENGTH (type);
4848            offset += REGISTER_RAW_SIZE (regnum), regnum++)
4849         {
4850           int xfer = REGISTER_RAW_SIZE (regnum);
4851           if (offset + xfer > TYPE_LENGTH (type))
4852             xfer = TYPE_LENGTH (type) - offset;
4853           if (mips_debug)
4854             fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
4855                                 offset, xfer, regnum);
4856           mips_xfer_register (regcache, regnum, xfer, BFD_ENDIAN_UNKNOWN,
4857                               in, out, offset);
4858         }
4859     }
4860   else
4861     {
4862       /* A scalar extract each part but least-significant-byte
4863          justified.  */
4864       int offset;
4865       int regnum;
4866       for (offset = 0, regnum = V0_REGNUM;
4867            offset < TYPE_LENGTH (type);
4868            offset += REGISTER_RAW_SIZE (regnum), regnum++)
4869         {
4870           int xfer = REGISTER_RAW_SIZE (regnum);
4871           int pos = 0;
4872           if (offset + xfer > TYPE_LENGTH (type))
4873             xfer = TYPE_LENGTH (type) - offset;
4874           if (mips_debug)
4875             fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
4876                                 offset, xfer, regnum);
4877           mips_xfer_register (regcache, regnum, xfer, TARGET_BYTE_ORDER,
4878                               in, out, offset);
4879         }
4880     }
4881 }
4882
4883 static void
4884 mips_n32n64_extract_return_value (struct type *type,
4885                                   struct regcache *regcache,
4886                                   char *valbuf)
4887 {
4888   mips_n32n64_xfer_return_value (type, regcache, valbuf, NULL);
4889 }
4890
4891 static void
4892 mips_n32n64_store_return_value (struct type *type, char *valbuf)
4893 {
4894   mips_n32n64_xfer_return_value (type, current_regcache, NULL, valbuf);
4895 }
4896
4897 static void
4898 mips_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
4899 {
4900   /* Nothing to do -- push_arguments does all the work.  */
4901 }
4902
4903 static CORE_ADDR
4904 mips_extract_struct_value_address (struct regcache *ignore)
4905 {
4906   /* FIXME: This will only work at random.  The caller passes the
4907      struct_return address in V0, but it is not preserved.  It may
4908      still be there, or this may be a random value.  */
4909   return read_register (V0_REGNUM);
4910 }
4911
4912 /* Exported procedure: Is PC in the signal trampoline code */
4913
4914 static int
4915 mips_pc_in_sigtramp (CORE_ADDR pc, char *ignore)
4916 {
4917   if (sigtramp_address == 0)
4918     fixup_sigtramp ();
4919   return (pc >= sigtramp_address && pc < sigtramp_end);
4920 }
4921
4922 /* Root of all "set mips "/"show mips " commands. This will eventually be
4923    used for all MIPS-specific commands.  */
4924
4925 static void
4926 show_mips_command (char *args, int from_tty)
4927 {
4928   help_list (showmipscmdlist, "show mips ", all_commands, gdb_stdout);
4929 }
4930
4931 static void
4932 set_mips_command (char *args, int from_tty)
4933 {
4934   printf_unfiltered ("\"set mips\" must be followed by an appropriate subcommand.\n");
4935   help_list (setmipscmdlist, "set mips ", all_commands, gdb_stdout);
4936 }
4937
4938 /* Commands to show/set the MIPS FPU type.  */
4939
4940 static void
4941 show_mipsfpu_command (char *args, int from_tty)
4942 {
4943   char *fpu;
4944   switch (MIPS_FPU_TYPE)
4945     {
4946     case MIPS_FPU_SINGLE:
4947       fpu = "single-precision";
4948       break;
4949     case MIPS_FPU_DOUBLE:
4950       fpu = "double-precision";
4951       break;
4952     case MIPS_FPU_NONE:
4953       fpu = "absent (none)";
4954       break;
4955     default:
4956       internal_error (__FILE__, __LINE__, "bad switch");
4957     }
4958   if (mips_fpu_type_auto)
4959     printf_unfiltered ("The MIPS floating-point coprocessor is set automatically (currently %s)\n",
4960                        fpu);
4961   else
4962     printf_unfiltered ("The MIPS floating-point coprocessor is assumed to be %s\n",
4963                        fpu);
4964 }
4965
4966
4967 static void
4968 set_mipsfpu_command (char *args, int from_tty)
4969 {
4970   printf_unfiltered ("\"set mipsfpu\" must be followed by \"double\", \"single\",\"none\" or \"auto\".\n");
4971   show_mipsfpu_command (args, from_tty);
4972 }
4973
4974 static void
4975 set_mipsfpu_single_command (char *args, int from_tty)
4976 {
4977   mips_fpu_type = MIPS_FPU_SINGLE;
4978   mips_fpu_type_auto = 0;
4979   gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_SINGLE;
4980 }
4981
4982 static void
4983 set_mipsfpu_double_command (char *args, int from_tty)
4984 {
4985   mips_fpu_type = MIPS_FPU_DOUBLE;
4986   mips_fpu_type_auto = 0;
4987   gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_DOUBLE;
4988 }
4989
4990 static void
4991 set_mipsfpu_none_command (char *args, int from_tty)
4992 {
4993   mips_fpu_type = MIPS_FPU_NONE;
4994   mips_fpu_type_auto = 0;
4995   gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_NONE;
4996 }
4997
4998 static void
4999 set_mipsfpu_auto_command (char *args, int from_tty)
5000 {
5001   mips_fpu_type_auto = 1;
5002 }
5003
5004 /* Command to set the processor type.  */
5005
5006 void
5007 mips_set_processor_type_command (char *args, int from_tty)
5008 {
5009   int i;
5010
5011   if (tmp_mips_processor_type == NULL || *tmp_mips_processor_type == '\0')
5012     {
5013       printf_unfiltered ("The known MIPS processor types are as follows:\n\n");
5014       for (i = 0; mips_processor_type_table[i].name != NULL; ++i)
5015         printf_unfiltered ("%s\n", mips_processor_type_table[i].name);
5016
5017       /* Restore the value.  */
5018       tmp_mips_processor_type = xstrdup (mips_processor_type);
5019
5020       return;
5021     }
5022
5023   if (!mips_set_processor_type (tmp_mips_processor_type))
5024     {
5025       error ("Unknown processor type `%s'.", tmp_mips_processor_type);
5026       /* Restore its value.  */
5027       tmp_mips_processor_type = xstrdup (mips_processor_type);
5028     }
5029 }
5030
5031 static void
5032 mips_show_processor_type_command (char *args, int from_tty)
5033 {
5034 }
5035
5036 /* Modify the actual processor type. */
5037
5038 int
5039 mips_set_processor_type (char *str)
5040 {
5041   int i;
5042
5043   if (str == NULL)
5044     return 0;
5045
5046   for (i = 0; mips_processor_type_table[i].name != NULL; ++i)
5047     {
5048       if (strcasecmp (str, mips_processor_type_table[i].name) == 0)
5049         {
5050           mips_processor_type = str;
5051           mips_processor_reg_names = mips_processor_type_table[i].regnames;
5052           return 1;
5053           /* FIXME tweak fpu flag too */
5054         }
5055     }
5056
5057   return 0;
5058 }
5059
5060 /* Attempt to identify the particular processor model by reading the
5061    processor id.  */
5062
5063 char *
5064 mips_read_processor_type (void)
5065 {
5066   CORE_ADDR prid;
5067
5068   prid = read_register (PRID_REGNUM);
5069
5070   if ((prid & ~0xf) == 0x700)
5071     return savestring ("r3041", strlen ("r3041"));
5072
5073   return NULL;
5074 }
5075
5076 /* Just like reinit_frame_cache, but with the right arguments to be
5077    callable as an sfunc.  */
5078
5079 static void
5080 reinit_frame_cache_sfunc (char *args, int from_tty,
5081                           struct cmd_list_element *c)
5082 {
5083   reinit_frame_cache ();
5084 }
5085
5086 int
5087 gdb_print_insn_mips (bfd_vma memaddr, disassemble_info *info)
5088 {
5089   mips_extra_func_info_t proc_desc;
5090
5091   /* Search for the function containing this address.  Set the low bit
5092      of the address when searching, in case we were given an even address
5093      that is the start of a 16-bit function.  If we didn't do this,
5094      the search would fail because the symbol table says the function
5095      starts at an odd address, i.e. 1 byte past the given address.  */
5096   memaddr = ADDR_BITS_REMOVE (memaddr);
5097   proc_desc = non_heuristic_proc_desc (MAKE_MIPS16_ADDR (memaddr), NULL);
5098
5099   /* Make an attempt to determine if this is a 16-bit function.  If
5100      the procedure descriptor exists and the address therein is odd,
5101      it's definitely a 16-bit function.  Otherwise, we have to just
5102      guess that if the address passed in is odd, it's 16-bits.  */
5103   if (proc_desc)
5104     info->mach = pc_is_mips16 (PROC_LOW_ADDR (proc_desc)) ?
5105       bfd_mach_mips16 : TM_PRINT_INSN_MACH;
5106   else
5107     info->mach = pc_is_mips16 (memaddr) ?
5108       bfd_mach_mips16 : TM_PRINT_INSN_MACH;
5109
5110   /* Round down the instruction address to the appropriate boundary.  */
5111   memaddr &= (info->mach == bfd_mach_mips16 ? ~1 : ~3);
5112
5113   /* Call the appropriate disassembler based on the target endian-ness.  */
5114   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
5115     return print_insn_big_mips (memaddr, info);
5116   else
5117     return print_insn_little_mips (memaddr, info);
5118 }
5119
5120 /* Old-style breakpoint macros.
5121    The IDT board uses an unusual breakpoint value, and sometimes gets
5122    confused when it sees the usual MIPS breakpoint instruction.  */
5123
5124 #define BIG_BREAKPOINT {0, 0x5, 0, 0xd}
5125 #define LITTLE_BREAKPOINT {0xd, 0, 0x5, 0}
5126 #define PMON_BIG_BREAKPOINT {0, 0, 0, 0xd}
5127 #define PMON_LITTLE_BREAKPOINT {0xd, 0, 0, 0}
5128 #define IDT_BIG_BREAKPOINT {0, 0, 0x0a, 0xd}
5129 #define IDT_LITTLE_BREAKPOINT {0xd, 0x0a, 0, 0}
5130 #define MIPS16_BIG_BREAKPOINT {0xe8, 0xa5}
5131 #define MIPS16_LITTLE_BREAKPOINT {0xa5, 0xe8}
5132
5133 /* This function implements the BREAKPOINT_FROM_PC macro.  It uses the program
5134    counter value to determine whether a 16- or 32-bit breakpoint should be
5135    used.  It returns a pointer to a string of bytes that encode a breakpoint
5136    instruction, stores the length of the string to *lenptr, and adjusts pc
5137    (if necessary) to point to the actual memory location where the
5138    breakpoint should be inserted.  */
5139
5140 static const unsigned char *
5141 mips_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
5142 {
5143   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
5144     {
5145       if (pc_is_mips16 (*pcptr))
5146         {
5147           static unsigned char mips16_big_breakpoint[] =
5148             MIPS16_BIG_BREAKPOINT;
5149           *pcptr = UNMAKE_MIPS16_ADDR (*pcptr);
5150           *lenptr = sizeof (mips16_big_breakpoint);
5151           return mips16_big_breakpoint;
5152         }
5153       else
5154         {
5155           static unsigned char big_breakpoint[] = BIG_BREAKPOINT;
5156           static unsigned char pmon_big_breakpoint[] = PMON_BIG_BREAKPOINT;
5157           static unsigned char idt_big_breakpoint[] = IDT_BIG_BREAKPOINT;
5158
5159           *lenptr = sizeof (big_breakpoint);
5160
5161           if (strcmp (target_shortname, "mips") == 0)
5162             return idt_big_breakpoint;
5163           else if (strcmp (target_shortname, "ddb") == 0
5164                    || strcmp (target_shortname, "pmon") == 0
5165                    || strcmp (target_shortname, "lsi") == 0)
5166             return pmon_big_breakpoint;
5167           else
5168             return big_breakpoint;
5169         }
5170     }
5171   else
5172     {
5173       if (pc_is_mips16 (*pcptr))
5174         {
5175           static unsigned char mips16_little_breakpoint[] =
5176             MIPS16_LITTLE_BREAKPOINT;
5177           *pcptr = UNMAKE_MIPS16_ADDR (*pcptr);
5178           *lenptr = sizeof (mips16_little_breakpoint);
5179           return mips16_little_breakpoint;
5180         }
5181       else
5182         {
5183           static unsigned char little_breakpoint[] = LITTLE_BREAKPOINT;
5184           static unsigned char pmon_little_breakpoint[] =
5185             PMON_LITTLE_BREAKPOINT;
5186           static unsigned char idt_little_breakpoint[] =
5187             IDT_LITTLE_BREAKPOINT;
5188
5189           *lenptr = sizeof (little_breakpoint);
5190
5191           if (strcmp (target_shortname, "mips") == 0)
5192             return idt_little_breakpoint;
5193           else if (strcmp (target_shortname, "ddb") == 0
5194                    || strcmp (target_shortname, "pmon") == 0
5195                    || strcmp (target_shortname, "lsi") == 0)
5196             return pmon_little_breakpoint;
5197           else
5198             return little_breakpoint;
5199         }
5200     }
5201 }
5202
5203 /* If PC is in a mips16 call or return stub, return the address of the target
5204    PC, which is either the callee or the caller.  There are several
5205    cases which must be handled:
5206
5207    * If the PC is in __mips16_ret_{d,s}f, this is a return stub and the
5208    target PC is in $31 ($ra).
5209    * If the PC is in __mips16_call_stub_{1..10}, this is a call stub
5210    and the target PC is in $2.
5211    * If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
5212    before the jal instruction, this is effectively a call stub
5213    and the the target PC is in $2.  Otherwise this is effectively
5214    a return stub and the target PC is in $18.
5215
5216    See the source code for the stubs in gcc/config/mips/mips16.S for
5217    gory details.
5218
5219    This function implements the SKIP_TRAMPOLINE_CODE macro.
5220  */
5221
5222 static CORE_ADDR
5223 mips_skip_stub (CORE_ADDR pc)
5224 {
5225   char *name;
5226   CORE_ADDR start_addr;
5227
5228   /* Find the starting address and name of the function containing the PC.  */
5229   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
5230     return 0;
5231
5232   /* If the PC is in __mips16_ret_{d,s}f, this is a return stub and the
5233      target PC is in $31 ($ra).  */
5234   if (strcmp (name, "__mips16_ret_sf") == 0
5235       || strcmp (name, "__mips16_ret_df") == 0)
5236     return read_signed_register (RA_REGNUM);
5237
5238   if (strncmp (name, "__mips16_call_stub_", 19) == 0)
5239     {
5240       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub
5241          and the target PC is in $2.  */
5242       if (name[19] >= '0' && name[19] <= '9')
5243         return read_signed_register (2);
5244
5245       /* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
5246          before the jal instruction, this is effectively a call stub
5247          and the the target PC is in $2.  Otherwise this is effectively
5248          a return stub and the target PC is in $18.  */
5249       else if (name[19] == 's' || name[19] == 'd')
5250         {
5251           if (pc == start_addr)
5252             {
5253               /* Check if the target of the stub is a compiler-generated
5254                  stub.  Such a stub for a function bar might have a name
5255                  like __fn_stub_bar, and might look like this:
5256                  mfc1    $4,$f13
5257                  mfc1    $5,$f12
5258                  mfc1    $6,$f15
5259                  mfc1    $7,$f14
5260                  la      $1,bar   (becomes a lui/addiu pair)
5261                  jr      $1
5262                  So scan down to the lui/addi and extract the target
5263                  address from those two instructions.  */
5264
5265               CORE_ADDR target_pc = read_signed_register (2);
5266               t_inst inst;
5267               int i;
5268
5269               /* See if the name of the target function is  __fn_stub_*.  */
5270               if (find_pc_partial_function (target_pc, &name, NULL, NULL) == 0)
5271                 return target_pc;
5272               if (strncmp (name, "__fn_stub_", 10) != 0
5273                   && strcmp (name, "etext") != 0
5274                   && strcmp (name, "_etext") != 0)
5275                 return target_pc;
5276
5277               /* Scan through this _fn_stub_ code for the lui/addiu pair.
5278                  The limit on the search is arbitrarily set to 20
5279                  instructions.  FIXME.  */
5280               for (i = 0, pc = 0; i < 20; i++, target_pc += MIPS_INSTLEN)
5281                 {
5282                   inst = mips_fetch_instruction (target_pc);
5283                   if ((inst & 0xffff0000) == 0x3c010000)        /* lui $at */
5284                     pc = (inst << 16) & 0xffff0000;     /* high word */
5285                   else if ((inst & 0xffff0000) == 0x24210000)   /* addiu $at */
5286                     return pc | (inst & 0xffff);        /* low word */
5287                 }
5288
5289               /* Couldn't find the lui/addui pair, so return stub address.  */
5290               return target_pc;
5291             }
5292           else
5293             /* This is the 'return' part of a call stub.  The return
5294                address is in $r18.  */
5295             return read_signed_register (18);
5296         }
5297     }
5298   return 0;                     /* not a stub */
5299 }
5300
5301
5302 /* Return non-zero if the PC is inside a call thunk (aka stub or trampoline).
5303    This implements the IN_SOLIB_CALL_TRAMPOLINE macro.  */
5304
5305 static int
5306 mips_in_call_stub (CORE_ADDR pc, char *name)
5307 {
5308   CORE_ADDR start_addr;
5309
5310   /* Find the starting address of the function containing the PC.  If the
5311      caller didn't give us a name, look it up at the same time.  */
5312   if (find_pc_partial_function (pc, name ? NULL : &name, &start_addr, NULL) == 0)
5313     return 0;
5314
5315   if (strncmp (name, "__mips16_call_stub_", 19) == 0)
5316     {
5317       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub.  */
5318       if (name[19] >= '0' && name[19] <= '9')
5319         return 1;
5320       /* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
5321          before the jal instruction, this is effectively a call stub.  */
5322       else if (name[19] == 's' || name[19] == 'd')
5323         return pc == start_addr;
5324     }
5325
5326   return 0;                     /* not a stub */
5327 }
5328
5329
5330 /* Return non-zero if the PC is inside a return thunk (aka stub or trampoline).
5331    This implements the IN_SOLIB_RETURN_TRAMPOLINE macro.  */
5332
5333 static int
5334 mips_in_return_stub (CORE_ADDR pc, char *name)
5335 {
5336   CORE_ADDR start_addr;
5337
5338   /* Find the starting address of the function containing the PC.  */
5339   if (find_pc_partial_function (pc, NULL, &start_addr, NULL) == 0)
5340     return 0;
5341
5342   /* If the PC is in __mips16_ret_{d,s}f, this is a return stub.  */
5343   if (strcmp (name, "__mips16_ret_sf") == 0
5344       || strcmp (name, "__mips16_ret_df") == 0)
5345     return 1;
5346
5347   /* If the PC is in __mips16_call_stub_{s,d}f_{0..10} but not at the start,
5348      i.e. after the jal instruction, this is effectively a return stub.  */
5349   if (strncmp (name, "__mips16_call_stub_", 19) == 0
5350       && (name[19] == 's' || name[19] == 'd')
5351       && pc != start_addr)
5352     return 1;
5353
5354   return 0;                     /* not a stub */
5355 }
5356
5357
5358 /* Return non-zero if the PC is in a library helper function that should
5359    be ignored.  This implements the IGNORE_HELPER_CALL macro.  */
5360
5361 int
5362 mips_ignore_helper (CORE_ADDR pc)
5363 {
5364   char *name;
5365
5366   /* Find the starting address and name of the function containing the PC.  */
5367   if (find_pc_partial_function (pc, &name, NULL, NULL) == 0)
5368     return 0;
5369
5370   /* If the PC is in __mips16_ret_{d,s}f, this is a library helper function
5371      that we want to ignore.  */
5372   return (strcmp (name, "__mips16_ret_sf") == 0
5373           || strcmp (name, "__mips16_ret_df") == 0);
5374 }
5375
5376
5377 /* Return a location where we can set a breakpoint that will be hit
5378    when an inferior function call returns.  This is normally the
5379    program's entry point.  Executables that don't have an entry
5380    point (e.g. programs in ROM) should define a symbol __CALL_DUMMY_ADDRESS
5381    whose address is the location where the breakpoint should be placed.  */
5382
5383 static CORE_ADDR
5384 mips_call_dummy_address (void)
5385 {
5386   struct minimal_symbol *sym;
5387
5388   sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
5389   if (sym)
5390     return SYMBOL_VALUE_ADDRESS (sym);
5391   else
5392     return entry_point_address ();
5393 }
5394
5395
5396 /* If the current gcc for this target does not produce correct debugging
5397    information for float parameters, both prototyped and unprototyped, then
5398    define this macro.  This forces gdb to  always assume that floats are
5399    passed as doubles and then converted in the callee.
5400
5401    For the mips chip, it appears that the debug info marks the parameters as
5402    floats regardless of whether the function is prototyped, but the actual
5403    values are passed as doubles for the non-prototyped case and floats for
5404    the prototyped case.  Thus we choose to make the non-prototyped case work
5405    for C and break the prototyped case, since the non-prototyped case is
5406    probably much more common.  (FIXME). */
5407
5408 static int
5409 mips_coerce_float_to_double (struct type *formal, struct type *actual)
5410 {
5411   return current_language->la_language == language_c;
5412 }
5413
5414 /* When debugging a 64 MIPS target running a 32 bit ABI, the size of
5415    the register stored on the stack (32) is different to its real raw
5416    size (64).  The below ensures that registers are fetched from the
5417    stack using their ABI size and then stored into the RAW_BUFFER
5418    using their raw size.
5419
5420    The alternative to adding this function would be to add an ABI
5421    macro - REGISTER_STACK_SIZE(). */
5422
5423 static void
5424 mips_get_saved_register (char *raw_buffer,
5425                          int *optimized,
5426                          CORE_ADDR *addrp,
5427                          struct frame_info *frame,
5428                          int regnum,
5429                          enum lval_type *lval)
5430 {
5431   CORE_ADDR addr;
5432
5433   if (!target_has_registers)
5434     error ("No registers.");
5435
5436   /* Normal systems don't optimize out things with register numbers.  */
5437   if (optimized != NULL)
5438     *optimized = 0;
5439   addr = find_saved_register (frame, regnum);
5440   if (addr != 0)
5441     {
5442       if (lval != NULL)
5443         *lval = lval_memory;
5444       if (regnum == SP_REGNUM)
5445         {
5446           if (raw_buffer != NULL)
5447             {
5448               /* Put it back in target format.  */
5449               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
5450                              (LONGEST) addr);
5451             }
5452           if (addrp != NULL)
5453             *addrp = 0;
5454           return;
5455         }
5456       if (raw_buffer != NULL)
5457         {
5458           LONGEST val;
5459           if (regnum < 32)
5460             /* Only MIPS_SAVED_REGSIZE bytes of GP registers are
5461                saved. */
5462             val = read_memory_integer (addr, MIPS_SAVED_REGSIZE);
5463           else
5464             val = read_memory_integer (addr, REGISTER_RAW_SIZE (regnum));
5465           store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), val);
5466         }
5467     }
5468   else
5469     {
5470       if (lval != NULL)
5471         *lval = lval_register;
5472       addr = REGISTER_BYTE (regnum);
5473       if (raw_buffer != NULL)
5474         read_register_gen (regnum, raw_buffer);
5475     }
5476   if (addrp != NULL)
5477     *addrp = addr;
5478 }
5479
5480 /* Immediately after a function call, return the saved pc.
5481    Can't always go through the frames for this because on some machines
5482    the new frame is not set up until the new function executes
5483    some instructions.  */
5484
5485 static CORE_ADDR
5486 mips_saved_pc_after_call (struct frame_info *frame)
5487 {
5488   return read_signed_register (RA_REGNUM);
5489 }
5490
5491
5492 /* Convert a dbx stab register number (from `r' declaration) to a gdb
5493    REGNUM */
5494
5495 static int
5496 mips_stab_reg_to_regnum (int num)
5497 {
5498   if (num < 32)
5499     return num;
5500   else
5501     return num + FP0_REGNUM - 38;
5502 }
5503
5504 /* Convert a ecoff register number to a gdb REGNUM */
5505
5506 static int
5507 mips_ecoff_reg_to_regnum (int num)
5508 {
5509   if (num < 32)
5510     return num;
5511   else
5512     return num + FP0_REGNUM - 32;
5513 }
5514
5515 /* Convert an integer into an address.  By first converting the value
5516    into a pointer and then extracting it signed, the address is
5517    guarenteed to be correctly sign extended.  */
5518
5519 static CORE_ADDR
5520 mips_integer_to_address (struct type *type, void *buf)
5521 {
5522   char *tmp = alloca (TYPE_LENGTH (builtin_type_void_data_ptr));
5523   LONGEST val = unpack_long (type, buf);
5524   store_signed_integer (tmp, TYPE_LENGTH (builtin_type_void_data_ptr), val);
5525   return extract_signed_integer (tmp,
5526                                  TYPE_LENGTH (builtin_type_void_data_ptr));
5527 }
5528
5529 static void
5530 mips_find_abi_section (bfd *abfd, asection *sect, void *obj)
5531 {
5532   enum mips_abi *abip = (enum mips_abi *) obj;
5533   const char *name = bfd_get_section_name (abfd, sect);
5534
5535   if (*abip != MIPS_ABI_UNKNOWN)
5536     return;
5537
5538   if (strncmp (name, ".mdebug.", 8) != 0)
5539     return;
5540
5541   if (strcmp (name, ".mdebug.abi32") == 0)
5542     *abip = MIPS_ABI_O32;
5543   else if (strcmp (name, ".mdebug.abiN32") == 0)
5544     *abip = MIPS_ABI_N32;
5545   else if (strcmp (name, ".mdebug.abiN64") == 0)
5546     *abip = MIPS_ABI_N64;
5547   else if (strcmp (name, ".mdebug.abiO64") == 0)
5548     *abip = MIPS_ABI_O64;
5549   else if (strcmp (name, ".mdebug.eabi32") == 0)
5550     *abip = MIPS_ABI_EABI32;
5551   else if (strcmp (name, ".mdebug.eabi64") == 0)
5552     *abip = MIPS_ABI_EABI64;
5553   else
5554     warning ("unsupported ABI %s.", name + 8);
5555 }
5556
5557 static enum mips_abi
5558 global_mips_abi (void)
5559 {
5560   int i;
5561
5562   for (i = 0; mips_abi_strings[i] != NULL; i++)
5563     if (mips_abi_strings[i] == mips_abi_string)
5564       return (enum mips_abi) i;
5565
5566   internal_error (__FILE__, __LINE__,
5567                   "unknown ABI string");
5568 }
5569
5570 static struct gdbarch *
5571 mips_gdbarch_init (struct gdbarch_info info,
5572                    struct gdbarch_list *arches)
5573 {
5574   static LONGEST mips_call_dummy_words[] =
5575   {0};
5576   struct gdbarch *gdbarch;
5577   struct gdbarch_tdep *tdep;
5578   int elf_flags;
5579   enum mips_abi mips_abi, found_abi, wanted_abi;
5580   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
5581
5582   /* Reset the disassembly info, in case it was set to something
5583      non-default.  */
5584   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
5585   tm_print_insn_info.arch = bfd_arch_unknown;
5586   tm_print_insn_info.mach = 0;
5587
5588   elf_flags = 0;
5589
5590   if (info.abfd)
5591     {
5592       /* First of all, extract the elf_flags, if available.  */
5593       if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
5594         elf_flags = elf_elfheader (info.abfd)->e_flags;
5595
5596       /* Try to determine the OS ABI of the object we are loading.  If
5597          we end up with `unknown', just leave it that way.  */
5598       osabi = gdbarch_lookup_osabi (info.abfd);
5599     }
5600
5601   /* Check ELF_FLAGS to see if it specifies the ABI being used.  */
5602   switch ((elf_flags & EF_MIPS_ABI))
5603     {
5604     case E_MIPS_ABI_O32:
5605       mips_abi = MIPS_ABI_O32;
5606       break;
5607     case E_MIPS_ABI_O64:
5608       mips_abi = MIPS_ABI_O64;
5609       break;
5610     case E_MIPS_ABI_EABI32:
5611       mips_abi = MIPS_ABI_EABI32;
5612       break;
5613     case E_MIPS_ABI_EABI64:
5614       mips_abi = MIPS_ABI_EABI64;
5615       break;
5616     default:
5617       if ((elf_flags & EF_MIPS_ABI2))
5618         mips_abi = MIPS_ABI_N32;
5619       else
5620         mips_abi = MIPS_ABI_UNKNOWN;
5621       break;
5622     }
5623
5624   /* GCC creates a pseudo-section whose name describes the ABI.  */
5625   if (mips_abi == MIPS_ABI_UNKNOWN && info.abfd != NULL)
5626     bfd_map_over_sections (info.abfd, mips_find_abi_section, &mips_abi);
5627
5628   /* If we have no bfd, then mips_abi will still be MIPS_ABI_UNKNOWN.
5629      Use the ABI from the last architecture if there is one.  */
5630   if (info.abfd == NULL && arches != NULL)
5631     mips_abi = gdbarch_tdep (arches->gdbarch)->found_abi;
5632
5633   /* Try the architecture for any hint of the correct ABI.  */
5634   if (mips_abi == MIPS_ABI_UNKNOWN
5635       && info.bfd_arch_info != NULL
5636       && info.bfd_arch_info->arch == bfd_arch_mips)
5637     {
5638       switch (info.bfd_arch_info->mach)
5639         {
5640         case bfd_mach_mips3900:
5641           mips_abi = MIPS_ABI_EABI32;
5642           break;
5643         case bfd_mach_mips4100:
5644         case bfd_mach_mips5000:
5645           mips_abi = MIPS_ABI_EABI64;
5646           break;
5647         case bfd_mach_mips8000:
5648         case bfd_mach_mips10000:
5649           /* On Irix, ELF64 executables use the N64 ABI.  The
5650              pseudo-sections which describe the ABI aren't present
5651              on IRIX.  (Even for executables created by gcc.)  */
5652           if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
5653               && elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
5654             mips_abi = MIPS_ABI_N64;
5655           else
5656             mips_abi = MIPS_ABI_N32;
5657           break;
5658         }
5659     }
5660
5661   if (mips_abi == MIPS_ABI_UNKNOWN)
5662     mips_abi = MIPS_ABI_O32;
5663
5664   /* Now that we have found what the ABI for this binary would be,
5665      check whether the user is overriding it.  */
5666   found_abi = mips_abi;
5667   wanted_abi = global_mips_abi ();
5668   if (wanted_abi != MIPS_ABI_UNKNOWN)
5669     mips_abi = wanted_abi;
5670
5671   if (gdbarch_debug)
5672     {
5673       fprintf_unfiltered (gdb_stdlog,
5674                           "mips_gdbarch_init: elf_flags = 0x%08x\n",
5675                           elf_flags);
5676       fprintf_unfiltered (gdb_stdlog,
5677                           "mips_gdbarch_init: mips_abi = %d\n",
5678                           mips_abi);
5679       fprintf_unfiltered (gdb_stdlog,
5680                           "mips_gdbarch_init: found_mips_abi = %d\n",
5681                           found_abi);
5682     }
5683
5684   /* try to find a pre-existing architecture */
5685   for (arches = gdbarch_list_lookup_by_info (arches, &info);
5686        arches != NULL;
5687        arches = gdbarch_list_lookup_by_info (arches->next, &info))
5688     {
5689       /* MIPS needs to be pedantic about which ABI the object is
5690          using.  */
5691       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
5692         continue;
5693       if (gdbarch_tdep (arches->gdbarch)->mips_abi != mips_abi)
5694         continue;
5695       if (gdbarch_tdep (arches->gdbarch)->osabi == osabi)
5696         return arches->gdbarch;
5697     }
5698
5699   /* Need a new architecture.  Fill in a target specific vector.  */
5700   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
5701   gdbarch = gdbarch_alloc (&info, tdep);
5702   tdep->elf_flags = elf_flags;
5703   tdep->osabi = osabi;
5704
5705   /* Initially set everything according to the default ABI/ISA.  */
5706   set_gdbarch_short_bit (gdbarch, 16);
5707   set_gdbarch_int_bit (gdbarch, 32);
5708   set_gdbarch_float_bit (gdbarch, 32);
5709   set_gdbarch_double_bit (gdbarch, 64);
5710   set_gdbarch_long_double_bit (gdbarch, 64);
5711   set_gdbarch_register_raw_size (gdbarch, mips_register_raw_size);
5712   set_gdbarch_max_register_raw_size (gdbarch, 8);
5713   set_gdbarch_max_register_virtual_size (gdbarch, 8);
5714   tdep->found_abi = found_abi;
5715   tdep->mips_abi = mips_abi;
5716
5717   set_gdbarch_elf_make_msymbol_special (gdbarch,
5718                                         mips_elf_make_msymbol_special);
5719
5720   switch (mips_abi)
5721     {
5722     case MIPS_ABI_O32:
5723       set_gdbarch_push_arguments (gdbarch, mips_o32_push_arguments);
5724       set_gdbarch_store_return_value (gdbarch, mips_o32_store_return_value);
5725       set_gdbarch_extract_return_value (gdbarch, mips_o32_extract_return_value);
5726       tdep->mips_default_saved_regsize = 4;
5727       tdep->mips_default_stack_argsize = 4;
5728       tdep->mips_fp_register_double = 0;
5729       tdep->mips_last_arg_regnum = A0_REGNUM + 4 - 1;
5730       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 4 - 1;
5731       tdep->gdb_target_is_mips64 = 0;
5732       tdep->default_mask_address_p = 0;
5733       set_gdbarch_long_bit (gdbarch, 32);
5734       set_gdbarch_ptr_bit (gdbarch, 32);
5735       set_gdbarch_long_long_bit (gdbarch, 64);
5736       set_gdbarch_reg_struct_has_addr (gdbarch,
5737                                        mips_o32_reg_struct_has_addr);
5738       set_gdbarch_use_struct_convention (gdbarch,
5739                                          mips_o32_use_struct_convention);
5740       break;
5741     case MIPS_ABI_O64:
5742       set_gdbarch_push_arguments (gdbarch, mips_o64_push_arguments);
5743       set_gdbarch_store_return_value (gdbarch, mips_o64_store_return_value);
5744       set_gdbarch_deprecated_extract_return_value (gdbarch, mips_o64_extract_return_value);
5745       tdep->mips_default_saved_regsize = 8;
5746       tdep->mips_default_stack_argsize = 8;
5747       tdep->mips_fp_register_double = 1;
5748       tdep->mips_last_arg_regnum = A0_REGNUM + 4 - 1;
5749       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 4 - 1;
5750       tdep->gdb_target_is_mips64 = 1;
5751       tdep->default_mask_address_p = 0;
5752       set_gdbarch_long_bit (gdbarch, 32);
5753       set_gdbarch_ptr_bit (gdbarch, 32);
5754       set_gdbarch_long_long_bit (gdbarch, 64);
5755       set_gdbarch_reg_struct_has_addr (gdbarch,
5756                                        mips_o32_reg_struct_has_addr);
5757       set_gdbarch_use_struct_convention (gdbarch,
5758                                          mips_o32_use_struct_convention);
5759       break;
5760     case MIPS_ABI_EABI32:
5761       set_gdbarch_push_arguments (gdbarch, mips_eabi_push_arguments);
5762       set_gdbarch_store_return_value (gdbarch, mips_eabi_store_return_value);
5763       set_gdbarch_deprecated_extract_return_value (gdbarch, mips_eabi_extract_return_value);
5764       tdep->mips_default_saved_regsize = 4;
5765       tdep->mips_default_stack_argsize = 4;
5766       tdep->mips_fp_register_double = 0;
5767       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5768       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5769       tdep->gdb_target_is_mips64 = 0;
5770       tdep->default_mask_address_p = 0;
5771       set_gdbarch_long_bit (gdbarch, 32);
5772       set_gdbarch_ptr_bit (gdbarch, 32);
5773       set_gdbarch_long_long_bit (gdbarch, 64);
5774       set_gdbarch_reg_struct_has_addr (gdbarch,
5775                                        mips_eabi_reg_struct_has_addr);
5776       set_gdbarch_use_struct_convention (gdbarch,
5777                                          mips_eabi_use_struct_convention);
5778       break;
5779     case MIPS_ABI_EABI64:
5780       set_gdbarch_push_arguments (gdbarch, mips_eabi_push_arguments);
5781       set_gdbarch_store_return_value (gdbarch, mips_eabi_store_return_value);
5782       set_gdbarch_deprecated_extract_return_value (gdbarch, mips_eabi_extract_return_value);
5783       tdep->mips_default_saved_regsize = 8;
5784       tdep->mips_default_stack_argsize = 8;
5785       tdep->mips_fp_register_double = 1;
5786       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5787       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5788       tdep->gdb_target_is_mips64 = 1;
5789       tdep->default_mask_address_p = 0;
5790       set_gdbarch_long_bit (gdbarch, 64);
5791       set_gdbarch_ptr_bit (gdbarch, 64);
5792       set_gdbarch_long_long_bit (gdbarch, 64);
5793       set_gdbarch_reg_struct_has_addr (gdbarch,
5794                                        mips_eabi_reg_struct_has_addr);
5795       set_gdbarch_use_struct_convention (gdbarch,
5796                                          mips_eabi_use_struct_convention);
5797       break;
5798     case MIPS_ABI_N32:
5799       set_gdbarch_push_arguments (gdbarch, mips_n32n64_push_arguments);
5800       set_gdbarch_store_return_value (gdbarch, mips_n32n64_store_return_value);
5801       set_gdbarch_extract_return_value (gdbarch, mips_n32n64_extract_return_value);
5802       tdep->mips_default_saved_regsize = 8;
5803       tdep->mips_default_stack_argsize = 8;
5804       tdep->mips_fp_register_double = 1;
5805       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5806       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5807       tdep->gdb_target_is_mips64 = 1;
5808       tdep->default_mask_address_p = 0;
5809       set_gdbarch_long_bit (gdbarch, 32);
5810       set_gdbarch_ptr_bit (gdbarch, 32);
5811       set_gdbarch_long_long_bit (gdbarch, 64);
5812
5813       /* Set up the disassembler info, so that we get the right
5814          register names from libopcodes.  */
5815       tm_print_insn_info.flavour = bfd_target_elf_flavour;
5816       tm_print_insn_info.arch = bfd_arch_mips;
5817       if (info.bfd_arch_info != NULL
5818           && info.bfd_arch_info->arch == bfd_arch_mips
5819           && info.bfd_arch_info->mach)
5820         tm_print_insn_info.mach = info.bfd_arch_info->mach;
5821       else
5822         tm_print_insn_info.mach = bfd_mach_mips8000;
5823
5824       set_gdbarch_use_struct_convention (gdbarch,
5825                                          mips_n32n64_use_struct_convention);
5826       set_gdbarch_reg_struct_has_addr (gdbarch,
5827                                        mips_n32n64_reg_struct_has_addr);
5828       break;
5829     case MIPS_ABI_N64:
5830       set_gdbarch_push_arguments (gdbarch, mips_n32n64_push_arguments);
5831       set_gdbarch_store_return_value (gdbarch, mips_n32n64_store_return_value);
5832       set_gdbarch_extract_return_value (gdbarch, mips_n32n64_extract_return_value);
5833       tdep->mips_default_saved_regsize = 8;
5834       tdep->mips_default_stack_argsize = 8;
5835       tdep->mips_fp_register_double = 1;
5836       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5837       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5838       tdep->gdb_target_is_mips64 = 1;
5839       tdep->default_mask_address_p = 0;
5840       set_gdbarch_long_bit (gdbarch, 64);
5841       set_gdbarch_ptr_bit (gdbarch, 64);
5842       set_gdbarch_long_long_bit (gdbarch, 64);
5843
5844       /* Set up the disassembler info, so that we get the right
5845          register names from libopcodes.  */
5846       tm_print_insn_info.flavour = bfd_target_elf_flavour;
5847       tm_print_insn_info.arch = bfd_arch_mips;
5848       if (info.bfd_arch_info != NULL
5849           && info.bfd_arch_info->arch == bfd_arch_mips
5850           && info.bfd_arch_info->mach)
5851         tm_print_insn_info.mach = info.bfd_arch_info->mach;
5852       else
5853         tm_print_insn_info.mach = bfd_mach_mips8000;
5854
5855       set_gdbarch_use_struct_convention (gdbarch,
5856                                          mips_n32n64_use_struct_convention);
5857       set_gdbarch_reg_struct_has_addr (gdbarch,
5858                                        mips_n32n64_reg_struct_has_addr);
5859       break;
5860     default:
5861       internal_error (__FILE__, __LINE__,
5862                       "unknown ABI in switch");
5863     }
5864
5865   /* FIXME: jlarmour/2000-04-07: There *is* a flag EF_MIPS_32BIT_MODE
5866      that could indicate -gp32 BUT gas/config/tc-mips.c contains the
5867      comment:
5868
5869      ``We deliberately don't allow "-gp32" to set the MIPS_32BITMODE
5870      flag in object files because to do so would make it impossible to
5871      link with libraries compiled without "-gp32".  This is
5872      unnecessarily restrictive.
5873
5874      We could solve this problem by adding "-gp32" multilibs to gcc,
5875      but to set this flag before gcc is built with such multilibs will
5876      break too many systems.''
5877
5878      But even more unhelpfully, the default linker output target for
5879      mips64-elf is elf32-bigmips, and has EF_MIPS_32BIT_MODE set, even
5880      for 64-bit programs - you need to change the ABI to change this,
5881      and not all gcc targets support that currently.  Therefore using
5882      this flag to detect 32-bit mode would do the wrong thing given
5883      the current gcc - it would make GDB treat these 64-bit programs
5884      as 32-bit programs by default.  */
5885
5886   /* enable/disable the MIPS FPU */
5887   if (!mips_fpu_type_auto)
5888     tdep->mips_fpu_type = mips_fpu_type;
5889   else if (info.bfd_arch_info != NULL
5890            && info.bfd_arch_info->arch == bfd_arch_mips)
5891     switch (info.bfd_arch_info->mach)
5892       {
5893       case bfd_mach_mips3900:
5894       case bfd_mach_mips4100:
5895       case bfd_mach_mips4111:
5896         tdep->mips_fpu_type = MIPS_FPU_NONE;
5897         break;
5898       case bfd_mach_mips4650:
5899         tdep->mips_fpu_type = MIPS_FPU_SINGLE;
5900         break;
5901       default:
5902         tdep->mips_fpu_type = MIPS_FPU_DOUBLE;
5903         break;
5904       }
5905   else
5906     tdep->mips_fpu_type = MIPS_FPU_DOUBLE;
5907
5908   /* MIPS version of register names.  NOTE: At present the MIPS
5909      register name management is part way between the old -
5910      #undef/#define REGISTER_NAMES and the new REGISTER_NAME(nr).
5911      Further work on it is required.  */
5912   set_gdbarch_register_name (gdbarch, mips_register_name);
5913   set_gdbarch_read_pc (gdbarch, mips_read_pc);
5914   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
5915   set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
5916   set_gdbarch_read_sp (gdbarch, mips_read_sp);
5917   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
5918
5919   /* Add/remove bits from an address.  The MIPS needs be careful to
5920      ensure that all 32 bit addresses are sign extended to 64 bits.  */
5921   set_gdbarch_addr_bits_remove (gdbarch, mips_addr_bits_remove);
5922
5923   /* There's a mess in stack frame creation.  See comments in
5924      blockframe.c near reference to INIT_FRAME_PC_FIRST.  */
5925   set_gdbarch_init_frame_pc_first (gdbarch, mips_init_frame_pc_first);
5926   set_gdbarch_init_frame_pc (gdbarch, init_frame_pc_noop);
5927
5928   /* Map debug register numbers onto internal register numbers.  */
5929   set_gdbarch_stab_reg_to_regnum (gdbarch, mips_stab_reg_to_regnum);
5930   set_gdbarch_ecoff_reg_to_regnum (gdbarch, mips_ecoff_reg_to_regnum);
5931
5932   /* Initialize a frame */
5933   set_gdbarch_init_extra_frame_info (gdbarch, mips_init_extra_frame_info);
5934   set_gdbarch_frame_init_saved_regs (gdbarch, mips_frame_init_saved_regs);
5935
5936   /* MIPS version of CALL_DUMMY */
5937
5938   set_gdbarch_call_dummy_p (gdbarch, 1);
5939   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
5940   set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
5941   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
5942   set_gdbarch_call_dummy_address (gdbarch, mips_call_dummy_address);
5943   set_gdbarch_push_return_address (gdbarch, mips_push_return_address);
5944   set_gdbarch_push_dummy_frame (gdbarch, mips_push_dummy_frame);
5945   set_gdbarch_pop_frame (gdbarch, mips_pop_frame);
5946   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
5947   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
5948   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
5949   set_gdbarch_call_dummy_length (gdbarch, 0);
5950   set_gdbarch_fix_call_dummy (gdbarch, mips_fix_call_dummy);
5951   set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
5952   set_gdbarch_call_dummy_words (gdbarch, mips_call_dummy_words);
5953   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (mips_call_dummy_words));
5954   set_gdbarch_push_return_address (gdbarch, mips_push_return_address);
5955   set_gdbarch_register_convertible (gdbarch, mips_register_convertible);
5956   set_gdbarch_register_convert_to_virtual (gdbarch,
5957                                            mips_register_convert_to_virtual);
5958   set_gdbarch_register_convert_to_raw (gdbarch,
5959                                        mips_register_convert_to_raw);
5960
5961   set_gdbarch_coerce_float_to_double (gdbarch, mips_coerce_float_to_double);
5962
5963   set_gdbarch_frame_chain (gdbarch, mips_frame_chain);
5964   set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
5965   set_gdbarch_frameless_function_invocation (gdbarch,
5966                                              generic_frameless_function_invocation_not);
5967   set_gdbarch_frame_saved_pc (gdbarch, mips_frame_saved_pc);
5968   set_gdbarch_frame_args_address (gdbarch, default_frame_address);
5969   set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
5970   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
5971   set_gdbarch_frame_args_skip (gdbarch, 0);
5972
5973   set_gdbarch_get_saved_register (gdbarch, mips_get_saved_register);
5974
5975   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
5976   set_gdbarch_breakpoint_from_pc (gdbarch, mips_breakpoint_from_pc);
5977   set_gdbarch_decr_pc_after_break (gdbarch, 0);
5978
5979   set_gdbarch_skip_prologue (gdbarch, mips_skip_prologue);
5980   set_gdbarch_saved_pc_after_call (gdbarch, mips_saved_pc_after_call);
5981
5982   set_gdbarch_pointer_to_address (gdbarch, signed_pointer_to_address);
5983   set_gdbarch_address_to_pointer (gdbarch, address_to_signed_pointer);
5984   set_gdbarch_integer_to_address (gdbarch, mips_integer_to_address);
5985
5986   set_gdbarch_function_start_offset (gdbarch, 0);
5987
5988   /* There are MIPS targets which do not yet use this since they still
5989      define REGISTER_VIRTUAL_TYPE.  */
5990   set_gdbarch_register_virtual_type (gdbarch, mips_register_virtual_type);
5991   set_gdbarch_register_virtual_size (gdbarch, generic_register_size);
5992
5993   set_gdbarch_do_registers_info (gdbarch, mips_do_registers_info);
5994   set_gdbarch_pc_in_sigtramp (gdbarch, mips_pc_in_sigtramp);
5995
5996   /* Hook in OS ABI-specific overrides, if they have been registered.  */
5997   gdbarch_init_osabi (info, gdbarch, osabi);
5998
5999   set_gdbarch_store_struct_return (gdbarch, mips_store_struct_return);
6000   set_gdbarch_extract_struct_value_address (gdbarch,
6001                                             mips_extract_struct_value_address);
6002
6003   set_gdbarch_skip_trampoline_code (gdbarch, mips_skip_stub);
6004
6005   set_gdbarch_in_solib_call_trampoline (gdbarch, mips_in_call_stub);
6006   set_gdbarch_in_solib_return_trampoline (gdbarch, mips_in_return_stub);
6007
6008   return gdbarch;
6009 }
6010
6011 static void
6012 mips_abi_update (char *ignore_args, int from_tty,
6013                  struct cmd_list_element *c)
6014 {
6015   struct gdbarch_info info;
6016
6017   /* Force the architecture to update, and (if it's a MIPS architecture)
6018      mips_gdbarch_init will take care of the rest.  */
6019   gdbarch_info_init (&info);
6020   gdbarch_update_p (info);
6021 }
6022
6023 static void
6024 mips_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
6025 {
6026   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
6027   if (tdep != NULL)
6028     {
6029       int ef_mips_arch;
6030       int ef_mips_32bitmode;
6031       /* determine the ISA */
6032       switch (tdep->elf_flags & EF_MIPS_ARCH)
6033         {
6034         case E_MIPS_ARCH_1:
6035           ef_mips_arch = 1;
6036           break;
6037         case E_MIPS_ARCH_2:
6038           ef_mips_arch = 2;
6039           break;
6040         case E_MIPS_ARCH_3:
6041           ef_mips_arch = 3;
6042           break;
6043         case E_MIPS_ARCH_4:
6044           ef_mips_arch = 4;
6045           break;
6046         default:
6047           ef_mips_arch = 0;
6048           break;
6049         }
6050       /* determine the size of a pointer */
6051       ef_mips_32bitmode = (tdep->elf_flags & EF_MIPS_32BITMODE);
6052       fprintf_unfiltered (file,
6053                           "mips_dump_tdep: tdep->elf_flags = 0x%x\n",
6054                           tdep->elf_flags);
6055       fprintf_unfiltered (file,
6056                           "mips_dump_tdep: ef_mips_32bitmode = %d\n",
6057                           ef_mips_32bitmode);
6058       fprintf_unfiltered (file,
6059                           "mips_dump_tdep: ef_mips_arch = %d\n",
6060                           ef_mips_arch);
6061       fprintf_unfiltered (file,
6062                           "mips_dump_tdep: tdep->mips_abi = %d (%s)\n",
6063                           tdep->mips_abi,
6064                           mips_abi_strings[tdep->mips_abi]);
6065       fprintf_unfiltered (file,
6066                           "mips_dump_tdep: mips_mask_address_p() %d (default %d)\n",
6067                           mips_mask_address_p (),
6068                           tdep->default_mask_address_p);
6069     }
6070   fprintf_unfiltered (file,
6071                       "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
6072                       FP_REGISTER_DOUBLE);
6073   fprintf_unfiltered (file,
6074                       "mips_dump_tdep: MIPS_DEFAULT_FPU_TYPE = %d (%s)\n",
6075                       MIPS_DEFAULT_FPU_TYPE,
6076                       (MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_NONE ? "none"
6077                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
6078                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
6079                        : "???"));
6080   fprintf_unfiltered (file,
6081                       "mips_dump_tdep: MIPS_EABI = %d\n",
6082                       MIPS_EABI);
6083   fprintf_unfiltered (file,
6084                       "mips_dump_tdep: MIPS_LAST_FP_ARG_REGNUM = %d (%d regs)\n",
6085                       MIPS_LAST_FP_ARG_REGNUM,
6086                       MIPS_LAST_FP_ARG_REGNUM - FPA0_REGNUM + 1);
6087   fprintf_unfiltered (file,
6088                       "mips_dump_tdep: MIPS_FPU_TYPE = %d (%s)\n",
6089                       MIPS_FPU_TYPE,
6090                       (MIPS_FPU_TYPE == MIPS_FPU_NONE ? "none"
6091                        : MIPS_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
6092                        : MIPS_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
6093                        : "???"));
6094   fprintf_unfiltered (file,
6095                       "mips_dump_tdep: MIPS_DEFAULT_SAVED_REGSIZE = %d\n",
6096                       MIPS_DEFAULT_SAVED_REGSIZE);
6097   fprintf_unfiltered (file,
6098                       "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
6099                       FP_REGISTER_DOUBLE);
6100   fprintf_unfiltered (file,
6101                       "mips_dump_tdep: MIPS_DEFAULT_STACK_ARGSIZE = %d\n",
6102                       MIPS_DEFAULT_STACK_ARGSIZE);
6103   fprintf_unfiltered (file,
6104                       "mips_dump_tdep: MIPS_STACK_ARGSIZE = %d\n",
6105                       MIPS_STACK_ARGSIZE);
6106   fprintf_unfiltered (file,
6107                       "mips_dump_tdep: MIPS_REGSIZE = %d\n",
6108                       MIPS_REGSIZE);
6109   fprintf_unfiltered (file,
6110                       "mips_dump_tdep: A0_REGNUM = %d\n",
6111                       A0_REGNUM);
6112   fprintf_unfiltered (file,
6113                       "mips_dump_tdep: ADDR_BITS_REMOVE # %s\n",
6114                       XSTRING (ADDR_BITS_REMOVE(ADDR)));
6115   fprintf_unfiltered (file,
6116                       "mips_dump_tdep: ATTACH_DETACH # %s\n",
6117                       XSTRING (ATTACH_DETACH));
6118   fprintf_unfiltered (file,
6119                       "mips_dump_tdep: BADVADDR_REGNUM = %d\n",
6120                       BADVADDR_REGNUM);
6121   fprintf_unfiltered (file,
6122                       "mips_dump_tdep: BIG_BREAKPOINT = delete?\n");
6123   fprintf_unfiltered (file,
6124                       "mips_dump_tdep: CAUSE_REGNUM = %d\n",
6125                       CAUSE_REGNUM);
6126   fprintf_unfiltered (file,
6127                       "mips_dump_tdep: CPLUS_MARKER = %c\n",
6128                       CPLUS_MARKER);
6129   fprintf_unfiltered (file,
6130                       "mips_dump_tdep: DEFAULT_MIPS_TYPE = %s\n",
6131                       DEFAULT_MIPS_TYPE);
6132   fprintf_unfiltered (file,
6133                       "mips_dump_tdep: DO_REGISTERS_INFO # %s\n",
6134                       XSTRING (DO_REGISTERS_INFO));
6135   fprintf_unfiltered (file,
6136                       "mips_dump_tdep: DWARF_REG_TO_REGNUM # %s\n",
6137                       XSTRING (DWARF_REG_TO_REGNUM (REGNUM)));
6138   fprintf_unfiltered (file,
6139                       "mips_dump_tdep: ECOFF_REG_TO_REGNUM # %s\n",
6140                       XSTRING (ECOFF_REG_TO_REGNUM (REGNUM)));
6141   fprintf_unfiltered (file,
6142                       "mips_dump_tdep: ELF_MAKE_MSYMBOL_SPECIAL # %s\n",
6143                       XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (SYM, MSYM)));
6144   fprintf_unfiltered (file,
6145                       "mips_dump_tdep: FCRCS_REGNUM = %d\n",
6146                       FCRCS_REGNUM);
6147   fprintf_unfiltered (file,
6148                       "mips_dump_tdep: FCRIR_REGNUM = %d\n",
6149                       FCRIR_REGNUM);
6150   fprintf_unfiltered (file,
6151                       "mips_dump_tdep: FIRST_EMBED_REGNUM = %d\n",
6152                       FIRST_EMBED_REGNUM);
6153   fprintf_unfiltered (file,
6154                       "mips_dump_tdep: FPA0_REGNUM = %d\n",
6155                       FPA0_REGNUM);
6156   fprintf_unfiltered (file,
6157                       "mips_dump_tdep: GDB_TARGET_IS_MIPS64 = %d\n",
6158                       GDB_TARGET_IS_MIPS64);
6159   fprintf_unfiltered (file,
6160                       "mips_dump_tdep: GDB_TARGET_MASK_DISAS_PC # %s\n",
6161                       XSTRING (GDB_TARGET_MASK_DISAS_PC (PC)));
6162   fprintf_unfiltered (file,
6163                       "mips_dump_tdep: GDB_TARGET_UNMASK_DISAS_PC # %s\n",
6164                       XSTRING (GDB_TARGET_UNMASK_DISAS_PC (PC)));
6165   fprintf_unfiltered (file,
6166                       "mips_dump_tdep: GEN_REG_SAVE_MASK = %d\n",
6167                       GEN_REG_SAVE_MASK);
6168   fprintf_unfiltered (file,
6169                       "mips_dump_tdep: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
6170                       XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
6171   fprintf_unfiltered (file,
6172                       "mips_dump_tdep:  HI_REGNUM = %d\n",
6173                       HI_REGNUM);
6174   fprintf_unfiltered (file,
6175                       "mips_dump_tdep: IDT_BIG_BREAKPOINT = delete?\n");
6176   fprintf_unfiltered (file,
6177                       "mips_dump_tdep: IDT_LITTLE_BREAKPOINT = delete?\n");
6178   fprintf_unfiltered (file,
6179                       "mips_dump_tdep: IGNORE_HELPER_CALL # %s\n",
6180                       XSTRING (IGNORE_HELPER_CALL (PC)));
6181   fprintf_unfiltered (file,
6182                       "mips_dump_tdep: IN_SOLIB_CALL_TRAMPOLINE # %s\n",
6183                       XSTRING (IN_SOLIB_CALL_TRAMPOLINE (PC, NAME)));
6184   fprintf_unfiltered (file,
6185                       "mips_dump_tdep: IN_SOLIB_RETURN_TRAMPOLINE # %s\n",
6186                       XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (PC, NAME)));
6187   fprintf_unfiltered (file,
6188                       "mips_dump_tdep: IS_MIPS16_ADDR = FIXME!\n");
6189   fprintf_unfiltered (file,
6190                       "mips_dump_tdep: LAST_EMBED_REGNUM = %d\n",
6191                       LAST_EMBED_REGNUM);
6192   fprintf_unfiltered (file,
6193                       "mips_dump_tdep: LITTLE_BREAKPOINT = delete?\n");
6194   fprintf_unfiltered (file,
6195                       "mips_dump_tdep: LO_REGNUM = %d\n",
6196                       LO_REGNUM);
6197 #ifdef MACHINE_CPROC_FP_OFFSET
6198   fprintf_unfiltered (file,
6199                       "mips_dump_tdep: MACHINE_CPROC_FP_OFFSET = %d\n",
6200                       MACHINE_CPROC_FP_OFFSET);
6201 #endif
6202 #ifdef MACHINE_CPROC_PC_OFFSET
6203   fprintf_unfiltered (file,
6204                       "mips_dump_tdep: MACHINE_CPROC_PC_OFFSET = %d\n",
6205                       MACHINE_CPROC_PC_OFFSET);
6206 #endif
6207 #ifdef MACHINE_CPROC_SP_OFFSET
6208   fprintf_unfiltered (file,
6209                       "mips_dump_tdep: MACHINE_CPROC_SP_OFFSET = %d\n",
6210                       MACHINE_CPROC_SP_OFFSET);
6211 #endif
6212   fprintf_unfiltered (file,
6213                       "mips_dump_tdep: MAKE_MIPS16_ADDR = FIXME!\n");
6214   fprintf_unfiltered (file,
6215                       "mips_dump_tdep: MIPS16_BIG_BREAKPOINT = delete?\n");
6216   fprintf_unfiltered (file,
6217                       "mips_dump_tdep: MIPS16_INSTLEN = %d\n",
6218                       MIPS16_INSTLEN);
6219   fprintf_unfiltered (file,
6220                       "mips_dump_tdep: MIPS16_LITTLE_BREAKPOINT = delete?\n");
6221   fprintf_unfiltered (file,
6222                       "mips_dump_tdep: MIPS_DEFAULT_ABI = FIXME!\n");
6223   fprintf_unfiltered (file,
6224                       "mips_dump_tdep: MIPS_EFI_SYMBOL_NAME = multi-arch!!\n");
6225   fprintf_unfiltered (file,
6226                       "mips_dump_tdep: MIPS_INSTLEN = %d\n",
6227                       MIPS_INSTLEN);
6228   fprintf_unfiltered (file,
6229                       "mips_dump_tdep: MIPS_LAST_ARG_REGNUM = %d (%d regs)\n",
6230                       MIPS_LAST_ARG_REGNUM,
6231                       MIPS_LAST_ARG_REGNUM - A0_REGNUM + 1);
6232   fprintf_unfiltered (file,
6233                       "mips_dump_tdep: MIPS_NUMREGS = %d\n",
6234                       MIPS_NUMREGS);
6235   fprintf_unfiltered (file,
6236                       "mips_dump_tdep: MIPS_REGISTER_NAMES = delete?\n");
6237   fprintf_unfiltered (file,
6238                       "mips_dump_tdep: MIPS_SAVED_REGSIZE = %d\n",
6239                       MIPS_SAVED_REGSIZE);
6240   fprintf_unfiltered (file,
6241                       "mips_dump_tdep: MSYMBOL_IS_SPECIAL = function?\n");
6242   fprintf_unfiltered (file,
6243                       "mips_dump_tdep: MSYMBOL_SIZE # %s\n",
6244                       XSTRING (MSYMBOL_SIZE (MSYM)));
6245   fprintf_unfiltered (file,
6246                       "mips_dump_tdep: OP_LDFPR = used?\n");
6247   fprintf_unfiltered (file,
6248                       "mips_dump_tdep: OP_LDGPR = used?\n");
6249   fprintf_unfiltered (file,
6250                       "mips_dump_tdep: PMON_BIG_BREAKPOINT = delete?\n");
6251   fprintf_unfiltered (file,
6252                       "mips_dump_tdep: PMON_LITTLE_BREAKPOINT = delete?\n");
6253   fprintf_unfiltered (file,
6254                       "mips_dump_tdep: PRID_REGNUM = %d\n",
6255                       PRID_REGNUM);
6256   fprintf_unfiltered (file,
6257                       "mips_dump_tdep: PRINT_EXTRA_FRAME_INFO # %s\n",
6258                       XSTRING (PRINT_EXTRA_FRAME_INFO (FRAME)));
6259   fprintf_unfiltered (file,
6260                       "mips_dump_tdep: PROC_DESC_IS_DUMMY = function?\n");
6261   fprintf_unfiltered (file,
6262                       "mips_dump_tdep: PROC_FRAME_ADJUST = function?\n");
6263   fprintf_unfiltered (file,
6264                       "mips_dump_tdep: PROC_FRAME_OFFSET = function?\n");
6265   fprintf_unfiltered (file,
6266                       "mips_dump_tdep: PROC_FRAME_REG = function?\n");
6267   fprintf_unfiltered (file,
6268                       "mips_dump_tdep: PROC_FREG_MASK = function?\n");
6269   fprintf_unfiltered (file,
6270                       "mips_dump_tdep: PROC_FREG_OFFSET = function?\n");
6271   fprintf_unfiltered (file,
6272                       "mips_dump_tdep: PROC_HIGH_ADDR = function?\n");
6273   fprintf_unfiltered (file,
6274                       "mips_dump_tdep: PROC_LOW_ADDR = function?\n");
6275   fprintf_unfiltered (file,
6276                       "mips_dump_tdep: PROC_PC_REG = function?\n");
6277   fprintf_unfiltered (file,
6278                       "mips_dump_tdep: PROC_REG_MASK = function?\n");
6279   fprintf_unfiltered (file,
6280                       "mips_dump_tdep: PROC_REG_OFFSET = function?\n");
6281   fprintf_unfiltered (file,
6282                       "mips_dump_tdep: PROC_SYMBOL = function?\n");
6283   fprintf_unfiltered (file,
6284                       "mips_dump_tdep: PS_REGNUM = %d\n",
6285                       PS_REGNUM);
6286   fprintf_unfiltered (file,
6287                       "mips_dump_tdep: PUSH_FP_REGNUM = %d\n",
6288                       PUSH_FP_REGNUM);
6289   fprintf_unfiltered (file,
6290                       "mips_dump_tdep: RA_REGNUM = %d\n",
6291                       RA_REGNUM);
6292   fprintf_unfiltered (file,
6293                       "mips_dump_tdep: REGISTER_CONVERT_FROM_TYPE # %s\n",
6294                       XSTRING (REGISTER_CONVERT_FROM_TYPE (REGNUM, VALTYPE, RAW_BUFFER)));
6295   fprintf_unfiltered (file,
6296                       "mips_dump_tdep: REGISTER_CONVERT_TO_TYPE # %s\n",
6297                       XSTRING (REGISTER_CONVERT_TO_TYPE (REGNUM, VALTYPE, RAW_BUFFER)));
6298   fprintf_unfiltered (file,
6299                       "mips_dump_tdep: REGISTER_NAMES = delete?\n");
6300   fprintf_unfiltered (file,
6301                       "mips_dump_tdep: ROUND_DOWN = function?\n");
6302   fprintf_unfiltered (file,
6303                       "mips_dump_tdep: ROUND_UP = function?\n");
6304 #ifdef SAVED_BYTES
6305   fprintf_unfiltered (file,
6306                       "mips_dump_tdep: SAVED_BYTES = %d\n",
6307                       SAVED_BYTES);
6308 #endif
6309 #ifdef SAVED_FP
6310   fprintf_unfiltered (file,
6311                       "mips_dump_tdep: SAVED_FP = %d\n",
6312                       SAVED_FP);
6313 #endif
6314 #ifdef SAVED_PC
6315   fprintf_unfiltered (file,
6316                       "mips_dump_tdep: SAVED_PC = %d\n",
6317                       SAVED_PC);
6318 #endif
6319   fprintf_unfiltered (file,
6320                       "mips_dump_tdep: SETUP_ARBITRARY_FRAME # %s\n",
6321                       XSTRING (SETUP_ARBITRARY_FRAME (NUMARGS, ARGS)));
6322   fprintf_unfiltered (file,
6323                       "mips_dump_tdep: SET_PROC_DESC_IS_DUMMY = function?\n");
6324   fprintf_unfiltered (file,
6325                       "mips_dump_tdep: SIGFRAME_BASE = %d\n",
6326                       SIGFRAME_BASE);
6327   fprintf_unfiltered (file,
6328                       "mips_dump_tdep: SIGFRAME_FPREGSAVE_OFF = %d\n",
6329                       SIGFRAME_FPREGSAVE_OFF);
6330   fprintf_unfiltered (file,
6331                       "mips_dump_tdep: SIGFRAME_PC_OFF = %d\n",
6332                       SIGFRAME_PC_OFF);
6333   fprintf_unfiltered (file,
6334                       "mips_dump_tdep: SIGFRAME_REGSAVE_OFF = %d\n",
6335                       SIGFRAME_REGSAVE_OFF);
6336   fprintf_unfiltered (file,
6337                       "mips_dump_tdep: SIGFRAME_REG_SIZE = %d\n",
6338                       SIGFRAME_REG_SIZE);
6339   fprintf_unfiltered (file,
6340                       "mips_dump_tdep: SKIP_TRAMPOLINE_CODE # %s\n",
6341                       XSTRING (SKIP_TRAMPOLINE_CODE (PC)));
6342   fprintf_unfiltered (file,
6343                       "mips_dump_tdep: SOFTWARE_SINGLE_STEP # %s\n",
6344                       XSTRING (SOFTWARE_SINGLE_STEP (SIG, BP_P)));
6345   fprintf_unfiltered (file,
6346                       "mips_dump_tdep: SOFTWARE_SINGLE_STEP_P () = %d\n",
6347                       SOFTWARE_SINGLE_STEP_P ());
6348   fprintf_unfiltered (file,
6349                       "mips_dump_tdep: STAB_REG_TO_REGNUM # %s\n",
6350                       XSTRING (STAB_REG_TO_REGNUM (REGNUM)));
6351 #ifdef STACK_END_ADDR
6352   fprintf_unfiltered (file,
6353                       "mips_dump_tdep: STACK_END_ADDR = %d\n",
6354                       STACK_END_ADDR);
6355 #endif
6356   fprintf_unfiltered (file,
6357                       "mips_dump_tdep: STEP_SKIPS_DELAY # %s\n",
6358                       XSTRING (STEP_SKIPS_DELAY (PC)));
6359   fprintf_unfiltered (file,
6360                       "mips_dump_tdep: STEP_SKIPS_DELAY_P = %d\n",
6361                       STEP_SKIPS_DELAY_P);
6362   fprintf_unfiltered (file,
6363                       "mips_dump_tdep: STOPPED_BY_WATCHPOINT # %s\n",
6364                       XSTRING (STOPPED_BY_WATCHPOINT (WS)));
6365   fprintf_unfiltered (file,
6366                       "mips_dump_tdep: T9_REGNUM = %d\n",
6367                       T9_REGNUM);
6368   fprintf_unfiltered (file,
6369                       "mips_dump_tdep: TABULAR_REGISTER_OUTPUT = used?\n");
6370   fprintf_unfiltered (file,
6371                       "mips_dump_tdep: TARGET_CAN_USE_HARDWARE_WATCHPOINT # %s\n",
6372                       XSTRING (TARGET_CAN_USE_HARDWARE_WATCHPOINT (TYPE,CNT,OTHERTYPE)));
6373   fprintf_unfiltered (file,
6374                       "mips_dump_tdep: TARGET_HAS_HARDWARE_WATCHPOINTS # %s\n",
6375                       XSTRING (TARGET_HAS_HARDWARE_WATCHPOINTS));
6376   fprintf_unfiltered (file,
6377                       "mips_dump_tdep: TARGET_MIPS = used?\n");
6378   fprintf_unfiltered (file,
6379                       "mips_dump_tdep: TM_PRINT_INSN_MACH # %s\n",
6380                       XSTRING (TM_PRINT_INSN_MACH));
6381 #ifdef TRACE_CLEAR
6382   fprintf_unfiltered (file,
6383                       "mips_dump_tdep: TRACE_CLEAR # %s\n",
6384                       XSTRING (TRACE_CLEAR (THREAD, STATE)));
6385 #endif
6386 #ifdef TRACE_FLAVOR
6387   fprintf_unfiltered (file,
6388                       "mips_dump_tdep: TRACE_FLAVOR = %d\n",
6389                       TRACE_FLAVOR);
6390 #endif
6391 #ifdef TRACE_FLAVOR_SIZE
6392   fprintf_unfiltered (file,
6393                       "mips_dump_tdep: TRACE_FLAVOR_SIZE = %d\n",
6394                       TRACE_FLAVOR_SIZE);
6395 #endif
6396 #ifdef TRACE_SET
6397   fprintf_unfiltered (file,
6398                       "mips_dump_tdep: TRACE_SET # %s\n",
6399                       XSTRING (TRACE_SET (X,STATE)));
6400 #endif
6401   fprintf_unfiltered (file,
6402                       "mips_dump_tdep: UNMAKE_MIPS16_ADDR = function?\n");
6403 #ifdef UNUSED_REGNUM
6404   fprintf_unfiltered (file,
6405                       "mips_dump_tdep: UNUSED_REGNUM = %d\n",
6406                       UNUSED_REGNUM);
6407 #endif
6408   fprintf_unfiltered (file,
6409                       "mips_dump_tdep: V0_REGNUM = %d\n",
6410                       V0_REGNUM);
6411   fprintf_unfiltered (file,
6412                       "mips_dump_tdep: VM_MIN_ADDRESS = %ld\n",
6413                       (long) VM_MIN_ADDRESS);
6414 #ifdef VX_NUM_REGS
6415   fprintf_unfiltered (file,
6416                       "mips_dump_tdep: VX_NUM_REGS = %d (used?)\n",
6417                       VX_NUM_REGS);
6418 #endif
6419   fprintf_unfiltered (file,
6420                       "mips_dump_tdep: ZERO_REGNUM = %d\n",
6421                       ZERO_REGNUM);
6422   fprintf_unfiltered (file,
6423                       "mips_dump_tdep: _PROC_MAGIC_ = %d\n",
6424                       _PROC_MAGIC_);
6425
6426   fprintf_unfiltered (file,
6427                       "mips_dump_tdep: OS ABI = %s\n",
6428                       gdbarch_osabi_name (tdep->osabi));
6429 }
6430
6431 void
6432 _initialize_mips_tdep (void)
6433 {
6434   static struct cmd_list_element *mipsfpulist = NULL;
6435   struct cmd_list_element *c;
6436
6437   mips_abi_string = mips_abi_strings [MIPS_ABI_UNKNOWN];
6438   if (MIPS_ABI_LAST + 1
6439       != sizeof (mips_abi_strings) / sizeof (mips_abi_strings[0]))
6440     internal_error (__FILE__, __LINE__, "mips_abi_strings out of sync");
6441
6442   gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
6443   if (!tm_print_insn)           /* Someone may have already set it */
6444     tm_print_insn = gdb_print_insn_mips;
6445
6446   /* Add root prefix command for all "set mips"/"show mips" commands */
6447   add_prefix_cmd ("mips", no_class, set_mips_command,
6448                   "Various MIPS specific commands.",
6449                   &setmipscmdlist, "set mips ", 0, &setlist);
6450
6451   add_prefix_cmd ("mips", no_class, show_mips_command,
6452                   "Various MIPS specific commands.",
6453                   &showmipscmdlist, "show mips ", 0, &showlist);
6454
6455   /* Allow the user to override the saved register size. */
6456   add_show_from_set (add_set_enum_cmd ("saved-gpreg-size",
6457                                        class_obscure,
6458                                        size_enums,
6459                                        &mips_saved_regsize_string, "\
6460 Set size of general purpose registers saved on the stack.\n\
6461 This option can be set to one of:\n\
6462   32    - Force GDB to treat saved GP registers as 32-bit\n\
6463   64    - Force GDB to treat saved GP registers as 64-bit\n\
6464   auto  - Allow GDB to use the target's default setting or autodetect the\n\
6465           saved GP register size from information contained in the executable.\n\
6466           (default: auto)",
6467                                        &setmipscmdlist),
6468                      &showmipscmdlist);
6469
6470   /* Allow the user to override the argument stack size. */
6471   add_show_from_set (add_set_enum_cmd ("stack-arg-size",
6472                                        class_obscure,
6473                                        size_enums,
6474                                        &mips_stack_argsize_string, "\
6475 Set the amount of stack space reserved for each argument.\n\
6476 This option can be set to one of:\n\
6477   32    - Force GDB to allocate 32-bit chunks per argument\n\
6478   64    - Force GDB to allocate 64-bit chunks per argument\n\
6479   auto  - Allow GDB to determine the correct setting from the current\n\
6480           target and executable (default)",
6481                                        &setmipscmdlist),
6482                      &showmipscmdlist);
6483
6484   /* Allow the user to override the ABI. */
6485   c = add_set_enum_cmd
6486     ("abi", class_obscure, mips_abi_strings, &mips_abi_string,
6487      "Set the ABI used by this program.\n"
6488      "This option can be set to one of:\n"
6489      "  auto  - the default ABI associated with the current binary\n"
6490      "  o32\n"
6491      "  o64\n"
6492      "  n32\n"
6493      "  n64\n"
6494      "  eabi32\n"
6495      "  eabi64",
6496      &setmipscmdlist);
6497   add_show_from_set (c, &showmipscmdlist);
6498   set_cmd_sfunc (c, mips_abi_update);
6499
6500   /* Let the user turn off floating point and set the fence post for
6501      heuristic_proc_start.  */
6502
6503   add_prefix_cmd ("mipsfpu", class_support, set_mipsfpu_command,
6504                   "Set use of MIPS floating-point coprocessor.",
6505                   &mipsfpulist, "set mipsfpu ", 0, &setlist);
6506   add_cmd ("single", class_support, set_mipsfpu_single_command,
6507            "Select single-precision MIPS floating-point coprocessor.",
6508            &mipsfpulist);
6509   add_cmd ("double", class_support, set_mipsfpu_double_command,
6510            "Select double-precision MIPS floating-point coprocessor.",
6511            &mipsfpulist);
6512   add_alias_cmd ("on", "double", class_support, 1, &mipsfpulist);
6513   add_alias_cmd ("yes", "double", class_support, 1, &mipsfpulist);
6514   add_alias_cmd ("1", "double", class_support, 1, &mipsfpulist);
6515   add_cmd ("none", class_support, set_mipsfpu_none_command,
6516            "Select no MIPS floating-point coprocessor.",
6517            &mipsfpulist);
6518   add_alias_cmd ("off", "none", class_support, 1, &mipsfpulist);
6519   add_alias_cmd ("no", "none", class_support, 1, &mipsfpulist);
6520   add_alias_cmd ("0", "none", class_support, 1, &mipsfpulist);
6521   add_cmd ("auto", class_support, set_mipsfpu_auto_command,
6522            "Select MIPS floating-point coprocessor automatically.",
6523            &mipsfpulist);
6524   add_cmd ("mipsfpu", class_support, show_mipsfpu_command,
6525            "Show current use of MIPS floating-point coprocessor target.",
6526            &showlist);
6527
6528   /* We really would like to have both "0" and "unlimited" work, but
6529      command.c doesn't deal with that.  So make it a var_zinteger
6530      because the user can always use "999999" or some such for unlimited.  */
6531   c = add_set_cmd ("heuristic-fence-post", class_support, var_zinteger,
6532                    (char *) &heuristic_fence_post,
6533                    "\
6534 Set the distance searched for the start of a function.\n\
6535 If you are debugging a stripped executable, GDB needs to search through the\n\
6536 program for the start of a function.  This command sets the distance of the\n\
6537 search.  The only need to set it is when debugging a stripped executable.",
6538                    &setlist);
6539   /* We need to throw away the frame cache when we set this, since it
6540      might change our ability to get backtraces.  */
6541   set_cmd_sfunc (c, reinit_frame_cache_sfunc);
6542   add_show_from_set (c, &showlist);
6543
6544   /* Allow the user to control whether the upper bits of 64-bit
6545      addresses should be zeroed.  */
6546   add_setshow_auto_boolean_cmd ("mask-address", no_class, &mask_address_var, "\
6547 Set zeroing of upper 32 bits of 64-bit addresses.\n\
6548 Use \"on\" to enable the masking, \"off\" to disable it and \"auto\" to \n\
6549 allow GDB to determine the correct value.\n", "\
6550 Show zeroing of upper 32 bits of 64-bit addresses.",
6551                                 NULL, show_mask_address,
6552                                 &setmipscmdlist, &showmipscmdlist);
6553
6554   /* Allow the user to control the size of 32 bit registers within the
6555      raw remote packet.  */
6556   add_show_from_set (add_set_cmd ("remote-mips64-transfers-32bit-regs",
6557                                   class_obscure,
6558                                   var_boolean,
6559                                   (char *)&mips64_transfers_32bit_regs_p, "\
6560 Set compatibility with MIPS targets that transfers 32 and 64 bit quantities.\n\
6561 Use \"on\" to enable backward compatibility with older MIPS 64 GDB+target\n\
6562 that would transfer 32 bits for some registers (e.g. SR, FSR) and\n\
6563 64 bits for others.  Use \"off\" to disable compatibility mode",
6564                                   &setlist),
6565                      &showlist);
6566
6567   /* Debug this files internals. */
6568   add_show_from_set (add_set_cmd ("mips", class_maintenance, var_zinteger,
6569                                   &mips_debug, "Set mips debugging.\n\
6570 When non-zero, mips specific debugging is enabled.", &setdebuglist),
6571                      &showdebuglist);
6572 }