gdb/mips-tdep.c

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