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         error (_("can't read register %d (%s)"),
6546                regnum, gdbarch_register_name (gdbarch, regnum));
6547       raw_buffer = value_contents_all (value);
6548       /* pad small registers */
6549       for (byte = 0;
6550            byte < (mips_abi_regsize (gdbarch)
6551                    - register_size (gdbarch, regnum)); byte++)
6552         fprintf_filtered (file, "  ");
6553       /* Now print the register value in hex, endian order.  */
6554       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
6555         for (byte =
6556              register_size (gdbarch, regnum) - register_size (gdbarch, regnum);
6557              byte < register_size (gdbarch, regnum); byte++)
6558           fprintf_filtered (file, "%02x", raw_buffer[byte]);
6559       else
6560         for (byte = register_size (gdbarch, regnum) - 1;
6561              byte >= 0; byte--)
6562           fprintf_filtered (file, "%02x", raw_buffer[byte]);
6563       fprintf_filtered (file, " ");
6564       col++;
6565     }
6566   if (col > 0)                  /* ie. if we actually printed anything...  */
6567     fprintf_filtered (file, "\n");
6568
6569   return regnum;
6570 }
6571
6572 /* MIPS_DO_REGISTERS_INFO(): called by "info register" command.  */
6573
6574 static void
6575 mips_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
6576                            struct frame_info *frame, int regnum, int all)
6577 {
6578   if (regnum != -1)             /* Do one specified register.  */
6579     {
6580       gdb_assert (regnum >= gdbarch_num_regs (gdbarch));
6581       if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
6582         error (_("Not a valid register for the current processor type"));
6583
6584       mips_print_register (file, frame, regnum);
6585       fprintf_filtered (file, "\n");
6586     }
6587   else
6588     /* Do all (or most) registers.  */
6589     {
6590       regnum = gdbarch_num_regs (gdbarch);
6591       while (regnum < gdbarch_num_regs (gdbarch)
6592                       + gdbarch_num_pseudo_regs (gdbarch))
6593         {
6594           if (mips_float_register_p (gdbarch, regnum))
6595             {
6596               if (all)          /* True for "INFO ALL-REGISTERS" command.  */
6597                 regnum = print_fp_register_row (file, frame, regnum);
6598               else
6599                 regnum += MIPS_NUMREGS; /* Skip floating point regs.  */
6600             }
6601           else
6602             regnum = print_gp_register_row (file, frame, regnum);
6603         }
6604     }
6605 }
6606
6607 static int
6608 mips_single_step_through_delay (struct gdbarch *gdbarch,
6609                                 struct frame_info *frame)
6610 {
6611   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
6612   CORE_ADDR pc = get_frame_pc (frame);
6613   struct address_space *aspace;
6614   enum mips_isa isa;
6615   ULONGEST insn;
6616   int status;
6617   int size;
6618
6619   if ((mips_pc_is_mips (pc)
6620        && !mips32_insn_at_pc_has_delay_slot (gdbarch, pc))
6621       || (mips_pc_is_micromips (gdbarch, pc)
6622           && !micromips_insn_at_pc_has_delay_slot (gdbarch, pc, 0))
6623       || (mips_pc_is_mips16 (gdbarch, pc)
6624           && !mips16_insn_at_pc_has_delay_slot (gdbarch, pc, 0)))
6625     return 0;
6626
6627   isa = mips_pc_isa (gdbarch, pc);
6628   /* _has_delay_slot above will have validated the read.  */
6629   insn = mips_fetch_instruction (gdbarch, isa, pc, NULL);
6630   size = mips_insn_size (isa, insn);
6631   aspace = get_frame_address_space (frame);
6632   return breakpoint_here_p (aspace, pc + size) != no_breakpoint_here;
6633 }
6634
6635 /* To skip prologues, I use this predicate.  Returns either PC itself
6636    if the code at PC does not look like a function prologue; otherwise
6637    returns an address that (if we're lucky) follows the prologue.  If
6638    LENIENT, then we must skip everything which is involved in setting
6639    up the frame (it's OK to skip more, just so long as we don't skip
6640    anything which might clobber the registers which are being saved.
6641    We must skip more in the case where part of the prologue is in the
6642    delay slot of a non-prologue instruction).  */
6643
6644 static CORE_ADDR
6645 mips_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
6646 {
6647   CORE_ADDR limit_pc;
6648   CORE_ADDR func_addr;
6649
6650   /* See if we can determine the end of the prologue via the symbol table.
6651      If so, then return either PC, or the PC after the prologue, whichever
6652      is greater.  */
6653   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
6654     {
6655       CORE_ADDR post_prologue_pc
6656         = skip_prologue_using_sal (gdbarch, func_addr);
6657       if (post_prologue_pc != 0)
6658         return std::max (pc, post_prologue_pc);
6659     }
6660
6661   /* Can't determine prologue from the symbol table, need to examine
6662      instructions.  */
6663
6664   /* Find an upper limit on the function prologue using the debug
6665      information.  If the debug information could not be used to provide
6666      that bound, then use an arbitrary large number as the upper bound.  */
6667   limit_pc = skip_prologue_using_sal (gdbarch, pc);
6668   if (limit_pc == 0)
6669     limit_pc = pc + 100;          /* Magic.  */
6670
6671   if (mips_pc_is_mips16 (gdbarch, pc))
6672     return mips16_scan_prologue (gdbarch, pc, limit_pc, NULL, NULL);
6673   else if (mips_pc_is_micromips (gdbarch, pc))
6674     return micromips_scan_prologue (gdbarch, pc, limit_pc, NULL, NULL);
6675   else
6676     return mips32_scan_prologue (gdbarch, pc, limit_pc, NULL, NULL);
6677 }
6678
6679 /* Implement the stack_frame_destroyed_p gdbarch method (32-bit version).
6680    This is a helper function for mips_stack_frame_destroyed_p.  */
6681
6682 static int
6683 mips32_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6684 {
6685   CORE_ADDR func_addr = 0, func_end = 0;
6686
6687   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
6688     {
6689       /* The MIPS epilogue is max. 12 bytes long.  */
6690       CORE_ADDR addr = func_end - 12;
6691
6692       if (addr < func_addr + 4)
6693         addr = func_addr + 4;
6694       if (pc < addr)
6695         return 0;
6696
6697       for (; pc < func_end; pc += MIPS_INSN32_SIZE)
6698         {
6699           unsigned long high_word;
6700           unsigned long inst;
6701
6702           inst = mips_fetch_instruction (gdbarch, ISA_MIPS, pc, NULL);
6703           high_word = (inst >> 16) & 0xffff;
6704
6705           if (high_word != 0x27bd       /* addiu $sp,$sp,offset */
6706               && high_word != 0x67bd    /* daddiu $sp,$sp,offset */
6707               && inst != 0x03e00008     /* jr $ra */
6708               && inst != 0x00000000)    /* nop */
6709             return 0;
6710         }
6711
6712       return 1;
6713     }
6714
6715   return 0;
6716 }
6717
6718 /* Implement the stack_frame_destroyed_p gdbarch method (microMIPS version).
6719    This is a helper function for mips_stack_frame_destroyed_p.  */
6720
6721 static int
6722 micromips_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6723 {
6724   CORE_ADDR func_addr = 0;
6725   CORE_ADDR func_end = 0;
6726   CORE_ADDR addr;
6727   ULONGEST insn;
6728   long offset;
6729   int dreg;
6730   int sreg;
6731   int loc;
6732
6733   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
6734     return 0;
6735
6736   /* The microMIPS epilogue is max. 12 bytes long.  */
6737   addr = func_end - 12;
6738
6739   if (addr < func_addr + 2)
6740     addr = func_addr + 2;
6741   if (pc < addr)
6742     return 0;
6743
6744   for (; pc < func_end; pc += loc)
6745     {
6746       loc = 0;
6747       insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, NULL);
6748       loc += MIPS_INSN16_SIZE;
6749       switch (mips_insn_size (ISA_MICROMIPS, insn))
6750         {
6751         /* 32-bit instructions.  */
6752         case 2 * MIPS_INSN16_SIZE:
6753           insn <<= 16;
6754           insn |= mips_fetch_instruction (gdbarch,
6755                                           ISA_MICROMIPS, pc + loc, NULL);
6756           loc += MIPS_INSN16_SIZE;
6757           switch (micromips_op (insn >> 16))
6758             {
6759             case 0xc: /* ADDIU: bits 001100 */
6760             case 0x17: /* DADDIU: bits 010111 */
6761               sreg = b0s5_reg (insn >> 16);
6762               dreg = b5s5_reg (insn >> 16);
6763               offset = (b0s16_imm (insn) ^ 0x8000) - 0x8000;
6764               if (sreg == MIPS_SP_REGNUM && dreg == MIPS_SP_REGNUM
6765                             /* (D)ADDIU $sp, imm */
6766                   && offset >= 0)
6767                 break;
6768               return 0;
6769
6770             default:
6771               return 0;
6772             }
6773           break;
6774
6775         /* 16-bit instructions.  */
6776         case MIPS_INSN16_SIZE:
6777           switch (micromips_op (insn))
6778             {
6779             case 0x3: /* MOVE: bits 000011 */
6780               sreg = b0s5_reg (insn);
6781               dreg = b5s5_reg (insn);
6782               if (sreg == 0 && dreg == 0)
6783                                 /* MOVE $zero, $zero aka NOP */
6784                 break;
6785               return 0;
6786
6787             case 0x11: /* POOL16C: bits 010001 */
6788               if (b5s5_op (insn) == 0x18
6789                                 /* JRADDIUSP: bits 010011 11000 */
6790                   || (b5s5_op (insn) == 0xd
6791                                 /* JRC: bits 010011 01101 */
6792                       && b0s5_reg (insn) == MIPS_RA_REGNUM))
6793                                 /* JRC $ra */
6794                 break;
6795               return 0;
6796
6797             case 0x13: /* POOL16D: bits 010011 */
6798               offset = micromips_decode_imm9 (b1s9_imm (insn));
6799               if ((insn & 0x1) == 0x1
6800                                 /* ADDIUSP: bits 010011 1 */
6801                   && offset > 0)
6802                 break;
6803               return 0;
6804
6805             default:
6806               return 0;
6807             }
6808         }
6809     }
6810
6811   return 1;
6812 }
6813
6814 /* Implement the stack_frame_destroyed_p gdbarch method (16-bit version).
6815    This is a helper function for mips_stack_frame_destroyed_p.  */
6816
6817 static int
6818 mips16_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6819 {
6820   CORE_ADDR func_addr = 0, func_end = 0;
6821
6822   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
6823     {
6824       /* The MIPS epilogue is max. 12 bytes long.  */
6825       CORE_ADDR addr = func_end - 12;
6826
6827       if (addr < func_addr + 4)
6828         addr = func_addr + 4;
6829       if (pc < addr)
6830         return 0;
6831
6832       for (; pc < func_end; pc += MIPS_INSN16_SIZE)
6833         {
6834           unsigned short inst;
6835
6836           inst = mips_fetch_instruction (gdbarch, ISA_MIPS16, pc, NULL);
6837
6838           if ((inst & 0xf800) == 0xf000)        /* extend */
6839             continue;
6840
6841           if (inst != 0x6300            /* addiu $sp,offset */
6842               && inst != 0xfb00         /* daddiu $sp,$sp,offset */
6843               && inst != 0xe820         /* jr $ra */
6844               && inst != 0xe8a0         /* jrc $ra */
6845               && inst != 0x6500)        /* nop */
6846             return 0;
6847         }
6848
6849       return 1;
6850     }
6851
6852   return 0;
6853 }
6854
6855 /* Implement the stack_frame_destroyed_p gdbarch method.
6856
6857    The epilogue is defined here as the area at the end of a function,
6858    after an instruction which destroys the function's stack frame.  */
6859
6860 static int
6861 mips_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
6862 {
6863   if (mips_pc_is_mips16 (gdbarch, pc))
6864     return mips16_stack_frame_destroyed_p (gdbarch, pc);
6865   else if (mips_pc_is_micromips (gdbarch, pc))
6866     return micromips_stack_frame_destroyed_p (gdbarch, pc);
6867   else
6868     return mips32_stack_frame_destroyed_p (gdbarch, pc);
6869 }
6870
6871 /* Root of all "set mips "/"show mips " commands.  This will eventually be
6872    used for all MIPS-specific commands.  */
6873
6874 static void
6875 show_mips_command (char *args, int from_tty)
6876 {
6877   help_list (showmipscmdlist, "show mips ", all_commands, gdb_stdout);
6878 }
6879
6880 static void
6881 set_mips_command (char *args, int from_tty)
6882 {
6883   printf_unfiltered
6884     ("\"set mips\" must be followed by an appropriate subcommand.\n");
6885   help_list (setmipscmdlist, "set mips ", all_commands, gdb_stdout);
6886 }
6887
6888 /* Commands to show/set the MIPS FPU type.  */
6889
6890 static void
6891 show_mipsfpu_command (char *args, int from_tty)
6892 {
6893   const char *fpu;
6894
6895   if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
6896     {
6897       printf_unfiltered
6898         ("The MIPS floating-point coprocessor is unknown "
6899          "because the current architecture is not MIPS.\n");
6900       return;
6901     }
6902
6903   switch (MIPS_FPU_TYPE (target_gdbarch ()))
6904     {
6905     case MIPS_FPU_SINGLE:
6906       fpu = "single-precision";
6907       break;
6908     case MIPS_FPU_DOUBLE:
6909       fpu = "double-precision";
6910       break;
6911     case MIPS_FPU_NONE:
6912       fpu = "absent (none)";
6913       break;
6914     default:
6915       internal_error (__FILE__, __LINE__, _("bad switch"));
6916     }
6917   if (mips_fpu_type_auto)
6918     printf_unfiltered ("The MIPS floating-point coprocessor "
6919                        "is set automatically (currently %s)\n",
6920                        fpu);
6921   else
6922     printf_unfiltered
6923       ("The MIPS floating-point coprocessor is assumed to be %s\n", fpu);
6924 }
6925
6926
6927 static void
6928 set_mipsfpu_command (char *args, int from_tty)
6929 {
6930   printf_unfiltered ("\"set mipsfpu\" must be followed by \"double\", "
6931                      "\"single\",\"none\" or \"auto\".\n");
6932   show_mipsfpu_command (args, from_tty);
6933 }
6934
6935 static void
6936 set_mipsfpu_single_command (char *args, int from_tty)
6937 {
6938   struct gdbarch_info info;
6939   gdbarch_info_init (&info);
6940   mips_fpu_type = MIPS_FPU_SINGLE;
6941   mips_fpu_type_auto = 0;
6942   /* FIXME: cagney/2003-11-15: Should be setting a field in "info"
6943      instead of relying on globals.  Doing that would let generic code
6944      handle the search for this specific architecture.  */
6945   if (!gdbarch_update_p (info))
6946     internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
6947 }
6948
6949 static void
6950 set_mipsfpu_double_command (char *args, int from_tty)
6951 {
6952   struct gdbarch_info info;
6953   gdbarch_info_init (&info);
6954   mips_fpu_type = MIPS_FPU_DOUBLE;
6955   mips_fpu_type_auto = 0;
6956   /* FIXME: cagney/2003-11-15: Should be setting a field in "info"
6957      instead of relying on globals.  Doing that would let generic code
6958      handle the search for this specific architecture.  */
6959   if (!gdbarch_update_p (info))
6960     internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
6961 }
6962
6963 static void
6964 set_mipsfpu_none_command (char *args, int from_tty)
6965 {
6966   struct gdbarch_info info;
6967   gdbarch_info_init (&info);
6968   mips_fpu_type = MIPS_FPU_NONE;
6969   mips_fpu_type_auto = 0;
6970   /* FIXME: cagney/2003-11-15: Should be setting a field in "info"
6971      instead of relying on globals.  Doing that would let generic code
6972      handle the search for this specific architecture.  */
6973   if (!gdbarch_update_p (info))
6974     internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
6975 }
6976
6977 static void
6978 set_mipsfpu_auto_command (char *args, int from_tty)
6979 {
6980   mips_fpu_type_auto = 1;
6981 }
6982
6983 /* Just like reinit_frame_cache, but with the right arguments to be
6984    callable as an sfunc.  */
6985
6986 static void
6987 reinit_frame_cache_sfunc (char *args, int from_tty,
6988                           struct cmd_list_element *c)
6989 {
6990   reinit_frame_cache ();
6991 }
6992
6993 static int
6994 gdb_print_insn_mips (bfd_vma memaddr, struct disassemble_info *info)
6995 {
6996   gdb_disassembler *di
6997     = static_cast<gdb_disassembler *>(info->application_data);
6998   struct gdbarch *gdbarch = di->arch ();
6999
7000   /* FIXME: cagney/2003-06-26: Is this even necessary?  The
7001      disassembler needs to be able to locally determine the ISA, and
7002      not rely on GDB.  Otherwize the stand-alone 'objdump -d' will not
7003      work.  */
7004   if (mips_pc_is_mips16 (gdbarch, memaddr))
7005     info->mach = bfd_mach_mips16;
7006   else if (mips_pc_is_micromips (gdbarch, memaddr))
7007     info->mach = bfd_mach_mips_micromips;
7008
7009   /* Round down the instruction address to the appropriate boundary.  */
7010   memaddr &= (info->mach == bfd_mach_mips16
7011               || info->mach == bfd_mach_mips_micromips) ? ~1 : ~3;
7012
7013   /* Set the disassembler options.  */
7014   if (!info->disassembler_options)
7015     /* This string is not recognized explicitly by the disassembler,
7016        but it tells the disassembler to not try to guess the ABI from
7017        the bfd elf headers, such that, if the user overrides the ABI
7018        of a program linked as NewABI, the disassembly will follow the
7019        register naming conventions specified by the user.  */
7020     info->disassembler_options = "gpr-names=32";
7021
7022   return default_print_insn (memaddr, info);
7023 }
7024
7025 static int
7026 gdb_print_insn_mips_n32 (bfd_vma memaddr, struct disassemble_info *info)
7027 {
7028   /* Set up the disassembler info, so that we get the right
7029      register names from libopcodes.  */
7030   info->disassembler_options = "gpr-names=n32";
7031   info->flavour = bfd_target_elf_flavour;
7032
7033   return gdb_print_insn_mips (memaddr, info);
7034 }
7035
7036 static int
7037 gdb_print_insn_mips_n64 (bfd_vma memaddr, struct disassemble_info *info)
7038 {
7039   /* Set up the disassembler info, so that we get the right
7040      register names from libopcodes.  */
7041   info->disassembler_options = "gpr-names=64";
7042   info->flavour = bfd_target_elf_flavour;
7043
7044   return gdb_print_insn_mips (memaddr, info);
7045 }
7046
7047 /* Implement the breakpoint_kind_from_pc gdbarch method.  */
7048
7049 static int
7050 mips_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
7051 {
7052   CORE_ADDR pc = *pcptr;
7053
7054   if (mips_pc_is_mips16 (gdbarch, pc))
7055     {
7056       *pcptr = unmake_compact_addr (pc);
7057       return MIPS_BP_KIND_MIPS16;
7058     }
7059   else if (mips_pc_is_micromips (gdbarch, pc))
7060     {
7061       ULONGEST insn;
7062       int status;
7063
7064       *pcptr = unmake_compact_addr (pc);
7065       insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, pc, &status);
7066       if (status || (mips_insn_size (ISA_MICROMIPS, insn) == 2))
7067         return MIPS_BP_KIND_MICROMIPS16;
7068       else
7069         return MIPS_BP_KIND_MICROMIPS32;
7070     }
7071   else
7072     return MIPS_BP_KIND_MIPS32;
7073 }
7074
7075 /* Implement the sw_breakpoint_from_kind gdbarch method.  */
7076
7077 static const gdb_byte *
7078 mips_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
7079 {
7080   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
7081
7082   switch (kind)
7083     {
7084     case MIPS_BP_KIND_MIPS16:
7085       {
7086         static gdb_byte mips16_big_breakpoint[] = { 0xe8, 0xa5 };
7087         static gdb_byte mips16_little_breakpoint[] = { 0xa5, 0xe8 };
7088
7089         *size = 2;
7090         if (byte_order_for_code == BFD_ENDIAN_BIG)
7091           return mips16_big_breakpoint;
7092         else
7093           return mips16_little_breakpoint;
7094       }
7095     case MIPS_BP_KIND_MICROMIPS16:
7096       {
7097         static gdb_byte micromips16_big_breakpoint[] = { 0x46, 0x85 };
7098         static gdb_byte micromips16_little_breakpoint[] = { 0x85, 0x46 };
7099
7100         *size = 2;
7101
7102         if (byte_order_for_code == BFD_ENDIAN_BIG)
7103           return micromips16_big_breakpoint;
7104         else
7105           return micromips16_little_breakpoint;
7106       }
7107     case MIPS_BP_KIND_MICROMIPS32:
7108       {
7109         static gdb_byte micromips32_big_breakpoint[] = { 0, 0x5, 0, 0x7 };
7110         static gdb_byte micromips32_little_breakpoint[] = { 0x5, 0, 0x7, 0 };
7111
7112         *size = 4;
7113         if (byte_order_for_code == BFD_ENDIAN_BIG)
7114           return micromips32_big_breakpoint;
7115         else
7116           return micromips32_little_breakpoint;
7117       }
7118     case MIPS_BP_KIND_MIPS32:
7119       {
7120         static gdb_byte big_breakpoint[] = { 0, 0x5, 0, 0xd };
7121         static gdb_byte little_breakpoint[] = { 0xd, 0, 0x5, 0 };
7122
7123         *size = 4;
7124         if (byte_order_for_code == BFD_ENDIAN_BIG)
7125           return big_breakpoint;
7126         else
7127           return little_breakpoint;
7128       }
7129     default:
7130       gdb_assert_not_reached ("unexpected mips breakpoint kind");
7131     };
7132 }
7133
7134 /* Return non-zero if the standard MIPS instruction INST has a branch
7135    delay slot (i.e. it is a jump or branch instruction).  This function
7136    is based on mips32_next_pc.  */
7137
7138 static int
7139 mips32_instruction_has_delay_slot (struct gdbarch *gdbarch, ULONGEST inst)
7140 {
7141   int op;
7142   int rs;
7143   int rt;
7144
7145   op = itype_op (inst);
7146   if ((inst & 0xe0000000) != 0)
7147     {
7148       rs = itype_rs (inst);
7149       rt = itype_rt (inst);
7150       return (is_octeon_bbit_op (op, gdbarch)
7151               || op >> 2 == 5   /* BEQL, BNEL, BLEZL, BGTZL: bits 0101xx  */
7152               || op == 29       /* JALX: bits 011101  */
7153               || (op == 17
7154                   && (rs == 8
7155                                 /* BC1F, BC1FL, BC1T, BC1TL: 010001 01000  */
7156                       || (rs == 9 && (rt & 0x2) == 0)
7157                                 /* BC1ANY2F, BC1ANY2T: bits 010001 01001  */
7158                       || (rs == 10 && (rt & 0x2) == 0))));
7159                                 /* BC1ANY4F, BC1ANY4T: bits 010001 01010  */
7160     }
7161   else
7162     switch (op & 0x07)          /* extract bits 28,27,26  */
7163       {
7164       case 0:                   /* SPECIAL  */
7165         op = rtype_funct (inst);
7166         return (op == 8         /* JR  */
7167                 || op == 9);    /* JALR  */
7168         break;                  /* end SPECIAL  */
7169       case 1:                   /* REGIMM  */
7170         rs = itype_rs (inst);
7171         rt = itype_rt (inst);   /* branch condition  */
7172         return ((rt & 0xc) == 0
7173                                 /* BLTZ, BLTZL, BGEZ, BGEZL: bits 000xx  */
7174                                 /* BLTZAL, BLTZALL, BGEZAL, BGEZALL: 100xx  */
7175                 || ((rt & 0x1e) == 0x1c && rs == 0));
7176                                 /* BPOSGE32, BPOSGE64: bits 1110x  */
7177         break;                  /* end REGIMM  */
7178       default:                  /* J, JAL, BEQ, BNE, BLEZ, BGTZ  */
7179         return 1;
7180         break;
7181       }
7182 }
7183
7184 /* Return non-zero if a standard MIPS instruction at ADDR has a branch
7185    delay slot (i.e. it is a jump or branch instruction).  */
7186
7187 static int
7188 mips32_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch, CORE_ADDR addr)
7189 {
7190   ULONGEST insn;
7191   int status;
7192
7193   insn = mips_fetch_instruction (gdbarch, ISA_MIPS, addr, &status);
7194   if (status)
7195     return 0;
7196
7197   return mips32_instruction_has_delay_slot (gdbarch, insn);
7198 }
7199
7200 /* Return non-zero if the microMIPS instruction INSN, comprising the
7201    16-bit major opcode word in the high 16 bits and any second word
7202    in the low 16 bits, has a branch delay slot (i.e. it is a non-compact
7203    jump or branch instruction).  The instruction must be 32-bit if
7204    MUSTBE32 is set or can be any instruction otherwise.  */
7205
7206 static int
7207 micromips_instruction_has_delay_slot (ULONGEST insn, int mustbe32)
7208 {
7209   ULONGEST major = insn >> 16;
7210
7211   switch (micromips_op (major))
7212     {
7213     /* 16-bit instructions.  */
7214     case 0x33:                  /* B16: bits 110011 */
7215     case 0x2b:                  /* BNEZ16: bits 101011 */
7216     case 0x23:                  /* BEQZ16: bits 100011 */
7217       return !mustbe32;
7218     case 0x11:                  /* POOL16C: bits 010001 */
7219       return (!mustbe32
7220               && ((b5s5_op (major) == 0xc
7221                                 /* JR16: bits 010001 01100 */
7222                   || (b5s5_op (major) & 0x1e) == 0xe)));
7223                                 /* JALR16, JALRS16: bits 010001 0111x */
7224     /* 32-bit instructions.  */
7225     case 0x3d:                  /* JAL: bits 111101 */
7226     case 0x3c:                  /* JALX: bits 111100 */
7227     case 0x35:                  /* J: bits 110101 */
7228     case 0x2d:                  /* BNE: bits 101101 */
7229     case 0x25:                  /* BEQ: bits 100101 */
7230     case 0x1d:                  /* JALS: bits 011101 */
7231       return 1;
7232     case 0x10:                  /* POOL32I: bits 010000 */
7233       return ((b5s5_op (major) & 0x1c) == 0x0
7234                                 /* BLTZ, BLTZAL, BGEZ, BGEZAL: 010000 000xx */
7235               || (b5s5_op (major) & 0x1d) == 0x4
7236                                 /* BLEZ, BGTZ: bits 010000 001x0 */
7237               || (b5s5_op (major) & 0x1d) == 0x11
7238                                 /* BLTZALS, BGEZALS: bits 010000 100x1 */
7239               || ((b5s5_op (major) & 0x1e) == 0x14
7240                   && (major & 0x3) == 0x0)
7241                                 /* BC2F, BC2T: bits 010000 1010x xxx00 */
7242               || (b5s5_op (major) & 0x1e) == 0x1a
7243                                 /* BPOSGE64, BPOSGE32: bits 010000 1101x */
7244               || ((b5s5_op (major) & 0x1e) == 0x1c
7245                   && (major & 0x3) == 0x0)
7246                                 /* BC1F, BC1T: bits 010000 1110x xxx00 */
7247               || ((b5s5_op (major) & 0x1c) == 0x1c
7248                   && (major & 0x3) == 0x1));
7249                                 /* BC1ANY*: bits 010000 111xx xxx01 */
7250     case 0x0:                   /* POOL32A: bits 000000 */
7251       return (b0s6_op (insn) == 0x3c
7252                                 /* POOL32Axf: bits 000000 ... 111100 */
7253               && (b6s10_ext (insn) & 0x2bf) == 0x3c);
7254                                 /* JALR, JALR.HB: 000000 000x111100 111100 */
7255                                 /* JALRS, JALRS.HB: 000000 010x111100 111100 */
7256     default:
7257       return 0;
7258     }
7259 }
7260
7261 /* Return non-zero if a microMIPS instruction at ADDR has a branch delay
7262    slot (i.e. it is a non-compact jump instruction).  The instruction
7263    must be 32-bit if MUSTBE32 is set or can be any instruction otherwise.  */
7264
7265 static int
7266 micromips_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch,
7267                                      CORE_ADDR addr, int mustbe32)
7268 {
7269   ULONGEST insn;
7270   int status;
7271   int size;
7272
7273   insn = mips_fetch_instruction (gdbarch, ISA_MICROMIPS, addr, &status);
7274   if (status)
7275     return 0;
7276   size = mips_insn_size (ISA_MICROMIPS, insn);
7277   insn <<= 16;
7278   if (size == 2 * MIPS_INSN16_SIZE)
7279     {
7280       insn |= mips_fetch_instruction (gdbarch, ISA_MICROMIPS, addr, &status);
7281       if (status)
7282         return 0;
7283     }
7284
7285   return micromips_instruction_has_delay_slot (insn, mustbe32);
7286 }
7287
7288 /* Return non-zero if the MIPS16 instruction INST, which must be
7289    a 32-bit instruction if MUSTBE32 is set or can be any instruction
7290    otherwise, has a branch delay slot (i.e. it is a non-compact jump
7291    instruction).  This function is based on mips16_next_pc.  */
7292
7293 static int
7294 mips16_instruction_has_delay_slot (unsigned short inst, int mustbe32)
7295 {
7296   if ((inst & 0xf89f) == 0xe800)        /* JR/JALR (16-bit instruction)  */
7297     return !mustbe32;
7298   return (inst & 0xf800) == 0x1800;     /* JAL/JALX (32-bit instruction)  */
7299 }
7300
7301 /* Return non-zero if a MIPS16 instruction at ADDR has a branch delay
7302    slot (i.e. it is a non-compact jump instruction).  The instruction
7303    must be 32-bit if MUSTBE32 is set or can be any instruction otherwise.  */
7304
7305 static int
7306 mips16_insn_at_pc_has_delay_slot (struct gdbarch *gdbarch,
7307                                   CORE_ADDR addr, int mustbe32)
7308 {
7309   unsigned short insn;
7310   int status;
7311
7312   insn = mips_fetch_instruction (gdbarch, ISA_MIPS16, addr, &status);
7313   if (status)
7314     return 0;
7315
7316   return mips16_instruction_has_delay_slot (insn, mustbe32);
7317 }
7318
7319 /* Calculate the starting address of the MIPS memory segment BPADDR is in.
7320    This assumes KSSEG exists.  */
7321
7322 static CORE_ADDR
7323 mips_segment_boundary (CORE_ADDR bpaddr)
7324 {
7325   CORE_ADDR mask = CORE_ADDR_MAX;
7326   int segsize;
7327
7328   if (sizeof (CORE_ADDR) == 8)
7329     /* Get the topmost two bits of bpaddr in a 32-bit safe manner (avoid
7330        a compiler warning produced where CORE_ADDR is a 32-bit type even
7331        though in that case this is dead code).  */
7332     switch (bpaddr >> ((sizeof (CORE_ADDR) << 3) - 2) & 3)
7333       {
7334       case 3:
7335         if (bpaddr == (bfd_signed_vma) (int32_t) bpaddr)
7336           segsize = 29;                 /* 32-bit compatibility segment  */
7337         else
7338           segsize = 62;                 /* xkseg  */
7339         break;
7340       case 2:                           /* xkphys  */
7341         segsize = 59;
7342         break;
7343       default:                          /* xksseg (1), xkuseg/kuseg (0)  */
7344         segsize = 62;
7345         break;
7346       }
7347   else if (bpaddr & 0x80000000)         /* kernel segment  */
7348     segsize = 29;
7349   else
7350     segsize = 31;                       /* user segment  */
7351   mask <<= segsize;
7352   return bpaddr & mask;
7353 }
7354
7355 /* Move the breakpoint at BPADDR out of any branch delay slot by shifting
7356    it backwards if necessary.  Return the address of the new location.  */
7357
7358 static CORE_ADDR
7359 mips_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
7360 {
7361   CORE_ADDR prev_addr;
7362   CORE_ADDR boundary;
7363   CORE_ADDR func_addr;
7364
7365   /* If a breakpoint is set on the instruction in a branch delay slot,
7366      GDB gets confused.  When the breakpoint is hit, the PC isn't on
7367      the instruction in the branch delay slot, the PC will point to
7368      the branch instruction.  Since the PC doesn't match any known
7369      breakpoints, GDB reports a trap exception.
7370
7371      There are two possible fixes for this problem.
7372
7373      1) When the breakpoint gets hit, see if the BD bit is set in the
7374      Cause register (which indicates the last exception occurred in a
7375      branch delay slot).  If the BD bit is set, fix the PC to point to
7376      the instruction in the branch delay slot.
7377
7378      2) When the user sets the breakpoint, don't allow him to set the
7379      breakpoint on the instruction in the branch delay slot.  Instead
7380      move the breakpoint to the branch instruction (which will have
7381      the same result).
7382
7383      The problem with the first solution is that if the user then
7384      single-steps the processor, the branch instruction will get
7385      skipped (since GDB thinks the PC is on the instruction in the
7386      branch delay slot).
7387
7388      So, we'll use the second solution.  To do this we need to know if
7389      the instruction we're trying to set the breakpoint on is in the
7390      branch delay slot.  */
7391
7392   boundary = mips_segment_boundary (bpaddr);
7393
7394   /* Make sure we don't scan back before the beginning of the current
7395      function, since we may fetch constant data or insns that look like
7396      a jump.  Of course we might do that anyway if the compiler has
7397      moved constants inline. :-(  */
7398   if (find_pc_partial_function (bpaddr, NULL, &func_addr, NULL)
7399       && func_addr > boundary && func_addr <= bpaddr)
7400     boundary = func_addr;
7401
7402   if (mips_pc_is_mips (bpaddr))
7403     {
7404       if (bpaddr == boundary)
7405         return bpaddr;
7406
7407       /* If the previous instruction has a branch delay slot, we have
7408          to move the breakpoint to the branch instruction. */
7409       prev_addr = bpaddr - 4;
7410       if (mips32_insn_at_pc_has_delay_slot (gdbarch, prev_addr))
7411         bpaddr = prev_addr;
7412     }
7413   else
7414     {
7415       int (*insn_at_pc_has_delay_slot) (struct gdbarch *, CORE_ADDR, int);
7416       CORE_ADDR addr, jmpaddr;
7417       int i;
7418
7419       boundary = unmake_compact_addr (boundary);
7420
7421       /* The only MIPS16 instructions with delay slots are JAL, JALX,
7422          JALR and JR.  An absolute JAL/JALX is always 4 bytes long,
7423          so try for that first, then try the 2 byte JALR/JR.
7424          The microMIPS ASE has a whole range of jumps and branches
7425          with delay slots, some of which take 4 bytes and some take
7426          2 bytes, so the idea is the same.
7427          FIXME: We have to assume that bpaddr is not the second half
7428          of an extended instruction.  */
7429       insn_at_pc_has_delay_slot = (mips_pc_is_micromips (gdbarch, bpaddr)
7430                                    ? micromips_insn_at_pc_has_delay_slot
7431                                    : mips16_insn_at_pc_has_delay_slot);
7432
7433       jmpaddr = 0;
7434       addr = bpaddr;
7435       for (i = 1; i < 4; i++)
7436         {
7437           if (unmake_compact_addr (addr) == boundary)
7438             break;
7439           addr -= MIPS_INSN16_SIZE;
7440           if (i == 1 && insn_at_pc_has_delay_slot (gdbarch, addr, 0))
7441             /* Looks like a JR/JALR at [target-1], but it could be
7442                the second word of a previous JAL/JALX, so record it
7443                and check back one more.  */
7444             jmpaddr = addr;
7445           else if (i > 1 && insn_at_pc_has_delay_slot (gdbarch, addr, 1))
7446             {
7447               if (i == 2)
7448                 /* Looks like a JAL/JALX at [target-2], but it could also
7449                    be the second word of a previous JAL/JALX, record it,
7450                    and check back one more.  */
7451                 jmpaddr = addr;
7452               else
7453                 /* Looks like a JAL/JALX at [target-3], so any previously
7454                    recorded JAL/JALX or JR/JALR must be wrong, because:
7455
7456                    >-3: JAL
7457                     -2: JAL-ext (can't be JAL/JALX)
7458                     -1: bdslot (can't be JR/JALR)
7459                      0: target insn
7460
7461                    Of course it could be another JAL-ext which looks
7462                    like a JAL, but in that case we'd have broken out
7463                    of this loop at [target-2]:
7464
7465                     -4: JAL
7466                    >-3: JAL-ext
7467                     -2: bdslot (can't be jmp)
7468                     -1: JR/JALR
7469                      0: target insn  */
7470                 jmpaddr = 0;
7471             }
7472           else
7473             {
7474               /* Not a jump instruction: if we're at [target-1] this
7475                  could be the second word of a JAL/JALX, so continue;
7476                  otherwise we're done.  */
7477               if (i > 1)
7478                 break;
7479             }
7480         }
7481
7482       if (jmpaddr)
7483         bpaddr = jmpaddr;
7484     }
7485
7486   return bpaddr;
7487 }
7488
7489 /* Return non-zero if SUFFIX is one of the numeric suffixes used for MIPS16
7490    call stubs, one of 1, 2, 5, 6, 9, 10, or, if ZERO is non-zero, also 0.  */
7491
7492 static int
7493 mips_is_stub_suffix (const char *suffix, int zero)
7494 {
7495   switch (suffix[0])
7496    {
7497    case '0':
7498      return zero && suffix[1] == '\0';
7499    case '1':
7500      return suffix[1] == '\0' || (suffix[1] == '0' && suffix[2] == '\0');
7501    case '2':
7502    case '5':
7503    case '6':
7504    case '9':
7505      return suffix[1] == '\0';
7506    default:
7507      return 0;
7508    }
7509 }
7510
7511 /* Return non-zero if MODE is one of the mode infixes used for MIPS16
7512    call stubs, one of sf, df, sc, or dc.  */
7513
7514 static int
7515 mips_is_stub_mode (const char *mode)
7516 {
7517   return ((mode[0] == 's' || mode[0] == 'd')
7518           && (mode[1] == 'f' || mode[1] == 'c'));
7519 }
7520
7521 /* Code at PC is a compiler-generated stub.  Such a stub for a function
7522    bar might have a name like __fn_stub_bar, and might look like this:
7523
7524       mfc1    $4, $f13
7525       mfc1    $5, $f12
7526       mfc1    $6, $f15
7527       mfc1    $7, $f14
7528
7529    followed by (or interspersed with):
7530
7531       j       bar
7532
7533    or:
7534
7535       lui     $25, %hi(bar)
7536       addiu   $25, $25, %lo(bar)
7537       jr      $25
7538
7539    ($1 may be used in old code; for robustness we accept any register)
7540    or, in PIC code:
7541
7542       lui     $28, %hi(_gp_disp)
7543       addiu   $28, $28, %lo(_gp_disp)
7544       addu    $28, $28, $25
7545       lw      $25, %got(bar)
7546       addiu   $25, $25, %lo(bar)
7547       jr      $25
7548
7549    In the case of a __call_stub_bar stub, the sequence to set up
7550    arguments might look like this:
7551
7552       mtc1    $4, $f13
7553       mtc1    $5, $f12
7554       mtc1    $6, $f15
7555       mtc1    $7, $f14
7556
7557    followed by (or interspersed with) one of the jump sequences above.
7558
7559    In the case of a __call_stub_fp_bar stub, JAL or JALR is used instead
7560    of J or JR, respectively, followed by:
7561
7562       mfc1    $2, $f0
7563       mfc1    $3, $f1
7564       jr      $18
7565
7566    We are at the beginning of the stub here, and scan down and extract
7567    the target address from the jump immediate instruction or, if a jump
7568    register instruction is used, from the register referred.  Return
7569    the value of PC calculated or 0 if inconclusive.
7570
7571    The limit on the search is arbitrarily set to 20 instructions.  FIXME.  */
7572
7573 static CORE_ADDR
7574 mips_get_mips16_fn_stub_pc (struct frame_info *frame, CORE_ADDR pc)
7575 {
7576   struct gdbarch *gdbarch = get_frame_arch (frame);
7577   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7578   int addrreg = MIPS_ZERO_REGNUM;
7579   CORE_ADDR start_pc = pc;
7580   CORE_ADDR target_pc = 0;
7581   CORE_ADDR addr = 0;
7582   CORE_ADDR gp = 0;
7583   int status = 0;
7584   int i;
7585
7586   for (i = 0;
7587        status == 0 && target_pc == 0 && i < 20;
7588        i++, pc += MIPS_INSN32_SIZE)
7589     {
7590       ULONGEST inst = mips_fetch_instruction (gdbarch, ISA_MIPS, pc, NULL);
7591       CORE_ADDR imm;
7592       int rt;
7593       int rs;
7594       int rd;
7595
7596       switch (itype_op (inst))
7597         {
7598         case 0:         /* SPECIAL */
7599           switch (rtype_funct (inst))
7600             {
7601             case 8:             /* JR */
7602             case 9:             /* JALR */
7603               rs = rtype_rs (inst);
7604               if (rs == MIPS_GP_REGNUM)
7605                 target_pc = gp;                         /* Hmm...  */
7606               else if (rs == addrreg)
7607                 target_pc = addr;
7608               break;
7609
7610             case 0x21:          /* ADDU */
7611               rt = rtype_rt (inst);
7612               rs = rtype_rs (inst);
7613               rd = rtype_rd (inst);
7614               if (rd == MIPS_GP_REGNUM
7615                   && ((rs == MIPS_GP_REGNUM && rt == MIPS_T9_REGNUM)
7616                       || (rs == MIPS_T9_REGNUM && rt == MIPS_GP_REGNUM)))
7617                 gp += start_pc;
7618               break;
7619             }
7620           break;
7621
7622         case 2:         /* J */
7623         case 3:         /* JAL */
7624           target_pc = jtype_target (inst) << 2;
7625           target_pc += ((pc + 4) & ~(CORE_ADDR) 0x0fffffff);
7626           break;
7627
7628         case 9:         /* ADDIU */
7629           rt = itype_rt (inst);
7630           rs = itype_rs (inst);
7631           if (rt == rs)
7632             {
7633               imm = (itype_immediate (inst) ^ 0x8000) - 0x8000;
7634               if (rt == MIPS_GP_REGNUM)
7635                 gp += imm;
7636               else if (rt == addrreg)
7637                 addr += imm;
7638             }
7639           break;
7640
7641         case 0xf:       /* LUI */
7642           rt = itype_rt (inst);
7643           imm = ((itype_immediate (inst) ^ 0x8000) - 0x8000) << 16;
7644           if (rt == MIPS_GP_REGNUM)
7645             gp = imm;
7646           else if (rt != MIPS_ZERO_REGNUM)
7647             {
7648               addrreg = rt;
7649               addr = imm;
7650             }
7651           break;
7652
7653         case 0x23:      /* LW */
7654           rt = itype_rt (inst);
7655           rs = itype_rs (inst);
7656           imm = (itype_immediate (inst) ^ 0x8000) - 0x8000;
7657           if (gp != 0 && rs == MIPS_GP_REGNUM)
7658             {
7659               gdb_byte buf[4];
7660
7661               memset (buf, 0, sizeof (buf));
7662               status = target_read_memory (gp + imm, buf, sizeof (buf));
7663               addrreg = rt;
7664               addr = extract_signed_integer (buf, sizeof (buf), byte_order);
7665             }
7666           break;
7667         }
7668     }
7669
7670   return target_pc;
7671 }
7672
7673 /* If PC is in a MIPS16 call or return stub, return the address of the
7674    target PC, which is either the callee or the caller.  There are several
7675    cases which must be handled:
7676
7677    * If the PC is in __mips16_ret_{d,s}{f,c}, this is a return stub
7678      and the target PC is in $31 ($ra).
7679    * If the PC is in __mips16_call_stub_{1..10}, this is a call stub
7680      and the target PC is in $2.
7681    * If the PC at the start of __mips16_call_stub_{s,d}{f,c}_{0..10},
7682      i.e. before the JALR instruction, this is effectively a call stub
7683      and the target PC is in $2.  Otherwise this is effectively
7684      a return stub and the target PC is in $18.
7685    * If the PC is at the start of __call_stub_fp_*, i.e. before the
7686      JAL or JALR instruction, this is effectively a call stub and the
7687      target PC is buried in the instruction stream.  Otherwise this
7688      is effectively a return stub and the target PC is in $18.
7689    * If the PC is in __call_stub_* or in __fn_stub_*, this is a call
7690      stub and the target PC is buried in the instruction stream.
7691
7692    See the source code for the stubs in gcc/config/mips/mips16.S, or the
7693    stub builder in gcc/config/mips/mips.c (mips16_build_call_stub) for the
7694    gory details.  */
7695
7696 static CORE_ADDR
7697 mips_skip_mips16_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
7698 {
7699   struct gdbarch *gdbarch = get_frame_arch (frame);
7700   CORE_ADDR start_addr;
7701   const char *name;
7702   size_t prefixlen;
7703
7704   /* Find the starting address and name of the function containing the PC.  */
7705   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
7706     return 0;
7707
7708   /* If the PC is in __mips16_ret_{d,s}{f,c}, this is a return stub
7709      and the target PC is in $31 ($ra).  */
7710   prefixlen = strlen (mips_str_mips16_ret_stub);
7711   if (strncmp (name, mips_str_mips16_ret_stub, prefixlen) == 0
7712       && mips_is_stub_mode (name + prefixlen)
7713       && name[prefixlen + 2] == '\0')
7714     return get_frame_register_signed
7715              (frame, gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM);
7716
7717   /* If the PC is in __mips16_call_stub_*, this is one of the call
7718      call/return stubs.  */
7719   prefixlen = strlen (mips_str_mips16_call_stub);
7720   if (strncmp (name, mips_str_mips16_call_stub, prefixlen) == 0)
7721     {
7722       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub
7723          and the target PC is in $2.  */
7724       if (mips_is_stub_suffix (name + prefixlen, 0))
7725         return get_frame_register_signed
7726                  (frame, gdbarch_num_regs (gdbarch) + MIPS_V0_REGNUM);
7727
7728       /* If the PC at the start of __mips16_call_stub_{s,d}{f,c}_{0..10},
7729          i.e. before the JALR instruction, this is effectively a call stub
7730          and the target PC is in $2.  Otherwise this is effectively
7731          a return stub and the target PC is in $18.  */
7732       else if (mips_is_stub_mode (name + prefixlen)
7733                && name[prefixlen + 2] == '_'
7734                && mips_is_stub_suffix (name + prefixlen + 3, 0))
7735         {
7736           if (pc == start_addr)
7737             /* This is the 'call' part of a call stub.  The return
7738                address is in $2.  */
7739             return get_frame_register_signed
7740                      (frame, gdbarch_num_regs (gdbarch) + MIPS_V0_REGNUM);
7741           else
7742             /* This is the 'return' part of a call stub.  The return
7743                address is in $18.  */
7744             return get_frame_register_signed
7745                      (frame, gdbarch_num_regs (gdbarch) + MIPS_S2_REGNUM);
7746         }
7747       else
7748         return 0;               /* Not a stub.  */
7749     }
7750
7751   /* If the PC is in __call_stub_* or __fn_stub*, this is one of the
7752      compiler-generated call or call/return stubs.  */
7753   if (startswith (name, mips_str_fn_stub)
7754       || startswith (name, mips_str_call_stub))
7755     {
7756       if (pc == start_addr)
7757         /* This is the 'call' part of a call stub.  Call this helper
7758            to scan through this code for interesting instructions
7759            and determine the final PC.  */
7760         return mips_get_mips16_fn_stub_pc (frame, pc);
7761       else
7762         /* This is the 'return' part of a call stub.  The return address
7763            is in $18.  */
7764         return get_frame_register_signed
7765                  (frame, gdbarch_num_regs (gdbarch) + MIPS_S2_REGNUM);
7766     }
7767
7768   return 0;                     /* Not a stub.  */
7769 }
7770
7771 /* Return non-zero if the PC is inside a return thunk (aka stub or trampoline).
7772    This implements the IN_SOLIB_RETURN_TRAMPOLINE macro.  */
7773
7774 static int
7775 mips_in_return_stub (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
7776 {
7777   CORE_ADDR start_addr;
7778   size_t prefixlen;
7779
7780   /* Find the starting address of the function containing the PC.  */
7781   if (find_pc_partial_function (pc, NULL, &start_addr, NULL) == 0)
7782     return 0;
7783
7784   /* If the PC is in __mips16_call_stub_{s,d}{f,c}_{0..10} but not at
7785      the start, i.e. after the JALR instruction, this is effectively
7786      a return stub.  */
7787   prefixlen = strlen (mips_str_mips16_call_stub);
7788   if (pc != start_addr
7789       && strncmp (name, mips_str_mips16_call_stub, prefixlen) == 0
7790       && mips_is_stub_mode (name + prefixlen)
7791       && name[prefixlen + 2] == '_'
7792       && mips_is_stub_suffix (name + prefixlen + 3, 1))
7793     return 1;
7794
7795   /* If the PC is in __call_stub_fp_* but not at the start, i.e. after
7796      the JAL or JALR instruction, this is effectively a return stub.  */
7797   prefixlen = strlen (mips_str_call_fp_stub);
7798   if (pc != start_addr
7799       && strncmp (name, mips_str_call_fp_stub, prefixlen) == 0)
7800     return 1;
7801
7802   /* Consume the .pic. prefix of any PIC stub, this function must return
7803      true when the PC is in a PIC stub of a __mips16_ret_{d,s}{f,c} stub
7804      or the call stub path will trigger in handle_inferior_event causing
7805      it to go astray.  */
7806   prefixlen = strlen (mips_str_pic);
7807   if (strncmp (name, mips_str_pic, prefixlen) == 0)
7808     name += prefixlen;
7809
7810   /* If the PC is in __mips16_ret_{d,s}{f,c}, this is a return stub.  */
7811   prefixlen = strlen (mips_str_mips16_ret_stub);
7812   if (strncmp (name, mips_str_mips16_ret_stub, prefixlen) == 0
7813       && mips_is_stub_mode (name + prefixlen)
7814       && name[prefixlen + 2] == '\0')
7815     return 1;
7816
7817   return 0;                     /* Not a stub.  */
7818 }
7819
7820 /* If the current PC is the start of a non-PIC-to-PIC stub, return the
7821    PC of the stub target.  The stub just loads $t9 and jumps to it,
7822    so that $t9 has the correct value at function entry.  */
7823
7824 static CORE_ADDR
7825 mips_skip_pic_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
7826 {
7827   struct gdbarch *gdbarch = get_frame_arch (frame);
7828   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7829   struct bound_minimal_symbol msym;
7830   int i;
7831   gdb_byte stub_code[16];
7832   int32_t stub_words[4];
7833
7834   /* The stub for foo is named ".pic.foo", and is either two
7835      instructions inserted before foo or a three instruction sequence
7836      which jumps to foo.  */
7837   msym = lookup_minimal_symbol_by_pc (pc);
7838   if (msym.minsym == NULL
7839       || BMSYMBOL_VALUE_ADDRESS (msym) != pc
7840       || MSYMBOL_LINKAGE_NAME (msym.minsym) == NULL
7841       || !startswith (MSYMBOL_LINKAGE_NAME (msym.minsym), ".pic."))
7842     return 0;
7843
7844   /* A two-instruction header.  */
7845   if (MSYMBOL_SIZE (msym.minsym) == 8)
7846     return pc + 8;
7847
7848   /* A three-instruction (plus delay slot) trampoline.  */
7849   if (MSYMBOL_SIZE (msym.minsym) == 16)
7850     {
7851       if (target_read_memory (pc, stub_code, 16) != 0)
7852         return 0;
7853       for (i = 0; i < 4; i++)
7854         stub_words[i] = extract_unsigned_integer (stub_code + i * 4,
7855                                                   4, byte_order);
7856
7857       /* A stub contains these instructions:
7858          lui    t9, %hi(target)
7859          j      target
7860           addiu t9, t9, %lo(target)
7861          nop
7862
7863          This works even for N64, since stubs are only generated with
7864          -msym32.  */
7865       if ((stub_words[0] & 0xffff0000U) == 0x3c190000
7866           && (stub_words[1] & 0xfc000000U) == 0x08000000
7867           && (stub_words[2] & 0xffff0000U) == 0x27390000
7868           && stub_words[3] == 0x00000000)
7869         return ((((stub_words[0] & 0x0000ffff) << 16)
7870                  + (stub_words[2] & 0x0000ffff)) ^ 0x8000) - 0x8000;
7871     }
7872
7873   /* Not a recognized stub.  */
7874   return 0;
7875 }
7876
7877 static CORE_ADDR
7878 mips_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
7879 {
7880   CORE_ADDR requested_pc = pc;
7881   CORE_ADDR target_pc;
7882   CORE_ADDR new_pc;
7883
7884   do
7885     {
7886       target_pc = pc;
7887
7888       new_pc = mips_skip_mips16_trampoline_code (frame, pc);
7889       if (new_pc)
7890         pc = new_pc;
7891
7892       new_pc = find_solib_trampoline_target (frame, pc);
7893       if (new_pc)
7894         pc = new_pc;
7895
7896       new_pc = mips_skip_pic_trampoline_code (frame, pc);
7897       if (new_pc)
7898         pc = new_pc;
7899     }
7900   while (pc != target_pc);
7901
7902   return pc != requested_pc ? pc : 0;
7903 }
7904
7905 /* Convert a dbx stab register number (from `r' declaration) to a GDB
7906    [1 * gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
7907
7908 static int
7909 mips_stab_reg_to_regnum (struct gdbarch *gdbarch, int num)
7910 {
7911   int regnum;
7912   if (num >= 0 && num < 32)
7913     regnum = num;
7914   else if (num >= 38 && num < 70)
7915     regnum = num + mips_regnum (gdbarch)->fp0 - 38;
7916   else if (num == 70)
7917     regnum = mips_regnum (gdbarch)->hi;
7918   else if (num == 71)
7919     regnum = mips_regnum (gdbarch)->lo;
7920   else if (mips_regnum (gdbarch)->dspacc != -1 && num >= 72 && num < 78)
7921     regnum = num + mips_regnum (gdbarch)->dspacc - 72;
7922   else
7923     return -1;
7924   return gdbarch_num_regs (gdbarch) + regnum;
7925 }
7926
7927
7928 /* Convert a dwarf, dwarf2, or ecoff register number to a GDB [1 *
7929    gdbarch_num_regs .. 2 * gdbarch_num_regs) REGNUM.  */
7930
7931 static int
7932 mips_dwarf_dwarf2_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int num)
7933 {
7934   int regnum;
7935   if (num >= 0 && num < 32)
7936     regnum = num;
7937   else if (num >= 32 && num < 64)
7938     regnum = num + mips_regnum (gdbarch)->fp0 - 32;
7939   else if (num == 64)
7940     regnum = mips_regnum (gdbarch)->hi;
7941   else if (num == 65)
7942     regnum = mips_regnum (gdbarch)->lo;
7943   else if (mips_regnum (gdbarch)->dspacc != -1 && num >= 66 && num < 72)
7944     regnum = num + mips_regnum (gdbarch)->dspacc - 66;
7945   else
7946     return -1;
7947   return gdbarch_num_regs (gdbarch) + regnum;
7948 }
7949
7950 static int
7951 mips_register_sim_regno (struct gdbarch *gdbarch, int regnum)
7952 {
7953   /* Only makes sense to supply raw registers.  */
7954   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
7955   /* FIXME: cagney/2002-05-13: Need to look at the pseudo register to
7956      decide if it is valid.  Should instead define a standard sim/gdb
7957      register numbering scheme.  */
7958   if (gdbarch_register_name (gdbarch,
7959                              gdbarch_num_regs (gdbarch) + regnum) != NULL
7960       && gdbarch_register_name (gdbarch,
7961                                 gdbarch_num_regs (gdbarch)
7962                                 + regnum)[0] != '\0')
7963     return regnum;
7964   else
7965     return LEGACY_SIM_REGNO_IGNORE;
7966 }
7967
7968
7969 /* Convert an integer into an address.  Extracting the value signed
7970    guarantees a correctly sign extended address.  */
7971
7972 static CORE_ADDR
7973 mips_integer_to_address (struct gdbarch *gdbarch,
7974                          struct type *type, const gdb_byte *buf)
7975 {
7976   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7977   return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
7978 }
7979
7980 /* Dummy virtual frame pointer method.  This is no more or less accurate
7981    than most other architectures; we just need to be explicit about it,
7982    because the pseudo-register gdbarch_sp_regnum will otherwise lead to
7983    an assertion failure.  */
7984
7985 static void
7986 mips_virtual_frame_pointer (struct gdbarch *gdbarch,
7987                             CORE_ADDR pc, int *reg, LONGEST *offset)
7988 {
7989   *reg = MIPS_SP_REGNUM;
7990   *offset = 0;
7991 }
7992
7993 static void
7994 mips_find_abi_section (bfd *abfd, asection *sect, void *obj)
7995 {
7996   enum mips_abi *abip = (enum mips_abi *) obj;
7997   const char *name = bfd_get_section_name (abfd, sect);
7998
7999   if (*abip != MIPS_ABI_UNKNOWN)
8000     return;
8001
8002   if (!startswith (name, ".mdebug."))
8003     return;
8004
8005   if (strcmp (name, ".mdebug.abi32") == 0)
8006     *abip = MIPS_ABI_O32;
8007   else if (strcmp (name, ".mdebug.abiN32") == 0)
8008     *abip = MIPS_ABI_N32;
8009   else if (strcmp (name, ".mdebug.abi64") == 0)
8010     *abip = MIPS_ABI_N64;
8011   else if (strcmp (name, ".mdebug.abiO64") == 0)
8012     *abip = MIPS_ABI_O64;
8013   else if (strcmp (name, ".mdebug.eabi32") == 0)
8014     *abip = MIPS_ABI_EABI32;
8015   else if (strcmp (name, ".mdebug.eabi64") == 0)
8016     *abip = MIPS_ABI_EABI64;
8017   else
8018     warning (_("unsupported ABI %s."), name + 8);
8019 }
8020
8021 static void
8022 mips_find_long_section (bfd *abfd, asection *sect, void *obj)
8023 {
8024   int *lbp = (int *) obj;
8025   const char *name = bfd_get_section_name (abfd, sect);
8026
8027   if (startswith (name, ".gcc_compiled_long32"))
8028     *lbp = 32;
8029   else if (startswith (name, ".gcc_compiled_long64"))
8030     *lbp = 64;
8031   else if (startswith (name, ".gcc_compiled_long"))
8032     warning (_("unrecognized .gcc_compiled_longXX"));
8033 }
8034
8035 static enum mips_abi
8036 global_mips_abi (void)
8037 {
8038   int i;
8039
8040   for (i = 0; mips_abi_strings[i] != NULL; i++)
8041     if (mips_abi_strings[i] == mips_abi_string)
8042       return (enum mips_abi) i;
8043
8044   internal_error (__FILE__, __LINE__, _("unknown ABI string"));
8045 }
8046
8047 /* Return the default compressed instruction set, either of MIPS16
8048    or microMIPS, selected when none could have been determined from
8049    the ELF header of the binary being executed (or no binary has been
8050    selected.  */
8051
8052 static enum mips_isa
8053 global_mips_compression (void)
8054 {
8055   int i;
8056
8057   for (i = 0; mips_compression_strings[i] != NULL; i++)
8058     if (mips_compression_strings[i] == mips_compression_string)
8059       return (enum mips_isa) i;
8060
8061   internal_error (__FILE__, __LINE__, _("unknown compressed ISA string"));
8062 }
8063
8064 static void
8065 mips_register_g_packet_guesses (struct gdbarch *gdbarch)
8066 {
8067   /* If the size matches the set of 32-bit or 64-bit integer registers,
8068      assume that's what we've got.  */
8069   register_remote_g_packet_guess (gdbarch, 38 * 4, mips_tdesc_gp32);
8070   register_remote_g_packet_guess (gdbarch, 38 * 8, mips_tdesc_gp64);
8071
8072   /* If the size matches the full set of registers GDB traditionally
8073      knows about, including floating point, for either 32-bit or
8074      64-bit, assume that's what we've got.  */
8075   register_remote_g_packet_guess (gdbarch, 90 * 4, mips_tdesc_gp32);
8076   register_remote_g_packet_guess (gdbarch, 90 * 8, mips_tdesc_gp64);
8077
8078   /* Otherwise we don't have a useful guess.  */
8079 }
8080
8081 static struct value *
8082 value_of_mips_user_reg (struct frame_info *frame, const void *baton)
8083 {
8084   const int *reg_p = (const int *) baton;
8085   return value_of_register (*reg_p, frame);
8086 }
8087
8088 static struct gdbarch *
8089 mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
8090 {
8091   struct gdbarch *gdbarch;
8092   struct gdbarch_tdep *tdep;
8093   int elf_flags;
8094   enum mips_abi mips_abi, found_abi, wanted_abi;
8095   int i, num_regs;
8096   enum mips_fpu_type fpu_type;
8097   struct tdesc_arch_data *tdesc_data = NULL;
8098   int elf_fpu_type = Val_GNU_MIPS_ABI_FP_ANY;
8099   const char **reg_names;
8100   struct mips_regnum mips_regnum, *regnum;
8101   enum mips_isa mips_isa;
8102   int dspacc;
8103   int dspctl;
8104
8105   /* Fill in the OS dependent register numbers and names.  */
8106   if (info.osabi == GDB_OSABI_LINUX)
8107     {
8108       mips_regnum.fp0 = 38;
8109       mips_regnum.pc = 37;
8110       mips_regnum.cause = 36;
8111       mips_regnum.badvaddr = 35;
8112       mips_regnum.hi = 34;
8113       mips_regnum.lo = 33;
8114       mips_regnum.fp_control_status = 70;
8115       mips_regnum.fp_implementation_revision = 71;
8116       mips_regnum.dspacc = -1;
8117       mips_regnum.dspctl = -1;
8118       dspacc = 72;
8119       dspctl = 78;
8120       num_regs = 90;
8121       reg_names = mips_linux_reg_names;
8122     }
8123   else
8124     {
8125       mips_regnum.lo = MIPS_EMBED_LO_REGNUM;
8126       mips_regnum.hi = MIPS_EMBED_HI_REGNUM;
8127       mips_regnum.badvaddr = MIPS_EMBED_BADVADDR_REGNUM;
8128       mips_regnum.cause = MIPS_EMBED_CAUSE_REGNUM;
8129       mips_regnum.pc = MIPS_EMBED_PC_REGNUM;
8130       mips_regnum.fp0 = MIPS_EMBED_FP0_REGNUM;
8131       mips_regnum.fp_control_status = 70;
8132       mips_regnum.fp_implementation_revision = 71;
8133       mips_regnum.dspacc = dspacc = -1;
8134       mips_regnum.dspctl = dspctl = -1;
8135       num_regs = MIPS_LAST_EMBED_REGNUM + 1;
8136       if (info.bfd_arch_info != NULL
8137           && info.bfd_arch_info->mach == bfd_mach_mips3900)
8138         reg_names = mips_tx39_reg_names;
8139       else
8140         reg_names = mips_generic_reg_names;
8141     }
8142
8143   /* Check any target description for validity.  */
8144   if (tdesc_has_registers (info.target_desc))
8145     {
8146       static const char *const mips_gprs[] = {
8147         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
8148         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
8149         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
8150         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
8151       };
8152       static const char *const mips_fprs[] = {
8153         "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
8154         "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
8155         "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
8156         "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
8157       };
8158
8159       const struct tdesc_feature *feature;
8160       int valid_p;
8161
8162       feature = tdesc_find_feature (info.target_desc,
8163                                     "org.gnu.gdb.mips.cpu");
8164       if (feature == NULL)
8165         return NULL;
8166
8167       tdesc_data = tdesc_data_alloc ();
8168
8169       valid_p = 1;
8170       for (i = MIPS_ZERO_REGNUM; i <= MIPS_RA_REGNUM; i++)
8171         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
8172                                             mips_gprs[i]);
8173
8174
8175       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8176                                           mips_regnum.lo, "lo");
8177       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8178                                           mips_regnum.hi, "hi");
8179       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8180                                           mips_regnum.pc, "pc");
8181
8182       if (!valid_p)
8183         {
8184           tdesc_data_cleanup (tdesc_data);
8185           return NULL;
8186         }
8187
8188       feature = tdesc_find_feature (info.target_desc,
8189                                     "org.gnu.gdb.mips.cp0");
8190       if (feature == NULL)
8191         {
8192           tdesc_data_cleanup (tdesc_data);
8193           return NULL;
8194         }
8195
8196       valid_p = 1;
8197       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8198                                           mips_regnum.badvaddr, "badvaddr");
8199       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8200                                           MIPS_PS_REGNUM, "status");
8201       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8202                                           mips_regnum.cause, "cause");
8203
8204       if (!valid_p)
8205         {
8206           tdesc_data_cleanup (tdesc_data);
8207           return NULL;
8208         }
8209
8210       /* FIXME drow/2007-05-17: The FPU should be optional.  The MIPS
8211          backend is not prepared for that, though.  */
8212       feature = tdesc_find_feature (info.target_desc,
8213                                     "org.gnu.gdb.mips.fpu");
8214       if (feature == NULL)
8215         {
8216           tdesc_data_cleanup (tdesc_data);
8217           return NULL;
8218         }
8219
8220       valid_p = 1;
8221       for (i = 0; i < 32; i++)
8222         valid_p &= tdesc_numbered_register (feature, tdesc_data,
8223                                             i + mips_regnum.fp0, mips_fprs[i]);
8224
8225       valid_p &= tdesc_numbered_register (feature, tdesc_data,
8226                                           mips_regnum.fp_control_status,
8227                                           "fcsr");
8228       valid_p
8229         &= tdesc_numbered_register (feature, tdesc_data,
8230                                     mips_regnum.fp_implementation_revision,
8231                                     "fir");
8232
8233       if (!valid_p)
8234         {
8235           tdesc_data_cleanup (tdesc_data);
8236           return NULL;
8237         }
8238
8239       num_regs = mips_regnum.fp_implementation_revision + 1;
8240
8241       if (dspacc >= 0)
8242         {
8243           feature = tdesc_find_feature (info.target_desc,
8244                                         "org.gnu.gdb.mips.dsp");
8245           /* The DSP registers are optional; it's OK if they are absent.  */
8246           if (feature != NULL)
8247             {
8248               i = 0;
8249               valid_p = 1;
8250               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8251                                                   dspacc + i++, "hi1");
8252               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8253                                                   dspacc + i++, "lo1");
8254               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8255                                                   dspacc + i++, "hi2");
8256               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8257                                                   dspacc + i++, "lo2");
8258               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8259                                                   dspacc + i++, "hi3");
8260               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8261                                                   dspacc + i++, "lo3");
8262
8263               valid_p &= tdesc_numbered_register (feature, tdesc_data,
8264                                                   dspctl, "dspctl");
8265
8266               if (!valid_p)
8267                 {
8268                   tdesc_data_cleanup (tdesc_data);
8269                   return NULL;
8270                 }
8271
8272               mips_regnum.dspacc = dspacc;
8273               mips_regnum.dspctl = dspctl;
8274
8275               num_regs = mips_regnum.dspctl + 1;
8276             }
8277         }
8278
8279       /* It would be nice to detect an attempt to use a 64-bit ABI
8280          when only 32-bit registers are provided.  */
8281       reg_names = NULL;
8282     }
8283
8284   /* First of all, extract the elf_flags, if available.  */
8285   if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
8286     elf_flags = elf_elfheader (info.abfd)->e_flags;
8287   else if (arches != NULL)
8288     elf_flags = gdbarch_tdep (arches->gdbarch)->elf_flags;
8289   else
8290     elf_flags = 0;
8291   if (gdbarch_debug)
8292     fprintf_unfiltered (gdb_stdlog,
8293                         "mips_gdbarch_init: elf_flags = 0x%08x\n", elf_flags);
8294
8295   /* Check ELF_FLAGS to see if it specifies the ABI being used.  */
8296   switch ((elf_flags & EF_MIPS_ABI))
8297     {
8298     case E_MIPS_ABI_O32:
8299       found_abi = MIPS_ABI_O32;
8300       break;
8301     case E_MIPS_ABI_O64:
8302       found_abi = MIPS_ABI_O64;
8303       break;
8304     case E_MIPS_ABI_EABI32:
8305       found_abi = MIPS_ABI_EABI32;
8306       break;
8307     case E_MIPS_ABI_EABI64:
8308       found_abi = MIPS_ABI_EABI64;
8309       break;
8310     default:
8311       if ((elf_flags & EF_MIPS_ABI2))
8312         found_abi = MIPS_ABI_N32;
8313       else
8314         found_abi = MIPS_ABI_UNKNOWN;
8315       break;
8316     }
8317
8318   /* GCC creates a pseudo-section whose name describes the ABI.  */
8319   if (found_abi == MIPS_ABI_UNKNOWN && info.abfd != NULL)
8320     bfd_map_over_sections (info.abfd, mips_find_abi_section, &found_abi);
8321
8322   /* If we have no useful BFD information, use the ABI from the last
8323      MIPS architecture (if there is one).  */
8324   if (found_abi == MIPS_ABI_UNKNOWN && info.abfd == NULL && arches != NULL)
8325     found_abi = gdbarch_tdep (arches->gdbarch)->found_abi;
8326
8327   /* Try the architecture for any hint of the correct ABI.  */
8328   if (found_abi == MIPS_ABI_UNKNOWN
8329       && info.bfd_arch_info != NULL
8330       && info.bfd_arch_info->arch == bfd_arch_mips)
8331     {
8332       switch (info.bfd_arch_info->mach)
8333         {
8334         case bfd_mach_mips3900:
8335           found_abi = MIPS_ABI_EABI32;
8336           break;
8337         case bfd_mach_mips4100:
8338         case bfd_mach_mips5000:
8339           found_abi = MIPS_ABI_EABI64;
8340           break;
8341         case bfd_mach_mips8000:
8342         case bfd_mach_mips10000:
8343           /* On Irix, ELF64 executables use the N64 ABI.  The
8344              pseudo-sections which describe the ABI aren't present
8345              on IRIX.  (Even for executables created by gcc.)  */
8346           if (info.abfd != NULL
8347               && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
8348               && elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
8349             found_abi = MIPS_ABI_N64;
8350           else
8351             found_abi = MIPS_ABI_N32;
8352           break;
8353         }
8354     }
8355
8356   /* Default 64-bit objects to N64 instead of O32.  */
8357   if (found_abi == MIPS_ABI_UNKNOWN
8358       && info.abfd != NULL
8359       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
8360       && elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
8361     found_abi = MIPS_ABI_N64;
8362
8363   if (gdbarch_debug)
8364     fprintf_unfiltered (gdb_stdlog, "mips_gdbarch_init: found_abi = %d\n",
8365                         found_abi);
8366
8367   /* What has the user specified from the command line?  */
8368   wanted_abi = global_mips_abi ();
8369   if (gdbarch_debug)
8370     fprintf_unfiltered (gdb_stdlog, "mips_gdbarch_init: wanted_abi = %d\n",
8371                         wanted_abi);
8372
8373   /* Now that we have found what the ABI for this binary would be,
8374      check whether the user is overriding it.  */
8375   if (wanted_abi != MIPS_ABI_UNKNOWN)
8376     mips_abi = wanted_abi;
8377   else if (found_abi != MIPS_ABI_UNKNOWN)
8378     mips_abi = found_abi;
8379   else
8380     mips_abi = MIPS_ABI_O32;
8381   if (gdbarch_debug)
8382     fprintf_unfiltered (gdb_stdlog, "mips_gdbarch_init: mips_abi = %d\n",
8383                         mips_abi);
8384
8385   /* Determine the default compressed ISA.  */
8386   if ((elf_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0
8387       && (elf_flags & EF_MIPS_ARCH_ASE_M16) == 0)
8388     mips_isa = ISA_MICROMIPS;
8389   else if ((elf_flags & EF_MIPS_ARCH_ASE_M16) != 0
8390            && (elf_flags & EF_MIPS_ARCH_ASE_MICROMIPS) == 0)
8391     mips_isa = ISA_MIPS16;
8392   else
8393     mips_isa = global_mips_compression ();
8394   mips_compression_string = mips_compression_strings[mips_isa];
8395
8396   /* Also used when doing an architecture lookup.  */
8397   if (gdbarch_debug)
8398     fprintf_unfiltered (gdb_stdlog,
8399                         "mips_gdbarch_init: "
8400                         "mips64_transfers_32bit_regs_p = %d\n",
8401                         mips64_transfers_32bit_regs_p);
8402
8403   /* Determine the MIPS FPU type.  */
8404 #ifdef HAVE_ELF
8405   if (info.abfd
8406       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
8407     elf_fpu_type = bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
8408                                              Tag_GNU_MIPS_ABI_FP);
8409 #endif /* HAVE_ELF */
8410
8411   if (!mips_fpu_type_auto)
8412     fpu_type = mips_fpu_type;
8413   else if (elf_fpu_type != Val_GNU_MIPS_ABI_FP_ANY)
8414     {
8415       switch (elf_fpu_type)
8416         {
8417         case Val_GNU_MIPS_ABI_FP_DOUBLE:
8418           fpu_type = MIPS_FPU_DOUBLE;
8419           break;
8420         case Val_GNU_MIPS_ABI_FP_SINGLE:
8421           fpu_type = MIPS_FPU_SINGLE;
8422           break;
8423         case Val_GNU_MIPS_ABI_FP_SOFT:
8424         default:
8425           /* Soft float or unknown.  */
8426           fpu_type = MIPS_FPU_NONE;
8427           break;
8428         }
8429     }
8430   else if (info.bfd_arch_info != NULL
8431            && info.bfd_arch_info->arch == bfd_arch_mips)
8432     switch (info.bfd_arch_info->mach)
8433       {
8434       case bfd_mach_mips3900:
8435       case bfd_mach_mips4100:
8436       case bfd_mach_mips4111:
8437       case bfd_mach_mips4120:
8438         fpu_type = MIPS_FPU_NONE;
8439         break;
8440       case bfd_mach_mips4650:
8441         fpu_type = MIPS_FPU_SINGLE;
8442         break;
8443       default:
8444         fpu_type = MIPS_FPU_DOUBLE;
8445         break;
8446       }
8447   else if (arches != NULL)
8448     fpu_type = gdbarch_tdep (arches->gdbarch)->mips_fpu_type;
8449   else
8450     fpu_type = MIPS_FPU_DOUBLE;
8451   if (gdbarch_debug)
8452     fprintf_unfiltered (gdb_stdlog,
8453                         "mips_gdbarch_init: fpu_type = %d\n", fpu_type);
8454
8455   /* Check for blatant incompatibilities.  */
8456
8457   /* If we have only 32-bit registers, then we can't debug a 64-bit
8458      ABI.  */
8459   if (info.target_desc
8460       && tdesc_property (info.target_desc, PROPERTY_GP32) != NULL
8461       && mips_abi != MIPS_ABI_EABI32
8462       && mips_abi != MIPS_ABI_O32)
8463     {
8464       if (tdesc_data != NULL)
8465         tdesc_data_cleanup (tdesc_data);
8466       return NULL;
8467     }
8468
8469   /* Try to find a pre-existing architecture.  */
8470   for (arches = gdbarch_list_lookup_by_info (arches, &info);
8471        arches != NULL;
8472        arches = gdbarch_list_lookup_by_info (arches->next, &info))
8473     {
8474       /* MIPS needs to be pedantic about which ABI and the compressed
8475          ISA variation the object is using.  */
8476       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
8477         continue;
8478       if (gdbarch_tdep (arches->gdbarch)->mips_abi != mips_abi)
8479         continue;
8480       if (gdbarch_tdep (arches->gdbarch)->mips_isa != mips_isa)
8481         continue;
8482       /* Need to be pedantic about which register virtual size is
8483          used.  */
8484       if (gdbarch_tdep (arches->gdbarch)->mips64_transfers_32bit_regs_p
8485           != mips64_transfers_32bit_regs_p)
8486         continue;
8487       /* Be pedantic about which FPU is selected.  */
8488       if (gdbarch_tdep (arches->gdbarch)->mips_fpu_type != fpu_type)
8489         continue;
8490
8491       if (tdesc_data != NULL)
8492         tdesc_data_cleanup (tdesc_data);
8493       return arches->gdbarch;
8494     }
8495
8496   /* Need a new architecture.  Fill in a target specific vector.  */
8497   tdep = XCNEW (struct gdbarch_tdep);
8498   gdbarch = gdbarch_alloc (&info, tdep);
8499   tdep->elf_flags = elf_flags;
8500   tdep->mips64_transfers_32bit_regs_p = mips64_transfers_32bit_regs_p;
8501   tdep->found_abi = found_abi;
8502   tdep->mips_abi = mips_abi;
8503   tdep->mips_isa = mips_isa;
8504   tdep->mips_fpu_type = fpu_type;
8505   tdep->register_size_valid_p = 0;
8506   tdep->register_size = 0;
8507
8508   if (info.target_desc)
8509     {
8510       /* Some useful properties can be inferred from the target.  */
8511       if (tdesc_property (info.target_desc, PROPERTY_GP32) != NULL)
8512         {
8513           tdep->register_size_valid_p = 1;
8514           tdep->register_size = 4;
8515         }
8516       else if (tdesc_property (info.target_desc, PROPERTY_GP64) != NULL)
8517         {
8518           tdep->register_size_valid_p = 1;
8519           tdep->register_size = 8;
8520         }
8521     }
8522
8523   /* Initially set everything according to the default ABI/ISA.  */
8524   set_gdbarch_short_bit (gdbarch, 16);
8525   set_gdbarch_int_bit (gdbarch, 32);
8526   set_gdbarch_float_bit (gdbarch, 32);
8527   set_gdbarch_double_bit (gdbarch, 64);
8528   set_gdbarch_long_double_bit (gdbarch, 64);
8529   set_gdbarch_register_reggroup_p (gdbarch, mips_register_reggroup_p);
8530   set_gdbarch_pseudo_register_read (gdbarch, mips_pseudo_register_read);
8531   set_gdbarch_pseudo_register_write (gdbarch, mips_pseudo_register_write);
8532
8533   set_gdbarch_ax_pseudo_register_collect (gdbarch,
8534                                           mips_ax_pseudo_register_collect);
8535   set_gdbarch_ax_pseudo_register_push_stack
8536       (gdbarch, mips_ax_pseudo_register_push_stack);
8537
8538   set_gdbarch_elf_make_msymbol_special (gdbarch,
8539                                         mips_elf_make_msymbol_special);
8540   set_gdbarch_make_symbol_special (gdbarch, mips_make_symbol_special);
8541   set_gdbarch_adjust_dwarf2_addr (gdbarch, mips_adjust_dwarf2_addr);
8542   set_gdbarch_adjust_dwarf2_line (gdbarch, mips_adjust_dwarf2_line);
8543
8544   regnum = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct mips_regnum);
8545   *regnum = mips_regnum;
8546   set_gdbarch_fp0_regnum (gdbarch, regnum->fp0);
8547   set_gdbarch_num_regs (gdbarch, num_regs);
8548   set_gdbarch_num_pseudo_regs (gdbarch, num_regs);
8549   set_gdbarch_register_name (gdbarch, mips_register_name);
8550   set_gdbarch_virtual_frame_pointer (gdbarch, mips_virtual_frame_pointer);
8551   tdep->mips_processor_reg_names = reg_names;
8552   tdep->regnum = regnum;
8553
8554   switch (mips_abi)
8555     {
8556     case MIPS_ABI_O32:
8557       set_gdbarch_push_dummy_call (gdbarch, mips_o32_push_dummy_call);
8558       set_gdbarch_return_value (gdbarch, mips_o32_return_value);
8559       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 4 - 1;
8560       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 4 - 1;
8561       tdep->default_mask_address_p = 0;
8562       set_gdbarch_long_bit (gdbarch, 32);
8563       set_gdbarch_ptr_bit (gdbarch, 32);
8564       set_gdbarch_long_long_bit (gdbarch, 64);
8565       break;
8566     case MIPS_ABI_O64:
8567       set_gdbarch_push_dummy_call (gdbarch, mips_o64_push_dummy_call);
8568       set_gdbarch_return_value (gdbarch, mips_o64_return_value);
8569       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 4 - 1;
8570       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 4 - 1;
8571       tdep->default_mask_address_p = 0;
8572       set_gdbarch_long_bit (gdbarch, 32);
8573       set_gdbarch_ptr_bit (gdbarch, 32);
8574       set_gdbarch_long_long_bit (gdbarch, 64);
8575       break;
8576     case MIPS_ABI_EABI32:
8577       set_gdbarch_push_dummy_call (gdbarch, mips_eabi_push_dummy_call);
8578       set_gdbarch_return_value (gdbarch, mips_eabi_return_value);
8579       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8580       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8581       tdep->default_mask_address_p = 0;
8582       set_gdbarch_long_bit (gdbarch, 32);
8583       set_gdbarch_ptr_bit (gdbarch, 32);
8584       set_gdbarch_long_long_bit (gdbarch, 64);
8585       break;
8586     case MIPS_ABI_EABI64:
8587       set_gdbarch_push_dummy_call (gdbarch, mips_eabi_push_dummy_call);
8588       set_gdbarch_return_value (gdbarch, mips_eabi_return_value);
8589       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8590       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8591       tdep->default_mask_address_p = 0;
8592       set_gdbarch_long_bit (gdbarch, 64);
8593       set_gdbarch_ptr_bit (gdbarch, 64);
8594       set_gdbarch_long_long_bit (gdbarch, 64);
8595       break;
8596     case MIPS_ABI_N32:
8597       set_gdbarch_push_dummy_call (gdbarch, mips_n32n64_push_dummy_call);
8598       set_gdbarch_return_value (gdbarch, mips_n32n64_return_value);
8599       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8600       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8601       tdep->default_mask_address_p = 0;
8602       set_gdbarch_long_bit (gdbarch, 32);
8603       set_gdbarch_ptr_bit (gdbarch, 32);
8604       set_gdbarch_long_long_bit (gdbarch, 64);
8605       set_gdbarch_long_double_bit (gdbarch, 128);
8606       set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
8607       break;
8608     case MIPS_ABI_N64:
8609       set_gdbarch_push_dummy_call (gdbarch, mips_n32n64_push_dummy_call);
8610       set_gdbarch_return_value (gdbarch, mips_n32n64_return_value);
8611       tdep->mips_last_arg_regnum = MIPS_A0_REGNUM + 8 - 1;
8612       tdep->mips_last_fp_arg_regnum = tdep->regnum->fp0 + 12 + 8 - 1;
8613       tdep->default_mask_address_p = 0;
8614       set_gdbarch_long_bit (gdbarch, 64);
8615       set_gdbarch_ptr_bit (gdbarch, 64);
8616       set_gdbarch_long_long_bit (gdbarch, 64);
8617       set_gdbarch_long_double_bit (gdbarch, 128);
8618       set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
8619       break;
8620     default:
8621       internal_error (__FILE__, __LINE__, _("unknown ABI in switch"));
8622     }
8623
8624   /* GCC creates a pseudo-section whose name specifies the size of
8625      longs, since -mlong32 or -mlong64 may be used independent of
8626      other options.  How those options affect pointer sizes is ABI and
8627      architecture dependent, so use them to override the default sizes
8628      set by the ABI.  This table shows the relationship between ABI,
8629      -mlongXX, and size of pointers:
8630
8631      ABI                -mlongXX        ptr bits
8632      ---                --------        --------
8633      o32                32              32
8634      o32                64              32
8635      n32                32              32
8636      n32                64              64
8637      o64                32              32
8638      o64                64              64
8639      n64                32              32
8640      n64                64              64
8641      eabi32             32              32
8642      eabi32             64              32
8643      eabi64             32              32
8644      eabi64             64              64
8645
8646     Note that for o32 and eabi32, pointers are always 32 bits
8647     regardless of any -mlongXX option.  For all others, pointers and
8648     longs are the same, as set by -mlongXX or set by defaults.  */
8649
8650   if (info.abfd != NULL)
8651     {
8652       int long_bit = 0;
8653
8654       bfd_map_over_sections (info.abfd, mips_find_long_section, &long_bit);
8655       if (long_bit)
8656         {
8657           set_gdbarch_long_bit (gdbarch, long_bit);
8658           switch (mips_abi)
8659             {
8660             case MIPS_ABI_O32:
8661             case MIPS_ABI_EABI32:
8662               break;
8663             case MIPS_ABI_N32:
8664             case MIPS_ABI_O64:
8665             case MIPS_ABI_N64:
8666             case MIPS_ABI_EABI64:
8667               set_gdbarch_ptr_bit (gdbarch, long_bit);
8668               break;
8669             default:
8670               internal_error (__FILE__, __LINE__, _("unknown ABI in switch"));
8671             }
8672         }
8673     }
8674
8675   /* FIXME: jlarmour/2000-04-07: There *is* a flag EF_MIPS_32BIT_MODE
8676      that could indicate -gp32 BUT gas/config/tc-mips.c contains the
8677      comment:
8678
8679      ``We deliberately don't allow "-gp32" to set the MIPS_32BITMODE
8680      flag in object files because to do so would make it impossible to
8681      link with libraries compiled without "-gp32".  This is
8682      unnecessarily restrictive.
8683
8684      We could solve this problem by adding "-gp32" multilibs to gcc,
8685      but to set this flag before gcc is built with such multilibs will
8686      break too many systems.''
8687
8688      But even more unhelpfully, the default linker output target for
8689      mips64-elf is elf32-bigmips, and has EF_MIPS_32BIT_MODE set, even
8690      for 64-bit programs - you need to change the ABI to change this,
8691      and not all gcc targets support that currently.  Therefore using
8692      this flag to detect 32-bit mode would do the wrong thing given
8693      the current gcc - it would make GDB treat these 64-bit programs
8694      as 32-bit programs by default.  */
8695
8696   set_gdbarch_read_pc (gdbarch, mips_read_pc);
8697   set_gdbarch_write_pc (gdbarch, mips_write_pc);
8698
8699   /* Add/remove bits from an address.  The MIPS needs be careful to
8700      ensure that all 32 bit addresses are sign extended to 64 bits.  */
8701   set_gdbarch_addr_bits_remove (gdbarch, mips_addr_bits_remove);
8702
8703   /* Unwind the frame.  */
8704   set_gdbarch_unwind_pc (gdbarch, mips_unwind_pc);
8705   set_gdbarch_unwind_sp (gdbarch, mips_unwind_sp);
8706   set_gdbarch_dummy_id (gdbarch, mips_dummy_id);
8707
8708   /* Map debug register numbers onto internal register numbers.  */
8709   set_gdbarch_stab_reg_to_regnum (gdbarch, mips_stab_reg_to_regnum);
8710   set_gdbarch_ecoff_reg_to_regnum (gdbarch,
8711                                    mips_dwarf_dwarf2_ecoff_reg_to_regnum);
8712   set_gdbarch_dwarf2_reg_to_regnum (gdbarch,
8713                                     mips_dwarf_dwarf2_ecoff_reg_to_regnum);
8714   set_gdbarch_register_sim_regno (gdbarch, mips_register_sim_regno);
8715
8716   /* MIPS version of CALL_DUMMY.  */
8717
8718   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
8719   set_gdbarch_push_dummy_code (gdbarch, mips_push_dummy_code);
8720   set_gdbarch_frame_align (gdbarch, mips_frame_align);
8721
8722   set_gdbarch_print_float_info (gdbarch, mips_print_float_info);
8723
8724   set_gdbarch_convert_register_p (gdbarch, mips_convert_register_p);
8725   set_gdbarch_register_to_value (gdbarch, mips_register_to_value);
8726   set_gdbarch_value_to_register (gdbarch, mips_value_to_register);
8727
8728   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
8729   set_gdbarch_breakpoint_kind_from_pc (gdbarch, mips_breakpoint_kind_from_pc);
8730   set_gdbarch_sw_breakpoint_from_kind (gdbarch, mips_sw_breakpoint_from_kind);
8731   set_gdbarch_adjust_breakpoint_address (gdbarch,
8732                                          mips_adjust_breakpoint_address);
8733
8734   set_gdbarch_skip_prologue (gdbarch, mips_skip_prologue);
8735
8736   set_gdbarch_stack_frame_destroyed_p (gdbarch, mips_stack_frame_destroyed_p);
8737
8738   set_gdbarch_pointer_to_address (gdbarch, signed_pointer_to_address);
8739   set_gdbarch_address_to_pointer (gdbarch, address_to_signed_pointer);
8740   set_gdbarch_integer_to_address (gdbarch, mips_integer_to_address);
8741
8742   set_gdbarch_register_type (gdbarch, mips_register_type);
8743
8744   set_gdbarch_print_registers_info (gdbarch, mips_print_registers_info);
8745
8746   if (mips_abi == MIPS_ABI_N32)
8747     set_gdbarch_print_insn (gdbarch, gdb_print_insn_mips_n32);
8748   else if (mips_abi == MIPS_ABI_N64)
8749     set_gdbarch_print_insn (gdbarch, gdb_print_insn_mips_n64);
8750   else
8751     set_gdbarch_print_insn (gdbarch, gdb_print_insn_mips);
8752
8753   /* FIXME: cagney/2003-08-29: The macros target_have_steppable_watchpoint,
8754      HAVE_NONSTEPPABLE_WATCHPOINT, and target_have_continuable_watchpoint
8755      need to all be folded into the target vector.  Since they are
8756      being used as guards for target_stopped_by_watchpoint, why not have
8757      target_stopped_by_watchpoint return the type of watchpoint that the code
8758      is sitting on?  */
8759   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
8760
8761   set_gdbarch_skip_trampoline_code (gdbarch, mips_skip_trampoline_code);
8762
8763   /* NOTE drow/2012-04-25: We overload the core solib trampoline code
8764      to support MIPS16.  This is a bad thing.  Make sure not to do it
8765      if we have an OS ABI that actually supports shared libraries, since
8766      shared library support is more important.  If we have an OS someday
8767      that supports both shared libraries and MIPS16, we'll have to find
8768      a better place for these.
8769      macro/2012-04-25: But that applies to return trampolines only and
8770      currently no MIPS OS ABI uses shared libraries that have them.  */
8771   set_gdbarch_in_solib_return_trampoline (gdbarch, mips_in_return_stub);
8772
8773   set_gdbarch_single_step_through_delay (gdbarch,
8774                                          mips_single_step_through_delay);
8775
8776   /* Virtual tables.  */
8777   set_gdbarch_vbit_in_delta (gdbarch, 1);
8778
8779   mips_register_g_packet_guesses (gdbarch);
8780
8781   /* Hook in OS ABI-specific overrides, if they have been registered.  */
8782   info.tdep_info = tdesc_data;
8783   gdbarch_init_osabi (info, gdbarch);
8784
8785   /* The hook may have adjusted num_regs, fetch the final value and
8786      set pc_regnum and sp_regnum now that it has been fixed.  */
8787   num_regs = gdbarch_num_regs (gdbarch);
8788   set_gdbarch_pc_regnum (gdbarch, regnum->pc + num_regs);
8789   set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs);
8790
8791   /* Unwind the frame.  */
8792   dwarf2_append_unwinders (gdbarch);
8793   frame_unwind_append_unwinder (gdbarch, &mips_stub_frame_unwind);
8794   frame_unwind_append_unwinder (gdbarch, &mips_insn16_frame_unwind);
8795   frame_unwind_append_unwinder (gdbarch, &mips_micro_frame_unwind);
8796   frame_unwind_append_unwinder (gdbarch, &mips_insn32_frame_unwind);
8797   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
8798   frame_base_append_sniffer (gdbarch, mips_stub_frame_base_sniffer);
8799   frame_base_append_sniffer (gdbarch, mips_insn16_frame_base_sniffer);
8800   frame_base_append_sniffer (gdbarch, mips_micro_frame_base_sniffer);
8801   frame_base_append_sniffer (gdbarch, mips_insn32_frame_base_sniffer);
8802
8803   if (tdesc_data)
8804     {
8805       set_tdesc_pseudo_register_type (gdbarch, mips_pseudo_register_type);
8806       tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
8807
8808       /* Override the normal target description methods to handle our
8809          dual real and pseudo registers.  */
8810       set_gdbarch_register_name (gdbarch, mips_register_name);
8811       set_gdbarch_register_reggroup_p (gdbarch,
8812                                        mips_tdesc_register_reggroup_p);
8813
8814       num_regs = gdbarch_num_regs (gdbarch);
8815       set_gdbarch_num_pseudo_regs (gdbarch, num_regs);
8816       set_gdbarch_pc_regnum (gdbarch, tdep->regnum->pc + num_regs);
8817       set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs);
8818     }
8819
8820   /* Add ABI-specific aliases for the registers.  */
8821   if (mips_abi == MIPS_ABI_N32 || mips_abi == MIPS_ABI_N64)
8822     for (i = 0; i < ARRAY_SIZE (mips_n32_n64_aliases); i++)
8823       user_reg_add (gdbarch, mips_n32_n64_aliases[i].name,
8824                     value_of_mips_user_reg, &mips_n32_n64_aliases[i].regnum);
8825   else
8826     for (i = 0; i < ARRAY_SIZE (mips_o32_aliases); i++)
8827       user_reg_add (gdbarch, mips_o32_aliases[i].name,
8828                     value_of_mips_user_reg, &mips_o32_aliases[i].regnum);
8829
8830   /* Add some other standard aliases.  */
8831   for (i = 0; i < ARRAY_SIZE (mips_register_aliases); i++)
8832     user_reg_add (gdbarch, mips_register_aliases[i].name,
8833                   value_of_mips_user_reg, &mips_register_aliases[i].regnum);
8834
8835   for (i = 0; i < ARRAY_SIZE (mips_numeric_register_aliases); i++)
8836     user_reg_add (gdbarch, mips_numeric_register_aliases[i].name,
8837                   value_of_mips_user_reg,
8838                   &mips_numeric_register_aliases[i].regnum);
8839
8840   return gdbarch;
8841 }
8842
8843 static void
8844 mips_abi_update (char *ignore_args, int from_tty, struct cmd_list_element *c)
8845 {
8846   struct gdbarch_info info;
8847
8848   /* Force the architecture to update, and (if it's a MIPS architecture)
8849      mips_gdbarch_init will take care of the rest.  */
8850   gdbarch_info_init (&info);
8851   gdbarch_update_p (info);
8852 }
8853
8854 /* Print out which MIPS ABI is in use.  */
8855
8856 static void
8857 show_mips_abi (struct ui_file *file,
8858                int from_tty,
8859                struct cmd_list_element *ignored_cmd,
8860                const char *ignored_value)
8861 {
8862   if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
8863     fprintf_filtered
8864       (file,
8865        "The MIPS ABI is unknown because the current architecture "
8866        "is not MIPS.\n");
8867   else
8868     {
8869       enum mips_abi global_abi = global_mips_abi ();
8870       enum mips_abi actual_abi = mips_abi (target_gdbarch ());
8871       const char *actual_abi_str = mips_abi_strings[actual_abi];
8872
8873       if (global_abi == MIPS_ABI_UNKNOWN)
8874         fprintf_filtered
8875           (file,
8876            "The MIPS ABI is set automatically (currently \"%s\").\n",
8877            actual_abi_str);
8878       else if (global_abi == actual_abi)
8879         fprintf_filtered
8880           (file,
8881            "The MIPS ABI is assumed to be \"%s\" (due to user setting).\n",
8882            actual_abi_str);
8883       else
8884         {
8885           /* Probably shouldn't happen...  */
8886           fprintf_filtered (file,
8887                             "The (auto detected) MIPS ABI \"%s\" is in use "
8888                             "even though the user setting was \"%s\".\n",
8889              actual_abi_str, mips_abi_strings[global_abi]);
8890         }
8891     }
8892 }
8893
8894 /* Print out which MIPS compressed ISA encoding is used.  */
8895
8896 static void
8897 show_mips_compression (struct ui_file *file, int from_tty,
8898                        struct cmd_list_element *c, const char *value)
8899 {
8900   fprintf_filtered (file, _("The compressed ISA encoding used is %s.\n"),
8901                     value);
8902 }
8903
8904 static void
8905 mips_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
8906 {
8907   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
8908   if (tdep != NULL)
8909     {
8910       int ef_mips_arch;
8911       int ef_mips_32bitmode;
8912       /* Determine the ISA.  */
8913       switch (tdep->elf_flags & EF_MIPS_ARCH)
8914         {
8915         case E_MIPS_ARCH_1:
8916           ef_mips_arch = 1;
8917           break;
8918         case E_MIPS_ARCH_2:
8919           ef_mips_arch = 2;
8920           break;
8921         case E_MIPS_ARCH_3:
8922           ef_mips_arch = 3;
8923           break;
8924         case E_MIPS_ARCH_4:
8925           ef_mips_arch = 4;
8926           break;
8927         default:
8928           ef_mips_arch = 0;
8929           break;
8930         }
8931       /* Determine the size of a pointer.  */
8932       ef_mips_32bitmode = (tdep->elf_flags & EF_MIPS_32BITMODE);
8933       fprintf_unfiltered (file,
8934                           "mips_dump_tdep: tdep->elf_flags = 0x%x\n",
8935                           tdep->elf_flags);
8936       fprintf_unfiltered (file,
8937                           "mips_dump_tdep: ef_mips_32bitmode = %d\n",
8938                           ef_mips_32bitmode);
8939       fprintf_unfiltered (file,
8940                           "mips_dump_tdep: ef_mips_arch = %d\n",
8941                           ef_mips_arch);
8942       fprintf_unfiltered (file,
8943                           "mips_dump_tdep: tdep->mips_abi = %d (%s)\n",
8944                           tdep->mips_abi, mips_abi_strings[tdep->mips_abi]);
8945       fprintf_unfiltered (file,
8946                           "mips_dump_tdep: "
8947                           "mips_mask_address_p() %d (default %d)\n",
8948                           mips_mask_address_p (tdep),
8949                           tdep->default_mask_address_p);
8950     }
8951   fprintf_unfiltered (file,
8952                       "mips_dump_tdep: MIPS_DEFAULT_FPU_TYPE = %d (%s)\n",
8953                       MIPS_DEFAULT_FPU_TYPE,
8954                       (MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_NONE ? "none"
8955                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
8956                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
8957                        : "???"));
8958   fprintf_unfiltered (file, "mips_dump_tdep: MIPS_EABI = %d\n",
8959                       MIPS_EABI (gdbarch));
8960   fprintf_unfiltered (file,
8961                       "mips_dump_tdep: MIPS_FPU_TYPE = %d (%s)\n",
8962                       MIPS_FPU_TYPE (gdbarch),
8963                       (MIPS_FPU_TYPE (gdbarch) == MIPS_FPU_NONE ? "none"
8964                        : MIPS_FPU_TYPE (gdbarch) == MIPS_FPU_SINGLE ? "single"
8965                        : MIPS_FPU_TYPE (gdbarch) == MIPS_FPU_DOUBLE ? "double"
8966                        : "???"));
8967 }
8968
8969 extern initialize_file_ftype _initialize_mips_tdep; /* -Wmissing-prototypes */
8970
8971 void
8972 _initialize_mips_tdep (void)
8973 {
8974   static struct cmd_list_element *mipsfpulist = NULL;
8975   struct cmd_list_element *c;
8976
8977   mips_abi_string = mips_abi_strings[MIPS_ABI_UNKNOWN];
8978   if (MIPS_ABI_LAST + 1
8979       != sizeof (mips_abi_strings) / sizeof (mips_abi_strings[0]))
8980     internal_error (__FILE__, __LINE__, _("mips_abi_strings out of sync"));
8981
8982   gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
8983
8984   mips_pdr_data = register_objfile_data ();
8985
8986   /* Create feature sets with the appropriate properties.  The values
8987      are not important.  */
8988   mips_tdesc_gp32 = allocate_target_description ();
8989   set_tdesc_property (mips_tdesc_gp32, PROPERTY_GP32, "");
8990
8991   mips_tdesc_gp64 = allocate_target_description ();
8992   set_tdesc_property (mips_tdesc_gp64, PROPERTY_GP64, "");
8993
8994   /* Add root prefix command for all "set mips"/"show mips" commands.  */
8995   add_prefix_cmd ("mips", no_class, set_mips_command,
8996                   _("Various MIPS specific commands."),
8997                   &setmipscmdlist, "set mips ", 0, &setlist);
8998
8999   add_prefix_cmd ("mips", no_class, show_mips_command,
9000                   _("Various MIPS specific commands."),
9001                   &showmipscmdlist, "show mips ", 0, &showlist);
9002
9003   /* Allow the user to override the ABI.  */
9004   add_setshow_enum_cmd ("abi", class_obscure, mips_abi_strings,
9005                         &mips_abi_string, _("\
9006 Set the MIPS ABI used by this program."), _("\
9007 Show the MIPS ABI used by this program."), _("\
9008 This option can be set to one of:\n\
9009   auto  - the default ABI associated with the current binary\n\
9010   o32\n\
9011   o64\n\
9012   n32\n\
9013   n64\n\
9014   eabi32\n\
9015   eabi64"),
9016                         mips_abi_update,
9017                         show_mips_abi,
9018                         &setmipscmdlist, &showmipscmdlist);
9019
9020   /* Allow the user to set the ISA to assume for compressed code if ELF
9021      file flags don't tell or there is no program file selected.  This
9022      setting is updated whenever unambiguous ELF file flags are interpreted,
9023      and carried over to subsequent sessions.  */
9024   add_setshow_enum_cmd ("compression", class_obscure, mips_compression_strings,
9025                         &mips_compression_string, _("\
9026 Set the compressed ISA encoding used by MIPS code."), _("\
9027 Show the compressed ISA encoding used by MIPS code."), _("\
9028 Select the compressed ISA encoding used in functions that have no symbol\n\
9029 information available.  The encoding can be set to either of:\n\
9030   mips16\n\
9031   micromips\n\
9032 and is updated automatically from ELF file flags if available."),
9033                         mips_abi_update,
9034                         show_mips_compression,
9035                         &setmipscmdlist, &showmipscmdlist);
9036
9037   /* Let the user turn off floating point and set the fence post for
9038      heuristic_proc_start.  */
9039
9040   add_prefix_cmd ("mipsfpu", class_support, set_mipsfpu_command,
9041                   _("Set use of MIPS floating-point coprocessor."),
9042                   &mipsfpulist, "set mipsfpu ", 0, &setlist);
9043   add_cmd ("single", class_support, set_mipsfpu_single_command,
9044            _("Select single-precision MIPS floating-point coprocessor."),
9045            &mipsfpulist);
9046   add_cmd ("double", class_support, set_mipsfpu_double_command,
9047            _("Select double-precision MIPS floating-point coprocessor."),
9048            &mipsfpulist);
9049   add_alias_cmd ("on", "double", class_support, 1, &mipsfpulist);
9050   add_alias_cmd ("yes", "double", class_support, 1, &mipsfpulist);
9051   add_alias_cmd ("1", "double", class_support, 1, &mipsfpulist);
9052   add_cmd ("none", class_support, set_mipsfpu_none_command,
9053            _("Select no MIPS floating-point coprocessor."), &mipsfpulist);
9054   add_alias_cmd ("off", "none", class_support, 1, &mipsfpulist);
9055   add_alias_cmd ("no", "none", class_support, 1, &mipsfpulist);
9056   add_alias_cmd ("0", "none", class_support, 1, &mipsfpulist);
9057   add_cmd ("auto", class_support, set_mipsfpu_auto_command,
9058            _("Select MIPS floating-point coprocessor automatically."),
9059            &mipsfpulist);
9060   add_cmd ("mipsfpu", class_support, show_mipsfpu_command,
9061            _("Show current use of MIPS floating-point coprocessor target."),
9062            &showlist);
9063
9064   /* We really would like to have both "0" and "unlimited" work, but
9065      command.c doesn't deal with that.  So make it a var_zinteger
9066      because the user can always use "999999" or some such for unlimited.  */
9067   add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
9068                             &heuristic_fence_post, _("\
9069 Set the distance searched for the start of a function."), _("\
9070 Show the distance searched for the start of a function."), _("\
9071 If you are debugging a stripped executable, GDB needs to search through the\n\
9072 program for the start of a function.  This command sets the distance of the\n\
9073 search.  The only need to set it is when debugging a stripped executable."),
9074                             reinit_frame_cache_sfunc,
9075                             NULL, /* FIXME: i18n: The distance searched for
9076                                      the start of a function is %s.  */
9077                             &setlist, &showlist);
9078
9079   /* Allow the user to control whether the upper bits of 64-bit
9080      addresses should be zeroed.  */
9081   add_setshow_auto_boolean_cmd ("mask-address", no_class,
9082                                 &mask_address_var, _("\
9083 Set zeroing of upper 32 bits of 64-bit addresses."), _("\
9084 Show zeroing of upper 32 bits of 64-bit addresses."), _("\
9085 Use \"on\" to enable the masking, \"off\" to disable it and \"auto\" to\n\
9086 allow GDB to determine the correct value."),
9087                                 NULL, show_mask_address,
9088                                 &setmipscmdlist, &showmipscmdlist);
9089
9090   /* Allow the user to control the size of 32 bit registers within the
9091      raw remote packet.  */
9092   add_setshow_boolean_cmd ("remote-mips64-transfers-32bit-regs", class_obscure,
9093                            &mips64_transfers_32bit_regs_p, _("\
9094 Set compatibility with 64-bit MIPS target that transfers 32-bit quantities."),
9095                            _("\
9096 Show compatibility with 64-bit MIPS target that transfers 32-bit quantities."),
9097                            _("\
9098 Use \"on\" to enable backward compatibility with older MIPS 64 GDB+target\n\
9099 that would transfer 32 bits for some registers (e.g. SR, FSR) and\n\
9100 64 bits for others.  Use \"off\" to disable compatibility mode"),
9101                            set_mips64_transfers_32bit_regs,
9102                            NULL, /* FIXME: i18n: Compatibility with 64-bit
9103                                     MIPS target that transfers 32-bit
9104                                     quantities is %s.  */
9105                            &setlist, &showlist);
9106
9107   /* Debug this files internals.  */
9108   add_setshow_zuinteger_cmd ("mips", class_maintenance,
9109                              &mips_debug, _("\
9110 Set mips debugging."), _("\
9111 Show mips debugging."), _("\
9112 When non-zero, mips specific debugging is enabled."),
9113                              NULL,
9114                              NULL, /* FIXME: i18n: Mips debugging is
9115                                       currently %s.  */
9116                              &setdebuglist, &showdebuglist);
9117 }