gdb/mips-tdep.c

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