gdb/mips-tdep.c

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