gdb/mips-tdep.c

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