gdb/mips-tdep.c

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