gdb/mips-tdep.c

   1 /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
   2
   3    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   5
   6    Contributed by Alessandro Forin([email protected]) at CMU
   7    and by Per Bothner([email protected]) at U.Wisconsin.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place - Suite 330,
  24    Boston, MA 02111-1307, USA.  */
  25
  26 #include "defs.h"
  27 #include "gdb_string.h"
  28 #include "frame.h"
  29 #include "inferior.h"
  30 #include "symtab.h"
  31 #include "value.h"
  32 #include "gdbcmd.h"
  33 #include "language.h"
  34 #include "gdbcore.h"
  35 #include "symfile.h"
  36 #include "objfiles.h"
  37 #include "gdbtypes.h"
  38 #include "target.h"
  39 #include "arch-utils.h"
  40 #include "regcache.h"
  41 #include "osabi.h"
  42
  43 #include "opcode/mips.h"
  44 #include "elf/mips.h"
  45 #include "elf-bfd.h"
  46 #include "symcat.h"
  47
  48 /* A useful bit in the CP0 status register (PS_REGNUM).  */
  49 /* This bit is set if we are emulating 32-bit FPRs on a 64-bit chip.  */
  50 #define ST0_FR (1 << 26)
  51
  52 /* The sizes of floating point registers.  */
  53
  54 enum
  55 {
  56   MIPS_FPU_SINGLE_REGSIZE = 4,
  57   MIPS_FPU_DOUBLE_REGSIZE = 8
  58 };
  59
  60 /* All the possible MIPS ABIs. */
  61
  62 enum mips_abi
  63   {
  64     MIPS_ABI_UNKNOWN = 0,
  65     MIPS_ABI_N32,
  66     MIPS_ABI_O32,
  67     MIPS_ABI_N64,
  68     MIPS_ABI_O64,
  69     MIPS_ABI_EABI32,
  70     MIPS_ABI_EABI64,
  71     MIPS_ABI_LAST
  72   };
  73
  74 static const char *mips_abi_string;
  75
  76 static const char *mips_abi_strings[] = {
  77   "auto",
  78   "n32",
  79   "o32",
  80   "n64",
  81   "o64",
  82   "eabi32",
  83   "eabi64",
  84   NULL
  85 };
  86
  87 struct frame_extra_info
  88   {
  89     mips_extra_func_info_t proc_desc;
  90     int num_args;
  91   };
  92
  93 /* Various MIPS ISA options (related to stack analysis) can be
  94    overridden dynamically.  Establish an enum/array for managing
  95    them. */
  96
  97 static const char size_auto[] = "auto";
  98 static const char size_32[] = "32";
  99 static const char size_64[] = "64";
 100
 101 static const char *size_enums[] = {
 102   size_auto,
 103   size_32,
 104   size_64,
 105   0
 106 };
 107
 108 /* Some MIPS boards don't support floating point while others only
 109    support single-precision floating-point operations.  See also
 110    FP_REGISTER_DOUBLE. */
 111
 112 enum mips_fpu_type
 113   {
 114     MIPS_FPU_DOUBLE,            /* Full double precision floating point.  */
 115     MIPS_FPU_SINGLE,            /* Single precision floating point (R4650).  */
 116     MIPS_FPU_NONE               /* No floating point.  */
 117   };
 118
 119 #ifndef MIPS_DEFAULT_FPU_TYPE
 120 #define MIPS_DEFAULT_FPU_TYPE MIPS_FPU_DOUBLE
 121 #endif
 122 static int mips_fpu_type_auto = 1;
 123 static enum mips_fpu_type mips_fpu_type = MIPS_DEFAULT_FPU_TYPE;
 124
 125 static int mips_debug = 0;
 126
 127 /* MIPS specific per-architecture information */
 128 struct gdbarch_tdep
 129   {
 130     /* from the elf header */
 131     int elf_flags;
 132
 133     /* mips options */
 134     enum mips_abi mips_abi;
 135     enum mips_abi found_abi;
 136     enum mips_fpu_type mips_fpu_type;
 137     int mips_last_arg_regnum;
 138     int mips_last_fp_arg_regnum;
 139     int mips_default_saved_regsize;
 140     int mips_fp_register_double;
 141     int mips_default_stack_argsize;
 142     int gdb_target_is_mips64;
 143     int default_mask_address_p;
 144
 145     enum gdb_osabi osabi;
 146   };
 147
 148 #define MIPS_EABI (gdbarch_tdep (current_gdbarch)->mips_abi == MIPS_ABI_EABI32 \
 149                    || gdbarch_tdep (current_gdbarch)->mips_abi == MIPS_ABI_EABI64)
 150
 151 #define MIPS_LAST_FP_ARG_REGNUM (gdbarch_tdep (current_gdbarch)->mips_last_fp_arg_regnum)
 152
 153 #define MIPS_LAST_ARG_REGNUM (gdbarch_tdep (current_gdbarch)->mips_last_arg_regnum)
 154
 155 #define MIPS_FPU_TYPE (gdbarch_tdep (current_gdbarch)->mips_fpu_type)
 156
 157 /* Return the currently configured (or set) saved register size. */
 158
 159 #define MIPS_DEFAULT_SAVED_REGSIZE (gdbarch_tdep (current_gdbarch)->mips_default_saved_regsize)
 160
 161 static const char *mips_saved_regsize_string = size_auto;
 162
 163 #define MIPS_SAVED_REGSIZE (mips_saved_regsize())
 164
 165 static unsigned int
 166 mips_saved_regsize (void)
 167 {
 168   if (mips_saved_regsize_string == size_auto)
 169     return MIPS_DEFAULT_SAVED_REGSIZE;
 170   else if (mips_saved_regsize_string == size_64)
 171     return 8;
 172   else /* if (mips_saved_regsize_string == size_32) */
 173     return 4;
 174 }
 175
 176 /* Functions for setting and testing a bit in a minimal symbol that
 177    marks it as 16-bit function.  The MSB of the minimal symbol's
 178    "info" field is used for this purpose. This field is already
 179    being used to store the symbol size, so the assumption is
 180    that the symbol size cannot exceed 2^31.
 181
 182    ELF_MAKE_MSYMBOL_SPECIAL tests whether an ELF symbol is "special",
 183    i.e. refers to a 16-bit function, and sets a "special" bit in a
 184    minimal symbol to mark it as a 16-bit function
 185
 186    MSYMBOL_IS_SPECIAL   tests the "special" bit in a minimal symbol
 187    MSYMBOL_SIZE         returns the size of the minimal symbol, i.e.
 188    the "info" field with the "special" bit masked out */
 189
 190 static void
 191 mips_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 192 {
 193   if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_MIPS16)
 194     {
 195       MSYMBOL_INFO (msym) = (char *)
 196         (((long) MSYMBOL_INFO (msym)) | 0x80000000);
 197       SYMBOL_VALUE_ADDRESS (msym) |= 1;
 198     }
 199 }
 200
 201 static int
 202 msymbol_is_special (struct minimal_symbol *msym)
 203 {
 204   return (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0);
 205 }
 206
 207 static long
 208 msymbol_size (struct minimal_symbol *msym)
 209 {
 210   return ((long) MSYMBOL_INFO (msym) & 0x7fffffff);
 211 }
 212
 213 /* XFER a value from the big/little/left end of the register.
 214    Depending on the size of the value it might occupy the entire
 215    register or just part of it.  Make an allowance for this, aligning
 216    things accordingly.  */
 217
 218 static void
 219 mips_xfer_register (struct regcache *regcache, int reg_num, int length,
 220                     enum bfd_endian endian, bfd_byte *in, const bfd_byte *out,
 221                     int buf_offset)
 222 {
 223   bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
 224   int reg_offset = 0;
 225   /* Need to transfer the left or right part of the register, based on
 226      the targets byte order.  */
 227   switch (endian)
 228     {
 229     case BFD_ENDIAN_BIG:
 230       reg_offset = REGISTER_RAW_SIZE (reg_num) - length;
 231       break;
 232     case BFD_ENDIAN_LITTLE:
 233       reg_offset = 0;
 234       break;
 235     case BFD_ENDIAN_UNKNOWN: /* Indicates no alignment.  */
 236       reg_offset = 0;
 237       break;
 238     default:
 239       internal_error (__FILE__, __LINE__, "bad switch");
 240     }
 241   if (mips_debug)
 242     fprintf_unfiltered (gdb_stderr,
 243                         "xfer $%d, reg offset %d, buf offset %d, length %d, ",
 244                         reg_num, reg_offset, buf_offset, length);
 245   if (mips_debug && out != NULL)
 246     {
 247       int i;
 248       fprintf_unfiltered (gdb_stdlog, "out ");
 249       for (i = 0; i < length; i++)
 250         fprintf_unfiltered (gdb_stdlog, "%02x", out[buf_offset + i]);
 251     }
 252   if (in != NULL)
 253     regcache_raw_read_part (regcache, reg_num, reg_offset, length, in + buf_offset);
 254   if (out != NULL)
 255     regcache_raw_write_part (regcache, reg_num, reg_offset, length, out + buf_offset);
 256   if (mips_debug && in != NULL)
 257     {
 258       int i;
 259       fprintf_unfiltered (gdb_stdlog, "in ");
 260       for (i = 0; i < length; i++)
 261         fprintf_unfiltered (gdb_stdlog, "%02x", in[buf_offset + i]);
 262     }
 263   if (mips_debug)
 264     fprintf_unfiltered (gdb_stdlog, "\n");
 265 }
 266
 267 /* Determine if a MIPS3 or later cpu is operating in MIPS{1,2} FPU
 268    compatiblity mode.  A return value of 1 means that we have
 269    physical 64-bit registers, but should treat them as 32-bit registers.  */
 270
 271 static int
 272 mips2_fp_compat (void)
 273 {
 274   /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
 275      meaningful.  */
 276   if (REGISTER_RAW_SIZE (FP0_REGNUM) == 4)
 277     return 0;
 278
 279 #if 0
 280   /* FIXME drow 2002-03-10: This is disabled until we can do it consistently,
 281      in all the places we deal with FP registers.  PR gdb/413.  */
 282   /* Otherwise check the FR bit in the status register - it controls
 283      the FP compatiblity mode.  If it is clear we are in compatibility
 284      mode.  */
 285   if ((read_register (PS_REGNUM) & ST0_FR) == 0)
 286     return 1;
 287 #endif
 288
 289   return 0;
 290 }
 291
 292 /* Indicate that the ABI makes use of double-precision registers
 293    provided by the FPU (rather than combining pairs of registers to
 294    form double-precision values).  Do not use "TARGET_IS_MIPS64" to
 295    determine if the ABI is using double-precision registers.  See also
 296    MIPS_FPU_TYPE. */
 297 #define FP_REGISTER_DOUBLE (gdbarch_tdep (current_gdbarch)->mips_fp_register_double)
 298
 299 /* The amount of space reserved on the stack for registers. This is
 300    different to MIPS_SAVED_REGSIZE as it determines the alignment of
 301    data allocated after the registers have run out. */
 302
 303 #define MIPS_DEFAULT_STACK_ARGSIZE (gdbarch_tdep (current_gdbarch)->mips_default_stack_argsize)
 304
 305 #define MIPS_STACK_ARGSIZE (mips_stack_argsize ())
 306
 307 static const char *mips_stack_argsize_string = size_auto;
 308
 309 static unsigned int
 310 mips_stack_argsize (void)
 311 {
 312   if (mips_stack_argsize_string == size_auto)
 313     return MIPS_DEFAULT_STACK_ARGSIZE;
 314   else if (mips_stack_argsize_string == size_64)
 315     return 8;
 316   else /* if (mips_stack_argsize_string == size_32) */
 317     return 4;
 318 }
 319
 320 #define GDB_TARGET_IS_MIPS64 (gdbarch_tdep (current_gdbarch)->gdb_target_is_mips64 + 0)
 321
 322 #define MIPS_DEFAULT_MASK_ADDRESS_P (gdbarch_tdep (current_gdbarch)->default_mask_address_p)
 323
 324 #define VM_MIN_ADDRESS (CORE_ADDR)0x400000
 325
 326 int gdb_print_insn_mips (bfd_vma, disassemble_info *);
 327
 328 static void mips_print_register (int, int);
 329
 330 static mips_extra_func_info_t
 331 heuristic_proc_desc (CORE_ADDR, CORE_ADDR, struct frame_info *, int);
 332
 333 static CORE_ADDR heuristic_proc_start (CORE_ADDR);
 334
 335 static CORE_ADDR read_next_frame_reg (struct frame_info *, int);
 336
 337 static int mips_set_processor_type (char *);
 338
 339 static void mips_show_processor_type_command (char *, int);
 340
 341 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element *);
 342
 343 static mips_extra_func_info_t
 344 find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame, int cur_frame);
 345
 346 static CORE_ADDR after_prologue (CORE_ADDR pc,
 347                                  mips_extra_func_info_t proc_desc);
 348
 349 static void mips_read_fp_register_single (int regno, char *rare_buffer);
 350 static void mips_read_fp_register_double (int regno, char *rare_buffer);
 351
 352 static struct type *mips_float_register_type (void);
 353 static struct type *mips_double_register_type (void);
 354
 355 /* This value is the model of MIPS in use.  It is derived from the value
 356    of the PrID register.  */
 357
 358 char *mips_processor_type;
 359
 360 char *tmp_mips_processor_type;
 361
 362 /* The list of available "set mips " and "show mips " commands */
 363
 364 static struct cmd_list_element *setmipscmdlist = NULL;
 365 static struct cmd_list_element *showmipscmdlist = NULL;
 366
 367 /* A set of original names, to be used when restoring back to generic
 368    registers from a specific set.  */
 369
 370 char *mips_generic_reg_names[] = MIPS_REGISTER_NAMES;
 371 char **mips_processor_reg_names = mips_generic_reg_names;
 372
 373 static const char *
 374 mips_register_name (int i)
 375 {
 376   return mips_processor_reg_names[i];
 377 }
 378 /* *INDENT-OFF* */
 379 /* Names of IDT R3041 registers.  */
 380
 381 char *mips_r3041_reg_names[] = {
 382         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 383         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 384         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 385         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 386         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 387         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 388         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 389         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 390         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 391         "fsr",  "fir",  "",/*"fp"*/     "",
 392         "",     "",     "bus",  "ccfg", "",     "",     "",     "",
 393         "",     "",     "port", "cmp",  "",     "",     "epc",  "prid",
 394 };
 395
 396 /* Names of IDT R3051 registers.  */
 397
 398 char *mips_r3051_reg_names[] = {
 399         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 400         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 401         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 402         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 403         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 404         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 405         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 406         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 407         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 408         "fsr",  "fir",  ""/*"fp"*/,     "",
 409         "inx",  "rand", "elo",  "",     "ctxt", "",     "",     "",
 410         "",     "",     "ehi",  "",     "",     "",     "epc",  "prid",
 411 };
 412
 413 /* Names of IDT R3081 registers.  */
 414
 415 char *mips_r3081_reg_names[] = {
 416         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 417         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 418         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 419         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 420         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 421         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 422         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 423         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 424         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 425         "fsr",  "fir",  ""/*"fp"*/,     "",
 426         "inx",  "rand", "elo",  "cfg",  "ctxt", "",     "",     "",
 427         "",     "",     "ehi",  "",     "",     "",     "epc",  "prid",
 428 };
 429
 430 /* Names of LSI 33k registers.  */
 431
 432 char *mips_lsi33k_reg_names[] = {
 433         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 434         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 435         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 436         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 437         "epc",  "hi",   "lo",   "sr",   "cause","badvaddr",
 438         "dcic", "bpc",  "bda",  "",     "",     "",     "",      "",
 439         "",     "",     "",     "",     "",     "",     "",      "",
 440         "",     "",     "",     "",     "",     "",     "",      "",
 441         "",     "",     "",     "",     "",     "",     "",      "",
 442         "",     "",     "",     "",
 443         "",     "",     "",     "",     "",     "",     "",      "",
 444         "",     "",     "",     "",     "",     "",     "",      "",
 445 };
 446
 447 struct {
 448   char *name;
 449   char **regnames;
 450 } mips_processor_type_table[] = {
 451   { "generic", mips_generic_reg_names },
 452   { "r3041", mips_r3041_reg_names },
 453   { "r3051", mips_r3051_reg_names },
 454   { "r3071", mips_r3081_reg_names },
 455   { "r3081", mips_r3081_reg_names },
 456   { "lsi33k", mips_lsi33k_reg_names },
 457   { NULL, NULL }
 458 };
 459 /* *INDENT-ON* */
 460
 461
 462
 463
 464 /* Table to translate MIPS16 register field to actual register number.  */
 465 static int mips16_to_32_reg[8] =
 466 {16, 17, 2, 3, 4, 5, 6, 7};
 467
 468 /* Heuristic_proc_start may hunt through the text section for a long
 469    time across a 2400 baud serial line.  Allows the user to limit this
 470    search.  */
 471
 472 static unsigned int heuristic_fence_post = 0;
 473
 474 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)   /* least address */
 475 #define PROC_HIGH_ADDR(proc) ((proc)->high_addr)        /* upper address bound */
 476 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
 477 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
 478 #define PROC_FRAME_ADJUST(proc)  ((proc)->frame_adjust)
 479 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
 480 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
 481 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
 482 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
 483 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
 484 /* FIXME drow/2002-06-10: If a pointer on the host is bigger than a long,
 485    this will corrupt pdr.iline.  Fortunately we don't use it.  */
 486 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
 487 #define _PROC_MAGIC_ 0x0F0F0F0F
 488 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
 489 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
 490
 491 struct linked_proc_info
 492   {
 493     struct mips_extra_func_info info;
 494     struct linked_proc_info *next;
 495   }
 496  *linked_proc_desc_table = NULL;
 497
 498 void
 499 mips_print_extra_frame_info (struct frame_info *fi)
 500 {
 501   if (fi
 502       && fi->extra_info
 503       && fi->extra_info->proc_desc
 504       && fi->extra_info->proc_desc->pdr.framereg < NUM_REGS)
 505     printf_filtered (" frame pointer is at %s+%s\n",
 506                      REGISTER_NAME (fi->extra_info->proc_desc->pdr.framereg),
 507                      paddr_d (fi->extra_info->proc_desc->pdr.frameoffset));
 508 }
 509
 510 /* Number of bytes of storage in the actual machine representation for
 511    register N.  NOTE: This indirectly defines the register size
 512    transfered by the GDB protocol. */
 513
 514 static int mips64_transfers_32bit_regs_p = 0;
 515
 516 static int
 517 mips_register_raw_size (int reg_nr)
 518 {
 519   if (mips64_transfers_32bit_regs_p)
 520     return REGISTER_VIRTUAL_SIZE (reg_nr);
 521   else if (reg_nr >= FP0_REGNUM && reg_nr < FP0_REGNUM + 32
 522            && FP_REGISTER_DOUBLE)
 523     /* For MIPS_ABI_N32 (for example) we need 8 byte floating point
 524        registers.  */
 525     return 8;
 526   else
 527     return MIPS_REGSIZE;
 528 }
 529
 530 /* Convert between RAW and VIRTUAL registers.  The RAW register size
 531    defines the remote-gdb packet. */
 532
 533 static int
 534 mips_register_convertible (int reg_nr)
 535 {
 536   if (mips64_transfers_32bit_regs_p)
 537     return 0;
 538   else
 539     return (REGISTER_RAW_SIZE (reg_nr) > REGISTER_VIRTUAL_SIZE (reg_nr));
 540 }
 541
 542 static void
 543 mips_register_convert_to_virtual (int n, struct type *virtual_type,
 544                                   char *raw_buf, char *virt_buf)
 545 {
 546   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 547     memcpy (virt_buf,
 548             raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 549             TYPE_LENGTH (virtual_type));
 550   else
 551     memcpy (virt_buf,
 552             raw_buf,
 553             TYPE_LENGTH (virtual_type));
 554 }
 555
 556 static void
 557 mips_register_convert_to_raw (struct type *virtual_type, int n,
 558                               char *virt_buf, char *raw_buf)
 559 {
 560   memset (raw_buf, 0, REGISTER_RAW_SIZE (n));
 561   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 562     memcpy (raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 563             virt_buf,
 564             TYPE_LENGTH (virtual_type));
 565   else
 566     memcpy (raw_buf,
 567             virt_buf,
 568             TYPE_LENGTH (virtual_type));
 569 }
 570
 571 void
 572 mips_register_convert_to_type (int regnum, struct type *type, char *buffer)
 573 {
 574   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 575       && REGISTER_RAW_SIZE (regnum) == 4
 576       && (regnum) >= FP0_REGNUM && (regnum) < FP0_REGNUM + 32
 577       && TYPE_CODE(type) == TYPE_CODE_FLT
 578       && TYPE_LENGTH(type) == 8)
 579     {
 580       char temp[4];
 581       memcpy (temp, ((char *)(buffer))+4, 4);
 582       memcpy (((char *)(buffer))+4, (buffer), 4);
 583       memcpy (((char *)(buffer)), temp, 4);
 584     }
 585 }
 586
 587 void
 588 mips_register_convert_from_type (int regnum, struct type *type, char *buffer)
 589 {
 590 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 591     && REGISTER_RAW_SIZE (regnum) == 4
 592     && (regnum) >= FP0_REGNUM && (regnum) < FP0_REGNUM + 32
 593     && TYPE_CODE(type) == TYPE_CODE_FLT
 594     && TYPE_LENGTH(type) == 8)
 595   {
 596     char temp[4];
 597     memcpy (temp, ((char *)(buffer))+4, 4);
 598     memcpy (((char *)(buffer))+4, (buffer), 4);
 599     memcpy (((char *)(buffer)), temp, 4);
 600   }
 601 }
 602
 603 /* Return the GDB type object for the "standard" data type
 604    of data in register REG.
 605
 606    Note: kevinb/2002-08-01: The definition below should faithfully
 607    reproduce the behavior of each of the REGISTER_VIRTUAL_TYPE
 608    definitions found in config/mips/tm-*.h.  I'm concerned about
 609    the ``FCRCS_REGNUM <= reg && reg <= LAST_EMBED_REGNUM'' clause
 610    though.  In some cases FP_REGNUM is in this range, and I doubt
 611    that this code is correct for the 64-bit case.  */
 612
 613 static struct type *
 614 mips_register_virtual_type (int reg)
 615 {
 616   if (FP0_REGNUM <= reg && reg < FP0_REGNUM + 32)
 617     {
 618       /* Floating point registers...  */
 619       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 620         return builtin_type_ieee_double_big;
 621       else
 622         return builtin_type_ieee_double_little;
 623     }
 624   else if (reg == PS_REGNUM /* CR */)
 625     return builtin_type_uint32;
 626   else if (FCRCS_REGNUM <= reg && reg <= LAST_EMBED_REGNUM)
 627     return builtin_type_uint32;
 628   else
 629     {
 630       /* Everything else...
 631          Return type appropriate for width of register.  */
 632       if (MIPS_REGSIZE == TYPE_LENGTH (builtin_type_uint64))
 633         return builtin_type_uint64;
 634       else
 635         return builtin_type_uint32;
 636     }
 637 }
 638
 639 /* TARGET_READ_SP -- Remove useless bits from the stack pointer.  */
 640
 641 static CORE_ADDR
 642 mips_read_sp (void)
 643 {
 644   return ADDR_BITS_REMOVE (read_register (SP_REGNUM));
 645 }
 646
 647 /* Should the upper word of 64-bit addresses be zeroed? */
 648 enum auto_boolean mask_address_var = AUTO_BOOLEAN_AUTO;
 649
 650 static int
 651 mips_mask_address_p (void)
 652 {
 653   switch (mask_address_var)
 654     {
 655     case AUTO_BOOLEAN_TRUE:
 656       return 1;
 657     case AUTO_BOOLEAN_FALSE:
 658       return 0;
 659       break;
 660     case AUTO_BOOLEAN_AUTO:
 661       return MIPS_DEFAULT_MASK_ADDRESS_P;
 662     default:
 663       internal_error (__FILE__, __LINE__,
 664                       "mips_mask_address_p: bad switch");
 665       return -1;
 666     }
 667 }
 668
 669 static void
 670 show_mask_address (char *cmd, int from_tty, struct cmd_list_element *c)
 671 {
 672   switch (mask_address_var)
 673     {
 674     case AUTO_BOOLEAN_TRUE:
 675       printf_filtered ("The 32 bit mips address mask is enabled\n");
 676       break;
 677     case AUTO_BOOLEAN_FALSE:
 678       printf_filtered ("The 32 bit mips address mask is disabled\n");
 679       break;
 680     case AUTO_BOOLEAN_AUTO:
 681       printf_filtered ("The 32 bit address mask is set automatically.  Currently %s\n",
 682                        mips_mask_address_p () ? "enabled" : "disabled");
 683       break;
 684     default:
 685       internal_error (__FILE__, __LINE__,
 686                       "show_mask_address: bad switch");
 687       break;
 688     }
 689 }
 690
 691 /* Should call_function allocate stack space for a struct return?  */
 692
 693 static int
 694 mips_eabi_use_struct_convention (int gcc_p, struct type *type)
 695 {
 696   return (TYPE_LENGTH (type) > 2 * MIPS_SAVED_REGSIZE);
 697 }
 698
 699 static int
 700 mips_n32n64_use_struct_convention (int gcc_p, struct type *type)
 701 {
 702   return (TYPE_LENGTH (type) > 2 * MIPS_SAVED_REGSIZE);
 703 }
 704
 705 static int
 706 mips_o32_use_struct_convention (int gcc_p, struct type *type)
 707 {
 708   return 1;     /* Structures are returned by ref in extra arg0.  */
 709 }
 710
 711 /* Should call_function pass struct by reference?
 712    For each architecture, structs are passed either by
 713    value or by reference, depending on their size.  */
 714
 715 static int
 716 mips_eabi_reg_struct_has_addr (int gcc_p, struct type *type)
 717 {
 718   enum type_code typecode = TYPE_CODE (check_typedef (type));
 719   int len = TYPE_LENGTH (check_typedef (type));
 720
 721   if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
 722     return (len > MIPS_SAVED_REGSIZE);
 723
 724   return 0;
 725 }
 726
 727 static int
 728 mips_n32n64_reg_struct_has_addr (int gcc_p, struct type *type)
 729 {
 730   return 0;     /* Assumption: N32/N64 never passes struct by ref.  */
 731 }
 732
 733 static int
 734 mips_o32_reg_struct_has_addr (int gcc_p, struct type *type)
 735 {
 736   return 0;     /* Assumption: O32/O64 never passes struct by ref.  */
 737 }
 738
 739 /* Tell if the program counter value in MEMADDR is in a MIPS16 function.  */
 740
 741 static int
 742 pc_is_mips16 (bfd_vma memaddr)
 743 {
 744   struct minimal_symbol *sym;
 745
 746   /* If bit 0 of the address is set, assume this is a MIPS16 address. */
 747   if (IS_MIPS16_ADDR (memaddr))
 748     return 1;
 749
 750   /* A flag indicating that this is a MIPS16 function is stored by elfread.c in
 751      the high bit of the info field.  Use this to decide if the function is
 752      MIPS16 or normal MIPS.  */
 753   sym = lookup_minimal_symbol_by_pc (memaddr);
 754   if (sym)
 755     return msymbol_is_special (sym);
 756   else
 757     return 0;
 758 }
 759
 760 /* MIPS believes that the PC has a sign extended value.  Perhaphs the
 761    all registers should be sign extended for simplicity? */
 762
 763 static CORE_ADDR
 764 mips_read_pc (ptid_t ptid)
 765 {
 766   return read_signed_register_pid (PC_REGNUM, ptid);
 767 }
 768
 769 /* This returns the PC of the first inst after the prologue.  If we can't
 770    find the prologue, then return 0.  */
 771
 772 static CORE_ADDR
 773 after_prologue (CORE_ADDR pc,
 774                 mips_extra_func_info_t proc_desc)
 775 {
 776   struct symtab_and_line sal;
 777   CORE_ADDR func_addr, func_end;
 778
 779   /* Pass cur_frame == 0 to find_proc_desc.  We should not attempt
 780      to read the stack pointer from the current machine state, because
 781      the current machine state has nothing to do with the information
 782      we need from the proc_desc; and the process may or may not exist
 783      right now.  */
 784   if (!proc_desc)
 785     proc_desc = find_proc_desc (pc, NULL, 0);
 786
 787   if (proc_desc)
 788     {
 789       /* If function is frameless, then we need to do it the hard way.  I
 790          strongly suspect that frameless always means prologueless... */
 791       if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
 792           && PROC_FRAME_OFFSET (proc_desc) == 0)
 793         return 0;
 794     }
 795
 796   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 797     return 0;                   /* Unknown */
 798
 799   sal = find_pc_line (func_addr, 0);
 800
 801   if (sal.end < func_end)
 802     return sal.end;
 803
 804   /* The line after the prologue is after the end of the function.  In this
 805      case, tell the caller to find the prologue the hard way.  */
 806
 807   return 0;
 808 }
 809
 810 /* Decode a MIPS32 instruction that saves a register in the stack, and
 811    set the appropriate bit in the general register mask or float register mask
 812    to indicate which register is saved.  This is a helper function
 813    for mips_find_saved_regs.  */
 814
 815 static void
 816 mips32_decode_reg_save (t_inst inst, unsigned long *gen_mask,
 817                         unsigned long *float_mask)
 818 {
 819   int reg;
 820
 821   if ((inst & 0xffe00000) == 0xafa00000         /* sw reg,n($sp) */
 822       || (inst & 0xffe00000) == 0xafc00000      /* sw reg,n($r30) */
 823       || (inst & 0xffe00000) == 0xffa00000)     /* sd reg,n($sp) */
 824     {
 825       /* It might be possible to use the instruction to
 826          find the offset, rather than the code below which
 827          is based on things being in a certain order in the
 828          frame, but figuring out what the instruction's offset
 829          is relative to might be a little tricky.  */
 830       reg = (inst & 0x001f0000) >> 16;
 831       *gen_mask |= (1 << reg);
 832     }
 833   else if ((inst & 0xffe00000) == 0xe7a00000    /* swc1 freg,n($sp) */
 834            || (inst & 0xffe00000) == 0xe7c00000         /* swc1 freg,n($r30) */
 835            || (inst & 0xffe00000) == 0xf7a00000)        /* sdc1 freg,n($sp) */
 836
 837     {
 838       reg = ((inst & 0x001f0000) >> 16);
 839       *float_mask |= (1 << reg);
 840     }
 841 }
 842
 843 /* Decode a MIPS16 instruction that saves a register in the stack, and
 844    set the appropriate bit in the general register or float register mask
 845    to indicate which register is saved.  This is a helper function
 846    for mips_find_saved_regs.  */
 847
 848 static void
 849 mips16_decode_reg_save (t_inst inst, unsigned long *gen_mask)
 850 {
 851   if ((inst & 0xf800) == 0xd000)        /* sw reg,n($sp) */
 852     {
 853       int reg = mips16_to_32_reg[(inst & 0x700) >> 8];
 854       *gen_mask |= (1 << reg);
 855     }
 856   else if ((inst & 0xff00) == 0xf900)   /* sd reg,n($sp) */
 857     {
 858       int reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
 859       *gen_mask |= (1 << reg);
 860     }
 861   else if ((inst & 0xff00) == 0x6200    /* sw $ra,n($sp) */
 862            || (inst & 0xff00) == 0xfa00)        /* sd $ra,n($sp) */
 863     *gen_mask |= (1 << RA_REGNUM);
 864 }
 865
 866
 867 /* Fetch and return instruction from the specified location.  If the PC
 868    is odd, assume it's a MIPS16 instruction; otherwise MIPS32.  */
 869
 870 static t_inst
 871 mips_fetch_instruction (CORE_ADDR addr)
 872 {
 873   char buf[MIPS_INSTLEN];
 874   int instlen;
 875   int status;
 876
 877   if (pc_is_mips16 (addr))
 878     {
 879       instlen = MIPS16_INSTLEN;
 880       addr = UNMAKE_MIPS16_ADDR (addr);
 881     }
 882   else
 883     instlen = MIPS_INSTLEN;
 884   status = read_memory_nobpt (addr, buf, instlen);
 885   if (status)
 886     memory_error (status, addr);
 887   return extract_unsigned_integer (buf, instlen);
 888 }
 889
 890
 891 /* These the fields of 32 bit mips instructions */
 892 #define mips32_op(x) (x >> 26)
 893 #define itype_op(x) (x >> 26)
 894 #define itype_rs(x) ((x >> 21) & 0x1f)
 895 #define itype_rt(x) ((x >> 16) & 0x1f)
 896 #define itype_immediate(x) (x & 0xffff)
 897
 898 #define jtype_op(x) (x >> 26)
 899 #define jtype_target(x) (x & 0x03ffffff)
 900
 901 #define rtype_op(x) (x >> 26)
 902 #define rtype_rs(x) ((x >> 21) & 0x1f)
 903 #define rtype_rt(x) ((x >> 16) & 0x1f)
 904 #define rtype_rd(x) ((x >> 11) & 0x1f)
 905 #define rtype_shamt(x) ((x >> 6) & 0x1f)
 906 #define rtype_funct(x) (x & 0x3f)
 907
 908 static CORE_ADDR
 909 mips32_relative_offset (unsigned long inst)
 910 {
 911   long x;
 912   x = itype_immediate (inst);
 913   if (x & 0x8000)               /* sign bit set */
 914     {
 915       x |= 0xffff0000;          /* sign extension */
 916     }
 917   x = x << 2;
 918   return x;
 919 }
 920
 921 /* Determine whate to set a single step breakpoint while considering
 922    branch prediction */
 923 static CORE_ADDR
 924 mips32_next_pc (CORE_ADDR pc)
 925 {
 926   unsigned long inst;
 927   int op;
 928   inst = mips_fetch_instruction (pc);
 929   if ((inst & 0xe0000000) != 0) /* Not a special, jump or branch instruction */
 930     {
 931       if (itype_op (inst) >> 2 == 5)
 932                                 /* BEQL, BNEL, BLEZL, BGTZL: bits 0101xx */
 933         {
 934           op = (itype_op (inst) & 0x03);
 935           switch (op)
 936             {
 937             case 0:             /* BEQL */
 938               goto equal_branch;
 939             case 1:             /* BNEL */
 940               goto neq_branch;
 941             case 2:             /* BLEZL */
 942               goto less_branch;
 943             case 3:             /* BGTZ */
 944               goto greater_branch;
 945             default:
 946               pc += 4;
 947             }
 948         }
 949       else if (itype_op (inst) == 17 && itype_rs (inst) == 8)
 950                                 /* BC1F, BC1FL, BC1T, BC1TL: 010001 01000 */
 951         {
 952           int tf = itype_rt (inst) & 0x01;
 953           int cnum = itype_rt (inst) >> 2;
 954           int fcrcs = read_signed_register (FCRCS_REGNUM);
 955           int cond = ((fcrcs >> 24) & 0x0e) | ((fcrcs >> 23) & 0x01);
 956
 957           if (((cond >> cnum) & 0x01) == tf)
 958             pc += mips32_relative_offset (inst) + 4;
 959           else
 960             pc += 8;
 961         }
 962       else
 963         pc += 4;                /* Not a branch, next instruction is easy */
 964     }
 965   else
 966     {                           /* This gets way messy */
 967
 968       /* Further subdivide into SPECIAL, REGIMM and other */
 969       switch (op = itype_op (inst) & 0x07)      /* extract bits 28,27,26 */
 970         {
 971         case 0:         /* SPECIAL */
 972           op = rtype_funct (inst);
 973           switch (op)
 974             {
 975             case 8:             /* JR */
 976             case 9:             /* JALR */
 977               /* Set PC to that address */
 978               pc = read_signed_register (rtype_rs (inst));
 979               break;
 980             default:
 981               pc += 4;
 982             }
 983
 984           break;        /* end SPECIAL */
 985         case 1:         /* REGIMM */
 986           {
 987             op = itype_rt (inst);       /* branch condition */
 988             switch (op)
 989               {
 990               case 0:           /* BLTZ */
 991               case 2:           /* BLTZL */
 992               case 16:          /* BLTZAL */
 993               case 18:          /* BLTZALL */
 994               less_branch:
 995                 if (read_signed_register (itype_rs (inst)) < 0)
 996                   pc += mips32_relative_offset (inst) + 4;
 997                 else
 998                   pc += 8;      /* after the delay slot */
 999                 break;
1000               case 1:           /* BGEZ */
1001               case 3:           /* BGEZL */
1002               case 17:          /* BGEZAL */
1003               case 19:          /* BGEZALL */
1004               greater_equal_branch:
1005                 if (read_signed_register (itype_rs (inst)) >= 0)
1006                   pc += mips32_relative_offset (inst) + 4;
1007                 else
1008                   pc += 8;      /* after the delay slot */
1009                 break;
1010                 /* All of the other instructions in the REGIMM category */
1011               default:
1012                 pc += 4;
1013               }
1014           }
1015           break;        /* end REGIMM */
1016         case 2:         /* J */
1017         case 3:         /* JAL */
1018           {
1019             unsigned long reg;
1020             reg = jtype_target (inst) << 2;
1021             /* Upper four bits get never changed... */
1022             pc = reg + ((pc + 4) & 0xf0000000);
1023           }
1024           break;
1025           /* FIXME case JALX : */
1026           {
1027             unsigned long reg;
1028             reg = jtype_target (inst) << 2;
1029             pc = reg + ((pc + 4) & 0xf0000000) + 1;     /* yes, +1 */
1030             /* Add 1 to indicate 16 bit mode - Invert ISA mode */
1031           }
1032           break;                /* The new PC will be alternate mode */
1033         case 4:         /* BEQ, BEQL */
1034         equal_branch:
1035           if (read_signed_register (itype_rs (inst)) ==
1036               read_signed_register (itype_rt (inst)))
1037             pc += mips32_relative_offset (inst) + 4;
1038           else
1039             pc += 8;
1040           break;
1041         case 5:         /* BNE, BNEL */
1042         neq_branch:
1043           if (read_signed_register (itype_rs (inst)) !=
1044               read_signed_register (itype_rt (inst)))
1045             pc += mips32_relative_offset (inst) + 4;
1046           else
1047             pc += 8;
1048           break;
1049         case 6:         /* BLEZ, BLEZL */
1050         less_zero_branch:
1051           if (read_signed_register (itype_rs (inst) <= 0))
1052             pc += mips32_relative_offset (inst) + 4;
1053           else
1054             pc += 8;
1055           break;
1056         case 7:
1057         default:
1058         greater_branch: /* BGTZ, BGTZL */
1059           if (read_signed_register (itype_rs (inst) > 0))
1060             pc += mips32_relative_offset (inst) + 4;
1061           else
1062             pc += 8;
1063           break;
1064         }                       /* switch */
1065     }                           /* else */
1066   return pc;
1067 }                               /* mips32_next_pc */
1068
1069 /* Decoding the next place to set a breakpoint is irregular for the
1070    mips 16 variant, but fortunately, there fewer instructions. We have to cope
1071    ith extensions for 16 bit instructions and a pair of actual 32 bit instructions.
1072    We dont want to set a single step instruction on the extend instruction
1073    either.
1074  */
1075
1076 /* Lots of mips16 instruction formats */
1077 /* Predicting jumps requires itype,ritype,i8type
1078    and their extensions      extItype,extritype,extI8type
1079  */
1080 enum mips16_inst_fmts
1081 {
1082   itype,                        /* 0  immediate 5,10 */
1083   ritype,                       /* 1   5,3,8 */
1084   rrtype,                       /* 2   5,3,3,5 */
1085   rritype,                      /* 3   5,3,3,5 */
1086   rrrtype,                      /* 4   5,3,3,3,2 */
1087   rriatype,                     /* 5   5,3,3,1,4 */
1088   shifttype,                    /* 6   5,3,3,3,2 */
1089   i8type,                       /* 7   5,3,8 */
1090   i8movtype,                    /* 8   5,3,3,5 */
1091   i8mov32rtype,                 /* 9   5,3,5,3 */
1092   i64type,                      /* 10  5,3,8 */
1093   ri64type,                     /* 11  5,3,3,5 */
1094   jalxtype,                     /* 12  5,1,5,5,16 - a 32 bit instruction */
1095   exiItype,                     /* 13  5,6,5,5,1,1,1,1,1,1,5 */
1096   extRitype,                    /* 14  5,6,5,5,3,1,1,1,5 */
1097   extRRItype,                   /* 15  5,5,5,5,3,3,5 */
1098   extRRIAtype,                  /* 16  5,7,4,5,3,3,1,4 */
1099   EXTshifttype,                 /* 17  5,5,1,1,1,1,1,1,5,3,3,1,1,1,2 */
1100   extI8type,                    /* 18  5,6,5,5,3,1,1,1,5 */
1101   extI64type,                   /* 19  5,6,5,5,3,1,1,1,5 */
1102   extRi64type,                  /* 20  5,6,5,5,3,3,5 */
1103   extshift64type                /* 21  5,5,1,1,1,1,1,1,5,1,1,1,3,5 */
1104 };
1105 /* I am heaping all the fields of the formats into one structure and
1106    then, only the fields which are involved in instruction extension */
1107 struct upk_mips16
1108   {
1109     CORE_ADDR offset;
1110     unsigned int regx;          /* Function in i8 type */
1111     unsigned int regy;
1112   };
1113
1114
1115 /* The EXT-I, EXT-ri nad EXT-I8 instructions all have the same format
1116    for the bits which make up the immediatate extension.  */
1117
1118 static CORE_ADDR
1119 extended_offset (unsigned int extension)
1120 {
1121   CORE_ADDR value;
1122   value = (extension >> 21) & 0x3f;     /* * extract 15:11 */
1123   value = value << 6;
1124   value |= (extension >> 16) & 0x1f;    /* extrace 10:5 */
1125   value = value << 5;
1126   value |= extension & 0x01f;   /* extract 4:0 */
1127   return value;
1128 }
1129
1130 /* Only call this function if you know that this is an extendable
1131    instruction, It wont malfunction, but why make excess remote memory references?
1132    If the immediate operands get sign extended or somthing, do it after
1133    the extension is performed.
1134  */
1135 /* FIXME: Every one of these cases needs to worry about sign extension
1136    when the offset is to be used in relative addressing */
1137
1138
1139 static unsigned int
1140 fetch_mips_16 (CORE_ADDR pc)
1141 {
1142   char buf[8];
1143   pc &= 0xfffffffe;             /* clear the low order bit */
1144   target_read_memory (pc, buf, 2);
1145   return extract_unsigned_integer (buf, 2);
1146 }
1147
1148 static void
1149 unpack_mips16 (CORE_ADDR pc,
1150                unsigned int extension,
1151                unsigned int inst,
1152                enum mips16_inst_fmts insn_format,
1153                struct upk_mips16 *upk)
1154 {
1155   CORE_ADDR offset;
1156   int regx;
1157   int regy;
1158   switch (insn_format)
1159     {
1160     case itype:
1161       {
1162         CORE_ADDR value;
1163         if (extension)
1164           {
1165             value = extended_offset (extension);
1166             value = value << 11;        /* rom for the original value */
1167             value |= inst & 0x7ff;              /* eleven bits from instruction */
1168           }
1169         else
1170           {
1171             value = inst & 0x7ff;
1172             /* FIXME : Consider sign extension */
1173           }
1174         offset = value;
1175         regx = -1;
1176         regy = -1;
1177       }
1178       break;
1179     case ritype:
1180     case i8type:
1181       {                         /* A register identifier and an offset */
1182         /* Most of the fields are the same as I type but the
1183            immediate value is of a different length */
1184         CORE_ADDR value;
1185         if (extension)
1186           {
1187             value = extended_offset (extension);
1188             value = value << 8; /* from the original instruction */
1189             value |= inst & 0xff;       /* eleven bits from instruction */
1190             regx = (extension >> 8) & 0x07;     /* or i8 funct */
1191             if (value & 0x4000) /* test the sign bit , bit 26 */
1192               {
1193                 value &= ~0x3fff;       /* remove the sign bit */
1194                 value = -value;
1195               }
1196           }
1197         else
1198           {
1199             value = inst & 0xff;        /* 8 bits */
1200             regx = (inst >> 8) & 0x07;  /* or i8 funct */
1201             /* FIXME: Do sign extension , this format needs it */
1202             if (value & 0x80)   /* THIS CONFUSES ME */
1203               {
1204                 value &= 0xef;  /* remove the sign bit */
1205                 value = -value;
1206               }
1207           }
1208         offset = value;
1209         regy = -1;
1210         break;
1211       }
1212     case jalxtype:
1213       {
1214         unsigned long value;
1215         unsigned int nexthalf;
1216         value = ((inst & 0x1f) << 5) | ((inst >> 5) & 0x1f);
1217         value = value << 16;
1218         nexthalf = mips_fetch_instruction (pc + 2);     /* low bit still set */
1219         value |= nexthalf;
1220         offset = value;
1221         regx = -1;
1222         regy = -1;
1223         break;
1224       }
1225     default:
1226       internal_error (__FILE__, __LINE__,
1227                       "bad switch");
1228     }
1229   upk->offset = offset;
1230   upk->regx = regx;
1231   upk->regy = regy;
1232 }
1233
1234
1235 static CORE_ADDR
1236 add_offset_16 (CORE_ADDR pc, int offset)
1237 {
1238   return ((offset << 2) | ((pc + 2) & (0xf0000000)));
1239 }
1240
1241 static CORE_ADDR
1242 extended_mips16_next_pc (CORE_ADDR pc,
1243                          unsigned int extension,
1244                          unsigned int insn)
1245 {
1246   int op = (insn >> 11);
1247   switch (op)
1248     {
1249     case 2:             /* Branch */
1250       {
1251         CORE_ADDR offset;
1252         struct upk_mips16 upk;
1253         unpack_mips16 (pc, extension, insn, itype, &upk);
1254         offset = upk.offset;
1255         if (offset & 0x800)
1256           {
1257             offset &= 0xeff;
1258             offset = -offset;
1259           }
1260         pc += (offset << 1) + 2;
1261         break;
1262       }
1263     case 3:             /* JAL , JALX - Watch out, these are 32 bit instruction */
1264       {
1265         struct upk_mips16 upk;
1266         unpack_mips16 (pc, extension, insn, jalxtype, &upk);
1267         pc = add_offset_16 (pc, upk.offset);
1268         if ((insn >> 10) & 0x01)        /* Exchange mode */
1269           pc = pc & ~0x01;      /* Clear low bit, indicate 32 bit mode */
1270         else
1271           pc |= 0x01;
1272         break;
1273       }
1274     case 4:             /* beqz */
1275       {
1276         struct upk_mips16 upk;
1277         int reg;
1278         unpack_mips16 (pc, extension, insn, ritype, &upk);
1279         reg = read_signed_register (upk.regx);
1280         if (reg == 0)
1281           pc += (upk.offset << 1) + 2;
1282         else
1283           pc += 2;
1284         break;
1285       }
1286     case 5:             /* bnez */
1287       {
1288         struct upk_mips16 upk;
1289         int reg;
1290         unpack_mips16 (pc, extension, insn, ritype, &upk);
1291         reg = read_signed_register (upk.regx);
1292         if (reg != 0)
1293           pc += (upk.offset << 1) + 2;
1294         else
1295           pc += 2;
1296         break;
1297       }
1298     case 12:            /* I8 Formats btez btnez */
1299       {
1300         struct upk_mips16 upk;
1301         int reg;
1302         unpack_mips16 (pc, extension, insn, i8type, &upk);
1303         /* upk.regx contains the opcode */
1304         reg = read_signed_register (24);        /* Test register is 24 */
1305         if (((upk.regx == 0) && (reg == 0))     /* BTEZ */
1306             || ((upk.regx == 1) && (reg != 0))) /* BTNEZ */
1307           /* pc = add_offset_16(pc,upk.offset) ; */
1308           pc += (upk.offset << 1) + 2;
1309         else
1310           pc += 2;
1311         break;
1312       }
1313     case 29:            /* RR Formats JR, JALR, JALR-RA */
1314       {
1315         struct upk_mips16 upk;
1316         /* upk.fmt = rrtype; */
1317         op = insn & 0x1f;
1318         if (op == 0)
1319           {
1320             int reg;
1321             upk.regx = (insn >> 8) & 0x07;
1322             upk.regy = (insn >> 5) & 0x07;
1323             switch (upk.regy)
1324               {
1325               case 0:
1326                 reg = upk.regx;
1327                 break;
1328               case 1:
1329                 reg = 31;
1330                 break;  /* Function return instruction */
1331               case 2:
1332                 reg = upk.regx;
1333                 break;
1334               default:
1335                 reg = 31;
1336                 break;  /* BOGUS Guess */
1337               }
1338             pc = read_signed_register (reg);
1339           }
1340         else
1341           pc += 2;
1342         break;
1343       }
1344     case 30:
1345       /* This is an instruction extension.  Fetch the real instruction
1346          (which follows the extension) and decode things based on
1347          that. */
1348       {
1349         pc += 2;
1350         pc = extended_mips16_next_pc (pc, insn, fetch_mips_16 (pc));
1351         break;
1352       }
1353     default:
1354       {
1355         pc += 2;
1356         break;
1357       }
1358     }
1359   return pc;
1360 }
1361
1362 static CORE_ADDR
1363 mips16_next_pc (CORE_ADDR pc)
1364 {
1365   unsigned int insn = fetch_mips_16 (pc);
1366   return extended_mips16_next_pc (pc, 0, insn);
1367 }
1368
1369 /* The mips_next_pc function supports single_step when the remote
1370    target monitor or stub is not developed enough to do a single_step.
1371    It works by decoding the current instruction and predicting where a
1372    branch will go. This isnt hard because all the data is available.
1373    The MIPS32 and MIPS16 variants are quite different */
1374 CORE_ADDR
1375 mips_next_pc (CORE_ADDR pc)
1376 {
1377   if (pc & 0x01)
1378     return mips16_next_pc (pc);
1379   else
1380     return mips32_next_pc (pc);
1381 }
1382
1383 /* Guaranteed to set fci->saved_regs to some values (it never leaves it
1384    NULL).
1385
1386    Note: kevinb/2002-08-09: The only caller of this function is (and
1387    should remain) mips_frame_init_saved_regs().  In fact,
1388    aside from calling mips_find_saved_regs(), mips_frame_init_saved_regs()
1389    does nothing more than set frame->saved_regs[SP_REGNUM].  These two
1390    functions should really be combined and now that there is only one
1391    caller, it should be straightforward.  (Watch out for multiple returns
1392    though.)  */
1393
1394 static void
1395 mips_find_saved_regs (struct frame_info *fci)
1396 {
1397   int ireg;
1398   CORE_ADDR reg_position;
1399   /* r0 bit means kernel trap */
1400   int kernel_trap;
1401   /* What registers have been saved?  Bitmasks.  */
1402   unsigned long gen_mask, float_mask;
1403   mips_extra_func_info_t proc_desc;
1404   t_inst inst;
1405
1406   frame_saved_regs_zalloc (fci);
1407
1408   /* If it is the frame for sigtramp, the saved registers are located
1409      in a sigcontext structure somewhere on the stack.
1410      If the stack layout for sigtramp changes we might have to change these
1411      constants and the companion fixup_sigtramp in mdebugread.c  */
1412 #ifndef SIGFRAME_BASE
1413 /* To satisfy alignment restrictions, sigcontext is located 4 bytes
1414    above the sigtramp frame.  */
1415 #define SIGFRAME_BASE           MIPS_REGSIZE
1416 /* FIXME!  Are these correct?? */
1417 #define SIGFRAME_PC_OFF         (SIGFRAME_BASE + 2 * MIPS_REGSIZE)
1418 #define SIGFRAME_REGSAVE_OFF    (SIGFRAME_BASE + 3 * MIPS_REGSIZE)
1419 #define SIGFRAME_FPREGSAVE_OFF  \
1420         (SIGFRAME_REGSAVE_OFF + MIPS_NUMREGS * MIPS_REGSIZE + 3 * MIPS_REGSIZE)
1421 #endif
1422 #ifndef SIGFRAME_REG_SIZE
1423 /* FIXME!  Is this correct?? */
1424 #define SIGFRAME_REG_SIZE       MIPS_REGSIZE
1425 #endif
1426   if (fci->signal_handler_caller)
1427     {
1428       for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
1429         {
1430           reg_position = fci->frame + SIGFRAME_REGSAVE_OFF
1431             + ireg * SIGFRAME_REG_SIZE;
1432           fci->saved_regs[ireg] = reg_position;
1433         }
1434       for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
1435         {
1436           reg_position = fci->frame + SIGFRAME_FPREGSAVE_OFF
1437             + ireg * SIGFRAME_REG_SIZE;
1438           fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
1439         }
1440       fci->saved_regs[PC_REGNUM] = fci->frame + SIGFRAME_PC_OFF;
1441       return;
1442     }
1443
1444   proc_desc = fci->extra_info->proc_desc;
1445   if (proc_desc == NULL)
1446     /* I'm not sure how/whether this can happen.  Normally when we can't
1447        find a proc_desc, we "synthesize" one using heuristic_proc_desc
1448        and set the saved_regs right away.  */
1449     return;
1450
1451   kernel_trap = PROC_REG_MASK (proc_desc) & 1;
1452   gen_mask = kernel_trap ? 0xFFFFFFFF : PROC_REG_MASK (proc_desc);
1453   float_mask = kernel_trap ? 0xFFFFFFFF : PROC_FREG_MASK (proc_desc);
1454
1455   if (                          /* In any frame other than the innermost or a frame interrupted by
1456                                    a signal, we assume that all registers have been saved.
1457                                    This assumes that all register saves in a function happen before
1458                                    the first function call.  */
1459        (fci->next == NULL || fci->next->signal_handler_caller)
1460
1461   /* In a dummy frame we know exactly where things are saved.  */
1462        && !PROC_DESC_IS_DUMMY (proc_desc)
1463
1464   /* Don't bother unless we are inside a function prologue.  Outside the
1465      prologue, we know where everything is. */
1466
1467        && in_prologue (fci->pc, PROC_LOW_ADDR (proc_desc))
1468
1469   /* Not sure exactly what kernel_trap means, but if it means
1470      the kernel saves the registers without a prologue doing it,
1471      we better not examine the prologue to see whether registers
1472      have been saved yet.  */
1473        && !kernel_trap)
1474     {
1475       /* We need to figure out whether the registers that the proc_desc
1476          claims are saved have been saved yet.  */
1477
1478       CORE_ADDR addr;
1479
1480       /* Bitmasks; set if we have found a save for the register.  */
1481       unsigned long gen_save_found = 0;
1482       unsigned long float_save_found = 0;
1483       int instlen;
1484
1485       /* If the address is odd, assume this is MIPS16 code.  */
1486       addr = PROC_LOW_ADDR (proc_desc);
1487       instlen = pc_is_mips16 (addr) ? MIPS16_INSTLEN : MIPS_INSTLEN;
1488
1489       /* Scan through this function's instructions preceding the current
1490          PC, and look for those that save registers.  */
1491       while (addr < fci->pc)
1492         {
1493           inst = mips_fetch_instruction (addr);
1494           if (pc_is_mips16 (addr))
1495             mips16_decode_reg_save (inst, &gen_save_found);
1496           else
1497             mips32_decode_reg_save (inst, &gen_save_found, &float_save_found);
1498           addr += instlen;
1499         }
1500       gen_mask = gen_save_found;
1501       float_mask = float_save_found;
1502     }
1503
1504   /* Fill in the offsets for the registers which gen_mask says
1505      were saved.  */
1506   reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
1507   for (ireg = MIPS_NUMREGS - 1; gen_mask; --ireg, gen_mask <<= 1)
1508     if (gen_mask & 0x80000000)
1509       {
1510         fci->saved_regs[ireg] = reg_position;
1511         reg_position -= MIPS_SAVED_REGSIZE;
1512       }
1513
1514   /* The MIPS16 entry instruction saves $s0 and $s1 in the reverse order
1515      of that normally used by gcc.  Therefore, we have to fetch the first
1516      instruction of the function, and if it's an entry instruction that
1517      saves $s0 or $s1, correct their saved addresses.  */
1518   if (pc_is_mips16 (PROC_LOW_ADDR (proc_desc)))
1519     {
1520       inst = mips_fetch_instruction (PROC_LOW_ADDR (proc_desc));
1521       if ((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)         /* entry */
1522         {
1523           int reg;
1524           int sreg_count = (inst >> 6) & 3;
1525
1526           /* Check if the ra register was pushed on the stack.  */
1527           reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
1528           if (inst & 0x20)
1529             reg_position -= MIPS_SAVED_REGSIZE;
1530
1531           /* Check if the s0 and s1 registers were pushed on the stack.  */
1532           for (reg = 16; reg < sreg_count + 16; reg++)
1533             {
1534               fci->saved_regs[reg] = reg_position;
1535               reg_position -= MIPS_SAVED_REGSIZE;
1536             }
1537         }
1538     }
1539
1540   /* Fill in the offsets for the registers which float_mask says
1541      were saved.  */
1542   reg_position = fci->frame + PROC_FREG_OFFSET (proc_desc);
1543
1544   /* Apparently, the freg_offset gives the offset to the first 64 bit
1545      saved.
1546
1547      When the ABI specifies 64 bit saved registers, the FREG_OFFSET
1548      designates the first saved 64 bit register.
1549
1550      When the ABI specifies 32 bit saved registers, the ``64 bit saved
1551      DOUBLE'' consists of two adjacent 32 bit registers, Hence
1552      FREG_OFFSET, designates the address of the lower register of the
1553      register pair.  Adjust the offset so that it designates the upper
1554      register of the pair -- i.e., the address of the first saved 32
1555      bit register.  */
1556
1557   if (MIPS_SAVED_REGSIZE == 4)
1558     reg_position += MIPS_SAVED_REGSIZE;
1559
1560   /* Fill in the offsets for the float registers which float_mask says
1561      were saved.  */
1562   for (ireg = MIPS_NUMREGS - 1; float_mask; --ireg, float_mask <<= 1)
1563     if (float_mask & 0x80000000)
1564       {
1565         fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
1566         reg_position -= MIPS_SAVED_REGSIZE;
1567       }
1568
1569   fci->saved_regs[PC_REGNUM] = fci->saved_regs[RA_REGNUM];
1570 }
1571
1572 /* Set up the 'saved_regs' array.  This is a data structure containing
1573    the addresses on the stack where each register has been saved, for
1574    each stack frame.  Registers that have not been saved will have
1575    zero here.  The stack pointer register is special:  rather than the
1576    address where the stack register has been saved, saved_regs[SP_REGNUM]
1577    will have the actual value of the previous frame's stack register.  */
1578
1579 static void
1580 mips_frame_init_saved_regs (struct frame_info *frame)
1581 {
1582   if (frame->saved_regs == NULL)
1583     {
1584       mips_find_saved_regs (frame);
1585     }
1586   frame->saved_regs[SP_REGNUM] = frame->frame;
1587 }
1588
1589 static CORE_ADDR
1590 read_next_frame_reg (struct frame_info *fi, int regno)
1591 {
1592   int optimized;
1593   CORE_ADDR addr;
1594   int realnum;
1595   enum lval_type lval;
1596   void *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
1597   frame_register_unwind (fi, regno, &optimized, &lval, &addr, &realnum,
1598                          raw_buffer);
1599   /* FIXME: cagney/2002-09-13: This is just soooo bad.  The MIPS
1600      should have a pseudo register range that correspons to the ABI's,
1601      rather than the ISA's, view of registers.  These registers would
1602      then implicitly describe their size and hence could be used
1603      without the below munging.  */
1604   if (lval == lval_memory)
1605     {
1606       if (regno < 32)
1607         {
1608           /* Only MIPS_SAVED_REGSIZE bytes of GP registers are
1609              saved. */
1610           return read_memory_integer (addr, MIPS_SAVED_REGSIZE);
1611         }
1612     }
1613
1614   return extract_signed_integer (raw_buffer, REGISTER_VIRTUAL_SIZE (regno));
1615 }
1616
1617 /* mips_addr_bits_remove - remove useless address bits  */
1618
1619 static CORE_ADDR
1620 mips_addr_bits_remove (CORE_ADDR addr)
1621 {
1622   if (GDB_TARGET_IS_MIPS64)
1623     {
1624       if (mips_mask_address_p () && (addr >> 32 == (CORE_ADDR) 0xffffffff))
1625         {
1626           /* This hack is a work-around for existing boards using
1627              PMON, the simulator, and any other 64-bit targets that
1628              doesn't have true 64-bit addressing.  On these targets,
1629              the upper 32 bits of addresses are ignored by the
1630              hardware.  Thus, the PC or SP are likely to have been
1631              sign extended to all 1s by instruction sequences that
1632              load 32-bit addresses.  For example, a typical piece of
1633              code that loads an address is this:
1634                  lui $r2, <upper 16 bits>
1635                  ori $r2, <lower 16 bits>
1636              But the lui sign-extends the value such that the upper 32
1637              bits may be all 1s.  The workaround is simply to mask off
1638              these bits.  In the future, gcc may be changed to support
1639              true 64-bit addressing, and this masking will have to be
1640              disabled.  */
1641           addr &= (CORE_ADDR) 0xffffffff;
1642         }
1643     }
1644   else if (mips_mask_address_p ())
1645     {
1646       /* FIXME: This is wrong!  mips_addr_bits_remove() shouldn't be
1647          masking off bits, instead, the actual target should be asking
1648          for the address to be converted to a valid pointer. */
1649       /* Even when GDB is configured for some 32-bit targets
1650          (e.g. mips-elf), BFD is configured to handle 64-bit targets,
1651          so CORE_ADDR is 64 bits.  So we still have to mask off
1652          useless bits from addresses.  */
1653       addr &= (CORE_ADDR) 0xffffffff;
1654     }
1655   return addr;
1656 }
1657
1658 /* mips_software_single_step() is called just before we want to resume
1659    the inferior, if we want to single-step it but there is no hardware
1660    or kernel single-step support (MIPS on GNU/Linux for example).  We find
1661    the target of the coming instruction and breakpoint it.
1662
1663    single_step is also called just after the inferior stops.  If we had
1664    set up a simulated single-step, we undo our damage.  */
1665
1666 void
1667 mips_software_single_step (enum target_signal sig, int insert_breakpoints_p)
1668 {
1669   static CORE_ADDR next_pc;
1670   typedef char binsn_quantum[BREAKPOINT_MAX];
1671   static binsn_quantum break_mem;
1672   CORE_ADDR pc;
1673
1674   if (insert_breakpoints_p)
1675     {
1676       pc = read_register (PC_REGNUM);
1677       next_pc = mips_next_pc (pc);
1678
1679       target_insert_breakpoint (next_pc, break_mem);
1680     }
1681   else
1682     target_remove_breakpoint (next_pc, break_mem);
1683 }
1684
1685 static void
1686 mips_init_frame_pc_first (int fromleaf, struct frame_info *prev)
1687 {
1688   CORE_ADDR pc, tmp;
1689
1690   pc = ((fromleaf) ? SAVED_PC_AFTER_CALL (prev->next) :
1691         prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
1692   tmp = SKIP_TRAMPOLINE_CODE (pc);
1693   prev->pc = tmp ? tmp : pc;
1694 }
1695
1696
1697 static CORE_ADDR
1698 mips_frame_saved_pc (struct frame_info *frame)
1699 {
1700   CORE_ADDR saved_pc;
1701   mips_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
1702   /* We have to get the saved pc from the sigcontext
1703      if it is a signal handler frame.  */
1704   int pcreg = frame->signal_handler_caller ? PC_REGNUM
1705   : (proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM);
1706
1707   if (USE_GENERIC_DUMMY_FRAMES
1708       && PC_IN_CALL_DUMMY (frame->pc, 0, 0))
1709     {
1710       LONGEST tmp;
1711       frame_unwind_signed_register (frame, PC_REGNUM, &tmp);
1712       saved_pc = tmp;
1713     }
1714   else if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))
1715     saved_pc = read_memory_integer (frame->frame - MIPS_SAVED_REGSIZE, MIPS_SAVED_REGSIZE);
1716   else
1717     saved_pc = read_next_frame_reg (frame, pcreg);
1718
1719   return ADDR_BITS_REMOVE (saved_pc);
1720 }
1721
1722 static struct mips_extra_func_info temp_proc_desc;
1723 static CORE_ADDR temp_saved_regs[NUM_REGS];
1724
1725 /* Set a register's saved stack address in temp_saved_regs.  If an address
1726    has already been set for this register, do nothing; this way we will
1727    only recognize the first save of a given register in a function prologue.
1728    This is a helper function for mips{16,32}_heuristic_proc_desc.  */
1729
1730 static void
1731 set_reg_offset (int regno, CORE_ADDR offset)
1732 {
1733   if (temp_saved_regs[regno] == 0)
1734     temp_saved_regs[regno] = offset;
1735 }
1736
1737
1738 /* Test whether the PC points to the return instruction at the
1739    end of a function. */
1740
1741 static int
1742 mips_about_to_return (CORE_ADDR pc)
1743 {
1744   if (pc_is_mips16 (pc))
1745     /* This mips16 case isn't necessarily reliable.  Sometimes the compiler
1746        generates a "jr $ra"; other times it generates code to load
1747        the return address from the stack to an accessible register (such
1748        as $a3), then a "jr" using that register.  This second case
1749        is almost impossible to distinguish from an indirect jump
1750        used for switch statements, so we don't even try.  */
1751     return mips_fetch_instruction (pc) == 0xe820;       /* jr $ra */
1752   else
1753     return mips_fetch_instruction (pc) == 0x3e00008;    /* jr $ra */
1754 }
1755
1756
1757 /* This fencepost looks highly suspicious to me.  Removing it also
1758    seems suspicious as it could affect remote debugging across serial
1759    lines.  */
1760
1761 static CORE_ADDR
1762 heuristic_proc_start (CORE_ADDR pc)
1763 {
1764   CORE_ADDR start_pc;
1765   CORE_ADDR fence;
1766   int instlen;
1767   int seen_adjsp = 0;
1768
1769   pc = ADDR_BITS_REMOVE (pc);
1770   start_pc = pc;
1771   fence = start_pc - heuristic_fence_post;
1772   if (start_pc == 0)
1773     return 0;
1774
1775   if (heuristic_fence_post == UINT_MAX
1776       || fence < VM_MIN_ADDRESS)
1777     fence = VM_MIN_ADDRESS;
1778
1779   instlen = pc_is_mips16 (pc) ? MIPS16_INSTLEN : MIPS_INSTLEN;
1780
1781   /* search back for previous return */
1782   for (start_pc -= instlen;; start_pc -= instlen)
1783     if (start_pc < fence)
1784       {
1785         /* It's not clear to me why we reach this point when
1786            stop_soon_quietly, but with this test, at least we
1787            don't print out warnings for every child forked (eg, on
1788            decstation).  22apr93 [email protected].  */
1789         if (!stop_soon_quietly)
1790           {
1791             static int blurb_printed = 0;
1792
1793             warning ("Warning: GDB can't find the start of the function at 0x%s.",
1794                      paddr_nz (pc));
1795
1796             if (!blurb_printed)
1797               {
1798                 /* This actually happens frequently in embedded
1799                    development, when you first connect to a board
1800                    and your stack pointer and pc are nowhere in
1801                    particular.  This message needs to give people
1802                    in that situation enough information to
1803                    determine that it's no big deal.  */
1804                 printf_filtered ("\n\
1805     GDB is unable to find the start of the function at 0x%s\n\
1806 and thus can't determine the size of that function's stack frame.\n\
1807 This means that GDB may be unable to access that stack frame, or\n\
1808 the frames below it.\n\
1809     This problem is most likely caused by an invalid program counter or\n\
1810 stack pointer.\n\
1811     However, if you think GDB should simply search farther back\n\
1812 from 0x%s for code which looks like the beginning of a\n\
1813 function, you can increase the range of the search using the `set\n\
1814 heuristic-fence-post' command.\n",
1815                                  paddr_nz (pc), paddr_nz (pc));
1816                 blurb_printed = 1;
1817               }
1818           }
1819
1820         return 0;
1821       }
1822     else if (pc_is_mips16 (start_pc))
1823       {
1824         unsigned short inst;
1825
1826         /* On MIPS16, any one of the following is likely to be the
1827            start of a function:
1828            entry
1829            addiu sp,-n
1830            daddiu sp,-n
1831            extend -n followed by 'addiu sp,+n' or 'daddiu sp,+n'  */
1832         inst = mips_fetch_instruction (start_pc);
1833         if (((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)      /* entry */
1834             || (inst & 0xff80) == 0x6380        /* addiu sp,-n */
1835             || (inst & 0xff80) == 0xfb80        /* daddiu sp,-n */
1836             || ((inst & 0xf810) == 0xf010 && seen_adjsp))       /* extend -n */
1837           break;
1838         else if ((inst & 0xff00) == 0x6300      /* addiu sp */
1839                  || (inst & 0xff00) == 0xfb00)  /* daddiu sp */
1840           seen_adjsp = 1;
1841         else
1842           seen_adjsp = 0;
1843       }
1844     else if (mips_about_to_return (start_pc))
1845       {
1846         start_pc += 2 * MIPS_INSTLEN;   /* skip return, and its delay slot */
1847         break;
1848       }
1849
1850   return start_pc;
1851 }
1852
1853 /* Fetch the immediate value from a MIPS16 instruction.
1854    If the previous instruction was an EXTEND, use it to extend
1855    the upper bits of the immediate value.  This is a helper function
1856    for mips16_heuristic_proc_desc.  */
1857
1858 static int
1859 mips16_get_imm (unsigned short prev_inst,       /* previous instruction */
1860                 unsigned short inst,    /* current instruction */
1861                 int nbits,              /* number of bits in imm field */
1862                 int scale,              /* scale factor to be applied to imm */
1863                 int is_signed)          /* is the imm field signed? */
1864 {
1865   int offset;
1866
1867   if ((prev_inst & 0xf800) == 0xf000)   /* prev instruction was EXTEND? */
1868     {
1869       offset = ((prev_inst & 0x1f) << 11) | (prev_inst & 0x7e0);
1870       if (offset & 0x8000)      /* check for negative extend */
1871         offset = 0 - (0x10000 - (offset & 0xffff));
1872       return offset | (inst & 0x1f);
1873     }
1874   else
1875     {
1876       int max_imm = 1 << nbits;
1877       int mask = max_imm - 1;
1878       int sign_bit = max_imm >> 1;
1879
1880       offset = inst & mask;
1881       if (is_signed && (offset & sign_bit))
1882         offset = 0 - (max_imm - offset);
1883       return offset * scale;
1884     }
1885 }
1886
1887
1888 /* Fill in values in temp_proc_desc based on the MIPS16 instruction
1889    stream from start_pc to limit_pc.  */
1890
1891 static void
1892 mips16_heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
1893                             struct frame_info *next_frame, CORE_ADDR sp)
1894 {
1895   CORE_ADDR cur_pc;
1896   CORE_ADDR frame_addr = 0;     /* Value of $r17, used as frame pointer */
1897   unsigned short prev_inst = 0; /* saved copy of previous instruction */
1898   unsigned inst = 0;            /* current instruction */
1899   unsigned entry_inst = 0;      /* the entry instruction */
1900   int reg, offset;
1901
1902   PROC_FRAME_OFFSET (&temp_proc_desc) = 0;      /* size of stack frame */
1903   PROC_FRAME_ADJUST (&temp_proc_desc) = 0;      /* offset of FP from SP */
1904
1905   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS16_INSTLEN)
1906     {
1907       /* Save the previous instruction.  If it's an EXTEND, we'll extract
1908          the immediate offset extension from it in mips16_get_imm.  */
1909       prev_inst = inst;
1910
1911       /* Fetch and decode the instruction.   */
1912       inst = (unsigned short) mips_fetch_instruction (cur_pc);
1913       if ((inst & 0xff00) == 0x6300     /* addiu sp */
1914           || (inst & 0xff00) == 0xfb00)         /* daddiu sp */
1915         {
1916           offset = mips16_get_imm (prev_inst, inst, 8, 8, 1);
1917           if (offset < 0)       /* negative stack adjustment? */
1918             PROC_FRAME_OFFSET (&temp_proc_desc) -= offset;
1919           else
1920             /* Exit loop if a positive stack adjustment is found, which
1921                usually means that the stack cleanup code in the function
1922                epilogue is reached.  */
1923             break;
1924         }
1925       else if ((inst & 0xf800) == 0xd000)       /* sw reg,n($sp) */
1926         {
1927           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1928           reg = mips16_to_32_reg[(inst & 0x700) >> 8];
1929           PROC_REG_MASK (&temp_proc_desc) |= (1 << reg);
1930           set_reg_offset (reg, sp + offset);
1931         }
1932       else if ((inst & 0xff00) == 0xf900)       /* sd reg,n($sp) */
1933         {
1934           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
1935           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1936           PROC_REG_MASK (&temp_proc_desc) |= (1 << reg);
1937           set_reg_offset (reg, sp + offset);
1938         }
1939       else if ((inst & 0xff00) == 0x6200)       /* sw $ra,n($sp) */
1940         {
1941           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1942           PROC_REG_MASK (&temp_proc_desc) |= (1 << RA_REGNUM);
1943           set_reg_offset (RA_REGNUM, sp + offset);
1944         }
1945       else if ((inst & 0xff00) == 0xfa00)       /* sd $ra,n($sp) */
1946         {
1947           offset = mips16_get_imm (prev_inst, inst, 8, 8, 0);
1948           PROC_REG_MASK (&temp_proc_desc) |= (1 << RA_REGNUM);
1949           set_reg_offset (RA_REGNUM, sp + offset);
1950         }
1951       else if (inst == 0x673d)  /* move $s1, $sp */
1952         {
1953           frame_addr = sp;
1954           PROC_FRAME_REG (&temp_proc_desc) = 17;
1955         }
1956       else if ((inst & 0xff00) == 0x0100)       /* addiu $s1,sp,n */
1957         {
1958           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1959           frame_addr = sp + offset;
1960           PROC_FRAME_REG (&temp_proc_desc) = 17;
1961           PROC_FRAME_ADJUST (&temp_proc_desc) = offset;
1962         }
1963       else if ((inst & 0xFF00) == 0xd900)       /* sw reg,offset($s1) */
1964         {
1965           offset = mips16_get_imm (prev_inst, inst, 5, 4, 0);
1966           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1967           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1968           set_reg_offset (reg, frame_addr + offset);
1969         }
1970       else if ((inst & 0xFF00) == 0x7900)       /* sd reg,offset($s1) */
1971         {
1972           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
1973           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1974           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1975           set_reg_offset (reg, frame_addr + offset);
1976         }
1977       else if ((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)    /* entry */
1978         entry_inst = inst;      /* save for later processing */
1979       else if ((inst & 0xf800) == 0x1800)       /* jal(x) */
1980         cur_pc += MIPS16_INSTLEN;       /* 32-bit instruction */
1981     }
1982
1983   /* The entry instruction is typically the first instruction in a function,
1984      and it stores registers at offsets relative to the value of the old SP
1985      (before the prologue).  But the value of the sp parameter to this
1986      function is the new SP (after the prologue has been executed).  So we
1987      can't calculate those offsets until we've seen the entire prologue,
1988      and can calculate what the old SP must have been. */
1989   if (entry_inst != 0)
1990     {
1991       int areg_count = (entry_inst >> 8) & 7;
1992       int sreg_count = (entry_inst >> 6) & 3;
1993
1994       /* The entry instruction always subtracts 32 from the SP.  */
1995       PROC_FRAME_OFFSET (&temp_proc_desc) += 32;
1996
1997       /* Now we can calculate what the SP must have been at the
1998          start of the function prologue.  */
1999       sp += PROC_FRAME_OFFSET (&temp_proc_desc);
2000
2001       /* Check if a0-a3 were saved in the caller's argument save area.  */
2002       for (reg = 4, offset = 0; reg < areg_count + 4; reg++)
2003         {
2004           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2005           set_reg_offset (reg, sp + offset);
2006           offset += MIPS_SAVED_REGSIZE;
2007         }
2008
2009       /* Check if the ra register was pushed on the stack.  */
2010       offset = -4;
2011       if (entry_inst & 0x20)
2012         {
2013           PROC_REG_MASK (&temp_proc_desc) |= 1 << RA_REGNUM;
2014           set_reg_offset (RA_REGNUM, sp + offset);
2015           offset -= MIPS_SAVED_REGSIZE;
2016         }
2017
2018       /* Check if the s0 and s1 registers were pushed on the stack.  */
2019       for (reg = 16; reg < sreg_count + 16; reg++)
2020         {
2021           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2022           set_reg_offset (reg, sp + offset);
2023           offset -= MIPS_SAVED_REGSIZE;
2024         }
2025     }
2026 }
2027
2028 static void
2029 mips32_heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
2030                             struct frame_info *next_frame, CORE_ADDR sp)
2031 {
2032   CORE_ADDR cur_pc;
2033   CORE_ADDR frame_addr = 0;     /* Value of $r30. Used by gcc for frame-pointer */
2034 restart:
2035   memset (temp_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
2036   PROC_FRAME_OFFSET (&temp_proc_desc) = 0;
2037   PROC_FRAME_ADJUST (&temp_proc_desc) = 0;      /* offset of FP from SP */
2038   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS_INSTLEN)
2039     {
2040       unsigned long inst, high_word, low_word;
2041       int reg;
2042
2043       /* Fetch the instruction.   */
2044       inst = (unsigned long) mips_fetch_instruction (cur_pc);
2045
2046       /* Save some code by pre-extracting some useful fields.  */
2047       high_word = (inst >> 16) & 0xffff;
2048       low_word = inst & 0xffff;
2049       reg = high_word & 0x1f;
2050
2051       if (high_word == 0x27bd   /* addiu $sp,$sp,-i */
2052           || high_word == 0x23bd        /* addi $sp,$sp,-i */
2053           || high_word == 0x67bd)       /* daddiu $sp,$sp,-i */
2054         {
2055           if (low_word & 0x8000)        /* negative stack adjustment? */
2056             PROC_FRAME_OFFSET (&temp_proc_desc) += 0x10000 - low_word;
2057           else
2058             /* Exit loop if a positive stack adjustment is found, which
2059                usually means that the stack cleanup code in the function
2060                epilogue is reached.  */
2061             break;
2062         }
2063       else if ((high_word & 0xFFE0) == 0xafa0)  /* sw reg,offset($sp) */
2064         {
2065           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2066           set_reg_offset (reg, sp + low_word);
2067         }
2068       else if ((high_word & 0xFFE0) == 0xffa0)  /* sd reg,offset($sp) */
2069         {
2070           /* Irix 6.2 N32 ABI uses sd instructions for saving $gp and $ra,
2071              but the register size used is only 32 bits. Make the address
2072              for the saved register point to the lower 32 bits.  */
2073           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2074           set_reg_offset (reg, sp + low_word + 8 - MIPS_REGSIZE);
2075         }
2076       else if (high_word == 0x27be)     /* addiu $30,$sp,size */
2077         {
2078           /* Old gcc frame, r30 is virtual frame pointer.  */
2079           if ((long) low_word != PROC_FRAME_OFFSET (&temp_proc_desc))
2080             frame_addr = sp + low_word;
2081           else if (PROC_FRAME_REG (&temp_proc_desc) == SP_REGNUM)
2082             {
2083               unsigned alloca_adjust;
2084               PROC_FRAME_REG (&temp_proc_desc) = 30;
2085               frame_addr = read_next_frame_reg (next_frame, 30);
2086               alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
2087               if (alloca_adjust > 0)
2088                 {
2089                   /* FP > SP + frame_size. This may be because
2090                    * of an alloca or somethings similar.
2091                    * Fix sp to "pre-alloca" value, and try again.
2092                    */
2093                   sp += alloca_adjust;
2094                   goto restart;
2095                 }
2096             }
2097         }
2098       /* move $30,$sp.  With different versions of gas this will be either
2099          `addu $30,$sp,$zero' or `or $30,$sp,$zero' or `daddu 30,sp,$0'.
2100          Accept any one of these.  */
2101       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
2102         {
2103           /* New gcc frame, virtual frame pointer is at r30 + frame_size.  */
2104           if (PROC_FRAME_REG (&temp_proc_desc) == SP_REGNUM)
2105             {
2106               unsigned alloca_adjust;
2107               PROC_FRAME_REG (&temp_proc_desc) = 30;
2108               frame_addr = read_next_frame_reg (next_frame, 30);
2109               alloca_adjust = (unsigned) (frame_addr - sp);
2110               if (alloca_adjust > 0)
2111                 {
2112                   /* FP > SP + frame_size. This may be because
2113                    * of an alloca or somethings similar.
2114                    * Fix sp to "pre-alloca" value, and try again.
2115                    */
2116                   sp += alloca_adjust;
2117                   goto restart;
2118                 }
2119             }
2120         }
2121       else if ((high_word & 0xFFE0) == 0xafc0)  /* sw reg,offset($30) */
2122         {
2123           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
2124           set_reg_offset (reg, frame_addr + low_word);
2125         }
2126     }
2127 }
2128
2129 static mips_extra_func_info_t
2130 heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
2131                      struct frame_info *next_frame, int cur_frame)
2132 {
2133   CORE_ADDR sp;
2134
2135   if (cur_frame)
2136     sp = read_next_frame_reg (next_frame, SP_REGNUM);
2137   else
2138     sp = 0;
2139
2140   if (start_pc == 0)
2141     return NULL;
2142   memset (&temp_proc_desc, '\0', sizeof (temp_proc_desc));
2143   memset (&temp_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
2144   PROC_LOW_ADDR (&temp_proc_desc) = start_pc;
2145   PROC_FRAME_REG (&temp_proc_desc) = SP_REGNUM;
2146   PROC_PC_REG (&temp_proc_desc) = RA_REGNUM;
2147
2148   if (start_pc + 200 < limit_pc)
2149     limit_pc = start_pc + 200;
2150   if (pc_is_mips16 (start_pc))
2151     mips16_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp);
2152   else
2153     mips32_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp);
2154   return &temp_proc_desc;
2155 }
2156
2157 struct mips_objfile_private
2158 {
2159   bfd_size_type size;
2160   char *contents;
2161 };
2162
2163 /* Global used to communicate between non_heuristic_proc_desc and
2164    compare_pdr_entries within qsort ().  */
2165 static bfd *the_bfd;
2166
2167 static int
2168 compare_pdr_entries (const void *a, const void *b)
2169 {
2170   CORE_ADDR lhs = bfd_get_32 (the_bfd, (bfd_byte *) a);
2171   CORE_ADDR rhs = bfd_get_32 (the_bfd, (bfd_byte *) b);
2172
2173   if (lhs < rhs)
2174     return -1;
2175   else if (lhs == rhs)
2176     return 0;
2177   else
2178     return 1;
2179 }
2180
2181 static mips_extra_func_info_t
2182 non_heuristic_proc_desc (CORE_ADDR pc, CORE_ADDR *addrptr)
2183 {
2184   CORE_ADDR startaddr;
2185   mips_extra_func_info_t proc_desc;
2186   struct block *b = block_for_pc (pc);
2187   struct symbol *sym;
2188   struct obj_section *sec;
2189   struct mips_objfile_private *priv;
2190
2191   if (PC_IN_CALL_DUMMY (pc, 0, 0))
2192     return NULL;
2193
2194   find_pc_partial_function (pc, NULL, &startaddr, NULL);
2195   if (addrptr)
2196     *addrptr = startaddr;
2197
2198   priv = NULL;
2199
2200   sec = find_pc_section (pc);
2201   if (sec != NULL)
2202     {
2203       priv = (struct mips_objfile_private *) sec->objfile->obj_private;
2204
2205       /* Search the ".pdr" section generated by GAS.  This includes most of
2206          the information normally found in ECOFF PDRs.  */
2207
2208       the_bfd = sec->objfile->obfd;
2209       if (priv == NULL
2210           && (the_bfd->format == bfd_object
2211               && bfd_get_flavour (the_bfd) == bfd_target_elf_flavour
2212               && elf_elfheader (the_bfd)->e_ident[EI_CLASS] == ELFCLASS64))
2213         {
2214           /* Right now GAS only outputs the address as a four-byte sequence.
2215              This means that we should not bother with this method on 64-bit
2216              targets (until that is fixed).  */
2217
2218           priv = obstack_alloc (& sec->objfile->psymbol_obstack,
2219                                 sizeof (struct mips_objfile_private));
2220           priv->size = 0;
2221           sec->objfile->obj_private = priv;
2222         }
2223       else if (priv == NULL)
2224         {
2225           asection *bfdsec;
2226
2227           priv = obstack_alloc (& sec->objfile->psymbol_obstack,
2228                                 sizeof (struct mips_objfile_private));
2229
2230           bfdsec = bfd_get_section_by_name (sec->objfile->obfd, ".pdr");
2231           if (bfdsec != NULL)
2232             {
2233               priv->size = bfd_section_size (sec->objfile->obfd, bfdsec);
2234               priv->contents = obstack_alloc (& sec->objfile->psymbol_obstack,
2235                                               priv->size);
2236               bfd_get_section_contents (sec->objfile->obfd, bfdsec,
2237                                         priv->contents, 0, priv->size);
2238
2239               /* In general, the .pdr section is sorted.  However, in the
2240                  presence of multiple code sections (and other corner cases)
2241                  it can become unsorted.  Sort it so that we can use a faster
2242                  binary search.  */
2243               qsort (priv->contents, priv->size / 32, 32, compare_pdr_entries);
2244             }
2245           else
2246             priv->size = 0;
2247
2248           sec->objfile->obj_private = priv;
2249         }
2250       the_bfd = NULL;
2251
2252       if (priv->size != 0)
2253         {
2254           int low, mid, high;
2255           char *ptr;
2256
2257           low = 0;
2258           high = priv->size / 32;
2259
2260           do
2261             {
2262               CORE_ADDR pdr_pc;
2263
2264               mid = (low + high) / 2;
2265
2266               ptr = priv->contents + mid * 32;
2267               pdr_pc = bfd_get_signed_32 (sec->objfile->obfd, ptr);
2268               pdr_pc += ANOFFSET (sec->objfile->section_offsets,
2269                                   SECT_OFF_TEXT (sec->objfile));
2270               if (pdr_pc == startaddr)
2271                 break;
2272               if (pdr_pc > startaddr)
2273                 high = mid;
2274               else
2275                 low = mid + 1;
2276             }
2277           while (low != high);
2278
2279           if (low != high)
2280             {
2281               struct symbol *sym = find_pc_function (pc);
2282
2283               /* Fill in what we need of the proc_desc.  */
2284               proc_desc = (mips_extra_func_info_t)
2285                 obstack_alloc (&sec->objfile->psymbol_obstack,
2286                                sizeof (struct mips_extra_func_info));
2287               PROC_LOW_ADDR (proc_desc) = startaddr;
2288
2289               /* Only used for dummy frames.  */
2290               PROC_HIGH_ADDR (proc_desc) = 0;
2291
2292               PROC_FRAME_OFFSET (proc_desc)
2293                 = bfd_get_32 (sec->objfile->obfd, ptr + 20);
2294               PROC_FRAME_REG (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2295                                                        ptr + 24);
2296               PROC_FRAME_ADJUST (proc_desc) = 0;
2297               PROC_REG_MASK (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2298                                                       ptr + 4);
2299               PROC_FREG_MASK (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2300                                                        ptr + 12);
2301               PROC_REG_OFFSET (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2302                                                         ptr + 8);
2303               PROC_FREG_OFFSET (proc_desc)
2304                 = bfd_get_32 (sec->objfile->obfd, ptr + 16);
2305               PROC_PC_REG (proc_desc) = bfd_get_32 (sec->objfile->obfd,
2306                                                     ptr + 28);
2307               proc_desc->pdr.isym = (long) sym;
2308
2309               return proc_desc;
2310             }
2311         }
2312     }
2313
2314   if (b == NULL)
2315     return NULL;
2316
2317   if (startaddr > BLOCK_START (b))
2318     {
2319       /* This is the "pathological" case referred to in a comment in
2320          print_frame_info.  It might be better to move this check into
2321          symbol reading.  */
2322       return NULL;
2323     }
2324
2325   sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, 0, NULL);
2326
2327   /* If we never found a PDR for this function in symbol reading, then
2328      examine prologues to find the information.  */
2329   if (sym)
2330     {
2331       proc_desc = (mips_extra_func_info_t) SYMBOL_VALUE (sym);
2332       if (PROC_FRAME_REG (proc_desc) == -1)
2333         return NULL;
2334       else
2335         return proc_desc;
2336     }
2337   else
2338     return NULL;
2339 }
2340
2341
2342 static mips_extra_func_info_t
2343 find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame, int cur_frame)
2344 {
2345   mips_extra_func_info_t proc_desc;
2346   CORE_ADDR startaddr = 0;
2347
2348   proc_desc = non_heuristic_proc_desc (pc, &startaddr);
2349
2350   if (proc_desc)
2351     {
2352       /* IF this is the topmost frame AND
2353        * (this proc does not have debugging information OR
2354        * the PC is in the procedure prologue)
2355        * THEN create a "heuristic" proc_desc (by analyzing
2356        * the actual code) to replace the "official" proc_desc.
2357        */
2358       if (next_frame == NULL)
2359         {
2360           struct symtab_and_line val;
2361           struct symbol *proc_symbol =
2362             PROC_DESC_IS_DUMMY (proc_desc) ? 0 : PROC_SYMBOL (proc_desc);
2363
2364           if (proc_symbol)
2365             {
2366               val = find_pc_line (BLOCK_START
2367                                   (SYMBOL_BLOCK_VALUE (proc_symbol)),
2368                                   0);
2369               val.pc = val.end ? val.end : pc;
2370             }
2371           if (!proc_symbol || pc < val.pc)
2372             {
2373               mips_extra_func_info_t found_heuristic =
2374                 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
2375                                      pc, next_frame, cur_frame);
2376               if (found_heuristic)
2377                 proc_desc = found_heuristic;
2378             }
2379         }
2380     }
2381   else
2382     {
2383       /* Is linked_proc_desc_table really necessary?  It only seems to be used
2384          by procedure call dummys.  However, the procedures being called ought
2385          to have their own proc_descs, and even if they don't,
2386          heuristic_proc_desc knows how to create them! */
2387
2388       register struct linked_proc_info *link;
2389
2390       for (link = linked_proc_desc_table; link; link = link->next)
2391         if (PROC_LOW_ADDR (&link->info) <= pc
2392             && PROC_HIGH_ADDR (&link->info) > pc)
2393           return &link->info;
2394
2395       if (startaddr == 0)
2396         startaddr = heuristic_proc_start (pc);
2397
2398       proc_desc =
2399         heuristic_proc_desc (startaddr, pc, next_frame, cur_frame);
2400     }
2401   return proc_desc;
2402 }
2403
2404 static CORE_ADDR
2405 get_frame_pointer (struct frame_info *frame,
2406                    mips_extra_func_info_t proc_desc)
2407 {
2408   return ADDR_BITS_REMOVE (read_next_frame_reg (frame,
2409                                                 PROC_FRAME_REG (proc_desc)) +
2410                            PROC_FRAME_OFFSET (proc_desc) -
2411                            PROC_FRAME_ADJUST (proc_desc));
2412 }
2413
2414 static mips_extra_func_info_t cached_proc_desc;
2415
2416 static CORE_ADDR
2417 mips_frame_chain (struct frame_info *frame)
2418 {
2419   mips_extra_func_info_t proc_desc;
2420   CORE_ADDR tmp;
2421   CORE_ADDR saved_pc = FRAME_SAVED_PC (frame);
2422
2423   if (saved_pc == 0 || inside_entry_file (saved_pc))
2424     return 0;
2425
2426   /* Check if the PC is inside a call stub.  If it is, fetch the
2427      PC of the caller of that stub.  */
2428   if ((tmp = SKIP_TRAMPOLINE_CODE (saved_pc)) != 0)
2429     saved_pc = tmp;
2430
2431   if (USE_GENERIC_DUMMY_FRAMES
2432       && PC_IN_CALL_DUMMY (saved_pc, 0, 0))
2433     {
2434       /* A dummy frame, uses SP not FP.  Get the old SP value.  If all
2435          is well, frame->frame the bottom of the current frame will
2436          contain that value.  */
2437       return frame->frame;
2438     }
2439
2440   /* Look up the procedure descriptor for this PC.  */
2441   proc_desc = find_proc_desc (saved_pc, frame, 1);
2442   if (!proc_desc)
2443     return 0;
2444
2445   cached_proc_desc = proc_desc;
2446
2447   /* If no frame pointer and frame size is zero, we must be at end
2448      of stack (or otherwise hosed).  If we don't check frame size,
2449      we loop forever if we see a zero size frame.  */
2450   if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
2451       && PROC_FRAME_OFFSET (proc_desc) == 0
2452       /* The previous frame from a sigtramp frame might be frameless
2453          and have frame size zero.  */
2454       && !frame->signal_handler_caller
2455       /* For a generic dummy frame, let get_frame_pointer() unwind a
2456          register value saved as part of the dummy frame call.  */
2457       && !(USE_GENERIC_DUMMY_FRAMES
2458            && PC_IN_CALL_DUMMY (frame->pc, 0, 0)))
2459     return 0;
2460   else
2461     return get_frame_pointer (frame, proc_desc);
2462 }
2463
2464 static void
2465 mips_init_extra_frame_info (int fromleaf, struct frame_info *fci)
2466 {
2467   int regnum;
2468
2469   /* Use proc_desc calculated in frame_chain */
2470   mips_extra_func_info_t proc_desc =
2471     fci->next ? cached_proc_desc : find_proc_desc (fci->pc, fci->next, 1);
2472
2473   fci->extra_info = (struct frame_extra_info *)
2474     frame_obstack_alloc (sizeof (struct frame_extra_info));
2475
2476   fci->saved_regs = NULL;
2477   fci->extra_info->proc_desc =
2478     proc_desc == &temp_proc_desc ? 0 : proc_desc;
2479   if (proc_desc)
2480     {
2481       /* Fixup frame-pointer - only needed for top frame */
2482       /* This may not be quite right, if proc has a real frame register.
2483          Get the value of the frame relative sp, procedure might have been
2484          interrupted by a signal at it's very start.  */
2485       if (fci->pc == PROC_LOW_ADDR (proc_desc)
2486           && !PROC_DESC_IS_DUMMY (proc_desc))
2487         fci->frame = read_next_frame_reg (fci->next, SP_REGNUM);
2488       else if (USE_GENERIC_DUMMY_FRAMES
2489                && PC_IN_CALL_DUMMY (fci->pc, 0, 0))
2490         /* Do not ``fix'' fci->frame.  It will have the value of the
2491            generic dummy frame's top-of-stack (since the draft
2492            fci->frame is obtained by returning the unwound stack
2493            pointer) and that is what we want.  That way the fci->frame
2494            value will match the top-of-stack value that was saved as
2495            part of the dummy frames data.  */
2496         /* Do nothing.  */;
2497       else
2498         fci->frame = get_frame_pointer (fci->next, proc_desc);
2499
2500       if (proc_desc == &temp_proc_desc)
2501         {
2502           char *name;
2503
2504           /* Do not set the saved registers for a sigtramp frame,
2505              mips_find_saved_registers will do that for us.
2506              We can't use fci->signal_handler_caller, it is not yet set.  */
2507           find_pc_partial_function (fci->pc, &name,
2508                                     (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
2509           if (!PC_IN_SIGTRAMP (fci->pc, name))
2510             {
2511               frame_saved_regs_zalloc (fci);
2512               memcpy (fci->saved_regs, temp_saved_regs, SIZEOF_FRAME_SAVED_REGS);
2513               fci->saved_regs[PC_REGNUM]
2514                 = fci->saved_regs[RA_REGNUM];
2515               /* Set value of previous frame's stack pointer.  Remember that
2516                  saved_regs[SP_REGNUM] is special in that it contains the
2517                  value of the stack pointer register.  The other saved_regs
2518                  values are addresses (in the inferior) at which a given
2519                  register's value may be found.  */
2520               fci->saved_regs[SP_REGNUM] = fci->frame;
2521             }
2522         }
2523
2524       /* hack: if argument regs are saved, guess these contain args */
2525       /* assume we can't tell how many args for now */
2526       fci->extra_info->num_args = -1;
2527       for (regnum = MIPS_LAST_ARG_REGNUM; regnum >= A0_REGNUM; regnum--)
2528         {
2529           if (PROC_REG_MASK (proc_desc) & (1 << regnum))
2530             {
2531               fci->extra_info->num_args = regnum - A0_REGNUM + 1;
2532               break;
2533             }
2534         }
2535     }
2536 }
2537
2538 /* MIPS stack frames are almost impenetrable.  When execution stops,
2539    we basically have to look at symbol information for the function
2540    that we stopped in, which tells us *which* register (if any) is
2541    the base of the frame pointer, and what offset from that register
2542    the frame itself is at.
2543
2544    This presents a problem when trying to examine a stack in memory
2545    (that isn't executing at the moment), using the "frame" command.  We
2546    don't have a PC, nor do we have any registers except SP.
2547
2548    This routine takes two arguments, SP and PC, and tries to make the
2549    cached frames look as if these two arguments defined a frame on the
2550    cache.  This allows the rest of info frame to extract the important
2551    arguments without difficulty.  */
2552
2553 struct frame_info *
2554 setup_arbitrary_frame (int argc, CORE_ADDR *argv)
2555 {
2556   if (argc != 2)
2557     error ("MIPS frame specifications require two arguments: sp and pc");
2558
2559   return create_new_frame (argv[0], argv[1]);
2560 }
2561
2562 /* According to the current ABI, should the type be passed in a
2563    floating-point register (assuming that there is space)?  When there
2564    is no FPU, FP are not even considered as possibile candidates for
2565    FP registers and, consequently this returns false - forces FP
2566    arguments into integer registers. */
2567
2568 static int
2569 fp_register_arg_p (enum type_code typecode, struct type *arg_type)
2570 {
2571   return ((typecode == TYPE_CODE_FLT
2572            || (MIPS_EABI
2573                && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
2574                && TYPE_NFIELDS (arg_type) == 1
2575                && TYPE_CODE (TYPE_FIELD_TYPE (arg_type, 0)) == TYPE_CODE_FLT))
2576           && MIPS_FPU_TYPE != MIPS_FPU_NONE);
2577 }
2578
2579 /* On o32, argument passing in GPRs depends on the alignment of the type being
2580    passed.  Return 1 if this type must be aligned to a doubleword boundary. */
2581
2582 static int
2583 mips_type_needs_double_align (struct type *type)
2584 {
2585   enum type_code typecode = TYPE_CODE (type);
2586
2587   if (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)
2588     return 1;
2589   else if (typecode == TYPE_CODE_STRUCT)
2590     {
2591       if (TYPE_NFIELDS (type) < 1)
2592         return 0;
2593       return mips_type_needs_double_align (TYPE_FIELD_TYPE (type, 0));
2594     }
2595   else if (typecode == TYPE_CODE_UNION)
2596     {
2597       int i, n;
2598
2599       n = TYPE_NFIELDS (type);
2600       for (i = 0; i < n; i++)
2601         if (mips_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
2602           return 1;
2603       return 0;
2604     }
2605   return 0;
2606 }
2607
2608 /* Macros to round N up or down to the next A boundary;
2609    A must be a power of two.  */
2610
2611 #define ROUND_DOWN(n,a) ((n) & ~((a)-1))
2612 #define ROUND_UP(n,a) (((n)+(a)-1) & ~((a)-1))
2613
2614 /* Adjust the address downward (direction of stack growth) so that it
2615    is correctly aligned for a new stack frame.  */
2616 static CORE_ADDR
2617 mips_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2618 {
2619   return ROUND_DOWN (addr, 16);
2620 }
2621
2622 static CORE_ADDR
2623 mips_eabi_push_arguments (int nargs,
2624                           struct value **args,
2625                           CORE_ADDR sp,
2626                           int struct_return,
2627                           CORE_ADDR struct_addr)
2628 {
2629   int argreg;
2630   int float_argreg;
2631   int argnum;
2632   int len = 0;
2633   int stack_offset = 0;
2634
2635   /* First ensure that the stack and structure return address (if any)
2636      are properly aligned.  The stack has to be at least 64-bit
2637      aligned even on 32-bit machines, because doubles must be 64-bit
2638      aligned.  For n32 and n64, stack frames need to be 128-bit
2639      aligned, so we round to this widest known alignment.  */
2640
2641   sp = ROUND_DOWN (sp, 16);
2642   struct_addr = ROUND_DOWN (struct_addr, 16);
2643
2644   /* Now make space on the stack for the args.  We allocate more
2645      than necessary for EABI, because the first few arguments are
2646      passed in registers, but that's OK.  */
2647   for (argnum = 0; argnum < nargs; argnum++)
2648     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
2649                      MIPS_STACK_ARGSIZE);
2650   sp -= ROUND_UP (len, 16);
2651
2652   if (mips_debug)
2653     fprintf_unfiltered (gdb_stdlog,
2654                         "mips_eabi_push_arguments: sp=0x%s allocated %d\n",
2655                         paddr_nz (sp), ROUND_UP (len, 16));
2656
2657   /* Initialize the integer and float register pointers.  */
2658   argreg = A0_REGNUM;
2659   float_argreg = FPA0_REGNUM;
2660
2661   /* The struct_return pointer occupies the first parameter-passing reg.  */
2662   if (struct_return)
2663     {
2664       if (mips_debug)
2665         fprintf_unfiltered (gdb_stdlog,
2666                             "mips_eabi_push_arguments: struct_return reg=%d 0x%s\n",
2667                             argreg, paddr_nz (struct_addr));
2668       write_register (argreg++, struct_addr);
2669     }
2670
2671   /* Now load as many as possible of the first arguments into
2672      registers, and push the rest onto the stack.  Loop thru args
2673      from first to last.  */
2674   for (argnum = 0; argnum < nargs; argnum++)
2675     {
2676       char *val;
2677       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
2678       struct value *arg = args[argnum];
2679       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
2680       int len = TYPE_LENGTH (arg_type);
2681       enum type_code typecode = TYPE_CODE (arg_type);
2682
2683       if (mips_debug)
2684         fprintf_unfiltered (gdb_stdlog,
2685                             "mips_eabi_push_arguments: %d len=%d type=%d",
2686                             argnum + 1, len, (int) typecode);
2687
2688       /* The EABI passes structures that do not fit in a register by
2689          reference.  */
2690       if (len > MIPS_SAVED_REGSIZE
2691           && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
2692         {
2693           store_address (valbuf, MIPS_SAVED_REGSIZE, VALUE_ADDRESS (arg));
2694           typecode = TYPE_CODE_PTR;
2695           len = MIPS_SAVED_REGSIZE;
2696           val = valbuf;
2697           if (mips_debug)
2698             fprintf_unfiltered (gdb_stdlog, " push");
2699         }
2700       else
2701         val = (char *) VALUE_CONTENTS (arg);
2702
2703       /* 32-bit ABIs always start floating point arguments in an
2704          even-numbered floating point register.  Round the FP register
2705          up before the check to see if there are any FP registers
2706          left.  Non MIPS_EABI targets also pass the FP in the integer
2707          registers so also round up normal registers.  */
2708       if (!FP_REGISTER_DOUBLE
2709           && fp_register_arg_p (typecode, arg_type))
2710         {
2711           if ((float_argreg & 1))
2712             float_argreg++;
2713         }
2714
2715       /* Floating point arguments passed in registers have to be
2716          treated specially.  On 32-bit architectures, doubles
2717          are passed in register pairs; the even register gets
2718          the low word, and the odd register gets the high word.
2719          On non-EABI processors, the first two floating point arguments are
2720          also copied to general registers, because MIPS16 functions
2721          don't use float registers for arguments.  This duplication of
2722          arguments in general registers can't hurt non-MIPS16 functions
2723          because those registers are normally skipped.  */
2724       /* MIPS_EABI squeezes a struct that contains a single floating
2725          point value into an FP register instead of pushing it onto the
2726          stack.  */
2727       if (fp_register_arg_p (typecode, arg_type)
2728           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
2729         {
2730           if (!FP_REGISTER_DOUBLE && len == 8)
2731             {
2732               int low_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
2733               unsigned long regval;
2734
2735               /* Write the low word of the double to the even register(s).  */
2736               regval = extract_unsigned_integer (val + low_offset, 4);
2737               if (mips_debug)
2738                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2739                                     float_argreg, phex (regval, 4));
2740               write_register (float_argreg++, regval);
2741
2742               /* Write the high word of the double to the odd register(s).  */
2743               regval = extract_unsigned_integer (val + 4 - low_offset, 4);
2744               if (mips_debug)
2745                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2746                                     float_argreg, phex (regval, 4));
2747               write_register (float_argreg++, regval);
2748             }
2749           else
2750             {
2751               /* This is a floating point value that fits entirely
2752                  in a single register.  */
2753               /* On 32 bit ABI's the float_argreg is further adjusted
2754                  above to ensure that it is even register aligned.  */
2755               LONGEST regval = extract_unsigned_integer (val, len);
2756               if (mips_debug)
2757                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2758                                     float_argreg, phex (regval, len));
2759               write_register (float_argreg++, regval);
2760             }
2761         }
2762       else
2763         {
2764           /* Copy the argument to general registers or the stack in
2765              register-sized pieces.  Large arguments are split between
2766              registers and stack.  */
2767           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
2768              are treated specially: Irix cc passes them in registers
2769              where gcc sometimes puts them on the stack.  For maximum
2770              compatibility, we will put them in both places.  */
2771           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
2772                                   (len % MIPS_SAVED_REGSIZE != 0));
2773
2774           /* Note: Floating-point values that didn't fit into an FP
2775              register are only written to memory.  */
2776           while (len > 0)
2777             {
2778               /* Remember if the argument was written to the stack.  */
2779               int stack_used_p = 0;
2780               int partial_len =
2781                 len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
2782
2783               if (mips_debug)
2784                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
2785                                     partial_len);
2786
2787               /* Write this portion of the argument to the stack.  */
2788               if (argreg > MIPS_LAST_ARG_REGNUM
2789                   || odd_sized_struct
2790                   || fp_register_arg_p (typecode, arg_type))
2791                 {
2792                   /* Should shorter than int integer values be
2793                      promoted to int before being stored? */
2794                   int longword_offset = 0;
2795                   CORE_ADDR addr;
2796                   stack_used_p = 1;
2797                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2798                     {
2799                       if (MIPS_STACK_ARGSIZE == 8 &&
2800                           (typecode == TYPE_CODE_INT ||
2801                            typecode == TYPE_CODE_PTR ||
2802                            typecode == TYPE_CODE_FLT) && len <= 4)
2803                         longword_offset = MIPS_STACK_ARGSIZE - len;
2804                       else if ((typecode == TYPE_CODE_STRUCT ||
2805                                 typecode == TYPE_CODE_UNION) &&
2806                                TYPE_LENGTH (arg_type) < MIPS_STACK_ARGSIZE)
2807                         longword_offset = MIPS_STACK_ARGSIZE - len;
2808                     }
2809
2810                   if (mips_debug)
2811                     {
2812                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
2813                                           paddr_nz (stack_offset));
2814                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
2815                                           paddr_nz (longword_offset));
2816                     }
2817
2818                   addr = sp + stack_offset + longword_offset;
2819
2820                   if (mips_debug)
2821                     {
2822                       int i;
2823                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
2824                                           paddr_nz (addr));
2825                       for (i = 0; i < partial_len; i++)
2826                         {
2827                           fprintf_unfiltered (gdb_stdlog, "%02x",
2828                                               val[i] & 0xff);
2829                         }
2830                     }
2831                   write_memory (addr, val, partial_len);
2832                 }
2833
2834               /* Note!!! This is NOT an else clause.  Odd sized
2835                  structs may go thru BOTH paths.  Floating point
2836                  arguments will not.  */
2837               /* Write this portion of the argument to a general
2838                  purpose register.  */
2839               if (argreg <= MIPS_LAST_ARG_REGNUM
2840                   && !fp_register_arg_p (typecode, arg_type))
2841                 {
2842                   LONGEST regval = extract_unsigned_integer (val, partial_len);
2843
2844                   if (mips_debug)
2845                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
2846                                       argreg,
2847                                       phex (regval, MIPS_SAVED_REGSIZE));
2848                   write_register (argreg, regval);
2849                   argreg++;
2850                 }
2851
2852               len -= partial_len;
2853               val += partial_len;
2854
2855               /* Compute the the offset into the stack at which we
2856                  will copy the next parameter.
2857
2858                  In the new EABI (and the NABI32), the stack_offset
2859                  only needs to be adjusted when it has been used.  */
2860
2861               if (stack_used_p)
2862                 stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
2863             }
2864         }
2865       if (mips_debug)
2866         fprintf_unfiltered (gdb_stdlog, "\n");
2867     }
2868
2869   /* Return adjusted stack pointer.  */
2870   return sp;
2871 }
2872
2873 /* N32/N64 version of push_arguments.  */
2874
2875 static CORE_ADDR
2876 mips_n32n64_push_arguments (int nargs,
2877                             struct value **args,
2878                             CORE_ADDR sp,
2879                             int struct_return,
2880                             CORE_ADDR struct_addr)
2881 {
2882   int argreg;
2883   int float_argreg;
2884   int argnum;
2885   int len = 0;
2886   int stack_offset = 0;
2887
2888   /* First ensure that the stack and structure return address (if any)
2889      are properly aligned.  The stack has to be at least 64-bit
2890      aligned even on 32-bit machines, because doubles must be 64-bit
2891      aligned.  For n32 and n64, stack frames need to be 128-bit
2892      aligned, so we round to this widest known alignment.  */
2893
2894   sp = ROUND_DOWN (sp, 16);
2895   struct_addr = ROUND_DOWN (struct_addr, 16);
2896
2897   /* Now make space on the stack for the args.  */
2898   for (argnum = 0; argnum < nargs; argnum++)
2899     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
2900                      MIPS_STACK_ARGSIZE);
2901   sp -= ROUND_UP (len, 16);
2902
2903   if (mips_debug)
2904     fprintf_unfiltered (gdb_stdlog,
2905                         "mips_n32n64_push_arguments: sp=0x%s allocated %d\n",
2906                         paddr_nz (sp), ROUND_UP (len, 16));
2907
2908   /* Initialize the integer and float register pointers.  */
2909   argreg = A0_REGNUM;
2910   float_argreg = FPA0_REGNUM;
2911
2912   /* The struct_return pointer occupies the first parameter-passing reg.  */
2913   if (struct_return)
2914     {
2915       if (mips_debug)
2916         fprintf_unfiltered (gdb_stdlog,
2917                             "mips_n32n64_push_arguments: struct_return reg=%d 0x%s\n",
2918                             argreg, paddr_nz (struct_addr));
2919       write_register (argreg++, struct_addr);
2920     }
2921
2922   /* Now load as many as possible of the first arguments into
2923      registers, and push the rest onto the stack.  Loop thru args
2924      from first to last.  */
2925   for (argnum = 0; argnum < nargs; argnum++)
2926     {
2927       char *val;
2928       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
2929       struct value *arg = args[argnum];
2930       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
2931       int len = TYPE_LENGTH (arg_type);
2932       enum type_code typecode = TYPE_CODE (arg_type);
2933
2934       if (mips_debug)
2935         fprintf_unfiltered (gdb_stdlog,
2936                             "mips_n32n64_push_arguments: %d len=%d type=%d",
2937                             argnum + 1, len, (int) typecode);
2938
2939       val = (char *) VALUE_CONTENTS (arg);
2940
2941       if (fp_register_arg_p (typecode, arg_type)
2942           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
2943         {
2944           /* This is a floating point value that fits entirely
2945              in a single register.  */
2946           /* On 32 bit ABI's the float_argreg is further adjusted
2947              above to ensure that it is even register aligned.  */
2948           LONGEST regval = extract_unsigned_integer (val, len);
2949           if (mips_debug)
2950             fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
2951                                 float_argreg, phex (regval, len));
2952           write_register (float_argreg++, regval);
2953
2954           if (mips_debug)
2955             fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
2956                                 argreg, phex (regval, len));
2957           write_register (argreg, regval);
2958           argreg += 1;
2959         }
2960       else
2961         {
2962           /* Copy the argument to general registers or the stack in
2963              register-sized pieces.  Large arguments are split between
2964              registers and stack.  */
2965           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
2966              are treated specially: Irix cc passes them in registers
2967              where gcc sometimes puts them on the stack.  For maximum
2968              compatibility, we will put them in both places.  */
2969           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
2970                                   (len % MIPS_SAVED_REGSIZE != 0));
2971           /* Note: Floating-point values that didn't fit into an FP
2972              register are only written to memory.  */
2973           while (len > 0)
2974             {
2975               /* Rememer if the argument was written to the stack.  */
2976               int stack_used_p = 0;
2977               int partial_len = len < MIPS_SAVED_REGSIZE ?
2978                 len : MIPS_SAVED_REGSIZE;
2979
2980               if (mips_debug)
2981                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
2982                                     partial_len);
2983
2984               /* Write this portion of the argument to the stack.  */
2985               if (argreg > MIPS_LAST_ARG_REGNUM
2986                   || odd_sized_struct
2987                   || fp_register_arg_p (typecode, arg_type))
2988                 {
2989                   /* Should shorter than int integer values be
2990                      promoted to int before being stored? */
2991                   int longword_offset = 0;
2992                   CORE_ADDR addr;
2993                   stack_used_p = 1;
2994                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2995                     {
2996                       if (MIPS_STACK_ARGSIZE == 8 &&
2997                           (typecode == TYPE_CODE_INT ||
2998                            typecode == TYPE_CODE_PTR ||
2999                            typecode == TYPE_CODE_FLT) && len <= 4)
3000                         longword_offset = MIPS_STACK_ARGSIZE - len;
3001                     }
3002
3003                   if (mips_debug)
3004                     {
3005                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
3006                                           paddr_nz (stack_offset));
3007                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
3008                                           paddr_nz (longword_offset));
3009                     }
3010
3011                   addr = sp + stack_offset + longword_offset;
3012
3013                   if (mips_debug)
3014                     {
3015                       int i;
3016                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
3017                                           paddr_nz (addr));
3018                       for (i = 0; i < partial_len; i++)
3019                         {
3020                           fprintf_unfiltered (gdb_stdlog, "%02x",
3021                                               val[i] & 0xff);
3022                         }
3023                     }
3024                   write_memory (addr, val, partial_len);
3025                 }
3026
3027               /* Note!!! This is NOT an else clause.  Odd sized
3028                  structs may go thru BOTH paths.  Floating point
3029                  arguments will not.  */
3030               /* Write this portion of the argument to a general
3031                  purpose register.  */
3032               if (argreg <= MIPS_LAST_ARG_REGNUM
3033                   && !fp_register_arg_p (typecode, arg_type))
3034                 {
3035                   LONGEST regval = extract_unsigned_integer (val, partial_len);
3036
3037                   /* A non-floating-point argument being passed in a
3038                      general register.  If a struct or union, and if
3039                      the remaining length is smaller than the register
3040                      size, we have to adjust the register value on
3041                      big endian targets.
3042
3043                      It does not seem to be necessary to do the
3044                      same for integral types.
3045
3046                      cagney/2001-07-23: gdb/179: Also, GCC, when
3047                      outputting LE O32 with sizeof (struct) <
3048                      MIPS_SAVED_REGSIZE, generates a left shift as
3049                      part of storing the argument in a register a
3050                      register (the left shift isn't generated when
3051                      sizeof (struct) >= MIPS_SAVED_REGSIZE).  Since it
3052                      is quite possible that this is GCC contradicting
3053                      the LE/O32 ABI, GDB has not been adjusted to
3054                      accommodate this.  Either someone needs to
3055                      demonstrate that the LE/O32 ABI specifies such a
3056                      left shift OR this new ABI gets identified as
3057                      such and GDB gets tweaked accordingly.  */
3058
3059                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3060                       && partial_len < MIPS_SAVED_REGSIZE
3061                       && (typecode == TYPE_CODE_STRUCT ||
3062                           typecode == TYPE_CODE_UNION))
3063                     regval <<= ((MIPS_SAVED_REGSIZE - partial_len) *
3064                                 TARGET_CHAR_BIT);
3065
3066                   if (mips_debug)
3067                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
3068                                       argreg,
3069                                       phex (regval, MIPS_SAVED_REGSIZE));
3070                   write_register (argreg, regval);
3071                   argreg++;
3072                 }
3073
3074               len -= partial_len;
3075               val += partial_len;
3076
3077               /* Compute the the offset into the stack at which we
3078                  will copy the next parameter.
3079
3080                  In N32 (N64?), the stack_offset only needs to be
3081                  adjusted when it has been used.  */
3082
3083               if (stack_used_p)
3084                 stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
3085             }
3086         }
3087       if (mips_debug)
3088         fprintf_unfiltered (gdb_stdlog, "\n");
3089     }
3090
3091   /* Return adjusted stack pointer.  */
3092   return sp;
3093 }
3094
3095 /* O32 version of push_arguments.  */
3096
3097 static CORE_ADDR
3098 mips_o32_push_arguments (int nargs,
3099                          struct value **args,
3100                          CORE_ADDR sp,
3101                          int struct_return,
3102                          CORE_ADDR struct_addr)
3103 {
3104   int argreg;
3105   int float_argreg;
3106   int argnum;
3107   int len = 0;
3108   int stack_offset = 0;
3109
3110   /* First ensure that the stack and structure return address (if any)
3111      are properly aligned.  The stack has to be at least 64-bit
3112      aligned even on 32-bit machines, because doubles must be 64-bit
3113      aligned.  For n32 and n64, stack frames need to be 128-bit
3114      aligned, so we round to this widest known alignment.  */
3115
3116   sp = ROUND_DOWN (sp, 16);
3117   struct_addr = ROUND_DOWN (struct_addr, 16);
3118
3119   /* Now make space on the stack for the args.  */
3120   for (argnum = 0; argnum < nargs; argnum++)
3121     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
3122                      MIPS_STACK_ARGSIZE);
3123   sp -= ROUND_UP (len, 16);
3124
3125   if (mips_debug)
3126     fprintf_unfiltered (gdb_stdlog,
3127                         "mips_o32_push_arguments: sp=0x%s allocated %d\n",
3128                         paddr_nz (sp), ROUND_UP (len, 16));
3129
3130   /* Initialize the integer and float register pointers.  */
3131   argreg = A0_REGNUM;
3132   float_argreg = FPA0_REGNUM;
3133
3134   /* The struct_return pointer occupies the first parameter-passing reg.  */
3135   if (struct_return)
3136     {
3137       if (mips_debug)
3138         fprintf_unfiltered (gdb_stdlog,
3139                             "mips_o32_push_arguments: struct_return reg=%d 0x%s\n",
3140                             argreg, paddr_nz (struct_addr));
3141       write_register (argreg++, struct_addr);
3142       stack_offset += MIPS_STACK_ARGSIZE;
3143     }
3144
3145   /* Now load as many as possible of the first arguments into
3146      registers, and push the rest onto the stack.  Loop thru args
3147      from first to last.  */
3148   for (argnum = 0; argnum < nargs; argnum++)
3149     {
3150       char *val;
3151       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
3152       struct value *arg = args[argnum];
3153       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
3154       int len = TYPE_LENGTH (arg_type);
3155       enum type_code typecode = TYPE_CODE (arg_type);
3156
3157       if (mips_debug)
3158         fprintf_unfiltered (gdb_stdlog,
3159                             "mips_o32_push_arguments: %d len=%d type=%d",
3160                             argnum + 1, len, (int) typecode);
3161
3162       val = (char *) VALUE_CONTENTS (arg);
3163
3164       /* 32-bit ABIs always start floating point arguments in an
3165          even-numbered floating point register.  Round the FP register
3166          up before the check to see if there are any FP registers
3167          left.  O32/O64 targets also pass the FP in the integer
3168          registers so also round up normal registers.  */
3169       if (!FP_REGISTER_DOUBLE
3170           && fp_register_arg_p (typecode, arg_type))
3171         {
3172           if ((float_argreg & 1))
3173             float_argreg++;
3174         }
3175
3176       /* Floating point arguments passed in registers have to be
3177          treated specially.  On 32-bit architectures, doubles
3178          are passed in register pairs; the even register gets
3179          the low word, and the odd register gets the high word.
3180          On O32/O64, the first two floating point arguments are
3181          also copied to general registers, because MIPS16 functions
3182          don't use float registers for arguments.  This duplication of
3183          arguments in general registers can't hurt non-MIPS16 functions
3184          because those registers are normally skipped.  */
3185
3186       if (fp_register_arg_p (typecode, arg_type)
3187           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
3188         {
3189           if (!FP_REGISTER_DOUBLE && len == 8)
3190             {
3191               int low_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
3192               unsigned long regval;
3193
3194               /* Write the low word of the double to the even register(s).  */
3195               regval = extract_unsigned_integer (val + low_offset, 4);
3196               if (mips_debug)
3197                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3198                                     float_argreg, phex (regval, 4));
3199               write_register (float_argreg++, regval);
3200               if (mips_debug)
3201                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3202                                     argreg, phex (regval, 4));
3203               write_register (argreg++, regval);
3204
3205               /* Write the high word of the double to the odd register(s).  */
3206               regval = extract_unsigned_integer (val + 4 - low_offset, 4);
3207               if (mips_debug)
3208                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3209                                     float_argreg, phex (regval, 4));
3210               write_register (float_argreg++, regval);
3211
3212               if (mips_debug)
3213                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3214                                     argreg, phex (regval, 4));
3215               write_register (argreg++, regval);
3216             }
3217           else
3218             {
3219               /* This is a floating point value that fits entirely
3220                  in a single register.  */
3221               /* On 32 bit ABI's the float_argreg is further adjusted
3222                  above to ensure that it is even register aligned.  */
3223               LONGEST regval = extract_unsigned_integer (val, len);
3224               if (mips_debug)
3225                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3226                                     float_argreg, phex (regval, len));
3227               write_register (float_argreg++, regval);
3228               /* CAGNEY: 32 bit MIPS ABI's always reserve two FP
3229                  registers for each argument.  The below is (my
3230                  guess) to ensure that the corresponding integer
3231                  register has reserved the same space.  */
3232               if (mips_debug)
3233                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3234                                     argreg, phex (regval, len));
3235               write_register (argreg, regval);
3236               argreg += FP_REGISTER_DOUBLE ? 1 : 2;
3237             }
3238           /* Reserve space for the FP register.  */
3239           stack_offset += ROUND_UP (len, MIPS_STACK_ARGSIZE);
3240         }
3241       else
3242         {
3243           /* Copy the argument to general registers or the stack in
3244              register-sized pieces.  Large arguments are split between
3245              registers and stack.  */
3246           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
3247              are treated specially: Irix cc passes them in registers
3248              where gcc sometimes puts them on the stack.  For maximum
3249              compatibility, we will put them in both places.  */
3250           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
3251                                   (len % MIPS_SAVED_REGSIZE != 0));
3252           /* Structures should be aligned to eight bytes (even arg registers)
3253              on MIPS_ABI_O32, if their first member has double precision.  */
3254           if (MIPS_SAVED_REGSIZE < 8
3255               && mips_type_needs_double_align (arg_type))
3256             {
3257               if ((argreg & 1))
3258                 argreg++;
3259             }
3260           /* Note: Floating-point values that didn't fit into an FP
3261              register are only written to memory.  */
3262           while (len > 0)
3263             {
3264               /* Remember if the argument was written to the stack.  */
3265               int stack_used_p = 0;
3266               int partial_len =
3267                 len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
3268
3269               if (mips_debug)
3270                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
3271                                     partial_len);
3272
3273               /* Write this portion of the argument to the stack.  */
3274               if (argreg > MIPS_LAST_ARG_REGNUM
3275                   || odd_sized_struct
3276                   || fp_register_arg_p (typecode, arg_type))
3277                 {
3278                   /* Should shorter than int integer values be
3279                      promoted to int before being stored? */
3280                   int longword_offset = 0;
3281                   CORE_ADDR addr;
3282                   stack_used_p = 1;
3283                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3284                     {
3285                       if (MIPS_STACK_ARGSIZE == 8 &&
3286                           (typecode == TYPE_CODE_INT ||
3287                            typecode == TYPE_CODE_PTR ||
3288                            typecode == TYPE_CODE_FLT) && len <= 4)
3289                         longword_offset = MIPS_STACK_ARGSIZE - len;
3290                     }
3291
3292                   if (mips_debug)
3293                     {
3294                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
3295                                           paddr_nz (stack_offset));
3296                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
3297                                           paddr_nz (longword_offset));
3298                     }
3299
3300                   addr = sp + stack_offset + longword_offset;
3301
3302                   if (mips_debug)
3303                     {
3304                       int i;
3305                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
3306                                           paddr_nz (addr));
3307                       for (i = 0; i < partial_len; i++)
3308                         {
3309                           fprintf_unfiltered (gdb_stdlog, "%02x",
3310                                               val[i] & 0xff);
3311                         }
3312                     }
3313                   write_memory (addr, val, partial_len);
3314                 }
3315
3316               /* Note!!! This is NOT an else clause.  Odd sized
3317                  structs may go thru BOTH paths.  Floating point
3318                  arguments will not.  */
3319               /* Write this portion of the argument to a general
3320                  purpose register.  */
3321               if (argreg <= MIPS_LAST_ARG_REGNUM
3322                   && !fp_register_arg_p (typecode, arg_type))
3323                 {
3324                   LONGEST regval = extract_signed_integer (val, partial_len);
3325                   /* Value may need to be sign extended, because
3326                      MIPS_REGSIZE != MIPS_SAVED_REGSIZE.  */
3327
3328                   /* A non-floating-point argument being passed in a
3329                      general register.  If a struct or union, and if
3330                      the remaining length is smaller than the register
3331                      size, we have to adjust the register value on
3332                      big endian targets.
3333
3334                      It does not seem to be necessary to do the
3335                      same for integral types.
3336
3337                      Also don't do this adjustment on O64 binaries.
3338
3339                      cagney/2001-07-23: gdb/179: Also, GCC, when
3340                      outputting LE O32 with sizeof (struct) <
3341                      MIPS_SAVED_REGSIZE, generates a left shift as
3342                      part of storing the argument in a register a
3343                      register (the left shift isn't generated when
3344                      sizeof (struct) >= MIPS_SAVED_REGSIZE).  Since it
3345                      is quite possible that this is GCC contradicting
3346                      the LE/O32 ABI, GDB has not been adjusted to
3347                      accommodate this.  Either someone needs to
3348                      demonstrate that the LE/O32 ABI specifies such a
3349                      left shift OR this new ABI gets identified as
3350                      such and GDB gets tweaked accordingly.  */
3351
3352                   if (MIPS_SAVED_REGSIZE < 8
3353                       && TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3354                       && partial_len < MIPS_SAVED_REGSIZE
3355                       && (typecode == TYPE_CODE_STRUCT ||
3356                           typecode == TYPE_CODE_UNION))
3357                     regval <<= ((MIPS_SAVED_REGSIZE - partial_len) *
3358                                 TARGET_CHAR_BIT);
3359
3360                   if (mips_debug)
3361                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
3362                                       argreg,
3363                                       phex (regval, MIPS_SAVED_REGSIZE));
3364                   write_register (argreg, regval);
3365                   argreg++;
3366
3367                   /* Prevent subsequent floating point arguments from
3368                      being passed in floating point registers.  */
3369                   float_argreg = MIPS_LAST_FP_ARG_REGNUM + 1;
3370                 }
3371
3372               len -= partial_len;
3373               val += partial_len;
3374
3375               /* Compute the the offset into the stack at which we
3376                  will copy the next parameter.
3377
3378                  In older ABIs, the caller reserved space for
3379                  registers that contained arguments.  This was loosely
3380                  refered to as their "home".  Consequently, space is
3381                  always allocated.  */
3382
3383               stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
3384             }
3385         }
3386       if (mips_debug)
3387         fprintf_unfiltered (gdb_stdlog, "\n");
3388     }
3389
3390   /* Return adjusted stack pointer.  */
3391   return sp;
3392 }
3393
3394 /* O64 version of push_arguments.  */
3395
3396 static CORE_ADDR
3397 mips_o64_push_arguments (int nargs,
3398                          struct value **args,
3399                          CORE_ADDR sp,
3400                          int struct_return,
3401                          CORE_ADDR struct_addr)
3402 {
3403   int argreg;
3404   int float_argreg;
3405   int argnum;
3406   int len = 0;
3407   int stack_offset = 0;
3408
3409   /* First ensure that the stack and structure return address (if any)
3410      are properly aligned.  The stack has to be at least 64-bit
3411      aligned even on 32-bit machines, because doubles must be 64-bit
3412      aligned.  For n32 and n64, stack frames need to be 128-bit
3413      aligned, so we round to this widest known alignment.  */
3414
3415   sp = ROUND_DOWN (sp, 16);
3416   struct_addr = ROUND_DOWN (struct_addr, 16);
3417
3418   /* Now make space on the stack for the args.  */
3419   for (argnum = 0; argnum < nargs; argnum++)
3420     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])),
3421                      MIPS_STACK_ARGSIZE);
3422   sp -= ROUND_UP (len, 16);
3423
3424   if (mips_debug)
3425     fprintf_unfiltered (gdb_stdlog,
3426                         "mips_o64_push_arguments: sp=0x%s allocated %d\n",
3427                         paddr_nz (sp), ROUND_UP (len, 16));
3428
3429   /* Initialize the integer and float register pointers.  */
3430   argreg = A0_REGNUM;
3431   float_argreg = FPA0_REGNUM;
3432
3433   /* The struct_return pointer occupies the first parameter-passing reg.  */
3434   if (struct_return)
3435     {
3436       if (mips_debug)
3437         fprintf_unfiltered (gdb_stdlog,
3438                             "mips_o64_push_arguments: struct_return reg=%d 0x%s\n",
3439                             argreg, paddr_nz (struct_addr));
3440       write_register (argreg++, struct_addr);
3441       stack_offset += MIPS_STACK_ARGSIZE;
3442     }
3443
3444   /* Now load as many as possible of the first arguments into
3445      registers, and push the rest onto the stack.  Loop thru args
3446      from first to last.  */
3447   for (argnum = 0; argnum < nargs; argnum++)
3448     {
3449       char *val;
3450       char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
3451       struct value *arg = args[argnum];
3452       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
3453       int len = TYPE_LENGTH (arg_type);
3454       enum type_code typecode = TYPE_CODE (arg_type);
3455
3456       if (mips_debug)
3457         fprintf_unfiltered (gdb_stdlog,
3458                             "mips_o64_push_arguments: %d len=%d type=%d",
3459                             argnum + 1, len, (int) typecode);
3460
3461       val = (char *) VALUE_CONTENTS (arg);
3462
3463       /* 32-bit ABIs always start floating point arguments in an
3464          even-numbered floating point register.  Round the FP register
3465          up before the check to see if there are any FP registers
3466          left.  O32/O64 targets also pass the FP in the integer
3467          registers so also round up normal registers.  */
3468       if (!FP_REGISTER_DOUBLE
3469           && fp_register_arg_p (typecode, arg_type))
3470         {
3471           if ((float_argreg & 1))
3472             float_argreg++;
3473         }
3474
3475       /* Floating point arguments passed in registers have to be
3476          treated specially.  On 32-bit architectures, doubles
3477          are passed in register pairs; the even register gets
3478          the low word, and the odd register gets the high word.
3479          On O32/O64, the first two floating point arguments are
3480          also copied to general registers, because MIPS16 functions
3481          don't use float registers for arguments.  This duplication of
3482          arguments in general registers can't hurt non-MIPS16 functions
3483          because those registers are normally skipped.  */
3484
3485       if (fp_register_arg_p (typecode, arg_type)
3486           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
3487         {
3488           if (!FP_REGISTER_DOUBLE && len == 8)
3489             {
3490               int low_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
3491               unsigned long regval;
3492
3493               /* Write the low word of the double to the even register(s).  */
3494               regval = extract_unsigned_integer (val + low_offset, 4);
3495               if (mips_debug)
3496                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3497                                     float_argreg, phex (regval, 4));
3498               write_register (float_argreg++, regval);
3499               if (mips_debug)
3500                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3501                                     argreg, phex (regval, 4));
3502               write_register (argreg++, regval);
3503
3504               /* Write the high word of the double to the odd register(s).  */
3505               regval = extract_unsigned_integer (val + 4 - low_offset, 4);
3506               if (mips_debug)
3507                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3508                                     float_argreg, phex (regval, 4));
3509               write_register (float_argreg++, regval);
3510
3511               if (mips_debug)
3512                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3513                                     argreg, phex (regval, 4));
3514               write_register (argreg++, regval);
3515             }
3516           else
3517             {
3518               /* This is a floating point value that fits entirely
3519                  in a single register.  */
3520               /* On 32 bit ABI's the float_argreg is further adjusted
3521                  above to ensure that it is even register aligned.  */
3522               LONGEST regval = extract_unsigned_integer (val, len);
3523               if (mips_debug)
3524                 fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
3525                                     float_argreg, phex (regval, len));
3526               write_register (float_argreg++, regval);
3527               /* CAGNEY: 32 bit MIPS ABI's always reserve two FP
3528                  registers for each argument.  The below is (my
3529                  guess) to ensure that the corresponding integer
3530                  register has reserved the same space.  */
3531               if (mips_debug)
3532                 fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
3533                                     argreg, phex (regval, len));
3534               write_register (argreg, regval);
3535               argreg += FP_REGISTER_DOUBLE ? 1 : 2;
3536             }
3537           /* Reserve space for the FP register.  */
3538           stack_offset += ROUND_UP (len, MIPS_STACK_ARGSIZE);
3539         }
3540       else
3541         {
3542           /* Copy the argument to general registers or the stack in
3543              register-sized pieces.  Large arguments are split between
3544              registers and stack.  */
3545           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
3546              are treated specially: Irix cc passes them in registers
3547              where gcc sometimes puts them on the stack.  For maximum
3548              compatibility, we will put them in both places.  */
3549           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
3550                                   (len % MIPS_SAVED_REGSIZE != 0));
3551           /* Structures should be aligned to eight bytes (even arg registers)
3552              on MIPS_ABI_O32, if their first member has double precision.  */
3553           if (MIPS_SAVED_REGSIZE < 8
3554               && mips_type_needs_double_align (arg_type))
3555             {
3556               if ((argreg & 1))
3557                 argreg++;
3558             }
3559           /* Note: Floating-point values that didn't fit into an FP
3560              register are only written to memory.  */
3561           while (len > 0)
3562             {
3563               /* Remember if the argument was written to the stack.  */
3564               int stack_used_p = 0;
3565               int partial_len =
3566                 len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
3567
3568               if (mips_debug)
3569                 fprintf_unfiltered (gdb_stdlog, " -- partial=%d",
3570                                     partial_len);
3571
3572               /* Write this portion of the argument to the stack.  */
3573               if (argreg > MIPS_LAST_ARG_REGNUM
3574                   || odd_sized_struct
3575                   || fp_register_arg_p (typecode, arg_type))
3576                 {
3577                   /* Should shorter than int integer values be
3578                      promoted to int before being stored? */
3579                   int longword_offset = 0;
3580                   CORE_ADDR addr;
3581                   stack_used_p = 1;
3582                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3583                     {
3584                       if (MIPS_STACK_ARGSIZE == 8 &&
3585                           (typecode == TYPE_CODE_INT ||
3586                            typecode == TYPE_CODE_PTR ||
3587                            typecode == TYPE_CODE_FLT) && len <= 4)
3588                         longword_offset = MIPS_STACK_ARGSIZE - len;
3589                     }
3590
3591                   if (mips_debug)
3592                     {
3593                       fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
3594                                           paddr_nz (stack_offset));
3595                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
3596                                           paddr_nz (longword_offset));
3597                     }
3598
3599                   addr = sp + stack_offset + longword_offset;
3600
3601                   if (mips_debug)
3602                     {
3603                       int i;
3604                       fprintf_unfiltered (gdb_stdlog, " @0x%s ",
3605                                           paddr_nz (addr));
3606                       for (i = 0; i < partial_len; i++)
3607                         {
3608                           fprintf_unfiltered (gdb_stdlog, "%02x",
3609                                               val[i] & 0xff);
3610                         }
3611                     }
3612                   write_memory (addr, val, partial_len);
3613                 }
3614
3615               /* Note!!! This is NOT an else clause.  Odd sized
3616                  structs may go thru BOTH paths.  Floating point
3617                  arguments will not.  */
3618               /* Write this portion of the argument to a general
3619                  purpose register.  */
3620               if (argreg <= MIPS_LAST_ARG_REGNUM
3621                   && !fp_register_arg_p (typecode, arg_type))
3622                 {
3623                   LONGEST regval = extract_signed_integer (val, partial_len);
3624                   /* Value may need to be sign extended, because
3625                      MIPS_REGSIZE != MIPS_SAVED_REGSIZE.  */
3626
3627                   /* A non-floating-point argument being passed in a
3628                      general register.  If a struct or union, and if
3629                      the remaining length is smaller than the register
3630                      size, we have to adjust the register value on
3631                      big endian targets.
3632
3633                      It does not seem to be necessary to do the
3634                      same for integral types.
3635
3636                      Also don't do this adjustment on O64 binaries.
3637
3638                      cagney/2001-07-23: gdb/179: Also, GCC, when
3639                      outputting LE O32 with sizeof (struct) <
3640                      MIPS_SAVED_REGSIZE, generates a left shift as
3641                      part of storing the argument in a register a
3642                      register (the left shift isn't generated when
3643                      sizeof (struct) >= MIPS_SAVED_REGSIZE).  Since it
3644                      is quite possible that this is GCC contradicting
3645                      the LE/O32 ABI, GDB has not been adjusted to
3646                      accommodate this.  Either someone needs to
3647                      demonstrate that the LE/O32 ABI specifies such a
3648                      left shift OR this new ABI gets identified as
3649                      such and GDB gets tweaked accordingly.  */
3650
3651                   if (MIPS_SAVED_REGSIZE < 8
3652                       && TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3653                       && partial_len < MIPS_SAVED_REGSIZE
3654                       && (typecode == TYPE_CODE_STRUCT ||
3655                           typecode == TYPE_CODE_UNION))
3656                     regval <<= ((MIPS_SAVED_REGSIZE - partial_len) *
3657                                 TARGET_CHAR_BIT);
3658
3659                   if (mips_debug)
3660                     fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
3661                                       argreg,
3662                                       phex (regval, MIPS_SAVED_REGSIZE));
3663                   write_register (argreg, regval);
3664                   argreg++;
3665
3666                   /* Prevent subsequent floating point arguments from
3667                      being passed in floating point registers.  */
3668                   float_argreg = MIPS_LAST_FP_ARG_REGNUM + 1;
3669                 }
3670
3671               len -= partial_len;
3672               val += partial_len;
3673
3674               /* Compute the the offset into the stack at which we
3675                  will copy the next parameter.
3676
3677                  In older ABIs, the caller reserved space for
3678                  registers that contained arguments.  This was loosely
3679                  refered to as their "home".  Consequently, space is
3680                  always allocated.  */
3681
3682               stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
3683             }
3684         }
3685       if (mips_debug)
3686         fprintf_unfiltered (gdb_stdlog, "\n");
3687     }
3688
3689   /* Return adjusted stack pointer.  */
3690   return sp;
3691 }
3692
3693 static CORE_ADDR
3694 mips_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
3695 {
3696   /* Set the return address register to point to the entry
3697      point of the program, where a breakpoint lies in wait.  */
3698   write_register (RA_REGNUM, CALL_DUMMY_ADDRESS ());
3699   return sp;
3700 }
3701
3702 static void
3703 mips_push_register (CORE_ADDR * sp, int regno)
3704 {
3705   char *buffer = alloca (MAX_REGISTER_RAW_SIZE);
3706   int regsize;
3707   int offset;
3708   if (MIPS_SAVED_REGSIZE < REGISTER_RAW_SIZE (regno))
3709     {
3710       regsize = MIPS_SAVED_REGSIZE;
3711       offset = (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3712                 ? REGISTER_RAW_SIZE (regno) - MIPS_SAVED_REGSIZE
3713                 : 0);
3714     }
3715   else
3716     {
3717       regsize = REGISTER_RAW_SIZE (regno);
3718       offset = 0;
3719     }
3720   *sp -= regsize;
3721   deprecated_read_register_gen (regno, buffer);
3722   write_memory (*sp, buffer + offset, regsize);
3723 }
3724
3725 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<(MIPS_NUMREGS-1). */
3726 #define MASK(i,j) (((1 << ((j)+1))-1) ^ ((1 << (i))-1))
3727
3728 static void
3729 mips_push_dummy_frame (void)
3730 {
3731   int ireg;
3732   struct linked_proc_info *link = (struct linked_proc_info *)
3733   xmalloc (sizeof (struct linked_proc_info));
3734   mips_extra_func_info_t proc_desc = &link->info;
3735   CORE_ADDR sp = ADDR_BITS_REMOVE (read_signed_register (SP_REGNUM));
3736   CORE_ADDR old_sp = sp;
3737   link->next = linked_proc_desc_table;
3738   linked_proc_desc_table = link;
3739
3740 /* FIXME!   are these correct ? */
3741 #define PUSH_FP_REGNUM 16       /* must be a register preserved across calls */
3742 #define GEN_REG_SAVE_MASK MASK(1,16)|MASK(24,28)|(1<<(MIPS_NUMREGS-1))
3743 #define FLOAT_REG_SAVE_MASK MASK(0,19)
3744 #define FLOAT_SINGLE_REG_SAVE_MASK \
3745   ((1<<18)|(1<<16)|(1<<14)|(1<<12)|(1<<10)|(1<<8)|(1<<6)|(1<<4)|(1<<2)|(1<<0))
3746   /*
3747    * The registers we must save are all those not preserved across
3748    * procedure calls. Dest_Reg (see tm-mips.h) must also be saved.
3749    * In addition, we must save the PC, PUSH_FP_REGNUM, MMLO/-HI
3750    * and FP Control/Status registers.
3751    *
3752    *
3753    * Dummy frame layout:
3754    *  (high memory)
3755    *    Saved PC
3756    *    Saved MMHI, MMLO, FPC_CSR
3757    *    Saved R31
3758    *    Saved R28
3759    *    ...
3760    *    Saved R1
3761    *    Saved D18 (i.e. F19, F18)
3762    *    ...
3763    *    Saved D0 (i.e. F1, F0)
3764    *    Argument build area and stack arguments written via mips_push_arguments
3765    *  (low memory)
3766    */
3767
3768   /* Save special registers (PC, MMHI, MMLO, FPC_CSR) */
3769   PROC_FRAME_REG (proc_desc) = PUSH_FP_REGNUM;
3770   PROC_FRAME_OFFSET (proc_desc) = 0;
3771   PROC_FRAME_ADJUST (proc_desc) = 0;
3772   mips_push_register (&sp, PC_REGNUM);
3773   mips_push_register (&sp, HI_REGNUM);
3774   mips_push_register (&sp, LO_REGNUM);
3775   mips_push_register (&sp, MIPS_FPU_TYPE == MIPS_FPU_NONE ? 0 : FCRCS_REGNUM);
3776
3777   /* Save general CPU registers */
3778   PROC_REG_MASK (proc_desc) = GEN_REG_SAVE_MASK;
3779   /* PROC_REG_OFFSET is the offset of the first saved register from FP.  */
3780   PROC_REG_OFFSET (proc_desc) = sp - old_sp - MIPS_SAVED_REGSIZE;
3781   for (ireg = 32; --ireg >= 0;)
3782     if (PROC_REG_MASK (proc_desc) & (1 << ireg))
3783       mips_push_register (&sp, ireg);
3784
3785   /* Save floating point registers starting with high order word */
3786   PROC_FREG_MASK (proc_desc) =
3787     MIPS_FPU_TYPE == MIPS_FPU_DOUBLE ? FLOAT_REG_SAVE_MASK
3788     : MIPS_FPU_TYPE == MIPS_FPU_SINGLE ? FLOAT_SINGLE_REG_SAVE_MASK : 0;
3789   /* PROC_FREG_OFFSET is the offset of the first saved *double* register
3790      from FP.  */
3791   PROC_FREG_OFFSET (proc_desc) = sp - old_sp - 8;
3792   for (ireg = 32; --ireg >= 0;)
3793     if (PROC_FREG_MASK (proc_desc) & (1 << ireg))
3794       mips_push_register (&sp, ireg + FP0_REGNUM);
3795
3796   /* Update the frame pointer for the call dummy and the stack pointer.
3797      Set the procedure's starting and ending addresses to point to the
3798      call dummy address at the entry point.  */
3799   write_register (PUSH_FP_REGNUM, old_sp);
3800   write_register (SP_REGNUM, sp);
3801   PROC_LOW_ADDR (proc_desc) = CALL_DUMMY_ADDRESS ();
3802   PROC_HIGH_ADDR (proc_desc) = CALL_DUMMY_ADDRESS () + 4;
3803   SET_PROC_DESC_IS_DUMMY (proc_desc);
3804   PROC_PC_REG (proc_desc) = RA_REGNUM;
3805 }
3806
3807 static void
3808 mips_pop_frame (void)
3809 {
3810   register int regnum;
3811   struct frame_info *frame = get_current_frame ();
3812   CORE_ADDR new_sp = FRAME_FP (frame);
3813   mips_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
3814
3815   if (USE_GENERIC_DUMMY_FRAMES
3816       && PC_IN_CALL_DUMMY (frame->pc, 0, 0))
3817     {
3818       generic_pop_dummy_frame ();
3819       flush_cached_frames ();
3820       return;
3821     }
3822
3823   write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
3824   if (frame->saved_regs == NULL)
3825     FRAME_INIT_SAVED_REGS (frame);
3826   for (regnum = 0; regnum < NUM_REGS; regnum++)
3827     if (regnum != SP_REGNUM && regnum != PC_REGNUM
3828         && frame->saved_regs[regnum])
3829       {
3830         /* Floating point registers must not be sign extended,
3831            in case MIPS_SAVED_REGSIZE = 4 but sizeof (FP0_REGNUM) == 8.  */
3832
3833         if (FP0_REGNUM <= regnum && regnum < FP0_REGNUM + 32)
3834           write_register (regnum,
3835                           read_memory_unsigned_integer (frame->saved_regs[regnum],
3836                                                         MIPS_SAVED_REGSIZE));
3837         else
3838           write_register (regnum,
3839                           read_memory_integer (frame->saved_regs[regnum],
3840                                                MIPS_SAVED_REGSIZE));
3841       }
3842
3843   write_register (SP_REGNUM, new_sp);
3844   flush_cached_frames ();
3845
3846   if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))
3847     {
3848       struct linked_proc_info *pi_ptr, *prev_ptr;
3849
3850       for (pi_ptr = linked_proc_desc_table, prev_ptr = NULL;
3851            pi_ptr != NULL;
3852            prev_ptr = pi_ptr, pi_ptr = pi_ptr->next)
3853         {
3854           if (&pi_ptr->info == proc_desc)
3855             break;
3856         }
3857
3858       if (pi_ptr == NULL)
3859         error ("Can't locate dummy extra frame info\n");
3860
3861       if (prev_ptr != NULL)
3862         prev_ptr->next = pi_ptr->next;
3863       else
3864         linked_proc_desc_table = pi_ptr->next;
3865
3866       xfree (pi_ptr);
3867
3868       write_register (HI_REGNUM,
3869                       read_memory_integer (new_sp - 2 * MIPS_SAVED_REGSIZE,
3870                                            MIPS_SAVED_REGSIZE));
3871       write_register (LO_REGNUM,
3872                       read_memory_integer (new_sp - 3 * MIPS_SAVED_REGSIZE,
3873                                            MIPS_SAVED_REGSIZE));
3874       if (MIPS_FPU_TYPE != MIPS_FPU_NONE)
3875         write_register (FCRCS_REGNUM,
3876                         read_memory_integer (new_sp - 4 * MIPS_SAVED_REGSIZE,
3877                                              MIPS_SAVED_REGSIZE));
3878     }
3879 }
3880
3881 static void
3882 mips_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
3883                      struct value **args, struct type *type, int gcc_p)
3884 {
3885   write_register(T9_REGNUM, fun);
3886 }
3887
3888 /* Floating point register management.
3889
3890    Background: MIPS1 & 2 fp registers are 32 bits wide.  To support
3891    64bit operations, these early MIPS cpus treat fp register pairs
3892    (f0,f1) as a single register (d0).  Later MIPS cpu's have 64 bit fp
3893    registers and offer a compatibility mode that emulates the MIPS2 fp
3894    model.  When operating in MIPS2 fp compat mode, later cpu's split
3895    double precision floats into two 32-bit chunks and store them in
3896    consecutive fp regs.  To display 64-bit floats stored in this
3897    fashion, we have to combine 32 bits from f0 and 32 bits from f1.
3898    Throw in user-configurable endianness and you have a real mess.
3899
3900    The way this works is:
3901      - If we are in 32-bit mode or on a 32-bit processor, then a 64-bit
3902        double-precision value will be split across two logical registers.
3903        The lower-numbered logical register will hold the low-order bits,
3904        regardless of the processor's endianness.
3905      - If we are on a 64-bit processor, and we are looking for a
3906        single-precision value, it will be in the low ordered bits
3907        of a 64-bit GPR (after mfc1, for example) or a 64-bit register
3908        save slot in memory.
3909      - If we are in 64-bit mode, everything is straightforward.
3910
3911    Note that this code only deals with "live" registers at the top of the
3912    stack.  We will attempt to deal with saved registers later, when
3913    the raw/cooked register interface is in place. (We need a general
3914    interface that can deal with dynamic saved register sizes -- fp
3915    regs could be 32 bits wide in one frame and 64 on the frame above
3916    and below).  */
3917
3918 static struct type *
3919 mips_float_register_type (void)
3920 {
3921   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3922     return builtin_type_ieee_single_big;
3923   else
3924     return builtin_type_ieee_single_little;
3925 }
3926
3927 static struct type *
3928 mips_double_register_type (void)
3929 {
3930   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3931     return builtin_type_ieee_double_big;
3932   else
3933     return builtin_type_ieee_double_little;
3934 }
3935
3936 /* Copy a 32-bit single-precision value from the current frame
3937    into rare_buffer.  */
3938
3939 static void
3940 mips_read_fp_register_single (int regno, char *rare_buffer)
3941 {
3942   int raw_size = REGISTER_RAW_SIZE (regno);
3943   char *raw_buffer = alloca (raw_size);
3944
3945   if (!frame_register_read (selected_frame, regno, raw_buffer))
3946     error ("can't read register %d (%s)", regno, REGISTER_NAME (regno));
3947   if (raw_size == 8)
3948     {
3949       /* We have a 64-bit value for this register.  Find the low-order
3950          32 bits.  */
3951       int offset;
3952
3953       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3954         offset = 4;
3955       else
3956         offset = 0;
3957
3958       memcpy (rare_buffer, raw_buffer + offset, 4);
3959     }
3960   else
3961     {
3962       memcpy (rare_buffer, raw_buffer, 4);
3963     }
3964 }
3965
3966 /* Copy a 64-bit double-precision value from the current frame into
3967    rare_buffer.  This may include getting half of it from the next
3968    register.  */
3969
3970 static void
3971 mips_read_fp_register_double (int regno, char *rare_buffer)
3972 {
3973   int raw_size = REGISTER_RAW_SIZE (regno);
3974
3975   if (raw_size == 8 && !mips2_fp_compat ())
3976     {
3977       /* We have a 64-bit value for this register, and we should use
3978          all 64 bits.  */
3979       if (!frame_register_read (selected_frame, regno, rare_buffer))
3980         error ("can't read register %d (%s)", regno, REGISTER_NAME (regno));
3981     }
3982   else
3983     {
3984       if ((regno - FP0_REGNUM) & 1)
3985         internal_error (__FILE__, __LINE__,
3986                         "mips_read_fp_register_double: bad access to "
3987                         "odd-numbered FP register");
3988
3989       /* mips_read_fp_register_single will find the correct 32 bits from
3990          each register.  */
3991       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3992         {
3993           mips_read_fp_register_single (regno, rare_buffer + 4);
3994           mips_read_fp_register_single (regno + 1, rare_buffer);
3995         }
3996       else
3997         {
3998           mips_read_fp_register_single (regno, rare_buffer);
3999           mips_read_fp_register_single (regno + 1, rare_buffer + 4);
4000         }
4001     }
4002 }
4003
4004 static void
4005 mips_print_register (int regnum, int all)
4006 {
4007   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
4008
4009   /* Get the data in raw format.  */
4010   if (!frame_register_read (selected_frame, regnum, raw_buffer))
4011     {
4012       printf_filtered ("%s: [Invalid]", REGISTER_NAME (regnum));
4013       return;
4014     }
4015
4016   /* If we have a actual 32-bit floating point register (or we are in
4017      32-bit compatibility mode), and the register is even-numbered,
4018      also print it as a double (spanning two registers).  */
4019   if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT
4020       && (REGISTER_RAW_SIZE (regnum) == 4
4021           || mips2_fp_compat ())
4022       && !((regnum - FP0_REGNUM) & 1))
4023     {
4024       char *dbuffer = alloca (2 * MAX_REGISTER_RAW_SIZE);
4025
4026       mips_read_fp_register_double (regnum, dbuffer);
4027
4028       printf_filtered ("(d%d: ", regnum - FP0_REGNUM);
4029       val_print (mips_double_register_type (), dbuffer, 0, 0,
4030                  gdb_stdout, 0, 1, 0, Val_pretty_default);
4031       printf_filtered ("); ");
4032     }
4033   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
4034
4035   /* The problem with printing numeric register names (r26, etc.) is that
4036      the user can't use them on input.  Probably the best solution is to
4037      fix it so that either the numeric or the funky (a2, etc.) names
4038      are accepted on input.  */
4039   if (regnum < MIPS_NUMREGS)
4040     printf_filtered ("(r%d): ", regnum);
4041   else
4042     printf_filtered (": ");
4043
4044   /* If virtual format is floating, print it that way.  */
4045   if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4046     if (REGISTER_RAW_SIZE (regnum) == 8 && !mips2_fp_compat ())
4047       {
4048         /* We have a meaningful 64-bit value in this register.  Show
4049            it as a 32-bit float and a 64-bit double.  */
4050         int offset = 4 * (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG);
4051
4052         printf_filtered (" (float) ");
4053         val_print (mips_float_register_type (), raw_buffer + offset, 0, 0,
4054                    gdb_stdout, 0, 1, 0, Val_pretty_default);
4055         printf_filtered (", (double) ");
4056         val_print (mips_double_register_type (), raw_buffer, 0, 0,
4057                    gdb_stdout, 0, 1, 0, Val_pretty_default);
4058       }
4059     else
4060       val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
4061                  gdb_stdout, 0, 1, 0, Val_pretty_default);
4062   /* Else print as integer in hex.  */
4063   else
4064     {
4065       int offset;
4066
4067       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
4068         offset = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
4069       else
4070         offset = 0;
4071
4072       print_scalar_formatted (raw_buffer + offset,
4073                               REGISTER_VIRTUAL_TYPE (regnum),
4074                               'x', 0, gdb_stdout);
4075     }
4076 }
4077
4078 /* Replacement for generic do_registers_info.
4079    Print regs in pretty columns.  */
4080
4081 static int
4082 do_fp_register_row (int regnum)
4083 {                               /* do values for FP (float) regs */
4084   char *raw_buffer;
4085   double doub, flt1, flt2;      /* doubles extracted from raw hex data */
4086   int inv1, inv2, inv3;
4087
4088   raw_buffer = (char *) alloca (2 * REGISTER_RAW_SIZE (FP0_REGNUM));
4089
4090   if (REGISTER_RAW_SIZE (regnum) == 4 || mips2_fp_compat ())
4091     {
4092       /* 4-byte registers: we can fit two registers per row.  */
4093       /* Also print every pair of 4-byte regs as an 8-byte double.  */
4094       mips_read_fp_register_single (regnum, raw_buffer);
4095       flt1 = unpack_double (mips_float_register_type (), raw_buffer, &inv1);
4096
4097       mips_read_fp_register_single (regnum + 1, raw_buffer);
4098       flt2 = unpack_double (mips_float_register_type (), raw_buffer, &inv2);
4099
4100       mips_read_fp_register_double (regnum, raw_buffer);
4101       doub = unpack_double (mips_double_register_type (), raw_buffer, &inv3);
4102
4103       printf_filtered (" %-5s", REGISTER_NAME (regnum));
4104       if (inv1)
4105         printf_filtered (": <invalid float>");
4106       else
4107         printf_filtered ("%-17.9g", flt1);
4108
4109       printf_filtered (" %-5s", REGISTER_NAME (regnum + 1));
4110       if (inv2)
4111         printf_filtered (": <invalid float>");
4112       else
4113         printf_filtered ("%-17.9g", flt2);
4114
4115       printf_filtered (" dbl: ");
4116       if (inv3)
4117         printf_filtered ("<invalid double>");
4118       else
4119         printf_filtered ("%-24.17g", doub);
4120       printf_filtered ("\n");
4121
4122       /* may want to do hex display here (future enhancement) */
4123       regnum += 2;
4124     }
4125   else
4126     {
4127       /* Eight byte registers: print each one as float AND as double.  */
4128       mips_read_fp_register_single (regnum, raw_buffer);
4129       flt1 = unpack_double (mips_double_register_type (), raw_buffer, &inv1);
4130
4131       mips_read_fp_register_double (regnum, raw_buffer);
4132       doub = unpack_double (mips_double_register_type (), raw_buffer, &inv3);
4133
4134       printf_filtered (" %-5s: ", REGISTER_NAME (regnum));
4135       if (inv1)
4136         printf_filtered ("<invalid float>");
4137       else
4138         printf_filtered ("flt: %-17.9g", flt1);
4139
4140       printf_filtered (" dbl: ");
4141       if (inv3)
4142         printf_filtered ("<invalid double>");
4143       else
4144         printf_filtered ("%-24.17g", doub);
4145
4146       printf_filtered ("\n");
4147       /* may want to do hex display here (future enhancement) */
4148       regnum++;
4149     }
4150   return regnum;
4151 }
4152
4153 /* Print a row's worth of GP (int) registers, with name labels above */
4154
4155 static int
4156 do_gp_register_row (int regnum)
4157 {
4158   /* do values for GP (int) regs */
4159   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
4160   int ncols = (MIPS_REGSIZE == 8 ? 4 : 8);      /* display cols per row */
4161   int col, byte;
4162   int start_regnum = regnum;
4163   int numregs = NUM_REGS;
4164
4165
4166   /* For GP registers, we print a separate row of names above the vals */
4167   printf_filtered ("     ");
4168   for (col = 0; col < ncols && regnum < numregs; regnum++)
4169     {
4170       if (*REGISTER_NAME (regnum) == '\0')
4171         continue;               /* unused register */
4172       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4173         break;                  /* end the row: reached FP register */
4174       printf_filtered (MIPS_REGSIZE == 8 ? "%17s" : "%9s",
4175                        REGISTER_NAME (regnum));
4176       col++;
4177     }
4178   printf_filtered (start_regnum < MIPS_NUMREGS ? "\n R%-4d" : "\n      ",
4179                    start_regnum);       /* print the R0 to R31 names */
4180
4181   regnum = start_regnum;        /* go back to start of row */
4182   /* now print the values in hex, 4 or 8 to the row */
4183   for (col = 0; col < ncols && regnum < numregs; regnum++)
4184     {
4185       if (*REGISTER_NAME (regnum) == '\0')
4186         continue;               /* unused register */
4187       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4188         break;                  /* end row: reached FP register */
4189       /* OK: get the data in raw format.  */
4190       if (!frame_register_read (selected_frame, regnum, raw_buffer))
4191         error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
4192       /* pad small registers */
4193       for (byte = 0; byte < (MIPS_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
4194         printf_filtered ("  ");
4195       /* Now print the register value in hex, endian order. */
4196       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
4197         for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
4198              byte < REGISTER_RAW_SIZE (regnum);
4199              byte++)
4200           printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
4201       else
4202         for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
4203              byte >= 0;
4204              byte--)
4205           printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
4206       printf_filtered (" ");
4207       col++;
4208     }
4209   if (col > 0)                  /* ie. if we actually printed anything... */
4210     printf_filtered ("\n");
4211
4212   return regnum;
4213 }
4214
4215 /* MIPS_DO_REGISTERS_INFO(): called by "info register" command */
4216
4217 static void
4218 mips_do_registers_info (int regnum, int fpregs)
4219 {
4220   if (regnum != -1)             /* do one specified register */
4221     {
4222       if (*(REGISTER_NAME (regnum)) == '\0')
4223         error ("Not a valid register for the current processor type");
4224
4225       mips_print_register (regnum, 0);
4226       printf_filtered ("\n");
4227     }
4228   else
4229     /* do all (or most) registers */
4230     {
4231       regnum = 0;
4232       while (regnum < NUM_REGS)
4233         {
4234           if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4235             if (fpregs)         /* true for "INFO ALL-REGISTERS" command */
4236               regnum = do_fp_register_row (regnum);     /* FP regs */
4237             else
4238               regnum += MIPS_NUMREGS;   /* skip floating point regs */
4239           else
4240             regnum = do_gp_register_row (regnum);       /* GP (int) regs */
4241         }
4242     }
4243 }
4244
4245 /* Is this a branch with a delay slot?  */
4246
4247 static int is_delayed (unsigned long);
4248
4249 static int
4250 is_delayed (unsigned long insn)
4251 {
4252   int i;
4253   for (i = 0; i < NUMOPCODES; ++i)
4254     if (mips_opcodes[i].pinfo != INSN_MACRO
4255         && (insn & mips_opcodes[i].mask) == mips_opcodes[i].match)
4256       break;
4257   return (i < NUMOPCODES
4258           && (mips_opcodes[i].pinfo & (INSN_UNCOND_BRANCH_DELAY
4259                                        | INSN_COND_BRANCH_DELAY
4260                                        | INSN_COND_BRANCH_LIKELY)));
4261 }
4262
4263 int
4264 mips_step_skips_delay (CORE_ADDR pc)
4265 {
4266   char buf[MIPS_INSTLEN];
4267
4268   /* There is no branch delay slot on MIPS16.  */
4269   if (pc_is_mips16 (pc))
4270     return 0;
4271
4272   if (target_read_memory (pc, buf, MIPS_INSTLEN) != 0)
4273     /* If error reading memory, guess that it is not a delayed branch.  */
4274     return 0;
4275   return is_delayed ((unsigned long) extract_unsigned_integer (buf, MIPS_INSTLEN));
4276 }
4277
4278
4279 /* Skip the PC past function prologue instructions (32-bit version).
4280    This is a helper function for mips_skip_prologue.  */
4281
4282 static CORE_ADDR
4283 mips32_skip_prologue (CORE_ADDR pc)
4284 {
4285   t_inst inst;
4286   CORE_ADDR end_pc;
4287   int seen_sp_adjust = 0;
4288   int load_immediate_bytes = 0;
4289
4290   /* Skip the typical prologue instructions. These are the stack adjustment
4291      instruction and the instructions that save registers on the stack
4292      or in the gcc frame.  */
4293   for (end_pc = pc + 100; pc < end_pc; pc += MIPS_INSTLEN)
4294     {
4295       unsigned long high_word;
4296
4297       inst = mips_fetch_instruction (pc);
4298       high_word = (inst >> 16) & 0xffff;
4299
4300       if (high_word == 0x27bd   /* addiu $sp,$sp,offset */
4301           || high_word == 0x67bd)       /* daddiu $sp,$sp,offset */
4302         seen_sp_adjust = 1;
4303       else if (inst == 0x03a1e823 ||    /* subu $sp,$sp,$at */
4304                inst == 0x03a8e823)      /* subu $sp,$sp,$t0 */
4305         seen_sp_adjust = 1;
4306       else if (((inst & 0xFFE00000) == 0xAFA00000       /* sw reg,n($sp) */
4307                 || (inst & 0xFFE00000) == 0xFFA00000)   /* sd reg,n($sp) */
4308                && (inst & 0x001F0000))  /* reg != $zero */
4309         continue;
4310
4311       else if ((inst & 0xFFE00000) == 0xE7A00000)       /* swc1 freg,n($sp) */
4312         continue;
4313       else if ((inst & 0xF3E00000) == 0xA3C00000 && (inst & 0x001F0000))
4314         /* sx reg,n($s8) */
4315         continue;               /* reg != $zero */
4316
4317       /* move $s8,$sp.  With different versions of gas this will be either
4318          `addu $s8,$sp,$zero' or `or $s8,$sp,$zero' or `daddu s8,sp,$0'.
4319          Accept any one of these.  */
4320       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
4321         continue;
4322
4323       else if ((inst & 0xFF9F07FF) == 0x00800021)       /* move reg,$a0-$a3 */
4324         continue;
4325       else if (high_word == 0x3c1c)     /* lui $gp,n */
4326         continue;
4327       else if (high_word == 0x279c)     /* addiu $gp,$gp,n */
4328         continue;
4329       else if (inst == 0x0399e021       /* addu $gp,$gp,$t9 */
4330                || inst == 0x033ce021)   /* addu $gp,$t9,$gp */
4331         continue;
4332       /* The following instructions load $at or $t0 with an immediate
4333          value in preparation for a stack adjustment via
4334          subu $sp,$sp,[$at,$t0]. These instructions could also initialize
4335          a local variable, so we accept them only before a stack adjustment
4336          instruction was seen.  */
4337       else if (!seen_sp_adjust)
4338         {
4339           if (high_word == 0x3c01 ||    /* lui $at,n */
4340               high_word == 0x3c08)      /* lui $t0,n */
4341             {
4342               load_immediate_bytes += MIPS_INSTLEN;     /* FIXME!! */
4343               continue;
4344             }
4345           else if (high_word == 0x3421 ||       /* ori $at,$at,n */
4346                    high_word == 0x3508 ||       /* ori $t0,$t0,n */
4347                    high_word == 0x3401 ||       /* ori $at,$zero,n */
4348                    high_word == 0x3408)         /* ori $t0,$zero,n */
4349             {
4350               load_immediate_bytes += MIPS_INSTLEN;     /* FIXME!! */
4351               continue;
4352             }
4353           else
4354             break;
4355         }
4356       else
4357         break;
4358     }
4359
4360   /* In a frameless function, we might have incorrectly
4361      skipped some load immediate instructions. Undo the skipping
4362      if the load immediate was not followed by a stack adjustment.  */
4363   if (load_immediate_bytes && !seen_sp_adjust)
4364     pc -= load_immediate_bytes;
4365   return pc;
4366 }
4367
4368 /* Skip the PC past function prologue instructions (16-bit version).
4369    This is a helper function for mips_skip_prologue.  */
4370
4371 static CORE_ADDR
4372 mips16_skip_prologue (CORE_ADDR pc)
4373 {
4374   CORE_ADDR end_pc;
4375   int extend_bytes = 0;
4376   int prev_extend_bytes;
4377
4378   /* Table of instructions likely to be found in a function prologue.  */
4379   static struct
4380     {
4381       unsigned short inst;
4382       unsigned short mask;
4383     }
4384   table[] =
4385   {
4386     {
4387       0x6300, 0xff00
4388     }
4389     ,                           /* addiu $sp,offset */
4390     {
4391       0xfb00, 0xff00
4392     }
4393     ,                           /* daddiu $sp,offset */
4394     {
4395       0xd000, 0xf800
4396     }
4397     ,                           /* sw reg,n($sp) */
4398     {
4399       0xf900, 0xff00
4400     }
4401     ,                           /* sd reg,n($sp) */
4402     {
4403       0x6200, 0xff00
4404     }
4405     ,                           /* sw $ra,n($sp) */
4406     {
4407       0xfa00, 0xff00
4408     }
4409     ,                           /* sd $ra,n($sp) */
4410     {
4411       0x673d, 0xffff
4412     }
4413     ,                           /* move $s1,sp */
4414     {
4415       0xd980, 0xff80
4416     }
4417     ,                           /* sw $a0-$a3,n($s1) */
4418     {
4419       0x6704, 0xff1c
4420     }
4421     ,                           /* move reg,$a0-$a3 */
4422     {
4423       0xe809, 0xf81f
4424     }
4425     ,                           /* entry pseudo-op */
4426     {
4427       0x0100, 0xff00
4428     }
4429     ,                           /* addiu $s1,$sp,n */
4430     {
4431       0, 0
4432     }                           /* end of table marker */
4433   };
4434
4435   /* Skip the typical prologue instructions. These are the stack adjustment
4436      instruction and the instructions that save registers on the stack
4437      or in the gcc frame.  */
4438   for (end_pc = pc + 100; pc < end_pc; pc += MIPS16_INSTLEN)
4439     {
4440       unsigned short inst;
4441       int i;
4442
4443       inst = mips_fetch_instruction (pc);
4444
4445       /* Normally we ignore an extend instruction.  However, if it is
4446          not followed by a valid prologue instruction, we must adjust
4447          the pc back over the extend so that it won't be considered
4448          part of the prologue.  */
4449       if ((inst & 0xf800) == 0xf000)    /* extend */
4450         {
4451           extend_bytes = MIPS16_INSTLEN;
4452           continue;
4453         }
4454       prev_extend_bytes = extend_bytes;
4455       extend_bytes = 0;
4456
4457       /* Check for other valid prologue instructions besides extend.  */
4458       for (i = 0; table[i].mask != 0; i++)
4459         if ((inst & table[i].mask) == table[i].inst)    /* found, get out */
4460           break;
4461       if (table[i].mask != 0)   /* it was in table? */
4462         continue;               /* ignore it */
4463       else
4464         /* non-prologue */
4465         {
4466           /* Return the current pc, adjusted backwards by 2 if
4467              the previous instruction was an extend.  */
4468           return pc - prev_extend_bytes;
4469         }
4470     }
4471   return pc;
4472 }
4473
4474 /* To skip prologues, I use this predicate.  Returns either PC itself
4475    if the code at PC does not look like a function prologue; otherwise
4476    returns an address that (if we're lucky) follows the prologue.  If
4477    LENIENT, then we must skip everything which is involved in setting
4478    up the frame (it's OK to skip more, just so long as we don't skip
4479    anything which might clobber the registers which are being saved.
4480    We must skip more in the case where part of the prologue is in the
4481    delay slot of a non-prologue instruction).  */
4482
4483 static CORE_ADDR
4484 mips_skip_prologue (CORE_ADDR pc)
4485 {
4486   /* See if we can determine the end of the prologue via the symbol table.
4487      If so, then return either PC, or the PC after the prologue, whichever
4488      is greater.  */
4489
4490   CORE_ADDR post_prologue_pc = after_prologue (pc, NULL);
4491
4492   if (post_prologue_pc != 0)
4493     return max (pc, post_prologue_pc);
4494
4495   /* Can't determine prologue from the symbol table, need to examine
4496      instructions.  */
4497
4498   if (pc_is_mips16 (pc))
4499     return mips16_skip_prologue (pc);
4500   else
4501     return mips32_skip_prologue (pc);
4502 }
4503
4504 /* Determine how a return value is stored within the MIPS register
4505    file, given the return type `valtype'. */
4506
4507 struct return_value_word
4508 {
4509   int len;
4510   int reg;
4511   int reg_offset;
4512   int buf_offset;
4513 };
4514
4515 static void
4516 return_value_location (struct type *valtype,
4517                        struct return_value_word *hi,
4518                        struct return_value_word *lo)
4519 {
4520   int len = TYPE_LENGTH (valtype);
4521
4522   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
4523       && ((MIPS_FPU_TYPE == MIPS_FPU_DOUBLE && (len == 4 || len == 8))
4524           || (MIPS_FPU_TYPE == MIPS_FPU_SINGLE && len == 4)))
4525     {
4526       if (!FP_REGISTER_DOUBLE && len == 8)
4527         {
4528           /* We need to break a 64bit float in two 32 bit halves and
4529              spread them across a floating-point register pair. */
4530           lo->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
4531           hi->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 0 : 4;
4532           lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4533                              && REGISTER_RAW_SIZE (FP0_REGNUM) == 8)
4534                             ? 4 : 0);
4535           hi->reg_offset = lo->reg_offset;
4536           lo->reg = FP0_REGNUM + 0;
4537           hi->reg = FP0_REGNUM + 1;
4538           lo->len = 4;
4539           hi->len = 4;
4540         }
4541       else
4542         {
4543           /* The floating point value fits in a single floating-point
4544              register. */
4545           lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4546                              && REGISTER_RAW_SIZE (FP0_REGNUM) == 8
4547                              && len == 4)
4548                             ? 4 : 0);
4549           lo->reg = FP0_REGNUM;
4550           lo->len = len;
4551           lo->buf_offset = 0;
4552           hi->len = 0;
4553           hi->reg_offset = 0;
4554           hi->buf_offset = 0;
4555           hi->reg = 0;
4556         }
4557     }
4558   else
4559     {
4560       /* Locate a result possibly spread across two registers. */
4561       int regnum = 2;
4562       lo->reg = regnum + 0;
4563       hi->reg = regnum + 1;
4564       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4565           && len < MIPS_SAVED_REGSIZE)
4566         {
4567           /* "un-left-justify" the value in the low register */
4568           lo->reg_offset = MIPS_SAVED_REGSIZE - len;
4569           lo->len = len;
4570           hi->reg_offset = 0;
4571           hi->len = 0;
4572         }
4573       else if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4574                && len > MIPS_SAVED_REGSIZE      /* odd-size structs */
4575                && len < MIPS_SAVED_REGSIZE * 2
4576                && (TYPE_CODE (valtype) == TYPE_CODE_STRUCT ||
4577                    TYPE_CODE (valtype) == TYPE_CODE_UNION))
4578         {
4579           /* "un-left-justify" the value spread across two registers. */
4580           lo->reg_offset = 2 * MIPS_SAVED_REGSIZE - len;
4581           lo->len = MIPS_SAVED_REGSIZE - lo->reg_offset;
4582           hi->reg_offset = 0;
4583           hi->len = len - lo->len;
4584         }
4585       else
4586         {
4587           /* Only perform a partial copy of the second register. */
4588           lo->reg_offset = 0;
4589           hi->reg_offset = 0;
4590           if (len > MIPS_SAVED_REGSIZE)
4591             {
4592               lo->len = MIPS_SAVED_REGSIZE;
4593               hi->len = len - MIPS_SAVED_REGSIZE;
4594             }
4595           else
4596             {
4597               lo->len = len;
4598               hi->len = 0;
4599             }
4600         }
4601       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
4602           && REGISTER_RAW_SIZE (regnum) == 8
4603           && MIPS_SAVED_REGSIZE == 4)
4604         {
4605           /* Account for the fact that only the least-signficant part
4606              of the register is being used */
4607           lo->reg_offset += 4;
4608           hi->reg_offset += 4;
4609         }
4610       lo->buf_offset = 0;
4611       hi->buf_offset = lo->len;
4612     }
4613 }
4614
4615 /* Given a return value in `regbuf' with a type `valtype', extract and
4616    copy its value into `valbuf'. */
4617
4618 static void
4619 mips_eabi_extract_return_value (struct type *valtype,
4620                                 char regbuf[REGISTER_BYTES],
4621                                 char *valbuf)
4622 {
4623   struct return_value_word lo;
4624   struct return_value_word hi;
4625   return_value_location (valtype, &hi, &lo);
4626
4627   memcpy (valbuf + lo.buf_offset,
4628           regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
4629           lo.len);
4630
4631   if (hi.len > 0)
4632     memcpy (valbuf + hi.buf_offset,
4633             regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
4634             hi.len);
4635 }
4636
4637 static void
4638 mips_o64_extract_return_value (struct type *valtype,
4639                                char regbuf[REGISTER_BYTES],
4640                                char *valbuf)
4641 {
4642   struct return_value_word lo;
4643   struct return_value_word hi;
4644   return_value_location (valtype, &hi, &lo);
4645
4646   memcpy (valbuf + lo.buf_offset,
4647           regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
4648           lo.len);
4649
4650   if (hi.len > 0)
4651     memcpy (valbuf + hi.buf_offset,
4652             regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
4653             hi.len);
4654 }
4655
4656 /* Given a return value in `valbuf' with a type `valtype', write it's
4657    value into the appropriate register. */
4658
4659 static void
4660 mips_eabi_store_return_value (struct type *valtype, char *valbuf)
4661 {
4662   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
4663   struct return_value_word lo;
4664   struct return_value_word hi;
4665   return_value_location (valtype, &hi, &lo);
4666
4667   memset (raw_buffer, 0, sizeof (raw_buffer));
4668   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
4669   deprecated_write_register_bytes (REGISTER_BYTE (lo.reg), raw_buffer,
4670                                    REGISTER_RAW_SIZE (lo.reg));
4671
4672   if (hi.len > 0)
4673     {
4674       memset (raw_buffer, 0, sizeof (raw_buffer));
4675       memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
4676       deprecated_write_register_bytes (REGISTER_BYTE (hi.reg), raw_buffer,
4677                                        REGISTER_RAW_SIZE (hi.reg));
4678     }
4679 }
4680
4681 static void
4682 mips_o64_store_return_value (struct type *valtype, char *valbuf)
4683 {
4684   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
4685   struct return_value_word lo;
4686   struct return_value_word hi;
4687   return_value_location (valtype, &hi, &lo);
4688
4689   memset (raw_buffer, 0, sizeof (raw_buffer));
4690   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
4691   deprecated_write_register_bytes (REGISTER_BYTE (lo.reg), raw_buffer,
4692                                    REGISTER_RAW_SIZE (lo.reg));
4693
4694   if (hi.len > 0)
4695     {
4696       memset (raw_buffer, 0, sizeof (raw_buffer));
4697       memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
4698       deprecated_write_register_bytes (REGISTER_BYTE (hi.reg), raw_buffer,
4699                                        REGISTER_RAW_SIZE (hi.reg));
4700     }
4701 }
4702
4703 /* O32 ABI stuff.  */
4704
4705 static void
4706 mips_o32_xfer_return_value (struct type *type,
4707                             struct regcache *regcache,
4708                             bfd_byte *in, const bfd_byte *out)
4709 {
4710   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
4711   if (TYPE_CODE (type) == TYPE_CODE_FLT
4712       && TYPE_LENGTH (type) == 4
4713       && tdep->mips_fpu_type != MIPS_FPU_NONE)
4714     {
4715       /* A single-precision floating-point value.  It fits in the
4716          least significant part of FP0.  */
4717       if (mips_debug)
4718         fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
4719       mips_xfer_register (regcache, FP0_REGNUM, TYPE_LENGTH (type),
4720                           TARGET_BYTE_ORDER, in, out, 0);
4721     }
4722   else if (TYPE_CODE (type) == TYPE_CODE_FLT
4723            && TYPE_LENGTH (type) == 8
4724            && tdep->mips_fpu_type != MIPS_FPU_NONE)
4725     {
4726       /* A double-precision floating-point value.  It fits in the
4727          least significant part of FP0/FP1 but with byte ordering
4728          based on the target (???).  */
4729       if (mips_debug)
4730         fprintf_unfiltered (gdb_stderr, "Return float in $fp0/$fp1\n");
4731       switch (TARGET_BYTE_ORDER)
4732         {
4733         case BFD_ENDIAN_LITTLE:
4734           mips_xfer_register (regcache, FP0_REGNUM + 0, 4,
4735                               TARGET_BYTE_ORDER, in, out, 0);
4736           mips_xfer_register (regcache, FP0_REGNUM + 1, 4,
4737                               TARGET_BYTE_ORDER, in, out, 4);
4738           break;
4739         case BFD_ENDIAN_BIG:
4740           mips_xfer_register (regcache, FP0_REGNUM + 1, 4,
4741                               TARGET_BYTE_ORDER, in, out, 0);
4742           mips_xfer_register (regcache, FP0_REGNUM + 0, 4,
4743                               TARGET_BYTE_ORDER, in, out, 4);
4744           break;
4745         default:
4746           internal_error (__FILE__, __LINE__, "bad switch");
4747         }
4748     }
4749 #if 0
4750   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4751            && TYPE_NFIELDS (type) <= 2
4752            && TYPE_NFIELDS (type) >= 1
4753            && ((TYPE_NFIELDS (type) == 1
4754                 && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4755                     == TYPE_CODE_FLT))
4756                || (TYPE_NFIELDS (type) == 2
4757                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4758                        == TYPE_CODE_FLT)
4759                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 1))
4760                        == TYPE_CODE_FLT)))
4761            && tdep->mips_fpu_type != MIPS_FPU_NONE)
4762     {
4763       /* A struct that contains one or two floats.  Each value is part
4764          in the least significant part of their floating point
4765          register..  */
4766       bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
4767       int regnum;
4768       int field;
4769       for (field = 0, regnum = FP0_REGNUM;
4770            field < TYPE_NFIELDS (type);
4771            field++, regnum += 2)
4772         {
4773           int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
4774                         / TARGET_CHAR_BIT);
4775           if (mips_debug)
4776             fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n", offset);
4777           mips_xfer_register (regcache, regnum, TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
4778                               TARGET_BYTE_ORDER, in, out, offset);
4779         }
4780     }
4781 #endif
4782 #if 0
4783   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4784            || TYPE_CODE (type) == TYPE_CODE_UNION)
4785     {
4786       /* A structure or union.  Extract the left justified value,
4787          regardless of the byte order.  I.e. DO NOT USE
4788          mips_xfer_lower.  */
4789       int offset;
4790       int regnum;
4791       for (offset = 0, regnum = V0_REGNUM;
4792            offset < TYPE_LENGTH (type);
4793            offset += REGISTER_RAW_SIZE (regnum), regnum++)
4794         {
4795           int xfer = REGISTER_RAW_SIZE (regnum);
4796           if (offset + xfer > TYPE_LENGTH (type))
4797             xfer = TYPE_LENGTH (type) - offset;
4798           if (mips_debug)
4799             fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
4800                                 offset, xfer, regnum);
4801           mips_xfer_register (regcache, regnum, xfer, BFD_ENDIAN_UNKNOWN,
4802                               in, out, offset);
4803         }
4804     }
4805 #endif
4806   else
4807     {
4808       /* A scalar extract each part but least-significant-byte
4809          justified.  o32 thinks registers are 4 byte, regardless of
4810          the ISA.  mips_stack_argsize controls this.  */
4811       int offset;
4812       int regnum;
4813       for (offset = 0, regnum = V0_REGNUM;
4814            offset < TYPE_LENGTH (type);
4815            offset += mips_stack_argsize (), regnum++)
4816         {
4817           int xfer = mips_stack_argsize ();
4818           int pos = 0;
4819           if (offset + xfer > TYPE_LENGTH (type))
4820             xfer = TYPE_LENGTH (type) - offset;
4821           if (mips_debug)
4822             fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
4823                                 offset, xfer, regnum);
4824           mips_xfer_register (regcache, regnum, xfer, TARGET_BYTE_ORDER,
4825                               in, out, offset);
4826         }
4827     }
4828 }
4829
4830 static void
4831 mips_o32_extract_return_value (struct type *type,
4832                                struct regcache *regcache,
4833                                void *valbuf)
4834 {
4835   mips_o32_xfer_return_value (type, regcache, valbuf, NULL);
4836 }
4837
4838 static void
4839 mips_o32_store_return_value (struct type *type, char *valbuf)
4840 {
4841   mips_o32_xfer_return_value (type, current_regcache, NULL, valbuf);
4842 }
4843
4844 /* N32/N44 ABI stuff.  */
4845
4846 static void
4847 mips_n32n64_xfer_return_value (struct type *type,
4848                                struct regcache *regcache,
4849                                bfd_byte *in, const bfd_byte *out)
4850 {
4851   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
4852   if (TYPE_CODE (type) == TYPE_CODE_FLT
4853       && tdep->mips_fpu_type != MIPS_FPU_NONE)
4854     {
4855       /* A floating-point value belongs in the least significant part
4856          of FP0.  */
4857       if (mips_debug)
4858         fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
4859       mips_xfer_register (regcache, FP0_REGNUM, TYPE_LENGTH (type),
4860                           TARGET_BYTE_ORDER, in, out, 0);
4861     }
4862   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4863            && TYPE_NFIELDS (type) <= 2
4864            && TYPE_NFIELDS (type) >= 1
4865            && ((TYPE_NFIELDS (type) == 1
4866                 && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4867                     == TYPE_CODE_FLT))
4868                || (TYPE_NFIELDS (type) == 2
4869                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0))
4870                        == TYPE_CODE_FLT)
4871                    && (TYPE_CODE (TYPE_FIELD_TYPE (type, 1))
4872                        == TYPE_CODE_FLT)))
4873            && tdep->mips_fpu_type != MIPS_FPU_NONE)
4874     {
4875       /* A struct that contains one or two floats.  Each value is part
4876          in the least significant part of their floating point
4877          register..  */
4878       bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
4879       int regnum;
4880       int field;
4881       for (field = 0, regnum = FP0_REGNUM;
4882            field < TYPE_NFIELDS (type);
4883            field++, regnum += 2)
4884         {
4885           int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
4886                         / TARGET_CHAR_BIT);
4887           if (mips_debug)
4888             fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n", offset);
4889           mips_xfer_register (regcache, regnum, TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
4890                               TARGET_BYTE_ORDER, in, out, offset);
4891         }
4892     }
4893   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
4894            || TYPE_CODE (type) == TYPE_CODE_UNION)
4895     {
4896       /* A structure or union.  Extract the left justified value,
4897          regardless of the byte order.  I.e. DO NOT USE
4898          mips_xfer_lower.  */
4899       int offset;
4900       int regnum;
4901       for (offset = 0, regnum = V0_REGNUM;
4902            offset < TYPE_LENGTH (type);
4903            offset += REGISTER_RAW_SIZE (regnum), regnum++)
4904         {
4905           int xfer = REGISTER_RAW_SIZE (regnum);
4906           if (offset + xfer > TYPE_LENGTH (type))
4907             xfer = TYPE_LENGTH (type) - offset;
4908           if (mips_debug)
4909             fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
4910                                 offset, xfer, regnum);
4911           mips_xfer_register (regcache, regnum, xfer, BFD_ENDIAN_UNKNOWN,
4912                               in, out, offset);
4913         }
4914     }
4915   else
4916     {
4917       /* A scalar extract each part but least-significant-byte
4918          justified.  */
4919       int offset;
4920       int regnum;
4921       for (offset = 0, regnum = V0_REGNUM;
4922            offset < TYPE_LENGTH (type);
4923            offset += REGISTER_RAW_SIZE (regnum), regnum++)
4924         {
4925           int xfer = REGISTER_RAW_SIZE (regnum);
4926           int pos = 0;
4927           if (offset + xfer > TYPE_LENGTH (type))
4928             xfer = TYPE_LENGTH (type) - offset;
4929           if (mips_debug)
4930             fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
4931                                 offset, xfer, regnum);
4932           mips_xfer_register (regcache, regnum, xfer, TARGET_BYTE_ORDER,
4933                               in, out, offset);
4934         }
4935     }
4936 }
4937
4938 static void
4939 mips_n32n64_extract_return_value (struct type *type,
4940                                   struct regcache *regcache,
4941                                   void *valbuf)
4942 {
4943   mips_n32n64_xfer_return_value (type, regcache, valbuf, NULL);
4944 }
4945
4946 static void
4947 mips_n32n64_store_return_value (struct type *type, char *valbuf)
4948 {
4949   mips_n32n64_xfer_return_value (type, current_regcache, NULL, valbuf);
4950 }
4951
4952 static void
4953 mips_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
4954 {
4955   /* Nothing to do -- push_arguments does all the work.  */
4956 }
4957
4958 static CORE_ADDR
4959 mips_extract_struct_value_address (struct regcache *regcache)
4960 {
4961   /* FIXME: This will only work at random.  The caller passes the
4962      struct_return address in V0, but it is not preserved.  It may
4963      still be there, or this may be a random value.  */
4964   LONGEST val;
4965
4966   regcache_cooked_read_signed (regcache, V0_REGNUM, &val);
4967   return val;
4968 }
4969
4970 /* Exported procedure: Is PC in the signal trampoline code */
4971
4972 static int
4973 mips_pc_in_sigtramp (CORE_ADDR pc, char *ignore)
4974 {
4975   if (sigtramp_address == 0)
4976     fixup_sigtramp ();
4977   return (pc >= sigtramp_address && pc < sigtramp_end);
4978 }
4979
4980 /* Root of all "set mips "/"show mips " commands. This will eventually be
4981    used for all MIPS-specific commands.  */
4982
4983 static void
4984 show_mips_command (char *args, int from_tty)
4985 {
4986   help_list (showmipscmdlist, "show mips ", all_commands, gdb_stdout);
4987 }
4988
4989 static void
4990 set_mips_command (char *args, int from_tty)
4991 {
4992   printf_unfiltered ("\"set mips\" must be followed by an appropriate subcommand.\n");
4993   help_list (setmipscmdlist, "set mips ", all_commands, gdb_stdout);
4994 }
4995
4996 /* Commands to show/set the MIPS FPU type.  */
4997
4998 static void
4999 show_mipsfpu_command (char *args, int from_tty)
5000 {
5001   char *fpu;
5002   switch (MIPS_FPU_TYPE)
5003     {
5004     case MIPS_FPU_SINGLE:
5005       fpu = "single-precision";
5006       break;
5007     case MIPS_FPU_DOUBLE:
5008       fpu = "double-precision";
5009       break;
5010     case MIPS_FPU_NONE:
5011       fpu = "absent (none)";
5012       break;
5013     default:
5014       internal_error (__FILE__, __LINE__, "bad switch");
5015     }
5016   if (mips_fpu_type_auto)
5017     printf_unfiltered ("The MIPS floating-point coprocessor is set automatically (currently %s)\n",
5018                        fpu);
5019   else
5020     printf_unfiltered ("The MIPS floating-point coprocessor is assumed to be %s\n",
5021                        fpu);
5022 }
5023
5024
5025 static void
5026 set_mipsfpu_command (char *args, int from_tty)
5027 {
5028   printf_unfiltered ("\"set mipsfpu\" must be followed by \"double\", \"single\",\"none\" or \"auto\".\n");
5029   show_mipsfpu_command (args, from_tty);
5030 }
5031
5032 static void
5033 set_mipsfpu_single_command (char *args, int from_tty)
5034 {
5035   mips_fpu_type = MIPS_FPU_SINGLE;
5036   mips_fpu_type_auto = 0;
5037   gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_SINGLE;
5038 }
5039
5040 static void
5041 set_mipsfpu_double_command (char *args, int from_tty)
5042 {
5043   mips_fpu_type = MIPS_FPU_DOUBLE;
5044   mips_fpu_type_auto = 0;
5045   gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_DOUBLE;
5046 }
5047
5048 static void
5049 set_mipsfpu_none_command (char *args, int from_tty)
5050 {
5051   mips_fpu_type = MIPS_FPU_NONE;
5052   mips_fpu_type_auto = 0;
5053   gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_NONE;
5054 }
5055
5056 static void
5057 set_mipsfpu_auto_command (char *args, int from_tty)
5058 {
5059   mips_fpu_type_auto = 1;
5060 }
5061
5062 /* Command to set the processor type.  */
5063
5064 void
5065 mips_set_processor_type_command (char *args, int from_tty)
5066 {
5067   int i;
5068
5069   if (tmp_mips_processor_type == NULL || *tmp_mips_processor_type == '\0')
5070     {
5071       printf_unfiltered ("The known MIPS processor types are as follows:\n\n");
5072       for (i = 0; mips_processor_type_table[i].name != NULL; ++i)
5073         printf_unfiltered ("%s\n", mips_processor_type_table[i].name);
5074
5075       /* Restore the value.  */
5076       tmp_mips_processor_type = xstrdup (mips_processor_type);
5077
5078       return;
5079     }
5080
5081   if (!mips_set_processor_type (tmp_mips_processor_type))
5082     {
5083       error ("Unknown processor type `%s'.", tmp_mips_processor_type);
5084       /* Restore its value.  */
5085       tmp_mips_processor_type = xstrdup (mips_processor_type);
5086     }
5087 }
5088
5089 static void
5090 mips_show_processor_type_command (char *args, int from_tty)
5091 {
5092 }
5093
5094 /* Modify the actual processor type. */
5095
5096 static int
5097 mips_set_processor_type (char *str)
5098 {
5099   int i;
5100
5101   if (str == NULL)
5102     return 0;
5103
5104   for (i = 0; mips_processor_type_table[i].name != NULL; ++i)
5105     {
5106       if (strcasecmp (str, mips_processor_type_table[i].name) == 0)
5107         {
5108           mips_processor_type = str;
5109           mips_processor_reg_names = mips_processor_type_table[i].regnames;
5110           return 1;
5111           /* FIXME tweak fpu flag too */
5112         }
5113     }
5114
5115   return 0;
5116 }
5117
5118 /* Attempt to identify the particular processor model by reading the
5119    processor id.  */
5120
5121 char *
5122 mips_read_processor_type (void)
5123 {
5124   CORE_ADDR prid;
5125
5126   prid = read_register (PRID_REGNUM);
5127
5128   if ((prid & ~0xf) == 0x700)
5129     return savestring ("r3041", strlen ("r3041"));
5130
5131   return NULL;
5132 }
5133
5134 /* Just like reinit_frame_cache, but with the right arguments to be
5135    callable as an sfunc.  */
5136
5137 static void
5138 reinit_frame_cache_sfunc (char *args, int from_tty,
5139                           struct cmd_list_element *c)
5140 {
5141   reinit_frame_cache ();
5142 }
5143
5144 int
5145 gdb_print_insn_mips (bfd_vma memaddr, disassemble_info *info)
5146 {
5147   mips_extra_func_info_t proc_desc;
5148
5149   /* Search for the function containing this address.  Set the low bit
5150      of the address when searching, in case we were given an even address
5151      that is the start of a 16-bit function.  If we didn't do this,
5152      the search would fail because the symbol table says the function
5153      starts at an odd address, i.e. 1 byte past the given address.  */
5154   memaddr = ADDR_BITS_REMOVE (memaddr);
5155   proc_desc = non_heuristic_proc_desc (MAKE_MIPS16_ADDR (memaddr), NULL);
5156
5157   /* Make an attempt to determine if this is a 16-bit function.  If
5158      the procedure descriptor exists and the address therein is odd,
5159      it's definitely a 16-bit function.  Otherwise, we have to just
5160      guess that if the address passed in is odd, it's 16-bits.  */
5161   if (proc_desc)
5162     info->mach = pc_is_mips16 (PROC_LOW_ADDR (proc_desc)) ?
5163       bfd_mach_mips16 : TM_PRINT_INSN_MACH;
5164   else
5165     info->mach = pc_is_mips16 (memaddr) ?
5166       bfd_mach_mips16 : TM_PRINT_INSN_MACH;
5167
5168   /* Round down the instruction address to the appropriate boundary.  */
5169   memaddr &= (info->mach == bfd_mach_mips16 ? ~1 : ~3);
5170
5171   /* Call the appropriate disassembler based on the target endian-ness.  */
5172   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
5173     return print_insn_big_mips (memaddr, info);
5174   else
5175     return print_insn_little_mips (memaddr, info);
5176 }
5177
5178 /* Old-style breakpoint macros.
5179    The IDT board uses an unusual breakpoint value, and sometimes gets
5180    confused when it sees the usual MIPS breakpoint instruction.  */
5181
5182 #define BIG_BREAKPOINT {0, 0x5, 0, 0xd}
5183 #define LITTLE_BREAKPOINT {0xd, 0, 0x5, 0}
5184 #define PMON_BIG_BREAKPOINT {0, 0, 0, 0xd}
5185 #define PMON_LITTLE_BREAKPOINT {0xd, 0, 0, 0}
5186 #define IDT_BIG_BREAKPOINT {0, 0, 0x0a, 0xd}
5187 #define IDT_LITTLE_BREAKPOINT {0xd, 0x0a, 0, 0}
5188 #define MIPS16_BIG_BREAKPOINT {0xe8, 0xa5}
5189 #define MIPS16_LITTLE_BREAKPOINT {0xa5, 0xe8}
5190
5191 /* This function implements the BREAKPOINT_FROM_PC macro.  It uses the program
5192    counter value to determine whether a 16- or 32-bit breakpoint should be
5193    used.  It returns a pointer to a string of bytes that encode a breakpoint
5194    instruction, stores the length of the string to *lenptr, and adjusts pc
5195    (if necessary) to point to the actual memory location where the
5196    breakpoint should be inserted.  */
5197
5198 static const unsigned char *
5199 mips_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
5200 {
5201   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
5202     {
5203       if (pc_is_mips16 (*pcptr))
5204         {
5205           static unsigned char mips16_big_breakpoint[] =
5206             MIPS16_BIG_BREAKPOINT;
5207           *pcptr = UNMAKE_MIPS16_ADDR (*pcptr);
5208           *lenptr = sizeof (mips16_big_breakpoint);
5209           return mips16_big_breakpoint;
5210         }
5211       else
5212         {
5213           static unsigned char big_breakpoint[] = BIG_BREAKPOINT;
5214           static unsigned char pmon_big_breakpoint[] = PMON_BIG_BREAKPOINT;
5215           static unsigned char idt_big_breakpoint[] = IDT_BIG_BREAKPOINT;
5216
5217           *lenptr = sizeof (big_breakpoint);
5218
5219           if (strcmp (target_shortname, "mips") == 0)
5220             return idt_big_breakpoint;
5221           else if (strcmp (target_shortname, "ddb") == 0
5222                    || strcmp (target_shortname, "pmon") == 0
5223                    || strcmp (target_shortname, "lsi") == 0)
5224             return pmon_big_breakpoint;
5225           else
5226             return big_breakpoint;
5227         }
5228     }
5229   else
5230     {
5231       if (pc_is_mips16 (*pcptr))
5232         {
5233           static unsigned char mips16_little_breakpoint[] =
5234             MIPS16_LITTLE_BREAKPOINT;
5235           *pcptr = UNMAKE_MIPS16_ADDR (*pcptr);
5236           *lenptr = sizeof (mips16_little_breakpoint);
5237           return mips16_little_breakpoint;
5238         }
5239       else
5240         {
5241           static unsigned char little_breakpoint[] = LITTLE_BREAKPOINT;
5242           static unsigned char pmon_little_breakpoint[] =
5243             PMON_LITTLE_BREAKPOINT;
5244           static unsigned char idt_little_breakpoint[] =
5245             IDT_LITTLE_BREAKPOINT;
5246
5247           *lenptr = sizeof (little_breakpoint);
5248
5249           if (strcmp (target_shortname, "mips") == 0)
5250             return idt_little_breakpoint;
5251           else if (strcmp (target_shortname, "ddb") == 0
5252                    || strcmp (target_shortname, "pmon") == 0
5253                    || strcmp (target_shortname, "lsi") == 0)
5254             return pmon_little_breakpoint;
5255           else
5256             return little_breakpoint;
5257         }
5258     }
5259 }
5260
5261 /* If PC is in a mips16 call or return stub, return the address of the target
5262    PC, which is either the callee or the caller.  There are several
5263    cases which must be handled:
5264
5265    * If the PC is in __mips16_ret_{d,s}f, this is a return stub and the
5266    target PC is in $31 ($ra).
5267    * If the PC is in __mips16_call_stub_{1..10}, this is a call stub
5268    and the target PC is in $2.
5269    * If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
5270    before the jal instruction, this is effectively a call stub
5271    and the the target PC is in $2.  Otherwise this is effectively
5272    a return stub and the target PC is in $18.
5273
5274    See the source code for the stubs in gcc/config/mips/mips16.S for
5275    gory details.
5276
5277    This function implements the SKIP_TRAMPOLINE_CODE macro.
5278  */
5279
5280 static CORE_ADDR
5281 mips_skip_stub (CORE_ADDR pc)
5282 {
5283   char *name;
5284   CORE_ADDR start_addr;
5285
5286   /* Find the starting address and name of the function containing the PC.  */
5287   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
5288     return 0;
5289
5290   /* If the PC is in __mips16_ret_{d,s}f, this is a return stub and the
5291      target PC is in $31 ($ra).  */
5292   if (strcmp (name, "__mips16_ret_sf") == 0
5293       || strcmp (name, "__mips16_ret_df") == 0)
5294     return read_signed_register (RA_REGNUM);
5295
5296   if (strncmp (name, "__mips16_call_stub_", 19) == 0)
5297     {
5298       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub
5299          and the target PC is in $2.  */
5300       if (name[19] >= '0' && name[19] <= '9')
5301         return read_signed_register (2);
5302
5303       /* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
5304          before the jal instruction, this is effectively a call stub
5305          and the the target PC is in $2.  Otherwise this is effectively
5306          a return stub and the target PC is in $18.  */
5307       else if (name[19] == 's' || name[19] == 'd')
5308         {
5309           if (pc == start_addr)
5310             {
5311               /* Check if the target of the stub is a compiler-generated
5312                  stub.  Such a stub for a function bar might have a name
5313                  like __fn_stub_bar, and might look like this:
5314                  mfc1    $4,$f13
5315                  mfc1    $5,$f12
5316                  mfc1    $6,$f15
5317                  mfc1    $7,$f14
5318                  la      $1,bar   (becomes a lui/addiu pair)
5319                  jr      $1
5320                  So scan down to the lui/addi and extract the target
5321                  address from those two instructions.  */
5322
5323               CORE_ADDR target_pc = read_signed_register (2);
5324               t_inst inst;
5325               int i;
5326
5327               /* See if the name of the target function is  __fn_stub_*.  */
5328               if (find_pc_partial_function (target_pc, &name, NULL, NULL) == 0)
5329                 return target_pc;
5330               if (strncmp (name, "__fn_stub_", 10) != 0
5331                   && strcmp (name, "etext") != 0
5332                   && strcmp (name, "_etext") != 0)
5333                 return target_pc;
5334
5335               /* Scan through this _fn_stub_ code for the lui/addiu pair.
5336                  The limit on the search is arbitrarily set to 20
5337                  instructions.  FIXME.  */
5338               for (i = 0, pc = 0; i < 20; i++, target_pc += MIPS_INSTLEN)
5339                 {
5340                   inst = mips_fetch_instruction (target_pc);
5341                   if ((inst & 0xffff0000) == 0x3c010000)        /* lui $at */
5342                     pc = (inst << 16) & 0xffff0000;     /* high word */
5343                   else if ((inst & 0xffff0000) == 0x24210000)   /* addiu $at */
5344                     return pc | (inst & 0xffff);        /* low word */
5345                 }
5346
5347               /* Couldn't find the lui/addui pair, so return stub address.  */
5348               return target_pc;
5349             }
5350           else
5351             /* This is the 'return' part of a call stub.  The return
5352                address is in $r18.  */
5353             return read_signed_register (18);
5354         }
5355     }
5356   return 0;                     /* not a stub */
5357 }
5358
5359
5360 /* Return non-zero if the PC is inside a call thunk (aka stub or trampoline).
5361    This implements the IN_SOLIB_CALL_TRAMPOLINE macro.  */
5362
5363 static int
5364 mips_in_call_stub (CORE_ADDR pc, char *name)
5365 {
5366   CORE_ADDR start_addr;
5367
5368   /* Find the starting address of the function containing the PC.  If the
5369      caller didn't give us a name, look it up at the same time.  */
5370   if (find_pc_partial_function (pc, name ? NULL : &name, &start_addr, NULL) == 0)
5371     return 0;
5372
5373   if (strncmp (name, "__mips16_call_stub_", 19) == 0)
5374     {
5375       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub.  */
5376       if (name[19] >= '0' && name[19] <= '9')
5377         return 1;
5378       /* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
5379          before the jal instruction, this is effectively a call stub.  */
5380       else if (name[19] == 's' || name[19] == 'd')
5381         return pc == start_addr;
5382     }
5383
5384   return 0;                     /* not a stub */
5385 }
5386
5387
5388 /* Return non-zero if the PC is inside a return thunk (aka stub or trampoline).
5389    This implements the IN_SOLIB_RETURN_TRAMPOLINE macro.  */
5390
5391 static int
5392 mips_in_return_stub (CORE_ADDR pc, char *name)
5393 {
5394   CORE_ADDR start_addr;
5395
5396   /* Find the starting address of the function containing the PC.  */
5397   if (find_pc_partial_function (pc, NULL, &start_addr, NULL) == 0)
5398     return 0;
5399
5400   /* If the PC is in __mips16_ret_{d,s}f, this is a return stub.  */
5401   if (strcmp (name, "__mips16_ret_sf") == 0
5402       || strcmp (name, "__mips16_ret_df") == 0)
5403     return 1;
5404
5405   /* If the PC is in __mips16_call_stub_{s,d}f_{0..10} but not at the start,
5406      i.e. after the jal instruction, this is effectively a return stub.  */
5407   if (strncmp (name, "__mips16_call_stub_", 19) == 0
5408       && (name[19] == 's' || name[19] == 'd')
5409       && pc != start_addr)
5410     return 1;
5411
5412   return 0;                     /* not a stub */
5413 }
5414
5415
5416 /* Return non-zero if the PC is in a library helper function that should
5417    be ignored.  This implements the IGNORE_HELPER_CALL macro.  */
5418
5419 int
5420 mips_ignore_helper (CORE_ADDR pc)
5421 {
5422   char *name;
5423
5424   /* Find the starting address and name of the function containing the PC.  */
5425   if (find_pc_partial_function (pc, &name, NULL, NULL) == 0)
5426     return 0;
5427
5428   /* If the PC is in __mips16_ret_{d,s}f, this is a library helper function
5429      that we want to ignore.  */
5430   return (strcmp (name, "__mips16_ret_sf") == 0
5431           || strcmp (name, "__mips16_ret_df") == 0);
5432 }
5433
5434
5435 /* Return a location where we can set a breakpoint that will be hit
5436    when an inferior function call returns.  This is normally the
5437    program's entry point.  Executables that don't have an entry
5438    point (e.g. programs in ROM) should define a symbol __CALL_DUMMY_ADDRESS
5439    whose address is the location where the breakpoint should be placed.  */
5440
5441 static CORE_ADDR
5442 mips_call_dummy_address (void)
5443 {
5444   struct minimal_symbol *sym;
5445
5446   sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
5447   if (sym)
5448     return SYMBOL_VALUE_ADDRESS (sym);
5449   else
5450     return entry_point_address ();
5451 }
5452
5453
5454 /* If the current gcc for this target does not produce correct debugging
5455    information for float parameters, both prototyped and unprototyped, then
5456    define this macro.  This forces gdb to  always assume that floats are
5457    passed as doubles and then converted in the callee.
5458
5459    For the mips chip, it appears that the debug info marks the parameters as
5460    floats regardless of whether the function is prototyped, but the actual
5461    values are passed as doubles for the non-prototyped case and floats for
5462    the prototyped case.  Thus we choose to make the non-prototyped case work
5463    for C and break the prototyped case, since the non-prototyped case is
5464    probably much more common.  (FIXME). */
5465
5466 static int
5467 mips_coerce_float_to_double (struct type *formal, struct type *actual)
5468 {
5469   return current_language->la_language == language_c;
5470 }
5471
5472 /* When debugging a 64 MIPS target running a 32 bit ABI, the size of
5473    the register stored on the stack (32) is different to its real raw
5474    size (64).  The below ensures that registers are fetched from the
5475    stack using their ABI size and then stored into the RAW_BUFFER
5476    using their raw size.
5477
5478    The alternative to adding this function would be to add an ABI
5479    macro - REGISTER_STACK_SIZE(). */
5480
5481 static void
5482 mips_get_saved_register (char *raw_buffer,
5483                          int *optimizedp,
5484                          CORE_ADDR *addrp,
5485                          struct frame_info *frame,
5486                          int regnum,
5487                          enum lval_type *lvalp)
5488 {
5489   CORE_ADDR addrx;
5490   enum lval_type lvalx;
5491   int optimizedx;
5492   int realnum;
5493
5494   if (!target_has_registers)
5495     error ("No registers.");
5496
5497   /* Make certain that all needed parameters are present.  */
5498   if (addrp == NULL)
5499     addrp = &addrx;
5500   if (lvalp == NULL)
5501     lvalp = &lvalx;
5502   if (optimizedp == NULL)
5503     optimizedp = &optimizedx;
5504   frame_register_unwind (get_next_frame (frame), regnum, optimizedp, lvalp,
5505                          addrp, &realnum, raw_buffer);
5506   /* FIXME: cagney/2002-09-13: This is just so bad.  The MIPS should
5507      have a pseudo register range that correspons to the ABI's, rather
5508      than the ISA's, view of registers.  These registers would then
5509      implicitly describe their size and hence could be used without
5510      the below munging.  */
5511   if ((*lvalp) == lval_memory)
5512     {
5513       if (raw_buffer != NULL)
5514         {
5515           if (regnum < 32)
5516             {
5517               /* Only MIPS_SAVED_REGSIZE bytes of GP registers are
5518                  saved. */
5519               LONGEST val = read_memory_integer ((*addrp), MIPS_SAVED_REGSIZE);
5520               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), val);
5521             }
5522         }
5523     }
5524 }
5525
5526 /* Immediately after a function call, return the saved pc.
5527    Can't always go through the frames for this because on some machines
5528    the new frame is not set up until the new function executes
5529    some instructions.  */
5530
5531 static CORE_ADDR
5532 mips_saved_pc_after_call (struct frame_info *frame)
5533 {
5534   return read_signed_register (RA_REGNUM);
5535 }
5536
5537
5538 /* Convert a dbx stab register number (from `r' declaration) to a gdb
5539    REGNUM */
5540
5541 static int
5542 mips_stab_reg_to_regnum (int num)
5543 {
5544   if (num < 32)
5545     return num;
5546   else
5547     return num + FP0_REGNUM - 38;
5548 }
5549
5550 /* Convert a ecoff register number to a gdb REGNUM */
5551
5552 static int
5553 mips_ecoff_reg_to_regnum (int num)
5554 {
5555   if (num < 32)
5556     return num;
5557   else
5558     return num + FP0_REGNUM - 32;
5559 }
5560
5561 /* Convert an integer into an address.  By first converting the value
5562    into a pointer and then extracting it signed, the address is
5563    guarenteed to be correctly sign extended.  */
5564
5565 static CORE_ADDR
5566 mips_integer_to_address (struct type *type, void *buf)
5567 {
5568   char *tmp = alloca (TYPE_LENGTH (builtin_type_void_data_ptr));
5569   LONGEST val = unpack_long (type, buf);
5570   store_signed_integer (tmp, TYPE_LENGTH (builtin_type_void_data_ptr), val);
5571   return extract_signed_integer (tmp,
5572                                  TYPE_LENGTH (builtin_type_void_data_ptr));
5573 }
5574
5575 static void
5576 mips_find_abi_section (bfd *abfd, asection *sect, void *obj)
5577 {
5578   enum mips_abi *abip = (enum mips_abi *) obj;
5579   const char *name = bfd_get_section_name (abfd, sect);
5580
5581   if (*abip != MIPS_ABI_UNKNOWN)
5582     return;
5583
5584   if (strncmp (name, ".mdebug.", 8) != 0)
5585     return;
5586
5587   if (strcmp (name, ".mdebug.abi32") == 0)
5588     *abip = MIPS_ABI_O32;
5589   else if (strcmp (name, ".mdebug.abiN32") == 0)
5590     *abip = MIPS_ABI_N32;
5591   else if (strcmp (name, ".mdebug.abi64") == 0)
5592     *abip = MIPS_ABI_N64;
5593   else if (strcmp (name, ".mdebug.abiO64") == 0)
5594     *abip = MIPS_ABI_O64;
5595   else if (strcmp (name, ".mdebug.eabi32") == 0)
5596     *abip = MIPS_ABI_EABI32;
5597   else if (strcmp (name, ".mdebug.eabi64") == 0)
5598     *abip = MIPS_ABI_EABI64;
5599   else
5600     warning ("unsupported ABI %s.", name + 8);
5601 }
5602
5603 static enum mips_abi
5604 global_mips_abi (void)
5605 {
5606   int i;
5607
5608   for (i = 0; mips_abi_strings[i] != NULL; i++)
5609     if (mips_abi_strings[i] == mips_abi_string)
5610       return (enum mips_abi) i;
5611
5612   internal_error (__FILE__, __LINE__,
5613                   "unknown ABI string");
5614 }
5615
5616 static struct gdbarch *
5617 mips_gdbarch_init (struct gdbarch_info info,
5618                    struct gdbarch_list *arches)
5619 {
5620   static LONGEST mips_call_dummy_words[] =
5621   {0};
5622   struct gdbarch *gdbarch;
5623   struct gdbarch_tdep *tdep;
5624   int elf_flags;
5625   enum mips_abi mips_abi, found_abi, wanted_abi;
5626   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
5627
5628   /* Reset the disassembly info, in case it was set to something
5629      non-default.  */
5630   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
5631   tm_print_insn_info.arch = bfd_arch_unknown;
5632   tm_print_insn_info.mach = 0;
5633
5634   elf_flags = 0;
5635
5636   if (info.abfd)
5637     {
5638       /* First of all, extract the elf_flags, if available.  */
5639       if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
5640         elf_flags = elf_elfheader (info.abfd)->e_flags;
5641
5642       /* Try to determine the OS ABI of the object we are loading.  If
5643          we end up with `unknown', just leave it that way.  */
5644       osabi = gdbarch_lookup_osabi (info.abfd);
5645     }
5646
5647   /* Check ELF_FLAGS to see if it specifies the ABI being used.  */
5648   switch ((elf_flags & EF_MIPS_ABI))
5649     {
5650     case E_MIPS_ABI_O32:
5651       mips_abi = MIPS_ABI_O32;
5652       break;
5653     case E_MIPS_ABI_O64:
5654       mips_abi = MIPS_ABI_O64;
5655       break;
5656     case E_MIPS_ABI_EABI32:
5657       mips_abi = MIPS_ABI_EABI32;
5658       break;
5659     case E_MIPS_ABI_EABI64:
5660       mips_abi = MIPS_ABI_EABI64;
5661       break;
5662     default:
5663       if ((elf_flags & EF_MIPS_ABI2))
5664         mips_abi = MIPS_ABI_N32;
5665       else
5666         mips_abi = MIPS_ABI_UNKNOWN;
5667       break;
5668     }
5669
5670   /* GCC creates a pseudo-section whose name describes the ABI.  */
5671   if (mips_abi == MIPS_ABI_UNKNOWN && info.abfd != NULL)
5672     bfd_map_over_sections (info.abfd, mips_find_abi_section, &mips_abi);
5673
5674   /* If we have no bfd, then mips_abi will still be MIPS_ABI_UNKNOWN.
5675      Use the ABI from the last architecture if there is one.  */
5676   if (info.abfd == NULL && arches != NULL)
5677     mips_abi = gdbarch_tdep (arches->gdbarch)->found_abi;
5678
5679   /* Try the architecture for any hint of the correct ABI.  */
5680   if (mips_abi == MIPS_ABI_UNKNOWN
5681       && info.bfd_arch_info != NULL
5682       && info.bfd_arch_info->arch == bfd_arch_mips)
5683     {
5684       switch (info.bfd_arch_info->mach)
5685         {
5686         case bfd_mach_mips3900:
5687           mips_abi = MIPS_ABI_EABI32;
5688           break;
5689         case bfd_mach_mips4100:
5690         case bfd_mach_mips5000:
5691           mips_abi = MIPS_ABI_EABI64;
5692           break;
5693         case bfd_mach_mips8000:
5694         case bfd_mach_mips10000:
5695           /* On Irix, ELF64 executables use the N64 ABI.  The
5696              pseudo-sections which describe the ABI aren't present
5697              on IRIX.  (Even for executables created by gcc.)  */
5698           if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
5699               && elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
5700             mips_abi = MIPS_ABI_N64;
5701           else
5702             mips_abi = MIPS_ABI_N32;
5703           break;
5704         }
5705     }
5706
5707   if (mips_abi == MIPS_ABI_UNKNOWN)
5708     mips_abi = MIPS_ABI_O32;
5709
5710   /* Now that we have found what the ABI for this binary would be,
5711      check whether the user is overriding it.  */
5712   found_abi = mips_abi;
5713   wanted_abi = global_mips_abi ();
5714   if (wanted_abi != MIPS_ABI_UNKNOWN)
5715     mips_abi = wanted_abi;
5716
5717   if (gdbarch_debug)
5718     {
5719       fprintf_unfiltered (gdb_stdlog,
5720                           "mips_gdbarch_init: elf_flags = 0x%08x\n",
5721                           elf_flags);
5722       fprintf_unfiltered (gdb_stdlog,
5723                           "mips_gdbarch_init: mips_abi = %d\n",
5724                           mips_abi);
5725       fprintf_unfiltered (gdb_stdlog,
5726                           "mips_gdbarch_init: found_mips_abi = %d\n",
5727                           found_abi);
5728     }
5729
5730   /* try to find a pre-existing architecture */
5731   for (arches = gdbarch_list_lookup_by_info (arches, &info);
5732        arches != NULL;
5733        arches = gdbarch_list_lookup_by_info (arches->next, &info))
5734     {
5735       /* MIPS needs to be pedantic about which ABI the object is
5736          using.  */
5737       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
5738         continue;
5739       if (gdbarch_tdep (arches->gdbarch)->mips_abi != mips_abi)
5740         continue;
5741       if (gdbarch_tdep (arches->gdbarch)->osabi == osabi)
5742         return arches->gdbarch;
5743     }
5744
5745   /* Need a new architecture.  Fill in a target specific vector.  */
5746   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
5747   gdbarch = gdbarch_alloc (&info, tdep);
5748   tdep->elf_flags = elf_flags;
5749   tdep->osabi = osabi;
5750
5751   /* Initially set everything according to the default ABI/ISA.  */
5752   set_gdbarch_short_bit (gdbarch, 16);
5753   set_gdbarch_int_bit (gdbarch, 32);
5754   set_gdbarch_float_bit (gdbarch, 32);
5755   set_gdbarch_double_bit (gdbarch, 64);
5756   set_gdbarch_long_double_bit (gdbarch, 64);
5757   set_gdbarch_register_raw_size (gdbarch, mips_register_raw_size);
5758   set_gdbarch_max_register_raw_size (gdbarch, 8);
5759   set_gdbarch_max_register_virtual_size (gdbarch, 8);
5760   tdep->found_abi = found_abi;
5761   tdep->mips_abi = mips_abi;
5762
5763   set_gdbarch_elf_make_msymbol_special (gdbarch,
5764                                         mips_elf_make_msymbol_special);
5765
5766   switch (mips_abi)
5767     {
5768     case MIPS_ABI_O32:
5769       set_gdbarch_push_arguments (gdbarch, mips_o32_push_arguments);
5770       set_gdbarch_deprecated_store_return_value (gdbarch, mips_o32_store_return_value);
5771       set_gdbarch_extract_return_value (gdbarch, mips_o32_extract_return_value);
5772       tdep->mips_default_saved_regsize = 4;
5773       tdep->mips_default_stack_argsize = 4;
5774       tdep->mips_fp_register_double = 0;
5775       tdep->mips_last_arg_regnum = A0_REGNUM + 4 - 1;
5776       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 4 - 1;
5777       tdep->gdb_target_is_mips64 = 0;
5778       tdep->default_mask_address_p = 0;
5779       set_gdbarch_long_bit (gdbarch, 32);
5780       set_gdbarch_ptr_bit (gdbarch, 32);
5781       set_gdbarch_long_long_bit (gdbarch, 64);
5782       set_gdbarch_reg_struct_has_addr (gdbarch,
5783                                        mips_o32_reg_struct_has_addr);
5784       set_gdbarch_use_struct_convention (gdbarch,
5785                                          mips_o32_use_struct_convention);
5786       break;
5787     case MIPS_ABI_O64:
5788       set_gdbarch_push_arguments (gdbarch, mips_o64_push_arguments);
5789       set_gdbarch_deprecated_store_return_value (gdbarch, mips_o64_store_return_value);
5790       set_gdbarch_deprecated_extract_return_value (gdbarch, mips_o64_extract_return_value);
5791       tdep->mips_default_saved_regsize = 8;
5792       tdep->mips_default_stack_argsize = 8;
5793       tdep->mips_fp_register_double = 1;
5794       tdep->mips_last_arg_regnum = A0_REGNUM + 4 - 1;
5795       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 4 - 1;
5796       tdep->gdb_target_is_mips64 = 1;
5797       tdep->default_mask_address_p = 0;
5798       set_gdbarch_long_bit (gdbarch, 32);
5799       set_gdbarch_ptr_bit (gdbarch, 32);
5800       set_gdbarch_long_long_bit (gdbarch, 64);
5801       set_gdbarch_reg_struct_has_addr (gdbarch,
5802                                        mips_o32_reg_struct_has_addr);
5803       set_gdbarch_use_struct_convention (gdbarch,
5804                                          mips_o32_use_struct_convention);
5805       break;
5806     case MIPS_ABI_EABI32:
5807       set_gdbarch_push_arguments (gdbarch, mips_eabi_push_arguments);
5808       set_gdbarch_deprecated_store_return_value (gdbarch, mips_eabi_store_return_value);
5809       set_gdbarch_deprecated_extract_return_value (gdbarch, mips_eabi_extract_return_value);
5810       tdep->mips_default_saved_regsize = 4;
5811       tdep->mips_default_stack_argsize = 4;
5812       tdep->mips_fp_register_double = 0;
5813       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5814       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5815       tdep->gdb_target_is_mips64 = 0;
5816       tdep->default_mask_address_p = 0;
5817       set_gdbarch_long_bit (gdbarch, 32);
5818       set_gdbarch_ptr_bit (gdbarch, 32);
5819       set_gdbarch_long_long_bit (gdbarch, 64);
5820       set_gdbarch_reg_struct_has_addr (gdbarch,
5821                                        mips_eabi_reg_struct_has_addr);
5822       set_gdbarch_use_struct_convention (gdbarch,
5823                                          mips_eabi_use_struct_convention);
5824       break;
5825     case MIPS_ABI_EABI64:
5826       set_gdbarch_push_arguments (gdbarch, mips_eabi_push_arguments);
5827       set_gdbarch_deprecated_store_return_value (gdbarch, mips_eabi_store_return_value);
5828       set_gdbarch_deprecated_extract_return_value (gdbarch, mips_eabi_extract_return_value);
5829       tdep->mips_default_saved_regsize = 8;
5830       tdep->mips_default_stack_argsize = 8;
5831       tdep->mips_fp_register_double = 1;
5832       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5833       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5834       tdep->gdb_target_is_mips64 = 1;
5835       tdep->default_mask_address_p = 0;
5836       set_gdbarch_long_bit (gdbarch, 64);
5837       set_gdbarch_ptr_bit (gdbarch, 64);
5838       set_gdbarch_long_long_bit (gdbarch, 64);
5839       set_gdbarch_reg_struct_has_addr (gdbarch,
5840                                        mips_eabi_reg_struct_has_addr);
5841       set_gdbarch_use_struct_convention (gdbarch,
5842                                          mips_eabi_use_struct_convention);
5843       break;
5844     case MIPS_ABI_N32:
5845       set_gdbarch_push_arguments (gdbarch, mips_n32n64_push_arguments);
5846       set_gdbarch_deprecated_store_return_value (gdbarch, mips_n32n64_store_return_value);
5847       set_gdbarch_extract_return_value (gdbarch, mips_n32n64_extract_return_value);
5848       tdep->mips_default_saved_regsize = 8;
5849       tdep->mips_default_stack_argsize = 8;
5850       tdep->mips_fp_register_double = 1;
5851       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5852       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5853       tdep->gdb_target_is_mips64 = 1;
5854       tdep->default_mask_address_p = 0;
5855       set_gdbarch_long_bit (gdbarch, 32);
5856       set_gdbarch_ptr_bit (gdbarch, 32);
5857       set_gdbarch_long_long_bit (gdbarch, 64);
5858
5859       /* Set up the disassembler info, so that we get the right
5860          register names from libopcodes.  */
5861       tm_print_insn_info.flavour = bfd_target_elf_flavour;
5862       tm_print_insn_info.arch = bfd_arch_mips;
5863       if (info.bfd_arch_info != NULL
5864           && info.bfd_arch_info->arch == bfd_arch_mips
5865           && info.bfd_arch_info->mach)
5866         tm_print_insn_info.mach = info.bfd_arch_info->mach;
5867       else
5868         tm_print_insn_info.mach = bfd_mach_mips8000;
5869
5870       set_gdbarch_use_struct_convention (gdbarch,
5871                                          mips_n32n64_use_struct_convention);
5872       set_gdbarch_reg_struct_has_addr (gdbarch,
5873                                        mips_n32n64_reg_struct_has_addr);
5874       break;
5875     case MIPS_ABI_N64:
5876       set_gdbarch_push_arguments (gdbarch, mips_n32n64_push_arguments);
5877       set_gdbarch_deprecated_store_return_value (gdbarch, mips_n32n64_store_return_value);
5878       set_gdbarch_extract_return_value (gdbarch, mips_n32n64_extract_return_value);
5879       tdep->mips_default_saved_regsize = 8;
5880       tdep->mips_default_stack_argsize = 8;
5881       tdep->mips_fp_register_double = 1;
5882       tdep->mips_last_arg_regnum = A0_REGNUM + 8 - 1;
5883       tdep->mips_last_fp_arg_regnum = FPA0_REGNUM + 8 - 1;
5884       tdep->gdb_target_is_mips64 = 1;
5885       tdep->default_mask_address_p = 0;
5886       set_gdbarch_long_bit (gdbarch, 64);
5887       set_gdbarch_ptr_bit (gdbarch, 64);
5888       set_gdbarch_long_long_bit (gdbarch, 64);
5889
5890       /* Set up the disassembler info, so that we get the right
5891          register names from libopcodes.  */
5892       tm_print_insn_info.flavour = bfd_target_elf_flavour;
5893       tm_print_insn_info.arch = bfd_arch_mips;
5894       if (info.bfd_arch_info != NULL
5895           && info.bfd_arch_info->arch == bfd_arch_mips
5896           && info.bfd_arch_info->mach)
5897         tm_print_insn_info.mach = info.bfd_arch_info->mach;
5898       else
5899         tm_print_insn_info.mach = bfd_mach_mips8000;
5900
5901       set_gdbarch_use_struct_convention (gdbarch,
5902                                          mips_n32n64_use_struct_convention);
5903       set_gdbarch_reg_struct_has_addr (gdbarch,
5904                                        mips_n32n64_reg_struct_has_addr);
5905       break;
5906     default:
5907       internal_error (__FILE__, __LINE__,
5908                       "unknown ABI in switch");
5909     }
5910
5911   /* FIXME: jlarmour/2000-04-07: There *is* a flag EF_MIPS_32BIT_MODE
5912      that could indicate -gp32 BUT gas/config/tc-mips.c contains the
5913      comment:
5914
5915      ``We deliberately don't allow "-gp32" to set the MIPS_32BITMODE
5916      flag in object files because to do so would make it impossible to
5917      link with libraries compiled without "-gp32".  This is
5918      unnecessarily restrictive.
5919
5920      We could solve this problem by adding "-gp32" multilibs to gcc,
5921      but to set this flag before gcc is built with such multilibs will
5922      break too many systems.''
5923
5924      But even more unhelpfully, the default linker output target for
5925      mips64-elf is elf32-bigmips, and has EF_MIPS_32BIT_MODE set, even
5926      for 64-bit programs - you need to change the ABI to change this,
5927      and not all gcc targets support that currently.  Therefore using
5928      this flag to detect 32-bit mode would do the wrong thing given
5929      the current gcc - it would make GDB treat these 64-bit programs
5930      as 32-bit programs by default.  */
5931
5932   /* enable/disable the MIPS FPU */
5933   if (!mips_fpu_type_auto)
5934     tdep->mips_fpu_type = mips_fpu_type;
5935   else if (info.bfd_arch_info != NULL
5936            && info.bfd_arch_info->arch == bfd_arch_mips)
5937     switch (info.bfd_arch_info->mach)
5938       {
5939       case bfd_mach_mips3900:
5940       case bfd_mach_mips4100:
5941       case bfd_mach_mips4111:
5942         tdep->mips_fpu_type = MIPS_FPU_NONE;
5943         break;
5944       case bfd_mach_mips4650:
5945         tdep->mips_fpu_type = MIPS_FPU_SINGLE;
5946         break;
5947       default:
5948         tdep->mips_fpu_type = MIPS_FPU_DOUBLE;
5949         break;
5950       }
5951   else
5952     tdep->mips_fpu_type = MIPS_FPU_DOUBLE;
5953
5954   /* MIPS version of register names.  NOTE: At present the MIPS
5955      register name management is part way between the old -
5956      #undef/#define REGISTER_NAMES and the new REGISTER_NAME(nr).
5957      Further work on it is required.  */
5958   /* NOTE: many targets (esp. embedded) do not go thru the
5959      gdbarch_register_name vector at all, instead bypassing it
5960      by defining REGISTER_NAMES.  */
5961   set_gdbarch_register_name (gdbarch, mips_register_name);
5962   set_gdbarch_read_pc (gdbarch, mips_read_pc);
5963   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
5964   set_gdbarch_read_fp (gdbarch, mips_read_sp); /* Draft FRAME base.  */
5965   set_gdbarch_read_sp (gdbarch, mips_read_sp);
5966   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
5967
5968   /* Add/remove bits from an address.  The MIPS needs be careful to
5969      ensure that all 32 bit addresses are sign extended to 64 bits.  */
5970   set_gdbarch_addr_bits_remove (gdbarch, mips_addr_bits_remove);
5971
5972   /* There's a mess in stack frame creation.  See comments in
5973      blockframe.c near reference to INIT_FRAME_PC_FIRST.  */
5974   set_gdbarch_init_frame_pc_first (gdbarch, mips_init_frame_pc_first);
5975   set_gdbarch_init_frame_pc (gdbarch, init_frame_pc_noop);
5976
5977   /* Map debug register numbers onto internal register numbers.  */
5978   set_gdbarch_stab_reg_to_regnum (gdbarch, mips_stab_reg_to_regnum);
5979   set_gdbarch_ecoff_reg_to_regnum (gdbarch, mips_ecoff_reg_to_regnum);
5980
5981   /* Initialize a frame */
5982   set_gdbarch_init_extra_frame_info (gdbarch, mips_init_extra_frame_info);
5983   set_gdbarch_frame_init_saved_regs (gdbarch, mips_frame_init_saved_regs);
5984
5985   /* MIPS version of CALL_DUMMY */
5986
5987   set_gdbarch_call_dummy_p (gdbarch, 1);
5988   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
5989 #if OLD_STYLE_MIPS_DUMMY_FRAMES
5990   set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
5991 #else
5992   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
5993 #endif
5994   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
5995   set_gdbarch_call_dummy_address (gdbarch, mips_call_dummy_address);
5996   set_gdbarch_push_return_address (gdbarch, mips_push_return_address);
5997 #if OLD_STYLE_MIPS_DUMMY_FRAMES
5998   set_gdbarch_push_dummy_frame (gdbarch, mips_push_dummy_frame);
5999 #else
6000   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
6001 #endif
6002   set_gdbarch_pop_frame (gdbarch, mips_pop_frame);
6003   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
6004   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
6005   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
6006   set_gdbarch_call_dummy_length (gdbarch, 0);
6007   set_gdbarch_fix_call_dummy (gdbarch, mips_fix_call_dummy);
6008 #if OLD_STYLE_MIPS_DUMMY_FRAMES
6009   set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
6010 #else
6011   set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
6012 #endif
6013   set_gdbarch_call_dummy_words (gdbarch, mips_call_dummy_words);
6014   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (mips_call_dummy_words));
6015   set_gdbarch_push_return_address (gdbarch, mips_push_return_address);
6016   set_gdbarch_frame_align (gdbarch, mips_frame_align);
6017 #if OLD_STYLE_MIPS_DUMMY_FRAMES
6018 #else
6019   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
6020 #endif
6021   set_gdbarch_register_convertible (gdbarch, mips_register_convertible);
6022   set_gdbarch_register_convert_to_virtual (gdbarch,
6023                                            mips_register_convert_to_virtual);
6024   set_gdbarch_register_convert_to_raw (gdbarch,
6025                                        mips_register_convert_to_raw);
6026
6027   set_gdbarch_coerce_float_to_double (gdbarch, mips_coerce_float_to_double);
6028
6029   set_gdbarch_frame_chain (gdbarch, mips_frame_chain);
6030   set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
6031   set_gdbarch_frameless_function_invocation (gdbarch,
6032                                              generic_frameless_function_invocation_not);
6033   set_gdbarch_frame_saved_pc (gdbarch, mips_frame_saved_pc);
6034   set_gdbarch_frame_args_address (gdbarch, default_frame_address);
6035   set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
6036   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
6037   set_gdbarch_frame_args_skip (gdbarch, 0);
6038
6039   set_gdbarch_get_saved_register (gdbarch, mips_get_saved_register);
6040
6041   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
6042   set_gdbarch_breakpoint_from_pc (gdbarch, mips_breakpoint_from_pc);
6043   set_gdbarch_decr_pc_after_break (gdbarch, 0);
6044
6045   set_gdbarch_skip_prologue (gdbarch, mips_skip_prologue);
6046   set_gdbarch_saved_pc_after_call (gdbarch, mips_saved_pc_after_call);
6047
6048   set_gdbarch_pointer_to_address (gdbarch, signed_pointer_to_address);
6049   set_gdbarch_address_to_pointer (gdbarch, address_to_signed_pointer);
6050   set_gdbarch_integer_to_address (gdbarch, mips_integer_to_address);
6051
6052   set_gdbarch_function_start_offset (gdbarch, 0);
6053
6054   /* There are MIPS targets which do not yet use this since they still
6055      define REGISTER_VIRTUAL_TYPE.  */
6056   set_gdbarch_register_virtual_type (gdbarch, mips_register_virtual_type);
6057   set_gdbarch_register_virtual_size (gdbarch, generic_register_size);
6058
6059   set_gdbarch_deprecated_do_registers_info (gdbarch, mips_do_registers_info);
6060   set_gdbarch_pc_in_sigtramp (gdbarch, mips_pc_in_sigtramp);
6061
6062   /* Hook in OS ABI-specific overrides, if they have been registered.  */
6063   gdbarch_init_osabi (info, gdbarch, osabi);
6064
6065   set_gdbarch_store_struct_return (gdbarch, mips_store_struct_return);
6066   set_gdbarch_extract_struct_value_address (gdbarch,
6067                                             mips_extract_struct_value_address);
6068
6069   set_gdbarch_skip_trampoline_code (gdbarch, mips_skip_stub);
6070
6071   set_gdbarch_in_solib_call_trampoline (gdbarch, mips_in_call_stub);
6072   set_gdbarch_in_solib_return_trampoline (gdbarch, mips_in_return_stub);
6073
6074   return gdbarch;
6075 }
6076
6077 static void
6078 mips_abi_update (char *ignore_args, int from_tty,
6079                  struct cmd_list_element *c)
6080 {
6081   struct gdbarch_info info;
6082
6083   /* Force the architecture to update, and (if it's a MIPS architecture)
6084      mips_gdbarch_init will take care of the rest.  */
6085   gdbarch_info_init (&info);
6086   gdbarch_update_p (info);
6087 }
6088
6089 static void
6090 mips_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
6091 {
6092   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
6093   if (tdep != NULL)
6094     {
6095       int ef_mips_arch;
6096       int ef_mips_32bitmode;
6097       /* determine the ISA */
6098       switch (tdep->elf_flags & EF_MIPS_ARCH)
6099         {
6100         case E_MIPS_ARCH_1:
6101           ef_mips_arch = 1;
6102           break;
6103         case E_MIPS_ARCH_2:
6104           ef_mips_arch = 2;
6105           break;
6106         case E_MIPS_ARCH_3:
6107           ef_mips_arch = 3;
6108           break;
6109         case E_MIPS_ARCH_4:
6110           ef_mips_arch = 4;
6111           break;
6112         default:
6113           ef_mips_arch = 0;
6114           break;
6115         }
6116       /* determine the size of a pointer */
6117       ef_mips_32bitmode = (tdep->elf_flags & EF_MIPS_32BITMODE);
6118       fprintf_unfiltered (file,
6119                           "mips_dump_tdep: tdep->elf_flags = 0x%x\n",
6120                           tdep->elf_flags);
6121       fprintf_unfiltered (file,
6122                           "mips_dump_tdep: ef_mips_32bitmode = %d\n",
6123                           ef_mips_32bitmode);
6124       fprintf_unfiltered (file,
6125                           "mips_dump_tdep: ef_mips_arch = %d\n",
6126                           ef_mips_arch);
6127       fprintf_unfiltered (file,
6128                           "mips_dump_tdep: tdep->mips_abi = %d (%s)\n",
6129                           tdep->mips_abi,
6130                           mips_abi_strings[tdep->mips_abi]);
6131       fprintf_unfiltered (file,
6132                           "mips_dump_tdep: mips_mask_address_p() %d (default %d)\n",
6133                           mips_mask_address_p (),
6134                           tdep->default_mask_address_p);
6135     }
6136   fprintf_unfiltered (file,
6137                       "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
6138                       FP_REGISTER_DOUBLE);
6139   fprintf_unfiltered (file,
6140                       "mips_dump_tdep: MIPS_DEFAULT_FPU_TYPE = %d (%s)\n",
6141                       MIPS_DEFAULT_FPU_TYPE,
6142                       (MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_NONE ? "none"
6143                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
6144                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
6145                        : "???"));
6146   fprintf_unfiltered (file,
6147                       "mips_dump_tdep: MIPS_EABI = %d\n",
6148                       MIPS_EABI);
6149   fprintf_unfiltered (file,
6150                       "mips_dump_tdep: MIPS_LAST_FP_ARG_REGNUM = %d (%d regs)\n",
6151                       MIPS_LAST_FP_ARG_REGNUM,
6152                       MIPS_LAST_FP_ARG_REGNUM - FPA0_REGNUM + 1);
6153   fprintf_unfiltered (file,
6154                       "mips_dump_tdep: MIPS_FPU_TYPE = %d (%s)\n",
6155                       MIPS_FPU_TYPE,
6156                       (MIPS_FPU_TYPE == MIPS_FPU_NONE ? "none"
6157                        : MIPS_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
6158                        : MIPS_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
6159                        : "???"));
6160   fprintf_unfiltered (file,
6161                       "mips_dump_tdep: MIPS_DEFAULT_SAVED_REGSIZE = %d\n",
6162                       MIPS_DEFAULT_SAVED_REGSIZE);
6163   fprintf_unfiltered (file,
6164                       "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
6165                       FP_REGISTER_DOUBLE);
6166   fprintf_unfiltered (file,
6167                       "mips_dump_tdep: MIPS_DEFAULT_STACK_ARGSIZE = %d\n",
6168                       MIPS_DEFAULT_STACK_ARGSIZE);
6169   fprintf_unfiltered (file,
6170                       "mips_dump_tdep: MIPS_STACK_ARGSIZE = %d\n",
6171                       MIPS_STACK_ARGSIZE);
6172   fprintf_unfiltered (file,
6173                       "mips_dump_tdep: MIPS_REGSIZE = %d\n",
6174                       MIPS_REGSIZE);
6175   fprintf_unfiltered (file,
6176                       "mips_dump_tdep: A0_REGNUM = %d\n",
6177                       A0_REGNUM);
6178   fprintf_unfiltered (file,
6179                       "mips_dump_tdep: ADDR_BITS_REMOVE # %s\n",
6180                       XSTRING (ADDR_BITS_REMOVE(ADDR)));
6181   fprintf_unfiltered (file,
6182                       "mips_dump_tdep: ATTACH_DETACH # %s\n",
6183                       XSTRING (ATTACH_DETACH));
6184   fprintf_unfiltered (file,
6185                       "mips_dump_tdep: BADVADDR_REGNUM = %d\n",
6186                       BADVADDR_REGNUM);
6187   fprintf_unfiltered (file,
6188                       "mips_dump_tdep: BIG_BREAKPOINT = delete?\n");
6189   fprintf_unfiltered (file,
6190                       "mips_dump_tdep: CAUSE_REGNUM = %d\n",
6191                       CAUSE_REGNUM);
6192   fprintf_unfiltered (file,
6193                       "mips_dump_tdep: DWARF_REG_TO_REGNUM # %s\n",
6194                       XSTRING (DWARF_REG_TO_REGNUM (REGNUM)));
6195   fprintf_unfiltered (file,
6196                       "mips_dump_tdep: ECOFF_REG_TO_REGNUM # %s\n",
6197                       XSTRING (ECOFF_REG_TO_REGNUM (REGNUM)));
6198   fprintf_unfiltered (file,
6199                       "mips_dump_tdep: FCRCS_REGNUM = %d\n",
6200                       FCRCS_REGNUM);
6201   fprintf_unfiltered (file,
6202                       "mips_dump_tdep: FCRIR_REGNUM = %d\n",
6203                       FCRIR_REGNUM);
6204   fprintf_unfiltered (file,
6205                       "mips_dump_tdep: FIRST_EMBED_REGNUM = %d\n",
6206                       FIRST_EMBED_REGNUM);
6207   fprintf_unfiltered (file,
6208                       "mips_dump_tdep: FPA0_REGNUM = %d\n",
6209                       FPA0_REGNUM);
6210   fprintf_unfiltered (file,
6211                       "mips_dump_tdep: GDB_TARGET_IS_MIPS64 = %d\n",
6212                       GDB_TARGET_IS_MIPS64);
6213   fprintf_unfiltered (file,
6214                       "mips_dump_tdep: GDB_TARGET_MASK_DISAS_PC # %s\n",
6215                       XSTRING (GDB_TARGET_MASK_DISAS_PC (PC)));
6216   fprintf_unfiltered (file,
6217                       "mips_dump_tdep: GDB_TARGET_UNMASK_DISAS_PC # %s\n",
6218                       XSTRING (GDB_TARGET_UNMASK_DISAS_PC (PC)));
6219   fprintf_unfiltered (file,
6220                       "mips_dump_tdep: GEN_REG_SAVE_MASK = %d\n",
6221                       GEN_REG_SAVE_MASK);
6222   fprintf_unfiltered (file,
6223                       "mips_dump_tdep: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
6224                       XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
6225   fprintf_unfiltered (file,
6226                       "mips_dump_tdep:  HI_REGNUM = %d\n",
6227                       HI_REGNUM);
6228   fprintf_unfiltered (file,
6229                       "mips_dump_tdep: IDT_BIG_BREAKPOINT = delete?\n");
6230   fprintf_unfiltered (file,
6231                       "mips_dump_tdep: IDT_LITTLE_BREAKPOINT = delete?\n");
6232   fprintf_unfiltered (file,
6233                       "mips_dump_tdep: IGNORE_HELPER_CALL # %s\n",
6234                       XSTRING (IGNORE_HELPER_CALL (PC)));
6235   fprintf_unfiltered (file,
6236                       "mips_dump_tdep: IN_SOLIB_CALL_TRAMPOLINE # %s\n",
6237                       XSTRING (IN_SOLIB_CALL_TRAMPOLINE (PC, NAME)));
6238   fprintf_unfiltered (file,
6239                       "mips_dump_tdep: IN_SOLIB_RETURN_TRAMPOLINE # %s\n",
6240                       XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (PC, NAME)));
6241   fprintf_unfiltered (file,
6242                       "mips_dump_tdep: IS_MIPS16_ADDR = FIXME!\n");
6243   fprintf_unfiltered (file,
6244                       "mips_dump_tdep: LAST_EMBED_REGNUM = %d\n",
6245                       LAST_EMBED_REGNUM);
6246   fprintf_unfiltered (file,
6247                       "mips_dump_tdep: LITTLE_BREAKPOINT = delete?\n");
6248   fprintf_unfiltered (file,
6249                       "mips_dump_tdep: LO_REGNUM = %d\n",
6250                       LO_REGNUM);
6251 #ifdef MACHINE_CPROC_FP_OFFSET
6252   fprintf_unfiltered (file,
6253                       "mips_dump_tdep: MACHINE_CPROC_FP_OFFSET = %d\n",
6254                       MACHINE_CPROC_FP_OFFSET);
6255 #endif
6256 #ifdef MACHINE_CPROC_PC_OFFSET
6257   fprintf_unfiltered (file,
6258                       "mips_dump_tdep: MACHINE_CPROC_PC_OFFSET = %d\n",
6259                       MACHINE_CPROC_PC_OFFSET);
6260 #endif
6261 #ifdef MACHINE_CPROC_SP_OFFSET
6262   fprintf_unfiltered (file,
6263                       "mips_dump_tdep: MACHINE_CPROC_SP_OFFSET = %d\n",
6264                       MACHINE_CPROC_SP_OFFSET);
6265 #endif
6266   fprintf_unfiltered (file,
6267                       "mips_dump_tdep: MAKE_MIPS16_ADDR = FIXME!\n");
6268   fprintf_unfiltered (file,
6269                       "mips_dump_tdep: MIPS16_BIG_BREAKPOINT = delete?\n");
6270   fprintf_unfiltered (file,
6271                       "mips_dump_tdep: MIPS16_INSTLEN = %d\n",
6272                       MIPS16_INSTLEN);
6273   fprintf_unfiltered (file,
6274                       "mips_dump_tdep: MIPS16_LITTLE_BREAKPOINT = delete?\n");
6275   fprintf_unfiltered (file,
6276                       "mips_dump_tdep: MIPS_DEFAULT_ABI = FIXME!\n");
6277   fprintf_unfiltered (file,
6278                       "mips_dump_tdep: MIPS_EFI_SYMBOL_NAME = multi-arch!!\n");
6279   fprintf_unfiltered (file,
6280                       "mips_dump_tdep: MIPS_INSTLEN = %d\n",
6281                       MIPS_INSTLEN);
6282   fprintf_unfiltered (file,
6283                       "mips_dump_tdep: MIPS_LAST_ARG_REGNUM = %d (%d regs)\n",
6284                       MIPS_LAST_ARG_REGNUM,
6285                       MIPS_LAST_ARG_REGNUM - A0_REGNUM + 1);
6286   fprintf_unfiltered (file,
6287                       "mips_dump_tdep: MIPS_NUMREGS = %d\n",
6288                       MIPS_NUMREGS);
6289   fprintf_unfiltered (file,
6290                       "mips_dump_tdep: MIPS_REGISTER_NAMES = delete?\n");
6291   fprintf_unfiltered (file,
6292                       "mips_dump_tdep: MIPS_SAVED_REGSIZE = %d\n",
6293                       MIPS_SAVED_REGSIZE);
6294   fprintf_unfiltered (file,
6295                       "mips_dump_tdep: OP_LDFPR = used?\n");
6296   fprintf_unfiltered (file,
6297                       "mips_dump_tdep: OP_LDGPR = used?\n");
6298   fprintf_unfiltered (file,
6299                       "mips_dump_tdep: PMON_BIG_BREAKPOINT = delete?\n");
6300   fprintf_unfiltered (file,
6301                       "mips_dump_tdep: PMON_LITTLE_BREAKPOINT = delete?\n");
6302   fprintf_unfiltered (file,
6303                       "mips_dump_tdep: PRID_REGNUM = %d\n",
6304                       PRID_REGNUM);
6305   fprintf_unfiltered (file,
6306                       "mips_dump_tdep: PRINT_EXTRA_FRAME_INFO # %s\n",
6307                       XSTRING (PRINT_EXTRA_FRAME_INFO (FRAME)));
6308   fprintf_unfiltered (file,
6309                       "mips_dump_tdep: PROC_DESC_IS_DUMMY = function?\n");
6310   fprintf_unfiltered (file,
6311                       "mips_dump_tdep: PROC_FRAME_ADJUST = function?\n");
6312   fprintf_unfiltered (file,
6313                       "mips_dump_tdep: PROC_FRAME_OFFSET = function?\n");
6314   fprintf_unfiltered (file,
6315                       "mips_dump_tdep: PROC_FRAME_REG = function?\n");
6316   fprintf_unfiltered (file,
6317                       "mips_dump_tdep: PROC_FREG_MASK = function?\n");
6318   fprintf_unfiltered (file,
6319                       "mips_dump_tdep: PROC_FREG_OFFSET = function?\n");
6320   fprintf_unfiltered (file,
6321                       "mips_dump_tdep: PROC_HIGH_ADDR = function?\n");
6322   fprintf_unfiltered (file,
6323                       "mips_dump_tdep: PROC_LOW_ADDR = function?\n");
6324   fprintf_unfiltered (file,
6325                       "mips_dump_tdep: PROC_PC_REG = function?\n");
6326   fprintf_unfiltered (file,
6327                       "mips_dump_tdep: PROC_REG_MASK = function?\n");
6328   fprintf_unfiltered (file,
6329                       "mips_dump_tdep: PROC_REG_OFFSET = function?\n");
6330   fprintf_unfiltered (file,
6331                       "mips_dump_tdep: PROC_SYMBOL = function?\n");
6332   fprintf_unfiltered (file,
6333                       "mips_dump_tdep: PS_REGNUM = %d\n",
6334                       PS_REGNUM);
6335   fprintf_unfiltered (file,
6336                       "mips_dump_tdep: PUSH_FP_REGNUM = %d\n",
6337                       PUSH_FP_REGNUM);
6338   fprintf_unfiltered (file,
6339                       "mips_dump_tdep: RA_REGNUM = %d\n",
6340                       RA_REGNUM);
6341   fprintf_unfiltered (file,
6342                       "mips_dump_tdep: REGISTER_CONVERT_FROM_TYPE # %s\n",
6343                       XSTRING (REGISTER_CONVERT_FROM_TYPE (REGNUM, VALTYPE, RAW_BUFFER)));
6344   fprintf_unfiltered (file,
6345                       "mips_dump_tdep: REGISTER_CONVERT_TO_TYPE # %s\n",
6346                       XSTRING (REGISTER_CONVERT_TO_TYPE (REGNUM, VALTYPE, RAW_BUFFER)));
6347   fprintf_unfiltered (file,
6348                       "mips_dump_tdep: REGISTER_NAMES = delete?\n");
6349   fprintf_unfiltered (file,
6350                       "mips_dump_tdep: ROUND_DOWN = function?\n");
6351   fprintf_unfiltered (file,
6352                       "mips_dump_tdep: ROUND_UP = function?\n");
6353 #ifdef SAVED_BYTES
6354   fprintf_unfiltered (file,
6355                       "mips_dump_tdep: SAVED_BYTES = %d\n",
6356                       SAVED_BYTES);
6357 #endif
6358 #ifdef SAVED_FP
6359   fprintf_unfiltered (file,
6360                       "mips_dump_tdep: SAVED_FP = %d\n",
6361                       SAVED_FP);
6362 #endif
6363 #ifdef SAVED_PC
6364   fprintf_unfiltered (file,
6365                       "mips_dump_tdep: SAVED_PC = %d\n",
6366                       SAVED_PC);
6367 #endif
6368   fprintf_unfiltered (file,
6369                       "mips_dump_tdep: SETUP_ARBITRARY_FRAME # %s\n",
6370                       XSTRING (SETUP_ARBITRARY_FRAME (NUMARGS, ARGS)));
6371   fprintf_unfiltered (file,
6372                       "mips_dump_tdep: SET_PROC_DESC_IS_DUMMY = function?\n");
6373   fprintf_unfiltered (file,
6374                       "mips_dump_tdep: SIGFRAME_BASE = %d\n",
6375                       SIGFRAME_BASE);
6376   fprintf_unfiltered (file,
6377                       "mips_dump_tdep: SIGFRAME_FPREGSAVE_OFF = %d\n",
6378                       SIGFRAME_FPREGSAVE_OFF);
6379   fprintf_unfiltered (file,
6380                       "mips_dump_tdep: SIGFRAME_PC_OFF = %d\n",
6381                       SIGFRAME_PC_OFF);
6382   fprintf_unfiltered (file,
6383                       "mips_dump_tdep: SIGFRAME_REGSAVE_OFF = %d\n",
6384                       SIGFRAME_REGSAVE_OFF);
6385   fprintf_unfiltered (file,
6386                       "mips_dump_tdep: SIGFRAME_REG_SIZE = %d\n",
6387                       SIGFRAME_REG_SIZE);
6388   fprintf_unfiltered (file,
6389                       "mips_dump_tdep: SKIP_TRAMPOLINE_CODE # %s\n",
6390                       XSTRING (SKIP_TRAMPOLINE_CODE (PC)));
6391   fprintf_unfiltered (file,
6392                       "mips_dump_tdep: SOFTWARE_SINGLE_STEP # %s\n",
6393                       XSTRING (SOFTWARE_SINGLE_STEP (SIG, BP_P)));
6394   fprintf_unfiltered (file,
6395                       "mips_dump_tdep: SOFTWARE_SINGLE_STEP_P () = %d\n",
6396                       SOFTWARE_SINGLE_STEP_P ());
6397   fprintf_unfiltered (file,
6398                       "mips_dump_tdep: STAB_REG_TO_REGNUM # %s\n",
6399                       XSTRING (STAB_REG_TO_REGNUM (REGNUM)));
6400 #ifdef STACK_END_ADDR
6401   fprintf_unfiltered (file,
6402                       "mips_dump_tdep: STACK_END_ADDR = %d\n",
6403                       STACK_END_ADDR);
6404 #endif
6405   fprintf_unfiltered (file,
6406                       "mips_dump_tdep: STEP_SKIPS_DELAY # %s\n",
6407                       XSTRING (STEP_SKIPS_DELAY (PC)));
6408   fprintf_unfiltered (file,
6409                       "mips_dump_tdep: STEP_SKIPS_DELAY_P = %d\n",
6410                       STEP_SKIPS_DELAY_P);
6411   fprintf_unfiltered (file,
6412                       "mips_dump_tdep: STOPPED_BY_WATCHPOINT # %s\n",
6413                       XSTRING (STOPPED_BY_WATCHPOINT (WS)));
6414   fprintf_unfiltered (file,
6415                       "mips_dump_tdep: T9_REGNUM = %d\n",
6416                       T9_REGNUM);
6417   fprintf_unfiltered (file,
6418                       "mips_dump_tdep: TABULAR_REGISTER_OUTPUT = used?\n");
6419   fprintf_unfiltered (file,
6420                       "mips_dump_tdep: TARGET_CAN_USE_HARDWARE_WATCHPOINT # %s\n",
6421                       XSTRING (TARGET_CAN_USE_HARDWARE_WATCHPOINT (TYPE,CNT,OTHERTYPE)));
6422   fprintf_unfiltered (file,
6423                       "mips_dump_tdep: TARGET_HAS_HARDWARE_WATCHPOINTS # %s\n",
6424                       XSTRING (TARGET_HAS_HARDWARE_WATCHPOINTS));
6425   fprintf_unfiltered (file,
6426                       "mips_dump_tdep: TARGET_MIPS = used?\n");
6427   fprintf_unfiltered (file,
6428                       "mips_dump_tdep: TM_PRINT_INSN_MACH # %s\n",
6429                       XSTRING (TM_PRINT_INSN_MACH));
6430 #ifdef TRACE_CLEAR
6431   fprintf_unfiltered (file,
6432                       "mips_dump_tdep: TRACE_CLEAR # %s\n",
6433                       XSTRING (TRACE_CLEAR (THREAD, STATE)));
6434 #endif
6435 #ifdef TRACE_FLAVOR
6436   fprintf_unfiltered (file,
6437                       "mips_dump_tdep: TRACE_FLAVOR = %d\n",
6438                       TRACE_FLAVOR);
6439 #endif
6440 #ifdef TRACE_FLAVOR_SIZE
6441   fprintf_unfiltered (file,
6442                       "mips_dump_tdep: TRACE_FLAVOR_SIZE = %d\n",
6443                       TRACE_FLAVOR_SIZE);
6444 #endif
6445 #ifdef TRACE_SET
6446   fprintf_unfiltered (file,
6447                       "mips_dump_tdep: TRACE_SET # %s\n",
6448                       XSTRING (TRACE_SET (X,STATE)));
6449 #endif
6450   fprintf_unfiltered (file,
6451                       "mips_dump_tdep: UNMAKE_MIPS16_ADDR = function?\n");
6452 #ifdef UNUSED_REGNUM
6453   fprintf_unfiltered (file,
6454                       "mips_dump_tdep: UNUSED_REGNUM = %d\n",
6455                       UNUSED_REGNUM);
6456 #endif
6457   fprintf_unfiltered (file,
6458                       "mips_dump_tdep: V0_REGNUM = %d\n",
6459                       V0_REGNUM);
6460   fprintf_unfiltered (file,
6461                       "mips_dump_tdep: VM_MIN_ADDRESS = %ld\n",
6462                       (long) VM_MIN_ADDRESS);
6463 #ifdef VX_NUM_REGS
6464   fprintf_unfiltered (file,
6465                       "mips_dump_tdep: VX_NUM_REGS = %d (used?)\n",
6466                       VX_NUM_REGS);
6467 #endif
6468   fprintf_unfiltered (file,
6469                       "mips_dump_tdep: ZERO_REGNUM = %d\n",
6470                       ZERO_REGNUM);
6471   fprintf_unfiltered (file,
6472                       "mips_dump_tdep: _PROC_MAGIC_ = %d\n",
6473                       _PROC_MAGIC_);
6474
6475   fprintf_unfiltered (file,
6476                       "mips_dump_tdep: OS ABI = %s\n",
6477                       gdbarch_osabi_name (tdep->osabi));
6478 }
6479
6480 void
6481 _initialize_mips_tdep (void)
6482 {
6483   static struct cmd_list_element *mipsfpulist = NULL;
6484   struct cmd_list_element *c;
6485
6486   mips_abi_string = mips_abi_strings [MIPS_ABI_UNKNOWN];
6487   if (MIPS_ABI_LAST + 1
6488       != sizeof (mips_abi_strings) / sizeof (mips_abi_strings[0]))
6489     internal_error (__FILE__, __LINE__, "mips_abi_strings out of sync");
6490
6491   gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
6492   if (!tm_print_insn)           /* Someone may have already set it */
6493     tm_print_insn = gdb_print_insn_mips;
6494
6495   /* Add root prefix command for all "set mips"/"show mips" commands */
6496   add_prefix_cmd ("mips", no_class, set_mips_command,
6497                   "Various MIPS specific commands.",
6498                   &setmipscmdlist, "set mips ", 0, &setlist);
6499
6500   add_prefix_cmd ("mips", no_class, show_mips_command,
6501                   "Various MIPS specific commands.",
6502                   &showmipscmdlist, "show mips ", 0, &showlist);
6503
6504   /* Allow the user to override the saved register size. */
6505   add_show_from_set (add_set_enum_cmd ("saved-gpreg-size",
6506                                        class_obscure,
6507                                        size_enums,
6508                                        &mips_saved_regsize_string, "\
6509 Set size of general purpose registers saved on the stack.\n\
6510 This option can be set to one of:\n\
6511   32    - Force GDB to treat saved GP registers as 32-bit\n\
6512   64    - Force GDB to treat saved GP registers as 64-bit\n\
6513   auto  - Allow GDB to use the target's default setting or autodetect the\n\
6514           saved GP register size from information contained in the executable.\n\
6515           (default: auto)",
6516                                        &setmipscmdlist),
6517                      &showmipscmdlist);
6518
6519   /* Allow the user to override the argument stack size. */
6520   add_show_from_set (add_set_enum_cmd ("stack-arg-size",
6521                                        class_obscure,
6522                                        size_enums,
6523                                        &mips_stack_argsize_string, "\
6524 Set the amount of stack space reserved for each argument.\n\
6525 This option can be set to one of:\n\
6526   32    - Force GDB to allocate 32-bit chunks per argument\n\
6527   64    - Force GDB to allocate 64-bit chunks per argument\n\
6528   auto  - Allow GDB to determine the correct setting from the current\n\
6529           target and executable (default)",
6530                                        &setmipscmdlist),
6531                      &showmipscmdlist);
6532
6533   /* Allow the user to override the ABI. */
6534   c = add_set_enum_cmd
6535     ("abi", class_obscure, mips_abi_strings, &mips_abi_string,
6536      "Set the ABI used by this program.\n"
6537      "This option can be set to one of:\n"
6538      "  auto  - the default ABI associated with the current binary\n"
6539      "  o32\n"
6540      "  o64\n"
6541      "  n32\n"
6542      "  n64\n"
6543      "  eabi32\n"
6544      "  eabi64",
6545      &setmipscmdlist);
6546   add_show_from_set (c, &showmipscmdlist);
6547   set_cmd_sfunc (c, mips_abi_update);
6548
6549   /* Let the user turn off floating point and set the fence post for
6550      heuristic_proc_start.  */
6551
6552   add_prefix_cmd ("mipsfpu", class_support, set_mipsfpu_command,
6553                   "Set use of MIPS floating-point coprocessor.",
6554                   &mipsfpulist, "set mipsfpu ", 0, &setlist);
6555   add_cmd ("single", class_support, set_mipsfpu_single_command,
6556            "Select single-precision MIPS floating-point coprocessor.",
6557            &mipsfpulist);
6558   add_cmd ("double", class_support, set_mipsfpu_double_command,
6559            "Select double-precision MIPS floating-point coprocessor.",
6560            &mipsfpulist);
6561   add_alias_cmd ("on", "double", class_support, 1, &mipsfpulist);
6562   add_alias_cmd ("yes", "double", class_support, 1, &mipsfpulist);
6563   add_alias_cmd ("1", "double", class_support, 1, &mipsfpulist);
6564   add_cmd ("none", class_support, set_mipsfpu_none_command,
6565            "Select no MIPS floating-point coprocessor.",
6566            &mipsfpulist);
6567   add_alias_cmd ("off", "none", class_support, 1, &mipsfpulist);
6568   add_alias_cmd ("no", "none", class_support, 1, &mipsfpulist);
6569   add_alias_cmd ("0", "none", class_support, 1, &mipsfpulist);
6570   add_cmd ("auto", class_support, set_mipsfpu_auto_command,
6571            "Select MIPS floating-point coprocessor automatically.",
6572            &mipsfpulist);
6573   add_cmd ("mipsfpu", class_support, show_mipsfpu_command,
6574            "Show current use of MIPS floating-point coprocessor target.",
6575            &showlist);
6576
6577   /* We really would like to have both "0" and "unlimited" work, but
6578      command.c doesn't deal with that.  So make it a var_zinteger
6579      because the user can always use "999999" or some such for unlimited.  */
6580   c = add_set_cmd ("heuristic-fence-post", class_support, var_zinteger,
6581                    (char *) &heuristic_fence_post,
6582                    "\
6583 Set the distance searched for the start of a function.\n\
6584 If you are debugging a stripped executable, GDB needs to search through the\n\
6585 program for the start of a function.  This command sets the distance of the\n\
6586 search.  The only need to set it is when debugging a stripped executable.",
6587                    &setlist);
6588   /* We need to throw away the frame cache when we set this, since it
6589      might change our ability to get backtraces.  */
6590   set_cmd_sfunc (c, reinit_frame_cache_sfunc);
6591   add_show_from_set (c, &showlist);
6592
6593   /* Allow the user to control whether the upper bits of 64-bit
6594      addresses should be zeroed.  */
6595   add_setshow_auto_boolean_cmd ("mask-address", no_class, &mask_address_var, "\
6596 Set zeroing of upper 32 bits of 64-bit addresses.\n\
6597 Use \"on\" to enable the masking, \"off\" to disable it and \"auto\" to \n\
6598 allow GDB to determine the correct value.\n", "\
6599 Show zeroing of upper 32 bits of 64-bit addresses.",
6600                                 NULL, show_mask_address,
6601                                 &setmipscmdlist, &showmipscmdlist);
6602
6603   /* Allow the user to control the size of 32 bit registers within the
6604      raw remote packet.  */
6605   add_show_from_set (add_set_cmd ("remote-mips64-transfers-32bit-regs",
6606                                   class_obscure,
6607                                   var_boolean,
6608                                   (char *)&mips64_transfers_32bit_regs_p, "\
6609 Set compatibility with MIPS targets that transfers 32 and 64 bit quantities.\n\
6610 Use \"on\" to enable backward compatibility with older MIPS 64 GDB+target\n\
6611 that would transfer 32 bits for some registers (e.g. SR, FSR) and\n\
6612 64 bits for others.  Use \"off\" to disable compatibility mode",
6613                                   &setlist),
6614                      &showlist);
6615
6616   /* Debug this files internals. */
6617   add_show_from_set (add_set_cmd ("mips", class_maintenance, var_zinteger,
6618                                   &mips_debug, "Set mips debugging.\n\
6619 When non-zero, mips specific debugging is enabled.", &setdebuglist),
6620                      &showdebuglist);
6621 }