gdb/tm-news.h

   1 /* Parameters for execution on a Sony/NEWS, for GDB, the GNU debugger.
   2    Copyright (C) 1987, 1989 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 GDB is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 GDB is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* See following cpu type determination macro to get the machine type.
  21
  22 Here is an m-news.h file for gdb.  It supports the 68881 registers.
  23                                            by hikichi@srava.sra.junet
  24
  25 * Support Sun assembly format instead of Motorola one.
  26 * Ptrace for handling floating register has a bug(before NEWS OS version 2.2),
  27 * After NEWS OS version 3.2, some of ptrace's bug is fixed.
  28   But we cannot change the floating register(see adb(1) in OS 3.2) yet.  */
  29
  30 /* Define this if the C compiler puts an underscore at the front
  31    of external names before giving them to the linker.  */
  32
  33 #define NAMES_HAVE_UNDERSCORE
  34
  35 /* Symbols on this machine are in DBX format. */
  36 #define READ_DBX_FORMAT
  37
  38 /* Use to compute STACK_END_ADDR.  */
  39 #define TARGET_UPAGES 2
  40 #define TARGET_NBPG 4096
  41
  42 /* Address of end of stack space.  */
  43
  44 #define STACK_END_ADDR (0x80000000 - TARGET_UPAGES * TARGET_NBPG)
  45
  46 /* Extract from an array REGBUF containing the (raw) register state
  47    a function return value of type TYPE, and copy that, in virtual format,
  48    into VALBUF.  */
  49
  50 /* when it return the floating value, use the FP0 in NEWS.  */
  51 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
  52   { if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \
  53       { \
  54         REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM, \
  55                                &REGBUF[REGISTER_BYTE (FP0_REGNUM)], VALBUF); \
  56       } \
  57     else \
  58       bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)); }
  59
  60 /* Write into appropriate registers a function return value
  61    of type TYPE, given in virtual format.  */
  62
  63 /* when it return the floating value, use the FP0 in NEWS.  */
  64 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
  65   { if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \
  66       { \
  67         char raw_buf[REGISTER_RAW_SIZE (FP0_REGNUM)]; \
  68         REGISTER_CONVERT_TO_RAW (FP0_REGNUM, VALBUF, raw_buf); \
  69         write_register_bytes (FP0_REGNUM, \
  70                               raw_buf, REGISTER_RAW_SIZE (FP0_REGNUM)); \
  71       } \
  72     else \
  73       write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)); }
  74
  75 /* Return number of args passed to a frame.
  76    Can return -1, meaning no way to tell.  */
  77
  78 #define FRAME_NUM_ARGS(val, fi)  \
  79 { register CORE_ADDR pc = FRAME_SAVED_PC (fi);                  \
  80   register int insn = 0177777 & read_memory_integer (pc, 2);    \
  81   val = 0;                                                      \
  82   if (insn == 0047757 || insn == 0157374)  /* lea W(sp),sp or addaw #W,sp */ \
  83     val = read_memory_integer (pc + 2, 2);                      \
  84   else if ((insn & 0170777) == 0050217 /* addql #N, sp */       \
  85            || (insn & 0170777) == 0050117)  /* addqw */         \
  86     { val = (insn >> 9) & 7; if (val == 0) val = 8; }           \
  87   else if (insn == 0157774) /* addal #WW, sp */                 \
  88     val = read_memory_integer (pc + 2, 4);                      \
  89   val >>= 2; }
  90
  91 /* Things needed for making the inferior call functions.  */
  92 #define PUSH_DUMMY_FRAME \
  93 { register CORE_ADDR sp = read_register (SP_REGNUM);                    \
  94   register int regnum;                                                  \
  95   char raw_buffer[12];                                                  \
  96   sp = push_word (sp, read_register (PC_REGNUM));                       \
  97   sp = push_word (sp, read_register (FP_REGNUM));                       \
  98   write_register (FP_REGNUM, sp);                                       \
  99   for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)         \
 100     { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);     \
 101       sp = push_bytes (sp, raw_buffer, 12); }                           \
 102   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)                   \
 103     sp = push_word (sp, read_register (regnum));                        \
 104   sp = push_word (sp, read_register (PS_REGNUM));                       \
 105   write_register (SP_REGNUM, sp);  }
 106
 107 /* Discard from the stack the innermost frame, restoring all registers.  */
 108
 109 #define POP_FRAME  \
 110 { register FRAME frame = get_current_frame ();                          \
 111   register CORE_ADDR fp;                                                \
 112   register int regnum;                                                  \
 113   struct frame_saved_regs fsr;                                          \
 114   struct frame_info *fi;                                                \
 115   char raw_buffer[12];                                                  \
 116   fi = get_frame_info (frame);                                          \
 117   fp = fi->frame;                                                       \
 118   get_frame_saved_regs (fi, &fsr);                                      \
 119   for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)         \
 120     if (fsr.regs[regnum])                                               \
 121       { read_memory (fsr.regs[regnum], raw_buffer, 12);                 \
 122         write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
 123   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)                   \
 124     if (fsr.regs[regnum])                                               \
 125       write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
 126   if (fsr.regs[PS_REGNUM])                                              \
 127     write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
 128   write_register (FP_REGNUM, read_memory_integer (fp, 4));              \
 129   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));          \
 130   write_register (SP_REGNUM, fp + 8);                                   \
 131   flush_cached_frames ();                                               \
 132   set_current_frame (create_new_frame (read_register (FP_REGNUM),       \
 133                                        read_pc ())); }
 134
 135 /* This sequence of words is the instructions
 136      fmove.m #<f0-f7>,-(sp)
 137      movem.l 0xfffc,-(sp)     ;; no save a6(fp) and a7(sp)
 138      clr.w -(sp)
 139      move.w ccr,-(sp)
 140      /..* The arguments are pushed at this point by GDB;
 141         no code is needed in the dummy for this.
 142         The CALL_DUMMY_START_OFFSET gives the position of
 143         the following jsr instruction.  *../
 144      jbsr (#32323232)
 145      add.l #69696969,sp
 146      bpt
 147      nop
 148 Note this is 24 bytes.
 149 We actually start executing at the jsr, since the pushing of the
 150 registers is done by PUSH_DUMMY_FRAME.  If this were real code,
 151 the arguments for the function called by the jsr would be pushed
 152 between the moveml and the jsr, and we could allow it to execute through.
 153 But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
 154 and we cannot allow the moveml to push the registers again lest they be
 155 taken for the arguments.  */
 156
 157 #define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
 158
 159 #define CALL_DUMMY_LENGTH 28
 160
 161 #define CALL_DUMMY_START_OFFSET 12
 162
 163 /* Insert the specified number of args and function address
 164    into a call sequence of the above form stored at DUMMYNAME.  */
 165
 166 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)     \
 167 { *(int *)((char *) dummyname + 20) = nargs * 4;  \
 168   *(int *)((char *) dummyname + 14) = fun; }
 169 \f
 170 #define HAVE_68881
 171
 172 #include "tm-68k.h"