gdb/mips-tdep.c

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