gdb/tm-np1.h

   1 /* Parameters for targeting on a Gould NP1, for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1993 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_NPL
  21
  22 #define TARGET_BYTE_ORDER BIG_ENDIAN
  23
  24 /* N_ENTRY appears in libraries on Gould machines.
  25    Don't know what 0xa4 is; it's mentioned in stab.h
  26    but only in the sdb symbol list.  */
  27 #define IGNORE_SYMBOL(type) (type == N_ENTRY || type == 0xa4)
  28
  29 /* We don't want the extra gnu symbols on the machine;
  30    they will interfere with the shared segment symbols.  */
  31 #define NO_GNU_STABS
  32
  33 /* Macro for text-offset and data info (in NPL a.out format).  */
  34 #define TEXTINFO                                                \
  35         text_offset = N_TXTOFF (exec_coffhdr, exec_aouthdr);    \
  36         exec_data_offset = N_TXTOFF (exec_coffhdr, exec_aouthdr)\
  37                 + exec_aouthdr.a_text
  38
  39 /* Macro for number of symbol table entries */
  40 #define NUMBER_OF_SYMBOLS                                       \
  41         (coffhdr.f_nsyms)
  42
  43 /* Macro for file-offset of symbol table (in NPL a.out format).  */
  44 #define SYMBOL_TABLE_OFFSET                                     \
  45         N_SYMOFF (coffhdr)
  46
  47 /* Macro for file-offset of string table (in NPL a.out format).  */
  48 #define STRING_TABLE_OFFSET                                     \
  49         (N_STROFF (coffhdr))
  50
  51 /* Macro to store the length of the string table data in INTO.  */
  52 #define READ_STRING_TABLE_SIZE(INTO)                            \
  53         { INTO = hdr.a_stsize; }
  54
  55 /* Macro to declare variables to hold the file's header data.  */
  56 #define DECLARE_FILE_HEADERS  struct exec hdr;                  \
  57                               FILHDR coffhdr
  58
  59 /* Macro to read the header data from descriptor DESC and validate it.
  60    NAME is the file name, for error messages.  */
  61 #define READ_FILE_HEADERS(DESC, NAME)                           \
  62 { val = myread (DESC, &coffhdr, sizeof coffhdr);                \
  63   if (val < 0)                                                  \
  64     perror_with_name (NAME);                                    \
  65   val = myread (DESC, &hdr, sizeof hdr);                        \
  66   if (val < 0)                                                  \
  67     perror_with_name (NAME);                                    \
  68   if (coffhdr.f_magic != GNP1MAGIC)                             \
  69     error ("File \"%s\" not in coff executable format.", NAME); \
  70   if (N_BADMAG (hdr))                                           \
  71     error ("File \"%s\" not in executable format.", NAME); }
  72
  73 /* Define COFF and other symbolic names needed on NP1 */
  74 #define NS32GMAGIC      GNP1MAGIC
  75 #define NS32SMAGIC      GPNMAGIC
  76
  77 /* Address of blocks in N_LBRAC and N_RBRAC symbols are absolute addresses,
  78    not relative to start of source address.  */
  79 #define BLOCK_ADDRESS_ABSOLUTE
  80
  81 /* Offset from address of function to start of its code.
  82    Zero on most machines.  */
  83 #define FUNCTION_START_OFFSET   8
  84
  85 /* Advance PC across any function entry prologue instructions
  86    to reach some "real" code.  One NPL we can have one two startup
  87    sequences depending on the size of the local stack:
  88
  89    Either:
  90       "suabr b2, #"
  91    of
  92       "lil r4, #", "suabr b2, #(r4)"
  93
  94    "lwbr b6, #", "stw r1, 8(b2)"
  95    Optional "stwbr b3, c(b2)"
  96    Optional "trr r2,r7"      (Gould first argument register passing)
  97      or
  98    Optional "stw r2,8(b3)"   (Gould first argument register passing)
  99  */
 100 #define SKIP_PROLOGUE(pc) {                                             \
 101         register int op = read_memory_integer ((pc), 4);                \
 102         if ((op & 0xffff0000) == 0xFA0B0000) {                          \
 103             pc += 4;                                                    \
 104             op = read_memory_integer ((pc), 4);                         \
 105             if ((op & 0xffff0000) == 0x59400000) {                      \
 106                 pc += 4;                                                \
 107                 op = read_memory_integer ((pc), 4);                     \
 108                 if ((op & 0xffff0000) == 0x5F000000) {                  \
 109                     pc += 4;                                            \
 110                     op = read_memory_integer ((pc), 4);                 \
 111                     if (op == 0xD4820008) {                             \
 112                         pc += 4;                                        \
 113                         op = read_memory_integer ((pc), 4);             \
 114                         if (op == 0x5582000C) {                         \
 115                             pc += 4;                                    \
 116                             op = read_memory_integer ((pc), 2);         \
 117                             if (op == 0x2fa0) {                         \
 118                                 pc += 2;                                \
 119                             } else {                                    \
 120                                 op = read_memory_integer ((pc), 4);     \
 121                                 if (op == 0xd5030008) {                 \
 122                                     pc += 4;                            \
 123                                 }                                       \
 124                             }                                           \
 125                         } else {                                        \
 126                             op = read_memory_integer ((pc), 2);         \
 127                             if (op == 0x2fa0) {                         \
 128                                 pc += 2;                                \
 129                             }                                           \
 130                         }                                               \
 131                     }                                                   \
 132                 }                                                       \
 133             }                                                           \
 134         }                                                               \
 135         if ((op & 0xffff0000) == 0x59000000) {                          \
 136             pc += 4;                                                    \
 137             op = read_memory_integer ((pc), 4);                         \
 138             if ((op & 0xffff0000) == 0x5F000000) {                      \
 139                 pc += 4;                                                \
 140                 op = read_memory_integer ((pc), 4);                     \
 141                 if (op == 0xD4820008) {                                 \
 142                     pc += 4;                                            \
 143                     op = read_memory_integer ((pc), 4);                 \
 144                     if (op == 0x5582000C) {                             \
 145                         pc += 4;                                        \
 146                         op = read_memory_integer ((pc), 2);             \
 147                         if (op == 0x2fa0) {                             \
 148                             pc += 2;                                    \
 149                         } else {                                        \
 150                             op = read_memory_integer ((pc), 4);         \
 151                             if (op == 0xd5030008) {                     \
 152                                 pc += 4;                                \
 153                             }                                           \
 154                         }                                               \
 155                     } else {                                            \
 156                         op = read_memory_integer ((pc), 2);             \
 157                         if (op == 0x2fa0) {                             \
 158                             pc += 2;                                    \
 159                         }                                               \
 160                     }                                                   \
 161                 }                                                       \
 162             }                                                           \
 163         }                                                               \
 164 }
 165
 166 /* Immediately after a function call, return the saved pc.
 167    Can't go through the frames for this because on some machines
 168    the new frame is not set up until the new function executes
 169    some instructions.  True on NPL! Return address is in R1.
 170    The true return address is REALLY 4 past that location! */
 171 #define SAVED_PC_AFTER_CALL(frame) \
 172         (read_register(R1_REGNUM) + 4)
 173
 174 /* Address of end of stack space.  */
 175 #define STACK_END_ADDR          0x7fffc000
 176
 177 /* Stack grows downward.  */
 178 #define INNER_THAN              <
 179
 180 /* Sequence of bytes for breakpoint instruction.
 181    This is padded out to the size of a machine word.  When it was just
 182    {0x28, 0x09} it gave problems if hit breakpoint on returning from a
 183    function call.  */
 184 #define BREAKPOINT              {0x28, 0x09, 0x0, 0x0}
 185
 186 /* Amount PC must be decremented by after a breakpoint.
 187    This is often the number of bytes in BREAKPOINT
 188    but not always.  */
 189 #define DECR_PC_AFTER_BREAK     2
 190
 191 /* Nonzero if instruction at PC is a return instruction. "bu 4(r1)" */
 192 #define ABOUT_TO_RETURN(pc)     (read_memory_integer (pc, 4) == 0x40100004)
 193
 194 /* Return 1 if P points to an invalid floating point value.  */
 195 #define INVALID_FLOAT(p, len)   ((*(short *)p & 0xff80) == 0x8000)
 196
 197 /* Say how long (ordinary) registers are.  */
 198 #define REGISTER_TYPE           long
 199
 200 /* Size of bytes of vector register (NP1 only), 32 elements * sizeof(int) */
 201 #define VR_SIZE                 128
 202
 203 /* Number of machine registers */
 204 #define NUM_REGS                27
 205 #define NUM_GEN_REGS            16
 206 #define NUM_CPU_REGS            4
 207 #define NUM_VECTOR_REGS         7
 208
 209 /* Initializer for an array of names of registers.
 210    There should be NUM_REGS strings in this initializer.  */
 211 #define REGISTER_NAMES { \
 212   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
 213   "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", \
 214   "sp", "ps", "pc", "ve", \
 215   "v1", "v2", "v3", "v4", "v5", "v6", "v7", \
 216 }
 217
 218 /* Register numbers of various important registers.
 219    Note that some of these values are "real" register numbers,
 220    and correspond to the general registers of the machine,
 221    and some are "phony" register numbers which are too large
 222    to be actual register numbers as far as the user is concerned
 223    but do serve to get the desired values when passed to read_register.  */
 224 #define R1_REGNUM       1       /* Gr1 => return address of caller */
 225 #define R2_REGNUM       2       /* Gr2 => return value from function */
 226 #define R4_REGNUM       4       /* Gr4 => register save area */
 227 #define R5_REGNUM       5       /* Gr5 => register save area */
 228 #define R6_REGNUM       6       /* Gr6 => register save area */
 229 #define R7_REGNUM       7       /* Gr7 => register save area */
 230 #define B1_REGNUM       9       /* Br1 => start of this code routine */
 231 #define SP_REGNUM       10      /* Br2 == (sp) */
 232 #define AP_REGNUM       11      /* Br3 == (ap) */
 233 #define FP_REGNUM       16      /* A copy of Br2 saved in trap */
 234 #define PS_REGNUM       17      /* Contains processor status */
 235 #define PC_REGNUM       18      /* Contains program counter */
 236 #define VE_REGNUM       19      /* Vector end (user setup) register */
 237 #define V1_REGNUM       20      /* First vector register */
 238 #define V7_REGNUM       26      /* First vector register */
 239
 240 /* Total amount of space needed to store our copies of the machine's
 241    register state, the array `registers'.  */
 242 #define REGISTER_BYTES \
 243         (NUM_GEN_REGS*4 + NUM_VECTOR_REGS*VR_SIZE + NUM_CPU_REGS*4)
 244
 245 /* Index within `registers' of the first byte of the space for
 246    register N.  */
 247 #define REGISTER_BYTE(N)  \
 248         (((N) < V1_REGNUM) ? ((N) * 4) : (((N) - V1_REGNUM) * VR_SIZE) + 80)
 249
 250 /* Number of bytes of storage in the actual machine representation
 251    for register N.  On the NP1, all normal regs are 4 bytes, but
 252    the vector registers are VR_SIZE*4 bytes long. */
 253 #define REGISTER_RAW_SIZE(N) \
 254         (((N) < V1_REGNUM) ? 4 : VR_SIZE)
 255
 256 /* Number of bytes of storage in the program's representation
 257    for register N.  On the NP1, all regs are 4 bytes. */
 258 #define REGISTER_VIRTUAL_SIZE(N) \
 259         (((N) < V1_REGNUM) ? 4 : VR_SIZE)
 260
 261 /* Largest value REGISTER_RAW_SIZE can have.  */
 262 #define MAX_REGISTER_RAW_SIZE           VR_SIZE
 263
 264 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 265 #define MAX_REGISTER_VIRTUAL_SIZE       VR_SIZE
 266
 267 /* Nonzero if register N requires conversion
 268    from raw format to virtual format.  */
 269 #define REGISTER_CONVERTIBLE(N)         (0)
 270
 271 /* Convert data from raw format for register REGNUM
 272    to virtual format for register REGNUM.  */
 273 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)     \
 274         bcopy ((FROM), (TO), REGISTER_RAW_SIZE(REGNUM));
 275
 276 /* Convert data from virtual format for register REGNUM
 277    to raw format for register REGNUM.  */
 278 #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
 279         bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
 280
 281 /* Return the GDB type object for the "standard" data type
 282    of data in register N.  */
 283 #define REGISTER_VIRTUAL_TYPE(N)        \
 284   ((N) > VE_REGNUM ? builtin_type_np1_vector : builtin_type_int)
 285 extern struct type *builtin_type_np1_vector;
 286
 287 /* Store the address of the place in which to copy the structure the
 288    subroutine will return.  This is called from call_function.
 289
 290    On this machine this is a no-op, because gcc isn't used on it
 291    yet.  So this calling convention is not used. */
 292
 293 #define STORE_STRUCT_RETURN(ADDR, SP) push_word(SP + 8, ADDR)
 294
 295 /* Extract from an arrary REGBUF containing the (raw) register state
 296    a function return value of type TYPE, and copy that, in virtual format,
 297    into VALBUF. */
 298
 299 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 300         bcopy (((int *)(REGBUF)) + 2, VALBUF, TYPE_LENGTH (TYPE))
 301
 302 /* Write into appropriate registers a function return value
 303    of type TYPE, given in virtual format.  */
 304
 305 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 306         write_register_bytes (REGISTER_BYTE (R2_REGNUM), VALBUF,      \
 307                               TYPE_LENGTH (TYPE))
 308
 309 /* Extract from an array REGBUF containing the (raw) register state
 310    the address in which a function should return its structure value,
 311    as a CORE_ADDR (or an expression that can be used as one).  */
 312
 313 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*((int *)(REGBUF) + 2))
 314
 315 /* Both gcc and cc return small structs in registers (i.e. in GDB
 316    terminology, small structs don't use the struct return convention).  */
 317 #define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH(type) > 8)
 318 \f
 319 /* Describe the pointer in each stack frame to the previous stack frame
 320    (its caller).  */
 321
 322 /* FRAME_CHAIN takes a frame's nominal address
 323    and produces the frame's chain-pointer.
 324
 325    However, if FRAME_CHAIN_VALID returns zero,
 326    it means the given frame is the outermost one and has no caller.  */
 327
 328 /* In the case of the NPL, the frame's norminal address is Br2 and the
 329    previous routines frame is up the stack X bytes, where X is the
 330    value stored in the code function header xA(Br1). */
 331 #define FRAME_CHAIN(thisframe)          (findframe(thisframe))
 332
 333 #define FRAME_CHAIN_VALID(chain, thisframe) \
 334         (chain != 0 && chain != (thisframe)->frame)
 335
 336 /* Define other aspects of the stack frame on NPL.  */
 337 #define FRAME_SAVED_PC(FRAME) \
 338         (read_memory_integer ((FRAME)->frame + 8, 4))
 339
 340 #define FRAME_ARGS_ADDRESS(fi) \
 341         ((fi)->next_frame ? \
 342          read_memory_integer ((fi)->frame + 12, 4) : \
 343          read_register (AP_REGNUM))
 344
 345 #define FRAME_LOCALS_ADDRESS(fi)        ((fi)->frame)
 346
 347 /* Set VAL to the number of args passed to frame described by FI.
 348    Can set VAL to -1, meaning no way to tell.  */
 349
 350 /* We can check the stab info to see how
 351    many arg we have.  No info in stack will tell us */
 352 #define FRAME_NUM_ARGS(val,fi)          (val = findarg(fi))
 353
 354 /* Return number of bytes at start of arglist that are not really args.  */
 355 #define FRAME_ARGS_SKIP                 8
 356
 357 /* Put here the code to store, into a struct frame_saved_regs,
 358    the addresses of the saved registers of frame described by FRAME_INFO.
 359    This includes special registers such as pc and fp saved in special
 360    ways in the stack frame.  sp is even more special:
 361    the address we return for it IS the sp for the next frame.  */
 362
 363 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)             \
 364 {                                                                       \
 365   bzero (&frame_saved_regs, sizeof frame_saved_regs);                   \
 366   (frame_saved_regs).regs[SP_REGNUM] = framechain (frame_info);         \
 367   (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 8;         \
 368   (frame_saved_regs).regs[R4_REGNUM] = (frame_info)->frame + 0x30;      \
 369   (frame_saved_regs).regs[R5_REGNUM] = (frame_info)->frame + 0x34;      \
 370   (frame_saved_regs).regs[R6_REGNUM] = (frame_info)->frame + 0x38;      \
 371   (frame_saved_regs).regs[R7_REGNUM] = (frame_info)->frame + 0x3C;      \
 372 }
 373 \f
 374 /* Things needed for making the inferior call functions.  */
 375
 376 #define CALL_DUMMY_LOCATION     BEFORE_TEXT_END
 377 #define NEED_TEXT_START_END
 378
 379 /* Push an empty stack frame, to record the current PC, etc.  */
 380
 381 #define PUSH_DUMMY_FRAME \
 382 { register CORE_ADDR sp = read_register (SP_REGNUM); \
 383   register int regnum;                               \
 384   for (regnum = 0; regnum < FP_REGNUM; regnum++)     \
 385     sp = push_word (sp, read_register (regnum));     \
 386   sp = push_word (sp, read_register (PS_REGNUM));    \
 387   sp = push_word (sp, read_register (PC_REGNUM));    \
 388   write_register (SP_REGNUM, sp);}
 389
 390 /* Discard from the stack the innermost frame,
 391    restoring all saved registers.  */
 392
 393 #define POP_FRAME  \
 394 { CORE_ADDR sp = read_register(SP_REGNUM);             \
 395   REGISTER_TYPE reg;                                   \
 396   int regnum;                                          \
 397   for(regnum = 0;regnum < FP_REGNUM;regnum++){         \
 398     sp-=sizeof(REGISTER_TYPE);                         \
 399     read_memory(sp,&reg,sizeof(REGISTER_TYPE));        \
 400     write_register(regnum,reg);}                       \
 401   sp-=sizeof(REGISTER_TYPE);                           \
 402   read_memory(sp,&reg,sizeof(REGISTER_TYPE));          \
 403   write_register(PS_REGNUM,reg);                       \
 404   sp-=sizeof(REGISTER_TYPE);                           \
 405   read_memory(sp,&reg,sizeof(REGISTER_TYPE));          \
 406   write_register(PC_REGNUM,reg);}
 407
 408 /* MJD - Size of dummy frame pushed onto stack by PUSH_DUMMY_FRAME */
 409
 410 #define DUMMY_FRAME_SIZE (0x48)
 411
 412 /* MJD - The sequence of words in the instructions is
 413    halt
 414    halt
 415    halt
 416    halt
 417    subr    b2,stack size,0             grab stack space for dummy call
 418    labr    b3,x0(b2),0                 set AP_REGNUM to point at arguments
 419    lw      r2,x8(b3),0                 load r2 with first argument
 420    lwbr    b1,arguments size(b2),0     load address of function to be called
 421    brlnk   r1,x8(b1),0                 call function
 422    halt
 423    halt
 424    labr    b2,stack size(b2),0         give back stack
 425    break                               break
 426    */
 427
 428 #define CALL_DUMMY {0x00000000,  \
 429                     0x00000000,  \
 430                     0x59000000,  \
 431                     0x598a0000,  \
 432                     0xb5030008,  \
 433                     0x5c820000,  \
 434                     0x44810008,  \
 435                     0x00000000,  \
 436                     0x590a0000,  \
 437                     0x28090000 }
 438
 439 #define CALL_DUMMY_LENGTH 40
 440
 441 #define CALL_DUMMY_START_OFFSET 8
 442
 443 #define CALL_DUMMY_STACK_ADJUST 8
 444
 445 /* MJD - Fixup CALL_DUMMY for the specific function call.
 446    OK heres the problems
 447    1) On a trap there are two copies of the stack pointer, one in SP_REGNUM
 448       which is read/write and one in FP_REGNUM which is only read. It seems
 449       that when restarting the GOULD NP1 uses FP_REGNUM's value.
 450    2) Loading function address into b1 looks a bit difficult if bigger than
 451       0x0000fffc, infact from what I can tell the compiler sets up table of
 452       function address in base3 through which function calls are referenced.
 453
 454    OK my solutions
 455      Calculate the size of the dummy stack frame and do adjustments of
 456      SP_REGNUM in the dummy call.
 457      Push function address onto the stack and load it in the dummy call
 458  */
 459
 460 #define FIX_CALL_DUMMY(dummyname, sp, fun, nargs, args, type, gcc_p) \
 461   {   int i;\
 462       int arg_len = 0, total_len;\
 463       old_sp = push_word(old_sp,fun);\
 464       for(i = nargs - 1;i >= 0;i--)\
 465         arg_len += TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args[i])));\
 466       if(struct_return)\
 467         arg_len += TYPE_LENGTH(value_type);\
 468       total_len = DUMMY_FRAME_SIZE+CALL_DUMMY_STACK_ADJUST+4+arg_len;\
 469       dummyname[0] += total_len;\
 470       dummyname[2] += total_len;\
 471       dummyname[5] += arg_len+CALL_DUMMY_STACK_ADJUST;\
 472       dummyname[8] += total_len;}
 473
 474 /* MJD - So the stack should end up looking like this
 475
 476                    | Normal stack frame  |
 477                    | from normal program |
 478                    | flow                |
 479                    +---------------------+ <- Final sp - 0x08 - argument size
 480                    |                     |    - 0x4 - dummy_frame_size
 481                    | Pushed dummy frame  |
 482                    |  b0-b7, r0-r7       |
 483                    |  pc and ps          |
 484                    |                     |
 485                    +---------------------+
 486                    | Function address    |
 487                    +---------------------+ <- Final sp - 0x8 - arguments size
 488                    |                     |
 489                    |                     |
 490                    |                     |
 491                    |  Arguments to       |
 492                    |       Function      |
 493                    |                     |
 494                    |                     |
 495                    |                     |
 496                    +---------------------+ <- Final sp - 0x8
 497                    | Dummy_stack_adjust  |
 498                    +---------------------+ <- Final sp
 499                    |                     |
 500                    | where call will     |
 501                    |   build frame       |
 502 */