gdb/mips-tdep.c

   1 /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
   2
   3    Copyright (C) 1988-2014 Free Software Foundation, Inc.
   4
   5    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   6    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "symtab.h"
  27 #include "value.h"
  28 #include "gdbcmd.h"
  29 #include "language.h"
  30 #include "gdbcore.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33 #include "gdbtypes.h"
  34 #include "target.h"
  35 #include "arch-utils.h"
  36 #include "regcache.h"
  37 #include "osabi.h"
  38 #include "mips-tdep.h"
  39 #include "block.h"
  40 #include "reggroups.h"
  41 #include "opcode/mips.h"
  42 #include "elf/mips.h"
  43 #include "elf-bfd.h"
  44 #include "symcat.h"
  45 #include "sim-regno.h"
  46 #include "dis-asm.h"
  47 #include "frame-unwind.h"
  48 #include "frame-base.h"
  49 #include "trad-frame.h"
  50 #include "infcall.h"
  51 #include "floatformat.h"
  52 #include "remote.h"
  53 #include "target-descriptions.h"
  54 #include "dwarf2-frame.h"
  55 #include "user-regs.h"
  56 #include "valprint.h"
  57 #include "ax.h"
  58
  59 static const struct objfile_data *mips_pdr_data;
  60
  61 static struct type *mips_register_type (struct gdbarch *gdbarch, int regnum);
  62
  63 static int mips32_instruction_has_delay_slot (struct gdbarch *gdbarch,
  64                                               ULONGEST inst);
  65 static int micromips_instruction_has_delay_slot (ULONGEST insn, int mustbe32);
  66 static int mips16_instruction_has_delay_slot (unsigned short inst,
  67                                               int mustbe32);
  68
  69 static int mips32_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch,
  70                                              CORE_ADDR addr);
  71 static int micromips_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch,
  72                                                 CORE_ADDR addr, int mustbe32);
  73 static int mips16_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch,
  74                                              CORE_ADDR addr, int mustbe32);
  75
  76 static void mips_print_float_info (struct gdbarch *, struct ui_file *,
  77                                    struct frame_info *, const char *);
  78
  79 /* A useful bit in the CP0 status register (MIPS_PS_REGNUM).  */
  80 /* This bit is set if we are emulating 32-bit FPRs on a 64-bit chip.  */
  81 #define ST0_FR (1 << 26)
  82
  83 /* The sizes of floating point registers.  */
  84
  85 enum
  86 {
  87   MIPS_FPU_SINGLE_REGSIZE = 4,
  88   MIPS_FPU_DOUBLE_REGSIZE = 8
  89 };
  90
  91 enum
  92 {
  93   MIPS32_REGSIZE = 4,
  94   MIPS64_REGSIZE = 8
  95 };
  96
  97 static const char *mips_abi_string;
  98
  99 static const char *const mips_abi_strings[] = {
 100   "auto",
 101   "n32",
 102   "o32",
 103   "n64",
 104   "o64",
 105   "eabi32",
 106   "eabi64",
 107   NULL
 108 };
 109
 110 /* For backwards compatibility we default to MIPS16.  This flag is
 111    overridden as soon as unambiguous ELF file flags tell us the
 112    compressed ISA encoding used.  */
 113 static const char mips_compression_mips16[] = "mips16";
 114 static const char mips_compression_micromips[] = "micromips";
 115 static const char *const mips_compression_strings[] =
 116 {
 117   mips_compression_mips16,
 118   mips_compression_micromips,
 119   NULL
 120 };
 121
 122 static const char *mips_compression_string = mips_compression_mips16;
 123
 124 /* The standard register names, and all the valid aliases for them.  */
 125 struct register_alias
 126 {
 127   const char *name;
 128   int regnum;
 129 };
 130
 131 /* Aliases for o32 and most other ABIs.  */
 132 const struct register_alias mips_o32_aliases[] = {
 133   { "ta0", 12 },
 134   { "ta1", 13 },
 135   { "ta2", 14 },
 136   { "ta3", 15 }
 137 };
 138
 139 /* Aliases for n32 and n64.  */
 140 const struct register_alias mips_n32_n64_aliases[] = {
 141   { "ta0", 8 },
 142   { "ta1", 9 },
 143   { "ta2", 10 },
 144   { "ta3", 11 }
 145 };
 146
 147 /* Aliases for ABI-independent registers.  */
 148 const struct register_alias mips_register_aliases[] = {
 149   /* The architecture manuals specify these ABI-independent names for
 150      the GPRs.  */
 151 #define R(n) { "r" #n, n }
 152   R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7),
 153   R(8), R(9), R(10), R(11), R(12), R(13), R(14), R(15),
 154   R(16), R(17), R(18), R(19), R(20), R(21), R(22), R(23),
 155   R(24), R(25), R(26), R(27), R(28), R(29), R(30), R(31),
 156 #undef R
 157
 158   /* k0 and k1 are sometimes called these instead (for "kernel
 159      temp").  */
 160   { "kt0", 26 },
 161   { "kt1", 27 },
 162
 163   /* This is the traditional GDB name for the CP0 status register.  */
 164   { "sr", MIPS_PS_REGNUM },
 165
 166   /* This is the traditional GDB name for the CP0 BadVAddr register.  */
 167   { "bad", MIPS_EMBED_BADVADDR_REGNUM },
 168
 169   /* This is the traditional GDB name for the FCSR.  */
 170   { "fsr", MIPS_EMBED_FP0_REGNUM + 32 }
 171 };
 172
 173 const struct register_alias mips_numeric_register_aliases[] = {
 174 #define R(n) { #n, n }
 175   R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7),
 176   R(8), R(9), R(10), R(11), R(12), R(13), R(14), R(15),
 177   R(16), R(17), R(18), R(19), R(20), R(21), R(22), R(23),
 178   R(24), R(25), R(26), R(27), R(28), R(29), R(30), R(31),
 179 #undef R
 180 };
 181
 182 #ifndef MIPS_DEFAULT_FPU_TYPE
 183 #define MIPS_DEFAULT_FPU_TYPE MIPS_FPU_DOUBLE
 184 #endif
 185 static int mips_fpu_type_auto = 1;
 186 static enum mips_fpu_type mips_fpu_type = MIPS_DEFAULT_FPU_TYPE;
 187
 188 static unsigned int mips_debug = 0;
 189
 190 /* Properties (for struct target_desc) describing the g/G packet
 191    layout.  */
 192 #define PROPERTY_GP32 "internal: transfers-32bit-registers"
 193 #define PROPERTY_GP64 "internal: transfers-64bit-registers"
 194
 195 struct target_desc *mips_tdesc_gp32;
 196 struct target_desc *mips_tdesc_gp64;
 197
 198 const struct mips_regnum *
 199 mips_regnum (struct gdbarch *gdbarch)
 200 {
 201   return gdbarch_tdep (gdbarch)->regnum;
 202 }
 203
 204 static int
 205 mips_fpa0_regnum (struct gdbarch *gdbarch)
 206 {
 207   return mips_regnum (gdbarch)->fp0 + 12;
 208 }
 209
 210 /* Return 1 if REGNUM refers to a floating-point general register, raw
 211    or cooked.  Otherwise return 0.  */
 212
 213 static int
 214 mips_float_register_p (struct gdbarch *gdbarch, int regnum)
 215 {
 216   int rawnum = regnum % gdbarch_num_regs (gdbarch);
 217
 218   return (rawnum >= mips_regnum (gdbarch)->fp0
 219           && rawnum < mips_regnum (gdbarch)->fp0 + 32);
 220 }
 221
 222 #define MIPS_EABI(gdbarch) (gdbarch_tdep (gdbarch)->mips_abi \
 223                      == MIPS_ABI_EABI32 \
 224                    || gdbarch_tdep (gdbarch)->mips_abi == MIPS_ABI_EABI64)
 225
 226 #define MIPS_LAST_FP_ARG_REGNUM(gdbarch) \
 227   (gdbarch_tdep (gdbarch)->mips_last_fp_arg_regnum)
 228
 229 #define MIPS_LAST_ARG_REGNUM(gdbarch) \
 230   (gdbarch_tdep (gdbarch)->mips_last_arg_regnum)
 231
 232 #define MIPS_FPU_TYPE(gdbarch) (gdbarch_tdep (gdbarch)->mips_fpu_type)
 233
 234 /* Return the MIPS ABI associated with GDBARCH.  */
 235 enum mips_abi
 236 mips_abi (struct gdbarch *gdbarch)
 237 {
 238   return gdbarch_tdep (gdbarch)->mips_abi;
 239 }
 240
 241 int
 242 mips_isa_regsize (struct gdbarch *gdbarch)
 243 {
 244   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 245
 246   /* If we know how big the registers are, use that size.  */
 247   if (tdep->register_size_valid_p)
 248     return tdep->register_size;
 249
 250   /* Fall back to the previous behavior.  */
 251   return (gdbarch_bfd_arch_info (gdbarch)->bits_per_word
 252           / gdbarch_bfd_arch_info (gdbarch)->bits_per_byte);
 253 }
 254
 255 /* Return the currently configured (or set) saved register size.  */
 256
 257 unsigned int
 258 mips_abi_regsize (struct gdbarch *gdbarch)
 259 {
 260   switch (mips_abi (gdbarch))
 261     {
 262     case MIPS_ABI_EABI32:
 263     case MIPS_ABI_O32:
 264       return 4;
 265     case MIPS_ABI_N32:
 266     case MIPS_ABI_N64:
 267     case MIPS_ABI_O64:
 268     case MIPS_ABI_EABI64:
 269       return 8;
 270     case MIPS_ABI_UNKNOWN:
 271     case MIPS_ABI_LAST:
 272     default:
 273       internal_error (__FILE__, __LINE__, _("bad switch"));
 274     }
 275 }
 276
 277 /* MIPS16/microMIPS function addresses are odd (bit 0 is set).  Here
 278    are some functions to handle addresses associated with compressed
 279    code including but not limited to testing, setting, or clearing
 280    bit 0 of such addresses.  */
 281
 282 /* Return one iff compressed code is the MIPS16 instruction set.  */
 283
 284 static int
 285 is_mips16_isa (struct gdbarch *gdbarch)
 286 {
 287   return gdbarch_tdep (gdbarch)->mips_isa == ISA_MIPS16;
 288 }
 289
 290 /* Return one iff compressed code is the microMIPS instruction set.  */
 291
 292 static int
 293 is_micromips_isa (struct gdbarch *gdbarch)
 294 {
 295   return gdbarch_tdep (gdbarch)->mips_isa == ISA_MICROMIPS;
 296 }
 297
 298 /* Return one iff ADDR denotes compressed code.  */
 299
 300 static int
 301 is_compact_addr (CORE_ADDR addr)
 302 {
 303   return ((addr) & 1);
 304 }
 305
 306 /* Return one iff ADDR denotes standard ISA code.  */
 307
 308 static int
 309 is_mips_addr (CORE_ADDR addr)
 310 {
 311   return !is_compact_addr (addr);
 312 }
 313
 314 /* Return one iff ADDR denotes MIPS16 code.  */
 315
 316 static int
 317 is_mips16_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 318 {
 319   return is_compact_addr (addr) && is_mips16_isa (gdbarch);
 320 }
 321
 322 /* Return one iff ADDR denotes microMIPS code.  */
 323
 324 static int
 325 is_micromips_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 326 {
 327   return is_compact_addr (addr) && is_micromips_isa (gdbarch);
 328 }
 329
 330 /* Strip the ISA (compression) bit off from ADDR.  */
 331
 332 static CORE_ADDR
 333 unmake_compact_addr (CORE_ADDR addr)
 334 {
 335   return ((addr) & ~(CORE_ADDR) 1);
 336 }
 337
 338 /* Add the ISA (compression) bit to ADDR.  */
 339
 340 static CORE_ADDR
 341 make_compact_addr (CORE_ADDR addr)
 342 {
 343   return ((addr) | (CORE_ADDR) 1);
 344 }
 345
 346 /* Extern version of unmake_compact_addr; we use a separate function
 347    so that unmake_compact_addr can be inlined throughout this file.  */
 348
 349 CORE_ADDR
 350 mips_unmake_compact_addr (CORE_ADDR addr)
 351 {
 352   return unmake_compact_addr (addr);
 353 }
 354
 355 /* Functions for setting and testing a bit in a minimal symbol that
 356    marks it as MIPS16 or microMIPS function.  The MSB of the minimal
 357    symbol's "info" field is used for this purpose.
 358
 359    gdbarch_elf_make_msymbol_special tests whether an ELF symbol is
 360    "special", i.e. refers to a MIPS16 or microMIPS function, and sets
 361    one of the "special" bits in a minimal symbol to mark it accordingly.
 362    The test checks an ELF-private flag that is valid for true function
 363    symbols only; for synthetic symbols such as for PLT stubs that have
 364    no ELF-private part at all the MIPS BFD backend arranges for this
 365    information to be carried in the asymbol's udata field instead.
 366
 367    msymbol_is_mips16 and msymbol_is_micromips test the "special" bit
 368    in a minimal symbol.  */
 369
 370 static void
 371 mips_elf_make_msymbol_special (asymbol * sym, struct minimal_symbol *msym)
 372 {
 373   elf_symbol_type *elfsym = (elf_symbol_type *) sym;
 374   unsigned char st_other;
 375
 376   if ((sym->flags & BSF_SYNTHETIC) == 0)
 377     st_other = elfsym->internal_elf_sym.st_other;
 378   else if ((sym->flags & BSF_FUNCTION) != 0)
 379     st_other = sym->udata.i;
 380   else
 381     return;
 382
 383   if (ELF_ST_IS_MICROMIPS (st_other))
 384     {
 385       MSYMBOL_TARGET_FLAG_MICROMIPS (msym) = 1;
 386       SET_MSYMBOL_VALUE_ADDRESS (msym, MSYMBOL_VALUE_RAW_ADDRESS (msym) | 1);
 387     }
 388   else if (ELF_ST_IS_MIPS16 (st_other))
 389     {
 390       MSYMBOL_TARGET_FLAG_MIPS16 (msym) = 1;
 391       SET_MSYMBOL_VALUE_ADDRESS (msym, MSYMBOL_VALUE_RAW_ADDRESS (msym) | 1);
 392     }
 393 }
 394
 395 /* Return one iff MSYM refers to standard ISA code.  */
 396
 397 static int
 398 msymbol_is_mips (struct minimal_symbol *msym)
 399 {
 400   return !(MSYMBOL_TARGET_FLAG_MIPS16 (msym)
 401            | MSYMBOL_TARGET_FLAG_MICROMIPS (msym));
 402 }
 403
 404 /* Return one iff MSYM refers to MIPS16 code.  */
 405
 406 static int
 407 msymbol_is_mips16 (struct minimal_symbol *msym)
 408 {
 409   return MSYMBOL_TARGET_FLAG_MIPS16 (msym);
 410 }
 411
 412 /* Return one iff MSYM refers to microMIPS code.  */
 413
 414 static int
 415 msymbol_is_micromips (struct minimal_symbol *msym)
 416 {
 417   return MSYMBOL_TARGET_FLAG_MICROMIPS (msym);
 418 }
 419
 420 /* Set the ISA bit in the main symbol too, complementing the corresponding
 421    minimal symbol setting and reflecting the run-time value of the symbol.
 422    The need for comes from the ISA bit having been cleared as code in
 423    `_bfd_mips_elf_symbol_processing' separated it into the ELF symbol's
 424    `st_other' STO_MIPS16 or STO_MICROMIPS annotation, making the values
 425    of symbols referring to compressed code different in GDB to the values
 426    used by actual code.  That in turn makes them evaluate incorrectly in
 427    expressions, producing results different to what the same expressions
 428    yield when compiled into the program being debugged.  */
 429
 430 static void
 431 mips_make_symbol_special (struct symbol *sym, struct objfile *objfile)
 432 {
 433   if (SYMBOL_CLASS (sym) == LOC_BLOCK)
 434     {
 435       /* We are in symbol reading so it is OK to cast away constness.  */
 436       struct block *block = (struct block *) SYMBOL_BLOCK_VALUE (sym);
 437       CORE_ADDR compact_block_start;
 438       struct bound_minimal_symbol msym;
 439
 440       compact_block_start = BLOCK_START (block) | 1;
 441       msym = lookup_minimal_symbol_by_pc (compact_block_start);
 442       if (msym.minsym && !msymbol_is_mips (msym.minsym))
 443         {
 444           BLOCK_START (block) = compact_block_start;
 445         }
 446     }
 447 }
 448
 449 /* XFER a value from the big/little/left end of the register.
 450    Depending on the size of the value it might occupy the entire
 451    register or just part of it.  Make an allowance for this, aligning
 452    things accordingly.  */
 453
 454 static void
 455 mips_xfer_register (struct gdbarch *gdbarch, struct regcache *regcache,
 456                     int reg_num, int length,
 457                     enum bfd_endian endian, gdb_byte *in,
 458                     const gdb_byte *out, int buf_offset)
 459 {
 460   int reg_offset = 0;
 461
 462   gdb_assert (reg_num >= gdbarch_num_regs (gdbarch));
 463   /* Need to transfer the left or right part of the register, based on
 464      the targets byte order.  */
 465   switch (endian)
 466     {
 467     case BFD_ENDIAN_BIG:
 468       reg_offset = register_size (gdbarch, reg_num) - length;
 469       break;
 470     case BFD_ENDIAN_LITTLE:
 471       reg_offset = 0;
 472       break;
 473     case BFD_ENDIAN_UNKNOWN:    /* Indicates no alignment.  */
 474       reg_offset = 0;
 475       break;
 476     default:
 477       internal_error (__FILE__, __LINE__, _("bad switch"));
 478     }
 479   if (mips_debug)
 480     fprintf_unfiltered (gdb_stderr,
 481                         "xfer $%d, reg offset %d, buf offset %d, length %d, ",
 482                         reg_num, reg_offset, buf_offset, length);
 483   if (mips_debug && out != NULL)
 484     {
 485       int i;
 486       fprintf_unfiltered (gdb_stdlog, "out ");
 487       for (i = 0; i < length; i++)
 488         fprintf_unfiltered (gdb_stdlog, "%02x", out[buf_offset + i]);
 489     }
 490   if (in != NULL)
 491     regcache_cooked_read_part (regcache, reg_num, reg_offset, length,
 492                                in + buf_offset);
 493   if (out != NULL)
 494     regcache_cooked_write_part (regcache, reg_num, reg_offset, length,
 495                                 out + buf_offset);
 496   if (mips_debug && in != NULL)
 497     {
 498       int i;
 499       fprintf_unfiltered (gdb_stdlog, "in ");
 500       for (i = 0; i < length; i++)
 501         fprintf_unfiltered (gdb_stdlog, "%02x", in[buf_offset + i]);
 502     }
 503   if (mips_debug)
 504     fprintf_unfiltered (gdb_stdlog, "\n");
 505 }
 506
 507 /* Determine if a MIPS3 or later cpu is operating in MIPS{1,2} FPU
 508    compatiblity mode.  A return value of 1 means that we have
 509    physical 64-bit registers, but should treat them as 32-bit registers.  */
 510
 511 static int
 512 mips2_fp_compat (struct frame_info *frame)
 513 {
 514   struct gdbarch *gdbarch = get_frame_arch (frame);
 515   /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
 516      meaningful.  */
 517   if (register_size (gdbarch, mips_regnum (gdbarch)->fp0) == 4)
 518     return 0;
 519
 520 #if 0
 521   /* FIXME drow 2002-03-10: This is disabled until we can do it consistently,
 522      in all the places we deal with FP registers.  PR gdb/413.  */
 523   /* Otherwise check the FR bit in the status register - it controls
 524      the FP compatiblity mode.  If it is clear we are in compatibility
 525      mode.  */
 526   if ((get_frame_register_unsigned (frame, MIPS_PS_REGNUM) & ST0_FR) == 0)
 527     return 1;
 528 #endif
 529
 530   return 0;
 531 }
 532
 533 #define VM_MIN_ADDRESS (CORE_ADDR)0x400000
 534
 535 static CORE_ADDR heuristic_proc_start (struct gdbarch *, CORE_ADDR);
 536
 537 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element *);
 538
 539 /* The list of available "set mips " and "show mips " commands.  */
 540
 541 static struct cmd_list_element *setmipscmdlist = NULL;
 542 static struct cmd_list_element *showmipscmdlist = NULL;
 543
 544 /* Integer registers 0 thru 31 are handled explicitly by
 545    mips_register_name().  Processor specific registers 32 and above
 546    are listed in the following tables.  */
 547
 548 enum
 549 { NUM_MIPS_PROCESSOR_REGS = (90 - 32) };
 550
 551 /* Generic MIPS.  */
 552
 553 static const char *mips_generic_reg_names[NUM_MIPS_PROCESSOR_REGS] = {
 554   "sr", "lo", "hi", "bad", "cause", "pc",
 555   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
 556   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 557   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 558   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 559   "fsr", "fir",
 560 };
 561
 562 /* Names of IDT R3041 registers.  */
 563
 564 static const char *mips_r3041_reg_names[] = {
 565   "sr", "lo", "hi", "bad", "cause", "pc",
 566   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
 567   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 568   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 569   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 570   "fsr", "fir", "", /*"fp" */ "",
 571   "", "", "bus", "ccfg", "", "", "", "",
 572   "", "", "port", "cmp", "", "", "epc", "prid",
 573 };
 574
 575 /* Names of tx39 registers.  */
 576
 577 static const char *mips_tx39_reg_names[NUM_MIPS_PROCESSOR_REGS] = {
 578   "sr", "lo", "hi", "bad", "cause", "pc",
 579   "", "", "", "", "", "", "", "",
 580   "", "", "", "", "", "", "", "",
 581   "", "", "", "", "", "", "", "",
 582   "", "", "", "", "", "", "", "",
 583   "", "", "", "",
 584   "", "", "", "", "", "", "", "",
 585   "", "", "config", "cache", "debug", "depc", "epc",
 586 };
 587
 588 /* Names of IRIX registers.  */
 589 static const char *mips_irix_reg_names[NUM_MIPS_PROCESSOR_REGS] = {
 590   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
 591   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 592   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 593   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 594   "pc", "cause", "bad", "hi", "lo", "fsr", "fir"
 595 };
 596
 597 /* Names of registers with Linux kernels.  */
 598 static const char *mips_linux_reg_names[NUM_MIPS_PROCESSOR_REGS] = {
 599   "sr", "lo", "hi", "bad", "cause", "pc",
 600   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
 601   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 602   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 603   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 604   "fsr", "fir"
 605 };
 606
 607
 608 /* Return the name of the register corresponding to REGNO.  */
 609 static const char *
 610 mips_register_name (struct gdbarch *gdbarch, int regno)
 611 {
 612   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 613   /* GPR names for all ABIs other than n32/n64.  */
 614   static char *mips_gpr_names[] = {
 615     "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
 616     "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
 617     "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
 618     "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra",
 619   };
 620
 621   /* GPR names for n32 and n64 ABIs.  */
 622   static char *mips_n32_n64_gpr_names[] = {
 623     "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
 624     "a4", "a5", "a6", "a7", "t0", "t1", "t2", "t3",
 625     "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
 626     "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra"
 627   };
 628
 629   enum mips_abi abi = mips_abi (gdbarch);
 630
 631   /* Map [gdbarch_num_regs .. 2*gdbarch_num_regs) onto the raw registers,
 632      but then don't make the raw register names visible.  This (upper)
 633      range of user visible register numbers are the pseudo-registers.
 634
 635      This approach was adopted accommodate the following scenario:
 636      It is possible to debug a 64-bit device using a 32-bit
 637      programming model.  In such instances, the raw registers are
 638      configured to be 64-bits wide, while the pseudo registers are
 639      configured to be 32-bits wide.  The registers that the user
 640      sees - the pseudo registers - match the users expectations
 641      given the programming model being used.  */
 642   int rawnum = regno % gdbarch_num_regs (gdbarch);
 643   if (regno < gdbarch_num_regs (gdbarch))
 644     return "";
 645
 646   /* The MIPS integer registers are always mapped from 0 to 31.  The
 647      names of the registers (which reflects the conventions regarding
 648      register use) vary depending on the ABI.  */
 649   if (0 <= rawnum && rawnum < 32)
 650     {
 651       if (abi == MIPS_ABI_N32 || abi == MIPS_ABI_N64)
 652         return mips_n32_n64_gpr_names[rawnum];
 653       else
 654         return mips_gpr_names[rawnum];
 655     }
 656   else if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
 657     return tdesc_register_name (gdbarch, rawnum);
 658   else if (32 <= rawnum && rawnum < gdbarch_num_regs (gdbarch))
 659     {
 660       gdb_assert (rawnum - 32 < NUM_MIPS_PROCESSOR_REGS);
 661       if (tdep->mips_processor_reg_names[rawnum - 32])
 662         return tdep->mips_processor_reg_names[rawnum - 32];
 663       return "";
 664     }
 665   else
 666     internal_error (__FILE__, __LINE__,
 667                     _("mips_register_name: bad register number %d"), rawnum);
 668 }
 669
 670 /* Return the groups that a MIPS register can be categorised into.  */
 671
 672 static int
 673 mips_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 674                           struct reggroup *reggroup)
 675 {
 676   int vector_p;
 677   int float_p;
 678   int raw_p;
 679   int rawnum = regnum % gdbarch_num_regs (gdbarch);
 680   int pseudo = regnum / gdbarch_num_regs (gdbarch);
 681   if (reggroup == all_reggroup)
 682     return pseudo;
 683   vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
 684   float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT;
 685   /* FIXME: cagney/2003-04-13: Can't yet use gdbarch_num_regs
 686      (gdbarch), as not all architectures are multi-arch.  */
 687   raw_p = rawnum < gdbarch_num_regs (gdbarch);
 688   if (gdbarch_register_name (gdbarch, regnum) == NULL
 689       || gdbarch_register_name (gdbarch, regnum)[0] == '\0')
 690     return 0;
 691   if (reggroup == float_reggroup)
 692     return float_p && pseudo;
 693   if (reggroup == vector_reggroup)
 694     return vector_p && pseudo;
 695   if (reggroup == general_reggroup)
 696     return (!vector_p && !float_p) && pseudo;
 697   /* Save the pseudo registers.  Need to make certain that any code
 698      extracting register values from a saved register cache also uses
 699      pseudo registers.  */
 700   if (reggroup == save_reggroup)
 701     return raw_p && pseudo;
 702   /* Restore the same pseudo register.  */
 703   if (reggroup == restore_reggroup)
 704     return raw_p && pseudo;
 705   return 0;
 706 }
 707
 708 /* Return the groups that a MIPS register can be categorised into.
 709    This version is only used if we have a target description which
 710    describes real registers (and their groups).  */
 711
 712 static int
 713 mips_tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 714                                 struct reggroup *reggroup)
 715 {
 716   int rawnum = regnum % gdbarch_num_regs (gdbarch);
 717   int pseudo = regnum / gdbarch_num_regs (gdbarch);
 718   int ret;
 719
 720   /* Only save, restore, and display the pseudo registers.  Need to
 721      make certain that any code extracting register values from a
 722      saved register cache also uses pseudo registers.
 723
 724      Note: saving and restoring the pseudo registers is slightly
 725      strange; if we have 64 bits, we should save and restore all
 726      64 bits.  But this is hard and has little benefit.  */
 727   if (!pseudo)
 728     return 0;
 729
 730   ret = tdesc_register_in_reggroup_p (gdbarch, rawnum, reggroup);
 731   if (ret != -1)
 732     return ret;
 733
 734   return mips_register_reggroup_p (gdbarch, regnum, reggroup);
 735 }
 736
 737 /* Map the symbol table registers which live in the range [1 *
 738    gdbarch_num_regs .. 2 * gdbarch_num_regs) back onto the corresponding raw
 739    registers.  Take care of alignment and size problems.  */
 740
 741 static enum register_status
 742 mips_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 743                            int cookednum, gdb_byte *buf)
 744 {
 745   int rawnum = cookednum % gdbarch_num_regs (gdbarch);
 746   gdb_assert (cookednum >= gdbarch_num_regs (gdbarch)
 747               && cookednum < 2 * gdbarch_num_regs (gdbarch));
 748   if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
 749     return regcache_raw_read (regcache, rawnum, buf);
 750   else if (register_size (gdbarch, rawnum) >
 751            register_size (gdbarch, cookednum))
 752     {
 753       if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p)
 754         return regcache_raw_read_part (regcache, rawnum, 0, 4, buf);
 755       else
 756         {
 757           enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 758           LONGEST regval;
 759           enum register_status status;
 760
 761           status = regcache_raw_read_signed (regcache, rawnum, &regval);
 762           if (status == REG_VALID)
 763             store_signed_integer (buf, 4, byte_order, regval);
 764           return status;
 765         }
 766     }
 767   else
 768     internal_error (__FILE__, __LINE__, _("bad register size"));
 769 }
 770
 771 static void
 772 mips_pseudo_register_write (struct gdbarch *gdbarch,
 773                             struct regcache *regcache, int cookednum,
 774                             const gdb_byte *buf)
 775 {
 776   int rawnum = cookednum % gdbarch_num_regs (gdbarch);
 777   gdb_assert (cookednum >= gdbarch_num_regs (gdbarch)
 778               && cookednum < 2 * gdbarch_num_regs (gdbarch));
 779   if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
 780     regcache_raw_write (regcache, rawnum, buf);
 781   else if (register_size (gdbarch, rawnum) >
 782            register_size (gdbarch, cookednum))
 783     {
 784       if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p)
 785         regcache_raw_write_part (regcache, rawnum, 0, 4, buf);
 786       else
 787         {
 788           /* Sign extend the shortened version of the register prior
 789              to placing it in the raw register.  This is required for
 790              some mips64 parts in order to avoid unpredictable behavior.  */
 791           enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 792           LONGEST regval = extract_signed_integer (buf, 4, byte_order);
 793           regcache_raw_write_signed (regcache, rawnum, regval);
 794         }
 795     }
 796   else
 797     internal_error (__FILE__, __LINE__, _("bad register size"));
 798 }
 799
 800 static int
 801 mips_ax_pseudo_register_collect (struct gdbarch *gdbarch,
 802                                  struct agent_expr *ax, int reg)
 803 {
 804   int rawnum = reg % gdbarch_num_regs (gdbarch);
 805   gdb_assert (reg >= gdbarch_num_regs (gdbarch)
 806               && reg < 2 * gdbarch_num_regs (gdbarch));
 807
 808   ax_reg_mask (ax, rawnum);
 809
 810   return 0;
 811 }
 812
 813 static int
 814 mips_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
 815                                     struct agent_expr *ax, int reg)
 816 {
 817   int rawnum = reg % gdbarch_num_regs (gdbarch);
 818   gdb_assert (reg >= gdbarch_num_regs (gdbarch)
 819               && reg < 2 * gdbarch_num_regs (gdbarch));
 820   if (register_size (gdbarch, rawnum) >= register_size (gdbarch, reg))
 821     {
 822       ax_reg (ax, rawnum);
 823
 824       if (register_size (gdbarch, rawnum) > register_size (gdbarch, reg))
 825         {
 826           if (!gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p
 827               || gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
 828             {
 829               ax_const_l (ax, 32);
 830               ax_simple (ax, aop_lsh);
 831             }
 832           ax_const_l (ax, 32);
 833           ax_simple (ax, aop_rsh_signed);
 834         }
 835     }
 836   else
 837     internal_error (__FILE__, __LINE__, _("bad register size"));
 838
 839   return 0;
 840 }
 841
 842 /* Table to translate 3-bit register field to actual register number.  */
 843 static const signed char mips_reg3_to_reg[8] = { 16, 17, 2, 3, 4, 5, 6, 7 };
 844
 845 /* Heuristic_proc_start may hunt through the text section for a long
 846    time across a 2400 baud serial line.  Allows the user to limit this
 847    search.  */
 848
 849 static int heuristic_fence_post = 0;
 850
 851 /* Number of bytes of storage in the actual machine representation for
 852    register N.  NOTE: This defines the pseudo register type so need to
 853    rebuild the architecture vector.  */
 854
 855 static int mips64_transfers_32bit_regs_p = 0;
 856
 857 static void
 858 set_mips64_transfers_32bit_regs (char *args, int from_tty,
 859                                  struct cmd_list_element *c)
 860 {
 861   struct gdbarch_info info;
 862   gdbarch_info_init (&info);
 863   /* FIXME: cagney/2003-11-15: Should be setting a field in "info"
 864      instead of relying on globals.  Doing that would let generic code
 865      handle the search for this specific architecture.  */
 866   if (!gdbarch_update_p (info))
 867     {
 868       mips64_transfers_32bit_regs_p = 0;
 869       error (_("32-bit compatibility mode not supported"));
 870     }
 871 }
 872
 873 /* Convert to/from a register and the corresponding memory value.  */
 874
 875 /* This predicate tests for the case of an 8 byte floating point
 876    value that is being transferred to or from a pair of floating point
 877    registers each of which are (or are considered to be) only 4 bytes
 878    wide.  */
 879 static int
 880 mips_convert_register_float_case_p (struct gdbarch *gdbarch, int regnum,
 881                                     struct type *type)
 882 {
 883   return (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 884           && register_size (gdbarch, regnum) == 4
 885           && mips_float_register_p (gdbarch, regnum)
 886           && TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8);
 887 }
 888
 889 /* This predicate tests for the case of a value of less than 8
 890    bytes in width that is being transfered to or from an 8 byte
 891    general purpose register.  */
 892 static int
 893 mips_convert_register_gpreg_case_p (struct gdbarch *gdbarch, int regnum,
 894                                     struct type *type)
 895 {
 896   int num_regs = gdbarch_num_regs (gdbarch);
 897
 898   return (register_size (gdbarch, regnum) == 8
 899           && regnum % num_regs > 0 && regnum % num_regs < 32
 900           && TYPE_LENGTH (type) < 8);
 901 }
 902
 903 static int
 904 mips_convert_register_p (struct gdbarch *gdbarch,
 905                          int regnum, struct type *type)
 906 {
 907   return (mips_convert_register_float_case_p (gdbarch, regnum, type)
 908           || mips_convert_register_gpreg_case_p (gdbarch, regnum, type));
 909 }
 910
 911 static int
 912 mips_register_to_value (struct frame_info *frame, int regnum,
 913                         struct type *type, gdb_byte *to,
 914                         int *optimizedp, int *unavailablep)
 915 {
 916   struct gdbarch *gdbarch = get_frame_arch (frame);
 917
 918   if (mips_convert_register_float_case_p (gdbarch, regnum, type))
 919     {
 920       get_frame_register (frame, regnum + 0, to + 4);
 921       get_frame_register (frame, regnum + 1, to + 0);
 922
 923       if (!get_frame_register_bytes (frame, regnum + 0, 0, 4, to + 4,
 924                                      optimizedp, unavailablep))
 925         return 0;
 926
 927       if (!get_frame_register_bytes (frame, regnum + 1, 0, 4, to + 0,
 928                                      optimizedp, unavailablep))
 929         return 0;
 930       *optimizedp = *unavailablep = 0;
 931       return 1;
 932     }
 933   else if (mips_convert_register_gpreg_case_p (gdbarch, regnum, type))
 934     {
 935       int len = TYPE_LENGTH (type);
 936       CORE_ADDR offset;
 937
 938       offset = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 8 - len : 0;
 939       if (!get_frame_register_bytes (frame, regnum, offset, len, to,
 940                                      optimizedp, unavailablep))
 941         return 0;
 942
 943       *optimizedp = *unavailablep = 0;
 944       return 1;
 945     }
 946   else
 947     {
 948       internal_error (__FILE__, __LINE__,
 949                       _("mips_register_to_value: unrecognized case"));
 950     }
 951 }
 952
 953 static void
 954 mips_value_to_register (struct frame_info *frame, int regnum,
 955                         struct type *type, const gdb_byte *from)
 956 {
 957   struct gdbarch *gdbarch = get_frame_arch (frame);
 958
 959   if (mips_convert_register_float_case_p (gdbarch, regnum, type))
 960     {
 961       put_frame_register (frame, regnum + 0, from + 4);
 962       put_frame_register (frame, regnum + 1, from + 0);
 963     }
 964   else if (mips_convert_register_gpreg_case_p (gdbarch, regnum, type))
 965     {
 966       gdb_byte fill[8];
 967       int len = TYPE_LENGTH (type);
 968
 969       /* Sign extend values, irrespective of type, that are stored to
 970          a 64-bit general purpose register.  (32-bit unsigned values
 971          are stored as signed quantities within a 64-bit register.
 972          When performing an operation, in compiled code, that combines
 973          a 32-bit unsigned value with a signed 64-bit value, a type
 974          conversion is first performed that zeroes out the high 32 bits.)  */
 975       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 976         {
 977           if (from[0] & 0x80)
 978             store_signed_integer (fill, 8, BFD_ENDIAN_BIG, -1);
 979           else
 980             store_signed_integer (fill, 8, BFD_ENDIAN_BIG, 0);
 981           put_frame_register_bytes (frame, regnum, 0, 8 - len, fill);
 982           put_frame_register_bytes (frame, regnum, 8 - len, len, from);
 983         }
 984       else
 985         {
 986           if (from[len-1] & 0x80)
 987             store_signed_integer (fill, 8, BFD_ENDIAN_LITTLE, -1);
 988           else
 989             store_signed_integer (fill, 8, BFD_ENDIAN_LITTLE, 0);
 990           put_frame_register_bytes (frame, regnum, 0, len, from);
 991           put_frame_register_bytes (frame, regnum, len, 8 - len, fill);
 992         }
 993     }
 994   else
 995     {
 996       internal_error (__FILE__, __LINE__,
 997                       _("mips_value_to_register: unrecognized case"));
 998     }
 999 }
1000
1001 /* Return the GDB type object for the "standard" data type of data in
1002    register REG.  */
1003
1004 static struct type *
1005 mips_register_type (struct gdbarch *gdbarch, int regnum)
1006 {
1007   gdb_assert (regnum >= 0 && regnum < 2 * gdbarch_num_regs (gdbarch));
1008   if (mips_float_register_p (gdbarch, regnum))
1009     {
1010       /* The floating-point registers raw, or cooked, always match
1011          mips_isa_regsize(), and also map 1:1, byte for byte.  */
1012       if (mips_isa_regsize (gdbarch) == 4)
1013         return builtin_type (gdbarch)->builtin_float;
1014       else
1015         return builtin_type (gdbarch)->builtin_double;
1016     }
1017   else if (regnum < gdbarch_num_regs (gdbarch))
1018     {
1019       /* The raw or ISA registers.  These are all sized according to
1020          the ISA regsize.  */
1021       if (mips_isa_regsize (gdbarch) == 4)
1022         return builtin_type (gdbarch)->builtin_int32;
1023       else
1024         return builtin_type (gdbarch)->builtin_int64;
1025     }
1026   else
1027     {
1028       int rawnum = regnum - gdbarch_num_regs (gdbarch);
1029
1030       /* The cooked or ABI registers.  These are sized according to
1031          the ABI (with a few complications).  */
1032       if (rawnum == mips_regnum (gdbarch)->fp_control_status
1033           || rawnum == mips_regnum (gdbarch)->fp_implementation_revision)
1034         return builtin_type (gdbarch)->builtin_int32;
1035       else if (gdbarch_osabi (gdbarch) != GDB_OSABI_IRIX
1036                && gdbarch_osabi (gdbarch) != GDB_OSABI_LINUX
1037                && rawnum >= MIPS_FIRST_EMBED_REGNUM
1038                && rawnum <= MIPS_LAST_EMBED_REGNUM)
1039         /* The pseudo/cooked view of the embedded registers is always
1040            32-bit.  The raw view is handled below.  */
1041         return builtin_type (gdbarch)->builtin_int32;
1042       else if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p)
1043         /* The target, while possibly using a 64-bit register buffer,
1044            is only transfering 32-bits of each integer register.
1045            Reflect this in the cooked/pseudo (ABI) register value.  */
1046         return builtin_type (gdbarch)->builtin_int32;
1047       else if (mips_abi_regsize (gdbarch) == 4)
1048         /* The ABI is restricted to 32-bit registers (the ISA could be
1049            32- or 64-bit).  */
1050         return builtin_type (gdbarch)->builtin_int32;
1051       else
1052         /* 64-bit ABI.  */
1053         return builtin_type (gdbarch)->builtin_int64;
1054     }
1055 }
1056
1057 /* Return the GDB type for the pseudo register REGNUM, which is the
1058    ABI-level view.  This function is only called if there is a target
1059    description which includes registers, so we know precisely the
1060    types of hardware registers.  */
1061
1062 static struct type *
1063 mips_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
1064 {
1065   const int num_regs = gdbarch_num_regs (gdbarch);
1066   int rawnum = regnum % num_regs;
1067   struct type *rawtype;
1068
1069   gdb_assert (regnum >= num_regs && regnum < 2 * num_regs);
1070
1071   /* Absent registers are still absent.  */
1072   rawtype = gdbarch_register_type (gdbarch, rawnum);
1073   if (TYPE_LENGTH (rawtype) == 0)
1074     return rawtype;
1075
1076   if (mips_float_register_p (gdbarch, rawnum))
1077     /* Present the floating point registers however the hardware did;
1078        do not try to convert between FPU layouts.  */
1079     return rawtype;
1080
1081   /* Use pointer types for registers if we can.  For n32 we can not,
1082      since we do not have a 64-bit pointer type.  */
1083   if (mips_abi_regsize (gdbarch)
1084       == TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr))
1085     {
1086       if (rawnum == MIPS_SP_REGNUM
1087           || rawnum == mips_regnum (gdbarch)->badvaddr)
1088         return builtin_type (gdbarch)->builtin_data_ptr;
1089       else if (rawnum == mips_regnum (gdbarch)->pc)
1090         return builtin_type (gdbarch)->builtin_func_ptr;
1091     }
1092
1093   if (mips_abi_regsize (gdbarch) == 4 && TYPE_LENGTH (rawtype) == 8
1094       && ((rawnum >= MIPS_ZERO_REGNUM && rawnum <= MIPS_PS_REGNUM)
1095           || rawnum == mips_regnum (gdbarch)->lo
1096           || rawnum == mips_regnum (gdbarch)->hi
1097           || rawnum == mips_regnum (gdbarch)->badvaddr
1098           || rawnum == mips_regnum (gdbarch)->cause
1099           || rawnum == mips_regnum (gdbarch)->pc
1100           || (mips_regnum (gdbarch)->dspacc != -1
1101               && rawnum >= mips_regnum (gdbarch)->dspacc
1102               && rawnum < mips_regnum (gdbarch)->dspacc + 6)))
1103     return builtin_type (gdbarch)->builtin_int32;
1104
1105   if (gdbarch_osabi (gdbarch) != GDB_OSABI_IRIX
1106       && gdbarch_osabi (gdbarch) != GDB_OSABI_LINUX
1107       && rawnum >= MIPS_EMBED_FP0_REGNUM + 32
1108       && rawnum <= MIPS_LAST_EMBED_REGNUM)
1109     {
1110       /* The pseudo/cooked view of embedded registers is always
1111          32-bit, even if the target transfers 64-bit values for them.
1112          New targets relying on XML descriptions should only transfer
1113          the necessary 32 bits, but older versions of GDB expected 64,
1114          so allow the target to provide 64 bits without interfering
1115          with the displayed type.  */
1116       return builtin_type (gdbarch)->builtin_int32;
1117     }
1118
1119   /* For all other registers, pass through the hardware type.  */
1120   return rawtype;
1121 }
1122
1123 /* Should the upper word of 64-bit addresses be zeroed?  */
1124 enum auto_boolean mask_address_var = AUTO_BOOLEAN_AUTO;
1125
1126 static int
1127 mips_mask_address_p (struct gdbarch_tdep *tdep)
1128 {
1129   switch (mask_address_var)
1130     {
1131     case AUTO_BOOLEAN_TRUE:
1132       return 1;
1133     case AUTO_BOOLEAN_FALSE:
1134       return 0;
1135       break;
1136     case AUTO_BOOLEAN_AUTO:
1137       return tdep->default_mask_address_p;
1138     default:
1139       internal_error (__FILE__, __LINE__,
1140                       _("mips_mask_address_p: bad switch"));
1141       return -1;
1142     }
1143 }
1144
1145 static void
1146 show_mask_address (struct ui_file *file, int from_tty,
1147                    struct cmd_list_element *c, const char *value)
1148 {
1149   struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
1150
1151   deprecated_show_value_hack (file, from_tty, c, value);
1152   switch (mask_address_var)
1153     {
1154     case AUTO_BOOLEAN_TRUE:
1155       printf_filtered ("The 32 bit mips address mask is enabled\n");
1156       break;
1157     case AUTO_BOOLEAN_FALSE:
1158       printf_filtered ("The 32 bit mips address mask is disabled\n");
1159       break;
1160     case AUTO_BOOLEAN_AUTO:
1161       printf_filtered
1162         ("The 32 bit address mask is set automatically.  Currently %s\n",
1163          mips_mask_address_p (tdep) ? "enabled" : "disabled");
1164       break;
1165     default:
1166       internal_error (__FILE__, __LINE__, _("show_mask_address: bad switch"));
1167       break;
1168     }
1169 }
1170
1171 /* Tell if the program counter value in MEMADDR is in a standard ISA
1172    function.  */
1173
1174 int
1175 mips_pc_is_mips (CORE_ADDR memaddr)
1176 {
1177   struct bound_minimal_symbol sym;
1178
1179   /* Flags indicating that this is a MIPS16 or microMIPS function is
1180      stored by elfread.c in the high bit of the info field.  Use this
1181      to decide if the function is standard MIPS.  Otherwise if bit 0
1182      of the address is clear, then this is a standard MIPS function.  */
1183   sym = lookup_minimal_symbol_by_pc (make_compact_addr (memaddr));
1184   if (sym.minsym)
1185     return msymbol_is_mips (sym.minsym);
1186   else
1187     return is_mips_addr (memaddr);
1188 }
1189
1190 /* Tell if the program counter value in MEMADDR is in a MIPS16 function.  */
1191
1192 int
1193 mips_pc_is_mips16 (struct gdbarch *gdbarch, CORE_ADDR memaddr)
1194 {
1195   struct bound_minimal_symbol sym;
1196
1197   /* A flag indicating that this is a MIPS16 function is stored by
1198      elfread.c in the high bit of the info field.  Use this to decide
1199      if the function is MIPS16.  Otherwise if bit 0 of the address is
1200      set, then ELF file flags will tell if this is a MIPS16 function.  */
1201   sym = lookup_minimal_symbol_by_pc (make_compact_addr (memaddr));
1202   if (sym.minsym)
1203     return msymbol_is_mips16 (sym.minsym);
1204   else
1205     return is_mips16_addr (gdbarch, memaddr);
1206 }
1207
1208 /* Tell if the program counter value in MEMADDR is in a microMIPS function.  */
1209
1210 int
1211 mips_pc_is_micromips (struct gdbarch *gdbarch, CORE_ADDR memaddr)
1212 {
1213   struct bound_minimal_symbol sym;
1214
1215   /* A flag indicating that this is a microMIPS function is stored by
1216      elfread.c in the high bit of the info field.  Use this to decide
1217      if the function is microMIPS.  Otherwise if bit 0 of the address
1218      is set, then ELF file flags will tell if this is a microMIPS
1219      function.  */
1220   sym = lookup_minimal_symbol_by_pc (make_compact_addr (memaddr));
1221   if (sym.minsym)
1222     return msymbol_is_micromips (sym.minsym);
1223   else
1224     return is_micromips_addr (gdbarch, memaddr);
1225 }
1226
1227 /* Tell the ISA type of the function the program counter value in MEMADDR
1228    is in.  */
1229
1230 static enum mips_isa
1231 mips_pc_isa (struct gdbarch *gdbarch, CORE_ADDR memaddr)
1232 {
1233   struct bound_minimal_symbol sym;
1234
1235   /* A flag indicating that this is a MIPS16 or a microMIPS function
1236      is stored by elfread.c in the high bit of the info field.  Use
1237      this to decide if the function is MIPS16 or microMIPS or normal
1238      MIPS.  Otherwise if bit 0 of the address is set, then ELF file
1239      flags will tell if this is a MIPS16 or a microMIPS function.  */
1240   sym = lookup_minimal_symbol_by_pc (make_compact_addr (memaddr));
1241   if (sym.minsym)
1242     {
1243       if (msymbol_is_micromips (sym.minsym))
1244         return ISA_MICROMIPS;
1245       else if (msymbol_is_mips16 (sym.minsym))
1246         return ISA_MIPS16;
1247       else
1248         return ISA_MIPS;
1249     }
1250   else
1251     {
1252       if (is_mips_addr (memaddr))
1253         return ISA_MIPS;
1254       else if (is_micromips_addr (gdbarch, memaddr))
1255         return ISA_MICROMIPS;
1256       else
1257         return ISA_MIPS16;
1258     }
1259 }
1260
1261 /* Set the ISA bit correctly in the PC, used by DWARF-2 machinery.
1262    The need for comes from the ISA bit having been cleared, making
1263    addresses in FDE, range records, etc. referring to compressed code
1264    different to those in line information, the symbol table and finally
1265    the PC register.  That in turn confuses many operations.  */
1266
1267 static CORE_ADDR
1268 mips_adjust_dwarf2_addr (CORE_ADDR pc)
1269 {
1270   pc = unmake_compact_addr (pc);
1271   return mips_pc_is_mips (pc) ? pc : make_compact_addr (pc);
1272 }
1273
1274 /* Recalculate the line record requested so that the resulting PC has
1275    the ISA bit set correctly, used by DWARF-2 machinery.  The need for
1276    this adjustment comes from some records associated with compressed
1277    code having the ISA bit cleared, most notably at function prologue
1278    ends.  The ISA bit is in this context retrieved from the minimal
1279    symbol covering the address requested, which in turn has been
1280    constructed from the binary's symbol table rather than DWARF-2
1281    information.  The correct setting of the ISA bit is required for
1282    breakpoint addresses to correctly match against the stop PC.
1283
1284    As line entries can specify relative address adjustments we need to
1285    keep track of the absolute value of the last line address recorded
1286    in line information, so that we can calculate the actual address to
1287    apply the ISA bit adjustment to.  We use PC for this tracking and
1288    keep the original address there.
1289
1290    As such relative address adjustments can be odd within compressed
1291    code we need to keep track of the last line address with the ISA
1292    bit adjustment applied too, as the original address may or may not
1293    have had the ISA bit set.  We use ADJ_PC for this tracking and keep
1294    the adjusted address there.
1295
1296    For relative address adjustments we then use these variables to
1297    calculate the address intended by line information, which will be
1298    PC-relative, and return an updated adjustment carrying ISA bit
1299    information, which will be ADJ_PC-relative.  For absolute address
1300    adjustments we just return the same address that we store in ADJ_PC
1301    too.
1302
1303    As the first line entry can be relative to an implied address value
1304    of 0 we need to have the initial address set up that we store in PC
1305    and ADJ_PC.  This is arranged with a call from `dwarf_decode_lines_1'
1306    that sets PC to 0 and ADJ_PC accordingly, usually 0 as well.  */
1307
1308 static CORE_ADDR
1309 mips_adjust_dwarf2_line (CORE_ADDR addr, int rel)
1310 {
1311   static CORE_ADDR adj_pc;
1312   static CORE_ADDR pc;
1313   CORE_ADDR isa_pc;
1314
1315   pc = rel ? pc + addr : addr;
1316   isa_pc = mips_adjust_dwarf2_addr (pc);
1317   addr = rel ? isa_pc - adj_pc : isa_pc;
1318   adj_pc = isa_pc;
1319   return addr;
1320 }
1321
1322 /* Various MIPS16 thunk (aka stub or trampoline) names.  */
1323
1324 static const char mips_str_mips16_call_stub[] = "__mips16_call_stub_";
1325 static const char mips_str_mips16_ret_stub[] = "__mips16_ret_";
1326 static const char mips_str_call_fp_stub[] = "__call_stub_fp_";
1327 static const char mips_str_call_stub[] = "__call_stub_";
1328 static const char mips_str_fn_stub[] = "__fn_stub_";
1329
1330 /* This is used as a PIC thunk prefix.  */
1331
1332 static const char mips_str_pic[] = ".pic.";
1333
1334 /* Return non-zero if the PC is inside a call thunk (aka stub or
1335    trampoline) that should be treated as a temporary frame.  */
1336
1337 static int
1338 mips_in_frame_stub (CORE_ADDR pc)
1339 {
1340   CORE_ADDR start_addr;
1341   const char *name;
1342
1343   /* Find the starting address of the function containing the PC.  */
1344   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
1345     return 0;
1346
1347   /* If the PC is in __mips16_call_stub_*, this is a call/return stub.  */
1348   if (strncmp (name, mips_str_mips16_call_stub,
1349                strlen (mips_str_mips16_call_stub)) == 0)
1350     return 1;
1351   /* If the PC is in __call_stub_*, this is a call/return or a call stub.  */
1352   if (strncmp (name, mips_str_call_stub, strlen (mips_str_call_stub)) == 0)
1353     return 1;
1354   /* If the PC is in __fn_stub_*, this is a call stub.  */
1355   if (strncmp (name, mips_str_fn_stub, strlen (mips_str_fn_stub)) == 0)
1356     return 1;
1357
1358   return 0;                     /* Not a stub.  */
1359 }
1360
1361 /* MIPS believes that the PC has a sign extended value.  Perhaps the
1362    all registers should be sign extended for simplicity?  */
1363
1364 static CORE_ADDR
1365 mips_read_pc (struct regcache *regcache)
1366 {
1367   int regnum = gdbarch_pc_regnum (get_regcache_arch (regcache));
1368   LONGEST pc;
1369
1370   regcache_cooked_read_signed (regcache, regnum, &pc);
1371   return pc;
1372 }
1373
1374 static CORE_ADDR
1375 mips_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1376 {
1377   CORE_ADDR pc;
1378
1379   pc = frame_unwind_register_signed (next_frame, gdbarch_pc_regnum (gdbarch));
1380   /* macro/2012-04-20: This hack skips over MIPS16 call thunks as
1381      intermediate frames.  In this case we can get the caller's address
1382      from $ra, or if $ra contains an address within a thunk as well, then
1383      it must be in the return path of __mips16_call_stub_{s,d}{f,c}_{0..10}
1384      and thus the caller's address is in $s2.  */
1385   if (frame_relative_level (next_frame) >= 0 && mips_in_frame_stub (pc))
1386     {
1387       pc = frame_unwind_register_signed
1388              (next_frame, gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM);
1389       if (mips_in_frame_stub (pc))
1390         pc = frame_unwind_register_signed
1391                (next_frame, gdbarch_num_regs (gdbarch) + MIPS_S2_REGNUM);
1392     }
1393   return pc;
1394 }
1395
1396 static CORE_ADDR
1397 mips_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1398 {
1399   return frame_unwind_register_signed
1400            (next_frame, gdbarch_num_regs (gdbarch) + MIPS_SP_REGNUM);
1401 }
1402
1403 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
1404    dummy frame.  The frame ID's base needs to match the TOS value
1405    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1406    breakpoint.  */
1407
1408 static struct frame_id
1409 mips_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1410 {
1411   return frame_id_build
1412            (get_frame_register_signed (this_frame,
1413                                        gdbarch_num_regs (gdbarch)
1414                                        + MIPS_SP_REGNUM),
1415             get_frame_pc (this_frame));
1416 }
1417
1418 /* Implement the "write_pc" gdbarch method.  */
1419
1420 void
1421 mips_write_pc (struct regcache *regcache, CORE_ADDR pc)
1422 {
1423   int regnum = gdbarch_pc_regnum (get_regcache_arch (regcache));
1424
1425   regcache_cooked_write_unsigned (regcache, regnum, pc);
1426 }
1427
1428 /* Fetch and return instruction from the specified location.  Handle
1429    MIPS16/microMIPS as appropriate.  */
1430
1431 static ULONGEST
1432 mips_fetch_instruction (struct gdbarch *gdbarch,
1433                         enum mips_isa isa, CORE_ADDR addr, int *statusp)
1434 {
1435   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1436   gdb_byte buf[MIPS_INSN32_SIZE];
1437   int instlen;
1438   int status;
1439
1440   switch (isa)
1441     {
1442     case ISA_MICROMIPS:
1443     case ISA_MIPS16:
1444       instlen = MIPS_INSN16_SIZE;
1445       addr = unmake_compact_addr (addr);
1446       break;
1447     case ISA_MIPS:
1448       instlen = MIPS_INSN32_SIZE;
1449       break;
1450     default:
1451       internal_error (__FILE__, __LINE__, _("invalid ISA"));
1452       break;
1453     }
1454   status = target_read_memory (addr, buf, instlen);
1455   if (statusp != NULL)
1456     *statusp = status;
1457   if (status)
1458     {
1459       if (statusp == NULL)
1460         memory_error (status, addr);
1461       return 0;
1462     }
1463   return extract_unsigned_integer (buf, instlen, byte_order);
1464 }
1465
1466 /* These are the fields of 32 bit mips instructions.  */
1467 #define mips32_op(x) (x >> 26)
1468 #define itype_op(x) (x >> 26)
1469 #define itype_rs(x) ((x >> 21) & 0x1f)
1470 #define itype_rt(x) ((x >> 16) & 0x1f)
1471 #define itype_immediate(x) (x & 0xffff)
1472
1473 #define jtype_op(x) (x >> 26)
1474 #define jtype_target(x) (x & 0x03ffffff)
1475
1476 #define rtype_op(x) (x >> 26)
1477 #define rtype_rs(x) ((x >> 21) & 0x1f)
1478 #define rtype_rt(x) ((x >> 16) & 0x1f)
1479 #define rtype_rd(x) ((x >> 11) & 0x1f)
1480 #define rtype_shamt(x) ((x >> 6) & 0x1f)
1481 #define rtype_funct(x) (x & 0x3f)
1482
1483 /* MicroMIPS instruction fields.  */
1484 #define micromips_op(x) ((x) >> 10)
1485
1486 /* 16-bit/32-bit-high-part instruction formats, B and S refer to the lowest
1487    bit and the size respectively of the field extracted.  */
1488 #define b0s4_imm(x) ((x) & 0xf)
1489 #define b0s5_imm(x) ((x) & 0x1f)
1490 #define b0s5_reg(x) ((x) & 0x1f)
1491 #define b0s7_imm(x) ((x) & 0x7f)
1492 #define b0s10_imm(x) ((x) & 0x3ff)
1493 #define b1s4_imm(x) (((x) >> 1) & 0xf)
1494 #define b1s9_imm(x) (((x) >> 1) & 0x1ff)
1495 #define b2s3_cc(x) (((x) >> 2) & 0x7)
1496 #define b4s2_regl(x) (((x) >> 4) & 0x3)
1497 #define b5s5_op(x) (((x) >> 5) & 0x1f)
1498 #define b5s5_reg(x) (((x) >> 5) & 0x1f)
1499 #define b6s4_op(x) (((x) >> 6) & 0xf)
1500 #define b7s3_reg(x) (((x) >> 7) & 0x7)
1501
1502 /* 32-bit instruction formats, B and S refer to the lowest bit and the size
1503    respectively of the field extracted.  */
1504 #define b0s6_op(x) ((x) & 0x3f)
1505 #define b0s11_op(x) ((x) & 0x7ff)
1506 #define b0s12_imm(x) ((x) & 0xfff)
1507 #define b0s16_imm(x) ((x) & 0xffff)
1508 #define b0s26_imm(x) ((x) & 0x3ffffff)
1509 #define b6s10_ext(x) (((x) >> 6) & 0x3ff)
1510 #define b11s5_reg(x) (((x) >> 11) & 0x1f)
1511 #define b12s4_op(x) (((x) >> 12) & 0xf)
1512
1513 /* Return the size in bytes of the instruction INSN encoded in the ISA
1514    instruction set.  */
1515
1516 static int
1517 mips_insn_size (enum mips_isa isa, ULONGEST insn)
1518 {
1519   switch (isa)
1520     {
1521     case ISA_MICROMIPS:
1522       if (micromips_op (insn) == 0x1f)
1523         return 3 * MIPS_INSN16_SIZE;
1524       else if (((micromips_op (insn) & 0x4) == 0x4)
1525                || ((micromips_op (insn) & 0x7) == 0x0))
1526         return 2 * MIPS_INSN16_SIZE;
1527       else
1528         return MIPS_INSN16_SIZE;
1529     case ISA_MIPS16:
1530       if ((insn & 0xf800) == 0xf000)
1531         return 2 * MIPS_INSN16_SIZE;
1532       else
1533         return MIPS_INSN16_SIZE;
1534     case ISA_MIPS:
1535         return MIPS_INSN32_SIZE;
1536     }
1537   internal_error (__FILE__, __LINE__, _("invalid ISA"));
1538 }
1539
1540 static LONGEST
1541 mips32_relative_offset (ULONGEST inst)
1542 {
1543   return ((itype_immediate (inst) ^ 0x8000) - 0x8000) << 2;
1544 }
1545
1546 /* Determine the address of the next instruction executed after the INST
1547    floating condition branch instruction at PC.  COUNT specifies the
1548    number of the floating condition bits tested by the branch.  */
1549
1550 static CORE_ADDR
1551 mips32_bc1_pc (struct gdbarch *gdbarch, struct frame_info *frame,
1552                ULONGEST inst, CORE_ADDR pc, int count)
1553 {
1554   int fcsr = mips_regnum (gdbarch)->fp_control_status;
1555   int cnum = (itype_rt (inst) >> 2) & (count - 1);
1556   int tf = itype_rt (inst) & 1;
1557   int mask = (1 << count) - 1;
1558   ULONGEST fcs;
1559   int cond;
1560
1561   if (fcsr == -1)
1562     /* No way to handle; it'll most likely trap anyway.  */
1563     return pc;
1564
1565   fcs = get_frame_register_unsigned (frame, fcsr);
1566   cond = ((fcs >> 24) & 0xfe) | ((fcs >> 23) & 0x01);
1567
1568   if (((cond >> cnum) & mask) != mask * !tf)
1569     pc += mips32_relative_offset (inst);
1570   else
1571     pc += 4;
1572
1573   return pc;
1574 }
1575
1576 /* Return nonzero if the gdbarch is an Octeon series.  */
1577
1578 static int
1579 is_octeon (struct gdbarch *gdbarch)
1580 {
1581   const struct bfd_arch_info *info = gdbarch_bfd_arch_info (gdbarch);
1582
1583   return (info->mach == bfd_mach_mips_octeon
1584          || info->mach == bfd_mach_mips_octeonp
1585          || info->mach == bfd_mach_mips_octeon2);
1586 }
1587
1588 /* Return true if the OP represents the Octeon's BBIT instruction.  */
1589
1590 static int
1591 is_octeon_bbit_op (int op, struct gdbarch *gdbarch)
1592 {
1593   if (!is_octeon (gdbarch))
1594     return 0;
1595   /* BBIT0 is encoded as LWC2: 110 010.  */
1596   /* BBIT032 is encoded as LDC2: 110 110.  */
1597   /* BBIT1 is encoded as SWC2: 111 010.  */
1598   /* BBIT132 is encoded as SDC2: 111 110.  */
1599   if (op == 50 || op == 54 || op == 58 || op == 62)
1600     return 1;
1601   return 0;
1602 }
1603
1604
1605 /* Determine where to set a single step breakpoint while considering
1606    branch prediction.  */
1607
1608 static CORE_ADDR
1609 mips32_next_pc (struct frame_info *frame, CORE_ADDR pc)
1610 {
1611   struct gdbarch *gdbarch = get_frame_arch (frame);
1612   unsigned long inst;
1613   int op;
1614   inst = mips_fetch_instruction (gdbarch, ISA_MIPS, pc, NULL);
1615   op = itype_op (inst);
1616   if ((inst & 0xe0000000) != 0)         /* Not a special, jump or branch
1617                                            instruction.  */
1618     {
1619       if (op >> 2 == 5)
1620         /* BEQL, BNEL, BLEZL, BGTZL: bits 0101xx */
1621         {
1622           switch (op & 0x03)
1623             {
1624             case 0:             /* BEQL */
1625               goto equal_branch;
1626             case 1:             /* BNEL */
1627               goto neq_branch;
1628             case 2:             /* BLEZL */
1629               goto less_branch;
1630             case 3:             /* BGTZL */
1631               goto greater_branch;
1632             default:
1633               pc += 4;
1634             }
1635         }
1636       else if (op == 17 && itype_rs (inst) == 8)
1637         /* BC1F, BC1FL, BC1T, BC1TL: 010001 01000 */
1638         pc = mips32_bc1_pc (gdbarch, frame, inst, pc + 4, 1);
1639       else if (op == 17 && itype_rs (inst) == 9
1640                && (itype_rt (inst) & 2) == 0)
1641         /* BC1ANY2F, BC1ANY2T: 010001 01001 xxx0x */
1642         pc = mips32_bc1_pc (gdbarch, frame, inst, pc + 4, 2);
1643       else if (op == 17 && itype_rs (inst) == 10
1644                && (itype_rt (inst) & 2) == 0)
1645         /* BC1ANY4F, BC1ANY4T: 010001 01010 xxx0x */
1646         pc = mips32_bc1_pc (gdbarch, frame, inst, pc + 4, 4);
1647       else if (op == 29)
1648         /* JALX: 011101 */
1649         /* The new PC will be alternate mode.  */
1650         {
1651           unsigned long reg;
1652
1653           reg = jtype_target (inst) << 2;
1654           /* Add 1 to indicate 16-bit mode -- invert ISA mode.  */
1655           pc = ((pc + 4) & ~(CORE_ADDR) 0x0fffffff) + reg + 1;
1656         }
1657       else if (is_octeon_bbit_op (op, gdbarch))
1658         {
1659           int bit, branch_if;
1660
1661           branch_if = op == 58 || op == 62;
1662           bit = itype_rt (inst);
1663
1664           /* Take into account the *32 instructions.  */
1665           if (op == 54 || op == 62)
1666             bit += 32;
1667
1668           if (((get_frame_register_signed (frame,
1669                                            itype_rs (inst)) >> bit) & 1)
1670               == branch_if)
1671             pc += mips32_relative_offset (inst) + 4;
1672           else
1673             pc += 8;        /* After the delay slot.  */
1674         }
1675
1676       else
1677         pc += 4;                /* Not a branch, next instruction is easy.  */
1678     }
1679   else
1680     {                           /* This gets way messy.  */
1681
1682       /* Further subdivide into SPECIAL, REGIMM and other.  */
1683       switch (op & 0x07)        /* Extract bits 28,27,26.  */
1684         {
1685         case 0:         /* SPECIAL */
1686           op = rtype_funct (inst);
1687           switch (op)
1688             {
1689             case 8:             /* JR */
1690             case 9:             /* JALR */
1691               /* Set PC to that address.  */
1692               pc = get_frame_register_signed (frame, rtype_rs (inst));
1693               break;
1694             case 12:            /* SYSCALL */
1695               {
1696                 struct gdbarch_tdep *tdep;
1697
1698                 tdep = gdbarch_tdep (get_frame_arch (frame));
1699                 if (tdep->syscall_next_pc != NULL)
1700                   pc = tdep->syscall_next_pc (frame);
1701                 else
1702                   pc += 4;
1703               }
1704               break;
1705             default:
1706               pc += 4;
1707             }
1708
1709           break;                /* end SPECIAL */
1710         case 1:                 /* REGIMM */
1711           {
1712             op = itype_rt (inst);       /* branch condition */
1713             switch (op)
1714               {
1715               case 0:           /* BLTZ */
1716               case 2:           /* BLTZL */
1717               case 16:          /* BLTZAL */
1718               case 18:          /* BLTZALL */
1719               less_branch:
1720                 if (get_frame_register_signed (frame, itype_rs (inst)) < 0)
1721                   pc += mips32_relative_offset (inst) + 4;
1722                 else
1723                   pc += 8;      /* after the delay slot */
1724                 break;
1725               case 1:           /* BGEZ */
1726               case 3:           /* BGEZL */
1727               case 17:          /* BGEZAL */
1728               case 19:          /* BGEZALL */
1729                 if (get_frame_register_signed (frame, itype_rs (inst)) >= 0)
1730                   pc += mips32_relative_offset (inst) + 4;
1731                 else
1732                   pc += 8;      /* after the delay slot */
1733                 break;
1734               case 0x1c:        /* BPOSGE32 */
1735               case 0x1e:        /* BPOSGE64 */
1736                 pc += 4;
1737                 if (itype_rs (inst) == 0)
1738                   {
1739                     unsigned int pos = (op & 2) ? 64 : 32;
1740                     int dspctl = mips_regnum (gdbarch)->dspctl;
1741
1742                     if (dspctl == -1)
1743                       /* No way to handle; it'll most likely trap anyway.  */
1744                       break;
1745
1746                     if ((get_frame_register_unsigned (frame,
1747                                                       dspctl) & 0x7f) >= pos)
1748                       pc += mips32_relative_offset (inst);
1749                     else
1750                       pc += 4;
1751                   }
1752                 break;
1753                 /* All of the other instructions in the REGIMM category */
1754               default:
1755                 pc += 4;
1756               }
1757           }
1758           break;                /* end REGIMM */
1759         case 2:         /* J */
1760         case 3:         /* JAL */
1761           {
1762             unsigned long reg;
1763             reg = jtype_target (inst) << 2;
1764             /* Upper four bits get never changed...  */
1765             pc = reg + ((pc + 4) & ~(CORE_ADDR) 0x0fffffff);
1766           }
1767           break;
1768         case 4:         /* BEQ, BEQL */
1769         equal_branch:
1770           if (get_frame_register_signed (frame, itype_rs (inst)) ==
1771               get_frame_register_signed (frame, itype_rt (inst)))
1772             pc += mips32_relative_offset (inst) + 4;
1773           else
1774             pc += 8;
1775           break;
1776         case 5:         /* BNE, BNEL */
1777         neq_branch:
1778           if (get_frame_register_signed (frame, itype_rs (inst)) !=
1779               get_frame_register_signed (frame, itype_rt (inst)))
1780             pc += mips32_relative_offset (inst) + 4;
1781           else
1782             pc += 8;
1783           break;
1784         case 6:         /* BLEZ, BLEZL */
1785           if (get_frame_register_signed (frame, itype_rs (inst)) <= 0)
1786             pc += mips32_relative_offset (inst) + 4;
1787           else
1788             pc += 8;
1789           break;
1790         case 7:
1791         default:
1792         greater_branch: /* BGTZ, BGTZL */
1793           if (get_frame_register_signed (frame, itype_rs (inst)) > 0)
1794             pc += mips32_relative_offset (inst) + 4;
1795           else
1796             pc += 8;
1797           break;
1798         }                       /* switch */
1799     }                           /* else */
1800   return pc;
1801 }                               /* mips32_next_pc */
1802
1803 /* Extract the 7-bit signed immediate offset from the microMIPS instruction
1804    INSN.  */
1805
1806 static LONGEST
1807 micromips_relative_offset7 (ULONGEST insn)
1808 {
1809   return ((b0s7_imm (insn) ^ 0x40) - 0x40) << 1;
1810 }
1811
1812 /* Extract the 10-bit signed immediate offset from the microMIPS instruction
1813    INSN.  */
1814
1815 static LONGEST
1816 micromips_relative_offset10 (ULONGEST insn)
1817 {
1818   return ((b0s10_imm (insn) ^ 0x200) - 0x200) << 1;
1819 }
1820
1821 /* Extract the 16-bit signed immediate offset from the microMIPS instruction
1822    INSN.  */
1823
1824 static LONGEST
1825 micromips_relative_offset16 (ULONGEST insn)
1826 {
1827   return ((b0s16_imm (insn) ^ 0x8000) - 0x8000) << 1;
1828 }
1829
1830 /* Return the size in bytes of the microMIPS instruction at the address PC.  */
1831
1832 static int
1833 micromips_pc_insn_size (struct gdbarch *gdbarch, CORE_ADDR pc)
1834 {
1835   ULONGEST insn;
1836
1837   insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, NULL);
1838   return mips_insn_size (ISA_MICROMIPS, insn);
1839 }
1840
1841 /* Calculate the address of the next microMIPS instruction to execute
1842    after the INSN coprocessor 1 conditional branch instruction at the
1843    address PC.  COUNT denotes the number of coprocessor condition bits
1844    examined by the branch.  */
1845
1846 static CORE_ADDR
1847 micromips_bc1_pc (struct gdbarch *gdbarch, struct frame_info *frame,
1848                   ULONGEST insn, CORE_ADDR pc, int count)
1849 {
1850   int fcsr = mips_regnum (gdbarch)->fp_control_status;
1851   int cnum = b2s3_cc (insn >> 16) & (count - 1);
1852   int tf = b5s5_op (insn >> 16) & 1;
1853   int mask = (1 << count) - 1;
1854   ULONGEST fcs;
1855   int cond;
1856
1857   if (fcsr == -1)
1858     /* No way to handle; it'll most likely trap anyway.  */
1859     return pc;
1860
1861   fcs = get_frame_register_unsigned (frame, fcsr);
1862   cond = ((fcs >> 24) & 0xfe) | ((fcs >> 23) & 0x01);
1863
1864   if (((cond >> cnum) & mask) != mask * !tf)
1865     pc += micromips_relative_offset16 (insn);
1866   else
1867     pc += micromips_pc_insn_size (gdbarch, pc);
1868
1869   return pc;
1870 }
1871
1872 /* Calculate the address of the next microMIPS instruction to execute
1873    after the instruction at the address PC.  */
1874
1875 static CORE_ADDR
1876 micromips_next_pc (struct frame_info *frame, CORE_ADDR pc)
1877 {
1878   struct gdbarch *gdbarch = get_frame_arch (frame);
1879   ULONGEST insn;
1880
1881   insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, NULL);
1882   pc += MIPS_INSN16_SIZE;
1883   switch (mips_insn_size (ISA_MICROMIPS, insn))
1884     {
1885     /* 48-bit instructions.  */
1886     case 3 * MIPS_INSN16_SIZE: /* POOL48A: bits 011111 */
1887       /* No branch or jump instructions in this category.  */
1888       pc += 2 * MIPS_INSN16_SIZE;
1889       break;
1890
1891     /* 32-bit instructions.  */
1892     case 2 * MIPS_INSN16_SIZE:
1893       insn <<= 16;
1894       insn |= mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, NULL);
1895       pc += MIPS_INSN16_SIZE;
1896       switch (micromips_op (insn >> 16))
1897         {
1898         case 0x00: /* POOL32A: bits 000000 */
1899           if (b0s6_op (insn) == 0x3c
1900                                 /* POOL32Axf: bits 000000 ... 111100 */
1901               && (b6s10_ext (insn) & 0x2bf) == 0x3c)
1902                                 /* JALR, JALR.HB: 000000 000x111100 111100 */
1903                                 /* JALRS, JALRS.HB: 000000 010x111100 111100 */
1904             pc = get_frame_register_signed (frame, b0s5_reg (insn >> 16));
1905           break;
1906
1907         case 0x10: /* POOL32I: bits 010000 */
1908           switch (b5s5_op (insn >> 16))
1909             {
1910             case 0x00: /* BLTZ: bits 010000 00000 */
1911             case 0x01: /* BLTZAL: bits 010000 00001 */
1912             case 0x11: /* BLTZALS: bits 010000 10001 */
1913               if (get_frame_register_signed (frame,
1914                                              b0s5_reg (insn >> 16)) < 0)
1915                 pc += micromips_relative_offset16 (insn);
1916               else
1917                 pc += micromips_pc_insn_size (gdbarch, pc);
1918               break;
1919
1920             case 0x02: /* BGEZ: bits 010000 00010 */
1921             case 0x03: /* BGEZAL: bits 010000 00011 */
1922             case 0x13: /* BGEZALS: bits 010000 10011 */
1923               if (get_frame_register_signed (frame,
1924                                              b0s5_reg (insn >> 16)) >= 0)
1925                 pc += micromips_relative_offset16 (insn);
1926               else
1927                 pc += micromips_pc_insn_size (gdbarch, pc);
1928               break;
1929
1930             case 0x04: /* BLEZ: bits 010000 00100 */
1931               if (get_frame_register_signed (frame,
1932                                              b0s5_reg (insn >> 16)) <= 0)
1933                 pc += micromips_relative_offset16 (insn);
1934               else
1935                 pc += micromips_pc_insn_size (gdbarch, pc);
1936               break;
1937
1938             case 0x05: /* BNEZC: bits 010000 00101 */
1939               if (get_frame_register_signed (frame,
1940                                              b0s5_reg (insn >> 16)) != 0)
1941                 pc += micromips_relative_offset16 (insn);
1942               break;
1943
1944             case 0x06: /* BGTZ: bits 010000 00110 */
1945               if (get_frame_register_signed (frame,
1946                                              b0s5_reg (insn >> 16)) > 0)
1947                 pc += micromips_relative_offset16 (insn);
1948               else
1949                 pc += micromips_pc_insn_size (gdbarch, pc);
1950               break;
1951
1952             case 0x07: /* BEQZC: bits 010000 00111 */
1953               if (get_frame_register_signed (frame,
1954                                              b0s5_reg (insn >> 16)) == 0)
1955                 pc += micromips_relative_offset16 (insn);
1956               break;
1957
1958             case 0x14: /* BC2F: bits 010000 10100 xxx00 */
1959             case 0x15: /* BC2T: bits 010000 10101 xxx00 */
1960               if (((insn >> 16) & 0x3) == 0x0)
1961                 /* BC2F, BC2T: don't know how to handle these.  */
1962                 break;
1963               break;
1964
1965             case 0x1a: /* BPOSGE64: bits 010000 11010 */
1966             case 0x1b: /* BPOSGE32: bits 010000 11011 */
1967               {
1968                 unsigned int pos = (b5s5_op (insn >> 16) & 1) ? 32 : 64;
1969                 int dspctl = mips_regnum (gdbarch)->dspctl;
1970
1971                 if (dspctl == -1)
1972                   /* No way to handle; it'll most likely trap anyway.  */
1973                   break;
1974
1975                 if ((get_frame_register_unsigned (frame,
1976                                                   dspctl) & 0x7f) >= pos)
1977                   pc += micromips_relative_offset16 (insn);
1978                 else
1979                   pc += micromips_pc_insn_size (gdbarch, pc);
1980               }
1981               break;
1982
1983             case 0x1c: /* BC1F: bits 010000 11100 xxx00 */
1984                        /* BC1ANY2F: bits 010000 11100 xxx01 */
1985             case 0x1d: /* BC1T: bits 010000 11101 xxx00 */
1986                        /* BC1ANY2T: bits 010000 11101 xxx01 */
1987               if (((insn >> 16) & 0x2) == 0x0)
1988                 pc = micromips_bc1_pc (gdbarch, frame, insn, pc,
1989                                        ((insn >> 16) & 0x1) + 1);
1990               break;
1991
1992             case 0x1e: /* BC1ANY4F: bits 010000 11110 xxx01 */
1993             case 0x1f: /* BC1ANY4T: bits 010000 11111 xxx01 */
1994               if (((insn >> 16) & 0x3) == 0x1)
1995                 pc = micromips_bc1_pc (gdbarch, frame, insn, pc, 4);
1996               break;
1997             }
1998           break;
1999
2000         case 0x1d: /* JALS: bits 011101 */
2001         case 0x35: /* J: bits 110101 */
2002         case 0x3d: /* JAL: bits 111101 */
2003             pc = ((pc | 0x7fffffe) ^ 0x7fffffe) | (b0s26_imm (insn) << 1);
2004           break;
2005
2006         case 0x25: /* BEQ: bits 100101 */
2007             if (get_frame_register_signed (frame, b0s5_reg (insn >> 16))
2008                 == get_frame_register_signed (frame, b5s5_reg (insn >> 16)))
2009               pc += micromips_relative_offset16 (insn);
2010             else
2011               pc += micromips_pc_insn_size (gdbarch, pc);
2012           break;
2013
2014         case 0x2d: /* BNE: bits 101101 */
2015             if (get_frame_register_signed (frame, b0s5_reg (insn >> 16))
2016                 != get_frame_register_signed (frame, b5s5_reg (insn >> 16)))
2017               pc += micromips_relative_offset16 (insn);
2018             else
2019               pc += micromips_pc_insn_size (gdbarch, pc);
2020           break;
2021
2022         case 0x3c: /* JALX: bits 111100 */
2023             pc = ((pc | 0xfffffff) ^ 0xfffffff) | (b0s26_imm (insn) << 2);
2024           break;
2025         }
2026       break;
2027
2028     /* 16-bit instructions.  */
2029     case MIPS_INSN16_SIZE:
2030       switch (micromips_op (insn))
2031         {
2032         case 0x11: /* POOL16C: bits 010001 */
2033           if ((b5s5_op (insn) & 0x1c) == 0xc)
2034             /* JR16, JRC, JALR16, JALRS16: 010001 011xx */
2035             pc = get_frame_register_signed (frame, b0s5_reg (insn));
2036           else if (b5s5_op (insn) == 0x18)
2037             /* JRADDIUSP: bits 010001 11000 */
2038             pc = get_frame_register_signed (frame, MIPS_RA_REGNUM);
2039           break;
2040
2041         case 0x23: /* BEQZ16: bits 100011 */
2042           {
2043             int rs = mips_reg3_to_reg[b7s3_reg (insn)];
2044
2045             if (get_frame_register_signed (frame, rs) == 0)
2046               pc += micromips_relative_offset7 (insn);
2047             else
2048               pc += micromips_pc_insn_size (gdbarch, pc);
2049           }
2050           break;
2051
2052         case 0x2b: /* BNEZ16: bits 101011 */
2053           {
2054             int rs = mips_reg3_to_reg[b7s3_reg (insn)];
2055
2056             if (get_frame_register_signed (frame, rs) != 0)
2057               pc += micromips_relative_offset7 (insn);
2058             else
2059               pc += micromips_pc_insn_size (gdbarch, pc);
2060           }
2061           break;
2062
2063         case 0x33: /* B16: bits 110011 */
2064           pc += micromips_relative_offset10 (insn);
2065           break;
2066         }
2067       break;
2068     }
2069
2070   return pc;
2071 }
2072
2073 /* Decoding the next place to set a breakpoint is irregular for the
2074    mips 16 variant, but fortunately, there fewer instructions.  We have
2075    to cope ith extensions for 16 bit instructions and a pair of actual
2076    32 bit instructions.  We dont want to set a single step instruction
2077    on the extend instruction either.  */
2078
2079 /* Lots of mips16 instruction formats */
2080 /* Predicting jumps requires itype,ritype,i8type
2081    and their extensions      extItype,extritype,extI8type.  */
2082 enum mips16_inst_fmts
2083 {
2084   itype,                        /* 0  immediate 5,10 */
2085   ritype,                       /* 1   5,3,8 */
2086   rrtype,                       /* 2   5,3,3,5 */
2087   rritype,                      /* 3   5,3,3,5 */
2088   rrrtype,                      /* 4   5,3,3,3,2 */
2089   rriatype,                     /* 5   5,3,3,1,4 */
2090   shifttype,                    /* 6   5,3,3,3,2 */
2091   i8type,                       /* 7   5,3,8 */
2092   i8movtype,                    /* 8   5,3,3,5 */
2093   i8mov32rtype,                 /* 9   5,3,5,3 */
2094   i64type,                      /* 10  5,3,8 */
2095   ri64type,                     /* 11  5,3,3,5 */
2096   jalxtype,                     /* 12  5,1,5,5,16 - a 32 bit instruction */
2097   exiItype,                     /* 13  5,6,5,5,1,1,1,1,1,1,5 */
2098   extRitype,                    /* 14  5,6,5,5,3,1,1,1,5 */
2099   extRRItype,                   /* 15  5,5,5,5,3,3,5 */
2100   extRRIAtype,                  /* 16  5,7,4,5,3,3,1,4 */
2101   EXTshifttype,                 /* 17  5,5,1,1,1,1,1,1,5,3,3,1,1,1,2 */
2102   extI8type,                    /* 18  5,6,5,5,3,1,1,1,5 */
2103   extI64type,                   /* 19  5,6,5,5,3,1,1,1,5 */
2104   extRi64type,                  /* 20  5,6,5,5,3,3,5 */
2105   extshift64type                /* 21  5,5,1,1,1,1,1,1,5,1,1,1,3,5 */
2106 };
2107 /* I am heaping all the fields of the formats into one structure and
2108    then, only the fields which are involved in instruction extension.  */
2109 struct upk_mips16
2110 {
2111   CORE_ADDR offset;
2112   unsigned int regx;            /* Function in i8 type.  */
2113   unsigned int regy;
2114 };
2115
2116
2117 /* The EXT-I, EXT-ri nad EXT-I8 instructions all have the same format
2118    for the bits which make up the immediate extension.  */
2119
2120 static CORE_ADDR
2121 extended_offset (unsigned int extension)
2122 {
2123   CORE_ADDR value;
2124
2125   value = (extension >> 16) & 0x1f;     /* Extract 15:11.  */
2126   value = value << 6;
2127   value |= (extension >> 21) & 0x3f;    /* Extract 10:5.  */
2128   value = value << 5;
2129   value |= extension & 0x1f;            /* Extract 4:0.  */
2130
2131   return value;
2132 }
2133
2134 /* Only call this function if you know that this is an extendable
2135    instruction.  It won't malfunction, but why make excess remote memory
2136    references?  If the immediate operands get sign extended or something,
2137    do it after the extension is performed.  */
2138 /* FIXME: Every one of these cases needs to worry about sign extension
2139    when the offset is to be used in relative addressing.  */
2140
2141 static unsigned int
2142 fetch_mips_16 (struct gdbarch *gdbarch, CORE_ADDR pc)
2143 {
2144   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2145   gdb_byte buf[8];
2146
2147   pc = unmake_compact_addr (pc);        /* Clear the low order bit.  */
2148   target_read_memory (pc, buf, 2);
2149   return extract_unsigned_integer (buf, 2, byte_order);
2150 }
2151
2152 static void
2153 unpack_mips16 (struct gdbarch *gdbarch, CORE_ADDR pc,
2154                unsigned int extension,
2155                unsigned int inst,
2156                enum mips16_inst_fmts insn_format, struct upk_mips16 *upk)
2157 {
2158   CORE_ADDR offset;
2159   int regx;
2160   int regy;
2161   switch (insn_format)
2162     {
2163     case itype:
2164       {
2165         CORE_ADDR value;
2166         if (extension)
2167           {
2168             value = extended_offset ((extension << 16) | inst);
2169             value = (value ^ 0x8000) - 0x8000;          /* Sign-extend.  */
2170           }
2171         else
2172           {
2173             value = inst & 0x7ff;
2174             value = (value ^ 0x400) - 0x400;            /* Sign-extend.  */
2175           }
2176         offset = value;
2177         regx = -1;
2178         regy = -1;
2179       }
2180       break;
2181     case ritype:
2182     case i8type:
2183       {                         /* A register identifier and an offset.  */
2184         /* Most of the fields are the same as I type but the
2185            immediate value is of a different length.  */
2186         CORE_ADDR value;
2187         if (extension)
2188           {
2189             value = extended_offset ((extension << 16) | inst);
2190             value = (value ^ 0x8000) - 0x8000;          /* Sign-extend.  */
2191           }
2192         else
2193           {
2194             value = inst & 0xff;                        /* 8 bits */
2195             value = (value ^ 0x80) - 0x80;              /* Sign-extend.  */
2196           }
2197         offset = value;
2198         regx = (inst >> 8) & 0x07;                      /* i8 funct */
2199         regy = -1;
2200         break;
2201       }
2202     case jalxtype:
2203       {
2204         unsigned long value;
2205         unsigned int nexthalf;
2206         value = ((inst & 0x1f) << 5) | ((inst >> 5) & 0x1f);
2207         value = value << 16;
2208         nexthalf = mips_fetch_instruction (gdbarch, ISA_MIPS16, pc + 2, NULL);
2209                                                 /* Low bit still set.  */
2210         value |= nexthalf;
2211         offset = value;
2212         regx = -1;
2213         regy = -1;
2214         break;
2215       }
2216     default:
2217       internal_error (__FILE__, __LINE__, _("bad switch"));
2218     }
2219   upk->offset = offset;
2220   upk->regx = regx;
2221   upk->regy = regy;
2222 }
2223
2224
2225 /* Calculate the destination of a branch whose 16-bit opcode word is at PC,
2226    and having a signed 16-bit OFFSET.  */
2227
2228 static CORE_ADDR
2229 add_offset_16 (CORE_ADDR pc, int offset)
2230 {
2231   return pc + (offset << 1) + 2;
2232 }
2233
2234 static CORE_ADDR
2235 extended_mips16_next_pc (struct frame_info *frame, CORE_ADDR pc,
2236                          unsigned int extension, unsigned int insn)
2237 {
2238   struct gdbarch *gdbarch = get_frame_arch (frame);
2239   int op = (insn >> 11);
2240   switch (op)
2241     {
2242     case 2:                     /* Branch */
2243       {
2244         struct upk_mips16 upk;
2245         unpack_mips16 (gdbarch, pc, extension, insn, itype, &upk);
2246         pc = add_offset_16 (pc, upk.offset);
2247         break;
2248       }
2249     case 3:                     /* JAL , JALX - Watch out, these are 32 bit
2250                                    instructions.  */
2251       {
2252         struct upk_mips16 upk;
2253         unpack_mips16 (gdbarch, pc, extension, insn, jalxtype, &upk);
2254         pc = ((pc + 2) & (~(CORE_ADDR) 0x0fffffff)) | (upk.offset << 2);
2255         if ((insn >> 10) & 0x01)        /* Exchange mode */
2256           pc = pc & ~0x01;      /* Clear low bit, indicate 32 bit mode.  */
2257         else
2258           pc |= 0x01;
2259         break;
2260       }
2261     case 4:                     /* beqz */
2262       {
2263         struct upk_mips16 upk;
2264         int reg;
2265         unpack_mips16 (gdbarch, pc, extension, insn, ritype, &upk);
2266         reg = get_frame_register_signed (frame, mips_reg3_to_reg[upk.regx]);
2267         if (reg == 0)
2268           pc = add_offset_16 (pc, upk.offset);
2269         else
2270           pc += 2;
2271         break;
2272       }
2273     case 5:                     /* bnez */
2274       {
2275         struct upk_mips16 upk;
2276         int reg;
2277         unpack_mips16 (gdbarch, pc, extension, insn, ritype, &upk);
2278         reg = get_frame_register_signed (frame, mips_reg3_to_reg[upk.regx]);
2279         if (reg != 0)
2280           pc = add_offset_16 (pc, upk.offset);
2281         else
2282           pc += 2;
2283         break;
2284       }
2285     case 12:                    /* I8 Formats btez btnez */
2286       {
2287         struct upk_mips16 upk;
2288         int reg;
2289         unpack_mips16 (gdbarch, pc, extension, insn, i8type, &upk);
2290         /* upk.regx contains the opcode */
2291         reg = get_frame_register_signed (frame, 24);  /* Test register is 24 */
2292         if (((upk.regx == 0) && (reg == 0))     /* BTEZ */
2293             || ((upk.regx == 1) && (reg != 0))) /* BTNEZ */
2294           pc = add_offset_16 (pc, upk.offset);
2295         else
2296           pc += 2;
2297         break;
2298       }
2299     case 29:                    /* RR Formats JR, JALR, JALR-RA */
2300       {
2301         struct upk_mips16 upk;
2302         /* upk.fmt = rrtype; */
2303         op = insn & 0x1f;
2304         if (op == 0)
2305           {
2306             int reg;
2307             upk.regx = (insn >> 8) & 0x07;
2308             upk.regy = (insn >> 5) & 0x07;
2309             if ((upk.regy & 1) == 0)
2310               reg = mips_reg3_to_reg[upk.regx];
2311             else
2312               reg = 31;         /* Function return instruction.  */
2313             pc = get_frame_register_signed (frame, reg);
2314           }
2315         else
2316           pc += 2;
2317         break;
2318       }
2319     case 30:
2320       /* This is an instruction extension.  Fetch the real instruction
2321          (which follows the extension) and decode things based on
2322          that.  */
2323       {
2324         pc += 2;
2325         pc = extended_mips16_next_pc (frame, pc, insn,
2326                                       fetch_mips_16 (gdbarch, pc));
2327         break;
2328       }
2329     default:
2330       {
2331         pc += 2;
2332         break;
2333       }
2334     }
2335   return pc;
2336 }
2337
2338 static CORE_ADDR
2339 mips16_next_pc (struct frame_info *frame, CORE_ADDR pc)
2340 {
2341   struct gdbarch *gdbarch = get_frame_arch (frame);
2342   unsigned int insn = fetch_mips_16 (gdbarch, pc);
2343   return extended_mips16_next_pc (frame, pc, 0, insn);
2344 }
2345
2346 /* The mips_next_pc function supports single_step when the remote
2347    target monitor or stub is not developed enough to do a single_step.
2348    It works by decoding the current instruction and predicting where a
2349    branch will go.  This isn't hard because all the data is available.
2350    The MIPS32, MIPS16 and microMIPS variants are quite different.  */
2351 static CORE_ADDR
2352 mips_next_pc (struct frame_info *frame, CORE_ADDR pc)
2353 {
2354   struct gdbarch *gdbarch = get_frame_arch (frame);
2355
2356   if (mips_pc_is_mips16 (gdbarch, pc))
2357     return mips16_next_pc (frame, pc);
2358   else if (mips_pc_is_micromips (gdbarch, pc))
2359     return micromips_next_pc (frame, pc);
2360   else
2361     return mips32_next_pc (frame, pc);
2362 }
2363
2364 /* Return non-zero if the MIPS16 instruction INSN is a compact branch
2365    or jump.  */
2366
2367 static int
2368 mips16_instruction_is_compact_branch (unsigned short insn)
2369 {
2370   switch (insn & 0xf800)
2371     {
2372     case 0xe800:
2373       return (insn & 0x009f) == 0x80;   /* JALRC/JRC */
2374     case 0x6000:
2375       return (insn & 0x0600) == 0;      /* BTNEZ/BTEQZ */
2376     case 0x2800:                        /* BNEZ */
2377     case 0x2000:                        /* BEQZ */
2378     case 0x1000:                        /* B */
2379       return 1;
2380     default:
2381       return 0;
2382     }
2383 }
2384
2385 /* Return non-zero if the microMIPS instruction INSN is a compact branch
2386    or jump.  */
2387
2388 static int
2389 micromips_instruction_is_compact_branch (unsigned short insn)
2390 {
2391   switch (micromips_op (insn))
2392     {
2393     case 0x11:                  /* POOL16C: bits 010001 */
2394       return (b5s5_op (insn) == 0x18
2395                                 /* JRADDIUSP: bits 010001 11000 */
2396               || b5s5_op (insn) == 0xd);
2397                                 /* JRC: bits 010011 01101 */
2398     case 0x10:                  /* POOL32I: bits 010000 */
2399       return (b5s5_op (insn) & 0x1d) == 0x5;
2400                                 /* BEQZC/BNEZC: bits 010000 001x1 */
2401     default:
2402       return 0;
2403     }
2404 }
2405
2406 struct mips_frame_cache
2407 {
2408   CORE_ADDR base;
2409   struct trad_frame_saved_reg *saved_regs;
2410 };
2411
2412 /* Set a register's saved stack address in temp_saved_regs.  If an
2413    address has already been set for this register, do nothing; this
2414    way we will only recognize the first save of a given register in a
2415    function prologue.
2416
2417    For simplicity, save the address in both [0 .. gdbarch_num_regs) and
2418    [gdbarch_num_regs .. 2*gdbarch_num_regs).
2419    Strictly speaking, only the second range is used as it is only second
2420    range (the ABI instead of ISA registers) that comes into play when finding
2421    saved registers in a frame.  */
2422
2423 static void
2424 set_reg_offset (struct gdbarch *gdbarch, struct mips_frame_cache *this_cache,
2425                 int regnum, CORE_ADDR offset)
2426 {
2427   if (this_cache != NULL
2428       && this_cache->saved_regs[regnum].addr == -1)
2429     {
2430       this_cache->saved_regs[regnum + 0 * gdbarch_num_regs (gdbarch)].addr
2431         = offset;
2432       this_cache->saved_regs[regnum + 1 * gdbarch_num_regs (gdbarch)].addr
2433         = offset;
2434     }
2435 }
2436
2437
2438 /* Fetch the immediate value from a MIPS16 instruction.
2439    If the previous instruction was an EXTEND, use it to extend
2440    the upper bits of the immediate value.  This is a helper function
2441    for mips16_scan_prologue.  */
2442
2443 static int
2444 mips16_get_imm (unsigned short prev_inst,       /* previous instruction */
2445                 unsigned short inst,    /* current instruction */
2446                 int nbits,      /* number of bits in imm field */
2447                 int scale,      /* scale factor to be applied to imm */
2448                 int is_signed)  /* is the imm field signed?  */
2449 {
2450   int offset;
2451
2452   if ((prev_inst & 0xf800) == 0xf000)   /* prev instruction was EXTEND? */
2453     {
2454       offset = ((prev_inst & 0x1f) << 11) | (prev_inst & 0x7e0);
2455       if (offset & 0x8000)      /* check for negative extend */
2456         offset = 0 - (0x10000 - (offset & 0xffff));
2457       return offset | (inst & 0x1f);
2458     }
2459   else
2460     {
2461       int max_imm = 1 << nbits;
2462       int mask = max_imm - 1;
2463       int sign_bit = max_imm >> 1;
2464
2465       offset = inst & mask;
2466       if (is_signed && (offset & sign_bit))
2467         offset = 0 - (max_imm - offset);
2468       return offset * scale;
2469     }
2470 }
2471
2472
2473 /* Analyze the function prologue from START_PC to LIMIT_PC. Builds
2474    the associated FRAME_CACHE if not null.
2475    Return the address of the first instruction past the prologue.  */
2476
2477 static CORE_ADDR
2478 mips16_scan_prologue (struct gdbarch *gdbarch,
2479                       CORE_ADDR start_pc, CORE_ADDR limit_pc,
2480                       struct frame_info *this_frame,
2481                       struct mips_frame_cache *this_cache)
2482 {
2483   int prev_non_prologue_insn = 0;
2484   int this_non_prologue_insn;
2485   int non_prologue_insns = 0;
2486   CORE_ADDR prev_pc;
2487   CORE_ADDR cur_pc;
2488   CORE_ADDR frame_addr = 0;     /* Value of $r17, used as frame pointer.  */
2489   CORE_ADDR sp;
2490   long frame_offset = 0;        /* Size of stack frame.  */
2491   long frame_adjust = 0;        /* Offset of FP from SP.  */
2492   int frame_reg = MIPS_SP_REGNUM;
2493   unsigned short prev_inst = 0; /* saved copy of previous instruction.  */
2494   unsigned inst = 0;            /* current instruction */
2495   unsigned entry_inst = 0;      /* the entry instruction */
2496   unsigned save_inst = 0;       /* the save instruction */
2497   int prev_delay_slot = 0;
2498   int in_delay_slot;
2499   int reg, offset;
2500
2501   int extend_bytes = 0;
2502   int prev_extend_bytes = 0;
2503   CORE_ADDR end_prologue_addr;
2504
2505   /* Can be called when there's no process, and hence when there's no
2506      THIS_FRAME.  */
2507   if (this_frame != NULL)
2508     sp = get_frame_register_signed (this_frame,
2509                                     gdbarch_num_regs (gdbarch)
2510                                     + MIPS_SP_REGNUM);
2511   else
2512     sp = 0;
2513
2514   if (limit_pc > start_pc + 200)
2515     limit_pc = start_pc + 200;
2516   prev_pc = start_pc;
2517
2518   /* Permit at most one non-prologue non-control-transfer instruction
2519      in the middle which may have been reordered by the compiler for
2520      optimisation.  */
2521   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS_INSN16_SIZE)
2522     {
2523       this_non_prologue_insn = 0;
2524       in_delay_slot = 0;
2525
2526       /* Save the previous instruction.  If it's an EXTEND, we'll extract
2527          the immediate offset extension from it in mips16_get_imm.  */
2528       prev_inst = inst;
2529
2530       /* Fetch and decode the instruction.  */
2531       inst = (unsigned short) mips_fetch_instruction (gdbarch, ISA_MIPS16,
2532                                                       cur_pc, NULL);
2533
2534       /* Normally we ignore extend instructions.  However, if it is
2535          not followed by a valid prologue instruction, then this
2536          instruction is not part of the prologue either.  We must
2537          remember in this case to adjust the end_prologue_addr back
2538          over the extend.  */
2539       if ((inst & 0xf800) == 0xf000)    /* extend */
2540         {
2541           extend_bytes = MIPS_INSN16_SIZE;
2542           continue;
2543         }
2544
2545       prev_extend_bytes = extend_bytes;
2546       extend_bytes = 0;
2547
2548       if ((inst & 0xff00) == 0x6300     /* addiu sp */
2549           || (inst & 0xff00) == 0xfb00) /* daddiu sp */
2550         {
2551           offset = mips16_get_imm (prev_inst, inst, 8, 8, 1);
2552           if (offset < 0)       /* Negative stack adjustment?  */
2553             frame_offset -= offset;
2554           else
2555             /* Exit loop if a positive stack adjustment is found, which
2556                usually means that the stack cleanup code in the function
2557                epilogue is reached.  */
2558             break;
2559         }
2560       else if ((inst & 0xf800) == 0xd000)       /* sw reg,n($sp) */
2561         {
2562           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
2563           reg = mips_reg3_to_reg[(inst & 0x700) >> 8];
2564           set_reg_offset (gdbarch, this_cache, reg, sp + offset);
2565         }
2566       else if ((inst & 0xff00) == 0xf900)       /* sd reg,n($sp) */
2567         {
2568           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
2569           reg = mips_reg3_to_reg[(inst & 0xe0) >> 5];
2570           set_reg_offset (gdbarch, this_cache, reg, sp + offset);
2571         }
2572       else if ((inst & 0xff00) == 0x6200)       /* sw $ra,n($sp) */
2573         {
2574           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
2575           set_reg_offset (gdbarch, this_cache, MIPS_RA_REGNUM, sp + offset);
2576         }
2577       else if ((inst & 0xff00) == 0xfa00)       /* sd $ra,n($sp) */
2578         {
2579           offset = mips16_get_imm (prev_inst, inst, 8, 8, 0);
2580           set_reg_offset (gdbarch, this_cache, MIPS_RA_REGNUM, sp + offset);
2581         }
2582       else if (inst == 0x673d)  /* move $s1, $sp */
2583         {
2584           frame_addr = sp;
2585           frame_reg = 17;
2586         }
2587       else if ((inst & 0xff00) == 0x0100)       /* addiu $s1,sp,n */
2588         {
2589           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
2590           frame_addr = sp + offset;
2591           frame_reg = 17;
2592           frame_adjust = offset;
2593         }
2594       else if ((inst & 0xFF00) == 0xd900)       /* sw reg,offset($s1) */
2595         {
2596           offset = mips16_get_imm (prev_inst, inst, 5, 4, 0);
2597           reg = mips_reg3_to_reg[(inst & 0xe0) >> 5];
2598           set_reg_offset (gdbarch, this_cache, reg, frame_addr + offset);
2599         }
2600       else if ((inst & 0xFF00) == 0x7900)       /* sd reg,offset($s1) */
2601         {
2602           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
2603           reg = mips_reg3_to_reg[(inst & 0xe0) >> 5];
2604           set_reg_offset (gdbarch, this_cache, reg, frame_addr + offset);
2605         }
2606       else if ((inst & 0xf81f) == 0xe809
2607                && (inst & 0x700) != 0x700)      /* entry */
2608         entry_inst = inst;      /* Save for later processing.  */
2609       else if ((inst & 0xff80) == 0x6480)       /* save */
2610         {
2611           save_inst = inst;     /* Save for later processing.  */
2612           if (prev_extend_bytes)                /* extend */
2613             save_inst |= prev_inst << 16;
2614         }
2615       else if ((inst & 0xff1c) == 0x6704)       /* move reg,$a0-$a3 */
2616         {
2617           /* This instruction is part of the prologue, but we don't
2618              need to do anything special to handle it.  */
2619         }
2620       else if (mips16_instruction_has_delay_slot (inst, 0))
2621                                                 /* JAL/JALR/JALX/JR */
2622         {
2623           /* The instruction in the delay slot can be a part
2624              of the prologue, so move forward once more.  */
2625           in_delay_slot = 1;
2626           if (mips16_instruction_has_delay_slot (inst, 1))
2627                                                 /* JAL/JALX */
2628             {
2629               prev_extend_bytes = MIPS_INSN16_SIZE;
2630               cur_pc += MIPS_INSN16_SIZE;       /* 32-bit instruction */
2631             }
2632         }
2633       else
2634         {
2635           this_non_prologue_insn = 1;
2636         }
2637
2638       non_prologue_insns += this_non_prologue_insn;
2639
2640       /* A jump or branch, or enough non-prologue insns seen?  If so,
2641          then we must have reached the end of the prologue by now.  */
2642       if (prev_delay_slot || non_prologue_insns > 1
2643           || mips16_instruction_is_compact_branch (inst))
2644         break;
2645
2646       prev_non_prologue_insn = this_non_prologue_insn;
2647       prev_delay_slot = in_delay_slot;
2648       prev_pc = cur_pc - prev_extend_bytes;
2649     }
2650
2651   /* The entry instruction is typically the first instruction in a function,
2652      and it stores registers at offsets relative to the value of the old SP
2653      (before the prologue).  But the value of the sp parameter to this
2654      function is the new SP (after the prologue has been executed).  So we
2655      can't calculate those offsets until we've seen the entire prologue,
2656      and can calculate what the old SP must have been.  */
2657   if (entry_inst != 0)
2658     {
2659       int areg_count = (entry_inst >> 8) & 7;
2660       int sreg_count = (entry_inst >> 6) & 3;
2661
2662       /* The entry instruction always subtracts 32 from the SP.  */
2663       frame_offset += 32;
2664
2665       /* Now we can calculate what the SP must have been at the
2666          start of the function prologue.  */
2667       sp += frame_offset;
2668
2669       /* Check if a0-a3 were saved in the caller's argument save area.  */
2670       for (reg = 4, offset = 0; reg < areg_count + 4; reg++)
2671         {
2672           set_reg_offset (gdbarch, this_cache, reg, sp + offset);
2673           offset += mips_abi_regsize (gdbarch);
2674         }
2675
2676       /* Check if the ra register was pushed on the stack.  */
2677       offset = -4;
2678       if (entry_inst & 0x20)
2679         {
2680           set_reg_offset (gdbarch, this_cache, MIPS_RA_REGNUM, sp + offset);
2681           offset -= mips_abi_regsize (gdbarch);
2682         }
2683
2684       /* Check if the s0 and s1 registers were pushed on the stack.  */
2685       for (reg = 16; reg < sreg_count + 16; reg++)
2686         {
2687           set_reg_offset (gdbarch, this_cache, reg, sp + offset);
2688           offset -= mips_abi_regsize (gdbarch);
2689         }
2690     }
2691
2692   /* The SAVE instruction is similar to ENTRY, except that defined by the
2693      MIPS16e ASE of the MIPS Architecture.  Unlike with ENTRY though, the
2694      size of the frame is specified as an immediate field of instruction
2695      and an extended variation exists which lets additional registers and
2696      frame space to be specified.  The instruction always treats registers
2697      as 32-bit so its usefulness for 64-bit ABIs is questionable.  */
2698   if (save_inst != 0 && mips_abi_regsize (gdbarch) == 4)
2699     {
2700       static int args_table[16] = {
2701         0, 0, 0, 0, 1, 1, 1, 1,
2702         2, 2, 2, 0, 3, 3, 4, -1,
2703       };
2704       static int astatic_table[16] = {
2705         0, 1, 2, 3, 0, 1, 2, 3,
2706         0, 1, 2, 4, 0, 1, 0, -1,
2707       };
2708       int aregs = (save_inst >> 16) & 0xf;
2709       int xsregs = (save_inst >> 24) & 0x7;
2710       int args = args_table[aregs];
2711       int astatic = astatic_table[aregs];
2712       long frame_size;
2713
2714       if (args < 0)
2715         {
2716           warning (_("Invalid number of argument registers encoded in SAVE."));
2717           args = 0;
2718         }
2719       if (astatic < 0)
2720         {
2721           warning (_("Invalid number of static registers encoded in SAVE."));
2722           astatic = 0;
2723         }
2724
2725       /* For standard SAVE the frame size of 0 means 128.  */
2726       frame_size = ((save_inst >> 16) & 0xf0) | (save_inst & 0xf);
2727       if (frame_size == 0 && (save_inst >> 16) == 0)
2728         frame_size = 16;
2729       frame_size *= 8;
2730       frame_offset += frame_size;
2731
2732       /* Now we can calculate what the SP must have been at the
2733          start of the function prologue.  */
2734       sp += frame_offset;
2735
2736       /* Check if A0-A3 were saved in the caller's argument save area.  */
2737       for (reg = MIPS_A0_REGNUM, offset = 0; reg < args + 4; reg++)
2738         {
2739           set_reg_offset (gdbarch, this_cache, reg, sp + offset);
2740           offset += mips_abi_regsize (gdbarch);
2741         }
2742
2743       offset = -4;
2744
2745       /* Check if the RA register was pushed on the stack.  */
2746       if (save_inst & 0x40)
2747         {
2748           set_reg_offset (gdbarch, this_cache, MIPS_RA_REGNUM, sp + offset);
2749           offset -= mips_abi_regsize (gdbarch);
2750         }
2751
2752       /* Check if the S8 register was pushed on the stack.  */
2753       if (xsregs > 6)
2754         {
2755           set_reg_offset (gdbarch, this_cache, 30, sp + offset);
2756           offset -= mips_abi_regsize (gdbarch);
2757           xsregs--;
2758         }
2759       /* Check if S2-S7 were pushed on the stack.  */
2760       for (reg = 18 + xsregs - 1; reg > 18 - 1; reg--)
2761         {
2762           set_reg_offset (gdbarch, this_cache, reg, sp + offset);
2763           offset -= mips_abi_regsize (gdbarch);
2764         }
2765
2766       /* Check if the S1 register was pushed on the stack.  */
2767       if (save_inst & 0x10)
2768         {
2769           set_reg_offset (gdbarch, this_cache, 17, sp + offset);
2770           offset -= mips_abi_regsize (gdbarch);
2771         }
2772       /* Check if the S0 register was pushed on the stack.  */
2773       if (save_inst & 0x20)
2774         {
2775           set_reg_offset (gdbarch, this_cache, 16, sp + offset);
2776           offset -= mips_abi_regsize (gdbarch);
2777         }
2778
2779       /* Check if A0-A3 were pushed on the stack.  */
2780       for (reg = MIPS_A0_REGNUM + 3; reg > MIPS_A0_REGNUM + 3 - astatic; reg--)
2781         {
2782           set_reg_offset (gdbarch, this_cache, reg, sp + offset);
2783           offset -= mips_abi_regsize (gdbarch);
2784         }
2785     }
2786
2787   if (this_cache != NULL)
2788     {
2789       this_cache->base =
2790         (get_frame_register_signed (this_frame,
2791                                     gdbarch_num_regs (gdbarch) + frame_reg)
2792          + frame_offset - frame_adjust);
2793       /* FIXME: brobecker/2004-10-10: Just as in the mips32 case, we should
2794          be able to get rid of the assignment below, evetually.  But it's
2795          still needed for now.  */
2796       this_cache->saved_regs[gdbarch_num_regs (gdbarch)
2797                              + mips_regnum (gdbarch)->pc]
2798         = this_cache->saved_regs[gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM];
2799     }
2800
2801   /* Set end_prologue_addr to the address of the instruction immediately
2802      after the last one we scanned.  Unless the last one looked like a
2803      non-prologue instruction (and we looked ahead), in which case use
2804      its address instead.  */
2805   end_prologue_addr = (prev_non_prologue_insn || prev_delay_slot
2806                        ? prev_pc : cur_pc - prev_extend_bytes);
2807
2808   return end_prologue_addr;
2809 }
2810
2811 /* Heuristic unwinder for 16-bit MIPS instruction set (aka MIPS16).
2812    Procedures that use the 32-bit instruction set are handled by the
2813    mips_insn32 unwinder.  */
2814
2815 static struct mips_frame_cache *
2816 mips_insn16_frame_cache (struct frame_info *this_frame, void **this_cache)
2817 {
2818   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2819   struct mips_frame_cache *cache;
2820
2821   if ((*this_cache) != NULL)
2822     return (*this_cache);
2823   cache = FRAME_OBSTACK_ZALLOC (struct mips_frame_cache);
2824   (*this_cache) = cache;
2825   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2826
2827   /* Analyze the function prologue.  */
2828   {
2829     const CORE_ADDR pc = get_frame_address_in_block (this_frame);
2830     CORE_ADDR start_addr;
2831
2832     find_pc_partial_function (pc, NULL, &start_addr, NULL);
2833     if (start_addr == 0)
2834       start_addr = heuristic_proc_start (gdbarch, pc);
2835     /* We can't analyze the prologue if we couldn't find the begining
2836        of the function.  */
2837     if (start_addr == 0)
2838       return cache;
2839
2840     mips16_scan_prologue (gdbarch, start_addr, pc, this_frame, *this_cache);
2841   }
2842
2843   /* gdbarch_sp_regnum contains the value and not the address.  */
2844   trad_frame_set_value (cache->saved_regs,
2845                         gdbarch_num_regs (gdbarch) + MIPS_SP_REGNUM,
2846                         cache->base);
2847
2848   return (*this_cache);
2849 }
2850
2851 static void
2852 mips_insn16_frame_this_id (struct frame_info *this_frame, void **this_cache,
2853                            struct frame_id *this_id)
2854 {
2855   struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
2856                                                            this_cache);
2857   /* This marks the outermost frame.  */
2858   if (info->base == 0)
2859     return;
2860   (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
2861 }
2862
2863 static struct value *
2864 mips_insn16_frame_prev_register (struct frame_info *this_frame,
2865                                  void **this_cache, int regnum)
2866 {
2867   struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
2868                                                            this_cache);
2869   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
2870 }
2871
2872 static int
2873 mips_insn16_frame_sniffer (const struct frame_unwind *self,
2874                            struct frame_info *this_frame, void **this_cache)
2875 {
2876   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2877   CORE_ADDR pc = get_frame_pc (this_frame);
2878   if (mips_pc_is_mips16 (gdbarch, pc))
2879     return 1;
2880   return 0;
2881 }
2882
2883 static const struct frame_unwind mips_insn16_frame_unwind =
2884 {
2885   NORMAL_FRAME,
2886   default_frame_unwind_stop_reason,
2887   mips_insn16_frame_this_id,
2888   mips_insn16_frame_prev_register,
2889   NULL,
2890   mips_insn16_frame_sniffer
2891 };
2892
2893 static CORE_ADDR
2894 mips_insn16_frame_base_address (struct frame_info *this_frame,
2895                                 void **this_cache)
2896 {
2897   struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
2898                                                            this_cache);
2899   return info->base;
2900 }
2901
2902 static const struct frame_base mips_insn16_frame_base =
2903 {
2904   &mips_insn16_frame_unwind,
2905   mips_insn16_frame_base_address,
2906   mips_insn16_frame_base_address,
2907   mips_insn16_frame_base_address
2908 };
2909
2910 static const struct frame_base *
2911 mips_insn16_frame_base_sniffer (struct frame_info *this_frame)
2912 {
2913   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2914   CORE_ADDR pc = get_frame_pc (this_frame);
2915   if (mips_pc_is_mips16 (gdbarch, pc))
2916     return &mips_insn16_frame_base;
2917   else
2918     return NULL;
2919 }
2920
2921 /* Decode a 9-bit signed immediate argument of ADDIUSP -- -2 is mapped
2922    to -258, -1 -- to -257, 0 -- to 256, 1 -- to 257 and other values are
2923    interpreted directly, and then multiplied by 4.  */
2924
2925 static int
2926 micromips_decode_imm9 (int imm)
2927 {
2928   imm = (imm ^ 0x100) - 0x100;
2929   if (imm > -3 && imm < 2)
2930     imm ^= 0x100;
2931   return imm << 2;
2932 }
2933
2934 /* Analyze the function prologue from START_PC to LIMIT_PC.  Return
2935    the address of the first instruction past the prologue.  */
2936
2937 static CORE_ADDR
2938 micromips_scan_prologue (struct gdbarch *gdbarch,
2939                          CORE_ADDR start_pc, CORE_ADDR limit_pc,
2940                          struct frame_info *this_frame,
2941                          struct mips_frame_cache *this_cache)
2942 {
2943   CORE_ADDR end_prologue_addr;
2944   int prev_non_prologue_insn = 0;
2945   int frame_reg = MIPS_SP_REGNUM;
2946   int this_non_prologue_insn;
2947   int non_prologue_insns = 0;
2948   long frame_offset = 0;        /* Size of stack frame.  */
2949   long frame_adjust = 0;        /* Offset of FP from SP.  */
2950   CORE_ADDR frame_addr = 0;     /* Value of $30, used as frame pointer.  */
2951   int prev_delay_slot = 0;
2952   int in_delay_slot;
2953   CORE_ADDR prev_pc;
2954   CORE_ADDR cur_pc;
2955   ULONGEST insn;                /* current instruction */
2956   CORE_ADDR sp;
2957   long offset;
2958   long sp_adj;
2959   long v1_off = 0;              /* The assumption is LUI will replace it.  */
2960   int reglist;
2961   int breg;
2962   int dreg;
2963   int sreg;
2964   int treg;
2965   int loc;
2966   int op;
2967   int s;
2968   int i;
2969
2970   /* Can be called when there's no process, and hence when there's no
2971      THIS_FRAME.  */
2972   if (this_frame != NULL)
2973     sp = get_frame_register_signed (this_frame,
2974                                     gdbarch_num_regs (gdbarch)
2975                                     + MIPS_SP_REGNUM);
2976   else
2977     sp = 0;
2978
2979   if (limit_pc > start_pc + 200)
2980     limit_pc = start_pc + 200;
2981   prev_pc = start_pc;
2982
2983   /* Permit at most one non-prologue non-control-transfer instruction
2984      in the middle which may have been reordered by the compiler for
2985      optimisation.  */
2986   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += loc)
2987     {
2988       this_non_prologue_insn = 0;
2989       in_delay_slot = 0;
2990       sp_adj = 0;
2991       loc = 0;
2992       insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, cur_pc, NULL);
2993       loc += MIPS_INSN16_SIZE;
2994       switch (mips_insn_size (ISA_MICROMIPS, insn))
2995         {
2996         /* 48-bit instructions.  */
2997         case 3 * MIPS_INSN16_SIZE:
2998           /* No prologue instructions in this category.  */
2999           this_non_prologue_insn = 1;
3000           loc += 2 * MIPS_INSN16_SIZE;
3001           break;
3002
3003         /* 32-bit instructions.  */
3004         case 2 * MIPS_INSN16_SIZE:
3005           insn <<= 16;
3006           insn |= mips_fetch_instruction (gdbarch,
3007                                           ISA_MICROMIPS, cur_pc + loc, NULL);
3008           loc += MIPS_INSN16_SIZE;
3009           switch (micromips_op (insn >> 16))
3010             {
3011             /* Record $sp/$fp adjustment.  */
3012             /* Discard (D)ADDU $gp,$jp used for PIC code.  */
3013             case 0x0: /* POOL32A: bits 000000 */
3014             case 0x16: /* POOL32S: bits 010110 */
3015               op = b0s11_op (insn);
3016               sreg = b0s5_reg (insn >> 16);
3017               treg = b5s5_reg (insn >> 16);
3018               dreg = b11s5_reg (insn);
3019               if (op == 0x1d0
3020                                 /* SUBU: bits 000000 00111010000 */
3021                                 /* DSUBU: bits 010110 00111010000 */
3022                   && dreg == MIPS_SP_REGNUM && sreg == MIPS_SP_REGNUM
3023                   && treg == 3)
3024                                 /* (D)SUBU $sp, $v1 */
3025                     sp_adj = v1_off;
3026               else if (op != 0x150
3027                                 /* ADDU: bits 000000 00101010000 */
3028                                 /* DADDU: bits 010110 00101010000 */
3029                        || dreg != 28 || sreg != 28 || treg != MIPS_T9_REGNUM)
3030                 this_non_prologue_insn = 1;
3031               break;
3032
3033             case 0x8: /* POOL32B: bits 001000 */
3034               op = b12s4_op (insn);
3035               breg = b0s5_reg (insn >> 16);
3036               reglist = sreg = b5s5_reg (insn >> 16);
3037               offset = (b0s12_imm (insn) ^ 0x800) - 0x800;
3038               if ((op == 0x9 || op == 0xc)
3039                                 /* SWP: bits 001000 1001 */
3040                                 /* SDP: bits 001000 1100 */
3041                   && breg == MIPS_SP_REGNUM && sreg < MIPS_RA_REGNUM)
3042                                 /* S[DW]P reg,offset($sp) */
3043                 {
3044                   s = 4 << ((b12s4_op (insn) & 0x4) == 0x4);
3045                   set_reg_offset (gdbarch, this_cache,
3046                                   sreg, sp + offset);
3047                   set_reg_offset (gdbarch, this_cache,
3048                                   sreg + 1, sp + offset + s);
3049                 }
3050               else if ((op == 0xd || op == 0xf)
3051                                 /* SWM: bits 001000 1101 */
3052                                 /* SDM: bits 001000 1111 */
3053                        && breg == MIPS_SP_REGNUM
3054                                 /* SWM reglist,offset($sp) */
3055                        && ((reglist >= 1 && reglist <= 9)
3056                            || (reglist >= 16 && reglist <= 25)))
3057                 {
3058                   int sreglist = min(reglist & 0xf, 8);
3059
3060                   s = 4 << ((b12s4_op (insn) & 0x2) == 0x2);
3061                   for (i = 0; i < sreglist; i++)
3062                     set_reg_offset (gdbarch, this_cache, 16 + i, sp + s * i);
3063                   if ((reglist & 0xf) > 8)
3064                     set_reg_offset (gdbarch, this_cache, 30, sp + s * i++);
3065                   if ((reglist & 0x10) == 0x10)
3066                     set_reg_offset (gdbarch, this_cache,
3067                                     MIPS_RA_REGNUM, sp + s * i++);
3068                 }
3069               else
3070                 this_non_prologue_insn = 1;
3071               break;
3072
3073             /* Record $sp/$fp adjustment.  */
3074             /* Discard (D)ADDIU $gp used for PIC code.  */
3075             case 0xc: /* ADDIU: bits 001100 */
3076             case 0x17: /* DADDIU: bits 010111 */
3077               sreg = b0s5_reg (insn >> 16);
3078               dreg = b5s5_reg (insn >> 16);
3079               offset = (b0s16_imm (insn) ^ 0x8000) - 0x8000;
3080               if (sreg == MIPS_SP_REGNUM && dreg == MIPS_SP_REGNUM)
3081                                 /* (D)ADDIU $sp, imm */
3082                 sp_adj = offset;
3083               else if (sreg == MIPS_SP_REGNUM && dreg == 30)
3084                                 /* (D)ADDIU $fp, $sp, imm */
3085                 {
3086                   frame_addr = sp + offset;
3087                   frame_adjust = offset;
3088                   frame_reg = 30;
3089                 }
3090               else if (sreg != 28 || dreg != 28)
3091                                 /* (D)ADDIU $gp, imm */
3092                 this_non_prologue_insn = 1;
3093               break;
3094
3095             /* LUI $v1 is used for larger $sp adjustments.  */
3096             /* Discard LUI $gp used for PIC code.  */
3097             case 0x10: /* POOL32I: bits 010000 */
3098               if (b5s5_op (insn >> 16) == 0xd
3099                                 /* LUI: bits 010000 001101 */
3100                   && b0s5_reg (insn >> 16) == 3)
3101                                 /* LUI $v1, imm */
3102                 v1_off = ((b0s16_imm (insn) << 16) ^ 0x80000000) - 0x80000000;
3103               else if (b5s5_op (insn >> 16) != 0xd
3104                                 /* LUI: bits 010000 001101 */
3105                        || b0s5_reg (insn >> 16) != 28)
3106                                 /* LUI $gp, imm */
3107                 this_non_prologue_insn = 1;
3108               break;
3109
3110             /* ORI $v1 is used for larger $sp adjustments.  */
3111             case 0x14: /* ORI: bits 010100 */
3112               sreg = b0s5_reg (insn >> 16);
3113               dreg = b5s5_reg (insn >> 16);
3114               if (sreg == 3 && dreg == 3)
3115                                 /* ORI $v1, imm */
3116                 v1_off |= b0s16_imm (insn);
3117               else
3118                 this_non_prologue_insn = 1;
3119               break;
3120
3121             case 0x26: /* SWC1: bits 100110 */
3122             case 0x2e: /* SDC1: bits 101110 */
3123               breg = b0s5_reg (insn >> 16);
3124               if (breg != MIPS_SP_REGNUM)
3125                                 /* S[DW]C1 reg,offset($sp) */
3126                 this_non_prologue_insn = 1;
3127               break;
3128
3129             case 0x36: /* SD: bits 110110 */
3130             case 0x3e: /* SW: bits 111110 */
3131               breg = b0s5_reg (insn >> 16);
3132               sreg = b5s5_reg (insn >> 16);
3133               offset = (b0s16_imm (insn) ^ 0x8000) - 0x8000;
3134               if (breg == MIPS_SP_REGNUM)
3135                                 /* S[DW] reg,offset($sp) */
3136                 set_reg_offset (gdbarch, this_cache, sreg, sp + offset);
3137               else
3138                 this_non_prologue_insn = 1;
3139               break;
3140
3141             default:
3142               /* The instruction in the delay slot can be a part
3143                  of the prologue, so move forward once more.  */
3144               if (micromips_instruction_has_delay_slot (insn, 0))
3145                 in_delay_slot = 1;
3146               else
3147                 this_non_prologue_insn = 1;
3148               break;
3149             }
3150           insn >>= 16;
3151           break;
3152
3153         /* 16-bit instructions.  */
3154         case MIPS_INSN16_SIZE:
3155           switch (micromips_op (insn))
3156             {
3157             case 0x3: /* MOVE: bits 000011 */
3158               sreg = b0s5_reg (insn);
3159               dreg = b5s5_reg (insn);
3160               if (sreg == MIPS_SP_REGNUM && dreg == 30)
3161                                 /* MOVE  $fp, $sp */
3162                 {
3163                   frame_addr = sp;
3164                   frame_reg = 30;
3165                 }
3166               else if ((sreg & 0x1c) != 0x4)
3167                                 /* MOVE  reg, $a0-$a3 */
3168                 this_non_prologue_insn = 1;
3169               break;
3170
3171             case 0x11: /* POOL16C: bits 010001 */
3172               if (b6s4_op (insn) == 0x5)
3173                                 /* SWM: bits 010001 0101 */
3174                 {
3175                   offset = ((b0s4_imm (insn) << 2) ^ 0x20) - 0x20;
3176                   reglist = b4s2_regl (insn);
3177                   for (i = 0; i <= reglist; i++)
3178                     set_reg_offset (gdbarch, this_cache, 16 + i, sp + 4 * i);
3179                   set_reg_offset (gdbarch, this_cache,
3180                                   MIPS_RA_REGNUM, sp + 4 * i++);
3181                 }
3182               else
3183                 this_non_prologue_insn = 1;
3184               break;
3185
3186             case 0x13: /* POOL16D: bits 010011 */
3187               if ((insn & 0x1) == 0x1)
3188                                 /* ADDIUSP: bits 010011 1 */
3189                 sp_adj = micromips_decode_imm9 (b1s9_imm (insn));
3190               else if (b5s5_reg (insn) == MIPS_SP_REGNUM)
3191                                 /* ADDIUS5: bits 010011 0 */
3192                                 /* ADDIUS5 $sp, imm */
3193                 sp_adj = (b1s4_imm (insn) ^ 8) - 8;
3194               else
3195                 this_non_prologue_insn = 1;
3196               break;
3197
3198             case 0x32: /* SWSP: bits 110010 */
3199               offset = b0s5_imm (insn) << 2;
3200               sreg = b5s5_reg (insn);
3201               set_reg_offset (gdbarch, this_cache, sreg, sp + offset);
3202               break;
3203
3204             default:
3205               /* The instruction in the delay slot can be a part
3206                  of the prologue, so move forward once more.  */
3207               if (micromips_instruction_has_delay_slot (insn << 16, 0))
3208                 in_delay_slot = 1;
3209               else
3210                 this_non_prologue_insn = 1;
3211               break;
3212             }
3213           break;
3214         }
3215       if (sp_adj < 0)
3216         frame_offset -= sp_adj;
3217
3218       non_prologue_insns += this_non_prologue_insn;
3219
3220       /* A jump or branch, enough non-prologue insns seen or positive
3221          stack adjustment?  If so, then we must have reached the end
3222          of the prologue by now.  */
3223       if (prev_delay_slot || non_prologue_insns > 1 || sp_adj > 0
3224           || micromips_instruction_is_compact_branch (insn))
3225         break;
3226
3227       prev_non_prologue_insn = this_non_prologue_insn;
3228       prev_delay_slot = in_delay_slot;
3229       prev_pc = cur_pc;
3230     }
3231
3232   if (this_cache != NULL)
3233     {
3234       this_cache->base =
3235         (get_frame_register_signed (this_frame,
3236                                     gdbarch_num_regs (gdbarch) + frame_reg)
3237          + frame_offset - frame_adjust);
3238       /* FIXME: brobecker/2004-10-10: Just as in the mips32 case, we should
3239          be able to get rid of the assignment below, evetually. But it's
3240          still needed for now.  */
3241       this_cache->saved_regs[gdbarch_num_regs (gdbarch)
3242                              + mips_regnum (gdbarch)->pc]
3243         = this_cache->saved_regs[gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM];
3244     }
3245
3246   /* Set end_prologue_addr to the address of the instruction immediately
3247      after the last one we scanned.  Unless the last one looked like a
3248      non-prologue instruction (and we looked ahead), in which case use
3249      its address instead.  */
3250   end_prologue_addr
3251     = prev_non_prologue_insn || prev_delay_slot ? prev_pc : cur_pc;
3252
3253   return end_prologue_addr;
3254 }
3255
3256 /* Heuristic unwinder for procedures using microMIPS instructions.
3257    Procedures that use the 32-bit instruction set are handled by the
3258    mips_insn32 unwinder.  Likewise MIPS16 and the mips_insn16 unwinder. */
3259
3260 static struct mips_frame_cache *
3261 mips_micro_frame_cache (struct frame_info *this_frame, void **this_cache)
3262 {
3263   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3264   struct mips_frame_cache *cache;
3265
3266   if ((*this_cache) != NULL)
3267     return (*this_cache);
3268
3269   cache = FRAME_OBSTACK_ZALLOC (struct mips_frame_cache);
3270   (*this_cache) = cache;
3271   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
3272
3273   /* Analyze the function prologue.  */
3274   {
3275     const CORE_ADDR pc = get_frame_address_in_block (this_frame);
3276     CORE_ADDR start_addr;
3277
3278     find_pc_partial_function (pc, NULL, &start_addr, NULL);
3279     if (start_addr == 0)
3280       start_addr = heuristic_proc_start (get_frame_arch (this_frame), pc);
3281     /* We can't analyze the prologue if we couldn't find the begining
3282        of the function.  */
3283     if (start_addr == 0)
3284       return cache;
3285
3286     micromips_scan_prologue (gdbarch, start_addr, pc, this_frame, *this_cache);
3287   }
3288
3289   /* gdbarch_sp_regnum contains the value and not the address.  */
3290   trad_frame_set_value (cache->saved_regs,
3291                         gdbarch_num_regs (gdbarch) + MIPS_SP_REGNUM,
3292                         cache->base);
3293
3294   return (*this_cache);
3295 }
3296
3297 static void
3298 mips_micro_frame_this_id (struct frame_info *this_frame, void **this_cache,
3299                           struct frame_id *this_id)
3300 {
3301   struct mips_frame_cache *info = mips_micro_frame_cache (this_frame,
3302                                                           this_cache);
3303   /* This marks the outermost frame.  */
3304   if (info->base == 0)
3305     return;
3306   (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
3307 }
3308
3309 static struct value *
3310 mips_micro_frame_prev_register (struct frame_info *this_frame,
3311                                 void **this_cache, int regnum)
3312 {
3313   struct mips_frame_cache *info = mips_micro_frame_cache (this_frame,
3314                                                           this_cache);
3315   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
3316 }
3317
3318 static int
3319 mips_micro_frame_sniffer (const struct frame_unwind *self,
3320                           struct frame_info *this_frame, void **this_cache)
3321 {
3322   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3323   CORE_ADDR pc = get_frame_pc (this_frame);
3324
3325   if (mips_pc_is_micromips (gdbarch, pc))
3326     return 1;
3327   return 0;
3328 }
3329
3330 static const struct frame_unwind mips_micro_frame_unwind =
3331 {
3332   NORMAL_FRAME,
3333   default_frame_unwind_stop_reason,
3334   mips_micro_frame_this_id,
3335   mips_micro_frame_prev_register,
3336   NULL,
3337   mips_micro_frame_sniffer
3338 };
3339
3340 static CORE_ADDR
3341 mips_micro_frame_base_address (struct frame_info *this_frame,
3342                                void **this_cache)
3343 {
3344   struct mips_frame_cache *info = mips_micro_frame_cache (this_frame,
3345                                                           this_cache);
3346   return info->base;
3347 }
3348
3349 static const struct frame_base mips_micro_frame_base =
3350 {
3351   &mips_micro_frame_unwind,
3352   mips_micro_frame_base_address,
3353   mips_micro_frame_base_address,
3354   mips_micro_frame_base_address
3355 };
3356
3357 static const struct frame_base *
3358 mips_micro_frame_base_sniffer (struct frame_info *this_frame)
3359 {
3360   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3361   CORE_ADDR pc = get_frame_pc (this_frame);
3362
3363   if (mips_pc_is_micromips (gdbarch, pc))
3364     return &mips_micro_frame_base;
3365   else
3366     return NULL;
3367 }
3368
3369 /* Mark all the registers as unset in the saved_regs array
3370    of THIS_CACHE.  Do nothing if THIS_CACHE is null.  */
3371
3372 static void
3373 reset_saved_regs (struct gdbarch *gdbarch, struct mips_frame_cache *this_cache)
3374 {
3375   if (this_cache == NULL || this_cache->saved_regs == NULL)
3376     return;
3377
3378   {
3379     const int num_regs = gdbarch_num_regs (gdbarch);
3380     int i;
3381
3382     for (i = 0; i < num_regs; i++)
3383       {
3384         this_cache->saved_regs[i].addr = -1;
3385       }
3386   }
3387 }
3388
3389 /* Analyze the function prologue from START_PC to LIMIT_PC.  Builds
3390    the associated FRAME_CACHE if not null.
3391    Return the address of the first instruction past the prologue.  */
3392
3393 static CORE_ADDR
3394 mips32_scan_prologue (struct gdbarch *gdbarch,
3395                       CORE_ADDR start_pc, CORE_ADDR limit_pc,
3396                       struct frame_info *this_frame,
3397                       struct mips_frame_cache *this_cache)
3398 {
3399   int prev_non_prologue_insn;
3400   int this_non_prologue_insn;
3401   int non_prologue_insns;
3402   CORE_ADDR frame_addr = 0; /* Value of $r30. Used by gcc for
3403                                frame-pointer.  */
3404   int prev_delay_slot;
3405   CORE_ADDR prev_pc;
3406   CORE_ADDR cur_pc;
3407   CORE_ADDR sp;
3408   long frame_offset;
3409   int  frame_reg = MIPS_SP_REGNUM;
3410
3411   CORE_ADDR end_prologue_addr;
3412   int seen_sp_adjust = 0;
3413   int load_immediate_bytes = 0;
3414   int in_delay_slot;
3415   int regsize_is_64_bits = (mips_abi_regsize (gdbarch) == 8);
3416
3417   /* Can be called when there's no process, and hence when there's no
3418      THIS_FRAME.  */
3419   if (this_frame != NULL)
3420     sp = get_frame_register_signed (this_frame,
3421                                     gdbarch_num_regs (gdbarch)
3422                                     + MIPS_SP_REGNUM);
3423   else
3424     sp = 0;
3425
3426   if (limit_pc > start_pc + 200)
3427     limit_pc = start_pc + 200;
3428
3429 restart:
3430   prev_non_prologue_insn = 0;
3431   non_prologue_insns = 0;
3432   prev_delay_slot = 0;
3433   prev_pc = start_pc;
3434
3435   /* Permit at most one non-prologue non-control-transfer instruction
3436      in the middle which may have been reordered by the compiler for
3437      optimisation.  */
3438   frame_offset = 0;
3439   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS_INSN32_SIZE)
3440     {
3441       unsigned long inst, high_word, low_word;
3442       int reg;
3443
3444       this_non_prologue_insn = 0;
3445       in_delay_slot = 0;
3446
3447       /* Fetch the instruction.  */
3448       inst = (unsigned long) mips_fetch_instruction (gdbarch, ISA_MIPS,
3449                                                      cur_pc, NULL);
3450
3451       /* Save some code by pre-extracting some useful fields.  */
3452       high_word = (inst >> 16) & 0xffff;
3453       low_word = inst & 0xffff;
3454       reg = high_word & 0x1f;
3455
3456       if (high_word == 0x27bd           /* addiu $sp,$sp,-i */
3457           || high_word == 0x23bd        /* addi $sp,$sp,-i */
3458           || high_word == 0x67bd)       /* daddiu $sp,$sp,-i */
3459         {
3460           if (low_word & 0x8000)        /* Negative stack adjustment?  */
3461             frame_offset += 0x10000 - low_word;
3462           else
3463             /* Exit loop if a positive stack adjustment is found, which
3464                usually means that the stack cleanup code in the function
3465                epilogue is reached.  */
3466             break;
3467           seen_sp_adjust = 1;
3468         }
3469       else if (((high_word & 0xFFE0) == 0xafa0) /* sw reg,offset($sp) */
3470                && !regsize_is_64_bits)
3471         {
3472           set_reg_offset (gdbarch, this_cache, reg, sp + low_word);
3473         }
3474       else if (((high_word & 0xFFE0) == 0xffa0) /* sd reg,offset($sp) */
3475                && regsize_is_64_bits)
3476         {
3477           /* Irix 6.2 N32 ABI uses sd instructions for saving $gp and $ra.  */
3478           set_reg_offset (gdbarch, this_cache, reg, sp + low_word);
3479         }
3480       else if (high_word == 0x27be)     /* addiu $30,$sp,size */
3481         {
3482           /* Old gcc frame, r30 is virtual frame pointer.  */
3483           if ((long) low_word != frame_offset)
3484             frame_addr = sp + low_word;
3485           else if (this_frame && frame_reg == MIPS_SP_REGNUM)
3486             {
3487               unsigned alloca_adjust;
3488
3489               frame_reg = 30;
3490               frame_addr = get_frame_register_signed
3491                 (this_frame, gdbarch_num_regs (gdbarch) + 30);
3492               frame_offset = 0;
3493
3494               alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
3495               if (alloca_adjust > 0)
3496                 {
3497                   /* FP > SP + frame_size.  This may be because of
3498                      an alloca or somethings similar.  Fix sp to
3499                      "pre-alloca" value, and try again.  */
3500                   sp += alloca_adjust;
3501                   /* Need to reset the status of all registers.  Otherwise,
3502                      we will hit a guard that prevents the new address
3503                      for each register to be recomputed during the second
3504                      pass.  */
3505                   reset_saved_regs (gdbarch, this_cache);
3506                   goto restart;
3507                 }
3508             }
3509         }
3510       /* move $30,$sp.  With different versions of gas this will be either
3511          `addu $30,$sp,$zero' or `or $30,$sp,$zero' or `daddu 30,sp,$0'.
3512          Accept any one of these.  */
3513       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
3514         {
3515           /* New gcc frame, virtual frame pointer is at r30 + frame_size.  */
3516           if (this_frame && frame_reg == MIPS_SP_REGNUM)
3517             {
3518               unsigned alloca_adjust;
3519
3520               frame_reg = 30;
3521               frame_addr = get_frame_register_signed
3522                 (this_frame, gdbarch_num_regs (gdbarch) + 30);
3523
3524               alloca_adjust = (unsigned) (frame_addr - sp);
3525               if (alloca_adjust > 0)
3526                 {
3527                   /* FP > SP + frame_size.  This may be because of
3528                      an alloca or somethings similar.  Fix sp to
3529                      "pre-alloca" value, and try again.  */
3530                   sp = frame_addr;
3531                   /* Need to reset the status of all registers.  Otherwise,
3532                      we will hit a guard that prevents the new address
3533                      for each register to be recomputed during the second
3534                      pass.  */
3535                   reset_saved_regs (gdbarch, this_cache);
3536                   goto restart;
3537                 }
3538             }
3539         }
3540       else if ((high_word & 0xFFE0) == 0xafc0   /* sw reg,offset($30) */
3541                && !regsize_is_64_bits)
3542         {
3543           set_reg_offset (gdbarch, this_cache, reg, frame_addr + low_word);
3544         }
3545       else if ((high_word & 0xFFE0) == 0xE7A0 /* swc1 freg,n($sp) */
3546                || (high_word & 0xF3E0) == 0xA3C0 /* sx reg,n($s8) */
3547                || (inst & 0xFF9F07FF) == 0x00800021 /* move reg,$a0-$a3 */
3548                || high_word == 0x3c1c /* lui $gp,n */
3549                || high_word == 0x279c /* addiu $gp,$gp,n */
3550                || inst == 0x0399e021 /* addu $gp,$gp,$t9 */
3551                || inst == 0x033ce021 /* addu $gp,$t9,$gp */
3552               )
3553         {
3554           /* These instructions are part of the prologue, but we don't
3555              need to do anything special to handle them.  */
3556         }
3557       /* The instructions below load $at or $t0 with an immediate
3558          value in preparation for a stack adjustment via
3559          subu $sp,$sp,[$at,$t0].  These instructions could also
3560          initialize a local variable, so we accept them only before
3561          a stack adjustment instruction was seen.  */
3562       else if (!seen_sp_adjust
3563                && !prev_delay_slot
3564                && (high_word == 0x3c01 /* lui $at,n */
3565                    || high_word == 0x3c08 /* lui $t0,n */
3566                    || high_word == 0x3421 /* ori $at,$at,n */
3567                    || high_word == 0x3508 /* ori $t0,$t0,n */
3568                    || high_word == 0x3401 /* ori $at,$zero,n */
3569                    || high_word == 0x3408 /* ori $t0,$zero,n */
3570                   ))
3571         {
3572           load_immediate_bytes += MIPS_INSN32_SIZE;             /* FIXME!  */
3573         }
3574       /* Check for branches and jumps.  The instruction in the delay
3575          slot can be a part of the prologue, so move forward once more.  */
3576       else if (mips32_instruction_has_delay_slot (gdbarch, inst))
3577         {
3578           in_delay_slot = 1;
3579         }
3580       /* This instruction is not an instruction typically found
3581          in a prologue, so we must have reached the end of the
3582          prologue.  */
3583       else
3584         {
3585           this_non_prologue_insn = 1;
3586         }
3587
3588       non_prologue_insns += this_non_prologue_insn;
3589
3590       /* A jump or branch, or enough non-prologue insns seen?  If so,
3591          then we must have reached the end of the prologue by now.  */
3592       if (prev_delay_slot || non_prologue_insns > 1)
3593         break;
3594
3595       prev_non_prologue_insn = this_non_prologue_insn;
3596       prev_delay_slot = in_delay_slot;
3597       prev_pc = cur_pc;
3598     }
3599
3600   if (this_cache != NULL)
3601     {
3602       this_cache->base =
3603         (get_frame_register_signed (this_frame,
3604                                     gdbarch_num_regs (gdbarch) + frame_reg)
3605          + frame_offset);
3606       /* FIXME: brobecker/2004-09-15: We should be able to get rid of
3607          this assignment below, eventually.  But it's still needed
3608          for now.  */
3609       this_cache->saved_regs[gdbarch_num_regs (gdbarch)
3610                              + mips_regnum (gdbarch)->pc]
3611         = this_cache->saved_regs[gdbarch_num_regs (gdbarch)
3612                                  + MIPS_RA_REGNUM];
3613     }
3614
3615   /* Set end_prologue_addr to the address of the instruction immediately
3616      after the last one we scanned.  Unless the last one looked like a
3617      non-prologue instruction (and we looked ahead), in which case use
3618      its address instead.  */
3619   end_prologue_addr
3620     = prev_non_prologue_insn || prev_delay_slot ? prev_pc : cur_pc;
3621
3622   /* In a frameless function, we might have incorrectly
3623      skipped some load immediate instructions.  Undo the skipping
3624      if the load immediate was not followed by a stack adjustment.  */
3625   if (load_immediate_bytes && !seen_sp_adjust)
3626     end_prologue_addr -= load_immediate_bytes;
3627
3628   return end_prologue_addr;
3629 }
3630
3631 /* Heuristic unwinder for procedures using 32-bit instructions (covers
3632    both 32-bit and 64-bit MIPS ISAs).  Procedures using 16-bit
3633    instructions (a.k.a. MIPS16) are handled by the mips_insn16
3634    unwinder.  Likewise microMIPS and the mips_micro unwinder. */
3635
3636 static struct mips_frame_cache *
3637 mips_insn32_frame_cache (struct frame_info *this_frame, void **this_cache)
3638 {
3639   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3640   struct mips_frame_cache *cache;
3641
3642   if ((*this_cache) != NULL)
3643     return (*this_cache);
3644
3645   cache = FRAME_OBSTACK_ZALLOC (struct mips_frame_cache);
3646   (*this_cache) = cache;
3647   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
3648
3649   /* Analyze the function prologue.  */
3650   {
3651     const CORE_ADDR pc = get_frame_address_in_block (this_frame);
3652     CORE_ADDR start_addr;
3653
3654     find_pc_partial_function (pc, NULL, &start_addr, NULL);
3655     if (start_addr == 0)
3656       start_addr = heuristic_proc_start (gdbarch, pc);
3657     /* We can't analyze the prologue if we couldn't find the begining
3658        of the function.  */
3659     if (start_addr == 0)
3660       return cache;
3661
3662     mips32_scan_prologue (gdbarch, start_addr, pc, this_frame, *this_cache);
3663   }
3664
3665   /* gdbarch_sp_regnum contains the value and not the address.  */
3666   trad_frame_set_value (cache->saved_regs,
3667                         gdbarch_num_regs (gdbarch) + MIPS_SP_REGNUM,
3668                         cache->base);
3669
3670   return (*this_cache);
3671 }
3672
3673 static void
3674 mips_insn32_frame_this_id (struct frame_info *this_frame, void **this_cache,
3675                            struct frame_id *this_id)
3676 {
3677   struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
3678                                                            this_cache);
3679   /* This marks the outermost frame.  */
3680   if (info->base == 0)
3681     return;
3682   (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
3683 }
3684
3685 static struct value *
3686 mips_insn32_frame_prev_register (struct frame_info *this_frame,
3687                                  void **this_cache, int regnum)
3688 {
3689   struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
3690                                                            this_cache);
3691   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
3692 }
3693
3694 static int
3695 mips_insn32_frame_sniffer (const struct frame_unwind *self,
3696                            struct frame_info *this_frame, void **this_cache)
3697 {
3698   CORE_ADDR pc = get_frame_pc (this_frame);
3699   if (mips_pc_is_mips (pc))
3700     return 1;
3701   return 0;
3702 }
3703
3704 static const struct frame_unwind mips_insn32_frame_unwind =
3705 {
3706   NORMAL_FRAME,
3707   default_frame_unwind_stop_reason,
3708   mips_insn32_frame_this_id,
3709   mips_insn32_frame_prev_register,
3710   NULL,
3711   mips_insn32_frame_sniffer
3712 };
3713
3714 static CORE_ADDR
3715 mips_insn32_frame_base_address (struct frame_info *this_frame,
3716                                 void **this_cache)
3717 {
3718   struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
3719                                                            this_cache);
3720   return info->base;
3721 }
3722
3723 static const struct frame_base mips_insn32_frame_base =
3724 {
3725   &mips_insn32_frame_unwind,
3726   mips_insn32_frame_base_address,
3727   mips_insn32_frame_base_address,
3728   mips_insn32_frame_base_address
3729 };
3730
3731 static const struct frame_base *
3732 mips_insn32_frame_base_sniffer (struct frame_info *this_frame)
3733 {
3734   CORE_ADDR pc = get_frame_pc (this_frame);
3735   if (mips_pc_is_mips (pc))
3736     return &mips_insn32_frame_base;
3737   else
3738     return NULL;
3739 }
3740
3741 static struct trad_frame_cache *
3742 mips_stub_frame_cache (struct frame_info *this_frame, void **this_cache)
3743 {
3744   CORE_ADDR pc;
3745   CORE_ADDR start_addr;
3746   CORE_ADDR stack_addr;
3747   struct trad_frame_cache *this_trad_cache;
3748   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3749   int num_regs = gdbarch_num_regs (gdbarch);
3750
3751   if ((*this_cache) != NULL)
3752     return (*this_cache);
3753   this_trad_cache = trad_frame_cache_zalloc (this_frame);
3754   (*this_cache) = this_trad_cache;
3755
3756   /* The return address is in the link register.  */
3757   trad_frame_set_reg_realreg (this_trad_cache,
3758                               gdbarch_pc_regnum (gdbarch),
3759                               num_regs + MIPS_RA_REGNUM);
3760
3761   /* Frame ID, since it's a frameless / stackless function, no stack
3762      space is allocated and SP on entry is the current SP.  */
3763   pc = get_frame_pc (this_frame);
3764   find_pc_partial_function (pc, NULL, &start_addr, NULL);
3765   stack_addr = get_frame_register_signed (this_frame,
3766                                           num_regs + MIPS_SP_REGNUM);
3767   trad_frame_set_id (this_trad_cache, frame_id_build (stack_addr, start_addr));
3768
3769   /* Assume that the frame's base is the same as the
3770      stack-pointer.  */
3771   trad_frame_set_this_base (this_trad_cache, stack_addr);
3772
3773   return this_trad_cache;
3774 }
3775
3776 static void
3777 mips_stub_frame_this_id (struct frame_info *this_frame, void **this_cache,
3778                          struct frame_id *this_id)
3779 {
3780   struct trad_frame_cache *this_trad_cache
3781     = mips_stub_frame_cache (this_frame, this_cache);
3782   trad_frame_get_id (this_trad_cache, this_id);
3783 }
3784
3785 static struct value *
3786 mips_stub_frame_prev_register (struct frame_info *this_frame,
3787                                void **this_cache, int regnum)
3788 {
3789   struct trad_frame_cache *this_trad_cache
3790     = mips_stub_frame_cache (this_frame, this_cache);
3791   return trad_frame_get_register (this_trad_cache, this_frame, regnum);
3792 }
3793
3794 static int
3795 mips_stub_frame_sniffer (const struct frame_unwind *self,
3796                          struct frame_info *this_frame, void **this_cache)
3797 {
3798   gdb_byte dummy[4];
3799   struct obj_section *s;
3800   CORE_ADDR pc = get_frame_address_in_block (this_frame);
3801   struct bound_minimal_symbol msym;
3802
3803   /* Use the stub unwinder for unreadable code.  */
3804   if (target_read_memory (get_frame_pc (this_frame), dummy, 4) != 0)
3805     return 1;
3806
3807   if (in_plt_section (pc) || in_mips_stubs_section (pc))
3808     return 1;
3809
3810   /* Calling a PIC function from a non-PIC function passes through a
3811      stub.  The stub for foo is named ".pic.foo".  */
3812   msym = lookup_minimal_symbol_by_pc (pc);
3813   if (msym.minsym != NULL
3814       && MSYMBOL_LINKAGE_NAME (msym.minsym) != NULL
3815       && strncmp (MSYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) == 0)
3816     return 1;
3817
3818   return 0;
3819 }
3820
3821 static const struct frame_unwind mips_stub_frame_unwind =
3822 {
3823   NORMAL_FRAME,
3824   default_frame_unwind_stop_reason,
3825   mips_stub_frame_this_id,
3826   mips_stub_frame_prev_register,
3827   NULL,
3828   mips_stub_frame_sniffer
3829 };
3830
3831 static CORE_ADDR
3832 mips_stub_frame_base_address (struct frame_info *this_frame,
3833                               void **this_cache)
3834 {
3835   struct trad_frame_cache *this_trad_cache
3836     = mips_stub_frame_cache (this_frame, this_cache);
3837   return trad_frame_get_this_base (this_trad_cache);
3838 }
3839
3840 static const struct frame_base mips_stub_frame_base =
3841 {
3842   &mips_stub_frame_unwind,
3843   mips_stub_frame_base_address,
3844   mips_stub_frame_base_address,
3845   mips_stub_frame_base_address
3846 };
3847
3848 static const struct frame_base *
3849 mips_stub_frame_base_sniffer (struct frame_info *this_frame)
3850 {
3851   if (mips_stub_frame_sniffer (&mips_stub_frame_unwind, this_frame, NULL))
3852     return &mips_stub_frame_base;
3853   else
3854     return NULL;
3855 }
3856
3857 /* mips_addr_bits_remove - remove useless address bits  */
3858
3859 static CORE_ADDR
3860 mips_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
3861 {
3862   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3863
3864   if (mips_mask_address_p (tdep) && (((ULONGEST) addr) >> 32 == 0xffffffffUL))
3865     /* This hack is a work-around for existing boards using PMON, the
3866        simulator, and any other 64-bit targets that doesn't have true
3867        64-bit addressing.  On these targets, the upper 32 bits of
3868        addresses are ignored by the hardware.  Thus, the PC or SP are
3869        likely to have been sign extended to all 1s by instruction
3870        sequences that load 32-bit addresses.  For example, a typical
3871        piece of code that loads an address is this:
3872
3873        lui $r2, <upper 16 bits>
3874        ori $r2, <lower 16 bits>
3875
3876        But the lui sign-extends the value such that the upper 32 bits
3877        may be all 1s.  The workaround is simply to mask off these
3878        bits.  In the future, gcc may be changed to support true 64-bit
3879        addressing, and this masking will have to be disabled.  */
3880     return addr &= 0xffffffffUL;
3881   else
3882     return addr;
3883 }
3884
3885
3886 /* Checks for an atomic sequence of instructions beginning with a LL/LLD
3887    instruction and ending with a SC/SCD instruction.  If such a sequence
3888    is found, attempt to step through it.  A breakpoint is placed at the end of
3889    the sequence.  */
3890
3891 /* Instructions used during single-stepping of atomic sequences, standard
3892    ISA version.  */
3893 #define LL_OPCODE 0x30
3894 #define LLD_OPCODE 0x34
3895 #define SC_OPCODE 0x38
3896 #define SCD_OPCODE 0x3c
3897
3898 static int
3899 mips_deal_with_atomic_sequence (struct gdbarch *gdbarch,
3900                                 struct address_space *aspace, CORE_ADDR pc)
3901 {
3902   CORE_ADDR breaks[2] = {-1, -1};
3903   CORE_ADDR loc = pc;
3904   CORE_ADDR branch_bp; /* Breakpoint at branch instruction's destination.  */
3905   ULONGEST insn;
3906   int insn_count;
3907   int index;
3908   int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed).  */
3909   const int atomic_sequence_length = 16; /* Instruction sequence length.  */
3910
3911   insn = mips_fetch_instruction (gdbarch, ISA_MIPS, loc, NULL);
3912   /* Assume all atomic sequences start with a ll/lld instruction.  */
3913   if (itype_op (insn) != LL_OPCODE && itype_op (insn) != LLD_OPCODE)
3914     return 0;
3915
3916   /* Assume that no atomic sequence is longer than "atomic_sequence_length"
3917      instructions.  */
3918   for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
3919     {
3920       int is_branch = 0;
3921       loc += MIPS_INSN32_SIZE;
3922       insn = mips_fetch_instruction (gdbarch, ISA_MIPS, loc, NULL);
3923
3924       /* Assume that there is at most one branch in the atomic
3925          sequence.  If a branch is found, put a breakpoint in its
3926          destination address.  */
3927       switch (itype_op (insn))
3928         {
3929         case 0: /* SPECIAL */
3930           if (rtype_funct (insn) >> 1 == 4) /* JR, JALR */
3931             return 0; /* fallback to the standard single-step code.  */
3932           break;
3933         case 1: /* REGIMM */
3934           is_branch = ((itype_rt (insn) & 0xc) == 0 /* B{LT,GE}Z* */
3935                        || ((itype_rt (insn) & 0x1e) == 0
3936                            && itype_rs (insn) == 0)); /* BPOSGE* */
3937           break;
3938         case 2: /* J */
3939         case 3: /* JAL */
3940           return 0; /* fallback to the standard single-step code.  */
3941         case 4: /* BEQ */
3942         case 5: /* BNE */
3943         case 6: /* BLEZ */
3944         case 7: /* BGTZ */
3945         case 20: /* BEQL */
3946         case 21: /* BNEL */
3947         case 22: /* BLEZL */
3948         case 23: /* BGTTL */
3949           is_branch = 1;
3950           break;
3951         case 17: /* COP1 */
3952           is_branch = ((itype_rs (insn) == 9 || itype_rs (insn) == 10)
3953                        && (itype_rt (insn) & 0x2) == 0);
3954           if (is_branch) /* BC1ANY2F, BC1ANY2T, BC1ANY4F, BC1ANY4T */
3955             break;
3956         /* Fall through.  */
3957         case 18: /* COP2 */
3958         case 19: /* COP3 */
3959           is_branch = (itype_rs (insn) == 8); /* BCzF, BCzFL, BCzT, BCzTL */
3960           break;
3961         }
3962       if (is_branch)
3963         {
3964           branch_bp = loc + mips32_relative_offset (insn) + 4;
3965           if (last_breakpoint >= 1)
3966             return 0; /* More than one branch found, fallback to the
3967                          standard single-step code.  */
3968           breaks[1] = branch_bp;
3969           last_breakpoint++;
3970         }
3971
3972       if (itype_op (insn) == SC_OPCODE || itype_op (insn) == SCD_OPCODE)
3973         break;
3974     }
3975
3976   /* Assume that the atomic sequence ends with a sc/scd instruction.  */
3977   if (itype_op (insn) != SC_OPCODE && itype_op (insn) != SCD_OPCODE)
3978     return 0;
3979
3980   loc += MIPS_INSN32_SIZE;
3981
3982   /* Insert a breakpoint right after the end of the atomic sequence.  */
3983   breaks[0] = loc;
3984
3985   /* Check for duplicated breakpoints.  Check also for a breakpoint
3986      placed (branch instruction's destination) in the atomic sequence.  */
3987   if (last_breakpoint && pc <= breaks[1] && breaks[1] <= breaks[0])
3988     last_breakpoint = 0;
3989
3990   /* Effectively inserts the breakpoints.  */
3991   for (index = 0; index <= last_breakpoint; index++)
3992     insert_single_step_breakpoint (gdbarch, aspace, breaks[index]);
3993
3994   return 1;
3995 }
3996
3997 static int
3998 micromips_deal_with_atomic_sequence (struct gdbarch *gdbarch,
3999                                      struct address_space *aspace,
4000                                      CORE_ADDR pc)
4001 {
4002   const int atomic_sequence_length = 16; /* Instruction sequence length.  */
4003   int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed).  */
4004   CORE_ADDR breaks[2] = {-1, -1};
4005   CORE_ADDR branch_bp = 0; /* Breakpoint at branch instruction's
4006                               destination.  */
4007   CORE_ADDR loc = pc;
4008   int sc_found = 0;
4009   ULONGEST insn;
4010   int insn_count;
4011   int index;
4012
4013   /* Assume all atomic sequences start with a ll/lld instruction.  */
4014   insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, loc, NULL);
4015   if (micromips_op (insn) != 0x18)      /* POOL32C: bits 011000 */
4016     return 0;
4017   loc += MIPS_INSN16_SIZE;
4018   insn <<= 16;
4019   insn |= mips_fetch_instruction (gdbarch, ISA_MICROMIPS, loc, NULL);
4020   if ((b12s4_op (insn) & 0xb) != 0x3)   /* LL, LLD: bits 011000 0x11 */
4021     return 0;
4022   loc += MIPS_INSN16_SIZE;
4023
4024   /* Assume all atomic sequences end with an sc/scd instruction.  Assume
4025      that no atomic sequence is longer than "atomic_sequence_length"
4026      instructions.  */
4027   for (insn_count = 0;
4028        !sc_found && insn_count < atomic_sequence_length;
4029        ++insn_count)
4030     {
4031       int is_branch = 0;
4032
4033       insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, loc, NULL);
4034       loc += MIPS_INSN16_SIZE;
4035
4036       /* Assume that there is at most one conditional branch in the
4037          atomic sequence.  If a branch is found, put a breakpoint in
4038          its destination address.  */
4039       switch (mips_insn_size (ISA_MICROMIPS, insn))
4040         {
4041         /* 48-bit instructions.  */
4042         case 3 * MIPS_INSN16_SIZE: /* POOL48A: bits 011111 */
4043           loc += 2 * MIPS_INSN16_SIZE;
4044           break;
4045
4046         /* 32-bit instructions.  */
4047         case 2 * MIPS_INSN16_SIZE:
4048           switch (micromips_op (insn))
4049             {
4050             case 0x10: /* POOL32I: bits 010000 */
4051               if ((b5s5_op (insn) & 0x18) != 0x0
4052                                 /* BLTZ, BLTZAL, BGEZ, BGEZAL: 010000 000xx */
4053                                 /* BLEZ, BNEZC, BGTZ, BEQZC: 010000 001xx */
4054                   && (b5s5_op (insn) & 0x1d) != 0x11
4055                                 /* BLTZALS, BGEZALS: bits 010000 100x1 */
4056                   && ((b5s5_op (insn) & 0x1e) != 0x14
4057                       || (insn & 0x3) != 0x0)
4058                                 /* BC2F, BC2T: bits 010000 1010x xxx00 */
4059                   && (b5s5_op (insn) & 0x1e) != 0x1a
4060                                 /* BPOSGE64, BPOSGE32: bits 010000 1101x */
4061                   && ((b5s5_op (insn) & 0x1e) != 0x1c
4062                       || (insn & 0x3) != 0x0)
4063                                 /* BC1F, BC1T: bits 010000 1110x xxx00 */
4064                   && ((b5s5_op (insn) & 0x1c) != 0x1c
4065                       || (insn & 0x3) != 0x1))
4066                                 /* BC1ANY*: bits 010000 111xx xxx01 */
4067                 break;
4068               /* Fall through.  */
4069
4070             case 0x25: /* BEQ: bits 100101 */
4071             case 0x2d: /* BNE: bits 101101 */
4072               insn <<= 16;
4073               insn |= mips_fetch_instruction (gdbarch,
4074                                               ISA_MICROMIPS, loc, NULL);
4075               branch_bp = (loc + MIPS_INSN16_SIZE
4076                            + micromips_relative_offset16 (insn));
4077               is_branch = 1;
4078               break;
4079
4080             case 0x00: /* POOL32A: bits 000000 */
4081               insn <<= 16;
4082               insn |= mips_fetch_instruction (gdbarch,
4083                                               ISA_MICROMIPS, loc, NULL);
4084               if (b0s6_op (insn) != 0x3c
4085                                 /* POOL32Axf: bits 000000 ... 111100 */
4086                   || (b6s10_ext (insn) & 0x2bf) != 0x3c)
4087                                 /* JALR, JALR.HB: 000000 000x111100 111100 */
4088                                 /* JALRS, JALRS.HB: 000000 010x111100 111100 */
4089                 break;
4090               /* Fall through.  */
4091
4092             case 0x1d: /* JALS: bits 011101 */
4093             case 0x35: /* J: bits 110101 */
4094             case 0x3d: /* JAL: bits 111101 */
4095             case 0x3c: /* JALX: bits 111100 */
4096               return 0; /* Fall back to the standard single-step code. */
4097
4098             case 0x18: /* POOL32C: bits 011000 */
4099               if ((b12s4_op (insn) & 0xb) == 0xb)
4100                                 /* SC, SCD: bits 011000 1x11 */
4101                 sc_found = 1;
4102               break;
4103             }
4104           loc += MIPS_INSN16_SIZE;
4105           break;
4106
4107         /* 16-bit instructions.  */
4108         case MIPS_INSN16_SIZE:
4109           switch (micromips_op (insn))
4110             {
4111             case 0x23: /* BEQZ16: bits 100011 */
4112             case 0x2b: /* BNEZ16: bits 101011 */
4113               branch_bp = loc + micromips_relative_offset7 (insn);
4114               is_branch = 1;
4115               break;
4116
4117             case 0x11: /* POOL16C: bits 010001 */
4118               if ((b5s5_op (insn) & 0x1c) != 0xc
4119                                 /* JR16, JRC, JALR16, JALRS16: 010001 011xx */
4120                   && b5s5_op (insn) != 0x18)
4121                                 /* JRADDIUSP: bits 010001 11000 */
4122                 break;
4123               return 0; /* Fall back to the standard single-step code. */
4124
4125             case 0x33: /* B16: bits 110011 */
4126               return 0; /* Fall back to the standard single-step code. */
4127             }
4128           break;
4129         }
4130       if (is_branch)
4131         {
4132           if (last_breakpoint >= 1)
4133             return 0; /* More than one branch found, fallback to the
4134                          standard single-step code.  */
4135           breaks[1] = branch_bp;
4136           last_breakpoint++;
4137         }
4138     }
4139   if (!sc_found)
4140     return 0;
4141
4142   /* Insert a breakpoint right after the end of the atomic sequence.  */
4143   breaks[0] = loc;
4144
4145   /* Check for duplicated breakpoints.  Check also for a breakpoint
4146      placed (branch instruction's destination) in the atomic sequence */
4147   if (last_breakpoint && pc <= breaks[1] && breaks[1] <= breaks[0])
4148     last_breakpoint = 0;
4149
4150   /* Effectively inserts the breakpoints.  */
4151   for (index = 0; index <= last_breakpoint; index++)
4152     insert_single_step_breakpoint (gdbarch, aspace, breaks[index]);
4153
4154   return 1;
4155 }
4156
4157 static int
4158 deal_with_atomic_sequence (struct gdbarch *gdbarch,
4159                            struct address_space *aspace, CORE_ADDR pc)
4160 {
4161   if (mips_pc_is_mips (pc))
4162     return mips_deal_with_atomic_sequence (gdbarch, aspace, pc);
4163   else if (mips_pc_is_micromips (gdbarch, pc))
4164     return micromips_deal_with_atomic_sequence (gdbarch, aspace, pc);
4165   else
4166     return 0;
4167 }
4168
4169 /* mips_software_single_step() is called just before we want to resume
4170    the inferior, if we want to single-step it but there is no hardware
4171    or kernel single-step support (MIPS on GNU/Linux for example).  We find
4172    the target of the coming instruction and breakpoint it.  */
4173
4174 int
4175 mips_software_single_step (struct frame_info *frame)
4176 {
4177   struct gdbarch *gdbarch = get_frame_arch (frame);
4178   struct address_space *aspace = get_frame_address_space (frame);
4179   CORE_ADDR pc, next_pc;
4180
4181   pc = get_frame_pc (frame);
4182   if (deal_with_atomic_sequence (gdbarch, aspace, pc))
4183     return 1;
4184
4185   next_pc = mips_next_pc (frame, pc);
4186
4187   insert_single_step_breakpoint (gdbarch, aspace, next_pc);
4188   return 1;
4189 }
4190
4191 /* Test whether the PC points to the return instruction at the
4192    end of a function.  */
4193
4194 static int
4195 mips_about_to_return (struct gdbarch *gdbarch, CORE_ADDR pc)
4196 {
4197   ULONGEST insn;
4198   ULONGEST hint;
4199
4200   /* This used to check for MIPS16, but this piece of code is never
4201      called for MIPS16 functions.  And likewise microMIPS ones.  */
4202   gdb_assert (mips_pc_is_mips (pc));
4203
4204   insn = mips_fetch_instruction (gdbarch, ISA_MIPS, pc, NULL);
4205   hint = 0x7c0;
4206   return (insn & ~hint) == 0x3e00008;                   /* jr(.hb) $ra */
4207 }
4208
4209
4210 /* This fencepost looks highly suspicious to me.  Removing it also
4211    seems suspicious as it could affect remote debugging across serial
4212    lines.  */
4213
4214 static CORE_ADDR
4215 heuristic_proc_start (struct gdbarch *gdbarch, CORE_ADDR pc)
4216 {
4217   CORE_ADDR start_pc;
4218   CORE_ADDR fence;
4219   int instlen;
4220   int seen_adjsp = 0;
4221   struct inferior *inf;
4222
4223   pc = gdbarch_addr_bits_remove (gdbarch, pc);
4224   start_pc = pc;
4225   fence = start_pc - heuristic_fence_post;
4226   if (start_pc == 0)
4227     return 0;
4228
4229   if (heuristic_fence_post == -1 || fence < VM_MIN_ADDRESS)
4230     fence = VM_MIN_ADDRESS;
4231
4232   instlen = mips_pc_is_mips (pc) ? MIPS_INSN32_SIZE : MIPS_INSN16_SIZE;
4233
4234   inf = current_inferior ();
4235
4236   /* Search back for previous return.  */
4237   for (start_pc -= instlen;; start_pc -= instlen)
4238     if (start_pc < fence)
4239       {
4240         /* It's not clear to me why we reach this point when
4241            stop_soon, but with this test, at least we
4242            don't print out warnings for every child forked (eg, on
4243            decstation).  22apr93 rich@cygnus.com.  */
4244         if (inf->control.stop_soon == NO_STOP_QUIETLY)
4245           {
4246             static int blurb_printed = 0;
4247
4248             warning (_("GDB can't find the start of the function at %s."),
4249                      paddress (gdbarch, pc));
4250
4251             if (!blurb_printed)
4252               {
4253                 /* This actually happens frequently in embedded
4254                    development, when you first connect to a board
4255                    and your stack pointer and pc are nowhere in
4256                    particular.  This message needs to give people
4257                    in that situation enough information to
4258                    determine that it's no big deal.  */
4259                 printf_filtered ("\n\
4260     GDB is unable to find the start of the function at %s\n\
4261 and thus can't determine the size of that function's stack frame.\n\
4262 This means that GDB may be unable to access that stack frame, or\n\
4263 the frames below it.\n\
4264     This problem is most likely caused by an invalid program counter or\n\
4265 stack pointer.\n\
4266     However, if you think GDB should simply search farther back\n\
4267 from %s for code which looks like the beginning of a\n\
4268 function, you can increase the range of the search using the `set\n\
4269 heuristic-fence-post' command.\n",
4270                         paddress (gdbarch, pc), paddress (gdbarch, pc));
4271                 blurb_printed = 1;
4272               }
4273           }
4274
4275         return 0;
4276       }
4277     else if (mips_pc_is_mips16 (gdbarch, start_pc))
4278       {
4279         unsigned short inst;
4280
4281         /* On MIPS16, any one of the following is likely to be the
4282            start of a function:
4283            extend save
4284            save
4285            entry
4286            addiu sp,-n
4287            daddiu sp,-n
4288            extend -n followed by 'addiu sp,+n' or 'daddiu sp,+n'.  */
4289         inst = mips_fetch_instruction (gdbarch, ISA_MIPS16, start_pc, NULL);
4290         if ((inst & 0xff80) == 0x6480)          /* save */
4291           {
4292             if (start_pc - instlen >= fence)
4293               {
4294                 inst = mips_fetch_instruction (gdbarch, ISA_MIPS16,
4295                                                start_pc - instlen, NULL);
4296                 if ((inst & 0xf800) == 0xf000)  /* extend */
4297                   start_pc -= instlen;
4298               }
4299             break;
4300           }
4301         else if (((inst & 0xf81f) == 0xe809
4302                   && (inst & 0x700) != 0x700)   /* entry */
4303                  || (inst & 0xff80) == 0x6380   /* addiu sp,-n */
4304                  || (inst & 0xff80) == 0xfb80   /* daddiu sp,-n */
4305                  || ((inst & 0xf810) == 0xf010 && seen_adjsp))  /* extend -n */
4306           break;
4307         else if ((inst & 0xff00) == 0x6300      /* addiu sp */
4308                  || (inst & 0xff00) == 0xfb00)  /* daddiu sp */
4309           seen_adjsp = 1;
4310         else
4311           seen_adjsp = 0;
4312       }
4313     else if (mips_pc_is_micromips (gdbarch, start_pc))
4314       {
4315         ULONGEST insn;
4316         int stop = 0;
4317         long offset;
4318         int dreg;
4319         int sreg;
4320
4321         /* On microMIPS, any one of the following is likely to be the
4322            start of a function:
4323            ADDIUSP -imm
4324            (D)ADDIU $sp, -imm
4325            LUI $gp, imm  */
4326         insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, NULL);
4327         switch (micromips_op (insn))
4328           {
4329           case 0xc: /* ADDIU: bits 001100 */
4330           case 0x17: /* DADDIU: bits 010111 */
4331             sreg = b0s5_reg (insn);
4332             dreg = b5s5_reg (insn);
4333             insn <<= 16;
4334             insn |= mips_fetch_instruction (gdbarch, ISA_MICROMIPS,
4335                                             pc + MIPS_INSN16_SIZE, NULL);
4336             offset = (b0s16_imm (insn) ^ 0x8000) - 0x8000;
4337             if (sreg == MIPS_SP_REGNUM && dreg == MIPS_SP_REGNUM
4338                                 /* (D)ADDIU $sp, imm */
4339                 && offset < 0)
4340               stop = 1;
4341             break;
4342
4343           case 0x10: /* POOL32I: bits 010000 */
4344             if (b5s5_op (insn) == 0xd
4345                                 /* LUI: bits 010000 001101 */
4346                 && b0s5_reg (insn >> 16) == 28)
4347                                 /* LUI $gp, imm */
4348               stop = 1;
4349             break;
4350
4351           case 0x13: /* POOL16D: bits 010011 */
4352             if ((insn & 0x1) == 0x1)
4353                                 /* ADDIUSP: bits 010011 1 */
4354               {
4355                 offset = micromips_decode_imm9 (b1s9_imm (insn));
4356                 if (offset < 0)
4357                                 /* ADDIUSP -imm */
4358                   stop = 1;
4359               }
4360             else
4361                                 /* ADDIUS5: bits 010011 0 */
4362               {
4363                 dreg = b5s5_reg (insn);
4364                 offset = (b1s4_imm (insn) ^ 8) - 8;
4365                 if (dreg == MIPS_SP_REGNUM && offset < 0)
4366                                 /* ADDIUS5  $sp, -imm */
4367                   stop = 1;
4368               }
4369             break;
4370           }
4371         if (stop)
4372           break;
4373       }
4374     else if (mips_about_to_return (gdbarch, start_pc))
4375       {
4376         /* Skip return and its delay slot.  */
4377         start_pc += 2 * MIPS_INSN32_SIZE;
4378         break;
4379       }
4380
4381   return start_pc;
4382 }
4383
4384 struct mips_objfile_private
4385 {
4386   bfd_size_type size;
4387   char *contents;
4388 };
4389
4390 /* According to the current ABI, should the type be passed in a
4391    floating-point register (assuming that there is space)?  When there
4392    is no FPU, FP are not even considered as possible candidates for
4393    FP registers and, consequently this returns false - forces FP
4394    arguments into integer registers.  */
4395
4396 static int
4397 fp_register_arg_p (struct gdbarch *gdbarch, enum type_code typecode,
4398                    struct type *arg_type)
4399 {
4400   return ((typecode == TYPE_CODE_FLT
4401            || (MIPS_EABI (gdbarch)
4402                && (typecode == TYPE_CODE_STRUCT
4403                    || typecode == TYPE_CODE_UNION)
4404                && TYPE_NFIELDS (arg_type) == 1
4405                && TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (arg_type, 0)))
4406                == TYPE_CODE_FLT))
4407           && MIPS_FPU_TYPE(gdbarch) != MIPS_FPU_NONE);
4408 }
4409
4410 /* On o32, argument passing in GPRs depends on the alignment of the type being
4411    passed.  Return 1 if this type must be aligned to a doubleword boundary.  */
4412
4413 static int
4414 mips_type_needs_double_align (struct type *type)
4415 {
4416   enum type_code typecode = TYPE_CODE (type);
4417
4418   if (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)
4419     return 1;
4420   else if (typecode == TYPE_CODE_STRUCT)
4421     {
4422       if (TYPE_NFIELDS (type) < 1)
4423         return 0;
4424       return mips_type_needs_double_align (TYPE_FIELD_TYPE (type, 0));
4425     }
4426   else if (typecode == TYPE_CODE_UNION)
4427     {
4428       int i, n;
4429
4430       n = TYPE_NFIELDS (type);
4431       for (i = 0; i < n; i++)
4432         if (mips_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
4433           return 1;
4434       return 0;
4435     }
4436   return 0;
4437 }
4438
4439 /* Adjust the address downward (direction of stack growth) so that it
4440    is correctly aligned for a new stack frame.  */
4441 static CORE_ADDR
4442 mips_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
4443 {
4444   return align_down (addr, 16);
4445 }
4446
4447 /* Implement the "push_dummy_code" gdbarch method.  */
4448
4449 static CORE_ADDR
4450 mips_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
4451                       CORE_ADDR funaddr, struct value **args,
4452                       int nargs, struct type *value_type,
4453                       CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
4454                       struct regcache *regcache)
4455 {
4456   static gdb_byte nop_insn[] = { 0, 0, 0, 0 };
4457   CORE_ADDR nop_addr;
4458   CORE_ADDR bp_slot;
4459
4460   /* Reserve enough room on the stack for our breakpoint instruction.  */
4461   bp_slot = sp - sizeof (nop_insn);
4462
4463   /* Return to microMIPS mode if calling microMIPS code to avoid
4464      triggering an address error exception on processors that only
4465      support microMIPS execution.  */
4466   *bp_addr = (mips_pc_is_micromips (gdbarch, funaddr)
4467               ? make_compact_addr (bp_slot) : bp_slot);
4468
4469   /* The breakpoint layer automatically adjusts the address of
4470      breakpoints inserted in a branch delay slot.  With enough
4471      bad luck, the 4 bytes located just before our breakpoint
4472      instruction could look like a branch instruction, and thus
4473      trigger the adjustement, and break the function call entirely.
4474      So, we reserve those 4 bytes and write a nop instruction
4475      to prevent that from happening.  */
4476   nop_addr = bp_slot - sizeof (nop_insn);
4477   write_memory (nop_addr, nop_insn, sizeof (nop_insn));
4478   sp = mips_frame_align (gdbarch, nop_addr);
4479
4480   /* Inferior resumes at the function entry point.  */
4481   *real_pc = funaddr;
4482
4483   return sp;
4484 }
4485
4486 static CORE_ADDR
4487 mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
4488                            struct regcache *regcache, CORE_ADDR bp_addr,
4489                            int nargs, struct value **args, CORE_ADDR sp,
4490                            int struct_return, CORE_ADDR struct_addr)
4491 {
4492   int argreg;
4493   int float_argreg;
4494   int argnum;
4495   int len = 0;
4496   int stack_offset = 0;
4497   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4498   CORE_ADDR func_addr = find_function_addr (function, NULL);
4499   int regsize = mips_abi_regsize (gdbarch);
4500
4501   /* For shared libraries, "t9" needs to point at the function
4502      address.  */
4503   regcache_cooked_write_signed (regcache, MIPS_T9_REGNUM, func_addr);
4504
4505   /* Set the return address register to point to the entry point of
4506      the program, where a breakpoint lies in wait.  */
4507   regcache_cooked_write_signed (regcache, MIPS_RA_REGNUM, bp_addr);
4508
4509   /* First ensure that the stack and structure return address (if any)
4510      are properly aligned.  The stack has to be at least 64-bit
4511      aligned even on 32-bit machines, because doubles must be 64-bit
4512      aligned.  For n32 and n64, stack frames need to be 128-bit
4513      aligned, so we round to this widest known alignment.  */
4514
4515   sp = align_down (sp, 16);
4516   struct_addr = align_down (struct_addr, 16);
4517
4518   /* Now make space on the stack for the args.  We allocate more
4519      than necessary for EABI, because the first few arguments are
4520      passed in registers, but that's OK.  */
4521   for (argnum = 0; argnum < nargs; argnum++)
4522     len += align_up (TYPE_LENGTH (value_type (args[argnum])), regsize);
4523   sp -= align_up (len, 16);
4524
4525   if (mips_debug)
4526     fprintf_unfiltered (gdb_stdlog,
4527                         "mips_eabi_push_dummy_call: sp=%s allocated %ld\n",
4528                         paddress (gdbarch, sp), (long) align_up (len, 16));
4529
4530   /* Initialize the integer and float register pointers.  */
4531   argreg = MIPS_A0_REGNUM;
4532   float_argreg = mips_fpa0_regnum (gdbarch);
4533
4534   /* The struct_return pointer occupies the first parameter-passing reg.  */
4535   if (struct_return)
4536     {
4537       if (mips_debug)
4538         fprintf_unfiltered (gdb_stdlog,
4539                             "mips_eabi_push_dummy_call: "
4540                             "struct_return reg=%d %s\n",
4541                             argreg, paddress (gdbarch, struct_addr));
4542       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
4543     }
4544
4545   /* Now load as many as possible of the first arguments into
4546      registers, and push the rest onto the stack.  Loop thru args
4547      from first to last.  */
4548   for (argnum = 0; argnum < nargs; argnum++)
4549     {
4550       const gdb_byte *val;
4551       gdb_byte valbuf[MAX_REGISTER_SIZE];
4552       struct value *arg = args[argnum];
4553       struct type *arg_type = check_typedef (value_type (arg));
4554       int len = TYPE_LENGTH (arg_type);
4555       enum type_code typecode = TYPE_CODE (arg_type);
4556
4557       if (mips_debug)
4558         fprintf_unfiltered (gdb_stdlog,
4559                             "mips_eabi_push_dummy_call: %d len=%d type=%d",
4560                             argnum + 1, len, (int) typecode);
4561
4562       /* The EABI passes structures that do not fit in a register by
4563          reference.  */
4564       if (len > regsize
4565           && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
4566         {
4567           store_unsigned_integer (valbuf, regsize, byte_order,
4568                                   value_address (arg));
4569           typecode = TYPE_CODE_PTR;
4570           len = regsize;
4571           val = valbuf;
4572           if (mips_debug)
4573             fprintf_unfiltered (gdb_stdlog, " push");
4574         }
4575       else
4576         val = value_contents (arg);
4577
4578       /* 32-bit ABIs always start floating point arguments in an
4579          even-numbered floating point register.  Round the FP register
4580          up before the check to see if there are any FP registers
4581          left.  Non MIPS_EABI targets also pass the FP in the integer
4582          registers so also round up normal registers.  */
4583       if (regsize < 8 && fp_register_arg_p (gdbarch, typecode, arg_type))
4584         {
4585           if ((float_argreg & 1))
4586             float_argreg++;
4587         }
4588
4589       /* Floating point arguments passed in registers have to be
4590          treated specially.  On 32-bit architectures, doubles
4591          are passed in register pairs; the even register gets
4592          the low word, and the odd register gets the high word.
4593          On non-EABI processors, the first two floating point arguments are
4594          also copied to general registers, because MIPS16 functions
4595          don't use float registers for arguments.  This duplication of
4596          arguments in general registers can't hurt non-MIPS16 functions
4597          because those registers are normally skipped.  */
4598       /* MIPS_EABI squeezes a struct that contains a single floating
4599          point value into an FP register instead of pushing it onto the
4600          stack.  */
4601       if (fp_register_arg_p (gdbarch, typecode, arg_type)
4602           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM (gdbarch))
4603         {
4604           /* EABI32 will pass doubles in consecutive registers, even on
4605              64-bit cores.  At one time, we used to check the size of
4606              `float_argreg' to determine whether or not to pass doubles
4607              in consecutive registers, but this is not sufficient for
4608              making the ABI determination.  */
4609           if (len == 8 && mips_abi (gdbarch) == MIPS_ABI_EABI32)
4610             {
4611               int low_offset = gdbarch_byte_order (gdbarch)
4612                                == BFD_ENDIAN_BIG ? 4 : 0;
4613               long regval;
4614
4615               /* Write the low word of the double to the even register(s).  */
4616               regval = extract_signed_integer (val + low_offset,
4617                                                4, byte_order);
4618               if (mips_debug)
4619                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
4620                                     float_argreg, phex (regval, 4));
4621               regcache_cooked_write_signed (regcache, float_argreg++, regval);
4622
4623               /* Write the high word of the double to the odd register(s).  */
4624               regval = extract_signed_integer (val + 4 - low_offset,
4625                                                4, byte_order);
4626               if (mips_debug)
4627                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
4628                                     float_argreg, phex (regval, 4));
4629               regcache_cooked_write_signed (regcache, float_argreg++, regval);
4630             }
4631           else
4632             {
4633               /* This is a floating point value that fits entirely
4634                  in a single register.  */
4635               /* On 32 bit ABI's the float_argreg is further adjusted
4636                  above to ensure that it is even register aligned.  */
4637               LONGEST regval = extract_signed_integer (val, len, byte_order);
4638               if (mips_debug)
4639                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
4640                                     float_argreg, phex (regval, len));
4641               regcache_cooked_write_signed (regcache, float_argreg++, regval);
4642             }
4643         }
4644       else
4645         {
4646           /* Copy the argument to general registers or the stack in
4647              register-sized pieces.  Large arguments are split between
4648              registers and stack.  */
4649           /* Note: structs whose size is not a multiple of regsize
4650              are treated specially: Irix cc passes
4651              them in registers where gcc sometimes puts them on the
4652              stack.  For maximum compatibility, we will put them in
4653              both places.  */
4654           int odd_sized_struct = (len > regsize && len % regsize != 0);
4655
4656           /* Note: Floating-point values that didn't fit into an FP
4657              register are only written to memory.  */
4658           while (len > 0)
4659             {
4660               /* Remember if the argument was written to the stack.  */
4661               int stack_used_p = 0;
4662               int partial_len = (len < regsize ? len : regsize);
4663
4664               if (mips_debug)
4665                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
4666                                     partial_len);
4667
4668               /* Write this portion of the argument to the stack.  */
4669               if (argreg > MIPS_LAST_ARG_REGNUM (gdbarch)
4670                   || odd_sized_struct
4671                   || fp_register_arg_p (gdbarch, typecode, arg_type))
4672                 {
4673                   /* Should shorter than int integer values be
4674                      promoted to int before being stored?  */
4675                   int longword_offset = 0;
4676                   CORE_ADDR addr;
4677                   stack_used_p = 1;
4678                   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
4679                     {
4680                       if (regsize == 8
4681                           && (typecode == TYPE_CODE_INT
4682                               || typecode == TYPE_CODE_PTR
4683                               || typecode == TYPE_CODE_FLT) && len <= 4)
4684                         longword_offset = regsize - len;
4685                       else if ((typecode == TYPE_CODE_STRUCT
4686                                 || typecode == TYPE_CODE_UNION)
4687                                && TYPE_LENGTH (arg_type) < regsize)
4688                         longword_offset = regsize - len;
4689                     }
4690
4691                   if (mips_debug)
4692                     {
4693                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
4694                                           paddress (gdbarch, stack_offset));
4695                       fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
4696                                           paddress (gdbarch, longword_offset));
4697                     }
4698
4699                   addr = sp + stack_offset + longword_offset;
4700
4701                   if (mips_debug)
4702                     {
4703                       int i;
4704                       fprintf_unfiltered (gdb_stdlog, " @%s ",
4705                                           paddress (gdbarch, addr));
4706                       for (i = 0; i < partial_len; i++)
4707                         {
4708                           fprintf_unfiltered (gdb_stdlog, "%02x",
4709                                               val[i] & 0xff);
4710                         }
4711                     }
4712                   write_memory (addr, val, partial_len);
4713                 }
4714
4715               /* Note!!! This is NOT an else clause.  Odd sized
4716                  structs may go thru BOTH paths.  Floating point
4717                  arguments will not.  */
4718               /* Write this portion of the argument to a general
4719                  purpose register.  */
4720               if (argreg <= MIPS_LAST_ARG_REGNUM (gdbarch)
4721                   && !fp_register_arg_p (gdbarch, typecode, arg_type))
4722                 {
4723                   LONGEST regval =
4724                     extract_signed_integer (val, partial_len, byte_order);
4725
4726                   if (mips_debug)
4727                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
4728                                       argreg,
4729                                       phex (regval, regsize));
4730                   regcache_cooked_write_signed (regcache, argreg, regval);
4731                   argreg++;
4732                 }
4733
4734               len -= partial_len;
4735               val += partial_len;
4736
4737               /* Compute the offset into the stack at which we will
4738                  copy the next parameter.
4739
4740                  In the new EABI (and the NABI32), the stack_offset
4741                  only needs to be adjusted when it has been used.  */
4742
4743               if (stack_used_p)
4744                 stack_offset += align_up (partial_len, regsize);
4745             }
4746         }
4747       if (mips_debug)
4748         fprintf_unfiltered (gdb_stdlog, "\n");
4749     }
4750
4751   regcache_cooked_write_signed (regcache, MIPS_SP_REGNUM, sp);
4752
4753   /* Return adjusted stack pointer.  */
4754   return sp;
4755 }
4756
4757 /* Determine the return value convention being used.  */
4758
4759 static enum return_value_convention
4760 mips_eabi_return_value (struct gdbarch *gdbarch, struct value *function,
4761                         struct type *type, struct regcache *regcache,
4762                         gdb_byte *readbuf, const gdb_byte *writebuf)
4763 {
4764   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4765   int fp_return_type = 0;
4766   int offset, regnum, xfer;
4767
4768   if (TYPE_LENGTH (type) > 2 * mips_abi_regsize (gdbarch))
4769     return RETURN_VALUE_STRUCT_CONVENTION;
4770
4771   /* Floating point type?  */
4772   if (tdep->mips_fpu_type != MIPS_FPU_NONE)
4773     {
4774       if (TYPE_CODE (type) == TYPE_CODE_FLT)
4775         fp_return_type = 1;
4776       /* Structs with a single field of float type
4777          are returned in a floating point register.  */
4778       if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
4779            || TYPE_CODE (type) == TYPE_CODE_UNION)
4780           && TYPE_NFIELDS (type) == 1)
4781         {
4782           struct type *fieldtype = TYPE_FIELD_TYPE (type, 0);
4783
4784           if (TYPE_CODE (check_typedef (fieldtype)) == TYPE_CODE_FLT)
4785             fp_return_type = 1;
4786         }
4787     }
4788
4789   if (fp_return_type)
4790     {
4791       /* A floating-point value belongs in the least significant part
4792          of FP0/FP1.  */
4793       if (mips_debug)
4794         fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
4795       regnum = mips_regnum (gdbarch)->fp0;
4796     }
4797   else
4798     {
4799       /* An integer value goes in V0/V1.  */
4800       if (mips_debug)
4801         fprintf_unfiltered (gdb_stderr, "Return scalar in $v0\n");
4802       regnum = MIPS_V0_REGNUM;
4803     }
4804   for (offset = 0;
4805        offset < TYPE_LENGTH (type);
4806        offset += mips_abi_regsize (gdbarch), regnum++)
4807     {
4808       xfer = mips_abi_regsize (gdbarch);
4809       if (offset + xfer > TYPE_LENGTH (type))
4810         xfer = TYPE_LENGTH (type) - offset;
4811       mips_xfer_register (gdbarch, regcache,
4812                           gdbarch_num_regs (gdbarch) + regnum, xfer,
4813                           gdbarch_byte_order (gdbarch), readbuf, writebuf,
4814                           offset);
4815     }
4816
4817   return RETURN_VALUE_REGISTER_CONVENTION;
4818 }
4819
4820
4821 /* N32/N64 ABI stuff.  */
4822
4823 /* Search for a naturally aligned double at OFFSET inside a struct
4824    ARG_TYPE.  The N32 / N64 ABIs pass these in floating point
4825    registers.  */
4826
4827 static int
4828 mips_n32n64_fp_arg_chunk_p (struct gdbarch *gdbarch, struct type *arg_type,
4829                             int offset)
4830 {
4831   int i;
4832
4833   if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
4834     return 0;
4835
4836   if (MIPS_FPU_TYPE (gdbarch) != MIPS_FPU_DOUBLE)
4837     return 0;
4838
4839   if (TYPE_LENGTH (arg_type) < offset + MIPS64_REGSIZE)
4840     return 0;
4841
4842   for (i = 0; i < TYPE_NFIELDS (arg_type); i++)
4843     {
4844       int pos;
4845       struct type *field_type;
4846
4847       /* We're only looking at normal fields.  */
4848       if (field_is_static (&TYPE_FIELD (arg_type, i))
4849           || (TYPE_FIELD_BITPOS (arg_type, i) % 8) != 0)
4850         continue;
4851
4852       /* If we have gone past the offset, there is no double to pass.  */
4853       pos = TYPE_FIELD_BITPOS (arg_type, i) / 8;
4854       if (pos > offset)
4855         return 0;
4856
4857       field_type = check_typedef (TYPE_FIELD_TYPE (arg_type, i));
4858
4859       /* If this field is entirely before the requested offset, go
4860          on to the next one.  */
4861       if (pos + TYPE_LENGTH (field_type) <= offset)
4862         continue;
4863
4864       /* If this is our special aligned double, we can stop.  */
4865       if (TYPE_CODE (field_type) == TYPE_CODE_FLT
4866           && TYPE_LENGTH (field_type) == MIPS64_REGSIZE)
4867         return 1;
4868
4869       /* This field starts at or before the requested offset, and
4870          overlaps it.  If it is a structure, recurse inwards.  */
4871       return mips_n32n64_fp_arg_chunk_p (gdbarch, field_type, offset - pos);
4872     }
4873
4874   return 0;
4875 }
4876
4877 static CORE_ADDR
4878 mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
4879                              struct regcache *regcache, CORE_ADDR bp_addr,
4880                              int nargs, struct value **args, CORE_ADDR sp,
4881                              int struct_return, CORE_ADDR struct_addr)
4882 {
4883   int argreg;
4884   int float_argreg;
4885   int argnum;
4886   int len = 0;
4887   int stack_offset = 0;
4888   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4889   CORE_ADDR func_addr = find_function_addr (function, NULL);
4890
4891   /* For shared libraries, "t9" needs to point at the function
4892      address.  */
4893   regcache_cooked_write_signed (regcache, MIPS_T9_REGNUM, func_addr);
4894
4895   /* Set the return address register to point to the entry point of
4896      the program, where a breakpoint lies in wait.  */
4897   regcache_cooked_write_signed (regcache, MIPS_RA_REGNUM, bp_addr);
4898
4899   /* First ensure that the stack and structure return address (if any)
4900      are properly aligned.  The stack has to be at least 64-bit
4901      aligned even on 32-bit machines, because doubles must be 64-bit
4902      aligned.  For n32 and n64, stack frames need to be 128-bit
4903      aligned, so we round to this widest known alignment.  */
4904
4905   sp = align_down (sp, 16);
4906   struct_addr = align_down (struct_addr, 16);
4907
4908   /* Now make space on the stack for the args.  */
4909   for (argnum = 0; argnum < nargs; argnum++)
4910     len += align_up (TYPE_LENGTH (value_type (args[argnum])), MIPS64_REGSIZE);
4911   sp -= align_up (len, 16);
4912
4913   if (mips_debug)
4914     fprintf_unfiltered (gdb_stdlog,
4915                         "mips_n32n64_push_dummy_call: sp=%s allocated %ld\n",
4916                         paddress (gdbarch, sp), (long) align_up (len, 16));
4917
4918   /* Initialize the integer and float register pointers.  */
4919   argreg = MIPS_A0_REGNUM;
4920   float_argreg = mips_fpa0_regnum (gdbarch);
4921
4922   /* The struct_return pointer occupies the first parameter-passing reg.  */
4923   if (struct_return)
4924     {
4925       if (mips_debug)
4926         fprintf_unfiltered (gdb_stdlog,
4927                             "mips_n32n64_push_dummy_call: "
4928                             "struct_return reg=%d %s\n",
4929                             argreg, paddress (gdbarch, struct_addr));
4930       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
4931     }
4932
4933   /* Now load as many as possible of the first arguments into
4934      registers, and push the rest onto the stack.  Loop thru args
4935      from first to last.  */
4936   for (argnum = 0; argnum < nargs; argnum++)
4937     {
4938       const gdb_byte *val;
4939       struct value *arg = args[argnum];
4940       struct type *arg_type = check_typedef (value_type (arg));
4941       int len = TYPE_LENGTH (arg_type);
4942       enum type_code typecode = TYPE_CODE (arg_type);
4943
4944       if (mips_debug)
4945         fprintf_unfiltered (gdb_stdlog,
4946                             "mips_n32n64_push_dummy_call: %d len=%d type=%d",
4947                             argnum + 1, len, (int) typecode);
4948
4949       val = value_contents (arg);
4950
4951       /* A 128-bit long double value requires an even-odd pair of
4952          floating-point registers.  */
4953       if (len == 16
4954           && fp_register_arg_p (gdbarch, typecode, arg_type)
4955           && (float_argreg & 1))
4956         {
4957           float_argreg++;
4958           argreg++;
4959         }
4960
4961       if (fp_register_arg_p (gdbarch, typecode, arg_type)
4962           && argreg <= MIPS_LAST_ARG_REGNUM (gdbarch))
4963         {
4964           /* This is a floating point value that fits entirely
4965              in a single register or a pair of registers.  */
4966           int reglen = (len <= MIPS64_REGSIZE ? len : MIPS64_REGSIZE);
4967           LONGEST regval = extract_unsigned_integer (val, reglen, byte_order);
4968           if (mips_debug)
4969             fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
4970                                 float_argreg, phex (regval, reglen));
4971           regcache_cooked_write_unsigned (regcache, float_argreg, regval);
4972
4973           if (mips_debug)
4974             fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
4975                                 argreg, phex (regval, reglen));
4976           regcache_cooked_write_unsigned (regcache, argreg, regval);
4977           float_argreg++;
4978           argreg++;
4979           if (len == 16)
4980             {
4981               regval = extract_unsigned_integer (val + reglen,
4982                                                  reglen, byte_order);
4983               if (mips_debug)
4984                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
4985                                     float_argreg, phex (regval, reglen));
4986               regcache_cooked_write_unsigned (regcache, float_argreg, regval);
4987
4988               if (mips_debug)
4989                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
4990                                     argreg, phex (regval, reglen));
4991               regcache_cooked_write_unsigned (regcache, argreg, regval);
4992               float_argreg++;
4993               argreg++;
4994             }
4995         }
4996       else
4997         {
4998           /* Copy the argument to general registers or the stack in
4999              register-sized pieces.  Large arguments are split between
5000              registers and stack.  */
5001           /* For N32/N64, structs, unions, or other composite types are
5002              treated as a sequence of doublewords, and are passed in integer
5003              or floating point registers as though they were simple scalar
5004              parameters to the extent that they fit, with any excess on the
5005              stack packed according to the normal memory layout of the
5006              object.
5007              The caller does not reserve space for the register arguments;
5008              the callee is responsible for reserving it if required.  */
5009           /* Note: Floating-point values that didn't fit into an FP
5010              register are only written to memory.  */
5011           while (len > 0)
5012             {
5013               /* Remember if the argument was written to the stack.  */
5014               int stack_used_p = 0;
5015               int partial_len = (len < MIPS64_REGSIZE ? len : MIPS64_REGSIZE);
5016
5017               if (mips_debug)
5018                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
5019                                     partial_len);
5020
5021               if (fp_register_arg_p (gdbarch, typecode, arg_type))
5022                 gdb_assert (argreg > MIPS_LAST_ARG_REGNUM (gdbarch));
5023
5024               /* Write this portion of the argument to the stack.  */
5025               if (argreg > MIPS_LAST_ARG_REGNUM (gdbarch))
5026                 {
5027                   /* Should shorter than int integer values be
5028                      promoted to int before being stored?  */
5029                   int longword_offset = 0;
5030                   CORE_ADDR addr;
5031                   stack_used_p = 1;
5032                   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
5033                     {
5034                       if ((typecode == TYPE_CODE_INT
5035                            || typecode == TYPE_CODE_PTR)
5036                           && len <= 4)
5037                         longword_offset = MIPS64_REGSIZE - len;
5038                     }
5039
5040                   if (mips_debug)
5041                     {
5042                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
5043                                           paddress (gdbarch, stack_offset));
5044                       fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
5045                                           paddress (gdbarch, longword_offset));
5046                     }
5047
5048                   addr = sp + stack_offset + longword_offset;
5049
5050                   if (mips_debug)
5051                     {
5052                       int i;
5053                       fprintf_unfiltered (gdb_stdlog, " @%s ",
5054                                           paddress (gdbarch, addr));
5055                       for (i = 0; i < partial_len; i++)
5056                         {
5057                           fprintf_unfiltered (gdb_stdlog, "%02x",
5058                                               val[i] & 0xff);
5059                         }
5060                     }
5061                   write_memory (addr, val, partial_len);
5062                 }
5063
5064               /* Note!!! This is NOT an else clause.  Odd sized
5065                  structs may go thru BOTH paths.  */
5066               /* Write this portion of the argument to a general
5067                  purpose register.  */
5068               if (argreg <= MIPS_LAST_ARG_REGNUM (gdbarch))
5069                 {
5070                   LONGEST regval;
5071
5072                   /* Sign extend pointers, 32-bit integers and signed
5073                      16-bit and 8-bit integers; everything else is taken
5074                      as is.  */
5075
5076                   if ((partial_len == 4
5077                        && (typecode == TYPE_CODE_PTR
5078                            || typecode == TYPE_CODE_INT))
5079                       || (partial_len < 4
5080                           && typecode == TYPE_CODE_INT
5081                           && !TYPE_UNSIGNED (arg_type)))
5082                     regval = extract_signed_integer (val, partial_len,
5083                                                      byte_order);
5084                   else
5085                     regval = extract_unsigned_integer (val, partial_len,
5086                                                        byte_order);
5087
5088                   /* A non-floating-point argument being passed in a
5089                      general register.  If a struct or union, and if
5090                      the remaining length is smaller than the register
5091                      size, we have to adjust the register value on
5092                      big endian targets.
5093
5094                      It does not seem to be necessary to do the
5095                      same for integral types.  */
5096
5097                   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
5098                       && partial_len < MIPS64_REGSIZE
5099                       && (typecode == TYPE_CODE_STRUCT
5100                           || typecode == TYPE_CODE_UNION))
5101                     regval <<= ((MIPS64_REGSIZE - partial_len)
5102                                 * TARGET_CHAR_BIT);
5103
5104                   if (mips_debug)
5105                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
5106                                       argreg,
5107                                       phex (regval, MIPS64_REGSIZE));
5108                   regcache_cooked_write_unsigned (regcache, argreg, regval);
5109
5110                   if (mips_n32n64_fp_arg_chunk_p (gdbarch, arg_type,
5111                                                   TYPE_LENGTH (arg_type) - len))
5112                     {
5113                       if (mips_debug)
5114                         fprintf_filtered (gdb_stdlog, " - fpreg=%d val=%s",
5115                                           float_argreg,
5116                                           phex (regval, MIPS64_REGSIZE));
5117                       regcache_cooked_write_unsigned (regcache, float_argreg,
5118                                                       regval);
5119                     }
5120
5121                   float_argreg++;
5122                   argreg++;
5123                 }
5124
5125               len -= partial_len;
5126               val += partial_len;
5127
5128               /* Compute the offset into the stack at which we will
5129                  copy the next parameter.
5130
5131                  In N32 (N64?), the stack_offset only needs to be
5132                  adjusted when it has been used.  */
5133
5134               if (stack_used_p)
5135                 stack_offset += align_up (partial_len, MIPS64_REGSIZE);
5136             }
5137         }
5138       if (mips_debug)
5139         fprintf_unfiltered (gdb_stdlog, "\n");
5140     }
5141
5142   regcache_cooked_write_signed (regcache, MIPS_SP_REGNUM, sp);
5143
5144   /* Return adjusted stack pointer.  */
5145   return sp;
5146 }
5147
5148 static enum return_value_convention
5149 mips_n32n64_return_value (struct gdbarch *gdbarch, struct value *function,
5150                           struct type *type, struct regcache *regcache,
5151                           gdb_byte *readbuf, const gdb_byte *writebuf)
5152 {
5153   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5154
5155   /* From MIPSpro N32 ABI Handbook, Document Number: 007-2816-004
5156
5157      Function results are returned in $2 (and $3 if needed), or $f0 (and $f2
5158      if needed), as appropriate for the type.  Composite results (struct,
5159      union, or array) are returned in $2/$f0 and $3/$f2 according to the
5160      following rules:
5161
5162      * A struct with only one or two floating point fields is returned in $f0
5163      (and $f2 if necessary).  This is a generalization of the Fortran COMPLEX
5164      case.
5165
5166      * Any other composite results of at most 128 bits are returned in
5167      $2 (first 64 bits) and $3 (remainder, if necessary).
5168
5169      * Larger composite results are handled by converting the function to a
5170      procedure with an implicit first parameter, which is a pointer to an area
5171      reserved by the caller to receive the result.  [The o32-bit ABI requires
5172      that all composite results be handled by conversion to implicit first
5173      parameters.  The MIPS/SGI Fortran implementation has always made a
5174      specific exception to return COMPLEX results in the floating point
5175      registers.]  */
5176
5177   if (TYPE_LENGTH (type) > 2 * MIPS64_REGSIZE)
5178     return RETURN_VALUE_STRUCT_CONVENTION;
5179   else if (TYPE_CODE (type) == TYPE_CODE_FLT
5180            && TYPE_LENGTH (type) == 16
5181            && tdep->mips_fpu_type != MIPS_FPU_NONE)
5182     {
5183       /* A 128-bit floating-point value fills both $f0 and $f2.  The
5184          two registers are used in the same as memory order, so the
5185          eight bytes with the lower memory address are in $f0.  */
5186       if (mips_debug)
5187         fprintf_unfiltered (gdb_stderr, "Return float in $f0 and $f2\n");
5188       mips_xfer_register (gdbarch, regcache,
5189                           (gdbarch_num_regs (gdbarch)
5190                            + mips_regnum (gdbarch)->fp0),
5191                           8, gdbarch_byte_order (gdbarch),
5192                           readbuf, writebuf, 0);
5193       mips_xfer_register (gdbarch, regcache,
5194                           (gdbarch_num_regs (gdbarch)
5195                            + mips_regnum (gdbarch)->fp0 + 2),
5196                           8, gdbarch_byte_order (gdbarch),
5197                           readbuf ? readbuf + 8 : readbuf,
5198                           writebuf ? writebuf + 8 : writebuf, 0);
5199       return RETURN_VALUE_REGISTER_CONVENTION;
5200     }
5201   else if (TYPE_CODE (type) == TYPE_CODE_FLT
5202            && tdep->mips_fpu_type != MIPS_FPU_NONE)
5203     {
5204       /* A single or double floating-point value that fits in FP0.  */
5205       if (mips_debug)
5206         fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
5207       mips_xfer_register (gdbarch, regcache,
5208                           (gdbarch_num_regs (gdbarch)
5209                            + mips_regnum (gdbarch)->fp0),
5210                           TYPE_LENGTH (type),
5211                           gdbarch_byte_order (gdbarch),
5212                           readbuf, writebuf, 0);
5213       return RETURN_VALUE_REGISTER_CONVENTION;
5214     }
5215   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
5216            && TYPE_NFIELDS (type) <= 2
5217            && TYPE_NFIELDS (type) >= 1
5218            && ((TYPE_NFIELDS (type) == 1
5219                 && (TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type, 0)))
5220                     == TYPE_CODE_FLT))
5221                || (TYPE_NFIELDS (type) == 2
5222                    && (TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type, 0)))
5223                        == TYPE_CODE_FLT)
5224                    && (TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type, 1)))
5225                        == TYPE_CODE_FLT))))
5226     {
5227       /* A struct that contains one or two floats.  Each value is part
5228          in the least significant part of their floating point
5229          register (or GPR, for soft float).  */
5230       int regnum;
5231       int field;
5232       for (field = 0, regnum = (tdep->mips_fpu_type != MIPS_FPU_NONE
5233                                 ? mips_regnum (gdbarch)->fp0
5234                                 : MIPS_V0_REGNUM);
5235            field < TYPE_NFIELDS (type); field++, regnum += 2)
5236         {
5237           int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
5238                         / TARGET_CHAR_BIT);
5239           if (mips_debug)
5240             fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
5241                                 offset);
5242           if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)) == 16)
5243             {
5244               /* A 16-byte long double field goes in two consecutive
5245                  registers.  */
5246               mips_xfer_register (gdbarch, regcache,
5247                                   gdbarch_num_regs (gdbarch) + regnum,
5248                                   8,
5249                                   gdbarch_byte_order (gdbarch),
5250                                   readbuf, writebuf, offset);
5251               mips_xfer_register (gdbarch, regcache,
5252                                   gdbarch_num_regs (gdbarch) + regnum + 1,
5253                                   8,
5254                                   gdbarch_byte_order (gdbarch),
5255                                   readbuf, writebuf, offset + 8);
5256             }
5257           else
5258             mips_xfer_register (gdbarch, regcache,
5259                                 gdbarch_num_regs (gdbarch) + regnum,
5260                                 TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
5261                                 gdbarch_byte_order (gdbarch),
5262                                 readbuf, writebuf, offset);
5263         }
5264       return RETURN_VALUE_REGISTER_CONVENTION;
5265     }
5266   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
5267            || TYPE_CODE (type) == TYPE_CODE_UNION
5268            || TYPE_CODE (type) == TYPE_CODE_ARRAY)
5269     {
5270       /* A composite type.  Extract the left justified value,
5271          regardless of the byte order.  I.e. DO NOT USE
5272          mips_xfer_lower.  */
5273       int offset;
5274       int regnum;
5275       for (offset = 0, regnum = MIPS_V0_REGNUM;
5276            offset < TYPE_LENGTH (type);
5277            offset += register_size (gdbarch, regnum), regnum++)
5278         {
5279           int xfer = register_size (gdbarch, regnum);
5280           if (offset + xfer > TYPE_LENGTH (type))
5281             xfer = TYPE_LENGTH (type) - offset;
5282           if (mips_debug)
5283             fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
5284                                 offset, xfer, regnum);
5285           mips_xfer_register (gdbarch, regcache,
5286                               gdbarch_num_regs (gdbarch) + regnum,
5287                               xfer, BFD_ENDIAN_UNKNOWN, readbuf, writebuf,
5288                               offset);
5289         }
5290       return RETURN_VALUE_REGISTER_CONVENTION;
5291     }
5292   else
5293     {
5294       /* A scalar extract each part but least-significant-byte
5295          justified.  */
5296       int offset;
5297       int regnum;
5298       for (offset = 0, regnum = MIPS_V0_REGNUM;
5299            offset < TYPE_LENGTH (type);
5300            offset += register_size (gdbarch, regnum), regnum++)
5301         {
5302           int xfer = register_size (gdbarch, regnum);
5303           if (offset + xfer > TYPE_LENGTH (type))
5304             xfer = TYPE_LENGTH (type) - offset;
5305           if (mips_debug)
5306             fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
5307                                 offset, xfer, regnum);
5308           mips_xfer_register (gdbarch, regcache,
5309                               gdbarch_num_regs (gdbarch) + regnum,
5310                               xfer, gdbarch_byte_order (gdbarch),
5311                               readbuf, writebuf, offset);
5312         }
5313       return RETURN_VALUE_REGISTER_CONVENTION;
5314     }
5315 }
5316
5317 /* Which registers to use for passing floating-point values between
5318    function calls, one of floating-point, general and both kinds of
5319    registers.  O32 and O64 use different register kinds for standard
5320    MIPS and MIPS16 code; to make the handling of cases where we may
5321    not know what kind of code is being used (e.g. no debug information)
5322    easier we sometimes use both kinds.  */
5323
5324 enum mips_fval_reg
5325 {
5326   mips_fval_fpr,
5327   mips_fval_gpr,
5328   mips_fval_both
5329 };
5330
5331 /* O32 ABI stuff.  */
5332
5333 static CORE_ADDR
5334 mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
5335                           struct regcache *regcache, CORE_ADDR bp_addr,
5336                           int nargs, struct value **args, CORE_ADDR sp,
5337                           int struct_return, CORE_ADDR struct_addr)
5338 {
5339   int argreg;
5340   int float_argreg;
5341   int argnum;
5342   int len = 0;
5343   int stack_offset = 0;
5344   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
5345   CORE_ADDR func_addr = find_function_addr (function, NULL);
5346
5347   /* For shared libraries, "t9" needs to point at the function
5348      address.  */
5349   regcache_cooked_write_signed (regcache, MIPS_T9_REGNUM, func_addr);
5350
5351   /* Set the return address register to point to the entry point of
5352      the program, where a breakpoint lies in wait.  */
5353   regcache_cooked_write_signed (regcache, MIPS_RA_REGNUM, bp_addr);
5354
5355   /* First ensure that the stack and structure return address (if any)
5356      are properly aligned.  The stack has to be at least 64-bit
5357      aligned even on 32-bit machines, because doubles must be 64-bit
5358      aligned.  For n32 and n64, stack frames need to be 128-bit
5359      aligned, so we round to this widest known alignment.  */
5360
5361   sp = align_down (sp, 16);
5362   struct_addr = align_down (struct_addr, 16);
5363
5364   /* Now make space on the stack for the args.  */
5365   for (argnum = 0; argnum < nargs; argnum++)
5366     {
5367       struct type *arg_type = check_typedef (value_type (args[argnum]));
5368
5369       /* Align to double-word if necessary.  */
5370       if (mips_type_needs_double_align (arg_type))
5371         len = align_up (len, MIPS32_REGSIZE * 2);
5372       /* Allocate space on the stack.  */
5373       len += align_up (TYPE_LENGTH (arg_type), MIPS32_REGSIZE);
5374     }
5375   sp -= align_up (len, 16);
5376
5377   if (mips_debug)
5378     fprintf_unfiltered (gdb_stdlog,
5379                         "mips_o32_push_dummy_call: sp=%s allocated %ld\n",
5380                         paddress (gdbarch, sp), (long) align_up (len, 16));
5381
5382   /* Initialize the integer and float register pointers.  */
5383   argreg = MIPS_A0_REGNUM;
5384   float_argreg = mips_fpa0_regnum (gdbarch);
5385
5386   /* The struct_return pointer occupies the first parameter-passing reg.  */
5387   if (struct_return)
5388     {
5389       if (mips_debug)
5390         fprintf_unfiltered (gdb_stdlog,
5391                             "mips_o32_push_dummy_call: "
5392                             "struct_return reg=%d %s\n",
5393                             argreg, paddress (gdbarch, struct_addr));
5394       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
5395       stack_offset += MIPS32_REGSIZE;
5396     }
5397
5398   /* Now load as many as possible of the first arguments into
5399      registers, and push the rest onto the stack.  Loop thru args
5400      from first to last.  */
5401   for (argnum = 0; argnum < nargs; argnum++)
5402     {
5403       const gdb_byte *val;
5404       struct value *arg = args[argnum];
5405       struct type *arg_type = check_typedef (value_type (arg));
5406       int len = TYPE_LENGTH (arg_type);
5407       enum type_code typecode = TYPE_CODE (arg_type);
5408
5409       if (mips_debug)
5410         fprintf_unfiltered (gdb_stdlog,
5411                             "mips_o32_push_dummy_call: %d len=%d type=%d",
5412                             argnum + 1, len, (int) typecode);
5413
5414       val = value_contents (arg);
5415
5416       /* 32-bit ABIs always start floating point arguments in an
5417          even-numbered floating point register.  Round the FP register
5418          up before the check to see if there are any FP registers
5419          left.  O32 targets also pass the FP in the integer registers
5420          so also round up normal registers.  */
5421       if (fp_register_arg_p (gdbarch, typecode, arg_type))
5422         {
5423           if ((float_argreg & 1))
5424             float_argreg++;
5425         }
5426
5427       /* Floating point arguments passed in registers have to be
5428          treated specially.  On 32-bit architectures, doubles are
5429          passed in register pairs; the even FP register gets the
5430          low word, and the odd FP register gets the high word.
5431          On O32, the first two floating point arguments are also
5432          copied to general registers, following their memory order,
5433          because MIPS16 functions don't use float registers for
5434          arguments.  This duplication of arguments in general
5435          registers can't hurt non-MIPS16 functions, because those
5436          registers are normally skipped.  */
5437
5438       if (fp_register_arg_p (gdbarch, typecode, arg_type)
5439           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM (gdbarch))
5440         {
5441           if (register_size (gdbarch, float_argreg) < 8 && len == 8)
5442             {
5443               int freg_offset = gdbarch_byte_order (gdbarch)
5444                                 == BFD_ENDIAN_BIG ? 1 : 0;
5445               unsigned long regval;
5446
5447               /* First word.  */
5448               regval = extract_unsigned_integer (val, 4, byte_order);
5449               if (mips_debug)
5450                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
5451                                     float_argreg + freg_offset,
5452                                     phex (regval, 4));
5453               regcache_cooked_write_unsigned (regcache,
5454                                               float_argreg++ + freg_offset,
5455                                               regval);
5456               if (mips_debug)
5457                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
5458                                     argreg, phex (regval, 4));
5459               regcache_cooked_write_unsigned (regcache, argreg++, regval);
5460
5461               /* Second word.  */
5462               regval = extract_unsigned_integer (val + 4, 4, byte_order);
5463               if (mips_debug)
5464                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
5465                                     float_argreg - freg_offset,
5466                                     phex (regval, 4));
5467               regcache_cooked_write_unsigned (regcache,
5468                                               float_argreg++ - freg_offset,
5469                                               regval);
5470               if (mips_debug)
5471                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
5472                                     argreg, phex (regval, 4));
5473               regcache_cooked_write_unsigned (regcache, argreg++, regval);
5474             }
5475           else
5476             {
5477               /* This is a floating point value that fits entirely
5478                  in a single register.  */
5479               /* On 32 bit ABI's the float_argreg is further adjusted
5480                  above to ensure that it is even register aligned.  */
5481               LONGEST regval = extract_unsigned_integer (val, len, byte_order);
5482               if (mips_debug)
5483                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
5484                                     float_argreg, phex (regval, len));
5485               regcache_cooked_write_unsigned (regcache,
5486                                               float_argreg++, regval);
5487               /* Although two FP registers are reserved for each
5488                  argument, only one corresponding integer register is
5489                  reserved.  */
5490               if (mips_debug)
5491                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
5492                                     argreg, phex (regval, len));
5493               regcache_cooked_write_unsigned (regcache, argreg++, regval);
5494             }
5495           /* Reserve space for the FP register.  */
5496           stack_offset += align_up (len, MIPS32_REGSIZE);
5497         }
5498       else
5499         {
5500           /* Copy the argument to general registers or the stack in
5501              register-sized pieces.  Large arguments are split between
5502              registers and stack.  */
5503           /* Note: structs whose size is not a multiple of MIPS32_REGSIZE
5504              are treated specially: Irix cc passes
5505              them in registers where gcc sometimes puts them on the
5506              stack.  For maximum compatibility, we will put them in
5507              both places.  */
5508           int odd_sized_struct = (len > MIPS32_REGSIZE
5509                                   && len % MIPS32_REGSIZE != 0);
5510           /* Structures should be aligned to eight bytes (even arg registers)
5511              on MIPS_ABI_O32, if their first member has double precision.  */
5512           if (mips_type_needs_double_align (arg_type))
5513             {
5514               if ((argreg & 1))
5515                 {
5516                   argreg++;
5517                   stack_offset += MIPS32_REGSIZE;
5518                 }
5519             }
5520           while (len > 0)
5521             {
5522               /* Remember if the argument was written to the stack.  */
5523               int stack_used_p = 0;
5524               int partial_len = (len < MIPS32_REGSIZE ? len : MIPS32_REGSIZE);
5525
5526               if (mips_debug)
5527                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
5528                                     partial_len);
5529
5530               /* Write this portion of the argument to the stack.  */
5531               if (argreg > MIPS_LAST_ARG_REGNUM (gdbarch)
5532                   || odd_sized_struct)
5533                 {
5534                   /* Should shorter than int integer values be
5535                      promoted to int before being stored?  */
5536                   int longword_offset = 0;
5537                   CORE_ADDR addr;
5538                   stack_used_p = 1;
5539
5540                   if (mips_debug)
5541                     {
5542                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
5543                                           paddress (gdbarch, stack_offset));
5544                       fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
5545                                           paddress (gdbarch, longword_offset));
5546                     }
5547
5548                   addr = sp + stack_offset + longword_offset;
5549
5550                   if (mips_debug)
5551                     {
5552                       int i;
5553                       fprintf_unfiltered (gdb_stdlog, " @%s ",
5554                                           paddress (gdbarch, addr));
5555                       for (i = 0; i < partial_len; i++)
5556                         {
5557                           fprintf_unfiltered (gdb_stdlog, "%02x",
5558                                               val[i] & 0xff);
5559                         }
5560                     }
5561                   write_memory (addr, val, partial_len);
5562                 }
5563
5564               /* Note!!! This is NOT an else clause.  Odd sized
5565                  structs may go thru BOTH paths.  */
5566               /* Write this portion of the argument to a general
5567                  purpose register.  */
5568               if (argreg <= MIPS_LAST_ARG_REGNUM (gdbarch))
5569                 {
5570                   LONGEST regval = extract_signed_integer (val, partial_len,
5571                                                            byte_order);
5572                   /* Value may need to be sign extended, because
5573                      mips_isa_regsize() != mips_abi_regsize().  */
5574
5575                   /* A non-floating-point argument being passed in a
5576                      general register.  If a struct or union, and if
5577                      the remaining length is smaller than the register
5578                      size, we have to adjust the register value on
5579                      big endian targets.
5580
5581                      It does not seem to be necessary to do the
5582                      same for integral types.
5583
5584                      Also don't do this adjustment on O64 binaries.
5585
5586                      cagney/2001-07-23: gdb/179: Also, GCC, when
5587                      outputting LE O32 with sizeof (struct) <
5588                      mips_abi_regsize(), generates a left shift
5589                      as part of storing the argument in a register
5590                      (the left shift isn't generated when
5591                      sizeof (struct) >= mips_abi_regsize()).  Since
5592                      it is quite possible that this is GCC
5593                      contradicting the LE/O32 ABI, GDB has not been
5594                      adjusted to accommodate this.  Either someone
5595                      needs to demonstrate that the LE/O32 ABI
5596                      specifies such a left shift OR this new ABI gets
5597                      identified as such and GDB gets tweaked
5598                      accordingly.  */
5599
5600                   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
5601                       && partial_len < MIPS32_REGSIZE
5602                       && (typecode == TYPE_CODE_STRUCT
5603                           || typecode == TYPE_CODE_UNION))
5604                     regval <<= ((MIPS32_REGSIZE - partial_len)
5605                                 * TARGET_CHAR_BIT);
5606
5607                   if (mips_debug)
5608                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
5609                                       argreg,
5610                                       phex (regval, MIPS32_REGSIZE));
5611                   regcache_cooked_write_unsigned (regcache, argreg, regval);
5612                   argreg++;
5613
5614                   /* Prevent subsequent floating point arguments from
5615                      being passed in floating point registers.  */
5616                   float_argreg = MIPS_LAST_FP_ARG_REGNUM (gdbarch) + 1;
5617                 }
5618
5619               len -= partial_len;
5620               val += partial_len;
5621
5622               /* Compute the offset into the stack at which we will
5623                  copy the next parameter.
5624
5625                  In older ABIs, the caller reserved space for
5626                  registers that contained arguments.  This was loosely
5627                  refered to as their "home".  Consequently, space is
5628                  always allocated.  */
5629
5630               stack_offset += align_up (partial_len, MIPS32_REGSIZE);
5631             }
5632         }
5633       if (mips_debug)
5634         fprintf_unfiltered (gdb_stdlog, "\n");
5635     }
5636
5637   regcache_cooked_write_signed (regcache, MIPS_SP_REGNUM, sp);
5638
5639   /* Return adjusted stack pointer.  */
5640   return sp;
5641 }
5642
5643 static enum return_value_convention
5644 mips_o32_return_value (struct gdbarch *gdbarch, struct value *function,
5645                        struct type *type, struct regcache *regcache,
5646                        gdb_byte *readbuf, const gdb_byte *writebuf)
5647 {
5648   CORE_ADDR func_addr = function ? find_function_addr (function, NULL) : 0;
5649   int mips16 = mips_pc_is_mips16 (gdbarch, func_addr);
5650   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5651   enum mips_fval_reg fval_reg;
5652
5653   fval_reg = readbuf ? mips16 ? mips_fval_gpr : mips_fval_fpr : mips_fval_both;
5654   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
5655       || TYPE_CODE (type) == TYPE_CODE_UNION
5656       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
5657     return RETURN_VALUE_STRUCT_CONVENTION;
5658   else if (TYPE_CODE (type) == TYPE_CODE_FLT
5659            && TYPE_LENGTH (type) == 4 && tdep->mips_fpu_type != MIPS_FPU_NONE)
5660     {
5661       /* A single-precision floating-point value.  If reading in or copying,
5662          then we get it from/put it to FP0 for standard MIPS code or GPR2
5663          for MIPS16 code.  If writing out only, then we put it to both FP0
5664          and GPR2.  We do not support reading in with no function known, if
5665          this safety check ever triggers, then we'll have to try harder.  */
5666       gdb_assert (function || !readbuf);
5667       if (mips_debug)
5668         switch (fval_reg)
5669           {
5670           case mips_fval_fpr:
5671             fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
5672             break;
5673           case mips_fval_gpr:
5674             fprintf_unfiltered (gdb_stderr, "Return float in $2\n");
5675             break;
5676           case mips_fval_both:
5677             fprintf_unfiltered (gdb_stderr, "Return float in $fp0 and $2\n");
5678             break;
5679           }
5680       if (fval_reg != mips_fval_gpr)
5681         mips_xfer_register (gdbarch, regcache,
5682                             (gdbarch_num_regs (gdbarch)
5683                              + mips_regnum (gdbarch)->fp0),
5684                             TYPE_LENGTH (type),
5685                             gdbarch_byte_order (gdbarch),
5686                             readbuf, writebuf, 0);
5687       if (fval_reg != mips_fval_fpr)
5688         mips_xfer_register (gdbarch, regcache,
5689                             gdbarch_num_regs (gdbarch) + 2,
5690                             TYPE_LENGTH (type),
5691                             gdbarch_byte_order (gdbarch),
5692                             readbuf, writebuf, 0);
5693       return RETURN_VALUE_REGISTER_CONVENTION;
5694     }
5695   else if (TYPE_CODE (type) == TYPE_CODE_FLT
5696            && TYPE_LENGTH (type) == 8 && tdep->mips_fpu_type != MIPS_FPU_NONE)
5697     {
5698       /* A double-precision floating-point value.  If reading in or copying,
5699          then we get it from/put it to FP1 and FP0 for standard MIPS code or
5700          GPR2 and GPR3 for MIPS16 code.  If writing out only, then we put it
5701          to both FP1/FP0 and GPR2/GPR3.  We do not support reading in with
5702          no function known, if this safety check ever triggers, then we'll
5703          have to try harder.  */
5704       gdb_assert (function || !readbuf);
5705       if (mips_debug)
5706         switch (fval_reg)
5707           {
5708           case mips_fval_fpr:
5709             fprintf_unfiltered (gdb_stderr, "Return float in $fp1/$fp0\n");
5710             break;
5711           case mips_fval_gpr:
5712             fprintf_unfiltered (gdb_stderr, "Return float in $2/$3\n");
5713             break;
5714           case mips_fval_both:
5715             fprintf_unfiltered (gdb_stderr,
5716                                 "Return float in $fp1/$fp0 and $2/$3\n");
5717             break;
5718           }
5719       if (fval_reg != mips_fval_gpr)
5720         {
5721           /* The most significant part goes in FP1, and the least significant
5722              in FP0.  */
5723           switch (gdbarch_byte_order (gdbarch))
5724             {
5725             case BFD_ENDIAN_LITTLE:
5726               mips_xfer_register (gdbarch, regcache,
5727                                   (gdbarch_num_regs (gdbarch)
5728                                    + mips_regnum (gdbarch)->fp0 + 0),
5729                                   4, gdbarch_byte_order (gdbarch),
5730                                   readbuf, writebuf, 0);
5731               mips_xfer_register (gdbarch, regcache,
5732                                   (gdbarch_num_regs (gdbarch)
5733                                    + mips_regnum (gdbarch)->fp0 + 1),
5734                                   4, gdbarch_byte_order (gdbarch),
5735                                   readbuf, writebuf, 4);
5736               break;
5737             case BFD_ENDIAN_BIG:
5738               mips_xfer_register (gdbarch, regcache,
5739                                   (gdbarch_num_regs (gdbarch)
5740                                    + mips_regnum (gdbarch)->fp0 + 1),
5741                                   4, gdbarch_byte_order (gdbarch),
5742                                   readbuf, writebuf, 0);
5743               mips_xfer_register (gdbarch, regcache,
5744                                   (gdbarch_num_regs (gdbarch)
5745                                    + mips_regnum (gdbarch)->fp0 + 0),
5746                                   4, gdbarch_byte_order (gdbarch),
5747                                   readbuf, writebuf, 4);
5748               break;
5749             default:
5750               internal_error (__FILE__, __LINE__, _("bad switch"));
5751             }
5752         }
5753       if (fval_reg != mips_fval_fpr)
5754         {
5755           /* The two 32-bit parts are always placed in GPR2 and GPR3
5756              following these registers' memory order.  */
5757           mips_xfer_register (gdbarch, regcache,
5758                               gdbarch_num_regs (gdbarch) + 2,
5759                               4, gdbarch_byte_order (gdbarch),
5760                               readbuf, writebuf, 0);
5761           mips_xfer_register (gdbarch, regcache,
5762                               gdbarch_num_regs (gdbarch) + 3,
5763                               4, gdbarch_byte_order (gdbarch),
5764                               readbuf, writebuf, 4);
5765         }
5766       return RETURN_VALUE_REGISTER_CONVENTION;
5767     }
5768 #if 0
5769   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
5770            && TYPE_NFIELDS (type) <= 2
5771            && TYPE_NFIELDS (type) >= 1
5772            && ((TYPE_NFIELDS (type) == 1
5773                 && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
5774                     == TYPE_CODE_FLT))
5775                || (TYPE_NFIELDS (type) == 2
5776                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
5777                        == TYPE_CODE_FLT)
5778                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 1))
5779                        == TYPE_CODE_FLT)))
5780            && tdep->mips_fpu_type != MIPS_FPU_NONE)
5781     {
5782       /* A struct that contains one or two floats.  Each value is part
5783          in the least significant part of their floating point
5784          register..  */
5785       gdb_byte reg[MAX_REGISTER_SIZE];
5786       int regnum;
5787       int field;
5788       for (field = 0, regnum = mips_regnum (gdbarch)->fp0;
5789            field < TYPE_NFIELDS (type); field++, regnum += 2)
5790         {
5791           int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
5792                         / TARGET_CHAR_BIT);
5793           if (mips_debug)
5794             fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
5795                                 offset);
5796           mips_xfer_register (gdbarch, regcache,
5797                               gdbarch_num_regs (gdbarch) + regnum,
5798                               TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
5799                               gdbarch_byte_order (gdbarch),
5800                               readbuf, writebuf, offset);
5801         }
5802       return RETURN_VALUE_REGISTER_CONVENTION;
5803     }
5804 #endif
5805 #if 0
5806   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
5807            || TYPE_CODE (type) == TYPE_CODE_UNION)
5808     {
5809       /* A structure or union.  Extract the left justified value,
5810          regardless of the byte order.  I.e. DO NOT USE
5811          mips_xfer_lower.  */
5812       int offset;
5813       int regnum;
5814       for (offset = 0, regnum = MIPS_V0_REGNUM;
5815            offset < TYPE_LENGTH (type);
5816            offset += register_size (gdbarch, regnum), regnum++)
5817         {
5818           int xfer = register_size (gdbarch, regnum);
5819           if (offset + xfer > TYPE_LENGTH (type))
5820             xfer = TYPE_LENGTH (type) - offset;
5821           if (mips_debug)
5822             fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
5823                                 offset, xfer, regnum);
5824           mips_xfer_register (gdbarch, regcache,
5825                               gdbarch_num_regs (gdbarch) + regnum, xfer,
5826                               BFD_ENDIAN_UNKNOWN, readbuf, writebuf, offset);
5827         }
5828       return RETURN_VALUE_REGISTER_CONVENTION;
5829     }
5830 #endif
5831   else
5832     {
5833       /* A scalar extract each part but least-significant-byte
5834          justified.  o32 thinks registers are 4 byte, regardless of
5835          the ISA.  */
5836       int offset;
5837       int regnum;
5838       for (offset = 0, regnum = MIPS_V0_REGNUM;
5839            offset < TYPE_LENGTH (type);
5840            offset += MIPS32_REGSIZE, regnum++)
5841         {
5842           int xfer = MIPS32_REGSIZE;
5843           if (offset + xfer > TYPE_LENGTH (type))
5844             xfer = TYPE_LENGTH (type) - offset;
5845           if (mips_debug)
5846             fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
5847                                 offset, xfer, regnum);
5848           mips_xfer_register (gdbarch, regcache,
5849                               gdbarch_num_regs (gdbarch) + regnum, xfer,
5850                               gdbarch_byte_order (gdbarch),
5851                               readbuf, writebuf, offset);
5852         }
5853       return RETURN_VALUE_REGISTER_CONVENTION;
5854     }
5855 }
5856
5857 /* O64 ABI.  This is a hacked up kind of 64-bit version of the o32
5858    ABI.  */
5859
5860 static CORE_ADDR
5861 mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
5862                           struct regcache *regcache, CORE_ADDR bp_addr,
5863                           int nargs,
5864                           struct value **args, CORE_ADDR sp,
5865                           int struct_return, CORE_ADDR struct_addr)
5866 {
5867   int argreg;
5868   int float_argreg;
5869   int argnum;
5870   int len = 0;
5871   int stack_offset = 0;
5872   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
5873   CORE_ADDR func_addr = find_function_addr (function, NULL);
5874
5875   /* For shared libraries, "t9" needs to point at the function
5876      address.  */
5877   regcache_cooked_write_signed (regcache, MIPS_T9_REGNUM, func_addr);
5878
5879   /* Set the return address register to point to the entry point of
5880      the program, where a breakpoint lies in wait.  */
5881   regcache_cooked_write_signed (regcache, MIPS_RA_REGNUM, bp_addr);
5882
5883   /* First ensure that the stack and structure return address (if any)
5884      are properly aligned.  The stack has to be at least 64-bit
5885      aligned even on 32-bit machines, because doubles must be 64-bit
5886      aligned.  For n32 and n64, stack frames need to be 128-bit
5887      aligned, so we round to this widest known alignment.  */
5888
5889   sp = align_down (sp, 16);
5890   struct_addr = align_down (struct_addr, 16);
5891
5892   /* Now make space on the stack for the args.  */
5893   for (argnum = 0; argnum < nargs; argnum++)
5894     {
5895       struct type *arg_type = check_typedef (value_type (args[argnum]));
5896
5897       /* Allocate space on the stack.  */
5898       len += align_up (TYPE_LENGTH (arg_type), MIPS64_REGSIZE);
5899     }
5900   sp -= align_up (len, 16);
5901
5902   if (mips_debug)
5903     fprintf_unfiltered (gdb_stdlog,
5904                         "mips_o64_push_dummy_call: sp=%s allocated %ld\n",
5905                         paddress (gdbarch, sp), (long) align_up (len, 16));
5906
5907   /* Initialize the integer and float register pointers.  */
5908   argreg = MIPS_A0_REGNUM;
5909   float_argreg = mips_fpa0_regnum (gdbarch);
5910
5911   /* The struct_return pointer occupies the first parameter-passing reg.  */
5912   if (struct_return)
5913     {
5914       if (mips_debug)
5915         fprintf_unfiltered (gdb_stdlog,
5916                             "mips_o64_push_dummy_call: "
5917                             "struct_return reg=%d %s\n",
5918                             argreg, paddress (gdbarch, struct_addr));
5919       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
5920       stack_offset += MIPS64_REGSIZE;
5921     }
5922
5923   /* Now load as many as possible of the first arguments into
5924      registers, and push the rest onto the stack.  Loop thru args
5925      from first to last.  */
5926   for (argnum = 0; argnum < nargs; argnum++)
5927     {
5928       const gdb_byte *val;
5929       struct value *arg = args[argnum];
5930       struct type *arg_type = check_typedef (value_type (arg));
5931       int len = TYPE_LENGTH (arg_type);
5932       enum type_code typecode = TYPE_CODE (arg_type);
5933
5934       if (mips_debug)
5935         fprintf_unfiltered (gdb_stdlog,
5936                             "mips_o64_push_dummy_call: %d len=%d type=%d",
5937                             argnum + 1, len, (int) typecode);
5938
5939       val = value_contents (arg);
5940
5941       /* Floating point arguments passed in registers have to be
5942          treated specially.  On 32-bit architectures, doubles are
5943          passed in register pairs; the even FP register gets the
5944          low word, and the odd FP register gets the high word.
5945          On O64, the first two floating point arguments are also
5946          copied to general registers, because MIPS16 functions
5947          don't use float registers for arguments.  This duplication
5948          of arguments in general registers can't hurt non-MIPS16
5949          functions because those registers are normally skipped.  */
5950
5951       if (fp_register_arg_p (gdbarch, typecode, arg_type)
5952           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM (gdbarch))
5953         {
5954           LONGEST regval = extract_unsigned_integer (val, len, byte_order);
5955           if (mips_debug)
5956             fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
5957                                 float_argreg, phex (regval, len));
5958           regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
5959           if (mips_debug)
5960             fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
5961                                 argreg, phex (regval, len));
5962           regcache_cooked_write_unsigned (regcache, argreg, regval);
5963           argreg++;
5964           /* Reserve space for the FP register.  */
5965           stack_offset += align_up (len, MIPS64_REGSIZE);
5966         }
5967       else
5968         {
5969           /* Copy the argument to general registers or the stack in
5970              register-sized pieces.  Large arguments are split between
5971              registers and stack.  */
5972           /* Note: structs whose size is not a multiple of MIPS64_REGSIZE
5973              are treated specially: Irix cc passes them in registers
5974              where gcc sometimes puts them on the stack.  For maximum
5975              compatibility, we will put them in both places.  */
5976           int odd_sized_struct = (len > MIPS64_REGSIZE
5977                                   && len % MIPS64_REGSIZE != 0);
5978           while (len > 0)
5979             {
5980               /* Remember if the argument was written to the stack.  */
5981               int stack_used_p = 0;
5982               int partial_len = (len < MIPS64_REGSIZE ? len : MIPS64_REGSIZE);
5983
5984               if (mips_debug)
5985                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
5986                                     partial_len);
5987
5988               /* Write this portion of the argument to the stack.  */
5989               if (argreg > MIPS_LAST_ARG_REGNUM (gdbarch)
5990                   || odd_sized_struct)
5991                 {
5992                   /* Should shorter than int integer values be
5993                      promoted to int before being stored?  */
5994                   int longword_offset = 0;
5995                   CORE_ADDR addr;
5996                   stack_used_p = 1;
5997                   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
5998                     {
5999                       if ((typecode == TYPE_CODE_INT
6000                            || typecode == TYPE_CODE_PTR
6001                            || typecode == TYPE_CODE_FLT)
6002                           && len <= 4)
6003                         longword_offset = MIPS64_REGSIZE - len;
6004                     }
6005
6006                   if (mips_debug)
6007                     {
6008                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
6009                                           paddress (gdbarch, stack_offset));
6010                       fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
6011                                           paddress (gdbarch, longword_offset));
6012                     }
6013
6014                   addr = sp + stack_offset + longword_offset;
6015
6016                   if (mips_debug)
6017                     {
6018                       int i;
6019                       fprintf_unfiltered (gdb_stdlog, " @%s ",
6020                                           paddress (gdbarch, addr));
6021                       for (i = 0; i < partial_len; i++)
6022                         {
6023                           fprintf_unfiltered (gdb_stdlog, "%02x",
6024                                               val[i] & 0xff);
6025                         }
6026                     }
6027                   write_memory (addr, val, partial_len);
6028                 }
6029
6030               /* Note!!! This is NOT an else clause.  Odd sized
6031                  structs may go thru BOTH paths.  */
6032               /* Write this portion of the argument to a general
6033                  purpose register.  */
6034               if (argreg <= MIPS_LAST_ARG_REGNUM (gdbarch))
6035                 {
6036                   LONGEST regval = extract_signed_integer (val, partial_len,
6037                                                            byte_order);
6038                   /* Value may need to be sign extended, because
6039                      mips_isa_regsize() != mips_abi_regsize().  */
6040
6041                   /* A non-floating-point argument being passed in a
6042                      general register.  If a struct or union, and if
6043                      the remaining length is smaller than the register
6044                      size, we have to adjust the register value on
6045                      big endian targets.
6046
6047                      It does not seem to be necessary to do the
6048                      same for integral types.  */
6049
6050                   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
6051                       && partial_len < MIPS64_REGSIZE
6052                       && (typecode == TYPE_CODE_STRUCT
6053                           || typecode == TYPE_CODE_UNION))
6054                     regval <<= ((MIPS64_REGSIZE - partial_len)
6055                                 * TARGET_CHAR_BIT);
6056
6057                   if (mips_debug)
6058                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
6059                                       argreg,
6060                                       phex (regval, MIPS64_REGSIZE));
6061                   regcache_cooked_write_unsigned (regcache, argreg, regval);
6062                   argreg++;
6063
6064                   /* Prevent subsequent floating point arguments from
6065                      being passed in floating point registers.  */
6066                   float_argreg = MIPS_LAST_FP_ARG_REGNUM (gdbarch) + 1;
6067                 }
6068
6069               len -= partial_len;
6070               val += partial_len;
6071
6072               /* Compute the offset into the stack at which we will
6073                  copy the next parameter.
6074
6075                  In older ABIs, the caller reserved space for
6076                  registers that contained arguments.  This was loosely
6077                  refered to as their "home".  Consequently, space is
6078                  always allocated.  */
6079
6080               stack_offset += align_up (partial_len, MIPS64_REGSIZE);
6081             }
6082         }
6083       if (mips_debug)
6084         fprintf_unfiltered (gdb_stdlog, "\n");
6085     }
6086
6087   regcache_cooked_write_signed (regcache, MIPS_SP_REGNUM, sp);
6088
6089   /* Return adjusted stack pointer.  */
6090   return sp;
6091 }
6092
6093 static enum return_value_convention
6094 mips_o64_return_value (struct gdbarch *gdbarch, struct value *function,
6095                        struct type *type, struct regcache *regcache,
6096                        gdb_byte *readbuf, const gdb_byte *writebuf)
6097 {
6098   CORE_ADDR func_addr = function ? find_function_addr (function, NULL) : 0;
6099   int mips16 = mips_pc_is_mips16 (gdbarch, func_addr);
6100   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
6101   enum mips_fval_reg fval_reg;
6102
6103   fval_reg = readbuf ? mips16 ? mips_fval_gpr : mips_fval_fpr : mips_fval_both;
6104   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
6105       || TYPE_CODE (type) == TYPE_CODE_UNION
6106       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
6107     return RETURN_VALUE_STRUCT_CONVENTION;
6108   else if (fp_register_arg_p (gdbarch, TYPE_CODE (type), type))
6109     {
6110       /* A floating-point value.  If reading in or copying, then we get it
6111          from/put it to FP0 for standard MIPS code or GPR2 for MIPS16 code.
6112          If writing out only, then we put it to both FP0 and GPR2.  We do
6113          not support reading in with no function known, if this safety
6114          check ever triggers, then we'll have to try harder.  */
6115       gdb_assert (function || !readbuf);
6116       if (mips_debug)
6117         switch (fval_reg)
6118           {
6119           case mips_fval_fpr:
6120             fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
6121             break;
6122           case mips_fval_gpr:
6123             fprintf_unfiltered (gdb_stderr, "Return float in $2\n");
6124             break;
6125           case mips_fval_both:
6126             fprintf_unfiltered (gdb_stderr, "Return float in $fp0 and $2\n");
6127             break;
6128           }
6129       if (fval_reg != mips_fval_gpr)
6130         mips_xfer_register (gdbarch, regcache,
6131                             (gdbarch_num_regs (gdbarch)
6132                              + mips_regnum (gdbarch)->fp0),
6133                             TYPE_LENGTH (type),
6134                             gdbarch_byte_order (gdbarch),
6135                             readbuf, writebuf, 0);
6136       if (fval_reg != mips_fval_fpr)
6137         mips_xfer_register (gdbarch, regcache,
6138                             gdbarch_num_regs (gdbarch) + 2,
6139                             TYPE_LENGTH (type),
6140                             gdbarch_byte_order (gdbarch),
6141                             readbuf, writebuf, 0);
6142       return RETURN_VALUE_REGISTER_CONVENTION;
6143     }
6144   else
6145     {
6146       /* A scalar extract each part but least-significant-byte
6147          justified.  */
6148       int offset;
6149       int regnum;
6150       for (offset = 0, regnum = MIPS_V0_REGNUM;
6151            offset < TYPE_LENGTH (type);
6152            offset += MIPS64_REGSIZE, regnum++)
6153         {
6154           int xfer = MIPS64_REGSIZE;
6155           if (offset + xfer > TYPE_LENGTH (type))
6156             xfer = TYPE_LENGTH (type) - offset;
6157           if (mips_debug)
6158             fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
6159                                 offset, xfer, regnum);
6160           mips_xfer_register (gdbarch, regcache,
6161                               gdbarch_num_regs (gdbarch) + regnum,
6162                               xfer, gdbarch_byte_order (gdbarch),
6163                               readbuf, writebuf, offset);
6164         }
6165       return RETURN_VALUE_REGISTER_CONVENTION;
6166     }
6167 }
6168
6169 /* Floating point register management.
6170
6171    Background: MIPS1 & 2 fp registers are 32 bits wide.  To support
6172    64bit operations, these early MIPS cpus treat fp register pairs
6173    (f0,f1) as a single register (d0).  Later MIPS cpu's have 64 bit fp
6174    registers and offer a compatibility mode that emulates the MIPS2 fp
6175    model.  When operating in MIPS2 fp compat mode, later cpu's split
6176    double precision floats into two 32-bit chunks and store them in
6177    consecutive fp regs.  To display 64-bit floats stored in this
6178    fashion, we have to combine 32 bits from f0 and 32 bits from f1.
6179    Throw in user-configurable endianness and you have a real mess.
6180
6181    The way this works is:
6182      - If we are in 32-bit mode or on a 32-bit processor, then a 64-bit
6183        double-precision value will be split across two logical registers.
6184        The lower-numbered logical register will hold the low-order bits,
6185        regardless of the processor's endianness.
6186      - If we are on a 64-bit processor, and we are looking for a
6187        single-precision value, it will be in the low ordered bits
6188        of a 64-bit GPR (after mfc1, for example) or a 64-bit register
6189        save slot in memory.
6190      - If we are in 64-bit mode, everything is straightforward.
6191
6192    Note that this code only deals with "live" registers at the top of the
6193    stack.  We will attempt to deal with saved registers later, when
6194    the raw/cooked register interface is in place.  (We need a general
6195    interface that can deal with dynamic saved register sizes -- fp
6196    regs could be 32 bits wide in one frame and 64 on the frame above
6197    and below).  */
6198
6199 /* Copy a 32-bit single-precision value from the current frame
6200    into rare_buffer.  */
6201
6202 static void
6203 mips_read_fp_register_single (struct frame_info *frame, int regno,
6204                               gdb_byte *rare_buffer)
6205 {
6206   struct gdbarch *gdbarch = get_frame_arch (frame);
6207   int raw_size = register_size (gdbarch, regno);
6208   gdb_byte *raw_buffer = alloca (raw_size);
6209
6210   if (!deprecated_frame_register_read (frame, regno, raw_buffer))
6211     error (_("can't read register %d (%s)"),
6212            regno, gdbarch_register_name (gdbarch, regno));
6213   if (raw_size == 8)
6214     {
6215       /* We have a 64-bit value for this register.  Find the low-order
6216          32 bits.  */
6217       int offset;
6218
6219       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
6220         offset = 4;
6221       else
6222         offset = 0;
6223
6224       memcpy (rare_buffer, raw_buffer + offset, 4);
6225     }
6226   else
6227     {
6228       memcpy (rare_buffer, raw_buffer, 4);
6229     }
6230 }
6231
6232 /* Copy a 64-bit double-precision value from the current frame into
6233    rare_buffer.  This may include getting half of it from the next
6234    register.  */
6235
6236 static void
6237 mips_read_fp_register_double (struct frame_info *frame, int regno,
6238                               gdb_byte *rare_buffer)
6239 {
6240   struct gdbarch *gdbarch = get_frame_arch (frame);
6241   int raw_size = register_size (gdbarch, regno);
6242
6243   if (raw_size == 8 && !mips2_fp_compat (frame))
6244     {
6245       /* We have a 64-bit value for this register, and we should use
6246          all 64 bits.  */
6247       if (!deprecated_frame_register_read (frame, regno, rare_buffer))
6248         error (_("can't read register %d (%s)"),
6249                regno, gdbarch_register_name (gdbarch, regno));
6250     }
6251   else
6252     {
6253       int rawnum = regno % gdbarch_num_regs (gdbarch);
6254
6255       if ((rawnum - mips_regnum (gdbarch)->fp0) & 1)
6256         internal_error (__FILE__, __LINE__,
6257                         _("mips_read_fp_register_double: bad access to "
6258                         "odd-numbered FP register"));
6259
6260       /* mips_read_fp_register_single will find the correct 32 bits from
6261          each register.  */
6262       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
6263         {
6264           mips_read_fp_register_single (frame, regno, rare_buffer + 4);
6265           mips_read_fp_register_single (frame, regno + 1, rare_buffer);
6266         }
6267       else
6268         {
6269           mips_read_fp_register_single (frame, regno, rare_buffer);
6270           mips_read_fp_register_single (frame, regno + 1, rare_buffer + 4);
6271         }
6272     }
6273 }
6274
6275 static void
6276 mips_print_fp_register (struct ui_file *file, struct frame_info *frame,
6277                         int regnum)
6278 {                               /* Do values for FP (float) regs.  */
6279   struct gdbarch *gdbarch = get_frame_arch (frame);
6280   gdb_byte *raw_buffer;
6281   double doub, flt1;    /* Doubles extracted from raw hex data.  */
6282   int inv1, inv2;
6283
6284   raw_buffer = alloca (2 * register_size (gdbarch,
6285                                           mips_regnum (gdbarch)->fp0));
6286
6287   fprintf_filtered (file, "%s:", gdbarch_register_name (gdbarch, regnum));
6288   fprintf_filtered (file, "%*s",
6289                     4 - (int) strlen (gdbarch_register_name (gdbarch, regnum)),
6290                     "");
6291
6292   if (register_size (gdbarch, regnum) == 4 || mips2_fp_compat (frame))
6293     {
6294       struct value_print_options opts;
6295
6296       /* 4-byte registers: Print hex and floating.  Also print even
6297          numbered registers as doubles.  */
6298       mips_read_fp_register_single (frame, regnum, raw_buffer);
6299       flt1 = unpack_double (builtin_type (gdbarch)->builtin_float,
6300                             raw_buffer, &inv1);
6301
6302       get_formatted_print_options (&opts, 'x');
6303       print_scalar_formatted (raw_buffer,
6304                               builtin_type (gdbarch)->builtin_uint32,
6305                               &opts, 'w', file);
6306
6307       fprintf_filtered (file, " flt: ");
6308       if (inv1)
6309         fprintf_filtered (file, " <invalid float> ");
6310       else
6311         fprintf_filtered (file, "%-17.9g", flt1);
6312
6313       if ((regnum - gdbarch_num_regs (gdbarch)) % 2 == 0)
6314         {
6315           mips_read_fp_register_double (frame, regnum, raw_buffer);
6316           doub = unpack_double (builtin_type (gdbarch)->builtin_double,
6317                                 raw_buffer, &inv2);
6318
6319           fprintf_filtered (file, " dbl: ");
6320           if (inv2)
6321             fprintf_filtered (file, "<invalid double>");
6322           else
6323             fprintf_filtered (file, "%-24.17g", doub);
6324         }
6325     }
6326   else
6327     {
6328       struct value_print_options opts;
6329
6330       /* Eight byte registers: print each one as hex, float and double.  */
6331       mips_read_fp_register_single (frame, regnum, raw_buffer);
6332       flt1 = unpack_double (builtin_type (gdbarch)->builtin_float,
6333                             raw_buffer, &inv1);
6334
6335       mips_read_fp_register_double (frame, regnum, raw_buffer);
6336       doub = unpack_double (builtin_type (gdbarch)->builtin_double,
6337                             raw_buffer, &inv2);
6338
6339       get_formatted_print_options (&opts, 'x');
6340       print_scalar_formatted (raw_buffer,
6341                               builtin_type (gdbarch)->builtin_uint64,
6342                               &opts, 'g', file);
6343
6344       fprintf_filtered (file, " flt: ");
6345       if (inv1)
6346         fprintf_filtered (file, "<invalid float>");
6347       else
6348         fprintf_filtered (file, "%-17.9g", flt1);
6349
6350       fprintf_filtered (file, " dbl: ");
6351       if (inv2)
6352         fprintf_filtered (file, "<invalid double>");
6353       else
6354         fprintf_filtered (file, "%-24.17g", doub);
6355     }
6356 }
6357
6358 static void
6359 mips_print_register (struct ui_file *file, struct frame_info *frame,
6360                      int regnum)
6361 {
6362   struct gdbarch *gdbarch = get_frame_arch (frame);
6363   struct value_print_options opts;
6364   struct value *val;
6365
6366   if (mips_float_register_p (gdbarch, regnum))
6367     {
6368       mips_print_fp_register (file, frame, regnum);
6369       return;
6370     }
6371
6372   val = get_frame_register_value (frame, regnum);
6373
6374   fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
6375
6376   /* The problem with printing numeric register names (r26, etc.) is that
6377      the user can't use them on input.  Probably the best solution is to
6378      fix it so that either the numeric or the funky (a2, etc.) names
6379      are accepted on input.  */
6380   if (regnum < MIPS_NUMREGS)
6381     fprintf_filtered (file, "(r%d): ", regnum);
6382   else
6383     fprintf_filtered (file, ": ");
6384
6385   get_formatted_print_options (&opts, 'x');
6386   val_print_scalar_formatted (value_type (val),
6387                               value_contents_for_printing (val),
6388                               value_embedded_offset (val),
6389                               val,
6390                               &opts, 0, file);
6391 }
6392
6393 /* Print IEEE exception condition bits in FLAGS.  */
6394
6395 static void
6396 print_fpu_flags (struct ui_file *file, int flags)
6397 {
6398   if (flags & (1 << 0))
6399     fputs_filtered (" inexact", file);
6400   if (flags & (1 << 1))
6401     fputs_filtered (" uflow", file);
6402   if (flags & (1 << 2))
6403     fputs_filtered (" oflow", file);
6404   if (flags & (1 << 3))
6405     fputs_filtered (" div0", file);
6406   if (flags & (1 << 4))
6407     fputs_filtered (" inval", file);
6408   if (flags & (1 << 5))
6409     fputs_filtered (" unimp", file);
6410   fputc_filtered ('\n', file);
6411 }
6412
6413 /* Print interesting information about the floating point processor
6414    (if present) or emulator.  */
6415
6416 static void
6417 mips_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
6418                       struct frame_info *frame, const char *args)
6419 {
6420   int fcsr = mips_regnum (gdbarch)->fp_control_status;
6421   enum mips_fpu_type type = MIPS_FPU_TYPE (gdbarch);
6422   ULONGEST fcs = 0;
6423   int i;
6424
6425   if (fcsr == -1 || !read_frame_register_unsigned (frame, fcsr, &fcs))
6426     type = MIPS_FPU_NONE;
6427
6428   fprintf_filtered (file, "fpu type: %s\n",
6429                     type == MIPS_FPU_DOUBLE ? "double-precision"
6430                     : type == MIPS_FPU_SINGLE ? "single-precision"
6431                     : "none / unused");
6432
6433   if (type == MIPS_FPU_NONE)
6434     return;
6435
6436   fprintf_filtered (file, "reg size: %d bits\n",
6437                     register_size (gdbarch, mips_regnum (gdbarch)->fp0) * 8);
6438
6439   fputs_filtered ("cond    :", file);
6440   if (fcs & (1 << 23))
6441     fputs_filtered (" 0", file);
6442   for (i = 1; i <= 7; i++)
6443     if (fcs & (1 << (24 + i)))
6444       fprintf_filtered (file, " %d", i);
6445   fputc_filtered ('\n', file);
6446
6447   fputs_filtered ("cause   :", file);
6448   print_fpu_flags (file, (fcs >> 12) & 0x3f);
6449   fputs ("mask    :", stdout);
6450   print_fpu_flags (file, (fcs >> 7) & 0x1f);
6451   fputs ("flags   :", stdout);
6452   print_fpu_flags (file, (fcs >> 2) & 0x1f);
6453
6454   fputs_filtered ("rounding: ", file);
6455   switch (fcs & 3)
6456     {
6457     case 0: fputs_filtered ("nearest\n", file); break;
6458     case 1: fputs_filtered ("zero\n", file); break;
6459     case 2: fputs_filtered ("+inf\n", file); break;
6460     case 3: fputs_filtered ("-inf\n", file); break;
6461     }
6462
6463   fputs_filtered ("flush   :", file);
6464   if (fcs & (1 << 21))
6465     fputs_filtered (" nearest", file);
6466   if (fcs & (1 << 22))
6467     fputs_filtered (" override", file);
6468   if (fcs & (1 << 24))
6469     fputs_filtered (" zero", file);
6470   if ((fcs & (0xb << 21)) == 0)
6471     fputs_filtered (" no", file);
6472   fputc_filtered ('\n', file);
6473
6474   fprintf_filtered (file, "nan2008 : %s\n", fcs & (1 << 18) ? "yes" : "no");
6475   fprintf_filtered (file, "abs2008 : %s\n", fcs & (1 << 19) ? "yes" : "no");
6476   fputc_filtered ('\n', file);
6477
6478   default_print_float_info (gdbarch, file, frame, args);
6479 }
6480
6481 /* Replacement for generic do_registers_info.
6482    Print regs in pretty columns.  */
6483
6484 static int
6485 print_fp_register_row (struct ui_file *file, struct frame_info *frame,
6486                        int regnum)
6487 {
6488   fprintf_filtered (file, " ");
6489   mips_print_fp_register (file, frame, regnum);
6490   fprintf_filtered (file, "\n");
6491   return regnum + 1;
6492 }
6493
6494
6495 /* Print a row's worth of GP (int) registers, with name labels above.  */
6496
6497 static int
6498 print_gp_register_row (struct ui_file *file, struct frame_info *frame,
6499                        int start_regnum)
6500 {
6501   struct gdbarch *gdbarch = get_frame_arch (frame);
6502   /* Do values for GP (int) regs.  */
6503   gdb_byte raw_buffer[MAX_REGISTER_SIZE];
6504   int ncols = (mips_abi_regsize (gdbarch) == 8 ? 4 : 8);    /* display cols
6505                                                                per row.  */
6506   int col, byte;
6507   int regnum;
6508
6509   /* For GP registers, we print a separate row of names above the vals.  */
6510   for (col = 0, regnum = start_regnum;
6511        col < ncols && regnum < gdbarch_num_regs (gdbarch)
6512                                + gdbarch_num_pseudo_regs (gdbarch);
6513        regnum++)
6514     {
6515       if (*gdbarch_register_name (gdbarch, regnum) == '\0')
6516         continue;               /* unused register */
6517       if (mips_float_register_p (gdbarch, regnum))
6518         break;                  /* End the row: reached FP register.  */
6519       /* Large registers are handled separately.  */
6520       if (register_size (gdbarch, regnum) > mips_abi_regsize (gdbarch))
6521         {
6522           if (col > 0)
6523             break;              /* End the row before this register.  */
6524
6525           /* Print this register on a row by itself.  */
6526           mips_print_register (file, frame, regnum);
6527           fprintf_filtered (file, "\n");
6528           return regnum + 1;
6529         }
6530       if (col == 0)
6531         fprintf_filtered (file, "     ");
6532       fprintf_filtered (file,
6533                         mips_abi_regsize (gdbarch) == 8 ? "%17s" : "%9s",
6534                         gdbarch_register_name (gdbarch, regnum));
6535       col++;
6536     }
6537
6538   if (col == 0)
6539     return regnum;
6540
6541   /* Print the R0 to R31 names.  */
6542   if ((start_regnum % gdbarch_num_regs (gdbarch)) < MIPS_NUMREGS)
6543     fprintf_filtered (file, "\n R%-4d",
6544                       start_regnum % gdbarch_num_regs (gdbarch));
6545   else
6546     fprintf_filtered (file, "\n      ");
6547
6548   /* Now print the values in hex, 4 or 8 to the row.  */
6549   for (col = 0, regnum = start_regnum;
6550        col < ncols && regnum < gdbarch_num_regs (gdbarch)
6551                                + gdbarch_num_pseudo_regs (gdbarch);
6552        regnum++)
6553     {
6554       if (*gdbarch_register_name (gdbarch, regnum) == '\0')
6555         continue;               /* unused register */
6556       if (mips_float_register_p (gdbarch, regnum))
6557         break;                  /* End row: reached FP register.  */
6558       if (register_size (gdbarch, regnum) > mips_abi_regsize (gdbarch))
6559         break;                  /* End row: large register.  */
6560
6561       /* OK: get the data in raw format.  */
6562       if (!deprecated_frame_register_read (frame, regnum, raw_buffer))
6563         error (_("can't read register %d (%s)"),
6564                regnum, gdbarch_register_name (gdbarch, regnum));
6565       /* pad small registers */
6566       for (byte = 0;
6567            byte < (mips_abi_regsize (gdbarch)
6568                    - register_size (gdbarch, regnum)); byte++)
6569         printf_filtered ("  ");
6570       /* Now print the register value in hex, endian order.  */
6571       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
6572         for (byte =
6573              register_size (gdbarch, regnum) - register_size (gdbarch, regnum);
6574              byte < register_size (gdbarch, regnum); byte++)
6575           fprintf_filtered (file, "%02x", raw_buffer[byte]);
6576       else
6577         for (byte = register_size (gdbarch, regnum) - 1;
6578              byte >= 0; byte--)
6579           fprintf_filtered (file, "%02x", raw_buffer[byte]);
6580       fprintf_filtered (file, " ");
6581       col++;
6582     }
6583   if (col > 0)                  /* ie. if we actually printed anything...  */
6584     fprintf_filtered (file, "\n");
6585
6586   return regnum;
6587 }
6588
6589 /* MIPS_DO_REGISTERS_INFO(): called by "info register" command.  */
6590
6591 static void
6592 mips_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
6593                            struct frame_info *frame, int regnum, int all)
6594 {
6595   if (regnum != -1)             /* Do one specified register.  */
6596     {
6597       gdb_assert (regnum >= gdbarch_num_regs (gdbarch));
6598       if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
6599         error (_("Not a valid register for the current processor type"));
6600
6601       mips_print_register (file, frame, regnum);
6602       fprintf_filtered (file, "\n");
6603     }
6604   else
6605     /* Do all (or most) registers.  */
6606     {
6607       regnum = gdbarch_num_regs (gdbarch);
6608       while (regnum < gdbarch_num_regs (gdbarch)
6609                       + gdbarch_num_pseudo_regs (gdbarch))
6610         {
6611           if (mips_float_register_p (gdbarch, regnum))
6612             {
6613               if (all)          /* True for "INFO ALL-REGISTERS" command.  */
6614                 regnum = print_fp_register_row (file, frame, regnum);
6615               else
6616                 regnum += MIPS_NUMREGS; /* Skip floating point regs.  */
6617             }
6618           else
6619             regnum = print_gp_register_row (file, frame, regnum);
6620         }
6621     }
6622 }
6623
6624 static int
6625 mips_single_step_through_delay (struct gdbarch *gdbarch,
6626                                 struct frame_info *frame)
6627 {
6628   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
6629   CORE_ADDR pc = get_frame_pc (frame);
6630   struct address_space *aspace;
6631   enum mips_isa isa;
6632   ULONGEST insn;
6633   int status;
6634   int size;
6635
6636   if ((mips_pc_is_mips (pc)
6637        && !mips32_insn_at_pc_has_delay_slot (gdbarch, pc))
6638       || (mips_pc_is_micromips (gdbarch, pc)
6639           && !micromips_insn_at_pc_has_delay_slot (gdbarch, pc, 0))
6640       || (mips_pc_is_mips16 (gdbarch, pc)
6641           && !mips16_insn_at_pc_has_delay_slot (gdbarch, pc, 0)))
6642     return 0;
6643
6644   isa = mips_pc_isa (gdbarch, pc);
6645   /* _has_delay_slot above will have validated the read.  */
6646   insn = mips_fetch_instruction (gdbarch, isa, pc, NULL);
6647   size = mips_insn_size (isa, insn);
6648   aspace = get_frame_address_space (frame);
6649   return breakpoint_here_p (aspace, pc + size) != no_breakpoint_here;
6650 }
6651
6652 /* To skip prologues, I use this predicate.  Returns either PC itself
6653    if the code at PC does not look like a function prologue; otherwise
6654    returns an address that (if we're lucky) follows the prologue.  If
6655    LENIENT, then we must skip everything which is involved in setting
6656    up the frame (it's OK to skip more, just so long as we don't skip
6657    anything which might clobber the registers which are being saved.
6658    We must skip more in the case where part of the prologue is in the
6659    delay slot of a non-prologue instruction).  */
6660
6661 static CORE_ADDR
6662 mips_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
6663 {
6664   CORE_ADDR limit_pc;
6665   CORE_ADDR func_addr;
6666
6667   /* See if we can determine the end of the prologue via the symbol table.
6668      If so, then return either PC, or the PC after the prologue, whichever
6669      is greater.  */
6670   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
6671     {
6672       CORE_ADDR post_prologue_pc
6673         = skip_prologue_using_sal (gdbarch, func_addr);
6674       if (post_prologue_pc != 0)
6675         return max (pc, post_prologue_pc);
6676     }
6677
6678   /* Can't determine prologue from the symbol table, need to examine
6679      instructions.  */
6680
6681   /* Find an upper limit on the function prologue using the debug
6682      information.  If the debug information could not be used to provide
6683      that bound, then use an arbitrary large number as the upper bound.  */
6684   limit_pc = skip_prologue_using_sal (gdbarch, pc);
6685   if (limit_pc == 0)
6686     limit_pc = pc + 100;          /* Magic.  */
6687
6688   if (mips_pc_is_mips16 (gdbarch, pc))
6689     return mips16_scan_prologue (gdbarch, pc, limit_pc, NULL, NULL);
6690   else if (mips_pc_is_micromips (gdbarch, pc))
6691     return micromips_scan_prologue (gdbarch, pc, limit_pc, NULL, NULL);
6692   else
6693     return mips32_scan_prologue (gdbarch, pc, limit_pc, NULL, NULL);
6694 }
6695
6696 /* Check whether the PC is in a function epilogue (32-bit version).
6697    This is a helper function for mips_in_function_epilogue_p.  */
6698 static int
6699 mips32_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6700 {
6701   CORE_ADDR func_addr = 0, func_end = 0;
6702
6703   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
6704     {
6705       /* The MIPS epilogue is max. 12 bytes long.  */
6706       CORE_ADDR addr = func_end - 12;
6707
6708       if (addr < func_addr + 4)
6709         addr = func_addr + 4;
6710       if (pc < addr)
6711         return 0;
6712
6713       for (; pc < func_end; pc += MIPS_INSN32_SIZE)
6714         {
6715           unsigned long high_word;
6716           unsigned long inst;
6717
6718           inst = mips_fetch_instruction (gdbarch, ISA_MIPS, pc, NULL);
6719           high_word = (inst >> 16) & 0xffff;
6720
6721           if (high_word != 0x27bd       /* addiu $sp,$sp,offset */
6722               && high_word != 0x67bd    /* daddiu $sp,$sp,offset */
6723               && inst != 0x03e00008     /* jr $ra */
6724               && inst != 0x00000000)    /* nop */
6725             return 0;
6726         }
6727
6728       return 1;
6729     }
6730
6731   return 0;
6732 }
6733
6734 /* Check whether the PC is in a function epilogue (microMIPS version).
6735    This is a helper function for mips_in_function_epilogue_p.  */
6736
6737 static int
6738 micromips_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6739 {
6740   CORE_ADDR func_addr = 0;
6741   CORE_ADDR func_end = 0;
6742   CORE_ADDR addr;
6743   ULONGEST insn;
6744   long offset;
6745   int dreg;
6746   int sreg;
6747   int loc;
6748
6749   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
6750     return 0;
6751
6752   /* The microMIPS epilogue is max. 12 bytes long.  */
6753   addr = func_end - 12;
6754
6755   if (addr < func_addr + 2)
6756     addr = func_addr + 2;
6757   if (pc < addr)
6758     return 0;
6759
6760   for (; pc < func_end; pc += loc)
6761     {
6762       loc = 0;
6763       insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, NULL);
6764       loc += MIPS_INSN16_SIZE;
6765       switch (mips_insn_size (ISA_MICROMIPS, insn))
6766         {
6767         /* 48-bit instructions.  */
6768         case 3 * MIPS_INSN16_SIZE:
6769           /* No epilogue instructions in this category.  */
6770           return 0;
6771
6772         /* 32-bit instructions.  */
6773         case 2 * MIPS_INSN16_SIZE:
6774           insn <<= 16;
6775           insn |= mips_fetch_instruction (gdbarch,
6776                                           ISA_MICROMIPS, pc + loc, NULL);
6777           loc += MIPS_INSN16_SIZE;
6778           switch (micromips_op (insn >> 16))
6779             {
6780             case 0xc: /* ADDIU: bits 001100 */
6781             case 0x17: /* DADDIU: bits 010111 */
6782               sreg = b0s5_reg (insn >> 16);
6783               dreg = b5s5_reg (insn >> 16);
6784               offset = (b0s16_imm (insn) ^ 0x8000) - 0x8000;
6785               if (sreg == MIPS_SP_REGNUM && dreg == MIPS_SP_REGNUM
6786                             /* (D)ADDIU $sp, imm */
6787                   && offset >= 0)
6788                 break;
6789               return 0;
6790
6791             default:
6792               return 0;
6793             }
6794           break;
6795
6796         /* 16-bit instructions.  */
6797         case MIPS_INSN16_SIZE:
6798           switch (micromips_op (insn))
6799             {
6800             case 0x3: /* MOVE: bits 000011 */
6801               sreg = b0s5_reg (insn);
6802               dreg = b5s5_reg (insn);
6803               if (sreg == 0 && dreg == 0)
6804                                 /* MOVE $zero, $zero aka NOP */
6805                 break;
6806               return 0;
6807
6808             case 0x11: /* POOL16C: bits 010001 */
6809               if (b5s5_op (insn) == 0x18
6810                                 /* JRADDIUSP: bits 010011 11000 */
6811                   || (b5s5_op (insn) == 0xd
6812                                 /* JRC: bits 010011 01101 */
6813                       && b0s5_reg (insn) == MIPS_RA_REGNUM))
6814                                 /* JRC $ra */
6815                 break;
6816               return 0;
6817
6818             case 0x13: /* POOL16D: bits 010011 */
6819               offset = micromips_decode_imm9 (b1s9_imm (insn));
6820               if ((insn & 0x1) == 0x1
6821                                 /* ADDIUSP: bits 010011 1 */
6822                   && offset > 0)
6823                 break;
6824               return 0;
6825
6826             default:
6827               return 0;
6828             }
6829         }
6830     }
6831
6832   return 1;
6833 }
6834
6835 /* Check whether the PC is in a function epilogue (16-bit version).
6836    This is a helper function for mips_in_function_epilogue_p.  */
6837 static int
6838 mips16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6839 {
6840   CORE_ADDR func_addr = 0, func_end = 0;
6841
6842   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
6843     {
6844       /* The MIPS epilogue is max. 12 bytes long.  */
6845       CORE_ADDR addr = func_end - 12;
6846
6847       if (addr < func_addr + 4)
6848         addr = func_addr + 4;
6849       if (pc < addr)
6850         return 0;
6851
6852       for (; pc < func_end; pc += MIPS_INSN16_SIZE)
6853         {
6854           unsigned short inst;
6855
6856           inst = mips_fetch_instruction (gdbarch, ISA_MIPS16, pc, NULL);
6857
6858           if ((inst & 0xf800) == 0xf000)        /* extend */
6859             continue;
6860
6861           if (inst != 0x6300            /* addiu $sp,offset */
6862               && inst != 0xfb00         /* daddiu $sp,$sp,offset */
6863               && inst != 0xe820         /* jr $ra */
6864               && inst != 0xe8a0         /* jrc $ra */
6865               && inst != 0x6500)        /* nop */
6866             return 0;
6867         }
6868
6869       return 1;
6870     }
6871
6872   return 0;
6873 }
6874
6875 /* The epilogue is defined here as the area at the end of a function,
6876    after an instruction which destroys the function's stack frame.  */
6877 static int
6878 mips_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6879 {
6880   if (mips_pc_is_mips16 (gdbarch, pc))
6881     return mips16_in_function_epilogue_p (gdbarch, pc);
6882   else if (mips_pc_is_micromips (gdbarch, pc))
6883     return micromips_in_function_epilogue_p (gdbarch, pc);
6884   else
6885     return mips32_in_function_epilogue_p (gdbarch, pc);
6886 }
6887
6888 /* Root of all "set mips "/"show mips " commands.  This will eventually be
6889    used for all MIPS-specific commands.  */
6890
6891 static void
6892 show_mips_command (char *args, int from_tty)
6893 {
6894   help_list (showmipscmdlist, "show mips ", all_commands, gdb_stdout);
6895 }
6896
6897 static void
6898 set_mips_command (char *args, int from_tty)
6899 {
6900   printf_unfiltered
6901     ("\"set mips\" must be followed by an appropriate subcommand.\n");
6902   help_list (setmipscmdlist, "set mips ", all_commands, gdb_stdout);
6903 }
6904
6905 /* Commands to show/set the MIPS FPU type.  */
6906
6907 static void
6908 show_mipsfpu_command (char *args, int from_tty)
6909 {
6910   char *fpu;
6911
6912   if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
6913     {
6914       printf_unfiltered
6915         ("The MIPS floating-point coprocessor is unknown "
6916          "because the current architecture is not MIPS.\n");
6917       return;
6918     }
6919
6920   switch (MIPS_FPU_TYPE (target_gdbarch ()))
6921     {
6922     case MIPS_FPU_SINGLE:
6923       fpu = "single-precision";
6924       break;
6925     case MIPS_FPU_DOUBLE:
6926       fpu = "double-precision";
6927       break;
6928     case MIPS_FPU_NONE:
6929       fpu = "absent (none)";
6930       break;
6931     default:
6932       internal_error (__FILE__, __LINE__, _("bad switch"));
6933     }
6934   if (mips_fpu_type_auto)
6935     printf_unfiltered ("The MIPS floating-point coprocessor "
6936                        "is set automatically (currently %s)\n",
6937                        fpu);
6938   else
6939     printf_unfiltered
6940       ("The MIPS floating-point coprocessor is assumed to be %s\n", fpu);
6941 }
6942
6943
6944 static void
6945 set_mipsfpu_command (char *args, int from_tty)
6946 {
6947   printf_unfiltered ("\"set mipsfpu\" must be followed by \"double\", "
6948                      "\"single\",\"none\" or \"auto\".\n");
6949   show_mipsfpu_command (args, from_tty);
6950 }
6951
6952 static void
6953 set_mipsfpu_single_command (char *args, int from_tty)
6954 {
6955   struct gdbarch_info info;
6956   gdbarch_info_init (&info);
6957   mips_fpu_type = MIPS_FPU_SINGLE;
6958   mips_fpu_type_auto = 0;
6959   /* FIXME: cagney/2003-11-15: Should be setting a field in "info"
6960      instead of relying on globals.  Doing that would let generic code
6961      handle the search for this specific architecture.  */
6962   if (!gdbarch_update_p (info))
6963     internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
6964 }
6965
6966 static void
6967 set_mipsfpu_double_command (char *args, int from_tty)
6968 {
6969   struct gdbarch_info info;
6970   gdbarch_info_init (&info);
6971   mips_fpu_type = MIPS_FPU_DOUBLE;
6972   mips_fpu_type_auto = 0;
6973   /* FIXME: cagney/2003-11-15: Should be setting a field in "info"
6974      instead of relying on globals.  Doing that would let generic code
6975      handle the search for this specific architecture.  */
6976   if (!gdbarch_update_p (info))
6977     internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
6978 }
6979
6980 static void
6981 set_mipsfpu_none_command (char *args, int from_tty)
6982 {
6983   struct gdbarch_info info;
6984   gdbarch_info_init (&info);
6985   mips_fpu_type = MIPS_FPU_NONE;
6986   mips_fpu_type_auto = 0;
6987   /* FIXME: cagney/2003-11-15: Should be setting a field in "info"
6988      instead of relying on globals.  Doing that would let generic code
6989      handle the search for this specific architecture.  */
6990   if (!gdbarch_update_p (info))
6991     internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
6992 }
6993
6994 static void
6995 set_mipsfpu_auto_command (char *args, int from_tty)
6996 {
6997   mips_fpu_type_auto = 1;
6998 }
6999
7000 /* Attempt to identify the particular processor model by reading the
7001    processor id.  NOTE: cagney/2003-11-15: Firstly it isn't clear that
7002    the relevant processor still exists (it dates back to '94) and
7003    secondly this is not the way to do this.  The processor type should
7004    be set by forcing an architecture change.  */
7005
7006 void
7007 deprecated_mips_set_processor_regs_hack (void)
7008 {
7009   struct regcache *regcache = get_current_regcache ();
7010   struct gdbarch *gdbarch = get_regcache_arch (regcache);
7011   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7012   ULONGEST prid;
7013
7014   regcache_cooked_read_unsigned (regcache, MIPS_PRID_REGNUM, &prid);
7015   if ((prid & ~0xf) == 0x700)
7016     tdep->mips_processor_reg_names = mips_r3041_reg_names;
7017 }
7018
7019 /* Just like reinit_frame_cache, but with the right arguments to be
7020    callable as an sfunc.  */
7021
7022 static void
7023 reinit_frame_cache_sfunc (char *args, int from_tty,
7024                           struct cmd_list_element *c)
7025 {
7026   reinit_frame_cache ();
7027 }
7028
7029 static int
7030 gdb_print_insn_mips (bfd_vma memaddr, struct disassemble_info *info)
7031 {
7032   struct gdbarch *gdbarch = info->application_data;
7033
7034   /* FIXME: cagney/2003-06-26: Is this even necessary?  The
7035      disassembler needs to be able to locally determine the ISA, and
7036      not rely on GDB.  Otherwize the stand-alone 'objdump -d' will not
7037      work.  */
7038   if (mips_pc_is_mips16 (gdbarch, memaddr))
7039     info->mach = bfd_mach_mips16;
7040   else if (mips_pc_is_micromips (gdbarch, memaddr))
7041     info->mach = bfd_mach_mips_micromips;
7042
7043   /* Round down the instruction address to the appropriate boundary.  */
7044   memaddr &= (info->mach == bfd_mach_mips16
7045               || info->mach == bfd_mach_mips_micromips) ? ~1 : ~3;
7046
7047   /* Set the disassembler options.  */
7048   if (!info->disassembler_options)
7049     /* This string is not recognized explicitly by the disassembler,
7050        but it tells the disassembler to not try to guess the ABI from
7051        the bfd elf headers, such that, if the user overrides the ABI
7052        of a program linked as NewABI, the disassembly will follow the
7053        register naming conventions specified by the user.  */
7054     info->disassembler_options = "gpr-names=32";
7055
7056   /* Call the appropriate disassembler based on the target endian-ness.  */
7057   if (info->endian == BFD_ENDIAN_BIG)
7058     return print_insn_big_mips (memaddr, info);
7059   else
7060     return print_insn_little_mips (memaddr, info);
7061 }
7062
7063 static int
7064 gdb_print_insn_mips_n32 (bfd_vma memaddr, struct disassemble_info *info)
7065 {
7066   /* Set up the disassembler info, so that we get the right
7067      register names from libopcodes.  */
7068   info->disassembler_options = "gpr-names=n32";
7069   info->flavour = bfd_target_elf_flavour;
7070
7071   return gdb_print_insn_mips (memaddr, info);
7072 }
7073
7074 static int
7075 gdb_print_insn_mips_n64 (bfd_vma memaddr, struct disassemble_info *info)
7076 {
7077   /* Set up the disassembler info, so that we get the right
7078      register names from libopcodes.  */
7079   info->disassembler_options = "gpr-names=64";
7080   info->flavour = bfd_target_elf_flavour;
7081
7082   return gdb_print_insn_mips (memaddr, info);
7083 }
7084
7085 /* This function implements gdbarch_breakpoint_from_pc.  It uses the
7086    program counter value to determine whether a 16- or 32-bit breakpoint
7087    should be used.  It returns a pointer to a string of bytes that encode a
7088    breakpoint instruction, stores the length of the string to *lenptr, and
7089    adjusts pc (if necessary) to point to the actual memory location where
7090    the breakpoint should be inserted.  */
7091
7092 static const gdb_byte *
7093 mips_breakpoint_from_pc (struct gdbarch *gdbarch,
7094                          CORE_ADDR *pcptr, int *lenptr)
7095 {
7096   CORE_ADDR pc = *pcptr;
7097
7098   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
7099     {
7100       if (mips_pc_is_mips16 (gdbarch, pc))
7101         {
7102           static gdb_byte mips16_big_breakpoint[] = { 0xe8, 0xa5 };
7103           *pcptr = unmake_compact_addr (pc);
7104           *lenptr = sizeof (mips16_big_breakpoint);
7105           return mips16_big_breakpoint;
7106         }
7107       else if (mips_pc_is_micromips (gdbarch, pc))
7108         {
7109           static gdb_byte micromips16_big_breakpoint[] = { 0x46, 0x85 };
7110           static gdb_byte micromips32_big_breakpoint[] = { 0, 0x5, 0, 0x7 };
7111           ULONGEST insn;
7112           int status;
7113           int size;
7114
7115           insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, &status);
7116           size = status ? 2
7117                         : mips_insn_size (ISA_MICROMIPS, insn) == 2 ? 2 : 4;
7118           *pcptr = unmake_compact_addr (pc);
7119           *lenptr = size;
7120           return (size == 2) ? micromips16_big_breakpoint
7121                              : micromips32_big_breakpoint;
7122         }
7123       else
7124         {
7125           /* The IDT board uses an unusual breakpoint value, and
7126              sometimes gets confused when it sees the usual MIPS
7127              breakpoint instruction.  */
7128           static gdb_byte big_breakpoint[] = { 0, 0x5, 0, 0xd };
7129           static gdb_byte pmon_big_breakpoint[] = { 0, 0, 0, 0xd };
7130           static gdb_byte idt_big_breakpoint[] = { 0, 0, 0x0a, 0xd };
7131           /* Likewise, IRIX appears to expect a different breakpoint,
7132              although this is not apparent until you try to use pthreads.  */
7133           static gdb_byte irix_big_breakpoint[] = { 0, 0, 0, 0xd };
7134
7135           *lenptr = sizeof (big_breakpoint);
7136
7137           if (strcmp (target_shortname, "mips") == 0)
7138             return idt_big_breakpoint;
7139           else if (strcmp (target_shortname, "ddb") == 0
7140                    || strcmp (target_shortname, "pmon") == 0
7141                    || strcmp (target_shortname, "lsi") == 0)
7142             return pmon_big_breakpoint;
7143           else if (gdbarch_osabi (gdbarch) == GDB_OSABI_IRIX)
7144             return irix_big_breakpoint;
7145           else
7146             return big_breakpoint;
7147         }
7148     }
7149   else
7150     {
7151       if (mips_pc_is_mips16 (gdbarch, pc))
7152         {
7153           static gdb_byte mips16_little_breakpoint[] = { 0xa5, 0xe8 };
7154           *pcptr = unmake_compact_addr (pc);
7155           *lenptr = sizeof (mips16_little_breakpoint);
7156           return mips16_little_breakpoint;
7157         }
7158       else if (mips_pc_is_micromips (gdbarch, pc))
7159         {
7160           static gdb_byte micromips16_little_breakpoint[] = { 0x85, 0x46 };
7161           static gdb_byte micromips32_little_breakpoint[] = { 0x5, 0, 0x7, 0 };
7162           ULONGEST insn;
7163           int status;
7164           int size;
7165
7166           insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, &status);
7167           size = status ? 2
7168                         : mips_insn_size (ISA_MICROMIPS, insn) == 2 ? 2 : 4;
7169           *pcptr = unmake_compact_addr (pc);
7170           *lenptr = size;
7171           return (size == 2) ? micromips16_little_breakpoint
7172                              : micromips32_little_breakpoint;
7173         }
7174       else
7175         {
7176           static gdb_byte little_breakpoint[] = { 0xd, 0, 0x5, 0 };
7177           static gdb_byte pmon_little_breakpoint[] = { 0xd, 0, 0, 0 };
7178           static gdb_byte idt_little_breakpoint[] = { 0xd, 0x0a, 0, 0 };
7179
7180           *lenptr = sizeof (little_breakpoint);
7181
7182           if (strcmp (target_shortname, "mips") == 0)
7183             return idt_little_breakpoint;
7184           else if (strcmp (target_shortname, "ddb") == 0
7185                    || strcmp (target_shortname, "pmon") == 0
7186                    || strcmp (target_shortname, "lsi") == 0)
7187             return pmon_little_breakpoint;
7188           else
7189             return little_breakpoint;
7190         }
7191     }
7192 }
7193
7194 /* Determine the remote breakpoint kind suitable for the PC.  The following
7195    kinds are used:
7196
7197    * 2 -- 16-bit MIPS16 mode breakpoint,
7198
7199    * 3 -- 16-bit microMIPS mode breakpoint,
7200
7201    * 4 -- 32-bit standard MIPS mode breakpoint,
7202
7203    * 5 -- 32-bit microMIPS mode breakpoint.  */
7204
7205 static void
7206 mips_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
7207                                 int *kindptr)
7208 {
7209   CORE_ADDR pc = *pcptr;
7210
7211   if (mips_pc_is_mips16 (gdbarch, pc))
7212     {
7213       *pcptr = unmake_compact_addr (pc);
7214       *kindptr = 2;
7215     }
7216   else if (mips_pc_is_micromips (gdbarch, pc))
7217     {
7218       ULONGEST insn;
7219       int status;
7220       int size;
7221
7222       insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, &status);
7223       size = status ? 2 : mips_insn_size (ISA_MICROMIPS, insn) == 2 ? 2 : 4;
7224       *pcptr = unmake_compact_addr (pc);
7225       *kindptr = size | 1;
7226     }
7227   else
7228     *kindptr = 4;
7229 }
7230
7231 /* Return non-zero if the standard MIPS instruction INST has a branch
7232    delay slot (i.e. it is a jump or branch instruction).  This function
7233    is based on mips32_next_pc.  */
7234
7235 static int
7236 mips32_instruction_has_delay_slot (struct gdbarch *gdbarch, ULONGEST inst)
7237 {
7238   int op;
7239   int rs;
7240   int rt;
7241
7242   op = itype_op (inst);
7243   if ((inst & 0xe0000000) != 0)
7244     {
7245       rs = itype_rs (inst);
7246       rt = itype_rt (inst);
7247       return (is_octeon_bbit_op (op, gdbarch)
7248               || op >> 2 == 5   /* BEQL, BNEL, BLEZL, BGTZL: bits 0101xx  */
7249               || op == 29       /* JALX: bits 011101  */
7250               || (op == 17
7251                   && (rs == 8
7252                                 /* BC1F, BC1FL, BC1T, BC1TL: 010001 01000  */
7253                       || (rs == 9 && (rt & 0x2) == 0)
7254                                 /* BC1ANY2F, BC1ANY2T: bits 010001 01001  */
7255                       || (rs == 10 && (rt & 0x2) == 0))));
7256                                 /* BC1ANY4F, BC1ANY4T: bits 010001 01010  */
7257     }
7258   else
7259     switch (op & 0x07)          /* extract bits 28,27,26  */
7260       {
7261       case 0:                   /* SPECIAL  */
7262         op = rtype_funct (inst);
7263         return (op == 8         /* JR  */
7264                 || op == 9);    /* JALR  */
7265         break;                  /* end SPECIAL  */
7266       case 1:                   /* REGIMM  */
7267         rs = itype_rs (inst);
7268         rt = itype_rt (inst);   /* branch condition  */
7269         return ((rt & 0xc) == 0
7270                                 /* BLTZ, BLTZL, BGEZ, BGEZL: bits 000xx  */
7271                                 /* BLTZAL, BLTZALL, BGEZAL, BGEZALL: 100xx  */
7272                 || ((rt & 0x1e) == 0x1c && rs == 0));
7273                                 /* BPOSGE32, BPOSGE64: bits 1110x  */
7274         break;                  /* end REGIMM  */
7275       default:                  /* J, JAL, BEQ, BNE, BLEZ, BGTZ  */
7276         return 1;
7277         break;
7278       }
7279 }
7280
7281 /* Return non-zero if a standard MIPS instruction at ADDR has a branch
7282    delay slot (i.e. it is a jump or branch instruction).  */
7283
7284 static int
7285 mips32_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch, CORE_ADDR addr)
7286 {
7287   ULONGEST insn;
7288   int status;
7289
7290   insn = mips_fetch_instruction (gdbarch, ISA_MIPS, addr, &status);
7291   if (status)
7292     return 0;
7293
7294   return mips32_instruction_has_delay_slot (gdbarch, insn);
7295 }
7296
7297 /* Return non-zero if the microMIPS instruction INSN, comprising the
7298    16-bit major opcode word in the high 16 bits and any second word
7299    in the low 16 bits, has a branch delay slot (i.e. it is a non-compact
7300    jump or branch instruction).  The instruction must be 32-bit if
7301    MUSTBE32 is set or can be any instruction otherwise.  */
7302
7303 static int
7304 micromips_instruction_has_delay_slot (ULONGEST insn, int mustbe32)
7305 {
7306   ULONGEST major = insn >> 16;
7307
7308   switch (micromips_op (major))
7309     {
7310     /* 16-bit instructions.  */
7311     case 0x33:                  /* B16: bits 110011 */
7312     case 0x2b:                  /* BNEZ16: bits 101011 */
7313     case 0x23:                  /* BEQZ16: bits 100011 */
7314       return !mustbe32;
7315     case 0x11:                  /* POOL16C: bits 010001 */
7316       return (!mustbe32
7317               && ((b5s5_op (major) == 0xc
7318                                 /* JR16: bits 010001 01100 */
7319                   || (b5s5_op (major) & 0x1e) == 0xe)));
7320                                 /* JALR16, JALRS16: bits 010001 0111x */
7321     /* 32-bit instructions.  */
7322     case 0x3d:                  /* JAL: bits 111101 */
7323     case 0x3c:                  /* JALX: bits 111100 */
7324     case 0x35:                  /* J: bits 110101 */
7325     case 0x2d:                  /* BNE: bits 101101 */
7326     case 0x25:                  /* BEQ: bits 100101 */
7327     case 0x1d:                  /* JALS: bits 011101 */
7328       return 1;
7329     case 0x10:                  /* POOL32I: bits 010000 */
7330       return ((b5s5_op (major) & 0x1c) == 0x0
7331                                 /* BLTZ, BLTZAL, BGEZ, BGEZAL: 010000 000xx */
7332               || (b5s5_op (major) & 0x1d) == 0x4
7333                                 /* BLEZ, BGTZ: bits 010000 001x0 */
7334               || (b5s5_op (major) & 0x1d) == 0x11
7335                                 /* BLTZALS, BGEZALS: bits 010000 100x1 */
7336               || ((b5s5_op (major) & 0x1e) == 0x14
7337                   && (major & 0x3) == 0x0)
7338                                 /* BC2F, BC2T: bits 010000 1010x xxx00 */
7339               || (b5s5_op (major) & 0x1e) == 0x1a
7340                                 /* BPOSGE64, BPOSGE32: bits 010000 1101x */
7341               || ((b5s5_op (major) & 0x1e) == 0x1c
7342                   && (major & 0x3) == 0x0)
7343                                 /* BC1F, BC1T: bits 010000 1110x xxx00 */
7344               || ((b5s5_op (major) & 0x1c) == 0x1c
7345                   && (major & 0x3) == 0x1));
7346                                 /* BC1ANY*: bits 010000 111xx xxx01 */
7347     case 0x0:                   /* POOL32A: bits 000000 */
7348       return (b0s6_op (insn) == 0x3c
7349                                 /* POOL32Axf: bits 000000 ... 111100 */
7350               && (b6s10_ext (insn) & 0x2bf) == 0x3c);
7351                                 /* JALR, JALR.HB: 000000 000x111100 111100 */
7352                                 /* JALRS, JALRS.HB: 000000 010x111100 111100 */
7353     default:
7354       return 0;
7355     }
7356 }
7357
7358 /* Return non-zero if a microMIPS instruction at ADDR has a branch delay
7359    slot (i.e. it is a non-compact jump instruction).  The instruction
7360    must be 32-bit if MUSTBE32 is set or can be any instruction otherwise.  */
7361
7362 static int
7363 micromips_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch,
7364                                      CORE_ADDR addr, int mustbe32)
7365 {
7366   ULONGEST insn;
7367   int status;
7368
7369   insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, addr, &status);
7370   if (status)
7371     return 0;
7372   insn <<= 16;
7373   if (mips_insn_size (ISA_MICROMIPS, insn) == 2 * MIPS_INSN16_SIZE)
7374     {
7375       insn |= mips_fetch_instruction (gdbarch, ISA_MICROMIPS, addr, &status);
7376       if (status)
7377         return 0;
7378     }
7379
7380   return micromips_instruction_has_delay_slot (insn, mustbe32);
7381 }
7382
7383 /* Return non-zero if the MIPS16 instruction INST, which must be
7384    a 32-bit instruction if MUSTBE32 is set or can be any instruction
7385    otherwise, has a branch delay slot (i.e. it is a non-compact jump
7386    instruction).  This function is based on mips16_next_pc.  */
7387
7388 static int
7389 mips16_instruction_has_delay_slot (unsigned short inst, int mustbe32)
7390 {
7391   if ((inst & 0xf89f) == 0xe800)        /* JR/JALR (16-bit instruction)  */
7392     return !mustbe32;
7393   return (inst & 0xf800) == 0x1800;     /* JAL/JALX (32-bit instruction)  */
7394 }
7395
7396 /* Return non-zero if a MIPS16 instruction at ADDR has a branch delay
7397    slot (i.e. it is a non-compact jump instruction).  The instruction
7398    must be 32-bit if MUSTBE32 is set or can be any instruction otherwise.  */
7399
7400 static int
7401 mips16_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch,
7402                                   CORE_ADDR addr, int mustbe32)
7403 {
7404   unsigned short insn;
7405   int status;
7406
7407   insn = mips_fetch_instruction (gdbarch, ISA_MIPS16, addr, &status);
7408   if (status)
7409     return 0;
7410
7411   return mips16_instruction_has_delay_slot (insn, mustbe32);
7412 }
7413
7414 /* Calculate the starting address of the MIPS memory segment BPADDR is in.
7415    This assumes KSSEG exists.  */
7416
7417 static CORE_ADDR
7418 mips_segment_boundary (CORE_ADDR bpaddr)
7419 {
7420   CORE_ADDR mask = CORE_ADDR_MAX;
7421   int segsize;
7422
7423   if (sizeof (CORE_ADDR) == 8)
7424     /* Get the topmost two bits of bpaddr in a 32-bit safe manner (avoid
7425        a compiler warning produced where CORE_ADDR is a 32-bit type even
7426        though in that case this is dead code).  */
7427     switch (bpaddr >> ((sizeof (CORE_ADDR) << 3) - 2) & 3)
7428       {
7429       case 3:
7430         if (bpaddr == (bfd_signed_vma) (int32_t) bpaddr)
7431           segsize = 29;                 /* 32-bit compatibility segment  */
7432         else
7433           segsize = 62;                 /* xkseg  */
7434         break;
7435       case 2:                           /* xkphys  */
7436         segsize = 59;
7437         break;
7438       default:                          /* xksseg (1), xkuseg/kuseg (0)  */
7439         segsize = 62;
7440         break;
7441       }
7442   else if (bpaddr & 0x80000000)         /* kernel segment  */
7443     segsize = 29;
7444   else
7445     segsize = 31;                       /* user segment  */
7446   mask <<= segsize;
7447   return bpaddr & mask;
7448 }
7449
7450 /* Move the breakpoint at BPADDR out of any branch delay slot by shifting
7451    it backwards if necessary.  Return the address of the new location.  */
7452
7453 static CORE_ADDR
7454 mips_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
7455 {
7456   CORE_ADDR prev_addr;
7457   CORE_ADDR boundary;
7458   CORE_ADDR func_addr;
7459
7460   /* If a breakpoint is set on the instruction in a branch delay slot,
7461      GDB gets confused.  When the breakpoint is hit, the PC isn't on
7462      the instruction in the branch delay slot, the PC will point to
7463      the branch instruction.  Since the PC doesn't match any known
7464      breakpoints, GDB reports a trap exception.
7465
7466      There are two possible fixes for this problem.
7467
7468      1) When the breakpoint gets hit, see if the BD bit is set in the
7469      Cause register (which indicates the last exception occurred in a
7470      branch delay slot).  If the BD bit is set, fix the PC to point to
7471      the instruction in the branch delay slot.
7472
7473      2) When the user sets the breakpoint, don't allow him to set the
7474      breakpoint on the instruction in the branch delay slot.  Instead
7475      move the breakpoint to the branch instruction (which will have
7476      the same result).
7477
7478      The problem with the first solution is that if the user then
7479      single-steps the processor, the branch instruction will get
7480      skipped (since GDB thinks the PC is on the instruction in the
7481      branch delay slot).
7482
7483      So, we'll use the second solution.  To do this we need to know if
7484      the instruction we're trying to set the breakpoint on is in the
7485      branch delay slot.  */
7486
7487   boundary = mips_segment_boundary (bpaddr);
7488
7489   /* Make sure we don't scan back before the beginning of the current
7490      function, since we may fetch constant data or insns that look like
7491      a jump.  Of course we might do that anyway if the compiler has
7492      moved constants inline. :-(  */
7493   if (find_pc_partial_function (bpaddr, NULL, &func_addr, NULL)
7494       && func_addr > boundary && func_addr <= bpaddr)
7495     boundary = func_addr;
7496
7497   if (mips_pc_is_mips (bpaddr))
7498     {
7499       if (bpaddr == boundary)
7500         return bpaddr;
7501
7502       /* If the previous instruction has a branch delay slot, we have
7503          to move the breakpoint to the branch instruction. */
7504       prev_addr = bpaddr - 4;
7505       if (mips32_insn_at_pc_has_delay_slot (gdbarch, prev_addr))
7506         bpaddr = prev_addr;
7507     }
7508   else
7509     {
7510       int (*insn_at_pc_has_delay_slot) (struct gdbarch *, CORE_ADDR, int);
7511       CORE_ADDR addr, jmpaddr;
7512       int i;
7513
7514       boundary = unmake_compact_addr (boundary);
7515
7516       /* The only MIPS16 instructions with delay slots are JAL, JALX,
7517          JALR and JR.  An absolute JAL/JALX is always 4 bytes long,
7518          so try for that first, then try the 2 byte JALR/JR.
7519          The microMIPS ASE has a whole range of jumps and branches
7520          with delay slots, some of which take 4 bytes and some take
7521          2 bytes, so the idea is the same.
7522          FIXME: We have to assume that bpaddr is not the second half
7523          of an extended instruction.  */
7524       insn_at_pc_has_delay_slot = (mips_pc_is_micromips (gdbarch, bpaddr)
7525                                    ? micromips_insn_at_pc_has_delay_slot
7526                                    : mips16_insn_at_pc_has_delay_slot);
7527
7528       jmpaddr = 0;
7529       addr = bpaddr;
7530       for (i = 1; i < 4; i++)
7531         {
7532           if (unmake_compact_addr (addr) == boundary)
7533             break;
7534           addr -= MIPS_INSN16_SIZE;
7535           if (i == 1 && insn_at_pc_has_delay_slot (gdbarch, addr, 0))
7536             /* Looks like a JR/JALR at [target-1], but it could be
7537                the second word of a previous JAL/JALX, so record it
7538                and check back one more.  */
7539             jmpaddr = addr;
7540           else if (i > 1 && insn_at_pc_has_delay_slot (gdbarch, addr, 1))
7541             {
7542               if (i == 2)
7543                 /* Looks like a JAL/JALX at [target-2], but it could also
7544                    be the second word of a previous JAL/JALX, record it,
7545                    and check back one more.  */
7546                 jmpaddr = addr;
7547               else
7548                 /* Looks like a JAL/JALX at [target-3], so any previously
7549                    recorded JAL/JALX or JR/JALR must be wrong, because:
7550
7551                    >-3: JAL
7552                     -2: JAL-ext (can't be JAL/JALX)
7553                     -1: bdslot (can't be JR/JALR)
7554                      0: target insn
7555
7556                    Of course it could be another JAL-ext which looks
7557                    like a JAL, but in that case we'd have broken out
7558                    of this loop at [target-2]:
7559
7560                     -4: JAL
7561                    >-3: JAL-ext
7562                     -2: bdslot (can't be jmp)
7563                     -1: JR/JALR
7564                      0: target insn  */
7565                 jmpaddr = 0;
7566             }
7567           else
7568             {
7569               /* Not a jump instruction: if we're at [target-1] this
7570                  could be the second word of a JAL/JALX, so continue;
7571                  otherwise we're done.  */
7572               if (i > 1)
7573                 break;
7574             }
7575         }
7576
7577       if (jmpaddr)
7578         bpaddr = jmpaddr;
7579     }
7580
7581   return bpaddr;
7582 }
7583
7584 /* Return non-zero if SUFFIX is one of the numeric suffixes used for MIPS16
7585    call stubs, one of 1, 2, 5, 6, 9, 10, or, if ZERO is non-zero, also 0.  */
7586
7587 static int
7588 mips_is_stub_suffix (const char *suffix, int zero)
7589 {
7590   switch (suffix[0])
7591    {
7592    case '0':
7593      return zero && suffix[1] == '\0';
7594    case '1':
7595      return suffix[1] == '\0' || (suffix[1] == '0' && suffix[2] == '\0');
7596    case '2':
7597    case '5':
7598    case '6':
7599    case '9':
7600      return suffix[1] == '\0';
7601    default:
7602      return 0;
7603    }
7604 }
7605
7606 /* Return non-zero if MODE is one of the mode infixes used for MIPS16
7607    call stubs, one of sf, df, sc, or dc.  */
7608
7609 static int
7610 mips_is_stub_mode (const char *mode)
7611 {
7612   return ((mode[0] == 's' || mode[0] == 'd')
7613           && (mode[1] == 'f' || mode[1] == 'c'));
7614 }
7615
7616 /* Code at PC is a compiler-generated stub.  Such a stub for a function
7617    bar might have a name like __fn_stub_bar, and might look like this:
7618
7619       mfc1    $4, $f13
7620       mfc1    $5, $f12
7621       mfc1    $6, $f15
7622       mfc1    $7, $f14
7623
7624    followed by (or interspersed with):
7625
7626       j       bar
7627
7628    or:
7629
7630       lui     $25, %hi(bar)
7631       addiu   $25, $25, %lo(bar)
7632       jr      $25
7633
7634    ($1 may be used in old code; for robustness we accept any register)
7635    or, in PIC code:
7636
7637       lui     $28, %hi(_gp_disp)
7638       addiu   $28, $28, %lo(_gp_disp)
7639       addu    $28, $28, $25
7640       lw      $25, %got(bar)
7641       addiu   $25, $25, %lo(bar)
7642       jr      $25
7643
7644    In the case of a __call_stub_bar stub, the sequence to set up
7645    arguments might look like this:
7646
7647       mtc1    $4, $f13
7648       mtc1    $5, $f12
7649       mtc1    $6, $f15
7650       mtc1    $7, $f14
7651
7652    followed by (or interspersed with) one of the jump sequences above.
7653
7654    In the case of a __call_stub_fp_bar stub, JAL or JALR is used instead
7655    of J or JR, respectively, followed by:
7656
7657       mfc1    $2, $f0
7658       mfc1    $3, $f1
7659       jr      $18
7660
7661    We are at the beginning of the stub here, and scan down and extract
7662    the target address from the jump immediate instruction or, if a jump
7663    register instruction is used, from the register referred.  Return
7664    the value of PC calculated or 0 if inconclusive.
7665
7666    The limit on the search is arbitrarily set to 20 instructions.  FIXME.  */
7667
7668 static CORE_ADDR
7669 mips_get_mips16_fn_stub_pc (struct frame_info *frame, CORE_ADDR pc)
7670 {
7671   struct gdbarch *gdbarch = get_frame_arch (frame);
7672   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7673   int addrreg = MIPS_ZERO_REGNUM;
7674   CORE_ADDR start_pc = pc;
7675   CORE_ADDR target_pc = 0;
7676   CORE_ADDR addr = 0;
7677   CORE_ADDR gp = 0;
7678   int status = 0;
7679   int i;
7680
7681   for (i = 0;
7682        status == 0 && target_pc == 0 && i < 20;
7683        i++, pc += MIPS_INSN32_SIZE)
7684     {
7685       ULONGEST inst = mips_fetch_instruction (gdbarch, ISA_MIPS, pc, NULL);
7686       CORE_ADDR imm;
7687       int rt;
7688       int rs;
7689       int rd;
7690
7691       switch (itype_op (inst))
7692         {
7693         case 0:         /* SPECIAL */
7694           switch (rtype_funct (inst))
7695             {
7696             case 8:             /* JR */
7697             case 9:             /* JALR */
7698               rs = rtype_rs (inst);
7699               if (rs == MIPS_GP_REGNUM)
7700                 target_pc = gp;                         /* Hmm...  */
7701               else if (rs == addrreg)
7702                 target_pc = addr;
7703               break;
7704
7705             case 0x21:          /* ADDU */
7706               rt = rtype_rt (inst);
7707               rs = rtype_rs (inst);
7708               rd = rtype_rd (inst);
7709               if (rd == MIPS_GP_REGNUM
7710                   && ((rs == MIPS_GP_REGNUM && rt == MIPS_T9_REGNUM)
7711                       || (rs == MIPS_T9_REGNUM && rt == MIPS_GP_REGNUM)))
7712                 gp += start_pc;
7713               break;
7714             }
7715           break;
7716
7717         case 2:         /* J */
7718         case 3:         /* JAL */
7719           target_pc = jtype_target (inst) << 2;
7720           target_pc += ((pc + 4) & ~(CORE_ADDR) 0x0fffffff);
7721           break;
7722
7723         case 9:         /* ADDIU */
7724           rt = itype_rt (inst);
7725           rs = itype_rs (inst);
7726           if (rt == rs)
7727             {
7728               imm = (itype_immediate (inst) ^ 0x8000) - 0x8000;
7729               if (rt == MIPS_GP_REGNUM)
7730                 gp += imm;
7731               else if (rt == addrreg)
7732                 addr += imm;
7733             }
7734           break;
7735
7736         case 0xf:       /* LUI */
7737           rt = itype_rt (inst);
7738           imm = ((itype_immediate (inst) ^ 0x8000) - 0x8000) << 16;
7739           if (rt == MIPS_GP_REGNUM)
7740             gp = imm;
7741           else if (rt != MIPS_ZERO_REGNUM)
7742             {
7743               addrreg = rt;
7744               addr = imm;
7745             }
7746           break;
7747
7748         case 0x23:      /* LW */
7749           rt = itype_rt (inst);
7750           rs = itype_rs (inst);
7751           imm = (itype_immediate (inst) ^ 0x8000) - 0x8000;
7752           if (gp != 0 && rs == MIPS_GP_REGNUM)
7753             {
7754               gdb_byte buf[4];
7755
7756               memset (buf, 0, sizeof (buf));
7757               status = target_read_memory (gp + imm, buf, sizeof (buf));
7758               addrreg = rt;
7759               addr = extract_signed_integer (buf, sizeof (buf), byte_order);
7760             }
7761           break;
7762         }
7763     }
7764
7765   return target_pc;
7766 }
7767
7768 /* If PC is in a MIPS16 call or return stub, return the address of the
7769    target PC, which is either the callee or the caller.  There are several
7770    cases which must be handled:
7771
7772    * If the PC is in __mips16_ret_{d,s}{f,c}, this is a return stub
7773      and the target PC is in $31 ($ra).
7774    * If the PC is in __mips16_call_stub_{1..10}, this is a call stub
7775      and the target PC is in $2.
7776    * If the PC at the start of __mips16_call_stub_{s,d}{f,c}_{0..10},
7777      i.e. before the JALR instruction, this is effectively a call stub
7778      and the target PC is in $2.  Otherwise this is effectively
7779      a return stub and the target PC is in $18.
7780    * If the PC is at the start of __call_stub_fp_*, i.e. before the
7781      JAL or JALR instruction, this is effectively a call stub and the
7782      target PC is buried in the instruction stream.  Otherwise this
7783      is effectively a return stub and the target PC is in $18.
7784    * If the PC is in __call_stub_* or in __fn_stub_*, this is a call
7785      stub and the target PC is buried in the instruction stream.
7786
7787    See the source code for the stubs in gcc/config/mips/mips16.S, or the
7788    stub builder in gcc/config/mips/mips.c (mips16_build_call_stub) for the
7789    gory details.  */
7790
7791 static CORE_ADDR
7792 mips_skip_mips16_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
7793 {
7794   struct gdbarch *gdbarch = get_frame_arch (frame);
7795   CORE_ADDR start_addr;
7796   const char *name;
7797   size_t prefixlen;
7798
7799   /* Find the starting address and name of the function containing the PC.  */
7800   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
7801     return 0;
7802
7803   /* If the PC is in __mips16_ret_{d,s}{f,c}, this is a return stub
7804      and the target PC is in $31 ($ra).  */
7805   prefixlen = strlen (mips_str_mips16_ret_stub);
7806   if (strncmp (name, mips_str_mips16_ret_stub, prefixlen) == 0
7807       && mips_is_stub_mode (name + prefixlen)
7808       && name[prefixlen + 2] == '\0')
7809     return get_frame_register_signed
7810              (frame, gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM);
7811
7812   /* If the PC is in __mips16_call_stub_*, this is one of the call
7813      call/return stubs.  */
7814   prefixlen = strlen (mips_str_mips16_call_stub);
7815   if (strncmp (name, mips_str_mips16_call_stub, prefixlen) == 0)
7816     {
7817       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub
7818          and the target PC is in $2.  */
7819       if (mips_is_stub_suffix (name + prefixlen, 0))
7820         return get_frame_register_signed
7821                  (frame, gdbarch_num_regs (gdbarch) + MIPS_V0_REGNUM);
7822
7823       /* If the PC at the start of __mips16_call_stub_{s,d}{f,c}_{0..10},
7824          i.e. before the JALR instruction, this is effectively a call stub
7825          and the target PC is in $2.  Otherwise this is effectively
7826          a return stub and the target PC is in $18.  */
7827       else if (mips_is_stub_mode (name + prefixlen)
7828                && name[prefixlen + 2] == '_'
7829                && mips_is_stub_suffix (name + prefixlen + 3, 0))
7830         {
7831           if (pc == start_addr)
7832             /* This is the 'call' part of a call stub.  The return
7833                address is in $2.  */
7834             return get_frame_register_signed
7835                      (frame, gdbarch_num_regs (gdbarch) + MIPS_V0_REGNUM);
7836           else
7837             /* This is the 'return' part of a call stub.  The return
7838                address is in $18.  */
7839             return get_frame_register_signed
7840                      (frame, gdbarch_num_regs (gdbarch) + MIPS_S2_REGNUM);
7841         }
7842       else
7843         return 0;               /* Not a stub.  */
7844     }
7845
7846   /* If the PC is in __call_stub_* or __fn_stub*, this is one of the
7847      compiler-generated call or call/return stubs.  */
7848   if (strncmp (name, mips_str_fn_stub, strlen (mips_str_fn_stub)) == 0
7849       || strncmp (name, mips_str_call_stub, strlen (mips_str_call_stub)) == 0)
7850     {
7851       if (pc == start_addr)
7852         /* This is the 'call' part of a call stub.  Call this helper
7853            to scan through this code for interesting instructions
7854            and determine the final PC.  */
7855         return mips_get_mips16_fn_stub_pc (frame, pc);
7856       else
7857         /* This is the 'return' part of a call stub.  The return address
7858            is in $18.  */
7859         return get_frame_register_signed
7860                  (frame, gdbarch_num_regs (gdbarch) + MIPS_S2_REGNUM);
7861     }
7862
7863   return 0;                     /* Not a stub.  */
7864 }
7865
7866 /* Return non-zero if the PC is inside a return thunk (aka stub or trampoline).
7867    This implements the IN_SOLIB_RETURN_TRAMPOLINE macro.  */
7868
7869 static int
7870 mips_in_return_stub (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
7871 {
7872   CORE_ADDR start_addr;
7873   size_t prefixlen;
7874
7875   /* Find the starting address of the function containing the PC.  */
7876   if (find_pc_partial_function (pc, NULL, &start_addr, NULL) == 0)
7877     return 0;
7878
7879   /* If the PC is in __mips16_call_stub_{s,d}{f,c}_{0..10} but not at
7880      the start, i.e. after the JALR instruction, this is effectively
7881      a return stub.  */
7882   prefixlen = strlen (mips_str_mips16_call_stub);
7883   if (pc != start_addr
7884       && strncmp (name, mips_str_mips16_call_stub, prefixlen) == 0
7885       && mips_is_stub_mode (name + prefixlen)
7886       && name[prefixlen + 2] == '_'
7887       && mips_is_stub_suffix (name + prefixlen + 3, 1))
7888     return 1;
7889
7890   /* If the PC is in __call_stub_fp_* but not at the start, i.e. after
7891      the JAL or JALR instruction, this is effectively a return stub.  */
7892   prefixlen = strlen (mips_str_call_fp_stub);
7893   if (pc != start_addr
7894       && strncmp (name, mips_str_call_fp_stub, prefixlen) == 0)
7895     return 1;
7896
7897   /* Consume the .pic. prefix of any PIC stub, this function must return
7898      true when the PC is in a PIC stub of a __mips16_ret_{d,s}{f,c} stub
7899      or the call stub path will trigger in handle_inferior_event causing
7900      it to go astray.  */
7901   prefixlen = strlen (mips_str_pic);
7902   if (strncmp (name, mips_str_pic, prefixlen) == 0)
7903     name += prefixlen;
7904
7905   /* If the PC is in __mips16_ret_{d,s}{f,c}, this is a return stub.  */
7906   prefixlen = strlen (mips_str_mips16_ret_stub);
7907   if (strncmp (name, mips_str_mips16_ret_stub, prefixlen) == 0
7908       && mips_is_stub_mode (name + prefixlen)
7909       && name[prefixlen + 2] == '\0')
7910     return 1;
7911
7912   return 0;                     /* Not a stub.  */
7913 }
7914
7915 /* If the current PC is the start of a non-PIC-to-PIC stub, return the
7916    PC of the stub target.  The stub just loads $t9 and jumps to it,
7917    so that $t9 has the correct value at function entry.  */
7918
7919 static CORE_ADDR
7920 mips_skip_pic_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
7921 {
7922   struct gdbarch *gdbarch = get_frame_arch (frame);
7923   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7924   struct bound_minimal_symbol msym;
7925   int i;
7926   gdb_byte stub_code[16];
7927   int32_t stub_words[4];
7928
7929   /* The stub for foo is named ".pic.foo", and is either two
7930      instructions inserted before foo or a three instruction sequence
7931      which jumps to foo.  */
7932   msym = lookup_minimal_symbol_by_pc (pc);
7933   if (msym.minsym == NULL
7934       || BMSYMBOL_VALUE_ADDRESS (msym) != pc
7935       || MSYMBOL_LINKAGE_NAME (msym.minsym) == NULL
7936       || strncmp (MSYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) != 0)
7937     return 0;
7938
7939   /* A two-instruction header.  */
7940   if (MSYMBOL_SIZE (msym.minsym) == 8)
7941     return pc + 8;
7942
7943   /* A three-instruction (plus delay slot) trampoline.  */
7944   if (MSYMBOL_SIZE (msym.minsym) == 16)
7945     {
7946       if (target_read_memory (pc, stub_code, 16) != 0)
7947         return 0;
7948       for (i = 0; i < 4; i++)
7949         stub_words[i] = extract_unsigned_integer (stub_code + i * 4,
7950                                                   4, byte_order);
7951
7952       /* A stub contains these instructions:
7953          lui    t9, %hi(target)
7954          j      target
7955           addiu t9, t9, %lo(target)
7956          nop
7957
7958          This works even for N64, since stubs are only generated with
7959          -msym32.  */
7960       if ((stub_words[0] & 0xffff0000U) == 0x3c190000
7961           && (stub_words[1] & 0xfc000000U) == 0x08000000
7962           && (stub_words[2] & 0xffff0000U) == 0x27390000
7963           && stub_words[3] == 0x00000000)
7964         return ((((stub_words[0] & 0x0000ffff) << 16)
7965                  + (stub_words[2] & 0x0000ffff)) ^ 0x8000) - 0x8000;
7966     }
7967
7968   /* Not a recognized stub.  */
7969   return 0;
7970 }
7971
7972 static CORE_ADDR
7973 mips_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
7974 {
7975   CORE_ADDR requested_pc = pc;
7976   CORE_ADDR target_pc;
7977   CORE_ADDR new_pc;
7978
7979   do
7980     {
7981       target_pc = pc;
7982
7983       new_pc = mips_skip_mips16_trampoline_code (frame, pc);
7984       if (new_pc)
7985         pc = new_pc;
7986
7987       new_pc = find_solib_trampoline_target (frame, pc);
7988       if (new_pc)
7989         pc = new_pc;
7990
7991       new_pc = mips_skip_pic_trampoline_code (frame, pc);
7992       if (new_pc)
7993         pc = new_pc;
7994     }
7995   while (pc != target_pc);
7996
7997   return pc != requested_pc ? pc : 0;
7998 }
7999
8000 /* Convert a dbx stab register number (from `r' declaration) to a GDB
8001    [1 * gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
8002
8003 static int
8004 mips_stab_reg_to_regnum (struct gdbarch *gdbarch, int num)
8005 {
8006   int regnum;
8007   if (num >= 0 && num < 32)
8008     regnum = num;
8009   else if (num >= 38 && num < 70)
8010     regnum = num + mips_regnum (gdbarch)->fp0 - 38;
8011   else if (num == 70)
8012     regnum = mips_regnum (gdbarch)->hi;
8013   else if (num == 71)
8014     regnum = mips_regnum (gdbarch)->lo;
8015   else if (mips_regnum (gdbarch)->dspacc != -1 && num >= 72 && num < 78)
8016     regnum = num + mips_regnum (gdbarch)->dspacc - 72;
8017   else
8018     /* This will hopefully (eventually) provoke a warning.  Should
8019        we be calling complaint() here?  */
8020     return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
8021   return gdbarch_num_regs (gdbarch) + regnum;
8022 }
8023
8024
8025 /* Convert a dwarf, dwarf2, or ecoff register number to a GDB [1 *
8026    gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
8027
8028 static int
8029 mips_dwarf_dwarf2_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int num)
8030 {
8031   int regnum;
8032   if (num >= 0 && num < 32)
8033     regnum = num;
8034   else if (num >= 32 && num < 64)
8035     regnum = num + mips_regnum (gdbarch)->fp0 - 32;
8036   else if (num == 64)
8037     regnum = mips_regnum (gdbarch)->hi;
8038   else if (num == 65)
8039     regnum = mips_regnum (gdbarch)->lo;
8040   else if (mips_regnum (gdbarch)->dspacc != -1 && num >= 66 && num < 72)
8041     regnum = num + mips_regnum (gdbarch)->dspacc - 66;
8042   else
8043     /* This will hopefully (eventually) provoke a warning.  Should we
8044        be calling complaint() here?  */
8045     return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
8046   return gdbarch_num_regs (gdbarch) + regnum;
8047 }
8048
8049 static int
8050 mips_register_sim_regno (struct gdbarch *gdbarch, int regnum)
8051 {
8052   /* Only makes sense to supply raw registers.  */
8053   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
8054   /* FIXME: cagney/2002-05-13: Need to look at the pseudo register to
8055      decide if it is valid.  Should instead define a standard sim/gdb
8056      register numbering scheme.  */
8057   if (gdbarch_register_name (gdbarch,
8058                              gdbarch_num_regs (gdbarch) + regnum) != NULL
8059       && gdbarch_register_name (gdbarch,
8060                                 gdbarch_num_regs (gdbarch)
8061                                 + regnum)[0] != '\0')
8062     return regnum;
8063   else
8064     return LEGACY_SIM_REGNO_IGNORE;
8065 }
8066
8067
8068 /* Convert an integer into an address.  Extracting the value signed
8069    guarantees a correctly sign extended address.  */
8070
8071 static CORE_ADDR
8072 mips_integer_to_address (struct gdbarch *gdbarch,
8073                          struct type *type, const gdb_byte *buf)
8074 {
8075   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
8076   return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
8077 }
8078
8079 /* Dummy virtual frame pointer method.  This is no more or less accurate
8080    than most other architectures; we just need to be explicit about it,
8081    because the pseudo-register gdbarch_sp_regnum will otherwise lead to
8082    an assertion failure.  */
8083
8084 static void
8085 mips_virtual_frame_pointer (struct gdbarch *gdbarch,
8086                             CORE_ADDR pc, int *reg, LONGEST *offset)
8087 {
8088   *reg = MIPS_SP_REGNUM;
8089   *offset = 0;
8090 }
8091
8092 static void
8093 mips_find_abi_section (bfd *abfd, asection *sect, void *obj)
8094 {
8095   enum mips_abi *abip = (enum mips_abi *) obj;
8096   const char *name = bfd_get_section_name (abfd, sect);
8097
8098   if (*abip != MIPS_ABI_UNKNOWN)
8099     return;
8100
8101   if (strncmp (name, ".mdebug.", 8) != 0)
8102     return;
8103
8104   if (strcmp (name, ".mdebug.abi32") == 0)
8105     *abip = MIPS_ABI_O32;
8106   else if (strcmp (name, ".mdebug.abiN32") == 0)
8107     *abip = MIPS_ABI_N32;
8108   else if (strcmp (name, ".mdebug.abi64") == 0)
8109     *abip = MIPS_ABI_N64;
8110   else if (strcmp (name, ".mdebug.abiO64") == 0)
8111     *abip = MIPS_ABI_O64;
8112   else if (strcmp (name, ".mdebug.eabi32") == 0)
8113     *abip = MIPS_ABI_EABI32;
8114   else if (strcmp (name, ".mdebug.eabi64") == 0)
8115     *abip = MIPS_ABI_EABI64;
8116   else
8117     warning (_("unsupported ABI %s."), name + 8);
8118 }
8119
8120 static void
8121 mips_find_long_section (bfd *abfd, asection *sect, void *obj)
8122 {
8123   int *lbp = (int *) obj;
8124   const char *name = bfd_get_section_name (abfd, sect);
8125
8126   if (strncmp (name, ".gcc_compiled_long32", 20) == 0)
8127     *lbp = 32;
8128   else if (strncmp (name, ".gcc_compiled_long64", 20) == 0)
8129     *lbp = 64;
8130   else if (strncmp (name, ".gcc_compiled_long", 18) == 0)
8131     warning (_("unrecognized .gcc_compiled_longXX"));
8132 }
8133
8134 static enum mips_abi
8135 global_mips_abi (void)
8136 {
8137   int i;
8138
8139   for (i = 0; mips_abi_strings[i] != NULL; i++)
8140     if (mips_abi_strings[i] == mips_abi_string)
8141       return (enum mips_abi) i;
8142
8143   internal_error (__FILE__, __LINE__, _("unknown ABI string"));
8144 }
8145
8146 /* Return the default compressed instruction set, either of MIPS16
8147    or microMIPS, selected when none could have been determined from
8148    the ELF header of the binary being executed (or no binary has been
8149    selected.  */
8150
8151 static enum mips_isa
8152 global_mips_compression (void)
8153 {
8154   int i;
8155
8156   for (i = 0; mips_compression_strings[i] != NULL; i++)
8157     if (mips_compression_strings[i] == mips_compression_string)
8158       return (enum mips_isa) i;
8159
8160   internal_error (__FILE__, __LINE__, _("unknown compressed ISA string"));
8161 }
8162
8163 static void
8164 mips_register_g_packet_guesses (struct gdbarch *gdbarch)
8165 {
8166   /* If the size matches the set of 32-bit or 64-bit integer registers,
8167      assume that's what we've got.  */
8168   register_remote_g_packet_guess (gdbarch, 38 * 4, mips_tdesc_gp32);
8169   register_remote_g_packet_guess (gdbarch, 38 * 8, mips_tdesc_gp64);
8170
8171   /* If the size matches the full set of registers GDB traditionally
8172      knows about, including floating point, for either 32-bit or
8173      64-bit, assume that's what we've got.  */
8174   register_remote_g_packet_guess (gdbarch, 90 * 4, mips_tdesc_gp32);
8175   register_remote_g_packet_guess (gdbarch, 90 * 8, mips_tdesc_gp64);
8176
8177   /* Otherwise we don't have a useful guess.  */
8178 }
8179
8180 static struct value *
8181 value_of_mips_user_reg (struct frame_info *frame, const void *baton)
8182 {
8183   const int *reg_p = baton;
8184   return value_of_register (*reg_p, frame);
8185 }
8186
8187 static struct gdbarch *
8188 mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
8189 {
8190   struct gdbarch *gdbarch;
8191   struct gdbarch_tdep *tdep;
8192   int elf_flags;
8193   enum mips_abi mips_abi, found_abi, wanted_abi;
8194   int i, num_regs;
8195   enum mips_fpu_type fpu_type;
8196   struct tdesc_arch_data *tdesc_data = NULL;
8197   int elf_fpu_type = Val_GNU_MIPS_ABI_FP_ANY;
8198   const char **reg_names;
8199   struct mips_regnum mips_regnum, *regnum;
8200   enum mips_isa mips_isa;
8201   int dspacc;
8202   int dspctl;
8203
8204   /* Fill in the OS dependent register numbers and names.  */
8205   if (info.osabi == GDB_OSABI_IRIX)
8206     {
8207       mips_regnum.fp0 = 32;
8208       mips_regnum.pc = 64;
8209       mips_regnum.cause = 65;
8210       mips_regnum.badvaddr = 66;
8211       mips_regnum.hi = 67;
8212       mips_regnum.lo = 68;
8213       mips_regnum.fp_control_status = 69;
8214       mips_regnum.fp_implementation_revision = 70;
8215       mips_regnum.dspacc = dspacc = -1;
8216       mips_regnum.dspctl = dspctl = -1;
8217       num_regs = 71;
8218       reg_names = mips_irix_reg_names;
8219     }
8220   else if (info.osabi == GDB_OSABI_LINUX)
8221     {
8222       mips_regnum.fp0 = 38;
8223       mips_regnum.pc = 37;
8224       mips_regnum.cause = 36;
8225       mips_regnum.badvaddr = 35;
8226       mips_regnum.hi = 34;
8227       mips_regnum.lo = 33;
8228       mips_regnum.fp_control_status = 70;
8229       mips_regnum.fp_implementation_revision = 71;
8230       mips_regnum.dspacc = -1;
8231       mips_regnum.dspctl = -1;
8232       dspacc = 72;
8233       dspctl = 78;
8234       num_regs = 79;
8235       reg_names = mips_linux_reg_names;
8236     }
8237   else
8238     {
8239       mips_regnum.lo = MIPS_EMBED_LO_REGNUM;
8240       mips_regnum.hi = MIPS_EMBED_HI_REGNUM;
8241       mips_regnum.badvaddr = MIPS_EMBED_BADVADDR_REGNUM;
8242       mips_regnum.cause = MIPS_EMBED_CAUSE_REGNUM;
8243       mips_regnum.pc = MIPS_EMBED_PC_REGNUM;
8244       mips_regnum.fp0 = MIPS_EMBED_FP0_REGNUM;
8245       mips_regnum.fp_control_status = 70;
8246       mips_regnum.fp_implementation_revision = 71;
8247       mips_regnum.dspacc = dspacc = -1;
8248       mips_regnum.dspctl = dspctl = -1;
8249       num_regs = MIPS_LAST_EMBED_REGNUM + 1;
8250       if (info.bfd_arch_info != NULL
8251           && info.bfd_arch_info->mach == bfd_mach_mips3900)
8252         reg_names = mips_tx39_reg_names;
8253       else
8254         reg_names = mips_generic_reg_names;
8255     }
8256
8257   /* Check any target description for validity.  */
8258   if (tdesc_has_registers (info.target_desc))
8259     {
8260       static const char *const mips_gprs[] = {
8261         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
8262         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
8263         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
8264         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
8265       };
8266       static const char *const mips_fprs[] = {
8267         "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
8268         "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
8269         "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
8270         "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
8271       };
8272
8273       const struct tdesc_feature *feature;
8274       int valid_p;
8275
8276       feature = tdesc_find_feature (info.target_desc,
8277                                     "org.gnu.gdb.mips.cpu");
8278       if (feature == NULL)
8279         return NULL;
8280
8281       tdesc_data = tdesc_data_alloc ();
8282
8283       valid_p = 1;
8284       for (i = MIPS_ZERO_REGNUM; i <= MIPS_RA_REGNUM; i++)
8285         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
8286                                             mips_gprs[i]);
8287
8288
8289       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8290                                           mips_regnum.lo, "lo");
8291       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8292                                           mips_regnum.hi, "hi");
8293       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8294                                           mips_regnum.pc, "pc");
8295
8296       if (!valid_p)
8297         {
8298           tdesc_data_cleanup (tdesc_data);
8299           return NULL;
8300         }
8301
8302       feature = tdesc_find_feature (info.target_desc,
8303                                     "org.gnu.gdb.mips.cp0");
8304       if (feature == NULL)
8305         {
8306           tdesc_data_cleanup (tdesc_data);
8307           return NULL;
8308         }
8309
8310       valid_p = 1;
8311       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8312                                           mips_regnum.badvaddr, "badvaddr");
8313       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8314                                           MIPS_PS_REGNUM, "status");
8315       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8316                                           mips_regnum.cause, "cause");
8317
8318       if (!valid_p)
8319         {
8320           tdesc_data_cleanup (tdesc_data);
8321           return NULL;
8322         }
8323
8324       /* FIXME drow/2007-05-17: The FPU should be optional.  The MIPS
8325          backend is not prepared for that, though.  */
8326       feature = tdesc_find_feature (info.target_desc,
8327                                     "org.gnu.gdb.mips.fpu");
8328       if (feature == NULL)
8329         {
8330           tdesc_data_cleanup (tdesc_data);
8331           return NULL;
8332         }
8333
8334       valid_p = 1;
8335       for (i = 0; i < 32; i++)
8336         valid_p &= tdesc_numbered_register (feature, tdesc_data,
8337                                             i + mips_regnum.fp0, mips_fprs[i]);
8338
8339       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8340                                           mips_regnum.fp_control_status,
8341                                           "fcsr");
8342       valid_p
8343         &= tdesc_numbered_register (feature, tdesc_data,
8344                                     mips_regnum.fp_implementation_revision,
8345                                     "fir");
8346
8347       if (!valid_p)
8348         {
8349           tdesc_data_cleanup (tdesc_data);
8350           return NULL;
8351         }
8352
8353       if (dspacc >= 0)
8354         {
8355           feature = tdesc_find_feature (info.target_desc,
8356                                         "org.gnu.gdb.mips.dsp");
8357           /* The DSP registers are optional; it's OK if they are absent.  */
8358           if (feature != NULL)
8359             {
8360               i = 0;
8361               valid_p = 1;
8362               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8363                                                   dspacc + i++, "hi1");
8364               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8365                                                   dspacc + i++, "lo1");
8366               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8367                                                   dspacc + i++, "hi2");
8368               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8369                                                   dspacc + i++, "lo2");
8370               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8371                                                   dspacc + i++, "hi3");
8372               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8373                                                   dspacc + i++, "lo3");
8374
8375               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8376                                                   dspctl, "dspctl");
8377
8378               if (!valid_p)
8379                 {
8380                   tdesc_data_cleanup (tdesc_data);
8381                   return NULL;
8382                 }
8383
8384               mips_regnum.dspacc = dspacc;
8385               mips_regnum.dspctl = dspctl;
8386             }
8387         }
8388
8389       /* It would be nice to detect an attempt to use a 64-bit ABI
8390          when only 32-bit registers are provided.  */
8391       reg_names = NULL;
8392     }
8393
8394   /* First of all, extract the elf_flags, if available.  */
8395   if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
8396     elf_flags = elf_elfheader (info.abfd)->e_flags;
8397   else if (arches != NULL)
8398     elf_flags = gdbarch_tdep (arches->gdbarch)->elf_flags;
8399   else
8400     elf_flags = 0;
8401   if (gdbarch_debug)
8402     fprintf_unfiltered (gdb_stdlog,
8403                         "mips_gdbarch_init: elf_flags = 0x%08x\n", elf_flags);
8404
8405   /* Check ELF_FLAGS to see if it specifies the ABI being used.  */
8406   switch ((elf_flags & EF_MIPS_ABI))
8407     {
8408     case E_MIPS_ABI_O32:
8409       found_abi = MIPS_ABI_O32;
8410       break;
8411     case E_MIPS_ABI_O64:
8412       found_abi = MIPS_ABI_O64;
8413       break;
8414     case E_MIPS_ABI_EABI32:
8415       found_abi = MIPS_ABI_EABI32;
8416       break;
8417     case E_MIPS_ABI_EABI64:
8418       found_abi = MIPS_ABI_EABI64;
8419       break;
8420     default:
8421       if ((elf_flags & EF_MIPS_ABI2))
8422         found_abi = MIPS_ABI_N32;
8423       else
8424         found_abi = MIPS_ABI_UNKNOWN;
8425       break;
8426     }
8427
8428   /* GCC creates a pseudo-section whose name describes the ABI.  */
8429   if (found_abi == MIPS_ABI_UNKNOWN && info.abfd != NULL)
8430     bfd_map_over_sections (info.abfd, mips_find_abi_section, &found_abi);
8431
8432   /* If we have no useful BFD information, use the ABI from the last
8433      MIPS architecture (if there is one).  */
8434   if (found_abi == MIPS_ABI_UNKNOWN && info.abfd == NULL && arches != NULL)
8435     found_abi = gdbarch_tdep (arches->gdbarch)->found_abi;
8436
8437   /* Try the architecture for any hint of the correct ABI.  */
8438   if (found_abi == MIPS_ABI_UNKNOWN
8439       && info.bfd_arch_info != NULL
8440       && info.bfd_arch_info->arch == bfd_arch_mips)
8441     {
8442       switch (info.bfd_arch_info->mach)
8443         {
8444         case bfd_mach_mips3900:
8445           found_abi = MIPS_ABI_EABI32;
8446           break;
8447         case bfd_mach_mips4100:
8448         case bfd_mach_mips5000:
8449           found_abi = MIPS_ABI_EABI64;
8450           break;
8451         case bfd_mach_mips8000:
8452         case bfd_mach_mips10000:
8453           /* On Irix, ELF64 executables use the N64 ABI.  The
8454              pseudo-sections which describe the ABI aren't present
8455              on IRIX.  (Even for executables created by gcc.)  */
8456           if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
8457               && elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
8458             found_abi = MIPS_ABI_N64;
8459           else
8460             found_abi = MIPS_ABI_N32;
8461           break;
8462         }
8463     }
8464
8465   /* Default 64-bit objects to N64 instead of O32.  */
8466   if (found_abi == MIPS_ABI_UNKNOWN
8467       && info.abfd != NULL
8468       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
8469       && elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
8470     found_abi = MIPS_ABI_N64;
8471
8472   if (gdbarch_debug)
8473     fprintf_unfiltered (gdb_stdlog, "mips_gdbarch_init: found_abi = %d\n",
8474                         found_abi);
8475
8476   /* What has the user specified from the command line?  */
8477   wanted_abi = global_mips_abi ();
8478   if (gdbarch_debug)
8479     fprintf_unfiltered (gdb_stdlog, "mips_gdbarch_init: wanted_abi = %d\n",
8480                         wanted_abi);
8481
8482   /* Now that we have found what the ABI for this binary would be,
8483      check whether the user is overriding it.  */
8484   if (wanted_abi != MIPS_ABI_UNKNOWN)
8485     mips_abi = wanted_abi;
8486   else if (found_abi != MIPS_ABI_UNKNOWN)
8487     mips_abi = found_abi;
8488   else
8489     mips_abi = MIPS_ABI_O32;
8490   if (gdbarch_debug)
8491     fprintf_unfiltered (gdb_stdlog, "mips_gdbarch_init: mips_abi = %d\n",
8492                         mips_abi);
8493
8494   /* Determine the default compressed ISA.  */
8495   if ((elf_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0
8496       && (elf_flags & EF_MIPS_ARCH_ASE_M16) == 0)
8497     mips_isa = ISA_MICROMIPS;
8498   else if ((elf_flags & EF_MIPS_ARCH_ASE_M16) != 0
8499            && (elf_flags & EF_MIPS_ARCH_ASE_MICROMIPS) == 0)
8500     mips_isa = ISA_MIPS16;
8501   else
8502     mips_isa = global_mips_compression ();
8503   mips_compression_string = mips_compression_strings[mips_isa];
8504
8505   /* Also used when doing an architecture lookup.  */
8506   if (gdbarch_debug)
8507     fprintf_unfiltered (gdb_stdlog,
8508                         "mips_gdbarch_init: "
8509                         "mips64_transfers_32bit_regs_p = %d\n",
8510                         mips64_transfers_32bit_regs_p);
8511
8512   /* Determine the MIPS FPU type.  */
8513 #ifdef HAVE_ELF
8514   if (info.abfd
8515       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
8516     elf_fpu_type = bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
8517                                              Tag_GNU_MIPS_ABI_FP);
8518 #endif /* HAVE_ELF */
8519
8520   if (!mips_fpu_type_auto)
8521     fpu_type = mips_fpu_type;
8522   else if (elf_fpu_type != Val_GNU_MIPS_ABI_FP_ANY)
8523     {
8524       switch (elf_fpu_type)
8525         {
8526         case Val_GNU_MIPS_ABI_FP_DOUBLE:
8527           fpu_type = MIPS_FPU_DOUBLE;
8528           break;
8529         case Val_GNU_MIPS_ABI_FP_SINGLE:
8530           fpu_type = MIPS_FPU_SINGLE;
8531           break;
8532         case Val_GNU_MIPS_ABI_FP_SOFT:
8533         default:
8534           /* Soft float or unknown.  */
8535           fpu_type = MIPS_FPU_NONE;
8536           break;
8537         }
8538     }
8539   else if (info.bfd_arch_info != NULL
8540            && info.bfd_arch_info->arch == bfd_arch_mips)
8541     switch (info.bfd_arch_info->mach)
8542       {
8543       case bfd_mach_mips3900:
8544       case bfd_mach_mips4100:
8545       case bfd_mach_mips4111:
8546       case bfd_mach_mips4120:
8547         fpu_type = MIPS_FPU_NONE;
8548         break;
8549       case bfd_mach_mips4650:
8550         fpu_type = MIPS_FPU_SINGLE;
8551         break;
8552       default:
8553         fpu_type = MIPS_FPU_DOUBLE;
8554         break;
8555       }
8556   else if (arches != NULL)
8557     fpu_type = gdbarch_tdep (arches->gdbarch)->mips_fpu_type;
8558   else
8559     fpu_type = MIPS_FPU_DOUBLE;
8560   if (gdbarch_debug)
8561     fprintf_unfiltered (gdb_stdlog,
8562                         "mips_gdbarch_init: fpu_type = %d\n", fpu_type);
8563
8564   /* Check for blatant incompatibilities.  */
8565
8566   /* If we have only 32-bit registers, then we can't debug a 64-bit
8567      ABI.  */
8568   if (info.target_desc
8569       && tdesc_property (info.target_desc, PROPERTY_GP32) != NULL
8570       && mips_abi != MIPS_ABI_EABI32
8571       && mips_abi != MIPS_ABI_O32)
8572     {
8573       if (tdesc_data != NULL)
8574         tdesc_data_cleanup (tdesc_data);
8575       return NULL;
8576     }
8577
8578   /* Try to find a pre-existing architecture.  */
8579   for (arches = gdbarch_list_lookup_by_info (arches, &info);
8580        arches != NULL;
8581        arches = gdbarch_list_lookup_by_info (arches->next, &info))
8582     {
8583       /* MIPS needs to be pedantic about which ABI and the compressed
8584          ISA variation the object is using.  */
8585       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
8586         continue;
8587       if (gdbarch_tdep (arches->gdbarch)->mips_abi != mips_abi)
8588         continue;
8589       if (gdbarch_tdep (arches->gdbarch)->mips_isa != mips_isa)
8590         continue;
8591       /* Need to be pedantic about which register virtual size is
8592          used.  */
8593       if (gdbarch_tdep (arches->gdbarch)->mips64_transfers_32bit_regs_p
8594           != mips64_transfers_32bit_regs_p)
8595         continue;
8596       /* Be pedantic about which FPU is selected.  */
8597       if (gdbarch_tdep (arches->gdbarch)->mips_fpu_type != fpu_type)
8598         continue;
8599
8600       if (tdesc_data != NULL)
8601         tdesc_data_cleanup (tdesc_data);
8602       return arches->gdbarch;
8603     }
8604
8605   /* Need a new architecture.  Fill in a target specific vector.  */
8606   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
8607   gdbarch = gdbarch_alloc (&info, tdep);
8608   tdep->elf_flags = elf_flags;
8609   tdep->mips64_transfers_32bit_regs_p = mips64_transfers_32bit_regs_p;
8610   tdep->found_abi = found_abi;
8611   tdep->mips_abi = mips_abi;
8612   tdep->mips_isa = mips_isa;
8613   tdep->mips_fpu_type = fpu_type;
8614   tdep->register_size_valid_p = 0;
8615   tdep->register_size = 0;
8616
8617   if (info.target_desc)
8618     {
8619       /* Some useful properties can be inferred from the target.  */
8620       if (tdesc_property (info.target_desc, PROPERTY_GP32) != NULL)
8621         {
8622           tdep->register_size_valid_p = 1;
8623           tdep->register_size = 4;
8624         }
8625       else if (tdesc_property (info.target_desc, PROPERTY_GP64) != NULL)
8626         {
8627           tdep->register_size_valid_p = 1;
8628           tdep->register_size = 8;
8629         }
8630     }
8631
8632   /* Initially set everything according to the default ABI/ISA.  */
8633   set_gdbarch_short_bit (gdbarch, 16);
8634   set_gdbarch_int_bit (gdbarch, 32);
8635   set_gdbarch_float_bit (gdbarch, 32);
8636   set_gdbarch_double_bit (gdbarch, 64);
8637   set_gdbarch_long_double_bit (gdbarch, 64);
8638   set_gdbarch_register_reggroup_p (gdbarch, mips_register_reggroup_p);
8639   set_gdbarch_pseudo_register_read (gdbarch, mips_pseudo_register_read);
8640   set_gdbarch_pseudo_register_write (gdbarch, mips_pseudo_register_write);
8641
8642   set_gdbarch_ax_pseudo_register_collect (gdbarch,
8643                                           mips_ax_pseudo_register_collect);
8644   set_gdbarch_ax_pseudo_register_push_stack
8645       (gdbarch, mips_ax_pseudo_register_push_stack);
8646
8647   set_gdbarch_elf_make_msymbol_special (gdbarch,
8648                                         mips_elf_make_msymbol_special);
8649   set_gdbarch_make_symbol_special (gdbarch, mips_make_symbol_special);
8650   set_gdbarch_adjust_dwarf2_addr (gdbarch, mips_adjust_dwarf2_addr);
8651   set_gdbarch_adjust_dwarf2_line (gdbarch, mips_adjust_dwarf2_line);
8652
8653   regnum = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct mips_regnum);
8654   *regnum = mips_regnum;
8655   set_gdbarch_fp0_regnum (gdbarch, regnum->fp0);
8656   set_gdbarch_num_regs (gdbarch, num_regs);
8657   set_gdbarch_num_pseudo_regs (gdbarch, num_regs);
8658   set_gdbarch_register_name (gdbarch, mips_register_name);
8659   set_gdbarch_virtual_frame_pointer (gdbarch, mips_virtual_frame_pointer);
8660   tdep->mips_processor_reg_names = reg_names;
8661   tdep->regnum = regnum;
8662
8663   switch (mips_abi)
8664     {
8665     case MIPS_ABI_O32:
8666       set_gdbarch_push_dummy_call (gdbarch, mips_o32_push_dummy_call);
8667       set_gdbarch_return_value (gdbarch, mips_o32_return_value);
8668       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 4 - 1;
8669       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 4 - 1;
8670       tdep->default_mask_address_p = 0;
8671       set_gdbarch_long_bit (gdbarch, 32);
8672       set_gdbarch_ptr_bit (gdbarch, 32);
8673       set_gdbarch_long_long_bit (gdbarch, 64);
8674       break;
8675     case MIPS_ABI_O64:
8676       set_gdbarch_push_dummy_call (gdbarch, mips_o64_push_dummy_call);
8677       set_gdbarch_return_value (gdbarch, mips_o64_return_value);
8678       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 4 - 1;
8679       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 4 - 1;
8680       tdep->default_mask_address_p = 0;
8681       set_gdbarch_long_bit (gdbarch, 32);
8682       set_gdbarch_ptr_bit (gdbarch, 32);
8683       set_gdbarch_long_long_bit (gdbarch, 64);
8684       break;
8685     case MIPS_ABI_EABI32:
8686       set_gdbarch_push_dummy_call (gdbarch, mips_eabi_push_dummy_call);
8687       set_gdbarch_return_value (gdbarch, mips_eabi_return_value);
8688       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8689       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8690       tdep->default_mask_address_p = 0;
8691       set_gdbarch_long_bit (gdbarch, 32);
8692       set_gdbarch_ptr_bit (gdbarch, 32);
8693       set_gdbarch_long_long_bit (gdbarch, 64);
8694       break;
8695     case MIPS_ABI_EABI64:
8696       set_gdbarch_push_dummy_call (gdbarch, mips_eabi_push_dummy_call);
8697       set_gdbarch_return_value (gdbarch, mips_eabi_return_value);
8698       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8699       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8700       tdep->default_mask_address_p = 0;
8701       set_gdbarch_long_bit (gdbarch, 64);
8702       set_gdbarch_ptr_bit (gdbarch, 64);
8703       set_gdbarch_long_long_bit (gdbarch, 64);
8704       break;
8705     case MIPS_ABI_N32:
8706       set_gdbarch_push_dummy_call (gdbarch, mips_n32n64_push_dummy_call);
8707       set_gdbarch_return_value (gdbarch, mips_n32n64_return_value);
8708       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8709       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8710       tdep->default_mask_address_p = 0;
8711       set_gdbarch_long_bit (gdbarch, 32);
8712       set_gdbarch_ptr_bit (gdbarch, 32);
8713       set_gdbarch_long_long_bit (gdbarch, 64);
8714       set_gdbarch_long_double_bit (gdbarch, 128);
8715       set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
8716       break;
8717     case MIPS_ABI_N64:
8718       set_gdbarch_push_dummy_call (gdbarch, mips_n32n64_push_dummy_call);
8719       set_gdbarch_return_value (gdbarch, mips_n32n64_return_value);
8720       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8721       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8722       tdep->default_mask_address_p = 0;
8723       set_gdbarch_long_bit (gdbarch, 64);
8724       set_gdbarch_ptr_bit (gdbarch, 64);
8725       set_gdbarch_long_long_bit (gdbarch, 64);
8726       set_gdbarch_long_double_bit (gdbarch, 128);
8727       set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
8728       break;
8729     default:
8730       internal_error (__FILE__, __LINE__, _("unknown ABI in switch"));
8731     }
8732
8733   /* GCC creates a pseudo-section whose name specifies the size of
8734      longs, since -mlong32 or -mlong64 may be used independent of
8735      other options.  How those options affect pointer sizes is ABI and
8736      architecture dependent, so use them to override the default sizes
8737      set by the ABI.  This table shows the relationship between ABI,
8738      -mlongXX, and size of pointers:
8739
8740      ABI                -mlongXX        ptr bits
8741      ---                --------        --------
8742      o32                32              32
8743      o32                64              32
8744      n32                32              32
8745      n32                64              64
8746      o64                32              32
8747      o64                64              64
8748      n64                32              32
8749      n64                64              64
8750      eabi32             32              32
8751      eabi32             64              32
8752      eabi64             32              32
8753      eabi64             64              64
8754
8755     Note that for o32 and eabi32, pointers are always 32 bits
8756     regardless of any -mlongXX option.  For all others, pointers and
8757     longs are the same, as set by -mlongXX or set by defaults.  */
8758
8759   if (info.abfd != NULL)
8760     {
8761       int long_bit = 0;
8762
8763       bfd_map_over_sections (info.abfd, mips_find_long_section, &long_bit);
8764       if (long_bit)
8765         {
8766           set_gdbarch_long_bit (gdbarch, long_bit);
8767           switch (mips_abi)
8768             {
8769             case MIPS_ABI_O32:
8770             case MIPS_ABI_EABI32:
8771               break;
8772             case MIPS_ABI_N32:
8773             case MIPS_ABI_O64:
8774             case MIPS_ABI_N64:
8775             case MIPS_ABI_EABI64:
8776               set_gdbarch_ptr_bit (gdbarch, long_bit);
8777               break;
8778             default:
8779               internal_error (__FILE__, __LINE__, _("unknown ABI in switch"));
8780             }
8781         }
8782     }
8783
8784   /* FIXME: jlarmour/2000-04-07: There *is* a flag EF_MIPS_32BIT_MODE
8785      that could indicate -gp32 BUT gas/config/tc-mips.c contains the
8786      comment:
8787
8788      ``We deliberately don't allow "-gp32" to set the MIPS_32BITMODE
8789      flag in object files because to do so would make it impossible to
8790      link with libraries compiled without "-gp32".  This is
8791      unnecessarily restrictive.
8792
8793      We could solve this problem by adding "-gp32" multilibs to gcc,
8794      but to set this flag before gcc is built with such multilibs will
8795      break too many systems.''
8796
8797      But even more unhelpfully, the default linker output target for
8798      mips64-elf is elf32-bigmips, and has EF_MIPS_32BIT_MODE set, even
8799      for 64-bit programs - you need to change the ABI to change this,
8800      and not all gcc targets support that currently.  Therefore using
8801      this flag to detect 32-bit mode would do the wrong thing given
8802      the current gcc - it would make GDB treat these 64-bit programs
8803      as 32-bit programs by default.  */
8804
8805   set_gdbarch_read_pc (gdbarch, mips_read_pc);
8806   set_gdbarch_write_pc (gdbarch, mips_write_pc);
8807
8808   /* Add/remove bits from an address.  The MIPS needs be careful to
8809      ensure that all 32 bit addresses are sign extended to 64 bits.  */
8810   set_gdbarch_addr_bits_remove (gdbarch, mips_addr_bits_remove);
8811
8812   /* Unwind the frame.  */
8813   set_gdbarch_unwind_pc (gdbarch, mips_unwind_pc);
8814   set_gdbarch_unwind_sp (gdbarch, mips_unwind_sp);
8815   set_gdbarch_dummy_id (gdbarch, mips_dummy_id);
8816
8817   /* Map debug register numbers onto internal register numbers.  */
8818   set_gdbarch_stab_reg_to_regnum (gdbarch, mips_stab_reg_to_regnum);
8819   set_gdbarch_ecoff_reg_to_regnum (gdbarch,
8820                                    mips_dwarf_dwarf2_ecoff_reg_to_regnum);
8821   set_gdbarch_dwarf2_reg_to_regnum (gdbarch,
8822                                     mips_dwarf_dwarf2_ecoff_reg_to_regnum);
8823   set_gdbarch_register_sim_regno (gdbarch, mips_register_sim_regno);
8824
8825   /* MIPS version of CALL_DUMMY.  */
8826
8827   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
8828   set_gdbarch_push_dummy_code (gdbarch, mips_push_dummy_code);
8829   set_gdbarch_frame_align (gdbarch, mips_frame_align);
8830
8831   set_gdbarch_print_float_info (gdbarch, mips_print_float_info);
8832
8833   set_gdbarch_convert_register_p (gdbarch, mips_convert_register_p);
8834   set_gdbarch_register_to_value (gdbarch, mips_register_to_value);
8835   set_gdbarch_value_to_register (gdbarch, mips_value_to_register);
8836
8837   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
8838   set_gdbarch_breakpoint_from_pc (gdbarch, mips_breakpoint_from_pc);
8839   set_gdbarch_remote_breakpoint_from_pc (gdbarch,
8840                                          mips_remote_breakpoint_from_pc);
8841   set_gdbarch_adjust_breakpoint_address (gdbarch,
8842                                          mips_adjust_breakpoint_address);
8843
8844   set_gdbarch_skip_prologue (gdbarch, mips_skip_prologue);
8845
8846   set_gdbarch_in_function_epilogue_p (gdbarch, mips_in_function_epilogue_p);
8847
8848   set_gdbarch_pointer_to_address (gdbarch, signed_pointer_to_address);
8849   set_gdbarch_address_to_pointer (gdbarch, address_to_signed_pointer);
8850   set_gdbarch_integer_to_address (gdbarch, mips_integer_to_address);
8851
8852   set_gdbarch_register_type (gdbarch, mips_register_type);
8853
8854   set_gdbarch_print_registers_info (gdbarch, mips_print_registers_info);
8855
8856   if (mips_abi == MIPS_ABI_N32)
8857     set_gdbarch_print_insn (gdbarch, gdb_print_insn_mips_n32);
8858   else if (mips_abi == MIPS_ABI_N64)
8859     set_gdbarch_print_insn (gdbarch, gdb_print_insn_mips_n64);
8860   else
8861     set_gdbarch_print_insn (gdbarch, gdb_print_insn_mips);
8862
8863   /* FIXME: cagney/2003-08-29: The macros target_have_steppable_watchpoint,
8864      HAVE_NONSTEPPABLE_WATCHPOINT, and target_have_continuable_watchpoint
8865      need to all be folded into the target vector.  Since they are
8866      being used as guards for target_stopped_by_watchpoint, why not have
8867      target_stopped_by_watchpoint return the type of watchpoint that the code
8868      is sitting on?  */
8869   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
8870
8871   set_gdbarch_skip_trampoline_code (gdbarch, mips_skip_trampoline_code);
8872
8873   /* NOTE drow/2012-04-25: We overload the core solib trampoline code
8874      to support MIPS16.  This is a bad thing.  Make sure not to do it
8875      if we have an OS ABI that actually supports shared libraries, since
8876      shared library support is more important.  If we have an OS someday
8877      that supports both shared libraries and MIPS16, we'll have to find
8878      a better place for these.
8879      macro/2012-04-25: But that applies to return trampolines only and
8880      currently no MIPS OS ABI uses shared libraries that have them.  */
8881   set_gdbarch_in_solib_return_trampoline (gdbarch, mips_in_return_stub);
8882
8883   set_gdbarch_single_step_through_delay (gdbarch,
8884                                          mips_single_step_through_delay);
8885
8886   /* Virtual tables.  */
8887   set_gdbarch_vbit_in_delta (gdbarch, 1);
8888
8889   mips_register_g_packet_guesses (gdbarch);
8890
8891   /* Hook in OS ABI-specific overrides, if they have been registered.  */
8892   info.tdep_info = (void *) tdesc_data;
8893   gdbarch_init_osabi (info, gdbarch);
8894
8895   /* The hook may have adjusted num_regs, fetch the final value and
8896      set pc_regnum and sp_regnum now that it has been fixed.  */
8897   num_regs = gdbarch_num_regs (gdbarch);
8898   set_gdbarch_pc_regnum (gdbarch, regnum->pc + num_regs);
8899   set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs);
8900
8901   /* Unwind the frame.  */
8902   dwarf2_append_unwinders (gdbarch);
8903   frame_unwind_append_unwinder (gdbarch, &mips_stub_frame_unwind);
8904   frame_unwind_append_unwinder (gdbarch, &mips_insn16_frame_unwind);
8905   frame_unwind_append_unwinder (gdbarch, &mips_micro_frame_unwind);
8906   frame_unwind_append_unwinder (gdbarch, &mips_insn32_frame_unwind);
8907   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
8908   frame_base_append_sniffer (gdbarch, mips_stub_frame_base_sniffer);
8909   frame_base_append_sniffer (gdbarch, mips_insn16_frame_base_sniffer);
8910   frame_base_append_sniffer (gdbarch, mips_micro_frame_base_sniffer);
8911   frame_base_append_sniffer (gdbarch, mips_insn32_frame_base_sniffer);
8912
8913   if (tdesc_data)
8914     {
8915       set_tdesc_pseudo_register_type (gdbarch, mips_pseudo_register_type);
8916       tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
8917
8918       /* Override the normal target description methods to handle our
8919          dual real and pseudo registers.  */
8920       set_gdbarch_register_name (gdbarch, mips_register_name);
8921       set_gdbarch_register_reggroup_p (gdbarch,
8922                                        mips_tdesc_register_reggroup_p);
8923
8924       num_regs = gdbarch_num_regs (gdbarch);
8925       set_gdbarch_num_pseudo_regs (gdbarch, num_regs);
8926       set_gdbarch_pc_regnum (gdbarch, tdep->regnum->pc + num_regs);
8927       set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs);
8928     }
8929
8930   /* Add ABI-specific aliases for the registers.  */
8931   if (mips_abi == MIPS_ABI_N32 || mips_abi == MIPS_ABI_N64)
8932     for (i = 0; i < ARRAY_SIZE (mips_n32_n64_aliases); i++)
8933       user_reg_add (gdbarch, mips_n32_n64_aliases[i].name,
8934                     value_of_mips_user_reg, &mips_n32_n64_aliases[i].regnum);
8935   else
8936     for (i = 0; i < ARRAY_SIZE (mips_o32_aliases); i++)
8937       user_reg_add (gdbarch, mips_o32_aliases[i].name,
8938                     value_of_mips_user_reg, &mips_o32_aliases[i].regnum);
8939
8940   /* Add some other standard aliases.  */
8941   for (i = 0; i < ARRAY_SIZE (mips_register_aliases); i++)
8942     user_reg_add (gdbarch, mips_register_aliases[i].name,
8943                   value_of_mips_user_reg, &mips_register_aliases[i].regnum);
8944
8945   for (i = 0; i < ARRAY_SIZE (mips_numeric_register_aliases); i++)
8946     user_reg_add (gdbarch, mips_numeric_register_aliases[i].name,
8947                   value_of_mips_user_reg,
8948                   &mips_numeric_register_aliases[i].regnum);
8949
8950   return gdbarch;
8951 }
8952
8953 static void
8954 mips_abi_update (char *ignore_args, int from_tty, struct cmd_list_element *c)
8955 {
8956   struct gdbarch_info info;
8957
8958   /* Force the architecture to update, and (if it's a MIPS architecture)
8959      mips_gdbarch_init will take care of the rest.  */
8960   gdbarch_info_init (&info);
8961   gdbarch_update_p (info);
8962 }
8963
8964 /* Print out which MIPS ABI is in use.  */
8965
8966 static void
8967 show_mips_abi (struct ui_file *file,
8968                int from_tty,
8969                struct cmd_list_element *ignored_cmd,
8970                const char *ignored_value)
8971 {
8972   if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
8973     fprintf_filtered
8974       (file,
8975        "The MIPS ABI is unknown because the current architecture "
8976        "is not MIPS.\n");
8977   else
8978     {
8979       enum mips_abi global_abi = global_mips_abi ();
8980       enum mips_abi actual_abi = mips_abi (target_gdbarch ());
8981       const char *actual_abi_str = mips_abi_strings[actual_abi];
8982
8983       if (global_abi == MIPS_ABI_UNKNOWN)
8984         fprintf_filtered
8985           (file,
8986            "The MIPS ABI is set automatically (currently \"%s\").\n",
8987            actual_abi_str);
8988       else if (global_abi == actual_abi)
8989         fprintf_filtered
8990           (file,
8991            "The MIPS ABI is assumed to be \"%s\" (due to user setting).\n",
8992            actual_abi_str);
8993       else
8994         {
8995           /* Probably shouldn't happen...  */
8996           fprintf_filtered (file,
8997                             "The (auto detected) MIPS ABI \"%s\" is in use "
8998                             "even though the user setting was \"%s\".\n",
8999              actual_abi_str, mips_abi_strings[global_abi]);
9000         }
9001     }
9002 }
9003
9004 /* Print out which MIPS compressed ISA encoding is used.  */
9005
9006 static void
9007 show_mips_compression (struct ui_file *file, int from_tty,
9008                        struct cmd_list_element *c, const char *value)
9009 {
9010   fprintf_filtered (file, _("The compressed ISA encoding used is %s.\n"),
9011                     value);
9012 }
9013
9014 static void
9015 mips_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
9016 {
9017   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
9018   if (tdep != NULL)
9019     {
9020       int ef_mips_arch;
9021       int ef_mips_32bitmode;
9022       /* Determine the ISA.  */
9023       switch (tdep->elf_flags & EF_MIPS_ARCH)
9024         {
9025         case E_MIPS_ARCH_1:
9026           ef_mips_arch = 1;
9027           break;
9028         case E_MIPS_ARCH_2:
9029           ef_mips_arch = 2;
9030           break;
9031         case E_MIPS_ARCH_3:
9032           ef_mips_arch = 3;
9033           break;
9034         case E_MIPS_ARCH_4:
9035           ef_mips_arch = 4;
9036           break;
9037         default:
9038           ef_mips_arch = 0;
9039           break;
9040         }
9041       /* Determine the size of a pointer.  */
9042       ef_mips_32bitmode = (tdep->elf_flags & EF_MIPS_32BITMODE);
9043       fprintf_unfiltered (file,
9044                           "mips_dump_tdep: tdep->elf_flags = 0x%x\n",
9045                           tdep->elf_flags);
9046       fprintf_unfiltered (file,
9047                           "mips_dump_tdep: ef_mips_32bitmode = %d\n",
9048                           ef_mips_32bitmode);
9049       fprintf_unfiltered (file,
9050                           "mips_dump_tdep: ef_mips_arch = %d\n",
9051                           ef_mips_arch);
9052       fprintf_unfiltered (file,
9053                           "mips_dump_tdep: tdep->mips_abi = %d (%s)\n",
9054                           tdep->mips_abi, mips_abi_strings[tdep->mips_abi]);
9055       fprintf_unfiltered (file,
9056                           "mips_dump_tdep: "
9057                           "mips_mask_address_p() %d (default %d)\n",
9058                           mips_mask_address_p (tdep),
9059                           tdep->default_mask_address_p);
9060     }
9061   fprintf_unfiltered (file,
9062                       "mips_dump_tdep: MIPS_DEFAULT_FPU_TYPE = %d (%s)\n",
9063                       MIPS_DEFAULT_FPU_TYPE,
9064                       (MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_NONE ? "none"
9065                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
9066                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
9067                        : "???"));
9068   fprintf_unfiltered (file, "mips_dump_tdep: MIPS_EABI = %d\n",
9069                       MIPS_EABI (gdbarch));
9070   fprintf_unfiltered (file,
9071                       "mips_dump_tdep: MIPS_FPU_TYPE = %d (%s)\n",
9072                       MIPS_FPU_TYPE (gdbarch),
9073                       (MIPS_FPU_TYPE (gdbarch) == MIPS_FPU_NONE ? "none"
9074                        : MIPS_FPU_TYPE (gdbarch) == MIPS_FPU_SINGLE ? "single"
9075                        : MIPS_FPU_TYPE (gdbarch) == MIPS_FPU_DOUBLE ? "double"
9076                        : "???"));
9077 }
9078
9079 extern initialize_file_ftype _initialize_mips_tdep; /* -Wmissing-prototypes */
9080
9081 void
9082 _initialize_mips_tdep (void)
9083 {
9084   static struct cmd_list_element *mipsfpulist = NULL;
9085   struct cmd_list_element *c;
9086
9087   mips_abi_string = mips_abi_strings[MIPS_ABI_UNKNOWN];
9088   if (MIPS_ABI_LAST + 1
9089       != sizeof (mips_abi_strings) / sizeof (mips_abi_strings[0]))
9090     internal_error (__FILE__, __LINE__, _("mips_abi_strings out of sync"));
9091
9092   gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
9093
9094   mips_pdr_data = register_objfile_data ();
9095
9096   /* Create feature sets with the appropriate properties.  The values
9097      are not important.  */
9098   mips_tdesc_gp32 = allocate_target_description ();
9099   set_tdesc_property (mips_tdesc_gp32, PROPERTY_GP32, "");
9100
9101   mips_tdesc_gp64 = allocate_target_description ();
9102   set_tdesc_property (mips_tdesc_gp64, PROPERTY_GP64, "");
9103
9104   /* Add root prefix command for all "set mips"/"show mips" commands.  */
9105   add_prefix_cmd ("mips", no_class, set_mips_command,
9106                   _("Various MIPS specific commands."),
9107                   &setmipscmdlist, "set mips ", 0, &setlist);
9108
9109   add_prefix_cmd ("mips", no_class, show_mips_command,
9110                   _("Various MIPS specific commands."),
9111                   &showmipscmdlist, "show mips ", 0, &showlist);
9112
9113   /* Allow the user to override the ABI.  */
9114   add_setshow_enum_cmd ("abi", class_obscure, mips_abi_strings,
9115                         &mips_abi_string, _("\
9116 Set the MIPS ABI used by this program."), _("\
9117 Show the MIPS ABI used by this program."), _("\
9118 This option can be set to one of:\n\
9119   auto  - the default ABI associated with the current binary\n\
9120   o32\n\
9121   o64\n\
9122   n32\n\
9123   n64\n\
9124   eabi32\n\
9125   eabi64"),
9126                         mips_abi_update,
9127                         show_mips_abi,
9128                         &setmipscmdlist, &showmipscmdlist);
9129
9130   /* Allow the user to set the ISA to assume for compressed code if ELF
9131      file flags don't tell or there is no program file selected.  This
9132      setting is updated whenever unambiguous ELF file flags are interpreted,
9133      and carried over to subsequent sessions.  */
9134   add_setshow_enum_cmd ("compression", class_obscure, mips_compression_strings,
9135                         &mips_compression_string, _("\
9136 Set the compressed ISA encoding used by MIPS code."), _("\
9137 Show the compressed ISA encoding used by MIPS code."), _("\
9138 Select the compressed ISA encoding used in functions that have no symbol\n\
9139 information available.  The encoding can be set to either of:\n\
9140   mips16\n\
9141   micromips\n\
9142 and is updated automatically from ELF file flags if available."),
9143                         mips_abi_update,
9144                         show_mips_compression,
9145                         &setmipscmdlist, &showmipscmdlist);
9146
9147   /* Let the user turn off floating point and set the fence post for
9148      heuristic_proc_start.  */
9149
9150   add_prefix_cmd ("mipsfpu", class_support, set_mipsfpu_command,
9151                   _("Set use of MIPS floating-point coprocessor."),
9152                   &mipsfpulist, "set mipsfpu ", 0, &setlist);
9153   add_cmd ("single", class_support, set_mipsfpu_single_command,
9154            _("Select single-precision MIPS floating-point coprocessor."),
9155            &mipsfpulist);
9156   add_cmd ("double", class_support, set_mipsfpu_double_command,
9157            _("Select double-precision MIPS floating-point coprocessor."),
9158            &mipsfpulist);
9159   add_alias_cmd ("on", "double", class_support, 1, &mipsfpulist);
9160   add_alias_cmd ("yes", "double", class_support, 1, &mipsfpulist);
9161   add_alias_cmd ("1", "double", class_support, 1, &mipsfpulist);
9162   add_cmd ("none", class_support, set_mipsfpu_none_command,
9163            _("Select no MIPS floating-point coprocessor."), &mipsfpulist);
9164   add_alias_cmd ("off", "none", class_support, 1, &mipsfpulist);
9165   add_alias_cmd ("no", "none", class_support, 1, &mipsfpulist);
9166   add_alias_cmd ("0", "none", class_support, 1, &mipsfpulist);
9167   add_cmd ("auto", class_support, set_mipsfpu_auto_command,
9168            _("Select MIPS floating-point coprocessor automatically."),
9169            &mipsfpulist);
9170   add_cmd ("mipsfpu", class_support, show_mipsfpu_command,
9171            _("Show current use of MIPS floating-point coprocessor target."),
9172            &showlist);
9173
9174   /* We really would like to have both "0" and "unlimited" work, but
9175      command.c doesn't deal with that.  So make it a var_zinteger
9176      because the user can always use "999999" or some such for unlimited.  */
9177   add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
9178                             &heuristic_fence_post, _("\
9179 Set the distance searched for the start of a function."), _("\
9180 Show the distance searched for the start of a function."), _("\
9181 If you are debugging a stripped executable, GDB needs to search through the\n\
9182 program for the start of a function.  This command sets the distance of the\n\
9183 search.  The only need to set it is when debugging a stripped executable."),
9184                             reinit_frame_cache_sfunc,
9185                             NULL, /* FIXME: i18n: The distance searched for
9186                                      the start of a function is %s.  */
9187                             &setlist, &showlist);
9188
9189   /* Allow the user to control whether the upper bits of 64-bit
9190      addresses should be zeroed.  */
9191   add_setshow_auto_boolean_cmd ("mask-address", no_class,
9192                                 &mask_address_var, _("\
9193 Set zeroing of upper 32 bits of 64-bit addresses."), _("\
9194 Show zeroing of upper 32 bits of 64-bit addresses."), _("\
9195 Use \"on\" to enable the masking, \"off\" to disable it and \"auto\" to\n\
9196 allow GDB to determine the correct value."),
9197                                 NULL, show_mask_address,
9198                                 &setmipscmdlist, &showmipscmdlist);
9199
9200   /* Allow the user to control the size of 32 bit registers within the
9201      raw remote packet.  */
9202   add_setshow_boolean_cmd ("remote-mips64-transfers-32bit-regs", class_obscure,
9203                            &mips64_transfers_32bit_regs_p, _("\
9204 Set compatibility with 64-bit MIPS target that transfers 32-bit quantities."),
9205                            _("\
9206 Show compatibility with 64-bit MIPS target that transfers 32-bit quantities."),
9207                            _("\
9208 Use \"on\" to enable backward compatibility with older MIPS 64 GDB+target\n\
9209 that would transfer 32 bits for some registers (e.g. SR, FSR) and\n\
9210 64 bits for others.  Use \"off\" to disable compatibility mode"),
9211                            set_mips64_transfers_32bit_regs,
9212                            NULL, /* FIXME: i18n: Compatibility with 64-bit
9213                                     MIPS target that transfers 32-bit
9214                                     quantities is %s.  */
9215                            &setlist, &showlist);
9216
9217   /* Debug this files internals.  */
9218   add_setshow_zuinteger_cmd ("mips", class_maintenance,
9219                              &mips_debug, _("\
9220 Set mips debugging."), _("\
9221 Show mips debugging."), _("\
9222 When non-zero, mips specific debugging is enabled."),
9223                              NULL,
9224                              NULL, /* FIXME: i18n: Mips debugging is
9225                                       currently %s.  */
9226                              &setdebuglist, &showdebuglist);
9227 }