gdb/mips-tdep.c

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