gdb/config/sparc/tm-sparc.h

   1 /* Target machine sub-parameters for SPARC, for GDB, the GNU debugger.
   2    This is included by other tm-*.h files to define SPARC cpu-related info.
   3    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
   4    Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@mcc.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 #define TARGET_BYTE_ORDER BIG_ENDIAN
  24
  25 /* Floating point is IEEE compatible.  */
  26 #define IEEE_FLOAT
  27
  28 /* If an argument is declared "register", Sun cc will keep it in a register,
  29    never saving it onto the stack.  So we better not believe the "p" symbol
  30    descriptor stab.  */
  31
  32 #define USE_REGISTER_NOT_ARG
  33
  34 /* When passing a structure to a function, Sun cc passes the address
  35    not the structure itself.  It (under SunOS4) creates two symbols,
  36    which we need to combine to a LOC_REGPARM.  Gcc version two (as of
  37    1.92) behaves like sun cc.  REG_STRUCT_HAS_ADDR is smart enough to
  38    distinguish between Sun cc, gcc version 1 and gcc version 2.  */
  39
  40 #define REG_STRUCT_HAS_ADDR(gcc_p,type) (gcc_p != 1)
  41
  42 /* Sun /bin/cc gets this right as of SunOS 4.1.x.  We need to define
  43    BELIEVE_PCC_PROMOTION to get this right now that the code which
  44    detects gcc2_compiled. is broken.  This loses for SunOS 4.0.x and
  45    earlier.  */
  46
  47 #define BELIEVE_PCC_PROMOTION 1
  48
  49 /* For acc, there's no need to correct LBRAC entries by guessing how
  50    they should work.  In fact, this is harmful because the LBRAC
  51    entries now all appear at the end of the function, not intermixed
  52    with the SLINE entries.  n_opt_found detects acc for Solaris binaries;
  53    function_stab_type detects acc for SunOS4 binaries.
  54
  55    For binary from SunOS4 /bin/cc, need to correct LBRAC's.
  56
  57    For gcc, like acc, don't correct.  */
  58
  59 #define SUN_FIXED_LBRAC_BUG \
  60   (n_opt_found \
  61    || function_stab_type == N_STSYM \
  62    || function_stab_type == N_GSYM \
  63    || processing_gcc_compilation)
  64
  65 /* Do variables in the debug stabs occur after the N_LBRAC or before it?
  66    acc: after, gcc: before, SunOS4 /bin/cc: before.  */
  67
  68 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) \
  69   (!(gcc_p) \
  70    && (n_opt_found \
  71        || function_stab_type == N_STSYM \
  72        || function_stab_type == N_GSYM))
  73
  74 /* Offset from address of function to start of its code.
  75    Zero on most machines.  */
  76
  77 #define FUNCTION_START_OFFSET 0
  78
  79 /* Advance PC across any function entry prologue instructions
  80    to reach some "real" code.  SKIP_PROLOGUE_FRAMELESS_P advances
  81    the PC past some of the prologue, but stops as soon as it
  82    knows that the function has a frame.  Its result is equal
  83    to its input PC if the function is frameless, unequal otherwise.  */
  84
  85 #define SKIP_PROLOGUE(pc) \
  86   { pc = skip_prologue (pc, 0); }
  87 #define SKIP_PROLOGUE_FRAMELESS_P(pc) \
  88   { pc = skip_prologue (pc, 1); }
  89 extern CORE_ADDR skip_prologue PARAMS ((CORE_ADDR, int));
  90
  91 /* Immediately after a function call, return the saved pc.
  92    Can't go through the frames for this because on some machines
  93    the new frame is not set up until the new function executes
  94    some instructions.  */
  95
  96 /* On the Sun 4 under SunOS, the compile will leave a fake insn which
  97    encodes the structure size being returned.  If we detect such
  98    a fake insn, step past it.  */
  99
 100 #define PC_ADJUST(pc) sparc_pc_adjust(pc)
 101 extern CORE_ADDR sparc_pc_adjust PARAMS ((CORE_ADDR));
 102
 103 #define SAVED_PC_AFTER_CALL(frame) PC_ADJUST (read_register (RP_REGNUM))
 104
 105 /* Stack grows downward.  */
 106
 107 #define INNER_THAN <
 108
 109 /* Stack must be aligned on 64-bit boundaries when synthesizing
 110    function calls. */
 111
 112 #define STACK_ALIGN(ADDR) (((ADDR) + 7) & -8)
 113
 114 /* Sequence of bytes for breakpoint instruction (ta 1). */
 115
 116 #define BREAKPOINT {0x91, 0xd0, 0x20, 0x01}
 117
 118 /* Amount PC must be decremented by after a breakpoint.
 119    This is often the number of bytes in BREAKPOINT
 120    but not always.  */
 121
 122 #define DECR_PC_AFTER_BREAK 0
 123
 124 /* Nonzero if instruction at PC is a return instruction.  */
 125 /* For SPARC, this is either a "jmpl %o7+8,%g0" or "jmpl %i7+8,%g0".
 126
 127    Note: this does not work for functions returning structures under SunOS.
 128    v9 does not have such critters though.  */
 129 #define ABOUT_TO_RETURN(pc) \
 130   ((read_memory_integer (pc, 4)|0x00040000) == 0x81c7e008)
 131
 132 /* Say how long (ordinary) registers are.  This is a piece of bogosity
 133    used in push_word and a few other places; REGISTER_RAW_SIZE is the
 134    real way to know how big a register is.  */
 135
 136 #define REGISTER_SIZE 4
 137
 138 /* Number of machine registers */
 139
 140 #define NUM_REGS 72
 141
 142 /* Initializer for an array of names of registers.
 143    There should be NUM_REGS strings in this initializer.  */
 144
 145 #define REGISTER_NAMES  \
 146 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",       \
 147   "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",       \
 148   "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",       \
 149   "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",       \
 150                                                                 \
 151   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",       \
 152   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
 153   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",       \
 154   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",       \
 155                                                                 \
 156   "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr" }
 157
 158 /* Register numbers of various important registers.
 159    Note that some of these values are "real" register numbers,
 160    and correspond to the general registers of the machine,
 161    and some are "phony" register numbers which are too large
 162    to be actual register numbers as far as the user is concerned
 163    but do serve to get the desired values when passed to read_register.  */
 164
 165 #define G0_REGNUM 0             /* %g0 */
 166 #define G1_REGNUM 1             /* %g1 */
 167 #define O0_REGNUM 8             /* %o0 */
 168 #define SP_REGNUM 14            /* Contains address of top of stack, \
 169                                    which is also the bottom of the frame.  */
 170 #define RP_REGNUM 15            /* Contains return address value, *before* \
 171                                    any windows get switched.  */
 172 #define O7_REGNUM 15            /* Last local reg not saved on stack frame */
 173 #define L0_REGNUM 16            /* First local reg that's saved on stack frame
 174                                    rather than in machine registers */
 175 #define I0_REGNUM 24            /* %i0 */
 176 #define FP_REGNUM 30            /* Contains address of executing stack frame */
 177 #define I7_REGNUM 31            /* Last local reg saved on stack frame */
 178 #define FP0_REGNUM 32           /* Floating point register 0 */
 179 #define Y_REGNUM 64             /* Temp register for multiplication, etc.  */
 180 #define PS_REGNUM 65            /* Contains processor status */
 181 #define PS_FLAG_CARRY 0x100000  /* Carry bit in PS */
 182 #define WIM_REGNUM 66           /* Window Invalid Mask (not really supported) */
 183 #define TBR_REGNUM 67           /* Trap Base Register (not really supported) */
 184 #define PC_REGNUM 68            /* Contains program counter */
 185 #define NPC_REGNUM 69           /* Contains next PC */
 186 #define FPS_REGNUM 70           /* Floating point status register */
 187 #define CPS_REGNUM 71           /* Coprocessor status register */
 188
 189 /* Total amount of space needed to store our copies of the machine's
 190    register state, the array `registers'.  On the sparc, `registers'
 191    contains the ins and locals, even though they are saved on the
 192    stack rather than with the other registers, and this causes hair
 193    and confusion in places like pop_frame.  It might be
 194    better to remove the ins and locals from `registers', make sure
 195    that get_saved_register can get them from the stack (even in the
 196    innermost frame), and make this the way to access them.  For the
 197    frame pointer we would do that via TARGET_READ_FP.  On the other hand,
 198    that is likely to be confusing or worse for flat frames.  */
 199
 200 #define REGISTER_BYTES (32*4+32*4+8*4)
 201
 202 /* Index within `registers' of the first byte of the space for
 203    register N.  */
 204 /* ?? */
 205 #define REGISTER_BYTE(N)  ((N)*4)
 206
 207 /* We need to override GET_SAVED_REGISTER so that we can deal with the way
 208    outs change into ins in different frames.  HAVE_REGISTER_WINDOWS can't
 209    deal with this case and also handle flat frames at the same time.  */
 210
 211 #define GET_SAVED_REGISTER 1
 212
 213 /* Number of bytes of storage in the actual machine representation
 214    for register N.  */
 215
 216 /* On the SPARC, all regs are 4 bytes.  */
 217
 218 #define REGISTER_RAW_SIZE(N) (4)
 219
 220 /* Number of bytes of storage in the program's representation
 221    for register N.  */
 222
 223 /* On the SPARC, all regs are 4 bytes.  */
 224
 225 #define REGISTER_VIRTUAL_SIZE(N) (4)
 226
 227 /* Largest value REGISTER_RAW_SIZE can have.  */
 228
 229 #define MAX_REGISTER_RAW_SIZE 8
 230
 231 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 232
 233 #define MAX_REGISTER_VIRTUAL_SIZE 8
 234
 235 /* Return the GDB type object for the "standard" data type
 236    of data in register N.  */
 237
 238 #define REGISTER_VIRTUAL_TYPE(N) \
 239  ((N) < 32 ? builtin_type_int : (N) < 64 ? builtin_type_float : \
 240   builtin_type_int)
 241
 242 /* Writing to %g0 is a noop (not an error or exception or anything like
 243    that, however).  */
 244
 245 #define CANNOT_STORE_REGISTER(regno) ((regno) == G0_REGNUM)
 246
 247 /* Store the address of the place in which to copy the structure the
 248    subroutine will return.  This is called from call_function_by_hand. */
 249
 250 #define STORE_STRUCT_RETURN(ADDR, SP) \
 251   { char val[4]; \
 252     store_unsigned_integer (val, 4, (ADDR)); \
 253     write_memory ((SP)+(16*4), val, 4); }
 254
 255 /* Extract from an array REGBUF containing the (raw) register state
 256    a function return value of type TYPE, and copy that, in virtual format,
 257    into VALBUF.  */
 258
 259 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF)              \
 260   {                                                                        \
 261     if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                                 \
 262       {                                                                    \
 263         memcpy ((VALBUF), ((int *)(REGBUF))+FP0_REGNUM, TYPE_LENGTH(TYPE));\
 264       }                                                                    \
 265     else                                                                   \
 266       memcpy ((VALBUF),                                                    \
 267               (char *)(REGBUF) + REGISTER_RAW_SIZE (O0_REGNUM) * 8 +       \
 268               (TYPE_LENGTH(TYPE) >= REGISTER_RAW_SIZE (O0_REGNUM)          \
 269                ? 0 : REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH(TYPE)),   \
 270               TYPE_LENGTH(TYPE));                                          \
 271   }
 272
 273 /* Write into appropriate registers a function return value
 274    of type TYPE, given in virtual format.  */
 275 /* On sparc, values are returned in register %o0.  */
 276 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 277   {                                                                          \
 278     if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                                   \
 279       /* Floating-point values are returned in the register pair */          \
 280       /* formed by %f0 and %f1 (doubles are, anyway).  */                    \
 281       write_register_bytes (REGISTER_BYTE (FP0_REGNUM), (VALBUF),            \
 282                             TYPE_LENGTH (TYPE));                             \
 283     else                                                                     \
 284       /* Other values are returned in register %o0.  */                      \
 285       write_register_bytes (REGISTER_BYTE (O0_REGNUM), (VALBUF),             \
 286                             TYPE_LENGTH (TYPE));  \
 287   }
 288
 289 /* Extract from an array REGBUF containing the (raw) register state
 290    the address in which a function should return its structure value,
 291    as a CORE_ADDR (or an expression that can be used as one).  */
 292
 293 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
 294   (sparc_extract_struct_value_address (REGBUF))
 295
 296 extern CORE_ADDR
 297 sparc_extract_struct_value_address PARAMS ((char [REGISTER_BYTES]));
 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 /* In the case of the Sun 4, the frame-chain's nominal address
 307    is held in the frame pointer register.
 308
 309    On the Sun4, the frame (in %fp) is %sp for the previous frame.
 310    From the previous frame's %sp, we can find the previous frame's
 311    %fp: it is in the save area just above the previous frame's %sp.
 312
 313    If we are setting up an arbitrary frame, we'll need to know where
 314    it ends.  Hence the following.  This part of the frame cache
 315    structure should be checked before it is assumed that this frame's
 316    bottom is in the stack pointer.
 317
 318    If there isn't a frame below this one, the bottom of this frame is
 319    in the stack pointer.
 320
 321    If there is a frame below this one, and the frame pointers are
 322    identical, it's a leaf frame and the bottoms are the same also.
 323
 324    Otherwise the bottom of this frame is the top of the next frame.
 325
 326    The bottom field is misnamed, since it might imply that memory from
 327    bottom to frame contains this frame.  That need not be true if
 328    stack frames are allocated in different segments (e.g. some on a
 329    stack, some on a heap in the data segment).
 330
 331    GCC 2.6 and later can generate ``flat register window'' code that
 332    makes frames by explicitly saving those registers that need to be
 333    saved.  %i7 is used as the frame pointer, and the frame is laid out so
 334    that flat and non-flat calls can be intermixed freely within a
 335    program.  Unfortunately for GDB, this means it must detect and record
 336    the flatness of frames.
 337
 338    Since the prologue in a flat frame also tells us where fp and pc
 339    have been stashed (the frame is of variable size, so their location
 340    is not fixed), it's convenient to record them in the frame info.  */
 341
 342 #ifdef __STDC__
 343 struct frame_info;
 344 #endif
 345
 346 #define EXTRA_FRAME_INFO  \
 347   CORE_ADDR bottom;  \
 348   int flat;  \
 349   /* Following fields only relevant for flat frames.  */ \
 350   CORE_ADDR pc_addr;  \
 351   CORE_ADDR fp_addr;  \
 352   /* Add this to ->frame to get the value of the stack pointer at the */ \
 353   /* time of the register saves.  */ \
 354   int sp_offset;
 355
 356 #define INIT_EXTRA_FRAME_INFO(fromleaf, fci) \
 357   sparc_init_extra_frame_info (fromleaf, fci)
 358 extern void sparc_init_extra_frame_info PARAMS((int, struct frame_info *));
 359
 360 #define PRINT_EXTRA_FRAME_INFO(fi) \
 361   { \
 362     if ((fi) && (fi)->flat) \
 363       printf_filtered (" flat, pc saved at 0x%x, fp saved at 0x%x\n", \
 364                        (fi)->pc_addr, (fi)->fp_addr); \
 365   }
 366
 367 #define FRAME_CHAIN(thisframe) (sparc_frame_chain (thisframe))
 368 extern CORE_ADDR sparc_frame_chain PARAMS ((struct frame_info *));
 369
 370 /* INIT_EXTRA_FRAME_INFO needs the PC to detect flat frames.  */
 371
 372 #define INIT_FRAME_PC(fromleaf, prev) /* nothing */
 373 #define INIT_FRAME_PC_FIRST(fromleaf, prev) \
 374   (prev)->pc = ((fromleaf) ? SAVED_PC_AFTER_CALL ((prev)->next) : \
 375               (prev)->next ? FRAME_SAVED_PC ((prev)->next) : read_pc ());
 376
 377 /* Define other aspects of the stack frame.  */
 378
 379 /* A macro that tells us whether the function invocation represented
 380    by FI does not have a frame on the stack associated with it.  If it
 381    does not, FRAMELESS is set to 1, else 0.  */
 382 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 383   (FRAMELESS) = frameless_look_for_prologue(FI)
 384
 385 /* The location of I0 w.r.t SP.  This is actually dependent on how the system's
 386    window overflow/underflow routines are written.  Most vendors save the L regs
 387    followed by the I regs (at the higher address).  Some vendors get it wrong.
 388  */
 389
 390 #define FRAME_SAVED_L0  0
 391 #define FRAME_SAVED_I0  (8 * REGISTER_RAW_SIZE (L0_REGNUM))
 392
 393 /* Where is the PC for a specific frame */
 394
 395 #define FRAME_SAVED_PC(FRAME) sparc_frame_saved_pc (FRAME)
 396 extern CORE_ADDR sparc_frame_saved_pc PARAMS ((struct frame_info *));
 397
 398 /* If the argument is on the stack, it will be here.  */
 399 #define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
 400
 401 #define FRAME_STRUCT_ARGS_ADDRESS(fi) ((fi)->frame)
 402
 403 #define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
 404
 405 /* Set VAL to the number of args passed to frame described by FI.
 406    Can set VAL to -1, meaning no way to tell.  */
 407
 408 /* We can't tell how many args there are
 409    now that the C compiler delays popping them.  */
 410 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 411
 412 /* Return number of bytes at start of arglist that are not really args.  */
 413
 414 #define FRAME_ARGS_SKIP 68
 415 \f
 416 /* Things needed for making the inferior call functions.  */
 417 /*
 418  * First of all, let me give my opinion of what the DUMMY_FRAME
 419  * actually looks like.
 420  *
 421  *               |                                 |
 422  *               |                                 |
 423  *               + - - - - - - - - - - - - - - - - +<-- fp (level 0)
 424  *               |                                 |
 425  *               |                                 |
 426  *               |                                 |
 427  *               |                                 |
 428  *               |  Frame of innermost program     |
 429  *               |           function              |
 430  *               |                                 |
 431  *               |                                 |
 432  *               |                                 |
 433  *               |                                 |
 434  *               |                                 |
 435  *               |---------------------------------|<-- sp (level 0), fp (c)
 436  *               |                                 |
 437  *     DUMMY     |             fp0-31              |
 438  *               |                                 |
 439  *               |             ------              |<-- fp - 0x80
 440  *     FRAME     |              g0-7               |<-- fp - 0xa0
 441  *               |              i0-7               |<-- fp - 0xc0
 442  *               |             other               |<-- fp - 0xe0
 443  *               |               ?                 |
 444  *               |               ?                 |
 445  *               |---------------------------------|<-- sp' = fp - 0x140
 446  *               |                                 |
 447  * xcution start |                                 |
 448  * sp' + 0x94 -->|        CALL_DUMMY (x code)      |
 449  *               |                                 |
 450  *               |                                 |
 451  *               |---------------------------------|<-- sp'' = fp - 0x200
 452  *               |  align sp to 8 byte boundary    |
 453  *               |     ==> args to fn <==          |
 454  *  Room for     |                                 |
 455  * i & l's + agg | CALL_DUMMY_STACK_ADJUST = 0x0x44|
 456  *               |---------------------------------|<-- final sp (variable)
 457  *               |                                 |
 458  *               |   Where function called will    |
 459  *               |           build frame.          |
 460  *               |                                 |
 461  *               |                                 |
 462  *
 463  *   I understand everything in this picture except what the space
 464  * between fp - 0xe0 and fp - 0x140 is used for.  Oh, and I don't
 465  * understand why there's a large chunk of CALL_DUMMY that never gets
 466  * executed (its function is superceeded by PUSH_DUMMY_FRAME; they
 467  * are designed to do the same thing).
 468  *
 469  *   PUSH_DUMMY_FRAME saves the registers above sp' and pushes the
 470  * register file stack down one.
 471  *
 472  *   call_function then writes CALL_DUMMY, pushes the args onto the
 473  * stack, and adjusts the stack pointer.
 474  *
 475  *   run_stack_dummy then starts execution (in the middle of
 476  * CALL_DUMMY, as directed by call_function).
 477  */
 478
 479 /* Push an empty stack frame, to record the current PC, etc.  */
 480
 481 #define PUSH_DUMMY_FRAME        sparc_push_dummy_frame ()
 482 #define POP_FRAME       sparc_pop_frame ()
 483
 484 void sparc_push_dummy_frame PARAMS ((void)), sparc_pop_frame PARAMS ((void));
 485 /* This sequence of words is the instructions
 486
 487    save %sp,-0x140,%sp
 488    std  %f30,[%fp-0x08]
 489    std  %f28,[%fp-0x10]
 490    std  %f26,[%fp-0x18]
 491    std  %f24,[%fp-0x20]
 492    std  %f22,[%fp-0x28]
 493    std  %f20,[%fp-0x30]
 494    std  %f18,[%fp-0x38]
 495    std  %f16,[%fp-0x40]
 496    std  %f14,[%fp-0x48]
 497    std  %f12,[%fp-0x50]
 498    std  %f10,[%fp-0x58]
 499    std  %f8,[%fp-0x60]
 500    std  %f6,[%fp-0x68]
 501    std  %f4,[%fp-0x70]
 502    std  %f2,[%fp-0x78]
 503    std  %f0,[%fp-0x80]
 504    std  %g6,[%fp-0x88]
 505    std  %g4,[%fp-0x90]
 506    std  %g2,[%fp-0x98]
 507    std  %g0,[%fp-0xa0]
 508    std  %i6,[%fp-0xa8]
 509    std  %i4,[%fp-0xb0]
 510    std  %i2,[%fp-0xb8]
 511    std  %i0,[%fp-0xc0]
 512    nop ! stcsr  [%fp-0xc4]
 513    nop ! stfsr  [%fp-0xc8]
 514    nop ! wr     %npc,[%fp-0xcc]
 515    nop ! wr     %pc,[%fp-0xd0]
 516    rd   %tbr,%o0
 517    st   %o0,[%fp-0xd4]
 518    rd   %wim,%o1
 519    st   %o0,[%fp-0xd8]
 520    rd   %psr,%o0
 521    st   %o0,[%fp-0xdc]
 522    rd   %y,%o0
 523    st   %o0,[%fp-0xe0]
 524
 525      /..* The arguments are pushed at this point by GDB;
 526         no code is needed in the dummy for this.
 527         The CALL_DUMMY_START_OFFSET gives the position of
 528         the following ld instruction.  *../
 529
 530    ld   [%sp+0x58],%o5
 531    ld   [%sp+0x54],%o4
 532    ld   [%sp+0x50],%o3
 533    ld   [%sp+0x4c],%o2
 534    ld   [%sp+0x48],%o1
 535    call 0x00000000
 536    ld   [%sp+0x44],%o0
 537    nop
 538    ta 1
 539    nop
 540
 541    note that this is 192 bytes, which is a multiple of 8 (not only 4) bytes.
 542    note that the `call' insn is a relative, not an absolute call.
 543    note that the `nop' at the end is needed to keep the trap from
 544         clobbering things (if NPC pointed to garbage instead).
 545
 546 We actually start executing at the `sethi', since the pushing of the
 547 registers (as arguments) is done by PUSH_DUMMY_FRAME.  If this were
 548 real code, the arguments for the function called by the CALL would be
 549 pushed between the list of ST insns and the CALL, and we could allow
 550 it to execute through.  But the arguments have to be pushed by GDB
 551 after the PUSH_DUMMY_FRAME is done, and we cannot allow these ST
 552 insns to be performed again, lest the registers saved be taken for
 553 arguments.  */
 554
 555 #define CALL_DUMMY { 0x9de3bee0, 0xfd3fbff8, 0xf93fbff0, 0xf53fbfe8,    \
 556                      0xf13fbfe0, 0xed3fbfd8, 0xe93fbfd0, 0xe53fbfc8,    \
 557                      0xe13fbfc0, 0xdd3fbfb8, 0xd93fbfb0, 0xd53fbfa8,    \
 558                      0xd13fbfa0, 0xcd3fbf98, 0xc93fbf90, 0xc53fbf88,    \
 559                      0xc13fbf80, 0xcc3fbf78, 0xc83fbf70, 0xc43fbf68,    \
 560                      0xc03fbf60, 0xfc3fbf58, 0xf83fbf50, 0xf43fbf48,    \
 561                      0xf03fbf40, 0x01000000, 0x01000000, 0x01000000,    \
 562                      0x01000000, 0x91580000, 0xd027bf50, 0x93500000,    \
 563                      0xd027bf4c, 0x91480000, 0xd027bf48, 0x91400000,    \
 564                      0xd027bf44, 0xda03a058, 0xd803a054, 0xd603a050,    \
 565                      0xd403a04c, 0xd203a048, 0x40000000, 0xd003a044,    \
 566                      0x01000000, 0x91d02001, 0x01000000, 0x01000000}
 567
 568 #define CALL_DUMMY_LENGTH 192
 569
 570 #define CALL_DUMMY_START_OFFSET 148
 571
 572 #define CALL_DUMMY_BREAKPOINT_OFFSET (CALL_DUMMY_START_OFFSET + (8 * 4))
 573
 574 #define CALL_DUMMY_STACK_ADJUST 68
 575
 576 /* Insert the specified number of args and function address
 577    into a call sequence of the above form stored at DUMMYNAME.
 578
 579    For structs and unions, if the function was compiled with Sun cc,
 580    it expects 'unimp' after the call.  But gcc doesn't use that
 581    (twisted) convention.  So leave a nop there for gcc (FIX_CALL_DUMMY
 582    can assume it is operating on a pristine CALL_DUMMY, not one that
 583    has already been customized for a different function).  */
 584
 585 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)    \
 586 {                                                                       \
 587   store_unsigned_integer (dummyname + 168, 4,                           \
 588                           (0x40000000                                   \
 589                            | (((fun - (pc + 168)) >> 2) & 0x3fffffff))); \
 590   if (!gcc_p                                                            \
 591       && (TYPE_CODE (type) == TYPE_CODE_STRUCT                          \
 592           || TYPE_CODE (type) == TYPE_CODE_UNION))                      \
 593     store_unsigned_integer (dummyname + 176, 4, TYPE_LENGTH (type) & 0x1fff); \
 594 }
 595
 596 /* The Sparc returns long doubles on the stack.  */
 597
 598 #define RETURN_VALUE_ON_STACK(TYPE) \
 599   (TYPE_CODE(TYPE) == TYPE_CODE_FLT \
 600    && TYPE_LENGTH(TYPE) > 8)
 601 \f
 602 /* Sparc has no reliable single step ptrace call */
 603
 604 #define NO_SINGLE_STEP 1
 605
 606 /* We need more arguments in a frame specification for the
 607    "frame" or "info frame" command.  */
 608
 609 #define SETUP_ARBITRARY_FRAME(argc, argv) setup_arbitrary_frame (argc, argv)
 610 extern struct frame_info *setup_arbitrary_frame PARAMS ((int, CORE_ADDR *));
 611
 612 /* To print every pair of float registers as a double, we use this hook.  */
 613
 614 #define PRINT_REGISTER_HOOK(regno)      \
 615   if (((regno) >= FP0_REGNUM)           \
 616    && ((regno) <  FP0_REGNUM + 32)      \
 617    && (0 == ((regno) & 1))) {           \
 618     char doublereg[8];          /* two float regs */    \
 619     if (!read_relative_register_raw_bytes ((regno)  , doublereg  )      \
 620      && !read_relative_register_raw_bytes ((regno)+1, doublereg+4)) {   \
 621       printf("\t");                     \
 622       print_floating (doublereg, builtin_type_double, stdout);  \
 623     }                                   \
 624   }
 625
 626 /* Optimization for storing registers to the inferior.  The hook
 627    DO_DEFERRED_STORES
 628    actually executes any deferred stores.  It is called any time
 629    we are going to proceed the child, or read its registers.
 630    The hook CLEAR_DEFERRED_STORES is called when we want to throw
 631    away the inferior process, e.g. when it dies or we kill it.
 632    FIXME, this does not handle remote debugging cleanly.  */
 633
 634 extern int deferred_stores;
 635 #define DO_DEFERRED_STORES      \
 636   if (deferred_stores)          \
 637     target_store_registers (-2);
 638 #define CLEAR_DEFERRED_STORES   \
 639   deferred_stores = 0;
 640
 641 /* If the current gcc for for this target does not produce correct debugging
 642    information for float parameters, both prototyped and unprototyped, then
 643    define this macro.  This forces gdb to  always assume that floats are
 644    passed as doubles and then converted in the callee. */
 645
 646 #define COERCE_FLOAT_TO_DOUBLE 1
 647
 648 /* Select the sparc disassembler */
 649
 650 #define TM_PRINT_INSN_MACH bfd_mach_sparc
 651
 652 /* Arguments smaller than an int must promoted to ints when synthesizing
 653    function calls.  */
 654
 655 #ifdef __STDC__
 656 struct value;
 657 #endif
 658
 659 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
 660     sp = sparc_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr))
 661 extern CORE_ADDR
 662 sparc_push_arguments PARAMS ((int, struct value **, CORE_ADDR, int, CORE_ADDR));