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, Free Software Foundation, Inc.
   5
   6    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   7    and by Per Bothner(bothner@cs.wisc.edu) 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
  41 #include "opcode/mips.h"
  42 #include "elf/mips.h"
  43 #include "elf-bfd.h"
  44 #include "symcat.h"
  45
  46 /* The sizes of floating point registers.  */
  47
  48 enum
  49 {
  50   MIPS_FPU_SINGLE_REGSIZE = 4,
  51   MIPS_FPU_DOUBLE_REGSIZE = 8
  52 };
  53
  54 /* All the possible MIPS ABIs. */
  55
  56 enum mips_abi
  57   {
  58     MIPS_ABI_UNKNOWN,
  59     MIPS_ABI_N32,
  60     MIPS_ABI_O32,
  61     MIPS_ABI_O64,
  62     MIPS_ABI_EABI32,
  63     MIPS_ABI_EABI64
  64   };
  65
  66 struct frame_extra_info
  67   {
  68     mips_extra_func_info_t proc_desc;
  69     int num_args;
  70   };
  71
  72 /* Various MIPS ISA options (related to stack analysis) can be
  73    overridden dynamically.  Establish an enum/array for managing
  74    them. */
  75
  76 static const char size_auto[] = "auto";
  77 static const char size_32[] = "32";
  78 static const char size_64[] = "64";
  79
  80 static const char *size_enums[] = {
  81   size_auto,
  82   size_32,
  83   size_64,
  84   0
  85 };
  86
  87 /* Some MIPS boards don't support floating point while others only
  88    support single-precision floating-point operations.  See also
  89    FP_REGISTER_DOUBLE. */
  90
  91 enum mips_fpu_type
  92   {
  93     MIPS_FPU_DOUBLE,            /* Full double precision floating point.  */
  94     MIPS_FPU_SINGLE,            /* Single precision floating point (R4650).  */
  95     MIPS_FPU_NONE               /* No floating point.  */
  96   };
  97
  98 #ifndef MIPS_DEFAULT_FPU_TYPE
  99 #define MIPS_DEFAULT_FPU_TYPE MIPS_FPU_DOUBLE
 100 #endif
 101 static int mips_fpu_type_auto = 1;
 102 static enum mips_fpu_type mips_fpu_type = MIPS_DEFAULT_FPU_TYPE;
 103 #define MIPS_FPU_TYPE mips_fpu_type
 104
 105 /* Do not use "TARGET_IS_MIPS64" to test the size of floating point registers */
 106 #ifndef FP_REGISTER_DOUBLE
 107 #define FP_REGISTER_DOUBLE (REGISTER_VIRTUAL_SIZE(FP0_REGNUM) == 8)
 108 #endif
 109
 110 static int mips_debug = 0;
 111
 112 /* MIPS specific per-architecture information */
 113 struct gdbarch_tdep
 114   {
 115     /* from the elf header */
 116     int elf_flags;
 117     /* mips options */
 118     enum mips_abi mips_abi;
 119     enum mips_fpu_type mips_fpu_type;
 120     int mips_last_arg_regnum;
 121     int mips_last_fp_arg_regnum;
 122     int mips_default_saved_regsize;
 123     int mips_fp_register_double;
 124     int mips_regs_have_home_p;
 125     int mips_default_stack_argsize;
 126     int gdb_target_is_mips64;
 127   };
 128
 129 #if GDB_MULTI_ARCH
 130 #undef MIPS_EABI
 131 #define MIPS_EABI (gdbarch_tdep (current_gdbarch)->mips_abi == MIPS_ABI_EABI32 \
 132                    || gdbarch_tdep (current_gdbarch)->mips_abi == MIPS_ABI_EABI64)
 133 #endif
 134
 135 #if GDB_MULTI_ARCH
 136 #undef MIPS_LAST_FP_ARG_REGNUM
 137 #define MIPS_LAST_FP_ARG_REGNUM (gdbarch_tdep (current_gdbarch)->mips_last_fp_arg_regnum)
 138 #endif
 139
 140 #if GDB_MULTI_ARCH
 141 #undef MIPS_LAST_ARG_REGNUM
 142 #define MIPS_LAST_ARG_REGNUM (gdbarch_tdep (current_gdbarch)->mips_last_arg_regnum)
 143 #endif
 144
 145 #if GDB_MULTI_ARCH
 146 #undef MIPS_FPU_TYPE
 147 #define MIPS_FPU_TYPE (gdbarch_tdep (current_gdbarch)->mips_fpu_type)
 148 #endif
 149
 150 /* Return the currently configured (or set) saved register size. */
 151
 152 #if GDB_MULTI_ARCH
 153 #undef MIPS_DEFAULT_SAVED_REGSIZE
 154 #define MIPS_DEFAULT_SAVED_REGSIZE (gdbarch_tdep (current_gdbarch)->mips_default_saved_regsize)
 155 #elif !defined (MIPS_DEFAULT_SAVED_REGSIZE)
 156 #define MIPS_DEFAULT_SAVED_REGSIZE MIPS_REGSIZE
 157 #endif
 158
 159 static const char *mips_saved_regsize_string = size_auto;
 160
 161 #define MIPS_SAVED_REGSIZE (mips_saved_regsize())
 162
 163 static unsigned int
 164 mips_saved_regsize ()
 165 {
 166   if (mips_saved_regsize_string == size_auto)
 167     return MIPS_DEFAULT_SAVED_REGSIZE;
 168   else if (mips_saved_regsize_string == size_64)
 169     return 8;
 170   else /* if (mips_saved_regsize_string == size_32) */
 171     return 4;
 172 }
 173
 174 /* Indicate that the ABI makes use of double-precision registers
 175    provided by the FPU (rather than combining pairs of registers to
 176    form double-precision values).  Do not use "TARGET_IS_MIPS64" to
 177    determine if the ABI is using double-precision registers.  See also
 178    MIPS_FPU_TYPE. */
 179 #if GDB_MULTI_ARCH
 180 #undef FP_REGISTER_DOUBLE
 181 #define FP_REGISTER_DOUBLE (gdbarch_tdep (current_gdbarch)->mips_fp_register_double)
 182 #endif
 183
 184 /* Does the caller allocate a ``home'' for each register used in the
 185    function call?  The N32 ABI and MIPS_EABI do not, the others do. */
 186
 187 #if GDB_MULTI_ARCH
 188 #undef MIPS_REGS_HAVE_HOME_P
 189 #define MIPS_REGS_HAVE_HOME_P (gdbarch_tdep (current_gdbarch)->mips_regs_have_home_p)
 190 #elif !defined (MIPS_REGS_HAVE_HOME_P)
 191 #define MIPS_REGS_HAVE_HOME_P (!MIPS_EABI)
 192 #endif
 193
 194 /* The amount of space reserved on the stack for registers. This is
 195    different to MIPS_SAVED_REGSIZE as it determines the alignment of
 196    data allocated after the registers have run out. */
 197
 198 #if GDB_MULTI_ARCH
 199 #undef MIPS_DEFAULT_STACK_ARGSIZE
 200 #define MIPS_DEFAULT_STACK_ARGSIZE (gdbarch_tdep (current_gdbarch)->mips_default_stack_argsize)
 201 #elif !defined (MIPS_DEFAULT_STACK_ARGSIZE)
 202 #define MIPS_DEFAULT_STACK_ARGSIZE (MIPS_DEFAULT_SAVED_REGSIZE)
 203 #endif
 204
 205 #define MIPS_STACK_ARGSIZE (mips_stack_argsize ())
 206
 207 static const char *mips_stack_argsize_string = size_auto;
 208
 209 static unsigned int
 210 mips_stack_argsize (void)
 211 {
 212   if (mips_stack_argsize_string == size_auto)
 213     return MIPS_DEFAULT_STACK_ARGSIZE;
 214   else if (mips_stack_argsize_string == size_64)
 215     return 8;
 216   else /* if (mips_stack_argsize_string == size_32) */
 217     return 4;
 218 }
 219
 220 #if GDB_MULTI_ARCH
 221 #undef GDB_TARGET_IS_MIPS64
 222 #define GDB_TARGET_IS_MIPS64 (gdbarch_tdep (current_gdbarch)->gdb_target_is_mips64 + 0)
 223 #endif
 224
 225 #define VM_MIN_ADDRESS (CORE_ADDR)0x400000
 226
 227 #if 0
 228 static int mips_in_lenient_prologue (CORE_ADDR, CORE_ADDR);
 229 #endif
 230
 231 int gdb_print_insn_mips (bfd_vma, disassemble_info *);
 232
 233 static void mips_print_register (int, int);
 234
 235 static mips_extra_func_info_t
 236 heuristic_proc_desc (CORE_ADDR, CORE_ADDR, struct frame_info *);
 237
 238 static CORE_ADDR heuristic_proc_start (CORE_ADDR);
 239
 240 static CORE_ADDR read_next_frame_reg (struct frame_info *, int);
 241
 242 int mips_set_processor_type (char *);
 243
 244 static void mips_show_processor_type_command (char *, int);
 245
 246 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element *);
 247
 248 static mips_extra_func_info_t
 249 find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame);
 250
 251 static CORE_ADDR after_prologue (CORE_ADDR pc,
 252                                  mips_extra_func_info_t proc_desc);
 253
 254 /* This value is the model of MIPS in use.  It is derived from the value
 255    of the PrID register.  */
 256
 257 char *mips_processor_type;
 258
 259 char *tmp_mips_processor_type;
 260
 261 /* A set of original names, to be used when restoring back to generic
 262    registers from a specific set.  */
 263
 264 char *mips_generic_reg_names[] = MIPS_REGISTER_NAMES;
 265 char **mips_processor_reg_names = mips_generic_reg_names;
 266
 267 /* The list of available "set mips " and "show mips " commands */
 268 static struct cmd_list_element *setmipscmdlist = NULL;
 269 static struct cmd_list_element *showmipscmdlist = NULL;
 270
 271 char *
 272 mips_register_name (i)
 273      int i;
 274 {
 275   return mips_processor_reg_names[i];
 276 }
 277 /* *INDENT-OFF* */
 278 /* Names of IDT R3041 registers.  */
 279
 280 char *mips_r3041_reg_names[] = {
 281         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 282         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 283         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 284         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 285         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 286         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 287         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 288         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 289         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 290         "fsr",  "fir",  "fp",   "",
 291         "",     "",     "bus",  "ccfg", "",     "",     "",     "",
 292         "",     "",     "port", "cmp",  "",     "",     "epc",  "prid",
 293 };
 294
 295 /* Names of IDT R3051 registers.  */
 296
 297 char *mips_r3051_reg_names[] = {
 298         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 299         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 300         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 301         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 302         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 303         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 304         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 305         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 306         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 307         "fsr",  "fir",  "fp",   "",
 308         "inx",  "rand", "elo",  "",     "ctxt", "",     "",     "",
 309         "",     "",     "ehi",  "",     "",     "",     "epc",  "prid",
 310 };
 311
 312 /* Names of IDT R3081 registers.  */
 313
 314 char *mips_r3081_reg_names[] = {
 315         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 316         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 317         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 318         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 319         "sr",   "lo",   "hi",   "bad",  "cause","pc",
 320         "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 321         "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 322         "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 323         "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 324         "fsr",  "fir",  "fp",   "",
 325         "inx",  "rand", "elo",  "cfg",  "ctxt", "",     "",     "",
 326         "",     "",     "ehi",  "",     "",     "",     "epc",  "prid",
 327 };
 328
 329 /* Names of LSI 33k registers.  */
 330
 331 char *mips_lsi33k_reg_names[] = {
 332         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 333         "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 334         "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 335         "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra",
 336         "epc",  "hi",   "lo",   "sr",   "cause","badvaddr",
 337         "dcic", "bpc",  "bda",  "",     "",     "",     "",      "",
 338         "",     "",     "",     "",     "",     "",     "",      "",
 339         "",     "",     "",     "",     "",     "",     "",      "",
 340         "",     "",     "",     "",     "",     "",     "",      "",
 341         "",     "",     "",     "",
 342         "",     "",     "",     "",     "",     "",     "",      "",
 343         "",     "",     "",     "",     "",     "",     "",      "",
 344 };
 345
 346 struct {
 347   char *name;
 348   char **regnames;
 349 } mips_processor_type_table[] = {
 350   { "generic", mips_generic_reg_names },
 351   { "r3041", mips_r3041_reg_names },
 352   { "r3051", mips_r3051_reg_names },
 353   { "r3071", mips_r3081_reg_names },
 354   { "r3081", mips_r3081_reg_names },
 355   { "lsi33k", mips_lsi33k_reg_names },
 356   { NULL, NULL }
 357 };
 358 /* *INDENT-ON* */
 359
 360
 361
 362
 363 /* Table to translate MIPS16 register field to actual register number.  */
 364 static int mips16_to_32_reg[8] =
 365 {16, 17, 2, 3, 4, 5, 6, 7};
 366
 367 /* Heuristic_proc_start may hunt through the text section for a long
 368    time across a 2400 baud serial line.  Allows the user to limit this
 369    search.  */
 370
 371 static unsigned int heuristic_fence_post = 0;
 372
 373 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)   /* least address */
 374 #define PROC_HIGH_ADDR(proc) ((proc)->high_addr)        /* upper address bound */
 375 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
 376 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
 377 #define PROC_FRAME_ADJUST(proc)  ((proc)->frame_adjust)
 378 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
 379 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
 380 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
 381 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
 382 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
 383 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
 384 #define _PROC_MAGIC_ 0x0F0F0F0F
 385 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
 386 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
 387
 388 struct linked_proc_info
 389   {
 390     struct mips_extra_func_info info;
 391     struct linked_proc_info *next;
 392   }
 393  *linked_proc_desc_table = NULL;
 394
 395 void
 396 mips_print_extra_frame_info (fi)
 397      struct frame_info *fi;
 398 {
 399   if (fi
 400       && fi->extra_info
 401       && fi->extra_info->proc_desc
 402       && fi->extra_info->proc_desc->pdr.framereg < NUM_REGS)
 403     printf_filtered (" frame pointer is at %s+%s\n",
 404                      REGISTER_NAME (fi->extra_info->proc_desc->pdr.framereg),
 405                      paddr_d (fi->extra_info->proc_desc->pdr.frameoffset));
 406 }
 407
 408 /* Convert between RAW and VIRTUAL registers.  The RAW register size
 409    defines the remote-gdb packet. */
 410
 411 static int mips64_transfers_32bit_regs_p = 0;
 412
 413 int
 414 mips_register_raw_size (reg_nr)
 415      int reg_nr;
 416 {
 417   if (mips64_transfers_32bit_regs_p)
 418     return REGISTER_VIRTUAL_SIZE (reg_nr);
 419   else
 420     return MIPS_REGSIZE;
 421 }
 422
 423 int
 424 mips_register_convertible (reg_nr)
 425      int reg_nr;
 426 {
 427   if (mips64_transfers_32bit_regs_p)
 428     return 0;
 429   else
 430     return (REGISTER_RAW_SIZE (reg_nr) > REGISTER_VIRTUAL_SIZE (reg_nr));
 431 }
 432
 433 void
 434 mips_register_convert_to_virtual (n, virtual_type, raw_buf, virt_buf)
 435      int n;
 436      struct type *virtual_type;
 437      char *raw_buf;
 438      char *virt_buf;
 439 {
 440   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 441     memcpy (virt_buf,
 442             raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 443             TYPE_LENGTH (virtual_type));
 444   else
 445     memcpy (virt_buf,
 446             raw_buf,
 447             TYPE_LENGTH (virtual_type));
 448 }
 449
 450 void
 451 mips_register_convert_to_raw (virtual_type, n, virt_buf, raw_buf)
 452      struct type *virtual_type;
 453      int n;
 454      char *virt_buf;
 455      char *raw_buf;
 456 {
 457   memset (raw_buf, 0, REGISTER_RAW_SIZE (n));
 458   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 459     memcpy (raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)),
 460             virt_buf,
 461             TYPE_LENGTH (virtual_type));
 462   else
 463     memcpy (raw_buf,
 464             virt_buf,
 465             TYPE_LENGTH (virtual_type));
 466 }
 467
 468 /* Should the upper word of 64-bit addresses be zeroed? */
 469 static int mask_address_p = 1;
 470
 471 /* Should call_function allocate stack space for a struct return?  */
 472 int
 473 mips_use_struct_convention (gcc_p, type)
 474      int gcc_p;
 475      struct type *type;
 476 {
 477   if (MIPS_EABI)
 478     return (TYPE_LENGTH (type) > 2 * MIPS_SAVED_REGSIZE);
 479   else
 480     return 1;                   /* Structures are returned by ref in extra arg0 */
 481 }
 482
 483 /* Tell if the program counter value in MEMADDR is in a MIPS16 function.  */
 484
 485 static int
 486 pc_is_mips16 (bfd_vma memaddr)
 487 {
 488   struct minimal_symbol *sym;
 489
 490   /* If bit 0 of the address is set, assume this is a MIPS16 address. */
 491   if (IS_MIPS16_ADDR (memaddr))
 492     return 1;
 493
 494   /* A flag indicating that this is a MIPS16 function is stored by elfread.c in
 495      the high bit of the info field.  Use this to decide if the function is
 496      MIPS16 or normal MIPS.  */
 497   sym = lookup_minimal_symbol_by_pc (memaddr);
 498   if (sym)
 499     return MSYMBOL_IS_SPECIAL (sym);
 500   else
 501     return 0;
 502 }
 503
 504
 505 /* This returns the PC of the first inst after the prologue.  If we can't
 506    find the prologue, then return 0.  */
 507
 508 static CORE_ADDR
 509 after_prologue (pc, proc_desc)
 510      CORE_ADDR pc;
 511      mips_extra_func_info_t proc_desc;
 512 {
 513   struct symtab_and_line sal;
 514   CORE_ADDR func_addr, func_end;
 515
 516   if (!proc_desc)
 517     proc_desc = find_proc_desc (pc, NULL);
 518
 519   if (proc_desc)
 520     {
 521       /* If function is frameless, then we need to do it the hard way.  I
 522          strongly suspect that frameless always means prologueless... */
 523       if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
 524           && PROC_FRAME_OFFSET (proc_desc) == 0)
 525         return 0;
 526     }
 527
 528   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 529     return 0;                   /* Unknown */
 530
 531   sal = find_pc_line (func_addr, 0);
 532
 533   if (sal.end < func_end)
 534     return sal.end;
 535
 536   /* The line after the prologue is after the end of the function.  In this
 537      case, tell the caller to find the prologue the hard way.  */
 538
 539   return 0;
 540 }
 541
 542 /* Decode a MIPS32 instruction that saves a register in the stack, and
 543    set the appropriate bit in the general register mask or float register mask
 544    to indicate which register is saved.  This is a helper function
 545    for mips_find_saved_regs.  */
 546
 547 static void
 548 mips32_decode_reg_save (inst, gen_mask, float_mask)
 549      t_inst inst;
 550      unsigned long *gen_mask;
 551      unsigned long *float_mask;
 552 {
 553   int reg;
 554
 555   if ((inst & 0xffe00000) == 0xafa00000         /* sw reg,n($sp) */
 556       || (inst & 0xffe00000) == 0xafc00000      /* sw reg,n($r30) */
 557       || (inst & 0xffe00000) == 0xffa00000)     /* sd reg,n($sp) */
 558     {
 559       /* It might be possible to use the instruction to
 560          find the offset, rather than the code below which
 561          is based on things being in a certain order in the
 562          frame, but figuring out what the instruction's offset
 563          is relative to might be a little tricky.  */
 564       reg = (inst & 0x001f0000) >> 16;
 565       *gen_mask |= (1 << reg);
 566     }
 567   else if ((inst & 0xffe00000) == 0xe7a00000    /* swc1 freg,n($sp) */
 568            || (inst & 0xffe00000) == 0xe7c00000         /* swc1 freg,n($r30) */
 569            || (inst & 0xffe00000) == 0xf7a00000)        /* sdc1 freg,n($sp) */
 570
 571     {
 572       reg = ((inst & 0x001f0000) >> 16);
 573       *float_mask |= (1 << reg);
 574     }
 575 }
 576
 577 /* Decode a MIPS16 instruction that saves a register in the stack, and
 578    set the appropriate bit in the general register or float register mask
 579    to indicate which register is saved.  This is a helper function
 580    for mips_find_saved_regs.  */
 581
 582 static void
 583 mips16_decode_reg_save (inst, gen_mask)
 584      t_inst inst;
 585      unsigned long *gen_mask;
 586 {
 587   if ((inst & 0xf800) == 0xd000)        /* sw reg,n($sp) */
 588     {
 589       int reg = mips16_to_32_reg[(inst & 0x700) >> 8];
 590       *gen_mask |= (1 << reg);
 591     }
 592   else if ((inst & 0xff00) == 0xf900)   /* sd reg,n($sp) */
 593     {
 594       int reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
 595       *gen_mask |= (1 << reg);
 596     }
 597   else if ((inst & 0xff00) == 0x6200    /* sw $ra,n($sp) */
 598            || (inst & 0xff00) == 0xfa00)        /* sd $ra,n($sp) */
 599     *gen_mask |= (1 << RA_REGNUM);
 600 }
 601
 602
 603 /* Fetch and return instruction from the specified location.  If the PC
 604    is odd, assume it's a MIPS16 instruction; otherwise MIPS32.  */
 605
 606 static t_inst
 607 mips_fetch_instruction (addr)
 608      CORE_ADDR addr;
 609 {
 610   char buf[MIPS_INSTLEN];
 611   int instlen;
 612   int status;
 613
 614   if (pc_is_mips16 (addr))
 615     {
 616       instlen = MIPS16_INSTLEN;
 617       addr = UNMAKE_MIPS16_ADDR (addr);
 618     }
 619   else
 620     instlen = MIPS_INSTLEN;
 621   status = read_memory_nobpt (addr, buf, instlen);
 622   if (status)
 623     memory_error (status, addr);
 624   return extract_unsigned_integer (buf, instlen);
 625 }
 626
 627
 628 /* These the fields of 32 bit mips instructions */
 629 #define mips32_op(x) (x >> 25)
 630 #define itype_op(x) (x >> 25)
 631 #define itype_rs(x) ((x >> 21)& 0x1f)
 632 #define itype_rt(x) ((x >> 16) & 0x1f)
 633 #define itype_immediate(x) ( x & 0xffff)
 634
 635 #define jtype_op(x) (x >> 25)
 636 #define jtype_target(x) ( x & 0x03fffff)
 637
 638 #define rtype_op(x) (x >>25)
 639 #define rtype_rs(x) ((x>>21) & 0x1f)
 640 #define rtype_rt(x) ((x>>16)  & 0x1f)
 641 #define rtype_rd(x) ((x>>11) & 0x1f)
 642 #define rtype_shamt(x) ((x>>6) & 0x1f)
 643 #define rtype_funct(x) (x & 0x3f )
 644
 645 static CORE_ADDR
 646 mips32_relative_offset (unsigned long inst)
 647 {
 648   long x;
 649   x = itype_immediate (inst);
 650   if (x & 0x8000)               /* sign bit set */
 651     {
 652       x |= 0xffff0000;          /* sign extension */
 653     }
 654   x = x << 2;
 655   return x;
 656 }
 657
 658 /* Determine whate to set a single step breakpoint while considering
 659    branch prediction */
 660 CORE_ADDR
 661 mips32_next_pc (CORE_ADDR pc)
 662 {
 663   unsigned long inst;
 664   int op;
 665   inst = mips_fetch_instruction (pc);
 666   if ((inst & 0xe0000000) != 0) /* Not a special, junp or branch instruction */
 667     {
 668       if ((inst >> 27) == 5)    /* BEQL BNEZ BLEZL BGTZE , bits 0101xx */
 669         {
 670           op = ((inst >> 25) & 0x03);
 671           switch (op)
 672             {
 673             case 0:
 674               goto equal_branch;        /* BEQL   */
 675             case 1:
 676               goto neq_branch;  /* BNEZ   */
 677             case 2:
 678               goto less_branch; /* BLEZ   */
 679             case 3:
 680               goto greater_branch;      /* BGTZ */
 681             default:
 682               pc += 4;
 683             }
 684         }
 685       else
 686         pc += 4;                /* Not a branch, next instruction is easy */
 687     }
 688   else
 689     {                           /* This gets way messy */
 690
 691       /* Further subdivide into SPECIAL, REGIMM and other */
 692       switch (op = ((inst >> 26) & 0x07))       /* extract bits 28,27,26 */
 693         {
 694         case 0:         /* SPECIAL */
 695           op = rtype_funct (inst);
 696           switch (op)
 697             {
 698             case 8:             /* JR */
 699             case 9:             /* JALR */
 700               pc = read_register (rtype_rs (inst));     /* Set PC to that address */
 701               break;
 702             default:
 703               pc += 4;
 704             }
 705
 706           break;                /* end special */
 707         case 1:         /* REGIMM */
 708           {
 709             op = jtype_op (inst);       /* branch condition */
 710             switch (jtype_op (inst))
 711               {
 712               case 0:           /* BLTZ */
 713               case 2:           /* BLTXL */
 714               case 16:          /* BLTZALL */
 715               case 18:          /* BLTZALL */
 716               less_branch:
 717                 if (read_register (itype_rs (inst)) < 0)
 718                   pc += mips32_relative_offset (inst) + 4;
 719                 else
 720                   pc += 8;      /* after the delay slot */
 721                 break;
 722               case 1:           /* GEZ */
 723               case 3:           /* BGEZL */
 724               case 17:          /* BGEZAL */
 725               case 19:          /* BGEZALL */
 726               greater_equal_branch:
 727                 if (read_register (itype_rs (inst)) >= 0)
 728                   pc += mips32_relative_offset (inst) + 4;
 729                 else
 730                   pc += 8;      /* after the delay slot */
 731                 break;
 732                 /* All of the other intructions in the REGIMM catagory */
 733               default:
 734                 pc += 4;
 735               }
 736           }
 737           break;                /* end REGIMM */
 738         case 2:         /* J */
 739         case 3:         /* JAL */
 740           {
 741             unsigned long reg;
 742             reg = jtype_target (inst) << 2;
 743             pc = reg + ((pc + 4) & 0xf0000000);
 744             /* Whats this mysterious 0xf000000 adjustment ??? */
 745           }
 746           break;
 747           /* FIXME case JALX : */
 748           {
 749             unsigned long reg;
 750             reg = jtype_target (inst) << 2;
 751             pc = reg + ((pc + 4) & 0xf0000000) + 1;     /* yes, +1 */
 752             /* Add 1 to indicate 16 bit mode - Invert ISA mode */
 753           }
 754           break;                /* The new PC will be alternate mode */
 755         case 4:         /* BEQ , BEQL */
 756         equal_branch:
 757           if (read_register (itype_rs (inst)) ==
 758               read_register (itype_rt (inst)))
 759             pc += mips32_relative_offset (inst) + 4;
 760           else
 761             pc += 8;
 762           break;
 763         case 5:         /* BNE , BNEL */
 764         neq_branch:
 765           if (read_register (itype_rs (inst)) !=
 766               read_register (itype_rs (inst)))
 767             pc += mips32_relative_offset (inst) + 4;
 768           else
 769             pc += 8;
 770           break;
 771         case 6:         /* BLEZ , BLEZL */
 772         less_zero_branch:
 773           if (read_register (itype_rs (inst) <= 0))
 774             pc += mips32_relative_offset (inst) + 4;
 775           else
 776             pc += 8;
 777           break;
 778         case 7:
 779         greater_branch: /* BGTZ BGTZL */
 780           if (read_register (itype_rs (inst) > 0))
 781             pc += mips32_relative_offset (inst) + 4;
 782           else
 783             pc += 8;
 784           break;
 785         default:
 786           pc += 8;
 787         }                       /* switch */
 788     }                           /* else */
 789   return pc;
 790 }                               /* mips32_next_pc */
 791
 792 /* Decoding the next place to set a breakpoint is irregular for the
 793    mips 16 variant, but fortunatly, there fewer instructions. We have to cope
 794    ith extensions for 16 bit instructions and a pair of actual 32 bit instructions.
 795    We dont want to set a single step instruction on the extend instruction
 796    either.
 797  */
 798
 799 /* Lots of mips16 instruction formats */
 800 /* Predicting jumps requires itype,ritype,i8type
 801    and their extensions      extItype,extritype,extI8type
 802  */
 803 enum mips16_inst_fmts
 804 {
 805   itype,                        /* 0  immediate 5,10 */
 806   ritype,                       /* 1   5,3,8 */
 807   rrtype,                       /* 2   5,3,3,5 */
 808   rritype,                      /* 3   5,3,3,5 */
 809   rrrtype,                      /* 4   5,3,3,3,2 */
 810   rriatype,                     /* 5   5,3,3,1,4 */
 811   shifttype,                    /* 6   5,3,3,3,2 */
 812   i8type,                       /* 7   5,3,8 */
 813   i8movtype,                    /* 8   5,3,3,5 */
 814   i8mov32rtype,                 /* 9   5,3,5,3 */
 815   i64type,                      /* 10  5,3,8 */
 816   ri64type,                     /* 11  5,3,3,5 */
 817   jalxtype,                     /* 12  5,1,5,5,16 - a 32 bit instruction */
 818   exiItype,                     /* 13  5,6,5,5,1,1,1,1,1,1,5 */
 819   extRitype,                    /* 14  5,6,5,5,3,1,1,1,5 */
 820   extRRItype,                   /* 15  5,5,5,5,3,3,5 */
 821   extRRIAtype,                  /* 16  5,7,4,5,3,3,1,4 */
 822   EXTshifttype,                 /* 17  5,5,1,1,1,1,1,1,5,3,3,1,1,1,2 */
 823   extI8type,                    /* 18  5,6,5,5,3,1,1,1,5 */
 824   extI64type,                   /* 19  5,6,5,5,3,1,1,1,5 */
 825   extRi64type,                  /* 20  5,6,5,5,3,3,5 */
 826   extshift64type                /* 21  5,5,1,1,1,1,1,1,5,1,1,1,3,5 */
 827 };
 828 /* I am heaping all the fields of the formats into one structure and then,
 829    only the fields which are involved in instruction extension */
 830 struct upk_mips16
 831   {
 832     unsigned short inst;
 833     enum mips16_inst_fmts fmt;
 834     unsigned long offset;
 835     unsigned int regx;          /* Function in i8 type */
 836     unsigned int regy;
 837   };
 838
 839
 840
 841 static void
 842 print_unpack (char *comment,
 843               struct upk_mips16 *u)
 844 {
 845   printf ("%s %04x ,f(%d) off(%s) (x(%x) y(%x)\n",
 846           comment, u->inst, u->fmt, paddr (u->offset), u->regx, u->regy);
 847 }
 848
 849 /* The EXT-I, EXT-ri nad EXT-I8 instructions all have the same
 850    format for the bits which make up the immediatate extension.
 851  */
 852 static unsigned long
 853 extended_offset (unsigned long extension)
 854 {
 855   unsigned long value;
 856   value = (extension >> 21) & 0x3f;     /* * extract 15:11 */
 857   value = value << 6;
 858   value |= (extension >> 16) & 0x1f;    /* extrace 10:5 */
 859   value = value << 5;
 860   value |= extension & 0x01f;   /* extract 4:0 */
 861   return value;
 862 }
 863
 864 /* Only call this function if you know that this is an extendable
 865    instruction, It wont malfunction, but why make excess remote memory references?
 866    If the immediate operands get sign extended or somthing, do it after
 867    the extension is performed.
 868  */
 869 /* FIXME: Every one of these cases needs to worry about sign extension
 870    when the offset is to be used in relative addressing */
 871
 872
 873 static unsigned short
 874 fetch_mips_16 (CORE_ADDR pc)
 875 {
 876   char buf[8];
 877   pc &= 0xfffffffe;             /* clear the low order bit */
 878   target_read_memory (pc, buf, 2);
 879   return extract_unsigned_integer (buf, 2);
 880 }
 881
 882 static void
 883 unpack_mips16 (CORE_ADDR pc,
 884                struct upk_mips16 *upk)
 885 {
 886   CORE_ADDR extpc;
 887   unsigned long extension;
 888   int extended;
 889   extpc = (pc - 4) & ~0x01;     /* Extensions are 32 bit instructions */
 890   /* Decrement to previous address and loose the 16bit mode flag */
 891   /* return if the instruction was extendable, but not actually extended */
 892   extended = ((mips32_op (extension) == 30) ? 1 : 0);
 893   if (extended)
 894     {
 895       extension = mips_fetch_instruction (extpc);
 896     }
 897   switch (upk->fmt)
 898     {
 899     case itype:
 900       {
 901         unsigned long value;
 902         if (extended)
 903           {
 904             value = extended_offset (extension);
 905             value = value << 11;        /* rom for the original value */
 906             value |= upk->inst & 0x7ff;         /* eleven bits from instruction */
 907           }
 908         else
 909           {
 910             value = upk->inst & 0x7ff;
 911             /* FIXME : Consider sign extension */
 912           }
 913         upk->offset = value;
 914       }
 915       break;
 916     case ritype:
 917     case i8type:
 918       {                         /* A register identifier and an offset */
 919         /* Most of the fields are the same as I type but the
 920            immediate value is of a different length */
 921         unsigned long value;
 922         if (extended)
 923           {
 924             value = extended_offset (extension);
 925             value = value << 8; /* from the original instruction */
 926             value |= upk->inst & 0xff;  /* eleven bits from instruction */
 927             upk->regx = (extension >> 8) & 0x07;        /* or i8 funct */
 928             if (value & 0x4000) /* test the sign bit , bit 26 */
 929               {
 930                 value &= ~0x3fff;       /* remove the sign bit */
 931                 value = -value;
 932               }
 933           }
 934         else
 935           {
 936             value = upk->inst & 0xff;   /* 8 bits */
 937             upk->regx = (upk->inst >> 8) & 0x07;        /* or i8 funct */
 938             /* FIXME: Do sign extension , this format needs it */
 939             if (value & 0x80)   /* THIS CONFUSES ME */
 940               {
 941                 value &= 0xef;  /* remove the sign bit */
 942                 value = -value;
 943               }
 944
 945           }
 946         upk->offset = value;
 947         break;
 948       }
 949     case jalxtype:
 950       {
 951         unsigned long value;
 952         unsigned short nexthalf;
 953         value = ((upk->inst & 0x1f) << 5) | ((upk->inst >> 5) & 0x1f);
 954         value = value << 16;
 955         nexthalf = mips_fetch_instruction (pc + 2);     /* low bit still set */
 956         value |= nexthalf;
 957         upk->offset = value;
 958         break;
 959       }
 960     default:
 961       printf_filtered ("Decoding unimplemented instruction format type\n");
 962       break;
 963     }
 964   /* print_unpack("UPK",upk) ; */
 965 }
 966
 967
 968 #define mips16_op(x) (x >> 11)
 969
 970 /* This is a map of the opcodes which ae known to perform branches */
 971 static unsigned char map16[32] =
 972 {0, 0, 1, 1, 1, 1, 0, 0,
 973  0, 0, 0, 0, 1, 0, 0, 0,
 974  0, 0, 0, 0, 0, 0, 0, 0,
 975  0, 0, 0, 0, 0, 1, 1, 0
 976 };
 977
 978 static CORE_ADDR
 979 add_offset_16 (CORE_ADDR pc, int offset)
 980 {
 981   return ((offset << 2) | ((pc + 2) & (0xf0000000)));
 982
 983 }
 984
 985
 986
 987 static struct upk_mips16 upk;
 988
 989 CORE_ADDR
 990 mips16_next_pc (CORE_ADDR pc)
 991 {
 992   int op;
 993   t_inst inst;
 994   /* inst = mips_fetch_instruction(pc) ; - This doesnt always work */
 995   inst = fetch_mips_16 (pc);
 996   upk.inst = inst;
 997   op = mips16_op (upk.inst);
 998   if (map16[op])
 999     {
1000       int reg;
1001       switch (op)
1002         {
1003         case 2:         /* Branch */
1004           upk.fmt = itype;
1005           unpack_mips16 (pc, &upk);
1006           {
1007             long offset;
1008             offset = upk.offset;
1009             if (offset & 0x800)
1010               {
1011                 offset &= 0xeff;
1012                 offset = -offset;
1013               }
1014             pc += (offset << 1) + 2;
1015           }
1016           break;
1017         case 3:         /* JAL , JALX - Watch out, these are 32 bit instruction */
1018           upk.fmt = jalxtype;
1019           unpack_mips16 (pc, &upk);
1020           pc = add_offset_16 (pc, upk.offset);
1021           if ((upk.inst >> 10) & 0x01)  /* Exchange mode */
1022             pc = pc & ~0x01;    /* Clear low bit, indicate 32 bit mode */
1023           else
1024             pc |= 0x01;
1025           break;
1026         case 4:         /* beqz */
1027           upk.fmt = ritype;
1028           unpack_mips16 (pc, &upk);
1029           reg = read_register (upk.regx);
1030           if (reg == 0)
1031             pc += (upk.offset << 1) + 2;
1032           else
1033             pc += 2;
1034           break;
1035         case 5:         /* bnez */
1036           upk.fmt = ritype;
1037           unpack_mips16 (pc, &upk);
1038           reg = read_register (upk.regx);
1039           if (reg != 0)
1040             pc += (upk.offset << 1) + 2;
1041           else
1042             pc += 2;
1043           break;
1044         case 12:                /* I8 Formats btez btnez */
1045           upk.fmt = i8type;
1046           unpack_mips16 (pc, &upk);
1047           /* upk.regx contains the opcode */
1048           reg = read_register (24);     /* Test register is 24 */
1049           if (((upk.regx == 0) && (reg == 0))   /* BTEZ */
1050               || ((upk.regx == 1) && (reg != 0)))       /* BTNEZ */
1051             /* pc = add_offset_16(pc,upk.offset) ; */
1052             pc += (upk.offset << 1) + 2;
1053           else
1054             pc += 2;
1055           break;
1056         case 29:                /* RR Formats JR, JALR, JALR-RA */
1057           upk.fmt = rrtype;
1058           op = upk.inst & 0x1f;
1059           if (op == 0)
1060             {
1061               upk.regx = (upk.inst >> 8) & 0x07;
1062               upk.regy = (upk.inst >> 5) & 0x07;
1063               switch (upk.regy)
1064                 {
1065                 case 0:
1066                   reg = upk.regx;
1067                   break;
1068                 case 1:
1069                   reg = 31;
1070                   break;        /* Function return instruction */
1071                 case 2:
1072                   reg = upk.regx;
1073                   break;
1074                 default:
1075                   reg = 31;
1076                   break;        /* BOGUS Guess */
1077                 }
1078               pc = read_register (reg);
1079             }
1080           else
1081             pc += 2;
1082           break;
1083         case 30:                /* This is an extend instruction */
1084           pc += 4;              /* Dont be setting breakpints on the second half */
1085           break;
1086         default:
1087           printf ("Filtered - next PC probably incorrrect due to jump inst\n");
1088           pc += 2;
1089           break;
1090         }
1091     }
1092   else
1093     pc += 2;                    /* just a good old instruction */
1094   /* See if we CAN actually break on the next instruction */
1095   /* printf("NXTm16PC %08x\n",(unsigned long)pc) ; */
1096   return pc;
1097 }                               /* mips16_next_pc */
1098
1099 /* The mips_next_pc function supports single_tep when the remote target monitor or
1100    stub is not developed enough to so a single_step.
1101    It works by decoding the current instruction and predicting where a branch
1102    will go. This isnt hard because all the data is available.
1103    The MIPS32 and MIPS16 variants are quite different
1104  */
1105 CORE_ADDR
1106 mips_next_pc (CORE_ADDR pc)
1107 {
1108   t_inst inst;
1109   /* inst = mips_fetch_instruction(pc) ; */
1110   /* if (pc_is_mips16) <----- This is failing */
1111   if (pc & 0x01)
1112     return mips16_next_pc (pc);
1113   else
1114     return mips32_next_pc (pc);
1115 }                               /* mips_next_pc */
1116
1117 /* Guaranteed to set fci->saved_regs to some values (it never leaves it
1118    NULL).  */
1119
1120 void
1121 mips_find_saved_regs (fci)
1122      struct frame_info *fci;
1123 {
1124   int ireg;
1125   CORE_ADDR reg_position;
1126   /* r0 bit means kernel trap */
1127   int kernel_trap;
1128   /* What registers have been saved?  Bitmasks.  */
1129   unsigned long gen_mask, float_mask;
1130   mips_extra_func_info_t proc_desc;
1131   t_inst inst;
1132
1133   frame_saved_regs_zalloc (fci);
1134
1135   /* If it is the frame for sigtramp, the saved registers are located
1136      in a sigcontext structure somewhere on the stack.
1137      If the stack layout for sigtramp changes we might have to change these
1138      constants and the companion fixup_sigtramp in mdebugread.c  */
1139 #ifndef SIGFRAME_BASE
1140 /* To satisfy alignment restrictions, sigcontext is located 4 bytes
1141    above the sigtramp frame.  */
1142 #define SIGFRAME_BASE           MIPS_REGSIZE
1143 /* FIXME!  Are these correct?? */
1144 #define SIGFRAME_PC_OFF         (SIGFRAME_BASE + 2 * MIPS_REGSIZE)
1145 #define SIGFRAME_REGSAVE_OFF    (SIGFRAME_BASE + 3 * MIPS_REGSIZE)
1146 #define SIGFRAME_FPREGSAVE_OFF  \
1147         (SIGFRAME_REGSAVE_OFF + MIPS_NUMREGS * MIPS_REGSIZE + 3 * MIPS_REGSIZE)
1148 #endif
1149 #ifndef SIGFRAME_REG_SIZE
1150 /* FIXME!  Is this correct?? */
1151 #define SIGFRAME_REG_SIZE       MIPS_REGSIZE
1152 #endif
1153   if (fci->signal_handler_caller)
1154     {
1155       for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
1156         {
1157           reg_position = fci->frame + SIGFRAME_REGSAVE_OFF
1158             + ireg * SIGFRAME_REG_SIZE;
1159           fci->saved_regs[ireg] = reg_position;
1160         }
1161       for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
1162         {
1163           reg_position = fci->frame + SIGFRAME_FPREGSAVE_OFF
1164             + ireg * SIGFRAME_REG_SIZE;
1165           fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
1166         }
1167       fci->saved_regs[PC_REGNUM] = fci->frame + SIGFRAME_PC_OFF;
1168       return;
1169     }
1170
1171   proc_desc = fci->extra_info->proc_desc;
1172   if (proc_desc == NULL)
1173     /* I'm not sure how/whether this can happen.  Normally when we can't
1174        find a proc_desc, we "synthesize" one using heuristic_proc_desc
1175        and set the saved_regs right away.  */
1176     return;
1177
1178   kernel_trap = PROC_REG_MASK (proc_desc) & 1;
1179   gen_mask = kernel_trap ? 0xFFFFFFFF : PROC_REG_MASK (proc_desc);
1180   float_mask = kernel_trap ? 0xFFFFFFFF : PROC_FREG_MASK (proc_desc);
1181
1182   if (                          /* In any frame other than the innermost or a frame interrupted by
1183                                    a signal, we assume that all registers have been saved.
1184                                    This assumes that all register saves in a function happen before
1185                                    the first function call.  */
1186        (fci->next == NULL || fci->next->signal_handler_caller)
1187
1188   /* In a dummy frame we know exactly where things are saved.  */
1189        && !PROC_DESC_IS_DUMMY (proc_desc)
1190
1191   /* Don't bother unless we are inside a function prologue.  Outside the
1192      prologue, we know where everything is. */
1193
1194        && in_prologue (fci->pc, PROC_LOW_ADDR (proc_desc))
1195
1196   /* Not sure exactly what kernel_trap means, but if it means
1197      the kernel saves the registers without a prologue doing it,
1198      we better not examine the prologue to see whether registers
1199      have been saved yet.  */
1200        && !kernel_trap)
1201     {
1202       /* We need to figure out whether the registers that the proc_desc
1203          claims are saved have been saved yet.  */
1204
1205       CORE_ADDR addr;
1206
1207       /* Bitmasks; set if we have found a save for the register.  */
1208       unsigned long gen_save_found = 0;
1209       unsigned long float_save_found = 0;
1210       int instlen;
1211
1212       /* If the address is odd, assume this is MIPS16 code.  */
1213       addr = PROC_LOW_ADDR (proc_desc);
1214       instlen = pc_is_mips16 (addr) ? MIPS16_INSTLEN : MIPS_INSTLEN;
1215
1216       /* Scan through this function's instructions preceding the current
1217          PC, and look for those that save registers.  */
1218       while (addr < fci->pc)
1219         {
1220           inst = mips_fetch_instruction (addr);
1221           if (pc_is_mips16 (addr))
1222             mips16_decode_reg_save (inst, &gen_save_found);
1223           else
1224             mips32_decode_reg_save (inst, &gen_save_found, &float_save_found);
1225           addr += instlen;
1226         }
1227       gen_mask = gen_save_found;
1228       float_mask = float_save_found;
1229     }
1230
1231   /* Fill in the offsets for the registers which gen_mask says
1232      were saved.  */
1233   reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
1234   for (ireg = MIPS_NUMREGS - 1; gen_mask; --ireg, gen_mask <<= 1)
1235     if (gen_mask & 0x80000000)
1236       {
1237         fci->saved_regs[ireg] = reg_position;
1238         reg_position -= MIPS_SAVED_REGSIZE;
1239       }
1240
1241   /* The MIPS16 entry instruction saves $s0 and $s1 in the reverse order
1242      of that normally used by gcc.  Therefore, we have to fetch the first
1243      instruction of the function, and if it's an entry instruction that
1244      saves $s0 or $s1, correct their saved addresses.  */
1245   if (pc_is_mips16 (PROC_LOW_ADDR (proc_desc)))
1246     {
1247       inst = mips_fetch_instruction (PROC_LOW_ADDR (proc_desc));
1248       if ((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)         /* entry */
1249         {
1250           int reg;
1251           int sreg_count = (inst >> 6) & 3;
1252
1253           /* Check if the ra register was pushed on the stack.  */
1254           reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
1255           if (inst & 0x20)
1256             reg_position -= MIPS_SAVED_REGSIZE;
1257
1258           /* Check if the s0 and s1 registers were pushed on the stack.  */
1259           for (reg = 16; reg < sreg_count + 16; reg++)
1260             {
1261               fci->saved_regs[reg] = reg_position;
1262               reg_position -= MIPS_SAVED_REGSIZE;
1263             }
1264         }
1265     }
1266
1267   /* Fill in the offsets for the registers which float_mask says
1268      were saved.  */
1269   reg_position = fci->frame + PROC_FREG_OFFSET (proc_desc);
1270
1271   /* The freg_offset points to where the first *double* register
1272      is saved.  So skip to the high-order word. */
1273   if (!GDB_TARGET_IS_MIPS64)
1274     reg_position += MIPS_SAVED_REGSIZE;
1275
1276   /* Fill in the offsets for the float registers which float_mask says
1277      were saved.  */
1278   for (ireg = MIPS_NUMREGS - 1; float_mask; --ireg, float_mask <<= 1)
1279     if (float_mask & 0x80000000)
1280       {
1281         fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
1282         reg_position -= MIPS_SAVED_REGSIZE;
1283       }
1284
1285   fci->saved_regs[PC_REGNUM] = fci->saved_regs[RA_REGNUM];
1286 }
1287
1288 static CORE_ADDR
1289 read_next_frame_reg (fi, regno)
1290      struct frame_info *fi;
1291      int regno;
1292 {
1293   for (; fi; fi = fi->next)
1294     {
1295       /* We have to get the saved sp from the sigcontext
1296          if it is a signal handler frame.  */
1297       if (regno == SP_REGNUM && !fi->signal_handler_caller)
1298         return fi->frame;
1299       else
1300         {
1301           if (fi->saved_regs == NULL)
1302             mips_find_saved_regs (fi);
1303           if (fi->saved_regs[regno])
1304             return read_memory_integer (ADDR_BITS_REMOVE (fi->saved_regs[regno]), MIPS_SAVED_REGSIZE);
1305         }
1306     }
1307   return read_register (regno);
1308 }
1309
1310 /* mips_addr_bits_remove - remove useless address bits  */
1311
1312 CORE_ADDR
1313 mips_addr_bits_remove (addr)
1314      CORE_ADDR addr;
1315 {
1316   if (GDB_TARGET_IS_MIPS64)
1317     {
1318       if (mask_address_p && (addr >> 32 == (CORE_ADDR) 0xffffffff))
1319         {
1320           /* This hack is a work-around for existing boards using
1321              PMON, the simulator, and any other 64-bit targets that
1322              doesn't have true 64-bit addressing.  On these targets,
1323              the upper 32 bits of addresses are ignored by the
1324              hardware.  Thus, the PC or SP are likely to have been
1325              sign extended to all 1s by instruction sequences that
1326              load 32-bit addresses.  For example, a typical piece of
1327              code that loads an address is this: lui $r2, <upper 16
1328              bits> ori $r2, <lower 16 bits> But the lui sign-extends
1329              the value such that the upper 32 bits may be all 1s.  The
1330              workaround is simply to mask off these bits.  In the
1331              future, gcc may be changed to support true 64-bit
1332              addressing, and this masking will have to be disabled.  */
1333           addr &= (CORE_ADDR) 0xffffffff;
1334         }
1335     }
1336   else
1337     {
1338       /* Even when GDB is configured for some 32-bit targets
1339          (e.g. mips-elf), BFD is configured to handle 64-bit targets,
1340          so CORE_ADDR is 64 bits.  So we still have to mask off
1341          useless bits from addresses.  */
1342       addr &= (CORE_ADDR) 0xffffffff;
1343     }
1344   return addr;
1345 }
1346
1347 void
1348 mips_init_frame_pc_first (fromleaf, prev)
1349      int fromleaf;
1350      struct frame_info *prev;
1351 {
1352   CORE_ADDR pc, tmp;
1353
1354   pc = ((fromleaf) ? SAVED_PC_AFTER_CALL (prev->next) :
1355         prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
1356   tmp = mips_skip_stub (pc);
1357   prev->pc = tmp ? tmp : pc;
1358 }
1359
1360
1361 CORE_ADDR
1362 mips_frame_saved_pc (frame)
1363      struct frame_info *frame;
1364 {
1365   CORE_ADDR saved_pc;
1366   mips_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
1367   /* We have to get the saved pc from the sigcontext
1368      if it is a signal handler frame.  */
1369   int pcreg = frame->signal_handler_caller ? PC_REGNUM
1370   : (proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM);
1371
1372   if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))
1373     saved_pc = read_memory_integer (frame->frame - MIPS_SAVED_REGSIZE, MIPS_SAVED_REGSIZE);
1374   else
1375     saved_pc = read_next_frame_reg (frame, pcreg);
1376
1377   return ADDR_BITS_REMOVE (saved_pc);
1378 }
1379
1380 static struct mips_extra_func_info temp_proc_desc;
1381 static CORE_ADDR temp_saved_regs[NUM_REGS];
1382
1383 /* Set a register's saved stack address in temp_saved_regs.  If an address
1384    has already been set for this register, do nothing; this way we will
1385    only recognize the first save of a given register in a function prologue.
1386    This is a helper function for mips{16,32}_heuristic_proc_desc.  */
1387
1388 static void
1389 set_reg_offset (regno, offset)
1390      int regno;
1391      CORE_ADDR offset;
1392 {
1393   if (temp_saved_regs[regno] == 0)
1394     temp_saved_regs[regno] = offset;
1395 }
1396
1397
1398 /* Test whether the PC points to the return instruction at the
1399    end of a function. */
1400
1401 static int
1402 mips_about_to_return (pc)
1403      CORE_ADDR pc;
1404 {
1405   if (pc_is_mips16 (pc))
1406     /* This mips16 case isn't necessarily reliable.  Sometimes the compiler
1407        generates a "jr $ra"; other times it generates code to load
1408        the return address from the stack to an accessible register (such
1409        as $a3), then a "jr" using that register.  This second case
1410        is almost impossible to distinguish from an indirect jump
1411        used for switch statements, so we don't even try.  */
1412     return mips_fetch_instruction (pc) == 0xe820;       /* jr $ra */
1413   else
1414     return mips_fetch_instruction (pc) == 0x3e00008;    /* jr $ra */
1415 }
1416
1417
1418 /* This fencepost looks highly suspicious to me.  Removing it also
1419    seems suspicious as it could affect remote debugging across serial
1420    lines.  */
1421
1422 static CORE_ADDR
1423 heuristic_proc_start (pc)
1424      CORE_ADDR pc;
1425 {
1426   CORE_ADDR start_pc;
1427   CORE_ADDR fence;
1428   int instlen;
1429   int seen_adjsp = 0;
1430
1431   pc = ADDR_BITS_REMOVE (pc);
1432   start_pc = pc;
1433   fence = start_pc - heuristic_fence_post;
1434   if (start_pc == 0)
1435     return 0;
1436
1437   if (heuristic_fence_post == UINT_MAX
1438       || fence < VM_MIN_ADDRESS)
1439     fence = VM_MIN_ADDRESS;
1440
1441   instlen = pc_is_mips16 (pc) ? MIPS16_INSTLEN : MIPS_INSTLEN;
1442
1443   /* search back for previous return */
1444   for (start_pc -= instlen;; start_pc -= instlen)
1445     if (start_pc < fence)
1446       {
1447         /* It's not clear to me why we reach this point when
1448            stop_soon_quietly, but with this test, at least we
1449            don't print out warnings for every child forked (eg, on
1450            decstation).  22apr93 rich@cygnus.com.  */
1451         if (!stop_soon_quietly)
1452           {
1453             static int blurb_printed = 0;
1454
1455             warning ("Warning: GDB can't find the start of the function at 0x%s.",
1456                      paddr_nz (pc));
1457
1458             if (!blurb_printed)
1459               {
1460                 /* This actually happens frequently in embedded
1461                    development, when you first connect to a board
1462                    and your stack pointer and pc are nowhere in
1463                    particular.  This message needs to give people
1464                    in that situation enough information to
1465                    determine that it's no big deal.  */
1466                 printf_filtered ("\n\
1467     GDB is unable to find the start of the function at 0x%s\n\
1468 and thus can't determine the size of that function's stack frame.\n\
1469 This means that GDB may be unable to access that stack frame, or\n\
1470 the frames below it.\n\
1471     This problem is most likely caused by an invalid program counter or\n\
1472 stack pointer.\n\
1473     However, if you think GDB should simply search farther back\n\
1474 from 0x%s for code which looks like the beginning of a\n\
1475 function, you can increase the range of the search using the `set\n\
1476 heuristic-fence-post' command.\n",
1477                                  paddr_nz (pc), paddr_nz (pc));
1478                 blurb_printed = 1;
1479               }
1480           }
1481
1482         return 0;
1483       }
1484     else if (pc_is_mips16 (start_pc))
1485       {
1486         unsigned short inst;
1487
1488         /* On MIPS16, any one of the following is likely to be the
1489            start of a function:
1490            entry
1491            addiu sp,-n
1492            daddiu sp,-n
1493            extend -n followed by 'addiu sp,+n' or 'daddiu sp,+n'  */
1494         inst = mips_fetch_instruction (start_pc);
1495         if (((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)      /* entry */
1496             || (inst & 0xff80) == 0x6380        /* addiu sp,-n */
1497             || (inst & 0xff80) == 0xfb80        /* daddiu sp,-n */
1498             || ((inst & 0xf810) == 0xf010 && seen_adjsp))       /* extend -n */
1499           break;
1500         else if ((inst & 0xff00) == 0x6300      /* addiu sp */
1501                  || (inst & 0xff00) == 0xfb00)  /* daddiu sp */
1502           seen_adjsp = 1;
1503         else
1504           seen_adjsp = 0;
1505       }
1506     else if (mips_about_to_return (start_pc))
1507       {
1508         start_pc += 2 * MIPS_INSTLEN;   /* skip return, and its delay slot */
1509         break;
1510       }
1511
1512 #if 0
1513   /* skip nops (usually 1) 0 - is this */
1514   while (start_pc < pc && read_memory_integer (start_pc, MIPS_INSTLEN) == 0)
1515     start_pc += MIPS_INSTLEN;
1516 #endif
1517   return start_pc;
1518 }
1519
1520 /* Fetch the immediate value from a MIPS16 instruction.
1521    If the previous instruction was an EXTEND, use it to extend
1522    the upper bits of the immediate value.  This is a helper function
1523    for mips16_heuristic_proc_desc.  */
1524
1525 static int
1526 mips16_get_imm (prev_inst, inst, nbits, scale, is_signed)
1527      unsigned short prev_inst;  /* previous instruction */
1528      unsigned short inst;       /* current instruction */
1529      int nbits;                 /* number of bits in imm field */
1530      int scale;                 /* scale factor to be applied to imm */
1531      int is_signed;             /* is the imm field signed? */
1532 {
1533   int offset;
1534
1535   if ((prev_inst & 0xf800) == 0xf000)   /* prev instruction was EXTEND? */
1536     {
1537       offset = ((prev_inst & 0x1f) << 11) | (prev_inst & 0x7e0);
1538       if (offset & 0x8000)      /* check for negative extend */
1539         offset = 0 - (0x10000 - (offset & 0xffff));
1540       return offset | (inst & 0x1f);
1541     }
1542   else
1543     {
1544       int max_imm = 1 << nbits;
1545       int mask = max_imm - 1;
1546       int sign_bit = max_imm >> 1;
1547
1548       offset = inst & mask;
1549       if (is_signed && (offset & sign_bit))
1550         offset = 0 - (max_imm - offset);
1551       return offset * scale;
1552     }
1553 }
1554
1555
1556 /* Fill in values in temp_proc_desc based on the MIPS16 instruction
1557    stream from start_pc to limit_pc.  */
1558
1559 static void
1560 mips16_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp)
1561      CORE_ADDR start_pc, limit_pc;
1562      struct frame_info *next_frame;
1563      CORE_ADDR sp;
1564 {
1565   CORE_ADDR cur_pc;
1566   CORE_ADDR frame_addr = 0;     /* Value of $r17, used as frame pointer */
1567   unsigned short prev_inst = 0; /* saved copy of previous instruction */
1568   unsigned inst = 0;            /* current instruction */
1569   unsigned entry_inst = 0;      /* the entry instruction */
1570   int reg, offset;
1571
1572   PROC_FRAME_OFFSET (&temp_proc_desc) = 0;      /* size of stack frame */
1573   PROC_FRAME_ADJUST (&temp_proc_desc) = 0;      /* offset of FP from SP */
1574
1575   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS16_INSTLEN)
1576     {
1577       /* Save the previous instruction.  If it's an EXTEND, we'll extract
1578          the immediate offset extension from it in mips16_get_imm.  */
1579       prev_inst = inst;
1580
1581       /* Fetch and decode the instruction.   */
1582       inst = (unsigned short) mips_fetch_instruction (cur_pc);
1583       if ((inst & 0xff00) == 0x6300     /* addiu sp */
1584           || (inst & 0xff00) == 0xfb00)         /* daddiu sp */
1585         {
1586           offset = mips16_get_imm (prev_inst, inst, 8, 8, 1);
1587           if (offset < 0)       /* negative stack adjustment? */
1588             PROC_FRAME_OFFSET (&temp_proc_desc) -= offset;
1589           else
1590             /* Exit loop if a positive stack adjustment is found, which
1591                usually means that the stack cleanup code in the function
1592                epilogue is reached.  */
1593             break;
1594         }
1595       else if ((inst & 0xf800) == 0xd000)       /* sw reg,n($sp) */
1596         {
1597           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1598           reg = mips16_to_32_reg[(inst & 0x700) >> 8];
1599           PROC_REG_MASK (&temp_proc_desc) |= (1 << reg);
1600           set_reg_offset (reg, sp + offset);
1601         }
1602       else if ((inst & 0xff00) == 0xf900)       /* sd reg,n($sp) */
1603         {
1604           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
1605           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1606           PROC_REG_MASK (&temp_proc_desc) |= (1 << reg);
1607           set_reg_offset (reg, sp + offset);
1608         }
1609       else if ((inst & 0xff00) == 0x6200)       /* sw $ra,n($sp) */
1610         {
1611           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1612           PROC_REG_MASK (&temp_proc_desc) |= (1 << RA_REGNUM);
1613           set_reg_offset (RA_REGNUM, sp + offset);
1614         }
1615       else if ((inst & 0xff00) == 0xfa00)       /* sd $ra,n($sp) */
1616         {
1617           offset = mips16_get_imm (prev_inst, inst, 8, 8, 0);
1618           PROC_REG_MASK (&temp_proc_desc) |= (1 << RA_REGNUM);
1619           set_reg_offset (RA_REGNUM, sp + offset);
1620         }
1621       else if (inst == 0x673d)  /* move $s1, $sp */
1622         {
1623           frame_addr = sp;
1624           PROC_FRAME_REG (&temp_proc_desc) = 17;
1625         }
1626       else if ((inst & 0xff00) == 0x0100)       /* addiu $s1,sp,n */
1627         {
1628           offset = mips16_get_imm (prev_inst, inst, 8, 4, 0);
1629           frame_addr = sp + offset;
1630           PROC_FRAME_REG (&temp_proc_desc) = 17;
1631           PROC_FRAME_ADJUST (&temp_proc_desc) = offset;
1632         }
1633       else if ((inst & 0xFF00) == 0xd900)       /* sw reg,offset($s1) */
1634         {
1635           offset = mips16_get_imm (prev_inst, inst, 5, 4, 0);
1636           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1637           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1638           set_reg_offset (reg, frame_addr + offset);
1639         }
1640       else if ((inst & 0xFF00) == 0x7900)       /* sd reg,offset($s1) */
1641         {
1642           offset = mips16_get_imm (prev_inst, inst, 5, 8, 0);
1643           reg = mips16_to_32_reg[(inst & 0xe0) >> 5];
1644           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1645           set_reg_offset (reg, frame_addr + offset);
1646         }
1647       else if ((inst & 0xf81f) == 0xe809 && (inst & 0x700) != 0x700)    /* entry */
1648         entry_inst = inst;      /* save for later processing */
1649       else if ((inst & 0xf800) == 0x1800)       /* jal(x) */
1650         cur_pc += MIPS16_INSTLEN;       /* 32-bit instruction */
1651     }
1652
1653   /* The entry instruction is typically the first instruction in a function,
1654      and it stores registers at offsets relative to the value of the old SP
1655      (before the prologue).  But the value of the sp parameter to this
1656      function is the new SP (after the prologue has been executed).  So we
1657      can't calculate those offsets until we've seen the entire prologue,
1658      and can calculate what the old SP must have been. */
1659   if (entry_inst != 0)
1660     {
1661       int areg_count = (entry_inst >> 8) & 7;
1662       int sreg_count = (entry_inst >> 6) & 3;
1663
1664       /* The entry instruction always subtracts 32 from the SP.  */
1665       PROC_FRAME_OFFSET (&temp_proc_desc) += 32;
1666
1667       /* Now we can calculate what the SP must have been at the
1668          start of the function prologue.  */
1669       sp += PROC_FRAME_OFFSET (&temp_proc_desc);
1670
1671       /* Check if a0-a3 were saved in the caller's argument save area.  */
1672       for (reg = 4, offset = 0; reg < areg_count + 4; reg++)
1673         {
1674           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1675           set_reg_offset (reg, sp + offset);
1676           offset += MIPS_SAVED_REGSIZE;
1677         }
1678
1679       /* Check if the ra register was pushed on the stack.  */
1680       offset = -4;
1681       if (entry_inst & 0x20)
1682         {
1683           PROC_REG_MASK (&temp_proc_desc) |= 1 << RA_REGNUM;
1684           set_reg_offset (RA_REGNUM, sp + offset);
1685           offset -= MIPS_SAVED_REGSIZE;
1686         }
1687
1688       /* Check if the s0 and s1 registers were pushed on the stack.  */
1689       for (reg = 16; reg < sreg_count + 16; reg++)
1690         {
1691           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1692           set_reg_offset (reg, sp + offset);
1693           offset -= MIPS_SAVED_REGSIZE;
1694         }
1695     }
1696 }
1697
1698 static void
1699 mips32_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp)
1700      CORE_ADDR start_pc, limit_pc;
1701      struct frame_info *next_frame;
1702      CORE_ADDR sp;
1703 {
1704   CORE_ADDR cur_pc;
1705   CORE_ADDR frame_addr = 0;     /* Value of $r30. Used by gcc for frame-pointer */
1706 restart:
1707   memset (temp_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
1708   PROC_FRAME_OFFSET (&temp_proc_desc) = 0;
1709   PROC_FRAME_ADJUST (&temp_proc_desc) = 0;      /* offset of FP from SP */
1710   for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += MIPS_INSTLEN)
1711     {
1712       unsigned long inst, high_word, low_word;
1713       int reg;
1714
1715       /* Fetch the instruction.   */
1716       inst = (unsigned long) mips_fetch_instruction (cur_pc);
1717
1718       /* Save some code by pre-extracting some useful fields.  */
1719       high_word = (inst >> 16) & 0xffff;
1720       low_word = inst & 0xffff;
1721       reg = high_word & 0x1f;
1722
1723       if (high_word == 0x27bd   /* addiu $sp,$sp,-i */
1724           || high_word == 0x23bd        /* addi $sp,$sp,-i */
1725           || high_word == 0x67bd)       /* daddiu $sp,$sp,-i */
1726         {
1727           if (low_word & 0x8000)        /* negative stack adjustment? */
1728             PROC_FRAME_OFFSET (&temp_proc_desc) += 0x10000 - low_word;
1729           else
1730             /* Exit loop if a positive stack adjustment is found, which
1731                usually means that the stack cleanup code in the function
1732                epilogue is reached.  */
1733             break;
1734         }
1735       else if ((high_word & 0xFFE0) == 0xafa0)  /* sw reg,offset($sp) */
1736         {
1737           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1738           set_reg_offset (reg, sp + low_word);
1739         }
1740       else if ((high_word & 0xFFE0) == 0xffa0)  /* sd reg,offset($sp) */
1741         {
1742           /* Irix 6.2 N32 ABI uses sd instructions for saving $gp and $ra,
1743              but the register size used is only 32 bits. Make the address
1744              for the saved register point to the lower 32 bits.  */
1745           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1746           set_reg_offset (reg, sp + low_word + 8 - MIPS_REGSIZE);
1747         }
1748       else if (high_word == 0x27be)     /* addiu $30,$sp,size */
1749         {
1750           /* Old gcc frame, r30 is virtual frame pointer.  */
1751           if ((long) low_word != PROC_FRAME_OFFSET (&temp_proc_desc))
1752             frame_addr = sp + low_word;
1753           else if (PROC_FRAME_REG (&temp_proc_desc) == SP_REGNUM)
1754             {
1755               unsigned alloca_adjust;
1756               PROC_FRAME_REG (&temp_proc_desc) = 30;
1757               frame_addr = read_next_frame_reg (next_frame, 30);
1758               alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
1759               if (alloca_adjust > 0)
1760                 {
1761                   /* FP > SP + frame_size. This may be because
1762                    * of an alloca or somethings similar.
1763                    * Fix sp to "pre-alloca" value, and try again.
1764                    */
1765                   sp += alloca_adjust;
1766                   goto restart;
1767                 }
1768             }
1769         }
1770       /* move $30,$sp.  With different versions of gas this will be either
1771          `addu $30,$sp,$zero' or `or $30,$sp,$zero' or `daddu 30,sp,$0'.
1772          Accept any one of these.  */
1773       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
1774         {
1775           /* New gcc frame, virtual frame pointer is at r30 + frame_size.  */
1776           if (PROC_FRAME_REG (&temp_proc_desc) == SP_REGNUM)
1777             {
1778               unsigned alloca_adjust;
1779               PROC_FRAME_REG (&temp_proc_desc) = 30;
1780               frame_addr = read_next_frame_reg (next_frame, 30);
1781               alloca_adjust = (unsigned) (frame_addr - sp);
1782               if (alloca_adjust > 0)
1783                 {
1784                   /* FP > SP + frame_size. This may be because
1785                    * of an alloca or somethings similar.
1786                    * Fix sp to "pre-alloca" value, and try again.
1787                    */
1788                   sp += alloca_adjust;
1789                   goto restart;
1790                 }
1791             }
1792         }
1793       else if ((high_word & 0xFFE0) == 0xafc0)  /* sw reg,offset($30) */
1794         {
1795           PROC_REG_MASK (&temp_proc_desc) |= 1 << reg;
1796           set_reg_offset (reg, frame_addr + low_word);
1797         }
1798     }
1799 }
1800
1801 static mips_extra_func_info_t
1802 heuristic_proc_desc (start_pc, limit_pc, next_frame)
1803      CORE_ADDR start_pc, limit_pc;
1804      struct frame_info *next_frame;
1805 {
1806   CORE_ADDR sp = read_next_frame_reg (next_frame, SP_REGNUM);
1807
1808   if (start_pc == 0)
1809     return NULL;
1810   memset (&temp_proc_desc, '\0', sizeof (temp_proc_desc));
1811   memset (&temp_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
1812   PROC_LOW_ADDR (&temp_proc_desc) = start_pc;
1813   PROC_FRAME_REG (&temp_proc_desc) = SP_REGNUM;
1814   PROC_PC_REG (&temp_proc_desc) = RA_REGNUM;
1815
1816   if (start_pc + 200 < limit_pc)
1817     limit_pc = start_pc + 200;
1818   if (pc_is_mips16 (start_pc))
1819     mips16_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp);
1820   else
1821     mips32_heuristic_proc_desc (start_pc, limit_pc, next_frame, sp);
1822   return &temp_proc_desc;
1823 }
1824
1825 static mips_extra_func_info_t
1826 non_heuristic_proc_desc (pc, addrptr)
1827      CORE_ADDR pc;
1828      CORE_ADDR *addrptr;
1829 {
1830   CORE_ADDR startaddr;
1831   mips_extra_func_info_t proc_desc;
1832   struct block *b = block_for_pc (pc);
1833   struct symbol *sym;
1834
1835   find_pc_partial_function (pc, NULL, &startaddr, NULL);
1836   if (addrptr)
1837     *addrptr = startaddr;
1838   if (b == NULL || PC_IN_CALL_DUMMY (pc, 0, 0))
1839     sym = NULL;
1840   else
1841     {
1842       if (startaddr > BLOCK_START (b))
1843         /* This is the "pathological" case referred to in a comment in
1844            print_frame_info.  It might be better to move this check into
1845            symbol reading.  */
1846         sym = NULL;
1847       else
1848         sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, 0, NULL);
1849     }
1850
1851   /* If we never found a PDR for this function in symbol reading, then
1852      examine prologues to find the information.  */
1853   if (sym)
1854     {
1855       proc_desc = (mips_extra_func_info_t) SYMBOL_VALUE (sym);
1856       if (PROC_FRAME_REG (proc_desc) == -1)
1857         return NULL;
1858       else
1859         return proc_desc;
1860     }
1861   else
1862     return NULL;
1863 }
1864
1865
1866 static mips_extra_func_info_t
1867 find_proc_desc (pc, next_frame)
1868      CORE_ADDR pc;
1869      struct frame_info *next_frame;
1870 {
1871   mips_extra_func_info_t proc_desc;
1872   CORE_ADDR startaddr;
1873
1874   proc_desc = non_heuristic_proc_desc (pc, &startaddr);
1875
1876   if (proc_desc)
1877     {
1878       /* IF this is the topmost frame AND
1879        * (this proc does not have debugging information OR
1880        * the PC is in the procedure prologue)
1881        * THEN create a "heuristic" proc_desc (by analyzing
1882        * the actual code) to replace the "official" proc_desc.
1883        */
1884       if (next_frame == NULL)
1885         {
1886           struct symtab_and_line val;
1887           struct symbol *proc_symbol =
1888           PROC_DESC_IS_DUMMY (proc_desc) ? 0 : PROC_SYMBOL (proc_desc);
1889
1890           if (proc_symbol)
1891             {
1892               val = find_pc_line (BLOCK_START
1893                                   (SYMBOL_BLOCK_VALUE (proc_symbol)),
1894                                   0);
1895               val.pc = val.end ? val.end : pc;
1896             }
1897           if (!proc_symbol || pc < val.pc)
1898             {
1899               mips_extra_func_info_t found_heuristic =
1900               heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
1901                                    pc, next_frame);
1902               if (found_heuristic)
1903                 proc_desc = found_heuristic;
1904             }
1905         }
1906     }
1907   else
1908     {
1909       /* Is linked_proc_desc_table really necessary?  It only seems to be used
1910          by procedure call dummys.  However, the procedures being called ought
1911          to have their own proc_descs, and even if they don't,
1912          heuristic_proc_desc knows how to create them! */
1913
1914       register struct linked_proc_info *link;
1915
1916       for (link = linked_proc_desc_table; link; link = link->next)
1917         if (PROC_LOW_ADDR (&link->info) <= pc
1918             && PROC_HIGH_ADDR (&link->info) > pc)
1919           return &link->info;
1920
1921       if (startaddr == 0)
1922         startaddr = heuristic_proc_start (pc);
1923
1924       proc_desc =
1925         heuristic_proc_desc (startaddr, pc, next_frame);
1926     }
1927   return proc_desc;
1928 }
1929
1930 static CORE_ADDR
1931 get_frame_pointer (frame, proc_desc)
1932      struct frame_info *frame;
1933      mips_extra_func_info_t proc_desc;
1934 {
1935   return ADDR_BITS_REMOVE (
1936                    read_next_frame_reg (frame, PROC_FRAME_REG (proc_desc)) +
1937              PROC_FRAME_OFFSET (proc_desc) - PROC_FRAME_ADJUST (proc_desc));
1938 }
1939
1940 mips_extra_func_info_t cached_proc_desc;
1941
1942 CORE_ADDR
1943 mips_frame_chain (frame)
1944      struct frame_info *frame;
1945 {
1946   mips_extra_func_info_t proc_desc;
1947   CORE_ADDR tmp;
1948   CORE_ADDR saved_pc = FRAME_SAVED_PC (frame);
1949
1950   if (saved_pc == 0 || inside_entry_file (saved_pc))
1951     return 0;
1952
1953   /* Check if the PC is inside a call stub.  If it is, fetch the
1954      PC of the caller of that stub.  */
1955   if ((tmp = mips_skip_stub (saved_pc)) != 0)
1956     saved_pc = tmp;
1957
1958   /* Look up the procedure descriptor for this PC.  */
1959   proc_desc = find_proc_desc (saved_pc, frame);
1960   if (!proc_desc)
1961     return 0;
1962
1963   cached_proc_desc = proc_desc;
1964
1965   /* If no frame pointer and frame size is zero, we must be at end
1966      of stack (or otherwise hosed).  If we don't check frame size,
1967      we loop forever if we see a zero size frame.  */
1968   if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
1969       && PROC_FRAME_OFFSET (proc_desc) == 0
1970   /* The previous frame from a sigtramp frame might be frameless
1971      and have frame size zero.  */
1972       && !frame->signal_handler_caller)
1973     return 0;
1974   else
1975     return get_frame_pointer (frame, proc_desc);
1976 }
1977
1978 void
1979 mips_init_extra_frame_info (fromleaf, fci)
1980      int fromleaf;
1981      struct frame_info *fci;
1982 {
1983   int regnum;
1984
1985   /* Use proc_desc calculated in frame_chain */
1986   mips_extra_func_info_t proc_desc =
1987   fci->next ? cached_proc_desc : find_proc_desc (fci->pc, fci->next);
1988
1989   fci->extra_info = (struct frame_extra_info *)
1990     frame_obstack_alloc (sizeof (struct frame_extra_info));
1991
1992   fci->saved_regs = NULL;
1993   fci->extra_info->proc_desc =
1994     proc_desc == &temp_proc_desc ? 0 : proc_desc;
1995   if (proc_desc)
1996     {
1997       /* Fixup frame-pointer - only needed for top frame */
1998       /* This may not be quite right, if proc has a real frame register.
1999          Get the value of the frame relative sp, procedure might have been
2000          interrupted by a signal at it's very start.  */
2001       if (fci->pc == PROC_LOW_ADDR (proc_desc)
2002           && !PROC_DESC_IS_DUMMY (proc_desc))
2003         fci->frame = read_next_frame_reg (fci->next, SP_REGNUM);
2004       else
2005         fci->frame = get_frame_pointer (fci->next, proc_desc);
2006
2007       if (proc_desc == &temp_proc_desc)
2008         {
2009           char *name;
2010
2011           /* Do not set the saved registers for a sigtramp frame,
2012              mips_find_saved_registers will do that for us.
2013              We can't use fci->signal_handler_caller, it is not yet set.  */
2014           find_pc_partial_function (fci->pc, &name,
2015                                     (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
2016           if (!IN_SIGTRAMP (fci->pc, name))
2017             {
2018               frame_saved_regs_zalloc (fci);
2019               memcpy (fci->saved_regs, temp_saved_regs, SIZEOF_FRAME_SAVED_REGS);
2020               fci->saved_regs[PC_REGNUM]
2021                 = fci->saved_regs[RA_REGNUM];
2022             }
2023         }
2024
2025       /* hack: if argument regs are saved, guess these contain args */
2026       /* assume we can't tell how many args for now */
2027       fci->extra_info->num_args = -1;
2028       for (regnum = MIPS_LAST_ARG_REGNUM; regnum >= A0_REGNUM; regnum--)
2029         {
2030           if (PROC_REG_MASK (proc_desc) & (1 << regnum))
2031             {
2032               fci->extra_info->num_args = regnum - A0_REGNUM + 1;
2033               break;
2034             }
2035         }
2036     }
2037 }
2038
2039 /* MIPS stack frames are almost impenetrable.  When execution stops,
2040    we basically have to look at symbol information for the function
2041    that we stopped in, which tells us *which* register (if any) is
2042    the base of the frame pointer, and what offset from that register
2043    the frame itself is at.
2044
2045    This presents a problem when trying to examine a stack in memory
2046    (that isn't executing at the moment), using the "frame" command.  We
2047    don't have a PC, nor do we have any registers except SP.
2048
2049    This routine takes two arguments, SP and PC, and tries to make the
2050    cached frames look as if these two arguments defined a frame on the
2051    cache.  This allows the rest of info frame to extract the important
2052    arguments without difficulty.  */
2053
2054 struct frame_info *
2055 setup_arbitrary_frame (argc, argv)
2056      int argc;
2057      CORE_ADDR *argv;
2058 {
2059   if (argc != 2)
2060     error ("MIPS frame specifications require two arguments: sp and pc");
2061
2062   return create_new_frame (argv[0], argv[1]);
2063 }
2064
2065 /* According to the current ABI, should the type be passed in a
2066    floating-point register (assuming that there is space)?  When there
2067    is no FPU, FP are not even considered as possibile candidates for
2068    FP registers and, consequently this returns false - forces FP
2069    arguments into integer registers. */
2070
2071 static int
2072 fp_register_arg_p (enum type_code typecode, struct type *arg_type)
2073 {
2074   return ((typecode == TYPE_CODE_FLT
2075            || (MIPS_EABI
2076                && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
2077                && TYPE_NFIELDS (arg_type) == 1
2078                && TYPE_CODE (TYPE_FIELD_TYPE (arg_type, 0)) == TYPE_CODE_FLT))
2079            && MIPS_FPU_TYPE != MIPS_FPU_NONE);
2080 }
2081
2082 CORE_ADDR
2083 mips_push_arguments (nargs, args, sp, struct_return, struct_addr)
2084      int nargs;
2085      value_ptr *args;
2086      CORE_ADDR sp;
2087      int struct_return;
2088      CORE_ADDR struct_addr;
2089 {
2090   int argreg;
2091   int float_argreg;
2092   int argnum;
2093   int len = 0;
2094   int stack_offset = 0;
2095
2096   /* Macros to round N up or down to the next A boundary; A must be
2097      a power of two. */
2098 #define ROUND_DOWN(n,a) ((n) & ~((a)-1))
2099 #define ROUND_UP(n,a) (((n)+(a)-1) & ~((a)-1))
2100
2101   /* First ensure that the stack and structure return address (if any)
2102      are properly aligned. The stack has to be at least 64-bit aligned
2103      even on 32-bit machines, because doubles must be 64-bit aligned.
2104      On at least one MIPS variant, stack frames need to be 128-bit
2105      aligned, so we round to this widest known alignment. */
2106   sp = ROUND_DOWN (sp, 16);
2107   struct_addr = ROUND_DOWN (struct_addr, MIPS_SAVED_REGSIZE);
2108
2109   /* Now make space on the stack for the args. We allocate more
2110      than necessary for EABI, because the first few arguments are
2111      passed in registers, but that's OK. */
2112   for (argnum = 0; argnum < nargs; argnum++)
2113     len += ROUND_UP (TYPE_LENGTH (VALUE_TYPE (args[argnum])), MIPS_SAVED_REGSIZE);
2114   sp -= ROUND_UP (len, 16);
2115
2116   if (mips_debug)
2117     fprintf_unfiltered (gdb_stdlog, "mips_push_arguments: sp=0x%lx allocated %d\n",
2118                         (long) sp, ROUND_UP (len, 16));
2119
2120   /* Initialize the integer and float register pointers.  */
2121   argreg = A0_REGNUM;
2122   float_argreg = FPA0_REGNUM;
2123
2124   /* the struct_return pointer occupies the first parameter-passing reg */
2125   if (struct_return)
2126     {
2127       if (mips_debug)
2128         fprintf_unfiltered (gdb_stdlog,
2129                             "mips_push_arguments: struct_return at r%d 0x%lx\n",
2130                             argreg, (long) struct_addr);
2131       write_register (argreg++, struct_addr);
2132     }
2133
2134   /* Now load as many as possible of the first arguments into
2135      registers, and push the rest onto the stack.  Loop thru args
2136      from first to last.  */
2137   for (argnum = 0; argnum < nargs; argnum++)
2138     {
2139       char *val;
2140       char valbuf[MAX_REGISTER_RAW_SIZE];
2141       value_ptr arg = args[argnum];
2142       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
2143       int len = TYPE_LENGTH (arg_type);
2144       enum type_code typecode = TYPE_CODE (arg_type);
2145
2146       if (mips_debug)
2147         fprintf_unfiltered (gdb_stdlog,
2148                             "mips_push_arguments: %d len=%d type=%d",
2149                             argnum, len, (int) typecode);
2150
2151       /* The EABI passes structures that do not fit in a register by
2152          reference. In all other cases, pass the structure by value.  */
2153       if (MIPS_EABI
2154           && len > MIPS_SAVED_REGSIZE
2155           && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
2156         {
2157           store_address (valbuf, MIPS_SAVED_REGSIZE, VALUE_ADDRESS (arg));
2158           typecode = TYPE_CODE_PTR;
2159           len = MIPS_SAVED_REGSIZE;
2160           val = valbuf;
2161           if (mips_debug)
2162             fprintf_unfiltered (gdb_stdlog, " push");
2163         }
2164       else
2165         val = (char *) VALUE_CONTENTS (arg);
2166
2167       /* 32-bit ABIs always start floating point arguments in an
2168          even-numbered floating point register.   */
2169       if (!FP_REGISTER_DOUBLE && typecode == TYPE_CODE_FLT
2170           && (float_argreg & 1))
2171         float_argreg++;
2172
2173       /* Floating point arguments passed in registers have to be
2174          treated specially.  On 32-bit architectures, doubles
2175          are passed in register pairs; the even register gets
2176          the low word, and the odd register gets the high word.
2177          On non-EABI processors, the first two floating point arguments are
2178          also copied to general registers, because MIPS16 functions
2179          don't use float registers for arguments.  This duplication of
2180          arguments in general registers can't hurt non-MIPS16 functions
2181          because those registers are normally skipped.  */
2182       /* MIPS_EABI squeeses a struct that contains a single floating
2183          point value into an FP register instead of pusing it onto the
2184          stack. */
2185       if (fp_register_arg_p (typecode, arg_type)
2186           && float_argreg <= MIPS_LAST_FP_ARG_REGNUM)
2187         {
2188           if (!FP_REGISTER_DOUBLE && len == 8)
2189             {
2190               int low_offset = TARGET_BYTE_ORDER == BIG_ENDIAN ? 4 : 0;
2191               unsigned long regval;
2192
2193               /* Write the low word of the double to the even register(s).  */
2194               regval = extract_unsigned_integer (val + low_offset, 4);
2195               if (mips_debug)
2196                 fprintf_unfiltered (gdb_stdlog, " fpreg=%d val=%s",
2197                                     float_argreg, phex (regval, 4));
2198               write_register (float_argreg++, regval);
2199               if (!MIPS_EABI)
2200                 {
2201                   if (mips_debug)
2202                     fprintf_unfiltered (gdb_stdlog, " reg=%d val=%s",
2203                                         argreg, phex (regval, 4));
2204                   write_register (argreg++, regval);
2205                 }
2206
2207               /* Write the high word of the double to the odd register(s).  */
2208               regval = extract_unsigned_integer (val + 4 - low_offset, 4);
2209               if (mips_debug)
2210                 fprintf_unfiltered (gdb_stdlog, " fpreg=%d val=%s",
2211                                     float_argreg, phex (regval, 4));
2212               write_register (float_argreg++, regval);
2213               if (!MIPS_EABI)
2214                 {
2215                   if (mips_debug)
2216                     fprintf_unfiltered (gdb_stdlog, " reg=%d val=%s",
2217                                         argreg, phex (regval, 4));
2218                   write_register (argreg++, regval);
2219                 }
2220
2221             }
2222           else
2223             {
2224               /* This is a floating point value that fits entirely
2225                  in a single register.  */
2226               /* On 32 bit ABI's the float_argreg is further adjusted
2227                  above to ensure that it is even register aligned. */
2228               LONGEST regval = extract_unsigned_integer (val, len);
2229               if (mips_debug)
2230                 fprintf_unfiltered (gdb_stdlog, " fpreg=%d val=%s",
2231                                     float_argreg, phex (regval, len));
2232               write_register (float_argreg++, regval);
2233               if (!MIPS_EABI)
2234                 {
2235                   /* CAGNEY: 32 bit MIPS ABI's always reserve two FP
2236                      registers for each argument.  The below is (my
2237                      guess) to ensure that the corresponding integer
2238                      register has reserved the same space. */
2239                   if (mips_debug)
2240                     fprintf_unfiltered (gdb_stdlog, " reg=%d val=%s",
2241                                         argreg, phex (regval, len));
2242                   write_register (argreg, regval);
2243                   argreg += FP_REGISTER_DOUBLE ? 1 : 2;
2244                 }
2245             }
2246         }
2247       else
2248         {
2249           /* Copy the argument to general registers or the stack in
2250              register-sized pieces.  Large arguments are split between
2251              registers and stack.  */
2252           /* Note: structs whose size is not a multiple of MIPS_REGSIZE
2253              are treated specially: Irix cc passes them in registers
2254              where gcc sometimes puts them on the stack.  For maximum
2255              compatibility, we will put them in both places.  */
2256           int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) &&
2257                                   (len % MIPS_SAVED_REGSIZE != 0));
2258           /* Note: Floating-point values that didn't fit into an FP
2259              register are only written to memory. */
2260           while (len > 0)
2261             {
2262               /* Rememer if the argument was written to the stack. */
2263               int stack_used_p = 0;
2264               int partial_len = len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
2265
2266               /* Write this portion of the argument to the stack.  */
2267               if (argreg > MIPS_LAST_ARG_REGNUM
2268                   || odd_sized_struct
2269                   || fp_register_arg_p (typecode, arg_type))
2270                 {
2271                   /* Should shorter than int integer values be
2272                      promoted to int before being stored? */
2273                   int longword_offset = 0;
2274                   CORE_ADDR addr;
2275                   stack_used_p = 1;
2276                   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
2277                     {
2278                       if (MIPS_STACK_ARGSIZE == 8 &&
2279                           (typecode == TYPE_CODE_INT ||
2280                            typecode == TYPE_CODE_PTR ||
2281                            typecode == TYPE_CODE_FLT) && len <= 4)
2282                         longword_offset = MIPS_STACK_ARGSIZE - len;
2283                       else if ((typecode == TYPE_CODE_STRUCT ||
2284                                 typecode == TYPE_CODE_UNION) &&
2285                                TYPE_LENGTH (arg_type) < MIPS_STACK_ARGSIZE)
2286                         longword_offset = MIPS_STACK_ARGSIZE - len;
2287                     }
2288
2289                   if (mips_debug)
2290                     {
2291                       fprintf_unfiltered (gdb_stdlog, " stack_offset=0x%lx",
2292                                           (long) stack_offset);
2293                       fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%lx",
2294                                           (long) longword_offset);
2295                     }
2296
2297                   addr = sp + stack_offset + longword_offset;
2298
2299                   if (mips_debug)
2300                     {
2301                       int i;
2302                       fprintf_unfiltered (gdb_stdlog, " @0x%lx ", (long) addr);
2303                       for (i = 0; i < partial_len; i++)
2304                         {
2305                           fprintf_unfiltered (gdb_stdlog, "%02x", val[i] & 0xff);
2306                         }
2307                     }
2308                   write_memory (addr, val, partial_len);
2309                 }
2310
2311               /* Note!!! This is NOT an else clause.  Odd sized
2312                  structs may go thru BOTH paths.  Floating point
2313                  arguments will not. */
2314               /* Write this portion of the argument to a general
2315                  purpose register. */
2316               if (argreg <= MIPS_LAST_ARG_REGNUM
2317                   && !fp_register_arg_p (typecode, arg_type))
2318                 {
2319                   LONGEST regval = extract_unsigned_integer (val, partial_len);
2320
2321                   /* A non-floating-point argument being passed in a
2322                      general register.  If a struct or union, and if
2323                      the remaining length is smaller than the register
2324                      size, we have to adjust the register value on
2325                      big endian targets.
2326
2327                      It does not seem to be necessary to do the
2328                      same for integral types.
2329
2330                      Also don't do this adjustment on EABI and O64
2331                      binaries. */
2332
2333                   if (!MIPS_EABI
2334                       && MIPS_SAVED_REGSIZE < 8
2335                       && TARGET_BYTE_ORDER == BIG_ENDIAN
2336                       && partial_len < MIPS_SAVED_REGSIZE
2337                       && (typecode == TYPE_CODE_STRUCT ||
2338                           typecode == TYPE_CODE_UNION))
2339                     regval <<= ((MIPS_SAVED_REGSIZE - partial_len) *
2340                                 TARGET_CHAR_BIT);
2341
2342                   if (mips_debug)
2343                     fprintf_filtered (gdb_stdlog, " reg=%d val=%s",
2344                                       argreg,
2345                                       phex (regval, MIPS_SAVED_REGSIZE));
2346                   write_register (argreg, regval);
2347                   argreg++;
2348
2349                   /* If this is the old ABI, prevent subsequent floating
2350                      point arguments from being passed in floating point
2351                      registers.  */
2352                   if (!MIPS_EABI)
2353                     float_argreg = MIPS_LAST_FP_ARG_REGNUM + 1;
2354                 }
2355
2356               len -= partial_len;
2357               val += partial_len;
2358
2359               /* Compute the the offset into the stack at which we
2360                  will copy the next parameter.
2361
2362                  In older ABIs, the caller reserved space for
2363                  registers that contained arguments.  This was loosely
2364                  refered to as their "home".  Consequently, space is
2365                  always allocated.
2366
2367                  In the new EABI (and the NABI32), the stack_offset
2368                  only needs to be adjusted when it has been used.. */
2369
2370               if (MIPS_REGS_HAVE_HOME_P || stack_used_p)
2371                 stack_offset += ROUND_UP (partial_len, MIPS_STACK_ARGSIZE);
2372             }
2373         }
2374       if (mips_debug)
2375         fprintf_unfiltered (gdb_stdlog, "\n");
2376     }
2377
2378   /* Return adjusted stack pointer.  */
2379   return sp;
2380 }
2381
2382 CORE_ADDR
2383 mips_push_return_address (pc, sp)
2384      CORE_ADDR pc;
2385      CORE_ADDR sp;
2386 {
2387   /* Set the return address register to point to the entry
2388      point of the program, where a breakpoint lies in wait.  */
2389   write_register (RA_REGNUM, CALL_DUMMY_ADDRESS ());
2390   return sp;
2391 }
2392
2393 static void
2394 mips_push_register (CORE_ADDR * sp, int regno)
2395 {
2396   char buffer[MAX_REGISTER_RAW_SIZE];
2397   int regsize;
2398   int offset;
2399   if (MIPS_SAVED_REGSIZE < REGISTER_RAW_SIZE (regno))
2400     {
2401       regsize = MIPS_SAVED_REGSIZE;
2402       offset = (TARGET_BYTE_ORDER == BIG_ENDIAN
2403                 ? REGISTER_RAW_SIZE (regno) - MIPS_SAVED_REGSIZE
2404                 : 0);
2405     }
2406   else
2407     {
2408       regsize = REGISTER_RAW_SIZE (regno);
2409       offset = 0;
2410     }
2411   *sp -= regsize;
2412   read_register_gen (regno, buffer);
2413   write_memory (*sp, buffer + offset, regsize);
2414 }
2415
2416 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<(MIPS_NUMREGS-1). */
2417 #define MASK(i,j) (((1 << ((j)+1))-1) ^ ((1 << (i))-1))
2418
2419 void
2420 mips_push_dummy_frame ()
2421 {
2422   int ireg;
2423   struct linked_proc_info *link = (struct linked_proc_info *)
2424   xmalloc (sizeof (struct linked_proc_info));
2425   mips_extra_func_info_t proc_desc = &link->info;
2426   CORE_ADDR sp = ADDR_BITS_REMOVE (read_register (SP_REGNUM));
2427   CORE_ADDR old_sp = sp;
2428   link->next = linked_proc_desc_table;
2429   linked_proc_desc_table = link;
2430
2431 /* FIXME!   are these correct ? */
2432 #define PUSH_FP_REGNUM 16       /* must be a register preserved across calls */
2433 #define GEN_REG_SAVE_MASK MASK(1,16)|MASK(24,28)|(1<<(MIPS_NUMREGS-1))
2434 #define FLOAT_REG_SAVE_MASK MASK(0,19)
2435 #define FLOAT_SINGLE_REG_SAVE_MASK \
2436   ((1<<18)|(1<<16)|(1<<14)|(1<<12)|(1<<10)|(1<<8)|(1<<6)|(1<<4)|(1<<2)|(1<<0))
2437   /*
2438    * The registers we must save are all those not preserved across
2439    * procedure calls. Dest_Reg (see tm-mips.h) must also be saved.
2440    * In addition, we must save the PC, PUSH_FP_REGNUM, MMLO/-HI
2441    * and FP Control/Status registers.
2442    *
2443    *
2444    * Dummy frame layout:
2445    *  (high memory)
2446    *    Saved PC
2447    *    Saved MMHI, MMLO, FPC_CSR
2448    *    Saved R31
2449    *    Saved R28
2450    *    ...
2451    *    Saved R1
2452    *    Saved D18 (i.e. F19, F18)
2453    *    ...
2454    *    Saved D0 (i.e. F1, F0)
2455    *    Argument build area and stack arguments written via mips_push_arguments
2456    *  (low memory)
2457    */
2458
2459   /* Save special registers (PC, MMHI, MMLO, FPC_CSR) */
2460   PROC_FRAME_REG (proc_desc) = PUSH_FP_REGNUM;
2461   PROC_FRAME_OFFSET (proc_desc) = 0;
2462   PROC_FRAME_ADJUST (proc_desc) = 0;
2463   mips_push_register (&sp, PC_REGNUM);
2464   mips_push_register (&sp, HI_REGNUM);
2465   mips_push_register (&sp, LO_REGNUM);
2466   mips_push_register (&sp, MIPS_FPU_TYPE == MIPS_FPU_NONE ? 0 : FCRCS_REGNUM);
2467
2468   /* Save general CPU registers */
2469   PROC_REG_MASK (proc_desc) = GEN_REG_SAVE_MASK;
2470   /* PROC_REG_OFFSET is the offset of the first saved register from FP.  */
2471   PROC_REG_OFFSET (proc_desc) = sp - old_sp - MIPS_SAVED_REGSIZE;
2472   for (ireg = 32; --ireg >= 0;)
2473     if (PROC_REG_MASK (proc_desc) & (1 << ireg))
2474       mips_push_register (&sp, ireg);
2475
2476   /* Save floating point registers starting with high order word */
2477   PROC_FREG_MASK (proc_desc) =
2478     MIPS_FPU_TYPE == MIPS_FPU_DOUBLE ? FLOAT_REG_SAVE_MASK
2479     : MIPS_FPU_TYPE == MIPS_FPU_SINGLE ? FLOAT_SINGLE_REG_SAVE_MASK : 0;
2480   /* PROC_FREG_OFFSET is the offset of the first saved *double* register
2481      from FP.  */
2482   PROC_FREG_OFFSET (proc_desc) = sp - old_sp - 8;
2483   for (ireg = 32; --ireg >= 0;)
2484     if (PROC_FREG_MASK (proc_desc) & (1 << ireg))
2485       mips_push_register (&sp, ireg + FP0_REGNUM);
2486
2487   /* Update the frame pointer for the call dummy and the stack pointer.
2488      Set the procedure's starting and ending addresses to point to the
2489      call dummy address at the entry point.  */
2490   write_register (PUSH_FP_REGNUM, old_sp);
2491   write_register (SP_REGNUM, sp);
2492   PROC_LOW_ADDR (proc_desc) = CALL_DUMMY_ADDRESS ();
2493   PROC_HIGH_ADDR (proc_desc) = CALL_DUMMY_ADDRESS () + 4;
2494   SET_PROC_DESC_IS_DUMMY (proc_desc);
2495   PROC_PC_REG (proc_desc) = RA_REGNUM;
2496 }
2497
2498 void
2499 mips_pop_frame ()
2500 {
2501   register int regnum;
2502   struct frame_info *frame = get_current_frame ();
2503   CORE_ADDR new_sp = FRAME_FP (frame);
2504
2505   mips_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
2506
2507   write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
2508   if (frame->saved_regs == NULL)
2509     mips_find_saved_regs (frame);
2510   for (regnum = 0; regnum < NUM_REGS; regnum++)
2511     {
2512       if (regnum != SP_REGNUM && regnum != PC_REGNUM
2513           && frame->saved_regs[regnum])
2514         write_register (regnum,
2515                         read_memory_integer (frame->saved_regs[regnum],
2516                                              MIPS_SAVED_REGSIZE));
2517     }
2518   write_register (SP_REGNUM, new_sp);
2519   flush_cached_frames ();
2520
2521   if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))
2522     {
2523       struct linked_proc_info *pi_ptr, *prev_ptr;
2524
2525       for (pi_ptr = linked_proc_desc_table, prev_ptr = NULL;
2526            pi_ptr != NULL;
2527            prev_ptr = pi_ptr, pi_ptr = pi_ptr->next)
2528         {
2529           if (&pi_ptr->info == proc_desc)
2530             break;
2531         }
2532
2533       if (pi_ptr == NULL)
2534         error ("Can't locate dummy extra frame info\n");
2535
2536       if (prev_ptr != NULL)
2537         prev_ptr->next = pi_ptr->next;
2538       else
2539         linked_proc_desc_table = pi_ptr->next;
2540
2541       free (pi_ptr);
2542
2543       write_register (HI_REGNUM,
2544                       read_memory_integer (new_sp - 2 * MIPS_SAVED_REGSIZE,
2545                                            MIPS_SAVED_REGSIZE));
2546       write_register (LO_REGNUM,
2547                       read_memory_integer (new_sp - 3 * MIPS_SAVED_REGSIZE,
2548                                            MIPS_SAVED_REGSIZE));
2549       if (MIPS_FPU_TYPE != MIPS_FPU_NONE)
2550         write_register (FCRCS_REGNUM,
2551                         read_memory_integer (new_sp - 4 * MIPS_SAVED_REGSIZE,
2552                                              MIPS_SAVED_REGSIZE));
2553     }
2554 }
2555
2556 static void
2557 mips_print_register (regnum, all)
2558      int regnum, all;
2559 {
2560   char raw_buffer[MAX_REGISTER_RAW_SIZE];
2561
2562   /* Get the data in raw format.  */
2563   if (read_relative_register_raw_bytes (regnum, raw_buffer))
2564     {
2565       printf_filtered ("%s: [Invalid]", REGISTER_NAME (regnum));
2566       return;
2567     }
2568
2569   /* If an even floating point register, also print as double. */
2570   if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT
2571       && !((regnum - FP0_REGNUM) & 1))
2572     if (REGISTER_RAW_SIZE (regnum) == 4)        /* this would be silly on MIPS64 or N32 (Irix 6) */
2573       {
2574         char dbuffer[2 * MAX_REGISTER_RAW_SIZE];
2575
2576         read_relative_register_raw_bytes (regnum, dbuffer);
2577         read_relative_register_raw_bytes (regnum + 1, dbuffer + MIPS_REGSIZE);
2578         REGISTER_CONVERT_TO_TYPE (regnum, builtin_type_double, dbuffer);
2579
2580         printf_filtered ("(d%d: ", regnum - FP0_REGNUM);
2581         val_print (builtin_type_double, dbuffer, 0, 0,
2582                    gdb_stdout, 0, 1, 0, Val_pretty_default);
2583         printf_filtered ("); ");
2584       }
2585   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
2586
2587   /* The problem with printing numeric register names (r26, etc.) is that
2588      the user can't use them on input.  Probably the best solution is to
2589      fix it so that either the numeric or the funky (a2, etc.) names
2590      are accepted on input.  */
2591   if (regnum < MIPS_NUMREGS)
2592     printf_filtered ("(r%d): ", regnum);
2593   else
2594     printf_filtered (": ");
2595
2596   /* If virtual format is floating, print it that way.  */
2597   if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
2598     if (FP_REGISTER_DOUBLE)
2599       {                         /* show 8-byte floats as float AND double: */
2600         int offset = 4 * (TARGET_BYTE_ORDER == BIG_ENDIAN);
2601
2602         printf_filtered (" (float) ");
2603         val_print (builtin_type_float, raw_buffer + offset, 0, 0,
2604                    gdb_stdout, 0, 1, 0, Val_pretty_default);
2605         printf_filtered (", (double) ");
2606         val_print (builtin_type_double, raw_buffer, 0, 0,
2607                    gdb_stdout, 0, 1, 0, Val_pretty_default);
2608       }
2609     else
2610       val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
2611                  gdb_stdout, 0, 1, 0, Val_pretty_default);
2612   /* Else print as integer in hex.  */
2613   else
2614     {
2615       int offset;
2616
2617       if (TARGET_BYTE_ORDER == BIG_ENDIAN)
2618         offset = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
2619       else
2620         offset = 0;
2621
2622       print_scalar_formatted (raw_buffer + offset,
2623                               REGISTER_VIRTUAL_TYPE (regnum),
2624                               'x', 0, gdb_stdout);
2625     }
2626 }
2627
2628 /* Replacement for generic do_registers_info.
2629    Print regs in pretty columns.  */
2630
2631 static int
2632 do_fp_register_row (regnum)
2633      int regnum;
2634 {                               /* do values for FP (float) regs */
2635   char *raw_buffer[2];
2636   char *dbl_buffer;
2637   /* use HI and LO to control the order of combining two flt regs */
2638   int HI = (TARGET_BYTE_ORDER == BIG_ENDIAN);
2639   int LO = (TARGET_BYTE_ORDER != BIG_ENDIAN);
2640   double doub, flt1, flt2;      /* doubles extracted from raw hex data */
2641   int inv1, inv2, inv3;
2642
2643   raw_buffer[0] = (char *) alloca (REGISTER_RAW_SIZE (FP0_REGNUM));
2644   raw_buffer[1] = (char *) alloca (REGISTER_RAW_SIZE (FP0_REGNUM));
2645   dbl_buffer = (char *) alloca (2 * REGISTER_RAW_SIZE (FP0_REGNUM));
2646
2647   /* Get the data in raw format.  */
2648   if (read_relative_register_raw_bytes (regnum, raw_buffer[HI]))
2649     error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
2650   if (REGISTER_RAW_SIZE (regnum) == 4)
2651     {
2652       /* 4-byte registers: we can fit two registers per row. */
2653       /* Also print every pair of 4-byte regs as an 8-byte double. */
2654       if (read_relative_register_raw_bytes (regnum + 1, raw_buffer[LO]))
2655         error ("can't read register %d (%s)",
2656                regnum + 1, REGISTER_NAME (regnum + 1));
2657
2658       /* copy the two floats into one double, and unpack both */
2659       memcpy (dbl_buffer, raw_buffer, 2 * REGISTER_RAW_SIZE (FP0_REGNUM));
2660       flt1 = unpack_double (builtin_type_float, raw_buffer[HI], &inv1);
2661       flt2 = unpack_double (builtin_type_float, raw_buffer[LO], &inv2);
2662       doub = unpack_double (builtin_type_double, dbl_buffer, &inv3);
2663
2664       printf_filtered (inv1 ? " %-5s: <invalid float>" :
2665                        " %-5s%-17.9g", REGISTER_NAME (regnum), flt1);
2666       printf_filtered (inv2 ? " %-5s: <invalid float>" :
2667                        " %-5s%-17.9g", REGISTER_NAME (regnum + 1), flt2);
2668       printf_filtered (inv3 ? " dbl: <invalid double>\n" :
2669                        " dbl: %-24.17g\n", doub);
2670       /* may want to do hex display here (future enhancement) */
2671       regnum += 2;
2672     }
2673   else
2674     {                           /* eight byte registers: print each one as float AND as double. */
2675       int offset = 4 * (TARGET_BYTE_ORDER == BIG_ENDIAN);
2676
2677       memcpy (dbl_buffer, raw_buffer[HI], 2 * REGISTER_RAW_SIZE (FP0_REGNUM));
2678       flt1 = unpack_double (builtin_type_float,
2679                             &raw_buffer[HI][offset], &inv1);
2680       doub = unpack_double (builtin_type_double, dbl_buffer, &inv3);
2681
2682       printf_filtered (inv1 ? " %-5s: <invalid float>" :
2683                        " %-5s flt: %-17.9g", REGISTER_NAME (regnum), flt1);
2684       printf_filtered (inv3 ? " dbl: <invalid double>\n" :
2685                        " dbl: %-24.17g\n", doub);
2686       /* may want to do hex display here (future enhancement) */
2687       regnum++;
2688     }
2689   return regnum;
2690 }
2691
2692 /* Print a row's worth of GP (int) registers, with name labels above */
2693
2694 static int
2695 do_gp_register_row (regnum)
2696      int regnum;
2697 {
2698   /* do values for GP (int) regs */
2699   char raw_buffer[MAX_REGISTER_RAW_SIZE];
2700   int ncols = (MIPS_REGSIZE == 8 ? 4 : 8);      /* display cols per row */
2701   int col, byte;
2702   int start_regnum = regnum;
2703   int numregs = NUM_REGS;
2704
2705
2706   /* For GP registers, we print a separate row of names above the vals */
2707   printf_filtered ("     ");
2708   for (col = 0; col < ncols && regnum < numregs; regnum++)
2709     {
2710       if (*REGISTER_NAME (regnum) == '\0')
2711         continue;               /* unused register */
2712       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
2713         break;                  /* end the row: reached FP register */
2714       printf_filtered (MIPS_REGSIZE == 8 ? "%17s" : "%9s",
2715                        REGISTER_NAME (regnum));
2716       col++;
2717     }
2718   printf_filtered (start_regnum < MIPS_NUMREGS ? "\n R%-4d" : "\n      ",
2719                    start_regnum);       /* print the R0 to R31 names */
2720
2721   regnum = start_regnum;        /* go back to start of row */
2722   /* now print the values in hex, 4 or 8 to the row */
2723   for (col = 0; col < ncols && regnum < numregs; regnum++)
2724     {
2725       if (*REGISTER_NAME (regnum) == '\0')
2726         continue;               /* unused register */
2727       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
2728         break;                  /* end row: reached FP register */
2729       /* OK: get the data in raw format.  */
2730       if (read_relative_register_raw_bytes (regnum, raw_buffer))
2731         error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
2732       /* pad small registers */
2733       for (byte = 0; byte < (MIPS_REGSIZE - REGISTER_VIRTUAL_SIZE (regnum)); byte++)
2734         printf_filtered ("  ");
2735       /* Now print the register value in hex, endian order. */
2736       if (TARGET_BYTE_ORDER == BIG_ENDIAN)
2737         for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
2738              byte < REGISTER_RAW_SIZE (regnum);
2739              byte++)
2740           printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
2741       else
2742         for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
2743              byte >= 0;
2744              byte--)
2745           printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
2746       printf_filtered (" ");
2747       col++;
2748     }
2749   if (col > 0)                  /* ie. if we actually printed anything... */
2750     printf_filtered ("\n");
2751
2752   return regnum;
2753 }
2754
2755 /* MIPS_DO_REGISTERS_INFO(): called by "info register" command */
2756
2757 void
2758 mips_do_registers_info (regnum, fpregs)
2759      int regnum;
2760      int fpregs;
2761 {
2762   if (regnum != -1)             /* do one specified register */
2763     {
2764       if (*(REGISTER_NAME (regnum)) == '\0')
2765         error ("Not a valid register for the current processor type");
2766
2767       mips_print_register (regnum, 0);
2768       printf_filtered ("\n");
2769     }
2770   else
2771     /* do all (or most) registers */
2772     {
2773       regnum = 0;
2774       while (regnum < NUM_REGS)
2775         {
2776           if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
2777             if (fpregs)         /* true for "INFO ALL-REGISTERS" command */
2778               regnum = do_fp_register_row (regnum);     /* FP regs */
2779             else
2780               regnum += MIPS_NUMREGS;   /* skip floating point regs */
2781           else
2782             regnum = do_gp_register_row (regnum);       /* GP (int) regs */
2783         }
2784     }
2785 }
2786
2787 /* Return number of args passed to a frame. described by FIP.
2788    Can return -1, meaning no way to tell.  */
2789
2790 int
2791 mips_frame_num_args (frame)
2792      struct frame_info *frame;
2793 {
2794 #if 0                           /* FIXME Use or lose this! */
2795   struct chain_info_t *p;
2796
2797   p = mips_find_cached_frame (FRAME_FP (frame));
2798   if (p->valid)
2799     return p->the_info.numargs;
2800 #endif
2801   return -1;
2802 }
2803
2804 /* Is this a branch with a delay slot?  */
2805
2806 static int is_delayed (unsigned long);
2807
2808 static int
2809 is_delayed (insn)
2810      unsigned long insn;
2811 {
2812   int i;
2813   for (i = 0; i < NUMOPCODES; ++i)
2814     if (mips_opcodes[i].pinfo != INSN_MACRO
2815         && (insn & mips_opcodes[i].mask) == mips_opcodes[i].match)
2816       break;
2817   return (i < NUMOPCODES
2818           && (mips_opcodes[i].pinfo & (INSN_UNCOND_BRANCH_DELAY
2819                                        | INSN_COND_BRANCH_DELAY
2820                                        | INSN_COND_BRANCH_LIKELY)));
2821 }
2822
2823 int
2824 mips_step_skips_delay (pc)
2825      CORE_ADDR pc;
2826 {
2827   char buf[MIPS_INSTLEN];
2828
2829   /* There is no branch delay slot on MIPS16.  */
2830   if (pc_is_mips16 (pc))
2831     return 0;
2832
2833   if (target_read_memory (pc, buf, MIPS_INSTLEN) != 0)
2834     /* If error reading memory, guess that it is not a delayed branch.  */
2835     return 0;
2836   return is_delayed ((unsigned long) extract_unsigned_integer (buf, MIPS_INSTLEN));
2837 }
2838
2839
2840 /* Skip the PC past function prologue instructions (32-bit version).
2841    This is a helper function for mips_skip_prologue.  */
2842
2843 static CORE_ADDR
2844 mips32_skip_prologue (pc, lenient)
2845      CORE_ADDR pc;              /* starting PC to search from */
2846      int lenient;
2847 {
2848   t_inst inst;
2849   CORE_ADDR end_pc;
2850   int seen_sp_adjust = 0;
2851   int load_immediate_bytes = 0;
2852
2853   /* Skip the typical prologue instructions. These are the stack adjustment
2854      instruction and the instructions that save registers on the stack
2855      or in the gcc frame.  */
2856   for (end_pc = pc + 100; pc < end_pc; pc += MIPS_INSTLEN)
2857     {
2858       unsigned long high_word;
2859
2860       inst = mips_fetch_instruction (pc);
2861       high_word = (inst >> 16) & 0xffff;
2862
2863 #if 0
2864       if (lenient && is_delayed (inst))
2865         continue;
2866 #endif
2867
2868       if (high_word == 0x27bd   /* addiu $sp,$sp,offset */
2869           || high_word == 0x67bd)       /* daddiu $sp,$sp,offset */
2870         seen_sp_adjust = 1;
2871       else if (inst == 0x03a1e823 ||    /* subu $sp,$sp,$at */
2872                inst == 0x03a8e823)      /* subu $sp,$sp,$t0 */
2873         seen_sp_adjust = 1;
2874       else if (((inst & 0xFFE00000) == 0xAFA00000       /* sw reg,n($sp) */
2875                 || (inst & 0xFFE00000) == 0xFFA00000)   /* sd reg,n($sp) */
2876                && (inst & 0x001F0000))  /* reg != $zero */
2877         continue;
2878
2879       else if ((inst & 0xFFE00000) == 0xE7A00000)       /* swc1 freg,n($sp) */
2880         continue;
2881       else if ((inst & 0xF3E00000) == 0xA3C00000 && (inst & 0x001F0000))
2882         /* sx reg,n($s8) */
2883         continue;               /* reg != $zero */
2884
2885       /* move $s8,$sp.  With different versions of gas this will be either
2886          `addu $s8,$sp,$zero' or `or $s8,$sp,$zero' or `daddu s8,sp,$0'.
2887          Accept any one of these.  */
2888       else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
2889         continue;
2890
2891       else if ((inst & 0xFF9F07FF) == 0x00800021)       /* move reg,$a0-$a3 */
2892         continue;
2893       else if (high_word == 0x3c1c)     /* lui $gp,n */
2894         continue;
2895       else if (high_word == 0x279c)     /* addiu $gp,$gp,n */
2896         continue;
2897       else if (inst == 0x0399e021       /* addu $gp,$gp,$t9 */
2898                || inst == 0x033ce021)   /* addu $gp,$t9,$gp */
2899         continue;
2900       /* The following instructions load $at or $t0 with an immediate
2901          value in preparation for a stack adjustment via
2902          subu $sp,$sp,[$at,$t0]. These instructions could also initialize
2903          a local variable, so we accept them only before a stack adjustment
2904          instruction was seen.  */
2905       else if (!seen_sp_adjust)
2906         {
2907           if (high_word == 0x3c01 ||    /* lui $at,n */
2908               high_word == 0x3c08)      /* lui $t0,n */
2909             {
2910               load_immediate_bytes += MIPS_INSTLEN;     /* FIXME!! */
2911               continue;
2912             }
2913           else if (high_word == 0x3421 ||       /* ori $at,$at,n */
2914                    high_word == 0x3508 ||       /* ori $t0,$t0,n */
2915                    high_word == 0x3401 ||       /* ori $at,$zero,n */
2916                    high_word == 0x3408)         /* ori $t0,$zero,n */
2917             {
2918               load_immediate_bytes += MIPS_INSTLEN;     /* FIXME!! */
2919               continue;
2920             }
2921           else
2922             break;
2923         }
2924       else
2925         break;
2926     }
2927
2928   /* In a frameless function, we might have incorrectly
2929      skipped some load immediate instructions. Undo the skipping
2930      if the load immediate was not followed by a stack adjustment.  */
2931   if (load_immediate_bytes && !seen_sp_adjust)
2932     pc -= load_immediate_bytes;
2933   return pc;
2934 }
2935
2936 /* Skip the PC past function prologue instructions (16-bit version).
2937    This is a helper function for mips_skip_prologue.  */
2938
2939 static CORE_ADDR
2940 mips16_skip_prologue (pc, lenient)
2941      CORE_ADDR pc;              /* starting PC to search from */
2942      int lenient;
2943 {
2944   CORE_ADDR end_pc;
2945   int extend_bytes = 0;
2946   int prev_extend_bytes;
2947
2948   /* Table of instructions likely to be found in a function prologue.  */
2949   static struct
2950     {
2951       unsigned short inst;
2952       unsigned short mask;
2953     }
2954   table[] =
2955   {
2956     {
2957       0x6300, 0xff00
2958     }
2959     ,                           /* addiu $sp,offset */
2960     {
2961       0xfb00, 0xff00
2962     }
2963     ,                           /* daddiu $sp,offset */
2964     {
2965       0xd000, 0xf800
2966     }
2967     ,                           /* sw reg,n($sp) */
2968     {
2969       0xf900, 0xff00
2970     }
2971     ,                           /* sd reg,n($sp) */
2972     {
2973       0x6200, 0xff00
2974     }
2975     ,                           /* sw $ra,n($sp) */
2976     {
2977       0xfa00, 0xff00
2978     }
2979     ,                           /* sd $ra,n($sp) */
2980     {
2981       0x673d, 0xffff
2982     }
2983     ,                           /* move $s1,sp */
2984     {
2985       0xd980, 0xff80
2986     }
2987     ,                           /* sw $a0-$a3,n($s1) */
2988     {
2989       0x6704, 0xff1c
2990     }
2991     ,                           /* move reg,$a0-$a3 */
2992     {
2993       0xe809, 0xf81f
2994     }
2995     ,                           /* entry pseudo-op */
2996     {
2997       0x0100, 0xff00
2998     }
2999     ,                           /* addiu $s1,$sp,n */
3000     {
3001       0, 0
3002     }                           /* end of table marker */
3003   };
3004
3005   /* Skip the typical prologue instructions. These are the stack adjustment
3006      instruction and the instructions that save registers on the stack
3007      or in the gcc frame.  */
3008   for (end_pc = pc + 100; pc < end_pc; pc += MIPS16_INSTLEN)
3009     {
3010       unsigned short inst;
3011       int i;
3012
3013       inst = mips_fetch_instruction (pc);
3014
3015       /* Normally we ignore an extend instruction.  However, if it is
3016          not followed by a valid prologue instruction, we must adjust
3017          the pc back over the extend so that it won't be considered
3018          part of the prologue.  */
3019       if ((inst & 0xf800) == 0xf000)    /* extend */
3020         {
3021           extend_bytes = MIPS16_INSTLEN;
3022           continue;
3023         }
3024       prev_extend_bytes = extend_bytes;
3025       extend_bytes = 0;
3026
3027       /* Check for other valid prologue instructions besides extend.  */
3028       for (i = 0; table[i].mask != 0; i++)
3029         if ((inst & table[i].mask) == table[i].inst)    /* found, get out */
3030           break;
3031       if (table[i].mask != 0)   /* it was in table? */
3032         continue;               /* ignore it */
3033       else
3034         /* non-prologue */
3035         {
3036           /* Return the current pc, adjusted backwards by 2 if
3037              the previous instruction was an extend.  */
3038           return pc - prev_extend_bytes;
3039         }
3040     }
3041   return pc;
3042 }
3043
3044 /* To skip prologues, I use this predicate.  Returns either PC itself
3045    if the code at PC does not look like a function prologue; otherwise
3046    returns an address that (if we're lucky) follows the prologue.  If
3047    LENIENT, then we must skip everything which is involved in setting
3048    up the frame (it's OK to skip more, just so long as we don't skip
3049    anything which might clobber the registers which are being saved.
3050    We must skip more in the case where part of the prologue is in the
3051    delay slot of a non-prologue instruction).  */
3052
3053 CORE_ADDR
3054 mips_skip_prologue (pc, lenient)
3055      CORE_ADDR pc;
3056      int lenient;
3057 {
3058   /* See if we can determine the end of the prologue via the symbol table.
3059      If so, then return either PC, or the PC after the prologue, whichever
3060      is greater.  */
3061
3062   CORE_ADDR post_prologue_pc = after_prologue (pc, NULL);
3063
3064   if (post_prologue_pc != 0)
3065     return max (pc, post_prologue_pc);
3066
3067   /* Can't determine prologue from the symbol table, need to examine
3068      instructions.  */
3069
3070   if (pc_is_mips16 (pc))
3071     return mips16_skip_prologue (pc, lenient);
3072   else
3073     return mips32_skip_prologue (pc, lenient);
3074 }
3075
3076 #if 0
3077 /* The lenient prologue stuff should be superseded by the code in
3078    init_extra_frame_info which looks to see whether the stores mentioned
3079    in the proc_desc have actually taken place.  */
3080
3081 /* Is address PC in the prologue (loosely defined) for function at
3082    STARTADDR?  */
3083
3084 static int
3085 mips_in_lenient_prologue (startaddr, pc)
3086      CORE_ADDR startaddr;
3087      CORE_ADDR pc;
3088 {
3089   CORE_ADDR end_prologue = mips_skip_prologue (startaddr, 1);
3090   return pc >= startaddr && pc < end_prologue;
3091 }
3092 #endif
3093
3094 /* Determine how a return value is stored within the MIPS register
3095    file, given the return type `valtype'. */
3096
3097 struct return_value_word
3098 {
3099   int len;
3100   int reg;
3101   int reg_offset;
3102   int buf_offset;
3103 };
3104
3105 static void return_value_location (struct type *, struct return_value_word *,
3106                                    struct return_value_word *);
3107
3108 static void
3109 return_value_location (valtype, hi, lo)
3110      struct type *valtype;
3111      struct return_value_word *hi;
3112      struct return_value_word *lo;
3113 {
3114   int len = TYPE_LENGTH (valtype);
3115
3116   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
3117       && ((MIPS_FPU_TYPE == MIPS_FPU_DOUBLE && (len == 4 || len == 8))
3118           || (MIPS_FPU_TYPE == MIPS_FPU_SINGLE && len == 4)))
3119     {
3120       if (!FP_REGISTER_DOUBLE && len == 8)
3121         {
3122           /* We need to break a 64bit float in two 32 bit halves and
3123              spread them across a floating-point register pair. */
3124           lo->buf_offset = TARGET_BYTE_ORDER == BIG_ENDIAN ? 4 : 0;
3125           hi->buf_offset = TARGET_BYTE_ORDER == BIG_ENDIAN ? 0 : 4;
3126           lo->reg_offset = ((TARGET_BYTE_ORDER == BIG_ENDIAN
3127                              && REGISTER_RAW_SIZE (FP0_REGNUM) == 8)
3128                             ? 4 : 0);
3129           hi->reg_offset = lo->reg_offset;
3130           lo->reg = FP0_REGNUM + 0;
3131           hi->reg = FP0_REGNUM + 1;
3132           lo->len = 4;
3133           hi->len = 4;
3134         }
3135       else
3136         {
3137           /* The floating point value fits in a single floating-point
3138              register. */
3139           lo->reg_offset = ((TARGET_BYTE_ORDER == BIG_ENDIAN
3140                              && REGISTER_RAW_SIZE (FP0_REGNUM) == 8
3141                              && len == 4)
3142                             ? 4 : 0);
3143           lo->reg = FP0_REGNUM;
3144           lo->len = len;
3145           lo->buf_offset = 0;
3146           hi->len = 0;
3147           hi->reg_offset = 0;
3148           hi->buf_offset = 0;
3149           hi->reg = 0;
3150         }
3151     }
3152   else
3153     {
3154       /* Locate a result possibly spread across two registers. */
3155       int regnum = 2;
3156       lo->reg = regnum + 0;
3157       hi->reg = regnum + 1;
3158       if (TARGET_BYTE_ORDER == BIG_ENDIAN
3159           && len < MIPS_SAVED_REGSIZE)
3160         {
3161           /* "un-left-justify" the value in the low register */
3162           lo->reg_offset = MIPS_SAVED_REGSIZE - len;
3163           lo->len = len;
3164           hi->reg_offset = 0;
3165           hi->len = 0;
3166         }
3167       else if (TARGET_BYTE_ORDER == BIG_ENDIAN
3168                && len > MIPS_SAVED_REGSIZE      /* odd-size structs */
3169                && len < MIPS_SAVED_REGSIZE * 2
3170                && (TYPE_CODE (valtype) == TYPE_CODE_STRUCT ||
3171                    TYPE_CODE (valtype) == TYPE_CODE_UNION))
3172         {
3173           /* "un-left-justify" the value spread across two registers. */
3174           lo->reg_offset = 2 * MIPS_SAVED_REGSIZE - len;
3175           lo->len = MIPS_SAVED_REGSIZE - lo->reg_offset;
3176           hi->reg_offset = 0;
3177           hi->len = len - lo->len;
3178         }
3179       else
3180         {
3181           /* Only perform a partial copy of the second register. */
3182           lo->reg_offset = 0;
3183           hi->reg_offset = 0;
3184           if (len > MIPS_SAVED_REGSIZE)
3185             {
3186               lo->len = MIPS_SAVED_REGSIZE;
3187               hi->len = len - MIPS_SAVED_REGSIZE;
3188             }
3189           else
3190             {
3191               lo->len = len;
3192               hi->len = 0;
3193             }
3194         }
3195       if (TARGET_BYTE_ORDER == BIG_ENDIAN
3196           && REGISTER_RAW_SIZE (regnum) == 8
3197           && MIPS_SAVED_REGSIZE == 4)
3198         {
3199           /* Account for the fact that only the least-signficant part
3200              of the register is being used */
3201           lo->reg_offset += 4;
3202           hi->reg_offset += 4;
3203         }
3204       lo->buf_offset = 0;
3205       hi->buf_offset = lo->len;
3206     }
3207 }
3208
3209 /* Given a return value in `regbuf' with a type `valtype', extract and
3210    copy its value into `valbuf'. */
3211
3212 void
3213 mips_extract_return_value (valtype, regbuf, valbuf)
3214      struct type *valtype;
3215      char regbuf[REGISTER_BYTES];
3216      char *valbuf;
3217 {
3218   struct return_value_word lo;
3219   struct return_value_word hi;
3220   return_value_location (valtype, &lo, &hi);
3221
3222   memcpy (valbuf + lo.buf_offset,
3223           regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
3224           lo.len);
3225
3226   if (hi.len > 0)
3227     memcpy (valbuf + hi.buf_offset,
3228             regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
3229             hi.len);
3230
3231 #if 0
3232   int regnum;
3233   int offset = 0;
3234   int len = TYPE_LENGTH (valtype);
3235
3236   regnum = 2;
3237   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
3238       && (MIPS_FPU_TYPE == MIPS_FPU_DOUBLE
3239           || (MIPS_FPU_TYPE == MIPS_FPU_SINGLE
3240               && len <= MIPS_FPU_SINGLE_REGSIZE)))
3241     regnum = FP0_REGNUM;
3242
3243   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
3244     {                           /* "un-left-justify" the value from the register */
3245       if (len < REGISTER_RAW_SIZE (regnum))
3246         offset = REGISTER_RAW_SIZE (regnum) - len;
3247       if (len > REGISTER_RAW_SIZE (regnum) &&   /* odd-size structs */
3248           len < REGISTER_RAW_SIZE (regnum) * 2 &&
3249           (TYPE_CODE (valtype) == TYPE_CODE_STRUCT ||
3250            TYPE_CODE (valtype) == TYPE_CODE_UNION))
3251         offset = 2 * REGISTER_RAW_SIZE (regnum) - len;
3252     }
3253   memcpy (valbuf, regbuf + REGISTER_BYTE (regnum) + offset, len);
3254   REGISTER_CONVERT_TO_TYPE (regnum, valtype, valbuf);
3255 #endif
3256 }
3257
3258 /* Given a return value in `valbuf' with a type `valtype', write it's
3259    value into the appropriate register. */
3260
3261 void
3262 mips_store_return_value (valtype, valbuf)
3263      struct type *valtype;
3264      char *valbuf;
3265 {
3266   char raw_buffer[MAX_REGISTER_RAW_SIZE];
3267   struct return_value_word lo;
3268   struct return_value_word hi;
3269   return_value_location (valtype, &lo, &hi);
3270
3271   memset (raw_buffer, 0, sizeof (raw_buffer));
3272   memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
3273   write_register_bytes (REGISTER_BYTE (lo.reg),
3274                         raw_buffer,
3275                         REGISTER_RAW_SIZE (lo.reg));
3276
3277   if (hi.len > 0)
3278     {
3279       memset (raw_buffer, 0, sizeof (raw_buffer));
3280       memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
3281       write_register_bytes (REGISTER_BYTE (hi.reg),
3282                             raw_buffer,
3283                             REGISTER_RAW_SIZE (hi.reg));
3284     }
3285
3286 #if 0
3287   int regnum;
3288   int offset = 0;
3289   int len = TYPE_LENGTH (valtype);
3290   char raw_buffer[MAX_REGISTER_RAW_SIZE];
3291
3292   regnum = 2;
3293   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
3294       && (MIPS_FPU_TYPE == MIPS_FPU_DOUBLE
3295           || (MIPS_FPU_TYPE == MIPS_FPU_SINGLE
3296               && len <= MIPS_REGSIZE)))
3297     regnum = FP0_REGNUM;
3298
3299   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
3300     {                           /* "left-justify" the value in the register */
3301       if (len < REGISTER_RAW_SIZE (regnum))
3302         offset = REGISTER_RAW_SIZE (regnum) - len;
3303       if (len > REGISTER_RAW_SIZE (regnum) &&   /* odd-size structs */
3304           len < REGISTER_RAW_SIZE (regnum) * 2 &&
3305           (TYPE_CODE (valtype) == TYPE_CODE_STRUCT ||
3306            TYPE_CODE (valtype) == TYPE_CODE_UNION))
3307         offset = 2 * REGISTER_RAW_SIZE (regnum) - len;
3308     }
3309   memcpy (raw_buffer + offset, valbuf, len);
3310   REGISTER_CONVERT_FROM_TYPE (regnum, valtype, raw_buffer);
3311   write_register_bytes (REGISTER_BYTE (regnum), raw_buffer,
3312                         len > REGISTER_RAW_SIZE (regnum) ?
3313                         len : REGISTER_RAW_SIZE (regnum));
3314 #endif
3315 }
3316
3317 /* Exported procedure: Is PC in the signal trampoline code */
3318
3319 int
3320 in_sigtramp (pc, ignore)
3321      CORE_ADDR pc;
3322      char *ignore;              /* function name */
3323 {
3324   if (sigtramp_address == 0)
3325     fixup_sigtramp ();
3326   return (pc >= sigtramp_address && pc < sigtramp_end);
3327 }
3328
3329 /* Root of all "set mips "/"show mips " commands. This will eventually be
3330    used for all MIPS-specific commands.  */
3331
3332 static void show_mips_command (char *, int);
3333 static void
3334 show_mips_command (args, from_tty)
3335      char *args;
3336      int from_tty;
3337 {
3338   help_list (showmipscmdlist, "show mips ", all_commands, gdb_stdout);
3339 }
3340
3341 static void set_mips_command (char *, int);
3342 static void
3343 set_mips_command (args, from_tty)
3344      char *args;
3345      int from_tty;
3346 {
3347   printf_unfiltered ("\"set mips\" must be followed by an appropriate subcommand.\n");
3348   help_list (setmipscmdlist, "set mips ", all_commands, gdb_stdout);
3349 }
3350
3351 /* Commands to show/set the MIPS FPU type.  */
3352
3353 static void show_mipsfpu_command (char *, int);
3354 static void
3355 show_mipsfpu_command (args, from_tty)
3356      char *args;
3357      int from_tty;
3358 {
3359   char *msg;
3360   char *fpu;
3361   switch (MIPS_FPU_TYPE)
3362     {
3363     case MIPS_FPU_SINGLE:
3364       fpu = "single-precision";
3365       break;
3366     case MIPS_FPU_DOUBLE:
3367       fpu = "double-precision";
3368       break;
3369     case MIPS_FPU_NONE:
3370       fpu = "absent (none)";
3371       break;
3372     }
3373   if (mips_fpu_type_auto)
3374     printf_unfiltered ("The MIPS floating-point coprocessor is set automatically (currently %s)\n",
3375                        fpu);
3376   else
3377     printf_unfiltered ("The MIPS floating-point coprocessor is assumed to be %s\n",
3378                        fpu);
3379 }
3380
3381
3382 static void set_mipsfpu_command (char *, int);
3383 static void
3384 set_mipsfpu_command (args, from_tty)
3385      char *args;
3386      int from_tty;
3387 {
3388   printf_unfiltered ("\"set mipsfpu\" must be followed by \"double\", \"single\",\"none\" or \"auto\".\n");
3389   show_mipsfpu_command (args, from_tty);
3390 }
3391
3392 static void set_mipsfpu_single_command (char *, int);
3393 static void
3394 set_mipsfpu_single_command (args, from_tty)
3395      char *args;
3396      int from_tty;
3397 {
3398   mips_fpu_type = MIPS_FPU_SINGLE;
3399   mips_fpu_type_auto = 0;
3400   if (GDB_MULTI_ARCH)
3401     {
3402       gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_SINGLE;
3403     }
3404 }
3405
3406 static void set_mipsfpu_double_command (char *, int);
3407 static void
3408 set_mipsfpu_double_command (args, from_tty)
3409      char *args;
3410      int from_tty;
3411 {
3412   mips_fpu_type = MIPS_FPU_DOUBLE;
3413   mips_fpu_type_auto = 0;
3414   if (GDB_MULTI_ARCH)
3415     {
3416       gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_DOUBLE;
3417     }
3418 }
3419
3420 static void set_mipsfpu_none_command (char *, int);
3421 static void
3422 set_mipsfpu_none_command (args, from_tty)
3423      char *args;
3424      int from_tty;
3425 {
3426   mips_fpu_type = MIPS_FPU_NONE;
3427   mips_fpu_type_auto = 0;
3428   if (GDB_MULTI_ARCH)
3429     {
3430       gdbarch_tdep (current_gdbarch)->mips_fpu_type = MIPS_FPU_NONE;
3431     }
3432 }
3433
3434 static void set_mipsfpu_auto_command (char *, int);
3435 static void
3436 set_mipsfpu_auto_command (args, from_tty)
3437      char *args;
3438      int from_tty;
3439 {
3440   mips_fpu_type_auto = 1;
3441 }
3442
3443 /* Command to set the processor type.  */
3444
3445 void
3446 mips_set_processor_type_command (args, from_tty)
3447      char *args;
3448      int from_tty;
3449 {
3450   int i;
3451
3452   if (tmp_mips_processor_type == NULL || *tmp_mips_processor_type == '\0')
3453     {
3454       printf_unfiltered ("The known MIPS processor types are as follows:\n\n");
3455       for (i = 0; mips_processor_type_table[i].name != NULL; ++i)
3456         printf_unfiltered ("%s\n", mips_processor_type_table[i].name);
3457
3458       /* Restore the value.  */
3459       tmp_mips_processor_type = strsave (mips_processor_type);
3460
3461       return;
3462     }
3463
3464   if (!mips_set_processor_type (tmp_mips_processor_type))
3465     {
3466       error ("Unknown processor type `%s'.", tmp_mips_processor_type);
3467       /* Restore its value.  */
3468       tmp_mips_processor_type = strsave (mips_processor_type);
3469     }
3470 }
3471
3472 static void
3473 mips_show_processor_type_command (args, from_tty)
3474      char *args;
3475      int from_tty;
3476 {
3477 }
3478
3479 /* Modify the actual processor type. */
3480
3481 int
3482 mips_set_processor_type (str)
3483      char *str;
3484 {
3485   int i, j;
3486
3487   if (str == NULL)
3488     return 0;
3489
3490   for (i = 0; mips_processor_type_table[i].name != NULL; ++i)
3491     {
3492       if (strcasecmp (str, mips_processor_type_table[i].name) == 0)
3493         {
3494           mips_processor_type = str;
3495           mips_processor_reg_names = mips_processor_type_table[i].regnames;
3496           return 1;
3497           /* FIXME tweak fpu flag too */
3498         }
3499     }
3500
3501   return 0;
3502 }
3503
3504 /* Attempt to identify the particular processor model by reading the
3505    processor id.  */
3506
3507 char *
3508 mips_read_processor_type ()
3509 {
3510   CORE_ADDR prid;
3511
3512   prid = read_register (PRID_REGNUM);
3513
3514   if ((prid & ~0xf) == 0x700)
3515     return savestring ("r3041", strlen ("r3041"));
3516
3517   return NULL;
3518 }
3519
3520 /* Just like reinit_frame_cache, but with the right arguments to be
3521    callable as an sfunc.  */
3522
3523 static void
3524 reinit_frame_cache_sfunc (args, from_tty, c)
3525      char *args;
3526      int from_tty;
3527      struct cmd_list_element *c;
3528 {
3529   reinit_frame_cache ();
3530 }
3531
3532 int
3533 gdb_print_insn_mips (memaddr, info)
3534      bfd_vma memaddr;
3535      disassemble_info *info;
3536 {
3537   mips_extra_func_info_t proc_desc;
3538
3539   /* Search for the function containing this address.  Set the low bit
3540      of the address when searching, in case we were given an even address
3541      that is the start of a 16-bit function.  If we didn't do this,
3542      the search would fail because the symbol table says the function
3543      starts at an odd address, i.e. 1 byte past the given address.  */
3544   memaddr = ADDR_BITS_REMOVE (memaddr);
3545   proc_desc = non_heuristic_proc_desc (MAKE_MIPS16_ADDR (memaddr), NULL);
3546
3547   /* Make an attempt to determine if this is a 16-bit function.  If
3548      the procedure descriptor exists and the address therein is odd,
3549      it's definitely a 16-bit function.  Otherwise, we have to just
3550      guess that if the address passed in is odd, it's 16-bits.  */
3551   if (proc_desc)
3552     info->mach = pc_is_mips16 (PROC_LOW_ADDR (proc_desc)) ?
3553       bfd_mach_mips16 : TM_PRINT_INSN_MACH;
3554   else
3555     info->mach = pc_is_mips16 (memaddr) ?
3556       bfd_mach_mips16 : TM_PRINT_INSN_MACH;
3557
3558   /* Round down the instruction address to the appropriate boundary.  */
3559   memaddr &= (info->mach == bfd_mach_mips16 ? ~1 : ~3);
3560
3561   /* Call the appropriate disassembler based on the target endian-ness.  */
3562   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
3563     return print_insn_big_mips (memaddr, info);
3564   else
3565     return print_insn_little_mips (memaddr, info);
3566 }
3567
3568 /* Old-style breakpoint macros.
3569    The IDT board uses an unusual breakpoint value, and sometimes gets
3570    confused when it sees the usual MIPS breakpoint instruction.  */
3571
3572 #define BIG_BREAKPOINT {0, 0x5, 0, 0xd}
3573 #define LITTLE_BREAKPOINT {0xd, 0, 0x5, 0}
3574 #define PMON_BIG_BREAKPOINT {0, 0, 0, 0xd}
3575 #define PMON_LITTLE_BREAKPOINT {0xd, 0, 0, 0}
3576 #define IDT_BIG_BREAKPOINT {0, 0, 0x0a, 0xd}
3577 #define IDT_LITTLE_BREAKPOINT {0xd, 0x0a, 0, 0}
3578 #define MIPS16_BIG_BREAKPOINT {0xe8, 0xa5}
3579 #define MIPS16_LITTLE_BREAKPOINT {0xa5, 0xe8}
3580
3581 /* This function implements the BREAKPOINT_FROM_PC macro.  It uses the program
3582    counter value to determine whether a 16- or 32-bit breakpoint should be
3583    used.  It returns a pointer to a string of bytes that encode a breakpoint
3584    instruction, stores the length of the string to *lenptr, and adjusts pc
3585    (if necessary) to point to the actual memory location where the
3586    breakpoint should be inserted.  */
3587
3588 unsigned char *
3589 mips_breakpoint_from_pc (pcptr, lenptr)
3590      CORE_ADDR *pcptr;
3591      int *lenptr;
3592 {
3593   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
3594     {
3595       if (pc_is_mips16 (*pcptr))
3596         {
3597           static char mips16_big_breakpoint[] = MIPS16_BIG_BREAKPOINT;
3598           *pcptr = UNMAKE_MIPS16_ADDR (*pcptr);
3599           *lenptr = sizeof (mips16_big_breakpoint);
3600           return mips16_big_breakpoint;
3601         }
3602       else
3603         {
3604           static char big_breakpoint[] = BIG_BREAKPOINT;
3605           static char pmon_big_breakpoint[] = PMON_BIG_BREAKPOINT;
3606           static char idt_big_breakpoint[] = IDT_BIG_BREAKPOINT;
3607
3608           *lenptr = sizeof (big_breakpoint);
3609
3610           if (strcmp (target_shortname, "mips") == 0)
3611             return idt_big_breakpoint;
3612           else if (strcmp (target_shortname, "ddb") == 0
3613                    || strcmp (target_shortname, "pmon") == 0
3614                    || strcmp (target_shortname, "lsi") == 0)
3615             return pmon_big_breakpoint;
3616           else
3617             return big_breakpoint;
3618         }
3619     }
3620   else
3621     {
3622       if (pc_is_mips16 (*pcptr))
3623         {
3624           static char mips16_little_breakpoint[] = MIPS16_LITTLE_BREAKPOINT;
3625           *pcptr = UNMAKE_MIPS16_ADDR (*pcptr);
3626           *lenptr = sizeof (mips16_little_breakpoint);
3627           return mips16_little_breakpoint;
3628         }
3629       else
3630         {
3631           static char little_breakpoint[] = LITTLE_BREAKPOINT;
3632           static char pmon_little_breakpoint[] = PMON_LITTLE_BREAKPOINT;
3633           static char idt_little_breakpoint[] = IDT_LITTLE_BREAKPOINT;
3634
3635           *lenptr = sizeof (little_breakpoint);
3636
3637           if (strcmp (target_shortname, "mips") == 0)
3638             return idt_little_breakpoint;
3639           else if (strcmp (target_shortname, "ddb") == 0
3640                    || strcmp (target_shortname, "pmon") == 0
3641                    || strcmp (target_shortname, "lsi") == 0)
3642             return pmon_little_breakpoint;
3643           else
3644             return little_breakpoint;
3645         }
3646     }
3647 }
3648
3649 /* If PC is in a mips16 call or return stub, return the address of the target
3650    PC, which is either the callee or the caller.  There are several
3651    cases which must be handled:
3652
3653    * If the PC is in __mips16_ret_{d,s}f, this is a return stub and the
3654    target PC is in $31 ($ra).
3655    * If the PC is in __mips16_call_stub_{1..10}, this is a call stub
3656    and the target PC is in $2.
3657    * If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
3658    before the jal instruction, this is effectively a call stub
3659    and the the target PC is in $2.  Otherwise this is effectively
3660    a return stub and the target PC is in $18.
3661
3662    See the source code for the stubs in gcc/config/mips/mips16.S for
3663    gory details.
3664
3665    This function implements the SKIP_TRAMPOLINE_CODE macro.
3666  */
3667
3668 CORE_ADDR
3669 mips_skip_stub (pc)
3670      CORE_ADDR pc;
3671 {
3672   char *name;
3673   CORE_ADDR start_addr;
3674
3675   /* Find the starting address and name of the function containing the PC.  */
3676   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
3677     return 0;
3678
3679   /* If the PC is in __mips16_ret_{d,s}f, this is a return stub and the
3680      target PC is in $31 ($ra).  */
3681   if (strcmp (name, "__mips16_ret_sf") == 0
3682       || strcmp (name, "__mips16_ret_df") == 0)
3683     return read_register (RA_REGNUM);
3684
3685   if (strncmp (name, "__mips16_call_stub_", 19) == 0)
3686     {
3687       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub
3688          and the target PC is in $2.  */
3689       if (name[19] >= '0' && name[19] <= '9')
3690         return read_register (2);
3691
3692       /* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
3693          before the jal instruction, this is effectively a call stub
3694          and the the target PC is in $2.  Otherwise this is effectively
3695          a return stub and the target PC is in $18.  */
3696       else if (name[19] == 's' || name[19] == 'd')
3697         {
3698           if (pc == start_addr)
3699             {
3700               /* Check if the target of the stub is a compiler-generated
3701                  stub.  Such a stub for a function bar might have a name
3702                  like __fn_stub_bar, and might look like this:
3703                  mfc1    $4,$f13
3704                  mfc1    $5,$f12
3705                  mfc1    $6,$f15
3706                  mfc1    $7,$f14
3707                  la      $1,bar   (becomes a lui/addiu pair)
3708                  jr      $1
3709                  So scan down to the lui/addi and extract the target
3710                  address from those two instructions.  */
3711
3712               CORE_ADDR target_pc = read_register (2);
3713               t_inst inst;
3714               int i;
3715
3716               /* See if the name of the target function is  __fn_stub_*.  */
3717               if (find_pc_partial_function (target_pc, &name, NULL, NULL) == 0)
3718                 return target_pc;
3719               if (strncmp (name, "__fn_stub_", 10) != 0
3720                   && strcmp (name, "etext") != 0
3721                   && strcmp (name, "_etext") != 0)
3722                 return target_pc;
3723
3724               /* Scan through this _fn_stub_ code for the lui/addiu pair.
3725                  The limit on the search is arbitrarily set to 20
3726                  instructions.  FIXME.  */
3727               for (i = 0, pc = 0; i < 20; i++, target_pc += MIPS_INSTLEN)
3728                 {
3729                   inst = mips_fetch_instruction (target_pc);
3730                   if ((inst & 0xffff0000) == 0x3c010000)        /* lui $at */
3731                     pc = (inst << 16) & 0xffff0000;     /* high word */
3732                   else if ((inst & 0xffff0000) == 0x24210000)   /* addiu $at */
3733                     return pc | (inst & 0xffff);        /* low word */
3734                 }
3735
3736               /* Couldn't find the lui/addui pair, so return stub address.  */
3737               return target_pc;
3738             }
3739           else
3740             /* This is the 'return' part of a call stub.  The return
3741                address is in $r18.  */
3742             return read_register (18);
3743         }
3744     }
3745   return 0;                     /* not a stub */
3746 }
3747
3748
3749 /* Return non-zero if the PC is inside a call thunk (aka stub or trampoline).
3750    This implements the IN_SOLIB_CALL_TRAMPOLINE macro.  */
3751
3752 int
3753 mips_in_call_stub (pc, name)
3754      CORE_ADDR pc;
3755      char *name;
3756 {
3757   CORE_ADDR start_addr;
3758
3759   /* Find the starting address of the function containing the PC.  If the
3760      caller didn't give us a name, look it up at the same time.  */
3761   if (find_pc_partial_function (pc, name ? NULL : &name, &start_addr, NULL) == 0)
3762     return 0;
3763
3764   if (strncmp (name, "__mips16_call_stub_", 19) == 0)
3765     {
3766       /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub.  */
3767       if (name[19] >= '0' && name[19] <= '9')
3768         return 1;
3769       /* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
3770          before the jal instruction, this is effectively a call stub.  */
3771       else if (name[19] == 's' || name[19] == 'd')
3772         return pc == start_addr;
3773     }
3774
3775   return 0;                     /* not a stub */
3776 }
3777
3778
3779 /* Return non-zero if the PC is inside a return thunk (aka stub or trampoline).
3780    This implements the IN_SOLIB_RETURN_TRAMPOLINE macro.  */
3781
3782 int
3783 mips_in_return_stub (pc, name)
3784      CORE_ADDR pc;
3785      char *name;
3786 {
3787   CORE_ADDR start_addr;
3788
3789   /* Find the starting address of the function containing the PC.  */
3790   if (find_pc_partial_function (pc, NULL, &start_addr, NULL) == 0)
3791     return 0;
3792
3793   /* If the PC is in __mips16_ret_{d,s}f, this is a return stub.  */
3794   if (strcmp (name, "__mips16_ret_sf") == 0
3795       || strcmp (name, "__mips16_ret_df") == 0)
3796     return 1;
3797
3798   /* If the PC is in __mips16_call_stub_{s,d}f_{0..10} but not at the start,
3799      i.e. after the jal instruction, this is effectively a return stub.  */
3800   if (strncmp (name, "__mips16_call_stub_", 19) == 0
3801       && (name[19] == 's' || name[19] == 'd')
3802       && pc != start_addr)
3803     return 1;
3804
3805   return 0;                     /* not a stub */
3806 }
3807
3808
3809 /* Return non-zero if the PC is in a library helper function that should
3810    be ignored.  This implements the IGNORE_HELPER_CALL macro.  */
3811
3812 int
3813 mips_ignore_helper (pc)
3814      CORE_ADDR pc;
3815 {
3816   char *name;
3817
3818   /* Find the starting address and name of the function containing the PC.  */
3819   if (find_pc_partial_function (pc, &name, NULL, NULL) == 0)
3820     return 0;
3821
3822   /* If the PC is in __mips16_ret_{d,s}f, this is a library helper function
3823      that we want to ignore.  */
3824   return (strcmp (name, "__mips16_ret_sf") == 0
3825           || strcmp (name, "__mips16_ret_df") == 0);
3826 }
3827
3828
3829 /* Return a location where we can set a breakpoint that will be hit
3830    when an inferior function call returns.  This is normally the
3831    program's entry point.  Executables that don't have an entry
3832    point (e.g. programs in ROM) should define a symbol __CALL_DUMMY_ADDRESS
3833    whose address is the location where the breakpoint should be placed.  */
3834
3835 CORE_ADDR
3836 mips_call_dummy_address ()
3837 {
3838   struct minimal_symbol *sym;
3839
3840   sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
3841   if (sym)
3842     return SYMBOL_VALUE_ADDRESS (sym);
3843   else
3844     return entry_point_address ();
3845 }
3846
3847
3848 /* If the current gcc for for this target does not produce correct debugging
3849    information for float parameters, both prototyped and unprototyped, then
3850    define this macro.  This forces gdb to  always assume that floats are
3851    passed as doubles and then converted in the callee.
3852
3853    For the mips chip, it appears that the debug info marks the parameters as
3854    floats regardless of whether the function is prototyped, but the actual
3855    values are passed as doubles for the non-prototyped case and floats for
3856    the prototyped case.  Thus we choose to make the non-prototyped case work
3857    for C and break the prototyped case, since the non-prototyped case is
3858    probably much more common.  (FIXME). */
3859
3860 static int
3861 mips_coerce_float_to_double (struct type *formal, struct type *actual)
3862 {
3863   return current_language->la_language == language_c;
3864 }
3865
3866 /* When debugging a 64 MIPS target running a 32 bit ABI, the size of
3867    the register stored on the stack (32) is different to its real raw
3868    size (64).  The below ensures that registers are fetched from the
3869    stack using their ABI size and then stored into the RAW_BUFFER
3870    using their raw size.
3871
3872    The alternative to adding this function would be to add an ABI
3873    macro - REGISTER_STACK_SIZE(). */
3874
3875 static void
3876 mips_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
3877      char *raw_buffer;
3878      int *optimized;
3879      CORE_ADDR *addrp;
3880      struct frame_info *frame;
3881      int regnum;
3882      enum lval_type *lval;
3883 {
3884   CORE_ADDR addr;
3885
3886   if (!target_has_registers)
3887     error ("No registers.");
3888
3889   /* Normal systems don't optimize out things with register numbers.  */
3890   if (optimized != NULL)
3891     *optimized = 0;
3892   addr = find_saved_register (frame, regnum);
3893   if (addr != 0)
3894     {
3895       if (lval != NULL)
3896         *lval = lval_memory;
3897       if (regnum == SP_REGNUM)
3898         {
3899           if (raw_buffer != NULL)
3900             {
3901               /* Put it back in target format.  */
3902               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
3903                              (LONGEST) addr);
3904             }
3905           if (addrp != NULL)
3906             *addrp = 0;
3907           return;
3908         }
3909       if (raw_buffer != NULL)
3910         {
3911           LONGEST val;
3912           if (regnum < 32)
3913             /* Only MIPS_SAVED_REGSIZE bytes of GP registers are
3914                saved. */
3915             val = read_memory_integer (addr, MIPS_SAVED_REGSIZE);
3916           else
3917             val = read_memory_integer (addr, REGISTER_RAW_SIZE (regnum));
3918           store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), val);
3919         }
3920     }
3921   else
3922     {
3923       if (lval != NULL)
3924         *lval = lval_register;
3925       addr = REGISTER_BYTE (regnum);
3926       if (raw_buffer != NULL)
3927         read_register_gen (regnum, raw_buffer);
3928     }
3929   if (addrp != NULL)
3930     *addrp = addr;
3931 }
3932
3933 static gdbarch_init_ftype mips_gdbarch_init;
3934 static struct gdbarch *
3935 mips_gdbarch_init (info, arches)
3936      struct gdbarch_info info;
3937      struct gdbarch_list *arches;
3938 {
3939   static LONGEST mips_call_dummy_words[] =
3940   {0};
3941   struct gdbarch *gdbarch;
3942   struct gdbarch_tdep *tdep;
3943   int elf_flags;
3944 #if 0
3945   int ef_mips_bitptrs;
3946 #endif
3947 #if 0
3948   int ef_mips_arch;
3949 #endif
3950   enum mips_abi mips_abi;
3951
3952   /* Extract the elf_flags if available */
3953   if (info.abfd != NULL
3954       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
3955     elf_flags = elf_elfheader (info.abfd)->e_flags;
3956   else
3957     elf_flags = 0;
3958
3959   /* Check ELF_FLAGS to see if it specifies the ABI being used. */
3960   switch ((elf_flags & EF_MIPS_ABI))
3961     {
3962     case E_MIPS_ABI_O32:
3963       mips_abi = MIPS_ABI_O32;
3964       break;
3965     case E_MIPS_ABI_O64:
3966       mips_abi = MIPS_ABI_O64;
3967       break;
3968     case E_MIPS_ABI_EABI32:
3969       mips_abi = MIPS_ABI_EABI32;
3970       break;
3971     case E_MIPS_ABI_EABI64:
3972       mips_abi = MIPS_ABI_EABI64;
3973       break;
3974     default:
3975       mips_abi = MIPS_ABI_UNKNOWN;
3976       break;
3977     }
3978   /* Try the architecture for any hint of the corect ABI */
3979   if (mips_abi == MIPS_ABI_UNKNOWN
3980       && info.bfd_arch_info != NULL
3981       && info.bfd_arch_info->arch == bfd_arch_mips)
3982     {
3983       switch (info.bfd_arch_info->mach)
3984         {
3985         case bfd_mach_mips3900:
3986           mips_abi = MIPS_ABI_EABI32;
3987           break;
3988         case bfd_mach_mips4100:
3989         case bfd_mach_mips5000:
3990           mips_abi = MIPS_ABI_EABI64;
3991           break;
3992         }
3993     }
3994 #ifdef MIPS_DEFAULT_ABI
3995   if (mips_abi == MIPS_ABI_UNKNOWN)
3996     mips_abi = MIPS_DEFAULT_ABI;
3997 #endif
3998
3999   if (gdbarch_debug)
4000     {
4001       fprintf_unfiltered (gdb_stdlog,
4002                           "mips_gdbarch_init: elf_flags = 0x%08x\n",
4003                           elf_flags);
4004 #if 0
4005       fprintf_unfiltered (gdb_stdlog,
4006                           "mips_gdbarch_init: ef_mips_arch = %d\n",
4007                           ef_mips_arch);
4008 #endif
4009 #if 0
4010       fprintf_unfiltered (gdb_stdlog,
4011                           "mips_gdbarch_init: ef_mips_bitptrs = %d\n",
4012                           ef_mips_bitptrs);
4013 #endif
4014       fprintf_unfiltered (gdb_stdlog,
4015                           "mips_gdbarch_init: mips_abi = %d\n",
4016                           mips_abi);
4017     }
4018
4019   /* try to find a pre-existing architecture */
4020   for (arches = gdbarch_list_lookup_by_info (arches, &info);
4021        arches != NULL;
4022        arches = gdbarch_list_lookup_by_info (arches->next, &info))
4023     {
4024       /* MIPS needs to be pedantic about which ABI the object is
4025          using. */
4026       if (gdbarch_tdep (current_gdbarch)->elf_flags != elf_flags)
4027         continue;
4028       if (gdbarch_tdep (current_gdbarch)->mips_abi != mips_abi)
4029         continue;
4030       return arches->gdbarch;
4031     }
4032
4033   /* Need a new architecture. Fill in a target specific vector. */
4034   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
4035   gdbarch = gdbarch_alloc (&info, tdep);
4036   tdep->elf_flags = elf_flags;
4037
4038   /* Initially set everything according to the ABI. */
4039   set_gdbarch_short_bit (gdbarch, 16);
4040   set_gdbarch_int_bit (gdbarch, 32);
4041   set_gdbarch_float_bit (gdbarch, 32);
4042   set_gdbarch_double_bit (gdbarch, 64);
4043   set_gdbarch_long_double_bit (gdbarch, 64);
4044   tdep->mips_abi = mips_abi;
4045   switch (mips_abi)
4046     {
4047     case MIPS_ABI_O32:
4048       tdep->mips_default_saved_regsize = 4;
4049       tdep->mips_default_stack_argsize = 4;
4050       tdep->mips_fp_register_double = 0;
4051       tdep->mips_last_arg_regnum = ZERO_REGNUM + 7;
4052       tdep->mips_last_fp_arg_regnum = FP0_REGNUM + 15;
4053       tdep->mips_regs_have_home_p = 1;
4054       tdep->gdb_target_is_mips64 = 0;
4055       set_gdbarch_long_bit (gdbarch, 32);
4056       set_gdbarch_ptr_bit (gdbarch, 32);
4057       set_gdbarch_long_long_bit (gdbarch, 64);
4058       break;
4059     case MIPS_ABI_O64:
4060       tdep->mips_default_saved_regsize = 8;
4061       tdep->mips_default_stack_argsize = 8;
4062       tdep->mips_fp_register_double = 1;
4063       tdep->mips_last_arg_regnum = ZERO_REGNUM + 7;
4064       tdep->mips_last_fp_arg_regnum = FP0_REGNUM + 15;
4065       tdep->mips_regs_have_home_p = 1;
4066       tdep->gdb_target_is_mips64 = 1;
4067       set_gdbarch_long_bit (gdbarch, 32);
4068       set_gdbarch_ptr_bit (gdbarch, 32);
4069       set_gdbarch_long_long_bit (gdbarch, 64);
4070       break;
4071     case MIPS_ABI_EABI32:
4072       tdep->mips_default_saved_regsize = 4;
4073       tdep->mips_default_stack_argsize = 4;
4074       tdep->mips_fp_register_double = 0;
4075       tdep->mips_last_arg_regnum = ZERO_REGNUM + 11;
4076       tdep->mips_last_fp_arg_regnum = FP0_REGNUM + 19;
4077       tdep->mips_regs_have_home_p = 0;
4078       tdep->gdb_target_is_mips64 = 0;
4079       set_gdbarch_long_bit (gdbarch, 32);
4080       set_gdbarch_ptr_bit (gdbarch, 32);
4081       set_gdbarch_long_long_bit (gdbarch, 64);
4082       break;
4083     case MIPS_ABI_EABI64:
4084       tdep->mips_default_saved_regsize = 8;
4085       tdep->mips_default_stack_argsize = 8;
4086       tdep->mips_fp_register_double = 1;
4087       tdep->mips_last_arg_regnum = ZERO_REGNUM + 11;
4088       tdep->mips_last_fp_arg_regnum = FP0_REGNUM + 19;
4089       tdep->mips_regs_have_home_p = 0;
4090       tdep->gdb_target_is_mips64 = 1;
4091       set_gdbarch_long_bit (gdbarch, 64);
4092       set_gdbarch_ptr_bit (gdbarch, 64);
4093       set_gdbarch_long_long_bit (gdbarch, 64);
4094       break;
4095     case MIPS_ABI_N32:
4096       tdep->mips_default_saved_regsize = 4;
4097       tdep->mips_default_stack_argsize = 8;
4098       tdep->mips_fp_register_double = 1;
4099       tdep->mips_last_arg_regnum = ZERO_REGNUM + 11;
4100       tdep->mips_last_fp_arg_regnum = FP0_REGNUM + 19;
4101       tdep->mips_regs_have_home_p = 0;
4102       tdep->gdb_target_is_mips64 = 0;
4103       set_gdbarch_long_bit (gdbarch, 32);
4104       set_gdbarch_ptr_bit (gdbarch, 32);
4105       set_gdbarch_long_long_bit (gdbarch, 64);
4106       break;
4107     default:
4108       tdep->mips_default_saved_regsize = MIPS_REGSIZE;
4109       tdep->mips_default_stack_argsize = MIPS_REGSIZE;
4110       tdep->mips_fp_register_double = (REGISTER_VIRTUAL_SIZE (FP0_REGNUM) == 8);
4111       tdep->mips_last_arg_regnum = ZERO_REGNUM + 11;
4112       tdep->mips_last_fp_arg_regnum = FP0_REGNUM + 19;
4113       tdep->mips_regs_have_home_p = 1;
4114       tdep->gdb_target_is_mips64 = 0;
4115       set_gdbarch_long_bit (gdbarch, 32);
4116       set_gdbarch_ptr_bit (gdbarch, 32);
4117       set_gdbarch_long_long_bit (gdbarch, 64);
4118       break;
4119     }
4120
4121   /* FIXME: jlarmour/2000-04-07: There *is* a flag EF_MIPS_32BIT_MODE
4122      that could indicate -gp32 BUT gas/config/tc-mips.c contains the
4123      comment:
4124
4125      ``We deliberately don't allow "-gp32" to set the MIPS_32BITMODE
4126      flag in object files because to do so would make it impossible to
4127      link with libraries compiled without "-gp32". This is
4128      unnecessarily restrictive.
4129
4130      We could solve this problem by adding "-gp32" multilibs to gcc,
4131      but to set this flag before gcc is built with such multilibs will
4132      break too many systems.''
4133
4134      But even more unhelpfully, the default linker output target for
4135      mips64-elf is elf32-bigmips, and has EF_MIPS_32BIT_MODE set, even
4136      for 64-bit programs - you need to change the ABI to change this,
4137      and not all gcc targets support that currently. Therefore using
4138      this flag to detect 32-bit mode would do the wrong thing given
4139      the current gcc - it would make GDB treat these 64-bit programs
4140      as 32-bit programs by default. */
4141
4142 #if 0
4143   /* determine the ISA */
4144   switch (elf_flags & EF_MIPS_ARCH)
4145     {
4146     case E_MIPS_ARCH_1:
4147       ef_mips_arch = 1;
4148       break;
4149     case E_MIPS_ARCH_2:
4150       ef_mips_arch = 2;
4151       break;
4152     case E_MIPS_ARCH_3:
4153       ef_mips_arch = 3;
4154       break;
4155     case E_MIPS_ARCH_4:
4156       ef_mips_arch = 0;
4157       break;
4158     default:
4159       break;
4160     }
4161 #endif
4162
4163 #if 0
4164   /* determine the size of a pointer */
4165   if ((elf_flags & EF_MIPS_32BITPTRS))
4166     {
4167       ef_mips_bitptrs = 32;
4168     }
4169   else if ((elf_flags & EF_MIPS_64BITPTRS))
4170     {
4171       ef_mips_bitptrs = 64;
4172     }
4173   else
4174     {
4175       ef_mips_bitptrs = 0;
4176     }
4177 #endif
4178
4179   /* enable/disable the MIPS FPU */
4180   if (!mips_fpu_type_auto)
4181     tdep->mips_fpu_type = mips_fpu_type;
4182   else if (info.bfd_arch_info != NULL
4183            && info.bfd_arch_info->arch == bfd_arch_mips)
4184     switch (info.bfd_arch_info->mach)
4185       {
4186       case bfd_mach_mips3900:
4187       case bfd_mach_mips4100:
4188       case bfd_mach_mips4111:
4189         tdep->mips_fpu_type = MIPS_FPU_NONE;
4190         break;
4191       case bfd_mach_mips4650:
4192         tdep->mips_fpu_type = MIPS_FPU_SINGLE;
4193         break;
4194       default:
4195         tdep->mips_fpu_type = MIPS_FPU_DOUBLE;
4196         break;
4197       }
4198   else
4199     tdep->mips_fpu_type = MIPS_FPU_DOUBLE;
4200
4201   /* MIPS version of register names.  NOTE: At present the MIPS
4202      register name management is part way between the old -
4203      #undef/#define REGISTER_NAMES and the new REGISTER_NAME(nr).
4204      Further work on it is required. */
4205   set_gdbarch_register_name (gdbarch, mips_register_name);
4206   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
4207   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
4208   set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
4209   set_gdbarch_write_fp (gdbarch, generic_target_write_fp);
4210   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
4211   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
4212
4213   /* Initialize a frame */
4214   set_gdbarch_init_extra_frame_info (gdbarch, mips_init_extra_frame_info);
4215
4216   /* MIPS version of CALL_DUMMY */
4217
4218   set_gdbarch_call_dummy_p (gdbarch, 1);
4219   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
4220   set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
4221   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
4222   set_gdbarch_call_dummy_address (gdbarch, mips_call_dummy_address);
4223   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
4224   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
4225   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
4226   set_gdbarch_call_dummy_length (gdbarch, 0);
4227   set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
4228   set_gdbarch_call_dummy_words (gdbarch, mips_call_dummy_words);
4229   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (mips_call_dummy_words));
4230   set_gdbarch_push_return_address (gdbarch, mips_push_return_address);
4231   set_gdbarch_push_arguments (gdbarch, mips_push_arguments);
4232   set_gdbarch_register_convertible (gdbarch, generic_register_convertible_not);
4233   set_gdbarch_coerce_float_to_double (gdbarch, mips_coerce_float_to_double);
4234
4235   set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
4236   set_gdbarch_get_saved_register (gdbarch, mips_get_saved_register);
4237
4238   return gdbarch;
4239 }
4240
4241 static void
4242 mips_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
4243 {
4244   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
4245   if (tdep != NULL)
4246     {
4247       fprintf_unfiltered (file,
4248                           "mips_dump_tdep: tdep->elf_flags = 0x%x\n",
4249                           tdep->elf_flags);
4250       fprintf_unfiltered (file,
4251                           "mips_dump_tdep: tdep->mips_abi = %d\n",
4252                           tdep->mips_abi);
4253     }
4254   fprintf_unfiltered (file,
4255                       "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
4256                       FP_REGISTER_DOUBLE);
4257   fprintf_unfiltered (file,
4258                       "mips_dump_tdep: MIPS_DEFAULT_FPU_TYPE = %d (%s)\n",
4259                       MIPS_DEFAULT_FPU_TYPE,
4260                       (MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_NONE ? "none"
4261                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
4262                        : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
4263                        : "???"));
4264   fprintf_unfiltered (file,
4265                       "mips_dump_tdep: MIPS_EABI = %d\n",
4266                       MIPS_EABI);
4267   fprintf_unfiltered (file,
4268                       "mips_dump_tdep: MIPS_LAST_FP_ARG_REGNUM = %d\n",
4269                       MIPS_LAST_FP_ARG_REGNUM);
4270   fprintf_unfiltered (file,
4271                       "mips_dump_tdep: MIPS_FPU_TYPE = %d (%s)\n",
4272                       MIPS_FPU_TYPE,
4273                       (MIPS_FPU_TYPE == MIPS_FPU_NONE ? "none"
4274                        : MIPS_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
4275                        : MIPS_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
4276                        : "???"));
4277   fprintf_unfiltered (file,
4278                       "mips_dump_tdep: MIPS_DEFAULT_SAVED_REGSIZE = %d\n",
4279                       MIPS_DEFAULT_SAVED_REGSIZE);
4280   fprintf_unfiltered (file,
4281                       "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
4282                       FP_REGISTER_DOUBLE);
4283   fprintf_unfiltered (file,
4284                       "mips_dump_tdep: MIPS_REGS_HAVE_HOME_P = %d\n",
4285                       MIPS_REGS_HAVE_HOME_P);
4286   fprintf_unfiltered (file,
4287                       "mips_dump_tdep: MIPS_DEFAULT_STACK_ARGSIZE = %d\n",
4288                       MIPS_DEFAULT_STACK_ARGSIZE);
4289   fprintf_unfiltered (file,
4290                       "mips_dump_tdep: MIPS_STACK_ARGSIZE = %d\n",
4291                       MIPS_STACK_ARGSIZE);
4292   fprintf_unfiltered (file,
4293                       "mips_dump_tdep: MIPS_REGSIZE = %d\n",
4294                       MIPS_REGSIZE);
4295   fprintf_unfiltered (file,
4296                       "mips_dump_tdep: A0_REGNUM = %d\n",
4297                       A0_REGNUM);
4298   fprintf_unfiltered (file,
4299                       "mips_dump_tdep: ADDR_BITS_REMOVE # %s\n",
4300                       XSTRING (ADDR_BITS_REMOVE(ADDR)));
4301   fprintf_unfiltered (file,
4302                       "mips_dump_tdep: ATTACH_DETACH # %s\n",
4303                       XSTRING (ATTACH_DETACH));
4304   fprintf_unfiltered (file,
4305                       "mips_dump_tdep: BADVADDR_REGNUM = %d\n",
4306                       BADVADDR_REGNUM);
4307   fprintf_unfiltered (file,
4308                       "mips_dump_tdep: BIG_BREAKPOINT = delete?\n");
4309   fprintf_unfiltered (file,
4310                       "mips_dump_tdep: CAUSE_REGNUM = %d\n",
4311                       CAUSE_REGNUM);
4312   fprintf_unfiltered (file,
4313                       "mips_dump_tdep: CPLUS_MARKER = %c\n",
4314                       CPLUS_MARKER);
4315   fprintf_unfiltered (file,
4316                       "mips_dump_tdep: DEFAULT_MIPS_TYPE = %s\n",
4317                       DEFAULT_MIPS_TYPE);
4318   fprintf_unfiltered (file,
4319                       "mips_dump_tdep: DO_REGISTERS_INFO # %s\n",
4320                       XSTRING (DO_REGISTERS_INFO));
4321   fprintf_unfiltered (file,
4322                       "mips_dump_tdep: DWARF_REG_TO_REGNUM # %s\n",
4323                       XSTRING (DWARF_REG_TO_REGNUM (REGNUM)));
4324   fprintf_unfiltered (file,
4325                       "mips_dump_tdep: ECOFF_REG_TO_REGNUM # %s\n",
4326                       XSTRING (ECOFF_REG_TO_REGNUM (REGNUM)));
4327   fprintf_unfiltered (file,
4328                       "mips_dump_tdep: ELF_MAKE_MSYMBOL_SPECIAL # %s\n",
4329                       XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (SYM, MSYM)));
4330   fprintf_unfiltered (file,
4331                       "mips_dump_tdep: FCRCS_REGNUM = %d\n",
4332                       FCRCS_REGNUM);
4333   fprintf_unfiltered (file,
4334                       "mips_dump_tdep: FCRIR_REGNUM = %d\n",
4335                       FCRIR_REGNUM);
4336   fprintf_unfiltered (file,
4337                       "mips_dump_tdep: FIRST_EMBED_REGNUM = %d\n",
4338                       FIRST_EMBED_REGNUM);
4339   fprintf_unfiltered (file,
4340                       "mips_dump_tdep: FPA0_REGNUM = %d\n",
4341                       FPA0_REGNUM);
4342   fprintf_unfiltered (file,
4343                       "mips_dump_tdep: GDB_TARGET_IS_MIPS64 = %d\n",
4344                       GDB_TARGET_IS_MIPS64);
4345   fprintf_unfiltered (file,
4346                       "mips_dump_tdep: GDB_TARGET_MASK_DISAS_PC # %s\n",
4347                       XSTRING (GDB_TARGET_MASK_DISAS_PC (PC)));
4348   fprintf_unfiltered (file,
4349                       "mips_dump_tdep: GDB_TARGET_UNMASK_DISAS_PC # %s\n",
4350                       XSTRING (GDB_TARGET_UNMASK_DISAS_PC (PC)));
4351   fprintf_unfiltered (file,
4352                       "mips_dump_tdep: GEN_REG_SAVE_MASK = %d\n",
4353                       GEN_REG_SAVE_MASK);
4354   fprintf_unfiltered (file,
4355                       "mips_dump_tdep: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
4356                       XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
4357   fprintf_unfiltered (file,
4358                       "mips_dump_tdep:  HI_REGNUM = %d\n",
4359                       HI_REGNUM);
4360   fprintf_unfiltered (file,
4361                       "mips_dump_tdep: IDT_BIG_BREAKPOINT = delete?\n");
4362   fprintf_unfiltered (file,
4363                       "mips_dump_tdep: IDT_LITTLE_BREAKPOINT = delete?\n");
4364   fprintf_unfiltered (file,
4365                       "mips_dump_tdep: IGNORE_HELPER_CALL # %s\n",
4366                       XSTRING (IGNORE_HELPER_CALL (PC)));
4367   fprintf_unfiltered (file,
4368                       "mips_dump_tdep: INIT_FRAME_PC # %s\n",
4369                       XSTRING (INIT_FRAME_PC (FROMLEAF, PREV)));
4370   fprintf_unfiltered (file,
4371                       "mips_dump_tdep: INIT_FRAME_PC_FIRST # %s\n",
4372                       XSTRING (INIT_FRAME_PC_FIRST (FROMLEAF, PREV)));
4373   fprintf_unfiltered (file,
4374                       "mips_dump_tdep: IN_SIGTRAMP # %s\n",
4375                       XSTRING (IN_SIGTRAMP (PC, NAME)));
4376   fprintf_unfiltered (file,
4377                       "mips_dump_tdep: IN_SOLIB_CALL_TRAMPOLINE # %s\n",
4378                       XSTRING (IN_SOLIB_CALL_TRAMPOLINE (PC, NAME)));
4379   fprintf_unfiltered (file,
4380                       "mips_dump_tdep: IN_SOLIB_RETURN_TRAMPOLINE # %s\n",
4381                       XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (PC, NAME)));
4382   fprintf_unfiltered (file,
4383                       "mips_dump_tdep: IS_MIPS16_ADDR = FIXME!\n");
4384   fprintf_unfiltered (file,
4385                       "mips_dump_tdep: LAST_EMBED_REGNUM = %d\n",
4386                       LAST_EMBED_REGNUM);
4387   fprintf_unfiltered (file,
4388                       "mips_dump_tdep: LITTLE_BREAKPOINT = delete?\n");
4389   fprintf_unfiltered (file,
4390                       "mips_dump_tdep: LO_REGNUM = %d\n",
4391                       LO_REGNUM);
4392 #ifdef MACHINE_CPROC_FP_OFFSET
4393   fprintf_unfiltered (file,
4394                       "mips_dump_tdep: MACHINE_CPROC_FP_OFFSET = %d\n",
4395                       MACHINE_CPROC_FP_OFFSET);
4396 #endif
4397 #ifdef MACHINE_CPROC_PC_OFFSET
4398   fprintf_unfiltered (file,
4399                       "mips_dump_tdep: MACHINE_CPROC_PC_OFFSET = %d\n",
4400                       MACHINE_CPROC_PC_OFFSET);
4401 #endif
4402 #ifdef MACHINE_CPROC_SP_OFFSET
4403   fprintf_unfiltered (file,
4404                       "mips_dump_tdep: MACHINE_CPROC_SP_OFFSET = %d\n",
4405                       MACHINE_CPROC_SP_OFFSET);
4406 #endif
4407   fprintf_unfiltered (file,
4408                       "mips_dump_tdep: MAKE_MIPS16_ADDR = FIXME!\n");
4409   fprintf_unfiltered (file,
4410                       "mips_dump_tdep: MIPS16_BIG_BREAKPOINT = delete?\n");
4411   fprintf_unfiltered (file,
4412                       "mips_dump_tdep: MIPS16_INSTLEN = %d\n",
4413                       MIPS16_INSTLEN);
4414   fprintf_unfiltered (file,
4415                       "mips_dump_tdep: MIPS16_LITTLE_BREAKPOINT = delete?\n");
4416   fprintf_unfiltered (file,
4417                       "mips_dump_tdep: MIPS_DEFAULT_ABI = FIXME!\n");
4418   fprintf_unfiltered (file,
4419                       "mips_dump_tdep: MIPS_EFI_SYMBOL_NAME = multi-arch!!\n");
4420   fprintf_unfiltered (file,
4421                       "mips_dump_tdep: MIPS_INSTLEN = %d\n",
4422                       MIPS_INSTLEN);
4423   fprintf_unfiltered (file,
4424                       "mips_dump_tdep: MIPS_LAST_ARG_REGNUM = %d\n",
4425                       MIPS_LAST_ARG_REGNUM);
4426   fprintf_unfiltered (file,
4427                       "mips_dump_tdep: MIPS_NUMREGS = %d\n",
4428                       MIPS_NUMREGS);
4429   fprintf_unfiltered (file,
4430                       "mips_dump_tdep: MIPS_REGISTER_NAMES = delete?\n");
4431   fprintf_unfiltered (file,
4432                       "mips_dump_tdep: MIPS_SAVED_REGSIZE = %d\n",
4433                       MIPS_SAVED_REGSIZE);
4434   fprintf_unfiltered (file,
4435                       "mips_dump_tdep: MSYMBOL_IS_SPECIAL = function?\n");
4436   fprintf_unfiltered (file,
4437                       "mips_dump_tdep: MSYMBOL_SIZE # %s\n",
4438                       XSTRING (MSYMBOL_SIZE (MSYM)));
4439   fprintf_unfiltered (file,
4440                       "mips_dump_tdep: OP_LDFPR = used?\n");
4441   fprintf_unfiltered (file,
4442                       "mips_dump_tdep: OP_LDGPR = used?\n");
4443   fprintf_unfiltered (file,
4444                       "mips_dump_tdep: PMON_BIG_BREAKPOINT = delete?\n");
4445   fprintf_unfiltered (file,
4446                       "mips_dump_tdep: PMON_LITTLE_BREAKPOINT = delete?\n");
4447   fprintf_unfiltered (file,
4448                       "mips_dump_tdep: PRID_REGNUM = %d\n",
4449                       PRID_REGNUM);
4450   fprintf_unfiltered (file,
4451                       "mips_dump_tdep: PRINT_EXTRA_FRAME_INFO # %s\n",
4452                       XSTRING (PRINT_EXTRA_FRAME_INFO (FRAME)));
4453   fprintf_unfiltered (file,
4454                       "mips_dump_tdep: PROC_DESC_IS_DUMMY = function?\n");
4455   fprintf_unfiltered (file,
4456                       "mips_dump_tdep: PROC_FRAME_ADJUST = function?\n");
4457   fprintf_unfiltered (file,
4458                       "mips_dump_tdep: PROC_FRAME_OFFSET = function?\n");
4459   fprintf_unfiltered (file,
4460                       "mips_dump_tdep: PROC_FRAME_REG = function?\n");
4461   fprintf_unfiltered (file,
4462                       "mips_dump_tdep: PROC_FREG_MASK = function?\n");
4463   fprintf_unfiltered (file,
4464                       "mips_dump_tdep: PROC_FREG_OFFSET = function?\n");
4465   fprintf_unfiltered (file,
4466                       "mips_dump_tdep: PROC_HIGH_ADDR = function?\n");
4467   fprintf_unfiltered (file,
4468                       "mips_dump_tdep: PROC_LOW_ADDR = function?\n");
4469   fprintf_unfiltered (file,
4470                       "mips_dump_tdep: PROC_PC_REG = function?\n");
4471   fprintf_unfiltered (file,
4472                       "mips_dump_tdep: PROC_REG_MASK = function?\n");
4473   fprintf_unfiltered (file,
4474                       "mips_dump_tdep: PROC_REG_OFFSET = function?\n");
4475   fprintf_unfiltered (file,
4476                       "mips_dump_tdep: PROC_SYMBOL = function?\n");
4477   fprintf_unfiltered (file,
4478                       "mips_dump_tdep: PS_REGNUM = %d\n",
4479                       PS_REGNUM);
4480   fprintf_unfiltered (file,
4481                       "mips_dump_tdep: PUSH_FP_REGNUM = %d\n",
4482                       PUSH_FP_REGNUM);
4483   fprintf_unfiltered (file,
4484                       "mips_dump_tdep: RA_REGNUM = %d\n",
4485                       RA_REGNUM);
4486   fprintf_unfiltered (file,
4487                       "mips_dump_tdep: REGISTER_CONVERT_FROM_TYPE # %s\n",
4488                       XSTRING (REGISTER_CONVERT_FROM_TYPE (REGNUM, VALTYPE, RAW_BUFFER)));
4489   fprintf_unfiltered (file,
4490                       "mips_dump_tdep: REGISTER_CONVERT_TO_TYPE # %s\n",
4491                       XSTRING (REGISTER_CONVERT_TO_TYPE (REGNUM, VALTYPE, RAW_BUFFER)));
4492   fprintf_unfiltered (file,
4493                       "mips_dump_tdep: REGISTER_NAMES = delete?\n");
4494   fprintf_unfiltered (file,
4495                       "mips_dump_tdep: ROUND_DOWN = function?\n");
4496   fprintf_unfiltered (file,
4497                       "mips_dump_tdep: ROUND_UP = function?\n");
4498 #ifdef SAVED_BYTES
4499   fprintf_unfiltered (file,
4500                       "mips_dump_tdep: SAVED_BYTES = %d\n",
4501                       SAVED_BYTES);
4502 #endif
4503 #ifdef SAVED_FP
4504   fprintf_unfiltered (file,
4505                       "mips_dump_tdep: SAVED_FP = %d\n",
4506                       SAVED_FP);
4507 #endif
4508 #ifdef SAVED_PC
4509   fprintf_unfiltered (file,
4510                       "mips_dump_tdep: SAVED_PC = %d\n",
4511                       SAVED_PC);
4512 #endif
4513   fprintf_unfiltered (file,
4514                       "mips_dump_tdep: SETUP_ARBITRARY_FRAME # %s\n",
4515                       XSTRING (SETUP_ARBITRARY_FRAME (NUMARGS, ARGS)));
4516   fprintf_unfiltered (file,
4517                       "mips_dump_tdep: SET_PROC_DESC_IS_DUMMY = function?\n");
4518   fprintf_unfiltered (file,
4519                       "mips_dump_tdep: SIGFRAME_BASE = %d\n",
4520                       SIGFRAME_BASE);
4521   fprintf_unfiltered (file,
4522                       "mips_dump_tdep: SIGFRAME_FPREGSAVE_OFF = %d\n",
4523                       SIGFRAME_FPREGSAVE_OFF);
4524   fprintf_unfiltered (file,
4525                       "mips_dump_tdep: SIGFRAME_PC_OFF = %d\n",
4526                       SIGFRAME_PC_OFF);
4527   fprintf_unfiltered (file,
4528                       "mips_dump_tdep: SIGFRAME_REGSAVE_OFF = %d\n",
4529                       SIGFRAME_REGSAVE_OFF);
4530   fprintf_unfiltered (file,
4531                       "mips_dump_tdep: SIGFRAME_REG_SIZE = %d\n",
4532                       SIGFRAME_REG_SIZE);
4533   fprintf_unfiltered (file,
4534                       "mips_dump_tdep: SKIP_TRAMPOLINE_CODE # %s\n",
4535                       XSTRING (SKIP_TRAMPOLINE_CODE (PC)));
4536   fprintf_unfiltered (file,
4537                       "mips_dump_tdep: SOFTWARE_SINGLE_STEP # %s\n",
4538                       XSTRING (SOFTWARE_SINGLE_STEP (SIG, BP_P)));
4539   fprintf_unfiltered (file,
4540                       "mips_dump_tdep: SOFTWARE_SINGLE_STEP_P = %d\n",
4541                       SOFTWARE_SINGLE_STEP_P);
4542   fprintf_unfiltered (file,
4543                       "mips_dump_tdep: SOFTWARE_SINGLE_STEP_P = %d\n",
4544                       SOFTWARE_SINGLE_STEP_P);
4545   fprintf_unfiltered (file,
4546                       "mips_dump_tdep: STAB_REG_TO_REGNUM # %s\n",
4547                       XSTRING (STAB_REG_TO_REGNUM (REGNUM)));
4548 #ifdef STACK_END_ADDR
4549   fprintf_unfiltered (file,
4550                       "mips_dump_tdep: STACK_END_ADDR = %d\n",
4551                       STACK_END_ADDR);
4552 #endif
4553   fprintf_unfiltered (file,
4554                       "mips_dump_tdep: STEP_SKIPS_DELAY # %s\n",
4555                       XSTRING (STEP_SKIPS_DELAY (PC)));
4556   fprintf_unfiltered (file,
4557                       "mips_dump_tdep: STEP_SKIPS_DELAY_P = %d\n",
4558                       STEP_SKIPS_DELAY_P);
4559   fprintf_unfiltered (file,
4560                       "mips_dump_tdep: STOPPED_BY_WATCHPOINT # %s\n",
4561                       XSTRING (STOPPED_BY_WATCHPOINT (WS)));
4562   fprintf_unfiltered (file,
4563                       "mips_dump_tdep: T9_REGNUM = %d\n",
4564                       T9_REGNUM);
4565   fprintf_unfiltered (file,
4566                       "mips_dump_tdep: TABULAR_REGISTER_OUTPUT = used?\n");
4567   fprintf_unfiltered (file,
4568                       "mips_dump_tdep: TARGET_CAN_USE_HARDWARE_WATCHPOINT # %s\n",
4569                       XSTRING (TARGET_CAN_USE_HARDWARE_WATCHPOINT (TYPE,CNT,OTHERTYPE)));
4570   fprintf_unfiltered (file,
4571                       "mips_dump_tdep: TARGET_HAS_HARDWARE_WATCHPOINTS # %s\n",
4572                       XSTRING (TARGET_HAS_HARDWARE_WATCHPOINTS));
4573   fprintf_unfiltered (file,
4574                       "mips_dump_tdep: TARGET_MIPS = used?\n");
4575   fprintf_unfiltered (file,
4576                       "mips_dump_tdep: TM_PRINT_INSN_MACH # %s\n",
4577                       XSTRING (TM_PRINT_INSN_MACH));
4578 #ifdef TRACE_CLEAR
4579   fprintf_unfiltered (file,
4580                       "mips_dump_tdep: TRACE_CLEAR # %s\n",
4581                       XSTRING (TRACE_CLEAR (THREAD, STATE)));
4582 #endif
4583 #ifdef TRACE_FLAVOR
4584   fprintf_unfiltered (file,
4585                       "mips_dump_tdep: TRACE_FLAVOR = %d\n",
4586                       TRACE_FLAVOR);
4587 #endif
4588 #ifdef TRACE_FLAVOR_SIZE
4589   fprintf_unfiltered (file,
4590                       "mips_dump_tdep: TRACE_FLAVOR_SIZE = %d\n",
4591                       TRACE_FLAVOR_SIZE);
4592 #endif
4593 #ifdef TRACE_SET
4594   fprintf_unfiltered (file,
4595                       "mips_dump_tdep: TRACE_SET # %s\n",
4596                       XSTRING (TRACE_SET (X,STATE)));
4597 #endif
4598   fprintf_unfiltered (file,
4599                       "mips_dump_tdep: UNMAKE_MIPS16_ADDR = function?\n");
4600 #ifdef UNUSED_REGNUM
4601   fprintf_unfiltered (file,
4602                       "mips_dump_tdep: UNUSED_REGNUM = %d\n",
4603                       UNUSED_REGNUM);
4604 #endif
4605   fprintf_unfiltered (file,
4606                       "mips_dump_tdep: V0_REGNUM = %d\n",
4607                       V0_REGNUM);
4608   fprintf_unfiltered (file,
4609                       "mips_dump_tdep: VM_MIN_ADDRESS = %ld\n",
4610                       (long) VM_MIN_ADDRESS);
4611 #ifdef VX_NUM_REGS
4612   fprintf_unfiltered (file,
4613                       "mips_dump_tdep: VX_NUM_REGS = %d (used?)\n",
4614                       VX_NUM_REGS);
4615 #endif
4616   fprintf_unfiltered (file,
4617                       "mips_dump_tdep: ZERO_REGNUM = %d\n",
4618                       ZERO_REGNUM);
4619   fprintf_unfiltered (file,
4620                       "mips_dump_tdep: _PROC_MAGIC_ = %d\n",
4621                       _PROC_MAGIC_);
4622 }
4623
4624 void
4625 _initialize_mips_tdep ()
4626 {
4627   static struct cmd_list_element *mipsfpulist = NULL;
4628   struct cmd_list_element *c;
4629
4630   gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
4631   if (!tm_print_insn)           /* Someone may have already set it */
4632     tm_print_insn = gdb_print_insn_mips;
4633
4634   /* Add root prefix command for all "set mips"/"show mips" commands */
4635   add_prefix_cmd ("mips", no_class, set_mips_command,
4636                   "Various MIPS specific commands.",
4637                   &setmipscmdlist, "set mips ", 0, &setlist);
4638
4639   add_prefix_cmd ("mips", no_class, show_mips_command,
4640                   "Various MIPS specific commands.",
4641                   &showmipscmdlist, "show mips ", 0, &showlist);
4642
4643   /* Allow the user to override the saved register size. */
4644   add_show_from_set (add_set_enum_cmd ("saved-gpreg-size",
4645                                        class_obscure,
4646                                        size_enums,
4647                                        &mips_saved_regsize_string, "\
4648 Set size of general purpose registers saved on the stack.\n\
4649 This option can be set to one of:\n\
4650   32    - Force GDB to treat saved GP registers as 32-bit\n\
4651   64    - Force GDB to treat saved GP registers as 64-bit\n\
4652   auto  - Allow GDB to use the target's default setting or autodetect the\n\
4653           saved GP register size from information contained in the executable.\n\
4654           (default: auto)",
4655                                        &setmipscmdlist),
4656                      &showmipscmdlist);
4657
4658   /* Allow the user to override the argument stack size. */
4659   add_show_from_set (add_set_enum_cmd ("stack-arg-size",
4660                                        class_obscure,
4661                                        size_enums,
4662                                        &mips_stack_argsize_string, "\
4663 Set the amount of stack space reserved for each argument.\n\
4664 This option can be set to one of:\n\
4665   32    - Force GDB to allocate 32-bit chunks per argument\n\
4666   64    - Force GDB to allocate 64-bit chunks per argument\n\
4667   auto  - Allow GDB to determine the correct setting from the current\n\
4668           target and executable (default)",
4669                                        &setmipscmdlist),
4670                      &showmipscmdlist);
4671
4672   /* Let the user turn off floating point and set the fence post for
4673      heuristic_proc_start.  */
4674
4675   add_prefix_cmd ("mipsfpu", class_support, set_mipsfpu_command,
4676                   "Set use of MIPS floating-point coprocessor.",
4677                   &mipsfpulist, "set mipsfpu ", 0, &setlist);
4678   add_cmd ("single", class_support, set_mipsfpu_single_command,
4679            "Select single-precision MIPS floating-point coprocessor.",
4680            &mipsfpulist);
4681   add_cmd ("double", class_support, set_mipsfpu_double_command,
4682            "Select double-precision MIPS floating-point coprocessor .",
4683            &mipsfpulist);
4684   add_alias_cmd ("on", "double", class_support, 1, &mipsfpulist);
4685   add_alias_cmd ("yes", "double", class_support, 1, &mipsfpulist);
4686   add_alias_cmd ("1", "double", class_support, 1, &mipsfpulist);
4687   add_cmd ("none", class_support, set_mipsfpu_none_command,
4688            "Select no MIPS floating-point coprocessor.",
4689            &mipsfpulist);
4690   add_alias_cmd ("off", "none", class_support, 1, &mipsfpulist);
4691   add_alias_cmd ("no", "none", class_support, 1, &mipsfpulist);
4692   add_alias_cmd ("0", "none", class_support, 1, &mipsfpulist);
4693   add_cmd ("auto", class_support, set_mipsfpu_auto_command,
4694            "Select MIPS floating-point coprocessor automatically.",
4695            &mipsfpulist);
4696   add_cmd ("mipsfpu", class_support, show_mipsfpu_command,
4697            "Show current use of MIPS floating-point coprocessor target.",
4698            &showlist);
4699
4700 #if !GDB_MULTI_ARCH
4701   c = add_set_cmd ("processor", class_support, var_string_noescape,
4702                    (char *) &tmp_mips_processor_type,
4703                    "Set the type of MIPS processor in use.\n\
4704 Set this to be able to access processor-type-specific registers.\n\
4705 ",
4706                    &setlist);
4707   c->function.cfunc = mips_set_processor_type_command;
4708   c = add_show_from_set (c, &showlist);
4709   c->function.cfunc = mips_show_processor_type_command;
4710
4711   tmp_mips_processor_type = strsave (DEFAULT_MIPS_TYPE);
4712   mips_set_processor_type_command (strsave (DEFAULT_MIPS_TYPE), 0);
4713 #endif
4714
4715   /* We really would like to have both "0" and "unlimited" work, but
4716      command.c doesn't deal with that.  So make it a var_zinteger
4717      because the user can always use "999999" or some such for unlimited.  */
4718   c = add_set_cmd ("heuristic-fence-post", class_support, var_zinteger,
4719                    (char *) &heuristic_fence_post,
4720                    "\
4721 Set the distance searched for the start of a function.\n\
4722 If you are debugging a stripped executable, GDB needs to search through the\n\
4723 program for the start of a function.  This command sets the distance of the\n\
4724 search.  The only need to set it is when debugging a stripped executable.",
4725                    &setlist);
4726   /* We need to throw away the frame cache when we set this, since it
4727      might change our ability to get backtraces.  */
4728   c->function.sfunc = reinit_frame_cache_sfunc;
4729   add_show_from_set (c, &showlist);
4730
4731   /* Allow the user to control whether the upper bits of 64-bit
4732      addresses should be zeroed.  */
4733   add_show_from_set
4734     (add_set_cmd ("mask-address", no_class, var_boolean, (char *) &mask_address_p,
4735                   "Set zeroing of upper 32 bits of 64-bit addresses.\n\
4736 Use \"on\" to enable the masking, and \"off\" to disable it.\n\
4737 Without an argument, zeroing of upper address bits is enabled.", &setlist),
4738      &showlist);
4739
4740   /* Allow the user to control the size of 32 bit registers within the
4741      raw remote packet.  */
4742   add_show_from_set (add_set_cmd ("remote-mips64-transfers-32bit-regs",
4743                                   class_obscure,
4744                                   var_boolean,
4745                                   (char *)&mips64_transfers_32bit_regs_p, "\
4746 Set compatibility with MIPS targets that transfers 32 and 64 bit quantities.\n\
4747 Use \"on\" to enable backward compatibility with older MIPS 64 GDB+target\n\
4748 that would transfer 32 bits for some registers (e.g. SR, FSR) and\n\
4749 64 bits for others.  Use \"off\" to disable compatibility mode",
4750                                   &setlist),
4751                      &showlist);
4752
4753   /* Debug this files internals. */
4754   add_show_from_set (add_set_cmd ("mips", class_maintenance, var_zinteger,
4755                                   &mips_debug, "Set mips debugging.\n\
4756 When non-zero, mips specific debugging is enabled.", &setdebuglist),
4757                      &showdebuglist);
4758 }
4759