gdb/mips-tdep.c

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