gdb/tm-pn.h

   1 /* Parameters for targe of a Gould Powernode, for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program 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 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program 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 this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #define GOULD_PN
  21
  22 #define TARGET_BYTE_ORDER BIG_ENDIAN
  23
  24 /* This code appears in libraries on Gould machines.  Ignore it. */
  25 #define IGNORE_SYMBOL(type) (type == N_ENTRY)
  26
  27 /* We don't want the extra gnu symbols on the machine;
  28    they will interfere with the shared segment symbols.  */
  29 #define NO_GNU_STABS
  30
  31 /* Macro for text-offset and data info (in PN a.out format).  */
  32 #define TEXTINFO                                                \
  33         text_offset = N_TXTOFF (exec_coffhdr);                  \
  34         exec_data_offset = N_TXTOFF (exec_coffhdr)              \
  35                 + exec_aouthdr.a_text
  36
  37 /* Macro for number of symbol table entries */
  38 #define END_OF_TEXT_DEFAULT                                     \
  39         (0xffffff)
  40
  41 /* Macro for number of symbol table entries */
  42 #define NUMBER_OF_SYMBOLS                                       \
  43         (coffhdr.f_nsyms)
  44
  45 /* Macro for file-offset of symbol table (in usual a.out format).  */
  46 #define SYMBOL_TABLE_OFFSET                                     \
  47         N_SYMOFF (coffhdr)
  48
  49 /* Macro for file-offset of string table (in usual a.out format).  */
  50 #define STRING_TABLE_OFFSET                                     \
  51         (N_STROFF (coffhdr) + sizeof(int))
  52
  53 /* Macro to store the length of the string table data in INTO.  */
  54 #define READ_STRING_TABLE_SIZE(INTO)                            \
  55         { INTO = hdr.a_stsize; }
  56
  57 /* Macro to declare variables to hold the file's header data.  */
  58 #define DECLARE_FILE_HEADERS  struct old_exec hdr;              \
  59                               FILHDR coffhdr
  60
  61 /* Macro to read the header data from descriptor DESC and validate it.
  62    NAME is the file name, for error messages.  */
  63 #define READ_FILE_HEADERS(DESC, NAME)                           \
  64 { val = myread (DESC, &coffhdr, sizeof coffhdr);                \
  65   if (val < 0)                                                  \
  66     perror_with_name (NAME);                                    \
  67   val = myread (DESC, &hdr, sizeof hdr);                        \
  68   if (val < 0)                                                  \
  69     perror_with_name (NAME);                                    \
  70   if (coffhdr.f_magic != GNP1MAGIC)                             \
  71     error ("File \"%s\" not in coff executable format.", NAME); \
  72   if (N_BADMAG (hdr))                                           \
  73     error ("File \"%s\" not in executable format.", NAME); }
  74
  75 /* Define COFF and other symbolic names needed on NP1 */
  76 #define NS32GMAGIC      GDPMAGIC
  77 #define NS32SMAGIC      PN_MAGIC
  78 /* Define this if the C compiler puts an underscore at the front
  79    of external names before giving them to the linker.  */
  80 #define NAMES_HAVE_UNDERSCORE
  81
  82 /* Debugger information will be in DBX format.  */
  83 #define READ_DBX_FORMAT
  84
  85 /* Offset from address of function to start of its code.
  86    Zero on most machines.  */
  87 #define FUNCTION_START_OFFSET   4
  88
  89 /* Advance PC across any function entry prologue instructions
  90    to reach some "real" code.  One PN we can have one or two startup
  91    sequences depending on the size of the local stack:
  92
  93    Either:
  94       "suabr b2, #"
  95    of
  96       "lil r4, #", "suabr b2, #(r4)"
  97
  98    "lwbr b6, #", "stw r1, 8(b2)"
  99    Optional "stwbr b3, c(b2)"
 100    Optional "trr r2,r7"      (Gould first argument register passing)
 101      or
 102    Optional "stw r2,8(b3)"   (Gould first argument register passing)
 103  */
 104 #define SKIP_PROLOGUE(pc) {                                             \
 105         register int op = read_memory_integer ((pc), 4);                \
 106         if ((op & 0xffff0000) == 0x580B0000) {                          \
 107             pc += 4;                                                    \
 108             op = read_memory_integer ((pc), 4);                         \
 109             if ((op & 0xffff0000) == 0x59400000) {                      \
 110                 pc += 4;                                                \
 111                 op = read_memory_integer ((pc), 4);                     \
 112                 if ((op & 0xffff0000) == 0x5F000000) {                  \
 113                     pc += 4;                                            \
 114                     op = read_memory_integer ((pc), 4);                 \
 115                     if (op == 0xD4820008) {                             \
 116                         pc += 4;                                        \
 117                         op = read_memory_integer ((pc), 4);             \
 118                         if (op == 0x5582000C) {                         \
 119                             pc += 4;                                    \
 120                             op = read_memory_integer ((pc), 2);         \
 121                             if (op == 0x2fa0) {                         \
 122                                 pc += 2;                                \
 123                             } else {                                    \
 124                                 op = read_memory_integer ((pc), 4);     \
 125                                 if (op == 0xd5030008) {                 \
 126                                     pc += 4;                            \
 127                                 }                                       \
 128                             }                                           \
 129                         } else {                                        \
 130                             op = read_memory_integer ((pc), 2);         \
 131                             if (op == 0x2fa0) {                         \
 132                                 pc += 2;                                \
 133                             }                                           \
 134                         }                                               \
 135                     }                                                   \
 136                 }                                                       \
 137             }                                                           \
 138         }                                                               \
 139         if ((op & 0xffff0000) == 0x59000000) {                          \
 140             pc += 4;                                                    \
 141             op = read_memory_integer ((pc), 4);                         \
 142             if ((op & 0xffff0000) == 0x5F000000) {                      \
 143                 pc += 4;                                                \
 144                 op = read_memory_integer ((pc), 4);                     \
 145                 if (op == 0xD4820008) {                                 \
 146                     pc += 4;                                            \
 147                     op = read_memory_integer ((pc), 4);                 \
 148                     if (op == 0x5582000C) {                             \
 149                         pc += 4;                                        \
 150                         op = read_memory_integer ((pc), 2);             \
 151                         if (op == 0x2fa0) {                             \
 152                             pc += 2;                                    \
 153                         } else {                                        \
 154                             op = read_memory_integer ((pc), 4);         \
 155                             if (op == 0xd5030008) {                     \
 156                                 pc += 4;                                \
 157                             }                                           \
 158                         }                                               \
 159                     } else {                                            \
 160                         op = read_memory_integer ((pc), 2);             \
 161                         if (op == 0x2fa0) {                             \
 162                             pc += 2;                                    \
 163                         }                                               \
 164                     }                                                   \
 165                 }                                                       \
 166             }                                                           \
 167         }                                                               \
 168 }
 169
 170 /* Immediately after a function call, return the saved pc.
 171    Can't go through the frames for this because on some machines
 172    the new frame is not set up until the new function executes
 173    some instructions.  True on PN!  Return address is in R1.
 174    Note: true return location is 4 bytes past R1! */
 175 #define SAVED_PC_AFTER_CALL(frame) \
 176         (read_register(R1_REGNUM) + 4)
 177
 178 /* Address of end of stack space.  */
 179 #define STACK_END_ADDR          0x480000
 180
 181 /* Stack grows downward.  */
 182 #define INNER_THAN              <
 183
 184 /* Sequence of bytes for breakpoint instruction.  */
 185 #define BREAKPOINT              {0x28, 0x09}
 186
 187 /* Amount PC must be decremented by after a breakpoint.
 188    This is often the number of bytes in BREAKPOINT
 189    but not always.  */
 190 #define DECR_PC_AFTER_BREAK     2
 191
 192 /* Nonzero if instruction at PC is a return instruction. "bu 4(r1)" */
 193 #define ABOUT_TO_RETURN(pc)     (read_memory_integer (pc, 4) == 0xEC100004)
 194
 195 /* Return 1 if P points to an invalid floating point value.  */
 196 #define INVALID_FLOAT(p, len)   ((*(short *)p & 0xff80) == 0x8000)
 197
 198 /* Say how long (ordinary) registers are.  */
 199 #define REGISTER_TYPE           long
 200
 201 /* Number of machine registers */
 202 #define NUM_REGS                19
 203 #define NUM_GEN_REGS            16
 204 #define NUM_CPU_REGS            3
 205
 206 /* Initializer for an array of names of registers.
 207    There should be NUM_REGS strings in this initializer.  */
 208 #define REGISTER_NAMES { \
 209   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
 210   "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", \
 211   "sp", "ps", "pc", \
 212 }
 213
 214 /* Register numbers of various important registers.
 215    Note that some of these values are "real" register numbers,
 216    and correspond to the general registers of the machine,
 217    and some are "phony" register numbers which are too large
 218    to be actual register numbers as far as the user is concerned
 219    but do serve to get the desired values when passed to read_register.  */
 220 #define R1_REGNUM       1       /* Gr1 => return address of caller */
 221 #define R4_REGNUM       4       /* Gr4 => register save area */
 222 #define R5_REGNUM       5       /* Gr5 => register save area */
 223 #define R6_REGNUM       6       /* Gr6 => register save area */
 224 #define R7_REGNUM       7       /* Gr7 => register save area */
 225 #define B1_REGNUM       9       /* Br1 => start of this code routine */
 226 #define FP_REGNUM       10      /* Br2 == (sp) */
 227 #define AP_REGNUM       11      /* Br3 == (ap) */
 228 #define SP_REGNUM       16      /* A copy of Br2 saved in trap */
 229 #define PS_REGNUM       17      /* Contains processor status */
 230 #define PC_REGNUM       18      /* Contains program counter */
 231
 232 /* Total amount of space needed to store our copies of the machine's
 233    register state, the array `registers'.  */
 234 #define REGISTER_BYTES                  (NUM_GEN_REGS*4 + NUM_CPU_REGS*4)
 235
 236 /* Index within `registers' of the first byte of the space for
 237    register N.  */
 238 #define REGISTER_BYTE(N)                ((N) * 4)
 239
 240 /* Number of bytes of storage in the actual machine representation
 241    for register N.  On the PN, all normal regs are 4 bytes. */
 242 #define REGISTER_RAW_SIZE(N)            (4)
 243
 244 /* Number of bytes of storage in the program's representation
 245    for register N.  On the PN, all regs are 4 bytes. */
 246 #define REGISTER_VIRTUAL_SIZE(N)        (4)
 247
 248 /* Largest value REGISTER_RAW_SIZE can have.  */
 249 #define MAX_REGISTER_RAW_SIZE           (4)
 250
 251 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 252 #define MAX_REGISTER_VIRTUAL_SIZE       (4)
 253
 254 /* Nonzero if register N requires conversion
 255    from raw format to virtual format.  */
 256 #define REGISTER_CONVERTIBLE(N)         (0)
 257
 258 /* Convert data from raw format for register REGNUM
 259    to virtual format for register REGNUM.  */
 260 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)     \
 261         bcopy ((FROM), (TO), REGISTER_RAW_SIZE(REGNUM));
 262
 263 /* Convert data from virtual format for register REGNUM
 264    to raw format for register REGNUM.  */
 265 #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
 266         bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
 267
 268 /* Return the GDB type object for the "standard" data type
 269    of data in register N.  */
 270 #define REGISTER_VIRTUAL_TYPE(N)        (builtin_type_int)
 271
 272 /* Store the address of the place in which to copy the structure the
 273    subroutine will return.  This is called from call_function.
 274
 275    On this machine this is a no-op, because gcc isn't used on it
 276    yet.  So this calling convention is not used. */
 277
 278 #define STORE_STRUCT_RETURN(ADDR, SP)
 279
 280 /* Extract from an arrary REGBUF containing the (raw) register state
 281    a function return value of type TYPE, and copy that, in virtual format,
 282    into VALBUF. */
 283
 284 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 285         bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
 286
 287 /* Write into appropriate registers a function return value
 288    of type TYPE, given in virtual format.  */
 289
 290 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 291         write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
 292
 293 /* Extract from an array REGBUF containing the (raw) register state
 294    the address in which a function should return its structure value,
 295    as a CORE_ADDR (or an expression that can be used as one).  */
 296
 297 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
 298
 299 \f
 300 /* Describe the pointer in each stack frame to the previous stack frame
 301    (its caller).  */
 302
 303 /* FRAME_CHAIN takes a frame's nominal address
 304    and produces the frame's chain-pointer.
 305
 306    FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
 307    and produces the nominal address of the caller frame.
 308
 309    However, if FRAME_CHAIN_VALID returns zero,
 310    it means the given frame is the outermost one and has no caller.
 311    In that case, FRAME_CHAIN_COMBINE is not used.  */
 312
 313 /* In the case of the NPL, the frame's norminal address is Br2 and the
 314    previous routines frame is up the stack X bytes, where X is the
 315    value stored in the code function header xA(Br1). */
 316 #define FRAME_CHAIN(thisframe)          (findframe(thisframe))
 317
 318 #define FRAME_CHAIN_VALID(chain, thisframe) \
 319         (chain != 0 && chain != (thisframe)->frame)
 320
 321 #define FRAME_CHAIN_COMBINE(chain, thisframe) \
 322         (chain)
 323
 324 /* Define other aspects of the stack frame on NPL.  */
 325 #define FRAME_SAVED_PC(frame) \
 326         (read_memory_integer ((frame)->frame + 8, 4))
 327
 328 #define FRAME_ARGS_ADDRESS(fi) \
 329         ((fi)->next_frame ? \
 330          read_memory_integer ((fi)->frame + 12, 4) : \
 331          read_register (AP_REGNUM))
 332
 333 #define FRAME_LOCALS_ADDRESS(fi)        ((fi)->frame + 80)
 334
 335 /* Set VAL to the number of args passed to frame described by FI.
 336    Can set VAL to -1, meaning no way to tell.  */
 337
 338 /* We can check the stab info to see how
 339    many arg we have.  No info in stack will tell us */
 340 #define FRAME_NUM_ARGS(val,fi)          (val = findarg(fi))
 341
 342 /* Return number of bytes at start of arglist that are not really args.  */
 343 #define FRAME_ARGS_SKIP                 8
 344
 345 /* Put here the code to store, into a struct frame_saved_regs,
 346    the addresses of the saved registers of frame described by FRAME_INFO.
 347    This includes special registers such as pc and fp saved in special
 348    ways in the stack frame.  sp is even more special:
 349    the address we return for it IS the sp for the next frame.  */
 350
 351 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)             \
 352 {                                                                       \
 353   bzero (&frame_saved_regs, sizeof frame_saved_regs);                   \
 354   (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 8;         \
 355   (frame_saved_regs).regs[R4_REGNUM] = (frame_info)->frame + 0x30;      \
 356   (frame_saved_regs).regs[R5_REGNUM] = (frame_info)->frame + 0x34;      \
 357   (frame_saved_regs).regs[R6_REGNUM] = (frame_info)->frame + 0x38;      \
 358   (frame_saved_regs).regs[R7_REGNUM] = (frame_info)->frame + 0x3C;      \
 359 }
 360 \f
 361 /* Things needed for making the inferior call functions.  */
 362
 363 /* Push an empty stack frame, to record the current PC, etc.  */
 364
 365 #define PUSH_DUMMY_FRAME \
 366 { register CORE_ADDR sp = read_register (SP_REGNUM);                    \
 367   register int regnum;                                                  \
 368   sp = push_word (sp, read_register (PC_REGNUM));                       \
 369   sp = push_word (sp, read_register (FP_REGNUM));                       \
 370   write_register (FP_REGNUM, sp);                                       \
 371   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)                   \
 372     sp = push_word (sp, read_register (regnum));                        \
 373   sp = push_word (sp, read_register (PS_REGNUM));                       \
 374   write_register (SP_REGNUM, sp);  }
 375
 376 /* Discard from the stack the innermost frame,
 377    restoring all saved registers.  */
 378
 379 #define POP_FRAME  \
 380 { register FRAME frame = get_current_frame ();                   \
 381   register CORE_ADDR fp;                                         \
 382   register int regnum;                                           \
 383   struct frame_saved_regs fsr;                                   \
 384   struct frame_info *fi;                                         \
 385   fi = get_frame_info (frame);                                   \
 386   fp = fi->frame;                                                \
 387   get_frame_saved_regs (fi, &fsr);                               \
 388   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)            \
 389     if (fsr.regs[regnum])                                        \
 390       write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
 391   if (fsr.regs[PS_REGNUM])                                       \
 392     write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
 393   write_register (FP_REGNUM, read_memory_integer (fp, 4));       \
 394   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
 395   write_register (SP_REGNUM, fp + 8);                            \
 396   flush_cached_frames ();                                        \
 397   set_current_frame ( create_new_frame (read_register (FP_REGNUM),\
 398                                         read_pc ())); }
 399
 400 /* This sequence of words is the instructions:
 401      halt
 402      halt
 403      halt
 404      halt
 405      suabr      b2, #<stacksize>
 406      lwbr       b6, #con
 407      stw        r1, 8(b2)       - save caller address, do we care?
 408      lw         r2, 60(b2)      - arg1
 409      labr       b3, 50(b2)
 410      std        r4, 30(b2)      - save r4-r7
 411      std        r6, 38(b2)
 412      lwbr       b1, #<func>     - load function call address
 413      brlnk      r1, 8(b1)       - call function
 414      halt
 415      halt
 416      ld         r4, 30(b2)      - restore r4-r7
 417      ld         r6, 38(b2)
 418
 419    Setup our stack frame, load argumemts, call and then restore registers.
 420 */
 421
 422 #define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
 423
 424 #define CALL_DUMMY_LENGTH 28
 425
 426 #define CALL_DUMMY_START_OFFSET 12
 427
 428 /* Insert the specified number of args and function address
 429    into a call sequence of the above form stored at DUMMYNAME.  */
 430
 431 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)     \
 432 { *(int *)((char *) dummyname + 20) = nargs * 4;  \
 433   *(int *)((char *) dummyname + 14) = fun; }