gdb/ns32k-tdep.c

   1 /* Print NS 32000 instructions for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1991, 1992, 1994, 1995
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23
  24 void
  25 _initialize_ns32k_tdep (void)
  26 {
  27   tm_print_insn = print_insn_ns32k;
  28 }
  29
  30 /* Advance PC across any function entry prologue instructions
  31    to reach some "real" code.  */
  32
  33 CORE_ADDR
  34 merlin_skip_prologue (CORE_ADDR pc)
  35 {
  36   register int op = read_memory_integer (pc, 1);
  37   if (op == 0x82)
  38     {
  39       op = read_memory_integer (pc + 2, 1);
  40       if ((op & 0x80) == 0)
  41         pc += 3;
  42       else if ((op & 0xc0) == 0x80)
  43         pc += 4;
  44       else
  45         pc += 6;
  46     }
  47   return pc;
  48 }
  49
  50 CORE_ADDR
  51 umax_skip_prologue (CORE_ADDR pc)
  52 {
  53   register unsigned char op = read_memory_integer (pc, 1);
  54   if (op == 0x82)
  55     {
  56       op = read_memory_integer (pc + 2, 1);
  57       if ((op & 0x80) == 0)
  58         pc += 3;
  59       else if ((op & 0xc0) == 0x80)
  60         pc += 4;
  61       else
  62         pc += 6;
  63     }
  64   return pc;
  65 }
  66
  67 /* Return number of args passed to a frame.
  68    Can return -1, meaning no way to tell.  */
  69
  70 int
  71 merlin_frame_num_args (struct frame_info *fi)
  72 {
  73   int numargs;
  74   CORE_ADDR pc;
  75   int insn;
  76   int addr_mode;
  77   int width;
  78
  79   pc = FRAME_SAVED_PC (fi);
  80   insn = read_memory_integer (pc, 2);
  81   addr_mode = (insn >> 11) & 0x1f;
  82   insn = insn & 0x7ff;
  83   if ((insn & 0x7fc) == 0x57c
  84       && addr_mode == 0x14)     /* immediate */
  85     {
  86       if (insn == 0x57c)        /* adjspb */
  87         width = 1;
  88       else if (insn == 0x57d)   /* adjspw */
  89         width = 2;
  90       else if (insn == 0x57f)   /* adjspd */
  91         width = 4;
  92       numargs = read_memory_integer (pc + 2, width);
  93       if (width > 1)
  94         flip_bytes (&numargs, width);
  95       numargs = -sign_extend (numargs, width * 8) / 4;
  96     }
  97   else
  98     numargs = -1;
  99   return numargs;
 100 }
 101
 102
 103 /* Return number of args passed to a frame.
 104    Can return -1, meaning no way to tell.
 105    Encore's C compiler often reuses same area on stack for args,
 106    so this will often not work properly.  If the arg names
 107    are known, it's likely most of them will be printed. */
 108 int
 109 umax_frame_num_args (struct frame_info *fi)
 110 {
 111   int numargs;
 112   CORE_ADDR pc;
 113   CORE_ADDR enter_addr;
 114   unsigned int insn;
 115   unsigned int addr_mode;
 116   int width;
 117
 118   numargs = -1;
 119   enter_addr = ns32k_get_enter_addr ((fi)->pc);
 120   if (enter_addr > 0)
 121     {
 122       pc = ((enter_addr == 1)
 123             ? SAVED_PC_AFTER_CALL (fi)
 124             : FRAME_SAVED_PC (fi));
 125       insn = read_memory_integer (pc, 2);
 126       addr_mode = (insn >> 11) & 0x1f;
 127       insn = insn & 0x7ff;
 128       if ((insn & 0x7fc) == 0x57c
 129           && addr_mode == 0x14) /* immediate */
 130         {
 131           if (insn == 0x57c)    /* adjspb */
 132             width = 1;
 133           else if (insn == 0x57d)       /* adjspw */
 134             width = 2;
 135           else if (insn == 0x57f)       /* adjspd */
 136             width = 4;
 137           numargs = read_memory_integer (pc + 2, width);
 138           if (width > 1)
 139             flip_bytes (&numargs, width);
 140           numargs = -sign_extend (numargs, width * 8) / 4;
 141         }
 142     }
 143   return numargs;
 144 }
 145
 146
 147 sign_extend (int value, int bits)
 148 {
 149   value = value & ((1 << bits) - 1);
 150   return (value & (1 << (bits - 1))
 151           ? value | (~((1 << bits) - 1))
 152           : value);
 153 }
 154
 155 void
 156 flip_bytes (char *ptr, int count)
 157 {
 158   char tmp;
 159
 160   while (count > 0)
 161     {
 162       tmp = *ptr;
 163       ptr[0] = ptr[count - 1];
 164       ptr[count - 1] = tmp;
 165       ptr++;
 166       count -= 2;
 167     }
 168 }
 169
 170 /* Return the number of locals in the current frame given a pc
 171    pointing to the enter instruction.  This is used in the macro
 172    FRAME_FIND_SAVED_REGS.  */
 173
 174 int
 175 ns32k_localcount (CORE_ADDR enter_pc)
 176 {
 177   unsigned char localtype;
 178   int localcount;
 179
 180   localtype = read_memory_integer (enter_pc + 2, 1);
 181   if ((localtype & 0x80) == 0)
 182     localcount = localtype;
 183   else if ((localtype & 0xc0) == 0x80)
 184     localcount = (((localtype & 0x3f) << 8)
 185                   | (read_memory_integer (enter_pc + 3, 1) & 0xff));
 186   else
 187     localcount = (((localtype & 0x3f) << 24)
 188                   | ((read_memory_integer (enter_pc + 3, 1) & 0xff) << 16)
 189                   | ((read_memory_integer (enter_pc + 4, 1) & 0xff) << 8)
 190                   | (read_memory_integer (enter_pc + 5, 1) & 0xff));
 191   return localcount;
 192 }
 193
 194
 195 /* Nonzero if instruction at PC is a return instruction.  */
 196
 197 static int
 198 ns32k_about_to_return (CORE_ADDR pc)
 199 {
 200   return (read_memory_integer (pc, 1) == 0x12);
 201 }
 202
 203
 204 /*
 205  * Get the address of the enter opcode for the function
 206  * containing PC, if there is an enter for the function,
 207  * and if the pc is between the enter and exit.
 208  * Returns positive address if pc is between enter/exit,
 209  * 1 if pc before enter or after exit, 0 otherwise.
 210  */
 211
 212 CORE_ADDR
 213 ns32k_get_enter_addr (CORE_ADDR pc)
 214 {
 215   CORE_ADDR enter_addr;
 216   unsigned char op;
 217
 218   if (pc == 0)
 219     return 0;
 220
 221   if (ns32k_about_to_return (pc))
 222     return 1;                   /* after exit */
 223
 224   enter_addr = get_pc_function_start (pc);
 225
 226   if (pc == enter_addr)
 227     return 1;                   /* before enter */
 228
 229   op = read_memory_integer (enter_addr, 1);
 230
 231   if (op != 0x82)
 232     return 0;                   /* function has no enter/exit */
 233
 234   return enter_addr;            /* pc is between enter and exit */
 235 }