contrib/gdb/gdb/config/i386/tm-symmetry.h

   1 /* Target machine definitions for GDB on a Sequent Symmetry under dynix 3.0,
   2    with Weitek 1167 and i387 support.
   3    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
   4    Free Software Foundation, Inc.
   5    Symmetry version by Jay Vosburgh (fubar@sequent.com).
   6
   7 This file is part of GDB.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #ifndef TM_SYMMETRY_H
  24 #define TM_SYMMETRY_H 1
  25
  26 /* I don't know if this will work for cross-debugging, even if you do get
  27    a copy of the right include file.  */
  28 #include <machine/reg.h>
  29
  30 #include "i386/tm-i386v.h"
  31
  32 #undef START_INFERIOR_TRAPS_EXPECTED
  33 #define START_INFERIOR_TRAPS_EXPECTED 2
  34
  35 /* Amount PC must be decremented by after a breakpoint.  This is often the
  36    number of bytes in BREAKPOINT but not always (such as now). */
  37
  38 #undef DECR_PC_AFTER_BREAK
  39 #define DECR_PC_AFTER_BREAK 0
  40
  41 #if 0
  42 /* --- this code can't be used unless we know we are running native,
  43        since it uses host specific ptrace calls. */
  44 /* code for 80387 fpu.  Functions are from i386-dep.c, copied into
  45  * symm-dep.c.
  46  */
  47 #define FLOAT_INFO { i386_float_info(); }
  48 #endif
  49
  50 /* Number of machine registers */
  51
  52 #undef NUM_REGS
  53 #define NUM_REGS 49
  54
  55 /* Initializer for an array of names of registers.
  56    There should be NUM_REGS strings in this initializer.  */
  57
  58 /* Initializer for an array of names of registers.  There should be at least
  59    NUM_REGS strings in this initializer.  Any excess ones are simply ignored.
  60    Symmetry registers are in this weird order to match the register numbers
  61    in the symbol table entries.  If you change the order, things will probably
  62    break mysteriously for no apparent reason.  Also note that the st(0)...
  63    st(7) 387 registers are represented as st0...st7.  */
  64
  65 #undef  REGISTER_NAMES
  66 #define REGISTER_NAMES {     "eax",  "edx",  "ecx",   "st0",  "st1", \
  67                              "ebx",  "esi",  "edi",   "st2",  "st3", \
  68                              "st4",  "st5",  "st6",   "st7",  "esp", \
  69                              "ebp",  "eip",  "eflags","fp1",  "fp2", \
  70                              "fp3",  "fp4",  "fp5",   "fp6",  "fp7", \
  71                              "fp8",  "fp9",  "fp10",  "fp11", "fp12", \
  72                              "fp13", "fp14", "fp15",  "fp16", "fp17", \
  73                              "fp18", "fp19", "fp20",  "fp21", "fp22", \
  74                              "fp23", "fp24", "fp25",  "fp26", "fp27", \
  75                              "fp28", "fp29", "fp30",  "fp31" }
  76
  77 /* Register numbers of various important registers.
  78    Note that some of these values are "real" register numbers,
  79    and correspond to the general registers of the machine,
  80    and some are "phony" register numbers which are too large
  81    to be actual register numbers as far as the user is concerned
  82    but do serve to get the desired values when passed to read_register.  */
  83
  84 #define EAX_REGNUM      0
  85 #define EDX_REGNUM      1
  86 #define ECX_REGNUM      2
  87 #define ST0_REGNUM      3
  88 #define ST1_REGNUM      4
  89 #define EBX_REGNUM      5
  90 #define ESI_REGNUM      6
  91 #define EDI_REGNUM      7
  92 #define ST2_REGNUM      8
  93 #define ST3_REGNUM      9
  94
  95 #define ST4_REGNUM      10
  96 #define ST5_REGNUM      11
  97 #define ST6_REGNUM      12
  98 #define ST7_REGNUM      13
  99
 100 #define FP1_REGNUM 18           /* first 1167 register */
 101 /* Get %fp2 - %fp31 by addition, since they are contiguous */
 102
 103 #undef  SP_REGNUM
 104 #define SP_REGNUM 14    /* (usp) Contains address of top of stack */
 105 #define ESP_REGNUM 14
 106 #undef  FP_REGNUM
 107 #define FP_REGNUM 15    /* (ebp) Contains address of executing stack frame */
 108 #define EBP_REGNUM 15
 109 #undef  PC_REGNUM
 110 #define PC_REGNUM 16    /* (eip) Contains program counter */
 111 #define EIP_REGNUM 16
 112 #undef  PS_REGNUM
 113 #define PS_REGNUM 17    /* (ps)  Contains processor status */
 114 #define EFLAGS_REGNUM 17
 115
 116 /*
 117  * Following macro translates i386 opcode register numbers to Symmetry
 118  * register numbers.  This is used by i386_frame_find_saved_regs.
 119  *
 120  *           %eax  %ecx  %edx  %ebx  %esp  %ebp  %esi  %edi
 121  * i386        0     1     2     3     4     5     6     7
 122  * Symmetry    0     2     1     5    14    15     6     7
 123  *
 124  */
 125 #define I386_REGNO_TO_SYMMETRY(n) \
 126 ((n)==0?0 :(n)==1?2 :(n)==2?1 :(n)==3?5 :(n)==4?14 :(n)==5?15 :(n))
 127
 128 /* The magic numbers below are offsets into u_ar0 in the user struct.
 129  * They live in <machine/reg.h>.  Gdb calls this macro with blockend
 130  * holding u.u_ar0 - KERNEL_U_ADDR.  Only the registers listed are
 131  * saved in the u area (along with a few others that aren't useful
 132  * here.  See <machine/reg.h>).
 133  */
 134
 135 #define REGISTER_U_ADDR(addr, blockend, regno) \
 136 { struct user foo;      /* needed for finding fpu regs */ \
 137 switch (regno) { \
 138     case 0: \
 139       addr = blockend + EAX * sizeof(int); break; \
 140   case 1: \
 141       addr = blockend + EDX * sizeof(int); break; \
 142   case 2: \
 143       addr = blockend + ECX * sizeof(int); break; \
 144   case 3:                       /* st(0) */ \
 145       addr = ((int)&foo.u_fpusave.fpu_stack[0][0] - (int)&foo); \
 146       break; \
 147   case 4:                       /* st(1) */ \
 148       addr = ((int) &foo.u_fpusave.fpu_stack[1][0] - (int)&foo); \
 149       break; \
 150   case 5: \
 151       addr = blockend + EBX * sizeof(int); break; \
 152   case 6: \
 153       addr = blockend + ESI * sizeof(int); break; \
 154   case 7: \
 155       addr = blockend + EDI * sizeof(int); break; \
 156   case 8:                       /* st(2) */ \
 157       addr = ((int) &foo.u_fpusave.fpu_stack[2][0] - (int)&foo); \
 158       break; \
 159   case 9:                       /* st(3) */ \
 160       addr = ((int) &foo.u_fpusave.fpu_stack[3][0] - (int)&foo); \
 161       break; \
 162   case 10:                      /* st(4) */ \
 163       addr = ((int) &foo.u_fpusave.fpu_stack[4][0] - (int)&foo); \
 164       break; \
 165   case 11:                      /* st(5) */ \
 166       addr = ((int) &foo.u_fpusave.fpu_stack[5][0] - (int)&foo); \
 167       break; \
 168   case 12:                      /* st(6) */ \
 169       addr = ((int) &foo.u_fpusave.fpu_stack[6][0] - (int)&foo); \
 170       break; \
 171   case 13:                      /* st(7) */ \
 172       addr = ((int) &foo.u_fpusave.fpu_stack[7][0] - (int)&foo); \
 173       break; \
 174   case 14: \
 175       addr = blockend + ESP * sizeof(int); break; \
 176   case 15: \
 177       addr = blockend + EBP * sizeof(int); break; \
 178   case 16: \
 179       addr = blockend + EIP * sizeof(int); break; \
 180   case 17: \
 181       addr = blockend + FLAGS * sizeof(int); break; \
 182   case 18:                      /* fp1 */ \
 183   case 19:                      /* fp2 */ \
 184   case 20:                      /* fp3 */ \
 185   case 21:                      /* fp4 */ \
 186   case 22:                      /* fp5 */ \
 187   case 23:                      /* fp6 */ \
 188   case 24:                      /* fp7 */ \
 189   case 25:                      /* fp8 */ \
 190   case 26:                      /* fp9 */ \
 191   case 27:                      /* fp10 */ \
 192   case 28:                      /* fp11 */ \
 193   case 29:                      /* fp12 */ \
 194   case 30:                      /* fp13 */ \
 195   case 31:                      /* fp14 */ \
 196   case 32:                      /* fp15 */ \
 197   case 33:                      /* fp16 */ \
 198   case 34:                      /* fp17 */ \
 199   case 35:                      /* fp18 */ \
 200   case 36:                      /* fp19 */ \
 201   case 37:                      /* fp20 */ \
 202   case 38:                      /* fp21 */ \
 203   case 39:                      /* fp22 */ \
 204   case 40:                      /* fp23 */ \
 205   case 41:                      /* fp24 */ \
 206   case 42:                      /* fp25 */ \
 207   case 43:                      /* fp26 */ \
 208   case 44:                      /* fp27 */ \
 209   case 45:                      /* fp28 */ \
 210   case 46:                      /* fp29 */ \
 211   case 47:                      /* fp30 */ \
 212   case 48:                      /* fp31 */ \
 213      addr = ((int) &foo.u_fpasave.fpa_regs[(regno)-18] - (int)&foo); \
 214   } \
 215 }
 216
 217 /* Total amount of space needed to store our copies of the machine's
 218    register state, the array `registers'.  10 i*86 registers, 8 i387
 219    registers, and 31 Weitek 1167 registers */
 220
 221 #undef  REGISTER_BYTES
 222 #define REGISTER_BYTES ((10 * 4) + (8 * 10) + (31 * 4))
 223
 224 /* Index within `registers' of the first byte of the space for
 225    register N.  */
 226
 227 #undef  REGISTER_BYTE
 228 #define REGISTER_BYTE(N)                \
 229 (((N) < 3) ? ((N) * 4) :                \
 230 ((N) < 5) ? ((((N) - 2) * 10) + 2) :    \
 231 ((N) < 8) ? ((((N) - 5) * 4) + 32) :    \
 232 ((N) < 14) ? ((((N) - 8) * 10) + 44) :  \
 233     ((((N) - 14) * 4) + 104))
 234
 235 /* Number of bytes of storage in the actual machine representation
 236  * for register N.  All registers are 4 bytes, except 387 st(0) - st(7),
 237  * which are 80 bits each.
 238  */
 239
 240 #undef  REGISTER_RAW_SIZE
 241 #define REGISTER_RAW_SIZE(N) \
 242 (((N) < 3) ? 4 :        \
 243 ((N) < 5) ? 10 :        \
 244 ((N) < 8) ? 4 :         \
 245 ((N) < 14) ? 10 :       \
 246     4)
 247
 248 /* Nonzero if register N requires conversion
 249    from raw format to virtual format.  */
 250
 251 #undef  REGISTER_CONVERTIBLE
 252 #define REGISTER_CONVERTIBLE(N) \
 253 (((N) < 3) ? 0 : \
 254 ((N) < 5) ? 1  : \
 255 ((N) < 8) ? 0  : \
 256 ((N) < 14) ? 1 : \
 257     0)
 258
 259 #include "floatformat.h"
 260
 261 /* Convert data from raw format for register REGNUM in buffer FROM
 262    to virtual format with type TYPE in buffer TO.  */
 263
 264 #undef REGISTER_CONVERT_TO_VIRTUAL
 265 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \
 266 { \
 267   double val; \
 268   floatformat_to_double (&floatformat_i387_ext, (FROM), &val); \
 269   store_floating ((TO), TYPE_LENGTH (TYPE), val); \
 270 }
 271
 272 /* Convert data from virtual format with type TYPE in buffer FROM
 273    to raw format for register REGNUM in buffer TO.  */
 274
 275 #undef REGISTER_CONVERT_TO_RAW
 276 #define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO) \
 277 { \
 278   double val = extract_floating ((FROM), TYPE_LENGTH (TYPE)); \
 279   floatformat_from_double (&floatformat_i387_ext, &val, (TO)); \
 280 }
 281
 282 /* Return the GDB type object for the "standard" data type
 283    of data in register N.  */
 284
 285 #undef REGISTER_VIRTUAL_TYPE
 286 #define REGISTER_VIRTUAL_TYPE(N) \
 287 ((N < 3) ? builtin_type_int : \
 288 (N < 5) ? builtin_type_double : \
 289 (N < 8) ? builtin_type_int : \
 290 (N < 14) ? builtin_type_double : \
 291     builtin_type_int)
 292
 293 /* Store the address of the place in which to copy the structure the
 294    subroutine will return.  This is called from call_function.
 295    Native cc passes the address in eax, gcc (up to version 2.5.8)
 296    passes it on the stack.  gcc should be fixed in future versions to
 297    adopt native cc conventions.  */
 298
 299 #undef  STORE_STRUCT_RETURN
 300 #define STORE_STRUCT_RETURN(ADDR, SP) write_register(0, (ADDR))
 301
 302 /* Extract from an array REGBUF containing the (raw) register state
 303    a function return value of type TYPE, and copy that, in virtual format,
 304    into VALBUF.  */
 305
 306 #undef  EXTRACT_RETURN_VALUE
 307 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 308   symmetry_extract_return_value(TYPE, REGBUF, VALBUF)
 309
 310 /* The following redefines make backtracing through sigtramp work.
 311    They manufacture a fake sigtramp frame and obtain the saved pc in sigtramp
 312    from the sigcontext structure which is pushed by the kernel on the
 313    user stack, along with a pointer to it.  */
 314
 315 #define IN_SIGTRAMP(pc, name) ((name) && STREQ ("_sigcode", name))
 316
 317 /* Offset to saved PC in sigcontext, from <signal.h>.  */
 318 #define SIGCONTEXT_PC_OFFSET 16
 319
 320 #endif  /* ifndef TM_SYMMETRY_H */
 321