| 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 Free Software Foundation, Inc. |
| 4 | Contributed by Michael Tiemann (tiemann@mcc.com) |
| 5 | |
| 6 | This file is part of GDB. |
| 7 | |
| 8 | This program is free software; you can redistribute it and/or modify |
| 9 | it under the terms of the GNU General Public License as published by |
| 10 | the Free Software Foundation; either version 2 of the License, or |
| 11 | (at your option) any later version. |
| 12 | |
| 13 | This program is distributed in the hope that it will be useful, |
| 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 16 | GNU General Public License for more details. |
| 17 | |
| 18 | You should have received a copy of the GNU General Public License |
| 19 | along with this program; if not, write to the Free Software |
| 20 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
| 21 | |
| 22 | #define TARGET_BYTE_ORDER BIG_ENDIAN |
| 23 | |
| 24 | /* Floating point is IEEE compatible. */ |
| 25 | #define IEEE_FLOAT |
| 26 | |
| 27 | /* When passing a structure to a function, Sun cc passes the address |
| 28 | in a register, not the structure itself. It (under SunOS4) creates |
| 29 | two symbols, so we get a LOC_ARG saying the address is on the stack |
| 30 | (a lie, and a serious one since we don't know which register to |
| 31 | use), and a LOC_REGISTER saying that the struct is in a register |
| 32 | (sort of a lie, but fixable with REG_STRUCT_HAS_ADDR). Gcc version |
| 33 | two (as of 1.92) behaves like sun cc. REG_STRUCT_HAS_ADDR is smart |
| 34 | enough to distinguish between Sun cc, gcc version 1 and gcc version 2. |
| 35 | |
| 36 | This still doesn't work if the argument is not one passed in a |
| 37 | register (i.e. it's the 7th or later argument). */ |
| 38 | #define REG_STRUCT_HAS_ADDR(gcc_p) (gcc_p != 1) |
| 39 | #define STRUCT_ARG_SYM_GARBAGE(gcc_p) (gcc_p != 1) |
| 40 | |
| 41 | /* If Pcc says that a parameter is a short, it's a short. This is |
| 42 | because the parameter does get passed in in a register as an int, |
| 43 | but pcc puts it onto the stack frame as a short (not nailing |
| 44 | whatever else might be there. I'm not sure that I consider this |
| 45 | swift. Sigh.) |
| 46 | |
| 47 | No, don't do this. The problem here is that pcc says that the |
| 48 | argument is in the upper half of the word reserved on the stack, |
| 49 | but puts it in the lower half. */ |
| 50 | /* #define BELIEVE_PCC_PROMOTION 1 */ |
| 51 | /* OK, I've added code to dbxread.c to deal with this case. */ |
| 52 | #define BELIEVE_PCC_PROMOTION_TYPE |
| 53 | |
| 54 | /* Offset from address of function to start of its code. |
| 55 | Zero on most machines. */ |
| 56 | |
| 57 | #define FUNCTION_START_OFFSET 0 |
| 58 | |
| 59 | /* Advance PC across any function entry prologue instructions |
| 60 | to reach some "real" code. SKIP_PROLOGUE_FRAMELESS_P advances |
| 61 | the PC past some of the prologue, but stops as soon as it |
| 62 | knows that the function has a frame. Its result is equal |
| 63 | to its input PC if the function is frameless, unequal otherwise. */ |
| 64 | |
| 65 | #define SKIP_PROLOGUE(pc) \ |
| 66 | { pc = skip_prologue (pc, 0); } |
| 67 | #define SKIP_PROLOGUE_FRAMELESS_P(pc) \ |
| 68 | { pc = skip_prologue (pc, 1); } |
| 69 | extern CORE_ADDR skip_prologue (); |
| 70 | |
| 71 | /* Immediately after a function call, return the saved pc. |
| 72 | Can't go through the frames for this because on some machines |
| 73 | the new frame is not set up until the new function executes |
| 74 | some instructions. */ |
| 75 | |
| 76 | /* On the Sun 4 under SunOS, the compile will leave a fake insn which |
| 77 | encodes the structure size being returned. If we detect such |
| 78 | a fake insn, step past it. */ |
| 79 | |
| 80 | #define PC_ADJUST(pc) sparc_pc_adjust(pc) |
| 81 | extern CORE_ADDR sparc_pc_adjust(); |
| 82 | |
| 83 | #define SAVED_PC_AFTER_CALL(frame) PC_ADJUST (read_register (RP_REGNUM)) |
| 84 | |
| 85 | /* Stack grows downward. */ |
| 86 | |
| 87 | #define INNER_THAN < |
| 88 | |
| 89 | /* Stack has strict alignment. */ |
| 90 | |
| 91 | #define STACK_ALIGN(ADDR) (((ADDR)+7)&-8) |
| 92 | |
| 93 | /* Sequence of bytes for breakpoint instruction. */ |
| 94 | |
| 95 | #define BREAKPOINT {0x91, 0xd0, 0x20, 0x01} |
| 96 | |
| 97 | /* Amount PC must be decremented by after a breakpoint. |
| 98 | This is often the number of bytes in BREAKPOINT |
| 99 | but not always. */ |
| 100 | |
| 101 | #define DECR_PC_AFTER_BREAK 0 |
| 102 | |
| 103 | /* Nonzero if instruction at PC is a return instruction. */ |
| 104 | /* For SPARC, this is either a "jmpl %o7+8,%g0" or "jmpl %i7+8,%g0". |
| 105 | |
| 106 | Note: this does not work for functions returning structures under SunOS. */ |
| 107 | #define ABOUT_TO_RETURN(pc) \ |
| 108 | ((read_memory_integer (pc, 4)|0x00040000) == 0x81c7e008) |
| 109 | |
| 110 | /* Return 1 if P points to an invalid floating point value. */ |
| 111 | |
| 112 | #define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */ |
| 113 | |
| 114 | /* Say how long (ordinary) registers are. */ |
| 115 | |
| 116 | #define REGISTER_TYPE long |
| 117 | |
| 118 | /* Number of machine registers */ |
| 119 | |
| 120 | #define NUM_REGS 72 |
| 121 | |
| 122 | /* Initializer for an array of names of registers. |
| 123 | There should be NUM_REGS strings in this initializer. */ |
| 124 | |
| 125 | #define REGISTER_NAMES \ |
| 126 | { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7", \ |
| 127 | "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7", \ |
| 128 | "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", \ |
| 129 | "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7", \ |
| 130 | \ |
| 131 | "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ |
| 132 | "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ |
| 133 | "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \ |
| 134 | "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \ |
| 135 | \ |
| 136 | "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr" } |
| 137 | |
| 138 | /* Register numbers of various important registers. |
| 139 | Note that some of these values are "real" register numbers, |
| 140 | and correspond to the general registers of the machine, |
| 141 | and some are "phony" register numbers which are too large |
| 142 | to be actual register numbers as far as the user is concerned |
| 143 | but do serve to get the desired values when passed to read_register. */ |
| 144 | |
| 145 | #define G0_REGNUM 0 /* %g0 */ |
| 146 | #define G1_REGNUM 1 /* %g1 */ |
| 147 | #define O0_REGNUM 8 /* %o0 */ |
| 148 | #define SP_REGNUM 14 /* Contains address of top of stack, \ |
| 149 | which is also the bottom of the frame. */ |
| 150 | #define RP_REGNUM 15 /* Contains return address value, *before* \ |
| 151 | any windows get switched. */ |
| 152 | #define O7_REGNUM 15 /* Last local reg not saved on stack frame */ |
| 153 | #define L0_REGNUM 16 /* First local reg that's saved on stack frame |
| 154 | rather than in machine registers */ |
| 155 | #define I0_REGNUM 24 /* %i0 */ |
| 156 | #define FP_REGNUM 30 /* Contains address of executing stack frame */ |
| 157 | #define I7_REGNUM 31 /* Last local reg saved on stack frame */ |
| 158 | #define FP0_REGNUM 32 /* Floating point register 0 */ |
| 159 | #define Y_REGNUM 64 /* Temp register for multiplication, etc. */ |
| 160 | #define PS_REGNUM 65 /* Contains processor status */ |
| 161 | #define WIM_REGNUM 66 /* Window Invalid Mask (not really supported) */ |
| 162 | #define TBR_REGNUM 67 /* Trap Base Register (not really supported) */ |
| 163 | #define PC_REGNUM 68 /* Contains program counter */ |
| 164 | #define NPC_REGNUM 69 /* Contains next PC */ |
| 165 | #define FPS_REGNUM 70 /* Floating point status register */ |
| 166 | #define CPS_REGNUM 71 /* Coprocessor status register */ |
| 167 | |
| 168 | /* Total amount of space needed to store our copies of the machine's |
| 169 | register state, the array `registers'. */ |
| 170 | #define REGISTER_BYTES (32*4+32*4+8*4) |
| 171 | |
| 172 | /* Index within `registers' of the first byte of the space for |
| 173 | register N. */ |
| 174 | /* ?? */ |
| 175 | #define REGISTER_BYTE(N) ((N)*4) |
| 176 | |
| 177 | /* The SPARC processor has register windows. */ |
| 178 | |
| 179 | #define HAVE_REGISTER_WINDOWS |
| 180 | |
| 181 | /* Is this register part of the register window system? A yes answer |
| 182 | implies that 1) The name of this register will not be the same in |
| 183 | other frames, and 2) This register is automatically "saved" (out |
| 184 | registers shifting into ins counts) upon subroutine calls and thus |
| 185 | there is no need to search more than one stack frame for it. */ |
| 186 | |
| 187 | #define REGISTER_IN_WINDOW_P(regnum) \ |
| 188 | ((regnum) >= 8 && (regnum) < 32) |
| 189 | |
| 190 | /* Number of bytes of storage in the actual machine representation |
| 191 | for register N. */ |
| 192 | |
| 193 | /* On the SPARC, all regs are 4 bytes. */ |
| 194 | |
| 195 | #define REGISTER_RAW_SIZE(N) (4) |
| 196 | |
| 197 | /* Number of bytes of storage in the program's representation |
| 198 | for register N. */ |
| 199 | |
| 200 | /* On the SPARC, all regs are 4 bytes. */ |
| 201 | |
| 202 | #define REGISTER_VIRTUAL_SIZE(N) (4) |
| 203 | |
| 204 | /* Largest value REGISTER_RAW_SIZE can have. */ |
| 205 | |
| 206 | #define MAX_REGISTER_RAW_SIZE 8 |
| 207 | |
| 208 | /* Largest value REGISTER_VIRTUAL_SIZE can have. */ |
| 209 | |
| 210 | #define MAX_REGISTER_VIRTUAL_SIZE 8 |
| 211 | |
| 212 | /* Nonzero if register N requires conversion |
| 213 | from raw format to virtual format. */ |
| 214 | |
| 215 | #define REGISTER_CONVERTIBLE(N) (0) |
| 216 | |
| 217 | /* Convert data from raw format for register REGNUM |
| 218 | to virtual format for register REGNUM. */ |
| 219 | |
| 220 | #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ |
| 221 | { memcpy ((TO), (FROM), 4); } |
| 222 | |
| 223 | /* Convert data from virtual format for register REGNUM |
| 224 | to raw format for register REGNUM. */ |
| 225 | |
| 226 | #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ |
| 227 | { memcpy ((TO), (FROM), 4); } |
| 228 | |
| 229 | /* Return the GDB type object for the "standard" data type |
| 230 | of data in register N. */ |
| 231 | |
| 232 | #define REGISTER_VIRTUAL_TYPE(N) \ |
| 233 | ((N) < 32 ? builtin_type_int : (N) < 64 ? builtin_type_float : \ |
| 234 | builtin_type_int) |
| 235 | |
| 236 | /* Writing to %g0 is a noop (not an error or exception or anything like |
| 237 | that, however). */ |
| 238 | |
| 239 | #define CANNOT_STORE_REGISTER(regno) ((regno) == G0_REGNUM) |
| 240 | |
| 241 | /* Store the address of the place in which to copy the structure the |
| 242 | subroutine will return. This is called from call_function. */ |
| 243 | |
| 244 | #define STORE_STRUCT_RETURN(ADDR, SP) \ |
| 245 | { target_write_memory ((SP)+(16*4), (char *)&(ADDR), 4); } |
| 246 | |
| 247 | /* Extract from an array REGBUF containing the (raw) register state |
| 248 | a function return value of type TYPE, and copy that, in virtual format, |
| 249 | into VALBUF. */ |
| 250 | |
| 251 | #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ |
| 252 | { \ |
| 253 | if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ |
| 254 | { \ |
| 255 | memcpy ((VALBUF), ((int *)(REGBUF))+FP0_REGNUM, TYPE_LENGTH(TYPE));\ |
| 256 | } \ |
| 257 | else \ |
| 258 | memcpy ((VALBUF), \ |
| 259 | (char *)(REGBUF) + 4 * 8 + \ |
| 260 | (TYPE_LENGTH(TYPE) >= 4 ? 0 : 4 - TYPE_LENGTH(TYPE)), \ |
| 261 | TYPE_LENGTH(TYPE)); \ |
| 262 | } |
| 263 | |
| 264 | /* Write into appropriate registers a function return value |
| 265 | of type TYPE, given in virtual format. */ |
| 266 | /* On sparc, values are returned in register %o0. */ |
| 267 | #define STORE_RETURN_VALUE(TYPE,VALBUF) \ |
| 268 | { \ |
| 269 | if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ |
| 270 | /* Floating-point values are returned in the register pair */ \ |
| 271 | /* formed by %f0 and %f1 (doubles are, anyway). */ \ |
| 272 | write_register_bytes (REGISTER_BYTE (FP0_REGNUM), (VALBUF), \ |
| 273 | TYPE_LENGTH (TYPE)); \ |
| 274 | else \ |
| 275 | /* Other values are returned in register %o0. */ \ |
| 276 | write_register_bytes (REGISTER_BYTE (O0_REGNUM), (VALBUF), \ |
| 277 | TYPE_LENGTH (TYPE)); \ |
| 278 | } |
| 279 | |
| 280 | /* Extract from an array REGBUF containing the (raw) register state |
| 281 | the address in which a function should return its structure value, |
| 282 | as a CORE_ADDR (or an expression that can be used as one). */ |
| 283 | |
| 284 | #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ |
| 285 | (sparc_extract_struct_value_address (REGBUF)) |
| 286 | |
| 287 | extern CORE_ADDR |
| 288 | sparc_extract_struct_value_address PARAMS ((char [REGISTER_BYTES])); |
| 289 | |
| 290 | \f |
| 291 | /* Describe the pointer in each stack frame to the previous stack frame |
| 292 | (its caller). */ |
| 293 | |
| 294 | /* FRAME_CHAIN takes a frame's nominal address |
| 295 | and produces the frame's chain-pointer. */ |
| 296 | |
| 297 | /* In the case of the Sun 4, the frame-chain's nominal address |
| 298 | is held in the frame pointer register. |
| 299 | |
| 300 | On the Sun4, the frame (in %fp) is %sp for the previous frame. |
| 301 | From the previous frame's %sp, we can find the previous frame's |
| 302 | %fp: it is in the save area just above the previous frame's %sp. |
| 303 | |
| 304 | If we are setting up an arbitrary frame, we'll need to know where |
| 305 | it ends. Hence the following. This part of the frame cache |
| 306 | structure should be checked before it is assumed that this frame's |
| 307 | bottom is in the stack pointer. |
| 308 | |
| 309 | If there isn't a frame below this one, the bottom of this frame is |
| 310 | in the stack pointer. |
| 311 | |
| 312 | If there is a frame below this one, and the frame pointers are |
| 313 | identical, it's a leaf frame and the bottoms are the same also. |
| 314 | |
| 315 | Otherwise the bottom of this frame is the top of the next frame. */ |
| 316 | |
| 317 | #define EXTRA_FRAME_INFO FRAME_ADDR bottom; |
| 318 | #define INIT_EXTRA_FRAME_INFO(fromleaf, fci) \ |
| 319 | (fci)->bottom = \ |
| 320 | ((fci)->next ? \ |
| 321 | ((fci)->frame == (fci)->next_frame ? \ |
| 322 | (fci)->next->bottom : (fci)->next->frame) : \ |
| 323 | read_register (SP_REGNUM)); |
| 324 | |
| 325 | #define FRAME_CHAIN(thisframe) (sparc_frame_chain (thisframe)) |
| 326 | CORE_ADDR sparc_frame_chain (); |
| 327 | |
| 328 | /* Define other aspects of the stack frame. */ |
| 329 | |
| 330 | /* A macro that tells us whether the function invocation represented |
| 331 | by FI does not have a frame on the stack associated with it. If it |
| 332 | does not, FRAMELESS is set to 1, else 0. */ |
| 333 | #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ |
| 334 | (FRAMELESS) = frameless_look_for_prologue(FI) |
| 335 | |
| 336 | /* Where is the PC for a specific frame */ |
| 337 | |
| 338 | #define FRAME_SAVED_PC(FRAME) frame_saved_pc (FRAME) |
| 339 | CORE_ADDR frame_saved_pc (); |
| 340 | |
| 341 | /* If the argument is on the stack, it will be here. */ |
| 342 | #define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) |
| 343 | |
| 344 | #define FRAME_STRUCT_ARGS_ADDRESS(fi) ((fi)->frame) |
| 345 | |
| 346 | #define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) |
| 347 | |
| 348 | /* Set VAL to the number of args passed to frame described by FI. |
| 349 | Can set VAL to -1, meaning no way to tell. */ |
| 350 | |
| 351 | /* We can't tell how many args there are |
| 352 | now that the C compiler delays popping them. */ |
| 353 | #define FRAME_NUM_ARGS(val,fi) (val = -1) |
| 354 | |
| 355 | /* Return number of bytes at start of arglist that are not really args. */ |
| 356 | |
| 357 | #define FRAME_ARGS_SKIP 68 |
| 358 | |
| 359 | /* Put here the code to store, into a struct frame_saved_regs, |
| 360 | the addresses of the saved registers of frame described by FRAME_INFO. |
| 361 | The actual code is in sparc-tdep.c so we can debug it sanely. */ |
| 362 | |
| 363 | #define FRAME_FIND_SAVED_REGS(fi, frame_saved_regs) \ |
| 364 | sparc_frame_find_saved_regs ((fi), &(frame_saved_regs)) |
| 365 | extern void sparc_frame_find_saved_regs (); |
| 366 | \f |
| 367 | /* Things needed for making the inferior call functions. */ |
| 368 | /* |
| 369 | * First of all, let me give my opinion of what the DUMMY_FRAME |
| 370 | * actually looks like. |
| 371 | * |
| 372 | * | | |
| 373 | * | | |
| 374 | * + - - - - - - - - - - - - - - - - +<-- fp (level 0) |
| 375 | * | | |
| 376 | * | | |
| 377 | * | | |
| 378 | * | | |
| 379 | * | Frame of innermost program | |
| 380 | * | function | |
| 381 | * | | |
| 382 | * | | |
| 383 | * | | |
| 384 | * | | |
| 385 | * | | |
| 386 | * |---------------------------------|<-- sp (level 0), fp (c) |
| 387 | * | | |
| 388 | * DUMMY | fp0-31 | |
| 389 | * | | |
| 390 | * | ------ |<-- fp - 0x80 |
| 391 | * FRAME | g0-7 |<-- fp - 0xa0 |
| 392 | * | i0-7 |<-- fp - 0xc0 |
| 393 | * | other |<-- fp - 0xe0 |
| 394 | * | ? | |
| 395 | * | ? | |
| 396 | * |---------------------------------|<-- sp' = fp - 0x140 |
| 397 | * | | |
| 398 | * xcution start | | |
| 399 | * sp' + 0x94 -->| CALL_DUMMY (x code) | |
| 400 | * | | |
| 401 | * | | |
| 402 | * |---------------------------------|<-- sp'' = fp - 0x200 |
| 403 | * | align sp to 8 byte boundary | |
| 404 | * | ==> args to fn <== | |
| 405 | * Room for | | |
| 406 | * i & l's + agg | CALL_DUMMY_STACK_ADJUST = 0x0x44| |
| 407 | * |---------------------------------|<-- final sp (variable) |
| 408 | * | | |
| 409 | * | Where function called will | |
| 410 | * | build frame. | |
| 411 | * | | |
| 412 | * | | |
| 413 | * |
| 414 | * I understand everything in this picture except what the space |
| 415 | * between fp - 0xe0 and fp - 0x140 is used for. Oh, and I don't |
| 416 | * understand why there's a large chunk of CALL_DUMMY that never gets |
| 417 | * executed (its function is superceeded by PUSH_DUMMY_FRAME; they |
| 418 | * are designed to do the same thing). |
| 419 | * |
| 420 | * PUSH_DUMMY_FRAME saves the registers above sp' and pushes the |
| 421 | * register file stack down one. |
| 422 | * |
| 423 | * call_function then writes CALL_DUMMY, pushes the args onto the |
| 424 | * stack, and adjusts the stack pointer. |
| 425 | * |
| 426 | * run_stack_dummy then starts execution (in the middle of |
| 427 | * CALL_DUMMY, as directed by call_function). |
| 428 | */ |
| 429 | |
| 430 | /* Push an empty stack frame, to record the current PC, etc. */ |
| 431 | |
| 432 | #define PUSH_DUMMY_FRAME sparc_push_dummy_frame () |
| 433 | #define POP_FRAME sparc_pop_frame () |
| 434 | |
| 435 | void sparc_push_dummy_frame (), sparc_pop_frame (); |
| 436 | /* This sequence of words is the instructions |
| 437 | |
| 438 | save %sp,-0x140,%sp |
| 439 | std %f30,[%fp-0x08] |
| 440 | std %f28,[%fp-0x10] |
| 441 | std %f26,[%fp-0x18] |
| 442 | std %f24,[%fp-0x20] |
| 443 | std %f22,[%fp-0x28] |
| 444 | std %f20,[%fp-0x30] |
| 445 | std %f18,[%fp-0x38] |
| 446 | std %f16,[%fp-0x40] |
| 447 | std %f14,[%fp-0x48] |
| 448 | std %f12,[%fp-0x50] |
| 449 | std %f10,[%fp-0x58] |
| 450 | std %f8,[%fp-0x60] |
| 451 | std %f6,[%fp-0x68] |
| 452 | std %f4,[%fp-0x70] |
| 453 | std %f2,[%fp-0x78] |
| 454 | std %f0,[%fp-0x80] |
| 455 | std %g6,[%fp-0x88] |
| 456 | std %g4,[%fp-0x90] |
| 457 | std %g2,[%fp-0x98] |
| 458 | std %g0,[%fp-0xa0] |
| 459 | std %i6,[%fp-0xa8] |
| 460 | std %i4,[%fp-0xb0] |
| 461 | std %i2,[%fp-0xb8] |
| 462 | std %i0,[%fp-0xc0] |
| 463 | nop ! stcsr [%fp-0xc4] |
| 464 | nop ! stfsr [%fp-0xc8] |
| 465 | nop ! wr %npc,[%fp-0xcc] |
| 466 | nop ! wr %pc,[%fp-0xd0] |
| 467 | rd %tbr,%o0 |
| 468 | st %o0,[%fp-0xd4] |
| 469 | rd %wim,%o1 |
| 470 | st %o0,[%fp-0xd8] |
| 471 | rd %psr,%o0 |
| 472 | st %o0,[%fp-0xdc] |
| 473 | rd %y,%o0 |
| 474 | st %o0,[%fp-0xe0] |
| 475 | |
| 476 | /..* The arguments are pushed at this point by GDB; |
| 477 | no code is needed in the dummy for this. |
| 478 | The CALL_DUMMY_START_OFFSET gives the position of |
| 479 | the following ld instruction. *../ |
| 480 | |
| 481 | ld [%sp+0x58],%o5 |
| 482 | ld [%sp+0x54],%o4 |
| 483 | ld [%sp+0x50],%o3 |
| 484 | ld [%sp+0x4c],%o2 |
| 485 | ld [%sp+0x48],%o1 |
| 486 | call 0x00000000 |
| 487 | ld [%sp+0x44],%o0 |
| 488 | nop |
| 489 | ta 1 |
| 490 | nop |
| 491 | |
| 492 | note that this is 192 bytes, which is a multiple of 8 (not only 4) bytes. |
| 493 | note that the `call' insn is a relative, not an absolute call. |
| 494 | note that the `nop' at the end is needed to keep the trap from |
| 495 | clobbering things (if NPC pointed to garbage instead). |
| 496 | |
| 497 | We actually start executing at the `sethi', since the pushing of the |
| 498 | registers (as arguments) is done by PUSH_DUMMY_FRAME. If this were |
| 499 | real code, the arguments for the function called by the CALL would be |
| 500 | pushed between the list of ST insns and the CALL, and we could allow |
| 501 | it to execute through. But the arguments have to be pushed by GDB |
| 502 | after the PUSH_DUMMY_FRAME is done, and we cannot allow these ST |
| 503 | insns to be performed again, lest the registers saved be taken for |
| 504 | arguments. */ |
| 505 | |
| 506 | #define CALL_DUMMY { 0x9de3bee0, 0xfd3fbff8, 0xf93fbff0, 0xf53fbfe8, \ |
| 507 | 0xf13fbfe0, 0xed3fbfd8, 0xe93fbfd0, 0xe53fbfc8, \ |
| 508 | 0xe13fbfc0, 0xdd3fbfb8, 0xd93fbfb0, 0xd53fbfa8, \ |
| 509 | 0xd13fbfa0, 0xcd3fbf98, 0xc93fbf90, 0xc53fbf88, \ |
| 510 | 0xc13fbf80, 0xcc3fbf78, 0xc83fbf70, 0xc43fbf68, \ |
| 511 | 0xc03fbf60, 0xfc3fbf58, 0xf83fbf50, 0xf43fbf48, \ |
| 512 | 0xf03fbf40, 0x01000000, 0x01000000, 0x01000000, \ |
| 513 | 0x01000000, 0x91580000, 0xd027bf50, 0x93500000, \ |
| 514 | 0xd027bf4c, 0x91480000, 0xd027bf48, 0x91400000, \ |
| 515 | 0xd027bf44, 0xda03a058, 0xd803a054, 0xd603a050, \ |
| 516 | 0xd403a04c, 0xd203a048, 0x40000000, 0xd003a044, \ |
| 517 | 0x01000000, 0x91d02001, 0x01000000, 0x01000000} |
| 518 | |
| 519 | #define CALL_DUMMY_LENGTH 192 |
| 520 | |
| 521 | #define CALL_DUMMY_START_OFFSET 148 |
| 522 | |
| 523 | #define CALL_DUMMY_STACK_ADJUST 68 |
| 524 | |
| 525 | /* Insert the specified number of args and function address |
| 526 | into a call sequence of the above form stored at DUMMYNAME. |
| 527 | |
| 528 | For structs and unions, if the function was compiled with Sun cc, |
| 529 | it expects 'unimp' after the call. But gcc doesn't use that |
| 530 | (twisted) convention. So leave a nop there for gcc (FIX_CALL_DUMMY |
| 531 | can assume it is operating on a pristine CALL_DUMMY, not one that |
| 532 | has already been customized for a different function). */ |
| 533 | |
| 534 | #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ |
| 535 | { \ |
| 536 | *(int *)((char *) dummyname+168) = (0x40000000|((fun-(pc+168))>>2)); \ |
| 537 | if (!gcc_p \ |
| 538 | && (TYPE_CODE (type) == TYPE_CODE_STRUCT \ |
| 539 | || TYPE_CODE (type) == TYPE_CODE_UNION)) \ |
| 540 | *(int *)((char *) dummyname+176) = (TYPE_LENGTH (type) & 0x1fff); \ |
| 541 | } |
| 542 | |
| 543 | \f |
| 544 | /* Sparc has no reliable single step ptrace call */ |
| 545 | |
| 546 | #define NO_SINGLE_STEP 1 |
| 547 | extern void single_step (); |
| 548 | |
| 549 | /* We need two arguments (in general) to the "info frame" command. |
| 550 | Note that the definition of this macro implies that there exists a |
| 551 | function "setup_arbitrary_frame" in sparc-tdep.c */ |
| 552 | |
| 553 | #define FRAME_SPECIFICATION_DYADIC |
| 554 | |
| 555 | /* To print every pair of float registers as a double, we use this hook. */ |
| 556 | |
| 557 | #define PRINT_REGISTER_HOOK(regno) \ |
| 558 | if (((regno) >= FP0_REGNUM) \ |
| 559 | && ((regno) < FP0_REGNUM + 32) \ |
| 560 | && (0 == (regno & 1))) { \ |
| 561 | char doublereg[8]; /* two float regs */ \ |
| 562 | if (!read_relative_register_raw_bytes (i , doublereg ) \ |
| 563 | && !read_relative_register_raw_bytes (i+1, doublereg+4)) { \ |
| 564 | printf("\t"); \ |
| 565 | print_floating (doublereg, builtin_type_double, stdout); \ |
| 566 | } \ |
| 567 | } |
| 568 | |
| 569 | /* Optimization for storing registers to the inferior. The hook |
| 570 | DO_DEFERRED_STORES |
| 571 | actually executes any deferred stores. It is called any time |
| 572 | we are going to proceed the child, or read its registers. |
| 573 | The hook CLEAR_DEFERRED_STORES is called when we want to throw |
| 574 | away the inferior process, e.g. when it dies or we kill it. |
| 575 | FIXME, this does not handle remote debugging cleanly. */ |
| 576 | |
| 577 | extern int deferred_stores; |
| 578 | #define DO_DEFERRED_STORES \ |
| 579 | if (deferred_stores) \ |
| 580 | target_store_registers (-2); |
| 581 | #define CLEAR_DEFERRED_STORES \ |
| 582 | deferred_stores = 0; |