gdb/mips-tdep.c

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