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