gdb/mips-tdep.c

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