gdb/mips-tdep.c

   1 /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
   2    Copyright 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   4    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "inferior.h"
  25 #include "symtab.h"
  26 #include "value.h"
  27 #include "gdbcmd.h"
  28 #include "language.h"
  29 #include "gdbcore.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32
  33 #include "opcode/mips.h"
  34
  35 #define VM_MIN_ADDRESS (unsigned)0x400000
  36 \f
  37 static int mips_in_lenient_prologue PARAMS ((CORE_ADDR, CORE_ADDR));
  38
  39 /* Some MIPS boards don't support floating point, so we permit the
  40    user to turn it off.  */
  41 int mips_fpu = 1;
  42
  43 /* Heuristic_proc_start may hunt through the text section for a long
  44    time across a 2400 baud serial line.  Allows the user to limit this
  45    search.  */
  46 static unsigned int heuristic_fence_post = 0;
  47
  48 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
  49 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
  50 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
  51 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
  52 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
  53 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
  54 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
  55 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
  56 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
  57 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
  58 #define _PROC_MAGIC_ 0x0F0F0F0F
  59 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
  60 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
  61
  62 struct linked_proc_info
  63 {
  64   struct mips_extra_func_info info;
  65   struct linked_proc_info *next;
  66 } *linked_proc_desc_table = NULL;
  67
  68 \f
  69 #define READ_FRAME_REG(fi, regno) read_next_frame_reg((fi)->next, regno)
  70
  71 static int
  72 read_next_frame_reg(fi, regno)
  73      FRAME fi;
  74      int regno;
  75 {
  76   /* If it is the frame for sigtramp we have a complete sigcontext
  77      immediately below the frame and we get the saved registers from there.
  78      If the stack layout for sigtramp changes we might have to change these
  79      constants and the companion fixup_sigtramp in mipsread.c  */
  80 #ifndef SIGFRAME_BASE
  81 #define SIGFRAME_BASE           0x12c   /* sizeof(sigcontext) */
  82 #define SIGFRAME_PC_OFF         (-SIGFRAME_BASE + 2 * 4)
  83 #define SIGFRAME_REGSAVE_OFF    (-SIGFRAME_BASE + 3 * 4)
  84 #endif
  85   for (; fi; fi = fi->next)
  86       if (in_sigtramp(fi->pc, 0)) {
  87           int offset;
  88           if (regno == PC_REGNUM) offset = SIGFRAME_PC_OFF;
  89           else if (regno < 32) offset = SIGFRAME_REGSAVE_OFF + regno * 4;
  90           else return 0;
  91           return read_memory_integer(fi->frame + offset, 4);
  92       }
  93       else if (regno == SP_REGNUM) return fi->frame;
  94       else if (fi->saved_regs->regs[regno])
  95         return read_memory_integer(fi->saved_regs->regs[regno], 4);
  96   return read_register(regno);
  97 }
  98
  99 int
 100 mips_frame_saved_pc(frame)
 101      FRAME frame;
 102 {
 103   mips_extra_func_info_t proc_desc = frame->proc_desc;
 104   int pcreg = proc_desc ? PROC_PC_REG(proc_desc) : RA_REGNUM;
 105
 106   if (proc_desc && PROC_DESC_IS_DUMMY(proc_desc))
 107       return read_memory_integer(frame->frame - 4, 4);
 108
 109   return read_next_frame_reg(frame, pcreg);
 110 }
 111
 112 static struct mips_extra_func_info temp_proc_desc;
 113 static struct frame_saved_regs temp_saved_regs;
 114
 115 /* This fencepost looks highly suspicious to me.  Removing it also
 116    seems suspicious as it could affect remote debugging across serial
 117    lines.  */
 118
 119 static CORE_ADDR
 120 heuristic_proc_start(pc)
 121     CORE_ADDR pc;
 122 {
 123     CORE_ADDR start_pc = pc;
 124     CORE_ADDR fence = start_pc - heuristic_fence_post;
 125
 126     if (start_pc == 0)  return 0;
 127
 128     if (heuristic_fence_post == UINT_MAX
 129         || fence < VM_MIN_ADDRESS)
 130       fence = VM_MIN_ADDRESS;
 131
 132     /* search back for previous return */
 133     for (start_pc -= 4; ; start_pc -= 4)
 134         if (start_pc < fence)
 135           {
 136             /* It's not clear to me why we reach this point when
 137                stop_soon_quietly, but with this test, at least we
 138                don't print out warnings for every child forked (eg, on
 139                decstation).  22apr93 rich@cygnus.com.  */
 140             if (!stop_soon_quietly)
 141               {
 142                 if (fence == VM_MIN_ADDRESS)
 143                   warning("Hit beginning of text section without finding");
 144                 else
 145                   warning("Hit heuristic-fence-post without finding");
 146
 147                 warning("enclosing function for pc 0x%x", pc);
 148               }
 149
 150             return 0;
 151           }
 152         else if (ABOUT_TO_RETURN(start_pc))
 153             break;
 154
 155     start_pc += 8; /* skip return, and its delay slot */
 156 #if 0
 157     /* skip nops (usually 1) 0 - is this */
 158     while (start_pc < pc && read_memory_integer (start_pc, 4) == 0)
 159         start_pc += 4;
 160 #endif
 161     return start_pc;
 162 }
 163
 164 static mips_extra_func_info_t
 165 heuristic_proc_desc(start_pc, limit_pc, next_frame)
 166     CORE_ADDR start_pc, limit_pc;
 167     FRAME next_frame;
 168 {
 169     CORE_ADDR sp = next_frame ? next_frame->frame : read_register (SP_REGNUM);
 170     CORE_ADDR cur_pc;
 171     int frame_size;
 172     int has_frame_reg = 0;
 173     int reg30; /* Value of $r30. Used by gcc for frame-pointer */
 174     unsigned long reg_mask = 0;
 175
 176     if (start_pc == 0) return NULL;
 177     bzero(&temp_proc_desc, sizeof(temp_proc_desc));
 178     bzero(&temp_saved_regs, sizeof(struct frame_saved_regs));
 179     PROC_LOW_ADDR(&temp_proc_desc) = start_pc;
 180
 181     if (start_pc + 200 < limit_pc) limit_pc = start_pc + 200;
 182   restart:
 183     frame_size = 0;
 184     for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += 4) {
 185         char buf[4];
 186         unsigned long word;
 187         int status;
 188
 189         status = read_memory_nobpt (cur_pc, buf, 4);
 190         if (status) memory_error (status, cur_pc);
 191         word = extract_unsigned_integer (buf, 4);
 192
 193         if ((word & 0xFFFF0000) == 0x27bd0000) /* addiu $sp,$sp,-i */
 194             frame_size += (-word) & 0xFFFF;
 195         else if ((word & 0xFFFF0000) == 0x23bd0000) /* addu $sp,$sp,-i */
 196             frame_size += (-word) & 0xFFFF;
 197         else if ((word & 0xFFE00000) == 0xafa00000) { /* sw reg,offset($sp) */
 198             int reg = (word & 0x001F0000) >> 16;
 199             reg_mask |= 1 << reg;
 200             temp_saved_regs.regs[reg] = sp + (short)word;
 201         }
 202         else if ((word & 0xFFFF0000) == 0x27be0000) { /* addiu $30,$sp,size */
 203             if ((unsigned short)word != frame_size)
 204                 reg30 = sp + (unsigned short)word;
 205             else if (!has_frame_reg) {
 206                 int alloca_adjust;
 207                 has_frame_reg = 1;
 208                 reg30 = read_next_frame_reg(next_frame, 30);
 209                 alloca_adjust = reg30 - (sp + (unsigned short)word);
 210                 if (alloca_adjust > 0) {
 211                     /* FP > SP + frame_size. This may be because
 212                     /* of an alloca or somethings similar.
 213                      * Fix sp to "pre-alloca" value, and try again.
 214                      */
 215                     sp += alloca_adjust;
 216                     goto restart;
 217                 }
 218             }
 219         }
 220         else if ((word & 0xFFE00000) == 0xafc00000) { /* sw reg,offset($30) */
 221             int reg = (word & 0x001F0000) >> 16;
 222             reg_mask |= 1 << reg;
 223             temp_saved_regs.regs[reg] = reg30 + (short)word;
 224         }
 225     }
 226     if (has_frame_reg) {
 227         PROC_FRAME_REG(&temp_proc_desc) = 30;
 228         PROC_FRAME_OFFSET(&temp_proc_desc) = 0;
 229     }
 230     else {
 231         PROC_FRAME_REG(&temp_proc_desc) = SP_REGNUM;
 232         PROC_FRAME_OFFSET(&temp_proc_desc) = frame_size;
 233     }
 234     PROC_REG_MASK(&temp_proc_desc) = reg_mask;
 235     PROC_PC_REG(&temp_proc_desc) = RA_REGNUM;
 236     return &temp_proc_desc;
 237 }
 238
 239 static mips_extra_func_info_t
 240 find_proc_desc(pc, next_frame)
 241     CORE_ADDR pc;
 242     FRAME next_frame;
 243 {
 244   mips_extra_func_info_t proc_desc;
 245   struct block *b = block_for_pc(pc);
 246   struct symbol *sym =
 247       b ? lookup_symbol(MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, 0, NULL) : NULL;
 248
 249   if (sym)
 250     {
 251         /* IF this is the topmost frame AND
 252          * (this proc does not have debugging information OR
 253          * the PC is in the procedure prologue)
 254          * THEN create a "heuristic" proc_desc (by analyzing
 255          * the actual code) to replace the "official" proc_desc.
 256          */
 257         proc_desc = (mips_extra_func_info_t)SYMBOL_VALUE(sym);
 258         if (next_frame == NULL) {
 259             struct symtab_and_line val;
 260             struct symbol *proc_symbol =
 261                 PROC_DESC_IS_DUMMY(proc_desc) ? 0 : PROC_SYMBOL(proc_desc);
 262
 263             if (proc_symbol) {
 264                 val = find_pc_line (BLOCK_START
 265                                     (SYMBOL_BLOCK_VALUE(proc_symbol)),
 266                                     0);
 267                 val.pc = val.end ? val.end : pc;
 268             }
 269             if (!proc_symbol || pc < val.pc) {
 270                 mips_extra_func_info_t found_heuristic =
 271                     heuristic_proc_desc(PROC_LOW_ADDR(proc_desc),
 272                                         pc, next_frame);
 273                 if (found_heuristic) proc_desc = found_heuristic;
 274             }
 275         }
 276     }
 277   else
 278     {
 279       /* Is linked_proc_desc_table really necessary?  It only seems to be used
 280          by procedure call dummys.  However, the procedures being called ought
 281          to have their own proc_descs, and even if they don't,
 282          heuristic_proc_desc knows how to create them! */
 283
 284       register struct linked_proc_info *link;
 285       for (link = linked_proc_desc_table; link; link = link->next)
 286           if (PROC_LOW_ADDR(&link->info) <= pc
 287               && PROC_HIGH_ADDR(&link->info) > pc)
 288               return &link->info;
 289       proc_desc =
 290           heuristic_proc_desc(heuristic_proc_start(pc), pc, next_frame);
 291     }
 292   return proc_desc;
 293 }
 294
 295 mips_extra_func_info_t cached_proc_desc;
 296
 297 FRAME_ADDR
 298 mips_frame_chain(frame)
 299     FRAME frame;
 300 {
 301     mips_extra_func_info_t proc_desc;
 302     CORE_ADDR saved_pc = FRAME_SAVED_PC(frame);
 303
 304     if (saved_pc == 0 || inside_entry_file (saved_pc))
 305       return 0;
 306
 307     proc_desc = find_proc_desc(saved_pc, frame);
 308     if (!proc_desc)
 309       return 0;
 310
 311     cached_proc_desc = proc_desc;
 312     return read_next_frame_reg(frame, PROC_FRAME_REG(proc_desc))
 313       + PROC_FRAME_OFFSET(proc_desc);
 314 }
 315
 316 void
 317 init_extra_frame_info(fci)
 318      struct frame_info *fci;
 319 {
 320   extern struct obstack frame_cache_obstack;
 321   /* Use proc_desc calculated in frame_chain */
 322   mips_extra_func_info_t proc_desc =
 323     fci->next ? cached_proc_desc : find_proc_desc(fci->pc, fci->next);
 324
 325   fci->saved_regs = (struct frame_saved_regs*)
 326     obstack_alloc (&frame_cache_obstack, sizeof(struct frame_saved_regs));
 327   memset (fci->saved_regs, 0, sizeof (struct frame_saved_regs));
 328   fci->proc_desc =
 329     proc_desc == &temp_proc_desc ? 0 : proc_desc;
 330   if (proc_desc)
 331     {
 332       int ireg;
 333       CORE_ADDR reg_position;
 334       unsigned long mask;
 335       /* r0 bit means kernel trap */
 336       int kernel_trap = PROC_REG_MASK(proc_desc) & 1;
 337
 338       /* Fixup frame-pointer - only needed for top frame */
 339       /* This may not be quite right, if proc has a real frame register */
 340       if (fci->pc == PROC_LOW_ADDR(proc_desc) && !PROC_DESC_IS_DUMMY(proc_desc))
 341         fci->frame = read_register (SP_REGNUM);
 342       else
 343         fci->frame = READ_FRAME_REG(fci, PROC_FRAME_REG(proc_desc))
 344                       + PROC_FRAME_OFFSET(proc_desc);
 345
 346       /* If this is the innermost frame, and we are still in the
 347          prologue (loosely defined), then the registers may not have
 348          been saved yet.  But they haven't been clobbered either, so
 349          it's fine to say they have not been saved.  */
 350       if (fci->next == NULL
 351           && mips_in_lenient_prologue (PROC_LOW_ADDR (proc_desc), fci->pc))
 352         /* We already zeroed the saved regs.  */
 353         ;
 354       else if (proc_desc == &temp_proc_desc)
 355         *fci->saved_regs = temp_saved_regs;
 356       else
 357         {
 358           /* find which general-purpose registers were saved */
 359           reg_position = fci->frame + PROC_REG_OFFSET(proc_desc);
 360           mask = kernel_trap ? 0xFFFFFFFF : PROC_REG_MASK(proc_desc);
 361           for (ireg= 31; mask; --ireg, mask <<= 1)
 362             if (mask & 0x80000000)
 363               {
 364                 fci->saved_regs->regs[ireg] = reg_position;
 365                 reg_position -= 4;
 366               }
 367           /* find which floating-point registers were saved */
 368           reg_position = fci->frame + PROC_FREG_OFFSET(proc_desc);
 369
 370           /* The freg_offset points to where the first *double* register
 371              is saved.  So skip to the high-order word. */
 372           reg_position += 4;
 373           mask = kernel_trap ? 0xFFFFFFFF : PROC_FREG_MASK(proc_desc);
 374           for (ireg = 31; mask; --ireg, mask <<= 1)
 375             if (mask & 0x80000000)
 376               {
 377                 fci->saved_regs->regs[FP0_REGNUM+ireg] = reg_position;
 378                 reg_position -= 4;
 379               }
 380         }
 381
 382       /* hack: if argument regs are saved, guess these contain args */
 383       if ((PROC_REG_MASK(proc_desc) & 0xF0) == 0) fci->num_args = -1;
 384       else if ((PROC_REG_MASK(proc_desc) & 0x80) == 0) fci->num_args = 4;
 385       else if ((PROC_REG_MASK(proc_desc) & 0x40) == 0) fci->num_args = 3;
 386       else if ((PROC_REG_MASK(proc_desc) & 0x20) == 0) fci->num_args = 2;
 387       else if ((PROC_REG_MASK(proc_desc) & 0x10) == 0) fci->num_args = 1;
 388
 389       fci->saved_regs->regs[PC_REGNUM] = fci->saved_regs->regs[RA_REGNUM];
 390     }
 391 }
 392
 393 /* MIPS stack frames are almost impenetrable.  When execution stops,
 394    we basically have to look at symbol information for the function
 395    that we stopped in, which tells us *which* register (if any) is
 396    the base of the frame pointer, and what offset from that register
 397    the frame itself is at.
 398
 399    This presents a problem when trying to examine a stack in memory
 400    (that isn't executing at the moment), using the "frame" command.  We
 401    don't have a PC, nor do we have any registers except SP.
 402
 403    This routine takes two arguments, SP and PC, and tries to make the
 404    cached frames look as if these two arguments defined a frame on the
 405    cache.  This allows the rest of info frame to extract the important
 406    arguments without difficulty.  */
 407
 408 FRAME
 409 setup_arbitrary_frame (argc, argv)
 410      int argc;
 411      FRAME_ADDR *argv;
 412 {
 413   if (argc != 2)
 414     error ("MIPS frame specifications require two arguments: sp and pc");
 415
 416   return create_new_frame (argv[0], argv[1]);
 417 }
 418
 419
 420 CORE_ADDR
 421 mips_push_arguments(nargs, args, sp, struct_return, struct_addr)
 422   int nargs;
 423   value *args;
 424   CORE_ADDR sp;
 425   int struct_return;
 426   CORE_ADDR struct_addr;
 427 {
 428   CORE_ADDR buf;
 429   register i;
 430   int accumulate_size = struct_return ? 4 : 0;
 431   struct mips_arg { char *contents; int len; int offset; };
 432   struct mips_arg *mips_args =
 433       (struct mips_arg*)alloca(nargs * sizeof(struct mips_arg));
 434   register struct mips_arg *m_arg;
 435   for (i = 0, m_arg = mips_args; i < nargs; i++, m_arg++) {
 436     extern value value_arg_coerce();
 437     value arg = value_arg_coerce (args[i]);
 438     m_arg->len = TYPE_LENGTH (VALUE_TYPE (arg));
 439     /* This entire mips-specific routine is because doubles must be aligned
 440      * on 8-byte boundaries. It still isn't quite right, because MIPS decided
 441      * to align 'struct {int a, b}' on 4-byte boundaries (even though this
 442      * breaks their varargs implementation...). A correct solution
 443      * requires an simulation of gcc's 'alignof' (and use of 'alignof'
 444      * in stdarg.h/varargs.h).
 445      */
 446     if (m_arg->len > 4) accumulate_size = (accumulate_size + 7) & -8;
 447     m_arg->offset = accumulate_size;
 448     accumulate_size = (accumulate_size + m_arg->len + 3) & -4;
 449     m_arg->contents = VALUE_CONTENTS(arg);
 450   }
 451   accumulate_size = (accumulate_size + 7) & (-8);
 452   if (accumulate_size < 16) accumulate_size = 16;
 453   sp -= accumulate_size;
 454   for (i = nargs; m_arg--, --i >= 0; )
 455     write_memory(sp + m_arg->offset, m_arg->contents, m_arg->len);
 456   if (struct_return) {
 457     buf = struct_addr;
 458     write_memory(sp, (char *)&buf, sizeof(CORE_ADDR));
 459   }
 460   return sp;
 461 }
 462
 463 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
 464 #define MASK(i,j) ((1 << (j)+1)-1 ^ (1 << (i))-1)
 465
 466 void
 467 mips_push_dummy_frame()
 468 {
 469   int ireg;
 470   struct linked_proc_info *link = (struct linked_proc_info*)
 471       xmalloc(sizeof(struct linked_proc_info));
 472   mips_extra_func_info_t proc_desc = &link->info;
 473   CORE_ADDR sp = read_register (SP_REGNUM);
 474   CORE_ADDR save_address;
 475   REGISTER_TYPE buffer;
 476   link->next = linked_proc_desc_table;
 477   linked_proc_desc_table = link;
 478 #define PUSH_FP_REGNUM 16 /* must be a register preserved across calls */
 479 #define GEN_REG_SAVE_MASK MASK(1,16)|MASK(24,28)|(1<<31)
 480 #define GEN_REG_SAVE_COUNT 22
 481 #define FLOAT_REG_SAVE_MASK MASK(0,19)
 482 #define FLOAT_REG_SAVE_COUNT 20
 483 #define SPECIAL_REG_SAVE_COUNT 4
 484   /*
 485    * The registers we must save are all those not preserved across
 486    * procedure calls. Dest_Reg (see tm-mips.h) must also be saved.
 487    * In addition, we must save the PC, and PUSH_FP_REGNUM.
 488    * (Ideally, we should also save MDLO/-HI and FP Control/Status reg.)
 489    *
 490    * Dummy frame layout:
 491    *  (high memory)
 492    *    Saved PC
 493    *    Saved MMHI, MMLO, FPC_CSR
 494    *    Saved R31
 495    *    Saved R28
 496    *    ...
 497    *    Saved R1
 498    *    Saved D18 (i.e. F19, F18)
 499    *    ...
 500    *    Saved D0 (i.e. F1, F0)
 501    *    CALL_DUMMY (subroutine stub; see tm-mips.h)
 502    *    Parameter build area (not yet implemented)
 503    *  (low memory)
 504    */
 505   PROC_REG_MASK(proc_desc) = GEN_REG_SAVE_MASK;
 506   PROC_FREG_MASK(proc_desc) = mips_fpu ? FLOAT_REG_SAVE_MASK : 0;
 507   PROC_REG_OFFSET(proc_desc) = /* offset of (Saved R31) from FP */
 508       -sizeof(long) - 4 * SPECIAL_REG_SAVE_COUNT;
 509   PROC_FREG_OFFSET(proc_desc) = /* offset of (Saved D18) from FP */
 510       -sizeof(double) - 4 * (SPECIAL_REG_SAVE_COUNT + GEN_REG_SAVE_COUNT);
 511   /* save general registers */
 512   save_address = sp + PROC_REG_OFFSET(proc_desc);
 513   for (ireg = 32; --ireg >= 0; )
 514     if (PROC_REG_MASK(proc_desc) & (1 << ireg))
 515       {
 516         buffer = read_register (ireg);
 517         write_memory (save_address, (char *)&buffer, sizeof(REGISTER_TYPE));
 518         save_address -= 4;
 519       }
 520   /* save floating-points registers starting with high order word */
 521   save_address = sp + PROC_FREG_OFFSET(proc_desc) + 4;
 522   for (ireg = 32; --ireg >= 0; )
 523     if (PROC_FREG_MASK(proc_desc) & (1 << ireg))
 524       {
 525         buffer = read_register (ireg + FP0_REGNUM);
 526         write_memory (save_address, (char *)&buffer, 4);
 527         save_address -= 4;
 528       }
 529   write_register (PUSH_FP_REGNUM, sp);
 530   PROC_FRAME_REG(proc_desc) = PUSH_FP_REGNUM;
 531   PROC_FRAME_OFFSET(proc_desc) = 0;
 532   buffer = read_register (PC_REGNUM);
 533   write_memory (sp - 4, (char *)&buffer, sizeof(REGISTER_TYPE));
 534   buffer = read_register (HI_REGNUM);
 535   write_memory (sp - 8, (char *)&buffer, sizeof(REGISTER_TYPE));
 536   buffer = read_register (LO_REGNUM);
 537   write_memory (sp - 12, (char *)&buffer, sizeof(REGISTER_TYPE));
 538   buffer = read_register (mips_fpu ? FCRCS_REGNUM : ZERO_REGNUM);
 539   write_memory (sp - 16, (char *)&buffer, sizeof(REGISTER_TYPE));
 540   sp -= 4 * (GEN_REG_SAVE_COUNT
 541              + (mips_fpu ? FLOAT_REG_SAVE_COUNT : 0)
 542              + SPECIAL_REG_SAVE_COUNT);
 543   write_register (SP_REGNUM, sp);
 544   PROC_LOW_ADDR(proc_desc) = sp - CALL_DUMMY_SIZE + CALL_DUMMY_START_OFFSET;
 545   PROC_HIGH_ADDR(proc_desc) = sp;
 546   SET_PROC_DESC_IS_DUMMY(proc_desc);
 547   PROC_PC_REG(proc_desc) = RA_REGNUM;
 548 }
 549
 550 void
 551 mips_pop_frame()
 552 {
 553   register int regnum;
 554   FRAME frame = get_current_frame ();
 555   CORE_ADDR new_sp = frame->frame;
 556
 557   mips_extra_func_info_t proc_desc = frame->proc_desc;
 558
 559   write_register (PC_REGNUM, FRAME_SAVED_PC(frame));
 560   if (proc_desc)
 561     {
 562       for (regnum = 32; --regnum >= 0; )
 563         if (PROC_REG_MASK(proc_desc) & (1 << regnum))
 564           write_register (regnum,
 565                           read_memory_integer (frame->saved_regs->regs[regnum],
 566                                                4));
 567       for (regnum = 32; --regnum >= 0; )
 568         if (PROC_FREG_MASK(proc_desc) & (1 << regnum))
 569           write_register (regnum + FP0_REGNUM,
 570                           read_memory_integer (frame->saved_regs->regs[regnum + FP0_REGNUM], 4));
 571     }
 572   write_register (SP_REGNUM, new_sp);
 573   flush_cached_frames ();
 574   /* We let mips_init_extra_frame_info figure out the frame pointer */
 575   set_current_frame (create_new_frame (0, read_pc ()));
 576
 577   if (PROC_DESC_IS_DUMMY(proc_desc))
 578     {
 579       struct linked_proc_info *pi_ptr, *prev_ptr;
 580
 581       for (pi_ptr = linked_proc_desc_table, prev_ptr = NULL;
 582            pi_ptr != NULL;
 583            prev_ptr = pi_ptr, pi_ptr = pi_ptr->next)
 584         {
 585           if (&pi_ptr->info == proc_desc)
 586             break;
 587         }
 588
 589       if (pi_ptr == NULL)
 590         error ("Can't locate dummy extra frame info\n");
 591
 592       if (prev_ptr != NULL)
 593         prev_ptr->next = pi_ptr->next;
 594       else
 595         linked_proc_desc_table = pi_ptr->next;
 596
 597       free (pi_ptr);
 598
 599       write_register (HI_REGNUM, read_memory_integer(new_sp - 8, 4));
 600       write_register (LO_REGNUM, read_memory_integer(new_sp - 12, 4));
 601       if (mips_fpu)
 602         write_register (FCRCS_REGNUM, read_memory_integer(new_sp - 16, 4));
 603     }
 604 }
 605
 606 static void
 607 mips_print_register (regnum, all)
 608      int regnum, all;
 609 {
 610       unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
 611       REGISTER_TYPE val;
 612
 613       /* Get the data in raw format.  */
 614       if (read_relative_register_raw_bytes (regnum, raw_buffer))
 615         {
 616           printf_filtered ("%s: [Invalid]", reg_names[regnum]);
 617           return;
 618         }
 619
 620       /* If an even floating pointer register, also print as double. */
 621       if (regnum >= FP0_REGNUM && regnum < FP0_REGNUM+32
 622           && !((regnum-FP0_REGNUM) & 1)) {
 623           char dbuffer[MAX_REGISTER_RAW_SIZE];
 624
 625           read_relative_register_raw_bytes (regnum, dbuffer);
 626           read_relative_register_raw_bytes (regnum+1, dbuffer+4);
 627 #ifdef REGISTER_CONVERT_TO_TYPE
 628           REGISTER_CONVERT_TO_TYPE(regnum, builtin_type_double, dbuffer);
 629 #endif
 630           printf_filtered ("(d%d: ", regnum-FP0_REGNUM);
 631           val_print (builtin_type_double, dbuffer, 0,
 632                      stdout, 0, 1, 0, Val_pretty_default);
 633           printf_filtered ("); ");
 634       }
 635       fputs_filtered (reg_names[regnum], stdout);
 636 #ifndef NUMERIC_REG_NAMES
 637       if (regnum < 32)
 638           printf_filtered ("(r%d): ", regnum);
 639       else
 640 #endif
 641           printf_filtered (": ");
 642
 643       /* If virtual format is floating, print it that way.  */
 644       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT
 645           && ! INVALID_FLOAT (raw_buffer, REGISTER_VIRTUAL_SIZE(regnum))) {
 646           val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0,
 647                      stdout, 0, 1, 0, Val_pretty_default);
 648       }
 649       /* Else print as integer in hex.  */
 650       else
 651         {
 652           long val;
 653
 654           val = extract_signed_integer (raw_buffer,
 655                                         REGISTER_RAW_SIZE (regnum));
 656
 657           if (val == 0)
 658             printf_filtered ("0");
 659           else if (all)
 660             printf_filtered (local_hex_format(), val);
 661           else
 662             printf_filtered ("%s=%d", local_hex_string(val), val);
 663         }
 664 }
 665
 666 /* Replacement for generic do_registers_info.  */
 667 void
 668 mips_do_registers_info (regnum, fpregs)
 669      int regnum;
 670      int fpregs;
 671 {
 672   if (regnum != -1) {
 673       mips_print_register (regnum, 0);
 674       printf_filtered ("\n");
 675   }
 676   else {
 677       for (regnum = 0; regnum < NUM_REGS; ) {
 678           if ((!fpregs) && regnum >= FP0_REGNUM && regnum <= FCRIR_REGNUM) {
 679             regnum++;
 680             continue;
 681           }
 682           mips_print_register (regnum, 1);
 683           regnum++;
 684           if ((regnum & 3) == 0 || regnum == NUM_REGS)
 685               printf_filtered (";\n");
 686           else
 687               printf_filtered ("; ");
 688       }
 689   }
 690 }
 691 /* Return number of args passed to a frame. described by FIP.
 692    Can return -1, meaning no way to tell.  */
 693
 694 int
 695 mips_frame_num_args(fip)
 696         FRAME fip;
 697 {
 698 #if 0
 699         struct chain_info_t *p;
 700
 701         p = mips_find_cached_frame(FRAME_FP(fip));
 702         if (p->valid)
 703                 return p->the_info.numargs;
 704 #endif
 705         return -1;
 706 }
 707 \f
 708 /* Does this instruction involve use of a delay slot?  */
 709 static int
 710 is_delayed (insn)
 711      unsigned long insn;
 712 {
 713   int i;
 714   for (i = 0; i < NUMOPCODES; ++i)
 715     if (mips_opcodes[i].pinfo != INSN_MACRO
 716         && (insn & mips_opcodes[i].mask) == mips_opcodes[i].match)
 717       break;
 718   return i < NUMOPCODES && (mips_opcodes[i].pinfo & ANY_DELAY);
 719 }
 720
 721 /* To skip prologues, I use this predicate.  Returns either PC itself
 722    if the code at PC does not look like a function prologue; otherwise
 723    returns an address that (if we're lucky) follows the prologue.  If
 724    LENIENT, then we must skip everything which is involved in setting
 725    up the frame (it's OK to skip more, just so long as we don't skip
 726    anything which might clobber the registers which are being saved.
 727    We must skip more in the case where part of the prologue is in the
 728    delay slot of a non-prologue instruction).  */
 729
 730 CORE_ADDR
 731 mips_skip_prologue (pc, lenient)
 732      CORE_ADDR pc;
 733      int lenient;
 734 {
 735     struct symbol *f;
 736     struct block *b;
 737     unsigned long inst;
 738     int offset;
 739     int seen_sp_adjust = 0;
 740
 741     /* Skip the typical prologue instructions. These are the stack adjustment
 742        instruction and the instructions that save registers on the stack
 743        or in the gcc frame.  */
 744     for (offset = 0; offset < 100; offset += 4)
 745       {
 746         char buf[4];
 747         int status;
 748
 749         status = read_memory_nobpt (pc + offset, buf, 4);
 750         if (status)
 751           memory_error (status, pc + offset);
 752         inst = extract_unsigned_integer (buf, 4);
 753
 754         if (lenient && is_delayed (inst))
 755           continue;
 756
 757         if ((inst & 0xffff0000) == 0x27bd0000)  /* addiu $sp,$sp,offset */
 758             seen_sp_adjust = 1;
 759         else if ((inst & 0xFFE00000) == 0xAFA00000 && (inst & 0x001F0000))
 760             continue;                           /* sw reg,n($sp) */
 761                                                 /* reg != $zero */
 762         else if ((inst & 0xFFE00000) == 0xE7A00000) /* swc1 freg,n($sp) */
 763             continue;
 764         else if ((inst & 0xF3E00000) == 0xA3C00000 && (inst & 0x001F0000))
 765                                                 /* sx reg,n($s8) */
 766             continue;                           /* reg != $zero */
 767         else if (inst == 0x03A0F021)            /* move $s8,$sp */
 768             continue;
 769         else if ((inst & 0xFF9F07FF) == 0x00800021) /* move reg,$a0-$a3 */
 770             continue;
 771         else
 772             break;
 773     }
 774     return pc + offset;
 775
 776 /* FIXME schauer. The following code seems no longer necessary if we
 777    always skip the typical prologue instructions.  */
 778
 779 #if 0
 780     if (seen_sp_adjust)
 781       return pc + offset;
 782
 783     /* Well, it looks like a frameless. Let's make sure.
 784        Note that we are not called on the current PC,
 785        but on the function`s start PC, and I have definitely
 786        seen optimized code that adjusts the SP quite later */
 787     b = block_for_pc(pc);
 788     if (!b) return pc;
 789
 790     f = lookup_symbol(MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, 0, NULL);
 791     if (!f) return pc;
 792     /* Ideally, I would like to use the adjusted info
 793        from mips_frame_info(), but for all practical
 794        purposes it will not matter (and it would require
 795        a different definition of SKIP_PROLOGUE())
 796
 797        Actually, it would not hurt to skip the storing
 798        of arguments on the stack as well. */
 799     if (((mips_extra_func_info_t)SYMBOL_VALUE(f))->pdr.frameoffset)
 800         return pc + 4;
 801
 802     return pc;
 803 #endif
 804 }
 805
 806 /* Is address PC in the prologue (loosely defined) for function at
 807    STARTADDR?  */
 808
 809 static int
 810 mips_in_lenient_prologue (startaddr, pc)
 811      CORE_ADDR startaddr;
 812      CORE_ADDR pc;
 813 {
 814   CORE_ADDR end_prologue = mips_skip_prologue (startaddr, 1);
 815   return pc >= startaddr && pc < end_prologue;
 816 }
 817
 818 /* Given a return value in `regbuf' with a type `valtype',
 819    extract and copy its value into `valbuf'.  */
 820 void
 821 mips_extract_return_value (valtype, regbuf, valbuf)
 822     struct type *valtype;
 823     char regbuf[REGISTER_BYTES];
 824     char *valbuf;
 825 {
 826   int regnum;
 827
 828   regnum = TYPE_CODE (valtype) == TYPE_CODE_FLT && mips_fpu ? FP0_REGNUM : 2;
 829
 830   memcpy (valbuf, regbuf + REGISTER_BYTE (regnum), TYPE_LENGTH (valtype));
 831 #ifdef REGISTER_CONVERT_TO_TYPE
 832   REGISTER_CONVERT_TO_TYPE(regnum, valtype, valbuf);
 833 #endif
 834 }
 835
 836 /* Given a return value in `regbuf' with a type `valtype',
 837    write it's value into the appropriate register.  */
 838 void
 839 mips_store_return_value (valtype, valbuf)
 840     struct type *valtype;
 841     char *valbuf;
 842 {
 843   int regnum;
 844   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 845
 846   regnum = TYPE_CODE (valtype) == TYPE_CODE_FLT && mips_fpu ? FP0_REGNUM : 2;
 847   memcpy(raw_buffer, valbuf, TYPE_LENGTH (valtype));
 848
 849 #ifdef REGISTER_CONVERT_FROM_TYPE
 850   REGISTER_CONVERT_FROM_TYPE(regnum, valtype, raw_buffer);
 851 #endif
 852
 853   write_register_bytes(REGISTER_BYTE (regnum), raw_buffer, TYPE_LENGTH (valtype));
 854 }
 855
 856 /* Let the user turn off floating point and set the fence post for
 857    heuristic_proc_start.  */
 858
 859 void
 860 _initialize_mips_tdep ()
 861 {
 862   add_show_from_set
 863     (add_set_cmd ("mipsfpu", class_support, var_boolean,
 864                   (char *) &mips_fpu,
 865                   "Set use of floating point coprocessor.\n\
 866 Turn off to avoid using floating point instructions when calling functions\n\
 867 or dealing with return values.", &setlist),
 868      &showlist);
 869
 870   add_show_from_set
 871     (add_set_cmd ("heuristic-fence-post", class_support, var_uinteger,
 872                   (char *) &heuristic_fence_post,
 873                   "Set the distance searched for the start of a function.\n\
 874 Set number of bytes to be searched backward to find the beginning of a\n\
 875 function without symbols.", &setlist),
 876      &showlist);
 877 }