gdb/mips-tdep.c

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