gdb/m-newsos3.h

   1 /* Parameters for execution on a Sony/NEWS with News-OS version 3,
   2    for GDB, the GNU debugger.
   3    Copyright (C) 1989 Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 GDB 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 1, or (at your option)
  10 any later version.
  11
  12 GDB 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 GDB; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20 #define NEWSOS3
  21 #include "m-news.h"
  22
  23 #undef STACK_END_ADDR
  24 /* <machine/vmparam.h> USRSTACK */
  25 #define STACK_END_ADDR  (0x80000000 - UPAGES*NBPG)
  26
  27 /* Have siginterupt on NEWS OS 3.x.  */
  28 #undef NO_SIGINTERRUPT
  29
  30 #undef USE_PCB
  31
  32 /* now old ptrace bug has fixed almost.  Remain constrain is;
  33      When some process do not touch the floating register,
  34      ptrace cannot change the floating register containts.
  35 */
  36 #undef PTRACE_BUG
  37
  38 #undef PUSH_DUMMY_FRAME
  39 #undef POP_FRAME
  40 /* now ptrace has a bug to write floating register in NEWS OS version 2.x */
  41 #define PUSH_DUMMY_FRAME \
  42 { register CORE_ADDR sp = read_register (SP_REGNUM);                    \
  43   register int regnum;                                                  \
  44   char raw_buffer[12];                                                  \
  45   sp = push_word (sp, read_register (PC_REGNUM));                       \
  46   sp = push_word (sp, read_register (FP_REGNUM));                       \
  47   write_register (FP_REGNUM, sp);                                       \
  48   for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)         \
  49     { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);     \
  50       sp = push_bytes (sp, raw_buffer, 12); }                           \
  51   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)                   \
  52     sp = push_word (sp, read_register (regnum));                        \
  53   sp = push_word (sp, read_register (PS_REGNUM));                       \
  54   write_register (SP_REGNUM, sp);  }
  55
  56 /* Discard from the stack the innermost frame, restoring all registers.  */
  57
  58 #define POP_FRAME  \
  59 { register FRAME frame = get_current_frame ();                          \
  60   register CORE_ADDR fp;                                                \
  61   register int regnum;                                                  \
  62   struct frame_saved_regs fsr;                                          \
  63   struct frame_info *fi;                                                \
  64   char raw_buffer[12];                                                  \
  65   fi = get_frame_info (frame);                                          \
  66   fp = fi->frame;                                                       \
  67   get_frame_saved_regs (fi, &fsr);                                      \
  68   for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)         \
  69     if (fsr.regs[regnum])                                               \
  70       { read_memory (fsr.regs[regnum], raw_buffer, 12);                 \
  71         write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
  72   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)                   \
  73     if (fsr.regs[regnum])                                               \
  74       write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
  75   if (fsr.regs[PS_REGNUM])                                              \
  76     write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
  77   write_register (FP_REGNUM, read_memory_integer (fp, 4));              \
  78   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));          \
  79   write_register (SP_REGNUM, fp + 8);                                   \
  80   flush_cached_frames ();                                               \
  81   set_current_frame (create_new_frame (read_register (FP_REGNUM),       \
  82                                        read_pc ())); }
  83
  84 /* NewsOS 3 apparently dies on large alloca's -- roland@ai.mit.edu.  */
  85 #define BROKEN_LARGE_ALLOCA
  86
  87 /* Make this macro from peep of core file.  */
  88 #undef REGISTER_U_ADDR
  89 #ifdef USE_PCB
  90 #define REGISTER_U_ADDR(addr, blockend, regno)          \
  91 {       blockend += 4;  /* why? */ \
  92         if (regno <= FP_REGNUM) \
  93           addr = blockend + regno * 4; \
  94         else if (regno == SP_REGNUM) \
  95           addr = blockend - 4 - 4 * 4; \
  96         else if (regno <= PS_REGNUM) \
  97           addr = blockend - 4 + (regno - PS_REGNUM) * 4; \
  98         else if (regno < FPC_REGNUM) \
  99           addr = blockend + (14 + 1 + 3) * 4 + (regno - FP0_REGNUM) * 12; \
 100         else \
 101           addr = blockend + 15 * 4 + (regno - FPC_REGNUM) * 4; \
 102 }
 103 #else
 104 #define REGISTER_U_ADDR(addr, blockend, regno)          \
 105 {       blockend += 4;  /* why? */ \
 106         if (regno <= FP_REGNUM) \
 107           addr = blockend + regno * 4; \
 108         else if (regno == SP_REGNUM) \
 109           addr = blockend -4 - 4 * 4; \
 110         else if (regno <= PS_REGNUM) \
 111           addr = blockend - 4 + (regno - PS_REGNUM) * 4; \
 112         else if (regno < FPC_REGNUM) \
 113           addr = blockend + (14 + 1 + 3) * 4 + (regno - FP0_REGNUM) * 12; \
 114         else \
 115           addr = blockend + 15 * 4 + (regno - FPC_REGNUM) * 4; \
 116 }
 117 #endif