gdb/i960-tdep.c

   1 // OBSOLETE /* Target-machine dependent code for the Intel 960
   2 // OBSOLETE
   3 // OBSOLETE    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
   4 // OBSOLETE    2001, 2002 Free Software Foundation, Inc.
   5 // OBSOLETE
   6 // OBSOLETE    Contributed by Intel Corporation.
   7 // OBSOLETE    examine_prologue and other parts contributed by Wind River Systems.
   8 // OBSOLETE
   9 // OBSOLETE    This file is part of GDB.
  10 // OBSOLETE
  11 // OBSOLETE    This program is free software; you can redistribute it and/or modify
  12 // OBSOLETE    it under the terms of the GNU General Public License as published by
  13 // OBSOLETE    the Free Software Foundation; either version 2 of the License, or
  14 // OBSOLETE    (at your option) any later version.
  15 // OBSOLETE
  16 // OBSOLETE    This program is distributed in the hope that it will be useful,
  17 // OBSOLETE    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // OBSOLETE    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // OBSOLETE    GNU General Public License for more details.
  20 // OBSOLETE
  21 // OBSOLETE    You should have received a copy of the GNU General Public License
  22 // OBSOLETE    along with this program; if not, write to the Free Software
  23 // OBSOLETE    Foundation, Inc., 59 Temple Place - Suite 330,
  24 // OBSOLETE    Boston, MA 02111-1307, USA.  */
  25 // OBSOLETE
  26 // OBSOLETE #include "defs.h"
  27 // OBSOLETE #include "symtab.h"
  28 // OBSOLETE #include "value.h"
  29 // OBSOLETE #include "frame.h"
  30 // OBSOLETE #include "floatformat.h"
  31 // OBSOLETE #include "target.h"
  32 // OBSOLETE #include "gdbcore.h"
  33 // OBSOLETE #include "inferior.h"
  34 // OBSOLETE #include "regcache.h"
  35 // OBSOLETE #include "gdb_string.h"
  36 // OBSOLETE
  37 // OBSOLETE static CORE_ADDR next_insn (CORE_ADDR memaddr,
  38 // OBSOLETE                         unsigned int *pword1, unsigned int *pword2);
  39 // OBSOLETE
  40 // OBSOLETE struct type *
  41 // OBSOLETE i960_register_type (int regnum)
  42 // OBSOLETE {
  43 // OBSOLETE   if (regnum < FP0_REGNUM)
  44 // OBSOLETE     return builtin_type_int32;
  45 // OBSOLETE   else
  46 // OBSOLETE     return builtin_type_i960_ext;
  47 // OBSOLETE }
  48 // OBSOLETE
  49 // OBSOLETE
  50 // OBSOLETE /* Does the specified function use the "struct returning" convention
  51 // OBSOLETE    or the "value returning" convention?  The "value returning" convention
  52 // OBSOLETE    almost invariably returns the entire value in registers.  The
  53 // OBSOLETE    "struct returning" convention often returns the entire value in
  54 // OBSOLETE    memory, and passes a pointer (out of or into the function) saying
  55 // OBSOLETE    where the value (is or should go).
  56 // OBSOLETE
  57 // OBSOLETE    Since this sometimes depends on whether it was compiled with GCC,
  58 // OBSOLETE    this is also an argument.  This is used in call_function to build a
  59 // OBSOLETE    stack, and in value_being_returned to print return values.
  60 // OBSOLETE
  61 // OBSOLETE    On i960, a structure is returned in registers g0-g3, if it will fit.
  62 // OBSOLETE    If it's more than 16 bytes long, g13 pointed to it on entry.  */
  63 // OBSOLETE
  64 // OBSOLETE int
  65 // OBSOLETE i960_use_struct_convention (int gcc_p, struct type *type)
  66 // OBSOLETE {
  67 // OBSOLETE   return (TYPE_LENGTH (type) > 16);
  68 // OBSOLETE }
  69 // OBSOLETE
  70 // OBSOLETE /* gdb960 is always running on a non-960 host.  Check its characteristics.
  71 // OBSOLETE    This routine must be called as part of gdb initialization.  */
  72 // OBSOLETE
  73 // OBSOLETE static void
  74 // OBSOLETE check_host (void)
  75 // OBSOLETE {
  76 // OBSOLETE   int i;
  77 // OBSOLETE
  78 // OBSOLETE   static struct typestruct
  79 // OBSOLETE     {
  80 // OBSOLETE       int hostsize;         /* Size of type on host         */
  81 // OBSOLETE       int i960size;         /* Size of type on i960         */
  82 // OBSOLETE       char *typename;               /* Name of type, for error msg  */
  83 // OBSOLETE     }
  84 // OBSOLETE   types[] =
  85 // OBSOLETE   {
  86 // OBSOLETE     {
  87 // OBSOLETE       sizeof (short), 2, "short"
  88 // OBSOLETE     }
  89 // OBSOLETE      ,
  90 // OBSOLETE     {
  91 // OBSOLETE       sizeof (int), 4, "int"
  92 // OBSOLETE     }
  93 // OBSOLETE      ,
  94 // OBSOLETE     {
  95 // OBSOLETE       sizeof (long), 4, "long"
  96 // OBSOLETE     }
  97 // OBSOLETE      ,
  98 // OBSOLETE     {
  99 // OBSOLETE       sizeof (float), 4, "float"
 100 // OBSOLETE     }
 101 // OBSOLETE      ,
 102 // OBSOLETE     {
 103 // OBSOLETE       sizeof (double), 8, "double"
 104 // OBSOLETE     }
 105 // OBSOLETE      ,
 106 // OBSOLETE     {
 107 // OBSOLETE       sizeof (char *), 4, "pointer"
 108 // OBSOLETE     }
 109 // OBSOLETE      ,
 110 // OBSOLETE   };
 111 // OBSOLETE #define TYPELEN     (sizeof(types) / sizeof(struct typestruct))
 112 // OBSOLETE
 113 // OBSOLETE   /* Make sure that host type sizes are same as i960
 114 // OBSOLETE    */
 115 // OBSOLETE   for (i = 0; i < TYPELEN; i++)
 116 // OBSOLETE     {
 117 // OBSOLETE       if (types[i].hostsize != types[i].i960size)
 118 // OBSOLETE     {
 119 // OBSOLETE       printf_unfiltered ("sizeof(%s) != %d:  PROCEED AT YOUR OWN RISK!\n",
 120 // OBSOLETE                          types[i].typename, types[i].i960size);
 121 // OBSOLETE     }
 122 // OBSOLETE
 123 // OBSOLETE     }
 124 // OBSOLETE }
 125 // OBSOLETE \f
 126 // OBSOLETE /* Is this register part of the register window system?  A yes answer
 127 // OBSOLETE    implies that 1) The name of this register will not be the same in
 128 // OBSOLETE    other frames, and 2) This register is automatically "saved" upon
 129 // OBSOLETE    subroutine calls and thus there is no need to search more than one
 130 // OBSOLETE    stack frame for it.
 131 // OBSOLETE
 132 // OBSOLETE    On the i960, in fact, the name of this register in another frame is
 133 // OBSOLETE    "mud" -- there is no overlap between the windows.  Each window is
 134 // OBSOLETE    simply saved into the stack (true for our purposes, after having been
 135 // OBSOLETE    flushed; normally they reside on-chip and are restored from on-chip
 136 // OBSOLETE    without ever going to memory).  */
 137 // OBSOLETE
 138 // OBSOLETE static int
 139 // OBSOLETE register_in_window_p (int regnum)
 140 // OBSOLETE {
 141 // OBSOLETE   return regnum <= R15_REGNUM;
 142 // OBSOLETE }
 143 // OBSOLETE
 144 // OBSOLETE /* i960_find_saved_register ()
 145 // OBSOLETE
 146 // OBSOLETE    Return the address in which frame FRAME's value of register REGNUM
 147 // OBSOLETE    has been saved in memory.  Or return zero if it has not been saved.
 148 // OBSOLETE    If REGNUM specifies the SP, the value we return is actually the SP
 149 // OBSOLETE    value, not an address where it was saved.  */
 150 // OBSOLETE
 151 // OBSOLETE static CORE_ADDR
 152 // OBSOLETE i960_find_saved_register (struct frame_info *frame, int regnum)
 153 // OBSOLETE {
 154 // OBSOLETE   register struct frame_info *frame1 = NULL;
 155 // OBSOLETE   register CORE_ADDR addr = 0;
 156 // OBSOLETE
 157 // OBSOLETE   if (frame == NULL)                /* No regs saved if want current frame */
 158 // OBSOLETE     return 0;
 159 // OBSOLETE
 160 // OBSOLETE   /* We assume that a register in a register window will only be saved
 161 // OBSOLETE      in one place (since the name changes and/or disappears as you go
 162 // OBSOLETE      towards inner frames), so we only call get_frame_saved_regs on
 163 // OBSOLETE      the current frame.  This is directly in contradiction to the
 164 // OBSOLETE      usage below, which assumes that registers used in a frame must be
 165 // OBSOLETE      saved in a lower (more interior) frame.  This change is a result
 166 // OBSOLETE      of working on a register window machine; get_frame_saved_regs
 167 // OBSOLETE      always returns the registers saved within a frame, within the
 168 // OBSOLETE      context (register namespace) of that frame. */
 169 // OBSOLETE
 170 // OBSOLETE   /* However, note that we don't want this to return anything if
 171 // OBSOLETE      nothing is saved (if there's a frame inside of this one).  Also,
 172 // OBSOLETE      callers to this routine asking for the stack pointer want the
 173 // OBSOLETE      stack pointer saved for *this* frame; this is returned from the
 174 // OBSOLETE      next frame.  */
 175 // OBSOLETE
 176 // OBSOLETE   if (register_in_window_p (regnum))
 177 // OBSOLETE     {
 178 // OBSOLETE       frame1 = get_next_frame (frame);
 179 // OBSOLETE       if (!frame1)
 180 // OBSOLETE     return 0;               /* Registers of this frame are active.  */
 181 // OBSOLETE
 182 // OBSOLETE       /* Get the SP from the next frame in; it will be this
 183 // OBSOLETE          current frame.  */
 184 // OBSOLETE       if (regnum != SP_REGNUM)
 185 // OBSOLETE     frame1 = frame;
 186 // OBSOLETE
 187 // OBSOLETE       FRAME_INIT_SAVED_REGS (frame1);
 188 // OBSOLETE       return frame1->saved_regs[regnum];    /* ... which might be zero */
 189 // OBSOLETE     }
 190 // OBSOLETE
 191 // OBSOLETE   /* Note that this next routine assumes that registers used in
 192 // OBSOLETE      frame x will be saved only in the frame that x calls and
 193 // OBSOLETE      frames interior to it.  This is not true on the sparc, but the
 194 // OBSOLETE      above macro takes care of it, so we should be all right. */
 195 // OBSOLETE   while (1)
 196 // OBSOLETE     {
 197 // OBSOLETE       QUIT;
 198 // OBSOLETE       frame1 = get_next_frame (frame);
 199 // OBSOLETE       if (frame1 == 0)
 200 // OBSOLETE     break;
 201 // OBSOLETE       frame = frame1;
 202 // OBSOLETE       FRAME_INIT_SAVED_REGS (frame1);
 203 // OBSOLETE       if (frame1->saved_regs[regnum])
 204 // OBSOLETE     addr = frame1->saved_regs[regnum];
 205 // OBSOLETE     }
 206 // OBSOLETE
 207 // OBSOLETE   return addr;
 208 // OBSOLETE }
 209 // OBSOLETE
 210 // OBSOLETE /* i960_get_saved_register ()
 211 // OBSOLETE
 212 // OBSOLETE    Find register number REGNUM relative to FRAME and put its (raw,
 213 // OBSOLETE    target format) contents in *RAW_BUFFER.  Set *OPTIMIZED if the
 214 // OBSOLETE    variable was optimized out (and thus can't be fetched).  Set *LVAL
 215 // OBSOLETE    to lval_memory, lval_register, or not_lval, depending on whether
 216 // OBSOLETE    the value was fetched from memory, from a register, or in a strange
 217 // OBSOLETE    and non-modifiable way (e.g. a frame pointer which was calculated
 218 // OBSOLETE    rather than fetched).  Set *ADDRP to the address, either in memory
 219 // OBSOLETE    on as a REGISTER_BYTE offset into the registers array.
 220 // OBSOLETE
 221 // OBSOLETE    Note that this implementation never sets *LVAL to not_lval.  But it
 222 // OBSOLETE    can be replaced by defining GET_SAVED_REGISTER and supplying your
 223 // OBSOLETE    own.
 224 // OBSOLETE
 225 // OBSOLETE    The argument RAW_BUFFER must point to aligned memory.  */
 226 // OBSOLETE
 227 // OBSOLETE void
 228 // OBSOLETE i960_get_saved_register (char *raw_buffer,
 229 // OBSOLETE                      int *optimized,
 230 // OBSOLETE                      CORE_ADDR *addrp,
 231 // OBSOLETE                      struct frame_info *frame,
 232 // OBSOLETE                      int regnum,
 233 // OBSOLETE                      enum lval_type *lval)
 234 // OBSOLETE {
 235 // OBSOLETE   CORE_ADDR addr;
 236 // OBSOLETE
 237 // OBSOLETE   if (!target_has_registers)
 238 // OBSOLETE     error ("No registers.");
 239 // OBSOLETE
 240 // OBSOLETE   /* Normal systems don't optimize out things with register numbers.  */
 241 // OBSOLETE   if (optimized != NULL)
 242 // OBSOLETE     *optimized = 0;
 243 // OBSOLETE   addr = i960_find_saved_register (frame, regnum);
 244 // OBSOLETE   if (addr != 0)
 245 // OBSOLETE     {
 246 // OBSOLETE       if (lval != NULL)
 247 // OBSOLETE     *lval = lval_memory;
 248 // OBSOLETE       if (regnum == SP_REGNUM)
 249 // OBSOLETE     {
 250 // OBSOLETE       if (raw_buffer != NULL)
 251 // OBSOLETE         {
 252 // OBSOLETE           /* Put it back in target format.  */
 253 // OBSOLETE           store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
 254 // OBSOLETE                          (LONGEST) addr);
 255 // OBSOLETE         }
 256 // OBSOLETE       if (addrp != NULL)
 257 // OBSOLETE         *addrp = 0;
 258 // OBSOLETE       return;
 259 // OBSOLETE     }
 260 // OBSOLETE       if (raw_buffer != NULL)
 261 // OBSOLETE     target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 262 // OBSOLETE     }
 263 // OBSOLETE   else
 264 // OBSOLETE     {
 265 // OBSOLETE       if (lval != NULL)
 266 // OBSOLETE     *lval = lval_register;
 267 // OBSOLETE       addr = REGISTER_BYTE (regnum);
 268 // OBSOLETE       if (raw_buffer != NULL)
 269 // OBSOLETE     read_register_gen (regnum, raw_buffer);
 270 // OBSOLETE     }
 271 // OBSOLETE   if (addrp != NULL)
 272 // OBSOLETE     *addrp = addr;
 273 // OBSOLETE }
 274 // OBSOLETE \f
 275 // OBSOLETE /* Examine an i960 function prologue, recording the addresses at which
 276 // OBSOLETE    registers are saved explicitly by the prologue code, and returning
 277 // OBSOLETE    the address of the first instruction after the prologue (but not
 278 // OBSOLETE    after the instruction at address LIMIT, as explained below).
 279 // OBSOLETE
 280 // OBSOLETE    LIMIT places an upper bound on addresses of the instructions to be
 281 // OBSOLETE    examined.  If the prologue code scan reaches LIMIT, the scan is
 282 // OBSOLETE    aborted and LIMIT is returned.  This is used, when examining the
 283 // OBSOLETE    prologue for the current frame, to keep examine_prologue () from
 284 // OBSOLETE    claiming that a given register has been saved when in fact the
 285 // OBSOLETE    instruction that saves it has not yet been executed.  LIMIT is used
 286 // OBSOLETE    at other times to stop the scan when we hit code after the true
 287 // OBSOLETE    function prologue (e.g. for the first source line) which might
 288 // OBSOLETE    otherwise be mistaken for function prologue.
 289 // OBSOLETE
 290 // OBSOLETE    The format of the function prologue matched by this routine is
 291 // OBSOLETE    derived from examination of the source to gcc960 1.21, particularly
 292 // OBSOLETE    the routine i960_function_prologue ().  A "regular expression" for
 293 // OBSOLETE    the function prologue is given below:
 294 // OBSOLETE
 295 // OBSOLETE    (lda LRn, g14
 296 // OBSOLETE    mov g14, g[0-7]
 297 // OBSOLETE    (mov 0, g14) | (lda 0, g14))?
 298 // OBSOLETE
 299 // OBSOLETE    (mov[qtl]? g[0-15], r[4-15])*
 300 // OBSOLETE    ((addo [1-31], sp, sp) | (lda n(sp), sp))?
 301 // OBSOLETE    (st[qtl]? g[0-15], n(fp))*
 302 // OBSOLETE
 303 // OBSOLETE    (cmpobne 0, g14, LFn
 304 // OBSOLETE    mov sp, g14
 305 // OBSOLETE    lda 0x30(sp), sp
 306 // OBSOLETE    LFn: stq g0, (g14)
 307 // OBSOLETE    stq g4, 0x10(g14)
 308 // OBSOLETE    stq g8, 0x20(g14))?
 309 // OBSOLETE
 310 // OBSOLETE    (st g14, n(fp))?
 311 // OBSOLETE    (mov g13,r[4-15])?
 312 // OBSOLETE  */
 313 // OBSOLETE
 314 // OBSOLETE /* Macros for extracting fields from i960 instructions.  */
 315 // OBSOLETE
 316 // OBSOLETE #define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos))
 317 // OBSOLETE #define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width))
 318 // OBSOLETE
 319 // OBSOLETE #define REG_SRC1(insn)    EXTRACT_FIELD (insn, 0, 5)
 320 // OBSOLETE #define REG_SRC2(insn)    EXTRACT_FIELD (insn, 14, 5)
 321 // OBSOLETE #define REG_SRCDST(insn)  EXTRACT_FIELD (insn, 19, 5)
 322 // OBSOLETE #define MEM_SRCDST(insn)  EXTRACT_FIELD (insn, 19, 5)
 323 // OBSOLETE #define MEMA_OFFSET(insn) EXTRACT_FIELD (insn, 0, 12)
 324 // OBSOLETE
 325 // OBSOLETE /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
 326 // OBSOLETE    is not the address of a valid instruction, the address of the next
 327 // OBSOLETE    instruction beyond ADDR otherwise.  *PWORD1 receives the first word
 328 // OBSOLETE    of the instruction, and (for two-word instructions), *PWORD2 receives
 329 // OBSOLETE    the second.  */
 330 // OBSOLETE
 331 // OBSOLETE #define NEXT_PROLOGUE_INSN(addr, lim, pword1, pword2) \
 332 // OBSOLETE   (((addr) < (lim)) ? next_insn (addr, pword1, pword2) : 0)
 333 // OBSOLETE
 334 // OBSOLETE static CORE_ADDR
 335 // OBSOLETE examine_prologue (register CORE_ADDR ip, register CORE_ADDR limit,
 336 // OBSOLETE               CORE_ADDR frame_addr, struct frame_saved_regs *fsr)
 337 // OBSOLETE {
 338 // OBSOLETE   register CORE_ADDR next_ip;
 339 // OBSOLETE   register int src, dst;
 340 // OBSOLETE   register unsigned int *pcode;
 341 // OBSOLETE   unsigned int insn1, insn2;
 342 // OBSOLETE   int size;
 343 // OBSOLETE   int within_leaf_prologue;
 344 // OBSOLETE   CORE_ADDR save_addr;
 345 // OBSOLETE   static unsigned int varargs_prologue_code[] =
 346 // OBSOLETE   {
 347 // OBSOLETE     0x3507a00c,                     /* cmpobne 0x0, g14, LFn */
 348 // OBSOLETE     0x5cf01601,                     /* mov sp, g14           */
 349 // OBSOLETE     0x8c086030,                     /* lda 0x30(sp), sp      */
 350 // OBSOLETE     0xb2879000,                     /* LFn: stq  g0, (g14)   */
 351 // OBSOLETE     0xb2a7a010,                     /* stq g4, 0x10(g14)     */
 352 // OBSOLETE     0xb2c7a020                      /* stq g8, 0x20(g14)     */
 353 // OBSOLETE   };
 354 // OBSOLETE
 355 // OBSOLETE   /* Accept a leaf procedure prologue code fragment if present.
 356 // OBSOLETE      Note that ip might point to either the leaf or non-leaf
 357 // OBSOLETE      entry point; we look for the non-leaf entry point first:  */
 358 // OBSOLETE
 359 // OBSOLETE   within_leaf_prologue = 0;
 360 // OBSOLETE   if ((next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2))
 361 // OBSOLETE       && ((insn1 & 0xfffff000) == 0x8cf00000        /* lda LRx, g14 (MEMA) */
 362 // OBSOLETE       || (insn1 & 0xfffffc60) == 0x8cf03000))       /* lda LRx, g14 (MEMB) */
 363 // OBSOLETE     {
 364 // OBSOLETE       within_leaf_prologue = 1;
 365 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn1, &insn2);
 366 // OBSOLETE     }
 367 // OBSOLETE
 368 // OBSOLETE   /* Now look for the prologue code at a leaf entry point:  */
 369 // OBSOLETE
 370 // OBSOLETE   if (next_ip
 371 // OBSOLETE       && (insn1 & 0xff87ffff) == 0x5c80161e /* mov g14, gx */
 372 // OBSOLETE       && REG_SRCDST (insn1) <= G0_REGNUM + 7)
 373 // OBSOLETE     {
 374 // OBSOLETE       within_leaf_prologue = 1;
 375 // OBSOLETE       if ((next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn1, &insn2))
 376 // OBSOLETE       && (insn1 == 0x8cf00000       /* lda 0, g14 */
 377 // OBSOLETE           || insn1 == 0x5cf01e00))  /* mov 0, g14 */
 378 // OBSOLETE     {
 379 // OBSOLETE       ip = next_ip;
 380 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2);
 381 // OBSOLETE       within_leaf_prologue = 0;
 382 // OBSOLETE     }
 383 // OBSOLETE     }
 384 // OBSOLETE
 385 // OBSOLETE   /* If something that looks like the beginning of a leaf prologue
 386 // OBSOLETE      has been seen, but the remainder of the prologue is missing, bail.
 387 // OBSOLETE      We don't know what we've got.  */
 388 // OBSOLETE
 389 // OBSOLETE   if (within_leaf_prologue)
 390 // OBSOLETE     return (ip);
 391 // OBSOLETE
 392 // OBSOLETE   /* Accept zero or more instances of "mov[qtl]? gx, ry", where y >= 4.
 393 // OBSOLETE      This may cause us to mistake the moving of a register
 394 // OBSOLETE      parameter to a local register for the saving of a callee-saved
 395 // OBSOLETE      register, but that can't be helped, since with the
 396 // OBSOLETE      "-fcall-saved" flag, any register can be made callee-saved.  */
 397 // OBSOLETE
 398 // OBSOLETE   while (next_ip
 399 // OBSOLETE      && (insn1 & 0xfc802fb0) == 0x5c000610
 400 // OBSOLETE      && (dst = REG_SRCDST (insn1)) >= (R0_REGNUM + 4))
 401 // OBSOLETE     {
 402 // OBSOLETE       src = REG_SRC1 (insn1);
 403 // OBSOLETE       size = EXTRACT_FIELD (insn1, 24, 2) + 1;
 404 // OBSOLETE       save_addr = frame_addr + ((dst - R0_REGNUM) * 4);
 405 // OBSOLETE       while (size--)
 406 // OBSOLETE     {
 407 // OBSOLETE       fsr->regs[src++] = save_addr;
 408 // OBSOLETE       save_addr += 4;
 409 // OBSOLETE     }
 410 // OBSOLETE       ip = next_ip;
 411 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2);
 412 // OBSOLETE     }
 413 // OBSOLETE
 414 // OBSOLETE   /* Accept an optional "addo n, sp, sp" or "lda n(sp), sp".  */
 415 // OBSOLETE
 416 // OBSOLETE   if (next_ip &&
 417 // OBSOLETE       ((insn1 & 0xffffffe0) == 0x59084800   /* addo n, sp, sp */
 418 // OBSOLETE        || (insn1 & 0xfffff000) == 0x8c086000        /* lda n(sp), sp (MEMA) */
 419 // OBSOLETE        || (insn1 & 0xfffffc60) == 0x8c087400))      /* lda n(sp), sp (MEMB) */
 420 // OBSOLETE     {
 421 // OBSOLETE       ip = next_ip;
 422 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2);
 423 // OBSOLETE     }
 424 // OBSOLETE
 425 // OBSOLETE   /* Accept zero or more instances of "st[qtl]? gx, n(fp)".
 426 // OBSOLETE      This may cause us to mistake the copying of a register
 427 // OBSOLETE      parameter to the frame for the saving of a callee-saved
 428 // OBSOLETE      register, but that can't be helped, since with the
 429 // OBSOLETE      "-fcall-saved" flag, any register can be made callee-saved.
 430 // OBSOLETE      We can, however, refuse to accept a save of register g14,
 431 // OBSOLETE      since that is matched explicitly below.  */
 432 // OBSOLETE
 433 // OBSOLETE   while (next_ip &&
 434 // OBSOLETE      ((insn1 & 0xf787f000) == 0x9287e000    /* stl? gx, n(fp) (MEMA) */
 435 // OBSOLETE       || (insn1 & 0xf787fc60) == 0x9287f400         /* stl? gx, n(fp) (MEMB) */
 436 // OBSOLETE       || (insn1 & 0xef87f000) == 0xa287e000         /* st[tq] gx, n(fp) (MEMA) */
 437 // OBSOLETE       || (insn1 & 0xef87fc60) == 0xa287f400)        /* st[tq] gx, n(fp) (MEMB) */
 438 // OBSOLETE      && ((src = MEM_SRCDST (insn1)) != G14_REGNUM))
 439 // OBSOLETE     {
 440 // OBSOLETE       save_addr = frame_addr + ((insn1 & BITMASK (12, 1))
 441 // OBSOLETE                             ? insn2 : MEMA_OFFSET (insn1));
 442 // OBSOLETE       size = (insn1 & BITMASK (29, 1)) ? ((insn1 & BITMASK (28, 1)) ? 4 : 3)
 443 // OBSOLETE     : ((insn1 & BITMASK (27, 1)) ? 2 : 1);
 444 // OBSOLETE       while (size--)
 445 // OBSOLETE     {
 446 // OBSOLETE       fsr->regs[src++] = save_addr;
 447 // OBSOLETE       save_addr += 4;
 448 // OBSOLETE     }
 449 // OBSOLETE       ip = next_ip;
 450 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2);
 451 // OBSOLETE     }
 452 // OBSOLETE
 453 // OBSOLETE   /* Accept the varargs prologue code if present.  */
 454 // OBSOLETE
 455 // OBSOLETE   size = sizeof (varargs_prologue_code) / sizeof (int);
 456 // OBSOLETE   pcode = varargs_prologue_code;
 457 // OBSOLETE   while (size-- && next_ip && *pcode++ == insn1)
 458 // OBSOLETE     {
 459 // OBSOLETE       ip = next_ip;
 460 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2);
 461 // OBSOLETE     }
 462 // OBSOLETE
 463 // OBSOLETE   /* Accept an optional "st g14, n(fp)".  */
 464 // OBSOLETE
 465 // OBSOLETE   if (next_ip &&
 466 // OBSOLETE       ((insn1 & 0xfffff000) == 0x92f7e000   /* st g14, n(fp) (MEMA) */
 467 // OBSOLETE        || (insn1 & 0xfffffc60) == 0x92f7f400))      /* st g14, n(fp) (MEMB) */
 468 // OBSOLETE     {
 469 // OBSOLETE       fsr->regs[G14_REGNUM] = frame_addr + ((insn1 & BITMASK (12, 1))
 470 // OBSOLETE                                         ? insn2 : MEMA_OFFSET (insn1));
 471 // OBSOLETE       ip = next_ip;
 472 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2);
 473 // OBSOLETE     }
 474 // OBSOLETE
 475 // OBSOLETE   /* Accept zero or one instance of "mov g13, ry", where y >= 4.
 476 // OBSOLETE      This is saving the address where a struct should be returned.  */
 477 // OBSOLETE
 478 // OBSOLETE   if (next_ip
 479 // OBSOLETE       && (insn1 & 0xff802fbf) == 0x5c00061d
 480 // OBSOLETE       && (dst = REG_SRCDST (insn1)) >= (R0_REGNUM + 4))
 481 // OBSOLETE     {
 482 // OBSOLETE       save_addr = frame_addr + ((dst - R0_REGNUM) * 4);
 483 // OBSOLETE       fsr->regs[G0_REGNUM + 13] = save_addr;
 484 // OBSOLETE       ip = next_ip;
 485 // OBSOLETE #if 0                               /* We'll need this once there is a subsequent instruction examined. */
 486 // OBSOLETE       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2);
 487 // OBSOLETE #endif
 488 // OBSOLETE     }
 489 // OBSOLETE
 490 // OBSOLETE   return (ip);
 491 // OBSOLETE }
 492 // OBSOLETE
 493 // OBSOLETE /* Given an ip value corresponding to the start of a function,
 494 // OBSOLETE    return the ip of the first instruction after the function
 495 // OBSOLETE    prologue.  */
 496 // OBSOLETE
 497 // OBSOLETE CORE_ADDR
 498 // OBSOLETE i960_skip_prologue (CORE_ADDR ip)
 499 // OBSOLETE {
 500 // OBSOLETE   struct frame_saved_regs saved_regs_dummy;
 501 // OBSOLETE   struct symtab_and_line sal;
 502 // OBSOLETE   CORE_ADDR limit;
 503 // OBSOLETE
 504 // OBSOLETE   sal = find_pc_line (ip, 0);
 505 // OBSOLETE   limit = (sal.end) ? sal.end : 0xffffffff;
 506 // OBSOLETE
 507 // OBSOLETE   return (examine_prologue (ip, limit, (CORE_ADDR) 0, &saved_regs_dummy));
 508 // OBSOLETE }
 509 // OBSOLETE
 510 // OBSOLETE /* Put here the code to store, into a struct frame_saved_regs,
 511 // OBSOLETE    the addresses of the saved registers of frame described by FRAME_INFO.
 512 // OBSOLETE    This includes special registers such as pc and fp saved in special
 513 // OBSOLETE    ways in the stack frame.  sp is even more special:
 514 // OBSOLETE    the address we return for it IS the sp for the next frame.
 515 // OBSOLETE
 516 // OBSOLETE    We cache the result of doing this in the frame_obstack, since it is
 517 // OBSOLETE    fairly expensive.  */
 518 // OBSOLETE
 519 // OBSOLETE void
 520 // OBSOLETE frame_find_saved_regs (struct frame_info *fi, struct frame_saved_regs *fsr)
 521 // OBSOLETE {
 522 // OBSOLETE   register CORE_ADDR next_addr;
 523 // OBSOLETE   register CORE_ADDR *saved_regs;
 524 // OBSOLETE   register int regnum;
 525 // OBSOLETE   register struct frame_saved_regs *cache_fsr;
 526 // OBSOLETE   CORE_ADDR ip;
 527 // OBSOLETE   struct symtab_and_line sal;
 528 // OBSOLETE   CORE_ADDR limit;
 529 // OBSOLETE
 530 // OBSOLETE   if (!fi->fsr)
 531 // OBSOLETE     {
 532 // OBSOLETE       cache_fsr = (struct frame_saved_regs *)
 533 // OBSOLETE     frame_obstack_alloc (sizeof (struct frame_saved_regs));
 534 // OBSOLETE       memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
 535 // OBSOLETE       fi->fsr = cache_fsr;
 536 // OBSOLETE
 537 // OBSOLETE       /* Find the start and end of the function prologue.  If the PC
 538 // OBSOLETE          is in the function prologue, we only consider the part that
 539 // OBSOLETE          has executed already.  */
 540 // OBSOLETE
 541 // OBSOLETE       ip = get_pc_function_start (fi->pc);
 542 // OBSOLETE       sal = find_pc_line (ip, 0);
 543 // OBSOLETE       limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
 544 // OBSOLETE
 545 // OBSOLETE       examine_prologue (ip, limit, fi->frame, cache_fsr);
 546 // OBSOLETE
 547 // OBSOLETE       /* Record the addresses at which the local registers are saved.
 548 // OBSOLETE          Strictly speaking, we should only do this for non-leaf procedures,
 549 // OBSOLETE          but no one will ever look at these values if it is a leaf procedure,
 550 // OBSOLETE          since local registers are always caller-saved.  */
 551 // OBSOLETE
 552 // OBSOLETE       next_addr = (CORE_ADDR) fi->frame;
 553 // OBSOLETE       saved_regs = cache_fsr->regs;
 554 // OBSOLETE       for (regnum = R0_REGNUM; regnum <= R15_REGNUM; regnum++)
 555 // OBSOLETE     {
 556 // OBSOLETE       *saved_regs++ = next_addr;
 557 // OBSOLETE       next_addr += 4;
 558 // OBSOLETE     }
 559 // OBSOLETE
 560 // OBSOLETE       cache_fsr->regs[FP_REGNUM] = cache_fsr->regs[PFP_REGNUM];
 561 // OBSOLETE     }
 562 // OBSOLETE
 563 // OBSOLETE   *fsr = *fi->fsr;
 564 // OBSOLETE
 565 // OBSOLETE   /* Fetch the value of the sp from memory every time, since it
 566 // OBSOLETE      is conceivable that it has changed since the cache was flushed.
 567 // OBSOLETE      This unfortunately undoes much of the savings from caching the
 568 // OBSOLETE      saved register values.  I suggest adding an argument to
 569 // OBSOLETE      get_frame_saved_regs () specifying the register number we're
 570 // OBSOLETE      interested in (or -1 for all registers).  This would be passed
 571 // OBSOLETE      through to FRAME_FIND_SAVED_REGS (), permitting more efficient
 572 // OBSOLETE      computation of saved register addresses (e.g., on the i960,
 573 // OBSOLETE      we don't have to examine the prologue to find local registers).
 574 // OBSOLETE      -- markf@wrs.com
 575 // OBSOLETE      FIXME, we don't need to refetch this, since the cache is cleared
 576 // OBSOLETE      every time the child process is restarted.  If GDB itself
 577 // OBSOLETE      modifies SP, it has to clear the cache by hand (does it?).  -gnu */
 578 // OBSOLETE
 579 // OBSOLETE   fsr->regs[SP_REGNUM] = read_memory_integer (fsr->regs[SP_REGNUM], 4);
 580 // OBSOLETE }
 581 // OBSOLETE
 582 // OBSOLETE /* Return the address of the argument block for the frame
 583 // OBSOLETE    described by FI.  Returns 0 if the address is unknown.  */
 584 // OBSOLETE
 585 // OBSOLETE CORE_ADDR
 586 // OBSOLETE frame_args_address (struct frame_info *fi, int must_be_correct)
 587 // OBSOLETE {
 588 // OBSOLETE   struct frame_saved_regs fsr;
 589 // OBSOLETE   CORE_ADDR ap;
 590 // OBSOLETE
 591 // OBSOLETE   /* If g14 was saved in the frame by the function prologue code, return
 592 // OBSOLETE      the saved value.  If the frame is current and we are being sloppy,
 593 // OBSOLETE      return the value of g14.  Otherwise, return zero.  */
 594 // OBSOLETE
 595 // OBSOLETE   get_frame_saved_regs (fi, &fsr);
 596 // OBSOLETE   if (fsr.regs[G14_REGNUM])
 597 // OBSOLETE     ap = read_memory_integer (fsr.regs[G14_REGNUM], 4);
 598 // OBSOLETE   else
 599 // OBSOLETE     {
 600 // OBSOLETE       if (must_be_correct)
 601 // OBSOLETE     return 0;               /* Don't cache this result */
 602 // OBSOLETE       if (get_next_frame (fi))
 603 // OBSOLETE     ap = 0;
 604 // OBSOLETE       else
 605 // OBSOLETE     ap = read_register (G14_REGNUM);
 606 // OBSOLETE       if (ap == 0)
 607 // OBSOLETE     ap = fi->frame;
 608 // OBSOLETE     }
 609 // OBSOLETE   fi->arg_pointer = ap;             /* Cache it for next time */
 610 // OBSOLETE   return ap;
 611 // OBSOLETE }
 612 // OBSOLETE
 613 // OBSOLETE /* Return the address of the return struct for the frame
 614 // OBSOLETE    described by FI.  Returns 0 if the address is unknown.  */
 615 // OBSOLETE
 616 // OBSOLETE CORE_ADDR
 617 // OBSOLETE frame_struct_result_address (struct frame_info *fi)
 618 // OBSOLETE {
 619 // OBSOLETE   struct frame_saved_regs fsr;
 620 // OBSOLETE   CORE_ADDR ap;
 621 // OBSOLETE
 622 // OBSOLETE   /* If the frame is non-current, check to see if g14 was saved in the
 623 // OBSOLETE      frame by the function prologue code; return the saved value if so,
 624 // OBSOLETE      zero otherwise.  If the frame is current, return the value of g14.
 625 // OBSOLETE
 626 // OBSOLETE      FIXME, shouldn't this use the saved value as long as we are past
 627 // OBSOLETE      the function prologue, and only use the current value if we have
 628 // OBSOLETE      no saved value and are at TOS?   -- gnu@cygnus.com */
 629 // OBSOLETE
 630 // OBSOLETE   if (get_next_frame (fi))
 631 // OBSOLETE     {
 632 // OBSOLETE       get_frame_saved_regs (fi, &fsr);
 633 // OBSOLETE       if (fsr.regs[G13_REGNUM])
 634 // OBSOLETE     ap = read_memory_integer (fsr.regs[G13_REGNUM], 4);
 635 // OBSOLETE       else
 636 // OBSOLETE     ap = 0;
 637 // OBSOLETE     }
 638 // OBSOLETE   else
 639 // OBSOLETE     ap = read_register (G13_REGNUM);
 640 // OBSOLETE
 641 // OBSOLETE   return ap;
 642 // OBSOLETE }
 643 // OBSOLETE
 644 // OBSOLETE /* Return address to which the currently executing leafproc will return,
 645 // OBSOLETE    or 0 if IP, the value of the instruction pointer from the currently
 646 // OBSOLETE    executing function, is not in a leafproc (or if we can't tell if it
 647 // OBSOLETE    is).
 648 // OBSOLETE
 649 // OBSOLETE    Do this by finding the starting address of the routine in which IP lies.
 650 // OBSOLETE    If the instruction there is "mov g14, gx" (where x is in [0,7]), this
 651 // OBSOLETE    is a leafproc and the return address is in register gx.  Well, this is
 652 // OBSOLETE    true unless the return address points at a RET instruction in the current
 653 // OBSOLETE    procedure, which indicates that we have a 'dual entry' routine that
 654 // OBSOLETE    has been entered through the CALL entry point.  */
 655 // OBSOLETE
 656 // OBSOLETE CORE_ADDR
 657 // OBSOLETE leafproc_return (CORE_ADDR ip)
 658 // OBSOLETE {
 659 // OBSOLETE   register struct minimal_symbol *msymbol;
 660 // OBSOLETE   char *p;
 661 // OBSOLETE   int dst;
 662 // OBSOLETE   unsigned int insn1, insn2;
 663 // OBSOLETE   CORE_ADDR return_addr;
 664 // OBSOLETE
 665 // OBSOLETE   if ((msymbol = lookup_minimal_symbol_by_pc (ip)) != NULL)
 666 // OBSOLETE     {
 667 // OBSOLETE       if ((p = strchr (SYMBOL_NAME (msymbol), '.')) && STREQ (p, ".lf"))
 668 // OBSOLETE     {
 669 // OBSOLETE       if (next_insn (SYMBOL_VALUE_ADDRESS (msymbol), &insn1, &insn2)
 670 // OBSOLETE           && (insn1 & 0xff87ffff) == 0x5c80161e     /* mov g14, gx */
 671 // OBSOLETE           && (dst = REG_SRCDST (insn1)) <= G0_REGNUM + 7)
 672 // OBSOLETE         {
 673 // OBSOLETE           /* Get the return address.  If the "mov g14, gx"
 674 // OBSOLETE              instruction hasn't been executed yet, read
 675 // OBSOLETE              the return address from g14; otherwise, read it
 676 // OBSOLETE              from the register into which g14 was moved.  */
 677 // OBSOLETE
 678 // OBSOLETE           return_addr =
 679 // OBSOLETE             read_register ((ip == SYMBOL_VALUE_ADDRESS (msymbol))
 680 // OBSOLETE                            ? G14_REGNUM : dst);
 681 // OBSOLETE
 682 // OBSOLETE           /* We know we are in a leaf procedure, but we don't know
 683 // OBSOLETE              whether the caller actually did a "bal" to the ".lf"
 684 // OBSOLETE              entry point, or a normal "call" to the non-leaf entry
 685 // OBSOLETE              point one instruction before.  In the latter case, the
 686 // OBSOLETE              return address will be the address of a "ret"
 687 // OBSOLETE              instruction within the procedure itself.  We test for
 688 // OBSOLETE              this below.  */
 689 // OBSOLETE
 690 // OBSOLETE           if (!next_insn (return_addr, &insn1, &insn2)
 691 // OBSOLETE               || (insn1 & 0xff000000) != 0xa000000  /* ret */
 692 // OBSOLETE               || lookup_minimal_symbol_by_pc (return_addr) != msymbol)
 693 // OBSOLETE             return (return_addr);
 694 // OBSOLETE         }
 695 // OBSOLETE     }
 696 // OBSOLETE     }
 697 // OBSOLETE
 698 // OBSOLETE   return (0);
 699 // OBSOLETE }
 700 // OBSOLETE
 701 // OBSOLETE /* Immediately after a function call, return the saved pc.
 702 // OBSOLETE    Can't go through the frames for this because on some machines
 703 // OBSOLETE    the new frame is not set up until the new function executes
 704 // OBSOLETE    some instructions.
 705 // OBSOLETE    On the i960, the frame *is* set up immediately after the call,
 706 // OBSOLETE    unless the function is a leaf procedure.  */
 707 // OBSOLETE
 708 // OBSOLETE CORE_ADDR
 709 // OBSOLETE saved_pc_after_call (struct frame_info *frame)
 710 // OBSOLETE {
 711 // OBSOLETE   CORE_ADDR saved_pc;
 712 // OBSOLETE
 713 // OBSOLETE   saved_pc = leafproc_return (get_frame_pc (frame));
 714 // OBSOLETE   if (!saved_pc)
 715 // OBSOLETE     saved_pc = FRAME_SAVED_PC (frame);
 716 // OBSOLETE
 717 // OBSOLETE   return saved_pc;
 718 // OBSOLETE }
 719 // OBSOLETE
 720 // OBSOLETE /* Discard from the stack the innermost frame,
 721 // OBSOLETE    restoring all saved registers.  */
 722 // OBSOLETE
 723 // OBSOLETE void
 724 // OBSOLETE i960_pop_frame (void)
 725 // OBSOLETE {
 726 // OBSOLETE   register struct frame_info *current_fi, *prev_fi;
 727 // OBSOLETE   register int i;
 728 // OBSOLETE   CORE_ADDR save_addr;
 729 // OBSOLETE   CORE_ADDR leaf_return_addr;
 730 // OBSOLETE   struct frame_saved_regs fsr;
 731 // OBSOLETE   char local_regs_buf[16 * 4];
 732 // OBSOLETE
 733 // OBSOLETE   current_fi = get_current_frame ();
 734 // OBSOLETE
 735 // OBSOLETE   /* First, undo what the hardware does when we return.
 736 // OBSOLETE      If this is a non-leaf procedure, restore local registers from
 737 // OBSOLETE      the save area in the calling frame.  Otherwise, load the return
 738 // OBSOLETE      address obtained from leafproc_return () into the rip.  */
 739 // OBSOLETE
 740 // OBSOLETE   leaf_return_addr = leafproc_return (current_fi->pc);
 741 // OBSOLETE   if (!leaf_return_addr)
 742 // OBSOLETE     {
 743 // OBSOLETE       /* Non-leaf procedure.  Restore local registers, incl IP.  */
 744 // OBSOLETE       prev_fi = get_prev_frame (current_fi);
 745 // OBSOLETE       read_memory (prev_fi->frame, local_regs_buf, sizeof (local_regs_buf));
 746 // OBSOLETE       write_register_bytes (REGISTER_BYTE (R0_REGNUM), local_regs_buf,
 747 // OBSOLETE                         sizeof (local_regs_buf));
 748 // OBSOLETE
 749 // OBSOLETE       /* Restore frame pointer.  */
 750 // OBSOLETE       write_register (FP_REGNUM, prev_fi->frame);
 751 // OBSOLETE     }
 752 // OBSOLETE   else
 753 // OBSOLETE     {
 754 // OBSOLETE       /* Leaf procedure.  Just restore the return address into the IP.  */
 755 // OBSOLETE       write_register (RIP_REGNUM, leaf_return_addr);
 756 // OBSOLETE     }
 757 // OBSOLETE
 758 // OBSOLETE   /* Now restore any global regs that the current function had saved. */
 759 // OBSOLETE   get_frame_saved_regs (current_fi, &fsr);
 760 // OBSOLETE   for (i = G0_REGNUM; i < G14_REGNUM; i++)
 761 // OBSOLETE     {
 762 // OBSOLETE       save_addr = fsr.regs[i];
 763 // OBSOLETE       if (save_addr != 0)
 764 // OBSOLETE     write_register (i, read_memory_integer (save_addr, 4));
 765 // OBSOLETE     }
 766 // OBSOLETE
 767 // OBSOLETE   /* Flush the frame cache, create a frame for the new innermost frame,
 768 // OBSOLETE      and make it the current frame.  */
 769 // OBSOLETE
 770 // OBSOLETE   flush_cached_frames ();
 771 // OBSOLETE }
 772 // OBSOLETE
 773 // OBSOLETE /* Given a 960 stop code (fault or trace), return the signal which
 774 // OBSOLETE    corresponds.  */
 775 // OBSOLETE
 776 // OBSOLETE enum target_signal
 777 // OBSOLETE i960_fault_to_signal (int fault)
 778 // OBSOLETE {
 779 // OBSOLETE   switch (fault)
 780 // OBSOLETE     {
 781 // OBSOLETE     case 0:
 782 // OBSOLETE       return TARGET_SIGNAL_BUS;     /* parallel fault */
 783 // OBSOLETE     case 1:
 784 // OBSOLETE       return TARGET_SIGNAL_UNKNOWN;
 785 // OBSOLETE     case 2:
 786 // OBSOLETE       return TARGET_SIGNAL_ILL;     /* operation fault */
 787 // OBSOLETE     case 3:
 788 // OBSOLETE       return TARGET_SIGNAL_FPE;     /* arithmetic fault */
 789 // OBSOLETE     case 4:
 790 // OBSOLETE       return TARGET_SIGNAL_FPE;     /* floating point fault */
 791 // OBSOLETE
 792 // OBSOLETE       /* constraint fault.  This appears not to distinguish between
 793 // OBSOLETE          a range constraint fault (which should be SIGFPE) and a privileged
 794 // OBSOLETE          fault (which should be SIGILL).  */
 795 // OBSOLETE     case 5:
 796 // OBSOLETE       return TARGET_SIGNAL_ILL;
 797 // OBSOLETE
 798 // OBSOLETE     case 6:
 799 // OBSOLETE       return TARGET_SIGNAL_SEGV;    /* virtual memory fault */
 800 // OBSOLETE
 801 // OBSOLETE       /* protection fault.  This is for an out-of-range argument to
 802 // OBSOLETE          "calls".  I guess it also could be SIGILL. */
 803 // OBSOLETE     case 7:
 804 // OBSOLETE       return TARGET_SIGNAL_SEGV;
 805 // OBSOLETE
 806 // OBSOLETE     case 8:
 807 // OBSOLETE       return TARGET_SIGNAL_BUS;     /* machine fault */
 808 // OBSOLETE     case 9:
 809 // OBSOLETE       return TARGET_SIGNAL_BUS;     /* structural fault */
 810 // OBSOLETE     case 0xa:
 811 // OBSOLETE       return TARGET_SIGNAL_ILL;     /* type fault */
 812 // OBSOLETE     case 0xb:
 813 // OBSOLETE       return TARGET_SIGNAL_UNKNOWN; /* reserved fault */
 814 // OBSOLETE     case 0xc:
 815 // OBSOLETE       return TARGET_SIGNAL_BUS;     /* process fault */
 816 // OBSOLETE     case 0xd:
 817 // OBSOLETE       return TARGET_SIGNAL_SEGV;    /* descriptor fault */
 818 // OBSOLETE     case 0xe:
 819 // OBSOLETE       return TARGET_SIGNAL_BUS;     /* event fault */
 820 // OBSOLETE     case 0xf:
 821 // OBSOLETE       return TARGET_SIGNAL_UNKNOWN; /* reserved fault */
 822 // OBSOLETE     case 0x10:
 823 // OBSOLETE       return TARGET_SIGNAL_TRAP;    /* single-step trace */
 824 // OBSOLETE     case 0x11:
 825 // OBSOLETE       return TARGET_SIGNAL_TRAP;    /* branch trace */
 826 // OBSOLETE     case 0x12:
 827 // OBSOLETE       return TARGET_SIGNAL_TRAP;    /* call trace */
 828 // OBSOLETE     case 0x13:
 829 // OBSOLETE       return TARGET_SIGNAL_TRAP;    /* return trace */
 830 // OBSOLETE     case 0x14:
 831 // OBSOLETE       return TARGET_SIGNAL_TRAP;    /* pre-return trace */
 832 // OBSOLETE     case 0x15:
 833 // OBSOLETE       return TARGET_SIGNAL_TRAP;    /* supervisor call trace */
 834 // OBSOLETE     case 0x16:
 835 // OBSOLETE       return TARGET_SIGNAL_TRAP;    /* breakpoint trace */
 836 // OBSOLETE     default:
 837 // OBSOLETE       return TARGET_SIGNAL_UNKNOWN;
 838 // OBSOLETE     }
 839 // OBSOLETE }
 840 // OBSOLETE
 841 // OBSOLETE /****************************************/
 842 // OBSOLETE /* MEM format                           */
 843 // OBSOLETE /****************************************/
 844 // OBSOLETE
 845 // OBSOLETE struct tabent
 846 // OBSOLETE {
 847 // OBSOLETE   char *name;
 848 // OBSOLETE   char numops;
 849 // OBSOLETE };
 850 // OBSOLETE
 851 // OBSOLETE /* Return instruction length, either 4 or 8.  When NOPRINT is non-zero
 852 // OBSOLETE    (TRUE), don't output any text.  (Actually, as implemented, if NOPRINT
 853 // OBSOLETE    is 0, abort() is called.) */
 854 // OBSOLETE
 855 // OBSOLETE static int
 856 // OBSOLETE mem (unsigned long memaddr, unsigned long word1, unsigned long word2,
 857 // OBSOLETE      int noprint)
 858 // OBSOLETE {
 859 // OBSOLETE   int i, j;
 860 // OBSOLETE   int len;
 861 // OBSOLETE   int mode;
 862 // OBSOLETE   int offset;
 863 // OBSOLETE   const char *reg1, *reg2, *reg3;
 864 // OBSOLETE
 865 // OBSOLETE   /* This lookup table is too sparse to make it worth typing in, but not
 866 // OBSOLETE    * so large as to make a sparse array necessary.  We allocate the
 867 // OBSOLETE    * table at runtime, initialize all entries to empty, and copy the
 868 // OBSOLETE    * real ones in from an initialization table.
 869 // OBSOLETE    *
 870 // OBSOLETE    * NOTE: In this table, the meaning of 'numops' is:
 871 // OBSOLETE    *       1: single operand
 872 // OBSOLETE    *       2: 2 operands, load instruction
 873 // OBSOLETE    *      -2: 2 operands, store instruction
 874 // OBSOLETE    */
 875 // OBSOLETE   static struct tabent *mem_tab = NULL;
 876 // OBSOLETE /* Opcodes of 0x8X, 9X, aX, bX, and cX must be in the table.  */
 877 // OBSOLETE #define MEM_MIN     0x80
 878 // OBSOLETE #define MEM_MAX     0xcf
 879 // OBSOLETE #define MEM_SIZ     ((MEM_MAX-MEM_MIN+1) * sizeof(struct tabent))
 880 // OBSOLETE
 881 // OBSOLETE   static struct
 882 // OBSOLETE     {
 883 // OBSOLETE       int opcode;
 884 // OBSOLETE       char *name;
 885 // OBSOLETE       char numops;
 886 // OBSOLETE     }
 887 // OBSOLETE   mem_init[] =
 888 // OBSOLETE   {
 889 // OBSOLETE     0x80, "ldob", 2,
 890 // OBSOLETE       0x82, "stob", -2,
 891 // OBSOLETE       0x84, "bx", 1,
 892 // OBSOLETE       0x85, "balx", 2,
 893 // OBSOLETE       0x86, "callx", 1,
 894 // OBSOLETE       0x88, "ldos", 2,
 895 // OBSOLETE       0x8a, "stos", -2,
 896 // OBSOLETE       0x8c, "lda", 2,
 897 // OBSOLETE       0x90, "ld", 2,
 898 // OBSOLETE       0x92, "st", -2,
 899 // OBSOLETE       0x98, "ldl", 2,
 900 // OBSOLETE       0x9a, "stl", -2,
 901 // OBSOLETE       0xa0, "ldt", 2,
 902 // OBSOLETE       0xa2, "stt", -2,
 903 // OBSOLETE       0xb0, "ldq", 2,
 904 // OBSOLETE       0xb2, "stq", -2,
 905 // OBSOLETE       0xc0, "ldib", 2,
 906 // OBSOLETE       0xc2, "stib", -2,
 907 // OBSOLETE       0xc8, "ldis", 2,
 908 // OBSOLETE       0xca, "stis", -2,
 909 // OBSOLETE       0, NULL, 0
 910 // OBSOLETE   };
 911 // OBSOLETE
 912 // OBSOLETE   if (mem_tab == NULL)
 913 // OBSOLETE     {
 914 // OBSOLETE       mem_tab = (struct tabent *) xmalloc (MEM_SIZ);
 915 // OBSOLETE       memset (mem_tab, '\0', MEM_SIZ);
 916 // OBSOLETE       for (i = 0; mem_init[i].opcode != 0; i++)
 917 // OBSOLETE     {
 918 // OBSOLETE       j = mem_init[i].opcode - MEM_MIN;
 919 // OBSOLETE       mem_tab[j].name = mem_init[i].name;
 920 // OBSOLETE       mem_tab[j].numops = mem_init[i].numops;
 921 // OBSOLETE     }
 922 // OBSOLETE     }
 923 // OBSOLETE
 924 // OBSOLETE   i = ((word1 >> 24) & 0xff) - MEM_MIN;
 925 // OBSOLETE   mode = (word1 >> 10) & 0xf;
 926 // OBSOLETE
 927 // OBSOLETE   if ((mem_tab[i].name != NULL)     /* Valid instruction */
 928 // OBSOLETE       && ((mode == 5) || (mode >= 12)))
 929 // OBSOLETE     {                               /* With 32-bit displacement */
 930 // OBSOLETE       len = 8;
 931 // OBSOLETE     }
 932 // OBSOLETE   else
 933 // OBSOLETE     {
 934 // OBSOLETE       len = 4;
 935 // OBSOLETE     }
 936 // OBSOLETE
 937 // OBSOLETE   if (noprint)
 938 // OBSOLETE     {
 939 // OBSOLETE       return len;
 940 // OBSOLETE     }
 941 // OBSOLETE   internal_error (__FILE__, __LINE__, "failed internal consistency check");
 942 // OBSOLETE }
 943 // OBSOLETE
 944 // OBSOLETE /* Read the i960 instruction at 'memaddr' and return the address of
 945 // OBSOLETE    the next instruction after that, or 0 if 'memaddr' is not the
 946 // OBSOLETE    address of a valid instruction.  The first word of the instruction
 947 // OBSOLETE    is stored at 'pword1', and the second word, if any, is stored at
 948 // OBSOLETE    'pword2'.  */
 949 // OBSOLETE
 950 // OBSOLETE static CORE_ADDR
 951 // OBSOLETE next_insn (CORE_ADDR memaddr, unsigned int *pword1, unsigned int *pword2)
 952 // OBSOLETE {
 953 // OBSOLETE   int len;
 954 // OBSOLETE   char buf[8];
 955 // OBSOLETE
 956 // OBSOLETE   /* Read the two (potential) words of the instruction at once,
 957 // OBSOLETE      to eliminate the overhead of two calls to read_memory ().
 958 // OBSOLETE      FIXME: Loses if the first one is readable but the second is not
 959 // OBSOLETE      (e.g. last word of the segment).  */
 960 // OBSOLETE
 961 // OBSOLETE   read_memory (memaddr, buf, 8);
 962 // OBSOLETE   *pword1 = extract_unsigned_integer (buf, 4);
 963 // OBSOLETE   *pword2 = extract_unsigned_integer (buf + 4, 4);
 964 // OBSOLETE
 965 // OBSOLETE   /* Divide instruction set into classes based on high 4 bits of opcode */
 966 // OBSOLETE
 967 // OBSOLETE   switch ((*pword1 >> 28) & 0xf)
 968 // OBSOLETE     {
 969 // OBSOLETE     case 0x0:
 970 // OBSOLETE     case 0x1:                       /* ctrl */
 971 // OBSOLETE
 972 // OBSOLETE     case 0x2:
 973 // OBSOLETE     case 0x3:                       /* cobr */
 974 // OBSOLETE
 975 // OBSOLETE     case 0x5:
 976 // OBSOLETE     case 0x6:
 977 // OBSOLETE     case 0x7:                       /* reg */
 978 // OBSOLETE       len = 4;
 979 // OBSOLETE       break;
 980 // OBSOLETE
 981 // OBSOLETE     case 0x8:
 982 // OBSOLETE     case 0x9:
 983 // OBSOLETE     case 0xa:
 984 // OBSOLETE     case 0xb:
 985 // OBSOLETE     case 0xc:
 986 // OBSOLETE       len = mem (memaddr, *pword1, *pword2, 1);
 987 // OBSOLETE       break;
 988 // OBSOLETE
 989 // OBSOLETE     default:                        /* invalid instruction */
 990 // OBSOLETE       len = 0;
 991 // OBSOLETE       break;
 992 // OBSOLETE     }
 993 // OBSOLETE
 994 // OBSOLETE   if (len)
 995 // OBSOLETE     return memaddr + len;
 996 // OBSOLETE   else
 997 // OBSOLETE     return 0;
 998 // OBSOLETE }
 999 // OBSOLETE
1000 // OBSOLETE /* 'start_frame' is a variable in the MON960 runtime startup routine
1001 // OBSOLETE    that contains the frame pointer of the 'start' routine (the routine
1002 // OBSOLETE    that calls 'main').  By reading its contents out of remote memory,
1003 // OBSOLETE    we can tell where the frame chain ends:  backtraces should halt before
1004 // OBSOLETE    they display this frame.  */
1005 // OBSOLETE
1006 // OBSOLETE int
1007 // OBSOLETE mon960_frame_chain_valid (CORE_ADDR chain, struct frame_info *curframe)
1008 // OBSOLETE {
1009 // OBSOLETE   struct symbol *sym;
1010 // OBSOLETE   struct minimal_symbol *msymbol;
1011 // OBSOLETE
1012 // OBSOLETE   /* crtmon960.o is an assembler module that is assumed to be linked
1013 // OBSOLETE    * first in an i80960 executable.  It contains the true entry point;
1014 // OBSOLETE    * it performs startup up initialization and then calls 'main'.
1015 // OBSOLETE    *
1016 // OBSOLETE    * 'sf' is the name of a variable in crtmon960.o that is set
1017 // OBSOLETE    *      during startup to the address of the first frame.
1018 // OBSOLETE    *
1019 // OBSOLETE    * 'a' is the address of that variable in 80960 memory.
1020 // OBSOLETE    */
1021 // OBSOLETE   static char sf[] = "start_frame";
1022 // OBSOLETE   CORE_ADDR a;
1023 // OBSOLETE
1024 // OBSOLETE
1025 // OBSOLETE   chain &= ~0x3f;           /* Zero low 6 bits because previous frame pointers
1026 // OBSOLETE                                contain return status info in them.  */
1027 // OBSOLETE   if (chain == 0)
1028 // OBSOLETE     {
1029 // OBSOLETE       return 0;
1030 // OBSOLETE     }
1031 // OBSOLETE
1032 // OBSOLETE   sym = lookup_symbol (sf, 0, VAR_NAMESPACE, (int *) NULL,
1033 // OBSOLETE                    (struct symtab **) NULL);
1034 // OBSOLETE   if (sym != 0)
1035 // OBSOLETE     {
1036 // OBSOLETE       a = SYMBOL_VALUE (sym);
1037 // OBSOLETE     }
1038 // OBSOLETE   else
1039 // OBSOLETE     {
1040 // OBSOLETE       msymbol = lookup_minimal_symbol (sf, NULL, NULL);
1041 // OBSOLETE       if (msymbol == NULL)
1042 // OBSOLETE     return 0;
1043 // OBSOLETE       a = SYMBOL_VALUE_ADDRESS (msymbol);
1044 // OBSOLETE     }
1045 // OBSOLETE
1046 // OBSOLETE   return (chain != read_memory_integer (a, 4));
1047 // OBSOLETE }
1048 // OBSOLETE
1049 // OBSOLETE
1050 // OBSOLETE void
1051 // OBSOLETE _initialize_i960_tdep (void)
1052 // OBSOLETE {
1053 // OBSOLETE   check_host ();
1054 // OBSOLETE
1055 // OBSOLETE   tm_print_insn = print_insn_i960;
1056 // OBSOLETE }